GHOST_Window.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2001-2002 NaN Holding BV. All rights reserved.
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include "GHOST_IWindow.hh"
 
class GHOST_Context;
 
class GHOST_Window : public GHOST_IWindow {
 public:
  GHOST_Window(uint32_t width,
               uint32_t height,
               GHOST_TWindowState state,
               const bool wantStereoVisual = false,
               const bool exclusive = false);
 
  virtual ~GHOST_Window();
 
  virtual bool getValid() const override
  {
    return m_context != nullptr;
  }
 
  virtual void *getOSWindow() const override;
 
  virtual GHOST_TSuccess setPath(const char * /*filepath*/) override
  {
    return GHOST_kFailure;
  }
 
  inline GHOST_TStandardCursor getCursorShape() const override;
 
  inline bool isDialog() const override
  {
    return false;
  }
 
  GHOST_TSuccess setCursorShape(GHOST_TStandardCursor cursorShape) override;
 
  GHOST_TSuccess setCustomCursorShape(uint8_t *bitmap,
                                      uint8_t *mask,
                                      int sizex,
                                      int sizey,
                                      int hotX,
                                      int hotY,
                                      bool canInvertColor) override;
 
  GHOST_TSuccess getCursorBitmap(GHOST_CursorBitmapRef *bitmap) override;
 
  inline bool getCursorVisibility() const override;
  inline GHOST_TGrabCursorMode getCursorGrabMode() const;
  inline bool getCursorGrabModeIsWarp() const;
  inline GHOST_TAxisFlag getCursorGrabAxis() const;
  inline void getCursorGrabInitPos(int32_t &x, int32_t &y) const;
  inline void getCursorGrabAccum(int32_t &x, int32_t &y) const;
  inline void setCursorGrabAccum(int32_t x, int32_t y);
 
  GHOST_TSuccess setCursorVisibility(bool visible) override;
 
  GHOST_TSuccess setCursorGrab(GHOST_TGrabCursorMode mode,
                               GHOST_TAxisFlag wrap_axis,
                               GHOST_Rect *bounds,
                               int32_t mouse_ungrab_xy[2]) override;
 
  GHOST_TSuccess getCursorGrabBounds(GHOST_Rect &bounds) const override;
 
  void getCursorGrabState(GHOST_TGrabCursorMode &mode,
                          GHOST_TAxisFlag &wrap_axis,
                          GHOST_Rect &bounds,
                          bool &use_software_cursor) override;
  bool getCursorGrabUseSoftwareDisplay() override;
 
  virtual GHOST_TSuccess setProgressBar(float /*progress*/) override
  {
    return GHOST_kFailure;
  }
 
  virtual GHOST_TSuccess endProgressBar() override
  {
    return GHOST_kFailure;
  }
 
  GHOST_TSuccess setSwapInterval(int interval) override;
 
  GHOST_TSuccess getSwapInterval(int &intervalOut) override;
 
  void setAcceptDragOperation(bool canAccept) override;
 
  bool canAcceptDragOperation() const override;
 
  virtual GHOST_TSuccess setModifiedState(bool isUnsavedChanges) override;
 
  virtual bool getModifiedState() override;
 
  inline GHOST_TDrawingContextType getDrawingContextType() override;
 
  GHOST_TSuccess setDrawingContextType(GHOST_TDrawingContextType type) override;
 
  virtual GHOST_IContext *getDrawingContext() override;
 
  virtual GHOST_TSuccess swapBuffers() override;
 
  virtual GHOST_TSuccess activateDrawingContext() override;
 
  GHOST_TSuccess updateDrawingContext();
 
  GHOST_Context *getContext();
 
  virtual unsigned int getDefaultFramebuffer() override;
 
#ifdef WITH_VULKAN_BACKEND
  virtual GHOST_TSuccess getVulkanSwapChainFormat(
      GHOST_VulkanSwapChainData *r_swap_chain_data) override;
#endif
 
  inline GHOST_TUserDataPtr getUserData() const override
  {
    return m_userData;
  }
 
  void setUserData(const GHOST_TUserDataPtr userData) override
  {
    m_userData = userData;
  }
 
  float getNativePixelSize() override
  {
    if (m_nativePixelSize > 0.0f) {
      return m_nativePixelSize;
    }
    return 1.0f;
  }
 
  virtual inline uint16_t getDPIHint() override
  {
    return 96;
  }
 
#ifdef WITH_INPUT_IME
  virtual void beginIME(
      int32_t /*x*/, int32_t /*y*/, int32_t /*w*/, int32_t /*h*/, bool /*completed*/) override
  {
    /* do nothing temporarily if not in windows */
  }
 
  virtual void endIME() override
  {
    /* 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(uint8_t *bitmap,
                                                    uint8_t *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;
 
  int32_t m_cursorGrabInitPos[2];
 
  int32_t 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;
 
  uint32_t m_fullScreenWidth;
  uint32_t 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(int32_t &x, int32_t &y) const
{
  x = m_cursorGrabInitPos[0];
  y = m_cursorGrabInitPos[1];
}
 
inline void GHOST_Window::getCursorGrabAccum(int32_t &x, int32_t &y) const
{
  x = m_cursorGrabAccumPos[0];
  y = m_cursorGrabAccumPos[1];
}
 
inline void GHOST_Window::setCursorGrabAccum(int32_t x, int32_t y)
{
  m_cursorGrabAccumPos[0] = x;
  m_cursorGrabAccumPos[1] = y;
}
 
inline GHOST_TStandardCursor GHOST_Window::getCursorShape() const
{
  return m_cursorShape;
}