Completed sorting in wxDataViewCtrl

[wxWidgets.git] / src / gtk / control.cpp

diff --git a/src/gtk/control.cpp b/src/gtk/control.cpp
index 921820d4275eab3864061c3473d9279c16a66db0..7369e8cd9e27678fba6c4d3dfd37e57c62b52707 100644 (file)
--- a/src/gtk/control.cpp
+++ b/src/gtk/control.cpp
@@ -12,12 +12,19 @@
 
 #if wxUSE_CONTROLS
 
 
 #if wxUSE_CONTROLS
 

-#include "wx/log.h"

 #include "wx/control.h"
 #include "wx/control.h"

+
+#ifndef WX_PRECOMP
+    #include "wx/log.h"
+    #include "wx/settings.h"
+#endif
+

 #include "wx/fontutil.h"
 #include "wx/fontutil.h"

-#include "wx/settings.h"

 #include "wx/gtk/private.h"
 
 #include "wx/gtk/private.h"
 

+#include "wx/private/stattext.h"
+
+

 // ============================================================================
 // wxControl implementation
 // ============================================================================
 // ============================================================================
 // wxControl implementation
 // ============================================================================


@@ -30,7 +37,6 @@ IMPLEMENT_DYNAMIC_CLASS(wxControl, wxWindow)
 
 wxControl::wxControl()
 {
 
 wxControl::wxControl()
 {

-    m_needParent = TRUE;

 }
 
 bool wxControl::Create( wxWindow *parent,
 }
 
 bool wxControl::Create( wxWindow *parent,


@@ -66,7 +72,6 @@ wxSize wxControl::DoGetBestSize() const
     return best;
 }
 
     return best;
 }
 

-

 void wxControl::PostCreation(const wxSize& size)
 {
     wxWindow::PostCreation();
 void wxControl::PostCreation(const wxSize& size)
 {
     wxWindow::PostCreation();


@@ -79,89 +84,139 @@ void wxControl::PostCreation(const wxSize& size)
     gtk_widget_ensure_style(m_widget);
 
     ApplyWidgetStyle();
     gtk_widget_ensure_style(m_widget);
 
     ApplyWidgetStyle();

-    SetInitialBestSize(size);
+    SetInitialSize(size);

 }
 
 // ----------------------------------------------------------------------------
 // wxControl dealing with labels
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // wxControl dealing with labels
 // ----------------------------------------------------------------------------
 

-void wxControl::SetLabel( const wxString &label )
+void wxControl::GTKSetLabelForLabel(GtkLabel *w, const wxString& label)

 {
 {

-    // keep the original string internally to be able to return it later (for
-    // consistency with the other ports)
-    m_label = label;
+    // save the original label
+    wxControlBase::SetLabel(label);

 
 

-    InvalidateBestSize();
+    const wxString labelGTK = GTKConvertMnemonics(label);
+    gtk_label_set_text_with_mnemonic(w, wxGTK_CONV(labelGTK));

 }
 
 }
 

-wxString wxControl::GetLabel() const
+void wxControl::GTKSetLabelWithMarkupForLabel(GtkLabel *w, const wxString& label)

 {
 {

-    return m_label;
+    const wxString labelGTK = GTKConvertMnemonicsWithMarkup(label);
+    gtk_label_set_markup_with_mnemonic(w, wxGTK_CONV(labelGTK));

 }
 
 }
 

-void wxControl::GTKSetLabelForLabel(GtkLabel *w, const wxString& label)
-{
-    // don't call the virtual function which might call this one back again
-    wxControl::SetLabel(label);

 
 

+// ----------------------------------------------------------------------------
+// GtkFrame helpers
+//
+// GtkFrames do in fact support mnemonics in GTK2+ but not through
+// gtk_frame_set_label, rather you need to use a custom label widget
+// instead (idea gleaned from the native gtk font dialog code in GTK)
+// ----------------------------------------------------------------------------
+
+GtkWidget* wxControl::GTKCreateFrame(const wxString& label)
+{

     const wxString labelGTK = GTKConvertMnemonics(label);
     const wxString labelGTK = GTKConvertMnemonics(label);

+    GtkWidget* labelwidget = gtk_label_new_with_mnemonic(wxGTK_CONV(labelGTK));
+    gtk_widget_show(labelwidget); // without this it won't show...

 
 

-    gtk_label_set_text_with_mnemonic(w, wxGTK_CONV(labelGTK));
+    GtkWidget* framewidget = gtk_frame_new(NULL);
+    gtk_frame_set_label_widget(GTK_FRAME(framewidget), labelwidget);
+
+    return framewidget; // note that the label is already set so you'll
+                        // only need to call wxControl::SetLabel afterwards

 }
 
 void wxControl::GTKSetLabelForFrame(GtkFrame *w, const wxString& label)
 {
 }
 
 void wxControl::GTKSetLabelForFrame(GtkFrame *w, const wxString& label)
 {

-    wxControl::SetLabel(label);
+    GtkLabel* labelwidget = GTK_LABEL(gtk_frame_get_label_widget(w));
+    GTKSetLabelForLabel(labelwidget, label);
+}
+
+void wxControl::GTKFrameApplyWidgetStyle(GtkFrame* w, GtkRcStyle* style)
+{
+    gtk_widget_modify_style(GTK_WIDGET(w), style);
+    gtk_widget_modify_style(gtk_frame_get_label_widget (w), style);
+}

 
 

-    // frames don't support mnemonics even under GTK+ 2
-    const wxString labelGTK = GTKRemoveMnemonics(label);
+void wxControl::GTKFrameSetMnemonicWidget(GtkFrame* w, GtkWidget* widget)
+{
+    GtkLabel* labelwidget = GTK_LABEL(gtk_frame_get_label_widget(w));

 
 

-    gtk_frame_set_label(w, labelGTK.empty() ? (char *)NULL
-                                            : wxGTK_CONV(labelGTK));
+    gtk_label_set_mnemonic_widget(labelwidget, widget);

 }
 
 }
 

-// worker function implementing both GTKConvert/RemoveMnemonics()
-//
-// notice that under GTK+ 1 we only really need to support MNEMONICS_REMOVE as
-// it doesn't support mnemonics anyhow but this would make the code so ugly
-// that we do the same thing for GKT+ 1 and 2
+// ----------------------------------------------------------------------------
+// worker function implementing GTK*Mnemonics() functions
+// ----------------------------------------------------------------------------
+

 enum MnemonicsFlag
 {
     MNEMONICS_REMOVE,
 enum MnemonicsFlag
 {
     MNEMONICS_REMOVE,

-    MNEMONICS_CONVERT
+    MNEMONICS_CONVERT,
+    MNEMONICS_CONVERT_MARKUP

 };
 
 static wxString GTKProcessMnemonics(const wxString& label, MnemonicsFlag flag)
 {
 };
 
 static wxString GTKProcessMnemonics(const wxString& label, MnemonicsFlag flag)
 {

-    const size_t len = label.length();

     wxString labelGTK;
     wxString labelGTK;

-    labelGTK.reserve(len);
-    for ( size_t i = 0; i < len; i++ )
+    labelGTK.reserve(label.length());
+    for ( wxString::const_iterator i = label.begin(); i != label.end(); ++i )

     {
     {

-        wxChar ch = label[i];
+        wxChar ch = *i;

 
         switch ( ch )
         {
             case wxT('&'):
 
         switch ( ch )
         {
             case wxT('&'):

-                if ( i == len - 1 )
+                if ( i + 1 == label.end() )

                 {
                     // "&" at the end of string is an error
                 {
                     // "&" at the end of string is an error

-                    wxLogDebug(wxT("Invalid label \"%s\"."), label.c_str());
+                    wxLogDebug(wxT("Invalid label \"%s\"."), label);

                     break;
                 }
 
                     break;
                 }
 

-                ch = label[++i]; // skip '&' itself
+                if ( flag == MNEMONICS_CONVERT_MARKUP )
+                {
+                    bool isMnemonic = true;
+                    size_t distanceFromEnd = label.end() - i;
+
+                    // is this ampersand introducing a mnemonic or rather an entity?
+                    for (size_t j=0; j < wxMARKUP_ENTITY_MAX; j++)
+                    {
+                        const wxChar *entity = wxMarkupEntities[wxMARKUP_ELEMENT_NAME][j];
+                        size_t entityLen = wxStrlen(entity);
+
+                        if (distanceFromEnd >= entityLen &&
+                            wxString(i, i + entityLen) == entity)
+                        {
+                            labelGTK << entity;
+                            i += entityLen - 1;     // the -1 is because main for()
+                                                    // loop already increments i
+                            isMnemonic = false;
+
+                            break;
+                        }
+                    }
+
+                    if (!isMnemonic)
+                        continue;
+                }
+
+                ch = *(++i); // skip '&' itself

                 switch ( ch )
                 {
                     case wxT('&'):
                         // special case: "&&" is not a mnemonic at all but just
                         // an escaped "&"
                 switch ( ch )
                 {
                     case wxT('&'):
                         // special case: "&&" is not a mnemonic at all but just
                         // an escaped "&"

-                        labelGTK += wxT('&');
+                        if ( flag == MNEMONICS_CONVERT_MARKUP )
+                            labelGTK += wxT("&amp;");
+                        else
+                            labelGTK += wxT('&');

                         break;
 
                     case wxT('_'):
                         break;
 
                     case wxT('_'):

-                        if ( flag == MNEMONICS_CONVERT )
+                        if ( flag != MNEMONICS_REMOVE )

                         {
                             // '_' can't be a GTK mnemonic apparently so
                             // replace it with something similar
                         {
                             // '_' can't be a GTK mnemonic apparently so
                             // replace it with something similar


@@ -171,14 +226,14 @@ static wxString GTKProcessMnemonics(const wxString& label, MnemonicsFlag flag)
                         //else: fall through
 
                     default:
                         //else: fall through
 
                     default:

-                        if ( flag == MNEMONICS_CONVERT )
+                        if ( flag != MNEMONICS_REMOVE )

                             labelGTK += wxT('_');
                         labelGTK += ch;
                 }
                 break;
 
             case wxT('_'):
                             labelGTK += wxT('_');
                         labelGTK += ch;
                 }
                 break;
 
             case wxT('_'):

-                if ( flag == MNEMONICS_CONVERT )
+                if ( flag != MNEMONICS_REMOVE )

                 {
                     // escape any existing underlines in the string so that
                     // they don't become mnemonics accidentally
                 {
                     // escape any existing underlines in the string so that
                     // they don't become mnemonics accidentally


@@ -207,6 +262,12 @@ wxString wxControl::GTKConvertMnemonics(const wxString& label)
     return GTKProcessMnemonics(label, MNEMONICS_CONVERT);
 }
 
     return GTKProcessMnemonics(label, MNEMONICS_CONVERT);
 }
 

+/* static */
+wxString wxControl::GTKConvertMnemonicsWithMarkup(const wxString& label)
+{
+    return GTKProcessMnemonics(label, MNEMONICS_CONVERT_MARKUP);
+}
+

 // ----------------------------------------------------------------------------
 // wxControl styles (a.k.a. attributes)
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxControl styles (a.k.a. attributes)
 // ----------------------------------------------------------------------------


@@ -217,9 +278,6 @@ wxVisualAttributes wxControl::GetDefaultAttributes() const
                                              UseGTKStyleBase());
 }
 
                                              UseGTKStyleBase());
 }
 

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

 // static
 wxVisualAttributes
 wxControl::GetDefaultAttributesFromGTKWidget(GtkWidget* widget,
 // static
 wxVisualAttributes
 wxControl::GetDefaultAttributesFromGTKWidget(GtkWidget* widget,


@@ -242,17 +300,11 @@ wxControl::GetDefaultAttributesFromGTKWidget(GtkWidget* widget,
         state = GTK_STATE_NORMAL;
 
     // get the style's colours
         state = GTK_STATE_NORMAL;
 
     // get the style's colours

-    attr.colFg = wxColour(style->fg[state].red   >> SHIFT,
-                          style->fg[state].green >> SHIFT,
-                          style->fg[state].blue  >> SHIFT);
+    attr.colFg = wxColour(style->fg[state]);

     if (useBase)
     if (useBase)

-        attr.colBg = wxColour(style->base[state].red   >> SHIFT,
-                              style->base[state].green >> SHIFT,
-                              style->base[state].blue  >> SHIFT);
+        attr.colBg = wxColour(style->base[state]);

     else
     else

-        attr.colBg = wxColour(style->bg[state].red   >> SHIFT,
-                              style->bg[state].green >> SHIFT,
-                              style->bg[state].blue  >> SHIFT);
+        attr.colBg = wxColour(style->bg[state]);

 
     // get the style's font
     if ( !style->font_desc )
 
     // get the style's font
     if ( !style->font_desc )


@@ -331,5 +383,24 @@ wxControl::GetDefaultAttributesFromGTKWidget(wxGtkWidgetNewFromAdj_t widget_new,
     return attr;
 }
 
     return attr;
 }
 

-#endif // wxUSE_CONTROLS
+// ----------------------------------------------------------------------------
+// idle handling
+// ----------------------------------------------------------------------------

 
 

+void wxControl::OnInternalIdle()
+{
+    if ( GtkShowFromOnIdle() )
+        return;
+
+    if ( GTK_WIDGET_REALIZED(m_widget) )
+    {
+        GTKUpdateCursor();
+
+        GTKSetDelayedFocusIfNeeded();
+    }
+
+    if ( wxUpdateUIEvent::CanUpdate(this) )
+        UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
+}
+
+#endif // wxUSE_CONTROLS