libGizmod/X11FocusWatcher.hpp

Go to the documentation of this file.

/*
  
  Copyright (c) 2007, Tim Burrell
  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at 

        http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and 
  limitations under the License. 
  
*/

#ifndef __X11FocusWatcher_h
#define __X11FocusWatcher_h

#if HAVE_CONFIG_H
#include "config.h"
#endif

#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/keysym.h>
#include <X11/Xatom.h>
#include <string>
#include <boost/tuple/tuple.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/base_object.hpp>

// Namespace

namespace Gizmod {

// Typedefs

typedef enum {
        X11FOCUSEVENT_IN,
        X11FOCUSEVENT_OUT
} X11FocusEventType;

// X11FocusEvent Class Definition

class X11FocusEvent {
public: 
        // public member variables
        X11FocusEventType               EventType;              
        std::string                     WindowName;             
        std::string                     WindowNameFormal;       
        std::string                     WindowClass;            
        
        // public functions
        bool                            isNull();               

        // operators
        bool                            operator != (X11FocusEvent const & Event); 
        bool                            operator == (X11FocusEvent const & Event); 

        // construction / deconstruction
        X11FocusEvent();
        X11FocusEvent(X11FocusEventType eventType, std::string windowName, std::string windowNameFormal, std::string windowClass);
        X11FocusEvent(X11FocusEvent const & Event);
        virtual ~X11FocusEvent();

private:
        // private functions
                
        // private member variables
        
private: 
        // serialization
        friend class boost::serialization::access;
        template<class Archive>
        void serialize(Archive & ar, const unsigned int version) {
                ar & EventType;
                ar & WindowName;
                ar & WindowNameFormal;
                ar & WindowClass;
        }                               
};

// X11FocusWatcher Class Definition

class X11FocusWatcher {
public: 
        // public functions
        void                            init();                 
        bool                            isApplicationRunning(std::string WindowTitle); 
        virtual void                    onFocusIn(X11FocusEvent const & Event); 
        virtual void                    onFocusOut(X11FocusEvent const & Event); 
        bool                            setInputFocus(std::string WindowTitle); 
        void                            shutdown();             

        // construction / deconstruction
        X11FocusWatcher();
        virtual ~X11FocusWatcher();
        
        // public static functions
        static int                      x11ErrorHandler(Display * display, XErrorEvent * error); 
        static int                      x11IOErrorHandler(Display * display); 

private:
        // private functions
        void                            closeDisplay();         
        X11FocusEvent                   createFocusEvent(Window const & window, X11FocusEventType EventType); 
        static boost::tuple<std::string, std::string, std::string> getWindowName(Display * dpy, Window const & window, bool recurse = true); 
        bool                            openDisplay(std::string DisplayName); 
        void                            setFocusEventMasks();   
        void                            threadProc();           
                
        // private member variables
        Window                          mCurrentWindow;         
        Display *                       mDisplay;               
        std::string                     mDisplayName;           
        X11FocusEvent                   mLastEventIn;           
        X11FocusEvent                   mLastEventOut;          
        int                             mScreen;                
        bool                            mWatching;              
        
        struct X11FocusWatcherThreadProc {
                X11FocusWatcherThreadProc(X11FocusWatcher * pX11FocusWatcher) : mpX11FocusWatcher(pX11FocusWatcher) {
                        mpX11FocusWatcher->mThreading = false;
                };
                
                void operator()() {
                        mpX11FocusWatcher->mThreading = true;
                        mpX11FocusWatcher->threadProc();
                        mpX11FocusWatcher->mThreading = false;
                }
                
                X11FocusWatcher *               mpX11FocusWatcher;
        };              
        bool                                    mThreading;     
        X11FocusWatcherThreadProc               mThreadProc;    
};


} // Gizmod namespace

#endif // __X11FocusWatcher_h

---