src/generic/srchctlg.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/generic/srchctlg.cpp
   3 // Purpose:     implements wxSearchCtrl as a composite control
   4 // Author:      Vince Harron
   5 // Created:     2006-02-19
   6 // RCS-ID:      $Id$
   7 // Copyright:   Vince Harron
   8 // Licence:     wxWindows licence
   9 ///////////////////////////////////////////////////////////////////////////////
  10
  11 // For compilers that support precompilation, includes "wx.h".
  12 #include "wx/wxprec.h"
  13
  14 #ifdef __BORLANDC__
  15     #pragma hdrstop
  16 #endif
  17
  18 #if wxUSE_SEARCHCTRL
  19
  20 #include "wx/srchctrl.h"
  21
  22 #ifndef WX_PRECOMP
  23     #include "wx/button.h"
  24     #include "wx/dcclient.h"
  25     #include "wx/menu.h"
  26     #include "wx/dcmemory.h"
  27 #endif //WX_PRECOMP
  28
  29 #if !wxUSE_NATIVE_SEARCH_CONTROL
  30
  31 #include "wx/image.h"
  32
  33 #define WXMAX(a,b) ((a)>(b)?(a):(b))
  34
  35 // ----------------------------------------------------------------------------
  36 // constants
  37 // ----------------------------------------------------------------------------
  38
  39 // the margin between the text control and the search/cancel buttons
  40 static const wxCoord MARGIN = 2;
  41
  42 // border around all controls to compensate for wxSIMPLE_BORDER
  43 #if defined(__WXMSW__)
  44 static const wxCoord BORDER = 0;
  45 static const wxCoord ICON_MARGIN = 2;
  46 static const wxCoord ICON_OFFSET = 2;
  47 #else
  48 static const wxCoord BORDER = 2;
  49 static const wxCoord ICON_MARGIN = 0;
  50 static const wxCoord ICON_OFFSET = 0;
  51 #endif
  52
  53 #define LIGHT_STEP 160
  54
  55 // ----------------------------------------------------------------------------
  56 // wxSearchTextCtrl: text control used by search control
  57 // ----------------------------------------------------------------------------
  58
  59 class wxSearchTextCtrl : public wxTextCtrl
  60 {
  61 public:
  62     wxSearchTextCtrl(wxSearchCtrl *search, const wxString& value, int style)
  63         : wxTextCtrl(search, wxID_ANY, value, wxDefaultPosition, wxDefaultSize,
  64                      (style & ~wxBORDER_MASK) | wxNO_BORDER)
  65     {
  66         m_search = search;
  67
  68         SetHint(_("Search"));
  69
  70         // Ensure that our best size is recomputed using our overridden
  71         // DoGetBestSize().
  72         InvalidateBestSize();
  73     }
  74
  75
  76     // provide access to the base class protected methods to wxSearchCtrl which
  77     // needs to forward to them
  78     void DoSetValue(const wxString& value, int flags)
  79     {
  80         wxTextCtrl::DoSetValue(value, flags);
  81     }
  82
  83     bool DoLoadFile(const wxString& file, int fileType)
  84     {
  85         return wxTextCtrl::DoLoadFile(file, fileType);
  86     }
  87
  88     bool DoSaveFile(const wxString& file, int fileType)
  89     {
  90         return wxTextCtrl::DoSaveFile(file, fileType);
  91     }
  92
  93 protected:
  94     void OnText(wxCommandEvent& eventText)
  95     {
  96         wxCommandEvent event(eventText);
  97         event.SetEventObject(m_search);
  98         event.SetId(m_search->GetId());
  99
 100         m_search->GetEventHandler()->ProcessEvent(event);
 101     }
 102
 103     void OnTextUrl(wxTextUrlEvent& eventText)
 104     {
 105         // copy constructor is disabled for some reason?
 106         //wxTextUrlEvent event(eventText);
 107         wxTextUrlEvent event(
 108             m_search->GetId(),
 109             eventText.GetMouseEvent(),
 110             eventText.GetURLStart(),
 111             eventText.GetURLEnd()
 112             );
 113         event.SetEventObject(m_search);
 114
 115         m_search->GetEventHandler()->ProcessEvent(event);
 116     }
 117
 118 #ifdef __WXMSW__
 119     // We increase the text control height to be the same as for the controls
 120     // with border as this is what we actually need here because even though
 121     // this control itself is borderless, it's inside wxSearchCtrl which does
 122     // have the border and so should have the same height as the normal text
 123     // entries with border.
 124     //
 125     // This is a bit ugly and it would arguably be better to use whatever size
 126     // the base class version returns and just centre the text vertically in
 127     // the search control but I failed to modify the code in LayoutControls()
 128     // to do this easily and as there is much in that code I don't understand
 129     // (notably what is the logic for buttons sizing?) I prefer to not touch it
 130     // at all.
 131     virtual wxSize DoGetBestSize() const
 132     {
 133         const long flags = GetWindowStyleFlag();
 134         wxSearchTextCtrl* const self = const_cast<wxSearchTextCtrl*>(this);
 135
 136         self->SetWindowStyleFlag((flags & ~wxBORDER_MASK) | wxBORDER_DEFAULT);
 137         const wxSize size = wxTextCtrl::DoGetBestSize();
 138         self->SetWindowStyleFlag(flags);
 139
 140         return size;
 141     }
 142 #endif // __WXMSW__
 143
 144 private:
 145     wxSearchCtrl* m_search;
 146
 147     DECLARE_EVENT_TABLE()
 148 };
 149
 150 BEGIN_EVENT_TABLE(wxSearchTextCtrl, wxTextCtrl)
 151     EVT_TEXT(wxID_ANY, wxSearchTextCtrl::OnText)
 152     EVT_TEXT_ENTER(wxID_ANY, wxSearchTextCtrl::OnText)
 153     EVT_TEXT_URL(wxID_ANY, wxSearchTextCtrl::OnTextUrl)
 154     EVT_TEXT_MAXLEN(wxID_ANY, wxSearchTextCtrl::OnText)
 155 END_EVENT_TABLE()
 156
 157 // ----------------------------------------------------------------------------
 158 // wxSearchButton: search button used by search control
 159 // ----------------------------------------------------------------------------
 160
 161 class wxSearchButton : public wxControl
 162 {
 163 public:
 164     wxSearchButton(wxSearchCtrl *search, int eventType, const wxBitmap& bmp)
 165         : wxControl(search, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxNO_BORDER),
 166           m_search(search),
 167           m_eventType(eventType),
 168           m_bmp(bmp)
 169     { }
 170
 171     void SetBitmapLabel(const wxBitmap& label) { m_bmp = label; }
 172
 173     // The buttons in wxSearchCtrl shouldn't accept focus from keyboard because
 174     // this would interfere with the usual TAB processing: the user expects
 175     // that pressing TAB in the search control should switch focus to the next
 176     // control and not give it to the button inside the same control. Besides,
 177     // the search button can be already activated by pressing "Enter" so there
 178     // is really no reason for it to be able to get focus from keyboard.
 179     virtual bool AcceptsFocusFromKeyboard() const { return false; }
 180
 181 protected:
 182     wxSize DoGetBestSize() const
 183     {
 184         return wxSize(m_bmp.GetWidth(), m_bmp.GetHeight());
 185     }
 186
 187     void OnLeftUp(wxMouseEvent&)
 188     {
 189         wxCommandEvent event(m_eventType, m_search->GetId());
 190         event.SetEventObject(m_search);
 191
 192         if ( m_eventType == wxEVT_COMMAND_SEARCHCTRL_SEARCH_BTN )
 193         {
 194             // it's convenient to have the string to search for directly in the
 195             // event instead of having to retrieve it from the control in the
 196             // event handler code later, so provide it here
 197             event.SetString(m_search->GetValue());
 198         }
 199
 200         GetEventHandler()->ProcessEvent(event);
 201
 202         m_search->SetFocus();
 203
 204 #if wxUSE_MENUS
 205         if ( m_eventType == wxEVT_COMMAND_SEARCHCTRL_SEARCH_BTN )
 206         {
 207             // this happens automatically, just like on Mac OS X
 208             m_search->PopupSearchMenu();
 209         }
 210 #endif // wxUSE_MENUS
 211     }
 212
 213     void OnPaint(wxPaintEvent&)
 214     {
 215         wxPaintDC dc(this);
 216         dc.DrawBitmap(m_bmp, 0,0, true);
 217     }
 218
 219
 220 private:
 221     wxSearchCtrl *m_search;
 222     wxEventType   m_eventType;
 223     wxBitmap      m_bmp;
 224
 225     DECLARE_EVENT_TABLE()
 226 };
 227
 228 BEGIN_EVENT_TABLE(wxSearchButton, wxControl)
 229     EVT_LEFT_UP(wxSearchButton::OnLeftUp)
 230     EVT_PAINT(wxSearchButton::OnPaint)
 231 END_EVENT_TABLE()
 232
 233 BEGIN_EVENT_TABLE(wxSearchCtrl, wxSearchCtrlBase)
 234     EVT_SEARCHCTRL_SEARCH_BTN(wxID_ANY, wxSearchCtrl::OnSearchButton)
 235     EVT_SET_FOCUS(wxSearchCtrl::OnSetFocus)
 236     EVT_SIZE(wxSearchCtrl::OnSize)
 237 END_EVENT_TABLE()
 238
 239 IMPLEMENT_DYNAMIC_CLASS(wxSearchCtrl, wxSearchCtrlBase)
 240
 241 // ============================================================================
 242 // implementation
 243 // ============================================================================
 244
 245 // ----------------------------------------------------------------------------
 246 // wxSearchCtrl creation
 247 // ----------------------------------------------------------------------------
 248
 249 // creation
 250 // --------
 251
 252 wxSearchCtrl::wxSearchCtrl()
 253 {
 254     Init();
 255 }
 256
 257 wxSearchCtrl::wxSearchCtrl(wxWindow *parent, wxWindowID id,
 258            const wxString& value,
 259            const wxPoint& pos,
 260            const wxSize& size,
 261            long style,
 262            const wxValidator& validator,
 263            const wxString& name)
 264 {
 265     Init();
 266
 267     Create(parent, id, value, pos, size, style, validator, name);
 268 }
 269
 270 void wxSearchCtrl::Init()
 271 {
 272     m_text = NULL;
 273     m_searchButton = NULL;
 274     m_cancelButton = NULL;
 275 #if wxUSE_MENUS
 276     m_menu = NULL;
 277 #endif // wxUSE_MENUS
 278
 279     m_searchButtonVisible = true;
 280     m_cancelButtonVisible = false;
 281
 282     m_searchBitmapUser = false;
 283     m_cancelBitmapUser = false;
 284 #if wxUSE_MENUS
 285     m_searchMenuBitmapUser = false;
 286 #endif // wxUSE_MENUS
 287 }
 288
 289 bool wxSearchCtrl::Create(wxWindow *parent, wxWindowID id,
 290             const wxString& value,
 291             const wxPoint& pos,
 292             const wxSize& size,
 293             long style,
 294             const wxValidator& validator,
 295             const wxString& name)
 296 {
 297     // force border style for more native appearance
 298     style &= ~wxBORDER_MASK;
 299 #ifdef __WXGTK__
 300     style |= wxBORDER_SUNKEN;
 301 #elif defined(__WXMSW__)
 302     // Don't set the style explicitly, let GetDefaultBorder() work it out, unless
 303     // we will get a sunken border (e.g. on Windows 200) in which case we must
 304     // override with a simple border.
 305     if (GetDefaultBorder() == wxBORDER_SUNKEN)
 306         style |= wxBORDER_SIMPLE;
 307 #else
 308     style |= wxBORDER_SIMPLE;
 309 #endif
 310     if ( !wxSearchCtrlBaseBaseClass::Create(parent, id, pos, size,
 311                                             style, validator, name) )
 312     {
 313         return false;
 314     }
 315
 316     m_text = new wxSearchTextCtrl(this, value, style);
 317
 318     m_searchButton = new wxSearchButton(this,
 319                                         wxEVT_COMMAND_SEARCHCTRL_SEARCH_BTN,
 320                                         m_searchBitmap);
 321     m_cancelButton = new wxSearchButton(this,
 322                                         wxEVT_COMMAND_SEARCHCTRL_CANCEL_BTN,
 323                                         m_cancelBitmap);
 324
 325     SetForegroundColour( m_text->GetForegroundColour() );
 326     SetBackgroundColour( m_text->GetBackgroundColour() );
 327
 328     RecalcBitmaps();
 329
 330     SetInitialSize(size);
 331     Move(pos);
 332     return true;
 333 }
 334
 335 wxSearchCtrl::~wxSearchCtrl()
 336 {
 337     delete m_text;
 338     delete m_searchButton;
 339     delete m_cancelButton;
 340 #if wxUSE_MENUS
 341     delete m_menu;
 342 #endif // wxUSE_MENUS
 343 }
 344
 345
 346 // search control specific interfaces
 347 #if wxUSE_MENUS
 348
 349 void wxSearchCtrl::SetMenu( wxMenu* menu )
 350 {
 351     if ( menu == m_menu )
 352     {
 353         // no change
 354         return;
 355     }
 356     bool hadMenu = (m_menu != NULL);
 357     delete m_menu;
 358     m_menu = menu;
 359
 360     if ( m_menu && !hadMenu )
 361     {
 362         m_searchButton->SetBitmapLabel(m_searchMenuBitmap);
 363         m_searchButton->Refresh();
 364     }
 365     else if ( !m_menu && hadMenu )
 366     {
 367         m_searchButton->SetBitmapLabel(m_searchBitmap);
 368         if ( m_searchButtonVisible )
 369         {
 370             m_searchButton->Refresh();
 371         }
 372     }
 373     wxRect rect = GetRect();
 374     LayoutControls(0, 0, rect.GetWidth(), rect.GetHeight());
 375 }
 376
 377 wxMenu* wxSearchCtrl::GetMenu()
 378 {
 379     return m_menu;
 380 }
 381
 382 #endif // wxUSE_MENUS
 383
 384 void wxSearchCtrl::ShowSearchButton( bool show )
 385 {
 386     if ( m_searchButtonVisible == show )
 387     {
 388         // no change
 389         return;
 390     }
 391     m_searchButtonVisible = show;
 392     if ( m_searchButtonVisible )
 393     {
 394         RecalcBitmaps();
 395     }
 396
 397     wxRect rect = GetRect();
 398     LayoutControls(0, 0, rect.GetWidth(), rect.GetHeight());
 399 }
 400
 401 bool wxSearchCtrl::IsSearchButtonVisible() const
 402 {
 403     return m_searchButtonVisible;
 404 }
 405
 406
 407 void wxSearchCtrl::ShowCancelButton( bool show )
 408 {
 409     if ( m_cancelButtonVisible == show )
 410     {
 411         // no change
 412         return;
 413     }
 414     m_cancelButtonVisible = show;
 415
 416     wxRect rect = GetRect();
 417     LayoutControls(0, 0, rect.GetWidth(), rect.GetHeight());
 418 }
 419
 420 bool wxSearchCtrl::IsCancelButtonVisible() const
 421 {
 422     return m_cancelButtonVisible;
 423 }
 424
 425 void wxSearchCtrl::SetDescriptiveText(const wxString& text)
 426 {
 427     m_text->SetHint(text);
 428 }
 429
 430 wxString wxSearchCtrl::GetDescriptiveText() const
 431 {
 432     return m_text->GetHint();
 433 }
 434
 435 // ----------------------------------------------------------------------------
 436 // geometry
 437 // ----------------------------------------------------------------------------
 438
 439 wxSize wxSearchCtrl::DoGetBestSize() const
 440 {
 441     wxSize sizeText = m_text->GetBestSize();
 442     wxSize sizeSearch(0,0);
 443     wxSize sizeCancel(0,0);
 444     int searchMargin = 0;
 445     int cancelMargin = 0;
 446     if ( m_searchButtonVisible || HasMenu() )
 447     {
 448         sizeSearch = m_searchButton->GetBestSize();
 449         searchMargin = MARGIN;
 450     }
 451     if ( m_cancelButtonVisible )
 452     {
 453         sizeCancel = m_cancelButton->GetBestSize();
 454         cancelMargin = MARGIN;
 455     }
 456
 457     int horizontalBorder = 1 + ( sizeText.y - sizeText.y * 14 / 21 ) / 2;
 458
 459     // buttons are square and equal to the height of the text control
 460     int height = sizeText.y;
 461     return wxSize(sizeSearch.x + searchMargin + sizeText.x + cancelMargin + sizeCancel.x + 2*horizontalBorder,
 462                   height + 2*BORDER);
 463 }
 464
 465 void wxSearchCtrl::DoMoveWindow(int x, int y, int width, int height)
 466 {
 467     wxSearchCtrlBase::DoMoveWindow(x, y, width, height);
 468
 469     LayoutControls(0, 0, width, height);
 470 }
 471
 472 void wxSearchCtrl::LayoutControls(int x, int y, int width, int height)
 473 {
 474     if ( !m_text )
 475         return;
 476
 477     wxSize sizeText = m_text->GetBestSize();
 478     // make room for the search menu & clear button
 479     int horizontalBorder = ( sizeText.y - sizeText.y * 14 / 21 ) / 2;
 480     x += horizontalBorder;
 481     y += BORDER;
 482     width -= horizontalBorder*2;
 483     height -= BORDER*2;
 484     if (width < 0) width = 0;
 485     if (height < 0) height = 0;
 486
 487     wxSize sizeSearch(0,0);
 488     wxSize sizeCancel(0,0);
 489     int searchMargin = 0;
 490     int cancelMargin = 0;
 491     if ( m_searchButtonVisible || HasMenu() )
 492     {
 493         sizeSearch = m_searchButton->GetBestSize();
 494         searchMargin = MARGIN;
 495     }
 496     if ( m_cancelButtonVisible )
 497     {
 498         sizeCancel = m_cancelButton->GetBestSize();
 499         cancelMargin = MARGIN;
 500     }
 501     m_searchButton->Show( m_searchButtonVisible || HasMenu() );
 502     m_cancelButton->Show( m_cancelButtonVisible );
 503
 504     if ( sizeSearch.x + sizeCancel.x > width )
 505     {
 506         sizeSearch.x = width/2;
 507         sizeCancel.x = width/2;
 508         searchMargin = 0;
 509         cancelMargin = 0;
 510     }
 511     wxCoord textWidth = width - sizeSearch.x - sizeCancel.x - searchMargin - cancelMargin - 1;
 512     if (textWidth < 0) textWidth = 0;
 513
 514     // position the subcontrols inside the client area
 515
 516     m_searchButton->SetSize(x, y + ICON_OFFSET - 1, sizeSearch.x, height);
 517     m_text->SetSize( x + sizeSearch.x + searchMargin,
 518                      y + ICON_OFFSET - BORDER,
 519                      textWidth,
 520                      height);
 521     m_cancelButton->SetSize(x + sizeSearch.x + searchMargin + textWidth + cancelMargin,
 522                             y + ICON_OFFSET - 1, sizeCancel.x, height);
 523 }
 524
 525 wxWindowList wxSearchCtrl::GetCompositeWindowParts() const
 526 {
 527     wxWindowList parts;
 528     parts.push_back(m_text);
 529     parts.push_back(m_searchButton);
 530     parts.push_back(m_cancelButton);
 531     return parts;
 532 }
 533
 534 // accessors
 535 // ---------
 536
 537 wxString wxSearchCtrl::DoGetValue() const
 538 {
 539     return m_text->GetValue();
 540 }
 541 wxString wxSearchCtrl::GetRange(long from, long to) const
 542 {
 543     return m_text->GetRange(from, to);
 544 }
 545
 546 int wxSearchCtrl::GetLineLength(long lineNo) const
 547 {
 548     return m_text->GetLineLength(lineNo);
 549 }
 550 wxString wxSearchCtrl::GetLineText(long lineNo) const
 551 {
 552     return m_text->GetLineText(lineNo);
 553 }
 554 int wxSearchCtrl::GetNumberOfLines() const
 555 {
 556     return m_text->GetNumberOfLines();
 557 }
 558
 559 bool wxSearchCtrl::IsModified() const
 560 {
 561     return m_text->IsModified();
 562 }
 563 bool wxSearchCtrl::IsEditable() const
 564 {
 565     return m_text->IsEditable();
 566 }
 567
 568 // more readable flag testing methods
 569 bool wxSearchCtrl::IsSingleLine() const
 570 {
 571     return m_text->IsSingleLine();
 572 }
 573 bool wxSearchCtrl::IsMultiLine() const
 574 {
 575     return m_text->IsMultiLine();
 576 }
 577
 578 // If the return values from and to are the same, there is no selection.
 579 void wxSearchCtrl::GetSelection(long* from, long* to) const
 580 {
 581     m_text->GetSelection(from, to);
 582 }
 583
 584 wxString wxSearchCtrl::GetStringSelection() const
 585 {
 586     return m_text->GetStringSelection();
 587 }
 588
 589 // operations
 590 // ----------
 591
 592 // editing
 593 void wxSearchCtrl::Clear()
 594 {
 595     m_text->Clear();
 596 }
 597 void wxSearchCtrl::Replace(long from, long to, const wxString& value)
 598 {
 599     m_text->Replace(from, to, value);
 600 }
 601 void wxSearchCtrl::Remove(long from, long to)
 602 {
 603     m_text->Remove(from, to);
 604 }
 605
 606 // load/save the controls contents from/to the file
 607 bool wxSearchCtrl::LoadFile(const wxString& file)
 608 {
 609     return m_text->LoadFile(file);
 610 }
 611 bool wxSearchCtrl::SaveFile(const wxString& file)
 612 {
 613     return m_text->SaveFile(file);
 614 }
 615
 616 // sets/clears the dirty flag
 617 void wxSearchCtrl::MarkDirty()
 618 {
 619     m_text->MarkDirty();
 620 }
 621 void wxSearchCtrl::DiscardEdits()
 622 {
 623     m_text->DiscardEdits();
 624 }
 625
 626 // set the max number of characters which may be entered in a single line
 627 // text control
 628 void wxSearchCtrl::SetMaxLength(unsigned long len)
 629 {
 630     m_text->SetMaxLength(len);
 631 }
 632
 633 // writing text inserts it at the current position, appending always
 634 // inserts it at the end
 635 void wxSearchCtrl::WriteText(const wxString& text)
 636 {
 637     m_text->WriteText(text);
 638 }
 639 void wxSearchCtrl::AppendText(const wxString& text)
 640 {
 641     m_text->AppendText(text);
 642 }
 643
 644 // insert the character which would have resulted from this key event,
 645 // return true if anything has been inserted
 646 bool wxSearchCtrl::EmulateKeyPress(const wxKeyEvent& event)
 647 {
 648     return m_text->EmulateKeyPress(event);
 649 }
 650
 651 // text control under some platforms supports the text styles: these
 652 // methods allow to apply the given text style to the given selection or to
 653 // set/get the style which will be used for all appended text
 654 bool wxSearchCtrl::SetStyle(long start, long end, const wxTextAttr& style)
 655 {
 656     return m_text->SetStyle(start, end, style);
 657 }
 658 bool wxSearchCtrl::GetStyle(long position, wxTextAttr& style)
 659 {
 660     return m_text->GetStyle(position, style);
 661 }
 662 bool wxSearchCtrl::SetDefaultStyle(const wxTextAttr& style)
 663 {
 664     return m_text->SetDefaultStyle(style);
 665 }
 666 const wxTextAttr& wxSearchCtrl::GetDefaultStyle() const
 667 {
 668     return m_text->GetDefaultStyle();
 669 }
 670
 671 // translate between the position (which is just an index in the text ctrl
 672 // considering all its contents as a single strings) and (x, y) coordinates
 673 // which represent column and line.
 674 long wxSearchCtrl::XYToPosition(long x, long y) const
 675 {
 676     return m_text->XYToPosition(x, y);
 677 }
 678 bool wxSearchCtrl::PositionToXY(long pos, long *x, long *y) const
 679 {
 680     return m_text->PositionToXY(pos, x, y);
 681 }
 682
 683 void wxSearchCtrl::ShowPosition(long pos)
 684 {
 685     m_text->ShowPosition(pos);
 686 }
 687
 688 // find the character at position given in pixels
 689 //
 690 // NB: pt is in device coords (not adjusted for the client area origin nor
 691 //     scrolling)
 692 wxTextCtrlHitTestResult wxSearchCtrl::HitTest(const wxPoint& pt, long *pos) const
 693 {
 694     return m_text->HitTest(pt, pos);
 695 }
 696 wxTextCtrlHitTestResult wxSearchCtrl::HitTest(const wxPoint& pt,
 697                                         wxTextCoord *col,
 698                                         wxTextCoord *row) const
 699 {
 700     return m_text->HitTest(pt, col, row);
 701 }
 702
 703 // Clipboard operations
 704 void wxSearchCtrl::Copy()
 705 {
 706     m_text->Copy();
 707 }
 708 void wxSearchCtrl::Cut()
 709 {
 710     m_text->Cut();
 711 }
 712 void wxSearchCtrl::Paste()
 713 {
 714     m_text->Paste();
 715 }
 716
 717 bool wxSearchCtrl::CanCopy() const
 718 {
 719     return m_text->CanCopy();
 720 }
 721 bool wxSearchCtrl::CanCut() const
 722 {
 723     return m_text->CanCut();
 724 }
 725 bool wxSearchCtrl::CanPaste() const
 726 {
 727     return m_text->CanPaste();
 728 }
 729
 730 // Undo/redo
 731 void wxSearchCtrl::Undo()
 732 {
 733     m_text->Undo();
 734 }
 735 void wxSearchCtrl::Redo()
 736 {
 737     m_text->Redo();
 738 }
 739
 740 bool wxSearchCtrl::CanUndo() const
 741 {
 742     return m_text->CanUndo();
 743 }
 744 bool wxSearchCtrl::CanRedo() const
 745 {
 746     return m_text->CanRedo();
 747 }
 748
 749 // Insertion point
 750 void wxSearchCtrl::SetInsertionPoint(long pos)
 751 {
 752     m_text->SetInsertionPoint(pos);
 753 }
 754 void wxSearchCtrl::SetInsertionPointEnd()
 755 {
 756     m_text->SetInsertionPointEnd();
 757 }
 758 long wxSearchCtrl::GetInsertionPoint() const
 759 {
 760     return m_text->GetInsertionPoint();
 761 }
 762 long wxSearchCtrl::GetLastPosition() const
 763 {
 764     return m_text->GetLastPosition();
 765 }
 766
 767 void wxSearchCtrl::SetSelection(long from, long to)
 768 {
 769     m_text->SetSelection(from, to);
 770 }
 771 void wxSearchCtrl::SelectAll()
 772 {
 773     m_text->SelectAll();
 774 }
 775
 776 void wxSearchCtrl::SetEditable(bool editable)
 777 {
 778     m_text->SetEditable(editable);
 779 }
 780
 781 bool wxSearchCtrl::SetFont(const wxFont& font)
 782 {
 783     if ( !wxSearchCtrlBase::SetFont(font) )
 784         return false;
 785
 786     // Recreate the bitmaps as their size may have changed.
 787     RecalcBitmaps();
 788
 789     return true;
 790 }
 791
 792 bool wxSearchCtrl::SetBackgroundColour(const wxColour& colour)
 793 {
 794     if ( !wxSearchCtrlBase::SetBackgroundColour(colour) )
 795         return false;
 796
 797     // When the background changes, re-render the bitmaps so that the correct
 798     // colour shows in their "transparent" area.
 799     RecalcBitmaps();
 800
 801     return true;
 802 }
 803
 804 // search control generic only
 805 void wxSearchCtrl::SetSearchBitmap( const wxBitmap& bitmap )
 806 {
 807     m_searchBitmap = bitmap;
 808     m_searchBitmapUser = bitmap.IsOk();
 809     if ( m_searchBitmapUser )
 810     {
 811         if ( m_searchButton && !HasMenu() )
 812         {
 813             m_searchButton->SetBitmapLabel( m_searchBitmap );
 814         }
 815     }
 816     else
 817     {
 818         // the user bitmap was just cleared, generate one
 819         RecalcBitmaps();
 820     }
 821 }
 822
 823 #if wxUSE_MENUS
 824
 825 void wxSearchCtrl::SetSearchMenuBitmap( const wxBitmap& bitmap )
 826 {
 827     m_searchMenuBitmap = bitmap;
 828     m_searchMenuBitmapUser = bitmap.IsOk();
 829     if ( m_searchMenuBitmapUser )
 830     {
 831         if ( m_searchButton && m_menu )
 832         {
 833             m_searchButton->SetBitmapLabel( m_searchMenuBitmap );
 834         }
 835     }
 836     else
 837     {
 838         // the user bitmap was just cleared, generate one
 839         RecalcBitmaps();
 840     }
 841 }
 842
 843 #endif // wxUSE_MENUS
 844
 845 void wxSearchCtrl::SetCancelBitmap( const wxBitmap& bitmap )
 846 {
 847     m_cancelBitmap = bitmap;
 848     m_cancelBitmapUser = bitmap.IsOk();
 849     if ( m_cancelBitmapUser )
 850     {
 851         if ( m_cancelButton )
 852         {
 853             m_cancelButton->SetBitmapLabel( m_cancelBitmap );
 854         }
 855     }
 856     else
 857     {
 858         // the user bitmap was just cleared, generate one
 859         RecalcBitmaps();
 860     }
 861 }
 862
 863 #if 0
 864
 865 // override streambuf method
 866 #if wxHAS_TEXT_WINDOW_STREAM
 867 int overflow(int i);
 868 #endif // wxHAS_TEXT_WINDOW_STREAM
 869
 870 // stream-like insertion operators: these are always available, whether we
 871 // were, or not, compiled with streambuf support
 872 wxTextCtrl& operator<<(const wxString& s);
 873 wxTextCtrl& operator<<(int i);
 874 wxTextCtrl& operator<<(long i);
 875 wxTextCtrl& operator<<(float f);
 876 wxTextCtrl& operator<<(double d);
 877 wxTextCtrl& operator<<(const wxChar c);
 878 #endif
 879
 880 void wxSearchCtrl::DoSetValue(const wxString& value, int flags)
 881 {
 882     m_text->DoSetValue(value, flags);
 883 }
 884
 885 bool wxSearchCtrl::DoLoadFile(const wxString& file, int fileType)
 886 {
 887     return m_text->DoLoadFile(file, fileType);
 888 }
 889
 890 bool wxSearchCtrl::DoSaveFile(const wxString& file, int fileType)
 891 {
 892     return m_text->DoSaveFile(file, fileType);
 893 }
 894
 895 // do the window-specific processing after processing the update event
 896 void wxSearchCtrl::DoUpdateWindowUI(wxUpdateUIEvent& event)
 897 {
 898     wxSearchCtrlBase::DoUpdateWindowUI(event);
 899 }
 900
 901 bool wxSearchCtrl::ShouldInheritColours() const
 902 {
 903     return true;
 904 }
 905
 906 // icons are rendered at 3-8 times larger than necessary and downscaled for
 907 // antialiasing
 908 static int GetMultiplier()
 909 {
 910 #ifdef __WXWINCE__
 911     // speed up bitmap generation by using a small bitmap
 912     return 3;
 913 #else
 914     int depth = ::wxDisplayDepth();
 915
 916     if  ( depth >= 24 )
 917     {
 918         return 8;
 919     }
 920     return 6;
 921 #endif
 922 }
 923
 924 wxBitmap wxSearchCtrl::RenderSearchBitmap( int x, int y, bool renderDrop )
 925 {
 926     wxColour bg = GetBackgroundColour();
 927     wxColour fg = GetForegroundColour().ChangeLightness(LIGHT_STEP-20);
 928
 929     //===============================================================================
 930     // begin drawing code
 931     //===============================================================================
 932     // image stats
 933
 934     // force width:height ratio
 935     if ( 14*x > y*20 )
 936     {
 937         // x is too big
 938         x = y*20/14;
 939     }
 940     else
 941     {
 942         // y is too big
 943         y = x*14/20;
 944     }
 945
 946     // glass 11x11, top left corner
 947     // handle (9,9)-(13,13)
 948     // drop (13,16)-(19,6)-(16,9)
 949
 950     int multiplier = GetMultiplier();
 951     int penWidth = multiplier * 2;
 952
 953     penWidth = penWidth * x / 20;
 954
 955     wxBitmap bitmap( multiplier*x, multiplier*y );
 956     wxMemoryDC mem;
 957     mem.SelectObject(bitmap);
 958
 959     // clear background
 960     mem.SetBrush( wxBrush(bg) );
 961     mem.SetPen( wxPen(bg) );
 962     mem.DrawRectangle(0,0,bitmap.GetWidth(),bitmap.GetHeight());
 963
 964     // draw drop glass
 965     mem.SetBrush( wxBrush(fg) );
 966     mem.SetPen( wxPen(fg) );
 967     int glassBase = 5 * x / 20;
 968     int glassFactor = 2*glassBase + 1;
 969     int radius = multiplier*glassFactor/2;
 970     mem.DrawCircle(radius,radius,radius);
 971     mem.SetBrush( wxBrush(bg) );
 972     mem.SetPen( wxPen(bg) );
 973     mem.DrawCircle(radius,radius,radius-penWidth);
 974
 975     // draw handle
 976     int lineStart = radius + (radius-penWidth/2) * 707 / 1000; // 707 / 1000 = 0.707 = 1/sqrt(2);
 977
 978     mem.SetPen( wxPen(fg) );
 979     mem.SetBrush( wxBrush(fg) );
 980     int handleCornerShift = penWidth * 707 / 1000 / 2; // 707 / 1000 = 0.707 = 1/sqrt(2);
 981     handleCornerShift = WXMAX( handleCornerShift, 1 );
 982     int handleBase = 4 * x / 20;
 983     int handleLength = 2*handleBase+1;
 984     wxPoint handlePolygon[] =
 985     {
 986         wxPoint(-handleCornerShift,+handleCornerShift),
 987         wxPoint(+handleCornerShift,-handleCornerShift),
 988         wxPoint(multiplier*handleLength/2+handleCornerShift,multiplier*handleLength/2-handleCornerShift),
 989         wxPoint(multiplier*handleLength/2-handleCornerShift,multiplier*handleLength/2+handleCornerShift),
 990     };
 991     mem.DrawPolygon(WXSIZEOF(handlePolygon),handlePolygon,lineStart,lineStart);
 992
 993     // draw drop triangle
 994     int triangleX = 13 * x / 20;
 995     int triangleY = 5 * x / 20;
 996     int triangleBase = 3 * x / 20;
 997     int triangleFactor = triangleBase*2+1;
 998     if ( renderDrop )
 999     {
1000         wxPoint dropPolygon[] =
1001         {
1002             wxPoint(multiplier*0,multiplier*0), // triangle left
1003             wxPoint(multiplier*triangleFactor-1,multiplier*0), // triangle right
1004             wxPoint(multiplier*triangleFactor/2,multiplier*triangleFactor/2), // triangle bottom
1005         };
1006         mem.DrawPolygon(WXSIZEOF(dropPolygon),dropPolygon,multiplier*triangleX,multiplier*triangleY);
1007     }
1008     mem.SelectObject(wxNullBitmap);
1009
1010     //===============================================================================
1011     // end drawing code
1012     //===============================================================================
1013
1014     if ( multiplier != 1 )
1015     {
1016         wxImage image = bitmap.ConvertToImage();
1017         image.Rescale(x,y);
1018         bitmap = wxBitmap( image );
1019     }
1020     if ( !renderDrop )
1021     {
1022         // Trim the edge where the arrow would have gone
1023         bitmap = bitmap.GetSubBitmap(wxRect(0,0, y,y));
1024     }
1025
1026     return bitmap;
1027 }
1028
1029 wxBitmap wxSearchCtrl::RenderCancelBitmap( int x, int y )
1030 {
1031     wxColour bg = GetBackgroundColour();
1032     wxColour fg = GetForegroundColour().ChangeLightness(LIGHT_STEP);
1033
1034     //===============================================================================
1035     // begin drawing code
1036     //===============================================================================
1037     // image stats
1038
1039     // total size 14x14
1040     // force 1:1 ratio
1041     if ( x > y )
1042     {
1043         // x is too big
1044         x = y;
1045     }
1046     else
1047     {
1048         // y is too big
1049         y = x;
1050     }
1051
1052     // 14x14 circle
1053     // cross line starts (4,4)-(10,10)
1054     // drop (13,16)-(19,6)-(16,9)
1055
1056     int multiplier = GetMultiplier();
1057
1058     int penWidth = multiplier * x / 14;
1059
1060     wxBitmap bitmap( multiplier*x, multiplier*y );
1061     wxMemoryDC mem;
1062     mem.SelectObject(bitmap);
1063
1064     // clear background
1065     mem.SetBrush( wxBrush(bg) );
1066     mem.SetPen( wxPen(bg) );
1067     mem.DrawRectangle(0,0,bitmap.GetWidth(),bitmap.GetHeight());
1068
1069     // draw drop glass
1070     mem.SetBrush( wxBrush(fg) );
1071     mem.SetPen( wxPen(fg) );
1072     int radius = multiplier*x/2;
1073     mem.DrawCircle(radius,radius,radius);
1074
1075     // draw cross
1076     int lineStartBase = 4 * x / 14;
1077     int lineLength = x - 2*lineStartBase;
1078
1079     mem.SetPen( wxPen(bg) );
1080     mem.SetBrush( wxBrush(bg) );
1081     int handleCornerShift = penWidth/2;
1082     handleCornerShift = WXMAX( handleCornerShift, 1 );
1083     wxPoint handlePolygon[] =
1084     {
1085         wxPoint(-handleCornerShift,+handleCornerShift),
1086         wxPoint(+handleCornerShift,-handleCornerShift),
1087         wxPoint(multiplier*lineLength+handleCornerShift,multiplier*lineLength-handleCornerShift),
1088         wxPoint(multiplier*lineLength-handleCornerShift,multiplier*lineLength+handleCornerShift),
1089     };
1090     mem.DrawPolygon(WXSIZEOF(handlePolygon),handlePolygon,multiplier*lineStartBase,multiplier*lineStartBase);
1091     wxPoint handlePolygon2[] =
1092     {
1093         wxPoint(+handleCornerShift,+handleCornerShift),
1094         wxPoint(-handleCornerShift,-handleCornerShift),
1095         wxPoint(multiplier*lineLength-handleCornerShift,-multiplier*lineLength-handleCornerShift),
1096         wxPoint(multiplier*lineLength+handleCornerShift,-multiplier*lineLength+handleCornerShift),
1097     };
1098     mem.DrawPolygon(WXSIZEOF(handlePolygon2),handlePolygon2,multiplier*lineStartBase,multiplier*(x-lineStartBase));
1099
1100     //===============================================================================
1101     // end drawing code
1102     //===============================================================================
1103
1104     if ( multiplier != 1 )
1105     {
1106         wxImage image = bitmap.ConvertToImage();
1107         image.Rescale(x,y);
1108         bitmap = wxBitmap( image );
1109     }
1110
1111     return bitmap;
1112 }
1113
1114 void wxSearchCtrl::RecalcBitmaps()
1115 {
1116     if ( !m_text )
1117     {
1118         return;
1119     }
1120     wxSize sizeText = m_text->GetBestSize();
1121
1122     int bitmapHeight = sizeText.y - 2 * ICON_MARGIN;
1123     int bitmapWidth  = sizeText.y * 20 / 14;
1124
1125     if ( !m_searchBitmapUser )
1126     {
1127         if (
1128             !m_searchBitmap.IsOk() ||
1129             m_searchBitmap.GetHeight() != bitmapHeight ||
1130             m_searchBitmap.GetWidth() != bitmapWidth
1131             )
1132         {
1133             m_searchBitmap = RenderSearchBitmap(bitmapWidth,bitmapHeight,false);
1134             if ( !HasMenu() )
1135             {
1136                 m_searchButton->SetBitmapLabel(m_searchBitmap);
1137             }
1138         }
1139         // else this bitmap was set by user, don't alter
1140     }
1141
1142 #if wxUSE_MENUS
1143     if ( !m_searchMenuBitmapUser )
1144     {
1145         if (
1146             !m_searchMenuBitmap.IsOk() ||
1147             m_searchMenuBitmap.GetHeight() != bitmapHeight ||
1148             m_searchMenuBitmap.GetWidth() != bitmapWidth
1149             )
1150         {
1151             m_searchMenuBitmap = RenderSearchBitmap(bitmapWidth,bitmapHeight,true);
1152             if ( m_menu )
1153             {
1154                 m_searchButton->SetBitmapLabel(m_searchMenuBitmap);
1155             }
1156         }
1157         // else this bitmap was set by user, don't alter
1158     }
1159 #endif // wxUSE_MENUS
1160
1161     if ( !m_cancelBitmapUser )
1162     {
1163         if (
1164             !m_cancelBitmap.IsOk() ||
1165             m_cancelBitmap.GetHeight() != bitmapHeight ||
1166             m_cancelBitmap.GetWidth() != bitmapHeight
1167             )
1168         {
1169             m_cancelBitmap = RenderCancelBitmap(bitmapHeight-BORDER-1,bitmapHeight-BORDER-1); // square
1170             m_cancelButton->SetBitmapLabel(m_cancelBitmap);
1171         }
1172         // else this bitmap was set by user, don't alter
1173     }
1174 }
1175
1176 void wxSearchCtrl::OnSearchButton( wxCommandEvent& event )
1177 {
1178     event.Skip();
1179 }
1180
1181 void wxSearchCtrl::OnSetFocus( wxFocusEvent& /*event*/ )
1182 {
1183     if ( m_text )
1184     {
1185         m_text->SetFocus();
1186     }
1187 }
1188
1189 void wxSearchCtrl::OnSize( wxSizeEvent& WXUNUSED(event) )
1190 {
1191     int width, height;
1192     GetSize(&width, &height);
1193     LayoutControls(0, 0, width, height);
1194 }
1195
1196 #if wxUSE_MENUS
1197
1198 void wxSearchCtrl::PopupSearchMenu()
1199 {
1200     if ( m_menu )
1201     {
1202         wxSize size = GetSize();
1203         PopupMenu( m_menu, 0, size.y );
1204     }
1205 }
1206
1207 #endif // wxUSE_MENUS
1208
1209 #endif // !wxUSE_NATIVE_SEARCH_CONTROL
1210
1211 #endif // wxUSE_SEARCHCTRL