CAUGui.h

Go to the documentation of this file.

/*
 *  CAUGui.h
 *  CoreGraphics AudioUnit GUI framework
 *
 *  Created by Urs Heckmann on Sat Oct 19 2002.
 *  Copyright (c) 2002 __MyCompanyName__. All rights reserved.
 *
 */


/**********************************************************************************

    usage:
    
        
**********************************************************************************/



#ifndef __COREGRAPHICS_AUDIOUNIT_GUI__
#define __COREGRAPHICS_AUDIOUNIT_GUI__




#include <Carbon/Carbon.h>
#include "AUCarbonViewBase.h"
#include "AUCarbonViewControl.h"

#include "CAUGuiConfig.h"

#ifndef __CAUGUI_TOOLS__
#include "CAUGuiTools.h"
#endif

#ifndef __CAUGUI_CONTROL__
#include "CAUGuiControl.h"
#endif



typedef enum
{
    kCAUGui_res_0   =   0,      
    kCAUGui_res_1   =   1,      
    kCAUGui_res_10  =   10,     
    kCAUGui_res_100 =   100,    
    kCAUGui_res_50  =   50      
} CAUGuiResolution;


extern "C" static pascal OSStatus CAUGuiControlHandler ( EventHandlerCallRef, EventRef, void*  );

extern "C" static void TimerProc ( EventLoopTimerRef inTimer, void *inUserData );

class CAUGuiCtrl;


/***********************************************************************

    CAUGuiMan
    
    CoreGraphics AudioUnit Graphical User Interface Manager
    -            -    -    -         -    -         ---
    
    the manager class that does all the admin for you

***********************************************************************/

class CAUGuiMan
{
public:
    
    CAUGuiMan (AUCarbonViewBase*, UInt32 x, UInt32 y );
    
    ~CAUGuiMan();
    
    void        initialize();

    // Images
    
    void                    addImage ( CAUGuiGraphic* theImage );
    
    CAUGuiGraphic*          getImageByID ( UInt32 theID );

    // Controls
    
    void                    addCtrl( CAUGuiCtrl* theCtrl );
    
    CAUGuiCtrl*             getCtrlByID( UInt32 theID );
    
    CAUGuiCtrl*             getCtrlByControlRef ( ControlRef theControl );
    
    CAUGuiCtrl*             getControls (){ return Controls; }
    
    // Relaxed drawing occurs when User adjusts parameters.
    
    void                    setRelaxed ( bool r ) { relaxed = r; }
    
    bool                    isRelaxed ( void ) { return relaxed; }
    
    AUCarbonViewBase*       getAUCarbonViewBase() { return myAUCarbonViewBase; }
    
    void                    requestInternalParameters(); // Fetch internal Parameters from AU
    
    float                   getInternalParameter ( int index );

    void                    idle();

    UInt32                  requestID ( void );
    
    UInt32                  X;
    UInt32                  Y;

private:

    UInt32                  itemCount;

    CAUGuiGraphic*          Images;
    CAUGuiCtrl*             Controls;
    
    bool                    relaxed;
    
    EventLoopTimerRef       timer;
    
    AUCarbonViewBase*       myAUCarbonViewBase;
    
    
    ControlDefSpec          ControlSpec;
    ToolboxObjectClassRef   ControlClass;
    char                    defString[ 64 ];
    
    
    // Mirrors the internal Parameters of the AudioUnit class
    
    float*                  internalParameters;
    

};



/***********************************************************************

    CAUGuiCtrl
    
    base class for all control objects

***********************************************************************/

class CAUGuiCtrl : public CAUGuiItem
{
public:

    // Parameter driven control
    
    CAUGuiCtrl ( CAUGuiMan* theCAUGuiMan, CAAUParameter& theAUVP, eRect* bounds, CAUGuiResolution resolution );
    
    // Control with no actual parameter attached
    
    CAUGuiCtrl ( CAUGuiMan* theCAUGuiMan, eRect* bounds, UInt32 Range );
    
    CAUGuiCtrl ( CAUGuiMan* theCAUGuiMan, eRect* bounds );
    
    virtual ~CAUGuiCtrl();
    
    void setDefaults(); 
        
    // ControlRefs will be implemented by Manager Class
    
    virtual void        setCarbonControl(ControlRef theCarbonControl) {carbonControl = theCarbonControl;}
    
    virtual ControlRef  getCarbonControl() { return carbonControl; }
    
    // Called by EventHandler Callback, draws a clipping region if opaque == true
    // otherwise asks embedded CAUGuiControls for their clipping regions
    
    virtual void    clip ( bool drawing );
    
    virtual void    setVisible ( bool viz );
    
    // The methods you should implement in derived controls
    
    virtual void    draw(CGContextRef context, UInt32 portHeight) {};
    
    virtual void    mouseDown(Point *P, bool with_option, bool with_shift) {};  // P is relative to controlBounds, so no hassle
    
    virtual void    mouseTrack(Point *P, bool with_option, bool with_shift) {};
    
    virtual void    mouseUp(Point *P, bool with_option, bool with_shift) {};
    
    virtual void    mouseRight(Point *P) {};
    
    // NEW this is called when you [CMD]-click the control. It resets the value to its default
    
    virtual void    setDefault(); 
    
    // Timer driven function.
    // If you derive this, always call this superclass CAUGuiCtrl::idle()
    
    virtual void    idle();
    
    virtual bool    isControlRef ( ControlRef theControl );
    
    // if you do not want parameter attached controls
    
    virtual bool    providesForeignControls () { return false; }
    
    virtual void    initForeignControls (ControlDefSpec &ControlSpec) {};
    
    virtual bool    isAUVPattached() { return AUVPattached; }
    
    // called by CAUGuiMan 
    
    virtual void    embedCAUGuiCtrl() {};
    
    virtual void    addCtrl( CAUGuiCtrl* theCtrl );
    
    // for the clipping region
    
    bool    getOpaque() { return opaque; }
    
    void    setOpaque(bool o) { opaque = o; }
    
    // accessor functions to be called by derived controls
    
    virtual void                getBounds ( Rect* r ) { where.to ( r ); }
    
    virtual void                getForeBounds ( Rect* r ) { vizArea.to ( r ); }
    
    virtual CAUGuiResolution    getResolution () { return Resolution; }
    
    virtual CAAUParameter&      getAUVP() { return auvp; }
    
    virtual float               getRange() { return Range; }
    
    virtual eRect*              getBounds() { return &where; }
    
    virtual eRect*              getForeBounds() { return &vizArea; }
    
    virtual CAUGuiMan*          getCAUGuiMan() { return Chief; }
    
    virtual CAUGuiCtrl*         getDaddy() { return Daddy; }
    
    virtual CAUGuiCtrl*         getChild(ControlRef theControl);
    
    virtual void                setDaddy( CAUGuiCtrl* theDaddy ) { this->Daddy = theDaddy; }
    
    virtual void                setOffset ( SInt32 x, SInt32 y );
    
    virtual void                setBounds ( eRect* r ) { where.set ( r ); }
    
    virtual void                setForeBounds ( eRect* r ) { vizArea.set ( r ); }
    
    virtual void                setForeBounds ( SInt32 x, SInt32 y, SInt32 w, SInt32 h );
    
    virtual void                shrinkForeBounds ( SInt32 x, SInt32 y, SInt32 w, SInt32 h );
    
    virtual void                setLastUpdated ( SInt32 v ) { lastUpdatedValue = v; }
    
    virtual SInt32              getLastUpdated (void ) { return lastUpdatedValue; }
    
    virtual void                setTolerance ( SInt32 t ) { tolerance = t; }
    
    virtual bool                mustUpdate ( void );
    
    virtual bool                wantsTracking ( void ) { return wantsTrackingFlag;}
    
    
    virtual void                setColour ( float r, float g, float b, float a )
                                {
                                    col_red = r;
                                    col_green = g;
                                    col_blue = b;
                                    col_alpha = a;
                                }
    
    virtual void                setFont ( char *theFont ) { strcpy ( font_name, theFont ); }
    
    virtual void                setTextAlign ( int a ) { textalign = a; }
    
    

    
    
    
protected:

    CAUGuiMan*          Chief;
    CAAUParameter       auvp;
    CAUGuiCtrl*         Daddy;
    CAUGuiCtrl*         children;
    UInt32              id;
    CAUGuiResolution    Resolution;
    float               Range;          //
    
    bool                AUVPattached;
    
    bool                opaque;         // is it a drawing control or just a virtual region?
    
    ControlRef          carbonControl;  // the physical control, if any
    eRect               where;          // the bounds...
    eRect               vizArea;        // where the foreground displays
    
    SInt32              lastUpdatedValue;
    SInt32              tolerance;
    bool                becameVisible;  // mustUpdate after setVisible(true)
    
    bool                wantsTrackingFlag;
    
    float               col_red;
    float               col_green;
    float               col_blue;
    float               col_alpha;
    
    float               font_size;
    int                 textalign;
    char                font_name[ 32 ];

};







#endif

(c) 2002 - 2003 by Urs Heckmann www.u-he.com