All Databases MacTech Vol 11-1995

Jan 95 Tips

Volume Number: 11

Issue Number: 1

Column Tag: Tips & Tidbits

Tips & Tidbits

By Scott T Boyd, Editor

Note: Source code files accompanying article are located on MacTech CD-ROM or

source code disks.

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 
#include 
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

Referenced by (6):