//////////

//

//  File:       QTSprites.c

//

//  Contains:   QuickTime sprites support for QuickTime movies.

//

//  Written by: Tim Monroe

//  Revised by: Deeje Cooley and Tim Monroe

//              Based (heavily!) on the existing MakeSpriteMovie.c code written by Sean Allen.

//

//  Copyright:  © 1997-1998 by Apple Computer, Inc., all rights reserved.

//

//  Change History (most recent first):

//

//     <6>      01/10/01    rtm     modified QTSprites_CreateSpritesMovie to create one of three

//                                  different sprite movies (icon, penguin, and space movies)

//     <5>      03/17/00    rtm     made changes to get things running under CarbonLib

//     <4>      09/30/98    rtm     tweaked call to AddMovieResource to create single-fork movies

//     <3>      06/19/98    rtm     moved to new routine names (e.g. SpriteMediaSetSpriteProperty)

//     <2>      04/09/98    rtm     added sprite hit-testing

//     <1>      04/02/98    rtm     first file; integrated existing code with shell framework

//     

//  This sample code creates a sprite movie containing one sprite track. The contents of the sprite

//  track vary, depending on the value passed to QTSprites_CreateSpritesMovie. In the simplest case,

//  we create a movie with an icon moviing from left to right, with the icon changing at the midpoint.

//  The second movie is contains a penguin sprite whose opacity gradually increases. In the third movie, the sprite

//  track contains a static background picture sprite (or just a colored background, depending on the value of the

//  global variable gUseBackgroundPicture) and three other sprites that change their properties over time.

//  The track's media contains only one key frame sample followed by many override samples. The key

//  frame contains all of the images used by the sprites; the override frames only contain the overrides

//  of the locations, image indices, and layers needed for the other sprites.

//

//  This sample code also shows how to hit test sprites. It uses the function SpriteMediaHitTestAllSprites

//  to find mouse clicks on the sprites in the first sprite track in a movie. If the user clicks on a

//  sprite, we toggle the visibility state of the sprite. You would probably want to do something a bit

//  more interesting when the user clicks on a sprite.

//

//////////

//////////

//

// header files

//

//////////

#include "QTSprites.h"

//////////

//

// global variables

//

//////////

Boolean                         gUseBackgroundPicture = false;      // do we display a background picture?

//////////

//

// QTSprites_InitWindowData

// Do any sprite-specific initialization for the specified window.

//

//////////

ApplicationDataHdl QTSprites_InitWindowData (WindowObject theWindowObject)

{

    ApplicationDataHdl      myAppData = NULL;

    Track                   myTrack = NULL;

    MediaHandler            myHandler = NULL;

    myAppData = (ApplicationDataHdl)NewHandleClear(sizeof(ApplicationDataRecord));

    if (myAppData != NULL) {

        myTrack = GetMovieIndTrackType((**theWindowObject).fMovie, 1, SpriteMediaType, movieTrackMediaType | movieTrackEnabledOnly);

        if (myTrack != NULL)

            myHandler = GetMediaHandler(GetTrackMedia(myTrack));

        // remember the sprite media handler

        (**myAppData).fMovieHasSprites = (myTrack != NULL);

        (**myAppData).fSpriteHandler = myHandler;

    }

    return(myAppData);

}

//////////

//

// QTSprites_DumpWindowData

// Get rid of any window-specific data for the sprite media handler.

//

//////////

void QTSprites_DumpWindowData (WindowObject theWindowObject)

{

    ApplicationDataHdl      myAppData = NULL;

    myAppData = (ApplicationDataHdl)QTFrame_GetAppDataFromWindowObject(theWindowObject);

    if (myAppData != NULL)

        DisposeHandle((Handle)myAppData);

}

//////////

//

// QTSprites_CreateSpritesMovie

// Create a QuickTime movie containing a sprite track.

//

//////////

OSErr QTSprites_CreateSpritesMovie (UInt16 theMenuItem)

{

    Movie                   myMovie = NULL;

    Track                   myTrack = NULL;

    Media                   myMedia = NULL;

    FSSpec                  myFile;

    Boolean                 myIsSelected = false;

    Boolean                 myIsReplacing = false;  

    Fixed                   myHeight = 0;

    Fixed                   myWidth = 0;

    StringPtr               myPrompt = QTUtils_ConvertCToPascalString(kSpriteSavePrompt);

    StringPtr               myFileName = QTUtils_ConvertCToPascalString(kSpriteSaveMovieFileName);

    long                    myFlags = createMovieFileDeleteCurFile | createMovieFileDontCreateResFile;

    short                   myResRefNum = 0;

    short                   myResID = movieInDataForkResID;

    OSErr                   myErr = noErr;

    //////////

    //

    // create a new movie file

    //

    //////////

    // prompt the user for the destination file name

    QTFrame_PutFile(myPrompt, myFileName, &myFile, &myIsSelected, &myIsReplacing);

    myErr = myIsSelected ? noErr : userCanceledErr;

    if (!myIsSelected)

        goto bail;

    // create a movie file for the destination movie

    myErr = CreateMovieFile(&myFile, FOUR_CHAR_CODE('TVOD'), smSystemScript, myFlags, &myResRefNum, &myMovie);

    if (myErr != noErr)

        goto bail;

    //////////

    //

    // create the sprite track and media

    //

    //////////

    QTSprites_GetMovieSize(theMenuItem, &myHeight, &myWidth);

    myTrack = NewMovieTrack(myMovie, myWidth, myHeight, kNoVolume);

    myMedia = NewTrackMedia(myTrack, SpriteMediaType, kSpriteMediaTimeScale, NULL, 0);

    BeginMediaEdits(myMedia);

    //////////

    //

    // add the appropriate samples to the sprite media

    //

    //////////

    switch (theMenuItem) {

        case IDM_MAKE_ICONS_MOVIE:

            QTSprites_AddIconMovieSamplesToMedia(myMedia);

            break;

        case IDM_MAKE_PENGUIN_MOVIE:

            QTSprites_AddPenguinMovieSamplesToMedia(myMedia);

            break;

        case IDM_MAKE_SPACE_MOVIE:

            QTSprites_AddSpaceMovieSamplesToMedia(myMedia);

            break;

        default:

            goto bail;

    }

    EndMediaEdits(myMedia);

    // add the media to the track

    InsertMediaIntoTrack(myTrack, 0, 0, GetMediaDuration(myMedia), fixed1);

    //////////

    //

    // set the sprite track properties

    //

    //////////

    QTSprites_SetTrackProperties(myMedia, theMenuItem);

    //////////

    //

    // finish up

    //

    //////////

    // add the movie resource to the movie file

    myErr = AddMovieResource(myMovie, myResRefNum, &myResID, myFile.name);

bail:

    if (myResRefNum != 0)

        CloseMovieFile(myResRefNum);

    if (myMovie != NULL)

        DisposeMovie(myMovie);

    free(myPrompt);

    free(myFileName);

    return(myErr);

}

//////////

//

// QTSprites_GetMovieSize

// Return the desired size of the specified sprite movie.

//

//////////

void QTSprites_GetMovieSize (UInt16 theMenuItem, Fixed *theHeight, Fixed *theWidth)

{

    if ((theHeight == NULL) || (theWidth == NULL))

        return;

    switch (theMenuItem) {

        case IDM_MAKE_ICONS_MOVIE:

            *theWidth = (long)kIconSpriteTrackWidth << 16;

            *theHeight = (long)kIconSpriteTrackHeight << 16;

            break;

        case IDM_MAKE_PENGUIN_MOVIE:

            *theWidth = (long)kPenguinSpriteTrackWidth << 16;

            *theHeight = (long)kPenguinSpriteTrackHeight << 16;

            break;

        case IDM_MAKE_SPACE_MOVIE:

            *theWidth = (long)kSpaceSpriteTrackWidth << 16;

            *theHeight = (long)kSpaceSpriteTrackHeight << 16;

            break;

    }

}

//////////

//

// QTSprites_GetBackgroundColor

// Return the desired size of the specified sprite movie.

//

//////////

void QTSprites_GetBackgroundColor (UInt16 theMenuItem, RGBColor *theColor)

{

    if (theColor == NULL)

        return;

    switch (theMenuItem) {

        case IDM_MAKE_ICONS_MOVIE:

        case IDM_MAKE_PENGUIN_MOVIE:

            theColor->red = EndianU16_NtoB(0xffff);

            theColor->green = EndianU16_NtoB(0xffff);

            theColor->blue = EndianU16_NtoB(0xffff);

            break;

        case IDM_MAKE_SPACE_MOVIE:

            theColor->red = EndianU16_NtoB(0x8000);

            theColor->green = EndianU16_NtoB(0);

            theColor->blue = EndianU16_NtoB(0xffff);

            break;

    }

}

//////////

//

// QTSprites_AddIconMovieSamplesToMedia

// Build the key frames and override frames for the icon sprite movie.

//

//////////

void QTSprites_AddIconMovieSamplesToMedia (Media theMedia)

{

    QTAtomContainer         mySample = NULL;

    QTAtomContainer         mySpriteData = NULL;

    RGBColor                myKeyColor;

    Point                   myLocation;

    short                   isVisible;

    short                   myLayer, myIndex, myCount;

    OSErr                   myErr = noErr;

    //////////

    //

    // create a key frame sample containing the sprite images

    //

    //////////

    // create a new, empty key frame sample

    myErr = QTNewAtomContainer(&mySample);

    if (myErr != noErr)

        goto bail;

    myKeyColor.red = myKeyColor.green = myKeyColor.blue = 0xffff;       // white

    // add images to the key frame sample

    SpriteUtils_AddPICTImageToKeyFrameSample(mySample, kOldQTIconID, &myKeyColor, 1, NULL, NULL);

    SpriteUtils_AddPICTImageToKeyFrameSample(mySample, kNewQTIconID, &myKeyColor, 2, NULL, NULL);

    //////////

    //

    // add the initial sprite properties to the key frame sample

    //

    //////////

    myErr = QTNewAtomContainer(&mySpriteData);

    if (myErr != noErr)

        goto bail;

    // the QT icon sprite

    myLocation.h    = 32;

    myLocation.v    = 32;

    isVisible       = true;

    myLayer         = -1;

    myIndex         = 1;

    SpriteUtils_SetSpriteData(mySpriteData, &myLocation, &isVisible, &myLayer, &myIndex, NULL, NULL, NULL);

    SpriteUtils_AddSpriteToSample(mySample, mySpriteData, kQTIconSpriteAtomID);

    SpriteUtils_AddSpriteSampleToMedia(theMedia, mySample, kSpriteMediaFrameDurationIcon, true, NULL);  

    //////////

    //

    // add a few override samples to change the icon's location and image

    //

    //////////

    for (myCount = 1; myCount <= kNumOverrideSamples; myCount++) {

        QTRemoveChildren(mySample, kParentAtomIsContainer);

        QTRemoveChildren(mySpriteData, kParentAtomIsContainer);

        // every frame, bump the icon's location

        myLocation.h += 2;

        // change icon half way thru

        if (myCount == kNumOverrideSamples / 2)

            myIndex = 2;

        SpriteUtils_SetSpriteData(mySpriteData, &myLocation, NULL, NULL, &myIndex, NULL, NULL, NULL);

        SpriteUtils_AddSpriteToSample(mySample, mySpriteData, kQTIconSpriteAtomID);

        SpriteUtils_AddSpriteSampleToMedia(theMedia, mySample, kSpriteMediaFrameDurationIcon, false, NULL); 

    }

bail:   

    if (mySample != NULL)

        QTDisposeAtomContainer(mySample);

    if (mySpriteData != NULL)

        QTDisposeAtomContainer(mySpriteData);   

}

//////////

//

// QTSprites_AddPenguinMovieSamplesToMedia

// Build the key frames and override frames for the penguin sprite movie.

//

//////////

void QTSprites_AddPenguinMovieSamplesToMedia (Media theMedia)

{

    QTAtomContainer         mySample = NULL;

    QTAtomContainer         mySpriteData = NULL;

    RGBColor                myKeyColor;

    Point                   myLocation;

    short                   isVisible;

    short                   myLayer, myIndex, myCount;

    ModifierTrackGraphicsModeRecord 

                            myGraphicsMode;

    OSErr                   myErr = noErr;

    //////////

    //

    // create a key frame sample containing the sprite images

    //

    //////////

    // create a new, empty key frame sample

    myErr = QTNewAtomContainer(&mySample);

    if (myErr != noErr)

        goto bail;

    myKeyColor.red = myKeyColor.green = myKeyColor.blue = 0xffff;       // white

    // add images to the key frame sample

    SpriteUtils_AddPICTImageToKeyFrameSample(mySample, kPenguinPictID, &myKeyColor, kPenguinImageIndex, NULL, NULL);

    //////////

    //

    // add the initial sprite properties to the key frame sample

    //

    //////////

    myErr = QTNewAtomContainer(&mySpriteData);

    if (myErr != noErr)

        goto bail;

    // the penguin sprite

    myLocation.h    = 0;

    myLocation.v    = 0;

    isVisible       = true;

    myLayer         = -1;

    myIndex         = 1;

    // set the initial blend amount (0 = fully transparent; 0xffff = fully opaque)

    myGraphicsMode.graphicsMode = blend;

    myGraphicsMode.opColor.red = 0;

    myGraphicsMode.opColor.green = 0;

    myGraphicsMode.opColor.blue = 0;

    SpriteUtils_SetSpriteData(mySpriteData, &myLocation, &isVisible, &myLayer, &myIndex, &myGraphicsMode, NULL, NULL);

    SpriteUtils_AddSpriteToSample(mySample, mySpriteData, kPenguinSpriteAtomID);

    SpriteUtils_AddSpriteSampleToMedia(theMedia, mySample, kSpriteMediaFrameDurationPenguin, true, NULL);   

    //////////

    //

    // add a few override samples to change the penguin's opacity

    //

    //////////

    for (myCount = 1; myCount <= kNumOverrideSamples; myCount++) {

        QTRemoveChildren(mySample, kParentAtomIsContainer);

        QTRemoveChildren(mySpriteData, kParentAtomIsContainer);

        // every frame, bump the penguin's opacity

        myGraphicsMode.graphicsMode = blend;

        myGraphicsMode.opColor.red = (myCount - 1) * (0xffff / kNumOverrideSamples - 1);

        myGraphicsMode.opColor.green = (myCount - 1) * (0xffff / kNumOverrideSamples - 1);

        myGraphicsMode.opColor.blue = (myCount - 1) * (0xffff / kNumOverrideSamples - 1);

        SpriteUtils_SetSpriteData(mySpriteData, NULL, NULL, NULL, NULL, &myGraphicsMode, NULL, NULL);

        SpriteUtils_AddSpriteToSample(mySample, mySpriteData, kPenguinSpriteAtomID);

        SpriteUtils_AddSpriteSampleToMedia(theMedia, mySample, kSpriteMediaFrameDurationPenguin, false, NULL);  

    }

bail:   

    if (mySample != NULL)

        QTDisposeAtomContainer(mySample);

    if (mySpriteData != NULL)

        QTDisposeAtomContainer(mySpriteData);   

}

//////////

//

// QTSprites_AddSpaceMovieSamplesToMedia

// Build the key frames and override frames for the space sprite movie.

//

//////////

void QTSprites_AddSpaceMovieSamplesToMedia (Media theMedia)

{

    QTAtomContainer         mySample = NULL;

    QTAtomContainer         mySpriteData = NULL;

    RGBColor                myKeyColor;

    Point                   myLocation, myIconLocation;

    short                   isVisible;

    short                   myLayer, myIndex, myCount, myDelta, myIconMinH, myIconMaxH;

    OSErr                   myErr = noErr;

    //////////

    //

    // create a key frame sample containing the sprite images

    //

    //////////

    // create a new, empty key frame sample

    myErr = QTNewAtomContainer(&mySample);

    if (myErr != noErr)

        goto bail;

    myKeyColor.red = myKeyColor.green = myKeyColor.blue = 0xffff;       // white

    // add images to the key frame sample

    SpriteUtils_AddPICTImageToKeyFrameSample(mySample, kIconPictID, &myKeyColor, kIconImageIndex, NULL, NULL);

    SpriteUtils_AddPICTImageToKeyFrameSample(mySample, kWorldPictID, &myKeyColor, kWorldImageIndex, NULL, NULL);

    SpriteUtils_AddPICTImageToKeyFrameSample(mySample, kBackgroundPictID, &myKeyColor, kBackgroundImageIndex, NULL, NULL);

    for (myCount = 1; myCount <= kNumSpaceShipImages; myCount++)

        SpriteUtils_AddPICTImageToKeyFrameSample(mySample, kFirstSpaceShipPictID + myCount - 1, &myKeyColor, myCount + (kFirstSpaceShipImageIndex - 1), NULL, NULL);

    //////////

    //

    // add the initial sprite properties to the key frame sample

    //

    //////////

    myErr = QTNewAtomContainer(&mySpriteData);

    if (myErr != noErr)

        goto bail;

    // the background image

    if (gUseBackgroundPicture) {

        myLocation.h    = 0;

        myLocation.v    = 0;

        isVisible       = true;

        myLayer         = kBackgroundSpriteLayerNum;            // this makes the sprite a background sprite

        myIndex         = kBackgroundImageIndex;

        myErr = SpriteUtils_SetSpriteData(mySpriteData, &myLocation, &isVisible, &myLayer, &myIndex, NULL, NULL, NULL);

        if (myErr != noErr)

            goto bail;

        SpriteUtils_AddSpriteToSample(mySample, mySpriteData, kBackgroundSpriteAtomID);

    }

    // the space ship sprite

    myLocation.h    = 0;

    myLocation.v    = 60;

    isVisible       = true;

    myLayer         = -1;

    myIndex         = kFirstSpaceShipImageIndex;

    myErr = SpriteUtils_SetSpriteData(mySpriteData, &myLocation, &isVisible, &myLayer, &myIndex, NULL, NULL, NULL);

    if (myErr != noErr)

        goto bail;

    SpriteUtils_AddSpriteToSample(mySample, mySpriteData, kSpaceShipSpriteAtomID);

    // the world sprite

    myLocation.h    = (kSpaceSpriteTrackWidth / 2) - 24;

    myLocation.v    = (kSpaceSpriteTrackHeight / 2) - 24;

    isVisible       = true;

    myLayer         = 1;

    myIndex         = kWorldImageIndex;

    myErr = SpriteUtils_SetSpriteData(mySpriteData, &myLocation, &isVisible, &myLayer, &myIndex, NULL, NULL, NULL);

    if (myErr != noErr)

        goto bail;

    SpriteUtils_AddSpriteToSample(mySample, mySpriteData, kWorldSpriteAtomID);

    // the icon sprite

    myIconMinH          = (kSpaceSpriteTrackWidth / 2) - 116;

    myIconMaxH          = myIconMinH + 200;

    myDelta             = 2;

    myIconLocation.h    = myIconMinH;

    myIconLocation.v    = (kSpaceSpriteTrackHeight / 2) - (24 + 12);

    isVisible           = true;

    myLayer             = 0;

    myIndex             = kIconImageIndex;

    myErr = SpriteUtils_SetSpriteData(mySpriteData, &myIconLocation, &isVisible, &myLayer, &myIndex, NULL, NULL, NULL);

    if (myErr != noErr)

        goto bail;

    SpriteUtils_AddSpriteToSample(mySample, mySpriteData, kIconSpriteAtomID);

    //////////

    //

    // add the key frame sample to the sprite track media

    //

    // to add the sample data in a compressed form, you would use a QuickTime DataCodec to perform the

    // compression; replace the call to the utility SpriteUtils_AddSpriteSampleToMedia with a call to the utility

    // SpriteUtils_AddCompressedSpriteSampleToMedia to do this

    //

    //////////

    SpriteUtils_AddSpriteSampleToMedia(theMedia, mySample, kSpriteMediaFrameDurationSpace, true, NULL); 

    //SpriteUtils_AddCompressedSpriteSampleToMedia(theMedia, mySample, kSpriteMediaFrameDurationSpace, true, zlibDataCompressorSubType, NULL);

    //////////

    //

    // add a few override samples to move the space ship and icon, and to change the icon's layer

    //

    //////////

    // original space ship location

    myIndex         = kFirstSpaceShipImageIndex;

    myLocation.h    = 0;

    myLocation.v    = 80;

    isVisible       = true;

    for (myCount = 1; myCount <= kNumOverrideSamplesSpace; myCount++) {

        QTRemoveChildren(mySample, kParentAtomIsContainer);

        QTRemoveChildren(mySpriteData, kParentAtomIsContainer);

        // every third frame, bump the space ship's image index (so that it spins as it moves)

        if ((myCount % 3) == 0) {

            myIndex++;

            if (myIndex > kLastSpaceShipImageIndex)

                myIndex = kFirstSpaceShipImageIndex;

        }

        // every frame, bump the space ship's location (so that it moves as it spins)

        myLocation.h += 2;

        myLocation.v += 1;

        if (isVisible)

            SpriteUtils_SetSpriteData(mySpriteData, &myLocation, NULL, NULL, &myIndex, NULL, NULL, NULL);

        else {

            isVisible = true;

            SpriteUtils_SetSpriteData(mySpriteData, &myLocation, &isVisible, NULL, &myIndex, NULL, NULL, NULL);

        }

        SpriteUtils_AddSpriteToSample(mySample, mySpriteData, kSpaceShipSpriteAtomID);

        // make the icon move and change layer

        QTRemoveChildren(mySpriteData, kParentAtomIsContainer);

        myIconLocation.h += myDelta;

        if (myIconLocation.h >= myIconMaxH) {

            myIconLocation.h = myIconMaxH;

            myDelta = -myDelta;

        }

        if (myIconLocation.h <= myIconMinH) {

            myIconLocation.h = myIconMinH;

            myDelta = -myDelta;

        }

        if (myDelta > 0)

            myLayer = 0;

        else

            myLayer = 3;

        SpriteUtils_SetSpriteData(mySpriteData, &myIconLocation, NULL, &myLayer, NULL, NULL, NULL, NULL);

        SpriteUtils_AddSpriteToSample(mySample, mySpriteData, kIconSpriteAtomID);

        SpriteUtils_AddSpriteSampleToMedia(theMedia, mySample, kSpriteMediaFrameDurationSpace, false, NULL);    

    }

bail:   

    if (mySample != NULL)

        QTDisposeAtomContainer(mySample);

    if (mySpriteData != NULL)

        QTDisposeAtomContainer(mySpriteData);   

}

//////////

//

// QTSprites_SetTrackProperties

// Set the track properties for the specified sample sprite movie.

//

//////////

void QTSprites_SetTrackProperties (Media theMedia, UInt16 theMenuItem)

{

    QTAtomContainer     myTrackProperties;

    RGBColor            myBackgroundColor;

    OSErr               myErr = noErr;

    if (!gUseBackgroundPicture) {

        // add a background color to the sprite track

        QTSprites_GetBackgroundColor(theMenuItem, &myBackgroundColor);

        myErr = QTNewAtomContainer(&myTrackProperties);

        if (myErr == noErr) {

            QTInsertChild(myTrackProperties, 0, kSpriteTrackPropertyBackgroundColor, 1, 1, sizeof(RGBColor), &myBackgroundColor, NULL);

            SetMediaPropertyAtom(theMedia, myTrackProperties);

            QTDisposeAtomContainer(myTrackProperties);

        }

    }

}

//////////

//

// QTSprites_HitTestSprites

// Determine whether a mouse click is on a sprite; return true if it is, false otherwise.

//

// This routine is intended to be called from your movie controller action filter function,

// in response to mcActionMouseDown actions.

//

//////////

Boolean QTSprites_HitTestSprites (WindowObject theWindowObject, EventRecord *theEvent)

{

    ApplicationDataHdl      myAppData = NULL;

    MediaHandler            myHandler = NULL;

    Boolean                 isHandled = false;

    long                    myFlags = 0L;

    QTAtomID                myAtomID = 0;

    Point                   myPoint;

    ComponentResult         myErr = noErr;

    myAppData = (ApplicationDataHdl)QTFrame_GetAppDataFromWindowObject(theWindowObject);

    if (myAppData == NULL)

        goto bail;

    if (theEvent == NULL)

        goto bail;

    // make sure that the click is in the frontmost window

    if ((**theWindowObject).fWindow != QTFrame_GetFrontMovieWindow())

        goto bail;

    myHandler = (**myAppData).fSpriteHandler;

    myFlags = spriteHitTestImage | spriteHitTestLocInDisplayCoordinates | spriteHitTestInvisibleSprites;

    myPoint = theEvent->where;

    myErr = SpriteMediaHitTestAllSprites(myHandler, myFlags, myPoint, &myAtomID);

    if ((myErr == noErr) && (myAtomID != 0)) {

        Boolean             isVisible;

        // the user has clicked on a sprite;

        // for now, we'll just toggle the visibility state of the sprite

        SpriteMediaGetSpriteProperty(myHandler, myAtomID, kSpritePropertyVisible, (void *)&isVisible);

        SpriteMediaSetSpriteProperty(myHandler, myAtomID, kSpritePropertyVisible, (void *)!isVisible);

        isHandled = true;

    }

bail:

    return(isHandled);

}