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