Contents > Library Reference |
Library Reference
Strings | Functions for basic string manipulation. | |
Math | Trigonometric and other mathematical functions. | |
Sound | Functions for generating sounds. | |
System | Functions for retrieving and manipulating system status, dynamic memory, dates, and the clipboard. | |
Database | Objects for creating and manipulating databases and memos. | |
VFS | Objects for accessing the virtual file system on expansion cards. | |
Networking | Objects for IP networking. | |
Printing | Printing support using PalmPrint. | |
Data structures | General purpose objects such as a dictionary and a string list. | |
User Interface | Objects and functions representing the application's user interface. | |
Type Strings | How type strings work. | |
High Density Graphics | How to use OS 5 high density graphics. |
Contents > Library Reference > Type Strings |
Type Strings
A type string is a way of describing the structure of data. Several API
functions use type strings to control how data is read and written, such
as Preferences.get. The
easiest way to generate a type string is to use the typeof()
operator, which generates a correct type string for any object/data type.
However, sometimes it is necessary to create type strings by hand in order
to interoperate with the data formats of other applications.
A type string consists of a list of characters representing primitive types, with optional modifier to specify repetition. The types are as follows:
Specifier | Primitive Type |
---|---|
i | int |
w | 2-byte int |
b | 1-byte int |
c | char |
f | float |
s | string |
l | fixed-length string |
o | object type id |
A specifier may be preceded by a number representing the number of repeated values of the type in a row.
For example:
struct X { int x, y; string name; float f[4]; };The type string for X could be encoded as "iisffff" or "2is4f".
If name were required to be stored as a 32 character array:
struct X { int x, y; string name; // stored as a 32 character array float f[4]; };The type string for X could be encoded as "iil32.ffff" or "2il32.4f".
The object type id is a location in memory at the start of an object that lets the runtime know what type of object is stored there. This value is skipped by the methods that take type strings (because writing out an object id is not possible). So, if the struct above was declared as an object:
object X { int x, y; string name; float f[4]; };The type string for X could be encoded as "oiisffff" or "o2is4f".
Contents > Library Reference > High Density Graphics |
High Density Graphics
Beginning with version 5, the Palm OS supports screen resolutions higher than 160 by 160. OrbC provides support for these higher resolutions as described below.
To maintain compatibility with older applications, the OS treats forms and controls based on a 160 by 160 "coordinates". The OS stretches them to fit the actual resolution of the device - on a 320 by 320 device, one coordinate represents a 2 by 2 block of pixels.
When creating forms and controls in OrbC, or when accessing their x,y,w,h properties at runtime, 160 by 160 coordinates are used. Also, when an older application draws to the screen, 160 by 160 coordinates are used and stretched by the OS to match the resolution of the device.
The easiest way to make an app look better on high-density devices is to provide high-density versions of the app bitmaps and icons. To use these high-density images, no application changes are required - the OS will automatically display the high-density image on a supported device (older devices will use the standard image instead).
To define a high-density bitmap or icon, create an additional .bmp file that is exactly twice as wide and twice as tall as the standard image. Select the bitmap or icon in the IDE and add the new .bmp file in the property inspector.
When using the Draw object, the parameters passed to e.g. line() are interpreted as 160 by 160 coordinates. This allows older applications (and applications that don't care about the high density screen) to work without modification.
To allow easy drawing on both high-density and standard devices (including pre OS 5 devices), OrbC supports drawing at "native" resolution. Native resolution will be 160 by 160 on older devices and may be higher (e.g. 320 by 320) on newer high density devices. To draw in native resolution, an application should call Draw.nbegin() rather than Draw.begin() and then use the graphics functions as usual. Once Draw.nbegin() has been called, the native width and height of the drawing surface can be retrieved using the Draw object's nw and nh properties. For example, a gadget may draw like this:
object MyGadget { UIGadget gadget; void onopen(); void ondraw(); Draw draw; } void MyGadget.onopen() { draw.attachGadget(gadget); } void MyGadget.ondraw() { // draw an X draw.nbegin(); draw.line(clrFG, 0, 0, draw.nw, draw.nh); draw.line(clrFG, 0, draw.nh, draw.nw, 0); draw.end(); }
To determine the location of a pen event in native pixels rather than coordinates, two new properties have been added to the Event structure: nx (native x) and ny (native y).
Although other Palm OS based devices added high resolution support before OS 5 (such as the Sony Clie and Handera), the API was not standardized. All future versions of these devices will use the new standardized API. OrbC does not currently support the non-standard APIs.