/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * This file is part of the LibreOffice project. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. * * This file incorporates work covered by the following license notice: * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed * with this work for additional information regarding copyright * ownership. The ASF licenses this file to you under the Apache * License, Version 2.0 (the "License"); you may not use this file * except in compliance with the License. You may obtain a copy of * the License at http://www.apache.org/licenses/LICENSE-2.0 . */ #pragma once #include #include #include #if !GTK_CHECK_VERSION(4,0,0) #include #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "gtkdata.hxx" class GtkSalGraphics; class GtkSalDisplay; typedef sal_uIntPtr GdkNativeWindow; class GtkInstDropTarget; class GtkInstDragSource; class GtkDnDTransferable; class GtkSalMenu; struct VclToGtkHelper; class GtkSalFrame final : public SalFrame { struct IMHandler { #if !GTK_CHECK_VERSION(4, 0, 0) // Not all GTK Input Methods swallow key release // events. Since they swallow the key press events and we // are left with the key release events, we need to // manually swallow those. To do this, we keep a list of // the previous 10 key press events in each GtkSalFrame // and when we get a key release that matches one of the // key press events in our list, we swallow it. struct PreviousKeyPress { GdkWindow *window; gint8 send_event; guint32 time; guint state; guint keyval; guint16 hardware_keycode; guint8 group; PreviousKeyPress (GdkEventKey *event) : window (nullptr), send_event (0), time (0), state (0), keyval (0), hardware_keycode (0), group (0) { if (event) { window = event->window; send_event = event->send_event; time = event->time; state = event->state; keyval = event->keyval; hardware_keycode = event->hardware_keycode; group = event->group; } } PreviousKeyPress( const PreviousKeyPress& rPrev ) : window( rPrev.window ), send_event( rPrev.send_event ), time( rPrev.time ), state( rPrev.state ), keyval( rPrev.keyval ), hardware_keycode( rPrev.hardware_keycode ), group( rPrev.group ) {} bool operator== (GdkEventKey const *event) const { return (event != nullptr) && (event->window == window) && (event->send_event == send_event) // ignore non-Gdk state bits, e.g., these used by IBus && ((event->state & GDK_MODIFIER_MASK) == (state & GDK_MODIFIER_MASK)) && (event->keyval == keyval) && (event->hardware_keycode == hardware_keycode) && (event->group == group) && (event->time - time < 300) ; } }; #endif GtkSalFrame* m_pFrame; #if !GTK_CHECK_VERSION(4, 0, 0) std::list< PreviousKeyPress > m_aPrevKeyPresses; #endif int m_nPrevKeyPresses; // avoid using size() GtkIMContext* m_pIMContext; bool m_bFocused; bool m_bPreeditJustChanged; SalExtTextInputEvent m_aInputEvent; std::vector< ExtTextInputAttr > m_aInputFlags; IMHandler( GtkSalFrame* ); ~IMHandler(); void createIMContext(); void deleteIMContext(); void updateIMSpotLocation(); void endExtTextInput( EndExtTextInputFlags nFlags ); #if !GTK_CHECK_VERSION(4, 0, 0) bool handleKeyEvent( GdkEventKey* pEvent ); #endif void focusChanged( bool bFocusIn ); void doCallEndExtTextInput(); void sendEmptyCommit(); static void signalIMCommit( GtkIMContext*, gchar*, gpointer ); static gboolean signalIMDeleteSurrounding( GtkIMContext*, gint, gint, gpointer ); static void signalIMPreeditChanged( GtkIMContext*, gpointer ); static void signalIMPreeditEnd( GtkIMContext*, gpointer ); static void signalIMPreeditStart( GtkIMContext*, gpointer ); static gboolean signalIMRetrieveSurrounding( GtkIMContext*, gpointer ); }; friend struct IMHandler; friend class GtkSalObjectWidgetClip; SalX11Screen m_nXScreen; GtkWidget* m_pWindow; GtkHeaderBar* m_pHeaderBar; GtkGrid* m_pTopLevelGrid; #if !GTK_CHECK_VERSION(4, 0, 0) GtkEventBox* m_pEventBox; GtkFixed* m_pFixedContainer; GtkFixed* m_pDrawingArea; #else GtkOverlay* m_pOverlay; GtkFixed* m_pFixedContainer; GtkDrawingArea* m_pDrawingArea; GtkEventControllerKey* m_pKeyController; gulong m_nSettingChangedSignalId; #endif gulong m_nPortalSettingChangedSignalId; GDBusProxy* m_pSettingsPortal; gulong m_nSessionClientSignalId; GDBusProxy* m_pSessionManager; GDBusProxy* m_pSessionClient; #if !GTK_CHECK_VERSION(4, 0, 0) GdkWindow* m_pForeignParent; GdkNativeWindow m_aForeignParentWindow; GdkWindow* m_pForeignTopLevel; GdkNativeWindow m_aForeignTopLevelWindow; #endif SalFrameStyleFlags m_nStyle; GtkSalFrame* m_pParent; std::list< GtkSalFrame* > m_aChildren; GdkToplevelState m_nState; SystemEnvData m_aSystemData; std::unique_ptr m_pGraphics; bool m_bGraphics; ModKeyFlags m_nKeyModifiers; PointerStyle m_ePointerStyle; SessionManagerInhibitor m_SessionManagerInhibitor; gulong m_nSetFocusSignalId; bool m_bFullscreen; bool m_bDefaultPos; bool m_bDefaultSize; bool m_bTooltipBlocked; OUString m_sWMClass; std::unique_ptr m_pIMHandler; Size m_aMaxSize; Size m_aMinSize; tools::Rectangle m_aRestorePosSize; OUString m_aTooltip; tools::Rectangle m_aHelpArea; tools::Rectangle m_aFloatRect; FloatWinPopupFlags m_nFloatFlags; bool m_bFloatPositioned; tools::Long m_nWidthRequest; tools::Long m_nHeightRequest; cairo_region_t* m_pRegion; GtkInstDropTarget* m_pDropTarget; GtkInstDragSource* m_pDragSource; bool m_bGeometryIsProvisional; bool m_bIconSetWhileUnmapped; GtkSalMenu* m_pSalMenu; #if ENABLE_DBUS && ENABLE_GIO private: friend void on_registrar_available (GDBusConnection*, const gchar*, const gchar*, gpointer); friend void on_registrar_unavailable (GDBusConnection*, const gchar*, gpointer); #endif guint m_nWatcherId; void Init( SalFrame* pParent, SalFrameStyleFlags nStyle ); void Init( SystemParentData* pSysData ); void InitCommon(); void InvalidateGraphics(); // signals #if !GTK_CHECK_VERSION(4, 0, 0) static gboolean signalButton( GtkWidget*, GdkEventButton*, gpointer ); static void signalStyleUpdated(GtkWidget*, gpointer); #else static void signalStyleUpdated(GtkWidget*, const gchar* pSetting, gpointer); #endif void DrawingAreaResized(GtkWidget* pWidget, int nWidth, int nHeight); void DrawingAreaDraw(cairo_t *cr); #if !GTK_CHECK_VERSION(4, 0, 0) static gboolean signalDraw( GtkWidget*, cairo_t *cr, gpointer ); static void sizeAllocated(GtkWidget*, GdkRectangle *pAllocation, gpointer frame); #else static void signalDraw(GtkDrawingArea*, cairo_t *cr, int width, int height, gpointer); static void sizeAllocated(GtkWidget*, int nWidth, int nHeight, gpointer frame); #endif static void signalRealize(GtkWidget*, gpointer frame); static gboolean signalTooltipQuery(GtkWidget*, gint x, gint y, gboolean keyboard_mode, GtkTooltip *tooltip, gpointer frame); #if GTK_CHECK_VERSION(4, 0, 0) static GdkDragAction signalDragMotion(GtkDropTargetAsync *dest, GdkDrop *drop, double x, double y, gpointer frame); static void signalDragLeave(GtkDropTargetAsync *dest, GdkDrop *drop, gpointer frame); static gboolean signalDragDrop(GtkDropTargetAsync* context, GdkDrop* drop, double x, double y, gpointer frame); static void signalDragFailed(GdkDrag* drag, GdkDragCancelReason reason, gpointer frame); static void signalDragDelete(GdkDrag* drag, gpointer frame); static void signalDragEnd(GdkDrag* drag, gpointer frame); #else static gboolean signalDragMotion(GtkWidget *widget, GdkDragContext *context, gint x, gint y, guint time, gpointer frame); static gboolean signalDragDrop(GtkWidget* widget, GdkDragContext *context, gint x, gint y, guint time, gpointer frame); static void signalDragDropReceived(GtkWidget *widget, GdkDragContext *context, gint x, gint y, GtkSelectionData *data, guint ttype, guint time, gpointer frame); static void signalDragLeave(GtkWidget *widget, GdkDragContext *context, guint time, gpointer frame); static gboolean signalDragFailed(GtkWidget *widget, GdkDragContext *context, GtkDragResult result, gpointer frame); static void signalDragDelete(GtkWidget *widget, GdkDragContext *context, gpointer frame); static void signalDragEnd(GtkWidget *widget, GdkDragContext *context, gpointer frame); static void signalDragDataGet(GtkWidget* widget, GdkDragContext* context, GtkSelectionData *data, guint info, guint time, gpointer frame); #endif static void gestureSwipe(GtkGestureSwipe* gesture, gdouble velocity_x, gdouble velocity_y, gpointer frame); static void gestureLongPress(GtkGestureLongPress* gesture, gdouble x, gdouble y, gpointer frame); bool DrawingAreaButton(SalEvent nEventType, int nEventX, int nEventY, int nButton, guint32 nTime, guint nState); #if GTK_CHECK_VERSION(4, 0, 0) static void gesturePressed(GtkGestureClick* gesture, int n_press, gdouble x, gdouble y, gpointer frame); static void gestureReleased(GtkGestureClick* gesture, int n_press, gdouble x, gdouble y, gpointer frame); void gestureButton(GtkGestureClick* gesture, SalEvent nEventType, gdouble x, gdouble y); #endif void DrawingAreaFocusInOut(SalEvent nEventType); #if GTK_CHECK_VERSION(4, 0, 0) static void signalFocusEnter(GtkEventControllerFocus* pController, gpointer frame); static void signalFocusLeave(GtkEventControllerFocus* pController, gpointer frame); #else static gboolean signalFocus( GtkWidget*, GdkEventFocus*, gpointer ); #endif #if !GTK_CHECK_VERSION(4, 0, 0) static void signalSetFocus(GtkWindow* pWindow, GtkWidget* pWidget, gpointer frame); #else static void signalSetFocus(GtkWindow* pWindow, GParamSpec* pSpec, gpointer frame); #endif void WindowMap(); void WindowUnmap(); bool WindowCloseRequest(); void DrawingAreaMotion(int nEventX, int nEventY, guint32 nTime, guint nState); void DrawingAreaCrossing(SalEvent nEventType, int nEventX, int nEventY, guint32 nTime, guint nState); void DrawingAreaScroll(double delta_x, double delta_y, int nEventX, int nEventY, guint32 nTime, guint nState); #if GTK_CHECK_VERSION(4, 0, 0) bool DrawingAreaKey(GtkEventControllerKey* pController, SalEvent nEventType, guint keyval, guint keycode, guint nState); static void signalMap(GtkWidget*, gpointer); static void signalUnmap(GtkWidget*, gpointer); static gboolean signalDelete(GtkWidget*, gpointer); static void signalMotion(GtkEventControllerMotion *controller, double x, double y, gpointer); static gboolean signalScroll(GtkEventControllerScroll* pController, double delta_x, double delta_y, gpointer); static void signalEnter(GtkEventControllerMotion *controller, double x, double y, gpointer); static void signalLeave(GtkEventControllerMotion *controller, gpointer); static gboolean signalKeyPressed(GtkEventControllerKey *controller, guint keyval, guint keycode, GdkModifierType state, gpointer); static gboolean signalKeyReleased(GtkEventControllerKey *controller, guint keyval, guint keycode, GdkModifierType state, gpointer); static void signalWindowState(GdkToplevel*, GParamSpec*, gpointer); #else static gboolean signalMap( GtkWidget*, GdkEvent*, gpointer ); static gboolean signalUnmap( GtkWidget*, GdkEvent*, gpointer ); static gboolean signalDelete( GtkWidget*, GdkEvent*, gpointer ); static gboolean signalMotion( GtkWidget*, GdkEventMotion*, gpointer ); static gboolean signalScroll( GtkWidget*, GdkEvent*, gpointer ); static gboolean signalCrossing( GtkWidget*, GdkEventCrossing*, gpointer ); static gboolean signalKey( GtkWidget*, GdkEventKey*, gpointer ); static gboolean signalWindowState( GtkWidget*, GdkEvent*, gpointer ); #endif static bool signalZoomBegin(GtkGesture*, GdkEventSequence*, gpointer); static bool signalZoomUpdate(GtkGesture*, GdkEventSequence*, gpointer); static bool signalZoomEnd(GtkGesture*, GdkEventSequence*, gpointer); static bool signalRotateBegin(GtkGesture*, GdkEventSequence*, gpointer); static bool signalRotateUpdate(GtkGesture*, GdkEventSequence*, gpointer); static bool signalRotateEnd(GtkGesture*, GdkEventSequence*, gpointer); #if !GTK_CHECK_VERSION(4, 0, 0) static gboolean signalConfigure( GtkWidget*, GdkEventConfigure*, gpointer ); #endif static void signalDestroy( GtkWidget*, gpointer ); void Center(); void SetDefaultSize(); bool doKeyCallback( guint state, guint keyval, guint16 hardware_keycode, guint8 group, sal_Unicode aOrigCode, bool bDown, bool bSendRelease ); #if !GTK_CHECK_VERSION(4, 0, 0) static GdkNativeWindow findTopLevelSystemWindow( GdkNativeWindow aWindow ); #endif static int m_nFloats; bool isFloatGrabWindow() const { return (m_nStyle & SalFrameStyleFlags::FLOAT) && // only a float can be floatgrab !(m_nStyle & SalFrameStyleFlags::TOOLTIP) && // tool tips are not !(m_nStyle & SalFrameStyleFlags::OWNERDRAWDECORATION); // toolbars are also not } bool isChild( bool bPlug = true, bool bSysChild = true ) { SalFrameStyleFlags nMask = SalFrameStyleFlags::NONE; if( bPlug ) nMask |= SalFrameStyleFlags::PLUG; if( bSysChild ) nMask |= SalFrameStyleFlags::SYSTEMCHILD; return bool(m_nStyle & nMask); } //call gtk_window_resize void window_resize(tools::Long nWidth, tools::Long nHeight); //call gtk_widget_set_size_request void widget_set_size_request(tools::Long nWidth, tools::Long nHeight); void resizeWindow( tools::Long nWidth, tools::Long nHeight ); void moveWindow( tools::Long nX, tools::Long nY ); Size calcDefaultSize(); void setMinMaxSize(); void AllocateFrame(); void TriggerPaintEvent(); void updateWMClass(); enum class SetType { RetainSize, Fullscreen, UnFullscreen }; void SetScreen( unsigned int nNewScreen, SetType eType, tools::Rectangle const *pSize = nullptr ); void SetIcon(const char* pIcon); bool HandleMenubarMnemonic(guint eState, guint nKeyval); void ListenPortalSettings(); void ListenSessionManager(); void UpdateGeometryFromEvent(int x_root, int y_root, int nEventX, int nEventY); public: cairo_surface_t* m_pSurface; basegfx::B2IVector m_aFrameSize; DamageHandler m_aDamageHandler; std::vector m_aPendingScrollEvents; #if !GTK_CHECK_VERSION(4, 0, 0) Idle m_aSmoothScrollIdle; #endif int m_nGrabLevel; bool m_bSalObjectSetPosSize; GtkSalFrame( SalFrame* pParent, SalFrameStyleFlags nStyle ); GtkSalFrame( SystemParentData* pSysData ); guint m_nMenuExportId; guint m_nActionGroupExportId; guint m_nHudAwarenessId; std::vector m_aMouseSignalIds; void grabPointer(bool bGrab, bool bKeyboardAlso, bool bOwnerEvents); static GtkSalDisplay* getDisplay(); static GdkDisplay* getGdkDisplay(); GtkWidget* getWindow() const { return m_pWindow; } GtkFixed* getFixedContainer() const { return GTK_FIXED(m_pFixedContainer); } GtkWidget* getMouseEventWidget() const; GtkGrid* getTopLevelGridWidget() const { return m_pTopLevelGrid; } const SalX11Screen& getXScreenNumber() const { return m_nXScreen; } int GetDisplayScreen() const { return maGeometry.screen(); } void updateScreenNumber(); cairo_t* getCairoContext() const; void damaged(sal_Int32 nExtentsLeft, sal_Int32 nExtentsTop, sal_Int32 nExtentsRight, sal_Int32 nExtentsBottom) const; void registerDropTarget(GtkInstDropTarget* pDropTarget) { assert(!m_pDropTarget); m_pDropTarget = pDropTarget; } void deregisterDropTarget(GtkInstDropTarget const * pDropTarget) { assert(m_pDropTarget == pDropTarget); (void)pDropTarget; m_pDropTarget = nullptr; } void registerDragSource(GtkInstDragSource* pDragSource) { assert(!m_pDragSource); m_pDragSource = pDragSource; } void deregisterDragSource(GtkInstDragSource const * pDragSource) { assert(m_pDragSource == pDragSource); (void)pDragSource; m_pDragSource = nullptr; } void startDrag(const css::datatransfer::dnd::DragGestureEvent& rEvent, const css::uno::Reference& rTrans, VclToGtkHelper& rConversionHelper, GdkDragAction sourceActions); void closePopup(); void addGrabLevel(); void removeGrabLevel(); #if !GTK_CHECK_VERSION(4, 0, 0) void nopaint_container_resize_children(GtkContainer*); void LaunchAsyncScroll(GdkEvent const * pEvent); DECL_LINK(AsyncScroll, Timer *, void); #endif virtual ~GtkSalFrame() override; // SalGraphics or NULL, but two Graphics for all SalFrames // must be returned virtual SalGraphics* AcquireGraphics() override; virtual void ReleaseGraphics( SalGraphics* pGraphics ) override; // Event must be destroyed, when Frame is destroyed // When Event is called, SalInstance::Yield() must be returned virtual bool PostEvent(std::unique_ptr pData) override; virtual void SetTitle( const OUString& rTitle ) override; virtual void SetIcon( sal_uInt16 nIcon ) override; virtual void SetMenu( SalMenu *pSalMenu ) override; SalMenu* GetMenu(); void EnsureAppMenuWatch(); virtual void SetExtendedFrameStyle( SalExtStyle nExtStyle ) override; // Before the window is visible, a resize event // must be sent with the correct size virtual void Show( bool bVisible, bool bNoActivate = false ) override; // Set ClientSize and Center the Window to the desktop // and send/post a resize message virtual void SetMinClientSize( tools::Long nWidth, tools::Long nHeight ) override; virtual void SetMaxClientSize( tools::Long nWidth, tools::Long nHeight ) override; virtual void SetPosSize( tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight, sal_uInt16 nFlags ) override; virtual void GetClientSize( tools::Long& rWidth, tools::Long& rHeight ) override; virtual void GetWorkArea( AbsoluteScreenPixelRectangle& rRect ) override; virtual SalFrame* GetParent() const override; virtual void SetWindowState(const vcl::WindowData*) override; virtual bool GetWindowState(vcl::WindowData*) override; virtual void ShowFullScreen( bool bFullScreen, sal_Int32 nDisplay ) override; // Enable/Disable ScreenSaver, SystemAgents, ... virtual void StartPresentation( bool bStart ) override; // Show Window over all other Windows virtual void SetAlwaysOnTop( bool bOnTop ) override; // Window to top and grab focus virtual void ToTop( SalFrameToTop nFlags ) override; // this function can call with the same // pointer style virtual void SetPointer( PointerStyle ePointerStyle ) override; virtual void CaptureMouse( bool bMouse ) override; virtual void GrabFocus() override; virtual void SetPointerPos( tools::Long nX, tools::Long nY ) override; // flush output buffer using SalFrame::Flush; virtual void Flush() override; // flush output buffer, wait till outstanding operations are done virtual void SetInputContext( SalInputContext* pContext ) override; virtual void EndExtTextInput( EndExtTextInputFlags nFlags ) override; virtual OUString GetKeyName( sal_uInt16 nKeyCode ) override; virtual bool MapUnicodeToKeyCode( sal_Unicode aUnicode, LanguageType aLangType, vcl::KeyCode& rKeyCode ) override; // returns the input language used for the last key stroke // may be LANGUAGE_DONTKNOW if not supported by the OS virtual LanguageType GetInputLanguage() override; virtual void UpdateSettings( AllSettings& rSettings ) override; virtual void Beep() override; // returns system data (most prominent: window handle) virtual const SystemEnvData* GetSystemData() const override; virtual void ResolveWindowHandle(SystemEnvData& rData) const override; // get current modifier and button mask virtual SalPointerState GetPointerState() override; virtual KeyIndicatorState GetIndicatorState() override; virtual void SimulateKeyPress( sal_uInt16 nKeyCode ) override; // set new parent window virtual void SetParent( SalFrame* pNewParent ) override; // reparent window to act as a plugin; implementation // may choose to use a new system window internally // return false to indicate failure virtual void SetPluginParent( SystemParentData* pNewParent ) override; virtual void SetScreenNumber( unsigned int ) override; virtual void SetApplicationID( const OUString &rWMClass ) override; // shaped system windows // set clip region to none (-> rectangular windows, normal state) virtual void ResetClipRegion() override; // start setting the clipregion consisting of nRects rectangles virtual void BeginSetClipRegion( sal_uInt32 nRects ) override; // add a rectangle to the clip region virtual void UnionClipRegion( tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight ) override; // done setting up the clipregion virtual void EndSetClipRegion() override; virtual void PositionByToolkit(const tools::Rectangle& rRect, FloatWinPopupFlags nFlags) override; virtual void SetModal(bool bModal) override; virtual bool GetModal() const override; void HideTooltip(); void BlockTooltip(); void UnblockTooltip(); virtual bool ShowTooltip(const OUString& rHelpText, const tools::Rectangle& rHelpArea) override; virtual void* ShowPopover(const OUString& rHelpText, vcl::Window* pParent, const tools::Rectangle& rHelpArea, QuickHelpFlags nFlags) override; virtual bool UpdatePopover(void* nId, const OUString& rHelpText, vcl::Window* pParent, const tools::Rectangle& rHelpArea) override; virtual bool HidePopover(void* nId) override; virtual weld::Window* GetFrameWeld() const override; virtual void UpdateDarkMode() override; virtual bool GetUseDarkMode() const override; virtual bool GetUseReducedAnimation() const override; static GtkSalFrame *getFromWindow( GtkWidget *pWindow ); static sal_uIntPtr GetNativeWindowHandle(GtkWidget *pWidget); //Call the usual SalFrame Callback, but catch uno exceptions and delegate //to GtkSalData to rethrow them after the gsignal is processed when its safe //to do so again in our own code after the g_main_context_iteration call //which triggers the gsignals. bool CallCallbackExc(SalEvent nEvent, const void* pEvent) const; // call gtk_widget_queue_draw on the drawing widget void queue_draw(); static void KeyCodeToGdkKey(const vcl::KeyCode& rKeyCode, guint* pGdkKeyCode, GdkModifierType *pGdkModifiers); static guint32 GetLastInputEventTime(); static void UpdateLastInputEventTime(guint32 nUserInputTime); static sal_uInt16 GetMouseModCode(guint nState); static sal_uInt16 GetKeyCode(guint nKeyVal); #if !GTK_CHECK_VERSION(4, 0, 0) static guint GetKeyValFor(GdkKeymap* pKeyMap, guint16 hardware_keycode, guint8 group); #endif static sal_uInt16 GetKeyModCode(guint nState); static GdkEvent* makeFakeKeyPress(GtkWidget* pWidget); #if !GTK_CHECK_VERSION(4, 0, 0) static SalWheelMouseEvent GetWheelEvent(const GdkEventScroll& rEvent); static gboolean NativeWidgetHelpPressed(GtkAccelGroup*, GObject*, guint, GdkModifierType, gpointer pFrame); #endif static OUString GetPreeditDetails(GtkIMContext* pIMContext, std::vector& rInputFlags, sal_Int32& rCursorPos, sal_uInt8& rCursorFlags); #if GTK_CHECK_VERSION(4, 0, 0) gboolean event_controller_scroll_forward(GtkEventControllerScroll* pController, double delta_x, double delta_y); #endif const cairo_font_options_t* get_font_options(); void SetColorScheme(GVariant* variant); void SessionManagerInhibit(bool bStart, ApplicationInhibitFlags eType, std::u16string_view sReason, const char* application_id); void DisallowCycleFocusOut(); bool IsCycleFocusOutDisallowed() const; void AllowCycleFocusOut(); }; extern "C" { GType ooo_fixed_get_type(); #if !GTK_CHECK_VERSION(4, 0, 0) AtkObject* ooo_fixed_get_accessible(GtkWidget *obj); #endif } // extern "C" #if !GTK_CHECK_VERSION(3, 22, 0) enum GdkAnchorHints { GDK_ANCHOR_FLIP_X = 1 << 0, GDK_ANCHOR_FLIP_Y = 1 << 1, GDK_ANCHOR_SLIDE_X = 1 << 2, GDK_ANCHOR_SLIDE_Y = 1 << 3, GDK_ANCHOR_RESIZE_X = 1 << 4, GDK_ANCHOR_RESIZE_Y = 1 << 5, GDK_ANCHOR_FLIP = GDK_ANCHOR_FLIP_X | GDK_ANCHOR_FLIP_Y, GDK_ANCHOR_SLIDE = GDK_ANCHOR_SLIDE_X | GDK_ANCHOR_SLIDE_Y, GDK_ANCHOR_RESIZE = GDK_ANCHOR_RESIZE_X | GDK_ANCHOR_RESIZE_Y }; #endif /* vim:set shiftwidth=4 softtabstop=4 expandtab: */