CWindow.hpp

Go to the documentation of this file.

#ifndef __CWindow__
#define __CWindow__

#include <Testing/CTrace.hpp>
#include <Host/CDLLLoader.hpp>
#include <Collections/TPointerCollection.hpp>
#include "../Basics/GUIDefines.h"
#include "../Basics/ITimedObject.hpp"
#include "../Controls/CControlRoot.hpp"
#include "IWindow.hpp"
#include "IToolTipSupportingWindow.hpp"
#include "IToolTip.hpp"
#include "CWindowTools.hpp"

//  ===========================================================================

using Exponent::Host::CDLLLoader;
using Exponent::GUI::Basics::ITimedObject;
using Exponent::GUI::Windowing::IWindow;
using Exponent::GUI::Windowing::IToolTipSupportingWindow;
using Exponent::GUI::Windowing::IToolTip;
using Exponent::GUI::Windowing::CWindowTools;
using Exponent::GUI::Controls::CControlRoot;
using Exponent::Testing::CTrace;
using Exponent::Collections::TPointerCollection;

//  ===========================================================================

#ifdef WIN32
    #pragma comment (lib, "Comctl32.lib")
#endif

namespace Exponent
{
    namespace GUI
    {
        namespace Windowing
        {
            class CWindow : public IWindow, public IWindowChangeListener, public IFocusListener, public IToolTipSupportingWindow
            {
                EXPONENT_CLASS_DECLARATION;
//  ===========================================================================

            public:

//  ===========================================================================

                CWindow(const CRect &size);

                virtual ~CWindow();

//  ===========================================================================

                virtual void referenced();

                virtual void dereference();

                virtual long getReferenceCount() const;

                virtual void getObjectDescription(char *string, const long size) const;

//  ===========================================================================

                virtual void setParentWindow(IWindow *parent) { m_windowParent = parent; }

                virtual IWindow *getParentWindow() const { return m_windowParent; }

//  ===========================================================================

                virtual void registerChildWindow(IWindow *child);

                virtual void unregisterAllChildWindows();

                virtual void unregisterChldWindow(IWindow *child);

//  ===========================================================================

                virtual const SWindowHandle *getWindowHandle() const { return m_windowHandle; }

                virtual SWindowHandle *getMutableWindowHandle() const { return m_windowHandle; }

                virtual CWindowAttributes *getWindowAttributes() const { return m_attributes; }

//  ===========================================================================

                virtual void initialiseWindow(CWindowAttributes *windowAttributes, const bool showWindow);

                virtual void uninitialiseWindow();

//  ===========================================================================

                virtual void openWindow();

                virtual void closeWindow();

                virtual void updateWindow();

                virtual void disableWindow();

                virtual void enableWindow();

                virtual void gainedFocus(IWindow *window);

                virtual void lostFocus(IWindow *window);

//  ===========================================================================

                virtual void draw(CGraphics &graphics);

                virtual void redrawWindow(const CRect &area);

                virtual void redrawWindow();

                #ifndef WIN32

                void setCompositingControl(HIViewRef ref) { m_userWindow = ref; }
                #endif

//  ===========================================================================

                virtual void setWindowPosition(const CPoint &position);

                virtual const CPoint &getWindowPosition() const { return m_windowPosition; }

                virtual void setWindowSize(const CDimension &dimension);

                virtual const CDimension &getWindowSize() const { return m_windowDimension; }

                virtual void setWindowPositionAndSize(const CRect &positionAndSize);

                virtual const CRect &getWindowPositionAndSize() const { return m_windowSize; }

                virtual void setWindowAlpha(const double alpha);

//  ===========================================================================

                virtual void handleTimerEvent(const long id);

                virtual void startTimer(const long id, const long timeInMilliseconds);

                virtual void stopTimer(const long id);

                virtual void addTimedObject(ITimedObject *timedObject);

                virtual void removeTimedObject(ITimedObject *timedObject);

                virtual void clearTimedObjects();

//  ===========================================================================

                virtual void registerFocusListener(IFocusListener *listener) { m_focusListener = listener; }

                virtual void registerWindowChangeListener(IWindowChangeListener *listener) { m_windowChangeListener = listener; }

                virtual void registerMouseListener(IMouseListener *listener) { m_mouseListener = listener; }

                virtual void registerDropFileListener(IDropFileListener *listener) { m_dropFileListener = listener; }

                virtual void registerKeyboardListener(IKeyboardListener *listener) { m_keyboardListener = listener; }

//  ===========================================================================

                virtual bool isMouseEnabled() const { return m_mouseListener != NULL; }

                virtual bool isKeyboardEnabled() const { return m_keyboardListener != NULL; }

                virtual bool isDropFileEnabled() const { return m_dropFileListener != NULL; }

//  ===========================================================================

                // Set the tooltip to display
                virtual void setToolTip(IToolTip *toolTip = NULL) { m_toolTip = toolTip; }

                // Get the mutable tool tip
                virtual IToolTip *getMutableToolTip() const { return m_toolTip; }

                // Get the tool tip
                virtual const IToolTip *getToolTip() const { return m_toolTip; }

//  ===========================================================================

                virtual CMouse *getMouse() { return &m_mouse; }

                virtual IControlRoot *getControlRoot() const { return m_theControlRoot; }

//  ===========================================================================

                virtual void windowSized(IWindow *window, const CDimension &newDimension);

                virtual void windowMoved(IWindow *window, const CPoint &newTopLeft);

                virtual bool windowClosed(IWindow *window);

                virtual void windowOpened(IWindow *window);

                virtual void windowMinimised(IWindow *window);

                virtual void windowMaximised(IWindow *window);

//  ===========================================================================

            protected:

//  ===========================================================================

                virtual bool createWindow();

                virtual void destroyWindow();

//  ===========================================================================

                #ifdef WIN32

                    virtual LRESULT handleWindowEvents(HWND windowHandle, UINT message, WPARAM wParam, LPARAM lParam);

                    virtual LRESULT handleKeyboardEvents(int nCode, WPARAM wParam, LPARAM lParam);

                    LRESULT handleMouseWheelEvents(int nCode, WPARAM wParam, LPARAM lParam);

                    virtual void constructMousePosition(LPARAM lParam);

                    virtual void startTrackMouseEvent();

                    virtual void unhookKeyboardHandler();

                    void unhookWheelHandler();
                #else

                    virtual pascal OSStatus handleWindowEvents(EventHandlerCallRef handler, EventRef theEvent);

                    virtual pascal OSErr handleDropEvent(WindowRef window, DragRef dragReference);

                    virtual void constructMousePosition(EventRef theEvent);

                    virtual void constructKeyboardEvent(EventRef theEvent);
                #endif

//  ===========================================================================

                #ifdef WIN32

                    static LRESULT CALLBACK WindowProc(HWND windowHandle, UINT message, WPARAM wParam, LPARAM lParam);

                    static LRESULT CALLBACK KeyboardProc(int nCode, WPARAM wParam, LPARAM lParam);

                    static LRESULT CALLBACK MouseWheelProc(int nCode, WPARAM wParam, LPARAM lParam);

                    static VOID CALLBACK TimerProc(HWND windowHandle, UINT message, UINT_PTR eventID, DWORD dwTime);
                #else

                    static pascal OSStatus WindowProc(EventHandlerCallRef handler, EventRef theEvent, void *userData);

                    static pascal OSErr handleDropMessages(WindowRef window, void *userData, DragRef dragReference);

                    static void handleTimerMessages(CFRunLoopTimerRef timer, void *info);
                #endif

//  ===========================================================================

                #ifndef WIN32

                    class CTimerObject : public CCountedObject
                    {
                    public:

                        CTimerObject()
                        {
                            m_isActive = false;
                            NULL_POINTER(m_timer);
                        }

                        virtual ~CTimerObject()
                        {
                            if (m_timer)
                            {
                                CFRelease(m_timer);
                            }
                        }

                        CFRunLoopTimerRef m_timer;                          
                        bool m_isActive;                                    
                    };
                #endif

//  ===========================================================================

                IMouseListener *m_mouseListener;                            
                IDropFileListener *m_dropFileListener;                      
                IKeyboardListener *m_keyboardListener;                      
                IWindowChangeListener *m_windowChangeListener;              
                IFocusListener *m_focusListener;                            
                CWindowAttributes *m_attributes;                            
                SWindowHandle *m_windowHandle;                              
                IWindow *m_windowParent;                                    
                CDimension m_windowDimension;                               
                CPoint m_windowPosition;                                    
                CRect m_windowSize;                                         
                CMouse m_mouse;                                             
                CPoint m_mousePoint;                                        
                CGraphics m_graphics;                                       
                CMouseEvent m_mouseEvent;                                   
                CKeyboardEvent m_keyEvent;                                  
                bool m_windowInitialised;                                   
                IToolTip *m_toolTip;                                        
                TPointerCollection<ITimedObject> *m_timedObjects;           
                CControlRoot *m_theControlRoot;                             
                long m_referenceCount;                                      
                #ifdef WIN32

                    SETLAYERATTRIBUTE m_setLayeredWindowAttributes;         
                    HHOOK m_keyboardHook;                                   
                    HHOOK m_mouseHook;                                      
                    static HWND m_hookWindowHandle;                         
                #else

                    bool m_leftClick;                                       
                    TPointerCollection<CTimerObject> *m_timerContexts;      
                    CRect m_redrawUpdateArea;                               
                    bool m_updateAreaIsValid;                               
                    HIViewRef m_userWindow;                                 
                #endif

//  ===========================================================================

            };
        }
    }
}
#endif  // End of CWindow.hpp

---