GHOST_WindowX11.h

Go to the documentation of this file.

/*
 * $Id: GHOST_WindowX11.h 36985 2011-05-28 15:34:02Z campbellbarton $
 * ***** BEGIN GPL LICENSE BLOCK *****
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
 * All rights reserved.
 *
 * The Original Code is: all of this file.
 *
 * Contributor(s): none yet.
 *
 * ***** END GPL LICENSE BLOCK *****
 */

#ifndef _GHOST_WINDOWX11_H_
#define _GHOST_WINDOWX11_H_

#include "GHOST_Window.h"
#include <X11/Xlib.h>
#include <GL/glx.h>
// For tablets
#ifdef WITH_X11_XINPUT
#  include <X11/extensions/XInput.h>
#endif

#include <map>

class STR_String;
class GHOST_SystemX11;

class GHOST_WindowX11 : public GHOST_Window
{
public:
        GHOST_WindowX11(
                GHOST_SystemX11 *system,
                Display * display,
                const STR_String& title, 
                GHOST_TInt32 left,
                GHOST_TInt32 top,
                GHOST_TUns32 width,     
                GHOST_TUns32 height,
                GHOST_TWindowState state,
                const GHOST_TEmbedderWindowID parentWindow,
                GHOST_TDrawingContextType type = GHOST_kDrawingContextTypeNone,
                const bool stereoVisual = false,
                const GHOST_TUns16 numOfAASamples = 0
        );

                bool 
        getValid(
        ) const;

                void 
        setTitle(const STR_String& title);

                void 
        getTitle(
                STR_String& title
        ) const;

                void 
        getWindowBounds(
                GHOST_Rect& bounds
        ) const;
        
                void 
        getClientBounds(
                GHOST_Rect& bounds
        ) const;

                GHOST_TSuccess 
        setClientWidth(
                GHOST_TUns32 width
        );

                GHOST_TSuccess 
        setClientHeight(
                GHOST_TUns32 height
        );

                GHOST_TSuccess 
        setClientSize(
                GHOST_TUns32 width,
                GHOST_TUns32 height
        );

                void 
        screenToClient(
                GHOST_TInt32 inX,
                GHOST_TInt32 inY,
                GHOST_TInt32& outX,
                GHOST_TInt32& outY
        ) const;

                void 
        clientToScreen(
                GHOST_TInt32 inX,
                GHOST_TInt32 inY,
                GHOST_TInt32& outX,
                GHOST_TInt32& outY
        ) const;
        
                GHOST_TWindowState 
        getState(
        ) const ;

                GHOST_TSuccess 
        setState(
                GHOST_TWindowState state
        );
        
                GHOST_TSuccess 
        setOrder(
                GHOST_TWindowOrder order
        );
        
                GHOST_TSuccess 
        swapBuffers(
        );
        
                GHOST_TSuccess 
        activateDrawingContext(
        );
                GHOST_TSuccess 
        invalidate(
        );

         ~GHOST_WindowX11();

                void
        validate(
        );      

                Window 
        getXWindow(
        );      
#ifdef WITH_X11_XINPUT
        class XTablet
        {
        public:
                GHOST_TabletData CommonData;

                XDevice* StylusDevice;
                XDevice* EraserDevice;

                XID StylusID, EraserID;

                int MotionEvent;
                int ProxInEvent;
                int ProxOutEvent;

                int PressureLevels;
                int XtiltLevels, YtiltLevels;
        };

        XTablet& GetXTablet()
        { return m_xtablet; }

        const GHOST_TabletData* GetTabletData()
        { return &m_xtablet.CommonData; }
#else // WITH_X11_XINPUT
        const GHOST_TabletData* GetTabletData()
        { return NULL; }
#endif // WITH_X11_XINPUT

        /*
         * Need this in case that we want start the window
         * in FullScree or Maximized state.
         * Check GHOST_WindowX11.cpp
         */
        bool m_post_init;
        GHOST_TWindowState m_post_state;

protected:
                GHOST_TSuccess 
        installDrawingContext(
                GHOST_TDrawingContextType type
        );

                GHOST_TSuccess 
        removeDrawingContext(
        );

                GHOST_TSuccess 
        setWindowCursorVisibility(
                bool visible
        );
        
                GHOST_TSuccess 
        setWindowCursorGrab(
                GHOST_TGrabCursorMode mode
        );

                GHOST_TGrabCursorMode
        getWindowCursorGrab() const;

                GHOST_TSuccess 
        setWindowCursorShape(
                GHOST_TStandardCursor shape
        );

                GHOST_TSuccess
        setWindowCustomCursorShape(
                GHOST_TUns8 bitmap[16][2], 
                GHOST_TUns8 mask[16][2], 
                int hotX, 
                int hotY
        );
        
                GHOST_TSuccess
        setWindowCustomCursorShape(
                GHOST_TUns8 *bitmap, 
                GHOST_TUns8 *mask, 
                int sizex, 
                int sizey,
                int hotX, 
                int hotY,
                int fg_color, 
                int bg_color
        );

private :

        
        GHOST_WindowX11(
        );

        GHOST_WindowX11(
                const GHOST_WindowX11 &
        );

                Cursor
        getStandardCursor(
                GHOST_TStandardCursor g_cursor
        );
        
                Cursor 
        getEmptyCursor(
        );

#ifdef WITH_X11_XINPUT
        void initXInputDevices();
#endif
        
        GLXContext      m_context;
        Window  m_window;
        Display         *m_display;
        XVisualInfo     *m_visual;
        GHOST_TWindowState m_normal_state;

        static GLXContext s_firstContext;

        
        GHOST_SystemX11 * m_system;

        bool m_valid_setup;

        bool m_invalid_window;

        Cursor m_empty_cursor;
        
        Cursor m_custom_cursor;
        
        std::map<unsigned int, Cursor> m_standard_cursors;

#ifdef WITH_X11_XINPUT
        /* Tablet devices */
        XTablet m_xtablet;
#endif

        void icccmSetState(int state);
        int icccmGetState() const;

        void netwmMaximized(bool set);
        bool netwmIsMaximized() const;

        void netwmFullScreen(bool set);
        bool netwmIsFullScreen() const;

        void motifFullScreen(bool set);
        bool motifIsFullScreen() const;
};


#endif // _GHOST_WINDOWX11_H_