diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-28 14:29:10 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-28 14:29:10 +0000 |
commit | 2aa4a82499d4becd2284cdb482213d541b8804dd (patch) | |
tree | b80bf8bf13c3766139fbacc530efd0dd9d54394c /gfx/src/X11Util.h | |
parent | Initial commit. (diff) | |
download | firefox-2aa4a82499d4becd2284cdb482213d541b8804dd.tar.xz firefox-2aa4a82499d4becd2284cdb482213d541b8804dd.zip |
Adding upstream version 86.0.1.upstream/86.0.1upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'gfx/src/X11Util.h')
-rw-r--r-- | gfx/src/X11Util.h | 143 |
1 files changed, 143 insertions, 0 deletions
diff --git a/gfx/src/X11Util.h b/gfx/src/X11Util.h new file mode 100644 index 0000000000..fc583fb6d4 --- /dev/null +++ b/gfx/src/X11Util.h @@ -0,0 +1,143 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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/. */ + +#ifndef mozilla_X11Util_h +#define mozilla_X11Util_h + +// Utilities common to all X clients, regardless of UI toolkit. + +#if defined(MOZ_WIDGET_GTK) +# include <gdk/gdk.h> +# include <gdk/gdkx.h> +# include "X11UndefineNone.h" +#else +# error Unknown toolkit +#endif + +#include <string.h> // for memset +#include "mozilla/Scoped.h" // for SCOPED_TEMPLATE + +namespace mozilla { + +/** + * Return the default X Display created and used by the UI toolkit. + */ +inline Display* DefaultXDisplay() { +#if defined(MOZ_WIDGET_GTK) + GdkDisplay* gdkDisplay = gdk_display_get_default(); + if (GDK_IS_X11_DISPLAY(gdkDisplay)) { + return GDK_DISPLAY_XDISPLAY(gdkDisplay); + } +#endif + return nullptr; +} + +/** + * Sets *aVisual to point to aDisplay's Visual struct corresponding to + * aVisualID, and *aDepth to its depth. When aVisualID is None, these are set + * to nullptr and 0 respectively. Both out-parameter pointers are assumed + * non-nullptr. + */ +void FindVisualAndDepth(Display* aDisplay, VisualID aVisualID, Visual** aVisual, + int* aDepth); + +/** + * Ensure that all X requests have been processed. + * + * This is similar to XSync, but doesn't need a round trip if the previous + * request was synchronous or if events have been received since the last + * request. Subsequent FinishX calls will be noops if there have been no + * intermediate requests. + */ + +void FinishX(Display* aDisplay); + +/** + * Invoke XFree() on a pointer to memory allocated by Xlib (if the + * pointer is nonnull) when this class goes out of scope. + */ +template <typename T> +struct ScopedXFreePtrTraits { + typedef T* type; + static T* empty() { return nullptr; } + static void release(T* ptr) { + if (ptr != nullptr) XFree(ptr); + } +}; +SCOPED_TEMPLATE(ScopedXFree, ScopedXFreePtrTraits) + +/** + * On construction, set a graceful X error handler that doesn't crash the + * application and records X errors. On destruction, restore the X error handler + * to what it was before construction. + * + * The SyncAndGetError() method allows to know whether a X error occurred, + * optionally allows to get the full XErrorEvent, and resets the recorded X + * error state so that a single X error will be reported only once. + * + * Nesting is correctly handled: multiple nested ScopedXErrorHandler's don't + * interfere with each other's state. However, if SyncAndGetError is not called + * on the nested ScopedXErrorHandler, then any X errors caused by X calls made + * while the nested ScopedXErrorHandler was in place may then be caught by the + * other ScopedXErrorHandler. This is just a result of X being asynchronous and + * us not doing any implicit syncing: the only method in this class what causes + * syncing is SyncAndGetError(). + * + * This class is not thread-safe at all. It is assumed that only one thread is + * using any ScopedXErrorHandler's. Given that it's not used on Mac, it should + * be easy to make it thread-safe by using thread-local storage with __thread. + */ +class ScopedXErrorHandler { + public: + // trivial wrapper around XErrorEvent, just adding ctor initializing by zero. + struct ErrorEvent { + XErrorEvent mError; + + ErrorEvent() { memset(this, 0, sizeof(ErrorEvent)); } + }; + + private: + // this ScopedXErrorHandler's ErrorEvent object + ErrorEvent mXError; + + // static pointer for use by the error handler + static ErrorEvent* sXErrorPtr; + + // what to restore sXErrorPtr to on destruction + ErrorEvent* mOldXErrorPtr; + + // what to restore the error handler to on destruction + int (*mOldErrorHandler)(Display*, XErrorEvent*); + + public: + static int ErrorHandler(Display*, XErrorEvent* ev); + + /** + * @param aAllowOffMainThread whether to warn if used off main thread + */ + explicit ScopedXErrorHandler(bool aAllowOffMainThread = false); + + ~ScopedXErrorHandler(); + + /** \returns true if a X error occurred since the last time this method was + * called on this ScopedXErrorHandler object, or since the creation of this + * ScopedXErrorHandler object if this method was never called on it. + * + * \param ev this optional parameter, if set, will be filled with the + * XErrorEvent object. If multiple errors occurred, the first one will be + * returned. + */ + bool SyncAndGetError(Display* dpy, XErrorEvent* ev = nullptr); +}; + +class OffMainThreadScopedXErrorHandler : public ScopedXErrorHandler { + public: + OffMainThreadScopedXErrorHandler() : ScopedXErrorHandler(true) {} +}; + +} // namespace mozilla + +#endif // mozilla_X11Util_h |