Clarion

Three new properties:

PROP:TextLeftMargin and PROP:TextRightMargin

The PROP:TextLeftMargin, PROP:TextRightMargin properties get or set the value of left and right margins for text in ENTRY, SPIN, COMBO, TEXT, RTF controls and in drop-down LIST controls.  The problem we had was that the old (pre-C7) fixed margin of 2 pixels wasn’t always correct for some of the newer fonts and font sizes.  The original C7 implementation calculated margin values based upon the control’s type, its font, and where the control is placed; in a WINDOW or REPORT, and some additional aspects.  However the new default margins could be incorrect in some specific situations like one which was described in the PTSS where large font sizes were not displayed correctly in a Entry control.  These two new properties allow you to justify margins in all cases, and they allow you to set different values for the left and right margins.

Syntax:

?control {PROP:TextLeftMargin} = n
?control {PROP:TextRightMargin} = n

Where, n is an integer constant or expression greater or equal to 0.  It sets the margin using the current units of the WINDOW or REPORT that owns the the control.
Negative values are treated as follows:
a value of -1 : the RTL uses the Windows default margin value which is dependent upon the control’s font
for all other negative values :  the RTL uses the C7 default margin value which is very close to Windows default value but takes into account some additional aspects such as the control type

PROP:LastChanceHook

This is a new write-only SYSTEM property which allows you to specify the hook function invoked if an exception has occurred. The hook function allows you to display
information about the exception and choose an action:

• continue execution of the thread where exception occurred (if the exception isn’t fatal)
• stop the thread (or entire process if the exception occurred in the main process thread) without invoking the RTL exception handler
• execute the RTL exception handler

The RTL exception handler allows you to show information about the exception and asks for an action, possible actions:

• stop the thread where exception occurred
• stop the entire process
• invoke the system debugger
• generate a debug event if the program is already running under debugger

The implementation provides a far more intelligent way for handling program termination in case of some abnormal behavior then the existing ‘Do you want to GPF?” message.  It also allows you to set the exit code (error level) returned by the program to the OS upon program termination without the necessity to terminate the program immediately.

Summary; this allows end users to avoid having to terminate an entire program if some error occurred in one of its threads.

Clarion 7.1 introduces two new functions; FREEZE and UNFREEZE.  FREEZE/UNFREEZE are used in tandem to suppress redrawing while you adjust multiple attributes of a control. For example, you would typically call the FREEZE method, then set the Size, Location, Text, or Color properties of the control, and then call the  UNFREEZE method to enable the changes to take effect.  This can increase the performance of applications with many controls, and eliminate screen flicker when dynamically creating controls or adjusting their properties.

The syntax is:

FREEZE (SIGNED feq),SIGNED

FREEZE suspends redrawing of the control which is identified by the feq parameter.
The return value must be passed to a paired UNFREEZE.

UNFREEZE (SIGNED feq, SIGNED state)

This function resumes redrawing of the control previously suspended by FREEZE.
The second parameter is a value returned by last FREEZE for that control which has not been closed
by paired UNFREEZE.

Calls to FREEZE can be nested. Every such call must have its paired UNFREEZE,
for example:

x1# = FREEZE (feq)
…
x2# = FREEZE (feq)
…
UNFREEZE (feq, x2#)
…
UNFREEZE (feq, x1#)

FREEZE and UNFREEZE must be properly paired: if there isn’t a paired call to UNFREEZE for an executed FREEZE, the control cannot be redrawn. The UNFREEZE function forces redrawing of the control.

(note: FREEZE/UNFREEZE cannot be used for menu items)

We’ve added some new functionality to the IDE in support for precompling and publishing a web app.  As you know by default, ASP.NET dynamically parses and compiles any ASPX page when the first request is made for the page. The .Net runtime caches the compilation outputs and does not need to recompile again unless someone edits a file. This behavior brings us a good amount of flexibility, including the flexibility to change code and markup. and instantly see the changes reflected in the next browser request.  ASP.NET 2.0 introduced the option of precompiling your website. Precompling offers the following advantages :

• You do not need to deploy the source code to the server. The website is precompiled into binaries, which are then deployed to the server.
• It allows you to identify any bugs during compilation rather then opening each page
  
• The deployment process is a bit easier as all your aspx pages, user controls etc. are compiled into binaries.There are a few different ways you can precompile a website.

When you have an ASP.Net project open the IDE command “Build” only validates the project and puts the assemblies into the ASP.NET temporary folder.

The values you enter on the new MSBuild tab of the Propect Properties are valid if you want to build the project from the command line. So at a command prompt you use this syntax:

MSBuild <projectfile>.aspxproj /target:Msbuild /property:ClaNetBinPath=<Clarion.Net BIN folder>

Precompile and publish websites using the Clarion IDE

To precompile and publish your website using the IDE follow these steps:

1. Open your website project
2. In the Solution Explorer right-click on the Project and from the context menu choose “Publish Web Site”

3. You then get a Publish Web Site dialog like shown below where you can specify the path to publish. Clicking on the eplisis(…) lets you choose a folder.

4. Select your options in the dialog :

a. Allow this precompiled site to be updatable – This option allows you to change the markup and client side functionality of the .aspx pages.
b. Use Fixed Naming And Single Page Assemblies
c. Enable strong naming on precompiled assemblies – specifies that your assemblies are strong named using a key file or container.

5. Click Ok to compile and publish the website. (more…)

In the effort to theme and polish the appearance of all UI elements for 7.0 the Tooltip was missed, but for the 7.1 release Tooltips now get the OS style as
shown in this screenshot taken from Windows 7.

We’ve implemented a new feature for 7.1 .that allows for auto-save of an .App and recovery from a crashed system.
The way it works is like this:

• explicitly saved changes are written to both the in-memory database and to the new recovery file
• upon saving an .App the recovery file is emptied (truncating it’s size to 0)
• when an APP is closed the recovery file is deleted
• if the recovery file’s size exceeds the limit (as set in Application Options), then AppGen auto-saves the APP file to disk
• if AppGen finds a recovery file when opening an .App, and the recovery file is older then the .App file, and its size is > 0, the user is queried to recover the .App or to open the last saved .App.

Here’s the new application option:

In all cases a backup of the .App is made when its first opened (.Bpp extension)