llui.h

Go to the documentation of this file.

// All immediate-mode gl drawing should happen here.

#ifndef LL_LLUI_H
#define LL_LLUI_H

#include "llrect.h"
#include "llcontrol.h"
#include "llrect.h"
#include "llcoord.h"
#include "llhtmlhelp.h"
#include "llgl.h"
#include <stack>
#include "llimagegl.h"

// LLUIFactory
#include "llsd.h"

class LLColor4; 
class LLVector3;
class LLVector2;
class LLUUID;
class LLWindow;
class LLView;
class LLUIImage;

// UI colors
extern const LLColor4 UI_VERTEX_COLOR;
void make_ui_sound(const LLString& name);

BOOL ui_point_in_rect(S32 x, S32 y, S32 left, S32 top, S32 right, S32 bottom);
void gl_state_for_2d(S32 width, S32 height);

void gl_line_2d(S32 x1, S32 y1, S32 x2, S32 y2);
void gl_line_2d(S32 x1, S32 y1, S32 x2, S32 y2, const LLColor4 &color );
void gl_triangle_2d(S32 x1, S32 y1, S32 x2, S32 y2, S32 x3, S32 y3, const LLColor4& color, BOOL filled);
void gl_rect_2d_simple( S32 width, S32 height );

void gl_draw_x(const LLRect& rect, const LLColor4& color);

void gl_rect_2d(S32 left, S32 top, S32 right, S32 bottom, BOOL filled = TRUE );
void gl_rect_2d(S32 left, S32 top, S32 right, S32 bottom, const LLColor4 &color, BOOL filled = TRUE );
void gl_rect_2d_offset_local( S32 left, S32 top, S32 right, S32 bottom, const LLColor4 &color, S32 pixel_offset = 0, BOOL filled = TRUE );
void gl_rect_2d_offset_local( S32 left, S32 top, S32 right, S32 bottom, S32 pixel_offset = 0, BOOL filled = TRUE );
void gl_rect_2d(const LLRect& rect, BOOL filled = TRUE );
void gl_rect_2d(const LLRect& rect, const LLColor4& color, BOOL filled = TRUE );
void gl_rect_2d_checkerboard(const LLRect& rect);

void gl_drop_shadow(S32 left, S32 top, S32 right, S32 bottom, const LLColor4 &start_color, S32 lines);

void gl_circle_2d(F32 x, F32 y, F32 radius, S32 steps, BOOL filled);
void gl_arc_2d(F32 center_x, F32 center_y, F32 radius, S32 steps, BOOL filled, F32 start_angle, F32 end_angle);
void gl_deep_circle( F32 radius, F32 depth );
void gl_ring( F32 radius, F32 width, const LLColor4& center_color, const LLColor4& side_color, S32 steps, BOOL render_center );
void gl_corners_2d(S32 left, S32 top, S32 right, S32 bottom, S32 length, F32 max_frac);
void gl_washer_2d(F32 outer_radius, F32 inner_radius, S32 steps, const LLColor4& inner_color, const LLColor4& outer_color);
void gl_washer_segment_2d(F32 outer_radius, F32 inner_radius, F32 start_radians, F32 end_radians, S32 steps, const LLColor4& inner_color, const LLColor4& outer_color);
void gl_washer_spokes_2d(F32 outer_radius, F32 inner_radius, S32 count, const LLColor4& inner_color, const LLColor4& outer_color);

void gl_draw_image(S32 x, S32 y, LLImageGL* image, const LLColor4& color = UI_VERTEX_COLOR, const LLRectf& uv_rect = LLRectf(0.f, 1.f, 1.f, 0.f));
void gl_draw_scaled_image(S32 x, S32 y, S32 width, S32 height, LLImageGL* image, const LLColor4& color = UI_VERTEX_COLOR, const LLRectf& uv_rect = LLRectf(0.f, 1.f, 1.f, 0.f));
void gl_draw_rotated_image(S32 x, S32 y, F32 degrees, LLImageGL* image, const LLColor4& color = UI_VERTEX_COLOR, const LLRectf& uv_rect = LLRectf(0.f, 1.f, 1.f, 0.f));
void gl_draw_scaled_rotated_image(S32 x, S32 y, S32 width, S32 height, F32 degrees,LLImageGL* image, const LLColor4& color = UI_VERTEX_COLOR, const LLRectf& uv_rect = LLRectf(0.f, 1.f, 1.f, 0.f));
void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 border_width, S32 border_height, S32 width, S32 height, LLImageGL* image, const LLColor4 &color, BOOL solid_color = FALSE, const LLRectf& uv_rect = LLRectf(0.f, 1.f, 1.f, 0.f));
void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 width, S32 height, LLImageGL* image, const LLColor4 &color, BOOL solid_color = FALSE, const LLRectf& uv_rect = LLRectf(0.f, 1.f, 1.f, 0.f), const LLRectf& scale_rect = LLRectf(0.f, 1.f, 1.f, 0.f));
// Flip vertical, used for LLFloaterHTML
void gl_draw_scaled_image_inverted(S32 x, S32 y, S32 width, S32 height, LLImageGL* image, const LLColor4& color = UI_VERTEX_COLOR, const LLRectf& uv_rect = LLRectf(0.f, 1.f, 1.f, 0.f));

void gl_rect_2d_xor(S32 left, S32 top, S32 right, S32 bottom);
void gl_stippled_line_3d( const LLVector3& start, const LLVector3& end, const LLColor4& color, F32 phase = 0.f ); 

void gl_rect_2d_simple_tex( S32 width, S32 height );

// segmented rectangles

/*
   TL |______TOP_________| TR 
     /|                  |\  
   _/_|__________________|_\_
   L| |    MIDDLE        | |R
   _|_|__________________|_|_
    \ |    BOTTOM        | /  
   BL\|__________________|/ BR
      |                  |    
*/

typedef enum e_rounded_edge
{
        ROUNDED_RECT_LEFT       = 0x1, 
        ROUNDED_RECT_TOP        = 0x2, 
        ROUNDED_RECT_RIGHT      = 0x4, 
        ROUNDED_RECT_BOTTOM     = 0x8,
        ROUNDED_RECT_ALL        = 0xf
}ERoundedEdge;


void gl_segmented_rect_2d_tex(const S32 left, const S32 top, const S32 right, const S32 bottom, const S32 texture_width, const S32 texture_height, const S32 border_size, const U32 edges = ROUNDED_RECT_ALL);
void gl_segmented_rect_2d_fragment_tex(const S32 left, const S32 top, const S32 right, const S32 bottom, const S32 texture_width, const S32 texture_height, const S32 border_size, const F32 start_fragment, const F32 end_fragment, const U32 edges = ROUNDED_RECT_ALL);
void gl_segmented_rect_3d_tex(const LLVector2& border_scale, const LLVector3& border_width, const LLVector3& border_height, const LLVector3& width_vec, const LLVector3& height_vec, U32 edges = ROUNDED_RECT_ALL);
void gl_segmented_rect_3d_tex_top(const LLVector2& border_scale, const LLVector3& border_width, const LLVector3& border_height, const LLVector3& width_vec, const LLVector3& height_vec);

inline void gl_rect_2d( const LLRect& rect, BOOL filled )
{
        gl_rect_2d( rect.mLeft, rect.mTop, rect.mRight, rect.mBottom, filled );
}

inline void gl_rect_2d_offset_local( const LLRect& rect, S32 pixel_offset, BOOL filled)
{
        gl_rect_2d_offset_local( rect.mLeft, rect.mTop, rect.mRight, rect.mBottom, pixel_offset, filled );
}

// No longer used
// Initializes translation table
// void init_tr();

// Returns a string from the string table in the correct language
// LLString tr(const LLString& english_chars);

// Used to hide the flashing text cursor when window doesn't have focus.
extern BOOL gShowTextEditCursor;

class LLImageProviderInterface;

typedef void (*LLUIAudioCallback)(const LLUUID& uuid);

class LLUI
{
public:
        //
        // Methods
        //
        static void initClass(LLControlGroup* config, 
                                                  LLControlGroup* colors, 
                                                  LLImageProviderInterface* image_provider,
                                                  LLUIAudioCallback audio_callback = NULL,
                                                  const LLVector2 *scale_factor = NULL,
                                                  const LLString& language = LLString::null);
        static void cleanupClass();

        static void pushMatrix();
        static void popMatrix();
        static void loadIdentity();
        static void translate(F32 x, F32 y, F32 z = 0.0f);

        //helper functions (should probably move free standing rendering helper functions here)
        static LLString locateSkin(const LLString& filename);
        static void setCursorPositionScreen(S32 x, S32 y);
        static void setCursorPositionLocal(const LLView* viewp, S32 x, S32 y);
        static void setScaleFactor(const LLVector2& scale_factor);
        static void setLineWidth(F32 width);
        static LLUIImage* getUIImage(const LLString& name);
        static LLVector2 getWindowSize();
        static void screenPointToGL(S32 screen_x, S32 screen_y, S32 *gl_x, S32 *gl_y);
        static void glPointToScreen(S32 gl_x, S32 gl_y, S32 *screen_x, S32 *screen_y);
        static void screenRectToGL(const LLRect& screen, LLRect *gl);
        static void glRectToScreen(const LLRect& gl, LLRect *screen);
        static void setHtmlHelp(LLHtmlHelp* html_help);

        //
        // Data
        //
        static LLControlGroup* sConfigGroup;
        static LLControlGroup* sColorsGroup;
        static LLImageProviderInterface* sImageProvider;
        static LLUIAudioCallback sAudioCallback;
        static LLVector2                sGLScaleFactor;
        static LLWindow*                sWindow;
        static BOOL             sShowXUINames;
        static LLHtmlHelp*              sHtmlHelp;

        // *TODO: remove the following when QAR-369 settings clean-up work is in.
        // Also remove the call to this method which will then be obsolete.
        // Search for QAR-369 below to enable the proper accessing of this feature. -MG
        static void setQAMode(BOOL b);
        static BOOL sQAMode;

};

//      FactoryPolicy is a static class that controls the creation and lookup of UI elements, 
//      such as floaters.
//      The key parameter is used to provide a unique identifier and/or associated construction 
//      parameters for a given UI instance
//
//      Specialize this traits for different types, or provide a class with an identical interface 
//      in the place of the traits parameter
//
//      For example:
//
//      template <>
//      class FactoryPolicy<MyClass> /* FactoryPolicy specialized for MyClass */
//      {
//      public:
//              static MyClass* findInstance(const LLSD& key = LLSD())
//              {
//                      /* return instance of MyClass associated with key */
//              }
//      
//              static MyClass* createInstance(const LLSD& key = LLSD())
//              {
//                      /* create new instance of MyClass using key for construction parameters */
//              }
//      }
//      
//      class MyClass : public LLUIFactory<MyClass>
//      {
//              /* uses FactoryPolicy<MyClass> by default */
//      }

template <class T>
class FactoryPolicy
{
public:
        // basic factory methods
        static T* findInstance(const LLSD& key); // unimplemented, provide specialiation
        static T* createInstance(const LLSD& key); // unimplemented, provide specialiation
};

//      VisibilityPolicy controls the visibility of UI elements, such as floaters.
//      The key parameter is used to store the unique identifier of a given UI instance
//
//      Specialize this traits for different types, or duplicate this interface for specific instances
//      (see above)

template <class T>
class VisibilityPolicy
{
public:
        // visibility methods
        static bool visible(T* instance, const LLSD& key); // unimplemented, provide specialiation
        static void show(T* instance, const LLSD& key); // unimplemented, provide specialiation
        static void hide(T* instance, const LLSD& key); // unimplemented, provide specialiation
};

//      Manages generation of UI elements by LLSD, such that (generally) there is
//      a unique instance per distinct LLSD parameter
//      Class T is the instance type being managed, and the FACTORY_POLICY and VISIBILITY_POLICY 
//      classes provide static methods for creating, accessing, showing and hiding the associated 
//      element T
template <class T, class FACTORY_POLICY = FactoryPolicy<T>, class VISIBILITY_POLICY = VisibilityPolicy<T> >
class LLUIFactory
{
public:
        // give names to the template parameters so derived classes can refer to them
        // except this doesn't work in gcc
        typedef FACTORY_POLICY factory_policy_t;
        typedef VISIBILITY_POLICY visibility_policy_t;

        LLUIFactory()
        {
        }

        virtual ~LLUIFactory() 
        { 
        }

        // default show and hide methods
        static T* showInstance(const LLSD& key = LLSD()) 
        { 
                T* instance = getInstance(key); 
                if (instance != NULL)
                {
                        VISIBILITY_POLICY::show(instance, key);
                }
                return instance;
        }

        static void hideInstance(const LLSD& key = LLSD()) 
        { 
                T* instance = getInstance(key); 
                if (instance != NULL)
                {
                        VISIBILITY_POLICY::hide(instance, key);
                }
        }

        static void toggleInstance(const LLSD& key = LLSD())
        {
                if (instanceVisible(key))
                {
                        hideInstance(key);
                }
                else
                {
                        showInstance(key);
                }
        }

        static bool instanceVisible(const LLSD& key = LLSD())
        {
                T* instance = FACTORY_POLICY::findInstance(key);
                return instance != NULL && VISIBILITY_POLICY::visible(instance, key);
        }

        static T* getInstance(const LLSD& key = LLSD()) 
        {
                T* instance = FACTORY_POLICY::findInstance(key);
                if (instance == NULL)
                {
                        instance = FACTORY_POLICY::createInstance(key);
                }
                return instance;
        }

};


//      Creates a UI singleton by ignoring the identifying parameter
//      and always generating the same instance via the LLUIFactory interface.
//      Note that since UI elements can be destroyed by their hierarchy, this singleton
//      pattern uses a static pointer to an instance that will be re-created as needed.
//      
//      Usage Pattern:
//      
//      class LLFloaterFoo : public LLFloater, public LLUISingleton<LLFloaterFoo>
//      {
//              friend class LLUISingleton<LLFloaterFoo>;
//              private:
//                      LLFloaterFoo(const LLSD& key);
//      };
//      
//      Note that LLUISingleton takes an option VisibilityPolicy parameter that defines
//      how showInstance(), hideInstance(), etc. work.
// 
//  https://wiki.lindenlab.com/mediawiki/index.php?title=LLUISingleton&oldid=79352

template <class T, class VISIBILITY_POLICY = VisibilityPolicy<T> >
class LLUISingleton: public LLUIFactory<T, LLUISingleton<T, VISIBILITY_POLICY>, VISIBILITY_POLICY>
{
protected:

        // T must derive from LLUISingleton<T>
        LLUISingleton() { sInstance = static_cast<T*>(this); }

        ~LLUISingleton() { sInstance = NULL; }

public:
        static T* findInstance(const LLSD& key = LLSD())
        {
                return sInstance;
        }
        
        static T* createInstance(const LLSD& key = LLSD())
        {
                if (sInstance == NULL)
                {
                        sInstance = new T(key);
                }
                return sInstance;
        }

private:
        static T*       sInstance;
};

template <class T, class U> T* LLUISingleton<T,U>::sInstance = NULL;

class LLScreenClipRect
{
public:
        LLScreenClipRect(const LLRect& rect, BOOL enabled = TRUE);
        virtual ~LLScreenClipRect();

private:
        static void pushClipRect(const LLRect& rect);
        static void popClipRect();
        static void updateScissorRegion();

private:
        LLGLState               mScissorState;
        BOOL                    mEnabled;

        static std::stack<LLRect> sClipRectStack;
};

class LLLocalClipRect : public LLScreenClipRect
{
public:
        LLLocalClipRect(const LLRect& rect, BOOL enabled = TRUE);
};

class LLUIImage : public LLRefCount
{
public:
        LLUIImage(const LLString& name, LLPointer<LLImageGL> image);

        void setClipRegion(const LLRectf& region);
        void setScaleRegion(const LLRectf& region);

        LLPointer<LLImageGL> getImage() { return mImage; }
        const LLPointer<LLImageGL>& getImage() const { return mImage; }

        void draw(S32 x, S32 y, S32 width, S32 height, const LLColor4& color = UI_VERTEX_COLOR) const;
        void draw(S32 x, S32 y, const LLColor4& color = UI_VERTEX_COLOR) const;
        void draw(const LLRect& rect, const LLColor4& color = UI_VERTEX_COLOR) const { draw(rect.mLeft, rect.mBottom, rect.getWidth(), rect.getHeight(), color); }
        
        void drawSolid(S32 x, S32 y, S32 width, S32 height, const LLColor4& color) const;
        void drawSolid(const LLRect& rect, const LLColor4& color) const { drawSolid(rect.mLeft, rect.mBottom, rect.getWidth(), rect.getHeight(), color); }
        void drawSolid(S32 x, S32 y, const LLColor4& color) const { drawSolid(x, y, mImage->getWidth(0), mImage->getHeight(0), color); }

        void drawBorder(S32 x, S32 y, S32 width, S32 height, const LLColor4& color, S32 border_width) const;
        void drawBorder(const LLRect& rect, const LLColor4& color, S32 border_width) const { drawBorder(rect.mLeft, rect.mBottom, rect.getWidth(), rect.getHeight(), color, border_width); }
        void drawBorder(S32 x, S32 y, const LLColor4& color, S32 border_width) const { drawBorder(x, y, mImage->getWidth(0), mImage->getHeight(0), color, border_width); }
        
        const LLString& getName() const { return mName; }

        S32 getWidth() const;
        S32 getHeight() const;

        // returns dimensions of underlying textures, which might not be equal to ui image portion
        S32 getTextureWidth() const;
        S32 getTextureHeight() const;

protected:
        LLString                        mName;
        LLRectf                         mScaleRegion;
        LLRectf                         mClipRegion;
        LLPointer<LLImageGL> mImage;
        BOOL                            mUniformScaling;
        BOOL                            mNoClip;
};

typedef LLPointer<LLUIImage> LLUIImagePtr;

template <typename T>
class LLTombStone : public LLRefCount
{
public:
        LLTombStone(T* target = NULL) : mTarget(target) {}
        
        void setTarget(T* target) { mTarget = target; }
        T* getTarget() const { return mTarget; }
private:
        T* mTarget;
};

//      LLHandles are used to refer to objects whose lifetime you do not control or influence.  
//      Calling get() on a handle will return a pointer to the referenced object or NULL, 
//      if the object no longer exists.  Note that during the lifetime of the returned pointer, 
//      you are assuming that the object will not be deleted by any action you perform, 
//      or any other thread, as normal when using pointers, so avoid using that pointer outside of
//      the local code block.
// 
//  https://wiki.lindenlab.com/mediawiki/index.php?title=LLHandle&oldid=79669

template <typename T>
class LLHandle
{
public:
        LLHandle() : mTombStone(sDefaultTombStone) {}
        const LLHandle<T>& operator =(const LLHandle<T>& other)  
        { 
                mTombStone = other.mTombStone;
                return *this; 
        }

        bool isDead() const 
        { 
                return mTombStone->getTarget() == NULL; 
        }

        void markDead() 
        { 
                mTombStone = sDefaultTombStone; 
        }

        T* get() const
        {
                return mTombStone->getTarget();
        }

        friend bool operator== (const LLHandle<T>& lhs, const LLHandle<T>& rhs)
        {
                return lhs.mTombStone == rhs.mTombStone;
        }
        friend bool operator!= (const LLHandle<T>& lhs, const LLHandle<T>& rhs)
        {
                return !(lhs == rhs);
        }
        friend bool     operator< (const LLHandle<T>& lhs, const LLHandle<T>& rhs)
        {
                return lhs.mTombStone < rhs.mTombStone;
        }
        friend bool     operator> (const LLHandle<T>& lhs, const LLHandle<T>& rhs)
        {
                return lhs.mTombStone > rhs.mTombStone;
        }
protected:

protected:
        LLPointer<LLTombStone<T> > mTombStone;

private:
        static LLPointer<LLTombStone<T> > sDefaultTombStone;
};

// initialize static "empty" tombstone pointer
template <typename T> LLPointer<LLTombStone<T> > LLHandle<T>::sDefaultTombStone = new LLTombStone<T>();


template <typename T>
class LLRootHandle : public LLHandle<T>
{
public:
        LLRootHandle(T* object) { bind(object); }
        LLRootHandle() {};
        ~LLRootHandle() { unbind(); }

        // this is redundant, since a LLRootHandle *is* an LLHandle
        LLHandle<T> getHandle() { return LLHandle<T>(*this); }

        void bind(T* object) 
        { 
                // unbind existing tombstone
                if (LLHandle<T>::mTombStone.notNull())
                {
                        if (LLHandle<T>::mTombStone->getTarget() == object) return;
                        LLHandle<T>::mTombStone->setTarget(NULL);
                }
                // tombstone reference counted, so no paired delete
                LLHandle<T>::mTombStone = new LLTombStone<T>(object);
        }

        void unbind() 
        {
                LLHandle<T>::mTombStone->setTarget(NULL);
        }

        //don't allow copying of root handles, since there should only be one
private:
        LLRootHandle(const LLRootHandle& other) {};
};

// Use this as a mixin for simple classes that need handles and when you don't
// want handles at multiple points of the inheritance hierarchy
template <typename T>
class LLHandleProvider
{
protected:
        typedef LLHandle<T> handle_type_t;
        LLHandleProvider() 
        {
                // provided here to enforce T deriving from LLHandleProvider<T>
        } 

        LLHandle<T> getHandle() 
        { 
                // perform lazy binding to avoid small tombstone allocations for handle
                // providers whose handles are never referenced
                mHandle.bind(static_cast<T*>(this)); 
                return mHandle; 
        }

private:
        LLRootHandle<T> mHandle;
};


//RN: maybe this needs to moved elsewhere?
class LLImageProviderInterface
{
public:
        LLImageProviderInterface() {};
        virtual ~LLImageProviderInterface() {};

        virtual LLUIImagePtr getUIImage(const LLString& name) = 0;
        virtual LLUIImagePtr getUIImageByID(const LLUUID& id) = 0;
        virtual void cleanUp() = 0;
};

#endif

---