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

Beta Alert!

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

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 pistol...um...actually 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 meeting....today....at 9:30.......um, 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 months....by someone other than yourself.....who quit because they won the lottery.......you 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 step...documentation.....uhgh.....talk about a Damnbeast.

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")
a.SetValue(_s)

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.

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 cooperate...at 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
lef
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.

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:

Lacedaemonians|60|Menelaus
Boeotians|50|Thersander
Minyans|30|Ascalaphus
Arcadians|60|Agapenor

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
a.getfile("C:\qm\ships.txt")

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 computer....um...ok 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)
,b.getl(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).

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


NEW-NEW BETA OUT!

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

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
mesText=
;Hey guys you gotta check this out.
;
'Ad
url.getsel
mesText.from(mesText url)
mesText.setclip

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
mailto="mailto:Ender@battle-school.mil;Bean@battle-school.mil?subject=subHere&body="
subj.getwintext(win)
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
mesText=
;Hey guys you gotta check this out.%0D%0D
'Ad
url.getsel
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.

!!! ALPHA ALERT !!!

Lookout! I just started using the new alpha of 2.2.0.6 and it's got some really nice features.
I'm not entirely sure because I can't compare to the 2.2.0.5 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!