RE/RE_Window.h

Go to the documentation of this file.

#ifndef __RE_Window_h__
#define __RE_Window_h__

#include "RE_API.h"
#include <UT/UT_Defines.h>
#include <UT/UT_PtrArray.h>
#include <UT/UT_Lock.h>
#include "RE_Types.h"

class RE_Visual;
class RE_Server;
class RE_Render;

typedef struct {
    unsigned int doOffScreen:1,
                 isOriginReadjusted:1,
                 alwaysOnTop:1,
                 maximized:1,
                 fullscreen:1;
} RE_WindowFlags;

class RE_API RE_Window
{
public:
    RE_Window(RE_Server *server,
              RE_WindowType type,
              RE_VisualType visType = RE_NORMAL_VIS,
              RE_WindowVisibility doOffScreen = RE_WINDOW_VISIBLE,
              bool alwaysOnTop = false);

    virtual ~RE_Window();

    virtual void setName(const char *name) = 0;
    virtual void setIconName(const char *name) = 0;
    
            void setParentWindow(RE_Window *parent);
    virtual void reparentWindow( RE_Window *newParent ) = 0;
    const RE_Window     *getParentWindow() const { return parentWindow; }

    virtual void         setParentOfTransient(RE_IDType transient);
    virtual RE_IDType    getParentOfTransient();
    

    RE_Server           *getServer() { return myServer; }
    RE_Visual           *getVisual()
                         { return visualResource; }
    RE_Render           *getRender();
    
    virtual RE_IDType    openWindow( int isMain = 0, int show=1 ) = 0;
    virtual void         showWindow();
    virtual void         closeWindow() = 0;

    virtual void         initMaxSize(  short w, short h ) = 0;
    virtual void         initMinSize(  short w, short h ) = 0;
    virtual void         initClass(    char *name, char *rclass ) = 0;
    virtual void         initVisual(   RE_Visual *visual );
    void                 setLimitPositions(bool limitpos)
                         { myLimitPositions = limitpos; }
    bool                 getLimitPositions() const
                         { return myLimitPositions; }

    virtual void         updateMaxSize(int w,int h);


    // The force argument for moveWindow, sizeWindow, and 
    // moveAndSizeWindow is only really used in RE_XWindow 
    // (as called from X11_Window).  See RE_XWindow.h.
    virtual void moveWindow(   short x, short y, int force = 1 ) = 0;
    virtual void sizeWindow(   short w, short h, int force = 1 ) = 0;
    virtual void resizeWindow( short w, short h ) = 0;
    virtual void moveAndSizeWindow(short x, short y, short w, short h, 
                                   int force = 1 ) = 0;


    // Maximize the window and/or mark it as maximized so that when openWindow
    // is called, it can open the window maximized.
    virtual void maximizeWindow();
    virtual void restoreWindow();

            bool isMaximized() const { return winFlags.maximized; }

    // Set the window as fullscreen. Depending on the windowing system, this
    // either informs the window manager to set us as fullscreen or simply
    // sets borders up so that higher-level classes can do the fullscreening
    // themselves.
    virtual void fullscreenWindow(bool full);
            bool isFullscreenWindow() const { return winFlags.fullscreen; }

    virtual short getX() const = 0;
    virtual short getY() const = 0;
    virtual short getW() const = 0;
    virtual short getH() const = 0;

    virtual void lowerWindow() = 0;
    virtual void raiseWindow() = 0;
    
    int          getBorderWidth() const
                 { return myLeftBorder+myRightBorder; }
    int          getBorderHeight() const
                 { return myTopBorder+myBottomBorder; }
    int          getBorderTopSize() const
                 { return myTopBorder; }
    int          getBorderLeftSize() const
                 { return myLeftBorder; }
    int          getBorderBottomSize() const
                 { return myBottomBorder; }
    int          getBorderRightSize() const
                 { return myRightBorder; }

    //makeCurrent will return true on success and false on failure.
    virtual bool         makeCurrent(bool &needs_initialization);
    virtual void         unmakeCurrent();

    virtual void         findLocation(short *x, short *y, short *w, short *h,
                                      char topMostParent = 0) = 0;

    // Sets the window to sit on top of all other windows, or turns off that
    // state, depending on whether newstate is true or false.
    virtual void         setWindowAlwaysOnTop(bool newstate);
    virtual void         setWindowAlwaysOnTopAndHideWhenInactive(bool newstate);
    int                  getWindowAlwaysOnTop() const
                         { return winFlags.alwaysOnTop; }

    int                  getDepth() const;
    RE_DisplayMode       getMode() const;
    int                  getNumColors() const;

    RE_VisualType        getVisualType() const
                         { return visualType; }
    void                 setVisualType(RE_VisualType t) { visualType = t; }

    // changes to the type will not occur until the window is opened again.
    void                 setWindowType(RE_WindowType t)
                         { myWindowType = t; }
    RE_WindowType        getWindowType() const
                         { return myWindowType; }
    
    void                 setWindowID(RE_IDType id) { windowID = id; }
    RE_IDType            getWindowID()  const
                         { return windowID; }
    int                  matchID( RE_IDType wid ) const
                         { return wid == windowID; }
    
    virtual RE_IDType    getBufferID() const { return 0; }

    virtual OGLDrawable  getGraphicsDrawable() = 0;
    virtual OGLDrawable  getAlternateDrawable() = 0;
    virtual void         setGraphicsDrawable(OGLDrawable ) { }
    virtual void         setAlternateDrawable(OGLDrawable) { }

    void                 setIconPixmap(unsigned long pm) { iconPixmap = pm; }
    unsigned long        getIconPixmap() const { return iconPixmap; }

    void                 setIconLoader(RE_IconLoader loader);

    
    UT_Bool              isOffscreen() const
                         { return winFlags.doOffScreen ==RE_WINDOW_OFFSCREEN; }

    virtual void         grabWindowFocusLock(bool /*pointer_too*/) { }
    virtual void         releaseWindowFocusLock() { }

    void         setWindowBorders(int left, int right, int top, int bottom)
                 {
                     myLeftBorder = left;
                     myRightBorder = right;
                     myTopBorder = top;
                     myBottomBorder = bottom;
                 }

    OGLDrawable          getDrawable()
    {
        return winFlags.doOffScreen
            ? getAlternateDrawable() : getGraphicsDrawable();
    }

protected:
    RE_OGLContext        getContext(bool &needs_initialization);

    RE_Server           *myServer;
    RE_Visual           *visualResource;
    RE_VisualType        visualType;
    RE_IDType            windowID;
    
#if ! RE_OGL_SINGLE_CONTEXT
    RE_Render           *myRender;
#endif
    
    unsigned long        iconPixmap;
    RE_IconLoader        iconLoader;
    RE_WindowFlags       winFlags;
    RE_WindowFlags       storeFlags;
    RE_Window           *parentWindow;

    RE_WindowType        myWindowType;

    int                  myLeftBorder;
    int                  myTopBorder;
    int                  myRightBorder;
    int                  myBottomBorder;

    unsigned int         myLimitPositions:1;
};

class RE_API RE_WindowList
{
public:
                         RE_WindowList()
                         { }
                        ~RE_WindowList()
                         { }

    void                 lock()
                         { myLock.lock(); }
    void                 unlock()
                         { myLock.unlock(); }
    void                 addWindow(RE_Window *w)
                         { lock(); myWindows.append(w); unlock(); }
    void                 removeWindow(RE_Window *w)
                         { lock(); myWindows.remove(w); unlock(); }
    int                  getNumWindows() const
                         { return myWindows.entries(); }
    RE_Window           *getWindow(int index) const
                         { return myWindows(index); }
    void                 removeWindow(RE_IDType wid);
    RE_Window           *isWindowHere(RE_IDType wid);

private:
    UT_PtrArray<RE_Window *>     myWindows;
    UT_Lock                      myLock;
};

#endif

---