Subversion Repositories filter_foundry

#include <Types.h>

#include <Menus.h>

#include <Quickdraw.h>

#include <Windows.h>

struct ZoomData {

        GDHandle                screenWithLargestPartOfWindow;

        unsigned long   largestArea;

        Rect                    windowBounds;

};

typedef struct ZoomData ZoomData, *ZoomDataPtr;

typedef void (*CalcIdealDocumentSizeProcPtr)(WindowPtr theWindow, Rect *idealContentSize);

enum {

        kNudgeSlop      =       4,

        kIconSpace      =       64

};

void ZoomTheWindow(WindowPeek theWindow, short zoomState,

                                        CalcIdealDocumentSizeProcPtr calcRoutine);

pascal void CalcWindowAreaOnScreen(short depth, short deviceFlags, GDHandle targetDevice,

                                                                        long userData);

short CalculateOffsetAmount(short idealStartPoint, short idealEndPoint,

                                                        short idealOnScreenStartPoint, short idealOnScreenEndPoint,

                                                        short screenEdge1, short screenEdge2);

static RgnHandle GetWindowContentRegion(WindowPeek theWindow);

static RgnHandle GetWindowStructureRegion(WindowPeek theWindow);

static void GetWindowPortRect(WindowPeek theWindow, Rect *portRect);

static void SetWindowStandardState(WindowPeek theWindow, const Rect *standardState);

static void GetWindowUserState(WindowPeek theWindow, Rect *userState);

void ZoomTheWindow(WindowPeek theWindow, short zoomState,

                                        CalcIdealDocumentSizeProcPtr calcRoutine)

{

        ZoomData        zoomData;

        Rect            newStandardRect;

        Rect            scratchRect;

        Rect            screenRect;

        Rect            portRect;

        Rect            contentRegionBoundingBox;

        Rect            structureRegionBoundingBox;

        Rect            deviceLoopRect;

        GrafPtr         currentPort;

        RgnHandle       scratchRegion;

        RgnHandle       contentRegion;

        RgnHandle       structureRegion;

        GDHandle        mainDevice;

        short           horizontalAmountOffScreen;

        short           verticalAmountOffScreen;

        short           windowFrameTopSize;

        short           windowFrameLeftSize;

        short           windowFrameRightSize;

        short           windowFrameBottomSize;

        GetPort(&currentPort);

        SetPort((WindowPtr) theWindow);

        contentRegion = GetWindowContentRegion(theWindow);

        structureRegion = GetWindowStructureRegion(theWindow);

        GetWindowPortRect(theWindow, &portRect);

        contentRegionBoundingBox = (**contentRegion).rgnBBox;

        structureRegionBoundingBox = (**structureRegion).rgnBBox;

        // Determine the size of the window frame

        windowFrameTopSize = contentRegionBoundingBox.top -

                                                                        structureRegionBoundingBox.top;

        windowFrameLeftSize = contentRegionBoundingBox.left -

                                                                        structureRegionBoundingBox.left;

        windowFrameRightSize = structureRegionBoundingBox.right -

                                                                        contentRegionBoundingBox.right;

        windowFrameBottomSize = structureRegionBoundingBox.bottom -

                                                                        contentRegionBoundingBox.bottom;

        // If the window is being zoomed into the standard state, calculate the best size

        // to display the windowÕs information.

        mainDevice = GetMainDevice();

        if (zoomState == inZoomOut) {

                zoomData.screenWithLargestPartOfWindow = mainDevice;

                zoomData.largestArea = 0;

                // Usually, we would use the content regionÕs bounding box to determine the monitor

                // with largest portion of the windowÕs area. However, if the entire content region

                // of the window is not on any screen, the structure region should be used instead.

                scratchRegion = NewRgn();

                SectRgn(GetGrayRgn(), contentRegion, scratchRegion);

                if (EmptyRgn(scratchRegion))

                        zoomData.windowBounds = structureRegionBoundingBox;

                else

                        zoomData.windowBounds = contentRegionBoundingBox;

                // Use DeviceLoop to walk through all the active screens to find the one with the

                // largest portion of the zoomed window

                deviceLoopRect = zoomData.windowBounds;

                GlobalToLocal((Point *)&deviceLoopRect);

                GlobalToLocal((Point *)&deviceLoopRect.bottom);

                RectRgn(scratchRegion, &deviceLoopRect);

                DeviceLoop(scratchRegion, &CalcWindowAreaOnScreen, (long) &zoomData,

                                        (DeviceLoopFlags) singleDevices);

                DisposeRgn(scratchRegion);

                screenRect = (**(zoomData.screenWithLargestPartOfWindow)).gdRect;

                // If the monitor being zoomed to is the main monitor, change the top of the

                // useable screen area to avoid putting the title bar underneath the menubar.

                if (zoomData.screenWithLargestPartOfWindow == mainDevice)

                        screenRect.top += GetMBarHeight();

                // Go figure out the perfect size for the window as if we had an infinitely large

                // screen

                (*calcRoutine)((WindowPtr) theWindow, &newStandardRect);

                // Anchor the new rectangle at the windowÕs current top left corner

                OffsetRect(&newStandardRect, -newStandardRect.left, -newStandardRect.top);

                OffsetRect(&newStandardRect, contentRegionBoundingBox.left,

                                        contentRegionBoundingBox.top);

                // newStandardRect is the ideal size for the content area. The window frame

                // needs to be accounted for when we see if the window needs to be moved,

                // or resized, so add in the dimensions of the window frame.

                newStandardRect.top -= windowFrameTopSize;

                newStandardRect.left -= windowFrameLeftSize;

                newStandardRect.right += windowFrameRightSize;

                newStandardRect.bottom += windowFrameBottomSize;

                // If the new rectangle falls off the edge of the screen, nudge it so that itÕs just

                // on the screen. CalculateOffsetAmount determines how much of the window is offscreen.

                SectRect(&newStandardRect, &screenRect, &scratchRect);

                if (!EqualRect(&newStandardRect, &scratchRect)) {

                        horizontalAmountOffScreen = CalculateOffsetAmount(newStandardRect.left,

                                                                                                                           newStandardRect.right,

                                                                                                                           scratchRect.left,

                                                                                                                           scratchRect.right,

                                                                                                                           screenRect.left,

                                                                                                                           screenRect.right);

                        verticalAmountOffScreen = CalculateOffsetAmount(newStandardRect.top,

                                                                                                                        newStandardRect.bottom,

                                                                                                                        scratchRect.top,

                                                                                                                        scratchRect.bottom,

                                                                                                                        screenRect.top,

                                                                                                                        screenRect.bottom);

                        OffsetRect(&newStandardRect, horizontalAmountOffScreen,

                                                verticalAmountOffScreen);

                }

                // If weÕre still falling off the edge of the screen, that means that the perfect

                // size is larger than the screen, so we need to shrink down the standard size

                SectRect(&newStandardRect, &screenRect, &scratchRect);

                if (!EqualRect(&newStandardRect, &scratchRect)) {

                // First shrink the width of the window. If the window is wider than the screen

                // it is zooming to, we can just pin the standard rectangle to the edges of the

                // screen, leaving some slop. If the window is narrower than the screen, we know

                // we just nudged it into position, so nothing needs to be done.

                        if ((newStandardRect.right - newStandardRect.left) >

                                (screenRect.right - screenRect.left)) {

                                newStandardRect.left = screenRect.left + kNudgeSlop;

                                newStandardRect.right = screenRect.right - kNudgeSlop;

                                if ((zoomData.screenWithLargestPartOfWindow == mainDevice) &&

                                        (newStandardRect.right > (screenRect.right - kIconSpace)))

                                        newStandardRect.right = screenRect.right - kIconSpace;

                        }

                        // Move in the top. Like the width of the window, nothing needs to be done unless

                        // the window is taller than the height of the screen.

                        if ((newStandardRect.bottom - newStandardRect.top) >

                                (screenRect.bottom - screenRect.top)) {

                                newStandardRect.top = screenRect.top + kNudgeSlop;

                                newStandardRect.bottom = screenRect.bottom - kNudgeSlop;

                        }

                }

                // WeÕve got the best possible window position. Remove the

                // frame, slam it into the WStateData record and let ZoomWindow

                // take care of the rest.

                newStandardRect.top += windowFrameTopSize;

                newStandardRect.left += windowFrameLeftSize;

                newStandardRect.right -= windowFrameRightSize;

                newStandardRect.bottom -= windowFrameBottomSize;

                SetWindowStandardState(theWindow, &newStandardRect);

        }

        else

                GetWindowUserState(theWindow, &newStandardRect);

        // If the window is still anchored at the current location, then just resize it

        if ((newStandardRect.left == contentRegionBoundingBox.left) &&

                (newStandardRect.top == contentRegionBoundingBox.top)) {

                OffsetRect(&newStandardRect, -newStandardRect.left, -newStandardRect.top);

                SizeWindow((WindowPtr) theWindow, newStandardRect.right, newStandardRect.bottom,

                                        true);

        }

        else {

                scratchRegion = NewRgn();

                GetClip(scratchRegion);

                ClipRect(&portRect);

                EraseRect(&portRect);

                ZoomWindow((WindowPtr) theWindow, zoomState, false);

                SetClip(scratchRegion);

                DisposeRgn(scratchRegion);

        }

        SetPort(currentPort);

}

pascal void     CalcWindowAreaOnScreen(short depth, short deviceFlags, GDHandle targetDevice, long userData)

{

#pragma unused (depth, deviceFlags)

        ZoomDataPtr     zoomData = (ZoomDataPtr) userData;

        long            windowAreaOnScreen;

        Rect            windowPortionOnScreen;

        // Find the rectangle that encloses the intersection of the window and this screen.

        SectRect(&(zoomData->windowBounds), &((**targetDevice).gdRect), &windowPortionOnScreen);

        // Offset the rectangle so that itÕs right and bottom are also itÕs width and height.

        OffsetRect(&windowPortionOnScreen, -windowPortionOnScreen.left, -windowPortionOnScreen.top);

        // Calculate the area of the portion of the window thatÕs on this screen.

        windowAreaOnScreen = (long) windowPortionOnScreen.right * (long) windowPortionOnScreen.bottom;

        // If this is the largest portion of the window that has been encountered so far,

        // remember this screen as the potential screen to zoom to.

        if (windowAreaOnScreen > zoomData->largestArea) {

                zoomData->largestArea = windowAreaOnScreen;

                zoomData->screenWithLargestPartOfWindow = targetDevice;

        }

}

// Figure out how much we need to move the window to get it entirely on the monitor.  If

// the window wouldnÕt fit completely on the monitor anyway, donÕt move it at all; weÕll

// make it fit later on.

short CalculateOffsetAmount(short idealStartPoint, short idealEndPoint, short idealOnScreenStartPoint,

                                                        short idealOnScreenEndPoint, short screenEdge1, short screenEdge2)

{

        short   offsetAmount;

        // First check to see if the window fits on the screen in this dimension.

        if ((idealStartPoint < screenEdge1) && (idealEndPoint > screenEdge2))

                offsetAmount = 0;

        else {

                // Find out how much of the window lies off this screen by subtracting the amount of the window

                // that is on the screen from the size of the entire window in this dimension. If the window

                // is completely offscreen, the offset amount is going to be the distance from the ideal

                // starting point to the first edge of the screen.

                if ((idealOnScreenStartPoint - idealOnScreenEndPoint) == 0) {

                        // See if the window is lying to the left or above the screen

                        if (idealEndPoint < screenEdge1)

                                offsetAmount = screenEdge1 - idealStartPoint + kNudgeSlop;

                        else

                        // Otherwise, itÕs below or to the right of the screen

                                offsetAmount = screenEdge2 - idealEndPoint - kNudgeSlop;

                }

                else {

                        // Window is already partially or completely on the screen

                        offsetAmount = (idealEndPoint - idealStartPoint) -

                                                        (idealOnScreenEndPoint - idealOnScreenStartPoint);

                        // If we are offscreen a little, move the window in a few more pixels from the edge of the screen.

                        if (offsetAmount != 0)

                                offsetAmount += kNudgeSlop;

                        // Check to see which side of the screen the window was falling off of, so that it can be

                        // nudged in the opposite direction.

                        if (idealEndPoint > screenEdge2)

                                offsetAmount = -offsetAmount;

                }

        }

        return offsetAmount;

}

/*

        WindowRecord accessor functions

*/

RgnHandle GetWindowContentRegion(WindowPeek theWindow)

{

        return (theWindow->contRgn);

}

RgnHandle GetWindowStructureRegion(WindowPeek theWindow)

{

        return (theWindow->strucRgn);

}

void GetWindowPortRect(WindowPeek theWindow, Rect *portRect)

{

        *portRect = theWindow->port.portRect;

}

void SetWindowStandardState(WindowPeek theWindow, const Rect *standardState)

{

        (**((WStateDataHandle) theWindow->dataHandle)).stdState = *standardState;

}

void GetWindowUserState(WindowPeek theWindow, Rect *userState)

{

        *userState = (**((WStateDataHandle) theWindow->dataHandle)).userState;

}