NOTE: This guide is a rough reference, please take the time to read the code line by line, as it is not that long. It is also outdated in some parts. Abstract: Itaka was developed in a purely Object Oriented fashion. It is designed to be completely modular and each component was made so that it is independent of the other to a certain extent. First there is the core loader 'itaka.py', which in turn loads the Console and Configuration handlers ('console.py' and 'config.py'). The configuration is read and loaded, and the passed to the new instance of our Console handler. After that, the main GTK+ GUI 'uigtk.py' is loaded, it is totally independent from any other modules, as are the Console and Configuration handlers. The main GTK+ GUI only relies on the Twisted GUI reactor to handle the multi threading for simultaneous running of a GTK loop and a Twisted server reactor. The GTK+ GUI then calls on the Itaka Twisted Web Server engine 'server.py'. Although the base Twisted server is completely independent of any other modules through its base class 'BaseHTTPServer', the classes used by the GUI are not. This is because or ScreenshotServer needs instances of our Gui, Configuration and Console engines. This expandability is a prime example of the Object Oriented nature of Itaka. It was designed from the ground up to be modular and easily expandable through inheritance. Such modularity allows for users to develop different GUIs in other toolkits such as PyObjC (Cocoa) or PyQT. In turn, those GUIs can adapt BaseHTTPServer to their needs. The HTTP server creates a resource called '/screenshot' (URL Path), which in turn takes the screenshot on request. This URL path is referenced on the HTML base code in the configuration as an <img>. The screenshot resource has a special render_GET() method that initiates the screenshot engine 'screenshot.py'. The screenshot engine is done entirely on GTK+ and does depend on it. It has not been yet modularized, but it would not take long to implement a totally different GUI for Itaka. Technical standards: * Inter-class communication: it is done by passing instances of one class to the child object that needs it. For example, the HTTP server needs an instance of the GUI for widget manipulation (Logging, etc.), and instance of the configuration class and an instance of the Console class. Since our main Itaka core 'itaka.py' passed the main instance of those classes to the GTK+ GUI, the only thing needed to do is to pass an instance of the GUI class to the child-objects that need it. * Exceptions: Itaka's exception definitions are stored in 'error.py'. Inheritance should be used widely. * Encapsulation: All of Twisted's exceptions and exceptions of screenshooting code should be encapsulated with equivalent Itaka exceptions. * Documentation: Use Epytext Markup Language. * Private methods: Methods that are _never_ going to be called outside the class should be prefixed with an underscore (_). Generating Documentation: Itaka is fully documented with Epydoc. You can download epydoc from http://epydoc.sourceforge.net/ You can generate documentation using epydoc. mkdir doc epydoc --html -o doc -n Itaka -u "http://itaka.jardinpresente.com.ar" *.py