Debian Codegraph @

lib/Application.hh

raw
1 // -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*-
2 // Application.hh for Blackbox - an X11 Window manager
3 // Copyright (c) 2001 - 2005 Sean 'Shaleh' Perry <shaleh at debian.org>
4 // Copyright (c) 1997 - 2000, 2002 - 2005
5 // Bradley T Hughes <bhughes at trolltech.com>
6 //
7 // Permission is hereby granted, free of charge, to any person obtaining a
8 // copy of this software and associated documentation files (the "Software"),
9 // to deal in the Software without restriction, including without limitation
10 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 // and/or sell copies of the Software, and to permit persons to whom the
12 // Software is furnished to do so, subject to the following conditions:
13 //
14 // The above copyright notice and this permission notice shall be included in
15 // all copies or substantial portions of the Software.
16 //
17 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
23 // DEALINGS IN THE SOFTWARE.
24
25 #ifndef __Application_hh
26 #define __Application_hh
27
28 #include "Timer.hh"
29 #include "Util.hh"
30
31 #include <map>
32
33 namespace bt {
34
35 // forward declarations
36 class Display;
37 class EventHandler;
38 class Menu;
39
40 /*
41 The application object. It provides event delivery, timer
42 activation and signal handling functionality to fit most
43 application needs.
44 */
45 class Application : public TimerQueueManager, public NoCopy {
46 protected:
47 enum RunState { STARTUP, RUNNING, SHUTDOWN, SIGNALLED };
48
49 private:
50 struct {
51 bool extensions;
52 int event_basep, error_basep;
53 } shape;
54
55 Display *_display;
56 std::string _app_name;
57
58 RunState run_state;
59 Time xserver_time;
60
61 typedef std::map<Window,EventHandler*> EventHandlerMap;
62 EventHandlerMap eventhandlers;
63
64 timeval currentTime;
65 TimerQueue timerList;
66 void adjustTimers(const timeval &offset);
67
68 typedef std::deque<Menu*> MenuStack;
69 MenuStack menus;
70 bool menu_grab;
71 void openMenu(Menu *menu);
72 void closeMenu(Menu *menu);
73 friend class Menu; // give Menu access to the above 2 functions
74
75 unsigned int MaskList[8];
76 size_t MaskListLength;
77
78 // the masks of the modifiers which are ignored in button events.
79 unsigned int NumLockMask, ScrollLockMask;
80
81 protected:
82 inline RunState runState(void) const
83 { return run_state; }
84 inline void setRunState(RunState new_state)
85 { run_state = new_state; }
86
87 /*
88 Called from run() just before the event loop starts.
89 */
90 virtual void startup(void);
91 /*
92 Called from shutdown() after the event loop stops.
93 */
94 virtual void shutdown(void);
95
96 /*
97 Processes the X11 event {event} by delivering the event to the
98 appropriate EventHandler.
99
100 Reimplement this function if you need to filter/intercept events
101 before normal processing.
102 */
103 virtual void process_event(XEvent *event);
104
105 /*
106 Processes the specified signal. Returns true if the signal was
107 handled; otherwise it returns false.
108
109 Reimplement this function if you need to handle signals.
110 */
111 virtual bool process_signal(int signal);
112
113 public:
114 Application(const std::string &app_name, const char *dpy_name = 0,
115 bool multi_head = false);
116 virtual ~Application(void);
117
118 inline bool hasShapeExtensions(void) const
119 { return shape.extensions; }
120
121 inline bool startingUp(void) const
122 { return run_state == STARTUP; }
123 inline bool running(void) const
124 { return run_state == RUNNING; }
125 inline bool shuttingDown(void) const
126 { return run_state == SHUTDOWN; }
127
128 ::Display *XDisplay(void) const;
129 inline const Display& display(void) const
130 { return *_display; }
131 inline Time XTime() const
132 { return xserver_time; }
133
134 inline const std::string &applicationName(void) const
135 { return _app_name; }
136
137 void grabButton(unsigned int button, unsigned int modifiers,
138 Window grab_window, bool owner_events,
139 unsigned int event_mask, int pointer_mode,
140 int keyboard_mode, Window confine_to, Cursor cursor,
141 bool allow_scroll_lock) const;
142 void ungrabButton(unsigned int button, unsigned int modifiers,
143 Window grab_window) const;
144
145 void run(void);
146 inline void quit(void)
147 { setRunState( SHUTDOWN ); }
148
149 inline unsigned int scrollLockMask(void) const
150 { return ScrollLockMask; }
151 inline unsigned int numLockMask(void) const
152 { return NumLockMask; }
153
154 // from TimerQueueManager interface
155 virtual void addTimer(Timer *timer);
156 virtual void removeTimer(Timer *timer);
157
158 /*
159 Inserts the EventHandler {handler} for Window {window}. All
160 events generated for {window} will be sent through {handler}.
161 */
162 void insertEventHandler(Window window, EventHandler *handler);
163 /*
164 Removes all EventHandlers for Window {window}.
165 */
166 void removeEventHandler(Window window);
167 /*
168 Returns the event handler registered for Window {window}. If no
169 handler has been registered, this function returns zero.
170 */
171 EventHandler *findEventHandler(Window window);
172 };
173
174 } // namespace bt
175
176 #endif // __Application_hh