use the new non-static display
[mikachu/openbox.git] / src / openbox.hh
1 // -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*-
2 #ifndef   __openbox_hh
3 #define   __openbox_hh
4
5 /*! @file openbox.hh
6   @brief The main class for the Openbox window manager
7 */
8
9 extern "C" {
10 #include <X11/Xlib.h>
11 }
12
13 #include <string>
14 #include <vector>
15 #include <map>
16
17 #include "otk/display.hh"
18 #include "otk/screeninfo.hh"
19 #include "otk/timerqueuemanager.hh"
20 #include "otk/property.hh"
21 #include "otk/configuration.hh"
22 #include "otk/eventdispatcher.hh"
23 #include "otk/eventhandler.hh"
24
25 namespace ob {
26
27 class Screen;
28 class Client;
29 class Actions;
30 class Bindings;
31
32 //! Mouse cursors used throughout Openbox
33 struct Cursors {
34   Cursor session;  //!< The default mouse cursor
35   Cursor move;     //!< For moving a window
36   Cursor ll_angle; //!< For resizing the bottom left corner of a window
37   Cursor lr_angle; //!< For resizing the bottom right corner of a window
38   Cursor ul_angle; //!< For resizing the top left corner of a window
39   Cursor ur_angle; //!< For resizing the right corner of a window
40 };
41
42 class Openbox;
43
44 //! The single instance of the Openbox class for the application
45 /*!
46   Since this variable is globally available in the application, the Openbox
47   class does not need to be passed around to any of the other classes.
48 */
49 extern Openbox *openbox;
50
51 //! The main class for the Openbox window manager
52 /*!
53   Only a single instance of the Openbox class may be used in the application. A
54   pointer to this instance is held in the Openbox::instance static member
55   variable.
56   Instantiation of this class begins the window manager. After instantiation,
57   the Openbox::eventLoop function should be called. The eventLoop method does
58   not exit until the window manager is ready to be destroyed. Destruction of
59   the Openbox class instance will shutdown the window manager.
60 */
61 class Openbox : public otk::EventDispatcher, public otk::EventHandler
62 {
63 public:
64   //! The posible running states of the window manager
65   enum RunState {
66     State_Starting, //!< The window manager is starting up (being created)
67     State_Normal,   //!< The window manager is running in its normal state
68     State_Exiting   //!< The window manager is exiting (being destroyed)
69   };
70
71   //! A map for looking up a specific client class from the window id
72   typedef std::map<Window, Client *> ClientMap;
73
74   //! A list of Screen classes
75   typedef std::vector<Screen *> ScreenList;
76   
77 private:
78   //! The display on which Openbox is running
79   otk::Display _display;
80   
81   // stuff that can be passed on the command line
82   //! Path to the config file to use/in use
83   /*!
84     Defaults to $(HOME)/.openbox/rc3
85   */
86   std::string _rcfilepath;
87   //! Path to the menu file to use/in use
88   /*!
89     Defaults to $(HOME)/.openbox/menu3
90   */
91   std::string _menufilepath;
92   //! Path to the script file to execute on startup
93   /*!
94     Defaults to $(HOME)/.openbox/user.py
95   */
96   std::string _scriptfilepath;
97   //! The display requested by the user, or null to use the DISPLAY env var
98   char *_displayreq;
99   //! The value of argv, i.e. how this application was executed
100   char **_argv;
101   //! Run the application in synchronous mode? (for debugging)
102   bool _sync;
103   //! Should Openbox run on a single screen or on all available screens?
104   bool _single;
105
106   //! A list of all managed clients
107   ClientMap _clients;
108
109   //! A list of all the managed screens
110   ScreenList _screens;
111   
112   //! Manages all timers for the application
113   /*!
114     Use of the otk::TimerQueueManager::fire funtion in this object ensures
115     that all timers fire when their times elapse.
116   */
117   otk::TimerQueueManager _timermanager;
118
119   //! Cached atoms on the display
120   /*!
121     This is a pointer because the Property class uses otk::Display::display
122     in its constructor, so, it needs to be initialized <b>after</b> the display
123     is initialized in this class' constructor.
124   */
125   otk::Property *_property;
126
127   //! The action interface through which all user-available actions occur
128   Actions *_actions;
129
130   //! The interface through which keys/buttons are grabbed and handled
131   Bindings *_bindings;
132
133   //! The running state of the window manager
134   RunState _state;
135
136   //! Mouse cursors used throughout Openbox
137   Cursors _cursors;
138
139   //! When set to true, the Openbox::eventLoop function will stop and return
140   bool _shutdown;
141
142   //! When set to true, and Openbox is about to exit, it will spawn a new
143   //! process
144   bool _restart;
145
146   //! If this contains anything, a restart will try to execute the program in
147   //! this variable, and will fallback to reexec'ing itself if that fails
148   std::string _restart_prog;
149
150   //! The client with input focus
151   /*!
152     Updated by the clients themselves.
153   */
154   Client *_focused_client;
155
156   //! The screen with input focus
157   /*!
158     Updated by the clients when they update the Openbox::focused_client
159     property.
160   */
161   Screen *_focused_screen;
162   
163   //! Parses the command line used when executing this application
164   void parseCommandLine(int argv, char **argv);
165   //! Displays the version string to stdout
166   void showVersion();
167   //! Displays usage information and help to stdout
168   void showHelp();
169
170   //! Handles signal events for the application
171   static void signalHandler(int signal);
172
173 public:
174 #ifndef SWIG
175   //! Openbox constructor.
176   /*!
177     \param argc Number of command line arguments, as received in main()
178     \param argv The command line arguments, as received in main()
179   */
180   Openbox(int argc, char **argv);
181   //! Openbox destructor.
182   virtual ~Openbox();
183 #endif
184
185   //! Returns the state of the window manager (starting, exiting, etc)
186   inline RunState state() const { return _state; }
187
188   //! Returns the otk::TimerQueueManager for the application
189   /*!
190     All otk::Timer objects used in the application should be made to use this
191     otk::TimerQueueManager.
192   */
193   inline otk::TimerQueueManager *timerManager() { return &_timermanager; }
194
195   //! Returns the otk::Property instance for the window manager
196   inline const otk::Property *property() const { return _property; }
197
198   //! Returns the Actions instance for the window manager
199   inline Actions *actions() const { return _actions; }
200
201   //! Returns the Bindings instance for the window manager
202   inline Bindings *bindings() const { return _bindings; }
203
204   //! Returns a managed screen
205   inline Screen *screen(int num) {
206     assert(num >= 0); assert(num < (signed)_screens.size());
207     if (num >= screenCount())
208       return NULL;
209     return _screens[num];
210   }
211
212   //! Returns the number of managed screens
213   inline int screenCount() const {
214     return (signed)_screens.size();
215   }
216
217   //! Returns the mouse cursors used throughout Openbox
218   inline const Cursors &cursors() const { return _cursors; }
219
220 #ifndef SWIG
221   //! The main function of the Openbox class
222   /*!
223     This function should be called after instantiating the Openbox class.
224     It loops indefinately while handling all events for the application.
225     The Openbox::shutdown method will cause this function to exit.
226   */
227   void eventLoop();
228 #endif
229
230   //! Adds an Client to the client list for lookups
231   void addClient(Window window, Client *client);
232
233   //! Removes an Client from the client list for lookups
234   void removeClient(Window window);
235
236   //! Finds an Client based on its window id
237   Client *findClient(Window window);
238
239   //! The client with input focus
240   inline Client *focusedClient() { return _focused_client; }
241
242   //! Change the client which has focus.
243   /*!
244     This is called by the clients themselves when their focus state changes.
245   */
246   void setFocusedClient(Client *c);
247
248   //! The screen with input focus
249   inline Screen *focusedScreen() { return _focused_screen; }
250   
251   //! Requests that the window manager exit
252   /*!
253     Causes the Openbox::eventLoop function to stop looping, so that the window
254     manager can be destroyed.
255   */
256   inline void shutdown() { _shutdown = true; }
257
258   inline void restart(const std::string &bin = "") {
259     _shutdown = true; _restart = true; _restart_prog = bin;
260   }
261
262   //! Executes a command on a screen
263   void execute(int screen, const std::string &bin);
264 };
265
266 }
267
268 #endif // __openbox_hh