GHOST_WindowX11.h

Go to the documentation of this file.

/*
 * ***** 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

#if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING)
    XIC getX11_XIC() { return m_xic; }
#endif

    /*
     * 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

#if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING)
    XIC m_xic;
#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_