src/gtk/control.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/gtk/control.cpp
   3 // Purpose:     wxControl implementation for wxGTK
   4 // Author:      Robert Roebling
   5 // Id:          $Id$
   6 // Copyright:   (c) 1998 Robert Roebling, Julian Smart and Vadim Zeitlin
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // For compilers that support precompilation, includes "wx.h".
  11 #include "wx/wxprec.h"
  12
  13 #if wxUSE_CONTROLS
  14
  15 #include "wx/log.h"
  16 #include "wx/control.h"
  17 #include "wx/fontutil.h"
  18 #include "wx/settings.h"
  19 #include "wx/gtk/private.h"
  20
  21 // ============================================================================
  22 // wxControl implementation
  23 // ============================================================================
  24
  25 // ----------------------------------------------------------------------------
  26 // wxControl creation
  27 // ----------------------------------------------------------------------------
  28
  29 IMPLEMENT_DYNAMIC_CLASS(wxControl, wxWindow)
  30
  31 wxControl::wxControl()
  32 {
  33     m_needParent = TRUE;
  34 }
  35
  36 bool wxControl::Create( wxWindow *parent,
  37                       wxWindowID id,
  38                       const wxPoint &pos,
  39                       const wxSize &size,
  40                       long style,
  41                       const wxValidator& validator,
  42                       const wxString &name )
  43 {
  44     bool ret = wxWindow::Create(parent, id, pos, size, style, name);
  45
  46 #if wxUSE_VALIDATORS
  47     SetValidator(validator);
  48 #endif
  49
  50     return ret;
  51 }
  52
  53 wxSize wxControl::DoGetBestSize() const
  54 {
  55     // Do not return any arbitrary default value...
  56     wxASSERT_MSG( m_widget, wxT("DoGetBestSize called before creation") );
  57
  58     GtkRequisition req;
  59     req.width = 2;
  60     req.height = 2;
  61     (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(m_widget) )->size_request )
  62         (m_widget, &req );
  63
  64     wxSize best(req.width, req.height);
  65     CacheBestSize(best);
  66     return best;
  67 }
  68
  69
  70 void wxControl::PostCreation(const wxSize& size)
  71 {
  72     wxWindow::PostCreation();
  73
  74     // NB: GetBestSize needs to know the style, otherwise it will assume
  75     //     default font and if the user uses a different font, determined
  76     //     best size will be different (typically, smaller) than the desired
  77     //     size. This call ensure that a style is available at the time
  78     //     GetBestSize is called.
  79     gtk_widget_ensure_style(m_widget);
  80
  81     ApplyWidgetStyle();
  82     SetInitialBestSize(size);
  83 }
  84
  85 // ----------------------------------------------------------------------------
  86 // wxControl dealing with labels
  87 // ----------------------------------------------------------------------------
  88
  89 void wxControl::SetLabel( const wxString &label )
  90 {
  91     // keep the original string internally to be able to return it later (for
  92     // consistency with the other ports)
  93     m_label = label;
  94
  95     InvalidateBestSize();
  96 }
  97
  98 wxString wxControl::GetLabel() const
  99 {
 100     return m_label;
 101 }
 102
 103 void wxControl::GTKSetLabelForLabel(GtkLabel *w, const wxString& label)
 104 {
 105     // don't call the virtual function which might call this one back again
 106     wxControl::SetLabel(label);
 107
 108     const wxString labelGTK = GTKConvertMnemonics(label);
 109
 110     gtk_label_set_text_with_mnemonic(w, wxGTK_CONV(labelGTK));
 111 }
 112
 113 void wxControl::GTKSetLabelForFrame(GtkFrame *w, const wxString& label)
 114 {
 115     wxControl::SetLabel(label);
 116
 117     // frames don't support mnemonics even under GTK+ 2
 118     const wxString labelGTK = GTKRemoveMnemonics(label);
 119
 120     gtk_frame_set_label(w, labelGTK.empty() ? (char *)NULL
 121                                             : wxGTK_CONV(labelGTK));
 122 }
 123
 124 // worker function implementing both GTKConvert/RemoveMnemonics()
 125 //
 126 // notice that under GTK+ 1 we only really need to support MNEMONICS_REMOVE as
 127 // it doesn't support mnemonics anyhow but this would make the code so ugly
 128 // that we do the same thing for GKT+ 1 and 2
 129 enum MnemonicsFlag
 130 {
 131     MNEMONICS_REMOVE,
 132     MNEMONICS_CONVERT
 133 };
 134
 135 static wxString GTKProcessMnemonics(const wxString& label, MnemonicsFlag flag)
 136 {
 137     const size_t len = label.length();
 138     wxString labelGTK;
 139     labelGTK.reserve(len);
 140     for ( size_t i = 0; i < len; i++ )
 141     {
 142         wxChar ch = label[i];
 143
 144         switch ( ch )
 145         {
 146             case wxT('&'):
 147                 if ( i == len - 1 )
 148                 {
 149                     // "&" at the end of string is an error
 150                     wxLogDebug(wxT("Invalid label \"%s\"."), label.c_str());
 151                     break;
 152                 }
 153
 154                 ch = label[++i]; // skip '&' itself
 155                 switch ( ch )
 156                 {
 157                     case wxT('&'):
 158                         // special case: "&&" is not a mnemonic at all but just
 159                         // an escaped "&"
 160                         labelGTK += wxT('&');
 161                         break;
 162
 163                     case wxT('_'):
 164                         if ( flag == MNEMONICS_CONVERT )
 165                         {
 166                             // '_' can't be a GTK mnemonic apparently so
 167                             // replace it with something similar
 168                             labelGTK += wxT("_-");
 169                             break;
 170                         }
 171                         //else: fall through
 172
 173                     default:
 174                         if ( flag == MNEMONICS_CONVERT )
 175                             labelGTK += wxT('_');
 176                         labelGTK += ch;
 177                 }
 178                 break;
 179
 180             case wxT('_'):
 181                 if ( flag == MNEMONICS_CONVERT )
 182                 {
 183                     // escape any existing underlines in the string so that
 184                     // they don't become mnemonics accidentally
 185                     labelGTK += wxT("__");
 186                     break;
 187                 }
 188                 //else: fall through
 189
 190             default:
 191                 labelGTK += ch;
 192         }
 193     }
 194
 195     return labelGTK;
 196 }
 197
 198 /* static */
 199 wxString wxControl::GTKRemoveMnemonics(const wxString& label)
 200 {
 201     return GTKProcessMnemonics(label, MNEMONICS_REMOVE);
 202 }
 203
 204 /* static */
 205 wxString wxControl::GTKConvertMnemonics(const wxString& label)
 206 {
 207     return GTKProcessMnemonics(label, MNEMONICS_CONVERT);
 208 }
 209
 210 // ----------------------------------------------------------------------------
 211 // wxControl styles (a.k.a. attributes)
 212 // ----------------------------------------------------------------------------
 213
 214 wxVisualAttributes wxControl::GetDefaultAttributes() const
 215 {
 216     return GetDefaultAttributesFromGTKWidget(m_widget,
 217                                              UseGTKStyleBase());
 218 }
 219
 220
 221 #define SHIFT (8*(sizeof(short int)-sizeof(char)))
 222
 223 // static
 224 wxVisualAttributes
 225 wxControl::GetDefaultAttributesFromGTKWidget(GtkWidget* widget,
 226                                              bool useBase,
 227                                              int state)
 228 {
 229     GtkStyle* style;
 230     wxVisualAttributes attr;
 231
 232     style = gtk_rc_get_style(widget);
 233     if (!style)
 234         style = gtk_widget_get_default_style();
 235
 236     if (!style)
 237     {
 238         return wxWindow::GetClassDefaultAttributes(wxWINDOW_VARIANT_NORMAL);
 239     }
 240
 241     if (state == -1)
 242         state = GTK_STATE_NORMAL;
 243
 244     // get the style's colours
 245     attr.colFg = wxColour(style->fg[state].red   >> SHIFT,
 246                           style->fg[state].green >> SHIFT,
 247                           style->fg[state].blue  >> SHIFT);
 248     if (useBase)
 249         attr.colBg = wxColour(style->base[state].red   >> SHIFT,
 250                               style->base[state].green >> SHIFT,
 251                               style->base[state].blue  >> SHIFT);
 252     else
 253         attr.colBg = wxColour(style->bg[state].red   >> SHIFT,
 254                               style->bg[state].green >> SHIFT,
 255                               style->bg[state].blue  >> SHIFT);
 256
 257     // get the style's font
 258     if ( !style->font_desc )
 259         style = gtk_widget_get_default_style();
 260     if ( style && style->font_desc )
 261     {
 262         wxNativeFontInfo info;
 263         info.description = pango_font_description_copy(style->font_desc);
 264         attr.font = wxFont(info);
 265     }
 266     else
 267     {
 268         GtkSettings *settings = gtk_settings_get_default();
 269         gchar *font_name = NULL;
 270         g_object_get ( settings,
 271                        "gtk-font-name",
 272                        &font_name,
 273                        NULL);
 274         if (!font_name)
 275             attr.font = wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT );
 276         else
 277             attr.font = wxFont(wxString::FromAscii(font_name));
 278         g_free (font_name);
 279     }
 280
 281     return attr;
 282 }
 283
 284
 285 //static
 286 wxVisualAttributes
 287 wxControl::GetDefaultAttributesFromGTKWidget(wxGtkWidgetNew_t widget_new,
 288                                              bool useBase,
 289                                              int state)
 290 {
 291     wxVisualAttributes attr;
 292     // NB: we need toplevel window so that GTK+ can find the right style
 293     GtkWidget *wnd = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 294     GtkWidget* widget = widget_new();
 295     gtk_container_add(GTK_CONTAINER(wnd), widget);
 296     attr = GetDefaultAttributesFromGTKWidget(widget, useBase, state);
 297     gtk_widget_destroy(wnd);
 298     return attr;
 299 }
 300
 301 //static
 302 wxVisualAttributes
 303 wxControl::GetDefaultAttributesFromGTKWidget(wxGtkWidgetNewFromStr_t widget_new,
 304                                              bool useBase,
 305                                              int state)
 306 {
 307     wxVisualAttributes attr;
 308     // NB: we need toplevel window so that GTK+ can find the right style
 309     GtkWidget *wnd = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 310     GtkWidget* widget = widget_new("");
 311     gtk_container_add(GTK_CONTAINER(wnd), widget);
 312     attr = GetDefaultAttributesFromGTKWidget(widget, useBase, state);
 313     gtk_widget_destroy(wnd);
 314     return attr;
 315 }
 316
 317
 318 //static
 319 wxVisualAttributes
 320 wxControl::GetDefaultAttributesFromGTKWidget(wxGtkWidgetNewFromAdj_t widget_new,
 321                                              bool useBase,
 322                                              int state)
 323 {
 324     wxVisualAttributes attr;
 325     // NB: we need toplevel window so that GTK+ can find the right style
 326     GtkWidget *wnd = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 327     GtkWidget* widget = widget_new(NULL);
 328     gtk_container_add(GTK_CONTAINER(wnd), widget);
 329     attr = GetDefaultAttributesFromGTKWidget(widget, useBase, state);
 330     gtk_widget_destroy(wnd);
 331     return attr;
 332 }
 333
 334 #endif // wxUSE_CONTROLS
 335