Monday, August 20, 2007

QM Quickling: OnScreenDisplay

OnScreenDisplay("Opening FireFox" -1 0 0 "Arial Black" 30 0xff 4 "FF_Start" 0x343434 )

So, this one has been floating around in the forums for a while and I thought I'd give my slants on it.

When I'm starting a program or a process that might take more than 1 second, I like to give a visual confirmation that it actually did start. For instance:

So, here's how the parameters break out:

  1. your text. you can also use a string variable instead. OnScreenDisplay(strText)
  2. the time the display stay on screen. the default is 0 (5 seconds) or -1 for indefinite.
  3. the X Y coordinates of where to put the top left corner of the box. 0 0 is the middle of the screen.
  4. the font name (mine is "Arial Black"). I get mine from the font drop-down list in Word.
  5. font size (mine is 30).
  6. font colour in hex. I use Pixie but you can try to do it online but I don't know how safe the site is.
  7. flags. Note: you can add the numbers together to have it activate more than one state (i.e. 6 is number 2 and number 4).
    • 1 - nontransparent. The background in transparent or not (not supported on Win98/Me).
    • 2 - synchronous. The macro pauses till the text disappears (see #2 above).
    • 4 - the user can click to hide the window.
  8. you can create an easy handle for the display window. For example, clo win("FF_Start")
  9. background colour in hex
  10. wrapwidth. this will create a multi-line display box with this number as the width (I didn't use it here); very handy for string variable texts.

Here is another format I use for a differ process.
OnScreenDisplay("Removing Dups...please wait" 0 0 0 "" 18 292929 4 "Rmv_Dps")

Ok, so now you have 5 days to put this into your code or I will mail you macros back to you in a function at a time.

Sunday, August 12, 2007

QM Quickling: FIND

_i= find(a "5")

This topic has hit the forums a lot lately and so I decided to do a little something on it.

'Find' is one of those funny little functions that returns a number instead of assigning it's value to a string like 'findreplace', 'left', etc. What it's doing is giving you the position of the first character of the sub-string that it finds. Here's an example right out of the Help document (press F1 and surf in there for a while it's really well done).

str s = "Notepad.exe"
int i = find(s ".exe")
out i;; now i is 7

Things to remember:

  • it is zero indexed so you need to remember that the first character is in position 0 not 1.
  • because it is zero indexed, the position returned for the last character will be 1 less than the length of the string.
  • if there is more than one line, the "newline" character in the Windows world is actually 2 characters. Here's an example of that:
    • int z
      str a=

      _i= find(a "3")
      out z
      out _i

Find is useful even if you don't care where in the source-string the string lies. For example, if you just want to know that it is in there somewhere, just test to see if the number returned is greater than '-1' which is what is returned if it is not present.

Ok, so now you have 5 days to put this into your code and learn the Feng shui of 'find'.

Monday, August 6, 2007

QM Quickling: Intro

The summer break! What a deal, everyday sit there and say, "holy cow it's been a long time since my last lesson; what am I gonna do?!" Well, since I've been busy doing some job hunt stuff and I still haven't made that million dollars I was hoping to get when I started blogging, I've decided to declare "Bloggging Bankruptcy" and start afresh...or call it "The Summer Break". Well, that's not entirely true. What I have been doing is thinking about making more posts about functions all in themselves in addition to full-blown lessons.

So, be looking for the "QM Quickling" (QMQ) which will be short synopsis of various functions and how to put them to use. This week's QMQ will be on incorporating 'find' in your code.

Tuesday, July 10, 2007

Lesson 6: The Extra Mile

Well, there are other options to dealing with dialogs....don't.

I use Winamp as my media player, not just because I can make it do strange and very useful little things but because I hate llamas. I have macros that will let me move forward and back in the media being played by 5 seconds, 30 seconds, and 3 minutes. I can also grab the current position of the playing media and save it to a text file sort of like "bookmarking". Now, of course you can do this via the buttons on the player and dialogs but it's clunky and not very responsive, so here's what I do.

I went nosing around the SDK for Winamp and got a hold of their 'WM_COMMAND Messages' definitions and menu ids. Now, instead of using a mouse command 'click here' on 'this window', I can forgo the whole graphical interface and it's associated problems. Here's how I'm moving 5 seconds forward or back using QM.

men 40144 win("" "Winamp v1.x") ;;Back 5 seconds
men 40060 win("" "Winamp v1.x") ;;FFwd 5 seconds

This responds MUCH faster via a trigger key than even using a mouse click manually but it's "faking" a menu choice. And, if I know I want to move 30 seconds forward (for skipping commercials on, guys...but I do watch the interesting ones...and GoDaddy ain't one of 'em), I use this code:

int hwnd=win("" "Winamp v1.x")
if(!hwnd) ret
_i=SendMessage(hwnd WM_USER 0 105)
_i+30000;;time to skip in miliseconds (this is 30 seconds)
SendMessage(hwnd WM_USER _i 106)

If you look closely, you'll see that I'm using the 'SendMessage' capability to get the current position in milliseconds (105) and then sending a new value back to the player (106). I get remarkably fast response times when doing this; the video at worst barely even stutters. This is much better than even using my above macro repeated 6 times.

Once you start getting a feel for what the 'SendMessage' commands start returning, you can really start cooking up some useful things. For instance, when I get a hold of a really good tune, I have a tendency to listen to it for 5 or 6 hours just repeating over and over. So, I came up with a quick method to force Winamp to do this. Since there is no setting for "Repeat Song" you have to build it from 2 settings: "Repeat Playlist" and "Manual Advance".

int y z
int hwnd=win("" "Winamp v1.x")
if(!hwnd) ret
z=SendMessage(hwnd WM_USER 0 251);;get repeat playlist value
y=SendMessage(hwnd WM_USER 1 634);;get manual advance value
if y+z=2
,Speak("Continue" 0 "" 0 100)
,SendMessage(hwnd WM_USER 0 635)
,OnScreenDisplay("Continue" 1 1000 10 "Arial" 0 0x1d60cd 0 "psa")
,Speak("Song Looped" 0 "" 0 100)
,OnScreenDisplay("Song Looped" 1 1000 10 "Arial" 0 0x1d60cd 0 "psa")
,SendMessage(hwnd WM_USER 1 635);;set man advance
,SendMessage(hwnd WM_USER 1 253);;set repeat

Since I want this macro to 'toggle' this state of 'Song Looped' rather than merely just 'turn it on', I have it use an 'if' statement to determine what state it is in and then reverse that state. I also tell it to give me a little audio feedback so that I know that the macro executed and let me know what it did (that's the 'Speak' function).

Now you have two ways of dealing with the GUI (or rather 1 way of dealing with it and 1 way of avoiding it). So have at it and I'll see you next time cause the hook always brings you back.

Monday, June 25, 2007


Well 2.2 is now gold! It's no longer beta and it's ready to roll.
There were a few upgrades to this version but only if you have Vista, otherwise, it seems to be a version history shake down.

I would like to see some of the new Vista toolbar settings in action though....hint, hint! 90)

Thursday, June 21, 2007

Lesson 6: Getting Stuck in the GUI Hacks

Getting Stuck in the GUI Hacks
GUI hacks are the processes that you have to create because you can't get at the option or method of doing something to/in a program. For example, a really ugly GUI Hack would be
  1. open Windows Explorer
  2. hit Alt-d and put in the directory you want to go to
  3. then hitting 'Tab' three times to get to the file list
  4. use the 'key' command to start spelling the name of the file you want so that it is selected
  5. type Ctl-c
  6. hit Alt-d to move to the address bar and put in the new directory
  7. hit 'Tab' three times to get to the file list
  8. hit Ctl-v

Of course no one would do this; that's what 'ren' or 'cop' is for but sometimes you just have to interact with program GUI dialogs. And God help me, I HATE GUI HACKS! There are just so many more things that can go wrong so many 'edge-cases' you have to account for...God help me but I hate them. Well, if you gotta you gotta so here's some ideas that might help.

Timing is everything in GUI hacking. If the dialog is slow to open, or if the field you need inside the dialog is slow to be drawn, or if...blah blah blah. The first thing I do to make sure my GUI hacks are going to work is put in 'wait's everywhere so that the macro 'paces' itself. Here's an example of that. Sometimes when I send emails via Outlook, I don't want a 'message receipt' nor do I want to keep a copy of the sent message, so I have a macro that changes the message property for me and then sends it. Here's what the dialog looks like.

As you can see, there are two check boxes I want to deselect; they can either be 'clicked' by the mouse (I find this less reliable for various reasons) or the values of the check boxes can be inverted by using keystrokes (Alt-r and Alt-n). First things first; I have to get the dialog to show up. I do that by using the "Accessible object actions" item in the "Windows, controls" button on the QM toolbar and drag the aiming reticle on top of the "Options..." button on the message I'm currently writing. This method works well enough but ask yourself what would happen if the toolbar that had that "Options..." button wasn't visible at the time; the macro would fail immediately (and so would my willowy grasp on sanity). I'd prefer a keyboard shortcut but I don't have one for it, so I make due. But now, I have to guess how long to wait for the dialog to show up before I start hitting my keystrokes....or do I?....Nope. Here's what I do.
0 WA "Message Options"
This is a version of the 'wait' command. The '0' tells QM to wait indefinitely for the window with the name "Message Options" to become 'active' ('WA'=wait till active). I pulled the window name directly from the QM Editor itself. When you have the editor open the status bar continually gives you information on both the cursor position and the window that it is currently hovering over. The window name is in the first row and comes just after the mouse position relative to the window. So now, when I start the macro, it 'clicks' the "Options..." button and waits for the dialog to become active; it then sends the keystrokes for the above check boxes and hits 'enter'. It then waits for the message itself to become active so that it can send the 'Send Message' command via an Alt-s keystroke.
spe 50
Acc option_a=acc("Options..." "DROPLIST" win(".*Message" "OpusApp" "" 0x200) "MsoCommandBar" "" 0x1001)
0 WA "Message Options"
0 WA "Message"

Now you may ask about the second line from the bottom and say, "Gordon Bennett, not ALL your emails can be tittled 'Message'!"...ok, so maybe you wouldn't say that but someone did....probably.....might have....well, ok they could have said it give me that at least.... Well, this kind of gets into the 'win' function which I should cover another time in depth but let's suffice it to say that, it is case sensitive and can be anywhere within the window name. Here's what my window's tittle bar actually looks like with a standard message.
There it is; a macro with built rest stops (but smells better) for when you just 'have' to GUI hack.

So have at it and I'll see you next time cause the hook always brings you back.

Monday, June 18, 2007

Beta Alert: ROUND 2! is out now.
Looks like Gintaras forgot to roll in a feature he'd promised on the forums.

  • Popup menu expandable folders: removed flag 64 (apply include/exclude to folders), and instead added /filterfolders.

Beta Alert!

New beta is now out (download here).
Not a lot of ground breaking things but some enhancements for the deep end programmers.

  • Better supports ActiveX controls.
  • Adding files to exe.

Monday, June 4, 2007

Paying the Automation Monkey

Well, I had an interesting discussion with a friend of mine the other day; let's call him "Dimitri". He told me about a reporting project that he was doing where his "superiors" were loath to allow him to automate. As you can tell from one of my posts, I'm not really hip to that sort of....well, I really can't express how I feel about that without offending a LOT of people and risking a visit from the FBI, Homeland Security, and theEYP (why the EYP ?...well, I can't into that either...but it was a total misunderstanding I swear!)...not to mention a courtesy call from the ELF. So, let's just say, "I am somewhat opposed to management outright denying permission to automate a re-occurring process." And what struck me most abhorrent about this situation was not the, capricious Jimmy Carter style micro-management of high-level technical staff, but the apparent lack of understanding of time/worker management or rather the limited understanding of what it costs to actually have people do things....No, I will say it plainly....The COMPLETE lack of understanding math....simple A+B+C+D+E=F kind of math. These are people that manage people for a LIVING for crying out loud; this is not a hobby they do; this IS what they do to eat and buy jet-skis. Stop drinking theKool Aid and take a work-force management course for crying out loud....ehmmm...ok, I'm done....for now....anyway...back to Dimitri. Here's the story.

For the next couple of years,
Dimitri is going to be running a diagnostic on systems within his organization and receive a small amount of output from that process. One of his higher-ups, wanted him to put that info into an email and send it out to everyone on a distribution list. He said that he could do that but none of the info from the diagnostics would be useful or informative for anyone but himself and to send that out would be a waste of time for him and everyone on the list. About that time, another higher-up got involved and started demanding the info be in a file and not just in an email and not just any file format but a spreadsheet. At that point, Dimitri went to his supervisor (yes, this is now the 3rd higher-up mixed up in this mess) and told him about the problem this TPS report has now become. His boss asked him if he could automate the file update process to which my buddy said yes, it is very easy unless you want it in Excel, then it will take at least a 2-3 hours for him to get some info on Perl/Excel functions (or maybe have me code something up in Quick Macros for him). After hearing how long it would take to automate, one of the two original higher-ups came to my friend's office and said, "It sounds like it's going to take more time to automate this than it will to just do it; so just do it manually for the next two years rather than automating it." Keep in mind that this person was not even Dimitri's boss.

And, it is at this point that I want to step-in and do a reality check..."Advertising doesn't cost; it pays."...Ok, well I don't have a cool saying for automation like the ad people do for advertising; well, there's "If you do something more than once, you're a sucker" but that seems overly rude at times. But, even that doesn't get to the point here. The point is that if you don't automate it, your going to spend more than that 1-3 hours to automate it. Here's why.

Let's say
Dimitri spends five minutes actually doing the process every week. He's going to need to train someone to do it in case he gets hit by a bus (or, God forbid, takes a vacation day). That person will, at some point, realize that they will need to show someone else how to do it as well, just in case. So, now we have a 15 minute training session for the first backup and a 25 minute training session for the second backup. But, if either the first or second backup needs to actually do the process, it's going to take them probably 15 and 25 minutes respectively to do it because it usually 'jumps up at them' and they'll have to scramble to do it which means they'll have to go track down the instructions and then go hunt down their id/password to get into the system to get the data file. So here's how it actually breaks down:

Primary and Secondary 15 min X 2 = 30 min
Secondary and Tertiary 25 min X 2 = 50 min
Running the Process ea wk 510 min = 510
All Goings-back and forth
talking @ automation 60 min = 60

Total 650 min or 10.8 HOURS

10 HOURS and 50 MINUTES! HOLY COW!!! And that doesn't even count the times that the secondary and tertiary run this process. The very worst case scenario for him to automate this project: 3 hours. Yeah, "It sounds like it's going to take more time to automate this than it will to just do it; so just do it manually for the next two years rather than automating it"...IN A PIG'S EYE! Look, I'm the second or third guy to admit that there are times when automating things just doesn't make sense but if you're going to count the cost then count the freakin' cost. There are times, like this one, where it is too expensive to not automate a project and that fact should be painfully obvious even to managers who manage overtime exempt employees. I'll lay it out for you this way:
  1. An employee only has "x" amount of minutes in a day
  2. No task takes "0" minutes to complete.
Have your six-year-old add it up for you!

Ok,, I'm coming off a little over board here; but it is a hard earned sense of indignation that comes from years of seeing "management" (read: "people who get paid more than the 'workers' but don't actually 'know' how to actually 'manage' them") going out of their way to not onlystifle worker productivity in the area of automation but actively seek out the proponents and developers of that automation to discipline with reprimands and down-checks on their yearlyevals.
It's all a big crazy game that they are playing up there and only God knows the rules cause to me it looks like a varsity game of Calvin-Ball.

Simply put, this is what I'm trying to say, "Automation doesn't cost you time; it pays everyday with interest."....GAHHHH....that was terrible!...see, I still don't have a good catch-phrase for automation....let's just stick with this:

"If you do something twice, you're a sucker."

Friday, May 25, 2007

RELEASE ALERT: New Beta is Out

The new Beta is out; mostly under-the-hood enhancements but there may be a few things of interest.

  1. computer unlocking that now works on Vista
  2. made the exe's smaller

Wednesday, May 23, 2007

Beta Alert!

The new beta,, is due out this week possibly 5/23!

Friday, May 18, 2007

The Evolution of Automation

After 5 lessons (well, 10 really), I thought I'd pause and take a look, not at specific automation code, but how automation evolves out of current processes. One of my first posts on this site was about the reasons to automate (I'M HAVING AN INDIGNATION MEETING). It gave four reasons why to automate and I've spent the last five weeks showing how to automate. In this article, I want to discuss how current processes evolve into an automated process in an office environment (can you use anymore Darwin buzz words without talking about 'Natural Selection'?!). There were a couple of surprisingly useful developments in a recent project that I hadn't actually planned out but just organically evolved when the project came to critical junctures.

The other day a project came across my desk that needed some updating. For some time, I've been retrieving some text files via a secured web server and adding some html to the contents to deliver to end users via a different secured web connection. Due to the security setup at my organisation, there had to be a lot of 'tweaking' done to make the automation server (let's call it 'Athens') connect with the data server (let's call it 'Carthage') as well as the machine that was to be the final resting place of the data where the end users will access the report (let's call that one 'Hellespont'). The process was executed by a 7 year old VB exe that frankly was a pain to deal with. Removing reports were a pain; adding reports were a pain; not fubar-ing the entire process doing either of the above was a pain...Not knowing what you were doing with VB was a pain. The whole thing was enough to make you ignore it till you could get your hands on an Impala outfitted with a military class JATO rocket, put the entire source-code and exe in the front seat, flip the switch, sit back and watch the glory. Well, as it turns out, the final security piece fell into place before I could get my hands on that JATO and I knew it was time to grab a large-caliber handgun, a tac-light, and crawl into that Damnbeast den (better make it machine two (John Woo style you know)....with extra ammo..all armour piercing of course...(the bullets not the pistols)...although....armour piercing pistols....hmmmmm...anyway). I then started to map out how I was going to make this thing work.

My first decision was to make it easy to add and subtract reports from the process (see above). I didn't want to code each report into the function separeatly because that would take a 10 line process and make it 'the-number-of-reports' times 10 lines. In case you weren't sure of what to call that, it's called 'Ugly and Kludgey'. I decided to create a text file that would contain the address of each report needed on the server Carthage, as well as, the final name of the report when I place it on the server Hellespont for distribution. These two pieces of info would be separated by a '|' character. It is just a very simple text document that I can step through one line at a time using 'foreach' to parse the file and and 'gett' to parse the line. The file is sort of a 'definitions' file. This method has several benefits:
  1. to add a report, I just add one line to the end of a text document rather than opening up QM to add like 10 lines of code to the 180 that are already there (if there were say 18 reports). When I say 'I', I'm really saying 'any of my co-workers' who need to add a report later on because I got hit by a bus or won the lottery.
  2. to remove a report, all I have to do is delete one line rather than opening up QM and deleting like 10 lines of code. When I say 'I', I really....well you get the point....It's called Agile baby!!
  3. If reports are added or deleted, there's no need to make 'versions' of the program (like we do now) because I'm not actually changing the code.
So, now that I have my list of reports and can get info on each of them individually, I need to build the routine for Athens to get them from Carthage..... And here we have all this simple and wonderful code using cURL to retrieve the files from Carthage and load them each individually into a string variable . I'm not going to go into... (wow, that didn't work well at all)...I'm not going to go into what I'm doing to get them or how I'm manipulating them (maybe I'll go over that another time); I'll just say that for https retrieval, cURL is really, really, nice!

So, to sum up, I've retrieved the files from Carthage and modified them so they look better for the end user and then placed them out on Hellespont for the end user. When I ran it the 'first' time it worked great till I realized one of the reports is no longer used. No problem, all I have to do is delete that line and....wait....that is never a good idea when dealing with capricious users (or any for that matter). I'll tell you a little principle I've developed in my years of report design. The report that has not been looked at for over a year by a single living soul will never even be thought of until you delete it from your report delivery system. Then an admin assistant is on the phone saying they want it....oh, and they want it for a, it's 9:40 now....yep. And here it is in business speak:
The value of a report is not based on its actual use or even its usefulness but rather directly on its difficulty in recreating its process after it has been discontinued....for six someone other than yourself.....who quit because they won the just wish they would get hit by a bus....while you were driving it.....which is what you'll be doing for a career if that admin assistant doesn't get that report printed within the next 10 minutes.
I don't have a catchy name for it yet but now that it's published I have a copy-write on it 80) ....BTW: I'm taking suggestions for the name.

So, as you can see, I'm a little reluctant to just delete the report entry. [Enter Stage Right: Comment Delimiter] ....Ooooh, excellent! Comment delimiter! I can actually use almost any character since all the report addresses have to start with the '/' character. I chose to use the '#' symbol because I'm used to it when I'm doing Korn shell work in Unix. My next step was to use 'find' in a simple 'if' statement to skip the entire process if the first character is a '#'. Done. Now I can keep that report ready in case someone wants it again.....wait a minute....I can also use a 'Comment Delimiter' to do things like 'make comments'...just in case I'm found guilty of a crime for hitting that guy with a bus and have to go to prison or something...yeah, I know, long shot; no jury is going to convict me of 'painting a new center-line' with that guy after deleting that report process without documentation. So without any extra code, I've also added the ability to place as many comments as I want anywhere inside the file as well as deactivating reports.

The 'definitions' file and the commenting capability were things that weren't specifically planned on, they just 'grew' out of the process as it went along. It solved problems I hadn't realized and became more and more useful as the project progressed. The comment capability really makes the whole project much more Agile since anyone who comes in behind me can easily find out what I'm doing from the comments in this definitions file. Which leads me to the next about a Damnbeast.

Monday, May 14, 2007

Lesson 5: The Extra Mile

Ok, so there's more than one way to skin a cat and there's more than just a few ways to get text into a window. This next method is much more complicated but hang with me; if I can do it, I think you will be able to as well.

Go to the "Windows, controls" icon on the QM Toolbar and go down to the "Accessible object actions" menu choice. This opens up a dialog that looks like this:

Take a look at all the different actions on the left-hand side. These will really start to open up your possibilities as you get more and more skilled at QM (or as some say, 'more kung-fu'). In this lesson, I'm just going to be dealing with the 'Get value' and the 'Set value'.

Let's start with a text editor of your choice; I'm going to use Notepad but you can use anything you like. First, let's set the value of a window/field or whatever you are wanting to change. Click on 'Set value' and then click-and-hold the 'Drag' icon; drag it over and drop it on the part of the window for which you want to set the value.

You'll notice that there is a thick black line surrounding the parts of the window as you hover over them. Let go of the mouse button when you have selected the right part of the window. QM now shows you what it 'sees' of that area.
Most of the time, you'll need to modify the 'Window' title; you can do that by clicking the button with three dots right next to it. You'll see this dialog after doing so.

The first thing I usually do is start adding wildcards to the Title. So, '- Notepad' becomes '*- Notepad'. Don't forget to also check the 'Use *' checkbox below! There are other options you can modify but I rarely have to.

There are also other values you can change in the main dialog too but I'll not be covering that in this lesson. So, now my dialog looks like this:

You can change the variable assignment if you wish within this dialog before letting QM enter this info into the macro. Now, hit 'Ok' and it puts this info into your macro.
Acc a=acc("" "TEXT" win("*- Notepad" "Notepad" "" 0x3) "Edit" "" 0x1800 0x0 0x20000040)
a.SetValue("Hey, set this value.")
Now that we have a target, let's start putting in the info. As you can see, the second line of my code is already doing just that. I can also have it set the value using a variable as well. Now, the thing to keep in mind about this function is that it will erase anything that is there already....unless......
_s=a.Value();;this, of course, gets the value
_s.from(_s "[]Now it's both values")
Yep, that's just what we were looking for. Now, you can 'append' info to the window by feeding its value back into a variable and manipulating than variable. You may not want to use this technique for more than small dialog fields but who knows, it may be just the thing you're looking for in that hard to get-at window.

So have at it and I'll see you next time cause the hook always brings you back.

Thursday, May 10, 2007

Lesson 5: Swimming The Keystroke

By this time you've probably started to out pace these lessons or at least come across problems you've had trouble solving when it comes to entering text. Some windows just don't all. Well, like ancient archers who picked certain arrows for certain jobs, you can do the same with keystrokes methods. So far, I've covered 'outp' with quoted text and with strings but there are two other ways as well: the 'key' function and QM key-codes (QM uses special characters to represent the special keys like Alt, Ctl, Shift, etc. (well, not 'etc' that's just one of those Latin things; it's not a keyboard thing)). Let's start with the apostrophe first.

Look at the QM Toolbar that starts up with the Editor; the second icon opens a dialog to show you all the special characters. You can start using these very easily by invoking the function with an apostrophe like this ' .

Note: I'll be taking many of the examples directly out of the QM Help. BTW: you can easily access the help documentation and go to the function you are curious about by just placing your cursor on the function and hitting F1; often times there is a very well documented article on the function (sometimes the help text appears in the output window below the editor instead).
'CSf A{ec} Wd ;;Ctrl+Shift+F, Alt+E+C, Win+D note: the Alt key is released after the c key
'SnewVSyork ;;type "New York" using QM key codes

The apostrophe is a quick and dirty way of getting text to type rather than pasting text via the 'outp' function. The 'key' function works similarly but has more flexibility. Here is how those examples would look when using 'key'.
key CSf A{ec} Wd ;;Ctrl+Shift+F, Alt+E+C, Win+D note: the Alt key is released after the c key
key SnewVSyork ;;type "New York" using QM key codes

Yeah I know but that was just to show you how it looks; now let's really get into it.
key (VK_MEDIA_PLAY_PAUSE) ;;Mimics hitting the Play/Pause button
key a (0.5) b ;;a waits 0.5 second b

Here's another way of doing multiple keystrokes while holding down modifier keys. You can put all kinds of things inside that block; not sure what other types of things you would want to though.
key+ CS
key- SC
'Key' will also let you feed the contents of a string variable into it. So, you can easily create the variable value from any other method and then you can have 'key' type it in. This works especially well for a telnet program I use that won't allow direct pasting into the command line.
key _s
Now usually, you won't have to go to such drastic measures just to input some text but if you need it (like in my telnet program) you've got it. Granted, it's not particularly strong me (mĀ), but when you gotta have it, you gotta have it.

So have at it and I'll see you next time cause the hook always brings you back.

Monday, May 7, 2007

Lesson 4: The Extra Mile

For me string variables are the sonic screwdriver of coding. I use them to build not only the functions I need but the logs that monitor them, so being able to manipulate them is crucial for doing the things I want.

Let's take a look at the whole log file concept. I have a text file that is filled with lines of text something like this:
The first thing you need to do is get the file data into a string so you can start modifying it.
str a b c
int z

Now lets get just the last line of that text file by using two different functions.
b.getl(a (numlines(a)-1) 2)
out b
The 'getl' function first asks you for the string from which you want to get the line (variable 'a'). The second part is a little trickier; the 'numlines' function tells you how many lines are in the string 'a', but the '-1' needs some explaining. The 'getl' function is what is called 'zero-based' which means (it's terribly annoying and prone to 'one-off' mistakes) it starts counting at '0' not '1' just like a yeah, that does make sense now but it's still annoying. So, it has 4 lines but the last line is 3 hence the '-1'. So now 'b' contains the last line of 'a'.

Now, let's remove the line that we loaded into 'b' and put it back into 'a' but in the 2nd position.
a.RemoveLineN(numlines(a)-1);;this removes the line at the end (that we just copied) so it won't be duped.
a.InsertLineN(b 1);;again zero-based function.

out a

For the next step, let's add a new line. This new line can come from anywhere i.e. a file, the clipboard, or text selection, but here I've just set 'b' to it and then dropped it onto the end of 'a'.
b="Salamis|12|Telamonian Ajax"
a.addline(b 1)
out a
A note about the flag used on line two (not zero-based 80) ). The '1' tells 'addline' to not add a 'new line' character at the end of 'a'.
A note about flags: flags are just parameter codes for functions that allow you to modify the basic behavior of a function.

Now let's say you want to pull out the last part of each string and take a look at it (e.g. Menelaus, Thersander, Ascalaphus, etc). Here's how to set up the loop and grab the last section.
rep numlines(a)
,c.gett(b 2 "|[]")
,out "c=%s" c
Note: the commas are another way of indenting the code within the QM Editor. However, when you copy/paste the code into another program, the tabs are replaced with commas. If you copy the code above to your QM Editor, you'll get the commas unless you use the menu Edit -> Other formats -> Paste escaped option.

Now, about the code, I'm using the 'numlines(a)' instead of checking for the error code output from the 'getl' just as a matter of preference (I'll explain more about that in a minute). The 'getl' is missing the line number to pull but when that value is missing, it just pulls the next line; you could use an incrementing integer but this is simpler. If, however, there is no next line, the 'getl' function returns -1; it would be that -1 that you would check for if you didn't know exactly how many lines where in the variable. The real money maker is the 'gett' or 'get token'. Think of a token as a 'chunk' of the string. To break up each line, I've used the pipe character '|' as my delimiter because it was very unlikely to show up in the data. But I also have the '[]' within the 'gett' command in its delimiter section. This tells QM that the last chunk of data in a line will end at the new-line character. Otherwise, it will grab the next line's first section (you can try it out to see how it affects the data pull). And finally, you'll notice that through out this lesson I've been using the 'out' command to monitor my changes in the data but I've used a modified version of this at the end to include some prefix text to identify the variable. This technique really comes in handy when I'm debugging and vetting several variables at once and it can contain many variables on the same line as well as identifying them.

So there you have it, some of the really useful string functions. And if you really want to turn it up, you can start getting into using 'replacerx' and Regular Expression coding...not that I would know anything about that. ;o)

So have at it and I'll see you next time cause the hook always brings you back.

BTW: Here's the entire code block to make it easy to import into the Editor (don't forget to use the Paste-Escaped option).

str a b c
b.getl(a (numlines(a)-1) 2)
a.InsertLineN(b 1)
b="Salamis|12|Telamonian Ajax"
a.addline(b 1)
out a
rep numlines(a)
,c.gett(b 2 "|[]")
,out "c=%s" c

Saturday, May 5, 2007


There was a bug in the new beta; if you have you should upgrade ASAP (turns out the predefined variables got unassigned).

Thursday, May 3, 2007

Lesson 4: String Theory

Sorry, this post won't have anything to do with gravity wells, point particles, or CERN so you can keep your boson particle "foam fingers" in your truck (however, I do like me some tailgate grilling action so feel free to fire up that Grill Master 3000 and make my buffalo steak well-done ... WOOT!). Though I can't tell you the foundation of reality or, more importantly, what's underneath reality that is so sturdy as to support reality's foundation, I can say this, "Variables are the foundation of coding" and especially so in macros. So crack open that 12-pack of Diet Coke and toss 'em in the cooler and let's get this party started.

To first use a variable, you'll need to declare it by telling QM what kind it is and what you want to call it. Here's what it looks like in the wild.
str a
That was easy enough but what can you DO with it? Well, let's start by giving it some values; which can be done several different ways.

str a="anything you want"
Note: the use of the double-quotes.

str a.getclip
This gets the contents of the clipboard.

str a.getsel
This gets the currently selected text.
str a.getwintext(win)
This gets the tittle-bar text of the currently active window.

Now let's put 'em into play. Let's say you want to create a macro that will grab the url of the current web page that you are on and send an email to your buddies (cuz they don't get enough of that stuff from their moms). In FireFox and I.E. 7, if you hit Alt-d the address bar is given the focus and the entire contents are selected. Let's put that into a string variable and the combine it with another string variable and then copy all that to the clipboard ready to paste into an email. Here's how we do it.

str url mesText
;Hey guys you gotta check this out.
mesText.from(mesText url)

Now there are some strange things going on in there so let's take a look.

First, line one is a shorthand way of creating more than one variable on one line. Second, the variable mesText is assigned a value rather oddly. If you set it up like this, every line that follows the 'mesText=' line that has a semi-colon or a space in the front (in other words, that are marked as 'comments' in the code) are assigned as the variable value. This allows you to set big blocks of text without it running all the way across the page and manually entering in the line-breaks (BTW: use [] as the escape-characters for a line-break in QM). Moving on, we have the 'get selection' function (this gets the url). And then, we have the 'from' function. Now, this is a handy one. 'From' allows you to combine (concatenate) two or more string variables and or text 'chunks' that are surrounded by double-quotes. To say it in a human language you would say, "Tack on 'url' to the end of 'mesText'." And then it takes the new value of mesText and loads it to the clipboard. All you have to do is: open a new email; paste it into the body; add a subject; and address it.

Ummmm....yeah....that's too much freakin' work! So, let's turn up the juice and see what shakes loose (MAN, I love quoting old 80's flicks!).

str url mesText mailto subj ;;I'm creating a bunch of variables at one time
subj.findreplace(" - Mozilla Firefox" "");;I'm just pulling out the 'Mozilla Firefox' part cuz I don't need it
mailto.findreplace("subHere" subj);;I'm injecting the url into the subject parameter of the mailto command
;Hey guys you gotta check this out.%0D%0D
mailto.from(mailto mesText url);;I'm 'stringing' them all together here
run mailto

Oh yeah, now that's lazy with a capital "L" baby efficient and helpful; besides, you've got better things to do than menial cut/paste you've got to defend the Frontier against Xur and the Ko-Dan Armada!

So have at it and I'll see you next time cause the hook always brings you back.

Tuesday, May 1, 2007


Lookout! I just started using the new alpha of and it's got some really nice features.
I'm not entirely sure because I can't compare to the build but I think you will have these new (among others) soon
  • Popup menus: Expandable folders, bitmaps and more.
  • A global hot key to show Threads dialog can be specified in Options.
  • Vista compatibility in both 32 and 64 bit versions.
  • Macro and function properties: "Run in separate process", "Run As".

The appearance of the alpha code means that the beta should be out soon; I'd say less than a week or even THIS WEEK!

Friday, April 27, 2007

Lesson 3: The Extra Mile

Ok, so now you've got your toolbar going. How can you really make this dog hunt? Let's get into the config and see.

If you go to your QM Editor and hit Ctl-F1, you'll open the help for QM. This is actually an extremely well documented program and the help is always my first stop. The first thing to do is click on the 'Index' tab and start entering 'Toolbar properties'; you'll notice that it jumps down the list as you type. Now, take a look at the entry for 'Toolbar properties'. We'll be doing some work in here in a bit but first open the properties of the toolbar (Ctl-p) and let's set it to open only when we have a certain window open.

Here's the properties window; now choose 'window' under the 'triggers' tab and then choose 'created and active'.

On the right you'll see a little icon that looks like a aiming reticle; click and drag that onto the window, who when starting up, will trigger the toolbar to open. You'll see it fill-in a bunch of info in the 'window name' field and probably the class as well. Edit the 'window name' field as needed as the toolbar will not open if the window tittle bar doesn't contain exactly what is in the field. For instance, if I want the toolbar to open when FireFox is started, it won't if I leave the value 'The Macro Hook - Mozilla Firefox' in the window field. To fix that, I'll just remove the first part and leave '
Mozilla Firefox' in there. I can also use the '*' wildcard by clicking the checkbox 'Use *' and put it in the field like this '*Mozilla Firefox'. And if you really want to let your Geek-Flag-Fly, start putting in Regular Expressions by hand or via the 'RX' button.

Now, let's say you want to make this toolbar (which should have a few buttons on it) sit on top of the window's title bar. Here's what we do. Run the tool bar and right click on it. Click on 'coordinates' and then 'top-right'. Also, make sure that 'Auto-Select' is unchecked. Now adjust the size by dragging the edges around. Once you have the size set to the way you want it, uncheck 'Sizing Border'. Now move it into place by dragging it into place with the right mouse button. Once it is set in place, it should move with the size of the window to always be next to the 'minimize' button.

Here's what I'm seeing.

Nice and very usable but let's see what else we can do. Open up the properties again and click on the 'Toolbar Properties' tab. Here you can see all kinds of hacking potential (i.e. 'Shrinked width', 'Text Colour', and 'Bitmap') but let's take a look at just one for now, 'Opacity'. I love this one! Windows opacity can be set from 0-255 (255 being standard Widows opaque and 0 being completely invisible). Now, set the Opacity for 150 and tab over to 'Transparent Colour' and click the button that says 'Back. Colour'. Hit 'Ok' and close your toolbar and open it again for the changes to take effect. Nice huh? Now, go back to the properties and take out the value for 'Opacity' and just leave the 'b' in the 'Transparent Colour'. Hit 'Ok' and restart your toolbar.....Even better huh? Notice the differences in the two? No lines just like the programmer put them there.

So now you know how to: build a toolbar; make it look like you want; and assign it's existence to only a particular window. There's plenty more you can do like: use a bitmap for the background (gradients are nice for this); have them shrink out of the way till you mouse-over them; and set different icons on them. Digg into them and you'll see all kinds of uses for them.

So have at it and I'll see you next time cause the hook always brings you back.

Thursday, April 26, 2007

The Extra Mile....

The Extra Mile will be a few more days this week due to illness.



Lesson 3: The Toolbar

Ok, so we've gone over two different ways to access your macros or code quickly and easily: the Text-Sensitive Menu (TSM (which is the quickest and invisible)) and the Pop-up Menu (PuM (which is visible but only till you choose an option or cancel it). But, there is a third that is more permanent than the PuM; it is called the Toolbar (Tb). Of course you've seen this ever since you've opened QM as there is one connected to the QM Editor. So, let's get into it so you can start doing more with less.

Toolbars, Pop-up Menus, and the Text-Sensitive Menus are all about giving you ways to execute code quickly by trading off speed with volume. If you have more than a score of text-replacements or other macros that you try to put into a TSM, you can start to loose track of them and start to reenter them having forgot you put them in there two or three months ago when you last used that particular process. So, moving them to the PuM can help remind you of what you already have, but if you've had to categorize it with sub-folders and sub-sub-folders and thus it has become tiresome to keep pulling up the PuM and then navigate to what you want, then you're in the market for a toolbar. So let's get that started.

Create a new Tb by clicking File>New>New Toolbar

No screenshot for YOU; come back one lesson!

Now, let's start dropping in some entries: a few programs you're always using; a few websites; and a macro or two. And here's the code for my quick one so you can see what they look like.

IEXPLORE :run "$program files$\Internet Explorer\IEXPLORE.EXE"
WINWORD :run "$program files$\Microsoft Office\OFFICE11\WINWORD.EXE"
EXCEL :run "$program files$\Microsoft Office\OFFICE11\EXCEL.EXE"
The Macro Hook :web "";;come on if John C. Dvorak can do it...!
Quick Macros Forum :web ""
One Line
Unformat Clipboard

The first three entries I created from last week's lesson on the PuM by just dragging over some exe's from my file manager. The second group will take me to a couple of websites (again these were created by merely dragging over the icon that's in the address bar to the QM Editor). The last two are a couple of custom macros that I built to help me out so they won't look right (or work) in your Editor but feel free to add your own there.

When you first start it, you probably won't like how it looks. Here's what I got (whoops those macro icons didn't show up...I'll fix that in the next slide; look for green triangles).

Not very pretty, huh? But let's pull it cherry hot from the furnace that is our desire and put it on the anvil of our will and shape it to be the beast of burden we need....(ok, so I listen to a lot of George R. Martin.....and Roy Dotrice better be reading the next book...I'm talking to you Random House!). Let's transmogrify to the below description....(ok, so I like Calvin and Hobbes too....) it to fit this description:

  • vertical
  • with text
If you right-click on the toolbar, you'll see this menu. Click "Vertical" and "Show Text"

Right-click on it again and click "Miscellaneous" and take a look at the options there. Click "Equal Buttons" and see how it affects your Tb.

Now, just grab the lower right-hand corner of the Tb and adjust the size as you needed. For bonus points, try out the "Auto-Shrink" option as well....(I'm not going to tell you what it does but it won't affect you in any way that you'll need to start paying attention to your spam folder to fix).

So there it is, 3 lessons, three execution platforms: No-look, Quick-look, and Always-look. Play around and keep expanding because these machines are here for us not the other way around.

So have at it and I'll see you next time cause the hook always brings you back.

Tuesday, April 24, 2007

Automation and the Crippled Masses

GAAAAAHHHH!!!! this didn't post!....such an E-List blogger mistake!

There are times when, the planets are aligned,the solstice is here, and that monkey just popped off for a very thorough shower....and this, my friend is a story about such a time. The yin and yang of automation is summed up in one article; it reminds us that automation cuts both ways but the cutting isn't always bad....Enter Ferdy.

Meaninglessness - Worse Than Failure

Tuesday, April 17, 2007

Lesson 2: The Pop-up Menu

Well, here here we are at lesson two and you've already reduced your annoyance and saved yourself a tonne of time with the Text Sensitive Menu (TSM). And if you're like me you may have a hard time keeping track of all the items it the T.S. Menu. Have I got just the thing for you: the Pop-up Menu (PuM). The PuM can hold command strings or execute macros, just like the TSM, but you can pick these items from a visual menu rather than trying to remember them. So now that the hook has been baited, let's put it in the water and see what hits it.

Create a new PuM by clicking File>New>New Menu

The syntax for the PuM is pretty straight forward. The label (the name you want to show on the menu), then a 'space' character, then a 'colon' character, then the magic. Let's start with all those 'text-replacements' you setup in the TSM but can't remember to use. Since it's pretty straight forward I'll just show you what it looks like.

And here's the code (note: there are only three lines of code even though your browser may have wrapped them:

No Thanks :outp "Thank you for your concern but I don't need any non-perscription v!agr4."
Good Luck :outp "That is unfortunate about your current financial circumstances; I would help you, however I am already helping a wrongly deposed prince in Sierra Leone."
PPpbbbbtttt :outp "Your offer is very tempting as your rates seem to be very low, however I won't do my banking with someone who can't spell 'r3f1nanc3' correctly."

Since you have other things to do besides reply to spam all day (which I don't recommend by the way), here's another function of the PuM that will save you a tonne of time. Launch your favorite applications from the PuM.

It is insanely simple to to code the PuM to launch programs; just drag the icon into the Editor, and then....ummmm....ok, well there isn't another step.

Here is the code that is put into the Editor when I drop the program's icon into the Editor.
halo :run "$program files$\Microsoft Games\Halo\halo.exe"
And here is what the PuM looks like when I hit the trigger for it.

But after a program or two plus the text-replacements, things can get cluttered but here's how we can deal with that. You can create Sub-Menus to organize all the entries that are related.

To do this use the '>' (greater than) character to let QM know that the following is the name of the Sub-Menu. When you hit enter, the Editor automatically 'tab-indents' the lines that follow. Now you can move the line down into the Sub-Menu like this and drop in a couple of tabs to line everything up and then end the block with a '<' (less than) character so that your code looks like this.

Now you've got a place for that Text-Sensitive Menu 'run-off' that you can't seem to keep in your head. Plus, a quick menu for your most used programs.

So have at it and I'll see you next time cause the hook always brings you back.

Lesson 2: The Extra Mile

Lesson 2:The Extra Mile

Well, now that you've got your menu up and going, it has probably gone all Audrey II on you and has like a 100 lines in it by now. Like the Sub-menu, there is another way that you can further categorize the Pop-up Menu (PuM) by making several and have them tied to the specific program that you are currently using. But the problem with a bunch of PuMs is that, you have to remember all those triggers. So here's a plan to avoid that. I call it "Macro Stacking".

First split up your PuM items into program categories ( e.g. browsing, email, Excel actions, etc.) and create a new PuM for each category. Now, make a new macro with the trigger you want (mouse or keyboard or second keyboard). What you're going to do is use the "getwintext" string function to get the active window's Tittle Bar text and then use the "sel" function to determine which PuM is brought up.

Here is how it is coded:

sel _s 2
case "*- Mozilla Firefox"
mac "Menu3"
case "Quick Macros - *"
mac "Menu2"
case "QM Help"
mac "Menu"

This is pretty straight forward but I will make a few notes. First the '_s' is a predefined local variable for a string. There are also numerous other predefined variables but I mostly use _s and _i (integer). It saves a line of code by not having to declare it. The '2' after 'sel _s' is a flag that tells QM that the values in the select case will/may contain wildcards. You can also tell QM that the case statements need to be case insensitive with the flag 1. Or, you can tell QM that the case statements are case insensitive AND may contain wildcards by adding the flags together and putting a 3 there.

So there you have it; one macro to rule them all using 'Macro Stacking'. Now you can make all kinds of PuMs without having to sift though all the macros/code or Sub-menus that don't apply to the situation at hand.

So have at it and I'll see you next time cause the hook always brings you back.

Lesson 2:The Pop-up Menu

Friday, April 13, 2007

Soft Coding - Worse Than Failure

Soft Coding - Worse Than Failure

I wanted to include this article from Worse Than Failure even though it doesn't seem to apply to automation per se. It does however discuss hard-coding versus soft coding. And in the end drags the big-wet-greasy finger of automation across the line between hard and soft coding. Especially when you have automated your compilers and program distribution. In the end, what's the difference between an end user going in and removing or adding a record to a database that a program uses to create output and a programmer going in and doing the same thing in the source code along with an automated compiling script and executable distribution....I'd say, "Dang little, and a sight more reliable."

Anyway, it's a good read.

Tuesday, April 10, 2007

The Format

Well, I've just posted my first lesson here on The Macro Hook. I've laid it out differently than most. The lessons come in two parts. The first part is an introduction to the topic and the second takes it a bit further (thus it is called "The Extra Mile").

Comments are open and I do take suggestions but I have had to limit it to registered users only...cuz MAN, there are a lot of spammers and griefers out there!!!

So, enjoy and jump in on the discussions. Future posts will certainly be affected by your input.


Lesson 1: The Text Sensitive Menu

In the 1st article here at The Macro Hook, I'm going to show you how to make the T.S. Menu (TSM) your friend.

T.S. stands for "Text Sensitive" and is used for "text replacement" but that's kind of misleading to the new user. Think of the TSM as a way to write tonnes of text with just a few keystrokes. Let's dive in and I'll show you.

Ok, so here's the scenario involving email but this can work for text documents or spreadsheets, or anytime you need to type the same thing over and over. So, you have numerous people writing you; you basically want to say the same thing to each of them but don't want to write it every time. Here's how we do it.

Create a new TSM by going to "File">"New">"New T.S. Menu"

You will notice that it automatically calls the menu "T.S. Menu" by default but the name is selected and ready for you to type in your name or you can just hit enter and accept the default name (subsequent TSM will be called " T.S. Menu2", "T.S. Menu3" etc). The big blank box is called the "Editor"; it's where the magic happens.

Just a quick aside: the first line of your new T.S. Menu put in this code. I'm not going to go into what this does at this time because we have enough to cover but you can look at the help file to find out more about it.


So, lets say you want to always say, "Thanks for your input." in responding to these emails your always getting. Here's how we do that. In the Editor, type the "trigger text". For example, if you want QM to type out the above response when you type "nr" (nice response), your code would look like this.

nr :outp "Thanks for your input."

Now, we need to set your "trigger" for the TSM itself. While in the editor, press Ctl-P to get the properties dialog (you can also get to that by right clicking the macro name in the "List"). You'll see this dialog.

Now, click the "Keyboard" item in the list of triggers. If you hit the tab key after selecting the trigger method, it will take you to the "Hot-Key" field. Now hit just the letter of the keyboard shortcut you want to use. For instance, if you want your TSM trigger to be Control-Shift-t, just hit the "t" key when in the Hot-Key field and then click check boxes for Ctrl and Shift. Now, every time you hit Ctrl-Shift-t, you have engaged the TSM and it will wait for you to hit the trigger 'nr'. It will wait for 5 seconds for you to give it a correct trigger, at that time it will end the process. If you hit keys that are: not a trigger, click the mouse, or type a non-printable key such as....ummm....well, I would print them out here but they are non-printable (kind of like Schrödinger's cat so don't try to print them; you don't want to kill kittens do you?...EGAD MAN, JUST DON'T DO IT!....)....Sorry about that. It's just that I feel very strongly about quantum keystrokes.

So, now we're in business. Open a document in something (I like ConText) and hit your TSM trigger and then your text trigger; I'll wait for you........................Ok, good. Nice huh? Now lets make another that has a little more to it. Try this.

nr :outp "Thanks for your input.[]The ''Hofstadter-Moebius loop'' is actually very common in that type of computer.[][]R. Chandra"

Note: paste this in as one line of QM code.

Now, go try your triggers again.....AAAhhhhh....why did it to a new line character after "input."? Yes, you're right. The "[]" told QM to do a new line there. It's a very handy thing to have; it's kind of like a special escape character. Now, did you notice the odd appearance of the double-quotes? Well, that's a special consideration in QM (and maybe in other 3G or 4G languages too). When you're telling QM to "output all info between the next two quotation marks", you can't have it output the quotation mark because it thinks you're trying to tell it to stop outputting the text, so, instead you use two apostrophes instead. So, two of these ' equal one of these "

So there you have it; a quick and easy way to output a tonne of text with only a few keystrokes. Only you can limit the use of this technique; you can use it in text documents, web page forms, or even to beat down Digg spammers. 80)

So have at it and I'll see you next time cause the hook always brings you back.

Lesson 1: The Extra Mile

Lesson 1: The Extra Mile

Now that you've seen how to get the T.S. Menu (TSM) up and going, let's get into it a bit more.

Your T.S. Menu looks like this (note there are only two lines; your browser may wrap long lines):

nr :outp "Thanks for your input.[]The ''Hofstadter-Moebius loop'' is actually very common in that type of computer.[][]R. Chandra"

But you might also want to run your macros from the TSM as well; not a problem. Let's say, you want to trigger your macro "Date-Time" with the trigger dt; here's how you would do that.

dt :mac "Date-Time"

Now, when you invoke the TSM and hit 'dt', your macro runs instead of outputting text. But here's a nice little trick that you can do in QM. If you don't want to create a new macro, just code it in the TSM.

In QM you can run all the lines together by separating them with a semi-colon ';' instead of carriage-returns. Take your Date-Time macro for example. Here's your code:

str a
outp a

Nice and compact; easy to maintain; and efficient. Good job; you're really getting the hang of this. Anyway, so you want to have this code in the TSM rather than making a whole new macro; no problem. Here's how you're going to do that. Replace the 'carriage-returns' with a 'semi-colon' like this:

str a;a.time("%c");outp a

Now put that into your trigger line in your TSM like this:

dt :str a;a.time("%c");outp a

And there you have it. It makes complicated macros and functions a real bear-cat to debug or even to know what it's for, but it can be done and it can be better sometimes than making all kinds of new macros clogging up your List in the main window.

So have at it and I'll see you next time cause the hook always brings you back.

Lesson 1: The Text Sensitive Menu

Saturday, April 7, 2007


I was talking to a guy at work the other day and we were discussing automation. He was curious as to why I was so gun-ho about automation; I told him that my driving force behind it was "INDIGNATION"!! If we can send men to the moon with a slide-ruler, then surely there's a way that I can keep from typing the same lines over and over and over (no, I still do not administrate that system contact ITS).

Yes, it is obvious why you would want to automate processes but as this is the beginning of this blog I'll go ahead and outline them so we can all start on the same page. Besides, I'm betting I have one benefit that you haven't thought of yet. 80)

The first reason is to free me up to do tasks that the computer isn't good at, like: what do I want to have for second breakfast or does this keyboard make me look fat? You know, the important stuff. The second reason is, things are done more accurately when you let the computer do it. Of course, you have to have accurate code in there to begin with but that's what this blog is about. The third reason is so that the tasks get done even if I'm not there. No training, no frantic calls from the nearly dead cellphone trying to explain how to get a report published. And the fourth reason is that you only have to be polite once. It doesn't matter if this is the 17th time you've answered the question since you got into work (and you haven't even had elevenses yet!). You can be as mad as you want and cuss the users till you pass out and hit your head on your faux targh-leather messenger bag but your email response is just as sweet as honey-laced ambrosia served by a Jewish grand-mother who hasn't seen you in too long.

So, as we approach these up coming code examples remember to gird your loins with your best winter kilt of Indignation and drink deep the cup of Vexation and remember "If you do something more than once, you're a sucker."

Friday, April 6, 2007

AAAaaannnnd We're Off!!

So here it is. My first post on a blog that I hope makes me a million bucks (USD). In the end isn't that what all us bloggers are out for (yeah, I'm talkin' to you Johnny C. D.!)? That way we'll have more time to sit in a St. Louis Bread Co. and eat chocolate-chip muffins and surf...I mean, work.

So, here's a little synopsis of what I'm trying to do (besides make that million); I've been working in a scripting and execution environment called Quick Macros for several years now. I'm doing all kinds of really handy things in it and I want to help make your life easier (and make a million bucks). Each post will be about a concept or procedure to help you understand QM better and help you free yourself up more.