{"id":222,"date":"2008-08-24T12:24:43","date_gmt":"2008-08-24T00:24:43","guid":{"rendered":"https:\/\/www.deltics.co.nz\/blog\/?p=222"},"modified":"2009-08-07T14:57:10","modified_gmt":"2009-08-07T02:57:10","slug":"more-delticsforms-magic","status":"publish","type":"post","link":"https:\/\/www.deltics.co.nz\/blog\/posts\/222\/","title":{"rendered":"More Deltics.Forms Magic"},"content":{"rendered":"[Estimated Reading Time: <\/span> 6<\/span> minutes]<\/span><\/span>

Last time I introduced a bit of skullduggery with my Deltics.Forms<\/strong> unit as a way to easily “inject” a new TForm<\/strong> class into my projects.\u00a0 We used this new class to add public property that we could use to add a size grip control to any form.<\/p>\n

This time we shall introduce some more code the Deltics.Forms<\/strong> unit in order to add some frequently useful capabilities to the Application<\/strong> object.<\/p>\n

<\/p>\n

What Is Application?<\/h3>\n

As you are no doubt aware, the Application<\/strong> object is a single object declared in the VCL Forms<\/strong> unit (but instantiated in the Controls<\/strong> unit), and is the heart of most Delphi applications.\u00a0 It’s a well named object in that respect.<\/p>\n

Unfortunately, the Application<\/strong> object is of a fixed class – TApplication<\/strong>.\u00a0 This class cannot be extended or replaced with a class that might, for example, contain extensions that you might wish to have included in all of your<\/span><\/em> applications.<\/p>\n

It was a surprise to me to find some years ago, for example, that the Application<\/strong> object in a Windows Application<\/em> project has nothing in common with the Application<\/strong> object in a Windows Service Application<\/em> project, for example – one is a TApplication<\/strong> the other a TServiceApplication<\/strong> and both derive directly from TComponent<\/strong>.<\/p>\n

It is also something of a surprise that the basic capabilities of the TApplication<\/strong> object have not evolved over the years to provide better access to version information or command line parameters, for example.\u00a0 But despite the rather closed nature of TApplication<\/strong>, the Deltics.Forms<\/strong> unit provides the platform for adding these things ourselves.<\/p>\n

Helpers For The Rest Of Us<\/h3>\n

A post on MelanderBlog<\/a> shows how to do this with a class helper, but these things are a) a bad idea (imho) and b) not available to anyone using Delphi 2006 (I think) or earlier.<\/p>\n

Class helpers are intrinsically a “bad idea” because only one can be in scope at a time, so if you had some other code that introduced another helper for the same class (perhaps without you even knowing it) you have a problem – one or other of those helpers will “disappear” and code that compiled perfectly well before suddenly stops compiling.<\/p>\n

But we can achieve the same result more safely without class helpers.\u00a0 They are merely syntactic sugar for a time-tested technique that is actually safer (and more opaque) than the formalised “helper” mechanism.\u00a0 “Safer” because code that uses the non-helper technique cannot cause problems with other code using the same technique in the way that formal class helpers suffer from.<\/p>\n

As we saw, the Deltics.Forms<\/strong> unit introduces a new TForm<\/strong> class that is compatible with the VCL TForm<\/strong> class.\u00a0 We can also introduce a new TApplication<\/strong> class that is similarly compatible with the VCL TApplication<\/strong>:<\/p>\n

  type\r\n    TApplication = class(Forms.TApplication);<\/pre>\n
A problem here however is that we cannot alter the fact that the Controls<\/strong> unit instantiates a Forms<\/em>.TApplication<\/strong>, and knows nothing of this new TApplication<\/strong> class.\u00a0 Our new TApplication<\/strong> class must therefore observe the same limitations of a class helper – we cannot introduce new member data and we cannot override any virtual methods.<\/p>\n
Another problem is that the Application<\/strong> variable in Forms<\/strong> is also declared using the Forms<\/em>.TApplication<\/strong> class, so if we are to refer to Application<\/strong> as our new class we’ll need just a little more smoke and mirrors in Deltics.Forms<\/strong>:<\/p>\n
interface\r\n\r\n  function Application: TApplication;\r\n\r\nimplementation\r\n\r\n  function Application: TApplication;\r\n  begin\r\n    result := TApplication(Forms.Application);\r\n  end;<\/pre>\n
We still need to do a little work in our actual projects to make use of this new Application<\/strong> object – the Forms<\/strong> unit reference in our project source needs to be replaced by a reference to Deltics.Forms<\/strong>.\u00a0 It is far less likely that we will need to have both Forms<\/strong> and Deltics.Forms<\/strong> referenced in the project source, but if that is necessary then instead of replacing the Forms<\/strong> reference, add the Deltics.Forms<\/strong> unit after<\/span><\/em> it in the uses list.<\/p>\n
With these fundamentals in place, we can now – with a little care – add some useful new capabilities to the Application<\/strong> object.\u00a0 For starters let’s add a VersionInfo<\/strong> property.<\/p>\n
Adding Properties Without Adding Member Data<\/h3>\n
The “care” that we need to exercise is as previously mentioned – we cannot add member data, and we cannot override any virtual methods.  So how can we add any new properties?<\/p>\n
In this case, things are made a great deal simpler by the fact that the Application<\/strong> object is a singleton – there is only ever one of them in any project.\u00a0 There is also only ever one Deltics.Forms<\/strong> unit in an application, so we can declare variables in the unit to hold the data we would otherwise introduce as member data in the Application<\/strong> object.<\/p>\n
These unit variables (sometimes mistakenly referred to as global variables – Delphi actually has no such thing) need only be declared in the implementation section as they are exposed only via our extensions to the TApplication<\/strong> class:<\/p>\n
interface\r\n\r\n  uses\r\n    Forms,\r\n    Deltics.VersionInfo;\r\n\r\n  type\r\n    TApplication = class(Forms.TApplication)\r\n    private\r\n      function get_VersionInfo: TVersionInfo;\r\n    public\r\n      property VersionInfo: TVersionInfo read get_VersionInfo;\r\n    end;\r\n\r\nimplementation\r\n\r\n  var\r\n    _VersionInfo: TVersionInfo = NIL;\r\n\r\n  function TApplication.get_VersionInfo: TVersionInfo;\r\n  begin\r\n    if NOT Assigned(_VersionInfo) then\r\n      _VersionInfo := TVersionInfo.Create;\r\n\r\n    result := _VersionInfo;\r\n  end;\r\n\r\ninitialization\r\n  \/\/ NO-OP\r\n\r\nfinalization\r\n  FreeAndNIL(_VersionInfo);\r\n\r\nend.<\/pre>\n
Obviously the above code is not entirely complete, only showing the changes and additions needed to add the VersionInfo<\/strong> property.\u00a0\u00a0 The details of the TVersionInfo<\/strong> implementation aren’t particularly important – there are lots of implementations of such a class freely available (the one I use will be available shortly – more on that in my next post).<\/p>\n
So we can add some useful new properties, but I also mentioned previously that we could introduce some behavioural changes inspired by an article about Creating Vista Ready Applications<\/a>.<\/p>\n
How do we do that without overriding any virtuals?<\/p>\n
Changing Behaviour Without Overriding<\/h3>\n
The original article about creating Vista ready applications<\/a> mentioned adding some code to a FormCreate<\/strong> event (presumably the FormCreate<\/strong> of the main form) to modify the characteristics of the hidden application window (Application.Handle<\/strong>). Not only is this a little inelegant (using an event in one form to make changes to some other form), it is also going to be cumbersome having to do this in every application.<\/p>\n
Now that we have our own TApplication<\/strong> class we can introduce these changes once and have that change apply in our applications simply by using the Deltics.Forms<\/strong> unit.\u00a0 The key method in this case is the TApplication.CreateForm<\/strong> method.\u00a0 This is not virtual and typically isn’t even referenced outside of our project source file anyway, so replacing this method with our own implementation is quite safe:<\/p>\n
interface\r\n\r\n  type\r\n    TApplication = class(Forms.TApplication)\r\n    public\r\n      procedure CreateForm(InstanceClass: TComponentClass; var Reference);\r\n    end;\r\n\r\nimplementation\r\n\r\n  procedure TApplication.CreateForm(InstanceClass: TComponentClass;\r\n                                    var Reference);\r\n  var\r\n    bMainForm: Boolean;\r\n  begin\r\n    bMainForm := (Forms.Application.MainForm = NIL);\r\n\r\n    inherited;\r\n\r\n    if NOT bMainForm\r\n    \u00a0or NOT MainFormOnTaskBar\r\n     or NOT (Application.MainForm.InheritsFrom(TForm)) then\r\n      EXIT;\r\n\r\n    ShowWindow(Application.Handle, SW_HIDE);\r\n    SetWindowLong(Application.Handle,\r\n                  GWL_EXSTYLE,\r\n                  GetWindowLong(Application.Handle, GWL_EXSTYLE)\r\n                   and NOT WS_EX_APPWINDOW or WS_EX_TOOLWINDOW);\r\n    ShowWindow(Application.Handle, SW_SHOW);\r\n\r\n    TForm(Application.MainForm).RecreateWnd;\r\n  end;<\/pre>\n
Again the above code showns only the changes and additions and is not complete.<\/p>\n
The MainFormOnTaskBar<\/strong> property is another property that I introduce to TApplication<\/strong> in a similar way that VersionInfo<\/strong> is introduced.\u00a0 It is deliberately named for a property that is introduced in Delphi 2007, and is used to determine whether the form shown on the Task Bar will be the hidden application hidden window (normal Delphi behaviour) or the MainForm window (the new behaviour introduced here).<\/p>\n
Our new CreateForm<\/strong> takes care of modifying the characteristics of the hidden application window when creating the Application<\/strong> MainForm<\/strong> (by design in the VCL, the MainForm<\/strong> is the first form created via a call to the Application.CreateForm<\/strong> method).<\/p>\n
We also only apply these changes if the MainForm<\/strong> is derived from our Deltics.Forms<\/em>.TForm<\/strong> (otherwise it won’t be aware of our Vista readiness changes).<\/p>\n
Finally, if the changes are applied, the MainForm<\/strong> window itself needs to be re-created to ensure that the necessary window parameter changes are applied that will present that form on the task bar.\u00a0 These parameter changes are applied in an override of CreateParams<\/strong> in the Deltics.Forms<\/em>.TForm<\/strong> class:<\/p>\n
  procedure TForm.CreateParams(var Params: TCreateParams);\r\n  begin\r\n    inherited;\r\n\r\n    Params.Style := Params.Style and (not WS_CHILD) or WS_GROUP or WS_TABSTOP;\r\n\r\n    if ShowOnTaskBar then\r\n      Params.ExStyle := Params.ExStyle and (NOT WS_EX_TOOLWINDOW) or WS_EX_APPWINDOW;\r\n  end;<\/pre>\n
Time for a quick confession – I originally did all this stuff quite a while ago now and rather foolishly neglected to document a lot of the finer details.  The changes to Params.Style<\/strong> being one such undocumented detail.<\/p>\n
It solves a puzzling problem – changing the caption of an AutoSize<\/strong> TLabel<\/strong> on a Deltics.Form.TForm<\/strong> results in that form changing size (a result of AlignControls<\/strong>).\u00a0 Setting these Style params fixes that behaviour.\u00a0 I must have reasoned this out myself at the time or come across some information that gave me the insight, but I’ve since lost that information.\u00a0 I hate code that “just works”, so if anyone can explain why this is necessary I would be very grateful.<\/p>\n
One last thing we can do is introduce the WM_SYSCOMMAND<\/strong> message handling described in the Vista readiness article:<\/p>\n
  procedure TForm.WMSysCommand(var aMessage: TWMSysCommand);\r\n  begin\r\n    if Application.MainFormOnTaskBar then\r\n    begin\r\n      case (aMessage.CmdType and $FFF0) of\r\n        SC_MINIMIZE : begin\r\n                        ShowWindow(Handle, SW_MINIMIZE);\r\n                        aMessage.Result := 0;\r\n                      end;\r\n\r\n        SC_RESTORE  : begin\r\n                        ShowWindow(Handle, SW_RESTORE);\r\n                        aMessage.Result := 0;\r\n                      end;\r\n      else\r\n        inherited;\r\n      end;\r\n    end\r\n    else\r\n      inherited;\r\n  end;<\/pre>\n
Code In Preparation<\/h3>\n
There is no code to download this time – for the time being – other than that provided in the article above.<\/p>\n
I am currently in the process of setting up a CodePlex<\/a> hosted project where I shall release all code that I cover in my blog – and more.  I have decided to release under the X11 (a.k.a “MIT”) License.  I find the Team Foundation version control model as unpalatable as SVN (as I understand it CodePlex projects can be accessed using Team Explorer or SVN) – the tight coupling between repository and local workspace is particularly uncomfortable to me.<\/p>\n
But this, and other aspects of the CodePlex experience, is something I shall blog about separately.<\/p>\n
Once the project is available I shall post the details in my blog.<\/p>\n","protected":false},"excerpt":{"rendered":"
[Estimated Reading Time: <\/span> 6<\/span> minutes]<\/span><\/span> Last time I introduced a bit of skullduggery with my Deltics.Forms unit as a way to easily “inject” a new TForm class into my projects.\u00a0 We used this new class to add public property that we could use to add a size grip control to any form. This time we shall introduce some more code […]<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"jetpack_post_was_ever_published":false,"jetpack_publicize_message":"","jetpack_is_tweetstorm":false,"jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":false,"jetpack_social_options":[]},"categories":[4],"tags":[45,292,44,46,41,43],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_shortlink":"https:\/\/wp.me\/p1TKYv-3A","jetpack_sharing_enabled":true,"jetpack-related-posts":[{"id":208,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/208\/","url_meta":{"origin":222,"position":0},"title":"When Type(name)s Collide","date":"19 Aug 2008","format":false,"excerpt":"It's funny how this happens.\u00a0 I was already intending to write about the way I have exploited like-type names to my advantage, and then noticed that the same subject cropped up recently in the re-invented Delphi forums.\u00a0 In that instance, the issue though was a problem, and one that I'm\u2026","rel":"","context":"In "Delphi"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":295,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/295\/","url_meta":{"origin":222,"position":1},"title":"Making A Splash","date":"04 Sep 2008","format":false,"excerpt":"OK, so who hasn't done this a million times - adding a splash screen to a Delphi application.\u00a0 I've seen any number of \"easy\" ways to do this but during a session at Tech Ed '08 this week I saw the latest in splash screen technology from Microsoft:\u00a0 A SplashScreen\u2026","rel":"","context":"In "Delphi"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":1833,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/1833\/","url_meta":{"origin":222,"position":2},"title":"Importing an Android Class For Use in Delphi","date":"03 Oct 2013","format":false,"excerpt":"In a previous post I noted the absence of the BatteryManager class in the AndroidAPI.JNI units. This class contains some constants useful when reading battery information. I showed how to use a suitably massaged literal in place of these missing constants, but in response to observations from Paul and Brian\u2026","rel":"","context":"In "Android"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":1503,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/1503\/","url_meta":{"origin":222,"position":3},"title":"Sharing Code Across Platforms in Oxygene","date":"22 Aug 2013","format":false,"excerpt":"There seems to be a perception among some people that Delphi is in the unique position of allowing developers to share and re-use code across the various platforms that it's compiler can now (and will soon) target. But this is not the case. Oxygene has had this capability right from\u2026","rel":"","context":"In "Cooper"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":1938,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/1938\/","url_meta":{"origin":222,"position":4},"title":"Menu Items, APIs, Crackers and Hackers","date":"16 Oct 2013","format":false,"excerpt":"Francois Piette recently posted a solution to obtaining the screen position of a menu item involving using a \"hacker\" class. There is however a safer, more direct mechanism which I hope Francois won't mind me sharing and a far less safe related hacking technique that his post brought to mind.\u2026","rel":"","context":"In "Delphi"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":160,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/160\/","url_meta":{"origin":222,"position":5},"title":"MultiCast Events – Conclusion","date":"11 Aug 2008","format":false,"excerpt":"Drawing this subject to a close (finally!), here's the concluding post I promised, including the fully documented and finished implementation that has been serving me well for almost 2 years.\u00a0 The finished implementation incorporates a number of refinements to the core framework, and those are what we shall briefly look\u2026","rel":"","context":"In "Delphi"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]}],"_links":{"self":[{"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/posts\/222"}],"collection":[{"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/comments?post=222"}],"version-history":[{"count":14,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/posts\/222\/revisions"}],"predecessor-version":[{"id":238,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/posts\/222\/revisions\/238"}],"wp:attachment":[{"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/media?parent=222"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/categories?post=222"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/tags?post=222"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}