src/generic/statusbr.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/generic/statusbr.cpp
   3 // Purpose:     wxStatusBarGeneric class implementation
   4 // Author:      Julian Smart
   5 // Modified by: Francesco Montorsi
   6 // Created:     01/02/97
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifdef __BORLANDC__
  16     #pragma hdrstop
  17 #endif
  18
  19 #if wxUSE_STATUSBAR
  20
  21 #include "wx/statusbr.h"
  22
  23 #ifndef WX_PRECOMP
  24     #include "wx/settings.h"
  25     #include "wx/dcclient.h"
  26     #include "wx/toplevel.h"
  27     #include "wx/control.h"
  28 #endif
  29
  30 #ifdef __WXGTK20__
  31     #include <gtk/gtk.h>
  32     #include "wx/gtk/private.h"
  33 #endif
  34
  35 // we only have to do it here when we use wxStatusBarGeneric in addition to the
  36 // standard wxStatusBar class, if wxStatusBarGeneric is the same as
  37 // wxStatusBar, then the corresponding IMPLEMENT_DYNAMIC_CLASS is already in
  38 // common/statbar.cpp
  39 #if defined(__WXMAC__) || \
  40     (defined(wxUSE_NATIVE_STATUSBAR) && wxUSE_NATIVE_STATUSBAR)
  41     #include "wx/generic/statusbr.h"
  42
  43     IMPLEMENT_DYNAMIC_CLASS(wxStatusBarGeneric, wxWindow)
  44 #endif // wxUSE_NATIVE_STATUSBAR
  45
  46 // Default status border dimensions
  47 #define wxTHICK_LINE_BORDER 2
  48
  49 // Margin between the field text and the field rect
  50 #define wxFIELD_TEXT_MARGIN 2
  51
  52 // ----------------------------------------------------------------------------
  53 // GTK+ signal handler
  54 // ----------------------------------------------------------------------------
  55
  56 #if defined( __WXGTK20__ )
  57 #if GTK_CHECK_VERSION(2,12,0)
  58 extern "C" {
  59 static
  60 gboolean statusbar_query_tooltip(GtkWidget*   WXUNUSED(widget),
  61                                  gint        x,
  62                                  gint        y,
  63                                  gboolean     WXUNUSED(keyboard_mode),
  64                                  GtkTooltip *tooltip,
  65                                  wxStatusBar* statbar)
  66 {
  67     int n = statbar->GetFieldFromPoint(wxPoint(x,y));
  68     if (n == wxNOT_FOUND)
  69         return FALSE;
  70
  71     // should we show the tooltip for the n-th pane of the statusbar?
  72     if (!statbar->GetField(n).IsEllipsized())
  73         return FALSE;   // no, it's not useful
  74
  75     const wxString& str = statbar->GetStatusText(n);
  76     if (str.empty())
  77         return FALSE;
  78
  79     gtk_tooltip_set_text(tooltip, wxGTK_CONV_SYS(str));
  80     return TRUE;
  81 }
  82 }
  83 #endif
  84 #endif
  85
  86 // ----------------------------------------------------------------------------
  87 // wxStatusBarGeneric
  88 // ----------------------------------------------------------------------------
  89
  90 BEGIN_EVENT_TABLE(wxStatusBarGeneric, wxWindow)
  91     EVT_PAINT(wxStatusBarGeneric::OnPaint)
  92     EVT_SIZE(wxStatusBarGeneric::OnSize)
  93     EVT_LEFT_DOWN(wxStatusBarGeneric::OnLeftDown)
  94     EVT_RIGHT_DOWN(wxStatusBarGeneric::OnRightDown)
  95     EVT_SYS_COLOUR_CHANGED(wxStatusBarGeneric::OnSysColourChanged)
  96 END_EVENT_TABLE()
  97
  98 void wxStatusBarGeneric::Init()
  99 {
 100     m_borderX = wxTHICK_LINE_BORDER;
 101     m_borderY = wxTHICK_LINE_BORDER;
 102 }
 103
 104 wxStatusBarGeneric::~wxStatusBarGeneric()
 105 {
 106 }
 107
 108 bool wxStatusBarGeneric::Create(wxWindow *parent,
 109                                 wxWindowID id,
 110                                 long style,
 111                                 const wxString& name)
 112 {
 113     style |= wxTAB_TRAVERSAL | wxFULL_REPAINT_ON_RESIZE;
 114     if ( !wxWindow::Create(parent, id,
 115                            wxDefaultPosition, wxDefaultSize,
 116                            style, name) )
 117         return false;
 118
 119     // The status bar should have a themed background
 120     SetThemeEnabled( true );
 121
 122     InitColours();
 123
 124 #ifdef __WXPM__
 125     SetFont(*wxSMALL_FONT);
 126 #endif
 127
 128     int height = (int)((11*GetCharHeight())/10 + 2*GetBorderY());
 129     SetSize(wxDefaultCoord, wxDefaultCoord, wxDefaultCoord, height);
 130
 131     SetFieldsCount(1);
 132
 133 #if defined( __WXGTK20__ )
 134 #if GTK_CHECK_VERSION(2,12,0)
 135     if (HasFlag(wxSTB_SHOW_TIPS) && !gtk_check_version(2,12,0))
 136     {
 137         g_object_set(m_widget, "has-tooltip", TRUE, NULL);
 138         g_signal_connect(m_widget, "query-tooltip",
 139                          G_CALLBACK(statusbar_query_tooltip), this);
 140     }
 141 #endif
 142 #endif
 143
 144     return true;
 145 }
 146
 147 wxSize wxStatusBarGeneric::DoGetBestSize() const
 148 {
 149     int width, height;
 150
 151     // best width is the width of the parent
 152     if (GetParent())
 153         GetParent()->GetClientSize(&width, NULL);
 154     else
 155         width = 80;     // a dummy value
 156
 157     // best height is as calculated above in Create()
 158     height = (int)((11*GetCharHeight())/10 + 2*GetBorderY());
 159
 160     return wxSize(width, height);
 161 }
 162
 163 void wxStatusBarGeneric::SetFieldsCount(int number, const int *widths)
 164 {
 165     wxASSERT_MSG( number >= 0, _T("negative number of fields in wxStatusBar?") );
 166
 167     // this will result in a call to SetStatusWidths() and thus an update to our
 168     // m_widthsAbs cache
 169     wxStatusBarBase::SetFieldsCount(number, widths);
 170 }
 171
 172 void wxStatusBarGeneric::SetStatusText(const wxString& text, int number)
 173 {
 174     wxCHECK_RET( (number >= 0) && ((size_t)number < m_panes.GetCount()),
 175                  _T("invalid status bar field index") );
 176
 177     wxString oldText = GetStatusText(number);
 178     if (oldText != text)
 179     {
 180         wxStatusBarBase::SetStatusText(text, number);
 181
 182         wxRect rect;
 183         GetFieldRect(number, rect);
 184
 185         Refresh(true, &rect);
 186
 187         // it's common to show some text in the status bar before starting a
 188         // relatively lengthy operation, ensure that the text is shown to the
 189         // user immediately and not after the lengthy operation end
 190         Update();
 191     }
 192 }
 193
 194 void wxStatusBarGeneric::SetStatusWidths(int n, const int widths_field[])
 195 {
 196     // only set status widths when n == number of statuswindows
 197     wxCHECK_RET( (size_t)n == m_panes.GetCount(), _T("status bar field count mismatch") );
 198
 199     wxStatusBarBase::SetStatusWidths(n, widths_field);
 200
 201     // update cache
 202     int width;
 203     GetClientSize(&width, &m_lastClientHeight);
 204     m_widthsAbs = CalculateAbsWidths(width);
 205 }
 206
 207 bool wxStatusBarGeneric::ShowsSizeGrip() const
 208 {
 209     if ( !HasFlag(wxSTB_SIZEGRIP) )
 210         return false;
 211
 212     wxTopLevelWindow * const
 213         tlw = wxDynamicCast(wxGetTopLevelParent(GetParent()), wxTopLevelWindow);
 214     return tlw && !tlw->IsMaximized() && tlw->HasFlag(wxRESIZE_BORDER);
 215 }
 216
 217 void wxStatusBarGeneric::DrawFieldText(wxDC& dc, const wxRect& rect, int i, int textHeight)
 218 {
 219     wxString text(GetStatusText(i));
 220     if (text.empty())
 221         return;     // optimization
 222
 223     int xpos = rect.x + wxFIELD_TEXT_MARGIN,
 224         maxWidth = rect.width - 2*wxFIELD_TEXT_MARGIN,
 225         ypos = (int) (((rect.height - textHeight) / 2) + rect.y + 0.5);
 226
 227     if (ShowsSizeGrip())
 228     {
 229         // don't write text over the size grip:
 230         // NOTE: overloading DoGetClientSize() and GetClientAreaOrigin() wouldn't
 231         //       work because the adjustment needs to be done only when drawing
 232         //       the field text and not also when drawing the background, the
 233         //       size grip itself, etc
 234         if ((GetLayoutDirection() == wxLayout_RightToLeft && i == 0) ||
 235             (GetLayoutDirection() != wxLayout_RightToLeft &&
 236                  i == (int)m_panes.GetCount()-1))
 237         {
 238             const wxRect& gripRc = GetSizeGripRect();
 239
 240             // NOTE: we don't need any special treatment wrt to the layout direction
 241             //       since DrawText() will automatically adjust the origin of the
 242             //       text accordingly to the layout in use
 243
 244             maxWidth -= gripRc.width;
 245         }
 246     }
 247
 248     // eventually ellipsize the text so that it fits the field width
 249
 250     wxEllipsizeMode ellmode = (wxEllipsizeMode)-1;
 251     if (HasFlag(wxSTB_ELLIPSIZE_START)) ellmode = wxELLIPSIZE_START;
 252     else if (HasFlag(wxSTB_ELLIPSIZE_MIDDLE)) ellmode = wxELLIPSIZE_MIDDLE;
 253     else if (HasFlag(wxSTB_ELLIPSIZE_END)) ellmode = wxELLIPSIZE_END;
 254
 255     if (ellmode == (wxEllipsizeMode)-1)
 256     {
 257         // if we have the wxSTB_SHOW_TIPS we must set the ellipsized flag even if
 258         // we don't ellipsize the text but just truncate it
 259         if (HasFlag(wxSTB_SHOW_TIPS))
 260             SetEllipsizedFlag(i, dc.GetTextExtent(text).GetWidth() > maxWidth);
 261
 262         dc.SetClippingRegion(rect);
 263     }
 264     else
 265     {
 266         text = wxControl::Ellipsize(text, dc,
 267                                     ellmode,
 268                                     maxWidth,
 269                                     wxELLIPSIZE_EXPAND_TAB);
 270             // Ellipsize() will do something only if necessary
 271
 272         // update the ellipsization status for this pane; this is used later to
 273         // decide whether a tooltip should be shown or not for this pane
 274         // (if we have wxSTB_SHOW_TIPS)
 275         SetEllipsizedFlag(i, text != GetStatusText(i));
 276     }
 277
 278 #if defined( __WXGTK__ ) || defined(__WXMAC__)
 279     xpos++;
 280     ypos++;
 281 #endif
 282
 283     // draw the text
 284     dc.DrawText(text, xpos, ypos);
 285
 286     if (ellmode == (wxEllipsizeMode)-1)
 287         dc.DestroyClippingRegion();
 288 }
 289
 290 void wxStatusBarGeneric::DrawField(wxDC& dc, int i, int textHeight)
 291 {
 292     wxRect rect;
 293     GetFieldRect(i, rect);
 294
 295     if (rect.GetWidth() <= 0)
 296         return;     // happens when the status bar is shrinked in a very small area!
 297
 298     int style = m_panes[i].GetStyle();
 299     if (style != wxSB_FLAT)
 300     {
 301         // Draw border
 302         // For wxSB_NORMAL: paint a grey background, plus 3-d border (one black rectangle)
 303         // Inside this, left and top sides (dark grey). Bottom and right (white).
 304         // Reverse it for wxSB_RAISED
 305
 306         dc.SetPen((style == wxSB_RAISED) ? m_mediumShadowPen : m_hilightPen);
 307
 308 #ifndef __WXPM__
 309
 310         // Right and bottom lines
 311         dc.DrawLine(rect.x + rect.width, rect.y,
 312                     rect.x + rect.width, rect.y + rect.height);
 313         dc.DrawLine(rect.x + rect.width, rect.y + rect.height,
 314                     rect.x, rect.y + rect.height);
 315
 316         dc.SetPen((style == wxSB_RAISED) ? m_hilightPen : m_mediumShadowPen);
 317
 318         // Left and top lines
 319         dc.DrawLine(rect.x, rect.y + rect.height,
 320                rect.x, rect.y);
 321         dc.DrawLine(rect.x, rect.y,
 322             rect.x + rect.width, rect.y);
 323 #else
 324
 325         dc.DrawLine(rect.x + rect.width, rect.height + 2,
 326                     rect.x, rect.height + 2);
 327         dc.DrawLine(rect.x + rect.width, rect.y,
 328                     rect.x + rect.width, rect.y + rect.height);
 329
 330         dc.SetPen((style == wxSB_RAISED) ? m_hilightPen : m_mediumShadowPen);
 331         dc.DrawLine(rect.x, rect.y,
 332                     rect.x + rect.width, rect.y);
 333         dc.DrawLine(rect.x, rect.y + rect.height,
 334                     rect.x, rect.y);
 335 #endif
 336     }
 337
 338     DrawFieldText(dc, rect, i, textHeight);
 339 }
 340
 341 bool wxStatusBarGeneric::GetFieldRect(int n, wxRect& rect) const
 342 {
 343     wxCHECK_MSG( (n >= 0) && ((size_t)n < m_panes.GetCount()), false,
 344                  _T("invalid status bar field index") );
 345
 346     if (m_widthsAbs.IsEmpty())
 347         return false;
 348
 349     rect.x = 0;
 350     for ( int i = 0; i < n; i++ )
 351         rect.x += m_widthsAbs[i];
 352     rect.x += m_borderX;
 353
 354     rect.y = m_borderY;
 355     rect.width = m_widthsAbs[n] - 2*m_borderX;
 356     rect.height = m_lastClientHeight - 2*m_borderY;
 357
 358     return true;
 359 }
 360
 361 int wxStatusBarGeneric::GetFieldFromPoint(const wxPoint& pt) const
 362 {
 363     if (m_widthsAbs.IsEmpty())
 364         return wxNOT_FOUND;
 365
 366     // NOTE: we explicitely don't take in count the borders since they are only
 367     //       useful when rendering the status text, not for hit-test computations
 368
 369     if (pt.y <= 0 || pt.y >= m_lastClientHeight)
 370         return wxNOT_FOUND;
 371
 372     int x = 0;
 373     for ( size_t i = 0; i < m_panes.GetCount(); i++ )
 374     {
 375         if (pt.x > x && pt.x < x+m_widthsAbs[i])
 376             return i;
 377
 378         x += m_widthsAbs[i];
 379     }
 380
 381     return wxNOT_FOUND;
 382 }
 383
 384 void wxStatusBarGeneric::InitColours()
 385 {
 386 #if defined(__WXPM__)
 387     m_mediumShadowPen = wxPen(wxColour(127, 127, 127));
 388     m_hilightPen = *wxWHITE_PEN;
 389
 390     SetBackgroundColour(*wxLIGHT_GREY);
 391     SetForegroundColour(*wxBLACK);
 392 #else // !__WXPM__
 393     m_mediumShadowPen = wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW));
 394     m_hilightPen = wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DHILIGHT));
 395 #endif // __WXPM__/!__WXPM__
 396 }
 397
 398 void wxStatusBarGeneric::SetMinHeight(int height)
 399 {
 400     // check that this min height is not less than minimal height for the
 401     // current font (min height is as calculated above in Create() except for border)
 402     int minHeight = (int)((11*GetCharHeight())/10);
 403
 404     if ( height > minHeight )
 405         SetSize(wxDefaultCoord, wxDefaultCoord, wxDefaultCoord, height + 2*m_borderY);
 406 }
 407
 408 wxRect wxStatusBarGeneric::GetSizeGripRect() const
 409 {
 410     int width, height;
 411     wxWindow::DoGetClientSize(&width, &height);
 412
 413     if (GetLayoutDirection() == wxLayout_RightToLeft)
 414         return wxRect(2, 2, height-2, height-4);
 415     else
 416         return wxRect(width-height-2, 2, height-2, height-4);
 417 }
 418
 419 // ----------------------------------------------------------------------------
 420 // wxStatusBarGeneric - event handlers
 421 // ----------------------------------------------------------------------------
 422
 423 void wxStatusBarGeneric::OnPaint(wxPaintEvent& WXUNUSED(event) )
 424 {
 425     wxPaintDC dc(this);
 426
 427 #ifdef __WXGTK20__
 428     // Draw grip first
 429     if ( ShowsSizeGrip() )
 430     {
 431         const wxRect& rc = GetSizeGripRect();
 432         GdkWindowEdge edge =
 433             GetLayoutDirection() == wxLayout_RightToLeft ? GDK_WINDOW_EDGE_SOUTH_WEST :
 434                                                            GDK_WINDOW_EDGE_SOUTH_EAST;
 435         gtk_paint_resize_grip( m_widget->style,
 436                             GTKGetDrawingWindow(),
 437                             (GtkStateType) GTK_WIDGET_STATE (m_widget),
 438                             NULL,
 439                             m_widget,
 440                             "statusbar",
 441                             edge,
 442                             rc.x, rc.y, rc.width, rc.height );
 443     }
 444 #endif // __WXGTK20__
 445
 446     if (GetFont().IsOk())
 447         dc.SetFont(GetFont());
 448
 449     // compute char height only once for all panes:
 450     int textHeight = dc.GetCharHeight();
 451
 452     dc.SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT);
 453     for (size_t i = 0; i < m_panes.GetCount(); i ++)
 454         DrawField(dc, i, textHeight);
 455 }
 456
 457 void wxStatusBarGeneric::OnSysColourChanged(wxSysColourChangedEvent& event)
 458 {
 459     InitColours();
 460
 461     // Propagate the event to the non-top-level children
 462     wxWindow::OnSysColourChanged(event);
 463 }
 464
 465 void wxStatusBarGeneric::OnLeftDown(wxMouseEvent& event)
 466 {
 467 #ifdef __WXGTK20__
 468     int width, height;
 469     GetClientSize(&width, &height);
 470
 471     if ( ShowsSizeGrip()  && (event.GetX() > width-height) )
 472     {
 473         GtkWidget *ancestor = gtk_widget_get_toplevel( m_widget );
 474
 475         if (!GTK_IS_WINDOW (ancestor))
 476             return;
 477
 478         GdkWindow *source = GTKGetDrawingWindow();
 479
 480         int org_x = 0;
 481         int org_y = 0;
 482         gdk_window_get_origin( source, &org_x, &org_y );
 483
 484         if (GetLayoutDirection() == wxLayout_RightToLeft)
 485         {
 486             gtk_window_begin_resize_drag (GTK_WINDOW (ancestor),
 487                                   GDK_WINDOW_EDGE_SOUTH_WEST,
 488                                   1,
 489                                   org_x - event.GetX() + GetSize().x ,
 490                                   org_y + event.GetY(),
 491                                   0);
 492         }
 493         else
 494         {
 495             gtk_window_begin_resize_drag (GTK_WINDOW (ancestor),
 496                                   GDK_WINDOW_EDGE_SOUTH_EAST,
 497                                   1,
 498                                   org_x + event.GetX(),
 499                                   org_y + event.GetY(),
 500                                   0);
 501         }
 502     }
 503     else
 504     {
 505         event.Skip( true );
 506     }
 507 #else
 508     event.Skip( true );
 509 #endif
 510 }
 511
 512 void wxStatusBarGeneric::OnRightDown(wxMouseEvent& event)
 513 {
 514 #ifdef __WXGTK20__
 515     int width, height;
 516     GetClientSize(&width, &height);
 517
 518     if ( ShowsSizeGrip() && (event.GetX() > width-height) )
 519     {
 520         GtkWidget *ancestor = gtk_widget_get_toplevel( m_widget );
 521
 522         if (!GTK_IS_WINDOW (ancestor))
 523             return;
 524
 525         GdkWindow *source = GTKGetDrawingWindow();
 526
 527         int org_x = 0;
 528         int org_y = 0;
 529         gdk_window_get_origin( source, &org_x, &org_y );
 530
 531         gtk_window_begin_move_drag (GTK_WINDOW (ancestor),
 532                                 2,
 533                                 org_x + event.GetX(),
 534                                 org_y + event.GetY(),
 535                                 0);
 536     }
 537     else
 538     {
 539         event.Skip( true );
 540     }
 541 #else
 542     event.Skip( true );
 543 #endif
 544 }
 545
 546 void wxStatusBarGeneric::OnSize(wxSizeEvent& WXUNUSED(event))
 547 {
 548     // FIXME: workarounds for OS/2 bugs have nothing to do here (VZ)
 549     int width;
 550 #ifdef __WXPM__
 551     GetSize(&width, &m_lastClientHeight);
 552 #else
 553     GetClientSize(&width, &m_lastClientHeight);
 554 #endif
 555
 556     // recompute the cache of the field widths if the status bar width has changed
 557     m_widthsAbs = CalculateAbsWidths(width);
 558 }
 559
 560 #endif // wxUSE_STATUSBAR