Release Notes – v0.x-v1.83

SIMPOL Professional v1.83 — Release Notes

CONGRATULATIONS on acquiring the latest SIMPOL Professional product. This product is the result of years of design and development together with in-house testing and use. In spite of that, no product is perfect, so we look forward to hearing from our customers with suggestions for improvements, and should a bug crop up, about those too. There is a large amount of documentation and example code provided with the product. Please make sure to look through the projects provided, most are well commented and can demonstrate various approaches to using SIMPOL. There are six handbooks so to get started quickly, it may be useful to read the first chapter of the IDE Tutorial, Chapter 2 in the Programmer’s Guide, and Chapter 3 of the Quick Start Guide, preferably in that order. At that point, the text in Chapter 3 of the Quick Start Guide will suggest various ways forward.

IMPORTANT!

To get access to the updated releases you will need to register on-line at our web site and then register your copy of the product. We will then make the downloads available to you.

Start Here

  1. Click on Windows Start / All Programs
  2. Find the folder marked: SIMPOL Professional
  3. Click on this and the following will pop out:
    • Samples (9 major sections with over 100 sample programs)
    • Utilities (12 utilities, including code and database converters)
    • Release Notes (this document)
    • Register Online
    • SIMPOL IDE (the new workplace & toolkit for the developer)
    • SIMPOL IDE Documentation
    • SIMPOL IDE Tutorial (the guide to your first SIMPOL program)
    • SIMPOL Language Reference
    • SIMPOL Personal (the program for creating items interactively)
    • SIMPOL Personal User Guide
    • SIMPOL Programming Guide
    • SIMPOL Quick Start Guide

Contents

V1.83 Release-Specific Notes
V1.8 Release-Specific Notes
V1.74 Release-Specific Notes
V1.73 Release-Specific Notes
V1.7 Release-Specific Notes
V1.61 Release-Specific Notes
V1.6 Release-Specific Notes
V1.5 Release-Specific Notes
V1.4 Release-Specific Notes
V1.3 Release-Specific Notes
V1.2 Release-Specific Notes
V1.1 Release-Specific Notes
V1.0 Release-Specific Notes
Pre-Release 4f-Specific Notes
Pre-Release 4e-Specific Notes
Pre-Release 4d-Specific Notes
Pre-Release 4c-Specific Notes
Pre-Release 4b-Specific Notes
Pre-Release 4a-Specific Notes
Pre-Release 4-Specific Notes
Pre-Release 3c-Specific Notes
Pre-Release 3b-Specific Notes
Pre-Release 3a-Specific Notes
Pre-Release 3-Specific Notes
What’s New
SIMPOL Professional Pre-Release 2 — Release
Notes
Included Files
SIMPOL Documentation in HTML Help format
SIMPOL Language Execution and Components
SIMPOL wxWidgets Components
SIMPOL IDE Components
IDE Color-coding Support
IDE Help Assistant Files
Runtime Files for the ANSI Editor
Runtime Files for the Unicode Editor
Runtime Files for Linux
The Rest
Library Code
CGI-Specific Issues
CGI Debugging
Constants
Gotchas
Using the IDE
Command Line Arguments
Debugging
Program Comments
Conclusion

Included Files

The distribution contains the following files:

releasenotes.html This file

SIMPOL Documentation in HTML Help format (docs…)

tutorial.chm The IDE Tutorial Book
ideref.chm The IDE Reference
personal.chm The SIMPOL Personal User Guide
progbook.chm The SIMPOL Programmer’s Guide
langref.chm The SIMPOL Language Reference
quickstart.chm The SIMPOL Quick Start Guide

SIMPOL Language Execution and Components (bin…)

ICONV.DLL The iconv library from the GNU project — used by the XML DOM Component.
LIBXML2.DLL The libxml2 library from the Apache project — used by the XML DOM Component.
LIBXSLT.DLL The libxslt library from the Apache project — used by the XML DOM Component.
ZLIB1.DLL The zlib1 library was written by Jean-loup Gailly (compression) and Mark Adler (decompression) — see
www.zlib.net for more information. This is used by the libxml2 library and is therefore included here. Used by the XML DOM Component.
FCGD1_32.EXE The debug Fast-CGI wrapper for use in web servers such as Apache, allowing SIMPOL programs to work as high-performance web applications (not for distribution, development use only).
serverclose.exe The program that is called to close the simpolserver.exe multi-user server program
simpolpersonal.exe The SIMPOL Personal program for creating and modifying databases, forms, printable forms, and reports
simpolserver.exe The SIMPOL database multi-user server program
simpolserverclient.exe The client program for controlling the SIMPOL database multi-user server program
SBSORT32.DLL The Win32 sort order support library (can be also used with the 32-bit ODBC driver).
SIMPOL.SMP The compiler (this is a compiled SIMPOL program — not for distribution).
SMCGI32.DLL The CGI support library used by SIMPOL when called from SMPCGI32.EXE.
SMPCGI32.EXE The CGI wrapper for use in web servers such as Apache, allowing SIMPOL programs to work as web applications.
SMDBG32.DLL The SIMPOL debug support library (not for distribution, development use only).
SMEXEC32.DLL This allows the calling of SIMPOL functions from compiled SIMPOL libraries as DLL calls for Win32.
SMFCGI32.EXE The Fast-CGI wrapper for use in web servers such as Apache, allowing SIMPOL programs to work as high-performance web applications.
SMGD1_32.EXE The CGI debug wrapper for use in web servers (not for distribution, development use only).
SMISAP32.DLL ISAPI support for Win32 (allows using SIMPOL programs with IIS as ISAPI web applications).
SMLXML32.DLL The SIMPOL LXML libxml2 Component used by the XML Document Object Model library.
SMODBC32.DLL The SIMPOL ODBC Client Component, which provides access to ODBC data sources for Win32.
SMPCGI32.EXE The CGI wrapper for use in Web servers (see below for details).
SMPD1_32.EXE The SIMPOL debug runtime loader (not for distribution, development use only).
SMPRUN32.EXE The SIMPOL runtime loader for command line programs.
SMPOL32.DLL The SIMPOL library for Win32 (core language).
SMPPCS32.DLL The SIMPOL PPCS support library for Win32 (multi-user database client).
SMPPSR32.DLL The SIMPOL PPSR support library for Win32 (multi-user database server).
SMSBME32.DLL The Superbase Micro Engine Database SBME component library for Win32.
SMSLIB32.DLL The SIMPOL Shared Library SLIB Component library for Win32 (allows SIMPOL language programs to call external DLL functions).
SMSOCK32.DLL The SIMPOL SOCK TCP/IP sockets component library for Win32, providing multi-threaded client and server functionality.
SMSYM32.DLL A SIMPOL debug support library (not for distribution, development use only).
SMUTOS32.DLL The SIMPOL UTOS Operating System Utilities component library for Win32 (provides file and directory support).
SMPW1_32.EXE The SIMPOL debug runtime loader for GUI programs.
SMPWIN32.EXE The SIMPOL runtime loader for GUI programs.
SMWXWN32.DLL The SIMPOL wxWidgets support library for Win32.
svcrunnr.exe The SIMPOL script service program for running the simpolserver.exe as a service

SIMPOL wxWidgets Components (bin…)

wxbase28u_vc_simpol.dll This contains the base wxWidgets support and is required when using the WXWN component.
wxmsw28u_core_vc_simpol.dll This contains the core GUI components for wxWidgets and is required when using the WXWN component.
wxmsw28u_adv_vc_simpol.dll This is used by advanced GUI components, such as the wxGrid control. It is not currently required or used.

SIMPOL IDE Components (bin…)

SBNGIDE.EXE The SIMPOL IDE for Win32 for Ansi
SBNGIDE.EXE The SIMPOL Unicode IDE for Win32 (will only install to Windows NT, 2000, XP, Vista, etc.). Only one editor installs, if the Unicode editor can be installed, then it will be selected over the Ansi editor.
SBNGIDEARA.DLL Arabic language support library for the IDE (not 100% translated yet).
SBNGIDECHS.DLL Chinese Simplified language support library for the IDE (not translated yet).
SBNGIDECHT.DLL Chinese Traditional language support library for the IDE (not translated yet).
SBNGIDEDEU.DLL German language support library for the IDE (not 100% translated yet).
SBNGIDEELL.DLL Greek language support library for the IDE (not 100% translated yet).
SBNGIDEENU.DLL English language support library for the IDE.
SBNGIDEESP.DLL Spanish language support library for the IDE (not 100% translated yet).
SBNGIDEFRA.DLL French language support library for the IDE (first French version released with 1.7!).
SBNGIDEITA.DLL Italian language support library for the IDE (not 100% translated yet).
SBNGIDEJPN.DLL Japanese language support library for the IDE (not translated yet).
SBNGIDENLG.DLL Dutch language support library for the IDE (not translated yet).
SBNGIDEPTG.DLL Portuguese language support library for the IDE (not translated yet).
SBNGIDERUS.DLL Russian language support library for the IDE (not translated yet).
SBNGIDESVE.DLL Swedish language support library for the IDE (not translated yet).
SBCODE32.DLL IDE support library.
SBNGIDECALLER.EXE Callback program for interactive web site debugging (NT, 2000, XP, Vista, etc. only).

If you know of a language that you think we should support (or are prepared
to help localize one of the above that is not yet done, then let us know!

IDE Color-coding Support (bin…)

The following are the INI files that are used to color code the various
languages supported by the IDE.

C#.INI C#
DevStudio.INI C, C++
EditBinary.INI For the editing of binary files
HTML.INI HTML, SMZ (SIMPOL Server Pages)
IDL.INI IDL (Interface Description Language)
JScript.INI JavaScript
ReadBinary.INI For the viewing of binary files
SIMPOL.INI SIMPOL
Superbase.INI SBP programs, tokenized and ASCII
TEXT.INI Basic text files
VB.INI Visual Basic
VBSCRIPT.INI Visual Basic Script
XML.INI XML, XSL

IDE Help Assistant Files (bin…)

simpol_odbc.api ODBC Component — ODBC Client Database Access
simpol_ppcs.api PPCS Component — PPCS-Based Database Client Access
simpol_ppsr.api PPSR Component — PPCS Type 1 Database Server for SBME
simpol_sbme.api SBME Component — Superbase Micro Engine (Single-user)
simpol_slib.api SLIB Component — Shared library access (DLLs)
simpol_sock.api SOCK Component —  TCP/IP Socket Client and Server support
simpol_utos.api UTOS Component — File System, Directories, Files
simpol_wxwn.api WXWN Component — wxWidgets-based Windows, Forms, Form Controls, Dialogs, …

Runtime Files for the ANSI Editor

OE70AS.DLL
VC6-RE200L.DLL
OT80AS.DLL
RWUXThemeS.dll
SF20AS.DLL
SYSTEM32MSVCP60.DLL
SYSTEM32MFC42.DLL
SYSTEM32MFC42LOC.DLL
SYSTEM32MSVCRT.DLL
SYSTEM32MSFLXGRD.OCX

Runtime Files for the Unicode Editor

OE70ASU.DLL
VC6-RE200L.DLL
OT80ASU.DLL
RWUXThemeSU.dll
SF20ASU.DLL
SYSTEM32MSVCP60.DLL
SYSTEM32MFC42U.DLL
SYSTEM32MFC42LOC.DLL
SYSTEM32MSVCRT.DLL
SYSTEM32MSFLXGRD.OCX

Runtime Files for Linux (linux…)

libsbcode.so Utility library used by SIMPOL.
libsbsort01.so Sort library used by various SIMPOL database library components.
libsmdbg.so Debugging library used by the debug versions of the runtime programs.
libsmpol.so SIMPOL main language library.
libsmpolcgi.so SIMPOL CGI library used by the smpcgi program for running web applications.
libsmpollxml.so SIMPOL XML library used by the SIMPOL DOM support library.
libsmpolppcs.so SIMPOL PPCS library for client database access using PPCS type 1.
libsmpolsbme.so SIMPOL SBME database library for single user database access to the new database engine.
libsmpolsock.so SIMPOL SOCK library that provides TCP/IP client and server sockets support.
libsmpolutos.so SIMPOL UTOS file system utilities (directory and directoryentry objects).
libsmpolwxwn.so SIMPOL WXWN GUI components. Requires wxWidgets 2.8.x to be installed on the distribution.
smfcgi SIMPOL Fast-CGI program launcher.
smfd1_ SIMPOL Fast-CGI program launcher with debugging information for handling errors that cause a program to halt.
smprun SIMPOL program launcher.
smpd1_ SIMPOL program launcher with debugging information for handling errors that cause a program to halt.
smpcgi SIMPOL CGI program launcher.
smpd1_ SIMPOL CGI program launcher with debugging information for handling errors that cause a program to halt.

The Linux files will eventually be placed in a Linux installer but for now we haven’t done so. The lib files should all be placed somewhere like /usr/lib or /usr/local/lib. The program launchers: smprun, smpcgi, smpd1_, and smgd1_ should be placed in /usr/bin or /usr/local/bin. They also need to be marked as executable (chmod a+x).

The Rest

The remainder should be self-evident. We haven’t listed the include files, library files, samples, or projects, since this has gradually become so much that it would take far too much effort to maintain in multiple places. For details see the SIMPOL Quick Start Guide.

SIMPOL Professional v1.83 Specific Notes

In this maintenance release of SIMPOL Professional there are a number of new features, changes, and bug fixes.

Changes to SIMPOL Professional v1.83

A new company was formed as part of the Papatuo Holdings group of companies, called Superbase Software Limited to manage both SIMPOL and Superbase. This is the first release of SIMPOL Professional to be done under the management of Superbase Software Limited. In this release in addition to the normal additions and changes to the code, there were also copyright notice changes throughout.

The changes have been divided up by where they took place this time. There were no changes to the SIMPOL C-language binaries except for copyright notices and one change to the PPSR component, to allow the transmission of the display format information even for string fields, to allow programs to determine desired field lengths and formatting information.

Library Changes

  • The appframework.sml library was updated to support changes in the duplicaterecord() functionality that was added to dataform1, trecordview, and ttableview. There were significant updates to showtableview(), showrecordview(), formview() and doformview() having to do with filters, among others. We added the property showtablepathincaption to the appwindow type so it can optionally show the current table and path in the window caption. We added an option to appwindow.addtable() and appwindow.opendatatable() to allow the suppression of the creation of a view object when the table is added. The alt_tb property was added to store an alternate tool bar for supporting the filter toggle button (the image cannot be modified in the existing tool bar so the most efficient solution is to swap tool bars). Significant enhancement was done of the appwindow.setcurrenttable() method. We added a bunch of support functions for things like positioning the index combo, filling the index list into the combo, finding a form control in the tool bar, etc.
  • In conflib.sml, we added a fix to writeprivateprofilestring() function where, if the file was empty, nothing would get written to it.
  • We made numerous changes to the databaseforms.sml. We fixed a bug in dataform1record.save() where an unnecessary operator was causing the code to branch incorrectly and added better support to dataform1 when a selectkey() is called with a filter active. We added the ability to better manage access to the properties of the type to remove a race condition that was occurring between onlostfocus and the dataform1.checkdirtyrecords() method (this made it difficult to change only one value in a form and then save it). We added the duplicaterecord() method to dataform1. This change means that the onnewrecord event handler will be called after the record is created and after the current record has been copied to it. This allows such an event handler to detect the record is not empty and only update fields that need changing. We added support for user-defined onselect event handlers to also be called when a dataform1.setmasterrecord() is called, since this is similar to a dataform1.selectkey() call. We added better handling for when dataform1.selectcurrent() is called if an unsaved new record is the current record (it now retrieves lastusedrecord). We added additional error checking to the dataform1.discardrecord() method. A bug was fixed that occurred when using dataform1bitmap objects in the detail block. We also made numerous enhancements that deal with the positioning of rows and columns in a detail block and fixed the tab order through a detail block so that, if tabacross has been selected, it will go across columns if there is more than one before going down the rows. This also applies to how the block is filled with data.
  • The db1util.sml library was enhanced with the db1fieldinfo type for use when retrieving information about database fields. This together with the new function getnewfieldinfoarray() is used to retrieve easier-to-use and extend information about fields in place of the older getfieldinfoarray() function, which is retained for compatibility reasons. We also added the analyzerecorddata() function, which returns an array of field names and values so that at runtime a record can be analysed in debug mode.
  • In dbconverter.sml we added support for Unicode to the CSV import and export converters, including UTF-8, UTF-16 LE and BE, with and without a byte order mark (BOM) and also fixed a problem in the PPCS and SBME import converters where if the default internal exposed unique field was present it was also being read and added to the table definition.
  • In the displayformat.sml, we added a special optimization to handle the case where the original format string passed to the integer and number format dialog is empty. This will now be modified to “9.” to fix the problem.
  • We created the tablesearch() function in the drilldown.sml library. This function provides an equivalent to the REQUEST 20 that was available in Superbase BASIC Language. It allows for easy pick lists to be produced for user selection.
  • In the graphicreportlib.sml the graphicreport1 type received the showprinterdialog option which defaults to .true but which can be set to .false to ensure that the printer selection dialog is not displayed when sending a graphic report to the printer. We also fixed a property name bug that occurred during the running of a report and removed the unsupported property backgroundrgb when adding a printform1bitmap control to a report. A default alignment value was added to the bitmap object when loading a report and we fixed a bug in the code that loads a bitmap control in a report.
  • The httpclientlib.sml was enhanced with support for sending in HTTP 1.1 format. As part of that, we added the xtraheaderfields property which is an array that can hold additional lines of header fields and which will be inserted into the HTTP 1.1 header. It does not add any special support for receiving in HTTP 1.1 format.
  • The labelslib.sml received minor improvements.
  • In printformlib.sml a new exported function called updatewxdialogdata() was added, which is used to make adjustments to an existing dialogdata string but can also work if the string is empty. The function supports changing both the page orientation and paper size. The pagesetupinfo type was given a new method called FindPaperType() which can find the numeric index for the paper type based on either the name or the dimensions and if using the dimensions will also indicate whether the paper should be in landscape mode.
  • In quickreportlib.sml we updated the storage format to version 0.2 and added the storage of the display format as part of the column info. The report loading was fixed to not create a title, date, and page number setting if they were not present in the stored file. We changed the way that data sources are retrieved during the getreport() method and added a counter so that the column index is passed when retrieving column info. We modified the xmlsqr1columninfo.get() method to support both version 0.1 and 0.2 when loading a report and switched to using the getnewfieldinfoarray() function from the older getfieldinfoarray() in db1util.sml to provide a more useful and extensible method of retrieving field info. The quickreport1columninfo type now has a displayformat property so that the display format can be assigned separately. There are new pagesetupinfo and showprinterdialog properties as well as three new methods: removedatasource(), removetable(), and setfont(), for the quickreport1 type. The quickreport1.new() method has a new optional pagesetupinfo property. The code that created the special versions of the core font is now in the setfont() method so that it can create the special versions while assigning the new font to ensure the font is consistent in every area when a new one is assigned. Minor adjustments were made to the positioning of the underline below the column header text at the start of each page. The output was fixed to properly change paper size and orientation when the printout is created if the target is window or printer.
  • The recordview.sml library had a lastusedrecord property and a duplicaterecord() method added to the trecordview type. Various optimizations and improvements were made to better cope with selecting a record that does not fall within the currently displayed filter, including making changes and saving those changes as well as deleting the record. We also enhanced the trecordview.setinitialrecord() method to have an additional refresh parameter that defaults to .false to preserve current behaviour. This fixed a problem when deleting records using the delete group functionality in SIMPOL Personal where the updated record in record view was not being refreshed.
  • In repguilib.sml (Quick Report UI), we added transparency that was missing for some of the images used in the GUI and fixed some controls that were using fixed rather than named colors. We added an additional Display Format button for the column information panel and necessary code to support it throughout. We created a new qrwfieldinfo type and added fieldinfo array and localeinfo properties to the quickreportwindow type. We modified the default rowheightadjustment from 1.4 to 1.3 and added the current path as a new parameter to the __quickreport() function so the it can maintain continuity with the calling application. We added a feature to display the path to the current report, if it has been saved, in the window caption.
  • In reportlib.sml, we added the ability to use the report to delete the matching rows from the report. We also added an event: ondeleterow, and a setdelete() method for turning it on or off. The uparrowoutputrow() function is now exported so that it can be used for error reporting farther downstream.
  • In smtpclient.sml, we added a 50ms delay after creating the socket before trying to receive the incoming message from the SMTP server.
  • The sql1.sml library saw minor adjustments to comparisons to avoid .nul being a valid value. We also added the sqlq1.setcolumndisplayformat() method to allow a display format to be set for a calculated column, as well as allowing it to override the default for a column.
  • The stringlib.sml saw the addition of the findfileencoding() exported function to provide downstream programs with the ability to open and determine if a file is in ANSI or Unicode and if in Unicode, which encoding method it might be using.
  • In STR.sml, we fixed a special case in STR() that occurred when the value on the right of the decimal point was being rounded such that the value on the left of the decimal point would need to increase by 1. Previously it would be truncated to 0 on the right, but not add 1 to the left. An appropriate test case was added to the unit test in STRTest.smp.
  • In tableview.sml, we added a lastusedrecord property and a duplicaterecord() method to the ttableview type. Selecting a record using the .selectkey() method when a filter is active has been disabled since showing the record out of sequence in the results and coping with potential changes to it would have been visually misleading.
  • In the val.sml library we enhanced the VAL() function so that it is not required to pass the SBLNumSettings object. If it is .nul, it will be created internally using the default values.

SIMPOL Business

  • The data source opening code was improved and we added the autolocking=.false to all the form prep routines.

SIMPOL Personal

  • We added the Remove Group functionality as well as support in the GUI for import and export of Unicode and Unicode encoding types when using CSV.
  • We created a clearuserfilter() function and removed that functionality from the douserfilter() function, so that the clearuserfilter() code could be called from elsewhere.
  • We modified the appwindow.setcurrenttable() method so that the filter string is cleared. and also make sure that the record view menu item is checked if setting the table results in a change to the view mode.
  • We added support to fix the internally supplied label definitions by reading the fixlabels ini file entry. If it is present and equals Y, then the label entries are removed and regenerated.
  • A problem was fixed in form view with the check for records that have been modified.
  • The deleterecordall() function was updated to call a new dodeleteallrecords() function so that the functionality can be called from elsewhere.
  • Support was added for passing the current load path to the __quickreport() function.
  • Numerous improvements were made to the Labels GUI code.
  • Improvements were made to the code that manages the state of the menu.

In the Form Designer, we made the following changes:

  • We fixed the opening of a data file to use the most recently used path instead of the current working directory.
  • We added the SIMPOL Label Designer caption text where needed.
  • We added a check to make sure that the setting of the default values for the labels was successful.
  • We fixed a bug when resetting the cursor to its default mode. An occasional problem with the size box not being positioned correctly after resizing certain controls was fixed.
  • The dataform1bitmap and dataform1datagrid were added to the list of dataform1 controls in the isdataform1control() function. This had various side-effects because the controls were failing a test to determine if they were dataform1 controls.
  • We fixed a problem with printform1 when setting a new font.
  • The layout of the graphic properties dialog was improved.
  • A delete button for removing a label from the list of defined label layouts was added to the label definition dialog window.
  • The accelerator key Ctrl+A for the Select All menu option was inserted.
  • We changed the dialog in the Form Designer to automatically select the master table of the form in the table combo, if one exists, instead of selecting None. We also added an internal __getcontrolname() function that is used throughout to retrieve an appropriately named control name if a field is selected and we added transparency to the Form Designer internal images.

In the File Designer, the valid Superbase field name length (for PPCS shares) was increased from 15 to 31 after investigation.

SIMPOL Professional v1.8 Specific Notes

In this maintenance release of SIMPOL Professional there are a number of new features, changes, and bug fixes.

New Features in SIMPOL Professional v1.8

This is the first release of SIMPOL Professional to be done under the ownership of Papatuo Holdings Limited. In this release in addition to the normal additions and changes to the code, there were also copyright notice changes throughout.

  • The following libraries have been added to this release:
    • calclib.sml (source project) – Provides a pop up calculator that can be used for basic calculator functions and which returns the total to the calling function. Contributed by Phil Alexander.
    • drilldown.sml (source project) – Provides the new drilldown() function that provides a dialog with a search box and a grid to allow the user to see what they are looking for as required. It returns a record object of the
      same type (PPCS, SBME, vola1base), as the index object that it searched against.
    • dxflib.sml (source project) – Contains the convertdxf() function for converting one style of DXF file into a bitmap. Also requires the associated drawhelper.dll file.
    • ieeelib.sml – Provides functions that convert to and from 4 and 8 byte IEEE floating point format.
    • iplib.sml (source project) – Container for functions related to Internet Protocol, which in the initial release is limited to one that parses a string containing an IP address.
    • json.sml – This library contains functions that convert to and from JSON (JavaScript Object Notation) format. These functions allow for easier interaction with web services, as well as making it easier to provide your own.
    • labelslib.sml – This is the new mailing labels module, which provides the labelmaker1 type that is used to load and run label definitions that may have been created with SIMPOL Personal.
    • parsenum.sml (source project) – Contains functionality for converting a number into words (commonly used in check writing programs). Contributed by Jim Locker.
    • propertybrowser.sml – Provides an interactive property browser for examining objects at run time. Useful for debugging hard to understand problems that may be data-dependant.
    • repguilib.sml – This is the front-end for the quick report, which exports the __quickreport() function as a single point of contact to open the end-user dialog used by SIMPOL Personal.
    • simpollib.sml (source project) – This library contains a set of core routines used in various parts of SIMPOL. These include things like: hasproperty(), inarray(), findfunction(), and others.
  • A new tutorial program was added, called SIMPOL Business. This program is a large step forwards beyond the sample provided in the Address Book or SB Air samples. It comes with multiple database tables: CUSTOMER, PRODUCT, ORDERMST, ORDERDTL, COUNTRY, SERNO, and implements a basic order taking system with a form for customers, one for products, and one for the orders. The orders form uses a detail block to display the order information and includes buttons for adding, editing, and deleting entries in the detail block. It also has an invoice that is run from a button and which uses a graphic report, and a sales report that is run from a menu item. The source code is fairly heavily documented.
  • Some new test programs were also added, based on the unittest.sml library:
    • datelibtest.smp – Has two tests, the DATESTR() and string2date() tests with an explanation about using the unittest.sml library as comments.
    • string2valtest.smp – Contains the entire test suite, based on the unittest.sml library, for the string2val() function.
    • STRtest.smp – Contains the entire test suite, based on the unittest.sml library, for the STR() function.
  • Additional utility programs were also added to this release:
    • sbm2sma.smp – Saves a SIMPOL database table as a source code program that will re-create the database table empty.
    • sbv2sxp.sbp – Superbase program that converts a print form to a SIMPOL Print Form format in XML.
  • Four new chapters were added to the SIMPOL Quick Start Guide: SIMPOL Business, Server Programs, Web Server Programs, and SIMPOL Server.

Changes in SIMPOL Professional v1.8

C-Language changes in major components

  • Modified smppsr so that the display format for string types can be passed through. This is generally used by programs to decide field lengths, or to apply upper, lower, title case, etc.
  • Fixed a problem in smlxml where a node was deleted before it should have been.
  • Resolved an issue in smsbme in sbme1 where in a selectkey() call, if the value was greater than the highest value in the index, and not found, even if a found parameter was provided it would return .nul and an error 64. Now if there is a found parameter it will return a record unless the table is empty.
  • In smpol we fixed the code page information for code page 850 to reflect the support for the Euro character that was added to Superbase 3.6i and later.
  • Updated from wxWidgets 2.8.8 to 2.8.12
  • Migrated from the GCC 3.x compiler on Linux to the GCC 4.x series.

SIMPOL language component and other changes

  • In the addressbook.smp tutorial program, we added a country code verification routine using the listpicker() function and a string containing the valid country codes separated by spaces. Modified the font size from 9 to 8 used in the combos in the tool bar. Added additional code to avoid errors with the selectkey prompt if the index type changed.
  • The appframework.sml library had the following updates:
    • Added an onopenform event to the appwindow type. This allows changes to be made to the form before it is shown.
    • Added the border parameter to appwindow.new() and application.newwindow() so that it can be passed on to the wxwindow.new() function.
    • Made improvements to the findfirstfocussablecontrol() function.
    • Also added a new property to the appwindow type called firsteditablecontrol to allow the programmer to override the selection of the findfirstfocussablecontrol() algorithm.
    • The newrecord() function will now change pages in form view on a multi-page form to the page of the control that is returned by the findfirstfocussablecontrol() function, if that is not the current page.
    • We repaired a bug where the ._property of the innerwindow property of the appwindow type was not being assigned the appwindow object, as is done with the wxwindow w property.
    • Fixed a resizing issue where the inner window was not being resized together with the outer window.
  • In boolstr.sml, the functions datetimestr() and string2datetime() had support for ISO8601 date/time format added.
  • The bzip2.sml library was updated from version 1.0 to version 1.1 of the packer. It still supports reading of version 1.0, but will only create version 1.1. Numerous fixes were made to deal with a problem that was discovered where in some cases files would pack incorrectly resulting in a failure when restoring. Changed restore so it will not overwrite existing files until it has successfully extracted the replacement.
  • In conflib.sml we fixed a curiosity where when a new section is added at the end of the config file, that the first entry of a section gets moved to the bottom of the group and stays there. This change will not affect existing groups, but will apply to new ones.
  • In databaseforms.sml, the following changes were made:
    • Added the setbitmaps() method to the dataform1bitmap type to allow the setting of the empty and missing bitmaps.
    • Also added a test in the dataform1page.addcontrol() method to ensure that if the control is being bound to a field, that the bound control is of data type string. This does not prevent someone attempting to assign a faulty control source later however.
    • Improved the dataform1 select() methods to blank the form if, when using a filter, no record matches the filter.
    • Modified the assignvaltofield(), dataform1onchange(), dataform1onselectionchange(), and dataform1onscroll() functions to call the onchangerecord event handler if defined;
      previously this was ignored.
    • Added code to test if the parent node still exists when removing a link in the dataform1link.remove() method.
    • Improved the code in the dataform1datagrid.refresh() method.
    • The function renderprintform1page() was creating a new font for each item on a page instead of using the already existing font. This was causing an unreasonable use of system resources and memory.
    • Added the type tag dataform1datagrid to the type dataform1datagrid (type tagged with its own type name), in order to support the already existing use of the type tag elsewhere.
    • Added the SIMPOL CORE Library Source Code License to each source file that was lacking it. Modified the dblocks.sma by removing the hasproperty() function and added the simpollib.sml that contains that function. Also removed the unnecessary lists.sml since that is included in a library that we are already including.
    • Added a dataform1record lastusedrecord property to the dataform1 object and support for it to the record selection functions. This allows the discardrecord() method to cleanly reselect a record.
    • Added a new boolean retaindetailblockpositions parameter to the dataform1.setmasterrecord() method. It defaults to .false. It now allows the setmasterrecord() method to skip the call to the dataform1readdetailrecords() function if requested.
    • Added the dataform1cleardetailrecords() and the cleardetailblockrecords() functions.
    • Split out the functionality from dataform1.blank() into a new blankcontrol() function so that it can be reused elsewhere.
    • Added a blank() method to the dataform1detailblock and all levels of the dataform1detailblock group of types.
    • Added a boolean doreset parameter to detailblockrowenable to permit control over whether or not the scroll bar is reset.
    • The dataform1readdetailrecords() function now positions the grid cursor to 1,1 on a dataform1datagrid.
    • In the dataform1onchange(), dataform1onselectionchange(), and dataform1onscroll() functions we added an important set of grouping parentheses to ensure the correct interpretation of the statement.
    • Fixed a positioning issue with the content of a detail block if the scrolltype is "bottom".
    • Added the updatescrollbar() method to the detailblockregion type.
    • Added the getrdata(), setrdata(), and addrowdata() methods to the dataform1detailblock type. The getrdata() and setrdata() methods act on the row position in the entire stored data set,
      whereas the getrowdata() and setrowdata() act only on rows that are visible on the screen, and the row must be between 1 and the number of visible rows.
    • Made numerous adjustments to dataform1detailblock.removerowdata() so that it correctly removes the record and correctly repositions the detail block and scroll bar position on the screen.
  • In db1util.sml, the following changes were made:
    • This library now depends on the PPCS component as well.
    • Also the getfieldinfoarray() function was enhanced to now return considerably more information about the fields. The return array now contains: fieldinfo[i] = fieldname, fieldinfo[fieldname] =@ fld, fieldinfo[fieldname, n) = (where n=1:displayformat, n=2:help, n=3:comment, n=4:fieldname or sharename, n=5:shareable, n=6:sharetype) and the function now works for sbme, ppcs, and vola1base.
    • Added the dataview.sma source file and the tdataview type for use in record and table view, as well as in import and export modules. This allows the user to rearrange, create subsets and even duplicate columns as a view.
    • Added support for the internal record ID field to getfieldinfoarray().
  • In dbconverter.sml we made changes to accommodate the data views that are now supported by the SBME and PPCS import and export converters. This required minor changes to the CSV, ASCII-Delimited, and XML converters, and fairly important changes to the SBME and PPCS converters. Also fixed a problem with the CSV converter that occurred if the content of the first data column began with the double-quote delimiter. Added comment headers with copyright notices to each source file.
  • The displayformat.sml library was updated to add support for the ISO8601 time format. We also added support for the “.” format string for numbers and fixed problems with the string format dialog. We also fixed some errors in the display format dialogs for numbers and strings. These would result in a recursive call to the event handler which caused an error 21.
  • The following changes were made to filesyslib.sml:
    • Added the functions: notrailingdirsep() and trailingdirsep(), which basically make it easy to assign or not assign a directory separator character to the end of a string.
    • Added the errors.sma and uisyshelphdr.sma as include files.
    • Removed the internal __iswindows_os() function and replaced it with the iswindows_os() function from uisyshelp.sml. Replaced all references to the old version with the new one.
    • Added the getuserhomedir(), getpublicdatadir() and getwindowssysdir() functions.
  • We made the following changes to formlib.sml:
    • Reworked the way data sources and tables are added to the forms.
    • Added support for all the wxformcontrol names in the function that retrieves a new control name.
    • Fixed an error in the code that outputs detail block headers, specifically in the link definition.
    • Made various improvements to the function that converts a wxform to a dataform1 form (usually so it can be saved as a *.sxf file).
    • Fixed a bug in the DTD for simpoldataform1, where the sdf1table was expecting a name element when it shouldn’t have.
    • Deleted the commented out SIMPOLWXFORMDTD from the source file. Removed findfunction(), findproperty(), and inarray() from the source since simpollib.sml is included now in an included library used in the project. In convertwxformtodataform1(), we improved the handling of option buttons.
  • The gaugelib.sml library has been changed to add range checking to the setgaugeposition() methods of both gauge dialog types.
  • In graphicreportlib.sml, the call to eval() in report1_graphicreport_outputrow(), report1_graphicreport_output_pageheader(), and report1_graphicreport_output_pagefooter() were modified to include the report1 object so that the locales can be passed through.
  • In the guisimpolserver.exe the program now incorporates support for the new simpolserver.exe config file format, including passwords, etc. It also still supports the old format. Additionally the included bzip functionality has been repaired to ensure that all database files can be successfully backed up and then restored. Furthermore, files will not be overwritten during restoration until they have been fully restored. IT IS VERY IMPORTANT THAT IF YOU ARE USING THIS PROGRAM THAT YOU UPDATE TO THE NEW RELEASE! We also added a debug capability to the writelogentry() function to ensure that if desired, the log is written to a file. We removed the dependency on the simpolserver.png external image file by adding it as a blob in the source code.
  • The labelslib.sml received the following updates:
    • Added various necessary functions for use in an environment where the label definition will not just be created, but also modified (for the Label Designer).
    • Enhanced the labelmaker1 type with additional components to make it comparable to the dataform1 and printform1 items: (datasources, tables, ppcs).
    • Implemented the labelmaker1.openlabeldef() and labelmaker1.savelabeldef() methods that were previously empty of any functionality.
    • Added support for ignoring printform1 elements that have had their printable property set to .false.
    • Added additional checks to the loading and saving of label definition files. When saving a label definition, it will always save the printform1 template as a file in the same directory with the same file name except for the file extension. Loading of a labels definition will now ignore the path information for the template unless it fails to find the file in the same directory as where it found the label definition.
  • The lists.sml library was updated to enhance the stack type with gettopitem() and getnextitem() methods for evaluating the content of the stack without modifying it. We also added a lock1 property
    to the stackprivate type to handle multi-threaded access to the stack.push() and stack.pop() methods as well as to the queueprivate type to control access during queue.add() and queue.remove() methods. We fixed an error where the unlinking code in the queue.remove() could fail when the count reached 1.
  • In netinfolib.sml we changed the library used on Linux from libglib-2.0.so to libc.so.6 to reduce the number of packages that need to be installed on the target Linux system. Also added the win32_getadapterinfo() function (Windows only currently).
  • Added a feature to the ole2excel.smp sample that also copies the chart to the clipboard and pastes it into the SIMPOL program as an image on the form.
  • In printformlib.sml a suggestion from one of our developers (Jim Locker) resulted in the addition of a usedpi property in the printformparams type. This property defaults to 0, but if it is greater than 0, then it will be used instead of the default DPI value of 96 in the function renderwxform(). The page setup dialog window is now DPI-aware.
  • The quickreportlib.sml was updated in the following ways:
    • The quickreport1 type was significantly enhanced with numerous events, such as: onoutputheader, onoutputfooter, onbeforerow, onafterrow, onbeforegroup, onaftergroup, onoutputreportheader, and onoutputreportfooter.
    • A new boolean property, suppressrowoutput, which defaults to .false was added. When set to .true it can be used to output summarized reports.
    • The quickreportextraoutputinfo exported type was added. It is used by handling one of the new events, listed above, and then this type is created and the new method quickreport1.outputextraline() is called.
    • An additional property, suppressoutputmessages was added for use when outputting the results to the clipboard, to prevent the message that the output is now on the clipboard from being shown.
    • The method setrowheightadjustment() is used to alter the default line spacing, which is set at 220% of the line height in micrometers.
    • Adjusted the positioning of the line below the column titles when output to window or printer. Adjusted the position of the line and column value for aggregates in the group footer. Added a double line to the report footer for columns with aggregates.

    For more information see the expanded entry about the Quick Report in the “Using Reports in SIMPOL” chapter of the Programmer’s Guide.

  • A bug in recordview.sml was fixed that occurred when saving changes to an existing record if a filter was currently applied. We also added support for the tdataview type so that record view can now show a subset of the columns, and/or rearrange them as required. We added special handling for new records if the table is empty.
  • In reorglib.sml fixed a place in reorg_one_table() where the error value was not being returned. Modified the copyallrecords() function so that if the user has cancelled, then it will be acted on inside the loop. Previously it would have continued until all records were copied. Also fixed a problem where the wrong variable was being used in the reorginfo.userupdate() call in copyallrecords().
  • Modified reportlib.sml by adding two boolean properties to report1group: suppressbeforegroupoutput and suppressaftergroupoutput. These are not otherwise used by the report itself, but they are used downstream by wrappers like quickreport1.
  • In the sbair.smp tutorial program, we modified the font size from 9 to 8 used in the combos in the tool bar. We also added additional code to avoid errors with the selectkey prompt if the index type changed. A menu entry was added to demonstrate running a quick report that is loaded from the disk.
  • Improved the OemToAnsi() support used in sbf2sbm.smp, the conversion tool for Superbase database files to SIMPOL.
  • In sbisreport.sma (part of the ssp directory of sample web server programs) the use of the objset object was changed to use the fastset object.
  • In SBLDateLib.sml we fixed a problem in DATESTR() if the date value was 0 (SBME) rather than 10 (0 in PPCS).
  • Various changes were made to SBLTimeLib.sml:
    • Support was added for outputting a time value as a string without any separator characters.
    • Made improvements to the string2time() function for converting string values to time objects.
    • Also switched the code for Linux from libglib-2.0.so to libc.so.6 to reduce the number of packages that need to be installed on the target Linux system.
    • Added support for the hour format "0h", which ensures that the hours are zero-filled if they are single digit in the TIMESTR() function. Also modified the string2time() function to handle the "0h" hours
      format.
  • Fixed a deficiency in sbnglib.sml in the wxformoptiongroupmember.new() method. There was no way to get from the option button to the member. Now the wxformoption._ is assigned a reference to the
    wxformoptiongroupmember.
  • Changes were made to the Sbv2xml.sbp Superbase program in an attempt to cope with older forms that are essentially broken internally and which cause various object model errors when attempting to analyse them using SBL. Not all errors can be worked around, and some forms are just fundamentally broken. These forms are mainly ones built using Superbase version 1.x and which incorporate one or more detail blocks (transaction line areas).
  • In simpolpacker.sml was removed because it was incomplete and duplicates functionality found in bzip2.sml.
  • The simpolserver.exe program has been significantly enhanced. It is now able to run (with the proper loader program) as a service. It can then provide various bits of functionality, such as reorganizing tables, backing up of database files, and restoring them. The companion program for this is the simpolserverclient.exe. The config file format has been changed (the old one is still supported but does not offer as many features as the new format). The new format supports named parameters followed by the = sign and the value, and now allows for specification of access passwords for each table. Added an ability to read the config file from the current directory using the default name (allows the exe to be run with no arguments). Added a loop time out to the dispatch loop to ensure it exits if nothing has been sent within a certain amount of time. Added a PING command so that clients can keep the connection alive avoiding the shut down because of the new loop time out. Enhanced the getexefilename() function with some commented out information about how to implement this on Linux, although it is essentially unnecessary, since we don’t need to deploy a binary on Linux in order to run it as a service. Added entries to the simpolserverinfo.cfg file: archiveroot, bz2libdll, cfgversion, and deflocktimeout. It is no longer necessary to assign a locktimeout value to each table if they wish to inherit the deflocktimeout.
  • New simpolserverclient.exe program with various capabilities meant to match the features and capabilities found in the new simpolserver.exe. Since the server program can run as a service it wouldn’t be able to show a user-interface, so the client program communicates with the server via TCP/IP and presents the necessary user-interface.
  • In stringlib.sml a new function: ismatchingpattern() was added, which does full and partial pattern matches between a string and a pattern. Very flexible,  see the source for documentation.
  • In tableview.sml we fixed an issue with the application of a filter not updating the grid. We also added support for the tdataview type so that table view can now show a subset of the columns, and/or rearrange them as required. We added special handling for new records and for when the table is empty and a record is added by simply clicking on the empty row.
  • In the timer.sml library we moved the started property from the timerprivate to the timer type. It was established that it was necessary to be able to tell externally if the timer had been started or not.
  • In uisyshelp.sml the following changes were made:
    • We changed the library used on Linux from libglib-2.0.so to libc.so.6 to reduce the number of packages that need to be installed on the target Linux system.
    • The functions windows_getactivewindow() and windows_redrawwindow() were added.
    • The new duallist() function was added. It produces a dialog with two list boxes and a set of buttons for moving things from one side to the other, including multiple select, double-click, all, etc. It takes a callback function and a reference for filling lists. All text can be localized. It returns an array of strings from the right-hand list. It also has the ability to define that the left list is constant. This allows duplicates in the right list, since the left list is not reduced when items are added to the right list. This is optional functionality.
    • Added the information string to the duallist.sma() function.
    • Removed the is_windows() and getwindowssysdir() functions and placed them into filesyslib.sml. Made uisyshelp.sml dependent on filesyslib.sml. Removed an unnecessary stringlib.sml dependency in the project. Added the findcomboliststring() function to search a wxformlist or wxformcombo for a given string and if found, to return .true otherwise return .false.
    • In uisyshelphdr.sma we enhanced the constants used for retrieving system directories, as well as documenting them much more thoroughly.
  • In the val.sml library we fixed a problem with VAL() not correctly supporting the Euro symbol or the current NumSettings currency symbol.
  • In the game sample worm.smp, the head and standard segment images have been modified. Additional planning for different types of power ups were added to the source. Switched the game from using a fixed grid size to basing it on the screen size.
  • The xmllib.sml library has a new function called decodeXMLEntities() to convert XML with encoded entities into normal text.

Changes in SIMPOL Personal v1.81

  • SIMPOL Personal now supports Field Lists (data views) in record and table view modes. The data view is also used when copying and pasting to and from the clipboard and is also used for importing and exporting data.
  • A Label Designer mode was added to the SIMPOL Form Designer. It runs with the Print Form Designer tool palette and has additional menu items to support creating labels.
  • The Form Designer now make use of the ini file and will remember the last window size and position.
  • In the Form Designer we fixed the following issues: if a combo box had a static list, then the right side with the value list information would not be displayed. Also, after modifying the content of the static list, it was not updated in the control. When setting a non-system color using the tool bar icons (foreground or background), the usessystemcolors property of the control was not being set to .false. Under certain circumstances, the formisdirty flag was not being cleared when a form was loaded.
  • Added support to SIMPOL Personal for retrying to open a PPCS table if it fails because of a missing or wrong password.
  • Integrated the new labels library and added a GUI for it.
  • Added the ability to initialize the list of label types if that list is empty.
  • Fixed a bug that would result in a failure to correctly refresh an existing table or record view when that table is set as current on an appwindow.
  • In the Print functionality we ensured that when printing and using a sort order that the results are correctly sorted both in ascending and descending order. Also made sure that the final record is printed, since previously it would print all but one record.
  • Repaired issues with the copyrecord() function and implemented the pasterecord() and cutrecord() functions.
  • To reduce flicker, modified the order of the code for applying a filter in table view.
  • Fixed the creation of a field in a table to make sure that the field name assigned as the shareable field meets the requirements for an SBL field name. Also changed behavior so that if a field name is changed then the share name is also changed. Modified the dialog during saving so that everything is disabled and a status message “Working…” is output.
  • Fixed a bug in the table designer where display formats selected from the dialogs were not being stored when the changes to the table definition were saved.
  • Added a feature to disable the important controls on the Quick Report GUI form after clicking on OK, since sometimes there is a delay between the click on the OK button and the appearance of the gauge dialog.

SIMPOL Professional v1.74 Specific Notes

In this minor maintenance release of SIMPOL Professional there are a number of changes
and bug fixes.

Changes in SIMPOL Professional v1.74

  • The functions in db1util.sml have been updated to correctly support the vola1base virtual database system. As a result, vola1base.sml is now included in this library. Also fixed a problem with the recent support for the minus
    sign, that could cause a runtime error if the minus sign were accidentally placed anywhere except the beginning of the string.
  • The recent update that fixed a problem with handling dates introduced a new problem when the year is greater than 12 and less than or equal to 31. The algorithm has been modified so that it makes use of the display format passed in in these cases where the values between separators could fit in either the year or the day. Updated test cases have been added to the regression test.
  • Repaired a problem in the dataform1 type family with bound option buttons and check box controls where if the value to be assigned was the empty string “”, then it would fail in some cases on string fields, because they would be equal to .nul if they had never had a value assigned to them, instead of the empty string. We also fixed several problems related to links not working correctly for printform1 objects. In addition, the setname() method was added to the printform1 type. We fixed a problem in the printform1.new() method where the value of the parameter deftimeformat was not being assigned to the internal property leaving it as .nul, which caused problems further downstream. The print() method of the printform1 type was not adjusting for landscape mode when outputting the print job to the wxprintout, preventing forms in landscape mode from being correctly printed. We also added the printable property to all of the printform1 control and graphic types so that each can be individually disabled during the printing phase and not be rendered in the final result.
  • In formlib.sml, we fixed an error where name instead of printname, and alignment instead of printalignment were used in one place causing a crash when copying and pasting printform1 controls. We also corrected a loading error in the printform1 section, where one of the paths was being provided with a duplicate path separator character at load between the path and the file name.
  • We fixed several problems in the Print Form Designer when attempting to link tables together using the Link Manager. We also added the ability to define the page size directly rather than use an entry from the combo box of paper sizes.
  • In the Quick Report GUI library (repguilib.sml), we fixed a problem where the last defined aggregate value could not be removed (off by 1 error). There was an error of omission in the indexorderpicker() function that had failed to set the dialog as the container for the form. A new property, boolean canceled was added to the __qrfilterinfo type. It was previously not possible to tell the difference between the user clicking on OK with and empty filter, and the user clicking on the Cancel button. Now, if the user cancels, the filter returns .nul instead of the empty string.
  • In the appframework.sml library the createformdirect() method was not listed as a function in the type definition for the appwindow type. This caused run time errors if the appwindow object was not passed as a parameter (which should have happened automatically). We also a fixed a copy/paste error in the checkneedsave() function where the record view and table view support was added. We also added a set of calls to manage menus and tool bars from the checkneedsave() function. An error trap was added to deal with the error iERR_INVALIDDATA that is returned when a user program fails a validation and returns .false when called during an onsave event. We
    fixed the deleterecord() function to work properly when in record or table view. The showtableview() function in the appframework.sml was significantly modified to work more effectively.
  • In SIMPOL Personal (not a separate product), there was a spelling error in the code that handles the Print dialog, which resulted in a crash if the function was called at all. Accomodated the change to the guigetsimplefilter() call in repguilib.sml that returns .nul if canceled, so that the user can cancel at the filter stage of a multi-record print job. Also, in the Form Designer and Print Form Designer modules, we fixed the setting of fonts, font sizes, and
    font styles for print form controls. We also fixed the display of field names and tables to be consistent in bound controls. Corrected the allowed field length from 16 characters to 15 for the shareable name in the Table Designer. There was a minor change to getemptyprompt() to make it consistent with new work in the tutorial samples. We also made improvements to tableview to improve the visual display when it is created.
  • In netinfolib.sml the code was updated to also work on Windows 98. It required a local copy of the windows version type and function, so that we could select the “A” version of the GetUserName() and GetComputerName() functions. For the same reason, we also updated the implementation of the locale type in uisyshelp.sml to prevent it from attempting to read unsupported locale values when running in Windows 9x. This was done because it was the only item preventing the running of the appframework.sml on Windows 98.
  • In printformlib.sml we modified the pagesetupinfo.SetPaperType() method to permit the passing of wxPAPER_NONE and added additional parameters: pagewidth and pageheight for support of non-standard paper sizes. More work is expected in this area. Improvements in the general functioning of the table view have been done. Including visual improvements.
  • The simpolserver and serverclose programs have been enhanced to no longer require a config file name (port number) to be passed to them. Instead, if no file is passed to simpolserver or no port to serverclose they will look for a file called simpolserverinfo.cfg in the same directory as that where the smprun32.exe, or if turned into an exe, the simpolserver.exe/serverclose.exe program was located when it was loaded (this is specific to Windows).
  • Corrected in trecordview, ttableview, dataform1, and printform1 a problem with the selectkey() method of the sbme1 object. In short, if the key value is for an index value beyond the end of the current index, instead of returning the last record in the index, sbme1 returns .nul and an error 64. The aforementioned types have now been updated to correct this behaviour and to return the last record in the index unless the table is empty, in which case .nul is returned. We will be investigating a full correction of this behavior for the next major update. Fixed a problem in the record view grid that would not update the grid if the index was not changing or the record was not being locked on a selectcurrent().
  • The addressbook and sbair projects were given minor updates to improve their handling of the select key type of lookup.
  • Fixed a problem with the SBV2SXP.SBP Superbase conversion program which was using the wrong color for backgrounds on rectangle and ellipse objects, and added the support for the printable property to all objects.

SIMPOL Professional v1.73 Specific Notes

In this minor maintenance release of SIMPOL Professional there are several new features and a number of bug fixes.

New Features in SIMPOL Professional v1.73

  • SIMPOL Personal now has filters and filter dialogs in all three view modes. It also allows you to define a filter in the Print routine for printing records and forms.
  • A new sample project was added to the tests folder. The timelibtest project demonstrates the use of the unittest.sml library.
  • A new conversion program has been created for converting Superbase forms meant for printing into SIMPOL printform1 files.

Changes in SIMPOL Professional v1.73

There have been a number of changes in this release, many are bug fixes for which we wish to thank our user community for the excellent feedback.

  • The appframework project — Added additional view modes to the framework: record view and table view, plus we included the repguilib.sml for calling the Quick Report UI. We added support for filters in record, table, and form view. Added a deffont property to the application object. Modified the DEFSCROLLBARS constant in the appframework project from .false to .true. Added an innerwindow property and modified the appwindow type to use an outer window for the frame, and an inner (child) window for the forms and views, which solves a number of issues regarding vertical scrolling on long forms. Added a closeform() method to the appwindow type. Almost all cases of the declaration of appwindow have been changed to type(appwindow), which will allow programmers to derive an appwindow type from the current appwindow and expect it to work in the appframework.
  • The nondigits() function has been enhanced to support returning negative values when converting from a string to a numeric value.
  • The databaseforms project — Fixed a problem with the dataform1control.setnext() method that did not support passing .nul. Added range checking to the dataform1page.addcontrol() method to ensure the control is within a valid range on the page and still fits. The dataform1filter type was exported so it could be used by other libraries, such as the recordview and tableview libraries. Also various adjustments to the filter implementation. Added dataform1.setfilter() and dataform1.assignfilterobject() methods. The setfilter() method is for setting a filter, the assign method is to assign an existing filter object (such as from the tableview or recordview for filter synchronization). Fixed a problem where the name of an optiongroup was not being added to the list for checking for existing names. Fixed a problem in detailblocks where the linking field was a date, time, or datetime. The printform1 family of types were updated with a printable property and a setprintable() method. If an object on a printform1 has a value of .false in the printable property, then it will not be rendered when printing. The printform1 type was also improved with the filter functionality and a setmasterrecord() method.
  • The db1util project — The string2val() function argument s was being modified internally in the call, resulting in a change to values that had been passed. This has been corrected to not change the input. Also the same fix for the minus sign for converting strings to negative numeric values was made.
  • The formlib project — Fixed some issues related to option buttons and where they would be created when merging a form page into another form page. The option buttons were being duplicated and would end up on page 1 even if pasted to another page. Added support for the printable property that was added to printform1 graphics and controls so it can be saved and read from the storage format.
  • The netinfolib project — Added a getcomputername_win32() function to the project for retrieving the specific machine name.
  • The printformlib project — The printwxform() and printrecord(() functions have been enhanced with additional parameters: wxprintout printout, integer pageno, and boolean closeprintout. Adding these parameters allows multiple calls to the functions using the same printout document.
  • The sbldatelib project &mdash The string2date() function has been updated to support more date entry options.
  • The sbltimelib project — The string2time() function has been updated to support more time format options.
  • The serialize project — The serialize() and readserializeddata() functions were updated to work with base object types such as blobs, not just complex objects.
  • Utility program sbf2sbm.smp — Added recognition of deleted fields still present in an unreorganized Superbase file and outputs an error message.
  • Various fixes in the sbv2xml.sbp utility program.
  • SIMPOL Personal — Single-table filters were added to all three view modes, and are synchronized across views. The Print function has now been enhanced to allow printing multiple records or forms (including print forms) that can be the entire file or use a filter specified with the filter dialog. Various bug fixes have been implemented in the Form Designer for copy/paste errors related to option buttons.

SIMPOL Professional v1.7 Specific Notes

In this sixth maintenance release of SIMPOL Professional there are a number of bug fixes, as well many minor enhancements as well as some major improvements:

New Features in SIMPOL Professional v1.7

  • SIMPOL Personal is now shipped as an EXE. It is also possible to double-click on files with the .sbm, .sxf, .sxp., and .sxq extensions to open them in a SIMPOL Personal instance.
  • SIMPOL Personal now has a Print Form Designer as well as a Form Designer. Print forms can now be loaded and printed using the File->Print menu item. Print forms can be created, modified and saved into the sxp file format.
  • SIMPOL Personal has a new Table View mode.
  • With grateful thanks to one of the members of the SIMPOL community, we are able to deliver the first release of the French language support for the IDE.
  • New sample programs, including: Worm (the classic game implemented in an object-oriented style) and quickreportsample, which demonstrates how to create a Quick Report in source code using the database from the Address Book sample.
  • An additional email library called windowsemaillib.sml and its source project were also added to the system. It was created to cope with the need for an email library on Windows that can use SSL, which is currently not available in SIMPOL. It supports login with user name and password as well as HTML email and attachments.
  • New library called parsenum, contributed by a member of the SIMPOL community. This library implements the parsenum() function which takes a numeric value and returns it as words, for use in check writing type applications.

Changes in SIMPOL Professional v1.7

  • The SMPPSR library has been enhanced to now support all of the code pages while serving as the SMPPCS component supports for accessing. In the past only code page 850 was supported for serving. To support this, the simpolserver.smp program that implements a basic server has been enhanced to support code pages as well, by adding that support to the config file. Code page support is table-specific.
  • The sbf2sbm.smp tool for converting Superbase database to SIMPOL has been improved by adding OemToAnsi support in various areas. Previously, database using content or field names from languages using upper ASCII characters would not have converted correctly.
  • The wxform type has been given the freeze() and thaw() methods for ensuring smoother animation and fewer redraws and flicker when making multiple changes to a form.
  • The smtpclientlib.sml and source library have been updated to support HTML email, attachments, and authentication (logging in with user name and password for sending email). The PLAIN and LOGIN authentication methods are supported.
  • There were various changes to the appframework.sml library. A disablewindowresize property was added to the appwindow type. Normally if an appwindow opens a form it will resize itself to accommodate the form. Using this property, this behavior can be suppressed. An appwindow.createformdirect() method was added to enable the opening of forms that were stored as source code and added as functions to the program.
  • In formlib.sml the function printform1mergeforms() was added to support the copying and pasting of print form elements to and from the clipboard.
  • In reorglib.sml the output log during reorganize has been made optional.
  • The query engine in sql1.sml had significant improvements made in the optimization of single and multiple table queries.
  • The Quick Report library now has a new target. It is able to output to a new SBME table.
  • SIMPOL Personal: Updated various items to better support Linux. Reimplemented record view as a library in conjunction with the new table view library. Changed to use a child window for each appwindow object as the host of the content which allows vertical scrolling without overwriting the status and tool bars. Various minor bug fixes. Moved all images into functions that are compiled into the program to remove dependency on external files.
  • uisyshelp – Improvements to the date picker. localecalendar was enhanced with methods for returning the day, day abbreviation, month, and month abbreviation names. Improved getdefaultfont() to take an optional desired point size.
  • graphicreportlib – Adjustments were done to remove workarounds that had been implemented because of problems in the printing system. Also made modifications due to improvements in the printform1 type family which is used heavily by graphicreport1.
  • db1util – Improvements to getfieldinfoarray() including supporting vola1base.
  • dbconverter – Enhanced the dbSBMEExport.createsbmetable() method to provide default field formats if none are specified.
  • displayformat – Dialogs were modified to use getdefaultfont() instead of specifying a font.
  • Added a chapter to the IDE Tutorial that teaches how to debug into the supplied library source code. Updated the Quick Start Guide with additional information related to new features and examples.
  • In the Programmer’s Guide we added a Types Overview chapter for some of the main type families supplied by the libraries and also revised and updated the dataform1, printform1, reports, and wxWidgets chapters.
  • Added a chapter for the Print Form Designer to the SIMPOL Personal handbook.
  • Updated the SIMPOL Language Reference with changes to existing libraries as well as adding all the information for the newly added ones.

Bugs Fixed in SIMPOL Professional v1.7

  • Fixed a parsing problem in calceval.sma.
  • Added sanity checks to the setposition() code for dataform1 controls. Fixed the setmasterrecord() method of the dataform1 type to ensure that it reads and updates any detail records. The setmastertable() method of the dataform1 type was enhanced to set the masterrecord property to .nul. Added the findproperty() function which can be used to establish if a property exists in a type. Added the setposition() method to all dataform1graphic types. Full enhancement of the printform1 family of types.
  • reportlib – Various fixes plus implementation of the distinct property.
  • formlib – Fixed various bugs in the loading of print forms. Improvements to the convertwxformtodataform1() function.
  • fastset – Improvements were made to the fastset.insert() functionality.

SIMPOL Professional v1.61 Specific Notes

This minor release contains a couple of necessary fixes that were affecting the initial run of SIMPOL Personal, if it was being run on a new installation with no pre-existing simpolpersonal.ini file. The problems were traced to a quirk in the way the writeprivateprofilestring() function was implemented in SIMPOL, in the conflib.sml library. The specific problem affected the case where a call was being made to remove a section in the ini file if in fact the ini file had no content. This release contains updates to the conflib.sml plus its project and to SIMPOL Personal, plus all binaries affected by the changes.

SIMPOL Professional v1.6 Specific Notes

In this sixth maintenance release of SIMPOL Professional there are a number of bug fixes, as well many minor enhancements as well as some major improvements:

New Features in SIMPOL Professional v1.6

  • First release that included the ODBC client component for accessing external data sources using embedded SQL.
  • Created the calceval library and function. This function can evaluate a string containing an expression and return the result. Supports all SQL92 functions provided by SIMPOL, all standard operators, and fields from a single supplied record.
  • The bzip2 library and the simpolpacker library were added. The bzip2 library provides high compression to a single file, while the simpolpacker library utilizes this to create an archive format containing the contents of a single directory only (no hierarchies), plus stores the file names, and date time stamps of each file. It includes all code necessary to create and unpack the archives.
  • Added a graphical PPCS server program that uses a similar configuration file format to the command line version. The new server can be stopped and started and provides reorganize, backup, and restore plus a log viewer. It is located in the SIMPOLUtilitiessimpolserver directory.
  • Added the lpad() and rpad() functions to the stringlib.sml library. These functions allow the pad character to be passed as an argument, but default to the space character.
  • Created a new library called soundlib.sml, which provides support for playing system sounds and *.wav files on Windows. Linux support is not yet included.
  • Added the datetimelib project and library, which includes new functions for converting to and from dates, times, and datetimes, and which consolidates most date, time, and datetime support in one library.
  • Created new user input dialogs for entering dates, times, and datetimes, with validation and the calendar control as part of uisyshelp.sml.
  • Added a new function called convertwxformtodataform1() to formlib, to allow promoting a wxform to dataform1 so that it can be saved as a standard form file (*.sxf).
  • Enhanced the source code generation routines in formlib to accept parameters for the tab size, whether to comment the line that includes the uisyshelphdr.sma, and whether paths should be stripped from images.
  • Added the urllib project and moved the URL type and the parseurl() funciton into that library to facilitate its use from multiple projects.
  • SIMPOL Personal has a new Quick Report front-end that works together with the quickreportlib.sml engine that was part of the previous release. Details about its use can be found in the new SIMPOL Personal User Guide.
  • First release of the SIMPOL Personal User Guide.

Changes in SIMPOL Professional v1.6

  • The printformlib.sml now exports the papersizeinfo type, and supplies a new exported function to retrieve a wxPaper type from a Windows paper ID.
  • SIMPOL Personal now has an MRU list for forms and another for tables, and the forms list is shared with the Form Designer.
  • Added a mode to the gaugedialog type that provides an indeterminate gauge, for when you don’t know how long it will take.
  • Enhanced the MRUList type to allow the list to be shared and so that more than one list can be added to a menu by supporting submenus.
  • Improved the lookup() function to better cope with non-matching but compatible data types such as dates, times, and datetimes.
  • The uuencode library had its base64 encode and decode functions completely reimplemented.
  • All of the GUI-based tools, SIMPOL Personal, all of dataform1, the formlib library and the SIMPOL Form Designer have been made DPI-aware. This includes the source code generation such that SIMPOL programs should be well-behaved on both large and small fonts machines, as long as the programmer makes use of the capability.
  • Added an optimization to improve performance of the scrollbar on detail blocks when they contain large numbers of records.
  • The datepicker project and library were removed and are now part of the uisyshelp project.
  • The string2time() function is now more robust and should be able to cope with a wider array of user input.
  • db1base type tag was added to the SBME documentation.
  • ppcstype1file now has a tablename property that is identical to its filename property.
  • ppcstype1server.addsbme() now has an additional boolean parameter called recordcount that defaults to .true, but if set to .false will prevent the record count from being performed when the file is added to the server. In most cases this should remain at its default value, but with very large files (gigabytes in size) it can take several minutes to get the record count. With several such files, it can take 30 minutes to start a server. As such, if the record count is not required (it will be set to the maximum value), passing .false here can make an enormous differnce in server start time in such cases.
  • smprun32.exe, smprun, smpd1_32.exe and smpd1_ have been changed to no longer output information about the running of the program. This change allows the output of the program to only be what is returned by it. This facilitates using the output of a console program in a pipe.
  • The wxformgrid had the following additions: getcursorrow(), getcursorcol(), setcursorposition(), and enablecelleditcontrol(). These provide even more ability to manage the grid control, building upon the additions from v1.5: the getselectedrow(), getselectedcol(), getcellbackgroundrgb(), getcelltextrgb(), setcellbackgroundrgb(), and setcelltextrgb() methods plus the onlabelclick event.

Bugs Fixed in SIMPOL Professional v1.6

  • UTOSdirectoryentry.setdates() would give a number out of range error if the lastaccessed value was not specified.
  • Fixed the copy_db1rec_to_db1rec() function to not copy the internal read-only record value.
  • gettemppath() was not always getting the correct path on Windows systems. Added an API call to correct for this.
  • The getuserinput() function was updated to cope with dates, times, and datetimes.
  • Fixed a bug in string2date().
  • The File Designer in SIMPOL Personal was limited to 300 fields. This has changed now to cope with the number of fields present in a pre-existing table and to allow up to 300 new fields to be added to a table definition. The speed of loading large table definitions was also optimized.
  • A bug in the area of detail block conversion in the sbv2xml.sbp program was fixed.
  • Fixed a problem when loading forms containing bitmap buttons.
  • The onfill event for dataform1combo and dataform1list controls was not being called at creation.

SIMPOL Professional v1.5 Specific Notes

This is the fifth maintenance release of SIMPOL Professional. This release contains significant enhancements to SIMPOL, specifically the three report engines, updates to the print form technology, and significant fine detail improvements in the libraries. There is updated documentation in the Programmer’s Guide, specifically in Converting SBL area plus two new chapters and updates to another in the part that covers programming with database applications using dataform1, as well as updates to the SIMPOL Language Reference and some useful improvements to the wxformgrid control. There are also two new tools in the Utilities section for converting Superbase applications, one for converting Graphic Reports and one that generates SIMPOL source code to handle the constants, calculations, and validations from Superbase databases that use them.

One of the minor but important changes to the redistributable portions of SIMPOL is the addition of Windows version resources and in the executables an icon resource and the manifest resource. This means that external manifest files are no longer required.

There were bug fixes and improvements in the date picking dialog, the drop list box functionality for edit controls, and the addition of sort order support for detail blocks. Various niggles have been fixed in the IDE: saving as a new project was not working because of a difference between Vista and XP in the way common dialogs work. The same problem was preventing the Add Module and Rename Module code from working correctly.

For details about the new report engines and the printable forms, please see the relevant sections of the SIMPOL Programmer’s Guide (last two chapters).

SIMPOL Professional v1.4 Specific Notes

This is the fourth maintenance release of SIMPOL Professional. The primary highlights in this release are changes to the Form Designer: cut, copy, paste for controls, plus a complete new toolbar with tools for assigning colors, fonts, font sizes, alignments, etc. plus setting the defaults for these items. Other great new features are the droplist boxes for dataform1edittext controls, the datepicker library, the new registry library, the new unlinked detailblock that uses queries, plus a few new libraries. The biggest new item is the release of the databaseforms library and formlib as source code. You can now see exactly how various pieces are implemented and debug into them if you think you have a problem in there. There is also some updates to the documentation regarding how to deploy your application (see the Quickstart Guide first chapter), and a new chapter in the Programmer’s Guide about the design of the dataform1 architecture.

What’s New

All of the following entries are supplied as source code projects, not just as libraries.

  • The first source release of databaseforms.sml.
  • Initial release of the datepicker.sml calendar popup dialog.
  • The first source release of formlib.sml.
  • Initial release of the registrylib.sml for working with the Windows registry.
  • Initial release of the serialize.sml library, for storing objects to files and reloading them later.
  • Initial release of the uuencode.sml library, with functions for uuencoding, uudecoding, base64 encoding and base64 decoding of data.

The Changes

There have been numerous changes, some very small, others quite significant. The biggest obvious changes are to the Form Designer. There is now a droplist capability added to dataform1edittext controls, so any editable textbox on the form can now have a drill down list added to it. The sbv2xml.sbp program has been enhanced to support detail blocks. There was a bug in the dataform1 system that prevented adding detail blocks on any page except the first one.

There is now a new directory called redist that contains the redistibutable loaders and libraries. See the section on deploying SIMPOL applications in the Quickstart Guide.

SIMPOL Professional v1.3 Specific Notes

This is the third quarterly release of SIMPOL Professional (we are running late here, but some things can’t be done in a single quarter). The primary highlights in this release are: Detail Blocks! (finally), Linux GUI support, data-aware bitmaps on forms (for external support), plus a few new libraries with useful bits.

There are a few caveats related to the detail blocks, but first: Thank you to everyone who joined into our discussion on the forum regarding the design of detail blocks. This first implementation provides linked (but not unlinked) detail blocks that can also have 1:1 links within the detail block. Child detail blocks are not yet supported (though much of the implementation is done). The detail blocks are not automatically writeable in this release. Much of the discussion on the forum revolved around how the detail blocks should support modifying, creating, and deleting records. Some wanted it all to work like in Superbase, others said they never do data-entry in detail blocks and don’t care. Others said don’t even bother with child detail blocks. In this release you can certainly add the create, delete and write capability using popup menus, buttons, dialogs, and any number of other methods. What is not present is an automatic method of doing it. We think that deserves another round of discussion after people spend some time with the current version.

Please note, there is a known bug currently with tab order and detail blocks that we are still trying to resolve. It shouldn’t matter unless you are doing data-entry in the block, and we don’t support that natively yet anyway.

Coming in the next release: more reports, more documentation, more examples!

What’s New

All three of the following entries are supplied as source code projects, not just as libraries.

  • Initial release of mathlib.smlabs(), sqrt(), int(), factorial(), pi(), sin(), cos(), tan(), cosecant(), secant(), cotangent(), arcsin(), arccos(), arctan(), arctan2(), degrees_to_radians(), radians_to_degrees(), raisetopower(), ceil(), floor(), round(), intnearest(). Finally a usable set of trigonometric functions!
  • First version of netinfolib.sml, providing the getusername() function for both Windows and Linux.
  • Initial release of the printformlib.sml project, which includes functions for printing forms and records.

We have added the wxWidgets support for Linux in the form of libsmpolwxwn.so. To use it you will also need the wxWidgets 2.8.x libraries installed on your distribution. For the most part, things work pretty much as they do on Windows. There are some differences, and we are looking closely at those for future updates. Having said that, our internal CRM system, written in SIMPOL, works fine on Ubuntu. We do recommend installing the Microsoft Font set that is available for download in order to provide consistent fonts.

The Changes

  • smwxwn32.dll — Added the wxform.setkeyfocus() method for providing a way to trap key strokes via the form.
  • uisyslib.sml — Fixed a problem with the prompt text in the getuserinput() function.
  • SBLDatelib.sml — brought the DAYS() function up to date by passing a SBLlocaledateinfo object only and removing the separate inclusion of the centurybase parameter.
  • filesyslib.sml — Added the functions gettemppath() and gettempfilename().
  • dataform1.sml, formlib.sml — First implementation of detailblocks. These are currently read-only and do not yet support nested detail blocks. In spite of this, read/write can be achieved by adding an onmouse event to the controls and providing a right-mouse popup menu, or by handling the ongotfocus event, or any of a number of other standard strategies. The utility for converting Superbase forms has not yet been updated to support detail blocks.
  • dataform1.smldataform1bitmap has been modified to be data-aware, which now allows linking a field to a bitmap on the form. The content of the field must be either a file URL or an http URL in the format:
    file:/// or http://. Please note that there is no automated caching code for images retrieved using the HTTP protocol.
  • Added support for images to the Sbv2xml.sbp program.
  • Enhanced the datetime support to deal better with .nul and “”.
  • dataform1.sml — Fixed the dataform1.refresh() method when dealing with entries that are equal to “” or .nul so they do not prompt to be added. Instead a ” ” space character entry is added without telling the user.
  • db1util.sml — Changed the way that val2string() deals with the .nul value.
  • displayformat.sml — Added support for EXT as a format in the library.
  • Fixed the formlib.sml and other related pieces to only use the now more limited set of system colors instead of the wider range used in the past (adjusted for optimal Linux support).
  • Updated the simpoldataform1.dtd to reflect recent changes.
  • mrulib.sml — Fixed a bug when adding entries to the MRU list.
  • sbf2sbm.smp — Added EXT support.
  • SBLTimeLib.sml — Fixed a bug in the implementation of string2time() when converting times using the pm format to internal time values.
  • stringlib.sml — Added support for the repeating decimal characters in the nondigitsordecimal() function.

SIMPOL Personal Changes

Obviously many of the changes mentioned above also pass through into the Form Designer and the standard end-user environment provided by SIMPOL Personal. In addition, here are some more updates to SIMPOL Personal.

  • Modified the Table Designer to use the default font but force it to 8 points.
  • Fixed the code in the Form Designer that handled opening data sources. Also added minimum control widths and did other changes to avoid crashes if the user tries to size things too small. Added the dirty flag change if the user moves or resizes items.
  • Changes were done to allow it to run well on Linux. Also added the support for the printformlib.sml, and provided an initial printing capability. Please note, it is not currently possible to deploy SIMPOL Personal
    on Linux, but it has been used for in-house testing. There are some outstanding issues with using the rubberband line functions of the wxform object while running on Linux (differences in wxWidgets between Windows and GTK). These will be resolved in a later release.
  • Enhanced the Form Designer to allow multi-line text for buttons.
  • Also implemented an Undo Manager for the Form Designer.
  • Added support for the EXT format and improved support of the LOG format in the Table Designer.
  • Modified the visual linking code to also use 8 point default fonts.
  • Modified the defer mechanism for the toolbar record selection and added number as a supported type for the index lookup. Added key event support for the panel (arrow keys for browsing).

SIMPOL Professional v1.2 Specific Notes

This is the second quarterly release of SIMPOL Professional. The primary highlights in this release are related to documentation. The new SIMPOL Quick Start Guide has been included. A couple of chapters are still missing, and others will be added over time, but this guide already contains all that is necessary to get a rapid start on building usable applications quickly and easily in SIMPOL. Also part of this release are samples related to the new guide. A major effort has gone into bug fixing, testing, and usability enhancements in the current release. These can be found in the underlying libraries and also in SIMPOL Personal. A number of important changes have been made to accomodate running fully on Linux, which we are currently testing. The full Linux support at the GUI did not make this release, but as soon as it is available, an update will be placed on the download server and everyone will be notified.

Another major improvement is the inclusion of a powerful database conversion tool for converting Superbase database files into SIMPOL database files and tables. This can be found in the Utilities section and is described in the last chapter of the new SIMPOL Quick Start Guide.

SIMPOL Professional v1.1 Specific Notes

This is the first quarterly release of SIMPOL Professional. It contains a few new features plus a number of bug fixes. SIMPOL Personal and the form designer have seen numerous improvements, including a most-recently used list which should make it easier to reopen commonly-used tables and forms. The mrulib project was also added so that this functionality can be added to other projects. Another new feature is the support on Windows for OLE2 automation. An example showing the use of SIMPOL to access Excel is provided as well in the Examples folder.

SIMPOL Professional Specific Notes

To access the RAD tools, you will need to use SIMPOL Personal. SIMPOL Personal is used to create and modify database tables, import and export data, reorganize databases, create forms, etc.

Some specific new utilities can be found in the Utilities directory and subdirectories, including:

  • simpolserver.smp — This is a server program for sharing your database tables via PPCS. See the readme.txt and sample.cfg files.
  • sbmerepair.smp — This is a repair utility should anything go wrong with your database. The database is quite solid, but some things can affect the best databases.

The utilities directory also contains some conversion tools for converting Superbase applications. More of these tools will soon follow.

Warning!

Please remember to click the Save All button in the IDE when making changes to the project settings or to the workspace (break points and bookmarks). There are still a couple of annoying and difficult to track down crashes that occasionally happen when debugging. The only things that ever get lost are the recent changes to the project settings and the workspace, so clicking Save All after making changes can ensure they are still there when you restart.

Pre-Release 4f-Specific Notes

This release has been a long time in coming and includes a few new bits but more importantly it includes significant stability improvements over the previous release. It isn’t perfect yet, so it is still important to save forms on a regular basis when working on them, but it should be far more usable than its predecessor. In the coming release following this one, the detail blocks will be added for forms, and a basic query engine will be added for creating ad-hoc queries. Also, the import/export functionality will be incorporated into SIMPOL Personal in the next release. Watch for more smoothing out of various wrinkles going forward.

This release incorporates a number of improvements to the product, including:

  • On Linux the 2GB file size limitation has been removed. The new code uses the 64-bit file size capabilities, but now requires a kernel that is compiled with 64-bit support (most 2.4 kernels and later).
  • Added the system functions: !getproperty(), !setproperty() and !getvariable to SIMPOL. These are primarily used to make extremely effective and dynamic generic code, so although they are probably not for everyone, those who can use them well will be able to build great and powerful things for others.
  • LANGUAGE CHANGE!!! — the readonly keyword for use in type definitions. To set the value of a readonly property the !setproperty() system function must be used from a member function of the type.
  • The smpwin32.exe program loader has been modified to respect the double-quote character in path names. Failure to do this resulted in errors when running programs in paths that contained spaces, for example when running SIMPOL Personal from the Start menu link if it were installed below the “Program Files” directory.
  • The IDE has been enhanced in the debugging area so that it is now possible to view the contents of an array. Yeaaaaaaa!!!
  • DATABASE CHANGE!!! — there have been numerous small improvements to the *.sbm files such that it is recommended that you reorganize (see the reorganize.smp in the projectstools directory (sorry, currently command line only).
  • The SLIB component (shared/DLL library calls) has been added for Linux.
  • A bug in the record count code for *.sbm files from both single-user (SBME) and mulit-user (PPSR) access was causing the record count to increment every time a record was saved, instead of only for new records.
  • Added the ability to expose the unique key from *.sbm files, the internal record ID, when sharing them via the PPSR component. These items are the recordidfieldname property and the setrecordidfieldname() method of the ppcstype1servertable.
  • Added the initial version of the ODBC client component that may ship later in the year. This component provides access to external data sources using the ODBC method of access.
  • Refresh problems with the wxformsizebox object that had been reported from its use in the Form Designer have been corrected.
  • Assorted documentation fixes and enhancements for new functionality.
  • Various minor (though important!) fixes to the database components.

SIMPOL Personal has had a number of enhancements, including:

  • The Form Designer can now draw all of the controls. The final two controls, dataform1bitmap and dataform1bitmapbutton were added. They are also able to be generated as part of a dataform1 or wxform source code target using the Save As program functionality.
  • The keyboard shortcut for deleting records has been changed from Del to Ctrl+Del. This is intended to cope with the problem encountered when simply using the Del key in an edit control on a form was causing
    the menu item to fire.
  • Removing all content in a grid cell in Record View was failing in the string2fieldval() call.
  • File->Modify->Table was causing SIMPOL Personal to close whether or not there was a table or form open. This no longer shows the menu item if no table is open or if the open table is one of the sys tables.
  • File->Modify->Form was causing SIMPOL Personal to close if there was no form open. This was caused by the closeform() code not calling managemenu().
  • Window->Close was closing all the SIMPOL Personal windows rather than just the active desktop window. This was caused by the menu item not setting the window to invisible. The whole routine was enhanced by adding a close() method to the appwindow type.
  • Opening the datasource adrb.sbm and entering a date in a date field and then pressing enter was causing SIMPOL Personal to close. Also, entering a date in the supplied adrbport.sfx form and pressing the enter or tab key was having the same effect. This required a major rewrite of the string2date() function to allow for a wider array of bad user input. This was done by creating a fairly flexible predictive function. This added an error parameter to the end, and this also resulted in a change to the string2fieldval() function, which also got an error parameter on the end.
  • Opening the supplied sample datasource table adrb and then opening the form adrbport.sfx in that sequence wasn’t displaying the data in the form. This has resulted in code being added to the finddatasource()
    method of the dataform1 type to account for sbme1 datasources that have a file name but no path. There has also been a change to the formlib library, to allow all of the necessary parameters to be passed
    through the opendataform1() function that are supported by the xmlsdf1.getform() method. Finally, the xmlsdf1.getform() method has been enhanced to check the list of tables passed before opening a new one.
  • Selecting Close->All was closing all the onscreen stuff but leaving the Close->Form and Open->Table and some of the Modify menu options enabled. Subsequently selecting Open->Table was causing SIMPOL Personal to close. All of this was dealt with by improvements to the managemenu() function.
  • Creating (or deleting) an index was not updating the Index dropdown list, instead it was updating the Table dropdown list by one, that is every time this was done, an extra "mytable" entry was added in the Table list. The code governing this area was carefully updated to fix these problems. It was possible to create indexes but unable to delete them once they were created. This required very minor modifications to the code that is called when the index value is changed and had to do with needing to use a space " " character in the combo box instead of using the empty string "".
  • Was getting spurious "End of File" dialog every time a table was opened or the Table Definition dialog was closed. Changed the record selection code to detect the record count and to not respond to an error on the selectfirst() or selectlast() functions if the table has no records. If the selectnext() or selectprevious() functions are called, it still shows the EOF message.
  • Loading the 3-page adrbport.sxf and paging down from page 1 to page 2 was not activating the PageUp button (it was only happening when you reached page 3). Similary, paging up from page 3 to page 2 was not activating the PageDown button until page 1 was reached. This required a very minimal modification to the code that checks if the new page is 1, 2, count, or count – 1.
  • Utilites->Status->Table (after opening a datasource e.g. adrb.sbm) was causing SIMPOL Personal to close. It turns out that a field with a value of .nul causes an error in the .tostr() function. The code was changed to trap for an index with a precision of .nul.
  • Using File->Close->All to close a table (e.g. adrb.sbm) was leaving the Utilites->Status->Table option enabled and selecting it was causing SIMPOL Personal to close as above. (File->Close->Table)
    disabled the option. I assume the managemenu() function issue. Good call, managemenu() wasn’t being called in this function.
  • When first loading SIMPOL Personal, File->Open->Table was disabled but subsequently left enabled after opening and closing a data source. This is correct behavior since it is necessary to open a data source first. If a table is then closed, but not the data source, then it is still possible to open tables from the still open data source.
  • After File->Close->All the table and index comboboxes were not being disabled. They were left enabled with empty droplists. This resulted in a consolidation of the management of the tool bar icons for selecting records and the comboboxes for tables and indexes.
  • Creating a new index on a string field e.g. the "Company1" field in adrb.sbm table was causing SIMPOL Personal to close when selecting the "Save" button if the "Index Max Chars" cell was left blank but not if it was set. On other datatype fields (e.g. integer or date), creating an index automatically sets the value of "Index Max Chars" to "100". All new indexes now get a precision of 100 except for date, time, and datetime fields where the precision is hard-coded to ,code>.nul and it can’t be changed. The code that is called when you exit the cell where the value can be modified has now been changed so that if it is empty, it is reset to 100 and a warning is issued.
  • Deleting a field in the Table Definition dialog and attempting to "Save" was causing SIMPOL Personal to close. Not consistently reproducible this one. Often the close was occuring on closing the Table Definition dialog after the "Save". If the deleted field was an indexed one, then error message “Error number 911 on updating the table in the *.sbm file” followed by a close was the result. This was happening in spite of having removed the index. This was a bug in the C-language component, that only happened if the field was indexed.
  • In the Form Designer, the menu item "Define->Graphic Properties" was initially enabled but selecting it did not open up the "Set Graphic Properties" dialog. It only became functional once a form control was selected.
    was it meant to be disabled initially? Thanks, we took a look at this and decided that not only that one, but also the Detail Blocks item needed more handling. The handling of both items has now been enhanced. Repeatedly toggling in and out of Form Designer mode was incrementing the entry in the Data Table droplist in the Properties dialog of the Form Designer by one e.g. got multiple entries for "MyTable". This was because the code was not checking to see if the table was already present in the form before adding it. This has been revised.
  • SIMPOL Personal was failing on machines using the Australian region when calling the File Designer. This was because the locale code was incorrectly assuming that the return value from a call to the Windows API was a decimal string, when in fact, this particular string was returned as hexidecimal.
  • In the File Definition area, it was not possible to delete an index. This was fixed by the same code changes that fixed the index creation bug.
  • In SIMPOL Personal the File Designer code was reworked such that the main form plus the one used for getting the table name now use the system colors instead of fixed color values.

SIMPOL Examples and Libraries have also been updated, with a number of improvements or new features.

  • The dataform1 object now has been updated to properly support the bitmap and bitmap button objects.
  • The formlib has been extended to allow for the saving and loading of forms that use the new and updated controls: bitmaps and bitmap buttons.
  • Added the valid property to the dataform1 object. This is set to .true when the object is created and will be set to
    .false by the opendataform1() function in formlib if it fails to open a data source or table used on the form.
  • Added the code to handle opening a form in a different location to the current directory of the running program, so that the path of the form is used to try and open the data sources if these are sbme1 sources and if the initial attempt to open them fails.
  • Fixed the comparison in the deletefile() function in filesyslib.sml, which was using =@= operator to compare the UTOSdirectoryentry object that was passed in, with the one returned from UTOSdirectory.getentry() method in a loop. This could not have worked, since they are not the same object, but two different objects that refer to the same thing. Changed the comparison to use the == operator and the function now works correctly.
  • In conflib.sml, changed both the getprivateprofilestring() and writeprivateprofilestring() functions to be able to handle not having the end of line character passed, but instead to try and infer it from the ini file itself. This will not work for writeprivateprofilestring() if the file does not yet exist.
  • In stringlib.sml, added the nondigits() and nondigitsordecimal() functions for working with .toval()‘s ignorechars parameter. Also added the information strings for all of the functions.
  • Fixed one spot in parsesbdentry() from sbd2sbme.smp that was using "NVU" instead of "VNU" to check for virtual
    NUM fields when converting a *.SBD file. Also removed some unused variables to allow building without warnings.
  • In conflib.sml, extracted the code that opens the ini file and which guesses the end of line character from the getprivateprofilestring() function and added it as a separate function called guesseolchar(). Added a new exported function called openinifile() that returns the content of the ini file prefixed with the end of line character as previously used by getprivateprofilestring(). Modified getprivateprofilestring() by adding a new parameter at the end that can contain the content of the ini file. If supplied, the ini file will not be opened but instead the content passed will be searched for the entry. This allows the ini file to be opened once and multiple calls to be made to
    read values out.
  • Numerous changes to the sbmerepair.smp program, specifically in the movesequential() function in order to improve the reliability of the repair process.
  • Added missing ondoubleclick event to the dataform1list object. This fixes the errors when saving forms and source code causing the wrong event to be output.
  • Enhanced db1util.sml, the fieldval2string() and val2string() functions were updated to take into account the fact that date values that are empty via PPCS may give the value 10 using SBME. The workaround for this is to hard-code that if the date value equals 10, then the string equals "". Although this does not roundtrip, it should work adequately.
  • Changes to dataform1. Added the fieldinfo array type property to the dataform1table. This contains the field name, a field reference, and a display format, which either comes from the extended information in an *.sbm file or the PPCS information for SBLdisplayformat. Also modified the code that assigns the display format in the various controls’
    .new() methods, and enhanced the support for empty values in the default onlostfocus event for all controls. Also added the displayformat parameter to the .new() method for dataform1text controls, which may break existing programs if they don’t expressly define "error=" in the parameter list.
  • In the objset.sml, added the deleteelement() method to the objset object. Also improved the objset.difference() method since the original design wasn’t as reliable. Added a set property to the objsetelement that refers to the objset that the element is a member of, to ensure that operations that take an objset and an element as arguments can check that the element is from the same set.
  • Completely rewrote the ppcsselectkey project to reflect modern practice. Much of the content of this was early versions of functions that have since been consolidated into the db1util.sml library. As such, added that library to the project and removed unnecessary old code.
  • Added the udtmemberopsample project as an example of how to use the member operator in a user-defined type.
  • Added a function to db1util.sml: copyextendedinfo() for copying the extended info from the system tables from one *.sbm file to another. Also added the getfieldinfoarray() function which returns an array with the field names, references, and format strings (if available) for a table. Added getdefaultformat() to return a default format string for the various data types. Added the extended information for the functions to the ones in the tablemanagement.sma source file.
  • Added support for the extended system tables to the reorganize() function in the reorganize.sml library project.
  • In filesyslib.sml the issamefilename() function was added to try and cope with the needs of establishing whether two file or file and path names that may differ only in case actually refer to the same file. Also added information
    sections for the other function that have return values.
  • Added the gaugelib project for providing a useful progress meter dialog type.
  • In sbnglib.sml, added the _ and __ properties to the datasourceinfo and tbinfo types. Enhanced the tablestatus() function by adding support for the record count information.
  • Added the record count support to volatable.
  • The winfiledlg.sml project has been converted from using the UTUI component to using the WXWN component.

The Superbase Form Conversion program SBV2XML.SBP have also been updated to reflect the latest capabilities of the form format, not yet including support for images, though SIMPOL does not support every image format supported by Superbase, so not all images will work once the support has been added to the converter. Also, embedded images in a Superbase form cannot be accessed programmatically! The image support will only work with an externally linked image, assuming that the path is still valid or that the image can be found in the current directory.

Pre-Release 4e-Specific Notes

This release incorporates a number of improvements to the product, including:

  • wxprintdialog() function for showing the printer dialog and retrieving the printer settings.
  • The wxprintout type now has a method called startprintpreview(), which allows the printout to be sent to the print preview window from where it can be viewed as well as printed.
  • wxformedittext.onchange and wxformcombo.onchange events were added.
  • wxformgrid.setcellvalue() now has a new parameter: valuearray. Using this parameter, a complete set of values can be sent to the grid in one operation, resulting in a vast improvement in execution speed and virtually no flicker of the grid.
  • LANGUAGE CHANGE!!! — it is now possible to add information strings to the function or method definitions. This is
    currently not heavily used in the examples, but it will be back-ported before the next release. This allows you to define the return value of a function and this will eventually be able to be picked up by the IDE and the post-processing unit for IDE tooltips and editing help as well as for identifying compile time errors.
  • LANGUAGE CHANGE!!! — it is now possible to define the member operator (!) for use in a user-defined type. Not every type is suitable to the definition of a member operator (typically this would be used for a group of types where one type contains a linked list of objects of another type). To use it, a function can be defined for both the left side of the assignment operation (essentially to assign a value to something) and for the right side of an operation (to get the reference to some object or its value) ie. to write or to read or to set and to get. Complete documentation will be in the next release in the programmer’s manual. A documented example can be found in the projectexamples directory, called
    “udtmemberopsample”.
  • Numerous optimizations in the drawing and refreshing of forms and form controls.
  • Fixed the refresh problem with wxformsizebox (most obvious in the Form Designer).
  • Fixed the problem where: “When first loading Desktop, “File / Open / Table” is disabled but subsequently left enabled after opening and closing a datasource”.
  • 6-digit date support in the SBLDateLib.sml project (string2date() function).
  • Assorted documentation fixes.
  • The sbme1.renamefield() method appeared to only work if the field name was the same size or shorter, this is now fixed.
  • In sbme1, continually creating and deleting large numbers of records resulted in unexpected growth of the database and a slowdown when adding records. This has been completely revised and the new algorithm is consistently fast and the database growth is now very minor over the course of time and in large data sets virtually non-existent. This was related to the algorithm for reusing space in database.
  • The PPSR server was returning an error 459 “record not available” to SBL, after running an update from SBL (always at the end — this appears to be because it was reaching end of file).
  • The staging of the txfactor was vastly improved so that the move from 5 to 6 is now a smooth progression. Previously it slowed down immensely between these two settings (on Windows).
  • The PPSR server was returning errors when dealing with an empty date field if the field was indexed when used from SBL.
  • wxgraphic objects reversed the x and y values in the point objects after they were created.
  • fixedpoint types allowed the x and y values to be changed after creation.
  • Documentation was updated for fixedpoint.new() and point.new(), which implied that they do not take parameters, but in fact they do: point.new(10,10).

SIMPOL Personal has had a number of enhancements, including:

  • The Form Designer can now draw all of the graphic objects: lines, triangles, rectangles, arcs, and ellipses. These can be moved and resized (though not reshaped except for the line, rectangle, and ellipse objects). These can be saved with the form and reloaded. They are also able to be generated as part of a dataform1 or wxform source code target using the Save As program functionality.
  • The Form Designer now supports full creation of non-data-aware grids, including row and column labels, fonts, draggability, etc. These can also be successfully saved and reloaded with the form, as well as generated to source code.
  • Record View has been updated to use the new valuearray parameter for the wxformgrid to improve performance and appearance.

SIMPOL Libraries have also been updated, with a number of improvements or new features.

  • The dataform1 object now has been updated to properly support non-data-aware grids and dataform1graphic  controls have been added to properly wrap the wxgraphic items.
  • The formlib has been extended to allow for the saving and loading of forms that use the new and updated controls, lines, rectangles, triangles, arcs, ellipses, and non-data-aware grids.

The Superbase Conversion Utilities have also been updated to reflect the latest capabilities of the form format, including  support for rectangles, lines, and ellipses.

Pre-Release 4d-Specific Notes

This is primarily a bug fix release for 4c. There have been numerous improvements in SIMPOL Personal and underlying library code. The following fixes are incorporated:

  • “File/Modify/Table” causes the desktop to close/crash whether or not there is a table or form open. This no longer shows the menu item if no table is open or if the open table is one of the sys tables.
  • “File/Modify/Form” causes the desktop to close/crash if there is no form open. This was caused by the closeform() code not calling managemenu().
  • “Window/Close” closes all the desktop windows rather than just the active desktop window. This was caused by the menu item not setting the window to invisible. The whole routine was enhanced by adding a close() method to the appwindow type.
  • Opening datasource adrb.sbm and entering a date in a datefield then pressing enter causes the desktop to close/crash. Entering a date in the supplied adrbport.sfx form and pressing enter or tab has the same result. This required a major rewrite of the string2date() function to allow for a wider array of bad user input. This was done by creating a fairly flexible predictive function. This added an error parameter to the end, and this also resulted in a change to the string2fieldval() function, which also got an error parameter on the end.
  • Opening the datasource and table adrb then opening the form adrbport.sfx in that sequence doesn’t display the data
    in the form. A share problem? I note this if more than one Desktop instance is open. This has resulted in code being added to the finddatasource() method of the dataform1 object to account for sbme1 datasources that have a file name but no path. There has also been a change to the formlib.sml, to allow all of the necessary parameters to be passed through opendataform1() that are supported by xmlsdf1.getform(). Finally, xmlsdf1.getform() has been enhanced to check the list of tables passed before opening a new one.
  • Then selecting “Close/All” closes all onscreen stuff but leaves the “Close/Form” and “Open/Table” and some of the “Modify” options enabled. Subsequently selecting “Open/Table” causes the desktop to close/crash. All of this was dealt with by improvements to the managemenu() function.
  • Creating (or deleting) an index does not update the Index dropdown list, instead it updates the Table dropdown list by one, that is every time you try this, you get an extra “mytable” entry in the Table list. This was handled by changes to the code that handles the rereading of a table after it has been modified in the Table Designer.
  • Managed to create indexes but cannot delete once created. This required very minor modifications to the code that is called when the index value is changed and had to do with needing to use a space ” ” character in the combo box instead of using “”.
  • Get spurious “End of File” dialog every time you open a table or close the Table Definition Dialog. Changed the record selection code to detect the record count and respond to an error on selecting the first or last record if the table is empty to not produce an error message. If selecting the next or previous record, it still returns the end of table message.
  • Loading the 3-page adrbport.sxf, paging down from page 1 to page 2 does not activate the PageUP button (only happens when you reach page 3). Similary, paging up from page 3 to page 2 does not activate the PageDown button until page 1 reached. This required a very minimal modification to the pageupdown code that checks if the new page is 1, 2, count, or count – 1.

There have also been some fixes to related program libraries, a fix to the sbme component and a fix to the fixedpoint object that was allowing modification of the properties. The IDE has also been updated with additional Help Assistant information for the point and fixedpoint objects.

The db1util.sml library and source code project have been updated to include the functionality for managing the new systables, sysfields, and sysfieldsext tables that are now included in the *.sbm files when they are created using SIMPOL Personal.

Pre-Release 4c-Specific Notes

This is an interim release that includes a number of new features plus improvements to the RAD tools. The major changes are:

  • THERE HAS BEEN A POSSIBLE PROGRAM BREAKING CHANGE IN sbme1.opentable()! If you have not been using the error= syntax for the error parameter, but just passing the value in place, this release will break your code! sbme1.opentable() now takes three parameters, and a gradually developing standard in SIMPOL has the error parameter last in most functions and methods. As such, it is always a good idea to name the error parameter when you make function or method calls. It also helps to do this in other places where it can assist in documenting what is going on with a function or method call.
  • SIMPOL Personal has been renamed SIMPOL Personal and is now in the main program group. SIMPOL Personal has had numerous bug fixes in the record view area, form view area, form designer, and has a new component for creating and modifying database tables. Also, the GUI for opening PPCS-based tables has been extended to allow the typing in of a table name (in case the tables are hidden on a target server).
  • The new print architecture has been added (wxprintout, wxprintpagetemplate, wxprintpage, wxprintstring, wxprintbitmap, wxprinttextitem, and wxprintbitmapitem). The print architecture works as follows: a wxprintout contains the entire print job that will be sent to the printer or print preview window (not yet implemented).
    The layout of items on each page in the printout is controlled by a wxprintpagetemplate object (if all the pages have the same layout, only one template is required). The data that is specific to a given page is stored as either a string or bitmap object in the page to be printed. Data that is specific to the template is stored as either a string or bitmap object in the template, together with non-data graphic objects such as rectangles, lines, ellipses, triangles, and arcs. Data that is used on more than one template, or that is specific to the entire printout is stored as a string or bitmap object in the wxprintout object. In practice this means that if you were creating a printout for a print form and were printing multiple records, then there would be a printout object, a template object, and as many page objects as there are records to be printed. Each page only contains the actual data, the template contains the information about the position of each data object and its characteristics (colors, fonts, background colors, borders, etc.), plus any graphics that are on each page (as well as static bitmap and text items). Once the entire thing has been created, it is sent to the printer. If a graphical report is being printed, then there will often be a template for each page, since in most cases the layout of each page will be different.
  • The sbme1 object has been updated with the ability to modify existing tables (add field, modify field, delete field, add index, delete index, rename field) in addition to the already existing ability to delete and rename tables. This has been used to add an interactive GUI component to SIMPOL Personal. Part of the GUI component allows the definition of a number of characteristics that are not directly part of the sbme1table object. These are stored in a set of system tables inside the *.sbm file. These tables are called systables, sysfields, and sysfieldsext. The content of the fields in these tables will be used to provide a number of capabilities, such as having the tables automatically correctly served by a standard ppsr server (coming very shortly in the next release). The displayformat is currently directly modifiable and follows the rules for older Superbase formats. This data is stored, together with the share type, shareability and share name (this should be restricted to a Superbase-compatible field name, but for safety’s sake, spaces are not permitted via the UI). More information about this will come with the documentation for SIMPOL Personal that will arrive in the near future. Also, a help text and a comment is currently stored in the sysfields table. The help text may eventually be integrated into a tooltip/statusbar help text capability for forms and record view.
  • The sbme and ppsr components now have a recordcount() method/capability (this is not stored, the record count is calculated when you request it and this will block any other access while it is running). This is still very fast and highly optimized. To retrieve the record count on a table that was 70MB in size with 176,000 records (roughly) took .04 seconds on a typical machine.
  • The sbme1table object now has the ability to expose the internal read-only unique record ID as an indexed read-only field. This is also now supported automatically with a default name in the SIMPOL Personal product. DO NOT RELY ON THIS ID FOR YOUR OWN USE EXCEPT DURING A SINGLE SESSION! Although the ID is guaranteed not to change for the lifetime of the record in the table, if you reorganize the table, the ID will probably change to some other internal ID value that is unique to the newly-created table. So DON’T use it to link tables to each other! Where it can be useful is if you are doing things like removing duplicate records and you want to always have a way to return to the same record in a table during a session. Even though this field is currently always shown in sbme1table objects that are opened in SIMPOL Personal, the entry is read-only and the dataform1 objects and the record view objects will not
    directly permit you to write to it. Attempting to write to this field will cause a runtime error.
  • There is a new httpclientlib.sml SIMPOL-based library that is supplied in full source code. The library provides programs with the ability to retrieve web pages using either GET or POST from a web server and returns a full
    httpresponse object to the caller.
  • There is also a command line program (supplied in full source) that uses the httpclientlib.sml library to retrieve web pages using either GET or POST. The command line project is a rewrite of the urldump.smp project. This also shows how to handle multiple command line arguments that are named with options.
  • The reorganize.smp program is supplied as a source code project that implements a command line based reorganize for *.sbm files. This will reorganize one table in the same *.sbm file, reorganize the table to a new file, do all tables, etc. Also demonstrates handling various command line options.
  • The sbmerepair.smp command line program will attempt to retrieve all of the data from a table in an *.sbm file by traversing the table in sequential order from the beginning until it encounters an error, and then retrieve the data from the end of the table sequentially in reverse until it encounters an error or reaches the point where it stopped.
  • A new library has been added to make it easy to send SMTP-type emails using the smptclientlib.sml. The library is called sendmail.sml and is also supplied as source code. Anyone who is interested in delving into the work needed to add the MIME support for allowing attachments, HTML messages, quoted-printable content, etc. should contact Neil Robinson. There is an existing amount of code already written for handling quoted-printable format, base64 encoding, and some MIME support code that could be contributed to these efforts. Eventually we will get to it, but if someone is in a hurry, let us know. Also, the smtpclientlib.sml project has been enhanced to handle code page conversions of messages, using the codepagelib.sml and the utf8lib.sml libraries.
  • A library that implements the ShellExecuteW() API call for Win32 has been added and supplied as a source code project.
  • The PAD.sml library has been enhanced with an LPAD() function, for doing the equivalent of PAD() but left-filled instead of right filled.
  • Some very minor improvements have been made to the lists.sml library, including some enhancements to the queue object implementation.
  • The uisyshelp.sml library (not supplied in source currently) has been enhanced with a new locale type that retrieves the user’s locale information on Windows. This type is not yet set in stone, but eventually it will be adjusted to primarily support locale information that is available on all the standard target platforms: Windows (Win32, Win64, WinCE), Linux, Mac OS-X, SymbianOS, and PalmOS (Access Linux Platform), plus possibly some platform-specific extended information.
  • Documentation: This time around the SIMPOL Language Reference got most of the significant updates. All of the new C-based component capabilities in sbme, ppsr and wxwn are fully covered in the SIMPOL Language Reference. There was also some improvement done in the chapter on converting from SBL to SIMPOL in the SIMPOL Programming Guide. All of the missing documentation for the SELECT KEY, etc. statements has been added.

If you find any problems with the IDE or with the portions of SIMPOL Personal that are in and activated, or with any conflict between the documentation and what actually works regarding any component, please let us know!

Things to look forward to in the next release

In the next release there will be a new ppsr server that will handle the new information stored in the *.sbm files. There will also be significant updates to the form designer and an added capability to define printable forms and to then print them out. Another major change that is coming is that the GUI objects based on the wxwn component will be running on Linux. There will also be a significant performance boost for grids by assigning multiple cell values in a grid control with a single statement.

Pre-Release 4b-Specific Notes

This is an interim release that only includes improvements to the IDE and installer. Specifically:

  • The hang that occurred if you were told that the project needed to be recompiled and that asked you if you should do so, has been fixed.
  • The GPF that occurred if you escaped from the Find dialog after an unsuccessful find has been fixed.
  • The Project Dependencies tool has had numerous improvements to ensure that only things that have changed get rebuilt.
  • The installer was attempting to set the user count to 3 for the smppsr32.dll and in some cases could hang or simply fail to do so. This part has been reworked and retested.

Pre-Release 4a-Specific Notes

This is an interim release with a number of improvements and a few new bits of functionality. The major changes are: significant testing and improvments to the single-user and multi-user database engines. They are now solid. We have migrated our production databases to the new database engine. A significant change in the area of the ppcstype1 object and related objects (both client and server) is the new txfactor property/parameter. This allows the user to set a throttle on the speed at which the
packets are sent. When sending over the Internet, where the ping speed may be considerably slower, it can be useful to set this to 6 or 7 to slow the transmission down so that the packets don’t get lost or discarded along the way.

Things that have been added include:

  • clipboard support (text and bitmaps) both setting and getting
  • mouse pointer control
  • improvements to the edit control (maxlength, getselection(), setselection(), getinsertionpoint(), and setinsertionpoint()
  • setfocus() for all controls that can take focus
  • clearfocus() for the form
  • a left double click event for the wxformlistbox
  • wxscreengettextextent() to retrieve information about the size of a string based on the font passed (a similar function will probably be a method of the print form)
  • wxformgrid.oncellselect as an event, so that you can get called whenever a cell is selected in the grid
  • there are also now vertical and horizontal scroll bars that can be activated and deactivated for a window
  • wxstatusbar was added
  • wxformbitmap object (images on forms)
  • wxbitmap now supports the following image formats: JPG, TIF, GIF, BMP, PNG, PCX, PBM, PPM, XPM, ICO, and ANI (but these are not yet shown animated).
  • ppcstype1servertable.setshareability() now allows the table to be hidden from the functionality that retrieves table lists.
  • ppcstype1servertable.setpassword() and .getpassword() methods
  • point and fixedpoint data types (part of the core simpol functionality)
  • wxgraphicline, wxgraphictriangle, wxgraphicrectangle, wxgraphicellipse, and wxgraphicarc types
  • child windows
  • documentation change to wxrgbdialog()
  • smpwin32.exe and smpw1_32.exe for running programs in normal and debug mode without a console window appearing

As described above, there have been a couple of changes to the PPCS support, but they hopefully won’t break much, in that there is now a txfactor parameter for opening files and also for the server when creating a udp socket. This allows the same data to be shared at high speed locally and at slower speeds for the Internet.

Another big enhancement is that you can now host forms in the toolbar as tools. That means that in practice, if you want to add a combobox, or an edit control, or some other kind of form control (spin button once we have them, etc.) in the toolbar, you can do that by creating a small form with just that one control and adding it to the toolbar. The form can also host multiple controls, not just one.

Obviously not all of these improvements have been able to trickle down to the stuff that has been supplied that is written in SIMPOL, but that is now coming. There is now a viable record view that works extremely well. It is now possible to create records and edit records with autolocking in record view. Some of the other changes will also show up in the various tools. This release doesn’t have detail blocks, but the next one will.

There have been major improvements to the SIMPOL Personal program. It now has a fully working record view, including creating records, editing, saving, and deleting. There is also now support for the file status, the selectkey() functionality, and you can also change the current index as well as switch between open tables. Everything here works for both PPCS accessed tables as well as SBME (the new single-user database engine).

Pre-Release 4-Specific Notes

This is the first pre-release of the SIMPOL Professional that includes data-aware forms, support for the new XML-based form format for loading and saving forms, and the first version of the Form Designer, written in SIMPOL. The data-aware form support is currently capable of displaying forms, and selecting records using selectlast(), selectfirst(), selectnext(), selectprevious(), and selectcurrent(). The selectkey() method has not yet been added. Also, the built-in support for locking and writing records back is prepared, but not yet implemented. Finally, this version does not yet support multi-file linkage, though this is implemented partially where the data source for listboxes and comboboxes can be specified and will be used. The intention is to give you a chance to look at and begin using the new form designer, and to play a bit with the forms. Most of the standard form controls are already supported.

In the next few weeks, the remaining support for linking files as well as for data-aware grid controls, detail blocks, setting the tab order, setting and applying default properties, etc. will be added to the designer. Utilities are provided for converting Superbase data files via PPCS to the SIMPOL database format. There are also utilities for converting forms to the new XML format, menus to source code, dialogs to source code, and forms to source code. Eventually menus, dialogs, and tool bars will have XML-based formats and will be able to be loaded and saved from these formats.

Other new pieces that have been added: wxformedittext and wxformtext now support alignment, wxformedittext now has additional capabilities, such as read-only, multiline, password, etc. More is coming here. The standalone scrollbar control has been added. Popup menus are now available. The common dialogs for selecting fonts and colors have been added. All of the form1 and window1 documentation and files have been dropped from the current product. Please migrate any use of the UTUI component to the wx equivalents. UTUI will be dropped in one of the next releases.

There is a basic sample called sbngpersonal.smp that includes the form designer and the ability to load and browse through the data. In the coming releases, the ability to modify the data (with locking), support for opening PPCS sources, and the coming tool for defining databases and tables will be added. The import/export tools are not yet integrated either. This integration will be a big part of the coming months, since the sbngpersonal.smp project will host most of the tools that you will use to create the various parts of your SIMPOL applications. Many of those tools already exist in some form, but are not yet ready to be fully integrated into the system. The form designer will get the remaining features in the near future, including a tools palette. Still, it is quite usable as is. When you have some controls selected, try the right-mouse button out.

To try out an existing Superbase form (not yet with detail blocks please), use the remote connections tool in SB 3.6i or later to share the data file(s). Then using the importppcs2sbme.smp import the PPCS-based Superbase data tables into SBME tables. At the beginning, it is recommended to put one table only in each container file. There are options for this in the tool. Then, export the form to XML using SBV2XML.SBP. Make sure that the *.sbm files and the *.sxf file for the form are in the same directory, and they should open up in the sbngpersonal.smp program immediately and be browsable. The forms should also be modifiable in the form designer. There is a sample that demonstrates how to work a bit with the dataform1 forms. It is called dataforms.smp and can be found in the examples directory.

The current release includes a fairly complete set of wxWidgets-based window, form, form control, and dialog objects. This does not include all possible wxWidgets components, by a far margin. Some more will be still added, but many will come in the releases down the road. The wxdialog objects can be either modal (like existing Superbase dialogs) or non-modal (more like an extra window that has no menu or toolbar and can’t be resized). When shown modally, there is a processmodal() method of the window that should be called. Just as with other process-type calls, it takes a timeout value so it can be closed automatically after a certain interval. I am sure that there are many of you who have wished this were possible in the past in your Superbase programs, when you had users who left dialogs up and then went to lunch or home (or on vacation). All of the common dialogs from UTUI are now available using the WXWN component, plus a number of new ones. The remaining common dialogs for Printer and Page Setup will be provided when the print architecture is added.

Currently, all of the wxWidgets components are only available for Win32, but we will be making them available for Linux, WinCE, and Mac OS-X eventually.

For tips and approaches to using the new forms, windows, and dialogs, see the demo in the forms directory and the various samples in the examples directory. The demo uses forms that are for the most part directly converted from the SBVs (created using the Superbase Classic form designer). The documentation in the Programmer’s Guide has not yet been updated to use the new forms, dialogs, and windows. That will come.

Documentation of the Form Designer and the SIMPOL Personal program as well as the dataform1 family of objects will be coming soon. Some of it should be fairly obvious, but if not, post questions on the news server at news://news.simpol.com in the sbng.programming.general group.

Pre-Release 3c-Specific Notes

This is an early release where not all of the changes are fully documented. It is primarily intended as an update to the existing SBME and PPSR database engine functionality, although there are some additional changes in the area of the wxformgrid control, though these will not be documented until the next release in a few weeks time. This release contains a vastly improved state of the single user and multi-user database engines, including accessing the multi-user engine from Superbase Classic as well as SIMPOL. The early test results are quite promising, showing the new SBME engine to be between 5 and 10 times faster than the current single user SBF engine. The multi-user engine using PPCS is roughly twice as fast from a Superbase-based (SBL) client and nearly four times faster from a SIMPOL-based client when compared to using SB Classic as the database server.

Pre-Release 3b-Specific Notes

This release includes toolbars, the new grid control, and the new wx-based common dialogs that replace the existing UTUI components: file open/save common dialog, directory picker, and message box. With this release there is now a minimal record
view client, together with a basic import/export tool. These tools are standalone programs currently, though it is expected that they will eventually be incorporated into an end-user personal database type of program. The import/export tools are not
currently optimized for speed, but they do work well enough to be useful. If you run into any problems with the tools please report them. The next release will also have a tool for creating database tables, plus the long-awaited data-aware form support.
The release after that should contain the initial form designer. The Language Reference has been updated to include the latest components, and for the first time now contains the information about the member operator (!) where it is supported.

Pre-Release 3a-Specific Notes

We have now added menus and bitmap buttons to the list of available GUI controls. In addition, there is a conversion program to convert menus from Superbase 3.x to SIMPOL source code. A large number of examples have been produced covering the
wxwindow, wxdialog, wxform, and the various form controls. The demo has been updated to account for the new capabilities. There are a few new and updated libraries, including a volatile file library. The lists library has been fairly heavily reworked. The Programmer’s Guide has been updated with a new chapter that covers the use of the wx-based GUI components. The older chapters covering window1 and form1 have been removed, and the samples are no longer shipped. With the next release, the libraries will no longer be shipped, so if you are using them for anything, please migrate to the wx-based components. There is also a new chapter in the Programmer’s Guide that briefly covers the supplied SIMPOL-language libraries. This chapter will be greatly fleshed out over time. The Reference Guide has also been updated with the latest documentation. A number of improvements have been made that greatly improve the efficiency of SIMPOL internally, so there has been a significant speed improvement in a number of areas, including the libxml.sml library.

Pre-Release 3-Specific Notes

Welcome to the 3rd pre-release of SIMPOL Professional and the SIMPOL programming language. There have been a number of important changes since the Pre-Release 2 series came out. Most significantly, all of the window1 and form1 controls have been deprecated in favour of the new wxwindow and wxform controls. In doing this we took a bit of a step backward, since we already had working window and form controls for Win32, but we also took a major step forward, since by choosing to use the wxWidgets cross-platform toolkit, we will have very little trouble getting all of the user interface components running on a number of different platforms, including Win64, Linux using GTK+, WinCE (PocketPC/Windows Mobile), and Mac OS-X. Currently you should still use the UTUI components for message boxes and the open and save file dialogs, but those will also be replaced with wx equivalents before too long. To make the use of these pieces easier, a new utility has been included that converts from the Superbase form to a wxform as source code. We will also soon be releasing a new version of our XML library with support for storing the new forms as XML and then loading them and displaying them directly in SIMPOL.

An important note about debugging. Currently debugging in the IDE using the forms and windows is torturously slow while waiting for the form to display. Also, often the variables window does not show anything in event handlers, though quick watch
normally works correctly. We are aware of this and are working to fix it quickly. We felt that it was more important to get a usable set of UI tools out to you than to delay even longer. For the best speed, run the programs from a command line (or
double-click on them using Explorer or equivalent.

What’s New

The current release includes our initial cut of wxWidgets-based window, form, form control, and dialog objects. These are not all complete, but there is enough there to get started. A significant change is that instead of calling a process() method of a window object, there is a wxprocess() function that processes all of the windows, and a companion wxbreak() that breaks out of the wxprocess() function call. The wxdialog objects can be either modal (like existing Superbase dialogs) or non-modal (more like an extra window that has no menu or toolbar and can’t be resized). When shown modally, there is a processmodal() method of the dialog that should be called. Just as with other process-type calls, it takes a timeout value so it can be closed automatically after a certain interval. I am sure that there are many of you who have wished this were possible in the past in your Superbase programs, when you had users who left dialogs up and then went to lunch or home (or on vacation).

Currently, all of the wxWidgets components are only available for Win32, but we will be making them available for Linux and WinCE relatively soon, and Mac OS-X somewhat later.

For tips and approaches to using the new forms, windows, and dialogs, see the demo in the forms directory. It uses forms that are for the most part directly converted from the SBVs (created using the Superbase Classic form designer). The documentation
in the Programmer’s Guide has not yet been updated to use the new forms, dialogs, and windows. That will come soon. Also, the associated source code examples still use the old windows and forms. These will also be updated when the documentation is changed (very soon!).

We have added a number of libraries (including source!) to the system. One in particular, the winfiledlg.sml is provided for making it easy to use the open and save file dialogs from Win32 from within the older Superbase product. There is also an example program provided in SBL. Other libraries are provided that may not be complete, but which are intended to host a specific style of functionality, such as the xmllib.sml.

We now have UTOS components (file system interrogation) for both Win32 and Linux.

There is a new SBP-based utility to convert SBVs to SIMPOL source code, called SBV2WXSM.SBP. To see it in action, look at the sample project called demo in the Projectsforms directory.

SIMPOL Professional Pre-Release 2 — Release Notes

This release was more-or-less “feature complete”. At this stage you were able to build some fairly sophisticated straight processing programs, programs that can be called from Superbase as DLL calls, CGI programs, and form-and-window based programs. Using this release those programs could incorporate database access using PPCS and SBME (single-user) and could communicate via TCP/IP using the tcpsocket objects using either Linux or Win32. The IDE was essentially complete. You could also debug CGI programs in the IDE, which greatly reduces the time to develop and debug sophisticated web server applications.

This release contained the first testing release of the new database engine. This is a testing release, so it has not had any speed optimization done to it yet. In spite of that, it seems to be reasonably fast. How fast we are still finding out.

What’s also useful to know (Pre-Release 2)

There are four online books, all of which are supplied in Windows HTML Help format (*.chm).

It is possible to call the user-interface pieces using SMEXEC32.DLL from Superbase Classic programs as long as the Superbase Classic program is running on Windows NT, 2000, or XP. This is not supported on Windows 9x (this is an operating system limitation, not us). See the new documentation and example projects for things to try out.

Expect fairly regular changes in the coming months and please give us feedback on your use of the product. The only way to build projects successfully is using the IDE. Although the IDE can generate make files, these cannot currently be used for
maintenance because of the changes required when we went to the component-based architecture. It is now necessary to select the components being used in your program in the Project->Settings dialog box. If these are not selected then the program may fail to work because the appropriate libraries will not be loaded. This was a necessary step to allow future components to be loaded when the program is loaded. This change pretty much requires you to work from the IDE in the future until some command line tools are built to account for these issues.

Library Code

There is a growing amount of library code that can be used in your programs. Currently most library code is provided as pre-compiled libraries and have an SML file that can be linked into your program. These files are found in the lib directory. The source code for the libraries (fully commented!) is in the projectslibs folder. An SML does not have a function
main(), but otherwise can be a complete program with constants, types, and functions. For functions and types to be visible outside of the SML module, they must be declared with the export keyword. In the Project->Settings menu there is a place to select the modules used in a project. These will be statically added to the resulting SMP in the bin directory of the project. As an alternative, they can be dynamically loaded using !loadmodulefile().

It is possible to use the SML (SIMPOL compiled library) for chunks of code that are common libraries. This will reduce how long your compile times take since if you use a module instead of adding it in as a source include, the module won’t be recompiled each time.

CGI-Specific Issues

In the project settings is a place to create additional targets. These targets (once defined) can also include (next to them) a shebang line. Win32 shebang lines are important for use with Apache on Win32 or under Linux, if using IIS, they are unnecessary (but won’t cause any trouble). With IIS, you have to set up the file extension in the server settings after which it will automatically invoke the correct program. At the end of the shebang line the appropriate new line character(s) must be include, and which should look like:

#!C:Program FilesSIMPOLbinsmpcgi32.exe{d}{a}

The {d}{a} is the same syntax as is used in SIMPOL itself in strings to represent non-printing characters (or characters not available on your keyboard) and is the carriage-return and linefeed characters. On Linux, only the linefeed should be used. Below is a typical Linux shebang line:

#!/usr/bin/smpcgi{a}

To enable the Server-Page style editing mode in a project, open the Project Settings dialog and click the CGI Project
checkbox. Then it is possible to add a server page below the Server Pages folder (right click->New Server Page). This file will have an extension of SMZ. When compiled, it will have the same root name with an SMU or SMA extension. The resulting file still needs to be included into the main program (unless you named it the same as the main program). In the SMZ file, you work just
like with ASP pages. You work in HTML (and can view it using the viewer button on the toolbar). The program code is in special comments, like that below:

<%'--------------------------------- begin code ---------------------------------
// hellocgi.sma - This is a simple Hello World program for SIMPOL Server Pages
//
// Author: Neil Robinson

constant CRLF "{d}{a}"

function main(cgicall cgi)
 string s

 cgi.output("Content-type: text/HTML" + CRLF + CRLF,1)
'--------------------------------- end code ---------------------------------%>

<HTML>
<BODY>
 Hello CGI World!!

<%'--------------------------------- begin code ---------------------------------
 cgi.output(cgi.getvariable("QUERY_STRING") + CRLF, 1)
'--------------------------------- end code ---------------------------------%>
</BODY>
</HTML>
<%'--------------------------------- begin code ---------------------------------
end function ""
'--------------------------------- end code ---------------------------------%>

The above program code is then compiled to the program shown below before it is compiled into the resulting program.

'--------------------------------- begin code ---------------------------------
// hellocgi.sma - This is a simple Hello World program for SIMPOL Server Pages
//
// Author: Neil Robinson

constant CRLF "{d}{a}"

function main(cgicall cgi)
string s

 cgi.output("Content-type: text/HTML"+ CRLF + CRLF,1)
'--------------------------------- end code ---------------------------------
 cgi.output(""+"{0D}{0A}",1)
 cgi.output("<HTML>"+"{0D}{0A}",1)
 cgi.output("<BODY>"+"{0D}{0A}",1)
 cgi.output(" Hello CGI World!!"+"{0D}{0A}",1)
 cgi.output(""+"{0D}{0A}",1)
'--------------------------------- begin code ---------------------------------
 cgi.output(cgi.getvariable("QUERY_STRING")+ CRLF,1)
'--------------------------------- end code ---------------------------------
 cgi.output("</BODY>"+"{0D}{0A}",1)
 cgi.output("</HTML>"+"{0D}{0A}",1)
'--------------------------------- begin code ---------------------------------
endfunction""
'--------------------------------- end code ---------------------------------

If you now wish to extend the program code, modify anything within the begin code and end code sections. When finished editing, right-click the program file in the project tree and select Regenerate Server Page. That will then rebuild the changes into the server page.

This design allows you to use the tools most appropriate for each portion of the server page. HTML syntax highlighting and preview for HTML coding and SIMPOL highlighting and intellisense-like features for SIMPOL coding.

CGI Debugging

To do this, use a shebang line like this if using Win9x:

#!/program files/simpol/bin/sbngide.exe /d{d}{a}

or this if using NT, 2000, or XP:

#!/program files/simpol/bin/sbngidecaller.exe{d}{a}

The first version will open the project in a new copy of the IDE and allow you to debug it. In order to return the final page to the web browser, it is necessary to close the new copy of the IDE. Also, the project is opened read-only.

The second version can use an existing copy of the IDE that is already running, so it will work in the same copy that you are working in. When the program finishes it is not necessary to close the IDE, the page is automatically passed back when the program ends.

Please note that the above instructions apply to using Apache on the local machine as a local web server for debugging purposes. Using IIS is possible but more complicated, since the association must be set up for the file name extension rather than being picked up from the file header as Apache does. Also, it is not possible to source-level debug ISAPI and Fast-CGI programs. It is best to debug them as CGI and then deploy in the other formats.

Currently debugging can also be done using the debug versions of the smprun32.exe and smpcgi32.exe programs, which will normally create a dump if the program exits with an error. If you run with the debug version of the CGI runtime then when an error occurs it creates a file called *.SLG in the same directory, which is very helpful since it contains the reconstructed source of the function where the error occurred and an arrow pointing at the line that caused the problem. It is still often helpful to use fsfileoutputstream to output information to a log file.

Constants

The syntax for a constant in SIMPOL is:

constant identifier "string"

or

contant identifier 1234

There is currently no support for decimal constants nor for negative constants. To place non-printing or other high Unicode characters into a constant use curly braces and hexadecimal values as follows:

constant crlf "{d}{a}"

or

constant CRLF "{d}{a}"

To enter a left curly brace use: "{{"

Gotchas

Whenever you start working with a new language you will hit a few things that are easy to forget. Here is a list of some of the one’s that we have already bumped up against:

  1. Many methods (most of the file access methods in fact) take an error object reference. If you don’t use it and you get an error, your program halts. You need to pass an initialized object, not just a variable name.
  2. When converting SBL code, watch out for = and ==. == is the test for equivalency. = is the assignment operator. There is a difference.
  3. Currently variables initialize to .nul. That is not the same as "" or 0, it means “no object”. In SIMPOL everything refers to either an object or .nul. An object can also have a value of .nul, this is different from having no object. The .nul and .inf are special values of their own, and if you add anything to it the result is also .nul or .inf, so if you forget to initialize a variable and your program acts funny, you will understand why! We intend eventually to make this an option that can be set in the IDE, so that you can decide what the various basic types initialize to at compile time.
  4. The backslash line continuation character works, even inside of strings, but only if it is the last non-whitespace character on the line prior to the end of line character. Also the backslash line continuation character does not apply if the line is a double slash comment. These are the only line-oriented features in the language.
  5. The date object has methods like dayinweek(). These items are methods, don’t forget the parentheses! Also, method and object names are case-sensitive, as are all features in SIMPOL!
  6. Watch out when looping around retrieving records. You not only have to test for an error value, you have to remember to stop at the error 1000010 (end of file) but not consider it an error.
  7. Retrieving a field value from a record via PPCS from a Superbase SBF file can still result in a return value of .nul, unlike with SBL. Make sure that you test for this anywhere that this is likely to happen and respond in the code accordingly.

Using the IDE

The IDE is fairly complete. Any problems using the IDE should be reported. The IDE does not print in color (but you can save the code off as HTML and print that in color). The editor supports a wide variety of file types including tokenized and ASCII SBL! There are numerous project-level features, see the IDE documentation for more information.

The basic approach using the IDE is to create a new project. This will ask you for a project name (to be entered into a directory browser). This will then create a directory of that name, inside that another directory of the same name (for the main module of the project), and inside that it will create a file (SMA or SMU depending on which version of the editor you are using) with the same name.

If you are using components, then you must add the components to your project before the type names will color code.

Make sure that you click the Save All button or menu item, otherwise your project changes will not be saved!

When your file includes other files (using the include directive) these will always show up below the file from which they were included when looking at the project tree. If a file can’t be found, because you haven’t set up the include section of the project settings, then an icon with a red line through it will appear next to the file.

See some of the examples that we are including and try the projects out.

Command Line Arguments

These are expected to be received by the main() function as strings. There is no practical limit on how many you can pass. If you pass numbers, you will need to convert them using the .toval() intrinsic function to an integer or a number before you can make much use of them.

Debugging

In addition to the source-level debugging provided by the IDE, there are command line utilities for console programs and CGI programs. The way they are used is to run your program using the appropriate debug version of the loader program. That means that for console programs you use SMPD1_32.EXE to run your program instead of SMPRUN32.EXE (on Linux you would use smpd1_ instead of smprun). For CGI programs you would use SMGD1_32.EXE instead of SMPCGI32.EXE (on Linux use smgd1_ instead of smpcgi).

When an error occurs, in the CGI environment the reconstructed source code of the function that is currently executing will be output to a file called <filename>.slg with an arrow indicating the line that has failed. If for some reason it hits a line it can’t reconstruct into source it will output a line of question marks. The line of source following this line is causing the problem so please send us just that line of source with a note about its failure to be handled. In the case of a console program the reconstructed source when an error occurs would look like this:

Running error typemismatch.smp string lv1  --->lv1 = 0x1  end function lv1 Elapsed time: 0.00 SMPOL error number 17 Finished

The original source was:

function main()  string s   s = 1 end function s

The names of the local variables are unknown to the program so it has to name them itself. It uses the convention of lv (local variable) and a number to enumerate the various variables. User-defined type names will be detected as will function names and built-in type names. This was the first step to providing a source-level debugger. We will eventually also provide a method of inhibiting this kind of dump in programs that are protected so that they can’t be cracked by people trying things like bad data to cause an error.

Program Comments

In SIMPOL, any L-Value that begins with a single-quote (‘) or a double-quote (“) character is considered to be a comment. It is technically a string, but since it is on the left rather than on the right of an assignment, it is assumed to be a comment. Also, strings do not have to be closed, the end of line will do that, just like in SBL or BASIC (this is still sloppy coding though 😉 ).

Also, any statement beginning with // will be considered a comment until end of line (backslash is not supported here as a line continuation character!). See also Ctrl-J and Ctrl-Shift-J in the IDE to comment and uncomment whole blocks!

Conclusion

Try things out. Explore. Most important, have fun! Any problems you hit should be discussed in the appropriate news group at news://news.simpol.com/simpol.*.

Neil Robinson

Technical Director

Simpol Limited

{V1.8 Release-Specific Notes}