ADVERTISEMENT

Tips & Tidbits

By Scott T Boyd, Editor

TIP OF THE MONTH

Using IOStreams with THINK’s Console

The C++ IOStreams library provides many advantages over the old stdio library in C++. But, one thing I missed from the old stdio library in THINK C (not part of the standard) is using console windows from C++ streams. I wanted to be able to use something like:

 myWindow << myData1 << myData2;

which is more convenient than the fprintf(window, ) form of the old stdio library. It wasn’t immediately obvious if this would work with streams. After a little exploring, it turned out to be pretty easy. Two lines of code is all it takes to create a console window and make it part of a stream.

    // create a std I/O buffer for stream using a console window (created by calling fopenc())
 stdiobuf w1(fopenc());

    // create the stream using the buffer from above
 ostream wout((streambuf *)&w1);

The first line creates a console by calling fopenc() and passes it to the stdiobuf constructor. The console window is used as the FILE * for the stdiobuf instance. Then, we create an output stream (ostream) passing a pointer to a streambuf (in this case a subclass of it, stdiobuf). That’s all. The short program below shows how to create one window and to send output to it using our created stream and our own window. It also sends output to the standard out stream (cout) as a way to differentiate the two.

WindStream.cp

#include <console.h>
#include <stdiostr.h>

void main(void)
{
    // set options for my stream window: 40 columns and title
 console_options.left = 10;
 console_options.ncols = 40;
 console_options.title = "\pMy Window/Stream";

    // create a std I/O buffer for stream using a console window (created by calling fopenc())
 stdiobuf w1(fopenc());

    // create the stream using the buffer from above
 ostream wout((streambuf *)&w1);

    // now we can use wout as an output window...
 wout << "Hello World" << endl;

    // This will go to the standard output console
 console_options.left = 300;
 console_options.title = "\pSystem Console";
 cout << "This is the standard output buffer" << endl;
}

- Manuel A. Pérez, Arlington, VA

Fast Apple Event Factoring

When writing a factored application, that is, an application that sends Apple events to itself in response to user interface actions, writing the send routines can be as difficult as writing the receivers.

This needn’t be the case if you use Jens Alfke’s most excellent AEGizmo’s package. To use it, you write a printf-like string and pass it with arguments to AEBuild. This string can be a little obscure, so here’s the tip: put an AEPrint in the Apple event handler, write an AppleScript equivalent and fire it from the AppleScript editor. AEPrint will print a descriptor that, with a small amount of editing, can be pasted into the factor routine and passed to AEBuild. Making an application recordable takes about ten minutes. Honest!

- Chris Sears, sears@netcom.com

MPW Goes Into The Trash

If you use MPW regularly, sooner or later you will delete a file and really wish you hadn’t. MPW’s Delete command is as unforgiving as its counterparts in DOS and Unix - as soon as you delete something, it’s gone. You can’t just drag deleted files out of the trash.

Be prepared. You can modify MPW’s Delete command so it behaves in a more Finder-like way. With these changes, MPW won’t really delete files, it will move them to the Trash (just as you would do if you were using the Finder). Nothing will really be deleted until you explicitly empty the trash.

First, add this line to MPW’s Startup file (or any UserStartup file):

Alias Delete Move_To_Trash

If you have other aliases established which invoke the Delete command (such as the unix alias rm or the DOS alias del), change them to invoke Move_To_Trash instead.

Next, create this Move_To_Trash file in your MPW Scripts folder:

 
Set Echo 0
 If {#}!=0 # if arg count is not zero
  Set Exit 0

  # Create one uniquely named folder in trash can
  Set folder_name "{Boot}"Trash:MPW.deleted.`date -n`
  NewFolder "{folder_name}"   Dev:Null

  # Move specified items to trash
  For file_name in {"Parameters"}
   Move -y "{file_name}" "{folder_name}"   Dev:Null
  End

  # Leave environment as we found it
  Unset file_name folder_name
  Set Exit 1
 End

Caveats:

1) This is reasonable protection against hastily entered Delete commands, but nothing is fool-proof (because fools can be so clever).

2) None of the built in Delete command line options are correctly supported by Move_To_Trash. If you have MPW scripts that invoke the Delete command with options, you will have to modify the scripts. One method would be remove these options from the script entirely, and just rely on Move_To_Trash. Alternately, you could add these commands at the start and end of your script:

 # First line of script
 # restore built in Delete command
   Unalias Delete

 # Last line of script
 # restore modified Delete command
   Alias Delete Move_To_Trash

If you’re lucky, you’ll spend the few minutes it takes to set this up, then never have to think about it again. But someday you may be glad you took the time. As for me, I wish I had thought of this yesterday morning, before I accidentally deleted 5 hours of work.

- Lee David Rimar
Absoft Corporation