MacHack 1998/MacHack 1998.toast/Papers/C++ Exceptions/µShell/Source/SillyBalls.c

Text File | 1998-06-21 | 8.1 KB | 357 lines | [TEXT/CWIE]

/*------------------------------------------------------------------------------
#
#    Macintosh Developer Technical Support
#
#    Simple Color QuickDraw Sample Application
#
#    SillyBalls
#
#    SillyBalls.c    -    C Source
#
#    Copyright © 1988 Apple Computer, Inc.
#    All rights reserved.
#
#    Versions:    1.0                    8/88
#
#    Components:    SillyBalls.c        August 1, 1988
#                SillyBalls.make        August 1, 1988
#
#    This is a very simple sample program that demonstrates how to use Color
#    QuickDraw.  It is about two pages of code, and does nothing more than open
#    a color window and draw randomly colored ovals in the window.
#
#    The purpose is to show how to get some initial results with Color QuickDraw.
#    It is a complete program and is very short to be as clear as possible.
#
#    It does not have an Event Loop.  It is not fully functional in the sense that
#    it does not do all the things you would expect a well behaved Macintosh
#    program to do, like size the window naturally, have an event loop, use menus,
#    etc.
#
#    See Sample and TESample for the general structure and MultiFinder techniques that
#    we recommend that you use when building a new application.
#
------------------------------------------------------------------------------*/


//    Version 1.0:    6/2/88
//                    7/20/88     DJB    Converted to C
//
//    purpose        To demonstrate a simple color App using Color QuickDraw.
//                        It draws colored balls in a color window, then uses colored
//                        text inverted in the ball.  The ball location and color is Random.
//
//                        This program was written by Bo3b Johnson, 1/88.
//
//                        The inverted Bob text was a Skippy Blair special concept,
//                        kept for obvious aesthetic reasons.
#include "SillyBalls.h"
#include "Exceptions.h"
#include "Main.h"

//MW -cut out some other program descriptions.-

//MW ** Metrowerks note **
//   All changed code by Metrowerks is commented by "//MW".
//   There is one type of modification to the original source:
//   • Added argument type and return type to function definitions.
//       In order to pass with extended error checking on.
//
//   8/31/93 JA


#include <Types.h>
#include <Memory.h>
#include <Quickdraw.h>
#include <Fonts.h>
#include <Events.h>
#include <Menus.h>
#include <Windows.h>
#include <TextEdit.h>
#include <Dialogs.h>
#include <OSUtils.h>
#include <ToolUtils.h>
#include <SegLoad.h>
#include <Sound.h>
#include <AERegistry.h>

#include "WindowManager.h"
#include "Toolbox.h"

/* Constants */
#define BallWidth        20
#define BallHeight        20
#define BobSize            8        /* Size of text in each ball */

/* Globals */
Rect    windRect;

ApplicationHeap        gApplicationHeap;
WindowManager        gWindowManager;
Toolbox                gToolbox;
TSillyLoop            xEventLoop;
EventLoop&            gEventLoop(xEventLoop);

/* Prototypes */
void Initialize(void);
void NewBall(void);

//
//    Main body of program SillyBalls
//

//MW specified argument and return type.

/*
void EventLoop(void)
{
    do {
        NewBall();
    } while (!Button());
}
*/

//
//    Initialize everything for the program, make sure we can run
//

    static pascal OSErr HandleNew(
        const AppleEvent*    theAppleEvent,
        AppleEvent*            reply,
        UInt32                handlerRefcon)
    {
        theAppleEvent; reply; handlerRefcon;

        return noErr;
    }

    static pascal OSErr HandleQuit(
        const AppleEvent*    theAppleEvent,
        AppleEvent*            reply,
        UInt32                handlerRefcon)
    {
        theAppleEvent; reply; handlerRefcon;

        return noErr;
    }

//MW specified argument and return type.
void Initialize(void)
{
#if 0
    OSErr        error;
    SysEnvRec    theWorld;

    //
    //    Test the computer to be sure we can do color.
    //    If not we would crash, which would be bad.
    //    If we can’t run, just beep and exit.
    //

    error = SysEnvirons(1, &theWorld);
    if (theWorld.hasColorQD == false) {
        SysBeep(50);
        return; //ExitToShell();                    /* If no color QD, we must leave. */
    }

    /* Initialize all the needed managers. */
    InitGraf(&qd.thePort);
    InitFonts();
    InitWindows();
    InitMenus();
    TEInit();
    InitDialogs(nil);
    InitCursor();
#endif

    TModule::UseModule(gWindowManager);
    TModule::UseModule(gToolbox);
    TModule::UseModule(gEventLoop);

    //
    //    To make the Random sequences truly random, we need to make the seed start
    //    at a different number.  An easy way to do this is to put the current time
    //    and date into the seed.  Since it is always incrementing the starting seed
    //    will always be different.  Don’t for each call of Random, or the sequence
    //    will no longer be random.  Only needed once, here in the init.
    //
    GetDateTime((unsigned long*) &qd.randSeed);

    Handle mbar = GetNewMBar(128);

    if (mbar != nil)
    {
        SetMenuBar(mbar);
        DrawMenuBar();
    }

    EventLoop::InstallAEHandler(kCoreEventClass, kAEQuitApplication, HandleQuit);

    EventLoop::InstallAEHandler(kCoreEventClass, kAEOpenApplication, HandleNew);
    EventLoop::InstallAEHandler(kAECoreSuite, kAECreateElement, HandleNew);
}

void Finalize(void)
{
}


TSillyBallWindow::TSillyBallWindow()
:    fWindow(nil),
    fThreadID(kNoThreadID)
{
    //
    //    Make a new window for drawing in, and it must be a color window.
    //    The window is full screen size, made smaller to make it more visible.
    //
    windRect = qd.screenBits.bounds;
    InsetRect(&windRect, 50, 50);
    fWindow = NewCWindow(nil, &windRect, "\pBob Land", true, zoomDocProc,
                        (WindowPtr) -1, false, 0);

    SetPort(fWindow);                        /* set window to current graf port */
    TextSize(BobSize);                        /* smaller font for drawing. */

    FailOSErr(NewThread(kCooperativeThread, SillyBallThread, this, 0, kCreateIfNeeded, nil, &fThreadID));
}

TSillyBallWindow::~TSillyBallWindow()
{
    ThreadID thread = fThreadID;

    if (thread != kNoThreadID)
    {
        void*    result;

        LogIfErr(DisposeThread(thread, &result, true));

        fThreadID = kNoThreadID;
    }

    WindowPtr wp = fWindow;

    if (wp != nil)
    {
        GrafPtr port;

        GetPort(&port);

        if (port == wp)                // if we're disposing of the current port
        {                            // switch to the WM port
            GetWMgrPort(&port);
            SetPort(port);
        }

        DisposeWindow(wp);

        fWindow = nil;
    }
}

//
//    NewBall: make another ball in the window at a random location and color.
//

//MW -specified argument and return type.-
void TSillyBallWindow::NewBall(void)
{
    RGBColor    ballColor;
    Rect        ballRect;
    long int    newLeft,
                newTop;
    GrafPtr        oldPort;

    GetPort(&oldPort);
    SetPort(fWindow);

    //
    //    Make a random new color for the ball.
    //
    ballColor.red   = Random();
    ballColor.green = Random();
    ballColor.blue  = Random();

    //
    //    Set that color as the new color to use in drawing.
    //
    RGBForeColor (&ballColor);

    //
    //    Make a Random new location for the ball, that is normalized to the window size.
    //    This makes the Integer from Random into a number that is 0..windRect.bottom
    //    and 0..windRect.right.  They are normalized so that we don't spend most of our
    //    time drawing in places outside of the window.
    //
    newTop = Random();    newLeft = Random();
    newTop = ((newTop+32767) * windRect.bottom)/65536;
    newLeft = ((newLeft+32767) * windRect.right)/65536;
    SetRect(&ballRect, newLeft, newTop, newLeft+BallWidth, newTop+BallHeight);

    //
    //    Move pen to the new location, and paint the colored ball.
    //
    MoveTo(newLeft, newTop);
    PaintOval (&ballRect);

    //
    //    Move the pen to the middle of the new ball position, for the text
    //
    MoveTo(ballRect.left + BallWidth/2 - BobSize,
        ballRect.top + BallHeight/2 + BobSize/2 -1);

    //
    //    Invert the color and draw the text there.  This won’t look quite right in 1 bit
    //    mode, since the foreground and background colors will be the same.
    //    Color QuickDraw special cases this to not invert the color, to avoid
    //    invisible drawing.
    //
    InvertColor(&ballColor);
    RGBForeColor(&ballColor);
    DrawString("\pBob");

    SetPort(oldPort);
}

pascal voidPtr TSillyBallWindow::SillyBallThread(void *threadParam)
{
    TSillyBallWindow* win = (TSillyBallWindow*) threadParam;

    while(1)
    {
        win->NewBall();
        YieldToAnyThread();
    }
}


TSillyLoop::~TSillyLoop()
{
}

bool TSillyLoop::HandleMenuSelection(long what)
{
    int menu = HiWord(what);
    int item = LoWord(what);

    switch (menu)
    {
    case 129:
        switch (item)
        {
        case 1:
            TSillyBallWindow* win = new TSillyBallWindow();
            break;

        case 3:
            Quit();
            break;
        }
    }

    return Inherited::HandleMenuSelection(what);
}