Jaques Law Office

Introduction to OneClick

© 1997 Kevin Jaques. All rights reserved excepting that this file may be copied for non-commercial purposes, unchanged. No warranties apply. I am just a user volunteering my observations and collecting those of others.

Table of Contents

This Article was delivered by:

This Article was prepared for:

My Struggles (With Macros)

No Command Line - - No Macros

• The blessing and the curse of the Mac was the separation of the user from the code. You understand the blessing. But consider the ease with which a command line interface may be scripted. You merely need a text file of return-separated commands. Since the system is not continually responsive to the user, but merely prompts the user when ready, it simply gets the next command in turn. Since a command line may operate at a low or high level, it could use data from memory, and with just a little effort, permit conditional responses. The MacOS instead reacted to user-generated events, and the user reacted to the display, in a dynamic process. So for years, we received no tools with which to script our system.

  It's all in the Timing

• But years back, the Dark Lord, Bill Gates, offered one of the first macro utilities for the Mac, MacroMaker. With great glee, I invested hours tinkering with macros, to save those needed seconds on everyday tasks. But since it was fun hours and annoying seconds, I didn't mind.
• MacroMaker merely recorded mouse movements and clicks and key strokes. The blessing and the curse of Macromaker was in the timing. Since it was too difficult to hack into the system to deduce the state of an application, let alone all the various possible applications, Macromaker just waited a pre-determined time. It figured that if the user had to wait 2.345 seconds when recording the macro, it should probably wait the same time when performing it. All things considered, it worked pretty well. Sure, you had to like tweaking the timing. I did. But it could then work system-wide.
• It was cute. It used the metaphor of a little tape recorder. You would tell it to record, then go about your business, and ultimately tell it to stop. Then you played it back to see if it would work. Recordability remains an essential element of scripting.
• MacroMaker died of neglect. A scripting utility of even such modest ambitions had to do a little hacking, and as the System moved on, it did not, until it became unstable.

  Extensibility

• Much later, it seemed, QuicKeys came out. In its first incarnations, as I recall, it was little more than MacroMaker, with assignable key combinations which could activate it. It wasn't long before QuicKeys offered extensions, and various developers began to create them. Increasingly demanding tasks could be scripted. New system capabilities could be accomodated without changing QuicKeys itself. Some of these extensions began to offer intelligence!
• Intelligent extensions was the next breakthrough. Now, rather than using menus just by a timed simulated mouse movement, the extension could analyze the available menus and activate them precisely and flexibly. Now you could make system-wide scripts. Before, MacroMaker was system-wide in the sense that it could operate in any application. Now, it began to be system-wide in the sense that the same script would work the same in any application. You could have scripts useful and usable everywhere, such as 'save as, play sound, hide other applications, mount/dismount volumes, etc.

  Relativity

• Relativity was now possible. For instance, rather than setting the sound volume to one, you could increase it by one. Rather than clicking 10 pixels down and 30 pixels right, hoping the window close box was in its usual place, it could click relative to the top left corner of the window. This makes such a difference to how reliable the script will be. It shields the script from extraneous variables.

  Reactivity

• True scripting, with conditional branching was next. QuicKeys introduced a rudimentary level of this power, at about the same time that Frontier arrived. Frontier was a huge, fantastically flexible, whole new concept which combined data management with programming. Sadly, it is a concept which still hadn't revealed itself to me after investing about 20 hours in it.
• With conditional branching, some sort of interface was now desirable, so it could let the user make choices. QuicKeys and probably Frontier, delivered increasingly specialized extensions to interact with the user, with things like list selectors, text dialogs, button dialogs, file dialogs, etc.

  AppleScript

• Apple let it languish like that for some time, until System 7, when it introduced AppleScript. To a degree, AppleScript was a macro utility for 'the rest of us'. You could record actions in the form of a script. You could run the script. or save it as an applet, a mini application. It did a crummy job of that, and offered virtually no user interface. You could write useful little applications, but Apple didn't bother to supply a guide to the language. Third parties filled the gap eventually.
• So why mention AppleScript, if it was so rotten? In retrospect, I now realize it was significant, in that it provided a structure and standard for scripting. Applications, to be certified as ready for System 7, had to support certain 'events'. There was a 'core suite' to which they all had to respond. Further, other specialties, such as word processing, drawing, database, painting, etc., all had 'suites' of events. An application was welcome to handle events of its own making as well.
• These 'events' burst the limits on intelligent scripting extensions. Why script a menu command to create a new file, when you could just send the 'new' event to the 'file' object? No more timing problems! No more menu dependence! No more hacking!
• Many events called for the return of data, greatly increasing the ability to respond conditionally.
• QuicKeys jumped on the new structure. It soon offered the ability to send events to programs. It could even read the 'dictionaries' which Apple said should be included in an Application, describing which events it understood. I understand Frontier jumped in too.
• The new standard was flexible. The system could recognize different scripting systems, and use each at the same time. QuicKeys and Frontier became scripting systems, just as AppleScript itself was.

  Portability

• Once somebody has designed a macro, can it be shared? QuicKey scripts are created by step by step user choices and recordings. Frontier adds tables of data. I won't say they can't be shared. I will only say that I never succeeded in doing so.

  Interface

• Well, now the user has all this scripting power. Yet activating it all by memorized key combinations was becoming more arcane than the command-line interface ever was! The interface was now the problem.
• Now Utilities designed the sweetest interface you could imagine. The Apple Menu was dynamic and hierarchical. The user could add tiny little system-wide menus, represented by space-saving icons. They could even fit to the right of the application menu and to the left of the Apple Menu. Even the desktop itself could be a popup menu. It would keep a dynamic list of recently used applications, documents, or any other file. The user could make an item permanent to a menu with a key click. The user could see what key combination activated any menu item, whether it belonged to Now or to something else. The user could change a key combination instantly.
• But, [heavy sigh], forget about Now Utilities. It never achieved stability, due to the profound hacking it used. Many users swear it is stable. Perhaps it is, on their systems, or perhaps love has made them blind. Certainly when used on a network, it is not stable in my experience. Even if it were stable, it has not really pursued scripting.
• Westcode Software came out with OneClick. I love it. Hence this article.

OneClick

Powers

• OneClick is not a culmination of scripting. Yet it has all the strengths listed above, with a solution to the interface problem.
• It has timing. When all else fails, it can simulate keys and mouse movements with precise timing.
• It is extensible.
• It has relativity. It has reactivity.
• It not only sends AppleEvents, it can actually run, and debug actual AppleScript code.
• It has its own language.
• It has a responsive and helpful interface.
• It is recordable. Better, it is smart about recording. If you access a popup menu, it doesn't record a click, it records a popup menu command. It isn't super-smart. It doesn't record a series of apple events. But hey, what does?

Interface

The Approach

• OneClick's solution to a profusion of key combinations is a profusion of icons. Check out the mess on my desktop in the accompanying files. The icons are collected in palettes, which float about everything else. Impressively, games like Doom or Greebles manage to float over the palettes, but virtually nothing else does. That speaks of a strong but controlled approach.
• The icons are called buttons. Each button has a name, text, dimensions, several icons, a script, and a key combination.
• I'm not a huge palette fan. What lured me to OneClick is that QuicKeys was a suspect in some system instability I had been having. That case was never closed. Further, I got the mistaken impression that OneClick was PPC native.
• Yet, the palettes have won me over. Most importantly, Keyboard combinations still work even if the palette is hidden. So, the first thing I did was set up and learn the keyboard commands to make them vanish and reappear, singly or all at once. That is also available through the OneClick Menu, or on palettes.
• The palettes can be programmed to 'dock' at a certain position or relative to a position. Buttons can be written to resize windows to fit within the palettes.
• There is an 'iconify' feature, whereby palettes can be shrunk to an icon, and expanded with a click. I don't like that feature, since moving one would unpredictably (to me) move the other.
• The icons themselves are usually sufficient to tell me what they do. If not, one of my palettes will show the name of the button which the mouse is over.
• You can even set up the palettes to show the name of the palette, with or without the icon.
• What really tips the balance is Drag And Drop. You can drop objects on the buttons, and the buttons will handle them. That adds another level of functionality, yet remains, intuitive. Since System 7, you have been able to choose which application opened a file with drag and drop. Perhaps you don't like SimpleText. Yeah, like perhaps you don't like to be strangled. Yet, it wasn't practical. There were just too many applications. Nice racks of small sized icons make it feasible. I use it constantly now.

  Editor

• The Editor is available with a mouseclick, through the menu, or from a button. In fact, you can use a key combination to just begin recording a new button for a palette.
• You can choose to edit libraries, palettes, buttons, scripts, icons, or an icon search.

  Libraries

• Libraries can be used to store buttons, for the purpose of archiving or exchanging. OneClick comes with a selection of extensive libraries.

  Palette

• Palettes may be global or tied to a specific application. If they are tied, then they appear when the application does, and their keyboard commands only work when the application is active. Here, the interface is confusing. I don't know how to change a palette from one application to another or to global. If you want to tie it to an application, that application must be active when you do so.
• You can play with the appearance of the palette. You can set the title or the background to a particular colour and pattern or to an image. You can control whether there is a title bar and whether it appears in the OneClick Menu.

  Buttons

• Buttons have a name. This means they may be activated from other buttons, even on other palettes. This is as close as OneClick gets to functions.
• Buttons have the all important key combination, for instant execution of scripts.
• Buttons have icons and text. You can set whether to show either or both, and in what relation to each other.
• Buttons have several icons, so the user can be subtly informed of the state of the button or the script. For instance, when it handles dragged items, it should darken when a mouse is over it. A trash icon could bulge if the trash is full.
• Buttons have balloon help, which you can set yourself.

  Icon Editing

• Icon editing is the normal thing you would expect to see, to permit you to draw your own icons.

  Icon Search

• Icon Search is a handy feature. You select a folder. It searches a while. Then it shows a list of files with icons. You click the file, and see the list of icons it has. If you like it, you copy it.

Scripting

Editing

• There's good news and bad. They are both that the OneClick Editor, which contains the script editor, comes up instantly, as a dialog box belonging to whatever application you are in.
• That's sweet speed, especially if you are accustomed to QuicKeys.
• Unfortunately, since it is not its own application, it doesn't have all the things one expects from an application. You can't drag and drop text. You can't script it. Truly, you shouldn't even expect copy and paste to work, except they do.
• There's more good news and bad. It is just a text editor. That's bad since users love to be guided through the building of a script, and to see meaningful icons and structure, as some of the graphical programming environments offer. It's good because you can copy and share scripts like crazy.
• The bad is greatly eased, since the popup Parameters tool offers users just that sort of graphic guiding. For instance, if you wish to designate an icon, you use the Icon item of the Parameters menu, and are given a choice of the available icons, graphically presented.

Online Help

• However, from the basic text editor, you have instant access to the online help. Again, I mean instant.
• There is a pull down menu to restrict the items shown to things like commands, properties, window related, text related, etc. When you see the item you like, you double click it, and get a clear explanation with examples which can be copied directly to your script.
• It's great. But it doesn't offer help for any buttons you have created, or for other available scripting resources, like Applescript.
• Also, it's weird. If you haven't actually chosen a button, it won't copy.

Object Oriented

• If you are accustomed to the concept, it is great. You learn names for some basic 'methods' then apply them to various objects. You use the object name, a period, then the method. So Button.new, file.new, menu.new, etc., do comparable things.
• The Objects are:
  • button
  • dialog button
  • file
  • menu
  • palette
  • process
  • screen
  • volume
  • window
• Still, I maintain that humans are verb-oriented, especially to us english speaking types, who find object oriented utterances and paths like file(startup:documents:calendars:mine).open to be awkward.
• But hey, Object Oriented Programming Style (OOPS) has been all the rage for years now.

Properties

• An object will have properties, which can be read or set. For instance, window.front can be read. It will be true if the window is front-most. Or it can be set. Or both. A typical toggle command would be window.front(not(window.front)).
• Note that buttons are objects and scripts are properties, so OneClick is capable of reprogramming itself on the fly.

Activation Events

• If you used Hypercard, you will find it familiar. Each button contains a script. The script may contain more than one Handlers. Each Handler will handle one of the following types of 'event':
  • DragAndDrop
  • DrawButton
  • MouseDown
  • MouseUp
  • Scheduled
  • Startup
• Plainly, there is the capability for scheduling scripts, either on startup, or at regular intervals.
• The following is WestCode's explanation of 'Scheduled'
  • Use the Schedule command to turn on scheduling for a script. (If you want scheduling to run all the time, put the Schedule command in the script's Startup handler.) You can specify how often the Scheduled handler should run in increments of 1/10th of a second. Scheduled scripts run only when the Macintosh is idle (waiting for keyboard or mouse input).
  • Normally, a Scheduled handler runs only when its palette is visible; the scheduling stops if the palette is hidden, then resumes when the palette is made visible again. To have a Scheduled handler run even if its palette is hidden, include 1 (True) in the Schedule command's optional run-always parameter.
  • Examples
  • // Play the Quack sound every five seconds from the time the application starts up.
  • On Startup
  • Schedule 50
  • End Startup
  •  
  • On Scheduled
  • Sound "Quack"
  • End Scheduled

• But, it gets better. In addition to handling the above tasks, and in addition to running periodically, one can install additional handlers, by passing negative parameters to the Schedule command, as follows:
  • &endash;1: Process start
  • Runs when an application starts up. Process.Name contains the name of the application that just started.
  •  
  • &endash;2: Process quit
  • Runs after an application has quit. The application that quit is no longer in Process.List when this handler runs.
  •  
  • &endash;3: Process switch
  • Runs when you switch from one application to another. Process.Name contains the name of the application after the switch.
  •  
  • &endash;4: Window switch
  • Runs when you switch from one window to another. Window.Name contains the name of the window after the switch. Window switch also occurs if you close a window and there are no more open windows or if you open the first window.
  •  
  • &endash;5: Menu bar redraw
  • Runs any time the menu bar is redrawn. This is generally done whenever the application adds, removes, enables, or disables menus. Generally it is a signal of a major mode change in the application.
  •  
  • &endash;6: Mouse enter/exit
  • Runs when the cursor moves over a different OneClick button or when the cursor moves off a button.
  •  
  • &endash;7: Palette show/hide
  • Runs when a palette is going to change state between visible and invisible. The script's Scheduled handler is called before the palette changes state, so the Palette.Visible flag will indicate the status before the change. Only buttons that are on the palette that is changing will receive this scheduled event.
  •  
  • &endash;8: Cursor change
  • Runs whenever the cursor changes (from a watch to the arrow, for example).
  •  
  • &endash;9: Monitor change
  • Runs whenever one or more monitors change resolution or position. For example, the handler runs if you change the monitor from 640x480 to 1024x768, or if you change monitor positions in the Monitors control panel. Any palettes that end up off screen due to a screen change are moved back on screen.

  Parameters

  • Here is undoubtedly a weakness of OneClick. You can't create functions, or even commands. You can't pass parameters. You can't even call a handler recursively.
  • But you can work around this. You can call specific handlers, within specific buttons, on specific palettes. You can set global or static variables. You can use loops.
  • There is one type of parameter, in a sense. It comes in the form of a DragAndDrop Event. You can drag things to buttons, which can then handle the things dropped. That is sweet! So far as I know, only text clippings and file objects may be dropped. This is what turns the tide and justifies the palette approach.

  Popups

  • Another justification of the visible palette approach is the popup button. There are four types.
  • PopUpFiles offers a popup hierarchical menu of the contents of a finder folder. This provides an easy Now Utility type of enormous navigational convenience.
  • PopUpPalette permits you to popup a, well, palette, and tear it off. This further eases the screen clutter inherent to palettes.
  • PopUpFonts calculates and lists available fonts.
  • PopUpMenu is the basic, generic version. You obtain or create a list of any sort, and present it as a popup menu. You can present it with dividing lines and even with checkmarks by certain items. However, it does not appear to have hierarchical capabilities!

  Inter Application Communication

  • In addition to simulation of user events, which can run other applications, OneClick can send apple events, or run AppleScripts. It can activate QuicKeys even!
  • OneClick provides lots of access to System Variables and provides a modest supply of well chosen functions.

Support

• The author is well pleased with the support. Better yet, Westcode hosts a mailing list, on which Westcode personnel participate. The list members are helpful and often virtually write scripts for newbies. Since the scripts are text based, they are easily exchanged.
• Westcode maintains an FTP site, also accessible via their web site, filled with buttons and scripts and FAQs and documentation.
• Westcode was generous with MUGORs, providing documentation, a door prize, a keeper, and a working model for the demonstration. They also offered special pricing for our members.
• Scripts are easy to exchange. Buttons are less easy. They have no life of their own. They can only be distributed on a palette or in a library. Even they can't be just dropped in. They must be imported. In fact, global palettes are all contained in a single file.

Stability

• The author is well pleased with the stability. There are minor dysfunctions with system 8. They don't crash. The menubar floating menu just doesn't appear. Finder scripting is more touchy about which application must be active. Nothing serious.
• Westcode seems to pride itself on the absence of hacks in the product.

Overall Review

• Is it perfect? Hell no. Let's see some functions, some recursive ability, some parameters, a closer obedience to interface guidelines in the editor, etc. Let's see some of Now Utilities sweet interface adopted. We want more cues as to the keyboard commands and greater ease in setting them.
• Is it best? I think so. I use it myself. I love it. I recommend it to my User's Group. I brag about it to my PC friends. I recommended it to my sainted mother, father, and brother, all Mac enthusiasts.

Where Are They Now?

• Macromaker is still dead. QuicKeys is still popular, and put out by CE Software. Frontier died, then was resurrected, and is now free, and more powerful than ever. OneClick may be reached at Westcode Software.

Sorry, that's all the time I have.

This Jaques Law Bits was delivered by:

Kevin Jaques, B.A. LL.B.
of the
Jaques Law Office
#101 - 2515 Victoria Avenue		Tel: (306) 359-3041
Regina, Saskatchewan		Fax: (306) 525-4173
Canada, S4P 0T2		Home: (306) 586-2234
email: jaques.law@dlcwest.com Remember, like any other form of communication, email may be intercepted.

Please visit our Web Site

Homepage	Education
Experience	Personal
Biography	Affiliations
Retain	Our Favourite Links

This Jaques Law Bits was prepared for:

The MacIntosh User's Group of Regina Saskatchewan

Text Based Page

Fancy Page