| GeoD_MTW |
|
Joined: 10-12-2009 08:07:49
Posts: 15
Location: |
|
|
|
|
|
Sorry for the delay, I've been trying to figure out how to simplify this macro and still have it makes sense. I finally gave up and decided to explain what I use this macro for instead.
A large part of developing the automation suite I'm working on is creating icons for the macro toolbars. They need to be consistent in their design and color, so the icons can impart the most clear information possible. I assigned pairs of colors to certain application types, and I chose a common font to use in all icons.
It wasn't long before I was spending a lot of time choosing which font size to use in a certain situation - what complicated matters is an issue with the icon app I was using. If I chose a capital T, size 30, the actual size of the font could be anywhere from 28 to 32 pixels high. It became a big waste of time using trial and error anytime I needed a letter, numeral or diacrit of a specific pixel size.
I decided to create an archive of character images of each letter, numeral and diacrit, in each size from 5 to 64. I would then have a reference image. If I integrated the font information into the filename, I would have a character image to insert into an icon, and also a quick reference chart by looking at the filename. Perhaps, over time I would remember what size actually came out when I chose a small 'e', size 33.
It's a big job to build a character archive of this size, so I decided to automate as much of it, as possible. It would make the job less time intensive and also expand my knowledge in macro writing.
As with many automation projects, the entire process of creating the icon image, incrementing it one pixel larger each cycle, naming and saving it is possible only by breaking it into multiple macros, especially at the beginning. After using it for a while, kinks, bugs and timing issues can be worked out, (speeding up or slowing down the macro for proper function OR inserting pauses of sufficient length so the user can 'proof' the results). Then it is possible to begin combining macros, with an end goal of having the minimum number of individual macros.
I don't try to always get one process into a single macro, sometimes it is just too much work with the end result being the process won't work in a single macro. What I do is to make the last command in the macro a cursor positioning command placing the cursor at the next macro icon in the progression. Try to combine a 'proofing' pause with the end of the individual macro, so you can proof, then click to start the next phase.
This cursor positioning technique also works well when you are still working to combine macros as it allows you to get the entire process working with less difficulty, giving you some time to use the tool, see how it works and figure out the flow: where you need timing commands, cursor positioning and other fine tuning aspects of creating a smoothly operating automation routine.
I don't remember how many macros I started with, but I managed to combine macros until I ended up with 4 macros in the routine, with 2 of them being special use macros not used in every cycle of the process.
The process begins by either creating a new image of the character I've chosen to work on or opening an old one. A new character image must be created manually, an old image need only be opened and then saved. (This is necessary to set the path to the filename and is a limitation of the icon app.) Then I execute the first macro:
icon..create.=.character..one.size.larger.'.delete
The icon application allows multiple icon sizes within a single 'ico' file. This macro increments the original character size by one font size, creates it and then deletes the original. ie: If I started with a size 32 character, the macro creates a size 33 character and deletes the size 32 original.)
The next macro is:
icon..save.=.character.reference.file
This macro saves the character reference file as per data entry and is the macro this post is all about. I have included the macro in two forms, the first is heavily annotated so you can figure it out, and the second is without the annotations.
The annotations will be in commented lines. If it is a single line annotation, it will be in the following format:
‹#› == single line annotation ==
If it is more than three lines, it will be in the following format:
‹#› == start.=.annotation ==
‹#›
‹#›
‹#›
‹#›
‹#› == end.=.annotation ==
When you see comments in the following format, note they are normal coding comments and will be in both versions of the macro.
‹#› ============== normal.coding.comment ==============
The macro shows a form offering data entry options for the different parts of the filename. What makes this work is a combination of variables in the form itself and a technique for identifying if this is the first run of the macro or repeat.
The end goal of the macro is to create a filename and save the current file with a filename of this format:
B.upper..48..(32)..comic.ico
The icon is a capital 'B', (B.upper), 48 pixels high, (48), which is actually a size 32 in the icon application, ((32)), and the font type is Comic Sans MS, (comic).
There are some situations where a character image is one pixel too big or small. ie: B.upper..32..(21+)..comic.ico, for example. A 32 pixel tall capital B cannot be made with a size 21 or size 22 character in the icon app. The 21 is 31 pixels high and the 22 is 33 pixels high. The macro has two naming options for this situation, depending on how I solved it. My choices are to use a 21+ or a 22-, that is, either add to a size 21 or take a row of pixels away from a size 22.
Now that I have explained the output filename, I'll explain how the macro works.
Note: I replaced the ‹ and › with Alt + 0139 and Alt + 0155. Using these characters tricks this stupid forum software into ignoring the ‹ and › in the code. I did NOT make the same replacement in the attached macro code.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
‹#› icon..save.=.character.reference.file
‹#›
‹#› This macro saves the character reference file as per data entry.
‹#›
‹#› save character reference file
‹#›
‹#› © 2011, George Dennison, all rights reserved.
‹#›
‹cmds›
‹#› == start.=.annotation ==
‹#› This 'if-endif' routine checks for the value of the variable 'ga_vCount'. The variable
‹#› designates if this is the first run of the macro. If it is, then numerous variables are
‹#› set to 'null' or 'NO'. Notice the variable 'ga_vCount', (and others), are global
‹#› variables. The value of a global variable persists outside of the macro until the value
‹#› is changed or the MTW is shutdown. Without using a global variable, this macro
‹#› would not work.
‹#› == end.=.annotation ==
‹#› item # 1
‹if›("ga_vCount==0")
‹varset›("ga_vChar=null","")
‹varset›("ga_vPixelSize=null","")
‹varset›("ga_vFontSize=null","")
‹varset›("vUpperPersDef=NO","")
‹varset›("vLowerPersDef=NO","")
‹varset›("vNumeralPersDef=NO","")
‹varset›("vRomanPersDef=NO","")
‹varset›("vDiacritPersDef=NO","")
‹#› == The 'goto' command included in the 'if-endif' statement bypasses the next ==
‹#› == 'if-endif' statement. This is largely an unnecessary command, but I find it ==
‹#› == easier to follow the flow of the code if I include them. ==
‹goto›("FORMSTART")
‹endif›
‹#› == start.=.annotation ==
‹#› This 'if-endif' routine checks for the value of the variable 'ga_vCount'.
‹#› The variable designates if this is a repeat run of the macro.
‹#› If it is, the variables are set to 'YES'. These variables are part of the macro's
‹#› ability to know if certain definitions are persistant, that is, repeated. The variable
‹#› name is descriptive of that: 'vUpperPersDef' determines if Upper (case) is a persistent
‹#› definition for the purpose of naming the file. There are five definitions: Upper (case),
‹#› Lower (case), Numeral, Roman (numeral) and Diacrit, (! # $ & - anything other than a
‹#› character or numeral.)
‹#› == end.=.annotation ==
‹#› item # 2
‹if›("ga_vCount==1")
‹if›("ga_vType==upper")
‹varset›("vUpperPersDef=YES","")
‹endif›
‹if›("ga_vType==lower")
‹varset›("vLowerPersDef=YES","")
‹endif›
‹if›("ga_vType==numeral")
‹varset›("vNumeralPersDef=YES","")
‹endif›
‹if›("ga_vType==roman")
‹varset›("vRomanPersDef=YES","")
‹endif›
‹if›("ga_vType==diacrit")
‹varset›("vDiacritPersDef=YES","")
‹endif›
‹endif›
‹label›("FORMSTART")
‹form_item›("FM1","","LINE","0","")
‹form_item›("FM1","","LINE","0","")
‹#› == start.=.annotation ==
‹#› This variable set in the form is to informs the macro if the full path to the filename
‹#› must be used, and if a new filename must be created, or if the existing filename can
‹#› be modified and the existing path used.
‹#› == end.=.annotation ==
‹form_item›("FM1","New File","CHECK","NO","vNew")
‹form_item›("FM1","","LINE","0","")
‹#› == start.=.annotation ==
‹#› Here's where we get into the meat of the macro. The text note tells the user to enter
‹#› data if the file is new or if any of the data is incorrect. The incorrect is what's not
‹#› typical. If you notice in each of the commands, the default variable value for the form
‹#› is the value of a variable, not a value. This enables the form to display values from
‹#› a previous run of the macro and is the key to how this macro works. Obviously, if new
‹#› data is entered, it will replace default value, if no entry takes place, the default
‹#› will be used. This undocumented feature in MTW enables a user to create forms that
‹#› minimize the amount of data entry necessary. It's surprising how much work
‹#› something this small can eliminate - it sure surprised me.
‹#› == end.=.annotation ==
‹form_item›("FM1","Enter data if new file, or if harvested data is inaccurate.","TEXT","0","")
‹form_item›("FM1","Character:","EDIT","%ga_vChar%","vCharInput")
‹form_item›("FM1","Height in Pixels:","EDIT","%ga_vPixelSize%","vPixelInput")
‹form_item›("FM1","Font Size:","EDIT","%ga_vFontSize%","vFontInput")
‹form_item›("FM1","","LINE","0","")
‹#› == start.=.annotation ==
‹#› These three buttons tell the macro if the font image is the default image or is
‹#› modified. This selection will determine if a '+' or '-' is included in the filename
‹#› & also starts the macro.
‹#› == end.=.annotation ==
‹#› item #3
‹form_item›("FM1","Select character modification method used to start.","TEXT","0","")
‹form_item›("FM1"," -::- Unmodified Font Size -::- ","BUTTON","NO","vNormal")
‹form_item›("FM1"," -::- Decreased Font Size -::- ","BUTTON","NO","vDecrease")
‹form_item›("FM1"," -::- Increased Font Size -::- ","BUTTON","NO","vIncrease")
‹form_item›("FM1","","LINE","0","")
‹form_item›("FM1","","LINE","0","")
‹#› == start.=.annotation ==
‹#› The following commands tell the macro if this is single or repeated use. Note the
‹#› inclusion of variables in the default value. This allows the user to visually
‹#› confirm, but eliminates the need for data entry if the macro will be repeated.
‹#› == end.=.annotation ==
‹#› item #4
‹form_item›("FM1","Indicate type of character.","TEXT","0","")
‹form_item›("FM1","Uppercase :: Single Use","RADIO","NO","vUpperSingle")
‹form_item›("FM1","Uppercase :: Persistent Use","RADIO","%vUpperPersDef%","ga_vUpperPersistent")
‹form_item›("FM1","Lowercase :: Single Use","RADIO","NO","vLowerSingle")
‹form_item›("FM1","Lowercase :: Persistent Use","RADIO","%vLowerPersDef%","ga_vLowerPersistent")
‹form_item›("FM1","Numeral :: Single Use","RADIO","NO","vNumeralSingle")
‹form_item›("FM1","Numeral :: Persistent Use","RADIO","%vNumeralPersDef%","ga_vNumeralPersistent")
‹form_item›("FM1","Roman :: Single Use","RADIO","NO","vRomanSingle")
‹form_item›("FM1","Roman :: Persistent Use","RADIO","%vRomanPersDef%","ga_vRomanPersistent")
‹form_item›("FM1","Diacrit :: Single Use","RADIO","NO","vDiacritSingle")
‹form_item›("FM1","Diacrit :: Persistent Use","RADIO","%vDiacritPersDef%","ga_vDiacritPersistent")
‹form_item›("FM1","","LINE","0","")
‹form_item›("FM1","","LINE","0","")
‹form_item›("FM1","","TEXT","0","")
‹#› == start.=.annotation ==
‹#› The following mouse cursor positioning command places the cursor over the form in
‹#› the 'most likely' position for cursor minimal movement and quickness in execution.
‹#› This particular position is over the second of the three buttons above. If all is OK
‹#› with the variable values displayed by the form, the user need only decide which
‹#› button command is appropriate. Small detail, but makes a big difference.
‹#› == end.=.annotation ==
‹wx›(150)
‹mm›(1178,850)
‹wx›(250)
‹form_show›("FM1","Save Character Reference File","S:\Icons\#...macro.toolworks\icon..save.=.character.reference.ico",0,500,1,1000,500)
‹if›("_vCanceled==1")‹exitmacro›‹endif›
‹#›
‹#› == start.=.annotation ==
‹#› This group of variable set commands are housekeeping in nature. The variables are
‹#› assigned values later in the macro but the values may not be correct in the next
‹#› execution of the macro. They are set to empty or are assigned the data entry values
‹#› from the form. '_vStrEmpty' is a MTW system variable used to designate that a text
‹#› string is empty. It's the only way use can assign a null value to variable used in
‹#› outputing a string of text.
‹#› == end.=.annotation ==
‹varset›("vPixelSpacer=%_vStrEmpty%","")
‹varset›("vFontSpacer=%_vStrEmpty%","")
‹varset›("vChar=%vCharInput%","")
‹varset›("vPixel=%vPixelInput%","")
‹varset›("vFont=%vFontInput%","")
‹#›
‹#› == start.=.annotation ==
‹#› These three 'if-endif' routines are in response to the value check of the variable
‹#› 'ga_vCount' at the top of the macro, (see item # 1).
‹#› == end.=.annotation ==
‹if›("vCharInput==null")
‹varset›("vChar=%_vStrEmpty%","")
‹endif›
‹if›("vPixelInput==null")
‹varset›("vPixel=%_vStrEmpty%","")
‹endif›
‹if›("vFontInput==null")
‹varset›("vFont=%_vStrEmpty%","")
‹endif›
‹#›
‹#› == start.=.annotation ==
‹#› More housekeeping routines. These are formatting in nature. If the pixel size of the
‹#› character image is a single digit, (1-9), a zero is inserted before it to make it a
‹#› two digit number. The same for the font size of the character the icon app uses. This
‹#› little housekeeping is what enables a macro to re-use a filename. Without it, the
‹#› filename would be off different lengths and would create a real headache if you tried
‹#› to get the macro to revise it. This is a technique I use very frequently.
‹#› == end.=.annotation ==
‹if›("vPixel‹10")
‹varset›("vPixelSpacer=0","")
‹endif›
‹if›("vFont‹10")
‹varset›("vFontSpacer=0","")
‹endif›
‹#›
‹#› == start.=.annotation ==
‹#› These five 'if-endif' routines are in response to data entry in the form,
‹#› (see item # 4). If the data signals this is a single run of the macro, the type value
‹#› is set, and the variable 'ga_vCount' is set to '0'. The main purpose of these routines
‹#› is to set the 'ga_vCount' variable, but it is a convenient place to set the ga_vType'
‹#› value, as well. Frequently when I am building macros, I will start with separate
‹#› routines for setting the values, then combine them later, simplifying the construction
‹#› of a complex macro.
‹#› == end.=.annotation ==
‹if›("vUpperSingle==YES")
‹varset›("ga_vType=upper","")
‹varset›("ga_vCount=0","")
‹endif›
‹if›("vLowerSingle==YES")
‹varset›("ga_vType=lower","")
‹varset›("ga_vCount=0","")
‹endif›
‹if›("vNumeralSingle==YES")
‹varset›("ga_vType=numeral","")
‹varset›("ga_vCount=0","")
‹endif›
‹if›("vRomanSingle==YES")
‹varset›("ga_vType=roman","")
‹varset›("ga_vCount=0","")
‹endif›
‹if›("vDiacritSingle==YES")
‹varset›("ga_vType=diacrit","")
‹varset›("ga_vCount=0","")
‹endif›
‹#›
‹#› == start.=.annotation ==
‹#› These five 'if-endif' routines are in response to the value check of the variable
‹#› 'ga_vCount' at the top of the macro, (see item # 2), where the macro checked if the
‹#› value was 1, designating a repeat run of the macro. In item # 2, if the macro confirms
‹#› this is a repeated run of the macro, the value of 'ga_vType' is checked. If it has one
‹#› of the designated types as it's value, then a variable is set to 'YES'. This becomes
‹#› the value shown in the form. Here that 'YES' is being picked up and instructs the
‹#› macro to either continue the value of upper, lower, numeral or diacrit or instructs
‹#› the macro to assign one of the values for the first time, based on the data entry
‹#› value from the form, (see item #4). Also, if this is the first run of the macro,
‹#› and the data entry in the form instructs, the value of 'ga_vCount' is set to '1',
‹#› designating the macro as a 'repeat'.
‹#› == end.=.annotation ==
‹if›("ga_vUpperPersistent==YES")
‹varset›("ga_vType=upper","")
‹varset›("ga_vCount=1","")
‹endif›
‹if›("ga_vLowerPersistent==YES")
‹varset›("ga_vType=lower","")
‹varset›("ga_vCount=1","")
‹endif›
‹if›("ga_vNumeralPersistent==YES")
‹varset›("ga_vType=numeral","")
‹varset›("ga_vCount=1","")
‹endif›
‹if›("ga_vRomanPersistent==YES")
‹varset›("ga_vType=roman","")
‹varset›("ga_vCount=1","")
‹endif›
‹if›("ga_vDiacritPersistent==YES")
‹varset›("ga_vType=diacrit","")
‹varset›("ga_vCount=1","")
‹endif›
‹#›
‹#› == start.=.annotation ==
‹#› These three if-endif routines are in response to the form, (see item #3), and set the
‹#› output variable value to the appropriate text string to be appended after the font size
‹#› in the filename. If there was no modification to the character image, a null string, or
‹#› nothing is appended to the font size. If it was necessary to reduce or enlarge the
‹#› character image, either a '+' or '-' is appended in the filename.
‹#› == end.=.annotation ==
‹if›("vNormal==YES")
‹varset›("vMod=%_vStrEmpty%","")
‹endif›
‹if›("vDecrease==YES")
‹varset›("vMod=-","")
‹endif›
‹if›("vIncrease==YES")
‹varset›("vMod=+","")
‹endif›
‹#›
‹#› == start.=.annotation ==
‹#› The rest of the macro commands are specific to the icon application I use. At this
‹#› point, the commands for any icon application could be substituted. As the normal
‹#› code notations describe, the app opens the 'Save As' applet, then enters a new
‹#› filename or modifies the existing filename. Since I have written this macro, I
‹#› have discovered some functions in the OS that allow combining the two options,
‹#› 'new filename' or 'modify old filename' into one, 'output filename'. If I use this
‹#› macro for the base of a new macro, I would make that change. I will most likely
‹#› leave this alone, since it works. In general, it's a good idea to streamline code
‹#› to eliminate unnecessary commands and routines. The code will perform better,
‹#› and there are fewer places for errors or required changes due to updates in
‹#› an application. There is nothing worse than a company modifying their
‹#› application, necessitating modification to every macro related to the app.
‹#› That's why it's wise to use letter commands when you designate a drop down
‹#› menu command, rather rather up or down arrow commands. Though, I've had
‹#› software companies change the letter commands in drop downs, as well, so you
‹#› can lose either way. The unique part of this macro is what's above.
‹#› == end.=.annotation ==
‹if_win›("mwAxialis IconWorkshop mcAXIconWorkshopClass cw[[ ]] cc[[ ]] ","ACT",0)
‹#› ============== open.=.save.as ==============
‹keys›‹alt›f‹alt›‹cmds›
‹wx›(50)
‹begloop›(9)
‹keys›‹down›‹cmds›
‹wx›(50)
‹endloop›
‹keys›‹enter›‹cmds›
‹wx›(150)
‹#› ============== enter.=.new.filename ==============
‹if›("vNew==YES")
‹keys›S:\Icons\#...digits\icon.‹cmds›
‹wx›(50)
‹varout›("ga_vType",0)
‹keys›.‹cmds›
‹wx›(50)
‹varout›("vChar",0)
‹keys›..‹cmds›
‹wx›(50)
‹varout›("vPixelSpacer",0)
‹varout›("vPixel",0)
‹keys›..‹cmds›
‹wx›(50)
‹varout›("_vKeyBracketL",0)
‹varout›("vFontSpacer",0)
‹varout›("vFont",0)
‹varout›("vMod",0)
‹varout›("_vKeyBracketR",0)
‹keys›..‹cmds›
‹wx›(50)
‹keys›comic.ico‹cmds›
‹wx›(50)
‹goto›("END")
‹endif›
‹#› ============== modify.=.filename ==============
‹keys›‹home›‹cmds›
‹wx›(50)
‹keys›‹ctrl›‹right›‹ctrl›‹cmds›
‹wx›(50)
‹keys›‹shift›‹ctrl›‹right›‹ctrl›‹shift›‹cmds›
‹wx›(50)
‹keys›‹shift›‹left›‹shift›‹cmds›
‹wx›(50)
‹varout›("ga_vType",0)
‹keys›‹right›‹cmds›
‹wx›(50)
‹if›("vCharInput==null")
‹keys›‹ctrl›‹right›‹ctrl›‹cmds›
‹wx›(50)
‹goto›("JUMPCHAR")
‹endif›
‹keys›‹shift›‹ctrl›‹right›‹ctrl›‹shift›‹cmds›
‹wx›(50)
‹keys›‹shift›‹left›‹shift›‹cmds›
‹wx›(50)
‹keys›‹shift›‹left›‹shift›‹cmds›
‹wx›(50)
‹varout›("vChar",0)
‹keys›‹right›‹cmds›
‹wx›(50)
‹keys›‹right›‹cmds›
‹wx›(50)
‹label›("JUMPCHAR")
‹if›("vPixelInput==null")
‹keys›‹ctrl›‹right›‹ctrl›‹cmds›
‹wx›(50)
‹goto›("JUMPPIXEL")
‹endif›
‹keys›‹shift›‹ctrl›‹right›‹ctrl›‹shift›‹cmds›
‹wx›(50)
‹keys›‹shift›‹left›‹shift›‹cmds›
‹wx›(50)
‹keys›‹shift›‹left›‹shift›‹cmds›
‹wx›(50)
‹keys›‹shift›‹left›‹shift›‹cmds›
‹wx›(50)
‹varout›("vPixelSpacer",0)
‹varout›("vPixel",0)
‹keys›‹right›‹cmds›
‹wx›(50)
‹keys›‹right›‹cmds›
‹wx›(50)
‹keys›‹right›‹cmds›
‹wx›(50)
‹label›("JUMPPIXEL")
‹endif›
‹if›("vFontInput==null")
‹keys›‹ctrl›‹right›‹ctrl›‹cmds›
‹wx›(50)
‹goto›("END")
‹endif›
‹keys›‹shift›‹ctrl›‹right›‹ctrl›‹shift›‹cmds›
‹wx›(50)
‹keys›‹shift›‹left›‹shift›‹cmds›
‹wx›(50)
‹keys›‹shift›‹left›‹shift›‹cmds›
‹wx›(50)
‹keys›‹shift›‹left›‹shift›‹cmds›
‹wx›(50)
‹varout›("vFontSpacer",0)
‹varout›("vFont",0)
‹varout›("vMod",0)
‹keys›‹right›‹cmds›
‹wx›(50)
‹keys›‹right›‹cmds›
‹wx›(50)
‹keys›‹right›‹cmds›
‹wx›(50)
‹endif›
‹#›
‹label›("END")
‹keys›‹enter›‹cmds› |
IP Logged
|
|
