X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Fopenbox.hh;h=c810057f83fe9b097bde749742efa11533782fd8;hb=0089719c806599a405c2def0e1e84a0ac99d9937;hp=96cb2158b90912c96353dd094102d229e69a3510;hpb=2bf55be0614a9c6455cbab98cc6cfc8f0a1abebd;p=chaz%2Fopenbox diff --git a/src/openbox.hh b/src/openbox.hh index 96cb2158..c810057f 100644 --- a/src/openbox.hh +++ b/src/openbox.hh @@ -2,47 +2,135 @@ #ifndef __openbox_hh #define __openbox_hh +/*! @file openbox.hh + @brief The main class for the Openbox window manager +*/ + +/* + cuz girls look soooo goood.. on the end of my DICK +*/ + extern "C" { #include } #include #include +#include #include "otk/screeninfo.hh" +#include "otk/timerqueuemanager.hh" +#include "otk/property.hh" +#include "otk/configuration.hh" +#include "otk/eventdispatcher.hh" +#include "otk/eventhandler.hh" +#include "client.hh" namespace ob { -class Openbox +class OBScreen; + +//! The main class for the Openbox window manager. +/*! + Only a single instance of the Openbox class may be used in the application. A + pointer to this instance is held in the Openbox::instance static member + variable. + Instantiation of this class begins the window manager. After instantiation, + the Openbox::eventLoop function should be called. The eventLoop method does + 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 { public: - static Openbox *instance; // there can only be ONE instance of this class in - // the program, and it is held in here - - typedef std::vector ScreenInfoList; + //! 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, - State_Normal, - State_Exiting + State_Starting, //!< The window manager is starting up (being created) + State_Normal, //!< The window manager is running in its normal state + State_Exiting //!< The window manager is exiting (being destroyed) }; + + //! Mouse cursors used throughout Openbox + struct Cursors { + Cursor session; //!< The default mouse cursor + Cursor move; //!< For moving a window + Cursor ll_angle; //!< For resizing the bottom left corner of a window + Cursor lr_angle; //!< For resizing the bottom right corner of a window + Cursor ul_angle; //!< For resizing the top left corner of a window + Cursor ur_angle; //!< For resizing the right corner of a window + }; + + //! A map for looking up a specific client class from the window id + typedef std::map ClientMap; + + //! A list of OBScreen classes + typedef std::vector ScreenList; private: // stuff that can be passed on the command line - std::string _rcfilepath; // path to the config file to use/in use - std::string _menufilepath; // path to the menu file to use/in use - char *_displayreq; // display requested by the user - char *_argv0; // argv[0], how the program was called + //! Path to the config file to use/in use + /*! + Defaults to $(HOME)/.openbox/rc3 + */ + std::string _rcfilepath; + //! Path to the menu file to use/in use + /*! + Defaults to $(HOME)/.openbox/menu3 + */ + std::string _menufilepath; + //! The display requested by the user, or null to use the DISPLAY env var + char *_displayreq; + //! The value of argv[0], i.e. how this application was executed + char *_argv0; - RunState _state; // the state of the window manager + //! A list of all managed clients + ClientMap _clients; - ScreenInfoList _screenInfoList; // info for all screens on the display + //! 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 running state of the window manager + RunState _state; + + //! Mouse cursors used throughout Openbox + Cursors _cursors; + + //! When set to true, the Openbox::eventLoop function will stop and return + bool _doshutdown; + + //! The configuration of the application. TEMPORARY + otk::Configuration _config; + + //! Parses the command line used when executing this application void parseCommandLine(int argv, char **argv); + //! Displays the version string to stdout void showVersion(); + //! Displays usage information and help to stdout void showHelp(); - static int xerrorHandler(Display *d, XErrorEvent *e); + //! Handles signal events for the application static void signalHandler(int signal); public: @@ -55,16 +143,51 @@ public: //! Openbox destructor. virtual ~Openbox(); - //! Returns the state of the window manager (starting, exiting, etc). + //! 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 otk::OBProperty instance for the window manager + inline const otk::OBProperty *property() const { return _property; } + + //! Returns a managed screen + inline OBScreen *screen(int num) { + assert(num >= 0); assert(num < (signed)_screens.size()); + return _screens[num]; + } + + //! Returns the mouse cursors used throughout Openbox + inline const Cursors &cursors() const { return _cursors; } + + //! The main function of the Openbox class + /*! + This function should be called after instantiating the Openbox class. + It loops indefinately while handling all events for the application. + The Openbox::shutdown method will cause this function to exit. + */ void eventLoop(); - // XXX: TEMPORARY!#!@%*!^#*!#!#! - virtual void process_event(XEvent *) = 0; + //! Adds an OBClient to the client list for lookups + void addClient(Window window, OBClient *client); - //! Requests that the window manager exit. - inline void shutdown() { _state = State_Exiting; } + //! Removes an OBClient from the client list for lookups + void removeClient(Window window); + + //! Finds an OBClient based on its window id + OBClient *findClient(Window window); + + //! Requests that the window manager exit + /*! + Causes the Openbox::eventLoop function to stop looping, so that the window + manager can be destroyed. + */ + inline void shutdown() { _doshutdown = true; } }; }