UI/UI_Value.h

Go to the documentation of this file.

#ifndef __UI_Value__
#define __UI_Value__

#include "UI_API.h"
#include <iostream.h>
#include <SYS/SYS_Types.h>
#include <UT/UT_Pointers.h>
#include "UI_Object.h"

/*
 *  A UI_Value is a utility class which maintains a single value of
 *  variable type and provides conversions between types.
 */

enum UI_ValueType {
    UI_VALUE_FLOAT,
    UI_VALUE_INTEGER,
    UI_VALUE_STRING,
    UI_VALUE_FLOAT_ARRAY,
    UI_VALUE_INT_ARRAY,
    UI_VALUE_STRING_ARRAY,
    UI_VALUE_POINTER
};

enum UI_Reason {
    UI_NO_REASON,
    UI_VALUE_CHANGED,
    UI_VALUE_ACTIVE,
    UI_VALUE_START,
    UI_VALUE_NEW,
    UI_VALUE_RANGE_CHANGED,
    UI_VALUE_PICKED,
    UI_VALUE_LOCATED,
    UI_VALUE_ITEMS_CHANGED
};

#define UI_STEP_BIG     4

enum UI_StepType {
    UI_STEP_INCREMENT = 1,
    UI_STEP_DECREMENT = 2,
    UI_STEP_INCREMENT_BIG = (UI_STEP_INCREMENT | UI_STEP_BIG),
    UI_STEP_DECREMENT_BIG = (UI_STEP_DECREMENT | UI_STEP_BIG)
};

class UI_Event;
class UT_Color;
class UT_String;
class UT_IStream;

//====================================================================

class UI_API UI_Value : public UI_Object
{
public:
    UI_Value();
    UI_Value(int   i);
    UI_Value(fpreal32 f);
    UI_Value(fpreal64 f);
    UI_Value(float fp[], int n);
    UI_Value(int   ip[], int n);
    UI_Value(char *ssp[], int n);
    UI_Value(const char *s);
    UI_Value(const UI_Value &v);
    UI_Value(void *p);

    virtual ~UI_Value();

            void setValue(long  l) { setValue((int)l); }
    virtual void setValue(int   i);
    virtual void setValue(fpreal32 f);
    virtual void setValue(fpreal64 f);
    virtual void setValue(fpreal32 f, int n);
    virtual void setValue(fpreal64 f, int n);
    virtual void setValue(int   i, int n);
    virtual void setValue(const char *s, int n);
    virtual void setValue(const float fp[], int n);
    virtual void setValue(const int   ip[], int n);
    virtual void setValue(const char *const ssp[], int n);
    virtual void setValue(const char *s);
    virtual void setValue(const UI_Value &v);
    virtual void setValue(void *pointer);

            void setValue(const UT_Color &c);
            void stringPrintf(const char *fmt, ...);

    virtual void changed(UI_Object      *by,
                         UI_Reason       reason = UI_VALUE_CHANGED,
                         UI_DeviceEvent *state = 0);
//
//  This method is similar to "changed" but it triggers the callback events
//  immediately (bypassing the event queue). It also only notifies the
//  objects that have added interests in this value. Not the immediate
//  dependents. **This should only be used in special circumstances.**
//
    void triggerImmediate(UI_Object      *by,
                          UI_Reason       reason = UI_VALUE_CHANGED,
                          UI_DeviceEvent *state = 0);

    virtual void enable(int state); // Sends enable event to dependents
    virtual void override(int state, int);// Sends override event to dependents
    virtual void   open(int state);     // Sends open/close event to dependents
    virtual void refresh();             // Sends redraw in place events

    // This ugly hack attempts to determine the open state of UI_Feel clients
    // which are open. It returns true only if *any* of them are open.
    bool         areAnyFeelClientsOpen();

    virtual void handleEvent(UI_Event *event);
    virtual void deleteReferences(UI_Object *to_whom);

    virtual void setSteps(float mysmall, float large);
    virtual void setRange(float  min,  float  max);
    virtual void getRange(float *min,  float *max) const;

    virtual void rangeCheck();
    virtual int  step(UI_StepType how);

    int         save(ostream &os) const;
    bool        load(UT_IStream &is);

    void setFormat(const char *fmt) { myFormat = fmt; }
    const char *getFormat() const { return myFormat; }

    void getValue(int   *ip) const;
    void getValue(float *fp) const;
    void getValue(char  *&s) const;             // does s = new char[n]
    void getValue(float *fp, int n) const;
    void getValue(int   *ip, int n) const;
    void getValue(char  **ssp, int n) const;    // does new char[] in ssp[i]
    void getValue(char  *sp, int bufsize) const;
    void getValue(char  *sp, int bufsize, const char *format) const;
    void getValue(UT_String &value) const;
    void getValue(UI_Value &v) const;
    void getValue(void **pp) const;

    int  getArrayLength() const;

    UI_ValueType getType() const { return type; }
    virtual int  isVector() const { return 0; }

    void    addInterest(UI_Object *client, UI_EventMethod method,
                        bool check_dup = false);
    void    addPriorityInterest(UI_Object *client, UI_EventMethod method,
                                bool check_dup = false);
    bool    hasInterest(UI_Object *in, UI_EventMethod method);
    bool    hasInterest(UI_Object *obj);
    void removeInterest(UI_Object *in, UI_EventMethod method);
    void removeInterest(UI_Object *client);
    void removeAllInterests();

//
//  Note: setString sets the char * value whereas setValue(char *) does
//        a strdup. (ie UI_Value will own the string you set with setString)
//
    const char  *getString() const;     // Short cuts for string manipulation.
    void         setString(char *sp);
    char        *stealString();         // Take the string away from the value.
    void         expandEnvironment();
    void         expandTilde();

    operator const char *() const;
    operator       int   () const;
    operator       bool  () const;
    operator       long  () const;
    operator       float () const;
    operator       void *() const;

    void operator       =(int   i)              { setValue(i); }
    void operator       =(long  l)              { setValue(l); }
    void operator       =(fpreal32 f)           { setValue(f); }
    void operator       =(fpreal64 f)           { setValue(f); }
    void operator       =(const char *s)        { setValue(s); }
    void operator       =(const UI_Value &v)    { setValue(v); }
    void operator       =(void *p)              { setValue(p); }
    void operator       =(const UT_Color &c)    { setValue(c); }

    void operator       +=(const UI_Value &v);
    void operator       +=(const char *string);

    int  operator       ==(const UI_Value &v) const;
    int  operator       ==(const float fp[]) const;
    int  operator       ==(const int   ip[]) const;
    int  operator       ==(const char *ssp[]) const;
    int  operator       ==(float f) const;
    int  operator       ==(int   i) const;
    int  operator       ==(const char *s) const;
    int  operator       ==(void *p) const;

    float & operator    [](float index);
    int   & operator    [](int index);

    virtual const char  *className() const;

    // Return the number of interests expressed in this value
    unsigned int         getNumInterested() const;
    UI_Object           *getInterest(int index) const; 


    // If a value is freezable, it cannot be updated while the UI is frozen.
    bool                 isFreezable() const { return myFreezeFlag; }
    virtual void         setFreezable(bool f) { myFreezeFlag = f; }
    
protected:
    union {
        int      i;
        float    f;
        float   *a;
        int     *j;
        char    *s;
        char    **ss;
        void    *p;
    } value;
    const char          *myFormat;
    UT_Pointers         *interests;
    UI_ValueType         type;
    bool                 myFreezeFlag;

private:
    void                 init();
    void                 zap();

    void                 addMyInterest(UI_Object *client,
                                       UI_EventMethod method,
                                       bool check_dup,
                                       bool priority);

    friend ostream      &operator<<(ostream &os, const UI_Value &v)
                        {
                            v.save(os);
                            return os;
                        }
};

#endif

---