/*

    EventLoop.c

    Handle events.

    © 1995 Apple Computer, Inc.

*/

#include <QuickDraw.h>

#include <Events.h>

#include <Windows.h>

#include <Menus.h>

#include <Devices.h>

#include <Events.h>

#include <Controls.h>

#include <Menus.h>

#include <ToolUtils.h>

#include <SegLoad.h>

#include "EventLoop.h"

#include "MenuDispatch.h"

#include "QD3DViewer.h"

Boolean     Done = false;               /* true when Quit is selected */

Boolean     KeyPressed = false;         /* true most recent event is a keyDown event */

char        KeyValue = 0;               /* the ascii code of the most recent key down */

Boolean     WNE_available = false;      /* Does WNE exist on this mac?? */

Boolean     BackgroundFlag = false;     /* true if we are in the background */

void DoCloseWindow(register EventRecord *evt, register WindowPtr theWindow);

void DoClickInContent(register EventRecord *evt, register WindowPtr theWindow);

void DoDragWindow(register EventRecord *evt, register WindowPtr theWindow);

void DoGrowWindow(register EventRecord *evt, register WindowPtr theWindow);

void DoZoom(register EventRecord *evt, register WindowPtr theWindow, int part);

void DoMenu(register long msel);

void DoKey(register EventRecord *evt);

void DrawClippedGrowIcon(WindowPtr theWindow);

void DoUpdate(register EventRecord *evt);

void ActivateWindow(register WindowRecord   *newFrontWindow);

void DeactivateWindow(register WindowRecord *newBehindWindow);

void DoActivate(register EventRecord *evt);

void DoMFinder(register EventRecord *evt);

void DoClick(register EventRecord *evt);

void MainEvent(void);

extern void MenuDispatch(short menuNumber,short itemNumber);

extern void DrawImage(GrafPtr graf);

extern void AdjustMenuItems(void);

extern void ChooseFile(short item);

extern WindowPtr        MainView;

void DoCloseWindow(register EventRecord *evt, register WindowPtr theWindow)

{

    if(TrackGoAway(theWindow,evt->where)) {

        ChooseFile(cmdClose);

    }

}

void DoClickInContent(register EventRecord *evt, register WindowPtr theWindow)

{

    int             part;

    ControlHandle   ctlh;

    Point           pt;

    GrafPtr         saveport;

    Rect            frame;

    if(theWindow != FrontWindow())

    {

        SelectWindow(theWindow);

        MainView = theWindow;

    }

    else

    {

        GetPort(&saveport);

        SetPort(theWindow);

        pt = evt->where;

        GlobalToLocal(&pt);

        if ((part = FindControl(pt, theWindow, &ctlh)) != kControlNoPart) {

            /* TrackControl Goes Here */

        }

        SetPort(saveport);

    }

}

void DoDragWindow(register EventRecord *evt, register WindowPtr theWindow)

{

    DragWindow(theWindow,evt->where,&qd.screenBits.bounds);

}

void DoGrowWindow(register EventRecord *evt, register WindowPtr theWindow)

{

    long    newSize;

    int     newHeight,newWidth;

    Rect    growLimitSizes;

    OSErr   anErr;

    SetPort(theWindow);

    growLimitSizes.top = 20;        /* min height */

    growLimitSizes.bottom = 400;    /* max height */

    growLimitSizes.left = 20;       /* min width */

    growLimitSizes.right = 600;     /* max width */

    newSize = GrowWindow(theWindow,evt->where, &growLimitSizes);

    if (newSize)

    {

        newHeight = HiWord(newSize);

        newWidth = LoWord(newSize);

        SizeWindow(theWindow, newWidth, newHeight, true);

        InvalRect(&theWindow->portRect);

        if (theWindow == MainView)

        {

            TVCDemoDataHdl  demoData;

            TQ3ViewerObject aViewer;

            demoData = (TVCDemoDataHdl)GetWRefCon(MainView);

            aViewer = (*demoData)->viewer1;

            anErr = Q3ViewerSetBounds(aViewer, &theWindow->portRect);

        }

    }

}

void DoZoom(register EventRecord *evt, register WindowPtr theWindow, int part)

{

    GrafPtr savePort;

    OSErr   anErr;

    GetPort(&savePort);

    SetPort(theWindow);

    if(TrackBox(theWindow,evt->where,part)) {

        ZoomWindow(theWindow,part,true);

        if (theWindow == MainView)

        {

            Rect            newRect;

            TQ3ViewerObject aViewer;

            TVCDemoDataHdl  demoData;

            demoData = (TVCDemoDataHdl)GetWRefCon(MainView);

            aViewer = (*demoData)->viewer1;

            newRect = theWindow->portRect;

            anErr = Q3ViewerSetBounds(aViewer, &newRect);

        }

    }

    SetPort(savePort);

}

void DoMenu(register long msel)

{

    int item,menu;

    item = LoWord(msel);

    menu = HiWord(msel);

    MenuDispatch(menu, item);

    HiliteMenu(0);

}

void DoKey(register EventRecord *evt)

{

    char        c;

    c = (char)evt->message & charCodeMask;

    if((evt->modifiers & cmdKey) == false) {

        KeyPressed = true;

        KeyValue = c;

    } else {

        AdjustMenuItems();

        DoMenu(MenuKey(evt->message & charCodeMask));   

    }

}

void DrawClippedGrowIcon(WindowPtr theWindow)

/*

    Clip out the lines that appear

    on the sides of a window with a grow icon.

*/

{

    Rect        clip;

    RgnHandle   oldClip;

    oldClip = NewRgn();

    GetClip(oldClip);

    clip = theWindow->portRect;

    clip.left = clip.right - 15;

    clip.top = clip.bottom - 15;

    ClipRect(&clip);

    DrawGrowIcon(theWindow);

    SetClip(oldClip);

}

void DoUpdate(register EventRecord *evt)

{

    WindowPtr       updateWindow;

    GrafPtr         savePort;

    TQ3ViewerObject aViewer;

    TVCDemoDataHdl  demoData;

    GetPort(&savePort);                     /* save current port */

    updateWindow=(WindowPtr)evt->message;   /* get windowPtr from event msg */

    SetPort(updateWindow);

    BeginUpdate(updateWindow);                      

    EraseRect(&updateWindow->portRect);     /* erase content region */

    demoData = (TVCDemoDataHdl)GetWRefCon(updateWindow);

    aViewer = (*demoData)->viewer1;

    if (Q3ViewerDraw(aViewer) != 0)         /* Draw the view controller contents */

        ExitToShell();

    if ((*demoData)->containerStyle == kContainerFourView)

    {

        aViewer = (*demoData)->viewer2;

        Q3ViewerDraw(aViewer);              /* Draw the view controller contents */

        aViewer = (*demoData)->viewer3;

        Q3ViewerDraw(aViewer);              /* Draw the view controller contents */

        aViewer = (*demoData)->viewer4;

        Q3ViewerDraw(aViewer);              /* Draw the view controller contents */

    }

    DrawControls(updateWindow);             /* draw any controls in the window */

    DrawClippedGrowIcon(updateWindow);

    EndUpdate(updateWindow);

    SetPort(savePort);

}

void ActivateWindow(register WindowRecord   *newFrontWindow)

{

    /* This window is now active.  Controls should be enabled, etc. */

}

void DeactivateWindow(register WindowRecord *newBehindWindow)

{

    /* 

        do anyting necessary to deactivate your windows here.

        controls should be dimmed, etc.

    */

}

void DoActivate(register EventRecord *evt)

{

    if(evt->modifiers & activeFlag)

        ActivateWindow((WindowRecord *)evt->message);

    else

        DeactivateWindow((WindowRecord *)evt->message);

}

void DoMFinder(register EventRecord *evt)

{

    if( (evt->message >> 24) == suspendResumeMessage)

        BackgroundFlag = !(evt->message & resumeFlag);

}

void DoClick(register EventRecord *evt)

{

    WindowPtr   theWindow;

    switch(FindWindow(evt->where, &theWindow)) {

        case inDesk:        break;

        case inMenuBar:     AdjustMenuItems();

                            DoMenu(MenuSelect(evt->where));

                            break;

        case inSysWindow:   SystemClick(evt,theWindow);

                            break;

        case inContent:     DoClickInContent(evt,theWindow);

                            break;

        case inDrag:        DoDragWindow(evt,theWindow);

                            break;

        case inGrow:        DoGrowWindow(evt,theWindow);

                            break;

        case inGoAway:      DoCloseWindow(evt,theWindow);

                            break;

        case inZoomIn:      DoZoom(evt,theWindow,inZoomIn);

                            break;

        case inZoomOut:     DoZoom(evt,theWindow,inZoomOut);

                            break;

        default:            break;

    }

}

void MainEvent(void)

{

    EventRecord event;

    Boolean     eventOccured, wasQ3Event;

    Point       localPt;

    TQ3ViewerObject aViewer = NULL;

    KeyPressed = false;             /* set to false every time through  */

    if (WNE_available)

        eventOccured = WaitNextEvent(everyEvent,&event,10,nil);

    else {

        SystemTask();

        eventOccured = GetNextEvent(everyEvent, &event);

    }

    if (eventOccured)

    {

        wasQ3Event = false;

        if (MainView && (event.what != updateEvt))

        {

            TVCDemoDataHdl  demoData;

            demoData = (TVCDemoDataHdl)GetWRefCon(MainView);

            aViewer = (*demoData)->viewer1;

            SetPort(MainView);              /* just to make sure */

            GetMouse(&localPt);

            if (!Q3ViewerAdjustCursor(aViewer, &localPt))

                InitCursor();

            wasQ3Event = Q3ViewerEvent(aViewer, &event);

            if (((*demoData)->containerStyle == kContainerFourView) && !wasQ3Event)

            {

                aViewer = (*demoData)->viewer2;

                wasQ3Event = Q3ViewerEvent(aViewer, &event);

                if (!wasQ3Event)

                {

                    aViewer = (*demoData)->viewer3;

                    wasQ3Event = Q3ViewerEvent(aViewer, &event);

                    if (!wasQ3Event)

                    {

                        aViewer = (*demoData)->viewer4;

                        wasQ3Event = Q3ViewerEvent(aViewer, &event);

                    }

                }

            }

        }

        if (!wasQ3Event)

            switch(event.what)

            {

                case nullEvent:                             break;

                case mouseDown:     DoClick(&event);        break;

                case mouseUp:                               break;

                case keyDown:       DoKey(&event);          break;

                case keyUp:                                 break;

                case autoKey:       DoKey(&event);          break;

                case updateEvt:     DoUpdate(&event);       break;

                case diskEvt:                               break;

                case activateEvt:   DoActivate(&event);     break;

                case osEvt:         DoMFinder(&event);      break;

                default:                                    break;

            }

    }

}

/* EOF */