I've got a couple of articles in preview at the moment, on by Tony York on passing groups, and another by Dr. Parker on the status of his much-desired fixes to the previewer and MASK in C7.1. And I've got an excellent two-parter by Philip Prohm on converting your apps to C7.1, the first part of which should be online by the end of this week.

Like a lot of other people, I installed the Windows 7 release candidate on my development machine sometime last year, fully intending to upgrade to the RTM when it came out. But I never got around to it. And last week I became aware that the deadline was March 1, as of which time I could expect my Windows 7 RC install to start shutting down abruptly every two hours. So last week I bit the bullet and did a fresh install.

Years ago I started keeping a document with the exact steps needed to get everything up and running on a new install. Even with that the process takes more than a day, and there's always some app or configuration that I added since the last time but forgot to document. I have around fifty different applications/utilities I use on a regular basis, so I really need that doc.

I started the install last weekend, and although I had my core configuration in place by Monday morning and the majority of apps installed by the afternoon, I'm still doing a certain amount of fixup and cleanup each day. And of course there were various glitches, such as when I installed the latest PostgreSQL 8.4 release. And found out when it came time to update the ClarionMag beta database that I was running 8.3 on the server. And I had problems importing the new database. And and and ... well, just another day at the office.

The new ClarionMag beta site is coming along nicely. You can have a look at beta.clarionmag.com. In particular check out the My ClarionMag page. As you'll notice on the latter page the login system is different on the new site. We're switching to forms-based authentication, with a "remember me" option that keeps you logged in. If you've been relying on your browser's memory to log you in to the current site you may have forgotten your password entirely. There are a couple of ways to retrieve it.

One way is to get it from your browser - FireFox will let you view stored passwords, and I imagine most other browsers will as well.

The other is to get your password emailed to you by ClarionMag. But please make sure we have your current email address - you can update that (as well as your mailing list preferences) here.

And please do verify your email address. We do at times sends out special offers by email only, and if we don't have a current email address, or you've declined to be on our mailing lists (which are double-opt-in) you're unlikely to hear about those offers.

There's a lot of cool stuff happening on the beta site - I'll have more to say in upcoming articles. Really, go check out My ClarionMag. You'll find some nifty new ways to manage your own view of ClarionMag, including lists of favorite and "read later" articles.

Oh yes, I had someone ask me about the .NET site. That's still in development, but as it uses the same server code base as the new ClarionMag site you can expect to see it online in the near future.

If you're on Twitter, you can follow the beta progress and other ClarionMag news and notes on the ClarionMag Twittwer feed.

Periodically Wikipedia has a fundraising drive. If you'd like to kick in, as ClarionMag just did, go to the Wikipedia home page and follow the donate link.

Wikipedia is run by a non-profit organization, the Wikimedia Foundation. (BTW they've got a bunch of other interesting projects on the go, like a free media repository and a species directory.)

I do expect to have Part 2 up next week, however.

In response to James' question, Maarten Veenstra posted this little gem from an unknown author. This program illustrates another approach, which is to store the ADDRESS of a procedure and then START the address instead of the label.

But there's a trick. Take a close look at the DynaStart prototype in the MAP:

   Program
include('builtins.clw')
Procs  LONG,DIM(16)

 MAP
  Main
  BrowseStudents
  BrowseTeachers
  BrowseSchools
  BrowseClassRooms
  MODULE('Clarion')
    DynaStart(LONG,LONG),LONG,PROC,NAME('Cla$START')
  END
 END

 CODE

 Procs[1] = address(BrowseStudents)
 Procs[2] = address(BrowseTeachers)
 Procs[3] = address(BrowseSchools)
 Procs[4] = address(BrowseClassRooms)
 MAIN

Main  PROCEDURE
Window WINDOW('Select Procedure'),AT(,,219,69),|
         FONT('MS Sans Serif',8,,FONT:regular,CHARSET:ANSI),|
         CENTER, GRAY
       LIST,AT(93,18,103,10),USE(?List1),VSCROLL,DROP(4),|
         FROM('BrowseStudents|BrowseTeachers|BrowseSchools|BrowseClassRooms')
       PROMPT('Select Procedure:'),AT(23,18),USE(?Prompt1)
       BUTTON('Start Selected Procedure'),AT(60,44,99,14),USE(?StartButton)
     END
     CODE
     OPEN(Window)
     SELECT(?List1,1)
     ACCEPT
     CASE FIELD()
      OF ?StartButton
       CASE EVENT()
       OF EVENT:Accepted
        DynaStart(Procs[CHOICE(?List1)],25000)

       END
     END
     END
 
BrowseStudents PROCEDURE
    CODE
     MESSAGE('Students')

BrowseTeachers PROCEDURE
   CODE
   MESSAGE('Teachers')

BrowseSchools     PROCEDURE
   CODE
   MESSAGE('Schools')


BrowseClassRooms  PROCEDURE
   CODE
   MESSAGE('ClassRooms')

You might think you could use START directly, but you can't. The libsrc\builtins.clw contains the following prototype:

 START(_PROC,UNSIGNED=0),SIGNED,PROC,NAME('Cla$START')  

And _PROC is a procedure prototype:

_PROC(),TYPE

The compiler complains if you attempt to pass an address instead of an actual procedure.

As the unknown author of that example deduced, internally START simply takes the address of a procedure. So the redeclaration of START uses LONG parameters instead, and now you can pass the address of any parameterless procedure. Presumably you could take the same approach with the other two forms of START.

It's a nifty bit of code. So who wrote it?

Now, he also said that it won't be until after there's a .NET AppGen, which he's previously indicated is 3-6 months away. I'm not sure there's quite enough time in the year for this, as to my mind a DevCon needs a good six months lead time.

UPDATE: Bob F certainly has DevCon on his mind, however. He just mentioned it again...

Also of note, the Applications Pad is getting more toolbar buttons and is intended to be the primary way developers interact with APP and DCT files.

What I neglected to mention in that blog post is that I also considered creating a batch file to run the solution's EXE directly, but batch files pop up console windows. My Clarion solution using RUN executed the EXE transparently.

But RUN isn't the solution to every problem. For instance, Brahn Patridge discovered some problems with the maximum length of parameters accepted by the template #RUN statement which he circumvented by writing out and executing a batch file. And that resulted in the annoying console window popup. Brahn eventually found a nifty tool called Hidden Start that executes batch files and console apps without displaying a window. Hidden Start is free, although a license is required for commercial distribution. Thanks for the tip, Brahn.

UPDATE: Mark Riffey tells me that AVG flags Hidden Start as a virus. As far as I can tell this is because Hidden Start can be used to run programs without the user receiving any indication that the program is running, not because there's an actual virus. But use appropriate caution.

I decided to play around with the Tools menu to see if there was a way to produce a “run only” behavior, and I did find a solution. But SV has now said that a run only button will be in the next build, but in the event that you can’t wait for the next build of C7, here’s what you need to do to add your own “Run only” menu option.

It was Ben Dell who got me started on the Tools menu. He pointed out that it was possible to run customized MSBuild tasks that way. And if you can run an MSBuild task on a project, why not a task to run an EXE?

First, create a new Win32 EXE solution (not an APP - this will be a hand coded program) called, say, Launcher. Launcher.clw contains just this code:

                    PROGRAM

                    MAP
                    END

    CODE
    run(COMMAND())

Compile the code.

Next, in Tools | Options | Tools create a new external tool called something like “Run the current application”.

Set the command to your Launcher.exe

Set the arguments to "${TargetPath}" (the quotes take care of long file names, although they may not be necessary) and the working directory to ${ProjectDir}.

Now when you want to launch a program you just highlight it in the solution explorer and choose the “Run the current application” option from the Tools menu.

My editor of choice (until recently <g>) is Textpad.  It has one very nice feature I found I can't live without - workspaces.  What this is you have a bunch of source files open (even if in different folders).  You save the workspace like a regular file.  When you open a workspace, all files opened are opened again.  A marvelous shortcut to opening one file at a time.  I use this for template coding, web sources (site code and shopping cart code), etc.

You could open each file in C7 on the start page, its opening one file at a time and you still have to contend with tab switching since the start page is no longer the current tab.  Its slower than opening one file to open many files.

So this is how you can create a "workspace" in C7:

1. Choose File/New/solution, project or application (or press Ctrl-Shift-N).
2. Select SharpDevelop as the solution, for the type, select "empty solution".
3. Fill in the name of the "workspace", in the folder you wish.
4. You have only one item in the solution explorer.  Expand this to show "solution items" - it is empty.
5. Right-click and choose Add/Add item...
6. Navigate to the folder you want, select one or multiple files and press open.  The files are added there.
7. Repeat #6 until you have loaded all the sources you want.

The "solution" is now on the Start page.  When you restart or select the start page again, just open the "solution" and you can then open any file in it as you wish.  You don't have to worry about build state since there is nothing to build, so nothing to change there.

There are limitations:

1. It won't remember where in the file you were editing.
2. The files won't open as the default, you have to open them.

If you are using code folding, it does remember that setting.

A few additional points came up in the ensuing discussion. You can run multiple instances of the IDE, so you can keep a workspace handy while you work on another app. The only issue I've noticed with multiple instances of the IDE is that the last one closed writes the recent projects list. So let's say you do the following:

1. Run an instance of the IDE (instance A)
2. Run another instance (instance B)
3. Create a new solution with B
4. Exit B
5. Exit A

Instance B will add the just-created solution to the recent projects list. In fact, before you exit instance A you can restart the IDE and see that project in the list. Now close B, then close A. Open the IDE again. The solution added by B will not be in the projects list, because instance A overwrite the list with what it had in memory.

Finally, you can always add files to your solution without necessarily compiling them. Just select the source file in the solution explorer, go to the Properties pad, and set the Build Action to None. Recent versions of C7 let you add "solution folders" to projects, and when you add files to these folders you are creating links to those files. I've used this feature to set up a Templates folder with links to template files I regularly edit. And since you can have multiple projects in a solution, it's easy to set up a project just for, say, frequently-edited templates which can then be attached to any solution where they are needed.

Next week it's back to the Clarion# web app goodies, although there will be a few bits and bobs in there to appease the non-web, non-Clarion# folk as well.

I'm particularly excited about this template chain as it provides us with the technology we need to begin porting the ClarionMag web application from its current Java code base to Clarion#.

Don't let the small number of pages in this web application fool you - there's a lot packed into this little app. The home page isn't particularly complex, however; it simply gives you an overview of the application's capabilities.

Most of the goodies are in the browse page. There are two versions of this browse. The HTML version features column sorting, filtering (many kinds of filters are possible, although only insensitive LIKE expressions are shown here), and fast server-side paging which allows you to work with large result sets. The browse state is persistent; navigate to another page, come back to the page, and you see the same data as last time.

But HTML browses aren't that pretty, and getting the next set of data requires a distracting page refresh. So there's a sneak peek at an AJAX version of the browse created with the ExtJS toolkit. This browse isn't fully functional yet, nor is it integrated with the templates, but it does demonstrate the use of JSON requests to load a browse without refreshing the page. And it looks a lot nicer than an HTML browse, and behaves the way a browse should. We'll be doing more work with ExtJS components in the future.

There isn't any security on the browse, but there is on the form. It's a simple requirement - you only need to be logged in. So if you attempt to edit, insert or delete a record (from the HTML browse) and you're not yet logged in, you'll see a login page.

You can use the guest login or register your own user id. If you have Javascript enabled you'll see validation messages appear below incorrectly filled fields. (If Javascript is disabled, server-side validation still ensures correct data.)

Once you're logged in you're returned to the form where you can complete the desired changes.

There are several important caveats to this template chain.

First, it's most definitely alpha code, and there's a lot of work to be done.

Second, since the generated code uses the NHibernate ORM to talk to the database you're limited to supported SQL databases. Right now that list includes:

• Microsoft SQL Server 2005/2000
• Oracle
• Microsoft Access
• Firebird
• PostgreSQL
• DB2 UDB
• MySQL
• SQLite

No TPS files there, and wouldn't hold my breath waiting for a TopSpeed NHibernate driver.

(Actually, you can still access TPS or other Clarion# drivers if you wish, you just can't take advantage of the automated validation and data binding, both of which are enormously useful on forms.)

Third, this template chain is not ABC or legacy Clarion compatible. You cannot use it to convert an existing application; you can only use it to create a new application. MVC web development is significantly different from Clarion desktop development, and while it may be possible to write these templates as an add-on, it really isn't practical.

I hope you'll find the upcoming screencast and an accompanying series of articles interesting and useful. Web development is a different beast from desktop development, and many of the issues I'll cover apply to non-MVC web development as well.

And even if you're not interested in doing your own web development you will benefit as a ClarionMag user, as this template chain forms the foundation for the next version of the Clarion Magazine web site....

Unfortunately, I keep wasting time actually reading the data. I mean, who can say with a straight face that Clarion programmers don't have baroque dinosaur religious issues....