/*

    File:       CustomWindow.c  

    Contains:   A sample on how to create a fully functional custom window for Carbon

    Written by:     Karl Groethe

    Copyright:  Copyright © 2000 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):

                        6/28/00     created

*/

#include "CustomWindow.h"

#include <Carbon/Carbon.h>

#define kPictureID  128

#define kMaskPictureID  129

SInt32 myWindowDef(short varCode,WindowRef window, SInt16 message, SInt32 param)

{

    /*------------------------------------------------------

        This is the main entry point for the Custom Window.

    --------------------------------------------------------*/

    switch(message){

        case kWindowMsgDraw:

                    return myWindowDraw(window,param);

        case kWindowMsgHitTest:

                    return myWindowHitTest(window,param);

        case kWindowMsgInitialize:

                    return myWindowInitialize(window,param);

        case kWindowMsgCleanUp:

                    return myWindowCleanUp(window,param);

        case kWindowMsgDrawGrowOutline:

                    return myWindowDrawGrowOutline(window,param);

        //8.0 forward

        case kWindowMsgGetFeatures:

                    return myWindowGetFeatures(window,param);

        case kWindowMsgGetRegion:

                    return myWindowGetRegion(window,param);

        //8.5 forward

        case kWindowMsgDragHilite:

                    return myWindowDragHilite(window,param);

        case kWindowMsgModified:

                    return myWindowModified(window,param);

        case kWindowMsgDrawInCurrentPort:

                    return myWindowDrawInCurrentPort(window,param);

        case kWindowMsgStateChanged:

                    return myWindowStateChanged(window,param);

        //carbon only

        case kWindowMsgGetGrowImageRegion:

                   return myWindowGetGrowImageRegion(window,param);

        default:

                    return 0;

    }

}

SInt32 myWindowGetFeatures(WindowRef window,SInt32 param)

{

    /*------------------------------------------------------

        Define which options your custom window supports.

    --------------------------------------------------------*/

    //just enable everything for our demo

    *(OptionBits*)param=kWindowCanGrow|

                        kWindowCanZoom|

                        kWindowCanCollapse|

                        kWindowCanGetWindowRegion|

                        kWindowHasTitleBar|

                        kWindowSupportsDragHilite|

                        kWindowCanDrawInCurrentPort|

                        kWindowCanMeasureTitle|

                        kWindowWantsDisposeAtProcessDeath|

                        kWindowSupportsSetGrowImageRegion|

                        kWindowDefSupportsColorGrafPort;    

    return 1;

}

SInt32 myWindowDraw(WindowRef window,SInt32 param)

{

    /*------------------------------------------------------

        Use this method to draw the window based on the value

        of param.

            wNoHit:         draw the frame and attributes

            wInGoAway:      hilite or unhilite GoAway box

            wInZoomIn:      hilite or unhilite ZoomIn Box

            wInZoomOut:     hilite or unhilite ZoomOut Box

            wInCollapseBox:     hilite or unhilite Collapse Box 

    --------------------------------------------------------*/

    static Boolean hilite=FALSE;

    WindowAttributes attributes;

    if(IsWindowVisible(window))

    {

        switch(param){

            case wNoHit:

                        hilite=FALSE;//redrawn so no box hiliteing

                        drawWindowFrame(window);

                        GetWindowAttributes(window,&attributes);

                        if(attributes & kWindowCloseBoxAttribute)//is there a close box?

                            drawWindowCloseBox(window,hilite);             

                        if(attributes & kWindowFullZoomAttribute)//is there a zoom box?

                            drawWindowZoomBox(window,hilite);

                        if(attributes & kWindowCollapseBoxAttribute)//is there a collapse box?

                            drawWindowCollapseBox(window,hilite);

                        break;

            case wInGoAway: 

                        hilite=drawWindowCloseBox(window,!hilite);

                        break;

            case wInZoomIn:

            case wInZoomOut:

                        hilite=drawWindowZoomBox(window,!hilite);

                        break;

            case wInCollapseBox:

                        hilite=drawWindowCollapseBox(window,!hilite);

                        break;

        }

    }

    return 0;

}

RgnHandle getWindowCloseBoxRegion(WindowRef window,RgnHandle closeBoxRegion)

{

    /*------------------------------------------------------

        Define the region for the close box

    --------------------------------------------------------*/

    SetEmptyRgn(closeBoxRegion);

    return closeBoxRegion;

}

RgnHandle getWindowZoomBoxRegion(WindowRef window,RgnHandle zoomBoxRegion)

{

    /*------------------------------------------------------

        Define the region for the zoom box

    --------------------------------------------------------*/

    SetEmptyRgn(zoomBoxRegion);

    return zoomBoxRegion;

}

RgnHandle getWindowCollapseBoxRegion(WindowRef window,RgnHandle collapseBoxRegion)

{

    /*------------------------------------------------------

        Define the region for the collapse box

    --------------------------------------------------------*/

    SetEmptyRgn(collapseBoxRegion);

    return collapseBoxRegion;

}

RgnHandle getWindowGrowBoxRegion(WindowRef window,RgnHandle growBoxRegion)

{

    /*------------------------------------------------------

        Define the region for the Grow Box

    --------------------------------------------------------*/

    SetEmptyRgn(growBoxRegion);

    return growBoxRegion;

}

RgnHandle getWindowTitleBarRegion(WindowRef window,RgnHandle titleBarRegion)

{

    /*------------------------------------------------------

        Define the region for the title bar

    --------------------------------------------------------*/

    SetEmptyRgn(titleBarRegion);

    return titleBarRegion;

}

RgnHandle getWindowTitleTextRegion(WindowRef window,RgnHandle titleTextRegion)

{

    /*------------------------------------------------------

        Define the region for the text in the title bar

    --------------------------------------------------------*/

    SetEmptyRgn(titleTextRegion);

    return titleTextRegion;

}

RgnHandle getWindowContentRegion(WindowRef window,RgnHandle contentRegion)

{

    /*------------------------------------------------------

        Define the content region of our window.

    --------------------------------------------------------*/

    SetEmptyRgn(contentRegion);

    if(!IsWindowCollapsed(window)){

        //only define the content region when the window is 

        //not collapsed

    }

    return contentRegion;

}

RgnHandle getWindowStructureRegion(WindowRef window, RgnHandle structureRegion)

{

    /*------------------------------------------------------

        Define the structural region of our window.

    --------------------------------------------------------*/

    static RgnHandle pictureRgn=NULL;

    static Rect pictureRect;

    Rect windowRect;

    SetEmptyRgn(structureRegion);

    if(!pictureRgn){//haven't Cached our region yet

        PicHandle myPicture=GetPicture(kMaskPictureID);

        GrafPtr origPort;

        GDHandle origDev;

        GWorldPtr pictMask;

        PixMapHandle maskBitMap;

        GetGWorld(&origPort,&origDev);

        pictureRgn=NewRgn();

        pictureRect=(*myPicture)->picFrame;

        NewGWorld(&pictMask,1,&pictureRect,NULL,NULL,0);

        maskBitMap=GetPortPixMap(pictMask);

        LockPixels(maskBitMap);

        SetGWorld(pictMask,NULL);

        EraseRect(&pictureRect);

        DrawPicture(myPicture,&pictureRect);

        BitMapToRegion(pictureRgn,(BitMap*)*maskBitMap);//use the mask to create a region

        InsetRgn(pictureRgn,1,1);

        SetGWorld(origPort,origDev);

        UnlockPixels(maskBitMap);

        DisposeGWorld(pictMask);

        ReleaseResource((Handle)myPicture);

    }

    getCurrentPortBounds(&windowRect);//how big is the window

    CopyRgn(pictureRgn,structureRegion);//make a copy of our cached region

    MapRgn(structureRegion,&pictureRect,&windowRect);//scale it to our actual window size

    return structureRegion;

}

RgnHandle getWindowDragRegion(WindowRef window, RgnHandle dragRegion)

{

    /*------------------------------------------------------

        Define the drag region of our window.

    --------------------------------------------------------*/

    RgnHandle structureRegion=NewRgn();

    RgnHandle contentRegion=NewRgn();

    SetEmptyRgn(dragRegion);

    getWindowStructureRegion(window,structureRegion);

    getWindowContentRegion(window,contentRegion);

    //our drag region is the difference between the structural and content regions

    DiffRgn(structureRegion,contentRegion,dragRegion); 

    DisposeRgn(structureRegion);

    DisposeRgn(contentRegion);

    return dragRegion;

}

void drawWindowFrame(WindowRef window)

{

    /*------------------------------------------------------

        Draw the frame of our window.

        This function needs to draw the title bar, 

        the grow box, the title string and the 

        structural aspects of the window.

    --------------------------------------------------------*/

    static GWorldPtr framePict=NULL;

    static Rect pictureRect;

    GrafPtr thePort;

    Rect frame;

    if(!framePict){//haven't cached our picture

        PicHandle myPicture=GetPicture(kPictureID);

        GrafPtr origPort;

        GDHandle origDev;

        GetGWorld(&origPort,&origDev);

        pictureRect=(*myPicture)->picFrame;

        NewGWorld(&framePict,0,&pictureRect,NULL,NULL,0);

        SetGWorld(framePict,NULL);

        DrawPicture(myPicture,&pictureRect);

        SetGWorld(origPort,origDev);

        ReleaseResource((Handle)myPicture);

    }

    getCurrentPortBounds(&frame);

    GetPort(&thePort);

    CopyBits(GetPortBitMapForCopyBits(framePict),

             GetPortBitMapForCopyBits(thePort),

             &pictureRect,&frame,srcCopy,NULL);//draw our picture

    myWindowDrawGrowBox(window,0);//draw grow box as part of frame

    if(IsWindowHilited(window))

    {

        //do any hilighting

    }

}

Boolean drawWindowCloseBox(WindowRef window, Boolean hilite)

{

    /*------------------------------------------------------

        This function draws the close box.

        If hilite is true it draws the hiliting as well.

    --------------------------------------------------------*/

    RgnHandle closeBoxRegion=NewRgn();

    getWindowCloseBoxRegion(window,closeBoxRegion);

    EraseRgn(closeBoxRegion);//clear away old

    //draw close box

    if(hilite)

    {

        //do hilighting

    }

    DisposeRgn(closeBoxRegion);

    return hilite;

}

Boolean drawWindowZoomBox(WindowRef window, Boolean hilite)

{

    /*------------------------------------------------------

        This function draws the zoom box.

        If hilite is true it draws the hiliting as well.

    --------------------------------------------------------*/

    RgnHandle zoomBoxRegion=NewRgn();

    getWindowZoomBoxRegion(window,zoomBoxRegion);

    EraseRgn(zoomBoxRegion);//clear away old

    //draw zoom Box

    if(hilite)

    {

        //do hilighting

    }

    DisposeRgn(zoomBoxRegion);

    return hilite;

}

Boolean drawWindowCollapseBox(WindowRef window, Boolean hilite)

{

    /*------------------------------------------------------

        This function draws the collapse box.

        If hilite is true it draws the hiliting as well.

    --------------------------------------------------------*/

    RgnHandle collapseBoxRegion=NewRgn();

    getWindowCollapseBoxRegion(window,collapseBoxRegion);

    EraseRgn(collapseBoxRegion);//clear away old stuff

    if(hilite){

        //do hilighting

    }

    DisposeRgn(collapseBoxRegion);

    return hilite;

}

RgnHandle getWindowUpdateRegion(WindowRef window, RgnHandle updateRegion)

{   

    return updateRegion;

}

SInt32 myWindowHitTest(WindowRef window,SInt32 param)

{

    /*------------------------------------------------------

        Determine the region of the window which was hit

    --------------------------------------------------------*/

    Point hitPoint;

    static RgnHandle tempRgn=nil;

    if(!tempRgn) tempRgn=NewRgn();

    SetPt(&hitPoint,LoWord(param),HiWord(param));//get the point clicked

    if(IsWindowHilited(window)){ //make sure the window is in front for these

        if(PtInRgn(hitPoint,getWindowGrowBoxRegion(window,tempRgn)))//in GrowBox?

            return wInGrow;

        if(PtInRgn(hitPoint,getWindowCloseBoxRegion(window,tempRgn)))//in the Close Box?

            return wInGoAway;

        if(PtInRgn(hitPoint,getWindowZoomBoxRegion(window,tempRgn)))//in the Zoom Box?

            return wInZoomOut;

        //Mac OS 8.0 or later

        if(PtInRgn(hitPoint,getWindowCollapseBoxRegion(window,tempRgn)))//in the Collapse Box?

            return wInCollapseBox;

    }

     //Mac OS 8.5 or later

    if(PtInRgn(hitPoint,getWindowContentRegion(window,tempRgn))) //in window content region?

        return wInContent;

    if(PtInRgn(hitPoint,getWindowDragRegion(window,tempRgn)))//in window drag region?

        return wInDrag;

    return wNoHit;//no significant area was hit.

}

SInt32 myWindowInitialize(WindowRef window,SInt32 param)

{

    /*------------------------------------------------------

        perform any initialization for your window here

    --------------------------------------------------------*/

    return 0;

}

SInt32 myWindowCleanUp(WindowRef window,SInt32 param)

{

    /*------------------------------------------------------

        dispose of anything allocated in Initialization

    --------------------------------------------------------*/

    return 0;

}

SInt32 myWindowDrawGrowBox(WindowRef window,SInt32 param)

{

    /*------------------------------------------------------

        This function draws the grow box of the window

    --------------------------------------------------------*/

    RgnHandle growBoxRegion=NewRgn();

    getWindowGrowBoxRegion(window,growBoxRegion);

    //draw grow box here

    return 0;

}

SInt32 myWindowGetRegion(WindowRef window,SInt32 param)

{

    /*------------------------------------------------------

        Define each of the window's regions

    --------------------------------------------------------*/

    GetWindowRegionPtr rgnRec=(GetWindowRegionPtr)param;

    switch(rgnRec->regionCode){

        case kWindowTitleBarRgn:

                                getWindowTitleBarRegion(window,rgnRec->winRgn);

                                break;

        case kWindowTitleTextRgn:

                                getWindowTitleTextRegion(window,rgnRec->winRgn);

                                break;

        case kWindowCloseBoxRgn:

                                getWindowCloseBoxRegion(window,rgnRec->winRgn);

                                break;

        case kWindowZoomBoxRgn:

                                getWindowZoomBoxRegion(window,rgnRec->winRgn);

                                break;

        case kWindowDragRgn:

                                getWindowDragRegion(window,rgnRec->winRgn);

                                break;

        case kWindowGrowRgn:

                                getWindowGrowBoxRegion(window,rgnRec->winRgn);

                                break;

        case kWindowCollapseBoxRgn:

                                getWindowCollapseBoxRegion(window,rgnRec->winRgn);

                                break;

        case kWindowStructureRgn:

                                getWindowStructureRegion(window,rgnRec->winRgn);

                                break;

        case kWindowContentRgn:

                                getWindowContentRegion(window,rgnRec->winRgn);

                                break;

        //Carbon Forward

        case kWindowUpdateRgn:

                                getWindowUpdateRegion(window,rgnRec->winRgn);

                                break;

        default:

                return errWindowRegionCodeInvalid;

    }

    return noErr;

}

SInt32 myWindowDragHilite(WindowRef window,SInt32 param)

{

    /*------------------------------------------------------

        Hilight the window to show support for

        drag-and-drop.

    --------------------------------------------------------*/

    if(param){

        //hilite window

    }else{

        //unhilight window

    }

    return 0;

}

SInt32 myWindowModified(WindowRef window,SInt32 param)

{

    /*------------------------------------------------------

        Called when a document's "modified" bit is changed

    --------------------------------------------------------*/

    if(param){

        //document has been modified

    }else{

        //document has been saved

    }

    return 0;

}

SInt32 myWindowDrawInCurrentPort(WindowRef window,SInt32 param)

{

     /*------------------------------------------------------

        same as myWindowDraw but must draw in current port.

        myWindowDraw is defined to draw in the current port

        so just call it directly.

    --------------------------------------------------------*/

    myWindowDraw(window,param);

    return 0;

}

SInt32 myWindowStateChanged(WindowRef window,SInt32 param)

{

    /*------------------------------------------------------

        use this method if you need notification of a state 

        change after the internal data has been altered but

        before the window is updated on the screen

    --------------------------------------------------------*/

    if(param & kWindowStateTitleChanged){

        //the Title Has changed

    }

    return 0;

}

SInt32 myWindowDrawGrowOutline(WindowRef window,SInt32 Param)

{

    /*------------------------------------------------------

        Draw the window's grow outline

    --------------------------------------------------------*/

    return 0;

}

SInt32 myWindowGetGrowImageRegion(WindowRef window,SInt32 param)

{

    /*------------------------------------------------------

        Get region to xor during grow/resize.

    --------------------------------------------------------*/

    GetGrowImageRegionRec* rgnRec=(GetGrowImageRegionRec*)param;

    #pragma unused(rgnRec)

    return noErr;

}

void getCurrentPortBounds(Rect* inRect)

{

    /*------------------------------------------------------

        Simple utility function to get the bounds of the

        current port.

    --------------------------------------------------------*/

    CGrafPtr thePort;

    GetPort(&thePort);

    GetPortBounds(thePort,inRect);

}