GoDB Developer Network

Chart control in GoDB

noreply@blogger.com (Author) — Tue, 07 Nov 2006 10:29:00 +0000

One of the cool features added in version 3.9 is the chart control.

Let me provide you the gist before going into the details:

Best part:

The GoDB Chart Control can Display Charts from data in Arrays or Data from SQL Statements using DB_RSARRAY.
Supports different types of charts (pie, line, bar) with minimum coding...
Highly useful for platforms (ex: symbian, palm, etc) where GUI charts are non-existent / pain till now

Other side of the coin:
Chart control is not available in the evaluation version. One need to purchase the chart control separately with GoDB Enterprise edition (full version).
The best part becomes worst part if you don't have a full version & do not intend to purchase the chart control as an add on

Best bet if there is a large and emcompassing requirement to build feature rich charts.

Type of Charts available:

The below links provide samples / syntax on how to create / use line, pie and bar charts

Chart Tutorial

Line Chart

Chart With X Legend Texts

Charts With Multiple Data Streams

Bar Charts With Multiple Data Streams

Horizonal Bar Charts

Horizonal Bar Charts With Multiple Data Streams

Chart with Chart Labels, Chart Legend and Chart Event handling

Different Chart Types for Different Data Streams

Chart with Colors Specified for Points

Pie Charts

Database Driven Charts

Database Driven Charts With Multiple Data Streams

Using Web Services with GBasic (GoDB)

noreply@blogger.com (Author) — Mon, 12 Dec 2005 09:28:00 +0000

This article shall peep into invoking a webservice from the internet through GoDB. Iam using HTTPDNLD file and XML commands of GoDB.

The application takes the input of a host name and queries a WHOIS server through webservices and gets the detailed information.

For this, I am using http://www.webservicex.net . You can use other WHOIS server though.

Configuring the proxy:

for those having a proxy, you need to configure first before using the application. To go to Configuration screen (inbuilt with GoDB) press Function key 9 (F9). Fillin only the 'ProxyIP' field with your Proxy server. Leave other fields. Click 'save' and 'Go Home'

Querying the web:

the httpdnld command sends a http request with a host name as the parameter to a webservice. The webservice inturn queries a whois server and sends the result back. The result is saved in a file called test.xml

path$=http://www.webservicex.net/whois.asmx/GetWhoIS?HostName=+trim$(#txtName$)
RET=HTTPDNLD(path$,"","TEST.XML",1)
if RET=-3 then
msgbox "unable to get file"
endif

Parsing the XML:

Now, having created a XML file, we need to parse and display the content in the application for view. Since, the parse is inbuilt in GoDB, my work is much reduced- precisely four lines.

h=XMLParseFile("TEST.XML",1)

if ret>0 then
ret= XMLGoToFirst(h)
while XMLFetch(h,"")=1
str$=str$+ xvalue$(h)
pprint xpath$(h) ; xvalue$(h)

wend
endif

ret=XMLClose(h)
#txtRes$=str$

Overall, if you see, I put up a simple form to enter the host name, a button to query the web and a text area to print the queried results. I stored the data in XML format, parsed it and and displayed in the text area. A variance can be, instead of saving it in XML format, we can also save the same in .txt format and display.

HTTPDOWNLOAD.ZIP

Plotting charts with GoDB

noreply@blogger.com (Author) — Wed, 07 Dec 2005 06:25:00 +0000

With GoDB you can construct graphs and charts- both static and dynamic quite easily and pep up your data presentation. This article will touch the shallow waters of charting with static data. End of the article there is a link to download the source code for this charting application.

First some definitions:

''*****************************************************************
''''SOME VARIABLES THAT CAN BE INCLUDED IN THE QUERY STRING ARE

'XMargin = 20 MARGIN WIDTH BETWEEN COORDINATES IN X LEGEND
'XOrigin = 5 STARTING X1 POSITION OF RECTANGLE
'XRange = 190 X2-530, XRANGE IS DIFF OF X1 AND X2
'XDiv = 5 NO. OF DIVISIONS IN X AXIS

'YMargin = 20 MARGIN WIDTH BETWEEN COORDINATES IN Y LEGEND
'YOrigin = 210 STARTING Y1 POSITION OF RECTANGLE
'YRange = 200 YRANGE IS DIFF OF Y1 AND Y2
'YDiv = 5 NO. OF DIVISIONS IN Y AXIS

'ShowData = 1 TO DISPLAY DATA, WHILE PLOTTING POINTS

'Type = 1 LINE CHART
'Type = 2 BAR CHART
''*****************************************************************

'XAXIS$ = LIST OF X COORDINATES
'YAXIS$ = LIST OF Y COORDINATES

'SAMPLE COORDINATES
'XAxis$ = "1999,2000,2001,2002,2003,2004,2005,2006,2007,2008, 2009"
'YAxis$ = "50.340,83,737,90.50,400,300,200,200,400, 200, 300"

Bar Chart: Drawing the rectangle bar

to draw the rectangle bar, use drawrect function

ex: drawrect(XOrigin-10,YOrigin,XRange+30,-YRange,2,0,46815,46815)

For Color coding the bar use Fillrect function

ex: fillrect(XOrigin,YOrigin,XRange,-YRange,46815)

Line charts:

Line charts invovle two basic components. Plotting the data and drawing line.

PLOTTING DATA

If ubound(Str$) > 0 Then
For Count = 0 to ubound(Str$)
If Count=0 Then
m1=split(arrY$,Str$(Count),",")
ElseIf Count = 1 Then
m1=split(arrY$,Str$(Count),",")
End If

for i = 0 to NoOfPoints - 1
DataX = atol(arrX$(i))
NewX = TransX(DataX, XMax, XMin)
DataY = atol(arrY$(i))
NewY = TransY(DataY, YMax, YMin)
If Request$("Type") = "1" Then
iff i>0 then drawline(NewX,NewY,OldX,OldY,1,1)
iff ShowData>0 then textout(NewX,NewY,arrY$(i),0,63504, 5)
drawrect(NewX,NewY,2,2,2,1,63488,0)
ElseIf Request$("Type") = "2" Then
iff showData>0 then textout(NewX-5,NewY-20,arrY$(i),0,63504, 5)
drawrect(NewX-5,NewY,10,YOrigin-NewY,2,1,1,255)
End If
OldX = NewX
OldY = NewY
next
Next
Else
for i = 0 to NoOfPoints - 1
DataX = atol(arrX$(i))
NewX = TransX(DataX, XMax, XMin)
DataY = atol(arrY$(i))
NewY = TransY(DataY, YMax, YMin)
If Request$("Type") = "1" Then
iff i>0 then drawline(NewX,NewY,OldX,OldY,1,1)
iff ShowData>0 then textout(NewX,NewY,arrY$(i),0,63504, 5)
drawrect(NewX,NewY,2,2,2,1,63488,0)
ElseIf Request$("Type") = "2" Then
iff showData>0 then textout(NewX-5,NewY-20,arrY$(i),0,63504, 5)
drawrect(NewX-5,NewY,10,YOrigin-NewY,2,1,1,255)
End If
OldX = NewX
OldY = NewY
next
End If

Plotting charts from dynamic data or from database shall be dealt in future articles. So expect a sequel.

charts.zip

Printing: support for USB printers

noreply@blogger.com (Author) — Tue, 06 Dec 2005 05:16:00 +0000

GoDB has support for printing from serial printers. But for Win32 platform, there may be a need print to common printers attached to PC.

Direct Printing is supported through serial ports. In case other printers are required, GoDB usually launch the printing application provided by the printer manufacturer with the temporary file contains the contents to be printed.

For ex: You can use HP's print application for Pocket PC to print a file using the OS_EXEC command.

Syntax: OS_EXEC("hpprint.exe data.txt")

Here data.txt is the data to be printed, created within GoDB as an external file

Sample code for Activating trial applications.

noreply@blogger.com (Author) — Fri, 02 Dec 2005 09:12:00 +0000

This sample application provides input on how to create Trial Versions of applications and their distribution & activation mechanism for the developer community. The Sample application attached herewith gives an idea on how to Create Application ID, generate activation key and activation of the same by the user. It includes an Activation form where 'No. of Tries left' is shown along with a button (How To Activate), on click of which shows an 'Application ID'.

P.S. By default "no. of times left" shows 1000. This means the user can login upto 1000 times in the application. This no. can be defined by the Developer also. (Syntax: MaxAllowed=1000)

Steps to be Followed:

=====================

1) How to Activate - On click of this button by the user a message box pops up with the application id. The user would need to send the application ID to your predefined Email address (Eg.info@xxxx.com)

2) Use your custom logic to Generate an activation key and send the same to the user.( Refer sample code in samplekey.asp )

3) The user enters the activation key and clicks on activate button.

ActivationKey.zip

Obtain IMEI number of your symbian phone from Your Go-DB application

noreply@blogger.com (Author) — Wed, 30 Nov 2005 08:19:00 +0000

by Ted Daniel -- Source: www.newlc.com

Go-DB supports loading external DLLs via simple GBasic APIs. Although most of the widgets neccessary for business application development are avaiable in Go-DB, you may in certain cases want to extend a particular platform for reasons best suited for your requirement be it for your application related needs or simply having fun. Find out how to use Go-DB to obtain IMEI number(International Mobile Equipment Identity) from your Go-DB application. In a later article, i will explain how to send SMS from your Go-DB application from a Sony Ericsson p910i phone.

Any cross platform application development at a particular point may need to extend a particular platform. Like any good cross platform development tool, Go-DB offers features which enable developers to fully extend a platform’s full capability. This article focuses on certain APIs in GBasic and how to use them to hook your DLL built using Symbian SDK.

Step 1

You will need GStudio 3.4 (now a newer version 3.6 is available for download) final realease. Get a trial copy from http://www.go-db.com. You will also need Symbian module , which can be downloaded from the same location. (comes pre-installed with version 3.6. So no need to do this step)

Step 2

Download and install a Symbian SDK. For this particular example any SDK for Symbian OS version 6.0 and above is needed. I have used UIQ 2.1 SDK wincw version, downloadable from Sony Ericsson developer site(http://developer.sonyericsson.com)

NOTE: You dont need to have Codewarrior to get this example working.

Step 3

Download the sources for this tutorial, downloadable with this article. Download and unzip to your Symbian install drive.Open a command prompt window and issue these commands.

bldmake bldfiles

abld build armi urel

This will buid the DLL. Pre-built SIS files are located in Group directory. SIS file installation will copy IMEIDLL.DLL to /system/libs directory on your device. Change the pkg file located in Group directory to suit your requirement.

Step 4

Build the Go-DB project in release mode. Create a SIS file for your device and install it. Click on "Fetch IMEI" button and a message box will pop-up displaying your device’s IMEI number.

The Source code is as Follows

Listing 1. Symbian cpp source code

Our DLL exports one function whose definition is EXPORT_C long GetIMEICode(char *str); and the implementation is as follows

EXPORT_C long GetIMEICode(char *str) { int i= 0; TBuf<256> Path; TPlpVariantMachineId imei; PlpVariant::GetMachineIdL(imei); Path.Copy(imei); for(i=0;i < Path.Length();i++) { str[i] = Path[i]; } str[i] = '\0'; return 1; }

Note that Go-DB understands "char *" only as parameters to functions.Converting to and from Symbian Descriptors is neccessary.After freezing the dll and building the project, note that a .DEF file will be created which will list the functions exported and theordinal associated with it.Our .DEF bundled with source shows the following.

EXPORTS

E32Dll__F10TDllReason @ 1 NONAME R3UNUSED ; E32Dll(TDllReason)

GetIMEICode__FPc @ 2 NONAME R3UNUSED ; GetIMEICode(char *)

We are not interested in E32Dll , just GetIMEICode. The ordinal as given to us is 2. This ordinal will be needed by our GBasic Code.

Note: To freeze a dll after exports have been identified and defined properly, issue this command

abld freeze armi

Listing 2. Go-DB source code

Sub IMEICTRL_Click st1$="Initial String" h = loadlib("\\system\\libs\\IMEIDLL.dll") if h <> -1 then ret = calllibfunc(h,"2",st1$) msgbox("IMEI Code is " + st1$) unloadlib(h) else msgbox("Failed loading IMEIDLL.DLL") end if End SubWe load the IMEIDLL first using loadlib function, if the function gets loaded properly, then the handle it returns will not be -1. Once we obtain the handle , use the handle in calllibfunc to execute the exported function. As explained in Listing 1, use "2" as Function Name. After the function call, st1$ will hold the IMEI number.

GoDB-IMEI.zip
7.6 kb

Ged Reference

noreply@blogger.com (Author) — Wed, 30 Nov 2005 06:54:00 +0000

Ged is the tool used to import and export data between html pages and databases and
GoDB's file system.

Note: This is used by GStudio Internally.

Ged can be used for the following :

1) Import Html, Image , Database, Text, config and forms.

2) Export database and config files.

Notes :

GoDB filesystems SHOULD be named as "bdb" and should be in the current working directory (of ged and simulator). All the following operations are executed on this file.

Usage : GED [options] InFile [ext]

Options

-a Add Any File without translation. Used to add raw binary files.

Usage: Ged -a xyz.txt

-h Add Html files with tag translation. Used to load html pages and forms.

Usage: Adding a Page -- Ged -h test.html .txt

Adding a form-- Ged -h test.html

Note: Refer to -p option to set font height while translation.

-p Sets the font height for translation. This should be combined with -h option.

Usage: ged -p 12 -h test.htm

Note: If this option is not provided then ged assumes a font height of 8.

-g Translates image into GoDB Image file.

Usage: ged -g [FileName] [Rle] [ColorDepth]

Rle - Determines the Compression

0 - Uncompressed.
1 - Compressed.

ColorDepth -

0 - Monochrome

1 - Pallete based 256 color

2 - 64k Colors (RGB565 format).

-i Will index the a database table

Usage: ged -i [Tablename] [IndexFileName] [KeyField] [KeyLength_in_chars]

Ex: ged -i Comp Comp.idx CompID 12

GStudio Reference

noreply@blogger.com (Author) — Tue, 29 Nov 2005 11:39:00 +0000

GStudio

GStudio is the and Integrated development Environment to edit debug and simulate GoDB applications.

Menu Options.

File Menu

File Operations.

Edit Menu

Editor Operations.

Build Menu

Compile : Compiles the current file.

Build : Builds the project by compiling all the Modified Files.

Build All : Builds all the Files in the project.

Clean: Deletes all the intermediate files in the build folder including the database files.

Start Debug : Launches the simulator and connotes to it for source level debugging.

Run : Launches the simulator in Run Mode.

Remove All Breakpoints: Removes all the breakpoints in the open bas files.

Configurations: Add or remove Platforms to the Forms Builder.

Publish: Publishes the current project to GoDB Sync Server for Application Deployment.

Exclude Setup: Launches a dialog that lets you exclude files for different platforms.Ex: In some cases you might have ifferent images for different platforms and youexclude the images from getting to all the platforms. Home_PPC.bin should get compiled only to PPC platforms, Home_PALM.bin should get compiled only to Palm platforms etc.

Tools Menu

AddPlatform To Project : This option adds a new platform to the project. Platforms option allows the developer to have different form layouts for different Resolutions.This is similar to Build ->Configurations.

Unicode To UTF: This option helps the developer to get UTF-8 Encoded strings from Unicode strings. elect the Language option from the Language tool bar in the OS and
type it on the Uincode Edit box , the UTF text will appear in the UTF Text
box.This can be copied and pasted into the property

window.

Other Options in this menu let you Publish the app and VM to devices create setups etc.

View Menu

Clear Build Window: Clears the Build Output Window. PPrint outputs to thiswindow during debug Sessions.

Clear Trace Marks : Clears the Cyan marks in the left margin when you run your project in debug mode.

Options -> Project

Project

GVS: When using the GoDB Sync server, GVS is the GODB Versioning system formulti user
projects. Refer to Sync server manual for GVS configuration.

Options -> Source & Design:

Insert Comments Options determines if the comments are automatically insertedwhen you press enter after entering a sub statement.

Enable Auto Completion Options determines if the Auto Completion Popup
ShowsUp.

Auto Intend Options determines if Code intends automatically in the editor.

Use UTF8 This option if Unchecked will render characters above ASCII 127 as Extended ASCII Characters. This is required for projects that use scandinavian ASCII characters .

Options -> Build

Verbrose option determines if the external tools output, like the compiler output etc are displayed in the build output window.

Publish Compiled Scripts option publishes the compiled files to GoDB Sync server
automaticallyafter compilation.

BDB Custom Size option lets you sepcify the Maximum size of the BDB. Default is 90 MB.

Command Line option let you specify the Additional Command line parameters while Executing.

Ex: -a=100 -b=200 etc these will be available in GBasic as GetOsVar$("*CMDLINE")

Option -> Workspace

Gridspacing Determines the guide grid in the form builder.

Render Images Determines if the images are rendered in the form builder.

Auto Hide DesignTools Determines if the Tool Box is automatically hidden when you switch to code view from the form builder.

Selection: Determines if the selection rectangle selects Complete or partial Selections.

When the "Select items that are completely..."
option is selected only the first control is selected.When
the "Include Partial Items..." option is selected both the controls are
selected.

Layout MenuForm Layout Operations.

Set Tab Order Let you set the focus order of the controls in the form.Select this option and click on the controls in the order you want the controlsand select Layout->Set Taborder Option to go back to normal editing.

Before After

Example:

Script Wizard Menu

Creates Scripts for the current form and fields.

Window Menu

Manages open windows in the IDE.

Help Menu

Help, Activation , Updates etc.

How GoDB Works ?

noreply@blogger.com (Author) — Tue, 29 Nov 2005 11:34:00 +0000

GoDB works by having runtimes (VM) for various platforms that isolate hardware specific issues from the application developer.

For example GoDB provides a consistent way of rendering forms with edit boxes and buttons, display images on forms, store data in RDBMS as records etc on all platforms. GoDB VM takes care of determining the type of file system used (Ex Flash,FAT etc) and implements appropriate the read and write routines. Similarly GoDB VM takes care of determining the display solution and color depth and renders forms in color or monochrome accordingly.

GoDB has the following components.

Microbrowser to render Forms and Pages.

RDBMS engine with ANSI SQL support.

GBasic programming environment.

File System Manager.

Display manager.

Pointer/Keyboard Manager

Connectivity Manager.

Smart Sync Manager.

Memory Manager (Heap/Stack)

All these components were written in pure ANSI "C" so that it could be compiled on multiple platforms. These components form the GoDB runtime environment (VM).
This enables the applications developed for GoDB on one platform say Win32 to run on the another platform say Palm without any change.

The following components are hosted in Windows.

GStudio - GoDB IDE with Integrated Source level Debugger.

GoDB Compiler

GoDB platform simulators.

Platforms supported

GoDB VM

GoDB VM is the runtime engine that renders the forms and executes the applications on the various platforms. GoDB VM reads the Forms, gBasic and image files from the GoDB file system that is generated by the GoDB IDE after successful compilation of the project. This file system contains all the files required by an application and is called the BDB. To deploy an application to other platforms this file is just copied to that platform.

GoDB Build Process

GoDB Architecture

Custom Keyboards (GoDb Enterprise Edition)

noreply@blogger.com (Author) — Tue, 29 Nov 2005 11:26:00 +0000

When dealing with multi lingual fonts or devices that do not have keyboards, GoDB provides an
extensible Multilingual Keyboard and GBasic API for managing the Keyboard.

To create a Custom Keyboard you need to create an Image with the KeyMap.

You need to create XML Keyboard Map files that specify the Location of the keys and the ASCII code that has to be generated corresponding to the font you are using. The XML file should have the same name as that of the image file, say you have T_Main.GIF the XML file should be called T_Main.xml.

The XML is defined as

<gkeymap keycount='10'>

<key x='17' y='0' w='17' h='15' c='1' >

<key x='28' y='31' w='17' h='15' c='a' >

<key x='212' y='47' w='26' h='15' a='13' >

<key x='0' y='47' w='34' h='17' i='T_shift_main'>

</gkeymap>

Where keycount Specifies the Number of keys in the keyboard.
x,y Specifies the Coordinates of the Key.
w,h Specifies the Dimensions of the Key.
Character Codes that need to be generated can be specified as c - Character that needs to be
generated for the key.

a - ASCII / Unicode Code for the character that needs to be generated.
Multiple Keyboards can also be liked with the i attribute
i - This attribute can be used to load another keyboard when the user clicks on the specified
region. In the example clicking on the Shift key will load the T_shift_main.bin and T_shift_main.xml.

To Load the Keyboard you have to use the LoadKeyBoard Method.
To Show the Keyboard you have to use the ShowKeyBoard Method.
To Hide the Keyboard you have to use the HideKeyBoard Method.

Compile and run the project

In the simulator you can Display the keyboard using the F5 key.

You can click on the Shift Key for the Alternate Keyboard.

Importing Fonts

noreply@blogger.com (Author) — Tue, 29 Nov 2005 10:44:00 +0000

Goto Tools -> Font Importer.

Select the Font By Clicking the Select Font Button.

This should open up the Font selection dialog select the font and Hit OK. Next Select the The Font File Name to Export the font to (Say Font7.fnt)

Next Select the Char Set. Select Basic Latin and Click on the Add (">") Button.

Click on the Export Button.

This should create the Font file. Add the font file (F7.fnt) to the project. Add a text box to your form and change the Font attribute for the text box to 7 and save compile and run the project.

GoDB supports Unicode fonts too. See Tutorial on using Unicode for Multilingual apps and font apps.

Note: Font files are copyrighted and you should acquire necessary Licences to export and
use them in your applications.

Styles Fonts and Icons

noreply@blogger.com (Author) — Tue, 29 Nov 2005 10:44:00 +0000

GoDB's Microbrowser supports customization of all the widgets and color schemes using Style Files.

Style files are standard text files with CSS extension that have the name of the colors to change and the new color value.

Ex:

TXTFLD_FG_COL=31 'Foreground color

TXTFLD_BG_COL= 65520'Background color

TXTFLD_BORDER_COL=63519'Border color
TXTFLD_SELTXT_COL= 63488 'Selected text color
TXTFLD_SEL_COL= 65504 'Selected background color
TXTFLD_SELBRDR_COL= 2016 'Selected border color

The above example shows how color scheme of a text box can be changed.

The file name of the CSS file determines which form the style is applied to. For example if you name the CSS file as home.css then the styles apply only to Home.Frm.

If the CSS file is named Global.CSS then the style applies to all the forms but can be overridden by specific CSS files (say home.css).

Starting with GoDB 3.6 you can use HTML 24 it Color formats #FE00FF

Example:

Right click in the project explorer and select Add File. Enter Home.CSS in the open dialog. Open Home.css and enter the example css data.

Compile and Run the application.

You can add global.css and copy the style contents and see that all the forms show the same style. Refer to styles section in the help for a complete list of style names.

You can also load custom fonts into godb. These fonts can be English or regional fonts. You need to use GoDB Font Converter tool to convert any standard ttf file to a file that can be used in GoDB. GoDB supports up to 20 concurrent fonts. These are numbered from 0-19 , Fonts 3, 4 and 5 are preloaded into the GoDB VM. These can be overridden to change the standard fonts in godb. GoDB also supports right to left Arabic and Hebrew Fonts.

Lessong 8: Advanced Topics -External Communication API.

noreply@blogger.com (Author) — Tue, 29 Nov 2005 05:05:00 +0000

GoDB has support for communicating using sockets, Serial Ports etc. You can use the
DevopenDevRead DevWrite and DevClose functions for this.

Socket Communication.

For Sockets
'DEVOPEN(0,IP,PORT)

st1$="Hello There\r\n"
ret=DEVOPEN(0,"127.0.0.1","8080")
ret = DEVWRITE(0,st1$,"")
ret = DEVREAD(0,st1$,"")
print st1$
DevClose(0,"")

DevRead and DevWrite use Binary Escaped Strings ie Nulls are escaped as /00 and / as /2f (Refer to Chapter on Binary Files).
For Serial Ports and Serial Printers.'DEVOPEN(1,PortID,[Speed,FlowControl])

st1$="Hello There\r\n"ret=DEVOPEN(1,"COM1:","9600,0")
ret = DEVWRITE(1,st1$,"")
ret = DEVREAD(1,st1$,"")
print st1$
DevClose(1,"")

Drawing and Painting

GoDB supports drawing and painting routines like DrawLine, FillRect etc. GoDB Repaints the screen when something major changes happen on the screen.
An example is a Calc Box or LUT Showing up. As the screen gets repainted, all previous drawing commands can get overwritten. To avoid this put all your drawing functions in Form_Paint routine

All drawing routines in Form_Paint routine are called automatically when ever the screen gets repainted.

Sub Form_Paint
' Add Handler Code Here fillrect(10,10,100,100,63488)
fillrect(20,20,100,100,2016) fillrect(30,30,100,100,31)
fillrect(40,40,100,100,2047)
End Sub

GoDB has built in Double Buffering where all drawing and painting routines are drawn on to a local offscreen buffer and then transferred to the OnScreen Buffer.This avoid flickering.

You can selectively paint a field in GoDB.This feature is useful in certain scenarios like for example if you want to paint a control inside a tight loop in GBasic.

If you run the following code you will see only the last number shown in the Field.

Sub Button1_Click
for i=1 to 100
#text1=i sleep(10)
next
End Sub

If you run the following code you can see the numbers changing in the edit control.

Sub Button1_Click
for i=1 to 100
#text1=i
#text1.paint(1)
sleep(10)
next End Sub

From GBasic you can paint the screen using the Paint method or refresh and repaint all the controls using the Update method.

Signature Fields (GoDb Enterprise Edition)

GoDB has a built in signature capture field. The signature capture fields uses the Value attribute of thefield to create two bitmap files, the signature and the thumbnail of signature.When the form is rendered the thumbnail is displayed on the form and when the user clicks onthe signature capture field, the bitmap is displayed in the popup. If the disabled attribute is set to 1 then the popup is not displayed so the user cannot modify the signature.

In a database application the Value attribute should be set to a unique key of the captured record.

Ex: #Sign1$="S_"+PrimKey$ This will create unique sig files that can be associated with a
record.Sig2BMP component can be used convert the .SIG file to a BMP File.

Timers

GoDB has a built in timer for handing background tasks. The timer can be set with a time interval and an Event handler function.

settimer(50,"TimerFunc")
end

Sub TimerFunc
#text1$=format$("time",Time())
#text1.paint(1)
End Sub

Calling External Processes

You can launch an external process / EXE using the OS_EXEC command. You can Launch Print Applications, IR Transfer applications (IRSquirt in Pocket PC), File viewers Like ACROBAT reader, Internet explorer etc
Ex:

ret = os_exec("F:/WINNT/NOTEPAD.EXE C:/temp/test.txt")

External API Dlls

GoDB supports loading of DLLS and Loadable modules (.so files in Linux) for calling native platform functions. The DLLs can be loaded using the LoadLib Function.

h=LoadLib("Test.dll")
When the DLL is loaded The Init function on the DLL is called with the HWND Handle.

//****************************************************
__declspec(dllexport) long Init(HWND hWnd)
{
MessageBox(NULL,"Init","Hi",MB_OK);
return 1;
}

You can call the functions in the Dll using the CallLib Function. GoDB passes all the Parameters as character Pointers to the DLL.

st1$="Hello There Param 1"
st2$="Hello There Param 2"
calllibfunc(h,"TestFunc0")
calllibfunc(h,"TestFunc1",st1$)
print st1$

//****************************************************

__declspec( dllexport ) long TestFunc0()
{
MessageBox(NULL,"Func0","Hi",MB_OK);
return 1;
}

__declspec( dllexport ) long TestFunc1(char *p1)
{
MessageBox(NULL,p1,"Hi",MB_OK);
strcpy(p1,"Changed in DLL");
return 1;
}

To Unload the dll call the UnloadLib Function.

h = loadlib("gDllTest.dll")
ret = unloadlib(h)

When the DLL is unloaded the Deinit Function is called.

//*******************************************************************
// DeInit function in the DLL
//*******************************************************************

__declspec(dllexport)
long DeInit()
{
MessageBox(NULL,"DeInit","Hi",MB_OK);
return 1;
}

Using ActiveX/COM Components in GoDB

GoDB Allows you to instantiate and use ActiveX/COM Components in Win32 and WinCE Platforms.To use a Component you need to add the GDO Control to your form First.This can be done at the design time by
adding the control to a Form.

Or or at runtime by using the Print Command.

print "<gdo Name='GDO1' ProgID= 'WMPlayer.OCX.7' X='100' Y= '100' W='100'
H= '100' >"

In GBasic you can call the methods on the objects as if they were standard Field Objects.

Sub Button1_Click #GDO1.URL$ = "c:\\temp\\1.mpg"
End Sub

The thing to note here is that All String Properties of the object should have a $ at the end.When distributing the Applications that have ActiveX components you need to distribute GDOBridge.dll in the GoDB Installation folder.

GDO Dlls

Only Win32 and WinCE support Com components natively. To create Native Dlls/SOs for other platforms thatCan support Introspection by the GoDB VM to expose the DLL as an object to GBasic you need to create the DLL that exposes the Standard GDO Introspection functions. For an example of a GDO DLL see GDODLL Template in the Dll Samples.

The VM Loads the DLL and calls these exported functions to identify the properties , methods, functions, Types and parameters supported by the DLL and exposes these to GBasic. GDO dlls can be Instantiated by using the GDO Control in the form. This can be done at the design time by adding the control and Setting the ProgID to the File Name of the Component Or or at runtime by using the Print Command.

Message Hook Dlls

GoDB supports devices that have external Barcode Readers/ RFID Readers etc. To support these devices GoDB has the option of loading Message Hook dlls. Message Hook Dlls are standard dlls that have a predefined set of exported Functions.

Message Hook DLLs should have the following exported functions.
HookGetEventRange(void* hWnd,long *EvStart,long *EvEnd, void** ppData)
HookOnEvent(MSG *msg)
HookFree(void* pData)

When GoDB Starts it looks for gHook.dll in the current directory. If Present GoDB loads the DLL and calls HookGetEventRange. The DLL should return the event range that GoDB should pump to the dll.

When an event is received in the Message Queue that matches this range GoDB Calls
the HookOnEvent(MSG *msg) with the Message Structure.

The DLL can then decode the message and post appropriate translated Message. A typical Example is a Symbol Device that has a Barcode Scanner.

THe GHook.dll Initialises the barcode scanner when it loads and registers with GoDB with the message ID range that is generated when the Scan Button is pressed.

When the user presses the scan button the Message ID since is in the requested range is passed to the gHook.dll. gHook.dll then Uses the BarCode Reader API to read the barcode and posts WM_CHAR message to the HWnd sent by godb in the HookGetEventRange function.

GoDB also has Encryption and Connection Manager Dlls. Refer to the External Processes & DLLs section for more information.

Server Push Functions Using Sockets

GoDB has Functions that can Listen for messages from the server or from other GoDB Applications. To Use the Push Functionality you need to start the Message listener using the MSGLISTNER function.

Currently GoDB supports socket listener. To start the Socket Listener,

MSGLISTENER("START_SOCK:9898")

Where START_SOCK is the command to start the socket listener in the future support for Bluetooth etc will be added, and 9898 is the Port Address where the socket will be listening. When a message is received the FORM_NOTIFY handler is called.

To send a message to the Socket Listener use SendMessage Function.

SendMessage("Sock/127.0.0.1:9898","Hello There")

Send message also takes the parameters of the format [Type]/[Commands]

For Sockets it isSock/[IP address]:[Port]

The second parameter is the message to be sent.

Here we are sending a message to the same machine (127.0.0.1).

To Get Notification you have to write a Form_Notify handler. Form_Notify handler receives all types of notifications from GoDB.The Function GetNotifySrc() should be used to determine the source of the Notification. GetNotifySrc() returns 1 for server messages.

When the notification is received you can use GetMessage Function to retrieve the message from the message queue.

GetMessage Takes 4 parameters, The First parameter returns the numeric Message ID that uniquely identifies the message.

The Second Parameter is the message type which is a string variable that specifies the type and identification of the sender. For socket message this contains the sender IP address.

The third parameter contains the message that was received.

The fourth parameter contains the options for retrieving the message.

Sample Code:

'******************************************************
' Form_Notify Is Called when a Notification Event is Received.
'*******************************************************
sub Form_Notify
if GetNotifySrc()=1 then
print "Server Notification Received"
dimi a
dims b$,c$
for i=1 to 10
if getmessage(a,b$,c$,"")=1 then
print a;b$;c$
else
exitfor
endif
next
update
endif
endsub

Note: For performance reasons a message can contain up to 255 characters.

Server Push Using SMS (Short Message Service) in smartphones.

On Smartphones the MSGLISTNER function can be used to setup a listener for SMS Incoming Messages.

MSGLISTENER("START_SMS") Starts the SMS Listener so when a SMS is received by the phone Form_Notify is called withGetNotifySrc Returning 4. The Form_Notify Event for SMS is

'*************************************************
' Form_Notify Is Called when a Notification
' Event is Received.
'*************************************************
sub Form_Notify
if GetNotifySrc()=11 then
print "SMS Notification Received"
dimi a
dims b$,c$
for i=1 to 10
if getmessage(a,b$,c$,"")=1 then
print a;b$;c$
else
exitfor
endif
next
update
endif
endsub

To Stop the SMS Listener .
MSGLISTENER("STOP_SMS")

To Send an SMS you can use the Send Message Function.
SendMessage("sms/+14250010001","Hello There")

Note: If some other built in program like Inbox is already listening for SMS, you cannot start the SMS.You need to shut it down first and then start the SMS
Listener.

Lesson 7: Syncronization API & XML Parsing

noreply@blogger.com (Author) — Mon, 28 Nov 2005 09:47:00 +0000

GoDB was designed to support occasionally connected and always connected applications.

Occasionally connected applications are standard rich client applications which can synchronize data and applications to the GoDB Sync server.

You can also create online applications using GoDB. There are two ways to create online applications in GoDB.

Using Forms and using net API.

Using Forms

NOTE: To Execute this sample you need a webserver.

Open the form builder and add a few text boxes. Also add a Submit Button.

Set the URL property of the Submit.box to /gtest/hello.asp.

Open the config page and set the GatewayIP to the IP address of the webserver.

You can do this at compile time by editing Config.ini or at run time by pulling up the config screen (F9 after login in) and changing the GateWay IP and saving. If you select the runtime approach when you rebuild the project you need to set the Gateway IP again.

In the Webserver machine create a directory called gtest and create a page called Hello.asp
in it and copy the following content.

<%

Response.Write Request.ServerVariables("QUERY_STRING") & vbcrlf
Response.Write "Text1 = " & Request("text1") & vbcrlf
Response.Write "Text1 = " & Request("text2") & vbcrlf
Response.Write "Text1 = " & Request("text3") & vbcrlf
Response.Write "<link Name='Link1' value='Go Home' URL='!home.frm'>" & vbcrlf
Response.Write "<link Name='Link2' value='Get More Info' URL='/gtest/Moreinfo.asp'>" & vbcrlf
%>

Compile and Run the Project.

Click on the Submit Button.

You should see the results from the server.

If URL property of the submit button does not start with a / then the BasePath
from the config file is used as the target url.

For example if BasePath is GoDBSS and the URL Property of the Submit Box is gtest.asp then target URL would be http://Server/GoDBSS/gtest.asp

You can also use the Link Control to link to internet pages.

Add a link control to the Form and set the URL to /gtest/hello.asp. When you click on the link you will be taken to the page in the webserver.

NET API

In the previous section we saw how we can connect to a webserver to post values and link to internet pages.

In this section we will see how we can do this from GBasic using net API. The remote site can be a standard website or a webservice.

You can use the HTTPDNLD Api for downloading data from internet site to a local file.

Result = HTTPDNLD(URL,POSTQUERY,FILENAME,ISEXTERNALFILE)

Examples of usage.

'Standard Download
ret=HTTPDNLD("/gtest/hello.asp","text1=v1&text2=v2","test.txt",0)

UnLike the Submit button and the Link Control HttpDNLD can be used to download data from Fully Qualified URLs.

ret=HTTPDNLD("http://www.consigntech.com/gTest/Hello.asp","Text1=v1&Text2=v2",

"test.txt",0)

Downloading Rows to a Table

Result = HTTPDNLDTABLE(URL,POSTQUERY,TABLENAME)

You can use the HTTPDNLDTable api to download a tab delimited file from a webserver and insert it into a local table. The table should exist on the client and the Column count in the downloaded file and the local table should be compatible.

ret=HTTPDNLDTABLE("/gab/default.asp","search=A&viewby=0","TestTable");

print ret
print DB_ERROR$()

Note On Proxies.

In some cases you might have a proxy server in your network.If this is the case you need to get the Port of the proxy server and enter it in the "Port" box. Also enter the Proxy IP in the "ProxyIP" box and finally check "UseProxy".

XML Parser

HttpDnld can be used to download data from normal sites and webservice sites.

When the file is downloaded from a webservice site the resultant file is usually a XML File. You can use the XML api in GoDB to parse the file and extract the information you require.

Example: To reterive market quotes from

http://www.webservicex.net/RealTimeMarketData.asmx/Quote?Symbol=IBM

Create a new form and add a few text box controls and name them Symbol, DateTime,Price,Shares.

Add a button and add the following code in the handler.

Sub Button1_Click

' Add Handler Code Here

url$="http://www.webservicex.net/RealTimeMarketData.asmx/Quote?Symbol="+#symbol$
ret=httpdnld(Url$,"","quote.xml",0)
h=XMLParseFile("quote.XML",0)
ifh<>-1 then
> ret=XMLGoToFirst(h)
while XMLFetch(h,"")=1
print xpath$(h) ; xvalue$(h)
iff xpath$(h)="\\QuoteList\\QuoteLists\\Quote\\Price" then #Price$=xvalue$(h)
iff xpath$(h)="\\QuoteList\\QuoteLists\\Quote\\MatchedShares" then #Shares$=xvalue$(h)
iff xpath$(h)="\\QuoteList\\QuoteLists\\Quote\\DateTime" then #DateTime$=xvalue$(h)
wend
endif
ret=XMLClose(h)

End Sub

Compile and Run the application and Click on the button.

Sync API (GoDB Enterprise Edition)

GoDB has a built in synchronization component to identify modified files, records and seamlessly synchronize them with the GoDB server. The developer doesn't have to write even a single line of code to synchronize files and tables. The developer just needs to map the
files and tables through in the GoDB Sync server admin panel and they automatically get downloaded and updated when the user synchronizes.

There are two ways the client can initiate synchronization. By Opening up the Menu and clicking on Sync.

Or by using the SYNC Api.

Sync([FULLSYNC],[Sync Status Display Level])

if FULLSYNC =0 then Incremental Sync is performed

if FULLSYNC =1 then All the files tables are downloaded from the server and synced locally OVERWRITING all the data on the client.

rem Delta Sync

SYNC(0,3)

rem FULL Sync

SYNC(1,3)

Refer to GoDB Sync Server Manual for an overview of GoDB Synchronization.

HTTP File Uploading.

Just as the HTTPDNLD enables you to download files , you can use the HttpUPLD and HTTPUpldTable apis to upload client files to the server.

Result = HTTPUPLD(URL,POSTQUERY,FILENAME,SERVERFILE,

RETURN_VARIABLE,IsExternalFile)
Ex:

'Internal File

dim a$(10000)

print httpupld("http://default.asp","a=U","SMS.jpg","SMS.jpg",a$,0)

print a$

NOTE: The file is uploaded as a HTTP Upload (HTML <input type=file>) and you need appropriate component on the server to receive and store the file.

You can upload a local table or results of a query to the server similarly using the HttpUpldTable Command.

Result = HTTPUPLDTABLE (URL,POSTQUERY,SQL,SERVERFILE,

COLUMNSEPERATOR,RETURN_VARIABLE)

dim a$(10000)

print httpupldtable("http://Server/default.asp","a=U","select * from customer","table.txt","\t",a$)

print a$

The return Variable holds the contents sent back from the server after upload.

You can implement a complete Sync system using the HTTP Uploading/Downloading api, You can use FATTR function to identify modified files on the client, FCOPY, FDelete and OS_exec to do post sync installation and cleanup tasks.

Lesson 6: Images, Custom Menus, Reading & writing Files and Authentication

noreply@blogger.com (Author) — Mon, 28 Nov 2005 08:48:00 +0000

Images

GoDB has an in-built Microbrowser which can render forms enabling you to develop rich UI applications with images.

Here are some of the UIs that are possible.

GoDB supports GIF,JPEG and BMP Images.

Select the Images Tab In Project Explorer.

Right Click on internal images and select Add File.

In the Open dialog select the images.

Open Home.Frm, Switch to the Images Tab in the project explorer and drag drop the images into the form.

Reposition the Image fields.

Compile and Run the application.

If you want to see the images rendered in the form builder after you drag and drop them, then click on Menu -> View-> Options. Select Workspace Tab and Check Render Images.

You should be able to see the rendered images in the form builder now.

When the project is compiled the images are converted to a BIN File (GoDB Bitmap Image format) and compiled into the BDB file.

External Images: (Not Recommended for handheld platforms)You also have the option of having the images in an external images folder (Sub-directory
below the BDB directory).

If the platform supports rendering of PNG/JPG/GIF files they can also be placed in
this folder.

Custom Menus

GoDB Has a standard Built in menu. This menu can be brought up by pressing the F1 key or or by clicking at the bottom right corner.

This menu can be changed by loading a custom menu using the strong>LoadMenu Command.

You can use Hierarchal Menus in GoDB.

To Specify a menu you need to form strings that represent each menu item as
MenuID,ParentID,MenuText.

For example a standard Menu would be.

St$=""
St$=St$+"10,0,Test1,"
St$=St$+"11,0,Test2,"
St$=St$+"12,0,Test3,"
St$=St$+"13,0,Test4,"
St$=St$+"14,0,Test5"
LoadMenu(St$)
END

The above code fragment creates the following single level menu

To Display the menu all Show Menu

Sub HelloBtn_Click
ShowMenu()
print GetMenuID()
End
Sub

Two Level Menu.

St$=""

St$=St$+"10,0,Test1,"

St$=St$+"11,0,Test2\x1E,"

St$=St$+"12,0,Test3,"

St$=St$+"13,0,Test4,"

St$=St$+"14,0,Test5,"

St$=St$+"15,11,Test21,"

St$=St$+"16,11,Test22,"

St$=St$+"17,11,Test23,"

St$=St$+"18,11,Test24,"

St$=St$+"19,11,Test25"

LoadMenu(St$)

END

The above code fragment creates a two level menu the first levels have MenuIDs 10-14 and second level menu have MenuIDs 15-19 and you can notice that the second level menu's parent id is 11. This is the Parent MenuID. The \x1E is the character icon for right arrow.

When the user selects the second item, the menu will move the current item to the top and show the second level menu.

Three Level Menu.

St$=""
St$=St$+"10,0,Test1,"
St$=St$+"11,0,Test2\x1E,"
St$=St$+"12,0,Test3,"
St$=St$+"13,0,Test4,"
St$=St$+"14,0,Test5,"
St$=St$+"15,11,Test21,"
St$=St$+"16,11,Test22,"
St$=St$+"17,11,Test23\x1E,"
St$=St$+"18,11,Test24,"
St$=St$+"19,11,Test25,"
St$=St$+"20,17,Test231,"
St$=St$+"21,17,Test232,"
St$=St$+"22,17,Test233,"
St$=St$+"23,17,Test234,"
St$=St$+"24,17,Test235"
LoadMenu(St$)
END

You can press Left or Backspace to go up one level. The Menu Colors can be changed using style files Refer to Lesson 9 for more details.

For applications that need to display the menu programmatically you can use ShowMenu function.

Sub HelloBtn_Click

ShowMenu
print GetMenuID()
End Sub

Showmenu command's first parameter determines if the selected item in the menu is restored or if the menu starts from the first level.

Sub HelloBtn_Click
ShowMenu(1) ' Remember Menu Settings
print GetMenuID()
End Sub

Showmenu command's second and third parameter determines position of the menu.

Sub HelloBtn_Click
ShowMenu(0,10,10) ' Show the menu in the top left corner.
print GetMenuID()
End
Sub

The Important thing to note is that, When a custom menu is loaded the
Standard hotkeys like F1,F7,F9 are disabled.

You can show the menuwhen F1 Key is pressed by handling the OnKeyPressed event.

sub Form_keypress

' If F1 Key is pressed set keyhandled to 2
if getkey()=1 then
showmenu()
endif
EndSub

Reading and Writing Files

GoDB VM was also designed to support devices that do no have file systems. GoDB has its own internal filesystem to store and reterive Forms, Script and Image files. This filesystem is part of the BDB file which shows up as a single file in the native OS.

The File API in GoDB can write to both internal files (into the BDB file - the GoDB File system) or external files (Native OS files).

Files can be opened with the FOpen(Filename,Location,Type) API where the location parameter determines if the file is internal or external.

The Type parameter determines if the file is opened for Reading(1), Writing(2) or Appending(3)

Reading From Files

'/*********************************************/

'/* Read The strings in the file and print */

'/*********************************************/

h1=fopen("test1.txt",0,1)
print "File Handle ",h1
print "Size ",fsize(h1)
while feof(h1)=0
print FREAD$(h1)
wend
ret=fclose(h1)

You can Read from the file using FREAD$ function. This function reads the upto 1024 chars each time.

'/*********************************************/

'/* Read The strings in the file and print */

'/*********************************************/

h1=fopen("test1.txt",0,1)
print "File Handle ",h1
print "Size ",fsize(h1)
while feof(h1)=0
print FREADLN$(h1)
wend
ret=fclose(h1)

To Read Lines you can use the FREADLN$ function.

Writing to Files

h1=fopen("test1.txt",0,2)
b=FWRITE(h1,"test1")
ret=fclose(h1)

You can write to the file using FWrite. This Function writes the contents of a string to a file.

'/*****************************************/

'/* Open and append some text to the file */

'/*****************************************/

h1=fopen("test1.txt",0,3)
a=100
a$="Test"
FPRINT h1,"test1",a,a$
ret=fclose(h1)

You can write to the file using FPrint. This commands writes a line to the file.
This command is similar to print and write to the file instead of to the screen.

Binary Files.

GoDB supports reading from and writing to binary files using the FREADBIN$ and FWRITEBIN functions.

Binary files can have Null chars that GoDB strings can infer as termination characters.

To Avoid this the FreadBin$ escapes the NULL characters in the File with a /00 and a / is escaped as /2f.

'/*********************************************/

'/* Read The strings in the file and print */

'/*********************************************/

h1=fopen("test1.txt",0,1)

while feof(h1)=0
print FREADBIN$(h1)
wend
ret=fclose(h1)

While writing the same rules of escaping applies.

h1=fopen("test1.txt",0,3)
b=FWRITEBIN(h1,"test/00Hello/2Fthere")
ret=fclose(h1)

In some cases where native multimedia apis expect pure binary data, you can use
LoadBlobFile and SaveBlobFile functions.

ret = LoadBlobFile("abc.wav",0,a$)
LoadRet = LoadBlobFile("abc.wav",0,a$)
saveRet = SaveBlobFile("abc.wav",0,a$,LoadRet)

These functions return the number of bytes that was read and should be stored because the String Len Function cannot be used with the strings
returned by these functions

Copying Files

GoDB supports copying of files into and out of the BDB using the FCOPY function

FCOPY(SrcFile,SrcLoc,DestFile,DestLoc).

To copy a file within the bdb use

FCOPY("test1.txt",0,"test2.txt",0)

To copy a file from within the bdb to the external file system use

FCOPY("test1.txt",0,"test2.txt",1)

To copy a file from the external file system to the bdb use

FCOPY("test2.txt",1,"test3.txt",0)

You can also copy files in the external file system using

FCOPY("test2.txt",1,"test3.txt",1)

Authentication - Config.ini and Config.frm

GoDB was designed primarily for business applications that communicate with GoDB Sync server to source data for local tables, download the Frm,Bas and Bin files etc.

For authentication purpose user has to log into the client application and use these credentials during sync process with GoDB Sync server. Information like the UserID,Password, Sync server IP address are held in CONFIG.INI configuration file.

To set the configuration the Config.frm is used. To load the config form you can press F9 in the simulator platforms. On the device the configuration form can be
loaded using the
"?A" URL.<link Name="Link1" Url="?A" Value="Config">

OR From GBasic

LoadURL("?A")

When this form is saved GoDB automatically stores the values in the form to the config.ini.

The Config.ini has the following format.

?A?UID=g&PWD=&USRID=0&IP=127.0.0.1&Port=80&BP=GoDBSS&UP=&

PI=192.168.0.123&HN=&LOG=

When GoDB starts Logon.frm is loaded from the BDB if present. If not then the default logon page is displayed. The UserID and the Password entered by the user in the logon screen are compared with the ones in the Config.ini. If they match then the user is authenticated and automatically taken to Home.FRM.

The Gateway IP is the ip address of the GoDB Sync server.

Skipping the Logon Page

In some cases you might want to skip the logon page this can be done by AUTHSUCCESS command.

In logon.bas You can add

AUTHSUCCESS
LOADURL("!home.frm")
END

Or you can add custom authentication / Startup screen in the Logon.FRM. When the user clicks on the button you can take the user to the home.frm.

Sub Button1_Click

if CustomAuth()=1 then
AUTHSUCCESS
LOADURL("!home.frm")
Endif
EndSub

Function CustomAuth
CustomAuth=1
End Function

Lesson 5: Advanced Forms Programming

noreply@blogger.com (Author) — Mon, 28 Nov 2005 08:27:00 +0000

Enumerating the Field Names

To reterive the column names and Column count in a recordset, you can use B_RSFLDCOUNT, DB_RSFLDNAME and DB_RSFLDVAL Functions.

DB_RSFETCH(A,"select * from test",1)
n=DB_RSFLDCOUNT(A)
print " Fld Count ",n
for i=0 to n-1
print " Fld Names ";i;DB_RSFLDNAME$(A,i)
next

while DB_RSISEOF(A)=0

for i=0 to n-1
print DB_RSFLDVAL$(A,i);
next
DB_RSMOVENEXT(A)
wend
DB_RSCLOSE(A)

Advanced Forms Programming.

Form Fields

To ease programming, the fields in a page that have GBasic Script show up as Field Objects. Hence changing the value of the fields in a page can directly the field value. For example if a page contains a text field named USERID then in your gbasic script you can directly set the field value like this.

#USERID$ =
"test"

Notethat form fields are proceeded by a '#'. A $ should be preceded to assign string variables to Form Fields

Example:

#USERID$ =
"Hello"

To assign Numeric variables the $ sign should be omitted

Example:

#USERID=100

NOTE: For all field variables use a # in front of the field name. To update the contents of the text field.

Dynamic Form Controls

GoDB Forms are rendered by the Microbrowser at runtime by parsing the XML Form tags. All controls that are dropped in to a GoDB Form exist as simple XML tags. For Example a text control has the following XML Tag.

<TEXT NAME='UID' VALUE='g' />

As the forms are rendered at run time, you can create controls at run time by just printing the XML Form tags using the print statement.

Sub Button1_Click
print "<text name='test1' value='g'>"
print "<text name='test2' value='g'>"
print "<text name='test3' value='g'>"End Sub
From GoDB 3.6 you can also use CreateObject Command to create objects.
CreateObject(ObjectType,ObjectName,Attrs)

Ex:CreateObject("Text","text1"," Value= 'g' ")

Form Field Arrays

Fields with same names can be accessed as Field Arrays using the '[' Operator.

Ex.:

Print #RAD1[0].checked
Print #RAD1[1].checked
Print #RAD1[2].checked

Events in Field Arrays

When Events are fired in the handler use Curfld$() to get the Field name that generated the Event.
EX: CurFld$ will return the Name of the Control with the index.
For the first control it will be Button1
For the second control it will be Button1[1]
For the third control it will be Button1[2]

Dereferencing Fields Objects

In some cases you might need to refer to a Field variable whose name is determined at runtime in such cases you can use the Field Variable Dereferencing operator {

Ex:

' Variable Name in a string literal
print #{"NAME"} $
' Variable Name in a string variable
b$="NAME"
'As Numeric
print #{b$}
'As String
print #{b$}$
#{b$}$="Hello"
'Accessing Field Properties
print #{b$}.x'Assigning Field Properties
#{b$}.y=100

'Assigning Array Field
b$="VAR[0]"
#{b$}.y=100

b$="Grid1" 'Calling Object Methods
#{b$}.Addrow("Data1,Data2,Data3,Data4,Data5")
' Getting the value of clicked field
b$=CURFLD$()
print #{b$}$

Passing Parameters between Forms

In Some Cases you might want to pass parameters between forms. You can use global variables to achieve this. If
the number of variables is small the you can pass variables in the page URL.

Ex:

LOADURL("!page1.txt&a=10&b=100")
<linkurl="!page1.txt&a=10&b=100">

In the preceding page the variables can be retereived using the REQUEST$ Function

' page1.basPRINT REQUEST$("a")
PRINT REQUEST$("b")

Lesson 4 -- Database Programming using GoDB

noreply@blogger.com (Author) — Mon, 28 Nov 2005 07:06:00 +0000

This is applicable only to GoDB Enterprise Edition.

Importing Data From External Database (MS Access) into your GoDB application Grid and LookupTables(LUTs)

GoDB has an embedded ANSI SQL RDBMS. You can create ,modify and query tables using standard SQL statements.

In this chapter lets see how we can import a MS Access MDB file into a GoDB application.

Select Tools->DataAccess -> Import From MSAccess.

This will prompt for the location of the MDB File.

For the sample we have used an MDB file called gsales.mdb located in GoDB Install Directory\palm\access.

Enter the Full path C:\Program Files\GoDB\palm\access\gsales.mdb.

This will import all the tables in the MDB file into GoDB. In GODB the RDBMS tables are stored in a .BDB.DB file. If you named your project gTest then the forms and basic scripts are stored
in gTest.bdb and the RDBMS tables are stored in gTest.bdb.db file. In Platforms that do not
support external files like palm the gTest.bdb.db file is created inside gTest.pdb file along with gTest.bdb.

To View the tables that were imported you can use the GoDB Query Manager.

Select Tools->DataAccess ->Query Manager.

Here enter a sample query select * from City and select Run.

This should show the query results.

Warning: If you select Build -> Clean in GStudio, the Database tables will also be deleted
(the .bdb.db file is deleted). So you will have to import the tables again.

Now that we have the tables lets see how we can use them.

Embedded Grid

In GStudio open home.frm add a embedded grid control.

Embedded grid can be used to display tabular data. The columns are defined in the ColNames attribute and to addrows you can use the AddRow Method.

In home.bas add the following code.

Ex:

#egrid1.ColNames$="Col1,Col2,Col3,Col4"
#egrid1.addRow("r11,r12,r13,r14")
#egrid1.addRow("r21,r22,r23,r24")
#egrid1.addRow("r31,r32,r33,r34")
END

Compile and run.

Sourcing Data for grid from a query. In Home.bas remove the previous code fragment and add

#egrid1.sql$="select * from city"
end

Compile and Run

You can see that the results of the query are now displayed in the grid. Alternatively you can also enter the query in the SQL Attribute in the Property list window.

Full Screen Grid

Full screen grids are used to display query results and occupy the entire screen.
For this insert a Full Screen Grid Control. Change the Value attribute to Results and the SQL attribute to "Select * from emp"

Compile and Run

Click on the control

You can change the SQL attribute from GBasic for different reports.

#grid1.sql$="select * from city"
Full Screen grids can also be displayed from gBasic using the DB_ShowGridcommand

Sub Button1_Click

DB_ShowGrid("select * from emp","Hello There","50,50,100")

End Sub

Lookup Tables (LUTs)

This is one of the most useful and powerful Data controls in GoDB. LUTs are usually used for selecting items in master tables. LUTs require three primary attributes, the TableName, IDField which will be the field that will uniquely identify a row in the table, ShowField The field that will be displayed to the user for filtering and selection.

Into the Home.frm add a LUT Control. Change the Value Attribute to Select Emp

Change the TableName Attribute to Emp

Change the IDField Attribute to EmpID

Change the ShowField Attribute to EmpName

Compile and Run the Project

Click on the Control

Type A

you can see that only the records starting with A are displayed. This is a very powerful feature when you are searching through few thousand records and you want to narrow down data as you type the first few characters.

To Select the row you can double click on the row or select the row and hit ok.

When you print the value for the LUT control from gbasic you will get the IDField Value.

Sub Button1_Click

print #lut1$

End Sub

Lut Data Binding

Lut Field has the capability to populate other controls with the current record value. For example if we might want to display the EmpID and AutoFld columns in the table.

For this add two Readonly controls to the form. Change the First Readonly control's
LutBind Attribute to Lut1 Change the First Readonly control's LutSrcField Attribute to empID

Change the Second Readonly control's LutBind Attribute to Lut1. Change the Second Readonly control's LutSrcField Attribute to AutoFld

Compile and Run the Project

Select the employee Balaji. This will automatically populate the two Readonly controls.

Lut from GBasic

LUTs can be displayed from GBasic using DB_SHOWLUT

Sub Button1_Click
ret=DB_SHOWLUT("select EmpID,EmpName from emp where EmpName like '?%'")
if ret=1 then
print lutselected$()
print lutselname$()
endif
End Sub

DB_SHOWLUT takes a SQL query as a parameter, this query should return two columns the first the IDField and the Second the ShowField. When the Lut is displayedand the ? is the SQL is replaced with the text the user enters. So if the user enters A the sql that would executed will be select EmpID,EmpName from emp where EmpName like 'A%'

DB_SHOWLUT Function returns 1 if the user selected a valid value.

LutSelected$() returns the Selected IDField.

LutSelName$() returns the Selected ShowField.

Database and Forms Programming.

GoDB Database

GoDB has a built in RDBMS that lets you use standard SQL commands to create tables, query data etc.

GBasic Supports two types of Database commands.

DB_EXEC

This command is used for data manipulation . Please note that this command does not return RecordSets. This command can be used for Creating tables, inserting, deleting and updating records etc.

EX:

db_exec("create table test(id int,name varchar(20))",0)

db_exec("insert into test values (1,'test1')",0)

db_exec("insert into test values (2,'test2')",0)

db_exec("insert into test values (3,'test3')",0)

db_exec("insert into test values (4,'test4')",0)

DB_RowsMod function can be used to determine the number of rows a DB_Exec statement affected.

db_exec "update vtable set qty= 100 where price > 10",0

print db_rowsmod()

DB_RSFETCH

This command is used for Data Querying. This command returns a recordset that can be used to get the value for individual columns. This command is used with the SQL Select query statement.

DB_RSFETCH(A,"select * from test",1)

while DB_RSISEOF(A)=0
print @A.id,@A.name$
DB_RSMOVENEXT(A)
wend

DB_RSCLOSE(A)

You will notice the A as the first parameter in the DB_RSFETCH command. This is will be used as the RecordSet Identifier.

GoDB Supports up to 10 con-currently open RECORDSETs named A - J.

Data in the Recordset can be Retrieved in two ways.

Direct Addressing

DB_RSFETCH(A,"select * from test",1)

while DB_RSISEOF(A)=0
print @A.id,@A.name$
DB_RSMOVENEXT(A)
wend
DB_RSCLOSE(A)

InDirect Addressing.

DB_RSFETCH(A,"select * from test",1)
while DB_RSISEOF(A)=0
print @A("id"),@A$("name")
DB_RSMOVENEXT(A)
wend
DB_RSCLOSE(A)

This format helps you use a string expression for the field name.

F1$="ID"
F2$="Name"
print @A(F1$),@A$(F2$)

Lesson 3: Form Controls & Events

noreply@blogger.com (Author) — Fri, 25 Nov 2005 14:36:00 +0000

Multiplatform Form Builder and Event Handlers

GStudio comes with a powerful Form builder that lets you design Forms visually. Forms in GoDB are text files with XML tags that correspond to different controls that GoDB Supports. When you add a text box to the Form a XML tag corresponding to a text box is created.

Ex:

GoDB Supports the following Controls.

A quick summary of the widgets

Standard Controls

	Label	Used to Display Labels.
	Text	Edit Box for capturing Data From the user.
	Password	Edit Box for capturing Password From the user.
	Radio	Radio Button. Controls with the same name are grouped.
	Check	Check Box.
	Button	Standard Button
	Image
	Frame box	Used to group controls.
	Link	Used to Navigate between pages. URL property determines the new page.
	Read Only	Readonly box for displaying results etc.
	Popup Box	Popup to display help and alert Messages.
	Script	To Associate a different Bas File to the form.

UI Enhancement Controls

	Divider	To Display a Divider between controls
	Poly Line	Special control to display polygons.
	Title Text	To set the title for the form.

Enterprise Controls

	MultiLine	Edit Box for capturing Multiline Data From the user.
	List Box	DropDown List box.

Data Related and Special Controls

	Look Up Table (LUT)	Used to Display a Popup to select master items like Products,Customers etc.
	Embedded Grid	Grid that can be embedded in a form.
	Calculator Box	Popup calculator Control for entering numeric data and calculations.
	Date	Popup Datebox Control to select date.
	Sign Box	Popup Sign box control to capture Signature.
	Grid	Full screen grid to display reports etc.

Form Submit Controls

	Hidden	Hidden box for holding temporary values.
	Submit Button	To Submit the values of a form to an internet site or to another page.
	Cancel Button	To Clear the values entered in a form.

Building Forms

This section will demonstrate the process of creating a form, dropping controls and creating event handlers.

Step 1) Create a New project

Step 2) Open Home.txt and select the "Welcome to GoDB" button and delete it.

Step 3) Drop three label controls and Change their values to Enter Number 1 , Enter Number 2 and Result.

Step 4) Drop a Button Control, Drop three text controls and empty the value attributes for the text controls.

Step 5) Right click on the Calc Button -> Script Wizard -> On Click.

Alternatively for Click events you can just double Click on the control.

This should open up home.bas with a empty event handler.

Sub Button1_Click

' Add Handler Code Here

End Sub

Add the following Code to the event handler

Sub Button1_Click
#text3=#text1+#text2
End Sub

Compile and run the application. Enter data in the text boxes and hit the button. The third editbox should show the sum of the numbers entered in the first two edit boxes.

Certain issues remain with this app. First the edit boxes allow characters.

Second the content in the result edit box can be modified. A common way to handle this is to make the edit boxes accept only numeric values and the result box readonly. Here is how this can be done.

Select the text box and locate the validate property , click on the ... button and select the Numeric Check Box and hit ok. Repeat this for the second text box too.

Select the third text box and make Disabled attribute to Yes. Alternatively you can also use a Readonly box for the result.

Multiplatform Forms

The form builder in GoDB can be used to create Forms that have different layout in different platforms. The Master Form is common for all the platforms. To adjust the layout for a different platform just select the appropriate platform tab.

The blue guide line indicates the screen boundaries for the platform.

Here we can see that the form has to be redesigned for palm.

Simply reposition or change the attributes of the controls to suit your platform screen size.

You can see that we have changed the X and Y positions in the Palm Form. This is indicated by the BOLD font in the attribute names.

If you want to remove any attribute you have to do it in the Master page.

When the project is compiled based on the platform selected for compilation the attributes from the appropriate Form will be used.

During the design process sometimes you might want to apply the value of a specific attribute to all the platforms.This can be done by selecting the attribute in the Property list window and clicking on the A button.

If you want to apply all the attributes in a specific control in a platform to all the platforms you can select the control and Right click > Apply to all platforms.

You can also restore the default settings for a control by selecting the control and Right click ->Revert all to default.

You can remove unwanted platforms by right clicking on the platform tab and selecting Remove Platform.

You can add a new platform you can right clicking on the platform tab and selecting Add Platform.

In the popup just select the platforms you want to add or remove and hit OK.

Debugging

GStudio has a powerful built in debugger with break points, watch points etc. Lets see how a program can be debugged using GStudio.

Copy the following code and paste it in home.bas

i=10
j=20
end

Sub Button1_Click
dim lvar
lvar=10
#text3=#text1+#text2
print i
print lvar
End Sub

You can set a Breakpoint by clicking on the left margin or pressing F9 key.

Now Compile the project and click on Start Debug.

This will launch the simulator in debug mode. When you login you should be able to see the Program Trace, That is the Blue markers in the Left Margin.

Now Click on the Button in the simulator.

This should stop the execution at the break point.

You can see the variables and fields in the Watch Window.

When the Execution is suspended by a break point you can use the debug aids to Control the execution.

Click on to "Step Into" a Call Statement

Click on to "Step Over" a Call Statement

Click on to "Step out" of a Subroutine

Click on to execute till the current cursor position

Click on to Continue Execution from the current break point

Click on to Stop the Debug session

Click on to Restart the Debug Session

To reset a breakpoint simply click on the red dot using your mouse or press F9 key.

Form Events

The above examples demonstrated Events that Fields generate, similarly the forms also generate events that are common to all the controls like Mouse Celik etc.

To Generate Form Event Handlers Right click on the form when no controls are selected.

Form_Load Event is called when the form is loaded.

Form_Keypress Event is called the user presses any key.
GetKey() Function can be used to identify the key pressed. KeyHandled method determines if the events are bubbled to the next control or not.

Sub Form_KeyPress
' Add Handler
Code Here
' keycode = GetKey()
' KeyHandled(1)
End Sub

Form_MouseClick , Form_MouseUP and Form_MouseMove

Events are generated for mouse events. GetX() and GetY() functions return the X,Y location of the mouse.
MouseHandled method determines if the events are bubbled to the next control or not.

For Example of a user clicked on a button
Form_MouseClick is called first and if mouse is handled in this event handler you can choose not to process the Button_Click Event.

Sub Form_MouseClick
' Add Handler Code Here
' x
= GetMouseX(0)
' y = GetMouseY(0)
' MouseHandled(1)
End
Sub

Form_Paint Event is called when the Microbrowser is painted. All the drawing routines like DrawLine FillRect etc should be coded here.

Starting with GoDB 3.6 Form_RMouseClick and Form_RMouseUp have been added to handle right mouse clicks on plaforms that support it.

Form Navigation

GoDB uses a microbrowser for rendering forms.

Add a new form to the project. Right click on project explorer and select Add Form.

In the open dialog enter the name Main.
Select Yes when prompted for creating a file.

Double click on the Main.Frm in the project explorer add a few controls to the form and save.

Now open Home.FRM and add a Link Control . Change the value attribute for this control to Load Main. Change the URL attribute to !main.frm.

In godb all references to local files should start with a !.

Note: When Changing primary properties use the Master page. Use the platform pages only for properties that differ from the Master. This is to avoid errors where you might change a property in PalmOS page and compile a Pocket PC project and wonder why the property change does not work.

Alternatively you can just dragdrop a file from the project explorer on to the form and this will create a link control.

Compile and run the project

Conditional Statements

noreply@blogger.com (Author) — Thu, 24 Nov 2005 12:41:00 +0000

GoDB Supports Block IF and Single line IFF statements.

ifConditionthen
Statements
Statements
else
Statements
Statements
endifEx:

if a >120 then
print "a is greater than 120"
else
print "a is less than or equal to 120"
endif
print "Program Continuing"

iff condition then Statement1:Statements2
The : operator can be used for separating statements in a single line.

Ex:

iff a > 120 then print "a is greater than 120": goto
!ProceedNext
print "a is less than or equal to 120"!ProceedNext
print "Program Continuing"

Note: GoDB Labels start with a !.

Loops

GoDB supports two types of Loops the For next and While Wend.Loops can be aborted by a Break Statement.The control can be transfered to the loop
begining using a Continue statement.

For Variable = Start to End [Step Increment]
iff condition then Break
iff condition then continue
Next

Ex:

for i =1 to 100
print i
next
for i =1 to 100 step 10
iff i > 50 then break
print i
next

While Condition

While Conditioniff condition then break iff condition then continue
Wend

Ex:

i=0
While i < i="i+1" i="0"> 5 then break
i=i+1
wend

Subroutines and Functions

GoDB allows creating modular applications using subroutines and functions. Subroutines are blocks of code that do not return values. Functions are blocks of code that return values.
Subroutines are defined as.
SUB SubroutineName(Parameters)

iff condition then return
EndSub

To call a subroutine you have to use the CALL statement.

Ex:
Call test1
End
sub Test1
print "Inside Test "
endsub

Ex Sub with parameters:

Call test1(1,"test")
End
sub Test1(a,b$)
print "Inside Test with numeric and string parameter";a;b$
endsub

Note: You should not jump out of a sub using a strong>goto statement.
Use Return statement if you want to exit a subroutine. In GoDB when strings are passed to a sub or function,they are passed by reference . String literals , String expressions , Numeric variables and Numeric Expressions are passed by value.All arrays variables are passed by reference.

c$="test"
d=100
Call test1(d,c$)
print "after Test1 ";d;c$
End
sub Test1(a,b$)
print "Inside Test1 ";a;b$
b$="Welcome to GoDB "
a=120
endsub ' Passing Array dim
a(10)a(0)=10call test2(a)print "After ";a(0)

Endsub Test2(b)print "Before" ;
b(0)b(0)=20
endsub

Recursion

GoDB supports recursion only in Subroutines and not in functions.

Call recsub(1)
End
sub recsub(a)
iff a >10 then return
print a
call recsub(a+1)
endsub

Functions

Functions are defined as

Function FunctionName(Parameters)
iff condition then return
FunctionName = ReturnValue
Endfunction
Functions are called by using them in an expression.
Ex:

t=TestFunc()
print t
End

function TestFunc
print "inside
TestFunc"
TestFunc=10
endfunction

Ex: With parameters

print TestFunc(1,"test")
End

function TestFunc(a,b$)
print "inside TestFunc ";a;b$
TestFunc=a+100
endfunction

Ex: String Functions

print TestFunc$(1,"test")
End

function TestFunc$(a,b$)
print "inside TestFunc ";a;b$
TestFunc$ = b$ +" added in func "
endfunction

Ex: String Functions Passed ByRef

c$="test"
print TestFunc$(1,c$)
print c$
End

function TestFunc$(a,b$)
print "inside TestFunc ";a;b$
TestFunc$ = b$ +" added in func "
b$="Modified in TestFunc"
endfunction

Note: Recursion is not supported in functions.

Dimensioning and Arrays

GoDB Supports creation of Numeric or string arrays using the DIM
statement.DIMI - Integer VariablesDIMF - Floating
Point VariablesDIMS - String Variables
Numeric Array
Ex:

DimI a(100)
for i=0 to 99
a(i)=i
next
for i=0 to 99
print a(i)
next

Note: GoDB arrays are 0 based so when you declare an array of 100 elements the elements start from 0-99.

Multidimensional Numeric Array

Ex:

DimI a(100,10)

GoDB Supports up to Four Dimensions for Numeric Arrays. Only single dimensional String arrays are supported.DimS can be used to define Strings and
String Arrays.
Ex:DimS a$ ' Single String
DimS b$(10) ' Array of 10
Strings.DimS b$(10,5) ' 2-D Array Strings.

One interesting thing about GoDB strings is that they can be accessed as an array of chars. You can also use the Mid$ function to get substrings.

a$="testing 123 "
for i=0 to len(a$)-1
print a$(i)
next

GoDB Strings are internally stored as Null terminated character strings. You need to consider this while setting characters at different positions. This will work

a$="123"
a$(0)="A"
print a$

This will not work because there is a null char at a(3) so the print statement will print only till a(3)

a$="123"
a$(4)="A"
print a$

This will work.

a$="123"
a$(3)="A"
a$(4)="\x00"
print a$
Dim can be used to define String
with explicit sizes.

Ex: String of size 10000

Dim a$(10000)
a$="testing 123 "
print a$

Ex: Array of 10 Strings with 100 chars

Dim a$(10,100)
for i=0 to 9
a$(i)="Hello there " + i
next
for i=0 to 9
print a$(i)
next

Array of strings can also be used like a two dimensional array of characters.

print a$(0,0)

Will print the first character in the first string.Multi dimensional strings (upto 3D) can be declared using the Dim Ex: 2D Array of 10x10 Strings with 100 charsDim a$(10,10,100). You Can use Redim to resize numeric arrays and StrExpand to resize Strings.

Advanced Subroutines and Labels

GoDB supports jumping using the GoTo Statements.
iff a=1 then goto !Cond1
iff a=2 then goto !Cond2
goto !ENDPROG

!Cond1
print "Cond1"
goto !ENDPROG

!Cond2
print "Cond2"
!ENDPROG

To allow jumping based on a variable GoDB supports Label Dereferencing. Using Label Dereferencing the label can be decided based on a string variable and a
Dereferencing {operator.

j$="Cond"+a
goto !{j$}
goto !ENDPROG

!Cond1
print "Cond1"
goto !ENDPROG

!Cond2
print "Cond2"
!ENDPROG

Similarly you can use Dereferencing operator to call Subroutines too.

for i=1 to 3
a$="Test"+icall
{a$}nextENDSub Test1print
"Test1"EndSubSub Test2print
"Test2"EndSubSub Test3print
"Test3"EndSub

Note: Dereferencing supports string variables only and not string expressions.Ex: call {s$+1} is not legal.

Variable Scope

noreply@blogger.com (Author) — Thu, 24 Nov 2005 11:07:00 +0000

The variables have three types of scopes

GLOBAL
LOCAL
PAGE

Any variable that starts with ~ is a global variable and is accessible from any function, subroutine and from any bas file in the project.
All variables declared outside the subroutines and functions becomes a page-scope variable. This type of variable is accessible in any function and subroutine within the same bas file. Variables created in a function or a sub have a LOCAL scope. They can be accessed only within the function.

Example

Home.Bas

Gnum1=10 'Page Variable - this variable can be accessed only in home.bas file.
~glob=20 'Global Variable - this variable can be accessed in all the .bas files.

sub test1

Lnum1=30 'local variable accessible in test1 sub only
print Gnum1 'gNum1 has PAGE scope, so it can be accessed in test1
print Lnum1
endsub

sub test2

print Gnum1 'OK
print ~glob 'OK
print Lnum1 'ERROR : LNum1 local variable accessible in test1 sub only
endsub

Home2.Bas

sub test3
print ~glob 'OK - if home.bas was loaded first and ~glob was initialized.
print Gnum1 'ERROR : Gnum1 is accessible only in home.bas
print Lnum1 'ERROR : LNum1 local variable accessible in test1 sub in home.bas only
endsub

GoDB Lite Reviewed on All About Symbian

noreply@blogger.com (Author) — Thu, 24 Nov 2005 08:29:00 +0000

Below the review of GoDB Lite Edition. You will now surely understand why I stand by GoDB.

Source: www.allaboutsymbian.com

Published by Steve Litchfield at 15:57 GMT, October 14th 2005 under Applications in Series 60, N-Gage

Steve Litchfield reviews Go-DB Lite, a new development system for Symbian Series 60

Version Reviewed: 3.6

Score: 75

So you've thought about writing a little program for your Series 60 smartphone?

At the one end of the programming spectrum you have the wizards at Zingmagic, EMCC, Synergenix and so on, all working in Symbian-optimised C++. To become productive in C++ for Symbian OS takes a long time, a really long time. We're talking about man months. And at the end of this time if you've not got an IQ of at least 150 then the chances are all you'll have done is give yourself a headache. It's OK if someone's employing you to learn, but the chances are you're having to learn in your spare time, in which case you won't have much of a social life for a while.

Somewhere near the other end of the spectrum is your favourite and mine, OPL, the BASIC like language created by Psion and which has worked well on everything from Psion palmtops to Nokia and Sony Ericsson smartphones. There are keywords for menus and dialogs and a clutch of handy file and graphics routines, but you're largely on your own and can create anything you like. To produce a decent application in OPL, from scratch (with no prior knowledge), you're looking at a week of work, even if you'll be avoiding the headaches of C++. (For more on learning OPL, see Ewan's book). In addition, OPL doesn't currently run on any of the Symbian OS 8 devices, and that's most of the really cool ones.

Go-DB Lite is designed to sit even closer to the 'easy' end of the programming spectrum, letting you produce Series 60 applications quickly and efficiently, although with a few rather important caveats. It's unashamedly a form-based tool, making it superb for typical business 'calculator' or 'data collector' style applications and a pain in the neck for anything graphical or involving real time operations, for which you have to hand craft BASIC-like statements in the code editor windows. If you can define your application idea in terms of a number of separate 'screens' (forms), with text and numbers to be filled in and with other screens and windows appearing depending on what you entered, then you're on your way with Go-DB Lite.

Go-DB (without the Lite) is a lot more expensive and designed to handle 'enterprise' applications, run on any portable device with a Go-DB runtime for Palm, Pocket PC, Series 60, etc. Go-DB Lite is a new venture, with ConsignTech recognising that many hobbyist Series 60 users would find it rather fun to write their own programs. One example of the slightly changed focus of Go-DB here is the inclusion in the excellent Help screens of a section called 'Game functions', which include routines to display images and play sounds. These game functions are very much tacked on to main product, which remains focussed on string variables and forms, but they do work. To prove the point, here are a bouncing ball and TicTacToe in SIS format (try them), both examples supplied with Go-DB Lite. The integration of graphics and sound with the main development system is a little arcane and disappointing: having dragged an image onto a Go-DB form, it's shown only as a black rectangle of the wrong size (though GIF files can be 'rendered' if you dig deep into 'Options'). You then have to manually resize it and generally 'imagine' what it should look like.

Working on a simple application that uses forms and popup boxes is a lot more straightforward, I knocked up this VAT calculator in (literally) 10 minutes. And, unlike the current version of OPL, it runs on any Series 60 phone. Pretty cool if your intended application falls in this genre. Every application is forced to have a 'login' screen (where things like user tracking and activation happen), another result of Go-DB's enterprise heritage, although you can bypass this and move straight to your main form with a single command.

GStudio, the Go-DB IDE (Integrated Development Environment), is pretty comprehensive once you take into account the caveats mentioned above. A browser on the left shows project files (forms and BASIC code modules) and images, with each coming up in its own window in the main space, where it can be tiled, hidden or maximised. A properties pane is usually present on the right hand side and individual properties are easy to change, with alterations shown immediately in the appropriate form windows. An array of tools for designing forms is dominated by form controls (list boxes, etc). Finally, an output window at the bottom of the IDE shows warnings and any success messages, plus any debug information if you've asked for this.

GStudio has been pre-programmed with the right product IDs for most recent Symbian Series 60 devices and the IDE can build SIS files for a particular device if needed. For most purposes though, it's easy enough to specify a 'Generic Series 60 device', which will run on anything from a Nokia 7610 upwards. Your application gets packaged with the 320K Go-DB runtime, making even a trivial utility appear to be the best part of half a Megabyte. When run, the RAM useage is similar.

Quite apart from the omissions in the image-handling department, there are other signs that Go-DB Lite isn't a mature product yet. The main 'Build' menu has options for 'Compile', 'Build', 'Rebuild all', 'Clean', 'Run', and so on. I appreciate that there are probably distinctions between these at the code level, but all a new user wants to see is a single option: 'Build'. Or, better, 'Build and run'. Similarly for the multitude of device build options ('Nokia 6260, Nokia 6600, etc.), when the vast majority of people will simply want to build for a class of device (e.g. Symbian OS 7 or 8), so that their application runs on as many devices as possible without having to make lots of different versions. A 'Check for new updates' option on the main Help menu seems like a good idea but, when run, offers a page of 'more recent' modules - these are largely irrelevant to Go-DB Lite and they're all also around a year old, at which time Go-DB Lite hadn't even been created.

If all this seems over critical, then I make no apologies. If Go-DB wasn't any good then I'd just slam it and move on, but it's actually got potential and I'd rather the developers saw enough interest in the product that they put work into improving it. I'm going to persevere with Go-DB because (in the absence of a OPL runtime for modern devices) it's about the only way for users to program their smartphone without having to spend months learning Symbian dialects of Java or C++.

So, with a view to using Go-DB Lite in earnest, I set up trying to convert my Hangman game (previously written in OPL). First, a couple of screenshots, so that you can see that I did get there in the end:

Most of the core formulae could be used as-is, with GBasic only differing from OPL (or any other BASIC) by a few characters here and there. Even the graphics handling turned out to be similar to OPL. Having to store images on forms, retrieve them to a hidden string buffer and then draw them onto a form as needed, isn't so different from retrieving image files into graphics ids in OPL and then copying them into an on-screen window. The biggest difference was the form-based, object-oriented approach, which means that you have to think in terms of specific forms that paint themselves according to the BASIC code you've specified. Keypresses while a form is shown are handled within a Form_Keypress subroutine, and so on. Once you get used to this, most applications could be adapted fairly easily, although I suspect that real-time arcade games would be somewhat harder.

The main showstoppers I found were to do with the lack of maturity mentioned above. For example, I was trying to use a sprite array (for the Hangman 'hung' images), but a bug in the Go-DB system meant that sprites weren't always shown correctly. I also started getting an 'Internal error, please contact support', which is never a good sign in an application. The building to SIS format is also lacking in sophistication - there's currently no way to automatically include your own version number or include your own certification '.key' file, so that the SIS file is signed as being 'from' you. (In practice, you could build your own SIS using the standard Symbian MAKESIS utility, but this should really be handled by the IDE that you've paid good money for.) Finally, you can only write a single font on screen at present. For most applications this simply isn't good enough.

Back on the positive side, there are some pretty powerful Symbian smartphone-specific system functions, though you have to dig pretty deep into the Help screens to spot how to use them. You can send and receive SMS messages, check GPRS/Bluetooth/battery status, make and receive voice calls and even play back video files directly, which is very cool for such a RAD tool.

Although the purchase price of $200 is enough to put casual users off, there's a trial version, meaning that you've got no excuse for downloading and at least having a play. For the company looking to make a custom 'calculator' or database-driven application for deployment to its employees' smartphone, Go-DB Lite is just the ticket. For the home user with a good idea for an application or game, Go-DB Lite is a viable option, even if you do currently have to work rather harder than you ought to.

With more development and 'polishing' (and I'm sure this will happen in the very near future), Go-DB could become a genuinely mainstream system. Watch this space for an updated review in a month or so, once ConsignTech have released another version or two...

Reviews & News on GoDB

noreply@blogger.com (Author) — Thu, 24 Nov 2005 07:21:00 +0000

Mobile app dev tool adds Windows Mobile 5.0

Source: www.windowsfordevices.com
Oct. 10, 2005

Consign Technology (Consigntech) has added support for Windows Mobile 5.0 to the latest release of its multi-platform tool for "rapid" development of mobile business applications. Consigntech characterizes GoDB as a "Develop Once, Deploy Anywhere" platform that runs applications on devices ranging from handhelds to desktops.

The GoDB IDE includes a GUI forms builder, scripting engine, and embedded RDBMS database with an ANSI SQL-92 engine, according to Consigntech. New features in version 3.6 include extending applications with native DLL-based objects, enterprise contols such as grids and lookup tables, and 2D gaming functions.

GoDB IDE screen shot
(Click for larger view)
GoDB applications can be designed to run offline, online, or in a "hybrid" mode, according to Consigntech. Offline appications cache their data on the client until a secure connection is available for synchronizing with the server. Online apps assume "always on" connectivity for real-time information exchange. Hybrid apps rely on "master data tables" stored on the device, which are periodically synchronized with the server. The user executes real-time transactions using the local tables.

Consigntech will shortly release a "Lite" edition of GoDB without the embedded database. The company says the Lite version will target non-enterprise developers looking to develop applications such as utilities and 2D games.

The GoDB Enterprise IDE retails for $499. Educational and non-commercial applcations can be deployed free. Commercial deployments require seperately purchased VM licenses. A 30-day free trial download is available here after registration.

GoDB Enterprise Edition -- Data Sheet

noreply@blogger.com (Author) — Thu, 24 Nov 2005 07:07:00 +0000

Develop Once, Deploy Anywhere

GoDB is a Multi-Platform Application Development tool for developing handheld and wireless applications. GoDB lets you develop applications you code once and deploy them to multiple platforms like Windows Mobile (Pocket PC, Smart phone, Win CE), Palm OS, Symbian, Linux, Windows, etc. without any change.

GoDB SDK comes with an IDE that lets you create, modify, build, run, simulate, debug and deploy your applications to multiple platforms from familiar Microsoft Windows.

IDE has the following components:

Form Builder.

Simulators for devices/PCs.

Integrated source level debugger.

Single click CAB / SIS / Setup package creation

System requirements:

Operating System: Windows 98 and above

Recommended Hardware:

256 MB RAM (minimum 128 MB)

667 Mhz processor, X86 architecture

1024 x 768 pixel screen or better

16-bit color or more

Features & Description:

Portability:

Application once developed using GoDB is portable across multiple platforms like Windows Mobile (Pocket PC, Smart phones, Win CE), Symbian, Palm, Linux, Embedded Linux and Windows.

Security:

Built in support for security at various level like on Device, data transfer and server side. GoDB by defaults provides support for AES encryption; other third party encryption can also be supported.

External Component:

Other platform requires separate licenses to be purchased for Embedded databases (SQL CE, Oracle Lite). In case of GoDB, the Run time client has the embedded database (ANSI SQL Compatible).

Form Factor:

GoDB has a browser based Interface, hence creating complicated scrolling forms is easy, in case of large forms the scroll buttons appears automatically. Fields for lookups auto populating transaction fields etc can be inserted into the form without the need for even a single line of code.

Focus Target

Unlike other platforms, which are for general-purpose application development, GoDB focus mainly on business application so the UI widgets required for biz apps are already a part of GoDB. Moreover, GoDB is optimized for database operations like lookups, filters, reports etc making GoDB apps much faster than other comparable platforms. This means that most of the business application components need not be coded from scratch.

Online - Offline:

GoDB applications can transition between online and offline seamlessly and can also operate in hybrid modes where transactions can be online with offline masters.

Compression:

GoDB comes with in-built compression technology, which compresses data up to 70% there by reducing the sync times between the device and the application.

Database Compatibility:

In Non-GoDB application, the Embedded RDBMS requires the server version of the same RDBMS (for eg Oracle lite requires Oracle on the server side). In case of GoDB it is compatible with SQL Server and Oracle.

Multi Lingual Support:

GoDB has a Language abstraction layer built in. Due to this GoDB can support multiple languages with one screen. GoDB can also support languages, which are not natively supported by the Hardware.

Power Management:

Built in support for software power management. This enhances the battery life of the PDA while running the business application.

GBasic Variables and Objects

noreply@blogger.com (Author) — Thu, 24 Nov 2005 06:44:00 +0000

GBasic has two types of variables, numeric and string variables.

String variables and functions that return strings always terminate with a $.

Ex: A$,B$, Mid$(a$,1,2) etc

Variables without a $ at the end are considered to be numeric variables.

GBasic has two types of objects , Form Field Objects (Controls on a form) and Database Field objects.

Form field objects precede with a #

Ex: #UID , #UID$ etc.

Database field objects precede with a @

EX: @a.ID, @a.Name$

GBasic Operators

Operators For Numeric variables

+ ADD
- SUB
* MULT
/ Division
\ Integer Division
% MOD
^ Integer Exponent

GBasic supports the following Comparison Operators.

> Greater than
< Less Than
= Equal
<> Not Equal

GBasic supports the following Logical Operators.

AND OR

Operators For String Variables

+ Append
EX:

B$="Test1"
A$=" Hello " +B$

Note: When appending a large number of strings use Concat Function instead of the + operator.

You can also append numeric literals, variables and expressions to strings.

' Numeric Literal

A$=" Hello " + 100.25

'Numeric Variable

c=100
A$=" Hello " + b$ + c

'Numeric Expressions appended to strings

c=100
d=200
A$=" Hello " + b$ + (c+d*20)
A$= (c*10+23) + " Hello There "
A$ = "Ubound of array is " + ubound(st$)
A$ = "Len of String is " + len("Hello")
A$ = "Len of String is " + len("Hello") +20 +" Done "
A$ = "Len of String is " + ( len("Hello") +20 ) +" Done "

GBasic supports the following String Comparison Operators.

= Equal
<> Not Equal

EX:

if a$=b$ then
print "a is equal to b"
endif

String Escaping

Special chars like " etc are escaped with a back slash '\' in a string Literal.

Ex
a$="Hello there \"124\" "
a$="Hello there \n"
a$="C:\\Temp\\a.txt"

Special Chars

\n - New Line
\r - Carriage Return
\t - Tab
\" - Double Quote
\' - Single Quote
\\ - Backslash

Other chars can be specified by specifying the HEX value prefixed \x

EX:
a$="Hello there \x0D \x0A "

Special Numeric Statements

You can use C Style Increment ,Decrement and Cumulative Numeric
statements

Increment ++
Decrement --
Cumulative Numeric , +=
, -= , *=
etc
Ex:
a++
b--
a+=10
a-=20

Etc: Note these commands cannot be used in expressions.
Ex: a = b+(c++) is not allowed.

Numeric Literals in other bases Hexadecimal and Binary.

GBasic Supports Hex Literals of the format &hAABBCC and binary Literals &b1010

Ex:
' Hex Literal
a=&hEF10D
'
Binary Literal
b=&b10101
'String Append with Hex Literal
a$="Test "
+ &hEF10 + "*" + &b10101

' Convert Decimal to Hex
print
Format$("%x",1000)

GBasic Introduction & Program Structure

noreply@blogger.com (Author) — Thu, 24 Nov 2005 05:21:00 +0000

GBasic is a variant of the Basic Language included in GoDB platform as the scripting language.It’s a simple and easy to language for the average and new entrant developer to program for mobile devices without the need for knowledge of the mobile platform concerned and high end language

Program Structure

GBasic programs are usually associated with a form and have the same name as that of the form.

For example

Home.Frm will have an associated BAS file in the project called home.bas.
When Home.Frm is loaded, GBasic scripting engine loads home.bas and executes all statements, till the END statement is not encountered.

Home.bas

a=10
b=20
print a,b
END
sub Button1_click
msgbox "Button clicked"
endsub

The program can also have subroutines that are event handlers for controls in the form, like a mouse click event on a control.

Event Handlers have names that are of the format ControlName_EventName

Ex: Button0_Click