Sailing with Xailer

Join to the xHarbour users list

2007-06-19T10:31:00.000-07:00

Today I found an interesting new link in xHarbour.org Open Source official web page: the brand new xHarbour Users list.

If you wish to join, leave your data in:

xHarbour.org users list

Only basic data is taken, and it's not shown in the panel list, so you can be confident about the spam stuff.

Changing the resource compiler.

2007-06-13T10:11:00.000-07:00

This article has been modified from its original spanish version. All references to other programming tools different of Xailer have been removed.

When working with Xailer, you probably have used the resource manager included in the IDE to handle the ImageList, Bitmaps, Icons, Cursors, etc.

Talking about resources, means that many of our visual appearance will be stored inside the own EXE file, this is a right and professional way to work because in other programming tools, all the visual interface came stored into a DLL.

In Xailer, all the resources are stored into a .RC file, which is created using the resource manager included in the IDE, this resource manager only handle the names of the resources, but doesn't let you "edit" them, (you will need an external tool), and then, during the application building process these resources are "compiled" and then linked into the final EXE file.

.RC files are like source code, in fact a .RC files is a text file, and, just the way we do with other source code, these .RC file must be compiled, the result of the compilation of a .RC file is a .RES file, equivalent to a .OBJ file in other programming languages, this .RES file will be linked into the .EXE as any other .OBJ file so the linker does this final step.

Since Xailer uses the Borland C++ 5.5, it comes with a "resource compiler" included, the name of the file is BRC32.EXE, in the \bin directory of the Borland C++ installation, the Xailer's building process uses this compiler to become the .RC files into .RES files, to let the ILINK32.EXE (also a Borland C++ component) do the rest of the job generating the final EXE.

The problem here is that BRC32.EXE in not a good choice when having huge resource files, or such .RC files are using big image files or have bitmaps with millions of colours, when this happens, the BRC32.EXE simply cannot compile the .RC file.

How to solve this problem ?

Easy, just change the resource compiler, obvious, but....

What resource compiler should I use ?

During my last trip to Spain in May 2007, I was talking with Bingen about this and he suggested me to use the Pelles C resource compiler, this is a free C compiler and its resource compiler works great with huge .RC files and with complex bitmaps that cannot be handled by the Borland C++ resource compiler.

The name of the resource compiler of Pelles C is PORC.EXE, it comes along with a PORC.DLL needed in order to compile our resurces, it works exactly the same way of the BRC32.EXE, so you don't need to change anything in the way you currently work, but the name of the compiler, instead of using the BRC32.EXE you will use the PORC.EXE and you are done, since the PORC uses the same compilation switches you don't need to change anything else.

Where to get it ?, dowload it from Pelles C download center, I do suggest to download the ZIP file, go to the second section of the page, where says Executables and Help. The zip is the suggested format because we don't need the full Pelles Installation, just the resource compiler. Using WinZip, WinRar search into the ZIP file and look for these two files :PORC.EXE & PORC.DLL, extract them in any directory in your hard drive.

To use them with Xailer, the fastest and easy way:

1) Copy the PORC.EXE and PORC.DLL into the \Xailer\bin directory
2) Open the Xailer's IDE, select Tools / Options... and you will see this form, select into the tree structure Resource Compiler into Directories section:

Select Use this compiler, set the path where PORC.EXE is (in my case \Xailer\bin) and that's all, it's no needed to touch the compilation flags, since they are the same for PORC and for BRC32.

4) From the Xailer's IDE open your project, and now BUILD (Alt+F9) the project, in order to recompile the resource file, is everything is ok, you will get a new EXE file without any problem.

During my test with Xailer, I faced a little problem, PORC was not generating the .RES file (the error the IDE will show is "cannot open FILE.RES", but the error will be shown until linking time), what was the cause ?, well, I have been working with Xailer since early versions, and in those early versions, the resource manager used to add a comment header at the top of the .RC file, this comment header had ";" as the comment indicator, which is not recognized by PORC as a valid comment operator, so, when it tried to compile, a syntax error occured, unfortunately, this error is not shown in the Xailer's compiling window, so you cannot trap it at the first time, after a little research the simply solution was to edit the old .RC file, change the ";" by the typical /*...*/ and all solved all my resources were compiled as expected.

Using this simply technical trick you will have a free yet powerful resource compiler and you will be able to handle bitmaps of any size or amount of colours.

I love OCX

2007-02-12T17:57:00.000-08:00

During these last days I've working with the OCX and ActiveX issue using Xailer, Visual xHarbour (finally I found where de ActiveX support is), FreeWin and FiveWin, because I'm preparing our Xailer's Advanced Course, and we are going to see ActiveX in deep in May.

Sufing the Internet and as mentioned in the FiveWin News Group, I found these nice ActiveX controls by CodeJock Software, I just have a single word to describe them... IMPRESIVE, but not cheap: $ 575.00 USD for the Xtreme ToolKit, which includes 9 fancy controls, with 1 single user license.

Documentation for these product is absolutly commited to be used under Visual Basic, fortunatly the documentation is complete talking about Property, Events, Methods, Enumerations and all other objects contained as control's data, you will also find source code samples and if you are fluent with OOP in xHarbour you will have them working with your favorite GUI in short time.

The controls included in the Xtreme ToolKit are:

Full OutLook Calendar, 100% customizeable, with hundreds of components that let you give your application a complete "day plannig" features for example for agendas, personal timing and planning, etc.

Command Bar, Office Style, you can place anything you want in these toolbars, including menus, so you can move, resize, change position, float them, etc. this control includes also the world famous Office 2007 Ribbon bar:

Docking Pane: These "movable panels" are gorgeous, the suite also includes a "bonus" control, the TAB Control to substitute the typical XP Folders, these folders features multiline tabs, and the tabs can be horizotals or verticals:

PropertyGrid: These is a "property browse" you can set your main Categories and then add sub-categories, and movable sections that open and closes, something similar to the Xailer or Visual xHarbour Object Inspector.

You are going to love the Report control, this is a data browse that supports millons of data lines, the difference with other browses you will find is that not only the columns are cutomizables but THE ROWS also can be !, you can have a several rows for each data register, these row can be "shrinkable" or "expandable" can hold images, actions, etc, etc, etc. This control can also "connect" itself to a SQL Server or MySQL database to retrieve data, ah ! by the way, you can also print the data, that's why is called "Report".

Shortcut Bar: just like the Outlook bar, very easy to customize, and if you place it inside a Xailer panel, looks great ! (download the sample at the end of this article).

Skin: Have you ever wanted to ge the rid off those boring Windows XP themes, and go for something more "cool" for your interface ???, now is your chance, using the "skin" control, which adds independent skins to your Windows or Dialogs, these themed windows are independent of the themes you are using, the skins will also work under Windows 98 or NT so you will have different windows for your application.

Task Panel: For the most of us working with Xailer, this control is native, but if we are working with other GUIs give them a try to include Explorer Bars for a great look.

These controls are compatible with the all the xHarbour compatible GUIs, the easy way to use them is with Xailer or with Visual xHarbour, because both have an "import Activex" tool include in the IDE, and to be honest, with two clicks under Xailer and you will get a .PRG file with a class source code to call the OCX control of your choice, and the header file (.CH) with all the "Enumerations" (predefined constants) needed to use the control.

The classes created, along with che CH file, lets you to instance the control and place it into any Xailer form using the OnInitialize event, this saves you a bunch to coding time.

Sorry to mention, no ofence, but you will find hard to use these tools under FiveWin, starting with the OCX support, limited to version 2.6 and greater (don't worry if you have an early version, keep reading).

The main problem with FWH and these OCX is the documentation, in this case, the documentation doesn't have an apendix with the numeric value of the "enumerations" needed to make the control work with FiveWin, you will need an external tool, such as DLL Explorer to get the numeric values, and on the other hand, there are certain events in the controls that FiveWin cannot handle in a proper way, so, my best advice is ......

To use FreeWin !, if you have an earlier version of FiveWin 2.6, you can use these controls in your program, download from the FreeWin's web site the OCX Support (you can use it also with FW 2.6 and upper, replacing the native FiveWin's OCX support), this is the easiest way to squeeze all the power of these OCX because the Oskar Lira OCX support handles in a very easy way, yet elegant all the control's event stuff, is by far superior to FiveWin's.

I have written a tiny Xailer project, so you can look by yourself these controls full in action, to test them you need:

* Xailer 1.2b (obviously)
* xHarbour compatible with Xailer 1.2
* To install the CodeJock OCX that you may download from de www.codejock.com, section Downloads, download the ActiveX version, and forget about .NET.

Due to the lack of time, I couldn't write a sample for every control in the suite, but I think that with these samples you will have a good idea of how easy is to create professional good looking applications using this OCX.

You can download the project clicking here I have included the EXE also just in case you don't have Xailer at hand, but remember, you will need to have the CodeJock OCX installed to see the demo in action.

Fancy predefined messages in Xailer

2007-01-11T18:03:00.000-08:00

(original post in: www.mundoxbase.info)

Bingen Ulgadebere, a fine and skilled Xailer programmer, has developed this nice set of functions for "messaging" under Xailer.

This set of functions contains several "message" functions all commited to display messages using Xailer forms, for example: splash forms to show logos or images, giant tooltips using a form, messages for entering a single value (string, numeric, logical, date), messages to show while you are perfoming a task (something like ... "processing, please wait").

There two nice functions I liked the most: first, the message with a "blinking" header in the form, and second, the "messagin" system that lets you send messages across the network to other users using the same application, pretty nice stuff.

You can download the Xailer project along with source code and EXE sample clicking here

Xailer goes OCX

2006-11-16T14:01:00.000-08:00

This week programming stuff has gone tooooo fast, less than 24 hours ago, I was writting, in other blog, about FreeWin's ActiveX implementation, and some minutes ago I was informed that Xailier had "officially" released the OCX (ActiveX) support, complete, along with event handling.

The sample written by Ignacio and José is quite impressive, just for a "little technical detail", I will write about it later on, but this issue is not Xailer's fault, it's Adobe Reader's.

Just started the sample program and It will keep you mouth open, what about your very own web browser embeded in you application, with tab support, just the way Internet Explorer 7 ? .

(click in the images to enlarge)

Let's go on with the samples, and now we find the RMChart OCX implementation, to build nice bussiness graphics. This OCX is absolutly free and you can download it from www.rmchart.com, the results leave your mouth open:

And finally, just to spread your opened mouth to the floor, what about a nice FLASH animation running in your own Xailer's Window:

So far so good, the only issue I found in the demo is with the PDF sample, it doesn't work and the application crashes with a GPF, it all seems that there's some problem with the configuration of the Adobe Reader 7, that crashes de application, but if you use a lower release, like version 5, the sample will run as expected.

If you want to try it by yourself, you can download it clicking here. You will need to install the RMChart OCX before running the application, if not, the programm will crash, you can download it from www.rmchart.com. The sample includes the Xailer Project along with the compiled EXE in order to rebuild it you will need Xailer 1.1a and the special version of xHarbour for Xailer, both are available in Xailer's web page (www.xailer.com)

And now, let's sit to see what the other guis have to say to impress us.

Business Graphics in Xailer

2006-10-12T10:38:00.000-07:00

[Original post by Freddy in Mundo Xbase]

Today I want to show you the integration between Xailer (using TOleAuto) with the ChartDirector library, this will let us give our applications, in an easy way, real professional business graphics.

ChartDirector is a commercial library with a relative low price, between $99 for an individual licence to $499 for the free distribution library that will let us to integrate CharDirector in our exe files.

You can also get a demo version, limited by a little publicity line at the bottom of the graphic, this version is useful for testing and learning the use of the library.

With CharDirector we can create from simple pie graphics, to very complex Gantt diagrams, radar, financial, meter, dispersion, paretto, polars, combined graphics, etc...

If you want to give it a try, the first step will be download the demo version from: http://www.advsofteng.com/download.html

You have to download the ChartDirector for ASP/COM/VB

Once installed we are ready to use it with Xailer.

Before going on, it's important to make clear what does ChartDirector really do.

ChartDirector simply convert to a graphic image (jpg, gif or png) a code given by us from within our program. This feature, let us handle with Xailer the obtained result, putting it into a form using a TImage control, or printing it in a report, or save a log of the generated graphics, you only have to give a name to every single file.

To integrate the graphic in one of our forms, we only have to pick a TImage control from the IDE toolbar, and drop it into the form, later, in the code, we can associate the control to the graphic file created with ChartDirector, let's check the following sample:

You can download this sample, clicking here

Programming in Xailer... without any idea at all

2006-08-19T07:35:00.000-07:00

Some days ago, I was talking with Ignacio Ortiz de Zuñiga about Xailer development as a product and the comments in the news gorups, and we both noticed one thing: Xailer is being used with pretty much success by programmers that don't have any idea or have very little experience in Xbase programming, most of them with no idea at all of object oriented programming.

I've been in touch with 3 of theses cases, the first is a Spanish friend of mine, good Paco Viruete, he had developed some applications in Xailer for the RENFE (the spanish trains company), with very little or not effort at all. Congrats Paco !

The second case is closer to me, another good friend, and coleague Pepe Lutrillo, we meet each other more than 10 years ago, in those good Clipper for DOS times.

Pepe left the programming stuff for a very long time, he moved into another IT branch, not exactly programming, but he is a very skillful Clipperhead, and some time ago he decided to come back to the programmer's world and created Gal4Win, an accounting program for Art Galleries, fully created with Xailer:

(click over the image to enlarge)

I have already meet the third, and most notorious case, from my point of view. This week I've been working in the city of Satillo, in the mexican state of Coahuila, giving a Database Design Introducction Seminar for the Health and Sanity Departament of the State Goverment , invited by my friend Oscar de la Peña, and by the way, I went to visit my coleagues of APSI (www.apsi.com.mx), they developed the best payroll software for Mexico, and there I meet Margarita.

Margarita es the new programmer in APSI, a great cotratation of Armando Garcia, the owner of the company, who has a very good eye to choose his employees.

These last 5 evenings I've been working with Cinthya and Margarita, who comes from the Visual Basic world, so, she knows the way to the Windows programming, she always had used an IDE, and she had always handled data with SQL and she had never "used" a DBF file, doesn't know a thing of CDX or code blocks, however, she had created a Xailer Program.... in less than 8 weeks !!!!!

The brand new product of the APSI family, created by Cinthya and Margarita is named APSI-Capa, and was developed to manage all the training courses given to the employees of a company, it's fully written in Xailer, using Microsoft SQL Server, and all the reports are developed using Crystal Reports.

Data handling is made with DataSets and DataControls, (in fact, Margarita doesn't know that there's a DBF behind de scene), the user inteface along with the reports are pretty well designed.

Here some images, say more than 1000 worlds.

(click on the image to enlarge)

Belive it or not, this software was created in less than 2 months and it's fully functional, one thing I've noticed, is that people that don't have the influence of other Xbase programming, gets addapted faster to the Xailer's way of work, however, I had also noticed that FiveWin programmers take more time to get adapted to Xailer because the have to change the way of thinking, they try to solve the problems in the old way, without notice that Xailer has a lot of tools to do the same things in an easier way.

Definitly, it looks that Xailer can become in a great programming tool not only for the Clipper or Xbase programmer, but all the others having experience in other IDE based programming tools, without having any idea of Xbase.

Windows Vista, new guidelines for the user interface

2006-08-08T16:55:00.000-07:00

Today I was making my weekly blogs review, and I found an article in Ave Mundi, that took me through a comment by Manu Calero, to the MSDN home page, and I found an article that sets the new guidelines to follow to be coherent with the new Windows Vista interface.

Here the link:

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/UxGuide/UXGuide/Principles/TopViolations/TopViolations.asp

More than a "guide" itself, this page shows things you have to avoid when you are writing a program to be ran under Windows Vista.

The first suggestion of MSDN is to read this article: Top Rules for the Windows Vista User Experience there you will find 12 simple rules about how to create a user interface in a compatible way with Windows Vista.

After reading this article, we can go to the "Controls" section, here we'll find which are new controls for Windows Vista, and how we should show these controls to the user, the "old" controls are also included in this review.

This guide also has a Text section, this section explains the way we should give instructions to the user in the screen, and the "tone" we should use in our text in order to make them more comprehensive to the final user.

This full featured guide offers also topic related to Windows and Dialogs design, error and warning messages, and also about the use of icons and images.

It really worth the time to give a look to it in order to be prepare in the way we should be programming in a very near future, Windows Vista will be hitting the road in a very short time.

Xailer does Crystal Reports

2006-06-21T14:40:00.000-07:00

Xailer's users had asked for Crystal Reports conectivity, because this report designer is one of the most used tools used by thousands of programmers around the world.

For FiveWin Tom Groeger wrote a class that highly ease the use of the Crystal Reports Print Engine (CRPE), this class is built using wrappers to the functions contained in the CRPE32.DLL.

This class works superb under 16 bits FiveWin, and with some minor modifications, I made it work under FiveWin Harbour 32 bits.

When I started to work with Xailer, I tried to make Tom's class to work the same way it worked with FiveWin, but I had a bunch of issues, regarding structures and with the preview window, so I gave up for a while.

A couple of days ago, I decided to go back to the problem, but this time, instead of struggling with wrappers, structures and trying to adapt a FW class, I stated from zero, and use something more simple: OLE. Since CRPE is an OLE server, you can easly use it form within xHarbour.

I tought that the thing was going to be easy, and it really was, 3 lines of code in the OnInitialize event of a From, and I had working the CRPE inside a Xailer form.... well, not too fast, there was "something" bugging me that made the preview window appear and desappear as soon as it was created. These are the original 3 lines of code:

oCrystal := TOleAuto():New( "Crystal.CRPE.Application" )
oCRReport := oCrystal:OpenReport( ".\impagen.rpt" )
oCRReport:Preview( "", 0, 0, 0, 0)

So I went to the Xailer Newgroup and posted a message about the issue and Jose Gimenez, fast as lighting bolt found that "something" I was missing. What was happening ?. Well in the code below, oCrystal and oCRReport were declared as LOCAL variables in the OnInitialize event, and when the form was displayed, the form simply desapeared because the local variables were losing its values.

Jose's solution was yet elegant: He created a TCrystalPreview class inherited form TForm, he also made my local variables datas of the class, so their values never lost themselves as long as the form is "alive".

Does it works ???... take a look:

The Crystal preview can work as a form, as a dialog or as MDI child window, all due the versatility of the Xailer's TForm class.

You can download the project clicking here. This project also includes the .RPT file, but you may have problems with it because of the database file, however you can try the sample changing the report name and using one created by you.

Working Crystal as an OLE object we get a lot of features to contol Crystal Reports, what is important, is to have the documentation of the COM componente, you can download the help files clicking here.

Xailer scores again !!!, now you can design your reports in Crystal, and make them work with Xailer in a very easy way.

A little of Xailer without using the IDE

2006-04-28T15:44:00.000-07:00

Original post by Rene Flores

I'm about to finish my first application fully written with XAILER, and, to be honest, I like it a lot !

Apart of how nice is the application, I'm very surprised on how you avoid a lot of "hard coding job" using the Xailer's IDE, saving you to write hundreds and hundreds of source code lines, that thanks to the IDE you don´t have to write them by yourself, specially talking about Textbox validations ("Gets" talking in Xbase) that I'm using a lot.

However there are certain things that you cannot do with the IDE, like the following programming challenge.

For my application (an accounting program) I needed a form with a folder, this is the easy part, but the folder had to have a variable number of tabs, (not more than 13), you can have 2, 3, 10 or 13 tabs, you really don't know how many tabs will the folder have, this value comes from an internal calculation, inside of the tab, I had to put a DBFBrowse along with a StatusBar, and here is where the challenge started.

To be aware on how Xailer creates the forms, my frist attempt was to create a form, using the IDE, drop a folder in, and add some tabs, all using the visual designer, I saved the form and then I opened the XFM file, this file is where Xailer storages all the from creation stuff, and here is where I found what I was looking for.

My first challenge was to make the folder to have a dinamic number of tabs, you cannot use the IDE for this task because you always have to indicate a fixed number of tabs, so far so good, What I did, was to create a MDI form, and just dropped a ToolBar inside:

The rest of the code was hand written, but believe me, it was too simple if you know a little bit about how Xailer builds controls.

First, I added a FOLDER component in the class definition, I wrote this directly in the source code:

CLASS Polizas FROM TForm

COMPONENT oReBar1
COMPONENT oFolderPolizas

DATA aFolderPages AS ARRAY(13)
.....
....
....

I wasn't able to create the folder in the IDE (just the folder, without tabs), and after that, add new tabs, for example in the ON INITIALIZE event, no way, because at the moment of creation, a call to the method ::Create() is done, and after that call you cannot manipulate the control anymore, later on, you will notice why the ::Create() method is so important.

After noticed that, I decided to use the ON INITIALIZE event, and write the code to build the folder, along with the needed tabs.

WITH OBJECT ::oFolderPolizas := TFolder():New( Self )
:SetBounds( 64, 44, 200, 160 )
FOR nContador := 1 TO LEN(aTitulos)
WITH OBJECT ::aFolderPages[nContador] := TFolderPage():New(::oFolderPolizas)
:cText := aTitulos[nContador]
:Create()
END
NEXT
:nAlign := alCLIENT
:nIndex := 1
:Create()
END

Let´s take a look into the code:

First, we need to instance the Folder objet, the call to ::SetBounds() is not really needed because later on we'll call the ::nAlign, once created the folder, we need to add the tabs, this is where fun begins, the number of tabs is stored in the aTitulos array, in this way, we can fill the array with the needed tab's titles and I will get the exact numbers of tabs I want.

Since the tabs creation is dynamic, I needed some way to make reference to them later. IF I had created the tabs in the IDE, the IDE had given them a variable name such "oFolderPage1, oFolderPage2...." etc. So, I noticed that it was easier and faster to create a new data in the class called aFolderPages, to store the pages in every element of the array instead of having 13 diffent data names.

There's something very important you should notice about Xailer's controls, and maybe this is one of the most confused terms related to the controls manipulation, the so called ::Create() method, which is the one that creates the control. In my firsts attemps to solve my problem, right after to instance the folder, I was calling the ::Create() method, and after that, I added the tabs.... WRONG !!!!, you have to instance the folder first, then add the tabs (you need to call the ::create() method of the tabs neither), and right after adding all the tabs you need, you have to call the ::Create() method of the folder, as you can notice in the previous code snipet.

Finally, and to make the folder fit in the client area of the form, the data ::nAlign is asigned to alCLIENT, so, when we change the form size, the control adjust itself to its container.

Done, now I have my dynamic folder, and now.... how can I include more controls ?, I needed a DBFBrowse and a Statusbar inside every tab, so in the same way I built the folder and its tabs, the same way I used to create the browses and the the status bars, using a FOR:

FOR nContador := 1 TO LEN(aTitulos)
WITH OBJECT ::aStatusBar[nContador]:=TStatusBar():New(::aFolderPages[nContador])
:SetBounds( 0, 243, 442, 22 )
:cText := "Total de pólizas: ";
+ALLTRIM(STR((aPublics[nContador+10])->(AdsKeyCount())))
:Create()
END
WITH OBJECT ::aBrowPoli[nContador]:= TDbfBrowse():New(::aFolderPages[nContador])
:SetBounds( 0, 0, 350, 166 )
:nAlign := alCLIENT
:nColDividerStyle := blFORECOLOR
:nMarqueeStyle := bmHIGHLROW
:lAllowEdit := .F.
:lAllowColSwapping := .F.
:lAllowColHiding := .F.
:lRecordSelector := .F.
:Create()
:SetDbf(aPublics[nContador+10],;
{"numpoli2","tipopoli2","fecha","concepto","total"})
:lFooter := .T.
nSuma := 0
(aPublics[nContador+10])->(DBGOTOP())
(aPublics[nContador+10])->(DBEVAL({|| nSuma += total}))
(aPublics[nContador+10])->(DBGOTOP())
:aCols[5]:cFooter := TRANSFORM(nSuma,"999,999,999.99")
:OnDblClick := "PoliDeta"
END
NEXT

Why did I create the folder and the tabs and then the DBFBrowse and the StatusBar ?, Can you do it in single step ?, That was what I tought the first time, because if in a single FOR-NEXT I could build all the needed controls, I save time.... really ?... no way man, and here comes the ::Create() method again. In order to add new controls to the tab, the tab has to exist, this may seen obvious because we have created the tab and called its ::Create method, but... YOU CANNOT ADD NEW CONTROLS, because the tab is not really created, the tab is created and exists as soon as its container is created, in this case the folder is not created until all the need tabs have been added. The fastest way to solve this problem is to have two separate routines, one to create the folder and the tab, and other to create the DBFBrowse and the Status bar.

Please notice: In Xailer you have to create the controls in the order you are going to need them at run time, first, because they use a determined area inside the client are of its container, and second, because the creation order will be the same order for TABSTOP, in my case, first I created the Staus bar, and after that, the DBFBrowse for every tab, you cannot do it in different order because at the moment of displaying the form the DBFBrowse will be painted OVER the StatusBar, so the bar will be hidden behind the browse until you resize the form.

To create the browse was a breeze, at the begining of my program I defined a PUBLIC array with all the alias of all the databases used in muy program, so I asigned the alias to the browse in a very fast way. Why didn't I used a DataSet... well my knowlege of DataSets was very poor, so I decided go into Xailer using the old Clipper style for database handling.

Finally I needed a footer in the browse with the sum of all the movements of the documents, so, once again, "a la Clipper", a DBEVAL() and a codeblock made the job.

The result is superb:

For a full size image, click over them.

This was one of my first Xailer challenges, and I really solved very fast, just a little of study of the product, some experiments and here is the result. To be honest, the programming in Xailer likes me a lot.

Advanced Xailer Techniques, The application starting code (I)

2006-03-27T14:52:00.000-08:00

[Original post by José F. Giménez]

When we are working with Xailer, the most common thing we do is to crete a project, then create a main form. This creates two source code modules, one with the same project name and other with a different name, given by us, when saving the file.

/*
* Proyecto: Ejemplo1
* Fichero: Ejemplo1.prg
* Descripción: Módulo de entrada a la aplicación
* Autor:
* Fecha: 13/10/2005
*/

#include "Xailer.ch"

//-------------------------------------------------------

Procedure Main()

 Application:cTitle :="Ejemplo1"
 Application:oIcon :="Icono1"
 TForm1():New( Application ):Show()
 Application:Run()

Return

//-------------------------------------------------------

As you can see, this function (procedure) just assign some properties to the Application object, the main form is created and shown, and finally, the call toApplication:Run(), starts the program's message loop.

This code is created by the IDE, adding, removing or changing lines when ever we make a change in the project's configuration. But, some times, you may not be interested on create and show a form, may be you could be interested on write the starting code by yourself. If you try and change the code by hand, the IDE will change it, undoing all our written code.

What can we do then ?, well, the solution is as simple as to write another function, after the MAIN() with the source code we want, after that simply change the main module in the project properties, setting the new created function as the new main module, from this point, the Xailer's ID will change the line which creates and show the form for a call to our function, like this:

/*
* Proyecto: Ejemplo1
* Fichero: Ejemplo1.prg
* Descripción: Módulo de entrada a la aplicación
* Autor:
* Fecha: 13/10/2005
*/

#include "Xailer.ch"

//-------------------------------------------------------

Procedure Main()

 Application:cTitle :="Ejemplo1"
 Application:oIcon :="Icono1"
 Empezar()
 Application:Run()

Return

//-------------------------------------------------------

Procedure Empezar()
Return

//-------------------------------------------------------

Now we can write the code we want, for example to show a "splash" window (the one that holds an image), may be we can use this function to load values from a INI file, show a dialog for the user and password, etc. and after all of that, show the main form, if it exist.

In the next article you will see how easy this task can be perform and you will a "live" simple example.

Advanced Xailer Techniques, The Application starting code (II)

2006-03-25T10:05:00.000-08:00

[Original post by José F. Giménez]

In the previous article we studied how to change the starting code of a Xailer application, in order to execute a function where we can do anything we want. Now we're going to see what stuff should we put inside that function, to show an entry window, at the same time that the program's main Window is shown, also, and before letting the user go into the main Window, we'll show the typical validation Window, you know, the one that asks for the user name and the password.

For the entry windows, the easier way is to create a form (called TEntrada) set its property nBorderStyle to bsSPLASH. Then choose a nice image, place inside the form, and rezise the form to fit the image's size (no image is included in the sample file). Now we need that this form be shown and removed few seconds later (let's say 4). To do so, just add a TTimer component into the form, set the nInvertval := 4000 (milisecs), lEnabled := .T., and write the event OnTimer, that looks like this:

METHOD Timer1Timer( oSender ) CLASS TEntrada

  ::Close()

RETURN Nil

For the main form, in this sample, we are going to use a single form, without any control or component inside (TPrincipal) with its property nShowMode := smMAXIMIZE. Now let's write the Empezar() function, we will place this function (procedure) in our program's entry module, just as we studied in the previous article:

Procedure Empezar()

  TEntrada():New( Application ):Show()
  TPrincipal():New( Application ):Show()

Return

If we compile an run this program, now we can see that the entry window shows itself and right after, the main window is shown, but thanks to the bsSPLASH style, the entry window remains on top, and after 4 seconds it closes itself.

A single detail is missing.... you may think: "ok, but as long as the entry window is runing, the user can do anything in the main window", you are right. We are going to solve this little "issue", but first, we are going to add a third window to get the user name and the password.

For this third windows, the style will be nBorderSyle := bsDIALOG, and we are going to place the need controls to get the user name and the password, 2 Tlabel objects, 2 TEdit objects and 2 TButton objects, one for "OK" and one for "Cancel"

Please notice that the "Ok" button has the properties lDefault := .T. and nModalResult := mrOK, and the "Cancel" button has the property lCancel := .T.

Also the "Ok" button will this in its OnClick event:

METHOD Button1Click( oSender ) CLASS TIdentificacion

RETURN ::oEdit1:Value == "User" .AND.;
      ::oEdit2:Value == "Password"

As you can see, the only thing done is to return .T. if you write "User" and "Password" in the TEdit boxes, .F. is returned if you miss with one of these words. Now we just have to modify the Empezar() function (procedure):

Procedure Empezar()

  LOCAL oEntrada

  oEntrada := TEntrada():New( Application )
  oEntrada:Show()

  TPrincipal():New( Application ):Show()
  oEntrada:ShowModal()

  IF TIdentificacion():New( Application ):ShowModal() != mrOK
     Application:oMainForm:Close()
  ENDIF

Return

Ok, here comes the magic, be very very aware on what's going on here: First oEntrada is shown, right after, the main window, TPrincipal, is shown, both are been shown at the same time, and, as explained before, the oEntrada remains on top due to the bsSPLASH style, but the insteresting thing comes right afte the call to TPrincipal:New(Application):Show(), the oEntrada window is shown AGAIN, well this is not really truth, in spite the call to the oEntrada:ShowModal(), which it supposes to show the entry window again, what it really does, is to change the show style of the entry window into a MODAL style, the entry window is not shown twice, as you may suppose, just the showing style is changed, from no-modal, to modal, this avoids the user to take control of the main window, until the entry screen closes.

But.... what about the Identification dialog ?, well, please notice that AFTER changing the style of the entry window from non-modal, to modal, in the very next line, the TIdentificacion:New(Application):ShowModal() is launched, this means that right after the entry window closes itself (4 seconds), the new window will appear, asking for user name and password and as it has the Modal style set, the user still won't be able of touch the main window until he gives the proper data. Once pressed the OK button and if the data is correct, the main window will catch the focus.

That's all by now, as you can see, is very easy to control the application start in Xailer, and you don't have to write almost any line of code.

The project source can be downloaded from here

Advanced Xailer Techniques: X classes and T classes

2006-03-24T09:15:00.000-08:00

[Original post by José F. Gímenez]

Many of you know that Xailer's class hierarchy is extensive and it also has the most of the classes duplicated in "X" classes and "T" classes, basically the class hierarchy is something like this:

XComponent -> TComponent -> XWinObject -> TWinObject ->
XControl -> TControl -> etc.

In the class hierarchy published in the help file this duality is not shown, you will only see the "T" classes, but the "X" classes also exist and they are the ones that hold all the code, so the "T" classes remain absoluty empty. For example, the TControl class is declared like this:

CLASS TControl FROM XControl
ENDCLASS

Now what ?, why do we want to have duplicated classes ?, what's the goal with this ?

If you don't know how to take advantage of this feature, this can be useless. But, as you will see as follows, it has enormous benefits.

In the past, I used to develop my windows applications with a well-known xBase library that you may already known and use. You also know that under this well-known-library if you want to correct a bug, modify certain behave of a control or perform any other modification, you must to work modifiying the original class source code, and then include the modified source in your list of .PRG files, or compile the code into an OBJ, and place it inside the original LIB o inside any other library, all a mess. At the end I had a library of patches as big as the original lib, and whenever a new release of the original library came, I was scared.

Using X classes and T classes you don't have to worry. Let's suppose that the SetSel() method of the TEdit class has a bug, to correct it, we just have to add the correction in any module of our application (or in a library of our own):

CLASS TEdit FROM XEdit
  METHOD SetSel( nStart, nEnd ) INLINE ;
         ::SendMsg( EM_SETSEL, nStart, nEnd )
ENDCLASS

That's all. If you notice, we just simply had declared a new class TEdit inherited from XEdit, and in this new class we had overwritten SetSel() method with a new corrected version. We don't need the original source of the class, either with any new release, nor we have a lot of stand alone modules with corrections.

This feature can be taken far away, not only for bug correction. Now let's suppose we want that all the Edit controls of our app were shown in yellow background when catching the focus, of course you can modify the nClrPaneFocus property of every single Edit control (a damn ammount of job). But it's easier to apply this techinique this way:

CLASS TEdit FROM XEdit
  PROPERTY nClrPaneFocus  INIT RGB( 255, 255, 192 )
ENDCLASS

Also, as TMaskEdit, TEditBtn, TDateEdit, TDBEdit, TDBMaskEdit, etc. are inherited directly or indirectly from TEdit, all these controls will have the very same behave.

Now let's think we want to create a demo of our application, limited by dates, that cannot be greater than 31-12-05, this code snipet can do the job:

CLASS TMaskEdit FROM XMaskEdit
  METHOD Valid( oNextCtl )
ENDCLASS

METHOD Valid( oNextCtl ) CLASS TMaskEdit
  LOCAL uRet := Super:Valid( oNextCtl )
  IF ::cType == "D" .AND. Day( ::Value ) > 0
     IF DTOS( ::Value ) > "20052131"
        MsgStop( "Date not allowed in demo version." )
        RETURN .F.
     ENDIF
  ENDIF
RETURN uRet

Well these are just some samples of this technique, but posibilities are enourmous and they are only limited by your imagination.

Advanced Xailer Techniques, What happen during form creation ?

2006-03-23T08:16:00.000-08:00

[Original post by José F. Gimenez]

Many of you are using OnInitialize event in the forms to do some control initialization, asigment of initial values, etc... But some of you are using it because someone has told you to do so, and don't realize really why you should do it.

In this article I'll try to clarify all the steps that happen during the process of forms creation, including the moment in which some events are launched. In this way all of you will notice where and when to use one event or other.

Back to the basics.... New(), Create(), Destroy() and End(). These four methods are the ones implied in Xailer's controls creation and destruction.

New() is the method which instances and initialize the control container. You just have to run the class function to instance the object, but the call to New() method, even is a tradition in xBase, also is used to indicate the "parent" of the control, and perform certain initialization of the control.
Create() This is the method that really creates the control. Between New() and Create() all the control's needed properties are asigned, so, at the very creation moment, all the properties are already asigned with a value given by ourselves, or with the default value.
Destroy() As you can imagine, this method destroys the control, but it doesn't free the resources used, nor destoys the container object.
End() is he one which frees all the resources used by the control (memory, images, etc.) On the other hand, remember that under xbase, you cannot destoy the object directly from himself, but notice all the time that once End() executed, the object cannot be used again.

So far so good, these applies to controls, but in the case of non-visual components, New() and Create() can be used all alike, due to the most of these components don't have an equivalent with any Windows object or control.

Talking about forms, there's also an important difference: You NEVER call Create() directly, you just need to call New(), because CreateForm() method is the one which calls Create(), we will be back on this later.

Ok, once we had clarified which methods are implied in forms and controls creation, let's see, step by step what happen when you execute a line like:

TForm1():New( Application ):Show()

New() intances and initializes the object. In the case of forms, it internally calls CreateForm() method, this method is written in the .XFM file. This .XFM file is just a source code file with the same name of the .PRG file, .XFM stands for "Xailer ForM". The main reason cause this file is separated from the .PRG is because it can be handle by the IDE in a easier way, after all, we don't have to modify it by ourselves, we just have to know what is it, and what does it have, and if you are curious enough and edit it, you will see something like this:

METHOD CreateForm() CLASS TForm1

 Super:CreateForm()
 ::SetBounds( 220, 120, 450, 300 )
 ::cText := "Form1"
 ::oFont := TFont():Create( "MS Sans Serif", 8, 0, 400 )
 ::nClientWidth := 442
 ::nClientHeight := 266
 ::Create()

 ::oFileOpenDlg1 := TFileOpenDlg():Create( Self )

 WITH OBJECT ::oMemo1 := TMemo():New( Self )
    :SetBounds( 0, 0, 442, 266 )
    :nAlign := alCLIENT
    :Value := ""
    :Create()
 END

RETURN Self

As mentioned before, the XFM file just contains the CreateForm() method. Please notice that it also calls Super:CreateForms() and ::SetBounds(), and right after these calls, some properties of the form are asigned and then ::Create() is called.

But here is where the first event comes: OnCreate. Just in the call to Create() method this event is launched, as you can notice, in spite the form is created, none of its components or controls are created yet, so if you need to do something in this point, you can use OnCreate event, but be aware that at this point you cannot modify any component, simply because they still don't exist, and you will get an error.

Right after, the creation of the TFileOpenDlg component comes. As stated before, you don't need to call New() and Create(), because it is instanced and created when you call Create().

Please notice that non-visual components should be created BEFORE to create the controls, the reason is simply, some of these components are used by the controls, for example a TDbfDataSource or a TDbfDataSet.

And finally we find the creation of the TMemo() control. In this case we need to instance the object calling the New() method, asign its properties, and finish it calling to Create(), to create the control, at this moment, the event OnCreate is launched, so you can use it if needed.

Once finished with the CreateForm(), the form al all its controls are created, and here is when OnInitialize event is launched, so when you need to perform an initialization task over an already created control, you can use this event. At this point, the form still is not visible.

After that, the events that are launched are: OnShow, when the form is visible by calling the methods Show() or ShowModal(), and OnActivate, when the form got the keyboard focus. These two events are not only launched when the form is created, they will be launched whenever needed.

Well, with this lesson you have already learned all the steps until the form is visible and got the focus. If you have learned this, you will now have learned a very important part of how Xailer works.

Advanced Xailer Techniques, Drag and Drop operations

2006-03-22T16:40:00.000-08:00

Xailer let you to perform 3 kinds of different Drag & Drop operations:

Dragging files from the Windows explorer into the Xailer program
Dragging elements inside a TreeView
Dragging controls over other controls

The most basic drag & drop operation is the drag of files from within the Windows Explorer into your Xailer Application, its functionality is limited because only let you "to send" a file name or a list of file names to a control, and let it to process them. It works in a very easy way, just set the lDragAcceptFiles property to TRUE, and finally catch the event OnDropFiles, in such event, we will recieve an array with a list of the file names and maybe we could handle it like this:

METHOD ListBox1DropFiles( oSender, aFiles, aPoint ) CLASS ...

Aeval( aFiles, {|v| oSender:AddItem( v ) } )

RETURN Nil

In this sample, we are adding into a TListBox control, the name of files dragged into the control.

The second Drag & Drop system in Xailer is used to perform drag & drop operations among elements inside a TreeView control, you just have to set lDragDropItem property to TRUE. However, the TreeView control has some other events to give more flexibility and power to this kind of operations:

OnBeginDragItem: This event is launches whenever you start a Drag&Drop operation between two TreeView items, recieves as a second parameter, after oSender, the TTreeViewItem object which launched the event.
OnDragOverItem: This event is launched when, inside a Drag&Drop between items, the cursor is over a certain item. It recieves as a second parameter, after oSender, the TTreeViewItem objetct where the cursor is over. If it returns FALSE, you will see the "prohibited" cursor, indicating that is not possible to perform the D&D operation over that item.
OnEndDragItem: This event is launched when a D&D operation is finished between items. It recieves as a second parameter, after the oSender object, two TTreeViewItem objects, one called oItemFrom, the one that launched the event, and other called oItemTo, the object where the mouse was dropped. If it returns NIL, o this event is not captured, oItemFrom will move right after oItemTo. Catching this event, is possible to reject the Drop operation or, instead of move the item after the oItemTo, it moves to a child branch of the oItemTo.

The third way to perform D&D opeartions in Xailer, allows you to do it between Xailer controls, even if these controls are in different forms. To acomplish this task, Xailer has these events, at TControl class level, so they are inherited to all the classes from it:

OnBeginDrag: Is launched when there's a request to begin a D&D operation. If returns .T., this means that the D&D opearation is allowed and you notice it inmediatly because the mouse cursor changes its shape.
OnDragOver: Is launched when the mouse cursos moves over a control, and a D&D operation has been started. It recieves as a second parameter, after oSender, the control which started the D&D operation. If returns .T. this means that the D&D operation can be performed, and you notice it because the mouse cursor shape changes to the oCursorDropYes. If this event is not trapped, or returns a value different of TRUE, the mouse cursos shape change to oCursorDropNo.
OnEndDrag: This event is launched when you release the mouse left button over a control, and previously a D&D operation has been started. It recieves as a second parameter, after the oSender, the control which starte the D&D operation.

Please notice that the second and third ways cannot be used together, this means that you cannot perform a D&D between controls and at the same time do a D&D between TreeViewItems.

You can find a sample of D&D in the directory \Samples\DragDrop showing you the 3 ways at the same time.

Advanced Xailer Techniques, Moving from other enviroments

2006-03-22T15:50:00.000-08:00

[Original post by José Lalín]

Many people have told me they are very comfortable working with Xailer, they use it, or going to use it, for new projects because they don't want to re-write already finished and working applications.

For sure, no programming tool let you to move automatically from one enviroment to other: in the most of the cases, we can rescue the code that handle the data layer, but you always have to to make changes in the interface to fit your code to match the features of your new programming tool.

Comming from this, in the Xailer team we thought we could make something about, it and we decided to include an option in the IDE's menu that let you to import previously designed dialogs in Workshop.

Note: The import dialogs feature only works under .RC files, if you have a DLL or a previously compiled .RES file, you should export them to the .RC format, the most of the resource editors, including Workshop can do it for you with some mouse clicks.

To see how it works, let's go to the main menu, select TOOLS / IMPORT DIALOGS

Then you will see a form like this:

This form lets us, among other things:

Select the .RC file to be imported
To choose which dialogs we want to import
If we want to see how the form is creating while importing
Configure which custom control has an equivalent in Xailer

A simple sample of how it works: Let's suppouse we have a dialog with a Hernan's TWBrowse control, and we use it to display an array, and we also have a Manuel Mercado's TSButton.

Pressing the "Configure" button, we can easily make that a dialog defined TWBrowse turns into an Xailer's TArrayBrowse, and a TSButton to become into a Xailer's TBtnBmp.

Once imported, we will have a new FORM in our Xailer project with all the controls used in the original dialog, and we only have to do some minor stuff using the Objects Inspector and some mouse clicks.

I kindly invite you to play around a little with this option, and you will see how easily you can become an old dialog, into a powerful Xailer form.

Welcome to Sailing with Xailer

2006-03-22T09:18:00.000-08:00

Hi every one and be welcome to "Sailing with Xailer"

We at CiberTec are very happy to start this new blog fullfill with Xailer's information.

Xailer is the most powerful XBase based development tool actually, It's really a dream came true because Xailer has all the tools you always wanted, full integrated in a single, yet elegant IDE.

Xailer features go far away you are used to in the XBase world, based in the powerful xHarbour compiler, Xailer offers you all the needed tools for mission critical projects integrated in one single place, and let you to use all the Clipper / Xbase knowledge you already have.

Our goal in this blog is to share with the non-spanish speakers Xailer comunity all the information and articles published regarding to Xailer to help you to speed your learning curve.

In this first stage we will be translating the articles written in different forums, please feel free to let us know what you want to know, we are here to help you.

So, let the fun begin......