RE/RE_XWindow.h

Go to the documentation of this file.

#ifndef __RE_XWindow_h__
#define __RE_XWindow_h__

#include "RE_API.h"
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <UT/UT_Pointers.h>
#include "RE_Types.h"
#include "RE_Window.h"
#include "RE_XServer.h"

class RE_XVisual;
class RE_XServer;

#ifdef  WM_POSITION_BUG
#define UserPosition                            PPosition
#define ProgPosition                            USPosition
#else
#define UserPosition                            USPosition
#define ProgPosition                            PPosition
#endif

#define UserSize                                USSize
#define ProgSize                                PBaseSize

#define ProgMaxSize                             PMaxSize
#define ProgMinSize                             PMinSize

class RE_API RE_XWindow : public RE_Window
{
public:
    RE_XWindow(RE_Server *newserver,
               RE_WindowType wintype = RE_WINDOW_NORMAL,
               RE_VisualType visType = RE_NORMAL_VIS,
               RE_WindowVisibility doOffScreen = RE_WINDOW_VISIBLE);

    virtual ~RE_XWindow();

    // By the way, the graphics drawable is also the fullscreen overlay drawable.
    virtual OGLDrawable  getGraphicsDrawable()
                         {
                             return static_cast<OGLDrawable>(windowID);
                         }
    virtual OGLDrawable  getAlternateDrawable()
                         {
                            return windowID
                                 ? static_cast<OGLDrawable>(windowID)
                                 : static_cast<OGLDrawable>(myXPbuffer);
                         }
    
    virtual RE_IDType    getBufferID() const { return (RE_IDType)myXPbuffer; }

    virtual void initMaxSize(  short w, short h );
    virtual void initMinSize(  short w, short h );
    virtual void initClass(    char *name, char *rclass );
    virtual void setName(const char *name);
    virtual void setIconName(const char *name);

    virtual void reparentWindow( RE_Window *newParent );

    // Transient windows are parented to the toplevel window, and need to know
    // what their immediate parent window is for the keyboard focus.
            void        setImmediateParent(RE_IDType pid)
                            { myImmediateParent = pid; }

    // The force argument indicates whether an Xlib call should
    // be made to force the window to the given position/size,
    // or whether we just want to set the internal variables to
    // the given values.  It was added because some window managers
    // (e.g. KDE under Linux), when asked to put a window at position
    // (x,y), would actually place the border at that point, so our
    // window's origin would actually be offset from the requested
    // value.  This caused a problem because we had assumed the window
    // was put where we asked it to.  To make a long story short, it
    // seemed best that for top-level windows, we should let the window
    // manager handle their motion/resizing, and not call those Xlib
    // functions ourselves.
    virtual void resizeWindow( short w, short h );
            void updateWindowPlacement(int x, int y);
    virtual void moveWindow(   short x, short y, int force = 1 );
    virtual void sizeWindow(   short w, short h, int force = 1 );
    virtual void moveAndSizeWindow(short x, short y, short w, short h, 
                                   int force = 1);

    // 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();

    virtual void fullscreenWindow(bool state);

    virtual short getX() const { return sizeHints.x; }
    virtual short getY() const { return sizeHints.y; }
    virtual short getW() const { return sizeHints.base_width; }
    virtual short getH() const { return sizeHints.base_height; }

    virtual void lowerWindow();
    virtual void raiseWindow();

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

    virtual unsigned long openWindow( int isMain = 0, int show = 1);
    virtual void          showWindow(); 
    virtual void          closeWindow();

    unsigned long         openRealWindow(int show);
    unsigned long         openPixmapWindow();

    void                 closeRealWindow();
    void                 closePixmapWindow();

    virtual bool         makeCurrent(bool &needs_initialization);
    virtual void         unmakeCurrent();

    int                  isChild() const
                         { return myWindowType == RE_WINDOW_CHILD; }

    const RE_XServer    *xServer() const
                         { return static_cast<const RE_XServer *>(myServer); }
          RE_XServer    *xServer()
                         { return static_cast<RE_XServer *>(myServer);       }

    virtual void         setWindowAlwaysOnTop(bool newstate);

    static RE_IDType     getWindowWithFocusLock();
    virtual void         grabWindowFocusLock(bool pointer_too);
    virtual void         releaseWindowFocusLock();

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

    // set the border sizes of various window types. If initialize is true,
    // these sizes are the ones loaded from disk, and may be overriden once
    // Houdini queries the current values from a mapped window.
    static void          setDefaultWindowBorder(RE_WindowType type,
                                                int left, int right,
                                                int top, int bottom,
                                                bool initialize);
protected:
    // Send an Extended Window Manager Hint state event to the window manager.
    // This will set the states (in the terminology of the standard, ADD them)
    // on the current window if add is true. If add is false, this will REMOVE
    // the states on the current window.  The window must be mapped before
    // doing this, and windowID must be nonzero.
    // If you want to set a EWMH state before mapping, use setEWMHAtoms()
    // with atomname = "_NET_WINDOW_STATE" instead.
    // Lock the server before calling this method.
    void                 sendEWMHStateEvent(const char *statename1,
                                            const char *statename2 = NULL,
                                            bool add = true);

    void                 sendEWMHEvent(const char *eventype);

    // Set the mentioned atom to have only states mentioned in the array.
    // This must be done on a window that has been created (windowID != 0)
    // but not yet mapped. (Using this on a mapped window has no effect; use
    // sendEWMHStateEvent instead if you need to set the EWMH state.)
    // Note that the states passed in REPLACE all other states set on the
    // window.
    // Lock the server before calling this method.
    void                 setEWMHAtoms(const char *atomname,
                                      const UT_StringArray &states);

    void                 initBorders();

    XSizeHints                   sizeHints;
    XSizeHints                   minSize;
    XClassHint                   classHints;
    XWMHints                     wmHints;
    XTextProperty                iconNameProperty;
    XTextProperty                windowNameProperty;
    Pixmap                       myXPixmap;
    GLXPbufferSGIX               myXPbuffer;
    GLXContext                   myPbufferContext;
    RE_IDType                    myImmediateParent;
};

#endif

---