/*

File: Snapshot.c

Contains: This application demonstrates how to quickly and

efficiently capture the main device's desktop into

a window. The program basically reads the image

stored in the the main device's pixmap then copies

it to a custom pixmap. The custom pixmap is de-

fined at the same depth of the main device and

contains an identical copy of that device's color-

table. This is done to provide the fastest

performance possible when copying from an offscreen

to onscreen pixmap. By making sure the pixel values

map to the exact same colors in both colortables,

copybits will do a direct transfer of bits without

wasting time remapping the colors. Also the ctSeed

field for each colortable should be the same. Finally,

since the main device's bounding rect is different

than that of the offscreen's, the copying performance

for the device to the offscreen is slightly affected

because of the scaling required. However, the copying

performance for the offscreen to the window is the

best possible since the bounding rects for each are

identical.

Written by: EL

Copyright: Copyright © 1991-1999 by Apple Computer, Inc., All Rights Reserved.

You may incorporate this Apple sample source code into your program(s) without

restriction. This Apple sample source code has been provided "AS IS" and the

responsibility for its operation is yours. You are not permitted to redistribute

this Apple sample source code as "Apple sample source code" after having made

changes. If you're going to re-distribute the source, we require that you make

it clear in the source that the code was descended from Apple sample source

code, but that you've made changes.

Change History (most recent first):

08/2000 JM Carbonized, non-Carbon code is commented out

for demonstration purposes.

11/6/1999 GGS Updated to work with modern (1999) Mac OS.

Fixed a PixMap disposing bug. Updated casts

and headers.

7/14/1999 KG Updated for Metrowerks Codewarror Pro 2.1

*/

#ifdef __APPLE_CC__

#include <Carbon/Carbon.h>

#else

#include <Carbon.h>

#endif

/* Constant Declarations */

#define WWIDTH ((qd.screenBits.bounds.right - qd.screenBits.bounds.left) / 2)

#define WHEIGHT ((qd.screenBits.bounds.bottom - qd.screenBits.bounds.top) / 2)

#define WLEFT (((qd.screenBits.bounds.right - qd.screenBits.bounds.left) - WWIDTH) / 2)

#define WTOP (((qd.screenBits.bounds.bottom - qd.screenBits.bounds.top) - WHEIGHT) / 2)

#define MENU_BAR_ID 128

#define MENU_BAR_IDX 129

#define FILE_MENU 128

enum {

FILE_NEW = 1,

FILE_REFRESH,

FILE_CLOSE,

FILE_SAVE,

FILE_QUIT

};

/* Global Variable Definitions */

WindowPtr gWindow; /* Main window */

PixMap gPixMap; /* Offscreen pixmap */

Rect gBounds; /* Offscreen pixmap's bounding rect */

Boolean gDone = false; // Application termination global

void initMac();

void setUp();

void handleMenuSelection(long result);

void handleKeyPress(EventRecord *);

void saveToPICTFile();

void createWindow();

void initPixmap();

void createImage();

void drawImage();

pascal OSErr AEQuitHandler(const AppleEvent *messagein, AppleEvent *reply, long refIn);

void doEventLoop();

int main()

{

initMac();

setUp();

createWindow(); /* Create a window to display the final image. */

initPixmap(); /* Initialize offscreen pixmap. */

createImage(); /* Copy the main screen's pixmap into the offscreen's. */

drawImage(); /* Copy the offscreen's pixmap onto the window. */

doEventLoop(); /* Handle any events. */

DisposeWindow( gWindow );

return 0;

}

void initMac()

{

/*MaxApplZone();

InitGraf( &qd.thePort );

InitFonts();

InitWindows();

InitMenus();

TEInit();

InitDialogs( nil );*/

InitCursor();

FlushEvents( 0, everyEvent );

}

void setUp()

{

Handle menuBar;

OSErr anErr = noErr;

long aLong;

long response;

anErr = Gestalt(gestaltSystemVersion, &response);

// Carbon Porting guidelines say provide alternate menu bar/menu scheme for OS X

// This is just one way of doing this, which is pretty static

if (response >= 0x01000)

menuBar = GetNewMBar(MENU_BAR_IDX);

else

menuBar = GetNewMBar(MENU_BAR_ID);

if ( menuBar == nil || anErr != noErr )

ExitToShell();

SetMenuBar(menuBar);

DisposeHandle(menuBar);

DrawMenuBar();

// Install 'quit' event handler

if ((Gestalt(gestaltAppleEventsAttr, &aLong) == noErr)) {

anErr = AEInstallEventHandler(kCoreEventClass, kAEQuitApplication,

NewAEEventHandlerUPP(AEQuitHandler), 0, false);

if (anErr != noErr)

ExitToShell();

}

}

void createWindow()

{

Rect wBounds;

BitMap bitMap;

Rect tempRect1;

int top, left, width, height;

GetQDGlobalsScreenBits(&bitMap);

width = ((bitMap.bounds.right - bitMap.bounds.left) / 2);

height = ((bitMap.bounds.bottom - bitMap.bounds.top) / 2);

left = (((bitMap.bounds.right - bitMap.bounds.left) - width) / 2);

top = (((bitMap.bounds.bottom - bitMap.bounds.top) - height) / 2);

/* Create a window to display the final offscreen image. */

//SetRect( &wBounds, WLEFT, WTOP, WLEFT + WWIDTH, WTOP + WHEIGHT );

SetRect( &wBounds, left, top, left + width, top + height );

gWindow = NewCWindow( 0L, &wBounds, "\pSnapshot Test", false, documentProc,

(WindowPtr)-1L, true, 0L );

//SetRect( &gBounds, 0, 0, gWindow->portRect.right - gWindow->portRect.left,

// gWindow->portRect.bottom - gWindow->portRect.top );

GetPortBounds(GetWindowPort(gWindow), &tempRect1);

SetRect( &gBounds, 0, 0, tempRect1.right - tempRect1.left,

tempRect1.bottom - tempRect1.top);

//SetPort( gWindow );

SetPortWindowPort( gWindow );

}

void initPixmap()

{

Ptr offBaseAddr; /* Pointer to the off-screen pixel image */

short bytesPerRow;

GDHandle mainDevice;

CTabHandle cTable;

short depth;

/* Get a handle to the main device. */

mainDevice = GetMainDevice();

/* Store its current pixel depth. */

depth = (**(**mainDevice).gdPMap).pixelSize;

/* Make an identical copy of its pixmap's colortable. */

cTable = (**(**mainDevice).gdPMap).pmTable;

(void) HandToHand( (Handle*)(&cTable) );

bytesPerRow = ((gBounds.right - gBounds.left) * depth) / 8;

offBaseAddr = NewPtr((unsigned long)bytesPerRow * (gBounds.bottom - gBounds.top));

gPixMap.baseAddr = offBaseAddr; /* Point to image */

gPixMap.rowBytes = bytesPerRow | 0x8000; /* MSB set for PixMap */

gPixMap.bounds = gBounds; /* Use given bounds */

gPixMap.pmVersion = 0; /* No special stuff */

gPixMap.packType = 0; /* Default PICT pack */

gPixMap.packSize = 0; /* Always zero in mem */

gPixMap.hRes = 72; /* 72 DPI default res */

gPixMap.vRes = 72; /* 72 DPI default res */

gPixMap.pixelSize = depth; /* Set # bits/pixel */

//gPixMap.planeBytes = 0; /* Not used */

//gPixMap.pmReserved = 0; /* Not used */

gPixMap.pixelType = 0; /* Indicates indexed */

gPixMap.cmpCount = 1; /* Have 1 component */

gPixMap.cmpSize = depth; /* Component size=depth */

gPixMap.pmTable = cTable; /* Handle to CLUT */

}

void createImage()

{

GDHandle mainDevice;

mainDevice = GetMainDevice();

/* Store the screen's pixmap image in the offscreen pixmap. */

CopyBits( (BitMap *)*(**mainDevice).gdPMap, (BitMap *)(&gPixMap),

&(**(**mainDevice).gdPMap).bounds, &gPixMap.bounds, srcCopy, 0l );

}

void drawImage(WindowPtr theWindow)

{

Rect tempRect1;

/* Copy the offscreen image back onto the window. */

//CopyBits( (BitMap *)&gPixMap, &gWindow->portBits, &gPixMap.bounds,

// &gWindow->portRect, srcCopy, 0l);

CopyBits( (BitMap *)&gPixMap, GetPortBitMapForCopyBits(GetWindowPort(theWindow)), &gPixMap.bounds,

GetPortBounds(GetWindowPort(gWindow), &tempRect1), srcCopy, 0L);

ShowWindow( gWindow );

}

void saveToPICTFile()

{

/*

Saving a PixMap as a PICT file isn't too hard.

1. Open a Picture with the port set to the destination of #2.

2. CopyBits the PixMap onto itself or another port. (Because CopyBits is

recorded in Pictures.

3. Close the picture.

4. Open the data fork for the file.

5. Write out 512 bytes of zeros followed by the contents of the Picture

handle.

6. Close the file.

*/

PicHandle picHandle;

OSErr anErr = noErr;

OSType fileTypeToSave = 'PICT';

OSType creatorType = 'ogle';

NavReplyRecord reply;

NavDialogOptions dialogOptions;

FSSpec documentFSSpec;

long inOutCount;

short refNum, count;

AEKeyword theKeyword;

DescType actualType;

unsigned char header[512];

Size actualSize;

Rect tempRect1;

CopyBits(GetPortBitMapForCopyBits(GetWindowPort(FrontWindow())), (BitMap*) &gPixMap,

GetPortBounds(GetWindowPort(gWindow), &tempRect1), &gPixMap.bounds, srcCopy, 0L);

SetPortWindowPort(gWindow);

picHandle = OpenPicture(&gPixMap.bounds);

CopyBits((BitMap*) &gPixMap, GetPortBitMapForCopyBits(GetWindowPort(FrontWindow())), &gPixMap.bounds,

GetPortBounds(GetWindowPort(gWindow), &tempRect1), srcCopy, 0L);

ClosePicture();

for (count = 0; count < 512; count++)

header[count] = 0x00;

anErr = NavGetDefaultDialogOptions(&dialogOptions);

dialogOptions.dialogOptionFlags |= kNavSelectDefaultLocation;

anErr = NavPutFile( nil,

&reply,

&dialogOptions,

nil,

fileTypeToSave,

creatorType,

nil );

if (anErr == noErr && reply.validRecord) {

anErr = AEGetNthPtr(&(reply.selection), 1, typeFSS,

&theKeyword, &actualType,

&documentFSSpec, sizeof(documentFSSpec),

&actualSize );

if (anErr == noErr) {

anErr = FSpCreate(&documentFSSpec, creatorType, fileTypeToSave, smSystemScript);

if (anErr == dupFNErr) {

anErr = FSpDelete(&documentFSSpec);

anErr = FSpCreate(&documentFSSpec, creatorType, fileTypeToSave, smSystemScript);

} // this is quick 'n' dirty or there'd be more robust handling here

// write the file

FSpOpenDF(&documentFSSpec, fsRdWrPerm, &refNum );

inOutCount = 512;

anErr = FSWrite(refNum, &inOutCount, header); // write the header

if (anErr == noErr) {

inOutCount = GetHandleSize((Handle)picHandle);

anErr = FSWrite(refNum,&inOutCount,*picHandle);

}

FSClose( refNum );

}

reply.translationNeeded = false;

anErr = NavCompleteSave(&reply, kNavTranslateInPlace);

NavDisposeReply(&reply);

}

KillPicture(picHandle);

}

void handleMenuSelection(long result)

{

int menuID, menuItem;

RgnHandle rgnHandle = NewRgn();

menuID = HiWord(result);

menuItem = LoWord(result);

if (menuID == FILE_MENU) {

if (menuItem == FILE_SAVE)

saveToPICTFile();

else if (menuItem == FILE_QUIT)

gDone = true;

else if (menuItem == FILE_CLOSE) {

DisposeWindow(FrontWindow());

if (FrontWindow() == NULL)

gDone = true;

}

else if (menuItem == FILE_NEW) {

}

else if (menuItem == FILE_REFRESH) {

createImage();

drawImage(FrontWindow());

QDFlushPortBuffer(GetWindowPort(FrontWindow()), GetPortVisibleRegion(GetWindowPort(FrontWindow()), rgnHandle));

}

}

HiliteMenu(0);

DisposeRgn(rgnHandle);

}

void handleKeyPress(EventRecord *event)

{

char key;

key = event->message & charCodeMask;

// just check to see if we want to quit...

if ( event->modifiers & cmdKey ) /* Command key down? */

handleMenuSelection(MenuKey(key));

}

// Apple Event - "Quit"

pascal OSErr AEQuitHandler(const AppleEvent *messagein, AppleEvent *reply, long refIn)

{

#pragma unused (messagein,refIn,reply)

gDone = true;

return noErr;

}

void doEventLoop()

{

EventRecord anEvent;

WindowPtr evtWind;

short clickArea;

Rect screenRect;

while (!gDone)

{

if (WaitNextEvent( everyEvent, &anEvent, 0, nil ))

{

if (anEvent.what == mouseDown)

{

clickArea = FindWindow( anEvent.where, &evtWind );

if (clickArea == inMenuBar)

handleMenuSelection(MenuSelect(anEvent.where));

else if (clickArea == inDrag)

{

//screenRect = (**GetGrayRgn ()).rgnBBox;

GetRegionBounds(GetGrayRgn(), &screenRect);

DragWindow( evtWind, anEvent.where, &screenRect );

}

else if (clickArea == inContent)

{

if (evtWind != FrontWindow())

SelectWindow( evtWind );

}

else if (clickArea == inGoAway)

if (TrackGoAway( evtWind, anEvent.where ))

gDone = true;

}

else if (anEvent.what == updateEvt)

{

evtWind = (WindowPtr)anEvent.message;

//SetPort( evtWind );

SetPortWindowPort( evtWind );

BeginUpdate( evtWind );

drawImage( evtWind );

EndUpdate (evtWind);

}

else if (anEvent.what == autoKey || anEvent.what == keyDown)

handleKeyPress(&anEvent);

}

}

}