main.py: Runs the program - shouldn't need much editing. Can change the style.

test.py: Runs the unit tests. If you add unit tests, or change the names, edit Here.

setup.py: Creates and initializes the database, and the test database, based on the config
	files (tables.json, db_init.json and test_db_init.json) in the \\data folder. If you want 
	to change these, you'll have to edit (database_creator.py and test_db_creator.py) in 
	\\controller.

kglobals.py: A set of objects or variables that can be created once, and called from anywhere 
	in the program. You could add a "datamapper" object to this, to manage persistance, if 
	the objects don't do that themselves.

database_manager.py: Handles all the sql statements. I made a convenience query function, 
	which picks the appropriate query statement. I haven't done any performance testing, 
	since the programs I've been writing tend to be small and contained.

	Some things to note: 
		* I was using a dictionary, and python dictionaries are unordered, so I did a bit of 
		a hack and added in the position attribute. It has to be in order under each menu, 
		like in &File.
		* The paths to the icons are relative to main.py, so you have to include view\\ like 
		shown.
		* You can use "Separators" to add a separator in the menu, or toolbar, as shown.

To make the buttons and menu selections actually do something, you need to connect the action 
with a "callback", in the main_window.py (KMainWindow) in the self.actiondict variable. 

Then you can write the functions in the KMainWindow.

Once you've specified your pages in \\page, you have to connect them in the pagemanager.py, 
self.pagedict variable. You have to import the page object by name, and give it a keyword, 
and the class name to call.

All the pages derive from pages.py Pages class, which is a QWidget. PageManager is what will 
be constructing them, and it passes itself as it's parent, and gives it the name you gave it, 
so the __init__ functions should all look pretty similar as far as interface goes. BlankPage 
is a good example of the simplest version.

Example:
	To get a form, look at formpage. I'll admit it's not pretty, but it gets the job done. 
	Questions out, input in.

	So, on __init__, page is going to call _setup and then _build. You can overwrite either, 
	set them to pass if you don't want them to do anything, and write something else, but I 
	found this pattern convenient.

	_setup:
		On setup, I define my lists. If I have a combobox, the list gets defined here. The 
		combolist could come from the database, and then you could get it again on refresh. 

		self.formlist is a list of dictionaries, (so this time it maintains it's order).
		Specify:
			"column" - The name you want to refer to it by (I usually make this the same as 
			the column in the database I will store the info in).
			
			"label" - What you want the ui to display.

		"type" - Can be:
			- "textenter": label + text entry box, 
			- "checkbox" : a checkbox. Value should be "True" or "False"
			- "button" : if you want a button. 
				-Add a "callback" attribute with the method to call when pressed.
			- "combobox" for a pulldown list selector. 
				- define the "list" attribute, as shown.
		
		"value" - This is the default value you want to show. (button's don't need it).

	_header:
		Simple label for the header. I used some html to style it up a bit. don't forget to 
		add the widget to the layout using self.layout.addWidget(). If you want to get crazy, 
		you can use PyQt documentation to adjust. 

	_center:
		Adds the form to the center of the page. "Form" is a custom widget I made to handle 
		all the setup for me. You can find it in \\view\\widgets. 

		All it needs to create it is the formlist.

	_footer:
		Simple ok, cancel buttons.

	_refresh:
		You may need to adjust this. It should be called when something needs updating, so 
		depending on what you're doing, you may need calls to the database here.