src/gtk/settings.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/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 // For compilers that support precompilation, includes "wx.h".
  12 #include "wx/wxprec.h"
  13
  14 #include "wx/settings.h"
  15
  16 #ifndef WX_PRECOMP
  17     #include "wx/toplevel.h"
  18 #endif
  19
  20 #include "wx/fontutil.h"
  21 #include "wx/fontenum.h"
  22
  23 #include <gtk/gtk.h>
  24 #include "wx/gtk/private/win_gtk.h"
  25 #include "wx/gtk/private/gtk2-compat.h"
  26
  27 bool wxGetFrameExtents(GdkWindow* window, int* left, int* right, int* top, int* bottom);
  28
  29 // ----------------------------------------------------------------------------
  30 // wxSystemSettings implementation
  31 // ----------------------------------------------------------------------------
  32
  33 static wxFont gs_fontSystem;
  34
  35 static GtkContainer* ContainerWidget()
  36 {
  37     static GtkContainer* s_widget;
  38     if (s_widget == NULL)
  39     {
  40         s_widget = GTK_CONTAINER(gtk_fixed_new());
  41         GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  42         gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(s_widget));
  43     }
  44     return s_widget;
  45 }
  46
  47 extern "C" {
  48 static void style_set(GtkWidget*, GtkStyle*, void*)
  49 {
  50     gs_fontSystem = wxNullFont;
  51 }
  52 }
  53
  54 static const GtkStyle* ButtonStyle()
  55 {
  56     static GtkWidget* s_widget;
  57     if (s_widget == NULL)
  58     {
  59         s_widget = gtk_button_new();
  60         gtk_container_add(ContainerWidget(), s_widget);
  61         gtk_widget_ensure_style(s_widget);
  62         g_signal_connect(s_widget, "style_set", G_CALLBACK(style_set), NULL);
  63     }
  64     return gtk_widget_get_style(s_widget);
  65 }
  66
  67 static const GtkStyle* ListStyle()
  68 {
  69     static GtkWidget* s_widget;
  70     if (s_widget == NULL)
  71     {
  72         s_widget = gtk_tree_view_new_with_model(
  73             GTK_TREE_MODEL(gtk_list_store_new(1, G_TYPE_INT)));
  74         gtk_container_add(ContainerWidget(), s_widget);
  75         gtk_widget_ensure_style(s_widget);
  76     }
  77     return gtk_widget_get_style(s_widget);
  78 }
  79
  80 static const GtkStyle* TextCtrlStyle()
  81 {
  82     static GtkWidget* s_widget;
  83     if (s_widget == NULL)
  84     {
  85         s_widget = gtk_text_view_new();
  86         gtk_container_add(ContainerWidget(), s_widget);
  87         gtk_widget_ensure_style(s_widget);
  88     }
  89     return gtk_widget_get_style(s_widget);
  90 }
  91
  92 static const GtkStyle* MenuItemStyle()
  93 {
  94     static GtkWidget* s_widget;
  95     if (s_widget == NULL)
  96     {
  97         s_widget = gtk_menu_item_new();
  98         gtk_container_add(ContainerWidget(), s_widget);
  99         gtk_widget_ensure_style(s_widget);
 100     }
 101     return gtk_widget_get_style(s_widget);
 102 }
 103
 104 static const GtkStyle* MenuBarStyle()
 105 {
 106     static GtkWidget* s_widget;
 107     if (s_widget == NULL)
 108     {
 109         s_widget = gtk_menu_bar_new();
 110         gtk_container_add(ContainerWidget(), s_widget);
 111         gtk_widget_ensure_style(s_widget);
 112     }
 113     return gtk_widget_get_style(s_widget);
 114 }
 115
 116 static const GtkStyle* ToolTipStyle()
 117 {
 118     static GtkWidget* s_widget;
 119     if (s_widget == NULL)
 120     {
 121         s_widget = gtk_window_new(GTK_WINDOW_POPUP);
 122         const char* name = "gtk-tooltip";
 123         if (gtk_check_version(2, 11, 0))
 124             name = "gtk-tooltips";
 125         gtk_widget_set_name(s_widget, name);
 126         gtk_widget_ensure_style(s_widget);
 127     }
 128     return gtk_widget_get_style(s_widget);
 129 }
 130
 131 wxColour wxSystemSettingsNative::GetColour( wxSystemColour index )
 132 {
 133     wxColor color;
 134     switch (index)
 135     {
 136         case wxSYS_COLOUR_SCROLLBAR:
 137         case wxSYS_COLOUR_BACKGROUND:
 138         //case wxSYS_COLOUR_DESKTOP:
 139         case wxSYS_COLOUR_INACTIVECAPTION:
 140         case wxSYS_COLOUR_MENU:
 141         case wxSYS_COLOUR_WINDOWFRAME:
 142         case wxSYS_COLOUR_ACTIVEBORDER:
 143         case wxSYS_COLOUR_INACTIVEBORDER:
 144         case wxSYS_COLOUR_BTNFACE:
 145         //case wxSYS_COLOUR_3DFACE:
 146         case wxSYS_COLOUR_3DLIGHT:
 147             color = wxColor(ButtonStyle()->bg[GTK_STATE_NORMAL]);
 148             break;
 149
 150         case wxSYS_COLOUR_WINDOW:
 151             color = wxColor(TextCtrlStyle()->base[GTK_STATE_NORMAL]);
 152             break;
 153
 154         case wxSYS_COLOUR_MENUBAR:
 155             color = wxColor(MenuBarStyle()->bg[GTK_STATE_NORMAL]);
 156             break;
 157
 158         case wxSYS_COLOUR_3DDKSHADOW:
 159             color = *wxBLACK;
 160             break;
 161
 162         case wxSYS_COLOUR_GRAYTEXT:
 163         case wxSYS_COLOUR_BTNSHADOW:
 164         //case wxSYS_COLOUR_3DSHADOW:
 165             {
 166                 wxColour faceColour(GetColour(wxSYS_COLOUR_3DFACE));
 167                 color =
 168                    wxColour((unsigned char) (faceColour.Red() * 2 / 3),
 169                             (unsigned char) (faceColour.Green() * 2 / 3),
 170                             (unsigned char) (faceColour.Blue() * 2 / 3));
 171             }
 172             break;
 173
 174         case wxSYS_COLOUR_BTNHIGHLIGHT:
 175         //case wxSYS_COLOUR_BTNHILIGHT:
 176         //case wxSYS_COLOUR_3DHIGHLIGHT:
 177         //case wxSYS_COLOUR_3DHILIGHT:
 178             color = *wxWHITE;
 179             break;
 180
 181         case wxSYS_COLOUR_HIGHLIGHT:
 182             color = wxColor(ButtonStyle()->bg[GTK_STATE_SELECTED]);
 183             break;
 184
 185         case wxSYS_COLOUR_LISTBOX:
 186             color = wxColor(ListStyle()->base[GTK_STATE_NORMAL]);
 187             break;
 188
 189         case wxSYS_COLOUR_LISTBOXTEXT:
 190             color = wxColor(ListStyle()->text[GTK_STATE_NORMAL]);
 191             break;
 192
 193         case wxSYS_COLOUR_LISTBOXHIGHLIGHTTEXT:
 194             // This is for the text in a list control (or tree) when the
 195             // item is selected, but not focused
 196             color = wxColor(ListStyle()->text[GTK_STATE_ACTIVE]);
 197             break;
 198
 199         case wxSYS_COLOUR_MENUTEXT:
 200         case wxSYS_COLOUR_WINDOWTEXT:
 201         case wxSYS_COLOUR_CAPTIONTEXT:
 202         case wxSYS_COLOUR_INACTIVECAPTIONTEXT:
 203         case wxSYS_COLOUR_BTNTEXT:
 204             color = wxColor(ButtonStyle()->fg[GTK_STATE_NORMAL]);
 205             break;
 206
 207         case wxSYS_COLOUR_INFOBK:
 208             color = wxColor(ToolTipStyle()->bg[GTK_STATE_NORMAL]);
 209             break;
 210
 211         case wxSYS_COLOUR_INFOTEXT:
 212             color = wxColor(ToolTipStyle()->fg[GTK_STATE_NORMAL]);
 213             break;
 214
 215         case wxSYS_COLOUR_HIGHLIGHTTEXT:
 216             color = wxColor(ButtonStyle()->fg[GTK_STATE_SELECTED]);
 217             break;
 218
 219         case wxSYS_COLOUR_APPWORKSPACE:
 220             color = *wxWHITE;    // ?
 221             break;
 222
 223         case wxSYS_COLOUR_ACTIVECAPTION:
 224         case wxSYS_COLOUR_MENUHILIGHT:
 225             color = wxColor(MenuItemStyle()->bg[GTK_STATE_SELECTED]);
 226             break;
 227
 228         case wxSYS_COLOUR_HOTLIGHT:
 229         case wxSYS_COLOUR_GRADIENTACTIVECAPTION:
 230         case wxSYS_COLOUR_GRADIENTINACTIVECAPTION:
 231             // TODO
 232             color = *wxBLACK;
 233             break;
 234
 235         case wxSYS_COLOUR_MAX:
 236         default:
 237             wxFAIL_MSG( wxT("unknown system colour index") );
 238             color = *wxWHITE;
 239             break;
 240     }
 241
 242     wxASSERT(color.IsOk());
 243     return color;
 244 }
 245
 246 wxFont wxSystemSettingsNative::GetFont( wxSystemFont index )
 247 {
 248     wxFont font;
 249     switch (index)
 250     {
 251         case wxSYS_OEM_FIXED_FONT:
 252         case wxSYS_ANSI_FIXED_FONT:
 253         case wxSYS_SYSTEM_FIXED_FONT:
 254             font = *wxNORMAL_FONT;
 255             break;
 256
 257         case wxSYS_ANSI_VAR_FONT:
 258         case wxSYS_SYSTEM_FONT:
 259         case wxSYS_DEVICE_DEFAULT_FONT:
 260         case wxSYS_DEFAULT_GUI_FONT:
 261             if (!gs_fontSystem.IsOk())
 262             {
 263                 wxNativeFontInfo info;
 264                 info.description = ButtonStyle()->font_desc;
 265                 gs_fontSystem = wxFont(info);
 266
 267 #if wxUSE_FONTENUM
 268                 // (try to) heal the default font (on some common systems e.g. Ubuntu
 269                 // it's "Sans Serif" but the real font is called "Sans"):
 270                 if (!wxFontEnumerator::IsValidFacename(gs_fontSystem.GetFaceName()) &&
 271                     gs_fontSystem.GetFaceName() == "Sans Serif")
 272                     gs_fontSystem.SetFaceName("Sans");
 273 #endif // wxUSE_FONTENUM
 274
 275                 info.description = NULL;
 276             }
 277             font = gs_fontSystem;
 278             break;
 279
 280         default:
 281             break;
 282     }
 283
 284     wxASSERT( font.IsOk() );
 285
 286     return font;
 287 }
 288
 289 // helper: return the GtkSettings either for the screen the current window is
 290 // on or for the default screen if window is NULL
 291 static GtkSettings *GetSettingsForWindowScreen(GdkWindow *window)
 292 {
 293     return window ? gtk_settings_get_for_screen(gdk_drawable_get_screen(window))
 294                   : gtk_settings_get_default();
 295 }
 296
 297 static int GetBorderWidth(wxSystemMetric index, wxWindow* win)
 298 {
 299     if (win->m_wxwindow)
 300     {
 301         wxPizza* pizza = WX_PIZZA(win->m_wxwindow);
 302         int x, y;
 303         pizza->get_border_widths(x, y);
 304         switch (index)
 305         {
 306             case wxSYS_BORDER_X:
 307             case wxSYS_EDGE_X:
 308             case wxSYS_FRAMESIZE_X:
 309                 return x;
 310             default:
 311                 return y;
 312         }
 313     }
 314     return -1;
 315 }
 316
 317 int wxSystemSettingsNative::GetMetric( wxSystemMetric index, wxWindow* win )
 318 {
 319     GdkWindow *window = NULL;
 320     if (win)
 321         window = gtk_widget_get_window(win->GetHandle());
 322
 323     switch (index)
 324     {
 325         case wxSYS_BORDER_X:
 326         case wxSYS_BORDER_Y:
 327         case wxSYS_EDGE_X:
 328         case wxSYS_EDGE_Y:
 329         case wxSYS_FRAMESIZE_X:
 330         case wxSYS_FRAMESIZE_Y:
 331             if (win)
 332             {
 333                 wxTopLevelWindow *tlw = wxDynamicCast(win, wxTopLevelWindow);
 334                 if (!tlw)
 335                     return GetBorderWidth(index, win);
 336                 else if (window)
 337                 {
 338                     // Get the frame extents from the windowmanager.
 339                     // In most cases the top extent is the titlebar, so we use the bottom extent
 340                     // for the heights.
 341                     int right, bottom;
 342                     if (wxGetFrameExtents(window, NULL, &right, NULL, &bottom))
 343                     {
 344                         switch (index)
 345                         {
 346                             case wxSYS_BORDER_X:
 347                             case wxSYS_EDGE_X:
 348                             case wxSYS_FRAMESIZE_X:
 349                                 return right; // width of right extent
 350                             default:
 351                                 return bottom; // height of bottom extent
 352                         }
 353                     }
 354                 }
 355             }
 356
 357             return -1; // no window specified
 358
 359         case wxSYS_CURSOR_X:
 360         case wxSYS_CURSOR_Y:
 361                 return gdk_display_get_default_cursor_size(
 362                             window ? gdk_drawable_get_display(window)
 363                                    : gdk_display_get_default());
 364
 365         case wxSYS_DCLICK_X:
 366         case wxSYS_DCLICK_Y:
 367             gint dclick_distance;
 368             g_object_get(GetSettingsForWindowScreen(window),
 369                             "gtk-double-click-distance", &dclick_distance, NULL);
 370
 371             return dclick_distance * 2;
 372
 373         case wxSYS_DCLICK_MSEC:
 374             gint dclick;
 375             g_object_get(GetSettingsForWindowScreen(window),
 376                             "gtk-double-click-time", &dclick, NULL);
 377             return dclick;
 378
 379         case wxSYS_DRAG_X:
 380         case wxSYS_DRAG_Y:
 381             gint drag_threshold;
 382             g_object_get(GetSettingsForWindowScreen(window),
 383                             "gtk-dnd-drag-threshold", &drag_threshold, NULL);
 384
 385             // The correct thing here would be to double the value
 386             // since that is what the API wants. But the values
 387             // are much bigger under GNOME than under Windows and
 388             // just seem to much in many cases to be useful.
 389             // drag_threshold *= 2;
 390
 391             return drag_threshold;
 392
 393         case wxSYS_ICON_X:
 394         case wxSYS_ICON_Y:
 395             return 32;
 396
 397         case wxSYS_SCREEN_X:
 398             if (window)
 399                 return gdk_screen_get_width(gdk_drawable_get_screen(window));
 400             else
 401                 return gdk_screen_width();
 402
 403         case wxSYS_SCREEN_Y:
 404             if (window)
 405                 return gdk_screen_get_height(gdk_drawable_get_screen(window));
 406             else
 407                 return gdk_screen_height();
 408
 409         case wxSYS_HSCROLL_Y:
 410         case wxSYS_VSCROLL_X:
 411             return 15;
 412
 413         case wxSYS_CAPTION_Y:
 414             if (!window)
 415                 // No realized window specified, and no implementation for that case yet.
 416                 return -1;
 417
 418             wxASSERT_MSG( wxDynamicCast(win, wxTopLevelWindow),
 419                           wxT("Asking for caption height of a non toplevel window") );
 420
 421             // Get the height of the top windowmanager border.
 422             // This is the titlebar in most cases. The titlebar might be elsewhere, and
 423             // we could check which is the thickest wm border to decide on which side the
 424             // titlebar is, but this might lead to interesting behaviours in used code.
 425             // Reconsider when we have a way to report to the user on which side it is.
 426             {
 427                 int top;
 428                 if (wxGetFrameExtents(window, NULL, NULL, &top, NULL))
 429                 {
 430                     return top; // top frame extent
 431                 }
 432             }
 433
 434             // Try a default approach without a window pointer, if possible
 435             // ...
 436
 437             return -1;
 438
 439         case wxSYS_PENWINDOWS_PRESENT:
 440             // No MS Windows for Pen computing extension available in X11 based gtk+.
 441             return 0;
 442
 443         default:
 444             return -1;   // metric is unknown
 445     }
 446 }
 447
 448 bool wxSystemSettingsNative::HasFeature(wxSystemFeature index)
 449 {
 450     switch (index)
 451     {
 452         case wxSYS_CAN_ICONIZE_FRAME:
 453             return false;
 454
 455         case wxSYS_CAN_DRAW_FRAME_DECORATIONS:
 456             return true;
 457
 458         default:
 459             return false;
 460     }
 461 }