![](/file/12652/www.mactech.com.tar/www.mactech.com/sites/all/themes/custom_front/images/you_are_here_red.gif)
![](/file/12652/www.mactech.com.tar/www.mactech.com/sites/default/files/beta-site.gif)
|
Volume Number: | 4 | |
Issue Number: | 2 | |
Column Tag: | Macintosh II |
Screen Dump FKEY for Color Picts
By Steven C. Sheets, Chicago, IL
In our first article, we saw how to create a plot in PICT format, complete with the old style Quickdraw color. But, since our program did not include an open command, how can we view the plot in color once it is made? If we try to snapshot the color screen, we get a beep! What we need is a way to snapshot and view our plot without having to turn off the color. Steve Sheets, from Apple’s Chicago technical support office, shows us how to capture the screen on a Mac II with the color enabled.And best of all, the picture is not rotated! Once we capture our plot, we want to view it. Steve again comes to our rescue with a companion viewer DA for color PICTs.
Color Images: Saving and Loading
Since this column has given some examples of how to draw in Color on the Mac //, now would be a good time to describe how to save and load color pictures. While a specific file format can always be defined for an application, it is convenient to be able to read generic file formats, so that various applications can share and port data. When discussing graphics, the two generic file formats have always been MacPaint file format and PICT file format. MacPaint format has always been considered the generic Bitmap method of saving Mac graphics, while PICT format is the associated with object oriented graphics programs (ie. MacDraw).
With the introduction of Color Quickdraw and the Mac //, things have changed slightly. Unfortunately MacPaint file format can not be expanded to cover PixMap graphics (ie. multiple colors per pixel). Nor is there any other PixMap file format that has been widely accepted by developers (though there is a need). On the other hand, PICT file format is nothing but an extension of a Quickdraw Picture Handle. With the introduction of the Mac //, Quickdraw Pictures have been expanded to support color. This article will talk about the new Color Quickdraw Picture format, the PICT file format, and will touch briefly on using the Palette Manager to display a Picture in the Color needed. The example sources, ColorImage DA and ColorImage FKEY, will demonstrate how to save and read PICT file.
Quickdraw Picture Format
A Quickdraw Picture is a data structure that contains a sequence of Quickdraw commands. To create a Picture, a program defines a Picture Frame (ie, a rectangle and data structure) with the OpenPicture function. OpenPicture returns a handle to the Picture data structure being created. At this point, the program can call any Quickdraw command. Instead of being drawn on the current grafport, the command is stored in the Picture for later use. A ClosePicture command needs to be issued to tell Quickdraw to stop saving the commands into the Picture Handle. Once the program has a Picture, it can display it using the DrawPicture call. This will draw the Picture (ie. all the Quickdraw commands saved in the Picture) into a destination rectangle. If the destination rectangle is not the same size as the picture frame, the picture will be expanded or reduced to fit the destination rectangle. The Plotter program in this issue illustrates this traditional use of the Quickdraw picture.
The Picture handle points to a data structure which contains the Picture Size (Integer picSize), the Picture Frame (Rect picFrame) and various Opcodes describing the Quickdraw calls. Always ignore picSize. With the expansion of the Memory Manager so that it can handle sizes beyond 32K, picSize is now ignored by Quickdraw. Instead, the picture is played out until the end. If the Picture size is needed, call GetHandleSize. Generally beyond picSize and picFrame, a program should not read the data structures directly. The internal structures beyond this point are documented in Inside Macintosh, Vol 5 and the various tech notes cited in the Pascal column.
An image stored and drawn as a Picture (using DrawPicture) is much more compressed than the same image drawn using individual Quickdraw commands in the code. Also the program can pass a Picture through the clipboard and Scrapbook to other Applications. Notice while the Picture is considered an Object Graphic type of data structure, one of the commands it stores is CopyBits. A Picture can thus have BitMapped graphics in it.
Version 1 vs Version 2 Format
With the introduction of the Mac //, the Picture Format has been extended. The old Picture format (called Version 1 Format) contains only the non-Color Quickdraw commands. The newer Picture format (called Version 2 Format) contains all the Color Quickdraw commands. On a Mac //, which Format is created with an OpenPicture call depends on the current GrafPort. If an OpenPicture call is made when the current GrafPort is a Color GrafPort, the Picture created is a Version 2 format. If a call is made on a normal GrafPort, a Version 1 Picture is created. Obviously non-Mac // computers can not create a Version 2 Picture. However, due to a patch in System 4.1 and later, an Enhanced Mac 512K, a MacPlus or a Mac SE can display a Version 2 Picture (not in color, of course).
While checking the Opcodes (Quickdraw picture commands) directly is not a good idea, a program can identify which version of Picture it has by checking the first integer past the picSize and picFrame. If this integer is 4353 ($1101), the Picture is Version 1. If the integer is 17 ($0011), the Picture is Version 2.
Just as a Version 1 Picture can have bitmap graphics in it, a Version 2 Picture can have a PixMap in it. Any CopyBits calls made following an OpenPicture, but before a ClosePicture call, will store the data into the Picture. If the source was a PixMap instead of a BitMap, the Picture handle will have both the bit data (compressed format) and a color table (Color Look Up Table or CLUT) describing the colors used in the PixMap.
PICT File Format
Knowing the Picture format, the PICT File Format is simple. A PICT file (ie. one that has the Filetype ‘PICT’) consists of a data fork with a 512 byte header followed by a picture data structure. The header is usually specific to the application that made it (most programs ignore it). After the header, the picture data contains picSize, picFrame and then the variable length Opcodes. As stated above, do not use picSize to determine how much data follows. Instead, check the size of the file with a File I/O call. Subtract 512 and that should be the size of the handle that the data should be read into.
ColorImage FKEY Code
The ColorImage FKEY was designed to save the current screen to file, similar to the Screen Save FKEY (Command-Shift-3). Instead of a MacPaint file being created, a PICT file is created instead. A CopyBits call on the current screen is used when creating the picture handle, which is then saved to the file.
The FKEY will work on any Macintosh. If the Macintosh has Color Quickdraw (ie. Macintosh //), the Color Window Manager GrafPort is temporarily set before creating the picture handle. Thus a version 2 PICT file will be created and any color images on the screen will be saved. On a non-Color Quickdraw Macintosh (ie. Mac SE and before), the normal Window Manager Port is used and a version 1 PICT file is created. If the Caps Lock key is pressed, the entire screen is saved to a file. If the Caps Lock key is not pressed and a front window exists, only the current window is saved to a file. The picture is not saved to a set file name like the Screen Save FKEY, instead the user is prompted for the file name. The image is also not rotated on a Mac II monitor. Thus you won’t need to edit your screen dumps before using them in your documentation, nor will you need to turn off your color interface as is the case with the old style shift-cmd-3.
Remember, if the Screen was a PixMap instead of a Bitmap, the CLUT will be saved into the PICT file along with the compressed bit data. Color PICTs are amazingly packed files.
Palette Manager
Reading a PICT file, however, is only half the job of displaying a color image correctly. If the Picture contained Color Quickdraw commands (for example, a Color Window saved with ColorImage FKEY), the user will want to see the Picture drawn again using the original colors. For this, the Palette Manager needs to be used.
The Palette Manager establishes the color environment of the Mac //. It uses the Color Manager (which controls what colors are used) to select the best colors for a given display. The idea is that each window can have a Color Palette associated with it. These are the Colors that the window wants the screen to be showing, in order to view the window at it’s best. Unless there are to many windows needing to many colors, each window gets it’s Palette. If there are not enough colors, highest priority goes to the top most window. Every time the top most window changes (and it has an associated Palette), the colors may change to give the new window it’s best appearance. The Palette Manager will then issue an update event for all Palette windows so that they can be redrawn to their best appearance in the new colors.
While an Application could use the Color Manager directly and bypass the Palette Manager, this is not recommended. Such programming would fall apart in a color Multiple task environment. Remember, Multifinder is not the only such environment. There are also color DAs like ColorImage.
Thus the DA takes the Picture (if it is Version 2), searches for a CLUT, and tries to create a Color Palette from it. The program does all this by temporarily replacing the low-level quickdraw procs (specifically StdBits) with one that checks for a PixMap, then transfers the RGB colors into a temporary buffer. The low-level routines are replaced and the buffer is converted to a Color Palette. Then the Palette is attached to the window so every time that particular window becomes the top most, the screen colors are set to the Palette. This also causes an update of the window so the Picture can be shown in it’s best colors.
ColorImage DA Code
The ColorImage Desk Accessory contains the complementing code to Color FKEY, and more. The DA creates a window (Color Window if the CPU has Color Quickdraw) to display Pictures in. The user can then select a PICT file and have it read into a Picture handle. Since a user may want to know what colors are being used for a specific Picture, the DA allows the users to switch between looking at the Picture or the current Palette.
Think of two ColorImage DA’s that are loaded into the system. Each opens a Picture with a radically different CLUT (one is a 256 color RGB Picture while the other is a 256 shade Gray Scaled one). When the RGB Picture is clicked on, it becomes the front window. The Palette Manager sets the 256 RGB colors (assuming the Color Video Card has 8 Bits per Pixel). Both pictures are completely redrawn using the current screen colors. Notice the Palette Manager caused the update; the program does not have to keep track. The RGB Picture appears perfect, while the Gray Picture (which can be seen behind the front window) appears as best as it can using the current screen colors. Then the user wants to look at the Gray Picture. He clicks on that window. It becomes front window, and the Palette Manager sets the current screen to 256 shades of gray. The windows are redrawn. The Gray Picture appears perfectly, while the RGB one appears as best it can using these new gray tones.
Last Comments
The ColorImage FKEY and Desk Accessory were created with LightSpeed Pascal (LSP). Macintosh Programming Workshop (MPW) has it’s points. It is an extremely powerful development system perfect for large projects. Being from Apple, MPW is the first development system that has any new Trap Listings or new code interfaces. LSP only recently has released the Mac // libraries and interfaces. MPW is also the best Object Pascal system around. However LSP may be the best environment to develop code segments (ie. DA, FKEYs, Window or Control Panel Definition Procedures) for the Macintosh. Both code examples were tested from inside a test program (a simple program that called the FKEY and a modified version of LSP DAShell). This decreases development time since the various codes could be tested without having to insert the DA or FKEY into the System file. The code could even be stepped through one line at a time, perhaps the best feature of LSP!
This program requires the Palette manager. When LS Pascal version 1.11 was released in September, Think did not include the Palette manager, nor the MultiFinder routines. We are still waiting for both Think and Borland to upgrade their products to MPW version 2.0 interfaces. You can add the Palette manager by taking the MPW 2.0 interface and adding it to your project. Remove the USES MemTypes and replace with USES ColorQuickdraw instead. Then add “Implementation” to the end of the file and your in business.
ColorImage DA could be expanded to check not only the PixMap’s CLUT in a Picture, but could check other Color Quickdraw commands. Since the DA was designed to work with the FKEY, checking the CLUT is all that is needed to function. The program could also check for colors that are in the CLUT, but are NOT present in the PixMap. Such colors are not displayed and need not be in the Palette.
Yet to come a full blown explanation of the Palette Manager and Palette Animation!
{ ColorImage DA / FKEY by Steve Sheets 12/87 } { Saves the current Screen to a PICT file. If Cap Lock } {is down, saves theentire screen. If the key is not & a} { Window exists, saves the window.} UNIT UColorImageFKEY; INTERFACE PROCEDURE main; IMPLEMENTATION {Returns the Color Window Manager Port. } PROCEDURE CGetWMgrPort (VAR CWPort : GrafPtr); INLINE $AA48; {Does this CPU have color Quickdraw? } FUNCTION ColorQDExists : boolean; CONST ROM85Loc = $28E; TwoHighMask = $C000; TYPE WordPtr = ^INTEGER; VAR Wd : WordPtr; BEGIN Wd := POINTER(ROM85Loc); ColorQDExists := (BitAnd(Wd^, TwoHighMask) = 0); END; {Is Cap Lock key down? } FUNCTION CapLockDown : BOOLEAN; VAR theMap : KeyMap; BEGIN GetKeys(theMap); CapLockDown := BitTst(@theMap[1], 30); END; {Given a flag saying color Quickdraw exists, returns} {the Handle of a Picture and a flag saying if the window } {was saved or if the entire screen was.} PROCEDURE GetPic (VAR thePic : PicHandle; VAR IsWindow : BOOLEAN; QDExists : BOOLEAN); TYPE BitMapPtr = ^BitMap; BitMapHdl = ^BitMapPtr; VAR sorcRect, destRect, mapRect : Rect; OldPort, WPort : GrafPtr; clip, vis : RgnHandle; FWin : WindowPtr; PixH : BitMapHdl; tempMap : BitMap; BEGIN GetPort(OldPort); { If Color Quickdraw exists, use the Color Window Manager { PixMap. Else use the normal Window Manager BitMap. } IF QDExists THEN BEGIN CGetWMgrPort(WPort); PixH := BitMapHdl(WPort^.portBits.baseAddr); mapRect := PixH^^.bounds; END ELSE BEGIN GetWMgrPort(WPort); mapRect := WPort^.portBits.bounds; END; {Chose to save the Window or entire Screen. } FWin := FrontWindow; IsWindow := (NOT CapLockDown) AND (FWin <> NIL); IF IsWindow THEN BEGIN SetPort(FWin); sorcRect := FWin^.portRect; LocalToGlobal(sorcRect.topLeft); LocalToGlobal(sorcRect.botRight); OffSetRect(sorcRect, mapRect.left, mapRect.top); END ELSE sorcRect := mapRect; destRect.left := 0; destRect.right := sorcRect.right - sorcRect.left; destRect.top := 0; destRect.bottom := sorcRect.bottom - sorcRect.top; {Resize the regions so they do not get in the way. } SetPort(WPort); vis := WPort^.visRgn; clip := WPort^.clipRgn; WPort^.visRgn := NewRgn; WPort^.clipRgn := NewRgn; SetRectRgn(WPort^.visRgn, -30000, -30000, 30000, 30000); SetRectRgn(WPort^.clipRgn, -30000, -30000, 30000, 30000); {Create Picture, copy map to it and close the Picture. } thePic := OpenPicture(destRect); CopyBits(WPort^.portBits, WPort^.portBits, sorcRect, destRect, srcCopy, NIL); ClosePicture; {Reset the Regions and Port.} DisposeRgn(WPort^.visRgn); DisposeRgn(WPort^.clipRgn); WPort^.visRgn := vis; WPort^.clipRgn := clip; SetPort(OldPort); END; {Pick a PICT file to save the Picture into (with correct title line). } PROCEDURE PickFile (VAR theReply : SFReply; IsWindow : BOOLEAN; QDExists : BOOLEAN); VAR Pt : Point; S1, S2 : str255; BEGIN Pt.v := 60; Pt.h := 60; IF QDExists THEN S1 := ‘Save Color ‘ ELSE S1 := ‘Save ‘; IF IsWindow THEN S2 := ‘Window PICT:’ ELSE S2 := ‘Screen PICT:’; SFPutFile(Pt, CONCAT(S1, S2), ‘’, NIL, theReply); END; {Given a Picture handle and a reference to a file, create a PICT file and save the Picture into it. } PROCEDURE SaveColorImage (thePic : PicHandle; theReply : SFReply); TYPE BufType = PACKED ARRAY[1..128] OF LongInt; VAR theErr : OSErr; OK : BOOLEAN; FileRef : INTEGER; BufSize : LongInt; Buf : BufType; count : integer; BEGIN OK := FALSE; FileRef := 0; theErr := FSDelete(theReply.fname, theReply.vRefNum); IF (theErr = noErr) OR (theErr = fnfErr) THEN BEGIN theErr := Create(theReply.fname, theReply.vRefNum, ‘MDRW’, ‘PICT’); IF (theErr = noErr) THEN BEGIN theErr := FSOpen(theReply.fname, theReply.vRefNum, FileRef); IF (theErr = noErr) THEN BEGIN FOR count := 1 TO 128 DO Buf[count] := 0; BufSize := 512; theErr := FSWrite(FileRef, BufSize, @Buf); IF (theErr = noErr) THEN BEGIN BufSize := GetHandleSize(Handle(thePic)); HLock(Handle(thePic)); theErr := FSWrite(FileRef, BufSize, Ptr(thePic^)); HUnLock(Handle(thePic)); IF (theErr = noErr) THEN BEGIN theErr := FSClose(FileRef); FileRef := 0; IF (theErr = noErr) THEN BEGIN theErr := FlushVol(NIL, theReply.vRefNum); OK := TRUE; END; END; END; END; END; END; IF NOT OK THEN SysBeep(60); IF (FileRef <> 0) THEN theErr := FSClose(FileRef); END; {Main FKEY routine: Check if this CPU has Color Quickdraw} {(used by all routines). Create the Picture Handle and Pick} { a File. If successful, savethe Picture into the file and} { kill the picture.} PROCEDURE main; VAR thePic : PicHandle; theReply : SFReply; IsWindow : BOOLEAN; QDExist : BOOLEAN; BEGIN QDExist := ColorQDExists; GetPic(thePic, IsWindow, QDExist); PickFile(theReply, IsWindow, QDExist); IF theReply.good THEN SaveColorImage(thePic, theReply); KillPicture(thePic); END; END. {ColorImage DA by Steve Sheets 12/87 } {Displays a PICT file. Checks if the PICT has a Color} { PixMap. If so, use the Palette Manager to display the PICT} { in the correct colors. } UNIT xColorImageDA; INTERFACE USES ColorQuickDraw, PaletteMgr, ColorWindowMgr; FUNCTION Main (theDCE : DCtlPtr; IOPB : ParmBlkPtr; driveCall : Integer) : OSErr; IMPLEMENTATION CONST DriverOpen = 0; DriverPrime = 1; DriverControl = 2; DriverStatus = 3; DriverClose = 4; MaxPal = 512; dCtlEnable = 10; kNum = 16; kBox = 20; kHst = 30; kVst = 40; kVoff = 40; kAbout = 1; kLoadPic = 3; kShowPic = 5; kShowPal = 6; TYPE BufType = RECORD Counter : integer; CLUTnum : longint; B : ARRAY[1..MaxPal] OF RGBColor; END; BufPtr = ^BufType; BufHdl = ^BufPtr; imageData = RECORD imagePic : PicHandle; imagePal : PaletteHandle; imageID : integer; imageWindow : WindowPtr; imageMenu : MenuHandle; picRect, palRect : Rect; ColorFlag, ShowPicFlag : boolean; numPal : integer; noPicstr, nameStr : str255; END; imagePtr = ^imageData; imageHandle = ^imagePtr; MyCSpecArray = ARRAY[0..MaxPal] OF ColorSpec; MyCTabHandle = ^MyCTabPtr; MyCTabPtr = ^MyColorTable; MyColorTable = RECORD ctSeed : LONGINT; transIndex : INTEGER; ctSize : INTEGER; ctTable : MyCSpecArray; END; {Resize the window W to the size R. Updates the entire} { window (window must be the current Grafport). } PROCEDURE ReSize (W : WindowPtr; R : rect); BEGIN SizeWindow(W, R.right, R.bottom, false); InvalRect(R) END; {Low level Quickdraw Proc. Instead of drawing a} {Bitmap/Pixmap, grabs the Color Lookup Table, and passes} {the RGB colors into the buffer (stored in the Window} {Ref Con). } PROCEDURE BitInfo (VAR srcBits : PixMap; VAR srcRect, dstRect : Rect; mode : integer; maskRgn : RgnHandle); VAR tempW : WindowPtr; theBuf : BufHdl; tempC : MyCTabHandle; n, count : integer; BEGIN GetPort(tempW); theBuf := POINTER(GetWRefCon(tempW)); { Make sure it is a PixMap.} IF (srcBits.rowBytes < 0) THEN BEGIN tempC := POINTER(srcBits.pmTable); { Make sure this is a new CLUT. } IF (tempC^^.ctSeed <> theBuf^^.CLUTnum) THEN BEGIN { Cycle through all colors, stuffing into Buf.} theBuf^^.CLUTnum := tempC^^.ctSeed; n := theBuf^^.Counter; IF tempC^^.ctSize >= 0 THEN FOR count := 0 TO tempC^^.ctSize DO BEGIN IF n < MaxPal THEN BEGIN n := n + 1; theBuf^^.B[n] := tempC^^.ctTable[count].rgb; END; END; theBuf^^.Counter := n; END; END; END; {Given a window and a Picture Handle, return a} { Palette Handle and Palette number of the colors used} { in the Picture Handle. } FUNCTION GetPal (theW : WindowPtr; thePic : PicHandle; VAR thePal : PaletteHandle; VAR theNum : integer) : boolean; TYPE myPicHdl = ^myPicPtr; myPicPtr = ^myPicData; myPicData = RECORD P : Picture; ID : integer; END; VAR count : integer; theBuf : BufHdl; tempPtr : myPicHdl; tempProc : CQDProcs; oldProc : QDProcsPtr; oldRef : longint; dummy : boolean; tempP : GrafPtr; BEGIN dummy := false; { If this is a Handle, } IF thePic <> NIL THEN BEGIN { And if it is a color Picture. } tempPtr := POINTER(thePic); IF tempPtr^^.ID = $0011 THEN BEGIN { Create the Buffer.} theBuf := POINTER(NewHandle(SizeOf(BufType))); IF (theBuf <> NIL) THEN BEGIN { Clear Buffers counters.} theBuf^^.Counter := 0; theBuf^^.CLUTnum := -1; {Save the old Window RefCon, and stuff the Buffer into the RefCon. } oldRef := GetWRefCon(theW); SetWRefCon(theW, ord4(theBuf)); {Save the old low level QD Procs, create new ones (including BitInfo). } oldProc := POINTER(theW^.grafProcs); SetStdCProcs(tempProc); tempProc.bitsProc := @BitInfo; theW^.grafProcs := @tempProc; {Draw the Picture (grabing the CLUT and RGB Colors). } GetPort(tempP); SetPort(theW); DrawPicture(thePic, thePic^^.picFrame); SetPort(tempP); theW^.grafProcs := POINTER(oldProc); SetWRefCon(theW, oldRef); {If there were any colors, create a Color Palette.} IF theBuf^^.Counter > 0 THEN BEGIN thePal := NewPalette(theBuf^^.Counter, NIL, pmTolerant, 0); IF thePal <> NIL THEN BEGIN dummy := true; theNum := theBuf^^.Counter; FOR count := 1 TO theNum DO SetEntryColor(thePal, count - 1, theBuf^^.B[count]); END; END ELSE thePal := NIL; DisposHandle(POINTER(theBuf)); END; END; END; GetPal := dummy; END; {Given references to a PICT file, read the PICT file into a PICT handle. } FUNCTION GetPic (theReply : SFReply; VAR thePic : PicHandle) : BOOLEAN; VAR OK : BOOLEAN; FileRef : INTEGER; BufSize : LongInt; theE : OSerr; tempPic : PicHandle; BEGIN OK := FALSE; FileRef := 0; tempPic := NIL; theE := FSOpen(theReply.fname, theReply.vRefNum, FileRef); IF (theE = noErr) THEN BEGIN theE := GetEOF(FileRef, BufSize); IF (theE = noErr) THEN BEGIN BufSize := BufSize - 512; theE := SetFPos(FileRef, fsFromStart, 512); IF (theE = noErr) THEN BEGIN tempPic := PicHandle(NewHandle(BufSize)); theE := MemError; IF (theE = noErr) THEN BEGIN HLock(Handle(tempPic)); theE := FSRead(FileRef, BufSize, POINTER(tempPic^)); HUnLock(Handle(tempPic)); OK := (theE = noErr); IF OK THEN thePic := tempPic; END; END; END; END; IF (FileRef <> 0) THEN FileRef := FSClose(FileRef); IF NOT OK THEN BEGIN SysBeep(1); IF tempPic <> NIL THEN DisposHandle(Handle(tempPic)); END; GetPic := OK; END; {Load a PICT into the DA. } PROCEDURE LoadPic (theDCE : DCtlPtr); VAR theImage : ImageHandle; tempReply : SFReply; P : point; theList : SFTypeList; S : str255; BEGIN theImage := ImageHandle(theDCE^.dCtlStorage); WITH theImage^^ DO BEGIN { Select a File.} P.h := 60; P.v := 60; theList[0] := ‘PICT’; SFGetFile(P, ‘’, NIL, 1, theList, NIL, tempReply); IF tempReply.good THEN BEGIN {If a files is selected, release the old Picture and Palette (if any).} IF imagePic <> NIL THEN BEGIN DisposHandle(Handle(imagePic)); imagePic := NIL; picRect.bottom := kBox * kNum; picRect.right := kBox * kNum; END; IF imagePal <> NIL THEN BEGIN DisposePalette(imagePal); numPal := 0; imagePal := NIL; END; { Prepare to set Windows name to ‘ColorImage’.} S := nameStr; { Read the Picture. } IF GetPic(tempReply, imagePic) THEN BEGIN { If PICT read correctly, resize the window & set the Window name to ‘ColorImage : (filename)’.} picRect.bottom := imagePic^^.picFrame.bottom - imagePic^^.picFrame.top; picRect.right := imagePic^^.picFrame.right - imagePic^^.picFrame.left; S := CONCAT(S, ‘: ‘, tempReply.fname); {If this is Color Quickdraw CPU.} IF ColorFlag THEN BEGIN { Get Palette from Picture.} IF GetPal(imageWindow, imagePic, imagePal, numpal) THEN BEGIN { If successful, set the Palette to the Image Window & resize the Pal rect. } SetPalette(imageWindow, imagePal, true); IF numPal > kNum THEN palRect.right := palRect.left + (kNum * kBox) ELSE palRect.right := numPal * kBox; palRect.bottom := (((numPal - 1) DIV kNum) + 1) * kBox; END; END; END; {Set the Menu correctly, set so the Picture is displayed first, resize the window, and set the Window Title. } IF imagePic <> NIL THEN EnableItem(imageMenu, kShowPic) ELSE DisableItem(imageMenu, kShowPic); IF imagePal <> NIL THEN EnableItem(imageMenu, kShowPal) ELSE DisableItem(imageMenu, kShowPal); ShowPicFlag := true; ReSize(imageWindow, picRect); SetWTitle(imageWindow, S); END; END; END; {Does this CPU have color Quickdraw? } FUNCTION ColorQDExists : boolean; CONST ROM85Loc = $28E; TwoHighMask = $C000; TYPE WordPtr = ^INTEGER; VAR Wd : WordPtr; BEGIN Wd := POINTER(ROM85Loc); ColorQDExists := (BitAnd(Wd^, TwoHighMask) = 0); END; {Open the DA. Set the data structures, the Menu, the window, etc. } FUNCTION Open (theDCE : DCtlPtr) : OSErr; VAR tempPort : Grafptr; theImage : ImageHandle; tmpRect : Rect; insideWindow : WindowPeek; BEGIN getport(tempPort); IF theDCE^.dCtlStorage = NIL THEN BEGIN theDCE^.dCtlStorage := NewHandle(SizeOf(imageData)); HLock(theDCE^.dCtlStorage); theImage := ImageHandle(theDCE^.dCtlStorage); WITH theDCE^, theImage^^ DO BEGIN imageID := dCtlRefNum; IF imageID > 0 THEN imageID := -imageID; imageID := $C000 + 32 * (-1 - imageID); imageMenu := GetMenu(imageID); IF dCtlRefNum < 0 THEN BEGIN imageMenu^^.menuID := imageID; theDCE^.dctlMenu := imageID; END ELSE BEGIN imageMenu^^.menuID := -imageID; theDCE^.dctlMenu := -imageID; END; imagePic := NIL; imagePal := NIL; numPal := 0; DisableItem(imageMenu, kShowPic); DisableItem(imageMenu, kShowPal); picRect.top := 0; picRect.left := 0; picRect.bottom := kBox * kNum; picRect.right := kBox * kNum; palRect := picRect; ShowPicFlag := true; ColorFlag := ColorQDExists; GetIndString(nameStr, imageID, 1); GetIndString(nopicStr, imageID, 2); tmpRect := picRect; OffSetRect(tmpRect, 0, kVoff); IF ColorFlag THEN imageWindow := NewCWindow(NIL, tmpRect, nameStr, true, rDocProc, Pointer(-1), True, 0) ELSE imageWindow := NewWindow(NIL, tmpRect, nameStr, true, rDocProc, Pointer(-1), True, 0); SetPort(imageWindow); insideWindow := WindowPeek(imageWindow); insideWindow^.windowKind := dCtlRefNum; dCtlWindow := Ptr(imageWindow); END; HUnLock(theDCE^.dCtlStorage); END ELSE BEGIN SelectWindow(WindowPtr(theDCE^.dCtlWindow)); SetPort(WindowPtr(theDCE^.dCtlWindow)); END; SetPort(tempPort); Open := noErr; END; {Do nothing Prime routine.} FUNCTION Prime (theDCE : DCtlPtr; IOPB : ParmBlkPtr) : OSErr; BEGIN Prime := noErr; END; {Do the Control routine (ie. Events, Menus, etc.).} FUNCTION Control (theDCE : DCtlPtr; IOPB : ParmBlkPtr) : OSErr; CONST accEvent = 64; accMenu = 67; accUndo = 68; accCut = 70; accCopy = 71; accPaste = 72; accClear = 73; VAR theEvent : EventRecord; theImage : ImageHandle; aWindow : WindowPtr; tempRect : Rect; tempPort : Grafptr; count : integer; BEGIN getport(tempPort); HLock(theDCE^.dCtlStorage); theImage := ImageHandle(theDCE^.dCtlStorage); WITH theImage^^ DO BEGIN SetPort(imageWindow); CASE IOPB^.csCode OF accEvent : BEGIN BlockMove(IOPB^.ioMisc, @theEvent, SizeOf(theEvent)); CASE theEvent.what OF {Update event: Show the Picture or the Palette.} updateEvt : BEGIN BeginUpdate(WindowPtr(theEvent.message)); SetPort(WindowPtr(theEvent.message)); IF ShowPicFlag THEN BEGIN EraseRect(picRect); IF imagePic <> NIL THEN DrawPicture(imagePic, picRect) ELSE BEGIN MoveTo(kHst, kVst); DrawString(noPicStr); END; END ELSE IF ColorFlag THEN BEGIN EraseRect(palRect); IF imagePal <> NIL THEN FOR count := 0 TO NumPal - 1 DO BEGIN PmForeColor(count); tempRect.top := (count DIV kNum) * kBox; tempRect.left := (count MOD kNum) * kBox; tempRect.bottom := tempRect.top + kBox; tempRect.right := tempRect.left + kBox; PaintRect(tempRect); END; END; EndUpdate(WindowPtr(theEvent.message)); END; { Activate Event: Add or remove the Menu. } activateEvt : IF BitAND(theEvent.modifiers, activeFlag) <> 0 THEN BEGIN IF Ord(theEvent.message) = Ord(imageWindow) THEN BEGIN InsertMenu(imageMenu, 0); DrawMenuBar; END; END ELSE IF Ord(theEvent.message) = Ord(imageWindow) THEN {De-activate event} BEGIN DeleteMenu(imageMenu^^.menuID); DrawMenuBar; END; { Mouse Down: Drag the window. } mouseDown : IF FindWindow(theEvent.where, awindow) IN [inSysWindow, inContent] THEN BEGIN SetRect(tempRect, -30000, -30000, 30000, 30000); DragWindow(awindow, theEvent.where, tempRect); END; keyDown, autoKey : SysBeep(1); OTHERWISE END; END; {Menus: Do the About Alert, Load a Picture or switch between the Picture or Palette. } accMenu : CASE IOPB^.CSParam[1] OF kAbout : count := Alert(imageID, NIL); kLoadPic : LoadPic(theDCE); kShowPic : IF NOT ShowPicFlag THEN BEGIN ShowPicFlag := true; ReSize(imageWindow, picRect); END; kShowPal : IF ShowPicFlag THEN BEGIN ShowPicFlag := false; ReSize(imageWindow, palRect); END; OTHERWISE END; accUndo, accCut, accCopy, accPaste, accClear : SysBeep(1); OTHERWISE END; END; HUnLock(Handle(theImage)); SetPort(tempPort); Control := noErr; END; {Do nothing Status routine. } FUNCTION Status (theDCE : DCtlPtr; IOPB : ParmBlkPtr) : OSErr; BEGIN Status := noErr; END; {Close Routine: Clear the Menu, Window, Palette, Picture and Data Structure. } FUNCTION Close (theDCE : DCtlPtr; IOPB : ParmBlkPtr) : OSErr; VAR theImage : ImageHandle; BEGIN HLock(theDCE^.dCtlStorage); theImage := ImageHandle(theDCE^.dCtlStorage); WITH theImage^^ DO BEGIN DeleteMenu(imageMenu^^.menuID); ReleaseResource(Handle(imageMenu)); DrawMenuBar; IF imagePal <> NIL THEN DisposePalette(imagePal); IF imagePic <> NIL THEN DisposHandle(Handle(imagePic)); DisposeWindow(imageWindow); END; HUnLock(theDCE^.dCtlStorage); IF theDCE^.dCtlRefNum < 0 THEN HPurge(Handle(theDCE^.dCtlDriver)); theDCE^.dCtlWindow := NIL; DisposHandle(theDCE^.dCtlStorage); theDCE^.dCtlStorage := NIL; Close := noErr; END; {DAs main routine. } FUNCTION Main; BEGIN CASE driveCall OF DriverOpen : Main := Open(theDCE); DriverPrime : Main := Prime(theDCE, IOPB); DriverControl : BEGIN BitClr(@theDCE^.dCtlFlags, 15 - dCtlEnable); Main := Control(theDCE, IOPB); BitSet(@theDCE^.dCtlFlags, 15 - dCtlEnable); END; DriverStatus : Main := Status(theDCE, IOPB); DriverClose : Main := Close(theDCE, IOPB); END; END; END. * ColorImageDA.R * Resource Source File *by Steve Sheets 12/87 * ColorImageDA Rsrc Type MENU ,-16000 ColorImage About ColorImage... (- Load Picture (- Show Picture Show Palette Type STR# ,-16000 2 ColorImage No Picture Available Type DITL ,-16000 5 button 160 170 180 230 OK staticText 20 95 39 305 ColorImage 1.1 by Steve Sheets staticText 40 104 59 296 Designed for MacTutor 12/87 staticText 80 40 119 360 DA - Displays a PICT file. If it contains a Color PixMap, displays it in the correct Palette. staticText 120 40 139 360 FKEY - Saves the current screen into a PICT file. Type ALRT ,-16000 60 120 260 520 -16000 5555
![](/file/12652/www.mactech.com.tar/www.mactech.com/sites/all/themes/custom_front/img/search_text.gif)
- SPREAD THE WORD:
- Slashdot
- Digg
- Del.icio.us
- Newsvine