464 lines
14 KiB
C++
464 lines
14 KiB
C++
/* SPDX-FileCopyrightText: 2001-2002 NaN Holding BV. All rights reserved.
|
|
*
|
|
* SPDX-License-Identifier: GPL-2.0-or-later */
|
|
|
|
/** \file
|
|
* \ingroup GHOST
|
|
* Declaration of GHOST_System class.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "GHOST_ISystem.hh"
|
|
|
|
#include "GHOST_Buttons.hh"
|
|
#include "GHOST_Debug.hh"
|
|
#include "GHOST_EventManager.hh"
|
|
#include "GHOST_ModifierKeys.hh"
|
|
#ifdef WITH_GHOST_DEBUG
|
|
# include "GHOST_EventPrinter.hh"
|
|
#endif // WITH_GHOST_DEBUG
|
|
|
|
class GHOST_DisplayManager;
|
|
class GHOST_Event;
|
|
class GHOST_TimerManager;
|
|
class GHOST_Window;
|
|
class GHOST_WindowManager;
|
|
#ifdef WITH_INPUT_NDOF
|
|
class GHOST_NDOFManager;
|
|
#endif
|
|
|
|
/**
|
|
* Implementation of platform independent functionality of the GHOST_ISystem
|
|
* interface.
|
|
* GHOST_System is an abstract class because not all methods of GHOST_ISystem
|
|
* are implemented.
|
|
* \see GHOST_ISystem.
|
|
*/
|
|
class GHOST_System : public GHOST_ISystem {
|
|
protected:
|
|
/**
|
|
* Constructor.
|
|
* Protected default constructor to force use of static createSystem member.
|
|
*/
|
|
GHOST_System();
|
|
|
|
/**
|
|
* Destructor.
|
|
* Protected default constructor to force use of static dispose member.
|
|
*/
|
|
virtual ~GHOST_System();
|
|
|
|
public:
|
|
/***************************************************************************************
|
|
* Time(r) functionality
|
|
***************************************************************************************/
|
|
|
|
/**
|
|
* Installs a timer.
|
|
*
|
|
* \note On most operating systems, messages need to be processed in order
|
|
* for the timer callbacks to be invoked.
|
|
*
|
|
* \param delay: The time to wait for the first call to the #timerProc (in milliseconds).
|
|
* \param interval: The interval between calls to the #timerProc.
|
|
* \param timerProc: The callback invoked when the interval expires.
|
|
* \param userData: Placeholder for user data.
|
|
* \return A timer task (0 if timer task installation failed).
|
|
*/
|
|
GHOST_ITimerTask *installTimer(uint64_t delay,
|
|
uint64_t interval,
|
|
GHOST_TimerProcPtr timerProc,
|
|
GHOST_TUserDataPtr userData = nullptr);
|
|
|
|
/**
|
|
* Removes a timer.
|
|
* \param timerTask: Timer task to be removed.
|
|
* \return Indication of success.
|
|
*/
|
|
GHOST_TSuccess removeTimer(GHOST_ITimerTask *timerTask);
|
|
|
|
/***************************************************************************************
|
|
* Display/window management functionality
|
|
***************************************************************************************/
|
|
|
|
/**
|
|
* Dispose a window.
|
|
* \param window: Pointer to the window to be disposed.
|
|
* \return Indication of success.
|
|
*/
|
|
GHOST_TSuccess disposeWindow(GHOST_IWindow *window);
|
|
|
|
/**
|
|
* Create a new off-screen context.
|
|
* Never explicitly delete the context, use #disposeContext() instead.
|
|
* \return The new context (or 0 if creation failed).
|
|
*/
|
|
virtual GHOST_IContext *createOffscreenContext(GHOST_GPUSettings gpuSettings) = 0;
|
|
|
|
/**
|
|
* Returns whether a window is valid.
|
|
* \param window: Pointer to the window to be checked.
|
|
* \return Indication of validity.
|
|
*/
|
|
bool validWindow(GHOST_IWindow *window);
|
|
|
|
/**
|
|
* Begins full screen mode.
|
|
* \param setting: The new setting of the display.
|
|
* \param window: Window displayed in full screen.
|
|
* \param stereoVisual: Stereo visual for quad buffered stereo.
|
|
* This window is invalid after full screen has been ended.
|
|
* \return Indication of success.
|
|
*/
|
|
GHOST_TSuccess beginFullScreen(const GHOST_DisplaySetting &setting,
|
|
GHOST_IWindow **window,
|
|
const bool stereoVisual);
|
|
|
|
/**
|
|
* Updates the resolution while in full-screen mode.
|
|
* \param setting: The new setting of the display.
|
|
* \param window: Window displayed in full screen.
|
|
*
|
|
* \return Indication of success.
|
|
*/
|
|
GHOST_TSuccess updateFullScreen(const GHOST_DisplaySetting &setting, GHOST_IWindow **window);
|
|
|
|
/**
|
|
* Ends full screen mode.
|
|
* \return Indication of success.
|
|
*/
|
|
GHOST_TSuccess endFullScreen();
|
|
|
|
/**
|
|
* Returns current full screen mode status.
|
|
* \return The current status.
|
|
*/
|
|
bool getFullScreen();
|
|
|
|
/**
|
|
* Native pixel size support (MacBook 'retina').
|
|
* \return The pixel size in float.
|
|
*/
|
|
bool useNativePixel();
|
|
bool m_nativePixel;
|
|
|
|
/**
|
|
* Focus window after opening, or put them in the background.
|
|
*/
|
|
void useWindowFocus(const bool use_focus);
|
|
|
|
bool m_windowFocus;
|
|
|
|
/**
|
|
* Focus and raise windows on mouse hover.
|
|
*/
|
|
void setAutoFocus(const bool auto_focus);
|
|
bool m_autoFocus;
|
|
|
|
/**
|
|
* Get the Window under the cursor.
|
|
* \param x: The x-coordinate of the cursor.
|
|
* \param y: The y-coordinate of the cursor.
|
|
* \return The window under the cursor or nullptr if none.
|
|
*/
|
|
GHOST_IWindow *getWindowUnderCursor(int32_t x, int32_t y);
|
|
|
|
/***************************************************************************************
|
|
* Event management functionality
|
|
***************************************************************************************/
|
|
|
|
/**
|
|
* Inherited from GHOST_ISystem but left pure virtual
|
|
*
|
|
* virtual bool processEvents(bool waitForEvent) = 0;
|
|
*/
|
|
|
|
/**
|
|
* Dispatches all the events on the stack.
|
|
* The event stack will be empty afterwards.
|
|
*/
|
|
void dispatchEvents();
|
|
|
|
/**
|
|
* Adds the given event consumer to our list.
|
|
* \param consumer: The event consumer to add.
|
|
* \return Indication of success.
|
|
*/
|
|
GHOST_TSuccess addEventConsumer(GHOST_IEventConsumer *consumer);
|
|
|
|
/**
|
|
* Remove the given event consumer to our list.
|
|
* \param consumer: The event consumer to remove.
|
|
* \return Indication of success.
|
|
*/
|
|
GHOST_TSuccess removeEventConsumer(GHOST_IEventConsumer *consumer);
|
|
|
|
/***************************************************************************************
|
|
* Cursor management functionality
|
|
***************************************************************************************/
|
|
|
|
/* Client relative functions use a default implementation
|
|
* that converts from screen-coordinates to client coordinates.
|
|
* Implementations may override. */
|
|
|
|
GHOST_TSuccess getCursorPositionClientRelative(const GHOST_IWindow *window,
|
|
int32_t &x,
|
|
int32_t &y) const;
|
|
GHOST_TSuccess setCursorPositionClientRelative(GHOST_IWindow *window, int32_t x, int32_t y);
|
|
|
|
/**
|
|
* Inherited from GHOST_ISystem but left pure virtual
|
|
* <pre>
|
|
* GHOST_TSuccess getCursorPosition(int32_t& x, int32_t& y) const = 0;
|
|
* GHOST_TSuccess setCursorPosition(int32_t x, int32_t y)
|
|
* </pre>
|
|
*/
|
|
|
|
/***************************************************************************************
|
|
* Access to mouse button and keyboard states.
|
|
***************************************************************************************/
|
|
|
|
/**
|
|
* Returns the state of a modifier key (outside the message queue).
|
|
* \param mask: The modifier key state to retrieve.
|
|
* \param isDown: The state of a modifier key (true == pressed).
|
|
* \return Indication of success.
|
|
*/
|
|
GHOST_TSuccess getModifierKeyState(GHOST_TModifierKey mask, bool &isDown) const;
|
|
|
|
/**
|
|
* Returns the state of a mouse button (outside the message queue).
|
|
* \param mask: The button state to retrieve.
|
|
* \param isDown: Button state.
|
|
* \return Indication of success.
|
|
*/
|
|
GHOST_TSuccess getButtonState(GHOST_TButton mask, bool &isDown) const;
|
|
|
|
/**
|
|
* Enable multi-touch gestures if supported.
|
|
* \param use: Enable or disable.
|
|
*/
|
|
void setMultitouchGestures(const bool use);
|
|
|
|
/**
|
|
* Set which tablet API to use. Only affects Windows, other platforms have a single API.
|
|
* \param api: Enum indicating which API to use.
|
|
*/
|
|
virtual void setTabletAPI(GHOST_TTabletAPI api);
|
|
GHOST_TTabletAPI getTabletAPI();
|
|
|
|
/**
|
|
* Get the color of the pixel at the current mouse cursor location
|
|
* \param r_color: returned sRGB float colors
|
|
* \return Success value (true == successful and supported by platform)
|
|
*/
|
|
GHOST_TSuccess getPixelAtCursor(float r_color[3]) const;
|
|
|
|
#ifdef WITH_INPUT_NDOF
|
|
/***************************************************************************************
|
|
* Access to 3D mouse.
|
|
***************************************************************************************/
|
|
|
|
/**
|
|
* Sets 3D mouse dead-zone
|
|
* \param deadzone: Dead-zone of the 3D mouse (both for rotation and pan) relative to full range.
|
|
*/
|
|
void setNDOFDeadZone(float deadzone);
|
|
#endif
|
|
|
|
/***************************************************************************************
|
|
* Other (internal) functionality.
|
|
***************************************************************************************/
|
|
|
|
/**
|
|
* Pushes an event on the stack.
|
|
* To dispatch it, call dispatchEvent() or dispatchEvents().
|
|
* Do not delete the event!
|
|
* \param event: The event to push on the stack.
|
|
*/
|
|
GHOST_TSuccess pushEvent(const GHOST_IEvent *event);
|
|
|
|
/**
|
|
* \return The timer manager.
|
|
*/
|
|
inline GHOST_TimerManager *getTimerManager() const;
|
|
|
|
/**
|
|
* \return A pointer to our event manager.
|
|
*/
|
|
inline GHOST_EventManager *getEventManager() const;
|
|
|
|
/**
|
|
* \return A pointer to our window manager.
|
|
*/
|
|
inline GHOST_WindowManager *getWindowManager() const;
|
|
|
|
#ifdef WITH_INPUT_NDOF
|
|
/**
|
|
* \return A pointer to our n-degree of freedom manager.
|
|
*/
|
|
inline GHOST_NDOFManager *getNDOFManager() const;
|
|
#endif
|
|
|
|
/**
|
|
* Returns the state of all modifier keys.
|
|
* \param keys: The state of all modifier keys (true == pressed).
|
|
* \return Indication of success.
|
|
*/
|
|
virtual GHOST_TSuccess getModifierKeys(GHOST_ModifierKeys &keys) const = 0;
|
|
|
|
/**
|
|
* Returns the state of the mouse buttons (outside the message queue).
|
|
* \param buttons: The state of the buttons.
|
|
* \return Indication of success.
|
|
*/
|
|
virtual GHOST_TSuccess getButtons(GHOST_Buttons &buttons) const = 0;
|
|
|
|
/**
|
|
* Returns the selection buffer
|
|
* \param selection: Only used on X11.
|
|
* \return Returns the clipboard data
|
|
*/
|
|
virtual char *getClipboard(bool selection) const = 0;
|
|
|
|
/**
|
|
* Put data to the Clipboard
|
|
* \param buffer: The buffer to copy to the clipboard.
|
|
* \param selection: The clipboard to copy too only used on X11.
|
|
*/
|
|
virtual void putClipboard(const char *buffer, bool selection) const = 0;
|
|
|
|
/**
|
|
* Returns GHOST_kSuccess if the clipboard contains an image.
|
|
*/
|
|
GHOST_TSuccess hasClipboardImage() const;
|
|
|
|
/**
|
|
* Get image data from the Clipboard
|
|
* \param r_width: the returned image width in pixels.
|
|
* \param r_height: the returned image height in pixels.
|
|
* \return pointer uint array in RGBA byte order. Caller must free.
|
|
*/
|
|
uint *getClipboardImage(int *r_width, int *r_height) const;
|
|
|
|
/**
|
|
* Put image data to the Clipboard
|
|
* \param rgba: uint array in RGBA byte order.
|
|
* \param width: the image width in pixels.
|
|
* \param height: the image height in pixels.
|
|
*/
|
|
GHOST_TSuccess putClipboardImage(uint *rgba, int width, int height) const;
|
|
|
|
/**
|
|
* Show a system message box
|
|
* \param title: The title of the message box.
|
|
* \param message: The message to display.
|
|
* \param help_label: Help button label.
|
|
* \param continue_label: Continue button label.
|
|
* \param link: An optional hyperlink.
|
|
* \param dialog_options: Options how to display the message.
|
|
*/
|
|
virtual GHOST_TSuccess showMessageBox(const char * /*title*/,
|
|
const char * /*message*/,
|
|
const char * /*help_label*/,
|
|
const char * /*continue_label*/,
|
|
const char * /*link*/,
|
|
GHOST_DialogOptions /*dialog_options*/) const
|
|
{
|
|
return GHOST_kFailure;
|
|
};
|
|
|
|
/***************************************************************************************
|
|
* Debugging
|
|
***************************************************************************************/
|
|
|
|
/**
|
|
* Specify whether debug messages are to be shown.
|
|
* \param debug: Flag for systems to debug.
|
|
*/
|
|
virtual void initDebug(GHOST_Debug debug);
|
|
|
|
/**
|
|
* Check whether debug messages are to be shown.
|
|
*/
|
|
virtual bool isDebugEnabled();
|
|
|
|
protected:
|
|
/**
|
|
* Initialize the system.
|
|
* \return Indication of success.
|
|
*/
|
|
virtual GHOST_TSuccess init();
|
|
|
|
/**
|
|
* Shut the system down.
|
|
* \return Indication of success.
|
|
*/
|
|
virtual GHOST_TSuccess exit();
|
|
|
|
/**
|
|
* Creates a full-screen window.
|
|
* \param window: The window created.
|
|
* \return Indication of success.
|
|
*/
|
|
GHOST_TSuccess createFullScreenWindow(GHOST_Window **window,
|
|
const GHOST_DisplaySetting &settings,
|
|
const bool stereoVisual);
|
|
|
|
/** The display manager (platform dependent). */
|
|
GHOST_DisplayManager *m_displayManager;
|
|
|
|
/** The timer manager. */
|
|
GHOST_TimerManager *m_timerManager;
|
|
|
|
/** The window manager. */
|
|
GHOST_WindowManager *m_windowManager;
|
|
|
|
/** The event manager. */
|
|
GHOST_EventManager *m_eventManager;
|
|
|
|
#ifdef WITH_INPUT_NDOF
|
|
/** The N-degree of freedom device manager */
|
|
GHOST_NDOFManager *m_ndofManager;
|
|
#endif
|
|
|
|
/** Prints all the events. */
|
|
#ifdef WITH_GHOST_DEBUG
|
|
GHOST_EventPrinter *m_eventPrinter;
|
|
#endif // WITH_GHOST_DEBUG
|
|
|
|
/** Settings of the display before the display went full-screen. */
|
|
GHOST_DisplaySetting m_preFullScreenSetting;
|
|
|
|
/* Use multi-touch gestures? */
|
|
bool m_multitouchGestures;
|
|
|
|
/** Which tablet API to use. */
|
|
GHOST_TTabletAPI m_tabletAPI;
|
|
|
|
bool m_is_debug_enabled;
|
|
};
|
|
|
|
inline GHOST_TimerManager *GHOST_System::getTimerManager() const
|
|
{
|
|
return m_timerManager;
|
|
}
|
|
|
|
inline GHOST_EventManager *GHOST_System::getEventManager() const
|
|
{
|
|
return m_eventManager;
|
|
}
|
|
|
|
inline GHOST_WindowManager *GHOST_System::getWindowManager() const
|
|
{
|
|
return m_windowManager;
|
|
}
|
|
|
|
#ifdef WITH_INPUT_NDOF
|
|
inline GHOST_NDOFManager *GHOST_System::getNDOFManager() const
|
|
{
|
|
return m_ndofManager;
|
|
}
|
|
#endif
|