X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Fopenbox.hh;h=460caa0cee00c09d5353fecb35800caf9517309c;hb=ea8d450ed30c96c1a5dd627740ec4533eeae2a09;hp=80b20a168e70eaf59e013aa63a315849f3372983;hpb=06388d73b75d985ab10586bd116de7fac4ea2b8e;p=chaz%2Fopenbox diff --git a/src/openbox.hh b/src/openbox.hh index 80b20a16..460caa0c 100644 --- a/src/openbox.hh +++ b/src/openbox.hh @@ -14,19 +14,17 @@ extern "C" { #include #include +#include "otk/display.hh" #include "otk/screeninfo.hh" -#include "otk/timerqueuemanager.hh" -#include "otk/property.hh" -#include "otk/configuration.hh" #include "otk/eventdispatcher.hh" #include "otk/eventhandler.hh" namespace ob { -class OBScreen; -class OBClient; -class OBActions; -class OBBindings; +class Screen; +class Client; +class Actions; +class Bindings; //! Mouse cursors used throughout Openbox struct Cursors { @@ -38,6 +36,14 @@ struct Cursors { Cursor ur_angle; //!< For resizing the right corner of a window }; +class Openbox; + +//! The single instance of the Openbox class for the application +/*! + Since this variable is globally available in the application, the Openbox + class does not need to be passed around to any of the other classes. +*/ +extern Openbox *openbox; //! The main class for the Openbox window manager /*! @@ -49,16 +55,9 @@ struct Cursors { not exit until the window manager is ready to be destroyed. Destruction of the Openbox class instance will shutdown the window manager. */ -class Openbox : public otk::OtkEventDispatcher, public otk::OtkEventHandler +class Openbox : public otk::EventDispatcher, public otk::EventHandler { public: - //! The single instance of the Openbox class for the application - /*! - Since this variable is globally available in the application, the Openbox - class does not need to be passed around to any of the other classes. - */ - static Openbox *instance; - //! The posible running states of the window manager enum RunState { State_Starting, //!< The window manager is starting up (being created) @@ -67,10 +66,10 @@ public: }; //! A map for looking up a specific client class from the window id - typedef std::map ClientMap; + typedef std::map ClientMap; - //! A list of OBScreen classes - typedef std::vector ScreenList; + //! A list of Screen classes + typedef std::vector ScreenList; private: // stuff that can be passed on the command line @@ -89,40 +88,29 @@ private: Defaults to $(HOME)/.openbox/user.py */ std::string _scriptfilepath; - //! The display requested by the user, or null to use the DISPLAY env var - char *_displayreq; //! The value of argv, i.e. how this application was executed char **_argv; + //! Run the application in synchronous mode? (for debugging) + bool _sync; + //! Should Openbox run on a single screen or on all available screens? + bool _single; + //! Optimize for a remote/low-bandwidth connection to the display? + bool _remote; //! A list of all managed clients ClientMap _clients; //! A list of all the managed screens ScreenList _screens; - - //! Manages all timers for the application - /*! - Use of the otk::OBTimerQueueManager::fire funtion in this object ensures - that all timers fire when their times elapse. - */ - otk::OBTimerQueueManager _timermanager; - - //! Cached atoms on the display - /*! - This is a pointer because the OBProperty class uses otk::OBDisplay::display - in its constructor, so, it needs to be initialized after the display - is initialized in this class' constructor. - */ - otk::OBProperty *_property; + //! The number of managed screens + int _managed_count; + //! The action interface through which all user-available actions occur - OBActions *_actions; + Actions *_actions; //! The interface through which keys/buttons are grabbed and handled - OBBindings *_bindings; - - //! Run the application in synchronous mode? (for debugging) - bool _sync; + Bindings *_bindings; //! The running state of the window manager RunState _state; @@ -145,14 +133,14 @@ private: /*! Updated by the clients themselves. */ - OBClient *_focused_client; + Client *_focused_client; //! The screen with input focus /*! Updated by the clients when they update the Openbox::focused_client property. */ - OBScreen *_focused_screen; + Screen *_focused_screen; //! Parses the command line used when executing this application void parseCommandLine(int argv, char **argv); @@ -165,7 +153,6 @@ private: static void signalHandler(int signal); public: -#ifndef SWIG //! Openbox constructor. /*! \param argc Number of command line arguments, as received in main() @@ -174,44 +161,42 @@ public: Openbox(int argc, char **argv); //! Openbox destructor. virtual ~Openbox(); -#endif //! Returns the state of the window manager (starting, exiting, etc) inline RunState state() const { return _state; } - //! Returns the otk::OBTimerQueueManager for the application - /*! - All otk::OBTimer objects used in the application should be made to use this - otk::OBTimerQueueManager. - */ - inline otk::OBTimerQueueManager *timerManager() { return &_timermanager; } + //! Returns the Actions instance for the window manager + inline Actions *actions() const { return _actions; } - //! Returns the otk::OBProperty instance for the window manager - inline const otk::OBProperty *property() const { return _property; } + //! Returns the Bindings instance for the window manager + inline Bindings *bindings() const { return _bindings; } - //! Returns the OBActions instance for the window manager - inline OBActions *actions() const { return _actions; } - - //! Returns the OBBindings instance for the window manager - inline OBBindings *bindings() const { return _bindings; } - - //! Returns a managed screen - inline OBScreen *screen(int num) { - assert(num >= 0); assert(num < (signed)_screens.size()); - if (num >= screenCount()) - return NULL; + //! Returns a managed screen or a null pointer + /*! + ALWAYS check the return value for a non-null, as any unmanaged screens + will return one. This includes screen(0) if the first managed screen is 1. + */ + inline Screen *screen(int num) { + assert(num >= 0); assert(num < (signed)ScreenCount(**otk::display)); + if (num < 0 || num >= (signed)_screens.size()) return 0; return _screens[num]; } - //! Returns the number of managed screens - inline int screenCount() const { - return (signed)_screens.size(); + inline int managedScreenCount() const { return _managed_count; } + + inline Screen *managedScreen(int num) { + assert(num >= 0); assert(num < _managed_count); + if (num < 0 || num >= _managed_count) return 0; + ScreenList::iterator it, end = _screens.end(); + int i = -1; + for (it = _screens.begin(); it != end; ++it) + if (*it && ++i == num) + return *it; } //! Returns the mouse cursors used throughout Openbox inline const Cursors &cursors() const { return _cursors; } -#ifndef SWIG //! The main function of the Openbox class /*! This function should be called after instantiating the Openbox class. @@ -219,28 +204,27 @@ public: The Openbox::shutdown method will cause this function to exit. */ void eventLoop(); -#endif - //! Adds an OBClient to the client list for lookups - void addClient(Window window, OBClient *client); + //! Adds an Client to the client list for lookups + void addClient(Window window, Client *client); - //! Removes an OBClient from the client list for lookups + //! Removes an Client from the client list for lookups void removeClient(Window window); - //! Finds an OBClient based on its window id - OBClient *findClient(Window window); + //! Finds an Client based on its window id + Client *findClient(Window window); //! The client with input focus - inline OBClient *focusedClient() { return _focused_client; } + inline Client *focusedClient() { return _focused_client; } //! Change the client which has focus. /*! This is called by the clients themselves when their focus state changes. */ - void setFocusedClient(OBClient *c); + void setFocusedClient(Client *c); //! The screen with input focus - inline OBScreen *focusedScreen() { return _focused_screen; } + inline Screen *focusedScreen() { return _focused_screen; } //! Requests that the window manager exit /*! @@ -253,8 +237,12 @@ public: _shutdown = true; _restart = true; _restart_prog = bin; } - //! Executes a command on a screen - void execute(int screen, const std::string &bin); + //! True if Openbox should be restarted instead of exiting + inline bool doRestart() const { return _restart; } + + //! The command line requested to be executed in place of restarting + //! Openbox the way it was run previously. + inline const std::string &restartProgram() const { return _restart_prog; } }; }