QuickTime 2.0 Developer Kit/QuickTime 2.0 Developer Kit.iso/mac/MAC/Programming Stuff/Sample Code/Sequence Grabber/Example Video Panel/ExampleVideoPanel.c

Text File | 1993-06-23 | 16.5 KB | 662 lines | [TEXT/KAHL]

/*
    File:        ExampleVideoPanel.c

    Contains:    Example video panel component routines.

    Written by:    Gary Woodcock

    Copyright:    © 1992 by Apple Computer, Inc., all rights reserved.

    Change History (most recent first):

*/

//-----------------------------------------------------------------------
// includes

#include "ExampleVideoPanelPrivate.h"
#include <QuickTimeComponents.h>
#include <Errors.h>
#include <Resources.h>
#include <SysEqu.h>

//-----------------------------------------------------------------------

#ifdef DEBUG_IT

// Use this declaration when we're running linked (for debugging)
pascal ComponentResult
ExampleVideoPanelDispatcher (ComponentParameters *params, Handle storage)

#else

// Use this declaration when we're a standalone component
pascal ComponentResult
main (ComponentParameters *params, Handle storage)

#endif DEBUG_IT

{
    // This routine is the main dispatcher for the component

    ComponentResult        result = noErr;
    ComponentFunction    exampleFunction = nil;

    // Did we get a Component Manager request code (< 0)?
    if (params->what < 0)
    {
        switch (params->what)
        {
            case kComponentOpenSelect:            // Open request
            {
                exampleFunction = _ExampleVideoPanelOpen;
                break;
            }
            case kComponentCloseSelect:            // Close request
            {
                exampleFunction = _ExampleVideoPanelClose;
                break;
            }
            case kComponentCanDoSelect:            // Can Do request
            {
                result = CallComponentFunction (params,
                    (ComponentFunction) _ExampleVideoPanelCanDo);
                break;
            }
            case kComponentVersionSelect:        // Version request
            {
                result = CallComponentFunction (params,
                    (ComponentFunction) _ExampleVideoPanelVersion);
                break;
            }
            case kComponentTargetSelect:        // Target request not supported
            case kComponentRegisterSelect:        // Register request not supported
            default:                            // Unknown request
            {
                result = badComponentSelector;
                break;
            }
        }
    }
    else    // Was it one of our request codes?
    {
        switch (params->what)
        {
            case kSGCPanelGetDitlSelect:        // SGPanelGetDitl request
            {
                exampleFunction = _ExampleVideoPanelGetDitl;
                break;
            }
            case kSGCPanelGetTitleSelect:        // SGPanelGetTitle request
            {
                exampleFunction = _ExampleVideoPanelGetTitle;
                break;
            }
            case kSGCPanelCanRunSelect:            // SGPanelCanRun request
            {
                exampleFunction = _ExampleVideoPanelCanRun;
                break;
            }
            case kSGCPanelInstallSelect:        // SGPanelInstall request
            {
                exampleFunction = _ExampleVideoPanelInstall;
                break;
            }
            case kSGCPanelEventSelect:            // SGPanelEvent request
            {
                exampleFunction = _ExampleVideoPanelEvent;
                break;
            }
            case kSGCPanelItemSelect:            // SGPanelItem request
            {
                exampleFunction = _ExampleVideoPanelItem;
                break;
            }
            case kSGCPanelRemoveSelect:            // SGPanelRemove request
            {
                exampleFunction = _ExampleVideoPanelRemove;
                break;
            }
            case kSGCPanelSetGrabberSelect:        // SGPanelSetGrabber request
            {
                exampleFunction = _ExampleVideoPanelSetGrabber;
                break;
            }
            case kSGCPanelSetResFileSelect:        // SGPanelSetResFile request
            {
                exampleFunction = _ExampleVideoPanelSetResFile;
                break;
            }
            case kSGCPanelGetSettingsSelect:    // SGPanelGetSettings request
            {
                exampleFunction = _ExampleVideoPanelGetSettings;
                break;
            }
            case kSGCPanelSetSettingsSelect:    // SGPanelSetSettings request
            {
                exampleFunction = _ExampleVideoPanelSetSettings;
                break;
            }
            default:                            // Unknown request
            {
                result = badComponentSelector;
                break;
            }
        }
    }
    if (exampleFunction != nil)
    {
        result = CallComponentFunctionWithStorage (storage, params, exampleFunction);
    }
    return (result);
}

//-----------------------------------------------------------------------

pascal ComponentResult
_ExampleVideoPanelOpen (Handle storage, ComponentInstance self)
{
    #pragma    unused (storage)

    PanelGlobalsHdl    globals;
    ComponentResult    result = noErr;

    #ifdef THINK_C
        SetComponentInstanceA5 (self, *(long *) CurrentA5);
    #endif THINK_C

    // Can we open another instance?
    if (CountComponentInstances ((Component) self) <= kMaxExampleVideoPanelInstances)
    {
        // Did we get our storage?
        globals = (PanelGlobalsHdl) NewHandleClear (sizeof (PanelGlobals));
        if (globals != nil)
        {
            // Keep a reference to self
            (**globals).self = (Component) self;

            // Set storage ref
            SetComponentInstanceStorage (self, (Handle) globals);
        }
        else    // NewHandleClear failed
        {
            result = MemError();
        }
    }
    else    // No more instances can be opened
    {
        result = kGenericError;
    }
    return (result);
}

//-----------------------------------------------------------------------

pascal ComponentResult
_ExampleVideoPanelClose (Handle storage, ComponentInstance self)
{
    PanelGlobalsHdl    globals = (PanelGlobalsHdl) storage;
    ComponentResult    result = noErr;

    // Do we have any clean up to do?
    if (globals != nil)
    {
        // Dispose globals
        DisposHandle ((Handle) globals);
    }
    return (result);
}

//-----------------------------------------------------------------------

pascal ComponentResult
_ExampleVideoPanelCanDo (short selector)
{
    // Case on the request code
    switch (selector)
    {
        // Component Manager request codes
        case kComponentOpenSelect:
        case kComponentCloseSelect:
        case kComponentCanDoSelect:
        case kComponentVersionSelect:

        // Sequence grabber panel component request codes
        case kSGCPanelGetDitlSelect:
        case kSGCPanelGetTitleSelect:
        case kSGCPanelCanRunSelect:
        case kSGCPanelInstallSelect:
        case kSGCPanelEventSelect:
        case kSGCPanelItemSelect:
        case kSGCPanelRemoveSelect:
        case kSGCPanelSetGrabberSelect:
        case kSGCPanelSetResFileSelect:
        case kSGCPanelGetSettingsSelect:
        case kSGCPanelSetSettingsSelect:
        {
            return (true);
        }

        // Unsupported or unknown request codes
        case kComponentRegisterSelect:    // Register request not supported
        case kComponentTargetSelect:    // Target request not supported
        default:                        // Not a request code we recognize
        {
            return (false);
        }
    }
}

//-----------------------------------------------------------------------

pascal ComponentResult
_ExampleVideoPanelVersion (void)
{
    // Return the version info
    return (exampleVideoPanelInterfaceRevision);
}

//-----------------------------------------------------------------------

pascal ComponentResult
_ExampleVideoPanelGetDitl (Handle storage, Handle *ditl)
{
    // This routine gets our ditl and hands it back to the sequence grabber

    #pragma unused (storage)

    ComponentResult    result = noErr;
    Handle            panelDITL = GetResource ('DITL', kExampleVideoPanelDITLID);

    // Did we get the DITL resource okay?
    result = ResError();
    if (panelDITL != nil)
    {
        // Detach it
        DetachResource (panelDITL);
    }
    *ditl = panelDITL;

    return (result);
}

//-----------------------------------------------------------------------

pascal ComponentResult
_ExampleVideoPanelGetTitle (Handle storage, Str255 title)
{
    #pragma unused (storage)
    #pragma unused (title)

    // Nothing to do here right now
    return (paramErr);
}

//-----------------------------------------------------------------------

pascal ComponentResult
_ExampleVideoPanelCanRun (Handle storage, SGChannel c)
{
    #pragma unused (storage)
    #pragma unused (c)

    // Our 'thng' resource has the channelFlagHasDependency flag set,
    // which means that this routine gets called to find out if
    // it can run in the current environment.  This usually means
    // finding out if the panel is compatible with the currently
    // selected digitizer.  This is handy for adding manufacturer
    // specific panels to the settings dialog.  We don't do anything
    // here except SysBeep just to show we actually get called.
    SysBeep(5);

    return (noErr);
}

//-----------------------------------------------------------------------

pascal ComponentResult
_ExampleVideoPanelInstall (Handle storage, SGChannel c, DialogPtr d,
    short itemOffset)
{
    // Do our setup in this routine

    #pragma unused (d)
    #pragma unused (itemOffset)

    PanelGlobalsHdl    globals = (PanelGlobalsHdl) storage;
    ComponentResult    result = noErr;

    // Get our gray pattern
    *(long *)((**globals).grayPat) = *(long *)((**globals).grayPat + 4) = 0x55AA55AA;

    // Get current black level
    result = VDGetBlackLevelValue (SGGetVideoDigitizerComponent (c), &((**globals).savedBlackLevel));
    if (result != noErr)
    {
        // Can't get the black level, so we can't do zero black level
        HiliteControl ((ControlHandle) GetItemHandle (d, itemOffset + kZeroBlackButton), 255);
    }

    return (noErr);
}

//-----------------------------------------------------------------------

pascal ComponentResult
_ExampleVideoPanelEvent (Handle storage, SGChannel c, DialogPtr d,
    short itemOffset, EventRecord *theEvent, short *itemHit, Boolean *handled)
{
    // This routine is quite similar to a normal event filter proc.

    PanelGlobalsHdl    globals = (PanelGlobalsHdl) storage;
    ComponentResult    result = noErr;
    GrafPtr            savedPort;
    PenState        savedPen;

    // Set up the port stuff
    GetPort (&savedPort);
    SetPort (d);
    GetPenState (&savedPen);

    // Assume we don't handle it
    *handled = false;

    // Look for a key hit
    if ((theEvent->what == keyDown) || (theEvent->what == autoKey))
    {
        char    theChar = theEvent->message & charCodeMask;
        char    theKeyCode = ((theEvent->message & keyCodeMask) >> 8);
        Boolean    cmdKeyDown = ((theEvent->modifiers & cmdKey) != 0) ? true : false;

        if (cmdKeyDown && (theKeyCode == kDKey))
        {
            unsigned short    maxBlackLevel = 0;

            // Fake a "Do it" button hit
            FakeDialogButtonHit (d, itemOffset + kZeroBlackButton);
            result = VDSetBlackLevelValue (SGGetVideoDigitizerComponent (c), &maxBlackLevel);
            *itemHit = itemOffset + kZeroBlackButton;
            *handled = true;
        }
        else if (cmdKeyDown && (theKeyCode == kRKey))
        {
            // Fake a "Reset" button hit
            FakeDialogButtonHit (d, itemOffset + kResetButton);
            result = VDSetBlackLevelValue (SGGetVideoDigitizerComponent (c), &((**globals).savedBlackLevel));
            *itemHit = itemOffset + kResetButton;
            *handled = true;
        }
    }
    else if (theEvent->what == updateEvt)
    {
        Rect    r;

        // Draw the separator line whenever we get an update cuz I'm lazy
        GetItemBox (d, itemOffset + kSeparator, &r);
        PenPat ((**globals).grayPat);
        FrameRect (&r);
    }

    // Restore stuff
    SetPenState (&savedPen);
    SetPort (savedPort);

    return (result);
}

//-----------------------------------------------------------------------

pascal ComponentResult
_ExampleVideoPanelItem (Handle storage, SGChannel c, DialogPtr d,
    short itemOffset, short itemNum)
{
    #pragma unused (d)

    PanelGlobalsHdl    globals = (PanelGlobalsHdl) storage;
    ComponentResult    result = noErr;
    short            theItem = itemNum - itemOffset;    // Remember to account for the item offset

    // What item got hit?
    switch (theItem)
    {
        case kZeroBlackButton:
        {
            unsigned short    maxBlackLevel = 0;

            result = VDSetBlackLevelValue (SGGetVideoDigitizerComponent (c), &maxBlackLevel);
            break;
        }
        case kResetButton:
        {
            result = VDSetBlackLevelValue (SGGetVideoDigitizerComponent (c), &((**globals).savedBlackLevel));
            break;
        }
        default:
        {
            break;
        }
    }
    return (result);
}

//-----------------------------------------------------------------------

pascal ComponentResult
_ExampleVideoPanelRemove (Handle storage, SGChannel c, DialogPtr d,
    short itemOffset)
{
    #pragma unused (storage)
    #pragma unused (c)
    #pragma unused (d)
    #pragma unused (itemOffset)

    // This is where you do your panel related cleanup.  Note that
    // this is different from the cleanup you do in your close component
    // routine.  Basically, this gets called when your ditl is getting
    // removed from the dialog and a new one is being added (like when
    // someone chooses a different panel from the panel popup menu).
    // Examples of stuff you might do here include getting rid of any
    // custom controls or popup menus, or saving panel settings.

    return (noErr);
}

//-----------------------------------------------------------------------

pascal ComponentResult
_ExampleVideoPanelSetGrabber (Handle storage, SeqGrabComponent sg)
{
    PanelGlobalsHdl    globals = (PanelGlobalsHdl) storage;

    // Save our grabber
    (**globals).seqGrabber = sg;

    return (noErr);
}

//-----------------------------------------------------------------------

pascal ComponentResult
_ExampleVideoPanelSetResFile (Handle storage, short resRef)
{
    PanelGlobalsHdl    globals = (PanelGlobalsHdl) storage;

    // Since we don't have the channelFlagDontOpenResFile flag
    // set in our 'thng' resource, the sequence grabber will
    // open our resource file for us.

    // Save our resfile ref
    (**globals).resRefNum = resRef;

    return (noErr);
}

//-----------------------------------------------------------------------

pascal ComponentResult
_ExampleVideoPanelGetSettings (Handle storage, SGChannel c, UserData *ud, long flags)
{
    #pragma unused (c)
    #pragma unused (flags)

    ComponentResult    result = noErr;
    UserData        userStuff = 0L;

    // You HAVE to give something valid back as user data when you
    // return from this routine or your panel will fail to install.
    // What is being asked for basically amounts to a handle to some
    // state info specific to your panel.  We don't really have any
    // state info we care about, so we just hand back an empty user
    // data just to keep everyone happy.

    if ((result = NewUserData (&userStuff)) == noErr)
    {
        *ud = userStuff;
    }
    return (result);
}

//-----------------------------------------------------------------------

pascal ComponentResult
_ExampleVideoPanelSetSettings (Handle storage, SGChannel c, UserData ud, long flags)
{
    #pragma unused (storage)
    #pragma unused (c)
    #pragma unused (ud)
    #pragma unused (flags)

    // Here is where you would decode your user data structure and use
    // the info to set the state of your panel items.  Again, we don't
    // really have anything that has any meaningful state in our panel,
    // so we ignore this.

    return (noErr);
}

//-----------------------------------------------------------------------

pascal ComponentResult
_ExampleVideoPanelValidateInput (Handle storage, Boolean *ok)
{
    #pragma unused (storage)

    // This is where you do a sanity check on the user-definable
    // items in your panel.  If there are any bad values, you
    // should alert the user somehow, and return false for *ok.
    // If everything's fine, return true.  We don't really have
    // anything to check on in our example, so we return true
    // all the time.

    *ok = true;
    return (noErr);
}

//-----------------------------------------------------------------------

static OSErr
FakeButtonHit (ControlHandle theButton)
{
    OSErr    result = noErr;

    if (theButton != nil)
    {
        long    dummyTicks = 0L;

        HiliteControl (theButton, inButton);
        Delay (8, &dummyTicks);
        HiliteControl (theButton, 0);
    }
    else
    {
        result = nilHandleErr;
    }
    return (result);
}

//-----------------------------------------------------------------------

static OSErr
FakeDialogButtonHit (DialogPtr theDialog, short theButtonItem)
{
    OSErr    result = noErr;

    if (theDialog != nil)
    {
        result = FakeButtonHit ((ControlHandle) GetItemHandle (theDialog, theButtonItem));
    }
    else
    {
        result = nilHandleErr;
    }
    return (result);
}

//-----------------------------------------------------------------------

static void
SetUserItem (DialogPtr theDialog, short theItem, Handle userProc)
{
    Handle    item;
    Rect    box;
    short    itemType;

    GetDItem (theDialog, theItem, &itemType, &item, &box);
    SetDItem (theDialog, theItem, itemType, userProc, &box);
}

//-----------------------------------------------------------------------

static Handle
GetItemHandle (DialogPtr theDialog, short theItem)
{
    Handle    item;
    Rect    box;
    short    itemType;

    GetDItem (theDialog, theItem, &itemType, &item, &box);
    return (item);
}

//-----------------------------------------------------------------------

static void
GetItemBox (DialogPtr theDialog, short theItem, Rect *theRect)
{
    Handle    item;
    short    itemType;

    GetDItem (theDialog, theItem, &itemType, &item, theRect);
}

//-----------------------------------------------------------------------

#ifdef THINK_C
#ifdef DEBUG_IT
void
RegisterExampleVideoPanel (void);

void
RegisterExampleVideoPanel (void)
{
    ComponentDescription foo;
    Handle h;

      foo.componentType = SeqGrabPanelType;
      foo.componentSubType = 'vide';
      foo.componentManufacturer = 'xmpl';
      foo.componentFlags = channelFlagHasDependency | channelFlagDontOpenResFile;    // Indicate that we want a can run message
      foo.componentFlagsMask = 0L;

    PtrToHand ("\pExample (linked)", &h, 17);
    RegisterComponent (&foo, (void *)ExampleVideoPanelDispatcher, 0, h, 0, 0);
    DisposHandle (h);
}
#endif DEBUG_IT
#endif THINK_C

//-----------------------------------------------------------------------