QuikNote

QuikNote is an application that lets you save up to 100* pages of color notes on a single GRP file. The application was designed to be used quickly, so you can start jotting down notes as soon as it starts up. This application uses the concept of "ink" to allow for multiple pages, so watch your ink bar on the bottom. If it gets filled up, you won't be able to draw anymore, so be careful!


 * Not all notes can have 100 pages. Notes are limited to ~49000 actions (~20000 vectors), and the page limit for any particular note is 100. You cannot create new pages once you've run out of "ink". You cannot edit old pages.

Features

 * Compacts pictures into vectors and actions to allow for many pages to be saved within a single file.
 * Full range of 256 colors available from the touchscreen/d-pad
 * Save and load QuikNote GRP files. Note that a regular GRP file will not display correctly in this application.
 * Replay the current page to watch exactly how you drew it
 * Lock the creation of new pages to mitigate the accidental creation of new pages (thus locking the previous page from being edited)
 * Choose from 3 boldness settings
 * Quickly start up a new notepad
 * Apply compression to your strokes to allow more data to be saved. Note that the higher the compression, the more "choppy" your writing will feel and look.

How it works
A full-fledged graphics editing program requires that each individual pixel be accounted for in order to allow a wide variety of editing options. However, notes and scribbles don't require this level of precision. If you think about it, simple writing and sketching is just a series of lines and points. Even curves can be broken down into lines (small ones). Thus, if no extra editing options are necessary, you can simply save the points between lines and their breakpoints and play them back on the screen to produce your image. This is why flipping through pages on this program requires a redraw, because the data isn't stored as a picture, but as a bunch of points which form lines. However, this doesn't solve all our problems. In order to apply boldness/color, we can either dedicate space for these for each line (for instance, line 120 has color 230 and thickness 3), OR we can just save the actions the user has taken when they take them and play those back as well. On this program, it uses special identifiers which can never be points on the screen (for instance, y=200) to insert an action into the drawing "stream". For instance, when the program is drawing, if it comes across a 193, it knows that it needs to change boldness (I don't know what 193 actually changes lol). Plus, since each point requires two sections of information (x and y), I can fill up the x with the actual boldness information. Thus, x and y can either be points in the drawing, or a token and its data. In order to actually GET those points, we need to sample the user's touchscreen location a certain number of times per second. This is where the compression comes in: if I sample 60 times per second, the drawing will look really smooth, but it uses a lot of data (you can still store a ton of points though). However, if I only sample the location touched 30 times per second (low compression on the program), we get around half as much data. In the real world, it actually works out to be 30% smaller due to all the other data. The lowest amount of samples this program will use is 15 per second, which makes it quite ugly. But, if you're just filling in a large section of the screen, you might as well use the lowest compression possible, right? There are also tokens for new pages and the end of a line segment (otherwise everything would be connected, like an Etch-A-Sketch). Well, I've talked your ears off (or you didn't read this far), so here's the download: