We just released an update for 7.2 with a nice mix of fixes and changes to both the IDE and the RTL. If you are a template writer then note that we’ve bumped the template version number to 7.2/7200.
You can check the readme list here
Category Archives: Clarion News
AppGen.Net – update
As we move forward in getting the new AppGen.Net and the new template families ready for you, we are simultaneously working to make writing the new T4 templates (much) easier. That task involves creating a specialized editor and supporting hybrid code completion. What’s hybrid code completion? Well to write a T4 styled template you need both code completion for the template directives and the template constructs (embeds, properties, ATs, etc), and code completion for the template language used (as we mentioned before that will be C# for the first release, and later we’ll support Clarion#). So the editor and parser must work together and determine whether the code being written or parsed is template directive or template language. Sounds simple enough but changing the context can happen almost anywhere, including on a line that starts in one context and mid-way through switches to another context and then back again.
Here’s an animated GIF that shows the code completion (CC) in action:
And here’s another one that shows the editor Drop list of “Methods” – equivalent to what in the Win32 templates we call #GROUPs (the drop lists also contains the equivalent to #ATs). All in all it makes for a very powerful template writing environment.
Of course the editor supports all the standard features we all depend on, like syntax coloring and code folding.
The T4 editor and hybrid code completion will make for much faster learning of the interfaces available in the templates, and will make it so much easier to write templates. We are also planning for the code completion to make available “Embed” names when you are in the equivalent to the Win32 #AT tag.
Well as you can see a considerable effort has been put into making writing and modifying templates a better experience. Writing templates is a bit of an art, not everyone can think in the abstract of translating lines of template code into lines of generated code, but writing good templates is much easier when you have the right tools available. As we got deeper into writing the T4 style templates we quickly saw that the syntax highlighting just wasn’t going to be enough. And though we hadn’t planned on support for code completion and code navigation in the T4 templates as critical for a first release, we decided from our own experience that it was actually going to be critical, for us and for you. We’re getting very close to finishing with that task, and doing so moves us that much closer to the end goal.
But enough on writing the templates, now let’s take a quick look at the user interface for using the templates in the new AppGen.Net. This screenshot shows a lot of key areas; central we have the Application Tree dialog. The dialog is split into the tree view on the left side, and the details view on the right. In the details view we can see the Properties, Extensions, Embeds and Procedures tabs. This is the main area you’ll be working from when not in the Designers or Editor. You can also see at the bottom right the new .Net Applications pad which has equivalent functionality the Win32 Applications pad; i.e. you can generate, generate/make or generate/make and run your applications.
We had hoped for an early June beta, and while we’ve decided the system isn’t quite ready today for a beta release you can see how much closer we’re getting. We’ll try to post weekly updates on the new AppGen.Net right here, and we’ll keep you informed as the beta release moves closer. And Thanks for your patience!
Summer sale and SMP is back!
In case you didn’t receive the email (and with the sea of spam I’ll bet many of you didn’t get it), and if you haven’t visited the “Special Offers” page on the website, you should know that we have some really nice offers going on right now; for a limited time – you can save up to $450 (ends on June 21st).
And not only are we offering great discounts on Core Subscription renewals, we’re also giving away free copies of our new training course “Inside the Clarion 7 IDE”, and offering free access to our new Application Migrations Assist (AMA) service. The new Application Migrations Assist service provides you with the option to invite one of our support technicians to log into your machine, and help you work through any migration issue you might run into – it’s expert help and advice right on your desktop.
And if you hadn’t heard, we brought back the Simple Maintenance Plan (SMP), and we have a one-time offer of $75 off that subscription (and you get the new Training course and AMA service). Hop on over to the special offers page, and get the full details on the new training course, and the discounts available. But you better do it soon, because these offers expire June 21, 2010
The new Clarion 7.2 IDE is the platform for the future of all Clarion development, now is your best chance to get into it and keep pace with the future of Clarion.
Update for 7.2
We just released an update for 7.2, this release fixes a couple regressions that slipped past us in the initial release, and introduces some very good optimizations to the App Recovery logging. You should see a very nice improvement in performance across the board (Opening Apps, Generating code, editing Embeds and Closing Apps) when working with the App Recovery feature turned ON. Its a short list since we just released a week ago, you can check the readme list here
7.2 Released
Notifications are going out now, and 7.2 will be in your hands shortly. There are many really great improvements in this release; from the OS style Menus, new additions to the MenuStyleManager class, and of course the new ReportWriter. I’ve posted blogs on most of these, you can use these links to review them or just check the “Clarion News” category;
https://clarionsharp.com/blog/2010/06/coming-up-with-72/
https://clarionsharp.com/blog/2010/05/reportwriter-and-the-report-engine/
https://clarionsharp.com/blog/2010/05/clarion-72-menus/
7.2 has a great list of new features and many good bug fixes, you can see the complete list of features/changes and fixes here.
Please take note of this excerpt from the readme file:
Release Notes:
——————–
– 3rd party component DLLs must be rebuilt with the Clarion 7.2 compiler and runtime.
– The .APP file format has been updated in this release and .App files opened in 7.2 cannot be opened with prior versions. When you open your. App file for editing you’ll be prompted to confirm that you want to convert it to 7.2 format. If you have a multi-APP Solution, you can initiate a generate all from within the Applications pad, and as each App is opened you’ll be prompted to confirm you want to convert to 7.2 format.
——————–
We’ll be posting a lot more about the new Report Writer, but if you haven’t already used it be sure to take a look when you get 7.2. And if you haven’t even had time to start it up, here’s a couple screen shots (click on them to see full size)
Coming up with 7.2
There was a recent thread in the news group where a lot of people were saying how much they used (and missed) the availability of a list of an Applications’ Procedures. Seems that code completion wasn’t the best option when you can’t remember the name of the Procedure. And its quite understandable when you have many many procedures, possibly hundreds, in your .App. So thanks to some quick work by Diego, Scott and Alexey, we were able to slip this this new feature into the 7.2 release; the Data pad now has a “Procedures” node, and when selected it lists all template based procedures, the Procedures node is only activated when you are in any of the editors, and dbl-clicking on a procedure name in the list inserts the procedure name into the editor. The Procedures list also has a Windows Explorer style incremental locator.
ReportWriter and the report engine
For 7.2 we’ll deliver the new standalone ReportWriter, and provide support for integrating the new report engine into Clarion Win32, Clarion#, and C# applications.
The new ReportWriter has major improvements in both functionality and ease-of-use, and of course it’s fully compatible with the Windows 7 64bit OS. It is extremely easy to create great looking reports, and reports can be exported to PDF, HTML, Excel, RichText, CSV, MHT, Text, and a variety of image formats (PNG, BMP, etc.). The ReportWriter also has support to export to any of those formats and email them in one operations. You can also preview reports in HTML format.
You’ll definitely want to offer upgrades to your end users so they can start using the new ReportWriter. The new ReportWriter automatically converts existing TXR libraries into the new library format. For quantity purchases we’ll be offering custom branding opportunities.
Using the report engine
Clarion 7 has existing support to work with TXR based reports from within your applications (see the Invoice example to see how it’s implemented), and we’ll continue to support TXR based report libraries in version 7.2. So any programs that are using the win32-based report engine won’t need any changes. But now in the release of 7.2, the ReportEngine class supports working with both the old report engine (TXR based reports), and the new report engine. The ReportEngine class determines which engine to run based on whether it’s asked to open a .TXR or a .REPXL library (.repxl is the extension used for the new report library files). And on the .Net side its equally easy to integrate the new report engine into your Clarion# or C# applications.
Bob Foreman is doing a ClarionLive presentation tomorrow (5/21), and he’ll be showing the new ReportWriter and showing how to integrate the new report engine into your applications.
Clarion 7.2 – Code gen from (almost) everywhere
For 7.2 we’ve come up with an implementation that allows developers to safely generate their application code from everywhere except from within the Window/Report Designers and the code Editor. We had previously added restrictions that prevented code generation being initiated with partial or unsaved changes, this new implementation ensures 100% consistency for code generation, but it allows you to generate code from anywhere on the Procedure Properties dialog or the main Application window.
Clarion 7.2 – Menus
We’re getting Clarion 7.2 ready for release, and I thought I’d make a few posts and talk about the changes and new features. Version 7 already has support for creating a very nice UI on your menu’s, and we recently added a couple new menu styles and support for using a 3d vertical separator. Using the Menu Styles lets you provide the exact same UI for your menu’s across all supported operating systems. No matter what OS your application is deployed on you have complete control of the menu colors and overall style.
Now in 7.2 we’ll introduce new support to make your applications use the OS menu’s. The new support doesn’t use the MenuStyleManager class, its only requirement is that your App is properly manifested, and with that your menus will match the menus on the users operating system. Here are some screen shots taken from different operating systems.
and for those who prefer using the C7 MenuStyleManager class you can be sure we’ll continue to enhance it, so that you’ll have complete consistency in your menu’s across operating systems
Update for 7.1
An update for 7.1 is going out today, there are no new features introduced in this release, but there is a change (for the better) that you’ll soon have:
CHANGE: Code generation only executes from the application tree window, this prevents generation with partial or unsaved changes and ensures consistency for code generation.
What this new change boils down to is a subtle (or not so subtle, depending on your work style) change to where and when you can initiate code generation. In all previous releases the IDE was very loose about allowing you to initiate code generation from just about anywhere within the Application Generator dialogs and supporting components (Designers, Embed Editor, etc.), without consideration for the current state of uncommitted changes, and unfortunately this flexibility opened up avenues for introducing problems into the generated code. Imagine if you changed a Window or Report and exited the Designer, now the structure has changed but you haven’t committed the changes at the Procedure level, but while still on Procedure Properties you execute code generation. What should generate? Should AppGen somehow restore the old structure (probably not what you want), or auto-commit the changes to the Procedure, again not a decision that should happen without an explicit choice by the developer. The implemented solution for this is very simple, the AppGen will inform you to return to the main window, which in turn forces you to either save the partial changes or abort them. The result is 100% consistency in the generated code, at the cost of having to make an explicit decision to save or abort changes at the Procedure level. Besides this change (for the better and safer) there are a good number of other fixes. You can read the entire list here