src/gtk1/control.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        control.cpp
   3 // Purpose:
   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 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  11 #pragma implementation "control.h"
  12 #endif
  13
  14 // For compilers that support precompilation, includes "wx.h".
  15 #include "wx/wxprec.h"
  16
  17 #include "wx/defs.h"
  18
  19 #if wxUSE_CONTROLS
  20
  21 #include "wx/control.h"
  22 #include "wx/fontutil.h"
  23 #include "wx/settings.h"
  24
  25 #include <gtk/gtk.h>
  26
  27 //-----------------------------------------------------------------------------
  28 // wxControl
  29 //-----------------------------------------------------------------------------
  30
  31 IMPLEMENT_DYNAMIC_CLASS(wxControl, wxWindow)
  32
  33 wxControl::wxControl()
  34 {
  35     m_needParent = TRUE;
  36 }
  37
  38 bool wxControl::Create( wxWindow *parent,
  39                       wxWindowID id,
  40                       const wxPoint &pos,
  41                       const wxSize &size,
  42                       long style,
  43                       const wxValidator& validator,
  44                       const wxString &name )
  45 {
  46     bool ret = wxWindow::Create(parent, id, pos, size, style, name);
  47
  48 #if wxUSE_VALIDATORS
  49     SetValidator(validator);
  50 #endif
  51
  52     return ret;
  53 }
  54
  55 void wxControl::SetLabel( const wxString &label )
  56 {
  57     m_label.Empty();
  58     for ( const wxChar *pc = label; *pc != wxT('\0'); pc++ )
  59     {
  60         if ( *pc == wxT('&') )
  61         {
  62             pc++; // skip it
  63 #if 0 // it would be unused anyhow for now - kbd interface not done yet
  64             if ( *pc != wxT('&') ) m_chAccel = *pc;
  65 #endif
  66         }
  67         m_label << *pc;
  68     }
  69 }
  70
  71 wxString wxControl::GetLabel() const
  72 {
  73     return m_label;
  74 }
  75
  76
  77 wxSize wxControl::DoGetBestSize() const
  78 {
  79     // Do not return any arbitrary default value...
  80     wxASSERT_MSG( m_widget, wxT("DoGetBestSize called before creation") );
  81
  82     GtkRequisition req;
  83     req.width = 2;
  84     req.height = 2;
  85     (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(m_widget) )->size_request )
  86         (m_widget, &req );
  87
  88     return wxSize(req.width, req.height);
  89 }
  90
  91
  92 void wxControl::PostCreation(const wxSize& size)
  93 {
  94     wxWindow::PostCreation();
  95
  96     // NB: GetBestSize needs to know the style, otherwise it will assume
  97     //     default font and if the user uses a different font, determined
  98     //     best size will be different (typically, smaller) than the desired
  99     //     size. This call ensure that a style is available at the time
 100     //     GetBestSize is called.
 101     gtk_widget_ensure_style(m_widget);
 102
 103     InheritAttributes();
 104     ApplyWidgetStyle();
 105     SetInitialBestSize(size);
 106 }
 107
 108
 109 #ifdef __WXGTK20__
 110 wxString wxControl::PrepareLabelMnemonics( const wxString &label ) const
 111 {
 112     //Format mnemonics properly for GTK2. This can be called from GTK1.x, but
 113     //it's not very useful because mnemonics don't exist prior to GTK2.
 114     wxString label2;
 115     for (size_t i = 0; i < label.Len(); i++)
 116     {
 117         if (label.GetChar(i) == wxT('&'))
 118         {
 119             //Mnemonic escape sequence "&&" is a literal "&" in the output.
 120             if (label.GetChar(i + 1) == wxT('&'))
 121             {
 122                 label2 << wxT('&');
 123                 i++;
 124             }
 125             //Handle special case of "&_" (i.e. "_" is the mnemonic).
 126             //FIXME - Is it possible to use "_" as a GTK mnemonic? Just use a
 127             //dash for now.
 128             else if (label.GetChar(i + 1) == wxT('_'))
 129             {
 130                 label2 << wxT("_-");
 131                 i++;
 132             }
 133             //Replace WX mnemonic indicator "&" with GTK indicator "_".
 134             else
 135             {
 136                 label2 << wxT('_');
 137             }
 138         }
 139         else if (label.GetChar(i) == wxT('_'))
 140         {
 141             //Escape any underlines in the string so GTK doesn't use them.
 142             label2 << wxT("__");
 143         }
 144         else
 145         {
 146             label2 << label.GetChar(i);
 147         }
 148     }
 149     return label2;
 150 }
 151 #endif
 152
 153
 154 wxVisualAttributes wxControl::GetDefaultAttributes() const
 155 {
 156     return GetDefaultAttributesFromGTKWidget(m_widget,
 157                                              UseGTKStyleBase());
 158 }
 159
 160
 161 #define SHIFT (8*(sizeof(short int)-sizeof(char)))
 162
 163 // static
 164 wxVisualAttributes
 165 wxControl::GetDefaultAttributesFromGTKWidget(GtkWidget* widget,
 166                                              bool useBase,
 167                                              int state)
 168 {
 169     GtkStyle* style;
 170     wxVisualAttributes attr;
 171
 172     style = gtk_rc_get_style(widget);
 173     if (!style)
 174         style = gtk_widget_get_default_style();
 175
 176     if (!style)
 177     {
 178         return wxWindow::GetClassDefaultAttributes(wxWINDOW_VARIANT_NORMAL);
 179     }
 180
 181     if (state == -1)
 182         state = GTK_STATE_NORMAL;
 183
 184     // get the style's colours
 185     attr.colFg = wxColour(style->fg[state].red   >> SHIFT,
 186                           style->fg[state].green >> SHIFT,
 187                           style->fg[state].blue  >> SHIFT);
 188     if (useBase)
 189         attr.colBg = wxColour(style->base[state].red   >> SHIFT,
 190                               style->base[state].green >> SHIFT,
 191                               style->base[state].blue  >> SHIFT);
 192     else
 193         attr.colBg = wxColour(style->bg[state].red   >> SHIFT,
 194                               style->bg[state].green >> SHIFT,
 195                               style->bg[state].blue  >> SHIFT);
 196
 197     // get the style's font
 198 #ifdef __WXGTK20__
 199     if ( !style->font_desc )
 200         style = gtk_widget_get_default_style();
 201     if ( style && style->font_desc )
 202     {
 203         wxNativeFontInfo info;
 204         info.description = style->font_desc;
 205         attr.font = wxFont(info);
 206     }
 207     else
 208     {
 209         GtkSettings *settings = gtk_settings_get_default();
 210         gchar *font_name = NULL;
 211         g_object_get ( settings,
 212                        "gtk-font-name",
 213                        &font_name,
 214                        NULL);
 215         if (!font_name)
 216             attr.font = wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT );
 217         else
 218             attr.font = wxFont(wxString::FromAscii(font_name));
 219         g_free (font_name);
 220     }
 221 #else
 222     // TODO: isn't there a way to get a standard gtk 1.2 font?
 223     attr.font = wxFont( 12, wxSWISS, wxNORMAL, wxNORMAL );
 224 #endif
 225
 226     return attr;
 227 }
 228
 229
 230 //static
 231 wxVisualAttributes
 232 wxControl::GetDefaultAttributesFromGTKWidget(GtkWidget* (*widget_new)(void),
 233                                              bool useBase,
 234                                              int state)
 235 {
 236     wxVisualAttributes attr;
 237     GtkWidget* widget = widget_new();
 238     attr = GetDefaultAttributesFromGTKWidget(widget, useBase, state);
 239     gtk_widget_destroy(widget);
 240     return attr;
 241 }
 242
 243 //static
 244 wxVisualAttributes
 245 wxControl::GetDefaultAttributesFromGTKWidget(GtkWidget* (*widget_new)(const gchar*),
 246                                              bool useBase,
 247                                              int state)
 248 {
 249     wxVisualAttributes attr;
 250     GtkWidget* widget = widget_new("");
 251     attr = GetDefaultAttributesFromGTKWidget(widget, useBase, state);
 252     gtk_widget_destroy(widget);
 253     return attr;
 254 }
 255
 256
 257 //static
 258 wxVisualAttributes
 259 wxControl::GetDefaultAttributesFromGTKWidget(GtkWidget* (*widget_new)(GtkAdjustment*),
 260                                              bool useBase,
 261                                              int state)
 262 {
 263     wxVisualAttributes attr;
 264     GtkWidget* widget = widget_new(NULL);
 265     attr = GetDefaultAttributesFromGTKWidget(widget, useBase, state);
 266     gtk_widget_destroy(widget);
 267     return attr;
 268 }
 269
 270 void wxControl::ApplyWidgetStyle()
 271 {
 272     GtkRcStyle *style = CreateWidgetStyle();
 273     if ( style )
 274     {
 275         DoApplyWidgetStyle(style);
 276         gtk_rc_style_unref(style);
 277     }
 278 }
 279
 280 void wxControl::DoApplyWidgetStyle(GtkRcStyle *style)
 281 {
 282     gtk_widget_modify_style(m_widget, style);
 283 }
 284
 285
 286 #endif // wxUSE_CONTROLS
 287