{"id":1938,"date":"2013-10-16T20:48:51","date_gmt":"2013-10-16T08:48:51","guid":{"rendered":"https:\/\/www.deltics.co.nz\/blog\/?p=1938"},"modified":"2013-10-16T20:58:45","modified_gmt":"2013-10-16T08:58:45","slug":"menu-items-apis-crackers-and-hackers","status":"publish","type":"post","link":"https:\/\/www.deltics.co.nz\/blog\/posts\/1938\/","title":{"rendered":"Menu Items, APIs, Crackers and Hackers"},"content":{"rendered":"[Estimated Reading Time: <\/span> 4<\/span> minutes]<\/span><\/span>

Francois Piette recently posted a solution to obtaining the screen position of a menu item involving using a “hacker” class<\/a>. There is however a safer, more direct mechanism which I hope Francois won’t mind me sharing and a far less<\/em> safe related hacking technique that his post brought to mind.<\/p>\n

<\/p>\n

A Puzzle Wrapped in an Enigma<\/h2>\n

Francois’ original puzzle was an interesting one to solve: how to determine the position on screen of a given menu item. I have to say first initial instinct was to think that the Windows API<\/strong> must provide access to this information more directly.<\/p>\n

And it does. \ud83d\ude42<\/p>\n

To obtain the screen co-ordinates of a menu item you can simply call the GetMenuItemRect<\/a>()<\/strong> API in Windows<\/strong>. All you need is the HMENU<\/strong> of the menu and the index of the item of interest.<\/p>\n

For reliable position information the menu item should be visible, which is of course going to be the case if you call this API in response to an OnClick<\/strong> of the menu item in question.<\/p>\n

Here’s a revised version of Francois example with a simple form which presents a modal version of itself at the position of either of two menu items on the File1<\/strong> menu (FileItem1<\/strong> and FileItem2<\/strong> both share the FileItemClick<\/strong> event): <\/p>\n

\r\nunit Unit1;\r\n\r\ninterface\r\n\r\nuses\r\n  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,\r\n  Dialogs, Menus;\r\n\r\ntype\r\n  TForm1 = class(TForm)\r\n    MainMenu1: TMainMenu;\r\n    File1: TMenuItem;\r\n    FileItem1: TMenuItem;\r\n    FileItem2: TMenuItem;\r\n    Close1: TMenuItem;\r\n    procedure FileItemClick(Sender: TObject);\r\n    procedure Close1Click(Sender: TObject);\r\n  private\r\n    { Private declarations }\r\n  public\r\n    { Public declarations }\r\n  end;\r\n\r\nvar\r\n  Form1: TForm1;\r\n\r\nimplementation\r\n\r\n{$R *.dfm}\r\n\r\nprocedure TForm1.Close1Click(Sender: TObject);\r\nbegin\r\n  ModalResult := mrOk;\r\nend;\r\n\r\nprocedure TForm1.FileItemClick(Sender: TObject);\r\nvar\r\n  rc: TRect;\r\n  form: TForm1;\r\nbegin\r\n  GetMenuItemRect(Handle, File1.Handle, File1.IndexOf(TMenuItem(Sender)), rc);\r\n\r\n  form := TForm1.Create(self);\r\n  form.Left := rc.Left;\r\n  form.Top  := rc.Top;\r\n  form.ShowModal;\r\nend;\r\n<\/pre>\n
There’s no attempt to code this correctly – freeing the modal forms properly etc.  The point is the menu item rectangle determination.<\/p>\n
Which isn’t to say that Francois’ hacker class technique doesn’t have it’s uses.  It absolutely does, in Delphi.<\/p>\n
Apart from anything else, it is an alternative to “class helpers” that is not vulnerable to the “Highlander<\/em>” constraint constraint those suffer from (“There can be only one<\/em> [in scope]”)<\/a>.<\/p>\n
But Francois’ post also stirred a distant memory of a related technique.<\/p>\n
Hackers vs Crackers<\/h2>\n
Francois calls his sub-class a “hacker”.  I prefer to call classes that exploit this particular “protected extension” behaviour “crackers”, since they “crack open” a class for access to protected members but are otherwise entirely safe.<\/p>\n
After all, they are more or less formally supported – though less well imho – by “class helpers”.<\/p>\n
I do have another type of class which I term a “hacker”, which is far, far less<\/strong> safe (diabolically unsafe<\/strong> would be nearer the mark) since they provide access to the private<\/strong> members of some other class.  Furthermore, classes exploiting this technique are vulnerable to changes in the “target” class in different Delphi versions.<\/p>\n
You start by declaring a class but in this case instead of the target<\/em> class you derive from the target class’ own ancestor<\/em>.<\/p>\n
So, to hack a TMenuItem<\/strong> you would extend TComponent<\/strong> since this is the class that TMenuItem<\/strong> extends:<\/p>\n
\r\n  TMenuItemHack = class(TComponent)\r\n<\/pre>\n
You then reproduce, verbatim, the member declarations of the target class, down to and including any private member you wish to gain access to.  For the sake of argument let’s assume we wanted to directly access the FRadioItem<\/strong> private member of a TMenuItem<\/strong> (this is a purely hypothetical example):<\/p>\n
\r\n  TMenuItemHack = class(TComponent)\r\n  private\r\n    FCaption: string;\r\n    FChecked: Boolean;\r\n    FEnabled: Boolean;\r\n    FDefault: Boolean;\r\n    FAutoHotkeys: TMenuItemAutoFlag;\r\n    FAutoLineReduction: TMenuItemAutoFlag;\r\n    FRadioItem: Boolean;\r\n  end;\r\n<\/pre>\n
Assuming you have a correctly declared hack class, you can now use this class to type-cast a reference to an instance of the target class and thus directly access the private<\/strong> members up to and including the last one declared.<\/p>\n
\r\n  isDefault := TMenuItemHack(SomeMenuItem).fDefault;\r\n\r\n  TMenuItemHack(SomeMenuItem).fDefault := FALSE;\r\n<\/pre>\n
If you place the hack class in a unit other than the unit where it is used, you will need to change private<\/strong> or protected<\/strong> visibility specifiers to public<\/strong> for the member(s) of interest.<\/p>\n
As I say, this is highly<\/em> sensitive to Delphi versions.  This is the declaration from Delphi 2010<\/strong>, which may be the same in a number of other Delphi versions, possibly all.  But if the member declarations of your target class vary in order or content in some other version then you must reflect those variations in the declaration when compiling using those other versions.<\/p>\n
Based on experience of this technique in the past*, you can omit any function or procedure declarations even if they occur between member variables.  All that seems to matter is that you have all the member variables themselves.<\/p>\n
(* – don’t ask.  It was on a project a joined and, to be fair, as unsavoury as it is it was necessary in that case with that particular version of Delphi to enable a particular behaviour in the application<\/em>)<\/p>\n
It is also potentially vulnerable to variations in compiler behavior that may impact on the member layout of class member variables.  This is perhaps unlikely, though it is possible (though again, not something I have encountered) that the declarations in the VCL source do not correspond to the actual declarations in the pre-compiled VCL unit that the compiler will use (unless you have contrived to redirect the compiler to your own copy of that unit, which is a whole other minefield!).<\/p>\n
As I say, the technique is utterly unsafe and relies on the memory layout of two classes with the same ancestor and the same member variable declarations being identical.  The “hack” class is – in effect – overlayed on top of the memory of an instance of the target class.<\/p>\n
You really are digging around in the guts – the physical memory – of the target instance, and if you get it even slightly wrong there is no telling what the impact might be.<\/p>\n
But it can be a life saver if you absolutely must gain access to some private member that is not exposed in a way that you need.<\/p>\n","protected":false},"excerpt":{"rendered":"
[Estimated Reading Time: <\/span> 4<\/span> minutes]<\/span><\/span> 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.<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","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":true,"jetpack_social_options":[]},"categories":[4],"tags":[244,245,52,292,13],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_shortlink":"https:\/\/wp.me\/p1TKYv-vg","jetpack_sharing_enabled":true,"jetpack-related-posts":[{"id":1658,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/1658\/","url_meta":{"origin":1938,"position":0},"title":"Crash Bang Wallop, What a Picture!","date":"19 Sep 2013","format":false,"excerpt":"The fourth and final part in the not-as-short-as-I-thought-it-would be series on building a camera app for Android using Oxygene. In this penultimate instalment we will add the capability to actually take a picture. But that won't take very long, so then we will spend a bit of time tidying up\u2026","rel":"","context":"In "Android"","img":{"alt_text":"Very Ugly Duckling","src":"https:\/\/i0.wp.com\/www.deltics.co.nz\/blog\/wp-content\/uploads\/Screenshot_2013-09-19-19-38-56-1024x640.jpg?resize=350%2C200&ssl=1","width":350,"height":200},"classes":[]},{"id":606,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/606\/","url_meta":{"origin":1938,"position":1},"title":"Learning Experiences – Moving The Execution Point Pre-Delphi 2010","date":"18 Oct 2009","format":false,"excerpt":"Thanks to commenters I have already learned two useful things as a result of yesterday's post, both things which I cannot fathom how I did not already know. \u00a0But here's something I learned for myself as a result of a comment made by Malcolm Groves at the Auckland Delphi 2010\u2026","rel":"","context":"In "Delphi"","img":{"alt_text":"","src":"https:\/\/i0.wp.com\/www.deltics.co.nz\/blog\/wp-content\/uploads\/New-EIP-300x286.jpg?resize=350%2C200&ssl=1","width":350,"height":200},"classes":[]},{"id":2086,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/2086\/","url_meta":{"origin":1938,"position":2},"title":"ADB WINLOG 1.0.1 – RELEASED!","date":"04 Nov 2013","format":false,"excerpt":"Are you doing Android development ? Whether you are using Delphi or some other Android development tool a key tool in the Android developer's toolbox is the logcat command, part of the Android SDK. But it can be a little... how to put this kindly... crude. So I put together\u2026","rel":"","context":"In "Android"","img":{"alt_text":"ADB WINLOG 1.0.1","src":"https:\/\/i0.wp.com\/www.deltics.co.nz\/blog\/wp-content\/uploads\/Screen-Shot-2013-11-03-at-19.56.37-.png?resize=350%2C200&ssl=1","width":350,"height":200},"classes":[]},{"id":825,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/825\/","url_meta":{"origin":1938,"position":3},"title":"Class Helpers – A Hackers Cloak of Respectability","date":"09 Nov 2011","format":false,"excerpt":"Mat DeLong just posted another great example of when not to abuse class helpers in Delphi (though I should add that he didn't seem to see it that way). :) But you don't need helpers to do what this technique achieves, and in my view you really shouldn't be using\u2026","rel":"","context":"In "Delphi"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":2511,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/2511\/","url_meta":{"origin":1938,"position":4},"title":"Anonymous Classes: Implementing Interfaces","date":"11 Feb 2017","format":false,"excerpt":"A few years ago (2011 to be precise) someone asked a question on StackOverflow about support for anonymous classes in Delphi. The reason for the question was that the poster was trying to use Delphi to develop for Android and on that platform the widespread use of callback interfaces makes\u2026","rel":"","context":"In "Android"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":295,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/295\/","url_meta":{"origin":1938,"position":5},"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":[]}],"_links":{"self":[{"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/posts\/1938"}],"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=1938"}],"version-history":[{"count":3,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/posts\/1938\/revisions"}],"predecessor-version":[{"id":1942,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/posts\/1938\/revisions\/1942"}],"wp:attachment":[{"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/media?parent=1938"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/categories?post=1938"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/tags?post=1938"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}