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 GHOST_ContextParams &context_params,
               const bool exclusive = false);


  ~GHOST_Window() override;

  bool getValid() const override
  {
    return context_ != nullptr;
  }

  void *getOSWindow() const override;

  GHOST_TSuccess setPath(const char * /*filepath*/) override
  {
    return GHOST_kFailure;
  }

  virtual GHOST_TWindowDecorationStyleFlags getWindowDecorationStyleFlags() override;

  virtual void setWindowDecorationStyleFlags(
      GHOST_TWindowDecorationStyleFlags style_flags) override;

  virtual void setWindowDecorationStyleSettings(
      GHOST_WindowDecorationStyleSettings decoration_settings) override;

  virtual GHOST_TSuccess applyWindowDecorationStyle() override
  {
    return GHOST_kSuccess;
  }

  inline GHOST_TStandardCursor getCursorShape() const override;
 
  bool isDialog() const override
  {
    return false;
  }

  GHOST_TSuccess setCursorShape(GHOST_TStandardCursor cursor_shape) override;

  GHOST_TSuccess setCustomCursorShape(const uint8_t *bitmap,
                                      const uint8_t *mask,
                                      const int size[2],
                                      const int hot_spot[2],
                                      bool can_invert_color) override;

  GHOST_TSuccess setCustomCursorGenerator(GHOST_CursorGenerator *cursor_generator) 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;

  GHOST_TSuccess setProgressBar(float /*progress*/) override
  {
    return GHOST_kFailure;
  }

  GHOST_TSuccess endProgressBar() override
  {
    return GHOST_kFailure;
  }

  GHOST_TSuccess setSwapInterval(int interval) override;
  GHOST_TSuccess getSwapInterval(int &interval_out) override;

  void setAcceptDragOperation(bool can_accept) override;

  bool canAcceptDragOperation() const override;

  GHOST_TSuccess setModifiedState(bool is_unsaved_changes) override;

  bool getModifiedState() override;

  inline GHOST_TDrawingContextType getDrawingContextType() override;

  GHOST_TSuccess setDrawingContextType(GHOST_TDrawingContextType type) override;

  GHOST_IContext *getDrawingContext() override;

  GHOST_TSuccess swapBufferAcquire() override;
  GHOST_TSuccess swapBufferRelease() override;

  GHOST_TSuccess activateDrawingContext() override;

  GHOST_TSuccess updateDrawingContext();

  GHOST_Context *getContext();

  unsigned int getDefaultFramebuffer() override;
 
#ifdef WITH_VULKAN_BACKEND
  virtual GHOST_TSuccess getVulkanSwapChainFormat(
      GHOST_VulkanSwapChainData *r_swap_chain_data) override;
#endif

  GHOST_TUserDataPtr getUserData() const override
  {
    return user_data_;
  }

  void setUserData(const GHOST_TUserDataPtr user_data) override
  {
    user_data_ = user_data;
  }

  float getNativePixelSize() override
  {
    if (native_pixel_size_ > 0.0f) {
      return native_pixel_size_;
    }
    return 1.0f;
  }

  uint16_t getDPIHint() override
  {
    return 96;
  }

  GHOST_WindowHDRInfo getHDRInfo() override
  {
    return hdr_info_;
  }
 
#ifdef WITH_INPUT_IME
  void beginIME(
      int32_t /*x*/, int32_t /*y*/, int32_t /*w*/, int32_t /*h*/, bool /*completed*/) override
  {
    /* do nothing temporarily if not in windows */
  }
 
  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(const uint8_t *bitmap,
                                                    const uint8_t *mask,
                                                    const int size[2],
                                                    const int hot_size[2],
                                                    bool can_invert_color) = 0;
  virtual GHOST_TSuccess setWindowCustomCursorGenerator(GHOST_CursorGenerator *cursor_generator)
  {
    cursor_generator->free_fn(cursor_generator);
    return GHOST_kFailure;
  };
 
  GHOST_TSuccess releaseNativeHandles();

  GHOST_TDrawingContextType drawing_context_type_;

  GHOST_TUserDataPtr user_data_;

  bool cursor_visible_;

  GHOST_TGrabCursorMode cursor_grab_;

  GHOST_TAxisFlag cursor_grab_axis_;

  int32_t cursor_grab_init_pos_[2];

  int32_t cursor_grab_accum_pos_[2];

  GHOST_Rect cursor_grab_bounds_;

  GHOST_TStandardCursor cursor_shape_;

  bool progress_bar_visible_;

  bool can_accept_drag_operation_;

  bool is_unsaved_changes_;

  bool full_screen_;

  GHOST_TWindowDecorationStyleFlags window_decoration_style_flags_;
  GHOST_WindowDecorationStyleSettings window_decoration_style_settings_;

  GHOST_ContextParams want_context_params_;

  uint32_t full_screen_width_;
  uint32_t full_screen_height_;
 
  /* OSX only, retina screens */
  float native_pixel_size_;
 
  GHOST_WindowHDRInfo hdr_info_ = GHOST_WINDOW_HDR_INFO_NONE;
 
 private:
  GHOST_Context *context_;
};
 
inline GHOST_TDrawingContextType GHOST_Window::getDrawingContextType()
{
  return drawing_context_type_;
}
 
inline bool GHOST_Window::getCursorVisibility() const
{
  return cursor_visible_;
}
 
inline GHOST_TGrabCursorMode GHOST_Window::getCursorGrabMode() const
{
  return cursor_grab_;
}
 
inline bool GHOST_Window::getCursorGrabModeIsWarp() const
{
  return (cursor_grab_ == GHOST_kGrabWrap) || (cursor_grab_ == GHOST_kGrabHide);
}
 
inline GHOST_TAxisFlag GHOST_Window::getCursorGrabAxis() const
{
  return cursor_grab_axis_;
}
 
inline void GHOST_Window::getCursorGrabInitPos(int32_t &x, int32_t &y) const
{
  x = cursor_grab_init_pos_[0];
  y = cursor_grab_init_pos_[1];
}
 
inline void GHOST_Window::getCursorGrabAccum(int32_t &x, int32_t &y) const
{
  x = cursor_grab_accum_pos_[0];
  y = cursor_grab_accum_pos_[1];
}
 
inline void GHOST_Window::setCursorGrabAccum(int32_t x, int32_t y)
{
  cursor_grab_accum_pos_[0] = x;
  cursor_grab_accum_pos_[1] = y;
}
 
inline GHOST_TStandardCursor GHOST_Window::getCursorShape() const
{
  return cursor_shape_;
}