Editing Liqbase library overview

Warning: You are not logged in. Your IP address will be recorded in this page's edit history.
The edit can be undone. Please check the comparison below to verify that this is what you want to do, and then save the changes below to finish undoing the edit.
Latest revision Your text
Line 1: Line 1:
-
{{out of date}}
+
=liqbase :: the core library=
-
 
+
-
==liqbase :: the core library==
+
-
 
+
-
'''Note, this document describes a library which is not currently available, however its precursor [[liqbase]] is available for download:'''
+
-
 
+
-
'''http://maemo.org/downloads/product/OS2008/liqbase/.'''
+
 +
The formatting here is rubbish and I dunno how to fix it.
This is preliminary outline documentation for my library and toolkit.
This is preliminary outline documentation for my library and toolkit.
-
it will be expanded upon over the coming days.
+
it will be expanded upon over the coming days
-
 
+
-
===Rationale===
+
-
 
+
-
liqbase was born of frustration.
+
-
It started out as a collection of ideas and principles which show off the nokia internet tablet as a fast versatile handheld computer which very rapidly grew into a large monolithic application.
+
'''Note, this describes a library which is not currently available, however its precursor [[liqbase]] is available.'''
-
It was the first application I have written in C in many years has been used to learn about the device and the various libraries and interactions on the Nokia internet tablets.
 
-
A proof of concept so to speak.
+
liqbase is a simplified interface to the computer.
-
The library is aimed to correct the mistakes I made and to provide a framework to continue building my shiny applications.
+
It has been designed to make it as easy as possible to produce high performance touch sensitive applications.
 +
The applications are resolution independent and capable of operating at high speed in with low cpu overheads.
It contains a small set of classes which are usable for creating rich touchable GUI components.
It contains a small set of classes which are usable for creating rich touchable GUI components.
It has been written in C for both speed and expandability.
It has been written in C for both speed and expandability.
-
At present it is very specifically focused upon the Nokia internet tablet computers though it is compilable and usable within x86 linux as well.
+
The core library has been written with expansion and translation in  mind and will be happy sitting in almost any operating system.
-
 
+
-
===Why not GTK+ or Qt?===
+
-
 
+
-
I looked carefully at GTK+ when I first got my tablet and would have been happy it if it had the required performance, it has (semi) sane construction methods and an expansive library of controls and utility functions.
+
-
 
+
-
However on the tablet graphical performance was so poor that anything I attempted felt slow and applications crawled along. Qt had its own problems and still is not a viable option on the devices.
+
-
 
+
-
I wanted to do things which I took for granted on my old PDA and have done for years in Visual Basic and found the existing toolkits lacking.
+
-
 
+
-
===Dependencies===
+
-
 
+
-
liqbase makes use of the following libraries:
+
 +
At present it is very specifically targeted at the Linux platform and requires
*X11 window manager for the events.
*X11 window manager for the events.
*XVideo, an x11 graphics accelerator usually used for rendering video frames.
*XVideo, an x11 graphics accelerator usually used for rendering video frames.
Line 45: Line 25:
*xsp for the pressure sensitive mouse input
*xsp for the pressure sensitive mouse input
*ttflib ttf font handling
*ttflib ttf font handling
-
*libpng for reading and writing image data
+
*libpng
*libjpeg
*libjpeg
-
*sqlite3 for the database manipulation
 
-
graphics are rendered using the XV library using the YUV video format. This is a lower bandwidth video mode which has full resolution Luma, but half resolution Chroma.
 
-
===Base Classes===
+
graphics are rendered using the XV library using the YUV video format.
 +
This is a lower bandwidth video mode which has full resolution Luma, but half resolution Chroma.
-
It is being constructed around a core set of interrelated classes
 
-
*liqapp core system functions
 
-
*liqcanvas provides actual display backbuffer and event sink
 
-
*liqimage native image class, allows alpha, files of type png and jpeg supported
 
-
*liqfont a renderable font library, extensive caching
 
-
*liqsketch a dynamic sketch built up from various strokes and points
 
-
*liqcliprect a physical rectangle within an image with direct drawing routines
 
-
Beyond the core there is a second layer of classes dealing with structured layout and rendering
+
It is being constructed around a set of interrelated classes
-
*liqcell a single unit capable of holding or representing physical or meta data
+
*liqapp core system functions global
-
*liqgraph a special resolution independent graphics interface which a cell uses
+
*liqcanvas provides actual display backbuffer and event sink global
 +
*liqimage native image class, allows alpha, files of type png and jpeg supported inst
 +
*liqfont a renderable font library, extensive caching, inst
 +
*liqsketch a dynamic sketch built up from various strokes and points inst
 +
*liqcliprect a physical rectangle within an image with direct drawing routines inst
-
With these classes I will be able to construct the applications started inside liqbase.
+
Beyond the core there is a whole other set of classes dealing with layout and grouping.
 +
 
 +
*liqcell a single unit capable of holding or representing physical or meta data inst
 +
*liqgraph a special resolution independent graphics interface which a cell uses inst
 +
 
 +
The cell class is capable of raising and listening for events as well as being inheritable.
-
The classes outlined here existed in some form or other in the old liqbase and I have not yet documented the descendants of the cell class which sit together to form the UI itself.
 
   
   
-
===system class structure===
+
=class structure=
 +
 
 +
 
 +
Most classes created in liqbase follow the same object pattern and contain the following default standard methods:
-
The system classes created in liqbase follow the same object pattern and contain the following default standard methods:
+
int class_new()
-
<source lang="c">
+
-
class *class_new()
+
{
{
// Create a brand new instance of the class
// Create a brand new instance of the class
}
}
-
int class_hold(class *self)
+
int class_hold()
{
{
// Add a reference to an existing instance
// Add a reference to an existing instance
}
}
-
int class_release(class *self)
+
int class_release()
{
{
// release a reference to an instance
// release a reference to an instance
Line 91: Line 72:
}
}
-
int class_free(class *self)
+
int class_free()
{
{
// release all memory for this instance
// release all memory for this instance
// call _release on all members of this class
// call _release on all members of this class
}
}
-
</source>
 
-
User classes and instances built from cells do not require this interface.
+
The reference counting is held as a private member inside the instance itself.
-
The reference counting is held as a private member inside the instance itself.
 
There is no concept of inheritance at this level, however once you have instances of cell classes (described in detail below) they follow generic inheritance rules and can expand.
There is no concept of inheritance at this level, however once you have instances of cell classes (described in detail below) they follow generic inheritance rules and can expand.
-
===Example cell lifespan===
 
-
A usual cycle goes something like this
 
-
<source lang="c">
+
-
void hello_world()
+
Example Cell construction
-
{
+
-
    liqcell * myform = liqcell_newwidget(“myform”,”form”, 340, 60);
+
-
    liqcell *l1 = liqcell_newwidget(“hello”,”label”, 60, 60);
+
-
    liqcell *l2 = liqcell_newwidget(“world”,” label”, 60, 60);
+
-
    // do stuff with these instances and maybe create a tree of objects
+
A usual cycle goes like this
-
    liqcell_child_insert(myform , l1 );
 
-
    liqcell_child_insert(myform , l2 );
 
-
    liqcell_child_arrange_automatic(myform);
 
-
    liqcell_show(myform);
 
-
    // now we are finished release the root of the tree. 
+
void hello_world()
-
    // all items inserted will be recursively released.
+
{
 +
liqcell * myform = liqcell_newwidget(“myform”,”form”, 340, 60);
 +
liqcell *l1                = liqcell_newwidget(“hello”,”label”, 60, 60);
 +
liqcell *l2 = liqcell_newwidget(“world”,” label”, 60, 60);
-
    liqcell_release(myform);
+
// do stuff with these instances and maybe create a tree of objects
-
}
+
-
</source>
+
-
===Cell inheritance===
+
liqcell_child_insert(myform , l1 );
 +
liqcell_child_insert(myform , l2 );
 +
liqcell_child_arrange_automatic(myform);
-
The cell class provides a basic unit which everything is built up from. When used in a visual context, it represents a rectangular area on the screen. A cell can also be used as a simple  property holding information intended for its parent. Each cell can hold references to a font, an image and a sketch or even another cell. It can be inherited from other cells which expand its utility and purpose.
+
liqcell_show(myform);
-
===Dynamic scaling===
+
// now we are finished release the root of the tree. 
 +
// all items inserted will be recursively released.
-
liqbase is designed to operate in a truly resolution independent manner, after designing a widget according to specifications, it does not matter whether it is run on a lower or higher resolution display as the content will render correctly.
+
liqcell_release(myform);
-
 
+
}
-
I have taken special care ensuring the font class operates as expected within a dynamic resolution independent environment. At design time, the operator configures a form to certain dimensions (at 225dpi) and configures font sizes and positions relative to this. The fonts make use of extensive dynamic caching to both improve loading speed and to ensure that the correct glyph is displayed at the correct size as required.  The slight drawback with this approach is that at different scales there is some very slight variation in the exact final font size due to integer only glyph widths.
+
-
 
+
-
At runtime, the entire screen is situated within the available boundary and rendered accordingly. A landscape layout will run correctly in portrait mode, however it will be displayed at a reduced size to maintain its aspect ratio.
+
-
 
+
-
===Event handlers===
+
-
 
+
-
You can assign event handlers to any cell in liqbase and have a routine called when the event is required.
+
-
New events can be dynamically created and utilized as required.
+
-
 
+
-
====Linking handler to cell====
+
-
 
+
-
<source lang="c">
+
-
*vcell_handleradd(self,    "paint",  world_paint);
+
-
</source>
+
-
 
+
-
====Handler Code====
+
-
 
+
-
<source lang="c">
+
-
static int world_paint(vcell *self, vcellpainteventargs *args)
+
-
{
+
-
//liqapp_log("painting...");
+
-
// tell the subsystem this event has been handled (returning 0 will cause the chain to continue)
+
-
return 1;
+
-
}
+
-
</source>
+
-
 
+
-
====Using a handler====
+
-
 
+
-
<source lang="c">
+
-
vcell_handlerrun(self,"paint",&paintargs);
+
-
</source>
+
-
 
+
-
[[Category:Software]]
+
-
[[Category:Documentation]]
+

Learn more about Contributing to the wiki.


Please note that all contributions to maemo.org wiki may be edited, altered, or removed by other contributors. If you do not want your writing to be edited mercilessly, then do not submit it here.
You are also promising us that you wrote this yourself, or copied it from a public domain or similar free resource (see maemo.org wiki:Copyrights for details). Do not submit copyrighted work without permission!


Cancel | Editing help (opens in new window)

Templates used on this page:

Retrieved from "http://wiki.maemo.org/Liqbase_library_overview"