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