<HTML><HEAD><TITLE>Using python to create Macintosh applications, part zero</TITLE></HEAD>
<BODY>
<H1>Using python to create Macintosh applications, part zero</H1>
<HR>

This document will show you how to create a simple mac-style
application using Python. We will glance at how to use file dialogs and
messages. <p>

Our example program <a href="example0/checktext.py">checktext.py</a> asks
the user for a text file and checks what style end-of-lines the file has.
This may need a little explanation: ASCII text files are almost identical
on different machines, with one exception: 
<ul>
<li> Unix systems terminate lines with the "linefeed" character, <code>0x0a</code>,
<li> Macintoshes terminate lines with the "carriage return" character,
<code>0x0d</code> and
<li> MSDOS and Windows terminate lines with first a carriage return and then a linefeed.
</ul>

Let us have a look at the program. The first interesting statement in the main
program is the call to <code>macfs.PromptGetFile</code>. This is one of the routines
that allow you to ask the user to specify a file. You pass it one required
argument, the prompt string. There are up to four optional MacOS <em>file type</em> arguments
you can pass, as 4-byte strings. Specifying no file
type will allow the user to select any file, specifying one or more types restricts
the user to files of this type. File types are explained in most books on the Mac. <p>

<code>PromptGetFile</code> returns two values: an <em>FSSpec</em> object and a
success indicator. The FSSpec object is the "official" MacOS way of specifying a
file, more on it later. The success indicator tells you whether the user clicked OK
or Cancel. In the event of Cancel we simply exit back to the finder. <p>

<code>PromptGetFile</code> has a number of friends that do similar things:
<ul>
<li> <code>StandardGetFile</code> is identical to <code>PromptGetFile</code> but
without the prompt. It has up to four optional filetype arguments.
<li> <code>StandardPutFile</code> asks the user for an output file. It will
warn the user when she tries to overwrite an existing file. The routine has one
mandatory argument: a prompt string. Pass the empty string if you do not want a prompt.
<li> <code>GetDirectory</code> asks the user for a folder (or directory, in unix terms).
It has one optional argument: a prompt string.
</ul>
All routines return an FSSpec and a success indicator. <p>

There are many things you can do with FSSpec objects (see the 
<a href="http://www.python.org/doc/lib/macfs.html">macfs</a> section in the
<a href="http://www.python.org/doc/lib/Top.html">Python Library Reference</a>
for details), but passing them to <code>open</code> is not
one of them. For this, we first have to convert the FSSpec object to a pathname, with
the <code>as_pathname</code> method. This returns a standard MacOS-style pathname with
colon-separated components. This can then be passed to <code>open</code>. Note that
we call open with mode parameter <code>'rb'</code>: we want to read the file in binary
mode. Python, like C and C++, uses unix-style line endings internally and opening a
file in text mode (<code>'r'</code>) would result in conversion of carriage-returns to
linefeeds upon reading. This is something that Mac and DOS programmers are usually aware
of but that never ceases to amaze unix buffs. <p>

After we open the file we attempt to read all data into memory. If this fails we use
<code>EasyDialogs.Message</code> to display a message in a standard dialog box and exit.
The EasyDialogs module has a few more useful simple dialog routines, more on that in 
<a href="example1.html">example 1</a>. <p>

The rest of the code is pretty straightforward: we check that the file actually contains
data, count the number of linefeeds and returns and display a message with our guess of the
end-of-line convention used in the file. <p>

The <a href="example0">example0</a> folder has three text files in Mac, Unix and DOS style
for you to try the program on. After that, you can continue with <a href="example1.html">example 1</a>
or go back to the <a href="index.html">index</a> to find another interesting topic. <p>

<HR>
<A HREF="http://www.cwi.nl/~jack">Jack Jansen</A>,
<A HREF="mailto:jack@cwi.nl">jack@cwi.nl</A>, 18-July-1996.
</BODY></HTML>
