diff options
Diffstat (limited to 'include/vcl/svapp.hxx')
| -rw-r--r-- | include/vcl/svapp.hxx | 1482 |
1 files changed, 1482 insertions, 0 deletions
diff --git a/include/vcl/svapp.hxx b/include/vcl/svapp.hxx new file mode 100644 index 000000000..22164ed78 --- /dev/null +++ b/include/vcl/svapp.hxx @@ -0,0 +1,1482 @@ +/* -*- 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 . + */ + +#ifndef INCLUDED_VCL_SVAPP_HXX +#define INCLUDED_VCL_SVAPP_HXX + +#include <sal/config.h> +#include <sal/types.h> + +#include <cassert> +#include <vector> + +#include <comphelper/solarmutex.hxx> +#include <LibreOfficeKit/LibreOfficeKitTypes.h> +#include <osl/mutex.hxx> +#include <rtl/ustring.hxx> +#include <osl/thread.h> +#include <tools/gen.hxx> +#include <tools/link.hxx> +#include <vcl/dllapi.h> +#include <vcl/IDialogRenderable.hxx> +#include <vcl/inputtypes.hxx> +#include <vcl/exceptiontypes.hxx> +#include <vcl/vclevent.hxx> +#include <vcl/vclenum.hxx> +#include <i18nlangtag/lang.h> +#include <o3tl/typed_flags_set.hxx> +#include <com/sun/star/uno/Reference.h> + + +class BitmapEx; +namespace weld +{ + class Builder; + class MessageDialog; + class Widget; + class Window; +} +class LocaleDataWrapper; +class AllSettings; +class DataChangedEvent; +class Accelerator; +class Help; +class OutputDevice; +namespace vcl { class Window; } +namespace vcl { class KeyCode; } +class NotifyEvent; +class KeyEvent; +class MouseEvent; +class GestureEvent; +struct ImplSVEvent; +struct ConvertData; + +namespace com::sun::star::uno { + class XComponentContext; +} +namespace com::sun::star::ui::dialogs { + class XFilePicker2; + class XFolderPicker2; +} +namespace com::sun::star::awt { + class XToolkit; + class XDisplayConnection; + class XWindow; +} + +// helper needed by SalLayout implementations as well as svx/source/dialog/svxbmpnumbalueset.cxx +VCL_DLLPUBLIC sal_UCS4 GetMirroredChar( sal_UCS4 ); +VCL_DLLPUBLIC sal_UCS4 GetLocalizedChar( sal_UCS4, LanguageType ); + +enum class SystemWindowFlags { + NOAUTOMODE = 0x0001, + DIALOG = 0x0002 +}; +namespace o3tl +{ + template<> struct typed_flags<SystemWindowFlags> : is_typed_flags<SystemWindowFlags, 0x03> {}; +} + +typedef long (*VCLEventHookProc)( NotifyEvent& rEvt, void* pData ); + +/** An application can be notified of a number of different events: + - Type::Accept - listen for connection to the application (a connection + string is passed via the event) + - Type::Unaccept - stops listening for a connection to the app (determined by + a connection string passed via the event) + - Type::Appear - brings the app to the front (i.e. makes it "appear") + - Type::Version - display the app version + - Type::Help - opens a help topic (help topic passed as string) + - Type::OpenHELP_URL - opens a help URL (URL passed as a string) + - Type::ShowDialog - shows a dialog (dialog passed as a string) + - Type::Open - opens a document or group of documents (documents passed + as an array of strings) + - Type::Print - print a document or group of documents (documents passed + as an array of strings + - Type::PrivateDoShutdown - shutdown the app +*/ + +class VCL_DLLPUBLIC ApplicationEvent +{ +public: + enum class Type { + Accept, ///< Listen for connections + Appear, ///< Make application appear + Open, ///< Open a document + OpenHelpUrl, ///< Open a help URL + Print, ///< Print document + PrivateDoShutdown, ///< Shutdown application + QuickStart, ///< Start QuickStart + ShowDialog, ///< Show a dialog + Unaccept ///< Stop listening for connections + }; + + /** Explicit constructor for ApplicationEvent. + + @attention Type::Appear, Type::PrivateDoShutdown and + Type::QuickStart are the \em only events that don't need to include + a data string with the event. No other events should use this + constructor! + */ + explicit ApplicationEvent(Type type): aEvent(type) + { + assert(type == Type::Appear || type == Type::PrivateDoShutdown || type == Type::QuickStart); + } + + /** Constructor for ApplicationEvent, accepts a string for the data + associated with the event. + + @attention Type::Accept, Type::OpenHelpUrl, Type::ShowDialog + and Type::Unaccept are the \em only events that accept a single + string as event data. No other events should use this constructor! + */ + ApplicationEvent(Type type, OUString const & data): aEvent(type) + { + assert( + type == Type::Accept || type == Type::OpenHelpUrl + || type == Type::ShowDialog || type == Type::Unaccept); + aData.push_back(data); + } + + /** Constructor for ApplicationEvent, accepts an array of strings for + the data associated with the event. + + @attention Type::Open and Type::Print can apply to multiple documents, + and are the \em only events that accept an array of strings. No other + events should use this constructor. + */ + ApplicationEvent(Type type, std::vector<OUString>&& data): + aEvent(type), aData(std::move(data)) + { + assert(type == Type::Open || type == Type::Print); + } + + /** Get the type of event. + + @returns The type of event. + */ + Type GetEvent() const + { + return aEvent; + } + + /** Gets the application event's data string. + + @attention The \em only events that need a single string Type::Accept, + Type::OpenHelpUrl, Type::ShowDialog and Type::Unaccept + + @returns The event's data string. + */ + OUString const & GetStringData() const + { + assert( + aEvent == Type::Accept + || aEvent == Type::OpenHelpUrl || aEvent == Type::ShowDialog + || aEvent == Type::Unaccept); + assert(aData.size() == 1); + return aData[0]; + } + + /** Gets the event's array of strings. + + @attention The \em only events that need an array of strings + are Type::Open and Type::Print. + */ + std::vector<OUString> const & GetStringsData() const + { + assert(aEvent == Type::Open || aEvent == Type::Print); + return aData; + } + +private: + Type aEvent; + std::vector<OUString> aData; +}; + +enum class DialogCancelMode { + Off, ///< do not automatically cancel dialogs + Silent, ///< silently cancel any dialogs + LOKSilent, ///< silently cancel any dialogs (LOK case) + Fatal ///< cancel any dialogs by std::abort +}; + +/** + @brief Base class used mainly for the LibreOffice Desktop class. + + The Application class is a base class mainly used by the Desktop + class. It is really meant to be subclassed, and the Main() function + should be overridden. Many of the ImplSVData members should be + moved to this class. + + The reason Application exists is because the VCL used to be a + standalone framework, long since abandoned by anything other than + our application. + + @see Desktop, ImplSVData + */ +class VCL_DLLPUBLIC Application : public vcl::ILibreOfficeKitNotifier +{ +public: + /** @name Initialization + The following functions perform initialization and deinitialization + of the application. + */ + ///@{ + + /** Default constructor for Application class. + + Initializes the LibreOffice global instance data structure if needed, + and then sets itself to be the Application class. Also initializes any + platform specific data structures. + + @attention The initialization of the application itself is done in Init() + */ + Application(); + + /** Virtual destructor for Application class. + + Deinitializes the LibreOffice global instance data structure, then + deinitializes any platform specific data structures. + */ + virtual ~Application(); + + /** Initialize the application itself. + + @attention Note that the global data structures and platform specific + initialization is done in the constructor. + + @see InitFinished, DeInit + */ + virtual void Init(); + + /** Finish initialization of the application. + + @see Init, DeInit + */ + virtual void InitFinished(); + + /** Deinitialized the application itself. + + @attention Note that the global data structures and platform specific + deinitialization is done in the destructor. + + @see Init, InitFinished + */ + virtual void DeInit(); + + ///@} + + /** @brief Pure virtual entrypoint to the application. + + Main() is the pure virtual entrypoint to your application. You + inherit your class from Application and subclass this function to + implement an application. + + The Main() function does not pass in command line parameters, + you must use the functions GetCommandLineParamCount() and + GetCommandLineParam() to get these values as these are platform + independent ways of getting the command line (use GetAppFileName() + to get the invoked executable filename). + + Once in this function, you create windows, etc. then call on + Execute() to start the application's main event loop. + + An example code snippet follows (it won't compile, this just gives the + general flavour of the framework and is adapted from an old HelloWorld + example program that Star Division used to provide as part of their + library). + + \code{.cpp} + class TheApplication : public Application + { + public: + virtual void Main(); + }; + + class TheWindow : public WorkWindow + { + public: + TheWindow(vcl::Window *parent, WinBits windowStyle) : + WorkWindow(parent, windowStyle) {} + + virtual void Paint(const Rectangle &); + }; + + void TheWindow::Paint(const Rectangle&) + { + DrawText(Point(100,100), String("Hello World!")); + } + + void TheApplication::Main() + { + TheWindow aWindow(NULL, WB_APP | WB_STDWORK); + aWindow.Show(); + Execute(); + } + + TheApplication anApplication; + \endcode + + Some examples in the source tree can be found here: + + vcl/workben/svdem.cxx + + This is an example of how to use the Application and WorkWindow. Unfortunately, it + no longer compiles. + + vcl/fpicker/test/svdem.cxx + */ + virtual int Main(); + + /** Exit from the application + + @returns true if exited successfully, false if not able to fully exit + */ + virtual bool QueryExit(); + + virtual void Shutdown(); + + /** @name Change Notification Functions + + Functions that notify when changes occur in the application. + */ + ///@{ + + /** Notify all windows that the application has changed data. + + @param rDCEvt Reference to a DataChangedEvent object + + @see DataChanged + */ + static void NotifyAllWindows( DataChangedEvent& rDCEvt ); + + ///@} + + /** @name Command Line Processing + + Command line processing is done via the following functions. They + give the number of parameters, the parameters themselves and a way + to get the name of the invoking application. + */ + + ///@{ + + /** Gets the number of command line parameters passed to the application + + @return sal_uInt16 - the number of parameters + + @see GetCommandLineParam, GetAppFileName + */ + static sal_uInt16 GetCommandLineParamCount(); + + /** Gets a particular command line parameter + + @param nParam The index of the parameter to return. + + @return The command line parameter as an OUString + + @see GetCommandLineParamCount, GetAppFileName + */ + static OUString GetCommandLineParam( sal_uInt16 nParam ); + + /** Get the name of the file used to start the application + + @return The filename as an OUString + + @see GetCommandLineParamCount, GetCommandLineParam + */ + static OUString GetAppFileName(); + + ///@} + + /** @name Error Handling + + \em Very rudimentary error handling is done by these + functions. + + @{ + */ + + /** Handles an error. + + @param nCategory The error category, see include/vcl/exceptiontypes.hxx + + @see Abort + */ + virtual void Exception( ExceptionCategory nCategory ); + + /** Ends the program prematurely with an error message. + + If the \code --norestore \endcode command line argument is given (assuming + this process is run by developers who are interested in cores, + vs. end users who are not) then it does a coredump. + + @param rErrorText The error message to report. + + @see Exception + */ + static void Abort( const OUString& rErrorText ); + + ///@} + + /** @name Event Loop Functions + + Functions that handle the LibreOffice main event loop are here, + including a global lock called the Solar Mutex. + */ + ///@{ + + /** Run the main event processing loop until it is quit by Quit(). + + @see Quit, Reschedule, Yield, EndYield, GetSolarMutex, + IsMainThread, ReleaseSolarMutex, AcquireSolarMutex, + */ + static void Execute(); + + /** Quit the program + + @see Execute, Reschedule, Yield, EndYield, GetSolarMutex, + IsMainThread, ReleaseSolarMutex, AcquireSolarMutex, + */ + static void Quit(); + + /** Has Quit() been called? + */ + static bool IsQuit(); + + /** Attempt to process current pending event(s) + + It doesn't sleep if no events are available for processing. + This doesn't process any events generated after invoking the function. + So in contrast to Scheduler::ProcessEventsToIdle, this cannot become + busy-locked by an event-generating event in the event queue. + + @param bHandleAllCurrentEvents If set to true, then try to process all + the current events. If set to false, then only process one event. + Defaults to false. + + @returns true if any event was processed. + + @see Yield, Scheduler::ProcessEventsToIdle + */ + static bool Reschedule( bool bHandleAllCurrentEvents = false ); + + /** Process the next event. + + It sleeps if no event is available for processing and just returns + if an event was processed. + + @see Execute, Quit, Reschedule, EndYield, GetSolarMutex, + IsMainThread, ReleaseSolarMutex, AcquireSolarMutex, + */ + static void Yield(); + + /** + + @see Execute, Quit, Reschedule, Yield, GetSolarMutex, + IsMainThread, ReleaseSolarMutex, AcquireSolarMutex, + */ + static void EndYield(); + + /** @brief Get the Solar Mutex for this thread. + + Get the Solar Mutex that prevents other threads from accessing VCL + concurrently. + + @returns SolarMutex reference + + @see Execute, Quit, Reschedule, Yield, EndYield, + IsMainThread, ReleaseSolarMutex, AcquireSolarMutex, + */ + static comphelper::SolarMutex& GetSolarMutex(); + + /** Queries whether we are in main thread. + + @returns true if we are in main thread, false if not + + @see Execute, Quit, Reschedule, Yield, EndYield, GetSolarMutex, + ReleaseSolarMutex, AcquireSolarMutex, + */ + static bool IsMainThread(); + + /** @brief Release Solar Mutex(es) for this thread + + Release the Solar Mutex(es) that prevents other threads from accessing + VCL concurrently. + + @returns The number of mutexes that were acquired by this thread. + + @see Execute, Quit, Reschedule, Yield, EndYield, GetSolarMutex, + IsMainThread, AcquireSolarMutex, + */ + static sal_uInt32 ReleaseSolarMutex(); + + /** @brief Acquire Solar Mutex(es) for this thread. + + Acquire the Solar Mutex(es) that prevents other threads from accessing + VCL concurrently. + + @see Execute, Quit, Reschedule, Yield, EndYield, GetSolarMutex, + IsMainThread, ReleaseSolarMutex, + */ + static void AcquireSolarMutex( sal_uInt32 nCount ); + + /** Queries whether the application is in "main", i.e. not yet in + the event loop + + @returns true if in main, false if not in main + + @see IsInExecute, IsInModalMode + */ + static bool IsInMain(); + + /** Queries whether the application is in the event loop + + @returns true if in the event loop, false if not + + @see IsInMain, IsInModalMode + */ + static bool IsInExecute(); + + /** Queries whether application has a modal dialog active. + + @returns true if a modal dialog is active, false if not + + @see IsInMain, IsInExecute + */ + static bool IsInModalMode(); + + /** Return how many events are being dispatched. + + @returns the number of events currently being dispatched + */ + static sal_uInt16 GetDispatchLevel(); + + /** Determine if there are any pending input events. + + @param nType input identifier, defined in include/vcl/inputtypes.hxx + The default is VCL_INPUT_ANY. + + @returns true if there are pending events, false if not. + + @see GetLastInputInterval + */ + static bool AnyInput( VclInputFlags nType = VCL_INPUT_ANY ); + + /** The interval from the last time that input was received. + + @returns system ticks - last input time + + @see AnyInput + */ + static sal_uInt64 GetLastInputInterval(); + + ///@} + + /* Determines if the UI is captured. + + The UI is considered captured if a system dialog is open (e.g. printer setup), + a floating window, menu or toolbox dropdown is open, or a window has been + captured by the mouse. + + @returns true if UI is captured, false if not + */ + static bool IsUICaptured(); + + /** @name Settings + + The following functions set system settings (e.g. tab color, etc.). There are functions + that set settings objects, and functions that set and get the actual system settings for + the application. + */ + ///@{ + + /** Sets user settings in settings object to override system settings + + The system settings that can be overridden are: + - window dragging options (on or off, including live scrolling!) + - style settings (e.g. checkbox color, border color, 3D colors, + button rollover colors, etc.) + - mouse settings + - menu options, including the mouse follows the menu and whether menu + icons are used + + @param rSettings Reference to the settings object to change. + + @see MergeSystemSettings, SetSettings, GetSettings + */ + virtual void OverrideSystemSettings( AllSettings& rSettings ); + + /** Set the settings object to the platform/desktop environment system + settings. + + @param rSettings Reference to the settings object to change. + + @see OverrideSystemSettings, SetSettings, GetSettings + */ + static void MergeSystemSettings( AllSettings& rSettings ); + + /** Sets the application's settings and notifies all windows of the + change. + + @param rSettings const reference to settings object used to + change the application's settings. + + @see OverrideSystemSettings, MergeSystemSettings, GetSettings + */ + static void SetSettings( const AllSettings& rSettings ); + + /** Gets the application's settings. If the application hasn't initialized + it's settings, then it does so (lazy initialization). + + @returns AllSettings instance that contains the current settings of the + application. + + @see OverrideSystemSettings, MergeSystemSettings, SetSettings + */ + static const AllSettings& GetSettings(); + + /** Get the application's locale data wrapper. + + @returns reference to a LocaleDataWrapper object + */ + static const LocaleDataWrapper& GetAppLocaleDataWrapper(); + + ///@} + + /** @name Event Listeners/Handlers + + A set of event listeners and callers. Note that in this code there is + platform specific functions - namely for zoom and scroll events. + */ + ///@{ + + + /** Add a VCL event listener to the application. If no event listener exists, + then initialize the application's event listener with a new one, then add + the event listener. + + @param rEventListener Const reference to the event listener to add. + + @see RemoveEventListener, AddKeyListener, RemoveKeyListener + */ + static void AddEventListener( const Link<VclSimpleEvent&,void>& rEventListener ); + + /** Remove a VCL event listener from the application. + + @param rEventListener Const reference to the event listener to be removed + + @see AddEventListener, AddKeyListener, RemoveKeyListener + */ + static void RemoveEventListener( const Link<VclSimpleEvent&,void>& rEventListener ); + + /** Add a keypress listener to the application. If keypress listener exists, + then initialize the application's keypress event listener with a new one, then + add the keypress listener. + + @param rKeyListener Const reference to the keypress event listener to add + + @see AddEventListener, RemoveEventListener, RemoveKeyListener + */ + static void AddKeyListener( const Link<VclWindowEvent&,bool>& rKeyListener ); + + /** Remove a keypress listener from the application. + + @param rKeyListener Const reference to the keypress event listener to be removed + + @see AddEventListener, RemoveEventListener, AddKeyListener + */ + static void RemoveKeyListener( const Link<VclWindowEvent&,bool>& rKeyListener ); + + /** Send event to all VCL application event listeners + + @param pWin Pointer to window to send event + @param pData Pointer to data to send with event + + @see ImplCallEventListeners(VclSimpleEvent* pEvent) + */ + static void ImplCallEventListenersApplicationDataChanged( void* pData ); + + /** Send event to all VCL application event listeners + + @param rEvent Reference to VclSimpleEvent + + @see ImplCallEventListeners(sal_uLong nEvent, Windows* pWin, void* pData); + */ + static void ImplCallEventListeners( VclSimpleEvent& rEvent ); + + /** Handle keypress event + + @param nEvent Event ID for keypress + @param pWin Pointer to window that receives the event + @param pKeyEvent Received key event + + @see PostKeyEvent + */ + static bool HandleKey( VclEventId nEvent, vcl::Window *pWin, KeyEvent* pKeyEvent ); + + /** Send keypress event + + @param nEvent Event ID for keypress + @param pWin Pointer to window to which the event is sent + @param pKeyEvent Key event to send + + @see HandleKey + */ + static ImplSVEvent * PostKeyEvent( VclEventId nEvent, vcl::Window *pWin, KeyEvent const * pKeyEvent ); + + + static bool LOKHandleMouseEvent( VclEventId nEvent, vcl::Window *pWin, const MouseEvent* pEvent ); + + /** Send mouse event + + @param nEvent Event ID for mouse event + @param pWin Pointer to window to which the event is sent + @param pMouseEvent Mouse event to send + */ + static ImplSVEvent * PostMouseEvent( VclEventId nEvent, vcl::Window *pWin, MouseEvent const * pMouseEvent ); + + static ImplSVEvent* PostGestureEvent(VclEventId nEvent, vcl::Window* pWin, GestureEvent const * pGestureEvent); + + /** Remove mouse and keypress events from a window... any also zoom and scroll events + if the platform supports it. + + @param pWin Window to remove events from + + @see HandleKey, PostKeyEvent, PostMouseEvent + */ + static void RemoveMouseAndKeyEvents( vcl::Window *pWin ); + + /** Post a user event to the default window. + + User events allow for the deferral of work to later in the main-loop - at idle. + + Execution of the deferred work is thread-safe which means all the tasks are executed + serially, so no thread-safety locks between tasks are necessary. + + @param rLink Link to event callback function + @param pCaller Pointer to data sent to the event by the caller. Optional. + @param bReferenceLink If true - hold a VclPtr<> reference on the Link's instance. + Taking the reference is guarded by a SolarMutexGuard. + + @return the event ID used to post the event. + */ + static ImplSVEvent * PostUserEvent( const Link<void*,void>& rLink, void* pCaller = nullptr, + bool bReferenceLink = false ); + + /** Remove user event based on event ID + + @param nUserEvent User event to remove + */ + static void RemoveUserEvent( ImplSVEvent * nUserEvent ); + + /*** Get the DisplayConnection. + + It is a reference to XDisplayConnection, which allows toolkits to send display + events to the application. + + @returns UNO reference to an object that implements the css:awt:XDisplayConnection + interface. + */ + static css::uno::Reference< css::awt::XDisplayConnection > GetDisplayConnection(); + + /** @deprecated AppEvent is used only in the Desktop class now. However, it is + intended to notify the application that an event has occurred. It was in oldsv.cxx, + but is still needed by a number of functions. + + @param rAppEvent const reference to ApplicationEvent event + */ + virtual void AppEvent( const ApplicationEvent& rAppEvent ); + + ///@} + + /** @name Application Window Functions + + Functions that deal with the application's windows + */ + ///@{ + + /** Get the currently focused window. + + @returns Pointer to focused window. + + @see GetDefaultDevice + */ + static vcl::Window* GetFocusWindow(); + + /** Get the default "device" (in this case the default window). + + @returns Pointer to an OutputDevice. However, it is a Window object - + Window class subclasses OutputDevice. + + @see GetFocusWindow + */ + static OutputDevice* GetDefaultDevice(); + + /** Get the first top-level window of the application. + + @returns Pointer to top-level window (a Window object) + + @see GetNextTopLevelWindow, GetTopWindowCount, GetTopWindow, + GetActiveTopWindow + */ + static vcl::Window* GetFirstTopLevelWindow(); + + /** Get the next top level window. + + @param pWindow Pointer to Window object you wish to get the next + window from. + + @returns Pointer to next top window. + */ + static vcl::Window* GetNextTopLevelWindow( vcl::Window const * pWindow ); + + /** Return the number of top-level windows being used by the application + + @returns the number of top-level windows + + @see GetFirstTopLevelWindow, GetNextTopLevelWindow, GetTopWindow, + GetActiveTopWindow + + */ + static tools::Long GetTopWindowCount(); + + /** Get the nth top window. + + @remark Top windows are actually implemented in a one-way linked list. + This iterates through top level windows n times. + + @param nIndex The index of the top-level window + + @returns The nth top-level window of the application + + @see GetFirstTopLevelWindow, GetNextTopLevelWindow, GetTopWindowCount, + GetActiveTopWindow + */ + static vcl::Window* GetTopWindow( tools::Long nIndex ); + + /** Get the "active" top window. + + An "active" top window is one that has a child window that has the + application's focus. + + @returns the active top window + + @see GetFirstTopLevelWindow, GetNextTopLevelWindow, GetTopWindowCount, + GetTopWindow + */ + static vcl::Window* GetActiveTopWindow(); + + ///@} + + /** Set the application's name. + + @param rUniqueName What to set the application name to + + @see GetAppName + */ + static void SetAppName( const OUString& rUniqueName ); + + + /** @name Application Name, Branding + */ + ///@{ + + /** Get the application's name. + + @returns The application name. + */ + static OUString GetAppName(); + + /** + * Get the OS version based on the OS specific implementation. + * + * @return OUString version string or "-" in case of problems + */ + static OUString GetOSVersion(); + + /** Get useful OS, Hardware and configuration information, + * cf. Help->About, and User-Agent + * bSelection = 0 to return all info, 1 for environment only, + * and 2 for VCL/render related infos + */ + static OUString GetHWOSConfInfo(const int bSelection = 0, bool bLocalize = true); + + /** Load a localized branding PNG file as a bitmap. + + @param pName Name of the bitmap to load. + @param rBitmap Reference to BitmapEx object to load PNG into + + @returns true if the PNG could be loaded, otherwise returns false. + */ + static bool LoadBrandBitmap (const char* pName, BitmapEx &rBitmap); + + ///@} + + /** @name Display and Screen + */ + ///@{ + + /** Set the default name of the application for message dialogs and printing. + + @param rDisplayName const reference to string to set the Display name to. + + @see GetDisplayName + */ + static void SetDisplayName( const OUString& rDisplayName ); + + /** Get the default name of the application for message dialogs and printing. + + @returns The display name of the application. + */ + static OUString GetDisplayName(); + + /** Get the toolkit's name. e.g. gtk3 + + @returns The toolkit name. + */ + static OUString GetToolkitName(); + + /** Get the number of screens available for the display. + + @returns The number of screens available. + + @see GetScreenPosSizePixel + */ + static unsigned int GetScreenCount(); + + /** Get a screen's rectangular area. + + @param nScreen The number of the screen requested. + + @returns The area of the screen in a Rectangle object. + + @see GetScreenCount + */ + static tools::Rectangle GetScreenPosSizePixel( unsigned int nScreen ); + + /** Determines if the screens that make up a display are separate or + form one large display area. + + @returns true when screens form up one large display area windows can be + moved between single screens (e.g. Xserver with Xinerama, Windows) + and false when different screens are separate and windows cannot be moved + between them (e.g. Xserver with multiple screens) + + @see GetBestScreen, GetDisplayBuiltInScreen + */ + static bool IsUnifiedDisplay(); + + /** Get the "best" screen. + + @returns If IsUnifiedDisplay() == true the return value will be + nearest screen of the target rectangle. + + In case of IsUnifiedDisplay() == false the return value + will always be GetDisplayDefaultScreen(). + + @see IsUnifiedDisplay, GetDisplayBuiltInScreen + */ + SAL_DLLPRIVATE static unsigned int GetBestScreen( const tools::Rectangle& ); + + /** Get the built-in screen. + + @return + This returns the LCD screen number for a laptop, or the primary + external VGA display for a desktop machine - it is where a presenter + console should be rendered if there are other (non-built-in) screens + present. + + @see IsUnifiedDisplay, GetBestScreen + */ + static unsigned int GetDisplayBuiltInScreen(); + + /** Get the display's external screen. + + Practically, this means - Get the screen we should run a presentation on. + + @returns 0 or 1 currently, will fallback to the first available screen if + there are more than one external screens. May be changed in the future. + */ + static unsigned int GetDisplayExternalScreen(); + + ///@} + + /** @name Accelerators and Mnemonics + + Accelerators allow a user to hold down Ctrl+key (or CMD+key on macOS) + combination to gain quick access to functionality. + + Mnemonics are underline letters in things like menus and dialog boxes + that allow a user to type in the letter to activate the menu or option. + */ + ///@{ + + /** Insert accelerator + + @param pAccel Pointer to an Accelerator object to insert + + @returns true if successful, false if otherwise + + @see RemoveAccel + */ + static bool InsertAccel( Accelerator* pAccel ); + + /** Remove accelerator + + @param pAccel Pointer to Accelerator object to remove + + @see InsertAccel + */ + static void RemoveAccel( Accelerator const * pAccel ); + + /** Get the number of reserved key codes used by the application. + + @returns number of reserved key codes + + @see GetReservedKeyCode + */ + static size_t GetReservedKeyCodeCount(); + + /** Get the reserved key code. + + @param i The keycode number to retrieve + + @returns Const pointer to a KeyCode object + + @see GetReservedKeyCodeCount + */ + static const vcl::KeyCode* GetReservedKeyCode( size_t i ); + + ///@} + + /** @name Application Help + + Deals with the help system, and "auto-help", where a user hovers a mouse above + a UI element and a tooltip with an explanation pops up. + */ + ///@{ + + /** Sets up help + + @param pHelp Pointer to a Help object (optional, can by NULL) + + @see GetHelp + */ + static void SetHelp( Help* pHelp = nullptr ); + + /** Gets the application's help + + @returns Pointer to application's help object. Note that the application may + not have a help object, so it might return NULL. + + @see SetHelp + */ + static Help* GetHelp(); + + ///@} + + /** @name Dialogs + + @remark "Dialog cancel mode" tells a headless install whether to + cancel dialogs when they appear. See the DialogCancelMode + enumerator. + */ + ///@{ + + /** Get the default parent window for dialog boxes. + + @remark This is almost always a terrible method to use to get a parent + for a dialog, try hard to instead pass a specific parent window + to dialogs. + + GetDefDialogParent does all sorts of things to try and find a useful + parent window for dialogs. It first uses the topmost parent of the + active window to avoid using floating windows or other dialog boxes. + If there are no active windows, then it will take a random stab and + choose the first visible top window. Otherwise, it defaults to + the desktop. + + @returns Pointer to the default window. + */ + static weld::Window* GetDefDialogParent(); + + + /** Gets the dialog cancel mode for headless environments. + + @return DialogCancelMode value + + @see SetDialogCancelMode, IsDialogCancelEnabled + */ + static DialogCancelMode GetDialogCancelMode(); + + /** Sets the dialog cancel mode for headless environments. + + This should be private, but XFrameImpl needs to access it and current + baseline gcc doesn't support forward definition of anonymous classes. + You probably should use EnableHeadlessMode instead. + + @param mode DialogCancel mode value + + @see GetDialogCancelMode, IsDialogCancelEnabled, EnableHeadlessMode + */ + static void SetDialogCancelMode( DialogCancelMode mode ); + + /** Determines if dialog cancel mode is enabled. + + @returns True if dialog cancel mode is enabled, false if disabled. + + @see GetDialogCancelMode, SetDialogCancelMode + */ + static bool IsDialogCancelEnabled(); + + + /** Make a dialog box a system window or not. + + @param nMode Can be either: SystemWindowFlags::NOAUTOMODE (0x0001) or + SystemWindowFlags::DIALOG (0x0002) + + @see GetSystemWindowMode + */ + static void SetSystemWindowMode( SystemWindowFlags nMode ); + + /** Get the system window mode of dialogs. + + @returns SystemWindowFlags::NOAUTOMODE (0x0001) or SystemWindowFlags::DIALOG (0x0002) + + @see SetSystemWindowMode + */ + static SystemWindowFlags GetSystemWindowMode(); + + ///@} + + /** @name VCL Toolkit and UNO Wrapper + + The VCL Toolkit implements the UNO XToolkit interface, which specifies a + factory interface for the window toolkit. It is similar to the abstract window + toolkit (AWT) in Java. + + */ + ///@{ + + /** Gets the VCL toolkit. + + @attention The global service manager has to be created before getting the toolkit! + + @returns UNO reference to VCL toolkit + */ + static css::uno::Reference< css::awt::XToolkit > GetVCLToolkit(); + + ///@} + + + /*** @name Graphic Filters + */ + ///@{ + + /** Setup a new graphics filter + + @param rLink Const reference to a Link object, which the filter calls upon. + + @see GetFilterHdl + */ + static void SetFilterHdl( const Link<ConvertData&,bool>& rLink ); + + ///@} + + /** @name Headless Mode + */ + + /** Enables headless mode. + + @param dialogsAreFatal Set to true if a dialog ends the session, false if not. + */ + static void EnableHeadlessMode( bool dialogsAreFatal ); + + /** Determines if headless mode is enabled + + @return True if headless mode is enabled, false if not. + */ + static bool IsHeadlessModeEnabled(); + + /** Enable Console Only mode + + Convenience function to enable headless and bitmap rendering. + */ + static void EnableConsoleOnly(); + + /** Enable software-only bitmap rendering + */ + static void EnableBitmapRendering(); + + /** Determines if bitmap rendering is enabled + + @return True if bitmap rendering is enabled. + */ + static bool IsBitmapRendering(); + + ///@} + + /** @name Event Testing Mode + */ + + /** Enables event testing mode. + + */ + static void EnableEventTestingMode(); + + /** Determines if event testing mode is enabled + + @return True if event testing mode is enabled, false if not. + */ + static bool IsEventTestingModeEnabled(); + + /** Set safe mode to enabled */ + static void EnableSafeMode(); + + /** Determines if safe mode is enabled */ + static bool IsSafeModeEnabled(); + + ///@} + + /** Get the desktop environment the process is currently running in + + @returns String representing the desktop environment + */ + static const OUString& GetDesktopEnvironment(); + + /*** @name Platform Functionality + */ + ///@{ + + /** Add a file to the system shells recent document list if there is any. + This function may have no effect under Unix because there is no standard + API among the different desktop managers. + + @param rFileUrl The file url of the document. + + @param rMimeType The mime content type of the document specified by aFileUrl. + If an empty string will be provided "application/octet-stream" + will be used. + + @param rDocumentService The app (or "document service") you will be adding the file to + e.g. com.sun.star.text.TextDocument + */ + static void AddToRecentDocumentList(const OUString& rFileUrl, const OUString& rMimeType, const OUString& rDocumentService); + + /*** Show a native error messagebox + + @param sTitle Title of error messagebox + + @param sMessage Message displayed in messagebox + */ + static void ShowNativeErrorBox(const OUString& sTitle , + const OUString& sMessage); + + /** Update main thread identifier */ + static void UpdateMainThread(); + + /** Do we have a native / system file selector available? + + @returns True if native file selector is available, false otherwise. + */ + static bool hasNativeFileSelection(); + + /** Create a platform specific file picker, if one is available, otherwise return an + empty reference. + + @param rServiceManager Const reference to a UNO component context (service manager). + + @returns File picker if available, otherwise an empty reference. + */ + static css::uno::Reference< css::ui::dialogs::XFilePicker2 > + createFilePicker( const css::uno::Reference< css::uno::XComponentContext >& rServiceManager ); + + /** Create a platform specific folder picker, if one is available, otherwise return an + empty reference + + @param rServiceManager Const reference to a UNO component context (service manager). + + @returns Folder picker if available, otherwise an empty reference. + */ + static css::uno::Reference< css::ui::dialogs::XFolderPicker2 > + createFolderPicker( const css::uno::Reference< css::uno::XComponentContext >& rServiceManager ); + + /** Cancel all open dialogs + */ + static void EndAllDialogs(); + + /** Cancel all open popups + */ + static void EndAllPopups(); + + /** Returns true, if the VCL plugin runs on the system event loop. + * + * AKA the VCL plugin can't handle nested event loops, like WASM or mobile. + */ + static bool IsOnSystemEventLoop(); + + ///@} + + // For vclbootstrapprotector: + static void setDeInitHook(Link<LinkParamNone*,void> const & hook); + + static std::unique_ptr<weld::Builder> CreateBuilder(weld::Widget* pParent, const OUString &rUIFile, bool bMobile = false, sal_uInt64 nLOKWindowId = 0); + // For the duration of vcl parent windows + static std::unique_ptr<weld::Builder> CreateInterimBuilder(vcl::Window* pParent, const OUString &rUIFile, bool bAllowCycleFocusOut, sal_uInt64 nLOKWindowId = 0); + + static weld::MessageDialog* CreateMessageDialog(weld::Widget* pParent, VclMessageType eMessageType, + VclButtonsType eButtonType, const OUString& rPrimaryMessage, + bool bMobile = false); + + static weld::Window* GetFrameWeld(const css::uno::Reference<css::awt::XWindow>& rWindow); + + // ILibreOfficeKitNotifier + void* m_pCallbackData; + LibreOfficeKitCallback m_pCallback; + + virtual void notifyWindow(vcl::LOKWindowId nLOKWindowId, + const OUString& rAction, + const std::vector<vcl::LOKPayloadItem>& rPayload = std::vector<vcl::LOKPayloadItem>()) const override; + virtual void libreOfficeKitViewCallback(int nType, const char* pPayload) const override; + +private: + DECL_DLLPRIVATE_STATIC_LINK( Application, PostEventHandler, void*, void ); +}; + +class SolarMutexGuard + : public osl::Guard<comphelper::SolarMutex> +{ +public: + SolarMutexGuard() + : osl::Guard<comphelper::SolarMutex>( Application::GetSolarMutex() ) {} +}; + +class SolarMutexClearableGuard + : public osl::ClearableGuard<comphelper::SolarMutex> +{ +public: + SolarMutexClearableGuard() + : osl::ClearableGuard<comphelper::SolarMutex>( Application::GetSolarMutex() ) {} +}; + +class SolarMutexResettableGuard + : public osl::ResettableGuard<comphelper::SolarMutex> +{ +public: + SolarMutexResettableGuard() + : osl::ResettableGuard<comphelper::SolarMutex>( Application::GetSolarMutex() ) {} +}; + +namespace vcl +{ + +/** guard class that uses tryToAcquire() and has isAcquired() to check + */ +class SolarMutexTryAndBuyGuard +{ +private: + bool m_isAcquired; +#ifdef DBG_UTIL + bool m_isChecked; +#endif + comphelper::SolarMutex& m_rSolarMutex; + + SolarMutexTryAndBuyGuard(const SolarMutexTryAndBuyGuard&) = delete; + SolarMutexTryAndBuyGuard& operator=(const SolarMutexTryAndBuyGuard&) = delete; + +public: + + SolarMutexTryAndBuyGuard() + : m_isAcquired(false) +#ifdef DBG_UTIL + , m_isChecked(false) +#endif + , m_rSolarMutex(Application::GetSolarMutex()) + + { + m_isAcquired = m_rSolarMutex.tryToAcquire(); + } + + ~SolarMutexTryAndBuyGuard() + { +#ifdef DBG_UTIL + assert(m_isChecked); +#endif + if (m_isAcquired) + m_rSolarMutex.release(); + } + + bool isAcquired() + { +#ifdef DBG_UTIL + m_isChecked = true; +#endif + return m_isAcquired; + } +}; + +} // namespace vcl + +/** + A helper class that calls Application::ReleaseSolarMutex() in its constructor + and restores the mutex in its destructor. +*/ +class SolarMutexReleaser +{ + const sal_uInt32 mnReleased; +public: + SolarMutexReleaser(): mnReleased(Application::ReleaseSolarMutex()) {} + ~SolarMutexReleaser() { Application::AcquireSolarMutex( mnReleased ); } +}; + +VCL_DLLPUBLIC Application* GetpApp(); + +// returns true if vcl is already initialized +VCL_DLLPUBLIC bool IsVCLInit(); +// returns true if vcl successfully initializes or was already initialized +VCL_DLLPUBLIC bool InitVCL(); +VCL_DLLPUBLIC void DeInitVCL(); + +VCL_DLLPUBLIC bool InitAccessBridge(); + +// only allowed to call, if no thread is running. You must call JoinMainLoopThread to free all memory. +VCL_DLLPUBLIC void CreateMainLoopThread( oslWorkerFunction pWorker, void * pThreadData ); +VCL_DLLPUBLIC void JoinMainLoopThread(); + +/// The following are to manage per-view (frame) help data. +struct ImplSVHelpData; +VCL_DLLPUBLIC ImplSVHelpData* CreateSVHelpData(); +VCL_DLLPUBLIC void DestroySVHelpData(ImplSVHelpData*); +VCL_DLLPUBLIC void SetSVHelpData(ImplSVHelpData*); + +/// The following are to manage per-view (frame) window data. +struct ImplSVWinData; +VCL_DLLPUBLIC ImplSVWinData* CreateSVWinData(); +VCL_DLLPUBLIC void DestroySVWinData(ImplSVWinData*); +VCL_DLLPUBLIC void SetSVWinData(ImplSVWinData*); + +inline void Application::EndYield() +{ + PostUserEvent( Link<void*,void>() ); +} + +#endif // _APP_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |