1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
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
|
