CAUGuiTools.h

Go to the documentation of this file.

/*
 *  CAUGuiTools.h
 *  CoreGraphics AudioUnit GUI framework
 *
 *  Created by Urs Heckmann on Mon Oct 28 2002.
 *  Copyright (c) 2002 __MyCompanyName__. All rights reserved.
 *
 */

#ifndef __CAUGUI_TOOLS__
#define __CAUGUI_TOOLS__

#define kCAUGuiSchemeMaxPatterns 16


#include <Carbon/Carbon.h>

#include "CAUGuiConfig.h"

typedef enum
{
    kCAUGui_noType      =   0,
    kCAUGui_PNG         =   'cPNG',
    kCAUGui_RSRC        =   'cRSC',
    kCAUGui_Graphic     =   'cAgr',
    kCAUGui_SpinImage   =   'cAsi',
    kCAUGui_Pane        =   'cApn',
    kCAUGui_LayeredPane =   'cAlp',
    kCAUGui_Knob        =   'cAkb',
    kCAUGui_Slider      =   'cAsr',
    kCAUGui_Selector    =   'cAst',
    kCAUGui_Display     =   'cAdy',
    kCAUGui_Meter       =   'cAmt',
    kCAUGui_Label       =   'cAlb'


} CAUGuiType;

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

    eRect alignments
    
    a bit crappy in naming :-(
    
    may need to be altered :-)

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

typedef enum
{
    kNone       = 0,
    
    kVOutside   = 1,
    
    kNorth      = 2,
    kSouth      = 4,
    kMiddle     = 6,
    
    kHOutside   = 8,
    
    kWest       = 16,
    kEast       = 32,
    kCenter     = 48,
    
    
    k_NW        = kNorth    +   kWest,
    k_NC        = kNorth    +   kCenter,
    k_NE        = kNorth    +   kEast,
    k_ME        = kMiddle   +   kEast,
    k_SE        = kSouth    +   kEast,
    k_SC        = kSouth    +   kCenter,
    k_SW        = kSouth    +   kWest,
    k_MW        = kMiddle   +   kWest,
    
    // Vertically outside
    
    k_oNW       = kNorth    +   kWest   + kVOutside,
    k_oNC       = kNorth    +   kCenter + kVOutside,
    k_oNE       = kNorth    +   kEast   + kVOutside,
    k_oSE       = kSouth    +   kEast   + kVOutside,
    k_oSC       = kSouth    +   kCenter + kVOutside,
    k_oSW       = kSouth    +   kWest   + kVOutside,

    // Horizontally outside

    k_NWo       = kNorth    +   kWest   + kHOutside,
    k_NEo       = kNorth    +   kEast   + kHOutside,
    k_MEo       = kMiddle   +   kEast   + kHOutside,
    k_SEo       = kSouth    +   kEast   + kHOutside,
    k_SWo       = kSouth    +   kWest   + kHOutside,
    k_MWo       = kMiddle   +   kWest   + kHOutside,

    // Completely outside (with helpful redundancy)

    k_oNWo      = kNorth    +   kWest   + kVOutside + kVOutside,
    k_oNCo      = kNorth    +   kCenter + kVOutside + kVOutside,
    k_oNEo      = kNorth    +   kEast   + kVOutside + kVOutside,
    k_oMEo      = kMiddle   +   kEast   + kVOutside + kVOutside,
    k_oSEo      = kSouth    +   kEast   + kVOutside + kVOutside,
    k_oSCo      = kSouth    +   kCenter + kVOutside + kVOutside,
    k_oSWo      = kSouth    +   kWest   + kVOutside + kVOutside,
    k_oMWo      = kMiddle   +   kWest   + kVOutside + kVOutside,
    
    // Convenience matrix naming scheme
    
    k_v1        = kNorth + kVOutside,   
    k_v2        = kNorth,               
    k_v3        = kMiddle,              
    k_v4        = kSouth,               
    k_v5        = kSouth + kVOutside,   
    k_h1        = kWest + kHOutside,    
    k_h2        = kWest,                
    k_h3        = kCenter,              
    k_h4        = kEast,                
    k_h5        = kEast + kHOutside     
} CAUGuiAlign;



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

    eRect
    
    a Rect class with better properties for layout issues...
    
    (sorry for the naming, but I just couldn't resist :-)

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

class eRect
{
public:
    
    eRect () { x = y = w = h = 0; }
    
    eRect ( SInt32 a, SInt32 b, SInt32 c, SInt32 d ) { x = a; y = b; w = c; h = d; }
    
    void offset ( SInt32 a, SInt32 b ) { x += a; y += b; }
    
    void at ( SInt32 a, SInt32 b ) { x = a; y = b; }
    
    void size ( SInt32 c, SInt32 d ) { w = c; h = d; }
    
    void grow ( SInt32 a, SInt32 b ) { x -= a; y -= b; w += a*2; h += b*2; }
    
    void grow ( SInt32 a, SInt32 b, SInt32 c, SInt32 d) { x -= a; y -= b; w += a + c; h += b + d; }
    
    void align ( CAUGuiAlign align );
    
    void align ( eRect* r, CAUGuiAlign align );
    
    void set ( eRect* from ) { x = from->x; y = from->y; w = from->w; h = from->h; }
    
    void set ( SInt32 X, SInt32 Y, SInt32 W, SInt32 H ) { x = X; y = Y; w = W; h = H; }
    
    void to ( Rect* r ) { r->left = x; r->top = y; r->right = x + w; r->bottom = y + h; }
    
    void to ( CGRect* r, UInt32 winH )
    {
        r->origin.x = x;
        r->origin.y = winH - y - h;
        r->size.width = w;
        r->size.height = h;
    }

    SInt32  x;  
    SInt32  y;  
    SInt32  w;  
    SInt32  h;  
};


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

    CAUGuiItem
    
    base class for Items contained in linked lists

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

class CAUGuiItem
{
public:

    CAUGuiItem()
    {
        this->type  = kCAUGui_noType;
        this->id    = 0;
        this->prev  = NULL;
        this->next  = NULL;
        
        //printf ("ctor CAUGuiItem\n");
    }
    
    virtual ~CAUGuiItem()
    {
        //printf ("dtor CAUGuiItem %d\n", (int)id );
        if ( this->next != NULL ) delete ( next );
        
        //printf ("dtor CAUGuiItem\n");
    }
    
    CAUGuiItem* getByID ( UInt32 theID )
    {
        if ( id == theID ) return (this);
        
        if ( next == NULL ) return (NULL);
        else return (next->getByID ( theID ));
    }
    
    void append ( CAUGuiItem* nextItem )
    {
        if ( next == NULL )
        {
            next = nextItem;
            nextItem->setPrev( this );
        }
        else
            next->append( nextItem );
    }
    
    CAUGuiItem*     getNext ()                      { return ( next ); }
    CAUGuiItem*     getPrev ()                      { return ( prev ); }
    void            setPrev ( CAUGuiItem* thePrev ) { prev = thePrev; }
    UInt32          getID()                         { return id; }
    void            setID( UInt32 theID )           { id = theID; }
    CAUGuiType      getType()                       { return type; }
    void            setType( CAUGuiType theType)    { type = theType; }
    
private:
    CAUGuiType          type;
    UInt32              id;
    CAUGuiItem*         prev;
    CAUGuiItem*         next;

};

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

    CAUGuiImage
    
    class for loading and containing images

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

class CAUGuiImage : public CAUGuiItem
{
public: 
    CAUGuiImage ( char* pngFileName );
    
    virtual ~CAUGuiImage ()
    {
        if ( this->Image != NULL )
            CGImageRelease( this->Image );
        this->Image = NULL;
        
        //printf ("dtor CAUGuiGraphic\n");
    }

    virtual CGImageRef      getImage() { return Image; }
    
    virtual bool            isPNG ( char* pngFileName );
    virtual bool            isRSRC ( int res ) { return ( res == resourceID );}
    

private:
    
    void            loadImagePNG ( char* pngFileName );

    char            fileName[ 64 ];
    int             resourceID;

    CGImageRef      Image;

};



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

    CAUGuiGraphic
    
    class for loading and containing images

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

class CAUGuiGraphic : public CAUGuiItem
{
public: 
    
    CAUGuiGraphic ( char* pngFileName );
    
    CAUGuiGraphic ( char* pngFileName, UInt32 numFrames );
    
    virtual ~CAUGuiGraphic ()
    {
        if ( this->Image != NULL )
            CGImageRelease( this->Image );
        this->Image = NULL;
        
        //printf ("dtor CAUGuiGraphic\n");
    }

    // passive API (for controls that want to draw images by themselves)


    virtual bool            isAnim() { return ( Frames == 1 ? false : true ); }

    virtual CGImageRef      getImage() { return Image; }
    
    virtual SInt32          getFrames () { return (SInt32)Frames; }
    
    virtual SInt32          getWidth();
    
    virtual SInt32          getHeight();
    
    // active API (for more than images...)
    
    virtual void            draw( CGContextRef context, UInt32 portHeight, eRect* rect, float value );

private:
    
    void            loadImagePNG ( char* pngFileName );

    CGImageRef      Image;
    UInt32          Frames;
    SInt32          FrameHeight;

};


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

    CAUGuiLabel
    
    class for simple images inside panes

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

class CAUGuiLabel : public CAUGuiItem
{
public: 
    CAUGuiLabel ( CAUGuiGraphic* theGraphic, eRect* theBounds );
    
    virtual ~CAUGuiLabel ()
    {
        this->Graphic = NULL;
        
        //printf ("dtor CAUGuiGraphic\n");
    }
    
    virtual SInt32          getWidth() {return Graphic->getWidth();}
    
    virtual SInt32          getHeight() {return Graphic->getHeight();}
        
    virtual void            draw( CGContextRef context, UInt32 portHeight, eRect* rect, float value );

private:
    
    CAUGuiGraphic*  Graphic;
    
    eRect Bounds;
    
};





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

    CAUGuiScheme
    
    class for automatically layouting controls

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

class CAUGuiScheme
{
public:
    CAUGuiScheme ();

    void            add( eRect* r, CAUGuiAlign align );

    void            reset();
    
    void            at ( SInt32 x, SInt32 y );
    
    eRect*          get();
    eRect*          getS( SInt32 w, SInt32 h );


private:
    eRect           resulting;
    eRect           rects[ kCAUGuiSchemeMaxPatterns ];
    CAUGuiAlign     aligns[ kCAUGuiSchemeMaxPatterns ];
    UInt32          patternLength;
    UInt32          currentIteration;
    UInt32          currentPattern;
    bool            notAligned;
    SInt32          X;
    SInt32          Y;
    SInt32          startX;
    SInt32          startY;
    SInt32          offsetX;
    SInt32          offsetY;
    
};



#endif

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