CutWithIt! (1991-1993)
CutIt! (later renamed CutWithIt! due to trademark issues) was my first serious, commercial project.
I was invited into the team when I was in my 2nd grade high school. The application was developed in order to compete with other 2D CAD applications at that time, mostly with the popular CorelDraw. The main goal was to provide software for high definition vinyl foil cutting, because all other available software lacked the following features:
High accuracy
Developed and running on 16 bit Microsoft Windows platform, CutIt! breached the usual barrier of 16 bit GDI, having a 2^32 x 2^32 fixed point resolution instead of 2^16 x 2^16 that the OS allowed. Instead of the usual 0.5mm accuracy on a maximum 1×1 meter sheet, the user was able to both design, then cut (using the plotter driver that was part of the package) an up to 25×25 meters sheet at 0.0002mm accuracy.
Huge objects
The majority of available software was only capable of operating with objects taking 65K or less in the memory. CutIt! extended this to full 32bit sized objects, allowing the manipulation of 10000 times more complex objects, when needed. Already having these two advantages, CutIt! also included the somewhat revolutionary features that the majority of all commercial CAD programs at that time was lacking:
Mutation and deformation stack
Instead of manipulating directly on vector state of an object, every action is attached to its deformation stack. That means that any object can be restored, step by step, to its original state or any state in history. It also means that text objects could always be edited, no matter how many deformations they had. It was also possible to copy deformations from one object to another.
Friendly dialog boxes
In today’s GUI OS, it is a norm that certain dialog boxes come equipped with utility features. Back then, when you opened a file open or file save dialog box, you had no tools within the dialog box to move or copy around the files, create new folders, etc. I cannot claim that this was my own invention, but I’m pretty sure that CutIt! had such dialog boxes, equipped with file operation menus, much before common dialog boxes appeared or became a standard.
Contextual toolbar
As an alternative to the static tool-bars prevalent at that time (and still nowadays), CutIt! sported dynamic tool-bars that changed depending on selected tool. The interface was thus much less cluttered than the norm.
CutIt! was developed exclusively by the team of three people: Gorazd Šterban, Matej Žvan and Matija Kostevc. It was written in 32 bit assembler and Object Pascal, compiled using Borland Pascal for Windows. Development took two years.
Despite it being developed for 16 bit Windows, it is still mostly operational under 32 bit windows more than 10 years later, even though certain features are problematic (mostly printing and import of third party files). The program went through a small make-over for Windows 95, mostly GUI issues. This version can be downloaded from here, as it is now freeware:
CutWithIt! - archived bin folder
Copy protection
Our main distributor requested a copy protection to lock each personal copy of the software to its buyer. I developed a simple locking mechanism in two parts. First part was the installer, which required a floppy disk to unlock the software. The floppy disk had a unique format, with variable gaps between sectors and variable sector sizes across the tracks. The combination was unbreakable by any of the floppy-hacking utilities that we tried out. Under windows, DPMI was used to control the BIOS in veryfying the floppy format.
The second part relied on the simple fact that when files are copied around using dos or windows file management command, only the exact number of bytes are copied as specified by file length. However, as file length is always rounded up to file chunk size, the last chunk occupied by the executable was filled up with data meaningful to the locking mechanism. Thus, if the executable was copied to another folder or another disk, this data was not copied along and the locking mechanism prevented the software from being executed.
Of course, this protection mechanism could eventually be broken fairly easily, however due to the market to which this product was released (mostly professional designers), this was not really expected, and simple protection seems to have been enough to prevent them from ‘sharing’ the software.