RE/RE_Server.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Side Effects
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        RE_Server.h (C++)
 *
 * COMMENTS:
 *      Server abstraction interface for basic session interaction.
 *      Virtual base class - RE_XServer, RE_NTServer, and RE_OSXServer.
 */
#ifndef __RE_Server__
#define __RE_Server__

#include <SYS/SYS_Types.h>
#include <UT/UT_PtrArray.h>
#include <UT/UT_Rect.h>

#include "RE_API.h"
#include "RE_Types.h"

class RE_Window;
class RE_Render;

class RE_API RE_Server
{
public:
    RE_Server();
    virtual ~RE_Server();

    virtual char                initServer(char *data = 0);
    virtual void                flush() const = 0;

    /// For multi-threaded applications the "use lock" flag can be used
    /// to tell the windowing code to use exclusion locks if available.
    ///
    /// Sub-classes should override and implement the lock and unlock
    /// methods. These should do nothing if the "use lock" flag is not set.
    void                        setUseLock(int state) { myUseLock = state; }
    int                         getUseLock() const    { return myUseLock; }

    virtual void                lock(const char *msg=0);
    virtual void                unlock(const char *msg=0);

    RE_IDType                   getFocusWindow() const { return focusWindow; }
    void                        setFocusWindow(RE_IDType wid);

    static void                 setMinRes( int xmin, int ymin );
    static int                  getMinXRes() { return myMinXRes; }
    static int                  getMinYRes() { return myMinYRes; }
    int                         meetsMinRes( );

    /// Determine if the given window is currently under the mouse
    /// The current x,y mouse coordinates are optional under
    /// certain platforms
    virtual bool                windowUnderCursor(RE_IDType wid,
                                                  int x, int y);

    virtual bool                getColorUnderCursor(float color[3]);

    virtual Display             *getDisplay() const { return NULL; }

#ifdef PLATFORM_OPEN_GL
    virtual short getWidth() const = 0;
    virtual short getHeight() const = 0;
    virtual short getWidthMM() const = 0;
    virtual short getHeightMM() const = 0;
    virtual bool  GLMakeCurrent( OGLDrawable draw, RE_OGLContext context ) = 0;
    virtual int   GLMakeCopyCurrent( OGLDrawable    draw,
                                     RE_OGLContext  sourceContext,
                                     RE_OGLContext  targetContext ) = 0;
    virtual void  GLSwapBuffers(RE_Window *currentWindow) = 0;
    virtual OGLDrawable GLGetCurrentDrawable() = 0;
    virtual void  GLWaitGL() = 0;

    // provide some reasonable defaults
    virtual int          getDragTolX() const    { return 4; }
    virtual int          getDragTolY() const    { return 4; }
    virtual fpreal64     getDragDelay() const   { return 0.75; }
#endif

    virtual UT_DimRect   getWorkArea() = 0;
    
    /// Add a window to the list of current main windows. If it is already in
    /// the list, it will not be added again.
    void                         addCurrentMainWindow(RE_Window *win);

    /// Remove a window from the list of current main windows.
    void                         removeCurrentMainWindow(RE_Window *win);

    /// Find the current main window that's focused, so you can attach
    /// dialog windows to it. If none is marked as focused, just returns
    /// the first window.
    RE_Window                   *getCurrentMainWindow() const;

    /// Find the first current main window, regardless of whether it's focused.
    /// Used on Windows to ensure that all subwindows are made tool windows of
    /// at least the main Houdini window.
    RE_Window                   *getFirstCurrentMainWindow() const;

    /// Creates a new RE_Window, ready to be opened.
    RE_Window                   *newWindow(RE_DisplayMode mode,
                                           RE_WindowType type,
                                           RE_VisualType visType=RE_NORMAL_VIS,
                                           RE_WindowVisibility doOffScreen
                                                        = RE_WINDOW_VISIBLE,
                                           bool alwaysOnTop = false);

    /// Returns current render context matching the mode passed in. All render
    /// contexts are tied to a specific drawable. This may return NULL if 
    /// there are no render contexts currently created that match mode.
    RE_Render                   *getContextMatching(RE_DisplayMode mode) const;

protected:
    RE_IDType                    focusWindow;

private:
    /// The current main windows are all the toplevel application windows.
    /// We keep track of them to find out what window we should use when
    /// creating dialogs - windowing systems can decorate and treat dialog
    /// windows differently if they know which window is the parent.
    UT_PtrArray<RE_Window *>    myCurrentMainWindows;
    int                         myUseLock;

    static int                  myMinXRes;
    static int                  myMinYRes;
};

class RE_ServerAutoLock
{
public:
    RE_ServerAutoLock(RE_Server& server, const char* message)
    : myServer(server)
    , myMessage(message)
    { myServer.lock(message); }

    ~RE_ServerAutoLock()
    { myServer.unlock(myMessage); }

private:
    RE_Server& myServer;
    const char* myMessage;
};

#endif

---