src/common/textentrycmn.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/textentrycmn.cpp
   3 // Purpose:     wxTextEntryBase implementation
   4 // Author:      Vadim Zeitlin
   5 // Created:     2007-09-26
   6 // RCS-ID:      $Id$
   7 // Copyright:   (c) 2007 Vadim Zeitlin <vadim@wxwindows.org>
   8 // Licence:     wxWindows licence
   9 ///////////////////////////////////////////////////////////////////////////////
  10
  11 // ============================================================================
  12 // declarations
  13 // ============================================================================
  14
  15 // ----------------------------------------------------------------------------
  16 // headers
  17 // ----------------------------------------------------------------------------
  18
  19 // for compilers that support precompilation, includes "wx.h".
  20 #include "wx/wxprec.h"
  21
  22 #ifdef __BORLANDC__
  23     #pragma hdrstop
  24 #endif
  25
  26 #if wxUSE_TEXTCTRL || wxUSE_COMBOBOX
  27
  28 #ifndef WX_PRECOMP
  29     #include "wx/window.h"
  30     #include "wx/dataobj.h"
  31 #endif //WX_PRECOMP
  32
  33 #include "wx/textentry.h"
  34 #include "wx/textcompleter.h"
  35 #include "wx/clipbrd.h"
  36
  37 // ----------------------------------------------------------------------------
  38 // wxTextEntryHintData
  39 // ----------------------------------------------------------------------------
  40
  41 class WXDLLIMPEXP_CORE wxTextEntryHintData wxBIND_OR_CONNECT_HACK_ONLY_BASE_CLASS
  42 {
  43 public:
  44     wxTextEntryHintData(wxTextEntryBase *entry, wxWindow *win)
  45         : m_entry(entry),
  46           m_win(win),
  47           m_text(m_entry->GetValue())
  48     {
  49         wxBIND_OR_CONNECT_HACK(win, wxEVT_SET_FOCUS, wxFocusEventHandler,
  50                                 wxTextEntryHintData::OnSetFocus, this);
  51         wxBIND_OR_CONNECT_HACK(win, wxEVT_KILL_FOCUS, wxFocusEventHandler,
  52                                 wxTextEntryHintData::OnKillFocus, this);
  53         wxBIND_OR_CONNECT_HACK(win, wxEVT_COMMAND_TEXT_UPDATED,
  54                                 wxCommandEventHandler,
  55                                 wxTextEntryHintData::OnTextChanged, this);
  56     }
  57
  58     // default dtor is ok
  59
  60     // Get the real text of the control such as it was before we replaced it
  61     // with the hint.
  62     const wxString& GetText() const { return m_text; }
  63
  64     // Set the hint to show, shouldn't be empty normally.
  65     //
  66     // This should be called after creating a new wxTextEntryHintData object
  67     // and may be called more times in the future.
  68     void SetHintString(const wxString& hint)
  69     {
  70         m_hint = hint;
  71
  72         if ( !m_win->HasFocus() )
  73             ShowHintIfAppropriate();
  74         //else: The new hint will be shown later when we lose focus.
  75     }
  76
  77     const wxString& GetHintString() const { return m_hint; }
  78
  79     // This is called whenever the text control contents changes.
  80     //
  81     // We call it ourselves when this change generates an event but it's also
  82     // necessary to call it explicitly from wxTextEntry::ChangeValue() as it,
  83     // by design, does not generate any events.
  84     void HandleTextUpdate(const wxString& text)
  85     {
  86         m_text = text;
  87
  88         // If we're called because of a call to Set or ChangeValue(), the
  89         // control may still have the hint text colour, reset it in this case.
  90         RestoreTextColourIfNecessary();
  91     }
  92
  93 private:
  94     // Show the hint in the window if we should do it, i.e. if the window
  95     // doesn't have any text of its own.
  96     void ShowHintIfAppropriate()
  97     {
  98         // Never overwrite existing window text.
  99         if ( !m_text.empty() )
 100             return;
 101
 102         // Save the old text colour and set a more inconspicuous one for the
 103         // hint.
 104         m_colFg = m_win->GetForegroundColour();
 105         m_win->SetForegroundColour(*wxLIGHT_GREY);
 106
 107         m_entry->DoSetValue(m_hint, wxTextEntryBase::SetValue_NoEvent);
 108     }
 109
 110     // Restore the original text colour if we had changed it to show the hint
 111     // and not restored it yet.
 112     void RestoreTextColourIfNecessary()
 113     {
 114         if ( m_colFg.IsOk() )
 115         {
 116             m_win->SetForegroundColour(m_colFg);
 117             m_colFg = wxColour();
 118         }
 119     }
 120
 121     void OnSetFocus(wxFocusEvent& event)
 122     {
 123         // If we had been showing the hint before, remove it now and restore
 124         // the normal colour.
 125         if ( m_text.empty() )
 126         {
 127             RestoreTextColourIfNecessary();
 128
 129             m_entry->DoSetValue(wxString(), wxTextEntryBase::SetValue_NoEvent);
 130         }
 131
 132         event.Skip();
 133     }
 134
 135     void OnKillFocus(wxFocusEvent& event)
 136     {
 137         // Restore the hint if the user didn't enter anything.
 138         ShowHintIfAppropriate();
 139
 140         event.Skip();
 141     }
 142
 143     void OnTextChanged(wxCommandEvent& event)
 144     {
 145         // Update the stored window text.
 146         //
 147         // Notice that we can't use GetValue() nor wxCommandEvent::GetString()
 148         // which uses it internally because this would just forward back to us
 149         // so go directly to the private method which returns the real control
 150         // contents.
 151         HandleTextUpdate(m_entry->DoGetValue());
 152
 153         event.Skip();
 154     }
 155
 156
 157     // the text control we're associated with (as its interface and its window)
 158     wxTextEntryBase * const m_entry;
 159     wxWindow * const m_win;
 160
 161     // the original foreground colour of m_win before we changed it
 162     wxColour m_colFg;
 163
 164     // The hint passed to wxTextEntry::SetHint(), never empty.
 165     wxString m_hint;
 166
 167     // The real text of the window.
 168     wxString m_text;
 169
 170
 171     wxDECLARE_NO_COPY_CLASS(wxTextEntryHintData);
 172 };
 173
 174 // ============================================================================
 175 // wxTextEntryBase implementation
 176 // ============================================================================
 177
 178 wxTextEntryBase::~wxTextEntryBase()
 179 {
 180     delete m_hintData;
 181 }
 182
 183 // ----------------------------------------------------------------------------
 184 // text accessors
 185 // ----------------------------------------------------------------------------
 186
 187 wxString wxTextEntryBase::GetValue() const
 188 {
 189     return m_hintData ? m_hintData->GetText() : DoGetValue();
 190 }
 191
 192 wxString wxTextEntryBase::GetRange(long from, long to) const
 193 {
 194     wxString sel;
 195     wxString value = GetValue();
 196
 197     if ( from < to && (long)value.length() >= to )
 198     {
 199         sel = value.substr(from, to - from);
 200     }
 201
 202     return sel;
 203 }
 204
 205 // ----------------------------------------------------------------------------
 206 // text operations
 207 // ----------------------------------------------------------------------------
 208
 209 void wxTextEntryBase::ChangeValue(const wxString& value)
 210 {
 211     DoSetValue(value, SetValue_NoEvent);
 212
 213     // As we didn't generate any events for wxTextEntryHintData to catch,
 214     // notify it explicitly about our changed contents.
 215     if ( m_hintData )
 216         m_hintData->HandleTextUpdate(value);
 217 }
 218
 219 void wxTextEntryBase::AppendText(const wxString& text)
 220 {
 221     SetInsertionPointEnd();
 222     WriteText(text);
 223 }
 224
 225 void wxTextEntryBase::DoSetValue(const wxString& value, int flags)
 226 {
 227     if ( value != GetValue() )
 228     {
 229         EventsSuppressor noeventsIf(this, !(flags & SetValue_SendEvent));
 230
 231         SelectAll();
 232         WriteText(value);
 233     }
 234     else // Same value, no need to do anything.
 235     {
 236         // Except that we still need to generate the event for consistency with
 237         // the normal case when the text does change.
 238         SendTextUpdatedEvent(GetEditableWindow());
 239     }
 240
 241     SetInsertionPoint(0);
 242 }
 243
 244 void wxTextEntryBase::Replace(long from, long to, const wxString& value)
 245 {
 246     {
 247         EventsSuppressor noevents(this);
 248         Remove(from, to);
 249     }
 250
 251     SetInsertionPoint(from);
 252     WriteText(value);
 253 }
 254
 255 // ----------------------------------------------------------------------------
 256 // selection
 257 // ----------------------------------------------------------------------------
 258
 259 bool wxTextEntryBase::HasSelection() const
 260 {
 261     long from, to;
 262     GetSelection(&from, &to);
 263
 264     return from < to;
 265 }
 266
 267 void wxTextEntryBase::RemoveSelection()
 268 {
 269     long from, to;
 270     GetSelection(& from, & to);
 271     if (from != -1 && to != -1)
 272         Remove(from, to);
 273 }
 274
 275 wxString wxTextEntryBase::GetStringSelection() const
 276 {
 277     long from, to;
 278     GetSelection(&from, &to);
 279
 280     return GetRange(from, to);
 281 }
 282
 283 // ----------------------------------------------------------------------------
 284 // clipboard
 285 // ----------------------------------------------------------------------------
 286
 287 bool wxTextEntryBase::CanCopy() const
 288 {
 289     return HasSelection();
 290 }
 291
 292 bool wxTextEntryBase::CanCut() const
 293 {
 294     return CanCopy() && IsEditable();
 295 }
 296
 297 bool wxTextEntryBase::CanPaste() const
 298 {
 299     if ( IsEditable() )
 300     {
 301 #if wxUSE_CLIPBOARD
 302         // check if there is any text on the clipboard
 303         if ( wxTheClipboard->IsSupported(wxDF_TEXT)
 304 #if wxUSE_UNICODE
 305                 || wxTheClipboard->IsSupported(wxDF_UNICODETEXT)
 306 #endif // wxUSE_UNICODE
 307            )
 308         {
 309             return true;
 310         }
 311 #endif // wxUSE_CLIPBOARD
 312     }
 313
 314     return false;
 315 }
 316
 317 // ----------------------------------------------------------------------------
 318 // hints support
 319 // ----------------------------------------------------------------------------
 320
 321 bool wxTextEntryBase::SetHint(const wxString& hint)
 322 {
 323     if ( !hint.empty() )
 324     {
 325         if ( !m_hintData )
 326             m_hintData = new wxTextEntryHintData(this, GetEditableWindow());
 327
 328         m_hintData->SetHintString(hint);
 329     }
 330     else if ( m_hintData )
 331     {
 332         // Setting empty hint removes any currently set one.
 333         delete m_hintData;
 334         m_hintData = NULL;
 335     }
 336     //else: Setting empty hint when we don't have any doesn't do anything.
 337
 338     return true;
 339 }
 340
 341 wxString wxTextEntryBase::GetHint() const
 342 {
 343     return m_hintData ? m_hintData->GetHintString() : wxString();
 344 }
 345
 346 // ----------------------------------------------------------------------------
 347 // margins support
 348 // ----------------------------------------------------------------------------
 349
 350 bool wxTextEntryBase::DoSetMargins(const wxPoint& WXUNUSED(pt))
 351 {
 352     return false;
 353 }
 354
 355 wxPoint wxTextEntryBase::DoGetMargins() const
 356 {
 357     return wxPoint(-1, -1);
 358 }
 359
 360 // ----------------------------------------------------------------------------
 361 // events
 362 // ----------------------------------------------------------------------------
 363
 364 /* static */
 365 bool wxTextEntryBase::SendTextUpdatedEvent(wxWindow *win)
 366 {
 367     wxCHECK_MSG( win, false, "can't send an event without a window" );
 368
 369     wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, win->GetId());
 370
 371     // do not do this as it could be very inefficient if the text control
 372     // contains a lot of text and we're not using ref-counted wxString
 373     // implementation -- instead, event.GetString() will query the control for
 374     // its current text if needed
 375     //event.SetString(win->GetValue());
 376
 377     event.SetEventObject(win);
 378     return win->HandleWindowEvent(event);
 379 }
 380
 381 // ----------------------------------------------------------------------------
 382 // auto-completion stubs
 383 // ----------------------------------------------------------------------------
 384
 385 wxTextCompleter::~wxTextCompleter()
 386 {
 387 }
 388
 389 bool wxTextCompleterSimple::Start(const wxString& prefix)
 390 {
 391     m_index = 0;
 392     m_completions.clear();
 393     GetCompletions(prefix, m_completions);
 394
 395     return !m_completions.empty();
 396 }
 397
 398 wxString wxTextCompleterSimple::GetNext()
 399 {
 400     if ( m_index == m_completions.size() )
 401         return wxString();
 402
 403     return m_completions[m_index++];
 404 }
 405
 406 bool wxTextEntryBase::DoAutoCompleteCustom(wxTextCompleter *completer)
 407 {
 408     // We don't do anything here but we still need to delete the completer for
 409     // consistency with the ports that do implement this method and take
 410     // ownership of the pointer.
 411     delete completer;
 412
 413     return false;
 414 }
 415
 416 #endif // wxUSE_TEXTCTRL || wxUSE_COMBOBOX