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();
            break;

        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__
    bool success = false;

    guchar *data = NULL;
    GdkWindow *window = NULL;
    if(win && GTK_WIDGET_REALIZED(win->GetHandle()))
        window = win->GetHandle()->window;
#endif

    switch (index)
    {
#ifdef __WXGTK20__
        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;

#if GTK_CHECK_VERSION(2,2,0)
                    if (!gtk_check_version(2,2,0))
                    {
                        gulong bytes_after;
                        success = (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);
                    }
#endif
                    if (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
#endif // gtk2

        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;

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