Object Shell 2
Volume Number: | | 6
|
Issue Number: | | 9
|
Column Tag: | | MacOOPs!
|
Related Info: Window Manager QuickDraw TextEdit
Object Shell, Part II 
By Dr. Christian Stratowa, Vienna, Austria
Part 2: Application-specific Units
Let me start the second part of my article once again with a statement, this time with the first sentence of the TMLetter: Apple is giving notice to Macintosh developers that object-oriented programming (OOP) will become the only way to write Mac software. I really hope this statement does not mean that in the future Apple will force programmers to use MacApp. Although I dont have MacApp yet, from what I have seen in the different articles published in MacTutor, I have the feeling that I wont like it. Once upon a time...Apple has started the computer revolution by giving people the freedom of personal computing. Now that Apple seems more and more to adopt IBM-like behaviour let me say: Freedom to the programmers to adopt their own programming style and to use the language of their choice! Programming is still an esthetic art and having a uniform user interface (which is surely of great benefit to the users) does not necessarily mean to have to adopt a uniform programming style.
Last time I have presented the general part of our shell program, which needs not be changed when you want to use ObjectShell for your own purposes. So lets now talk about the units specific to our demo application.
Adding your own menus
Unit MyMenus allows us to attach all menus specific to our application. Here we make use of Apples new Hierarchical Menus feature, where any menu item can be defined as submenu. So we define an object TSubMenu, whose method Create inserts a submenu (see IM V-236). In our program we make use of this feature not only in menu Text where Font, Size, Style and Justification are arranged as submenus, and in Color with submenus TForeCMenu and TBackCMenu, but we do also define item New of our standard File menu as submenu to be able to create NewText or NewPict documents. We can do this by creating submenu TNewMenu without having to change any code in our unit StdMenus. Every submenu item can itself be another submenu, although Apple states that only one level of hierarchical menus should be used. In our demo program we create another submenu level by defining TNewPictMenu and TNewTextMenu to let the user choose the window type. Normally you would delete this level.
We can open windows containing either TEXT or PICT documents which use different menus. For this we want to change the appearance of the menubar depending on the type of window becoming Frontwindow. Therefore procedure SetMyMenuBar, which is called from DoActivate every time a window will be activated, does change the whole MenuBar by calling SwitchMenus. When no window is in front, all but the three standard menus will be deleted from the menubar. In the case Frontwindow is a desk acessory I decided for demonstration purposes to disable the application-specific menus only although we could have also deleted them in this case. (I have put the necessary call to SwitchMenus in parenthesis.) Procedure SwitchMenus does insert or delete the necessary menus by calling DoInsertMenu. This procedure requires parameter vMenuHdl besides vRsrcID, because it is not possible to call GetMenuHandle(vRsrcID), when a menu is not installed in the menulist.
When a userwindow becomes activated, we want the current menu settings to be marked, e.g. for text the current Font, Size, Style and Align menu items should be indicated with a checkmark. This is pretty straight foreward. For text procedure SwitchMenus calls CheckFontMenu, CheckSizeMenu etc. Procedure CheckFontMenu does for example get the current font from the GrafPort (thePort^.txFont) and does call SetCheckMark if vFontName equals vCurrentFont. It has also to call OutlineFontSize for every RealFont in the System. Procedure CheckStyleMenu is a little more tricky, because Apple has decided to define Style as set of type StyleItem [see IM I-152]. Together with style Plain there exist eight style items, therefore I have decided to use the bits of one byte for the style setting. For this purpose I defined a field variable fMyHdl of type Handle in TDocument. All procedure CheckStyleMenu has to do is to set the corresponding bits. (Because a Handle is defined as ^^SignedByte the initial setting Plain is: fMyHdl^^:= -128.) Similarly, when we select or unselect a style item, TStyleMenu.Choose sets or clears the corresponding bit.
For graphics we have only to call SetCheckMark every time a graphics window becomes activated or the user selects an item from the Graphics menu or one of the Color submenus. (To save some space in this article, I have decided not to colorize the Color submenu items. With new ResEdit 1.3 (one.three!) it is much too easy to do, anyway.)
Documents - What the Mac is Made for
So far we have learned how to deal with Mac specific stuff, but every computer is built for one purpose only - to process our documents.
As mentioned earlier, our program can handle text and graphics. In unit MyDocuments we define subclasses TTextDocument and TPictDocument. The document type itself is then set in TWindow.DoNew in the already known manner. However, creating a new document this way does have its disadvantages, too: We have to place every field, which has to be set from outside the object, in ancestor class TDocument. Let us take textedit records handle fTextHdl as an example. This is clearly a field variable, which does only belong to subclass TTextDocument. But if we define it there the compiler will generate an error message in method Choose of our submenus, where we have set e.g. fTextHdl^^.txFont. Isnt this a limitation of the ObjectPascal compiler? (You will probably say objects should be encapsulated and fields not changed from outside directly.)
Since we are already talking about text lets have a closer look.
Typewriters Mac
Before creating a new fTextHdl for our textedit record in DoNew we have to define its view rectangle fViewRect and destination rectangle fDocRect. These two rectangles have also to be set in our Update routine, otherwise you will be in trouble when for example selecting text with TEClick. You may be wondering why we declare field fViewRect in addition to fViewRgn. This is necessary to be able to inset fViewRect by kTextMargin. Insetting fViewRgn would lead to strange looking results in the case you want to place some controls within your window and use a background color other than white.
Typing itself is handled in method KeyPress. In this routine we inform the user when the number of characters in the text exceeds MaxInt during typing by displaying a dialog box.
Every time we SetColor or change Font, Size, Style or Justification of our text method ReDraw does the necessary calculations before calling TECalText and invalidating fViewRgn to force an update event.
The World of QuickDraw
Our graphics example shows how to deal with the following features:
selecting the desired shape from menu Graphics
clicking anywhere within fViewRgn to determine where the shape should be drawn
popping up a dialog box for setting the shape parameters every time you click the mouse button within the view region
changing fore and background color any time you want
This time we create every shape in DoNew as a distinct object oOvals, oSpirals, together with its connected oDialog box. Only after having clicked the mouse button in fViewRgn we are setting the choosen shape equal to oShape to be able to use field oShape in the other methods.
Method ClickInDoc does first call DoDialog to allow the user to set the shape parameters and then calls self.ReDraw. But keep in mind that the user could have scrolled fDocRect before clicking in the view region to position the draw origin, so you have to adjust field oShape.fPt accordingly first. When the dialog window has been closed all needed update and activate events are generated automatically. In our case automatically updating is not necessary, because the whole view region will be redrawn anyhow since we clip to fViewRgn and call Update ourselves, so we call ValidRgn(fViewRgn) first to prevent redrawing the part of fViewRgn covered by the dialog box twice.
The actual drawing is done in method ReDraw using QuickDraws picture record. QuickDraw lets you save a sequence of drawing commands between calls OpenPicture and ClosePicture and play them back later with a single procedure call [IM I-158]. To be compatible with MacDraw we have to embed picture comments picDwgBeg and picDwgEnd. PicComments, which do not have an effect on the displayed image, are used to apply additional information when pictures are transmitted from one application to another. Here we use also PicGrpBeg and PicGrpEnd to group our QuickDraw calls together to act like one object. Our application supports scrolling, therefore we have first to limit drawing to region vClipRect within the portRect of QuickDraw. Otherwise offsetting the picture rectangle just one pixel to the right or bottom will set the clipping rectangle to the empty rectangle and the whole picture gets clipped (see IM I-190 and MT 4/86 p.57).
There are three ways to redraw pictures, when we scroll or resize the drawing window:
1, We could store the picture as an offscreen bitmap. This would allow fast scrolling but uses lots of RAM, especially when drawing in color with new 32bit ColorQuickDraw.
2, We could recalculate our drawing for every update event like MacDraw does. This approach is unacceptable in the case our drawing contains e.g. a graph obtained from a set of differential equations, or a Mandelbrot fractal, where calculation times easily exceed one hour. In that case recalculating the picture should not be done for saving and printing our documents either.
3, We could calculate our drawing only once and define it as QuickDraw picture, then redraw it when necessary with procedure DrawPicture. This approach should also be used for saving and printing.
In my example I use the third possibility which seems to me to be the best one. However, to be able to change the color of our drawing every time we select a different color from the Color menu, we have to define our picture in method ReDraw instead of method ClickInDoc, an approach not possible for long calculation times. (For more information about pictures and picComments see MT 4/86 p.56, MT 10/87 p.66 and MT 6/88 p.40.)
Macs Way to Communicate
As mentioned earlier, before drawing our picture we put up a dialog box to get all of the shape parameters we need. Object TDialog contains variable fDlogItems, which determines the size of string array fStr, the array of editable text fields fStr itself, and a boolean flag fDFlag as field variables. Array fStr stores the parameters we input so that the next time we select the dialog box our new parameter settings will be displayed. The flag field is set to TRUE when we press OK after setting the dialog parameters or to FALSE when we cancel the dialog, in which case the default values are displayed the next time the dialog box is called. Fig.5 shows the dialog box, which will be displayed after calling oOvals.DoDialog. As you can see it does not only contain editable text fields but also a popup menu, which I have implemented so that you can see how Apples demo example (Macintosh developer technical sample code disk) works in a real application. It is pretty straight foreward, you only have to take care to preserve the old grafport in filterfunction MyFilter before setting the grafport to vDPtr.
Method DoDialog does first call CenterMyDialog to make sure the dialog box will be centered for every screen size used. This is always possible because records DialogTemplate and AlertTemplate contain field boundsRect, which stores the global coordinates of the Dialog or Alert window [see IM I-423]. After determining dialogs width and height procedure CenterDialogBox calculates the new TopLeft position of boundsRect. Before allowing the changed resource being purged from the heap CenterMyDialog has to call SetResPurge, so that the resource data can be written out to the resource file.
The parameters stored in array fStr when the user presses the OK button, are converted to numbers in method TShape.Create. I did not implement error checking in case the user types a non-numeric entry in the dialog.

Cut, Copy and Paste
Our application does implement the Edit menu. This is pretty straight forward for text, where we can use the editing routines from TextEdit. The only difference to other peoples code is that after calling TECut or TECopy we transfer the content of TextEdits private scrap immediately to the desk scrap. By doing this we need not take care to transfer the private scrap when another window gets activated or when running under MultiFinder. (Apples new TextEdit routines TECut and TECopy write both text and its associated style information directly to the desk scrap, anyhow. [IM V-267]) Before pasting we check first if the desk scrap contains text and if the length of the current text plus the text to be pasted does not exceed MaxInt in which case we put up an alert box informing the user. In method ApplTask we enable menu items Cut and Copy only when text is selected, and Paste only when the scrap is not empty.
Setting up editing for pictures is a little more complicated. We have to know exactly when to dispose of vScrapHdl we have created before, and when to call KillPicture. For menu items Cut and Copy we have to set vScrapHdl to nil before disposing it, for menu item Paste we are not allowed to dispose of vScrapHdl because it has been converted before to type PicHandle. At the end of method Edit we have to call self.Update if the content of our document has changed. In our demo application we have implemented the Edit menu mainly to be able to paste pictures into other applications like MacDraw. Pasting a picture within our program, although possible, does not give you any advantage, in contrast you are not able to change the color afterwards.
Saving and Opening Files
Once we have typed text or played around with different shapes we want to store our work to disk. This is done with TWindow function Saved. When we have choosen Save as... from the File menu (vSaveAs) or want to save a document the first time (vNewFile), we call the standard file dialog. If vReply is good we do first check for DuplicateFileName and then create a new file. DuplicateFileName makes recursive calls to nextWindow to check if a window with title vFileName is already open. If this is the case we rename the old window Untitled, delete its file and set flag fChanged of the old document to TRUE. This forces the program to ask the user if s/he wants to save the old document before closing it. In any case we open the file, call oDocument.DoSave, and close the file.
For text we set the file position to the start of the file and use TextEdit record handle hText to write text into the file. (Remember to lock the handle before dereferencing it.)
In the case of our drawings we have first to write a 512 byte blank header to disk before we can write our QuickDraw picture document into the file. This will enable MacDraw to open our PICT file and use its default settings.
Opening documents is done similarly. We call the standard file dialog and if vReply is good and the file is not already open, we create a new window by calling DoNew. We open then the file in windows method DoOpen, call oDocument.DoOpen, set the new window title, force an update event, and close the file.
When opening a text file we check first if vFileSize is not larger than allowed by TextEdit before reading in the text. We set the caret to the end of our document and scroll the text to the bottom.
Because we have saved our picture as a MacDraw document we have to set the file position to 512 bytes from start before reading in the picture. In this way we are also able to open MacDraw documents saved as PICT documents. To be able to do this we have to set fDocRect equal to the picture frame otherwise the MacDraw document would be displayed with distortion.
Using the File Manager to save and open files involves a lot of error checking, so we embed most of its routines in our boolean function OSError, which displays an error message when an error has occured. It would be good programming style and helpful to the user if the dialog box would not only show the error ID number but a description of the error, too. In order to save space in this article we describe only the errors Duplicate File name and File already open, in all other cases we display vErrNr only.
When closing a file whose document field fChanged has been set to TRUE, an alert box pops up asking the user to save the document before closing it. When the user presses Cancel the flag gQuitting will be set to FALSE. This is important in case Quit was choosen from the File menu, because procedure DoQuit will then discontinue closing further windows and not set flag gDone.
When the last application window will be closed or vNextWindow is a desk accessory gCloseFlag will enable us to SetMyMenuBar.
Making Hardcopies
Although some people have promised us a paperless world with the advent of computers quite the opposite became true. To enable our user to waste paper too we support printing text and graphics.
Printing a document using the Printing Manager involves a lot of opening and closing stuff. At first we have to open the printer resource file and the Printer Driver (PrOpen) in procedure DoPrint called from the standard File menu. Then we validate our print record, put up the standard printing dialog box and pass control to oWindow.DoPrint before calling PrClose. In unit StdWindows we open the printing grafport after having saved our current grafport. We DisplayPrintDialog to enable the user to cancel the printing process. In case of draft printing the actual printing is done in TDocument.DoPrint, where each page is opened, printed and closed separately. In the other cases each page is prepared for printing only once by drawing into the printing port and writing it to disk as part of a spool file. The actual printing is then done in TWindow.DoPrint by calling PrPicFile. This procedure images and prints a spool file containing a previously spooled document.
While this time printing graphics is easy by simply calling DrawPicture, you only have to reset vDocRect in case the user has scrolled the picture before choosing Print, printing text involves more work. First we calculate the bounding rectangle our edit record will use for wrapping text by insetting vPageRect. Then we create a new TextEdit record which will draw into the printing port, determine vPageHeight, and copy the text handle and text length from the active windows main edit record fTextHdl into our new one, vTextHdl. After wrapping the text to vPageRect we open each page separately and draw our text by calling TEUpdate. Before closing the page we have to offset our text so that the next part of our document can be drawn on the following page. When done we dispose of the edit record, but first we have to clear its text handle hText to nil. Otherwise we would automatically deallocate the text while our window still needs it (MR 3-168).
Multifinder Support
Trying to support Multifinder was pretty hard because the only information I have until now comes from two articles in MacTutor (MT 11/87 and 2/88), which I didnt quite understand, so I had to play around to get the code right. And this is how I think Multifinder is working: When you switch between different applications under Multifinder, the application which comes to the front gets activated. Multifinder will not only feed an activate event to the proper window, but will also post a resume/suspend event in the event queue (App4Evt). When you have set in resource SIZE, that your application supports resume/suspend events then you should not use these activation events (is this true?) but handle the necessary activations yourself. Since App4Evt is an application defined event type, then depending on the state of gEvent.message, which, for activate events, is a pointer to the window effected, you have to set the activate/deactivate flag yourself. Therefore, in procedure DoMFEvent we are forcing an activate/deactivate event by setting the activeFlag bit of the EventRecord field gEvent.modifiers. This field is an integer, therefore we have to set/clear bit 15 (because the bit-numbering convention of the toolbox is the reverse of the one generally used on the 68000 processor). Then when FrontWindow is ours we call oWindow.Activate as usual. This code does now really work. To see, that it is also necessary, delete all code in procedure DoMFEvent and recompile the program. When you open now the program under Multifinder then at first sight you wont see any difference. But when you look carefully you will see, that after switching between programs our grow box and scroll bars will not be activated properly.
Although set up for mouse moved events, we are not supporting this feature of MultiFinder and have therefore set gMouseRgn to nil. I have only one monitor so I could not test if the necessary region arithmetics would be ok on multiple monitors.

A Personal Outlook
Now that I have finished to outline a typical shell program for the Mac, which I hope some of you may find useful, let me take the opportunity to make some personal remarks about the future of computers, Apple computers, and programming.
It seems clear to me that object-oriented programming will be the software-approach of the future. However, I dont think that MacApp will have a bright future, because first it does restrict programmers thinking too much, and second it is limited to the Mac only. (Besides that I dont see any advantage in learning more than 500 MacApp procedures over learning more than 500 ROM calls.) The way of the future seems to lie more in GAOOP - graphic assisted object-oriented programming, a way outlined in Steve Jobss NextStep, and to a more limited content also in HyperCard. Maybe Smalltalk will finally get the attention it deserves, although for some strange reason Apple has never promoted it officially. Using Smalltalk scientists at Canons European research center have recently developed a visual programming language, called VPL, which enables nonspecialists to manipulate images on a computer screen. I have the feeling that Apple is more and more loosing ground.
Talking about Apple - what is the difference between IBM and Apple? Most people would probably agree that IBM became worlds largest computer company not because of innovative products but (at least partly) because of its known customer service, a word that does not even exist at Apple. At mainframe times customer service and compatability to existing operating systems was more important than staying at the edge of technology. In contrast to IBM, Apple became a billion dollar company due to only two innovative products, the Apple II and the Macintosh. For personal computers of today innovation and userfriendliness is more important than compatibility to existing systems (even if this system is UNIX). This will be even more important tomorrow.
What is the hardware approach of the future, and where will Apple be? Sun and HP have already come out with RISC machines, even Atari has recently presented an innovative computer, the Atari Transputer Workstation. Meanwhile Apple has presented a third Mac II clone (IIci) without graphics processor. (How can a company claiming to make one of the best graphics computers, still design its hardware without at least one graphics processor?) Maybe Apple is already too large to be innovative. I think Apple will only survive if it will be the first to present the power of an old Cray 1 on the desktop at the cost of a Mac II. Where are the NeXT Jobs at Apple? (Note added in proof (Oct89): On a trip to New York I had the possibility to get a demonstration of the NeXT cube. I am really sorry for Apple but after having seen and heard(!) the NeXT in action I have almost lost all interest in working with or programming the Mac. If I would have the money I would buy one immediately. Forget the Mac, join the NeXT! - or at least get a demonstration yourself.)
Be it RISC or transputer or another processor technology, the real hardware innovation of the near future will be parallel processing, which will stay with us forever (!), because this is how our brain works. Neural network design will also become more and more important. In the farther future optical computing will give parallel processing a completely new meaning. And then will come the quantum computer, which may at last be able to think. I guess Ill better stop here!
Continued in next frame
Volume Number: | | 6
|
Issue Number: | | 9
|
Column Tag: | | MacOOPs!
|
Related Info: Window Manager QuickDraw TextEdit
Object Shell, Part II (code) 
By Dr. Christian Stratowa, Vienna, Austria
Listing: MyMenus.p
UNIT MyMenus;
{****************************************}
INTERFACE
USES
MemTypes, QuickDraw, OSIntf, ToolIntf, PackIntf, MacPrint, ObjIntf,
GlobalStuff, StdWindows, StdMenus, MyDocuments;
TYPE
TSubMenu = OBJECT(TMenu)
PROCEDURE Create(vRsrcID: Integer);
override;
END;
TNewMenu = OBJECT(TSubMenu)
PROCEDURE Choose(vItem: Integer);
override;
END;
TNewPictMenu = OBJECT(TNewMenu)
PROCEDURE Choose(vItem: Integer);
override;
END;
TNewTextMenu = OBJECT(TNewMenu)
PROCEDURE Choose(vItem: Integer);
override;
END;
TGraphMenu = OBJECT(TMenu)
PROCEDURE Choose(vItem: Integer);
override;
END;
TColorMenu = OBJECT(TMenu)
END;
TForeCMenu = OBJECT(TSubMenu)
PROCEDURE Choose(vItem: Integer);
override;
END;
TBackCMenu = OBJECT(TSubMenu)
PROCEDURE Choose(vItem: Integer);
override;
END;
TTextMenu = OBJECT(TMenu)
END;
TFontMenu = OBJECT(TSubMenu)
PROCEDURE Create(vRsrcID: Integer);
override;
PROCEDURE Choose(vItem: Integer);
override;
END;
TSizeMenu = OBJECT(TSubMenu)
PROCEDURE Choose(vItem: Integer);
override;
END;
TStyleMenu = OBJECT(TSubMenu)
PROCEDURE Choose(vItem: Integer);
override;
END;
TJustMenu = OBJECT(TSubMenu)
PROCEDURE Choose(vItem: Integer);
override;
END;
VAR
oNewMenu: TNewMenu;
oNewPictMenu: TNewPictMenu;
oNewTextMenu: TNewTextMenu;
oGraphMenu: TGraphMenu;
oColorMenu: TColorMenu;
oForeCMenu: TForeCMenu;
oBackCMenu: TBackCMenu;
oTextMenu: TTextMenu;
oFontMenu: TFontMenu;
oSizeMenu: TSizeMenu;
oStyleMenu: TStyleMenu;
oJustMenu: TJustMenu;
PROCEDURE InitMyMenus;
PROCEDURE ClickInMyMenus(vMenu,vItem: Integer);
PROCEDURE SetMyMenuItems;
PROCEDURE SetMyMenuBar;
PROCEDURE DisposeMyMenus;
{****************************************}
IMPLEMENTATION
PROCEDURE SetCheckMark(vMenuHdl: MenuHandle; vItem: Integer);
VAR
vMaxMItem: Integer;
i: Integer;
BEGIN
vMaxMItem:= CountMItems(vMenuHdl);
FOR i:= 1 TO vMaxMItem DO
CheckItem(vMenuHdl, i, (i = vItem));
END; {SetCheckMark}
{----------------------------------------}
PROCEDURE OutlineFontSize(vFontNumber: Integer);
VAR
vSizeMenu: MenuHandle;
vSizeName: Str255;
vSizeNumber: LongInt;
i: Integer;
BEGIN
vSizeMenu:= oSizeMenu.fMenuHdl;
FOR i:= 1 TO CountMItems(vSizeMenu) DO
BEGIN
GetItem(vSizeMenu, i, vSizeName);
StringToNum(vSizeName, vSizeNumber);
IF RealFont(vFontNumber, vSizeNumber) THEN
SetItemStyle(vSizeMenu, i, [Outline])
ELSE
SetItemStyle(vSizeMenu, i, []);
END;
END; {OutlineFontSize}
{----------------------------------------}
PROCEDURE CheckFontMenu(vMenuHdl: MenuHandle);
VAR
vMaxMItem: Integer;
vFontName: Str255;
vFontNumber: Integer;
vCurrentFont: Str255;
i: Integer;
BEGIN
vMaxMItem := CountMItems(vMenuHdl);
GetFontName(thePort^.txFont, vCurrentFont);
FOR i:= 1 TO vMaxMItem DO
BEGIN
GetItem(vMenuHdl, i, vFontName);
IF vFontName = vCurrentFont THEN
BEGIN
SetCheckMark(vMenuHdl, i);
GetFNum(vFontName, vFontNumber);
OutlineFontSize(vFontNumber);
leave;
END;
END;
END; {CheckFontMenu}
{----------------------------------------}
PROCEDURE CheckSizeMenu (vMenuHdl: MenuHandle);
VAR
vMaxMItem: Integer;
vSizeName: Str255;
vSizeNumber: LongInt;
vCurrentSize: Integer;
i: Integer;
BEGIN
vMaxMItem:= CountMItems(vMenuHdl);
vCurrentSize:= thePort^.txSize;
FOR i:= 1 TO vMaxMItem DO
BEGIN
GetItem(vMenuHdl, i, vSizeName);
StringToNum(vSizeName, vSizeNumber);
IF LoWord(vSizeNumber) = vCurrentSize THEN
BEGIN
SetCheckMark(vMenuHdl, i);
leave;
END;
END;
END; {CheckSizeMenu}
{----------------------------------------}
PROCEDURE CheckStyleMenu(vMenuHdl: MenuHandle);
VAR
i: Integer;
vStylePtr: Ptr;
BEGIN
vStylePtr:= oWindow.oDocument.fMyHdl^;
FOR i:= kPlain TO kExtend DO
CheckItem(vMenuHdl,i, BitTst(vStylePtr,i - 1))
END; {CheckStyleMenu}
{----------------------------------------}
PROCEDURE CheckJustMenu(vMenuHdl: MenuHandle);
VAR
vJust: Integer;
vItem: Integer;
BEGIN
vJust:= oWindow.oDocument.fTextHdl^^.just;
CASE vJust OF
teJustLeft:
vItem:= kLeft;
teJustCenter:
vItem:= kCenter;
OTHERWISE
vItem:= kRight;
END;
SetCheckMark(vMenuHdl, vItem);
END; {CheckJustMenu}
{----------------------------------------}
PROCEDURE SwitchMenus(vPictFlag,vTextFlag: BOOLEAN);
PROCEDURE DoInsertMenu(vMenuHdl: MenuHandle;
vRsrcID: Integer; vFlag: BOOLEAN);
BEGIN
IF vFlag THEN
InsertMenu(vMenuHdl, 0)
ELSE
DeleteMenu(vRsrcID);
END; {DoInsertMenu}
{- - - - - - - - - - - - - -}
BEGIN
IF vPictFlag = FALSE THEN
BEGIN
DoInsertMenu(oGraphMenu.fMenuHdl, kGraphID, vPictFlag);
DoInsertMenu(oColorMenu.fMenuHdl, kColorID, vPictFlag);
DoInsertMenu(oTextMenu.fMenuHdl, kTextID, vTextFlag);
DoInsertMenu(oColorMenu.fMenuHdl, kColorID, vTextFlag);
IF vTextFlag = TRUE THEN
BEGIN
CheckFontMenu(oFontMenu.fMenuHdl);
CheckSizeMenu(oSizeMenu.fMenuHdl);
CheckStyleMenu(oStyleMenu.fMenuHdl);
CheckJustMenu(oJustMenu.fMenuHdl);
WITH oWindow.oDocument DO
BEGIN
SetCheckMark(oForeCMenu.fMenuHdl, fForeC);
SetCheckMark(oBackCMenu.fMenuHdl, fBackC);
END;
END;
END
ELSE
BEGIN
DoInsertMenu(oTextMenu.fMenuHdl, kTextID, vTextFlag);
DoInsertMenu(oColorMenu.fMenuHdl, kColorID, vTextFlag);
DoInsertMenu(oGraphMenu.fMenuHdl, kGraphID, vPictFlag);
DoInsertMenu(oColorMenu.fMenuHdl, kColorID, vPictFlag);
WITH oWindow.oDocument DO
BEGIN
SetCheckMark(oGraphMenu.fMenuHdl, fShapeID);
SetCheckMark(oForeCMenu.fMenuHdl, fForeC);
SetCheckMark(oBackCMenu.fMenuHdl, fBackC);
END;
END;
END; {SwitchMenus}
{========================================}
PROCEDURE InitMyMenus;
BEGIN
New(oNewMenu);
oNewMenu.Create(kNewID);
New(oNewPictMenu);
oNewPictMenu.Create(kNewPictID);
New(oNewTextMenu);
oNewTextMenu.Create(kNewTextID);
New(oGraphMenu);
oGraphMenu.Create(kGraphID);
New(oColorMenu);
oColorMenu.Create(kColorID);
New(oForeCMenu);
oForeCMenu.Create(kForeCID);
New(oBackCMenu);
oBackCMenu.Create(kBackCID);
New(oTextMenu);
oTextMenu.Create(kTextID);
New(oFontMenu);
oFontMenu.Create(kFontID);
New(oSizeMenu);
oSizeMenu.Create(kSizeID);
New(oStyleMenu);
oStyleMenu.Create(kStyleID);
New(oJustMenu);
oJustMenu.Create(kJustID);
SwitchMenus(FALSE, FALSE);
END; {InitMyMenus}
{========================================}
PROCEDURE ClickInMyMenus(vMenu,vItem: Integer);
BEGIN
CASE vMenu OF
kNewPictID:
oNewPictMenu.Choose(vItem);
kNewTextID:
oNewTextMenu.Choose(vItem);
kGraphID:
oGraphMenu.Choose(vItem);
kForeCID:
oForeCMenu.Choose(vItem);
kBackCID:
oBackCMenu.Choose(vItem);
kFontID:
oFontMenu.Choose(vItem);
kSizeID:
oSizeMenu.Choose(vItem);
kStyleID:
oStyleMenu.Choose(vItem);
kJustID:
oJustMenu.Choose(vItem);
OTHERWISE
END;
END; {ClickInMyMenus}
{========================================}
PROCEDURE SetMyMenuItems;
VAR
vFrontWFlag: BOOLEAN;
vUserWFlag: BOOLEAN;
BEGIN
vFrontWFlag:= (FrontWindow <> NIL);
vUserWFlag := IsAppWindow(FrontWindow);
{Enable/disable items of MyMenus}
END; {SetMyMenuItems}
{========================================}
PROCEDURE SetMyMenuBar;
VAR
vFrontWFlag: BOOLEAN;
vUserWFlag: BOOLEAN;
vDocType: OSType;
BEGIN
vFrontWFlag:= (FrontWindow <> NIL);
vUserWFlag := IsAppWindow(FrontWindow);
IF NOT vFrontWFlag THEN
SwitchMenus(FALSE, FALSE);
IF vUserWFlag THEN
BEGIN
oWindow:= TWindow(GetWRefCon(FrontWindow));
vDocType:= oWindow.oDocument.fDocType;
IF vDocType = kPictDoc THEN
SwitchMenus(TRUE, FALSE)
ELSE IF vDocType = kTextDoc THEN
SwitchMenus(FALSE, TRUE);
END
ELSE
{SwitchMenus(FALSE, FALSE)};
SetEnable(kEditID, 0, vFrontWFlag);
SetEnable(kGraphID, 0, vUserWFlag);
SetEnable(kTextID, 0, vUserWFlag);
SetEnable(kColorID, 0, vUserWFlag);
DrawMenuBar;
END; {SetMyMenuBar}
{========================================}
PROCEDURE DisposeMyMenus;
BEGIN
oNewMenu.Free;
oNewPictMenu.Free;
oNewTextMenu.Free;
oGraphMenu.Free;
oColorMenu.Free;
oForeCMenu.Free;
oBackCMenu.Free;
oTextMenu.Free;
oFontMenu.Free;
oSizeMenu.Free;
oStyleMenu.Free;
oJustMenu.Free;
END; {DisposeMyMenus}
{========================================}
PROCEDURE TSubMenu.Create(vRsrcID: Integer);
BEGIN
HLock(Handle(Self));
fMenuHdl:= GetMenu(vRsrcID);
InsertMenu(fMenuHdl, -1);
HUnlock(Handle(Self));
END; {Create}
{========================================}
PROCEDURE TNewMenu.Choose(vItem: Integer);
BEGIN
{for TML create tempvariable}
CASE vItem OF
kNoGrow:
New(TWindow(oWindow));
kGrow:
New(TGrowWindow(oWindow));
kHScroll..kScroll:
New(TScrollWindow(oWindow));
kHScrollZoom..kScrollZoom:
IF BitTst(Ptr(ROM85), 0) THEN
New(TScrollWindow(oWindow))
ELSE
New(TScrollZoomWindow(oWindow));
OTHERWISE
END;
oWindow.fWKind:= vItem;
END; {Choose}
{----------------------------------------}
PROCEDURE TNewPictMenu.Choose(vItem: Integer);
BEGIN
INHERITED Choose(vItem);
oWindow.DoNew(kPictDoc);
ShowWindow(oWindow.fWPtr);
SetCheckMark(oForeCMenu.fMenuHdl, kBlack);
SetCheckMark(oBackCMenu.fMenuHdl, kWhite);
END; {Choose}
{----------------------------------------}
PROCEDURE TNewTextMenu.Choose(vItem: Integer);
BEGIN
INHERITED Choose(vItem);
oWindow.DoNew(kTextDoc);
ShowWindow(oWindow.fWPtr);
CheckFontMenu(oFontMenu.fMenuHdl);
CheckSizeMenu(oSizeMenu.fMenuHdl);
CheckStyleMenu(oStyleMenu.fMenuHdl);
SetCheckMark(oJustMenu.fMenuHdl, kLeft);
SetCheckMark(oForeCMenu.fMenuHdl, kBlack);
SetCheckMark(oBackCMenu.fMenuHdl, kWhite);
END; {Choose}
{========================================}
PROCEDURE TGraphMenu.Choose(vItem: Integer);
BEGIN
oWindow := TWindow(GetWRefCon(FrontWindow));
oWindow.oDocument.fShapeID:= vItem;
SetCheckMark(fMenuHdl, vItem);
END; {Choose}
{========================================}
PROCEDURE TForeCMenu.Choose(vItem: Integer);
BEGIN
oWindow:= TWindow(GetWRefCon(FrontWindow));
oWindow.oDocument.fForeC:= vItem;
oWindow.ReDrawContent;
SetCheckMark(fMenuHdl, vItem);
END; {Choose}
{----------------------------------------}
PROCEDURE TBackCMenu.Choose(vItem: Integer);
BEGIN
oWindow:= TWindow(GetWRefCon(FrontWindow));
oWindow.oDocument.fBackC:= vItem;
oWindow.ReDrawContent;
SetCheckMark(fMenuHdl, vItem);
END; {Choose}
{========================================}
PROCEDURE TFontMenu.Create(vRsrcID: Integer);
BEGIN
HLock(Handle(Self));
fMenuHdl:= GetMenu(vRsrcID);
AddResMenu(fMenuHdl, FONT);
InsertMenu(fMenuHdl, -1);
HUnlock(Handle(Self));
END; {Create}
{----------------------------------------}
PROCEDURE TFontMenu.Choose(vItem: Integer);
VAR
vFontName: Str255;
vFontNumber: Integer;
BEGIN
GetItem(fMenuHdl, vItem, vFontName);
GetFNum(vFontName, vFontNumber);
TextFont(vFontNumber);
oWindow:= TWindow(GetWRefCon(FrontWindow));
oWindow.oDocument.fTextHdl^^.txFont:= vFontNumber;
oWindow.ReDrawContent;
SetCheckMark(fMenuHdl, vItem);
OutlineFontSize(vFontNumber);
END; {Choose}
{========================================}
PROCEDURE TSizeMenu.Choose (vItem: Integer);
VAR
vSizeName: Str255;
vSizeNumber: LongInt;
BEGIN
GetItem(fMenuHdl, vItem, vSizeName);
StringToNum(vSizeName, vSizeNumber);
TextSize(LoWord(vSizeNumber));
oWindow:= TWindow(GetWRefCon(FrontWindow));
oWindow.oDocument.fTextHdl^^.txSize:= LoWord(vSizeNumber);
oWindow.ReDrawContent;
SetCheckMark(fMenuHdl, vItem);
END; {Choose}
{========================================}
PROCEDURE TStyleMenu.Choose(vItem: Integer);
VAR
vStyle: Style;
vStylePtr: Ptr;
BEGIN
oWindow:= TWindow(GetWRefCon(FrontWindow));
WITH oWindow.oDocument DO
BEGIN
vStylePtr:= fMyHdl^;
vStyle:= [];
CASE vItem OF
kPlain:
BEGIN
TextFace([]);
fMyHdl^^:= -128;
END;
kBold:
vStyle:= [Bold];
kItalic:
vStyle:= [Italic];
kUnderline:
vStyle:= [Underline];
kOutline:
vStyle:= [Outline];
kShadow:
vStyle:= [Shadow];
kCondense:
vStyle:= [Condense];
kExtend:
vStyle:= [Extend];
OTHERWISE
END;
IF (vStyle <= thePort^.txFace)
AND (vItem <> kPlain) THEN
BEGIN
TextFace(thePort^.txFace - vStyle);
BitClr(vStylePtr, vItem - 1);
END
ELSE
BEGIN
TextFace(thePort^.txFace + vStyle);
BitClr(vStylePtr, kPlain - 1);
BitSet(vStylePtr, vItem - 1);
END;
fTextHdl^^.txFace:= thePort^.txFace;
fMyHdl^^:= vStylePtr^;
END;
oWindow.ReDrawContent;
CheckStyleMenu(fMenuHdl);
END; {Choose}
{========================================}
PROCEDURE TJustMenu.Choose(vItem: Integer);
VAR
vJust: Integer;
BEGIN
oWindow:= TWindow(GetWRefCon(FrontWindow));
CASE vItem OF
kLeft:
vJust:= teJustLeft;
kCenter:
vJust:= teJustCenter;
kRight:
vJust:= teJustRight;
OTHERWISE
END;
oWindow.oDocument.fTextHdl^^.just:= vJust;
oWindow.ReDrawContent;
SetCheckMark(fMenuHdl, vItem);
END; {Choose}
END. {unit MyMenus}
{****************************************}
Listing: MyDocuments.p
UNIT MyDocuments;
{****************************************}
INTERFACE
USES
MemTypes, QuickDraw, OSIntf, ToolIntf, PackIntf, MacPrint, ObjIntf,
GlobalStuff, MyDialogs, MyShapes;
TYPE
TDocument = OBJECT(TObject)
fDocType: OSType;
fVolNum: Integer;
fFileNum: Integer;
fChanged: BOOLEAN;
fViewRgn: RgnHandle;
fViewRect: Rect;
fDocRect: Rect;
fTextHdl: TEHandle;
fPictHdl: PicHandle;
fMyHdl: Handle;
fForeC: Integer;
fBackC: Integer;
fShapeID: Integer;
PROCEDURE DoNew;
PROCEDURE DoOpen(vVolNum,vFileNum: Integer);
PROCEDURE DoSave(vFileNum: Integer);
PROCEDURE DoPrint(vPrPort: TPPrPort);
PROCEDURE ApplTask;
PROCEDURE ClickInDoc(vPt: Point);
PROCEDURE KeyPress(vChar: CHAR);
PROCEDURE ReDraw;
PROCEDURE Update;
PROCEDURE Activate;
PROCEDURE Edit(vItem: Integer);
END;
TTextDocument = OBJECT(TDocument)
PROCEDURE DoNew;
override;
PROCEDURE DoOpen(vVolNum,vFileNum: Integer);
override;
PROCEDURE DoSave(vFileNum: Integer);
override;
PROCEDURE DoPrint(vPrPort: TPPrPort);
override;
PROCEDURE ApplTask;
override;
PROCEDURE ClickInDoc(vPt: Point);
override;
PROCEDURE KeyPress(vChar: CHAR);
override;
PROCEDURE ReDraw;
override;
PROCEDURE Update;
override;
PROCEDURE Activate;
override;
PROCEDURE Edit(vItem: Integer);
override;
PROCEDURE Free;
override;
END;
TPictDocument = OBJECT(TDocument)
oOvals: TOvals;
oSpirals: TSpirals;
oShape: TShape;
PROCEDURE DoNew;
override;
PROCEDURE DoOpen(vVolNum,vFileNum: Integer);
override;
PROCEDURE DoSave(vFileNum: Integer);
override;
PROCEDURE DoPrint(vPrPort: TPPrPort);
override;
PROCEDURE ApplTask;
override;
PROCEDURE ClickInDoc(vPt: Point);
override;
PROCEDURE ReDraw;
override;
PROCEDURE Update;
override;
PROCEDURE Edit(vItem: Integer);
override;
PROCEDURE Free;
override;
END;
{****************************************}
IMPLEMENTATION
FUNCTION SetColor(vColor: Integer): LongInt;
BEGIN
CASE vColor OF
kBlack:
SetColor:= blackColor;
kWhite:
SetColor:= whiteColor;
kRed:
SetColor:= redColor;
kGreen:
SetColor:= greenColor;
kBlue:
SetColor:= blueColor;
kCyan:
SetColor:= cyanColor;
kMagenta:
SetColor:= magentaColor;
kYellow:
SetColor:= yellowColor;
END;
END; {SetColor}
{----------------------------------------}
PROCEDURE TDocument.DoNew;
BEGIN
fVolNum:= 0;
fFileNum:= 0;
fChanged:= FALSE;
fTextHdl:= NIL;
fPictHdl:= NIL;
fMyHdl:= NIL;
END; {DoNew}
{----------------------------------------}
PROCEDURE TDocument.DoOpen(vVolNum,vFileNum: Integer);
BEGIN
END; {DoOpen}
{----------------------------------------}
PROCEDURE TDocument.DoSave(vFileNum: Integer);
BEGIN
END; {DoSave}
{----------------------------------------}
PROCEDURE TDocument.DoPrint(vPrPort: TPPrPort);
BEGIN
END; {DoPrint}
{----------------------------------------}
PROCEDURE TDocument.ApplTask;
BEGIN
END; {ApplTask}
{----------------------------------------}
PROCEDURE TDocument.ClickInDoc(vPt: Point);
BEGIN
END; {ClickInDoc}
{----------------------------------------}
PROCEDURE TDocument.KeyPress(vChar: CHAR);
BEGIN
END; {KeyPress}
{----------------------------------------}
PROCEDURE TDocument.ReDraw;
BEGIN
END; {ReDraw}
{----------------------------------------}
PROCEDURE TDocument.Update;
BEGIN
END; {Update}
{----------------------------------------}
PROCEDURE TDocument.Activate;
BEGIN
END; {Activate}
{----------------------------------------}
PROCEDURE TDocument.Edit(vItem: Integer);
BEGIN
END; {Edit}
{========================================}
PROCEDURE TTextDocument.DoNew;
VAR
vColumnWidth: Integer;
vViewRect: Rect;
BEGIN
INHERITED DoNew;
vColumnWidth:= 6 * 72;
vViewRect := fViewRect;
InsetRect(vViewRect, kTextMargin, 0);
fViewRect := vViewRect;
fDocRect:= fViewRect;
fDocRect.right:= vColumnWidth;
fTextHdl:= TENew(fDocRect, fViewRect);
fDocType:= TEXT;
TextSize(12);
fTextHdl^^.txSize:= thePort^.txSize;
TextFace([]);
fMyHdl:= NewHandle($2);
fMyHdl^^:= -128;
fForeC:= kBlack;
fBackC:= kWhite;
END; {DoNew}
{----------------------------------------}
PROCEDURE TTextDocument.DoOpen(vVolNum,
vFileNum: Integer);
VAR
vFileSize: LongInt;
vHdl: Handle;
vDocRect: Rect;
BEGIN
IF OSError(GetEOF(vFileNum, vFileSize)) THEN
Exit(DoOpen);
IF OSError(SetFPos(vFileNum, FSFromStart, 0)) THEN
Exit(DoOpen);
IF vFileSize > MaxInt THEN
BEGIN
CenterMyDialog(ALRT, kSizeErrID);
IF StopAlert(kSizeErrID, NIL) = OK THEN
Exit(DoOpen);
END;
SetHandleSize(fTextHdl^^.hText, vFileSize);
IF OSError(MemError) THEN
Exit(DoOpen);
vHdl:= fTextHdl^^.hText;
MoveHHi(vHdl);
HLock(vHdl);
IF OSError(FSRead(vFileNum, vFileSize, vHdl^)) THEN
BEGIN
HUnlock(vHdl);
Exit(DoOpen);
END;
HUnlock(vHdl);
fTextHdl^^.teLength:= vFileSize;
TECalText(fTextHdl);
TESetSelect(MaxInt, MaxInt, fTextHdl);
WITH fDocRect, fTextHdl^^ DO
BEGIN
bottom:= top + nLines * lineHeight;
vDocRect := fDocRect;
OffsetRect(vDocRect, 0, bottom);
fDocRect := vDocRect;
END;
fVolNum:= vVolNum;
fFileNum:= vFileNum;
fChanged:= FALSE;
END; {DoOpen}
{----------------------------------------}
PROCEDURE TTextDocument.DoSave(vFileNum: Integer);
VAR
vFileSize: LongInt;
vHdl: Handle;
BEGIN
IF OSError(SetFPos(vFileNum, FSFromStart, 0)) THEN
Exit(DoSave);
vFileSize:= fTextHdl^^.teLength;
vHdl:= fTextHdl^^.hText;
MoveHHi(vHdl);
HLock(vHdl);
IF OSError(FSWrite(vFileNum, vFileSize, vHdl^)) THEN
BEGIN
HUnlock(vHdl);
Exit(DoSave);
END;
HUnlock(vHdl);
fFileNum:= vFileNum;
fChanged:= FALSE;
END; {DoSave}
{----------------------------------------}
PROCEDURE TTextDocument.DoPrint(vPrPort: TPPrPort);
VAR
vHMargin, vVMargin: Integer;
vPageRect: Rect;
vTextHdl: TEHandle;
vPageSize: Integer;
vPageHeight: Integer;
vDocSize: Integer;
vNumCopies: Integer;
i: Integer;
BEGIN
WITH fTextHdl^^ DO
BEGIN
TextFont(txFont);
TextSize(txSize);
TextFace(txFace);
END;
WITH gPrintHdl^^.prInfo DO
BEGIN
vHMargin:= ROUND(kPrintMargin * iHRes);
vVMargin:= ROUND(kPrintMargin * iVRes);
vPageRect:= rPage;
InsetRect(vPageRect, vHMargin, vVMargin);
END;
vTextHdl := TENew(vPageRect, vPageRect);
WITH vTextHdl^^, viewRect DO
BEGIN
vPageSize:= (bottom - top) DIV lineHeight;
vPageHeight:= vPageSize * lineHeight;
bottom:= top + vPageHeight;
destRect:= viewRect;
DisposHandle(hText);
hText:= fTextHdl^^.hText;
teLength:= fTextHdl^^.teLength;
END;
SetCursor(gWatch);
TECalText(vTextHdl);
SetCursor(arrow);
WITH gPrintHdl^^.prJob DO
IF bJDocLoop = BDraftLoop THEN
vNumCopies:= iCopies
ELSE
vNumCopies:= 1;
MoveHHi(Handle(vTextHdl));
HLock(Handle(vTextHdl));
WITH vTextHdl^^ DO
FOR i:= 1 TO vNumCopies DO
BEGIN
vDocSize:= nLines;
WHILE vDocSize > 0 DO
BEGIN
PrOpenPage(vPrPort, NIL);
IF OSError(PrError) THEN
leave;
TEUpdate(viewRect, vTextHdl);
OffsetRect(destRect, 0, -vPageHeight);
PrClosePage(vPrPort);
IF OSError(PrError) THEN
leave;
vDocSize:= vDocSize - vPageSize;
END;
END;
vTextHdl^^.hText:= NIL;
HUnlock(Handle(vTextHdl));
TEDispose(vTextHdl);
END; {DoPrint}
{----------------------------------------}
PROCEDURE TTextDocument.ApplTask;
VAR
vPt: Point;
vCopyFlag: BOOLEAN;
vPasteFlag: BOOLEAN;
BEGIN
TEIdle(fTextHdl);
GetMouse(vPt);
IF PtInRgn(vPt, fViewRgn) THEN
SetCursor(gIBeam)
ELSE
SetCursor(arrow);
WITH fTextHdl^^ DO
vCopyFlag:= (selStart <> selEnd);
vPasteFlag:= (TEGetScrapLen <> 0);
SetEnable(kEditID, kCut, vCopyFlag);
SetEnable(kEditID, kCopy, vCopyFlag);
SetEnable(kEditID, kPaste, vPasteFlag);
END; {ApplTask}
{----------------------------------------}
PROCEDURE TTextDocument.ClickInDoc(vPt: Point);
VAR
vShift: BOOLEAN;
BEGIN
vShift:= (BitAnd(gEvent.modifiers, ShiftKey)= ShiftKey);
TEClick(vPt, vShift, fTextHdl);
END; {ClickInDoc}
{----------------------------------------}
PROCEDURE TTextDocument.KeyPress(vChar: CHAR);
BEGIN
IF fTextHdl <> NIL THEN
BEGIN
IF (fTextHdl^^.teLength = MaxInt)
AND (vChar <> Chr(kBS)) THEN
BEGIN
CenterMyDialog(ALRT, kSizeErrID);
IF StopAlert(kSizeErrID, NIL) = OK THEN
Exit(KeyPress);
END;
TEKey(vChar, fTextHdl);
WITH fDocRect, fTextHdl^^ DO
bottom:= top + lineHeight * nLines;
fChanged:= TRUE;
END;
END; {KeyPress}
{----------------------------------------}
PROCEDURE TTextDocument.ReDraw;
VAR
vFontInfo: FontInfo;
vViewRect: Rect;
BEGIN
vViewRect:= fViewRect;
InsetRect(vViewRect, kTextMargin, 0);
fViewRect:= vViewRect;
ForeColor(SetColor(fForeC));
BackColor(SetColor(fBackC));
GetFontInfo(vFontInfo);
WITH fTextHdl^^, vFontInfo, fDocRect DO
BEGIN
fontAscent:= ascent;
lineHeight:= ascent + descent + leading;
bottom:= top + nLines * lineHeight;
END;
TECalText(fTextHdl);
InvalRgn(fViewRgn);
END; {ReDraw}
{----------------------------------------}
PROCEDURE TTextDocument.Update;
BEGIN
WITH fTextHdl^^ DO
BEGIN
viewRect:= fViewRect;
destRect:= fDocRect;
TEUpdate(viewRect, fTextHdl);
END;
END; {Update}
{----------------------------------------}
PROCEDURE TTextDocument.Activate;
BEGIN
IF fTextHdl <> NIL THEN
IF BitAnd(gEvent.modifiers, activeFlag) <> 0 THEN
TEActivate(fTextHdl)
ELSE
TEDeActivate(fTextHdl);
END; {Activate}
{----------------------------------------}
PROCEDURE TTextDocument.Edit(vItem: Integer);
VAR
vOffset: LongInt;
BEGIN
CASE vItem OF
kUndo:
;
kCut:
BEGIN
TECut(fTextHdl);
IF OSError(ZeroScrap) THEN
Exit(Edit);
IF OSError(TEToScrap) THEN
Exit(Edit);
END;
kCopy:
BEGIN
TECopy(fTextHdl);
IF OSError(ZeroScrap) THEN
Exit(Edit);
IF OSError(TEToScrap) THEN
Exit(Edit);
END;
kPaste:
BEGIN
IF GetScrap(NIL, TEXT, vOffset) > 0 THEN
IF OSError(TEFromScrap) THEN
Exit(Edit);
IF (fTextHdl^^.teLength + TEGetScrapLen > MaxInt) THEN
BEGIN
CenterMyDialog(ALRT, kSizeErrID);
IF StopAlert(kSizeErrID, NIL) = OK THEN
Exit(Edit);
END;
TEPaste(fTextHdl);
END;
kClear:
TEDelete(fTextHdl);
OTHERWISE
END;
IF vItem <> kCopy THEN
fChanged:= TRUE;
WITH fDocRect, fTextHdl^^ DO
bottom:= top + lineHeight * nLines;
END; {Edit}
{----------------------------------------}
PROCEDURE TTextDocument.Free;
BEGIN
IF fMyHdl <> NIL THEN
DisposHandle(fMyHdl);
TEDispose(fTextHdl);
INHERITED Free;
END; {Free}
{========================================}
PROCEDURE TPictDocument.DoNew;
BEGIN
INHERITED DoNew;
oOvals:= NIL;
oSpirals:= NIL;
oShape:= NIL;
IF gPrintHdl <> NIL THEN
fDocRect:= gPrintHdl^^.prInfo.rPage
ELSE
fDocRect:= thePort^.portRect;
fDocType:= PICT;
fForeC:= kBlack;
fBackC:= kWhite;
fShapeID:= 0;
New(oOvals);
New(oOvals.oDialog);
oOvals.oDialog.Init(5, 1, kPopUPID1, FALSE);
New(oSpirals);
New(oSpirals.oDialog);
oSpirals.oDialog.Init(3, 0, 0, FALSE);
END; {DoNew}
{----------------------------------------}
PROCEDURE TPictDocument.DoOpen(vVolNum, vFileNum: Integer);
VAR
vFileSize: LongInt;
vHdl: Handle;
BEGIN
IF OSError(GetEOF(vFileNum, vFileSize)) THEN
Exit(DoOpen);
IF OSError(SetFPos(vFileNum, FSFromStart, kPictHeader)) THEN
Exit(DoOpen);
vFileSize:= vFileSize - kPictHeader;
vHdl:= NewHandle(vFileSize);
MoveHHi(vHdl);
HLock(vHdl);
IF OSError(FSRead(vFileNum, vFileSize, vHdl^)) THEN
BEGIN
HUnlock(vHdl);
DisposHandle(vHdl);
Exit(DoOpen);
END;
HUnlock(vHdl);
fPictHdl:= PicHandle(vHdl);
fDocRect:= fPictHdl^^.picFrame;
fVolNum:= vVolNum;
fFileNum:= vFileNum;
fChanged:= FALSE;
END; {DoOpen}
{----------------------------------------}
FUNCTION NewClearPtr(logicalSize: LongInt): Ptr;
INLINE
$201F, {move.l (a7)+, d0}
$A31E, {_NewPtr, CLEAR}
$2E88; {move.l a0, (a7)}
{- - - - - - - - - - - - - -}
PROCEDURE TPictDocument.DoSave(vFileNum: Integer);
VAR
vFileSize: LongInt;
vClearPtr: Ptr;
vHdl: Handle;
BEGIN
IF fPictHdl = NIL THEN
Exit(DoSave);
IF OSError(SetFPos(vFileNum, FSFromStart, 0)) THEN
Exit(DoSave);
vFileSize:= kPictHeader;
vClearPtr:= NewClearPtr(vFileSize);
IF OSError(FSWrite(vFileNum, vFileSize, vClearPtr))
THEN BEGIN
DisposPtr(vClearPtr);
Exit(DoSave);
END;
DisposPtr(vClearPtr);
vHdl:= Handle(fPictHdl);
vFileSize:= GetHandleSize(vHdl);
MoveHHi(vHdl);
HLock(vHdl);
IF OSError(FSWrite(vFileNum, vFileSize, vHdl^)) THEN
BEGIN
HUnlock(vHdl);
Exit(DoSave);
END;
HUnlock(vHdl);
fFileNum:= vFileNum;
fChanged:= FALSE;
END; {DoSave}
{----------------------------------------}
PROCEDURE TPictDocument.DoPrint(vPrPort: TPPrPort);
VAR
vPageRect: Rect;
vDocRect: Rect;
vNumCopies: Integer;
i: Integer;
BEGIN
WITH gPrintHdl^^.prJob DO
IF bJDocLoop = BDraftLoop THEN
vNumCopies:= iCopies
ELSE
vNumCopies:= 1;
FOR i:= 1 TO vNumCopies DO
BEGIN
PrOpenPage(vPrPort, NIL);
IF OSError(PrError) THEN
Exit(DoPrint);
vDocRect := fDocRect;
WITH fDocRect DO
OffsetRect(vDocRect, -left, -top);
DrawPicture(fPictHdl, vDocRect);
PrClosePage(vPrPort);
IF OSError(PrError) THEN
END;
END; {DoPrint}
{----------------------------------------}
PROCEDURE TPictDocument.ApplTask;
VAR
vPt: Point;
vCopyFlag: BOOLEAN;
vPasteFlag: BOOLEAN;
BEGIN
GetMouse(vPt);
IF PtInRgn(vPt, fViewRgn) THEN
SetCursor(gCross)
ELSE
SetCursor(arrow);
vCopyFlag:= TRUE;
vPasteFlag:= (InfoScrap^.scrapSize > 0);
SetEnable(kEditID, kCut, vCopyFlag);
SetEnable(kEditID, kCopy, vCopyFlag);
SetEnable(kEditID, kPaste, vPasteFlag);
END; {ApplTask}
{----------------------------------------}
PROCEDURE TPictDocument.ClickInDoc(vPt: Point);
BEGIN
CASE fShapeID OF
kOvals:
oShape:= oOvals;
kSpirals:
oShape:= oSpirals;
OTHERWISE
Exit(ClickInDoc);
END;
WITH oShape DO
BEGIN
fPt.h:= vPt.h - fDocRect.left;
fPt.v:= vPt.v - fDocRect.top;
oDialog.DoDialog(2000 + fShapeID);
IF oDialog.fDFlag = FALSE THEN
Exit(ClickInDoc);
END;
self.ReDraw;
ValidRgn(fViewRgn);
SetClip(fViewRgn);
EraseRgn(fViewRgn);
self.Update;
ClipRect(thePort^.portRect);
END; {ClickInDoc}
{----------------------------------------}
PROCEDURE TPictDocument.ReDraw;
CONST
PicDwgBeg = 130;
PicDwgEnd = 131;
PicGrpBeg = 140;
PicGrpEnd = 141;
VAR
vPt: Point;
vClipRect: Rect;
BEGIN
IF oShape <> NIL THEN
BEGIN
ForeColor(SetColor(fForeC));
BackColor(SetColor(fBackC));
WITH oShape DO
BEGIN
vPt.h:= fPt.h + fDocRect.left;
vPt.v:= fPt.v + fDocRect.top;
END;
SetRect(vClipRect,-10000,-10000,10000,10000);
ClipRect(vClipRect);
IF fPictHdl <> NIL THEN
KillPicture(fPictHdl);
fPictHdl:= OpenPicture(fDocRect);
PicComment(PicDwgBeg, 0, NIL);
PicComment(PicGrpBeg, 0, NIL);
oShape.Create(vPt);
PicComment(PicGrpEnd, 0, NIL);
PicComment(PicDwgEnd, 0, NIL);
ClosePicture;
fDocRect:= fPictHdl^^.picFrame;
fChanged:= TRUE;
END;
IF fPictHdl <> NIL THEN
InvalRgn(fViewRgn);
END; {ReDraw}
{----------------------------------------}
PROCEDURE TPictDocument.Update;
BEGIN
IF fPictHdl <> NIL THEN
DrawPicture(fPictHdl, fDocRect);
END; {Update}
{----------------------------------------}
PROCEDURE TPictDocument.Edit (vItem: Integer);
VAR
vLength: LongInt;
vErr: OSErr;
vOffset: LongInt;
vScrapHdl: Handle;
BEGIN
CASE vItem OF
kUndo:
;
kCut:
BEGIN
vScrapHdl:= NewHandle(0);
vScrapHdl:= Handle(fPictHdl);
IF vScrapHdl <> NIL THEN
IF NOT OSError(ZeroScrap) THEN
BEGIN
vLength:= GetHandleSize(vScrapHdl);
MoveHHi(vScrapHdl);
HLock(vScrapHdl);
vErr:= PutScrap(vLength, PICT, vScrapHdl^);
HUnlock(vScrapHdl);
IF oShape <> NIL THEN
oShape:= NIL;
IF fPictHdl <> NIL THEN
BEGIN
KillPicture(fPictHdl);
fPictHdl:= NIL;
END;
END;
vScrapHdl:= NIL;
DisposHandle(vScrapHdl);
END;
kCopy:
BEGIN
vScrapHdl:= NewHandle(0);
vScrapHdl:= Handle(fPictHdl);
IF NOT OSError(ZeroScrap) THEN
IF vScrapHdl <> NIL THEN
BEGIN
vLength:= GetHandleSize(vScrapHdl);
MoveHHi(vScrapHdl);
HLock(vScrapHdl);
vErr:= PutScrap(vLength, PICT, vScrapHdl^);
HUnlock(vScrapHdl);
END;
vScrapHdl:= NIL;
DisposHandle(vScrapHdl);
END;
kPaste:
BEGIN
vScrapHdl:= NewHandle(0);
vLength:= GetScrap(vScrapHdl, PICT, vOffset);
IF vLength > 0 THEN
BEGIN
IF fPictHdl <> NIL THEN
BEGIN
KillPicture(fPictHdl);
fPictHdl:= NIL;
END;
fPictHdl:= PicHandle(vScrapHdl);
fDocRect:= fPictHdl^^.picFrame;
END;
END;
kClear:
BEGIN
IF oShape <> NIL THEN
oShape:= NIL;
IF fPictHdl <> NIL THEN
BEGIN
KillPicture(fPictHdl);
fPictHdl:= NIL;
END;
END;
OTHERWISE
END;
IF vItem <> kCopy THEN
BEGIN
SetClip(fViewRgn);
EraseRgn(fViewRgn);
self.Update;
ClipRect(thePort^.portRect);
fChanged:= TRUE;
END;
END; {Edit}
{----------------------------------------}
PROCEDURE TPictDocument.Free;
BEGIN
IF oOvals <> NIL THEN
oOvals.Free;
IF oSpirals <> NIL THEN
oSpirals.Free;
IF fPictHdl <> NIL THEN
KillPicture(fPictHdl);
INHERITED Free;
END; {Free}
END. {unit MyDocuments}
{***********************************}
Listing: MyShapes.p
UNIT MyShapes;
{****************************************}
INTERFACE
USES
MemTypes, QuickDraw, OSIntf, ToolIntf, PackIntf, MacPrint, ObjIntf,
GlobalStuff, MyDialogs;
TYPE
TShape = OBJECT(TObject)
fPt: Point;
oDialog: TDialog;
PROCEDURE Create(vPt: Point);
PROCEDURE Free;
override;
END;
TOvals = OBJECT(TShape)
PROCEDURE Create(vPt: Point);
override;
END;
TSpirals = OBJECT(TShape)
PROCEDURE Create(vPt: Point);
override;
END;
{****************************************}
IMPLEMENTATION
PROCEDURE TShape.Create(vPt: Point);
BEGIN
END; {Create}
{----------------------------------------}
PROCEDURE TShape.Free;
BEGIN
IF oDialog <> NIL THEN
oDialog.Free;
INHERITED Free;
END; {Free}
{========================================}
PROCEDURE TOvals.Create(vPt: Point);
VAR
vItem: Integer;
i: Integer;
vRect: Rect;
vMax: LongInt;
vHSize, vVSize: LongInt;
vHDelta, vVDelta: LongInt;
BEGIN
MoveTo(vPt.h, vPt.v);
WITH oDialog DO
BEGIN
StringToNum(fStr[1], vMax);
StringToNum(fStr[2], vHSize);
StringToNum(fStr[3], vVSize);
StringToNum(fStr[4], vHDelta);
StringToNum(fStr[5], vVDelta);
END;
vItem := oDialog.fPopItem;
WITH vPt DO
SetRect(vRect,h-vHSize,v-vVSize,
h+vHSize,v+vVSize);
IF vMax > 0 THEN
FOR i:= 1 TO vMax DO
BEGIN
CASE vItem OF
kFrameOval:
FrameOval(vRect);
kInvertOval:
InvertOval(vRect);
kFrameRect:
FrameRect(vRect);
kInvertRect:
InvertRect(vRect);
OTHERWISE
END;
InsetRect(vRect, vHDelta, vVDelta);
END;
END; {Create}
{========================================}
PROCEDURE TSpirals.Create(vPt: Point);
VAR
i, j: Integer;
x, y, z: LongInt;
dH, dV, dX: LongInt;
vMax: LongInt;
BEGIN
MoveTo(vPt.h, vPt.v);
WITH oDialog DO
BEGIN
StringToNum(fStr[1], dH);
StringToNum(fStr[2], dV);
StringToNum(fStr[3], vMax);
END;
x:= 0;
y:= 1;
z:= -1;
IF vMax > 0 THEN
REPEAT
x:= x + 1;
IF odd(x) THEN
y:= -y;
IF odd(x + 1) THEN
z:= -z;
dV:= dV * y * z;
dH:= dH * z * y;
Line(dH, dV);
dX:= dH + 2 * y;
dH:= dV + 2 * z;
dV:= dX;
UNTIL x = vMax;
END; {Create}
END. {unit MyShapes}
{****************************************}
Listing: MyDialogs.p
UNIT MyDialogs;
{****************************************}
INTERFACE
USES
MemTypes, QuickDraw, OSIntf, ToolIntf, PackIntf, MacPrint, ObjIntf,
GlobalStuff;
TYPE
TDialog = OBJECT(TObject)
fDlogItems: Integer;
fDFlag: BOOLEAN;
fPopMenus: Integer;
fPopUpID: Integer;
fPopItem: Integer;
fStr: ARRAY[1..kMaxEditItems] OF Str255;
PROCEDURE Init (vDlogItems, vPopMenus,
vPopUpID: Integer; vDFlag: BOOLEAN);
PROCEDURE DoDialog(vDialogID: Integer);
END;
{****************************************}
IMPLEMENTATION
CONST
cPromptItem = 3;
cPopUpItem = 4;
cFirstEditItem = 5;
VAR
uItemType: Integer;
uItemHdl: Handle;
uItemRect: Rect;
uPopUpRect: Rect;
uPromptRect: Rect;
uPopUpID: Integer;
uPopMenuHdl: MenuHandle;
uMarkedItem: Integer;
{========================================}
PROCEDURE TDialog.Init (vDlogItems, vPopMenus,
vPopUpID: Integer; vDFlag: BOOLEAN);
BEGIN
fDlogItems:= vDlogItems;
fPopMenus:= vPopMenus;
fPopUpID:= vPopUpID;
fPopItem:= 1;
fDFlag:= vDFlag;
END; {Init}
{========================================}
PROCEDURE OutlineOK(vDPtr: DialogPtr);
VAR
vSavePort: GrafPtr;
BEGIN
GetPort(vSavePort);
SetPort(vDPtr);
GetDItem(vDPtr,OK,uItemType,uItemHdl,uItemRect);
IF uItemHdl <> NIL THEN
BEGIN
PenSize(3, 3);
InsetRect(uItemRect, -4, -4);
FrameRoundRect(uItemRect, 16, 16);
PenSize(1, 1);
END;
SetPort(vSavePort);
END; {OutlineOK}
{- - - - - - - - - - - - - -}
PROCEDURE DrawPopUp (vDPtr: DialogPtr; vItem: Integer);
CONST
cLeftSlop = 5;
cRightSlop = 3;
cBotSlop = 7;
VAR
vRect: Rect;
vItemText: Str255;
vWidth, vNewWidth, vNewLength: Integer;
BEGIN
GetItem(uPopMenuHdl, uMarkedItem, vItemText);
vRect:= uPopUpRect;
WITH vRect DO
BEGIN
InsetRect(vRect, -1, -1);
vWidth:= (right - left) - (cLeftSlop + cRightSlop);
vNewWidth:= StringWidth(vItemText);
IF vNewWidth > vWidth THEN
BEGIN
vNewLength:= LENGTH(vItemText);
vWidth:= vWidth - CharWidth( );
REPEAT
vNewWidth:= vNewWidth -CharWidth(vItemText[vNewLength]);
Delete(vItemText, vNewLength, 1);
vNewLength:= PRED(vNewLength);
UNTIL (vNewWidth <= vWidth) OR (LENGTH(vItemText) = 0);
vNewLength:= SUCC(vNewLength);
Insert( , vItemText, vNewLength);
END;
FrameRect(vRect);
MoveTo(right, top + 2);
LineTo(right, bottom);
LineTo(left + 2, bottom);
MoveTo(left + cLeftSlop, bottom - cBotSlop);
DrawString(vItemText);
END;
END; {DrawPopUp}
{- - - - - - - - - - - - - -}
FUNCTION MyFilter (vDPtr: DialogPtr;
VAR vEvent: EventRecord;
VAR vItemHit: Integer): BOOLEAN;
VAR
vSavePort: GrafPtr;
vMousePt, vPopLoc: Point;
vNewItem: Integer;
vResult: LongInt;
BEGIN
vItemHit:= 0;
MyFilter:= FALSE;
GetPort(vSavePort);
SetPort(vDPtr);
CASE vEvent.what OF
keyDown:
BEGIN
IF (vEvent.message MOD 256) IN [kCR, kEnter]
THEN BEGIN
GetDItem(vDPtr, OK, uItemType, uItemHdl, uItemRect);
HiliteControl(ControlHandle(uItemHdl), 1);
Delay(3, vResult);
MyFilter:= TRUE;
vItemHit:= OK;
END;
END;
mouseDown:
BEGIN
vMousePt:= vEvent.where;
GlobalToLocal(vMousePt);
IF (FindDItem(vDPtr, vMousePt)+1)= cPopUpItem
THEN BEGIN
InvertRect(uPromptRect);
InsertMenu(uPopMenuHdl, -1);
vPopLoc:= uPopUpRect.topLeft;
LocalToGlobal(vPopLoc);
CalcMenuSize(uPopMenuHdl);
WITH vPopLoc DO
vResult:= PopUpMenuSelect(uPopMenuHdl, v, h, uMarkedItem);
InvertRect(uPromptRect);
DeleteMenu(uPopUpID);
IF vResult <> 0 THEN
BEGIN
vNewItem:= LoWord(vResult);
IF vNewItem <> uMarkedItem THEN
BEGIN
SetItemMark(uPopMenuHdl, uMarkedItem, );
SetItemMark(uPopMenuHdl, vNewItem, CHR(checkMark));
uMarkedItem:= vNewItem;
EraseRect(uPopUpRect);
DrawPopUp(vDPtr, cPopUpItem);
MyFilter:= TRUE;
vItemHit:= cPopUpItem;
END;
END;
END;
END;
OTHERWISE
END;
SetPort(vSavePort);
END; {MyFilter}
{- - - - - - - - - - - - - -}
PROCEDURE TDialog.DoDialog (vDialogID: Integer);
VAR
vDPtr: DialogPtr;
vItem, vItemNum: Integer;
vStr: Str255;
BEGIN
CenterMyDialog(DLOG, vDialogID);
vDPtr:= GetNewDialog(vDialogID, NIL, POINTER(-1));
IF vDPtr = NIL THEN
Exit(DoDialog);
IF fDFlag THEN
FOR vItem:= 1 TO fDlogItems DO
BEGIN
vItemNum:= vItem + cFirstEditItem - 1;
GetDItem(vDPtr, vItemNum, uItemType, uItemHdl, uItemRect);
SetIText(uItemHdl, fStr[vItem]);
END;
OutlineOK(vDPtr);
GetDItem(vDPtr, cFirstEditItem, uItemType, uItemHdl, uItemRect);
SelIText(vDPtr, cFirstEditItem, 0, maxInt);
CASE fPopMenus OF
0:
REPEAT
ModalDialog(NIL, vItemNum)
UNTIL (vItemNum IN [OK, Cancel]);
1:
BEGIN
uPopUpID:= fPopUpID;
uPopMenuHdl:= GetMenu(fPopUpID);
SetItemMark(uPopMenuHdl, fPopItem, CHR(checkMark));
uMarkedItem:= fPopItem;
GetDItem(vDPtr, cPopUpItem, uItemType, uItemHdl, uPopUpRect);
SetDItem(vDPtr, cPopUpItem, uItemType, @DrawPopUp, uPopUpRect);
GetDItem(vDPtr, cPromptItem, uItemType, uItemHdl, uPromptRect);
REPEAT
ModalDialog(@MyFilter, vItemNum);
CASE vItemNum OF
cPopUpItem:
BEGIN
fPopItem:= uMarkedItem;
END;
OTHERWISE
END;
UNTIL (vItemNum IN [OK, Cancel]);
ReleaseResource(Handle(uPopMenuHdl));
END;
OTHERWISE
END;
CASE vItemNum OF
OK:
BEGIN
FOR vItem:= 1 TO fDlogItems DO
BEGIN
vItemNum:= vItem + cFirstEditItem - 1;
GetDItem(vDPtr, vItemNum, uItemType, uItemHdl, uItemRect);
GetIText(uItemHdl, vStr);
fStr[vItem]:= vStr;
END;
fDFlag:= TRUE;
END;
Cancel:
BEGIN
fPopItem:= 1;
fDFlag:= FALSE;
END;
OTHERWISE
END;
DisposDialog(vDPtr);
END; {DoDialog}
END. {unit MyDialogs}
{****************************************}
Listing: ResourceFile.r
resource ALRT (1000) {
{80, 58, 224, 366},
100,
{ /* array: 4 elements */
/* [1] */
OK, visible, silent,
/* [2] */
OK, visible, silent,
/* [3] */
OK, visible, silent,
/* [4] */
OK, visible, silent
}
};
resource ALRT (1001) {
{82, 78, 164, 464},
1001,
{ /* array: 4 elements */
/* [1] */
OK, visible, sound1,
/* [2] */
OK, visible, sound1,
/* [3] */
OK, visible, sound1,
/* [4] */
OK, visible, sound1
}
};
resource ALRT (1003) {
{64, 68, 188, 348},
1003,
{ /* array: 4 elements */
/* [1] */
OK, visible, sound1,
/* [2] */
OK, visible, sound1,
/* [3] */
OK, visible, sound1,
/* [4] */
OK, visible, sound1
}
};
resource ALRT (1002) {
{94, 84, 170, 370},
1002,
{ /* array: 4 elements */
/* [1] */
OK, visible, sound1,
/* [2] */
OK, visible, sound1,
/* [3] */
OK, visible, sound1,
/* [4] */
OK, visible, sound1
}
};
resource DITL (100, purgeable) {
{ /* array DITLarray: 2 elements */
/* [1] */
{109, 45, 129, 104},
Button {
enabled,
OK
},
/* [2] */
{30, 40, 87, 268},
StaticText {
disabled,
ObjectShell Program\n
Version 1.0\n Copyright by ^0
}
}
};
resource DITL (1001) {
{ /* array DITLarray: 3 elements */
/* [1] */
{50, 296, 71, 358},
Button {
enabled,
OK
},
/* [2] */
{40, 104, 70, 260},
StaticText {
disabled,
Error number: ^0
},
/* [3] */
{8, 104, 32, 360},
StaticText {
disabled,
^1
}
}
};
resource DITL (1002) {
{ /* array DITLarray: 2 elements */
/* [1] */
{45, 84, 66, 144},
Button {
enabled,
OK
},
/* [2] */
{7, 84, 36, 274},
StaticText {
disabled,
Text too long for TextEdit
}
}
};
resource DITL (1003) {
{ /* array DITLarray: 4 elements */
/* [1] */
{81, 31, 101, 91},
Button {
enabled,
Yes
},
/* [2] */
{80, 184, 100, 244},
Button {
enabled,
cancel
},
/* [3] */
{13, 31, 60, 227},
StaticText {
disabled,
Do you want to save changes to \^0\?
},
/* [4] */
{80, 107, 100, 167},
Button {
enabled,
No
}
}
};
resource DITL (2000) {
{ /* array DITLarray: 1 elements */
/* [1] */
{19, 25, 80, 245},
StaticText {
disabled,
Printing in Progress...\nTo stop printing
, hold down the\n\0x11-Key and type period(.)
.
}
}
};
resource DITL (2001) {
{ /* array DITLarray: 14 elements */
/* [1] */
{216, 24, 236, 84},
Button {
enabled,
OK
},
/* [2] */
{216, 104, 236, 164},
Button {
enabled,
Cancel
},
/* [3] */
{20, 110, 36, 213},
StaticText {
disabled,
Kind of Shape
},
/* [4] */
{20, 214, 38, 295},
UserItem {
enabled
},
/* [5] */
{56, 272, 77, 332},
EditText {
enabled,
38
},
/* [6] */
{96, 272, 118, 332},
EditText {
enabled,
150
},
/* [7] */
{128, 272, 148, 332},
EditText {
enabled,
150
},
/* [8] */
{168, 272, 188, 332},
EditText {
enabled,
4
},
/* [9] */
{198, 272, 218, 332},
EditText {
enabled,
0
},
/* [10] */
{56, 136, 80, 256},
StaticText {
disabled,
Number of Shapes
},
/* [11] */
{96, 24, 120, 256},
StaticText {
disabled,
Starting Size of Shapes: horizontal
},
/* [12] */
{127, 185, 147, 245},
StaticText {
disabled,
vertical
},
/* [13] */
{168, 32, 192, 264},
StaticText {
disabled,
Pixels to inset Shapes: horizontal
},
/* [14] */
{198, 185, 218, 245},
StaticText {
disabled,
vertical
}
}
};
resource DITL (2002) {
{ /* array DITLarray: 8 elements */
/* [1] */
{179, 26, 199, 86},
Button {
enabled,
OK
},
/* [2] */
{180, 110, 200, 170},
Button {
enabled,
Cancel
},
/* [3] */
{24, 56, 48, 208},
StaticText {
disabled,
Length of Initial Line
},
/* [4] */
{72, 80, 96, 208},
StaticText {
disabled,
Vertical Deviation
},
/* [5] */
{24, 224, 44, 284},
EditText {
enabled,
150
},
/* [6] */
{72, 224, 92, 284},
EditText {
enabled,
150
},
/* [7] */
{128, 224, 148, 284},
EditText {
enabled,
150
},
/* [8] */
{128, 88, 152, 208},
StaticText {
disabled,
Number of Lines
}
}
};
resource MENU (1) {
1,
textMenuProc,
0x7FFFFFFD,
enabled,
apple,
{ /* array: 2 elements */
/* [1] */
About ObjectShell.., noIcon, , , plain,
/* [2] */
-, noIcon, , , plain
}
};
resource MENU (2) {
2,
textMenuProc,
0x7FFFFDB7,
enabled,
File,
{ /* array: 11 elements */
/* [1] */
New, noIcon, hierarchicalMenu, \0x15, plain,
/* [2] */
Open, noIcon, O, , plain,
/* [3] */
Close, noIcon, , , plain,
/* [4] */
-, noIcon, , , plain,
/* [5] */
Save, noIcon, S, , plain,
/* [6] */
Save As... , noIcon, , , plain,
/* [7] */
-, noIcon, , , plain,
/* [8] */
Page Setup..., noIcon, , , plain,
/* [9] */
Print, noIcon, P, , plain,
/* [10] */
-, noIcon, , , plain,
/* [11] */
Quit , noIcon, Q, , plain
}
};
resource MENU (3) {
3,
textMenuProc,
0x7FFFFFFD,
enabled,
Edit,
{ /* array: 6 elements */
/* [1] */
Undo , noIcon, Z, , plain,
/* [2] */
-, noIcon, , , plain,
/* [3] */
Cut , noIcon, X, , plain,
/* [4] */
Copy , noIcon, C, , plain,
/* [5] */
Paste , noIcon, V, , plain,
/* [6] */
Clear, noIcon, , , plain
}
};
resource MENU (21) {
21,
textMenuProc,
allEnabled,
enabled,
New,
{ /* array: 2 elements */
/* [1] */
TextWindow, noIcon, hierarchicalMenu, , plain,
/* [2] */
PictWindow, noIcon, hierarchicalMenu, , plain
}
};
resource MENU (4) {
4,
textMenuProc,
allEnabled,
enabled,
Graphics,
{ /* array: 3 elements */
/* [1] */
Ovals, noIcon, , , plain,
/* [2] */
Spirals, noIcon, , , plain,
}
};
resource MENU (5) {
5,
textMenuProc,
allEnabled,
enabled,
Color,
{ /* array: 2 elements */
/* [1] */
ForeColor , noIcon, hierarchicalMenu, 3, plain,
/* [2] */
BackColor, noIcon, hierarchicalMenu, 4, plain
}
};
resource MENU (51) {
51,
textMenuProc,
allEnabled,
enabled,
ForeColor,
{ /* array: 8 elements */
/* [1] */
Black, noIcon, , , plain,
/* [2] */
White, noIcon, , , plain,
/* [3] */
Red, noIcon, , , plain,
/* [4] */
Green, noIcon, , , plain,
/* [5] */
Blue, noIcon, , , plain,
/* [6] */
Cyan, noIcon, , , plain,
/* [7] */
Magenta, noIcon, , , plain,
/* [8] */
Yellow, noIcon, , , plain
}
};
resource MENU (52) {
52,
textMenuProc,
allEnabled,
enabled,
BackColor,
{ /* array: 8 elements */
/* [1] */
Black, noIcon, , , plain,
/* [2] */
White, noIcon, , , plain,
/* [3] */
Red, noIcon, , , plain,
/* [4] */
Green, noIcon, , , plain,
/* [5] */
Blue, noIcon, , , plain,
/* [6] */
Cyan, noIcon, , , plain,
/* [7] */
Magenta, noIcon, , , plain,
/* [8] */
Yellow, noIcon, , , plain
}
};
resource MENU (6) {
6,
textMenuProc,
allEnabled,
enabled,
Text,
{ /* array: 4 elements */
/* [1] */
Font, noIcon, hierarchicalMenu, =, plain,
/* [2] */
Size, noIcon, hierarchicalMenu, >, plain,
/* [3] */
Style, noIcon, hierarchicalMenu, ?, plain,
/* [4] */
Align\0x00, noIcon, hierarchicalMenu, @, plain
}
};
resource MENU (61) {
61,
textMenuProc,
allEnabled,
enabled,
Font,
{ /* array: 0 elements */
}
};
resource MENU (62) {
62,
textMenuProc,
allEnabled,
enabled,
Size,
{ /* array: 9 elements */
9, noIcon, , , plain,
10, noIcon, , , plain,
12, noIcon, , , plain,
14, noIcon, , , plain,
18, noIcon, , , plain,
24, noIcon, , , plain,
36, noIcon, , , plain,
48, noIcon, , , plain,
72, noIcon, , , plain
}
};
resource MENU (211) {
211,
textMenuProc,
allEnabled,
enabled,
PictWindow,
{ /* array: 8 elements */
/* [1] */
NoGrowWindow, noIcon, , , plain,
/* [2] */
GrowWindow, noIcon, , , plain,
/* [3] */
HScrollWindow, noIcon, , , plain,
/* [4] */
VScrollWindow, noIcon, , , plain,
/* [5] */
ScrollWindow, noIcon, , , plain,
/* [6] */
HScrollZoomWindow, noIcon, , , plain,
/* [7] */
VScrollZoomWindow, noIcon, , , plain,
/* [8] */
ScrollZoomWindow, noIcon, , , plain
}
};
resource MENU (212) {
212,
textMenuProc,
allEnabled,
enabled,
TextWindow,
{ /* array: 8 elements */
/* [1] */
NoGrowWindow, noIcon, , , plain,
/* [2] */
GrowWindow, noIcon, , , plain,
/* [3] */
HScrollWindow, noIcon, , , plain,
/* [4] */
VScrollWindow, noIcon, , , plain,
/* [5] */
ScrollWindow, noIcon, , , plain,
/* [6] */
HScrollZoomWindow, noIcon, , , plain,
/* [7] */
VScrollZoomWindow, noIcon, , , plain,
/* [8] */
ScrollZoomWindow, noIcon, , , plain
}
};
resource MENU (63) {
63,
textMenuProc,
allEnabled,
enabled,
Style,
{ /* array: 8 elements */
/* [1] */
Plain, noIcon, , , plain,
/* [2] */
Bold, noIcon, B, , 1,
/* [3] */
Italic, noIcon, I, , 2,
/* [4] */
Underline, noIcon, U, , 4,
/* [5] */
Outline, noIcon, , , 8,
/* [6] */
Shadow, noIcon, T, , 16,
/* [7] */
Condense, noIcon, , , plain,
/* [8] */
Extend, noIcon, , , plain
}
};
resource MENU (64) {
64,
textMenuProc,
allEnabled,
enabled,
Align,
{ /* array: 3 elements */
/* [1] */
Left, noIcon, , , plain,
/* [2] */
Middle, noIcon, , , plain,
/* [3] */
Right, noIcon, , , plain
}
};
resource MENU (10) {
10,
textMenuProc,
allEnabled,
enabled,
PopupMenu,
{ /* array: 4 elements */
/* [1] */
FrameOval, noIcon, , , plain,
/* [2] */
InvertOval, noIcon, , , plain,
/* [3] */
FrameRectangle, noIcon, , , plain,
/* [4] */
InvertRectangle, noIcon, , , plain
}
};
resource STR# (1000) {
{ /* array StringArray: 2 elements */
/* [1] */
Untitled,
/* [2] */
Save current document as:
}
};
resource STR# (1001) {
{ /* array StringArray: 2 elements */
/* [1] */
Duplicate file name,
/* [2] */
File already open
}
};
resource DLOG (2000, purgeable) {
{72, 66, 174, 334},
dBoxProc,
visible,
noGoAway,
0x0,
2000,
New Dialog
};
resource DLOG (2001, purgeable) {
{46, 44, 312, 406},
dBoxProc,
visible,
noGoAway,
0x0,
2001,
New Dialog
};
resource DLOG (2002, purgeable) {
{40, 40, 252, 360},
dBoxProc,
visible,
noGoAway,
0x0,
2002,
New Dialog
};
resource BNDL (1001) {
CSOS,
0,
{ /* array TypeArray: 2 elements */
/* [1] */
ICN#,
{ /* array IDArray: 3 elements */
0, 1001,
1, 1002,
2, 1003
},
/* [2] */
FREF,
{ /* array IDArray: 3 elements */
0, 1001,
1, 1002,
2, 1003
}
}
};
resource FREF (1001) {
APPL,
0,
};
resource FREF (1002) {
TEXT,
1,
};
resource FREF (1003) {
PICT,
2,
};
resource ICN# (1001, CSOS APPL, purgeable) {
{ /* array: 2 elements */
/* [1] */
$0000 0000 0000 0000 0000 0000 07FF FF00"
$0800 0080 0FFF FF80 0800 0080 0FFF FF80"
$0800 0080 0FFF FF80 7800 00F0 8000 0008"
$8000 0008 99C5 CDC8 A525 1088 A5C5 9088"
$A525 1088 99CD CC88 8000 0008 FFFF FFF8"
$8000 0008 8757 4408 8854 4408 8676 4408"
$8154 4408 8E57 7708 8000 0008 FFFF FFF8"
$8000 0008 FFFF FFF8 8000 0008 7FFF FFF0",
/* [2] */
$0000 0000 0000 0000 0000 0000 07FF FF00"
$0FFF FF80 0FFF FF80 0FFF FF80 0FFF FF80"
$0FFF FF80 0FFF FF80 7FFF FFF0 FFFF FFF8"
$FFFF FFF8 FFFF FFF8 FFFF FFF8 FFFF FFF8"
$FFFF FFF8 FFFF FFF8 FFFF FFF8 FFFF FFF8"
$FFFF FFF8 FFFF FFF8 FFFF FFF8 FFFF FFF8"
$FFFF FFF8 FFFF FFF8 FFFF FFF8 FFFF FFF8"
$FFFF FFF8 FFFF FFF8 FFFF FFF8 7FFF FFF0"
}
};
resource ICN# (1002, CSOS TEXT, purgeable) {
{ /* array: 2 elements */
/* [1] */
$0000 0000 0000 0000 0000 0000 07FF FF00"
$0800 0080 0FFF FF80 0800 0080 0FFF FF80"
$0800 0080 0FFF FF80 0800 0080 7FFF FFF0"
$8000 0008 99C5 CDC8 A525 1088 A5C5 9088"
$A525 1088 99CD CC88 8000 0008 FFFF FFF8"
$8000 0008 81DD 5C08 8090 8808 8098 8808"
$8090 8808 809D 4808 8000 0008 7FFF FFF0"
$0800 0080 0FFF FF80 0800 0080 07FF FF,
/* [2] */
$0000 0000 0000 0000 0000 0000 07FF FF00"
$0FFF FF80 0FFF FF80 0FFF FF80 0FFF FF80"
$0FFF FF80 0FFF FF80 0FFF FF80 7FFF FFF0"
$FFFF FFF8 FFFF FFF8 FFFF FFF8 FFFF FFF8"
$FFFF FFF8 FFFF FFF8 FFFF FFF8 FFFF FFF8"
$FFFF FFF8 FFFF FFF8 FFFF FFF8 FFFF FFF8"
$FFFF FFF8 FFFF FFF8 FFFF FFF8 7FFF FFF0"
$0FFF FF80 0FFF FF80 0FFF FF80 07FF FF
}
};
resource ICN# (1003, CSOS PICT, purgeable) {
{ /* array: 2 elements */
/* [1] */
$0000 0000 0000 0000 0000 0000 07FF FF00"
$0800 0080 0FFF FF80 0800 0080 0FFF FF80"
$0800 0080 0FFF FF80 0800 0080 7FFF FFF0"
$8000 0008 99C5 CDC8 A525 1088 A5C5 9088"
$A525 1088 99CD CC88 8000 0008 FFFF FFF8"
$8000 0008 81C9 B808 812A 1008 81CA 1008"
$810A 1008 8109 9008 8000 0008 7FFF FFF0"
$0800 0080 0FFF FF80 0800 0080 07FF FF,
/* [2] */
$0000 0000 0000 0000 0000 0000 07FF FF00"
$0FFF FF80 0FFF FF80 0FFF FF80 0FFF FF80"
$0FFF FF80 0FFF FF80 0FFF FF80 7FFF FFF0"
$FFFF FFF8 FFFF FFF8 FFFF FFF8 FFFF FFF8"
$FFFF FFF8 FFFF FFF8 FFFF FFF8 FFFF FFF8"
$FFFF FFF8 FFFF FFF8 FFFF FFF8 FFFF FFF8"
$FFFF FFF8 FFFF FFF8 FFFF FFF8 7FFF FFF0"
$0FFF FF80 0FFF FF80 0FFF FF80 07FF FF
}
};
data CSOS (0) {
$19A9 2031 3938 3920 4368 7269 7374 6961"
$6E20 5374 7261 746F 7761"
};
resource SIZE (-1) {
dontSaveScreen,
acceptSuspendResumeEvents,
enableOptionSwitch,
cannotBackground,
multiFinderAware,
131072,
81920
};