]> git.saurik.com Git - wxWidgets.git/blob - src/generic/srchctlg.cpp
projects / wxWidgets.git / blob
? search:


4e9fd4bb83cc143a14537a2d1abeaa235846cd5f
[wxWidgets.git] / 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
wxWidgets (Impactor)