src/gtk1/settings.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        gtk/settings.cpp
// Purpose:
// Author:      Robert Roebling
// Modified by: Mart Raudsepp (GetMetric)
// Id:          $Id$
// Copyright:   (c) 1998 Robert Roebling
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////


#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma implementation "settings.h"
#endif

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#include "wx/settings.h"
#include "wx/debug.h"
#include "wx/cmndata.h"
#include "wx/fontutil.h"
#include "wx/toplevel.h"

#include <gdk/gdk.h>
#include <gdk/gdkx.h>
#include <gdk/gdkprivate.h>
#include <gtk/gtk.h>

#include <X11/Xatom.h>

#define SHIFT (8*(sizeof(short int)-sizeof(char)))

// ----------------------------------------------------------------------------
// wxSystemObjects
// ----------------------------------------------------------------------------

struct wxSystemObjects
{
    wxColour m_colBtnFace,
             m_colBtnShadow,
             m_colBtnHighlight,
             m_colHighlight,
             m_colHighlightText,
             m_colListBox,
             m_colBtnText,
             m_colMenuItemHighlight;

    wxFont m_fontSystem;
};

static wxSystemObjects gs_objects;

// ----------------------------------------------------------------------------
// wxSystemSettings implementation
// ----------------------------------------------------------------------------

// kind of widget to use in GetColourFromGTKWidget
enum wxGtkWidgetType
{
    wxGTK_BUTTON,
    wxGTK_LIST,
    wxGTK_MENUITEM
};

// the colour we need
enum wxGtkColourType
{
    wxGTK_FG,
    wxGTK_BG,
    wxGTK_BASE
};

// wxSystemSettings::GetColour() helper: get the colours from a GTK+
// widget style, return true if we did get them, false to use defaults
static bool GetColourFromGTKWidget(int& red, int& green, int& blue,
                                   wxGtkWidgetType type = wxGTK_BUTTON,
                                   GtkStateType state = GTK_STATE_NORMAL,
                                   wxGtkColourType colour = wxGTK_BG)
{
    GtkWidget *widget;
    switch ( type )
    {
        default:
            wxFAIL_MSG( _T("unexpected GTK widget type") );
            // fall through

        case wxGTK_BUTTON:
            widget = gtk_button_new();
            break;

        case wxGTK_LIST:
            widget = gtk_list_new();

        case wxGTK_MENUITEM:
            widget = gtk_menu_item_new();
    }

    GtkStyle *def = gtk_rc_get_style( widget );
    if ( !def )
        def = gtk_widget_get_default_style();

    bool ok;
    if ( def )
    {
        GdkColor *col;
        switch ( colour )
        {
            default:
                wxFAIL_MSG( _T("unexpected GTK colour type") );
                // fall through

            case wxGTK_FG:
                col = def->fg;
                break;

            case wxGTK_BG:
                col = def->bg;
                break;

            case wxGTK_BASE:
                col = def->base;
                break;
        }

        red = col[state].red;
        green = col[state].green;
        blue = col[state].blue;

        ok = TRUE;
    }
    else
    {
        ok = FALSE;
    }

    gtk_widget_destroy( widget );

    return ok;
}

wxColour wxSystemSettingsNative::GetColour( wxSystemColour index )
{
    switch (index)
    {
        case wxSYS_COLOUR_SCROLLBAR:
        case wxSYS_COLOUR_BACKGROUND:
        case wxSYS_COLOUR_INACTIVECAPTION:
        case wxSYS_COLOUR_MENU:
        case wxSYS_COLOUR_WINDOWFRAME:
        case wxSYS_COLOUR_ACTIVEBORDER:
        case wxSYS_COLOUR_INACTIVEBORDER:
        case wxSYS_COLOUR_BTNFACE:
        case wxSYS_COLOUR_MENUBAR:
        case wxSYS_COLOUR_3DLIGHT:
            if (!gs_objects.m_colBtnFace.Ok())
            {
                int red, green, blue;
                if ( !GetColourFromGTKWidget(red, green, blue) )
                {
                    red =
                    green = 0;
                    blue = 0x9c40;
                }

                gs_objects.m_colBtnFace = wxColour( red   >> SHIFT,
                                                   green >> SHIFT,
                                                   blue  >> SHIFT );
            }
            return gs_objects.m_colBtnFace;

        case wxSYS_COLOUR_WINDOW:
            return *wxWHITE;

        case wxSYS_COLOUR_3DDKSHADOW:
            return *wxBLACK;

        case wxSYS_COLOUR_GRAYTEXT:
        case wxSYS_COLOUR_BTNSHADOW:
        //case wxSYS_COLOUR_3DSHADOW:
            if (!gs_objects.m_colBtnShadow.Ok())
            {
                wxColour faceColour(GetColour(wxSYS_COLOUR_3DFACE));
                gs_objects.m_colBtnShadow =
                   wxColour((unsigned char) (faceColour.Red() * 0.666),
                            (unsigned char) (faceColour.Green() * 0.666),
                            (unsigned char) (faceColour.Blue() * 0.666));
            }

            return gs_objects.m_colBtnShadow;

        case wxSYS_COLOUR_3DHIGHLIGHT:
        //case wxSYS_COLOUR_BTNHIGHLIGHT:
            return * wxWHITE;

        case wxSYS_COLOUR_HIGHLIGHT:
            if (!gs_objects.m_colHighlight.Ok())
            {
                int red, green, blue;
                if ( !GetColourFromGTKWidget(red, green, blue,
                                             wxGTK_BUTTON,
                                             GTK_STATE_SELECTED) )
                {
                    red =
                    green = 0;
                    blue = 0x9c40;
                }

                gs_objects.m_colHighlight = wxColour( red   >> SHIFT,
                                                        green >> SHIFT,
                                                        blue  >> SHIFT );
            }
            return gs_objects.m_colHighlight;

        case wxSYS_COLOUR_LISTBOX:
            if (!gs_objects.m_colListBox.Ok())
            {
                int red, green, blue;
                if ( GetColourFromGTKWidget(red, green, blue,
                                            wxGTK_LIST,
                                            GTK_STATE_NORMAL,
                                            wxGTK_BASE) )
                {
                    gs_objects.m_colListBox = wxColour( red   >> SHIFT,
                                                          green >> SHIFT,
                                                          blue  >> SHIFT );
                }
                else
                {
                    gs_objects.m_colListBox = wxColour(*wxWHITE);
                }
            }
            return gs_objects.m_colListBox;

        case wxSYS_COLOUR_MENUTEXT:
        case wxSYS_COLOUR_WINDOWTEXT:
        case wxSYS_COLOUR_CAPTIONTEXT:
        case wxSYS_COLOUR_INACTIVECAPTIONTEXT:
        case wxSYS_COLOUR_BTNTEXT:
        case wxSYS_COLOUR_INFOTEXT:
            if (!gs_objects.m_colBtnText.Ok())
            {
                int red, green, blue;
                if ( !GetColourFromGTKWidget(red, green, blue,
                                             wxGTK_BUTTON,
                                             GTK_STATE_NORMAL,
                                             wxGTK_FG) )
                {
                    red =
                    green =
                    blue = 0;
                }

                gs_objects.m_colBtnText = wxColour( red   >> SHIFT,
                                                      green >> SHIFT,
                                                      blue  >> SHIFT );
            }
            return gs_objects.m_colBtnText;

            // this (as well as wxSYS_COLOUR_INFOTEXT above) is used for
            // tooltip windows - Robert, please change this code to use the
            // real GTK tooltips when/if you can (TODO)
        case wxSYS_COLOUR_INFOBK:
            return wxColour(255, 255, 225);

        case wxSYS_COLOUR_HIGHLIGHTTEXT:
            if (!gs_objects.m_colHighlightText.Ok())
            {
                wxColour hclr = GetColour(wxSYS_COLOUR_HIGHLIGHT);
                if (hclr.Red() > 200 && hclr.Green() > 200 && hclr.Blue() > 200)
                    gs_objects.m_colHighlightText = wxColour(*wxBLACK);
                else
                    gs_objects.m_colHighlightText = wxColour(*wxWHITE);
            }
            return gs_objects.m_colHighlightText;

        case wxSYS_COLOUR_APPWORKSPACE:
            return *wxWHITE;    // ?

        case wxSYS_COLOUR_ACTIVECAPTION:
        case wxSYS_COLOUR_MENUHILIGHT:
            if (!gs_objects.m_colMenuItemHighlight.Ok())
            {
                int red, green, blue;
                if ( !GetColourFromGTKWidget(red, green, blue,
                                             wxGTK_MENUITEM,
                                             GTK_STATE_SELECTED,
                                             wxGTK_BG) )
                {
                    red =
                    green =
                    blue = 0;
                }

                gs_objects.m_colMenuItemHighlight = wxColour( red  >> SHIFT,
                                                              green >> SHIFT,
                                                              blue  >> SHIFT );
            }
            return gs_objects.m_colMenuItemHighlight;

        case wxSYS_COLOUR_HOTLIGHT:
        case wxSYS_COLOUR_GRADIENTACTIVECAPTION:
        case wxSYS_COLOUR_GRADIENTINACTIVECAPTION:
            // TODO
            return *wxBLACK;

        case wxSYS_COLOUR_MAX:
        default:
            wxFAIL_MSG( _T("unknown system colour index") );
  }

  return *wxWHITE;
}

wxFont wxSystemSettingsNative::GetFont( wxSystemFont index )
{
    switch (index)
    {
        case wxSYS_OEM_FIXED_FONT:
        case wxSYS_ANSI_FIXED_FONT:
        case wxSYS_SYSTEM_FIXED_FONT:
        {
            return *wxNORMAL_FONT;
        }
        case wxSYS_ANSI_VAR_FONT:
        case wxSYS_SYSTEM_FONT:
        case wxSYS_DEVICE_DEFAULT_FONT:
        case wxSYS_DEFAULT_GUI_FONT:
        {
            if (!gs_objects.m_fontSystem.Ok())
            {
#ifdef __WXGTK20__
                GtkWidget *widget = gtk_button_new();
                GtkStyle *def = gtk_rc_get_style( widget );
                if ( !def || !def->font_desc )
                    def = gtk_widget_get_default_style();
                if ( def && def->font_desc )
                {
                    wxNativeFontInfo info;
                    info.description =
                        pango_font_description_copy(def->font_desc);
                    gs_objects.m_fontSystem = wxFont(info);
                }
                else
                {
                    GtkSettings *settings = gtk_settings_get_default();
                    gchar *font_name = NULL;
                    g_object_get ( settings,
                                   "gtk-font-name",
                                   &font_name,
                                   NULL);
                    if (!font_name)
                        gs_objects.m_fontSystem = wxFont( 12, wxSWISS, wxNORMAL, wxNORMAL );
                    else
                        gs_objects.m_fontSystem = wxFont(wxString::FromAscii(font_name));
                    g_free (font_name);
                }
                gtk_widget_destroy( widget );
#else
                gs_objects.m_fontSystem = wxFont( 12, wxSWISS, wxNORMAL, wxNORMAL );
#endif
            }
            return gs_objects.m_fontSystem;
        }

        default:
            return wxNullFont;
    }
}

int wxSystemSettingsNative::GetMetric( wxSystemMetric index, wxWindow* win )
{
#ifdef __WXGTK20__
    guchar *data = NULL;
    GdkWindow *window = NULL;
    if(win && GTK_WIDGET_REALIZED(win->GetHandle()))
        window = win->GetHandle()->window;
#endif

    switch (index)
    {
        case wxSYS_BORDER_X:
        case wxSYS_BORDER_Y:
        case wxSYS_EDGE_X:
        case wxSYS_EDGE_Y:
        case wxSYS_FRAMESIZE_X:
        case wxSYS_FRAMESIZE_Y:
            // If a window is specified/realized, and it is a toplevel window, we can query from wm.
            // The returned border thickness is outside the client area in that case.
            if (window)
            {
                wxTopLevelWindow *tlw = wxDynamicCast(win, wxTopLevelWindow);
                if (!tlw)
                    return -1; // not a tlw, not sure how to approach
                else
                {
                    // Check if wm supports frame extents - we can't know
                    // the border widths if it does not.
#if GTK_CHECK_VERSION(2,2,0)
                    if (!gtk_check_version(2,2,0))
                    {
                        if (!gdk_x11_screen_supports_net_wm_hint(
                                gdk_drawable_get_screen(window),
                                gdk_atom_intern("_NET_FRAME_EXTENTS", false) ) )
                            return -1;
                    }
                    else
#endif
                    {
                        if (!gdk_net_wm_supports(gdk_atom_intern("_NET_FRAME_EXTENTS", false)))
                            return -1;
                    }

                    // Get the frame extents from the windowmanager.
                    // In most cases the top extent is the titlebar, so we use the bottom extent
                    // for the heights.

                    Atom type;
                    gint format;
                    gulong nitems;
                    gulong bytes_after;

                    if (XGetWindowProperty (GDK_DISPLAY_XDISPLAY(gdk_drawable_get_display(window)),
                                            GDK_WINDOW_XWINDOW(window),
                                            gdk_x11_get_xatom_by_name_for_display (
                                                    gdk_drawable_get_display(window),
                                                    "_NET_FRAME_EXTENTS" ),
                                            0, // left, right, top, bottom, CARDINAL[4]/32
                                            G_MAXLONG, // size of long
                                            false, // do not delete property
                                            XA_CARDINAL, // 32 bit
                                            &type, &format, &nitems, &bytes_after, &data
                                           ) == Success)
                    {
                        int border_return = -1;

                        if ((type == XA_CARDINAL) && (format == 32) && (nitems >= 4) && (data))
                        {
                            long *borders;
                            borders = (long*)data;
                            switch(index)
                            {
                                case wxSYS_BORDER_X:
                                case wxSYS_EDGE_X:
                                case wxSYS_FRAMESIZE_X:
                                    border_return = borders[1]; // width of right extent
                                    break;
                                default:
                                    border_return = borders[3]; // height of bottom extent
                                    break;
                            }
                        }

                        if (data)
                            XFree(data);

                        return border_return;
                    }
                }
            }

            return -1; // no window specified

        case wxSYS_CURSOR_X:
        case wxSYS_CURSOR_Y:
#ifdef __WXGTK24__
            if (!gtk_check_version(2,4,0))
            {
                if (window)
                    return gdk_display_get_default_cursor_size(gdk_drawable_get_display(window));
                else
                    return gdk_display_get_default_cursor_size(gdk_display_get_default());
            }
            else
#endif
                return 16;

#ifdef __WXGTK20__
        case wxSYS_DCLICK_X:
        case wxSYS_DCLICK_Y:
            gint dclick_distance;
#if GTK_CHECK_VERSION(2,2,0)
            if (window && !gtk_check_version(2,2,0))
                g_object_get(gtk_settings_get_for_screen(gdk_drawable_get_screen(window)),
                                "gtk-double-click-distance", &dclick_distance, NULL);
            else
#endif
                g_object_get(gtk_settings_get_default(),
                                "gtk-double-click-distance", &dclick_distance, NULL);

            return dclick_distance * 2;
#endif // gtk2

#ifdef __WXGTK20__
        case wxSYS_DRAG_X:
        case wxSYS_DRAG_Y:
            gint drag_threshold;
#if GTK_CHECK_VERSION(2,2,0)
            if (window && !gtk_check_version(2,2,0))
            {
                g_object_get(
                        gtk_settings_get_for_screen(gdk_drawable_get_screen(window)),
                        "gtk-dnd-drag-threshold",
                        &drag_threshold, NULL);
            }
            else
#endif
            {
                g_object_get(gtk_settings_get_default(),
                             "gtk-dnd-drag-threshold", &drag_threshold, NULL);
            }

            return drag_threshold * 2;
#endif

        // MBN: ditto for icons
        case wxSYS_ICON_X:     return 32;
        case wxSYS_ICON_Y:     return 32;

        case wxSYS_SCREEN_X:
#if defined(__WXGTK20__) && GTK_CHECK_VERSION(2,2,0)
            if (window && !gtk_check_version(2,2,0))
                return gdk_screen_get_width(gdk_drawable_get_screen(window));
            else
#endif
                return gdk_screen_width();

        case wxSYS_SCREEN_Y:
#if defined(__WXGTK20__) && GTK_CHECK_VERSION(2,2,0)
            if (window && !gtk_check_version(2,2,0))
                return gdk_screen_get_height(gdk_drawable_get_screen(window));
            else
#endif
                return gdk_screen_height();

        case wxSYS_HSCROLL_Y:  return 15;
        case wxSYS_VSCROLL_X:  return 15;

// a gtk1 implementation should be possible too if gtk2 efficiency/convenience functions aren't used
#ifdef __WXGTK20__
        case wxSYS_CAPTION_Y:
            if (!window)
                // No realized window specified, and no implementation for that case yet.
                return -1;

            // Check if wm supports frame extents - we can't know the caption height if it does not.
#if GTK_CHECK_VERSION(2,2,0)
            if (!gtk_check_version(2,2,0))
            {
                if (!gdk_x11_screen_supports_net_wm_hint(
                        gdk_drawable_get_screen(window),
                        gdk_atom_intern("_NET_FRAME_EXTENTS", false) ) )
                    return -1;
            }
            else
#endif
            {
                if (!gdk_net_wm_supports(gdk_atom_intern("_NET_FRAME_EXTENTS", false)))
                    return -1;
            }

            wxASSERT_MSG( wxDynamicCast(win, wxTopLevelWindow),
                          wxT("Asking for caption height of a non toplevel window") );

            // Get the height of the top windowmanager border.
            // This is the titlebar in most cases. The titlebar might be elsewhere, and
            // we could check which is the thickest wm border to decide on which side the
            // titlebar is, but this might lead to interesting behaviours in used code.
            // Reconsider when we have a way to report to the user on which side it is.

            Atom type;
            gint format;
            gulong nitems;
            gulong bytes_after;

            if (XGetWindowProperty (GDK_DISPLAY_XDISPLAY(gdk_drawable_get_display(window)),
                                    GDK_WINDOW_XWINDOW(window),
                                    gdk_x11_get_xatom_by_name_for_display (
                                            gdk_drawable_get_display(window),
                                            "_NET_FRAME_EXTENTS" ),
                                    0, // left, right, top, bottom, CARDINAL[4]/32
                                    G_MAXLONG, // size of long
                                    false, // do not delete property
                                    XA_CARDINAL, // 32 bit
                                    &type, &format, &nitems, &bytes_after, &data
                                   ) == Success)
            {
                int caption_height = -1;

                if ((type == XA_CARDINAL) && (format == 32) && (nitems >= 3) && (data))
                {
                    long *borders;
                    borders = (long*)data;
                    caption_height = borders[2]; // top frame extent
                }

                if (data)
                    XFree(data);

                return caption_height;
            }

            // Try a default approach without a window pointer, if possible
            // ...

            return -1;
#endif // gtk2

        case wxSYS_PENWINDOWS_PRESENT:
            // No MS Windows for Pen computing extension available in X11 based gtk+.
            return 0;

        default:
            return -1;   // metric is unknown
    }
}

bool wxSystemSettingsNative::HasFeature(wxSystemFeature index)
{
    switch (index)
    {
        case wxSYS_CAN_ICONIZE_FRAME:
            return FALSE;
            break;
        case wxSYS_CAN_DRAW_FRAME_DECORATIONS:
            return TRUE;
            break;
        default:
            return FALSE;
    }
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: gtk/settings.cpp
	3	// Purpose:
	4	// Author: Robert Roebling
	5	// Modified by: Mart Raudsepp (GetMetric)
	6	// Id: $Id$
	7	// Copyright: (c) 1998 Robert Roebling
	8	// Licence: wxWindows licence
	9	/////////////////////////////////////////////////////////////////////////////
	10
	11
	12	#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
	13	#pragma implementation "settings.h"
	14	#endif
	15
	16	// For compilers that support precompilation, includes "wx.h".
	17	#include "wx/wxprec.h"
	18
	19	#include "wx/settings.h"
	20	#include "wx/debug.h"
	21	#include "wx/cmndata.h"
	22	#include "wx/fontutil.h"
	23	#include "wx/toplevel.h"
	24
	25	#include <gdk/gdk.h>
	26	#include <gdk/gdkx.h>
	27	#include <gdk/gdkprivate.h>
	28	#include <gtk/gtk.h>
	29
	30	#include <X11/Xatom.h>
	31
	32	#define SHIFT (8*(sizeof(short int)-sizeof(char)))
	33
	34	// ----------------------------------------------------------------------------
	35	// wxSystemObjects
	36	// ----------------------------------------------------------------------------
	37
	38	struct wxSystemObjects
	39	{
	40	wxColour m_colBtnFace,
	41	m_colBtnShadow,
	42	m_colBtnHighlight,
	43	m_colHighlight,
	44	m_colHighlightText,
	45	m_colListBox,
	46	m_colBtnText,
	47	m_colMenuItemHighlight;
	48
	49	wxFont m_fontSystem;
	50	};
	51
	52	static wxSystemObjects gs_objects;
	53
	54	// ----------------------------------------------------------------------------
	55	// wxSystemSettings implementation
	56	// ----------------------------------------------------------------------------
	57
	58	// kind of widget to use in GetColourFromGTKWidget
	59	enum wxGtkWidgetType
	60	{
	61	wxGTK_BUTTON,
	62	wxGTK_LIST,
	63	wxGTK_MENUITEM
	64	};
	65
	66	// the colour we need
	67	enum wxGtkColourType
	68	{
	69	wxGTK_FG,
	70	wxGTK_BG,
	71	wxGTK_BASE
	72	};
	73
	74	// wxSystemSettings::GetColour() helper: get the colours from a GTK+
	75	// widget style, return true if we did get them, false to use defaults
	76	static bool GetColourFromGTKWidget(int& red, int& green, int& blue,
	77	wxGtkWidgetType type = wxGTK_BUTTON,
	78	GtkStateType state = GTK_STATE_NORMAL,
	79	wxGtkColourType colour = wxGTK_BG)
	80	{
	81	GtkWidget *widget;
	82	switch ( type )
	83	{
	84	default:
	85	wxFAIL_MSG( _T("unexpected GTK widget type") );
	86	// fall through
	87
	88	case wxGTK_BUTTON:
	89	widget = gtk_button_new();
	90	break;
	91
	92	case wxGTK_LIST:
	93	widget = gtk_list_new();
	94
	95	case wxGTK_MENUITEM:
	96	widget = gtk_menu_item_new();
	97	}
	98
	99	GtkStyle *def = gtk_rc_get_style( widget );
	100	if ( !def )
	101	def = gtk_widget_get_default_style();
	102
	103	bool ok;
	104	if ( def )
	105	{
	106	GdkColor *col;
	107	switch ( colour )
	108	{
	109	default:
	110	wxFAIL_MSG( _T("unexpected GTK colour type") );
	111	// fall through
	112
	113	case wxGTK_FG:
	114	col = def->fg;
	115	break;
	116
	117	case wxGTK_BG:
	118	col = def->bg;
	119	break;
	120
	121	case wxGTK_BASE:
	122	col = def->base;
	123	break;
	124	}
	125
	126	red = col[state].red;
	127	green = col[state].green;
	128	blue = col[state].blue;
	129
	130	ok = TRUE;
	131	}
	132	else
	133	{
	134	ok = FALSE;
	135	}
	136
	137	gtk_widget_destroy( widget );
	138
	139	return ok;
	140	}
	141
	142	wxColour wxSystemSettingsNative::GetColour( wxSystemColour index )
	143	{
	144	switch (index)
	145	{
	146	case wxSYS_COLOUR_SCROLLBAR:
	147	case wxSYS_COLOUR_BACKGROUND:
	148	case wxSYS_COLOUR_INACTIVECAPTION:
	149	case wxSYS_COLOUR_MENU:
	150	case wxSYS_COLOUR_WINDOWFRAME:
	151	case wxSYS_COLOUR_ACTIVEBORDER:
	152	case wxSYS_COLOUR_INACTIVEBORDER:
	153	case wxSYS_COLOUR_BTNFACE:
	154	case wxSYS_COLOUR_MENUBAR:
	155	case wxSYS_COLOUR_3DLIGHT:
	156	if (!gs_objects.m_colBtnFace.Ok())
	157	{
	158	int red, green, blue;
	159	if ( !GetColourFromGTKWidget(red, green, blue) )
	160	{
	161	red =
	162	green = 0;
	163	blue = 0x9c40;
	164	}
	165
	166	gs_objects.m_colBtnFace = wxColour( red >> SHIFT,
	167	green >> SHIFT,
	168	blue >> SHIFT );
	169	}
	170	return gs_objects.m_colBtnFace;
	171
	172	case wxSYS_COLOUR_WINDOW:
	173	return *wxWHITE;
	174
	175	case wxSYS_COLOUR_3DDKSHADOW:
	176	return *wxBLACK;
	177
	178	case wxSYS_COLOUR_GRAYTEXT:
	179	case wxSYS_COLOUR_BTNSHADOW:
	180	//case wxSYS_COLOUR_3DSHADOW:
	181	if (!gs_objects.m_colBtnShadow.Ok())
	182	{
	183	wxColour faceColour(GetColour(wxSYS_COLOUR_3DFACE));
	184	gs_objects.m_colBtnShadow =
	185	wxColour((unsigned char) (faceColour.Red() * 0.666),
	186	(unsigned char) (faceColour.Green() * 0.666),
	187	(unsigned char) (faceColour.Blue() * 0.666));
	188	}
	189
	190	return gs_objects.m_colBtnShadow;
	191
	192	case wxSYS_COLOUR_3DHIGHLIGHT:
	193	//case wxSYS_COLOUR_BTNHIGHLIGHT:
	194	return * wxWHITE;
	195
	196	case wxSYS_COLOUR_HIGHLIGHT:
	197	if (!gs_objects.m_colHighlight.Ok())
	198	{
	199	int red, green, blue;
	200	if ( !GetColourFromGTKWidget(red, green, blue,
	201	wxGTK_BUTTON,
	202	GTK_STATE_SELECTED) )
	203	{
	204	red =
	205	green = 0;
	206	blue = 0x9c40;
	207	}
	208
	209	gs_objects.m_colHighlight = wxColour( red >> SHIFT,
	210	green >> SHIFT,
	211	blue >> SHIFT );
	212	}
	213	return gs_objects.m_colHighlight;
	214
	215	case wxSYS_COLOUR_LISTBOX:
	216	if (!gs_objects.m_colListBox.Ok())
	217	{
	218	int red, green, blue;
	219	if ( GetColourFromGTKWidget(red, green, blue,
	220	wxGTK_LIST,
	221	GTK_STATE_NORMAL,
	222	wxGTK_BASE) )
	223	{
	224	gs_objects.m_colListBox = wxColour( red >> SHIFT,
	225	green >> SHIFT,
	226	blue >> SHIFT );
	227	}
	228	else
	229	{
	230	gs_objects.m_colListBox = wxColour(*wxWHITE);
	231	}
	232	}
	233	return gs_objects.m_colListBox;
	234
	235	case wxSYS_COLOUR_MENUTEXT:
	236	case wxSYS_COLOUR_WINDOWTEXT:
	237	case wxSYS_COLOUR_CAPTIONTEXT:
	238	case wxSYS_COLOUR_INACTIVECAPTIONTEXT:
	239	case wxSYS_COLOUR_BTNTEXT:
	240	case wxSYS_COLOUR_INFOTEXT:
	241	if (!gs_objects.m_colBtnText.Ok())
	242	{
	243	int red, green, blue;
	244	if ( !GetColourFromGTKWidget(red, green, blue,
	245	wxGTK_BUTTON,
	246	GTK_STATE_NORMAL,
	247	wxGTK_FG) )
	248	{
	249	red =
	250	green =
	251	blue = 0;
	252	}
	253
	254	gs_objects.m_colBtnText = wxColour( red >> SHIFT,
	255	green >> SHIFT,
	256	blue >> SHIFT );
	257	}
	258	return gs_objects.m_colBtnText;
	259
	260	// this (as well as wxSYS_COLOUR_INFOTEXT above) is used for
	261	// tooltip windows - Robert, please change this code to use the
	262	// real GTK tooltips when/if you can (TODO)
	263	case wxSYS_COLOUR_INFOBK:
	264	return wxColour(255, 255, 225);
	265
	266	case wxSYS_COLOUR_HIGHLIGHTTEXT:
	267	if (!gs_objects.m_colHighlightText.Ok())
	268	{
	269	wxColour hclr = GetColour(wxSYS_COLOUR_HIGHLIGHT);
	270	if (hclr.Red() > 200 && hclr.Green() > 200 && hclr.Blue() > 200)
	271	gs_objects.m_colHighlightText = wxColour(*wxBLACK);
	272	else
	273	gs_objects.m_colHighlightText = wxColour(*wxWHITE);
	274	}
	275	return gs_objects.m_colHighlightText;
	276
	277	case wxSYS_COLOUR_APPWORKSPACE:
	278	return *wxWHITE; // ?
	279
	280	case wxSYS_COLOUR_ACTIVECAPTION:
	281	case wxSYS_COLOUR_MENUHILIGHT:
	282	if (!gs_objects.m_colMenuItemHighlight.Ok())
	283	{
	284	int red, green, blue;
	285	if ( !GetColourFromGTKWidget(red, green, blue,
	286	wxGTK_MENUITEM,
	287	GTK_STATE_SELECTED,
	288	wxGTK_BG) )
	289	{
	290	red =
	291	green =
	292	blue = 0;
	293	}
	294
	295	gs_objects.m_colMenuItemHighlight = wxColour( red >> SHIFT,
	296	green >> SHIFT,
	297	blue >> SHIFT );
	298	}
	299	return gs_objects.m_colMenuItemHighlight;
	300
	301	case wxSYS_COLOUR_HOTLIGHT:
	302	case wxSYS_COLOUR_GRADIENTACTIVECAPTION:
	303	case wxSYS_COLOUR_GRADIENTINACTIVECAPTION:
	304	// TODO
	305	return *wxBLACK;
	306
	307	case wxSYS_COLOUR_MAX:
	308	default:
	309	wxFAIL_MSG( _T("unknown system colour index") );
	310	}
	311
	312	return *wxWHITE;
	313	}
	314
	315	wxFont wxSystemSettingsNative::GetFont( wxSystemFont index )
	316	{
	317	switch (index)
	318	{
	319	case wxSYS_OEM_FIXED_FONT:
	320	case wxSYS_ANSI_FIXED_FONT:
	321	case wxSYS_SYSTEM_FIXED_FONT:
	322	{
	323	return *wxNORMAL_FONT;
	324	}
	325	case wxSYS_ANSI_VAR_FONT:
	326	case wxSYS_SYSTEM_FONT:
	327	case wxSYS_DEVICE_DEFAULT_FONT:
	328	case wxSYS_DEFAULT_GUI_FONT:
	329	{
	330	if (!gs_objects.m_fontSystem.Ok())
	331	{
	332	#ifdef __WXGTK20__
	333	GtkWidget *widget = gtk_button_new();
	334	GtkStyle *def = gtk_rc_get_style( widget );
	335	if ( !def \|\| !def->font_desc )
	336	def = gtk_widget_get_default_style();
	337	if ( def && def->font_desc )
	338	{
	339	wxNativeFontInfo info;
	340	info.description =
	341	pango_font_description_copy(def->font_desc);
	342	gs_objects.m_fontSystem = wxFont(info);
	343	}
	344	else
	345	{
	346	GtkSettings *settings = gtk_settings_get_default();
	347	gchar *font_name = NULL;
	348	g_object_get ( settings,
	349	"gtk-font-name",
	350	&font_name,
	351	NULL);
	352	if (!font_name)
	353	gs_objects.m_fontSystem = wxFont( 12, wxSWISS, wxNORMAL, wxNORMAL );
	354	else
	355	gs_objects.m_fontSystem = wxFont(wxString::FromAscii(font_name));
	356	g_free (font_name);
	357	}
	358	gtk_widget_destroy( widget );
	359	#else
	360	gs_objects.m_fontSystem = wxFont( 12, wxSWISS, wxNORMAL, wxNORMAL );
	361	#endif
	362	}
	363	return gs_objects.m_fontSystem;
	364	}
	365
	366	default:
	367	return wxNullFont;
	368	}
	369	}
	370
	371	int wxSystemSettingsNative::GetMetric( wxSystemMetric index, wxWindow* win )
	372	{
	373	#ifdef __WXGTK20__
	374	guchar *data = NULL;
	375	GdkWindow *window = NULL;
	376	if(win && GTK_WIDGET_REALIZED(win->GetHandle()))
	377	window = win->GetHandle()->window;
	378	#endif
	379
	380	switch (index)
	381	{
	382	case wxSYS_BORDER_X:
	383	case wxSYS_BORDER_Y:
	384	case wxSYS_EDGE_X:
	385	case wxSYS_EDGE_Y:
	386	case wxSYS_FRAMESIZE_X:
	387	case wxSYS_FRAMESIZE_Y:
	388	// If a window is specified/realized, and it is a toplevel window, we can query from wm.
	389	// The returned border thickness is outside the client area in that case.
	390	if (window)
	391	{
	392	wxTopLevelWindow *tlw = wxDynamicCast(win, wxTopLevelWindow);
	393	if (!tlw)
	394	return -1; // not a tlw, not sure how to approach
	395	else
	396	{
	397	// Check if wm supports frame extents - we can't know
	398	// the border widths if it does not.
	399	#if GTK_CHECK_VERSION(2,2,0)
	400	if (!gtk_check_version(2,2,0))
	401	{
	402	if (!gdk_x11_screen_supports_net_wm_hint(
	403	gdk_drawable_get_screen(window),
	404	gdk_atom_intern("_NET_FRAME_EXTENTS", false) ) )
	405	return -1;
	406	}
	407	else
	408	#endif
	409	{
	410	if (!gdk_net_wm_supports(gdk_atom_intern("_NET_FRAME_EXTENTS", false)))
	411	return -1;
	412	}
	413
	414	// Get the frame extents from the windowmanager.
	415	// In most cases the top extent is the titlebar, so we use the bottom extent
	416	// for the heights.
	417
	418	Atom type;
	419	gint format;
	420	gulong nitems;
	421	gulong bytes_after;
	422
	423	if (XGetWindowProperty (GDK_DISPLAY_XDISPLAY(gdk_drawable_get_display(window)),
	424	GDK_WINDOW_XWINDOW(window),
	425	gdk_x11_get_xatom_by_name_for_display (
	426	gdk_drawable_get_display(window),
	427	"_NET_FRAME_EXTENTS" ),
	428	0, // left, right, top, bottom, CARDINAL[4]/32
	429	G_MAXLONG, // size of long
	430	false, // do not delete property
	431	XA_CARDINAL, // 32 bit
	432	&type, &format, &nitems, &bytes_after, &data
	433	) == Success)
	434	{
	435	int border_return = -1;
	436
	437	if ((type == XA_CARDINAL) && (format == 32) && (nitems >= 4) && (data))
	438	{
	439	long *borders;
	440	borders = (long*)data;
	441	switch(index)
	442	{
	443	case wxSYS_BORDER_X:
	444	case wxSYS_EDGE_X:
	445	case wxSYS_FRAMESIZE_X:
	446	border_return = borders[1]; // width of right extent
	447	break;
	448	default:
	449	border_return = borders[3]; // height of bottom extent
	450	break;
	451	}
	452	}
	453
	454	if (data)
	455	XFree(data);
	456
	457	return border_return;
	458	}
	459	}
	460	}
	461
	462	return -1; // no window specified
	463
	464	case wxSYS_CURSOR_X:
	465	case wxSYS_CURSOR_Y:
	466	#ifdef __WXGTK24__
	467	if (!gtk_check_version(2,4,0))
	468	{
	469	if (window)
	470	return gdk_display_get_default_cursor_size(gdk_drawable_get_display(window));
	471	else
	472	return gdk_display_get_default_cursor_size(gdk_display_get_default());
	473	}
	474	else
	475	#endif
	476	return 16;
	477
	478	#ifdef __WXGTK20__
	479	case wxSYS_DCLICK_X:
	480	case wxSYS_DCLICK_Y:
	481	gint dclick_distance;
	482	#if GTK_CHECK_VERSION(2,2,0)
	483	if (window && !gtk_check_version(2,2,0))
	484	g_object_get(gtk_settings_get_for_screen(gdk_drawable_get_screen(window)),
	485	"gtk-double-click-distance", &dclick_distance, NULL);
	486	else
	487	#endif
	488	g_object_get(gtk_settings_get_default(),
	489	"gtk-double-click-distance", &dclick_distance, NULL);
	490
	491	return dclick_distance * 2;
	492	#endif // gtk2
	493
	494	#ifdef __WXGTK20__
	495	case wxSYS_DRAG_X:
	496	case wxSYS_DRAG_Y:
	497	gint drag_threshold;
	498	#if GTK_CHECK_VERSION(2,2,0)
	499	if (window && !gtk_check_version(2,2,0))
	500	{
	501	g_object_get(
	502	gtk_settings_get_for_screen(gdk_drawable_get_screen(window)),
	503	"gtk-dnd-drag-threshold",
	504	&drag_threshold, NULL);
	505	}
	506	else
	507	#endif
	508	{
	509	g_object_get(gtk_settings_get_default(),
	510	"gtk-dnd-drag-threshold", &drag_threshold, NULL);
	511	}
	512
	513	return drag_threshold * 2;
	514	#endif
	515
	516	// MBN: ditto for icons
	517	case wxSYS_ICON_X: return 32;
	518	case wxSYS_ICON_Y: return 32;
	519
	520	case wxSYS_SCREEN_X:
	521	#if defined(__WXGTK20__) && GTK_CHECK_VERSION(2,2,0)
	522	if (window && !gtk_check_version(2,2,0))
	523	return gdk_screen_get_width(gdk_drawable_get_screen(window));
	524	else
	525	#endif
	526	return gdk_screen_width();
	527
	528	case wxSYS_SCREEN_Y:
	529	#if defined(__WXGTK20__) && GTK_CHECK_VERSION(2,2,0)
	530	if (window && !gtk_check_version(2,2,0))
	531	return gdk_screen_get_height(gdk_drawable_get_screen(window));
	532	else
	533	#endif
	534	return gdk_screen_height();
	535
	536	case wxSYS_HSCROLL_Y: return 15;
	537	case wxSYS_VSCROLL_X: return 15;
	538
	539	// a gtk1 implementation should be possible too if gtk2 efficiency/convenience functions aren't used
	540	#ifdef __WXGTK20__
	541	case wxSYS_CAPTION_Y:
	542	if (!window)
	543	// No realized window specified, and no implementation for that case yet.
	544	return -1;
	545
	546	// Check if wm supports frame extents - we can't know the caption height if it does not.
	547	#if GTK_CHECK_VERSION(2,2,0)
	548	if (!gtk_check_version(2,2,0))
	549	{
	550	if (!gdk_x11_screen_supports_net_wm_hint(
	551	gdk_drawable_get_screen(window),
	552	gdk_atom_intern("_NET_FRAME_EXTENTS", false) ) )
	553	return -1;
	554	}
	555	else
	556	#endif
	557	{
	558	if (!gdk_net_wm_supports(gdk_atom_intern("_NET_FRAME_EXTENTS", false)))
	559	return -1;
	560	}
	561
	562	wxASSERT_MSG( wxDynamicCast(win, wxTopLevelWindow),
	563	wxT("Asking for caption height of a non toplevel window") );
	564
	565	// Get the height of the top windowmanager border.
	566	// This is the titlebar in most cases. The titlebar might be elsewhere, and
	567	// we could check which is the thickest wm border to decide on which side the
	568	// titlebar is, but this might lead to interesting behaviours in used code.
	569	// Reconsider when we have a way to report to the user on which side it is.
	570
	571	Atom type;
	572	gint format;
	573	gulong nitems;
	574	gulong bytes_after;
	575
	576	if (XGetWindowProperty (GDK_DISPLAY_XDISPLAY(gdk_drawable_get_display(window)),
	577	GDK_WINDOW_XWINDOW(window),
	578	gdk_x11_get_xatom_by_name_for_display (
	579	gdk_drawable_get_display(window),
	580	"_NET_FRAME_EXTENTS" ),
	581	0, // left, right, top, bottom, CARDINAL[4]/32
	582	G_MAXLONG, // size of long
	583	false, // do not delete property
	584	XA_CARDINAL, // 32 bit
	585	&type, &format, &nitems, &bytes_after, &data
	586	) == Success)
	587	{
	588	int caption_height = -1;
	589
	590	if ((type == XA_CARDINAL) && (format == 32) && (nitems >= 3) && (data))
	591	{
	592	long *borders;
	593	borders = (long*)data;
	594	caption_height = borders[2]; // top frame extent
	595	}
	596
	597	if (data)
	598	XFree(data);
	599
	600	return caption_height;
	601	}
	602
	603	// Try a default approach without a window pointer, if possible
	604	// ...
	605
	606	return -1;
	607	#endif // gtk2
	608
	609	case wxSYS_PENWINDOWS_PRESENT:
	610	// No MS Windows for Pen computing extension available in X11 based gtk+.
	611	return 0;
	612
	613	default:
	614	return -1; // metric is unknown
	615	}
	616	}
	617
	618	bool wxSystemSettingsNative::HasFeature(wxSystemFeature index)
	619	{
	620	switch (index)
	621	{
	622	case wxSYS_CAN_ICONIZE_FRAME:
	623	return FALSE;
	624	break;
	625	case wxSYS_CAN_DRAW_FRAME_DECORATIONS:
	626	return TRUE;
	627	break;
	628	default:
	629	return FALSE;
	630	}
	631	}