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