Late November:
I was able to free up time in my schedule so I could start re-writing the source code to LinkView. My motivation came from helping with the beta testing of Ice Hockey 68k and Oblivion. Since it was beneficial to the progress of testing, I dove back into tutorials for C and TIGCC. I plan on making this application very user friendly, highly customizable, much more efficient than any explorer, and have an agreeable aesthetic quality. This program has the potential to become an explorer AND a program launcher, but the latter is still a pie in the sky.

December 6:
Tonight I decided to start making this log to track my progress.
*Finished coding all the drawing routines for displaying the interface for the File Viewer.
*Though ExtGraph is really fast, I noticed that certain areas/phases of the drawing were noticeable. After about a half an hour of reading about double buffering and not being about get it to work with ExtGraph, I looked at the ExtGraph header file and banged my head against a wall for being so stupid (c'mon not literally). I then implemented it on first try.
*Reorganized some of my internal data structures do to accessibility problems.
*Added support to change the contrast
*The calculator will now turn off when the APD timer expires.

NOTE: Do to the fact that there is large number of variables I have in LinkView to make it work; I will be modifying a significant amount of my global data and how different functions access it. This should increase speed and decrease the size of the program. It turns out that my latest change in the organization was rather foolish because it is very limiting. Instead of passing 6 or more items to major functions, I can pass one or two if I redefine a few structures.

To Do List (delete items when completed):
*Complete the File Viewer for the 240x128 screen size and then program the routines.
*In the strings display, add the code for text wrapping for errors and messages as well as a mod of the scrolling engine for a history.
*Redo the scroll engine from the original code. If possible, make one of two major sections, not four. Also make may special flashing cursor.
*Add the scroll bar code and avoid divide by zero crashes ;)
*Collect and store data from the VAT table of the calculator. Also I need to come up with and intelligent monitor so I can maintain my own index of "relevant" information of each file. This will significantly increase scrolling speed and file display.
*Implement a smarter (read: more intuitive) version of simple file manipulation, i.e. move, copy, rename, lock etc. Possibility of overwrites with user consent.
*Add key press, first letter search capability
*Add a search engine to find files and return its folder size and attributes.
*Start work on designing to Transceiver screen and implement its drawing routines for each screen size.
*Get file transmission up and running.
*Make four lists, files sent, files received, files to send, files to receive.
*Program the protocol(s) so LinkView can talk and interface with Var-Link.
*Adjust file transmission (between two calcs running LinkView only) in order to display an actually progress bar for file transmission.

*Eater egg(s) will have been implemented.
*Add a catalog for identifying files via extension and name. Create on calc editor.

Wish List:
*Look at the advantages of the Silent Link feature of newer OSs and take advantage of it.
*Add the feature controls to adjust the settings of LinkView and save them in a config file. Also add one or two different types of layouts (skins).
*Add a help screen and possibly automation for examples.
*Explore the possibility to force the link port to operate a full duplex, otherwise emulate it.
*Enable remote viewing of the contents of a connected calculator. Also enable the ability to give and take files via this method.
*In config file, save the index of files and folders along with a time stamp for easier identification. File will be auto-archived.
*Add/create a hex editor and make the search engine scan files internally when requested.
*Add support for the executions of programs while breaking the 24KB limit.