glWidget.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */
 
#ifndef __GL_WIDGET_H__
#define __GL_WIDGET_H__


#include <stdint.h>
#include <stdio.h>
#include <vector>


// forward declarations
class glDisplay;


class glWidget
{
public:
        enum Shape
        {
                Rect,
                Line,
                Ellipse
        };

        glWidget( Shape shape=Rect );

        glWidget( float x, float y, float width, float height, Shape shape=Rect );

        virtual ~glWidget();

        bool Contains( float x, float y ) const;

        inline void Move( float x, float y )                                    { mX += x; mY += y; }

        inline float X() const                                                          { return mX; }

        inline float Y() const                                                          { return mY; }

        inline void SetX( float x )                                                     { mX = x; }

        inline void SetY( float y )                                                     { mY = y; }

        inline float Width() const                                                      { return mWidth; }

        inline float Height() const                                                     { return mHeight; }

        inline void SetWidth( float width )                                     { mWidth = width; }

        inline void SetHeight( float height )                                   { mHeight = height; }

        inline void GetPosition( float* x, float* y ) const             { if(x) *x=mX; if(y) *y=mY; }
        
        inline void SetPosition( float x, float y )                             { mX = x; mY = y; }

        inline void GetCoords( float* x1, float* y1, float* x2, float* y2 ) const       { if(x1) *x1=mX; if(y1) *y1=mY; if(x2) *x2=mX+mWidth; if(y2) *y2=mY+mHeight; }

        inline void SetCoords( float x1, float y1, float x2, float y2 )                 { mX = x1; mY = y1; mWidth=x2-x1; mHeight=y2-y1; }

        inline void GetSize( float* width, float* height ) const        { if(width) *width=mWidth; if(height) *height=mHeight; }
        
        inline void SetSize( float width, float height )                        { mWidth = width; mHeight = height; }

        inline Shape GetShape() const                                                   { return mShape; }

        inline void SetShape( Shape shape )                                     { mShape = shape; }

        inline void SetFillAlpha( float a )                                     { mFillColor[3] = a; }

        inline void SetLineAlpha( float a )                                     { mLineColor[3] = a; }

        inline void SetLineWidth( float width )                                 { mLineWidth = width; }

        inline void SetFillColor( float r, float g, float b, float a=1.0f )                     { mFillColor[0] = r; mFillColor[1] = g; mFillColor[2] = b; mFillColor[3] = a; }

        inline void SetLineColor( float r, float g, float b, float a=1.0f )                     { mLineColor[0] = r; mLineColor[1] = g; mLineColor[2] = b; mLineColor[3] = a; }

        inline void SetSelectedFillColor( float r, float g, float b, float a=1.0f )     { mSelectedFillColor[0] = r; mSelectedFillColor[1] = g; mSelectedFillColor[2] = b; mSelectedFillColor[3] = a; }

        inline void SetSelectedLineColor( float r, float g, float b, float a=1.0f )     { mSelectedLineColor[0] = r; mSelectedLineColor[1] = g; mSelectedLineColor[2] = b; mSelectedLineColor[3] = a; }

        inline bool IsMoveable() const                                          { return mMoveable; }

        inline void SetMoveable( bool moveable )                                { mMoveable = moveable; }

        inline bool IsResizeable() const                                                { return mResizeable; }

        inline void SetResizeable( bool resizeable )                            { mResizeable = resizeable; }

        inline bool IsSelected() const                                          { return mSelected; }

        inline void SetSelected( bool selected )                                { mSelected = true; }

        inline bool IsVisible() const                                                   { return mVisible; }

        inline void SetVisible( bool visible )                                  { mVisible = visible; }

        inline void* GetUserData() const                                                { return mUserData; }

        inline void SetUserData( void* user )                                   { mUserData = user; }

        inline glDisplay* GetDisplay() const                                    { return mDisplay; }

        int GetIndex() const;

        void Render();

        void GlobalToLocal( float x, float y, float* x_out, float* y_out ) const;

        void LocalToGlobal( float x, float y, float* x_out, float* y_out ) const;

        typedef bool (*glWidgetEventHandler)(glWidget* widget, uint16_t event, int a, int b, void* user);

        void AddEventHandler( glWidgetEventHandler callback, void* user=NULL );

        void RemoveEventHandler( glWidgetEventHandler callback, void* user=NULL );

        bool OnEvent( uint16_t event, int a, int b, void* user );

        
protected:
        friend class glDisplay;

        enum DragState
        {
                DragNone,
                DragMove,
                DragResizeN,
                DragResizeNW,
                DragResizeNE,
                DragResizeS,
                DragResizeSW,
                DragResizeSE,
                DragResizeW,
                DragResizeE             
        };

        struct eventHandler
        {
                glWidgetEventHandler callback;
                void* user;
        };

        void initDefaults();
        void setCursor( DragState cursor );     
        void setDisplay( glDisplay* display );
        void dispatchEvent( uint16_t msg, int a, int b );

        DragState coordToBorder( float x, float y, float max_distance=10.0f );

        float mX;
        float mY;
        float mWidth;
        float mHeight;

        float mSelectedFillColor[4];
        float mSelectedLineColor[4];

        float mFillColor[4];
        float mLineColor[4];
        float mLineWidth;

        bool  mMoveable;
        bool  mResizeable;
        bool  mSelected;
        bool  mVisible;
        
        Shape mShape;
        void* mUserData;

        glDisplay* mDisplay;
        DragState  mDragState;

        std::vector<eventHandler> mEventHandlers;
};

#endif