GHOST_Window.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
 * All rights reserved.
 */
 
#pragma once
 
#include "GHOST_IWindow.h"
 
class GHOST_Context;
 
class GHOST_Window : public GHOST_IWindow {
 public:
  GHOST_Window(GHOST_TUns32 width,
               GHOST_TUns32 height,
               GHOST_TWindowState state,
               const bool wantStereoVisual = false,
               const bool exclusive = false);
 
  virtual ~GHOST_Window();
 
  virtual bool getValid() const
  {
    return m_context != NULL;
  }
 
  virtual void *getOSWindow() const;
 
  inline GHOST_TStandardCursor getCursorShape() const;
 
  inline bool isDialog() const
  {
    return false;
  }
 
  GHOST_TSuccess setCursorShape(GHOST_TStandardCursor cursorShape);
 
  GHOST_TSuccess setCustomCursorShape(GHOST_TUns8 *bitmap,
                                      GHOST_TUns8 *mask,
                                      int sizex,
                                      int sizey,
                                      int hotX,
                                      int hotY,
                                      bool canInvertColor);
 
  inline bool getCursorVisibility() const;
  inline GHOST_TGrabCursorMode getCursorGrabMode() const;
  inline bool getCursorGrabModeIsWarp() const;
  inline GHOST_TAxisFlag getCursorGrabAxis() const;
  inline void getCursorGrabInitPos(GHOST_TInt32 &x, GHOST_TInt32 &y) const;
  inline void getCursorGrabAccum(GHOST_TInt32 &x, GHOST_TInt32 &y) const;
  inline void setCursorGrabAccum(GHOST_TInt32 x, GHOST_TInt32 y);
 
  GHOST_TSuccess setCursorVisibility(bool visible);
 
  GHOST_TSuccess setCursorGrab(GHOST_TGrabCursorMode mode,
                               GHOST_TAxisFlag wrap_axis,
                               GHOST_Rect *bounds,
                               GHOST_TInt32 mouse_ungrab_xy[2]);
 
  GHOST_TSuccess getCursorGrabBounds(GHOST_Rect &bounds);
 
  virtual GHOST_TSuccess setProgressBar(float /*progress*/)
  {
    return GHOST_kFailure;
  }
 
  virtual GHOST_TSuccess endProgressBar()
  {
    return GHOST_kFailure;
  }
 
  GHOST_TSuccess setSwapInterval(int interval);
 
  GHOST_TSuccess getSwapInterval(int &intervalOut);
 
  void setAcceptDragOperation(bool canAccept);
 
  bool canAcceptDragOperation() const;
 
  virtual GHOST_TSuccess setModifiedState(bool isUnsavedChanges);
 
  virtual bool getModifiedState();
 
  inline GHOST_TDrawingContextType getDrawingContextType();
 
  GHOST_TSuccess setDrawingContextType(GHOST_TDrawingContextType type);
 
  virtual GHOST_TSuccess swapBuffers();
 
  virtual GHOST_TSuccess activateDrawingContext();
 
  GHOST_TSuccess updateDrawingContext();
 
  virtual unsigned int getDefaultFramebuffer();
 
  inline GHOST_TUserDataPtr getUserData() const
  {
    return m_userData;
  }
 
  void setUserData(const GHOST_TUserDataPtr userData)
  {
    m_userData = userData;
  }
 
  float getNativePixelSize(void)
  {
    if (m_nativePixelSize > 0.0f)
      return m_nativePixelSize;
    return 1.0f;
  }
 
  virtual inline GHOST_TUns16 getDPIHint()
  {
    return 96;
  }
 
#ifdef WITH_INPUT_IME
  virtual void beginIME(
      GHOST_TInt32 x, GHOST_TInt32 y, GHOST_TInt32 w, GHOST_TInt32 h, int completed)
  {
    /* do nothing temporarily if not in windows */
  }
 
  virtual void endIME()
  {
    /* do nothing temporarily if not in windows */
  }
#endif /* WITH_INPUT_IME */
 
 protected:
  virtual GHOST_Context *newDrawingContext(GHOST_TDrawingContextType type) = 0;
 
  virtual GHOST_TSuccess setWindowCursorVisibility(bool visible) = 0;
 
  virtual GHOST_TSuccess setWindowCursorGrab(GHOST_TGrabCursorMode /*mode*/)
  {
    return GHOST_kSuccess;
  }
 
  virtual GHOST_TSuccess setWindowCursorShape(GHOST_TStandardCursor shape) = 0;
 
  virtual GHOST_TSuccess setWindowCustomCursorShape(GHOST_TUns8 *bitmap,
                                                    GHOST_TUns8 *mask,
                                                    int szx,
                                                    int szy,
                                                    int hotX,
                                                    int hotY,
                                                    bool canInvertColor) = 0;
 
  GHOST_TSuccess releaseNativeHandles();
 
  GHOST_TDrawingContextType m_drawingContextType;
 
  GHOST_TUserDataPtr m_userData;
 
  bool m_cursorVisible;
 
  GHOST_TGrabCursorMode m_cursorGrab;
 
  GHOST_TAxisFlag m_cursorGrabAxis;
 
  GHOST_TInt32 m_cursorGrabInitPos[2];
 
  GHOST_TInt32 m_cursorGrabAccumPos[2];
 
  GHOST_Rect m_cursorGrabBounds;
 
  GHOST_TStandardCursor m_cursorShape;
 
  bool m_progressBarVisible;
 
  bool m_canAcceptDragOperation;
 
  bool m_isUnsavedChanges;
 
  bool m_fullScreen;
 
  bool m_wantStereoVisual;
 
  GHOST_TUns32 m_fullScreenWidth;
  GHOST_TUns32 m_fullScreenHeight;
 
  /* OSX only, retina screens */
  float m_nativePixelSize;
 
 private:
  GHOST_Context *m_context;
};
 
inline GHOST_TDrawingContextType GHOST_Window::getDrawingContextType()
{
  return m_drawingContextType;
}
 
inline bool GHOST_Window::getCursorVisibility() const
{
  return m_cursorVisible;
}
 
inline GHOST_TGrabCursorMode GHOST_Window::getCursorGrabMode() const
{
  return m_cursorGrab;
}
 
inline bool GHOST_Window::getCursorGrabModeIsWarp() const
{
  return (m_cursorGrab == GHOST_kGrabWrap) || (m_cursorGrab == GHOST_kGrabHide);
}
 
inline GHOST_TAxisFlag GHOST_Window::getCursorGrabAxis() const
{
  return m_cursorGrabAxis;
}
 
inline void GHOST_Window::getCursorGrabInitPos(GHOST_TInt32 &x, GHOST_TInt32 &y) const
{
  x = m_cursorGrabInitPos[0];
  y = m_cursorGrabInitPos[1];
}
 
inline void GHOST_Window::getCursorGrabAccum(GHOST_TInt32 &x, GHOST_TInt32 &y) const
{
  x = m_cursorGrabAccumPos[0];
  y = m_cursorGrabAccumPos[1];
}
 
inline void GHOST_Window::setCursorGrabAccum(GHOST_TInt32 x, GHOST_TInt32 y)
{
  m_cursorGrabAccumPos[0] = x;
  m_cursorGrabAccumPos[1] = y;
}
 
inline GHOST_TStandardCursor GHOST_Window::getCursorShape() const
{
  return m_cursorShape;
}