intern/ghost/intern/GHOST_Window.h

   1 /**
   2  * $Id$
   3  * ***** BEGIN GPL LICENSE BLOCK *****
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software Foundation,
  17  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18  *
  19  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  20  * All rights reserved.
  21  *
  22  * The Original Code is: all of this file.
  23  *
  24  * Contributor(s): none yet.
  25  *
  26  * ***** END GPL LICENSE BLOCK *****
  27  */
  28 /**
  29  * @file        GHOST_Window.h
  30  * Declaration of GHOST_Window class.
  31  */
  32
  33 #ifndef _GHOST_WINDOW_H_
  34 #define _GHOST_WINDOW_H_
  35
  36 #include "GHOST_IWindow.h"
  37
  38 class STR_String;
  39
  40 /**
  41  * Platform independent implementation of GHOST_IWindow.
  42  * Dimensions are given in screen coordinates that are relative to the
  43  * upper-left corner of the screen.
  44  * Implements part of the GHOST_IWindow interface and adds some methods to
  45  * be implemented by childs of this class.
  46  * @author      Maarten Gribnau
  47  * @date        May 7, 2001
  48  */
  49 class GHOST_Window : public GHOST_IWindow
  50 {
  51 public:
  52         /**
  53          * @section Interface inherited from GHOST_IWindow left for derived class
  54          * implementation.
  55          * virtual      bool getValid() const = 0;
  56          * virtual void setTitle(const STR_String& title) = 0;
  57          * virtual void getTitle(STR_String& title) const = 0;
  58          * virtual      void getWindowBounds(GHOST_Rect& bounds) const = 0;
  59          * virtual      void getClientBounds(GHOST_Rect& bounds) const = 0;
  60          * virtual      GHOST_TSuccess setClientWidth(GHOST_TUns32 width) = 0;
  61          * virtual      GHOST_TSuccess setClientHeight(GHOST_TUns32 height) = 0;
  62          * virtual      GHOST_TSuccess setClientSize(GHOST_TUns32 width, GHOST_TUns32 height) = 0;
  63          * virtual      void screenToClient(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const = 0;
  64          * virtual      void clientToScreen(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const = 0;
  65          * virtual GHOST_TWindowState getState() const = 0;
  66          * virtual GHOST_TSuccess setState(GHOST_TWindowState state) = 0;
  67          * virtual GHOST_TWindowOrder getOrder(void) = 0;
  68          * virtual GHOST_TSuccess setOrder(GHOST_TWindowOrder order) = 0;
  69          * virtual GHOST_TSuccess swapBuffers() = 0;
  70          * virtual GHOST_TSuccess activateDrawingContext() = 0;
  71          * virtual GHOST_TSuccess invalidate() = 0;
  72          */
  73
  74         /**
  75          * Constructor.
  76          * Creates a new window and opens it.
  77          * To check if the window was created properly, use the getValid() method.
  78          * @param title         The text shown in the title bar of the window.
  79          * @param left          The coordinate of the left edge of the window.
  80          * @param top           The coordinate of the top edge of the window.
  81          * @param width         The width the window.
  82          * @param heigh         The height the window.
  83          * @param state         The state the window is initially opened with.
  84          * @param type          The type of drawing context installed in this window.
  85          * @param stereoVisual  Stereo visual for quad buffered stereo.
  86          */
  87         GHOST_Window(
  88                 const STR_String& title,
  89                 GHOST_TInt32 left,
  90                 GHOST_TInt32 top,
  91                 GHOST_TUns32 width,
  92                 GHOST_TUns32 height,
  93                 GHOST_TWindowState state,
  94                 GHOST_TDrawingContextType type = GHOST_kDrawingContextTypeNone,
  95                 const bool stereoVisual = false);
  96
  97         /**
  98          * @section Interface inherited from GHOST_IWindow left for derived class
  99          * implementation.
 100          * virtual      bool getValid() const = 0;
 101          * virtual void setTitle(const STR_String& title) = 0;
 102          * virtual void getTitle(STR_String& title) const = 0;
 103          * virtual      void getWindowBounds(GHOST_Rect& bounds) const = 0;
 104          * virtual      void getClientBounds(GHOST_Rect& bounds) const = 0;
 105          * virtual      GHOST_TSuccess setClientWidth(GHOST_TUns32 width) = 0;
 106          * virtual      GHOST_TSuccess setClientHeight(GHOST_TUns32 height) = 0;
 107          * virtual      GHOST_TSuccess setClientSize(GHOST_TUns32 width, GHOST_TUns32 height) = 0;
 108          * virtual      void screenToClient(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const = 0;
 109          * virtual      void clientToScreen(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const = 0;
 110          * virtual GHOST_TWindowState getState() const = 0;
 111          * virtual GHOST_TSuccess setState(GHOST_TWindowState state) = 0;
 112          * virtual GHOST_TSuccess setOrder(GHOST_TWindowOrder order) = 0;
 113          * virtual GHOST_TSuccess swapBuffers() = 0;
 114          * virtual GHOST_TSuccess activateDrawingContext() = 0;
 115          * virtual GHOST_TSuccess invalidate() = 0;
 116          */
 117
 118         /**
 119          * Destructor.
 120          * Closes the window and disposes resources allocated.
 121          */
 122         virtual ~GHOST_Window();
 123
 124         /**
 125          * Returns the current cursor shape.
 126          * @return      The current cursor shape.
 127          */
 128         inline virtual GHOST_TStandardCursor getCursorShape() const;
 129
 130         /**
 131          * Set the shape of the cursor.
 132          * @param       cursor  The new cursor shape type id.
 133          * @return      Indication of success.
 134          */
 135         virtual GHOST_TSuccess setCursorShape(GHOST_TStandardCursor cursorShape);
 136
 137         /**
 138          * Set the shape of the cursor to a custom cursor.
 139          * @param       bitmap  The bitmap data for the cursor.
 140          * @param       mask    The mask data for the cursor.
 141          * @param       hotX    The X coordinate of the cursor hotspot.
 142          * @param       hotY    The Y coordinate of the cursor hotspot.
 143          * @return      Indication of success.
 144          */
 145         virtual GHOST_TSuccess setCustomCursorShape(GHOST_TUns8 bitmap[16][2],
 146                                                                                                 GHOST_TUns8 mask[16][2],
 147                                                                                                 int hotX,
 148                                                                                                 int hotY);
 149
 150         virtual GHOST_TSuccess setCustomCursorShape(GHOST_TUns8 *bitmap,
 151                                                                                                 GHOST_TUns8 *mask,
 152                                                                                                 int sizex, int sizey,
 153                                                                                                 int hotX,  int hotY,
 154                                                                                                 int fg_color, int bg_color);
 155
 156         /**
 157          * Returns the visibility state of the cursor.
 158          * @return      The visibility state of the cursor.
 159          */
 160         inline virtual bool getCursorVisibility() const;
 161
 162         /**
 163          * Shows or hides the cursor.
 164          * @param       visible The new visibility state of the cursor.
 165          * @return      Indication of success.
 166          */
 167         virtual GHOST_TSuccess setCursorVisibility(bool visible);
 168
 169         /**
 170          * Sets the cursor grab.
 171          * @param       grab The new grab state of the cursor.
 172          * @return      Indication of success.
 173          */
 174         virtual GHOST_TSuccess setCursorGrab(bool grab);
 175
 176         /**
 177          * Returns the type of drawing context used in this window.
 178          * @return The current type of drawing context.
 179          */
 180         inline virtual GHOST_TDrawingContextType getDrawingContextType();
 181
 182         /**
 183          * Tries to install a rendering context in this window.
 184          * Child classes do not need to overload this method.
 185          * They should overload the installDrawingContext and removeDrawingContext instead.
 186          * @param type  The type of rendering context installed.
 187          * @return Indication as to whether installation has succeeded.
 188          */
 189         virtual GHOST_TSuccess setDrawingContextType(GHOST_TDrawingContextType type);
 190
 191         /**
 192          * Returns the window user data.
 193          * @return The window user data.
 194          */
 195         inline virtual GHOST_TUserDataPtr getUserData() const
 196         {
 197                 return m_userData;
 198         }
 199
 200         /**
 201          * Changes the window user data.
 202          * @param data The window user data.
 203          */
 204         virtual void setUserData(const GHOST_TUserDataPtr userData)
 205         {
 206                 m_userData = userData;
 207         }
 208
 209 protected:
 210         /**
 211          * Tries to install a rendering context in this window.
 212          * @param type  The type of rendering context installed.
 213          * @return Indication as to whether installation has succeeded.
 214          */
 215         virtual GHOST_TSuccess installDrawingContext(GHOST_TDrawingContextType type) = 0;
 216
 217         /**
 218          * Removes the current drawing context.
 219          * @return Indication as to whether removal has succeeded.
 220          */
 221         virtual GHOST_TSuccess removeDrawingContext() = 0;
 222
 223         /**
 224          * Sets the cursor visibility on the window using
 225          * native window system calls.
 226          */
 227         virtual GHOST_TSuccess setWindowCursorVisibility(bool visible) = 0;
 228
 229         /**
 230          * Sets the cursor grab on the window using
 231          * native window system calls.
 232          */
 233         virtual GHOST_TSuccess setWindowCursorGrab(bool grab) { return GHOST_kSuccess; };
 234
 235         /**
 236          * Sets the cursor shape on the window using
 237          * native window system calls.
 238          */
 239         virtual GHOST_TSuccess setWindowCursorShape(GHOST_TStandardCursor shape) = 0;
 240
 241         /**
 242          * Sets the cursor shape on the window using
 243          * native window system calls.
 244          */
 245         virtual GHOST_TSuccess setWindowCustomCursorShape(GHOST_TUns8 bitmap[16][2], GHOST_TUns8 mask[16][2],
 246                                                          int hotX, int hotY) = 0;
 247
 248         virtual GHOST_TSuccess setWindowCustomCursorShape(GHOST_TUns8 *bitmap, GHOST_TUns8 *mask,
 249                                                 int szx, int szy, int hotX, int hotY, int fg, int bg) = 0;
 250         /** The the of drawing context installed in this window. */
 251         GHOST_TDrawingContextType m_drawingContextType;
 252
 253         /** The window user data */
 254         GHOST_TUserDataPtr m_userData;
 255
 256         /** The current visibility of the cursor */
 257         bool m_cursorVisible;
 258
 259         /** The current grabbed state of the cursor */
 260         bool m_cursorGrabbed;
 261
 262         /** The current shape of the cursor */
 263         GHOST_TStandardCursor m_cursorShape;
 264
 265         /** Stores wether this is a full screen window. */
 266         bool m_fullScreen;
 267
 268         /** Stereo visual created. Only necessary for 'real' stereo support,
 269          *  ie quad buffered stereo. This is not always possible, depends on
 270          *  the graphics h/w
 271          */
 272         bool m_stereoVisual;
 273
 274     /** Full-screen width */
 275     GHOST_TUns32 m_fullScreenWidth;
 276     /** Full-screen height */
 277     GHOST_TUns32 m_fullScreenHeight;
 278 };
 279
 280
 281 inline GHOST_TDrawingContextType GHOST_Window::getDrawingContextType()
 282 {
 283         return m_drawingContextType;
 284 }
 285
 286 inline bool GHOST_Window::getCursorVisibility() const
 287 {
 288         return m_cursorVisible;
 289 }
 290
 291 inline GHOST_TStandardCursor GHOST_Window::getCursorShape() const
 292 {
 293         return m_cursorShape;
 294 }
 295
 296 #endif // _GHOST_WINDOW_H
 297