| 1 | ///////////////////////////////////////////////////////////////////////////// |
| 2 | // Name: src/osx/textctrl_osx.cpp |
| 3 | // Purpose: wxTextCtrl |
| 4 | // Author: Stefan Csomor |
| 5 | // Modified by: Ryan Norton (MLTE GetLineLength and GetLineText) |
| 6 | // Created: 1998-01-01 |
| 7 | // RCS-ID: $Id: textctrl.cpp 54820 2008-07-29 20:04:11Z SC $ |
| 8 | // Copyright: (c) Stefan Csomor |
| 9 | // Licence: wxWindows licence |
| 10 | ///////////////////////////////////////////////////////////////////////////// |
| 11 | |
| 12 | #include "wx/wxprec.h" |
| 13 | |
| 14 | #if wxUSE_TEXTCTRL |
| 15 | |
| 16 | #include "wx/textctrl.h" |
| 17 | |
| 18 | #ifndef WX_PRECOMP |
| 19 | #include "wx/intl.h" |
| 20 | #include "wx/app.h" |
| 21 | #include "wx/utils.h" |
| 22 | #include "wx/dc.h" |
| 23 | #include "wx/button.h" |
| 24 | #include "wx/menu.h" |
| 25 | #include "wx/settings.h" |
| 26 | #include "wx/msgdlg.h" |
| 27 | #include "wx/toplevel.h" |
| 28 | #endif |
| 29 | |
| 30 | #ifdef __DARWIN__ |
| 31 | #include <sys/types.h> |
| 32 | #include <sys/stat.h> |
| 33 | #else |
| 34 | #include <stat.h> |
| 35 | #endif |
| 36 | |
| 37 | #if wxUSE_STD_IOSTREAM |
| 38 | #if wxUSE_IOSTREAMH |
| 39 | #include <fstream.h> |
| 40 | #else |
| 41 | #include <fstream> |
| 42 | #endif |
| 43 | #endif |
| 44 | |
| 45 | #include "wx/filefn.h" |
| 46 | #include "wx/sysopt.h" |
| 47 | #include "wx/thread.h" |
| 48 | |
| 49 | #include "wx/osx/private.h" |
| 50 | |
| 51 | IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxTextCtrlBase) |
| 52 | |
| 53 | BEGIN_EVENT_TABLE(wxTextCtrl, wxTextCtrlBase) |
| 54 | EVT_DROP_FILES(wxTextCtrl::OnDropFiles) |
| 55 | EVT_CHAR(wxTextCtrl::OnChar) |
| 56 | EVT_KEY_DOWN(wxTextCtrl::OnKeyDown) |
| 57 | EVT_MENU(wxID_CUT, wxTextCtrl::OnCut) |
| 58 | EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy) |
| 59 | EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste) |
| 60 | EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo) |
| 61 | EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo) |
| 62 | EVT_MENU(wxID_CLEAR, wxTextCtrl::OnDelete) |
| 63 | EVT_MENU(wxID_SELECTALL, wxTextCtrl::OnSelectAll) |
| 64 | |
| 65 | EVT_CONTEXT_MENU(wxTextCtrl::OnContextMenu) |
| 66 | |
| 67 | EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut) |
| 68 | EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy) |
| 69 | EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste) |
| 70 | EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo) |
| 71 | EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo) |
| 72 | EVT_UPDATE_UI(wxID_CLEAR, wxTextCtrl::OnUpdateDelete) |
| 73 | EVT_UPDATE_UI(wxID_SELECTALL, wxTextCtrl::OnUpdateSelectAll) |
| 74 | END_EVENT_TABLE() |
| 75 | |
| 76 | |
| 77 | void wxTextCtrl::Init() |
| 78 | { |
| 79 | m_dirty = false; |
| 80 | |
| 81 | m_privateContextMenu = NULL; |
| 82 | } |
| 83 | |
| 84 | wxTextCtrl::~wxTextCtrl() |
| 85 | { |
| 86 | #if wxUSE_MENUS |
| 87 | delete m_privateContextMenu; |
| 88 | #endif |
| 89 | } |
| 90 | |
| 91 | bool wxTextCtrl::Create( wxWindow *parent, |
| 92 | wxWindowID id, |
| 93 | const wxString& str, |
| 94 | const wxPoint& pos, |
| 95 | const wxSize& size, |
| 96 | long style, |
| 97 | const wxValidator& validator, |
| 98 | const wxString& name ) |
| 99 | { |
| 100 | m_macIsUserPane = false ; |
| 101 | m_editable = true ; |
| 102 | |
| 103 | if ( ! (style & wxNO_BORDER) ) |
| 104 | style = (style & ~wxBORDER_MASK) | wxSUNKEN_BORDER ; |
| 105 | |
| 106 | if ( !wxTextCtrlBase::Create( parent, id, pos, size, style & ~(wxHSCROLL | wxVSCROLL), validator, name ) ) |
| 107 | return false; |
| 108 | |
| 109 | if ( m_windowStyle & wxTE_MULTILINE ) |
| 110 | { |
| 111 | // always turn on this style for multi-line controls |
| 112 | m_windowStyle |= wxTE_PROCESS_ENTER; |
| 113 | style |= wxTE_PROCESS_ENTER ; |
| 114 | } |
| 115 | |
| 116 | |
| 117 | m_peer = wxWidgetImpl::CreateTextControl( this, GetParent(), GetId(), str, pos, size, style, GetExtraStyle() ); |
| 118 | |
| 119 | MacPostControlCreate(pos, size) ; |
| 120 | |
| 121 | #if wxOSX_USE_COCOA |
| 122 | // under carbon everything can already be set before the MacPostControlCreate embedding takes place |
| 123 | // but under cocoa for single line textfields this only works after everything has been set up |
| 124 | GetTextPeer()->SetStringValue(str); |
| 125 | #endif |
| 126 | |
| 127 | // only now the embedding is correct and we can do a positioning update |
| 128 | |
| 129 | MacSuperChangedPosition() ; |
| 130 | |
| 131 | if ( m_windowStyle & wxTE_READONLY) |
| 132 | SetEditable( false ) ; |
| 133 | |
| 134 | SetCursor( wxCursor( wxCURSOR_IBEAM ) ) ; |
| 135 | |
| 136 | return true; |
| 137 | } |
| 138 | |
| 139 | void wxTextCtrl::MacSuperChangedPosition() |
| 140 | { |
| 141 | wxWindow::MacSuperChangedPosition() ; |
| 142 | #if wxOSX_USE_CARBON |
| 143 | GetPeer()->SuperChangedPosition() ; |
| 144 | #endif |
| 145 | } |
| 146 | |
| 147 | void wxTextCtrl::MacVisibilityChanged() |
| 148 | { |
| 149 | #if wxOSX_USE_CARBON |
| 150 | GetPeer()->VisibilityChanged( GetPeer()->IsVisible() ); |
| 151 | #endif |
| 152 | } |
| 153 | |
| 154 | void wxTextCtrl::MacCheckSpelling(bool check) |
| 155 | { |
| 156 | GetTextPeer()->CheckSpelling(check); |
| 157 | } |
| 158 | |
| 159 | void wxTextCtrl::SetMaxLength(unsigned long len) |
| 160 | { |
| 161 | m_maxLength = len ; |
| 162 | } |
| 163 | |
| 164 | bool wxTextCtrl::SetFont( const wxFont& font ) |
| 165 | { |
| 166 | if ( !wxTextCtrlBase::SetFont( font ) ) |
| 167 | return false ; |
| 168 | |
| 169 | GetPeer()->SetFont( font , GetForegroundColour() , GetWindowStyle(), false /* dont ignore black */ ) ; |
| 170 | |
| 171 | return true ; |
| 172 | } |
| 173 | |
| 174 | bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style) |
| 175 | { |
| 176 | if (GetTextPeer()) |
| 177 | GetTextPeer()->SetStyle( start , end , style ) ; |
| 178 | |
| 179 | return true ; |
| 180 | } |
| 181 | |
| 182 | bool wxTextCtrl::SetDefaultStyle(const wxTextAttr& style) |
| 183 | { |
| 184 | wxTextCtrlBase::SetDefaultStyle( style ) ; |
| 185 | SetStyle( -1 /*current selection*/ , -1 /*current selection*/ , GetDefaultStyle() ) ; |
| 186 | |
| 187 | return true ; |
| 188 | } |
| 189 | |
| 190 | bool wxTextCtrl::IsModified() const |
| 191 | { |
| 192 | return m_dirty; |
| 193 | } |
| 194 | |
| 195 | bool wxTextCtrl::AcceptsFocus() const |
| 196 | { |
| 197 | // we don't want focus if we can't be edited |
| 198 | return /*IsEditable() && */ wxControl::AcceptsFocus(); |
| 199 | } |
| 200 | |
| 201 | wxSize wxTextCtrl::DoGetBestSize() const |
| 202 | { |
| 203 | if (GetTextPeer()) |
| 204 | { |
| 205 | wxSize size = GetTextPeer()->GetBestSize(); |
| 206 | if (size.x > 0 && size.y > 0) |
| 207 | return size; |
| 208 | } |
| 209 | |
| 210 | int wText, hText; |
| 211 | |
| 212 | // these are the numbers from the HIG: |
| 213 | // we reduce them by the borders first |
| 214 | wText = 100 ; |
| 215 | |
| 216 | switch ( m_windowVariant ) |
| 217 | { |
| 218 | case wxWINDOW_VARIANT_NORMAL : |
| 219 | hText = 22 - 6 ; |
| 220 | break ; |
| 221 | |
| 222 | case wxWINDOW_VARIANT_SMALL : |
| 223 | hText = 19 - 6 ; |
| 224 | break ; |
| 225 | |
| 226 | case wxWINDOW_VARIANT_MINI : |
| 227 | hText = 15 - 6 ; |
| 228 | break ; |
| 229 | |
| 230 | default : |
| 231 | hText = 22 - 6; |
| 232 | break ; |
| 233 | } |
| 234 | |
| 235 | // as the above numbers have some free space around the text |
| 236 | // we get 5 lines like this anyway |
| 237 | if ( m_windowStyle & wxTE_MULTILINE ) |
| 238 | hText *= 5 ; |
| 239 | |
| 240 | if ( !HasFlag(wxNO_BORDER) ) |
| 241 | hText += 6 ; |
| 242 | |
| 243 | return wxSize(wText, hText); |
| 244 | } |
| 245 | |
| 246 | bool wxTextCtrl::GetStyle(long position, wxTextAttr& style) |
| 247 | { |
| 248 | return GetTextPeer()->GetStyle(position, style); |
| 249 | } |
| 250 | |
| 251 | void wxTextCtrl::MarkDirty() |
| 252 | { |
| 253 | m_dirty = true; |
| 254 | } |
| 255 | |
| 256 | void wxTextCtrl::DiscardEdits() |
| 257 | { |
| 258 | m_dirty = false; |
| 259 | } |
| 260 | |
| 261 | int wxTextCtrl::GetNumberOfLines() const |
| 262 | { |
| 263 | return GetTextPeer()->GetNumberOfLines() ; |
| 264 | } |
| 265 | |
| 266 | long wxTextCtrl::XYToPosition(long x, long y) const |
| 267 | { |
| 268 | return GetTextPeer()->XYToPosition( x , y ) ; |
| 269 | } |
| 270 | |
| 271 | bool wxTextCtrl::PositionToXY(long pos, long *x, long *y) const |
| 272 | { |
| 273 | return GetTextPeer()->PositionToXY( pos , x , y ) ; |
| 274 | } |
| 275 | |
| 276 | void wxTextCtrl::ShowPosition(long pos) |
| 277 | { |
| 278 | return GetTextPeer()->ShowPosition(pos) ; |
| 279 | } |
| 280 | |
| 281 | int wxTextCtrl::GetLineLength(long lineNo) const |
| 282 | { |
| 283 | return GetTextPeer()->GetLineLength(lineNo) ; |
| 284 | } |
| 285 | |
| 286 | wxString wxTextCtrl::GetLineText(long lineNo) const |
| 287 | { |
| 288 | return GetTextPeer()->GetLineText(lineNo) ; |
| 289 | } |
| 290 | |
| 291 | void wxTextCtrl::Copy() |
| 292 | { |
| 293 | if (CanCopy()) |
| 294 | { |
| 295 | wxClipboardTextEvent evt(wxEVT_COMMAND_TEXT_COPY, GetId()); |
| 296 | evt.SetEventObject(this); |
| 297 | if (!GetEventHandler()->ProcessEvent(evt)) |
| 298 | { |
| 299 | wxTextEntry::Copy(); |
| 300 | } |
| 301 | } |
| 302 | } |
| 303 | |
| 304 | void wxTextCtrl::Cut() |
| 305 | { |
| 306 | if (CanCut()) |
| 307 | { |
| 308 | wxClipboardTextEvent evt(wxEVT_COMMAND_TEXT_CUT, GetId()); |
| 309 | evt.SetEventObject(this); |
| 310 | if (!GetEventHandler()->ProcessEvent(evt)) |
| 311 | { |
| 312 | wxTextEntry::Cut(); |
| 313 | |
| 314 | SendTextUpdatedEvent(); |
| 315 | } |
| 316 | } |
| 317 | } |
| 318 | |
| 319 | void wxTextCtrl::Paste() |
| 320 | { |
| 321 | if (CanPaste()) |
| 322 | { |
| 323 | wxClipboardTextEvent evt(wxEVT_COMMAND_TEXT_PASTE, GetId()); |
| 324 | evt.SetEventObject(this); |
| 325 | if (!GetEventHandler()->ProcessEvent(evt)) |
| 326 | { |
| 327 | wxTextEntry::Paste(); |
| 328 | |
| 329 | // TODO: eventually we should add setting the default style again |
| 330 | SendTextUpdatedEvent(); |
| 331 | } |
| 332 | } |
| 333 | } |
| 334 | |
| 335 | void wxTextCtrl::OnDropFiles(wxDropFilesEvent& event) |
| 336 | { |
| 337 | // By default, load the first file into the text window. |
| 338 | if (event.GetNumberOfFiles() > 0) |
| 339 | LoadFile( event.GetFiles()[0] ); |
| 340 | } |
| 341 | |
| 342 | void wxTextCtrl::OnKeyDown(wxKeyEvent& event) |
| 343 | { |
| 344 | if ( event.GetModifiers() == wxMOD_CMD ) |
| 345 | { |
| 346 | switch( event.GetKeyCode() ) |
| 347 | { |
| 348 | case 'A': |
| 349 | SelectAll(); |
| 350 | return; |
| 351 | case 'C': |
| 352 | if ( CanCopy() ) |
| 353 | Copy() ; |
| 354 | return; |
| 355 | case 'V': |
| 356 | if ( CanPaste() ) |
| 357 | Paste() ; |
| 358 | return; |
| 359 | case 'X': |
| 360 | if ( CanCut() ) |
| 361 | Cut() ; |
| 362 | return; |
| 363 | default: |
| 364 | break; |
| 365 | } |
| 366 | } |
| 367 | // no, we didn't process it |
| 368 | event.Skip(); |
| 369 | } |
| 370 | |
| 371 | void wxTextCtrl::OnChar(wxKeyEvent& event) |
| 372 | { |
| 373 | int key = event.GetKeyCode() ; |
| 374 | bool eat_key = false ; |
| 375 | long from, to; |
| 376 | |
| 377 | if ( !IsEditable() && !event.IsKeyInCategory(WXK_CATEGORY_ARROW | WXK_CATEGORY_TAB) && |
| 378 | !( key == WXK_RETURN && ( (m_windowStyle & wxTE_PROCESS_ENTER) || (m_windowStyle & wxTE_MULTILINE) ) ) |
| 379 | // && key != WXK_PAGEUP && key != WXK_PAGEDOWN && key != WXK_HOME && key != WXK_END |
| 380 | ) |
| 381 | { |
| 382 | // eat it |
| 383 | return ; |
| 384 | } |
| 385 | |
| 386 | // Check if we have reached the max # of chars (if it is set), but still |
| 387 | // allow navigation and deletion |
| 388 | GetSelection( &from, &to ); |
| 389 | if ( !IsMultiLine() && m_maxLength && GetValue().length() >= m_maxLength && |
| 390 | !event.IsKeyInCategory(WXK_CATEGORY_ARROW | WXK_CATEGORY_TAB | WXK_CATEGORY_CUT) && |
| 391 | !( key == WXK_RETURN && (m_windowStyle & wxTE_PROCESS_ENTER) ) && |
| 392 | from == to ) |
| 393 | { |
| 394 | // eat it, we don't want to add more than allowed # of characters |
| 395 | |
| 396 | // TODO: generate EVT_TEXT_MAXLEN() |
| 397 | return; |
| 398 | } |
| 399 | |
| 400 | // assume that any key not processed yet is going to modify the control |
| 401 | m_dirty = true; |
| 402 | |
| 403 | switch ( key ) |
| 404 | { |
| 405 | case WXK_RETURN: |
| 406 | if (m_windowStyle & wxTE_PROCESS_ENTER) |
| 407 | { |
| 408 | wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId); |
| 409 | event.SetEventObject( this ); |
| 410 | event.SetString( GetValue() ); |
| 411 | if ( HandleWindowEvent(event) ) |
| 412 | return; |
| 413 | } |
| 414 | |
| 415 | if ( !(m_windowStyle & wxTE_MULTILINE) ) |
| 416 | { |
| 417 | wxTopLevelWindow *tlw = wxDynamicCast(wxGetTopLevelParent(this), wxTopLevelWindow); |
| 418 | if ( tlw && tlw->GetDefaultItem() ) |
| 419 | { |
| 420 | wxButton *def = wxDynamicCast(tlw->GetDefaultItem(), wxButton); |
| 421 | if ( def && def->IsEnabled() ) |
| 422 | { |
| 423 | wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() ); |
| 424 | event.SetEventObject(def); |
| 425 | def->Command(event); |
| 426 | |
| 427 | return ; |
| 428 | } |
| 429 | } |
| 430 | |
| 431 | // this will make wxWidgets eat the ENTER key so that |
| 432 | // we actually prevent line wrapping in a single line text control |
| 433 | eat_key = true; |
| 434 | } |
| 435 | break; |
| 436 | |
| 437 | case WXK_TAB: |
| 438 | if ( !(m_windowStyle & wxTE_PROCESS_TAB)) |
| 439 | { |
| 440 | int flags = 0; |
| 441 | if (!event.ShiftDown()) |
| 442 | flags |= wxNavigationKeyEvent::IsForward ; |
| 443 | if (event.ControlDown()) |
| 444 | flags |= wxNavigationKeyEvent::WinChange ; |
| 445 | Navigate(flags); |
| 446 | |
| 447 | return; |
| 448 | } |
| 449 | else |
| 450 | { |
| 451 | // This is necessary (don't know why); |
| 452 | // otherwise the tab will not be inserted. |
| 453 | WriteText(wxT("\t")); |
| 454 | eat_key = true; |
| 455 | } |
| 456 | break; |
| 457 | |
| 458 | default: |
| 459 | break; |
| 460 | } |
| 461 | |
| 462 | if (!eat_key) |
| 463 | { |
| 464 | // perform keystroke handling |
| 465 | event.Skip(true) ; |
| 466 | } |
| 467 | |
| 468 | // osx_cocoa sends its event upon insertText |
| 469 | #if wxOSX_USE_CARBON |
| 470 | if ( ( key >= 0x20 && key < WXK_START ) || |
| 471 | ( key >= WXK_NUMPAD0 && key <= WXK_DIVIDE ) || |
| 472 | key == WXK_RETURN || |
| 473 | key == WXK_DELETE || |
| 474 | key == WXK_BACK) |
| 475 | { |
| 476 | wxCommandEvent event1(wxEVT_COMMAND_TEXT_UPDATED, m_windowId); |
| 477 | event1.SetEventObject( this ); |
| 478 | wxPostEvent( GetEventHandler(), event1 ); |
| 479 | } |
| 480 | #endif |
| 481 | } |
| 482 | |
| 483 | void wxTextCtrl::Command(wxCommandEvent & event) |
| 484 | { |
| 485 | SetValue(event.GetString()); |
| 486 | ProcessCommand(event); |
| 487 | } |
| 488 | |
| 489 | // ---------------------------------------------------------------------------- |
| 490 | // standard handlers for standard edit menu events |
| 491 | // ---------------------------------------------------------------------------- |
| 492 | |
| 493 | // CS: Context Menus only work with MLTE implementations or non-multiline HIViews at the moment |
| 494 | |
| 495 | void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event)) |
| 496 | { |
| 497 | Cut(); |
| 498 | } |
| 499 | |
| 500 | void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event)) |
| 501 | { |
| 502 | Copy(); |
| 503 | } |
| 504 | |
| 505 | void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event)) |
| 506 | { |
| 507 | Paste(); |
| 508 | } |
| 509 | |
| 510 | void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event)) |
| 511 | { |
| 512 | Undo(); |
| 513 | } |
| 514 | |
| 515 | void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event)) |
| 516 | { |
| 517 | Redo(); |
| 518 | } |
| 519 | |
| 520 | void wxTextCtrl::OnDelete(wxCommandEvent& WXUNUSED(event)) |
| 521 | { |
| 522 | long from, to; |
| 523 | |
| 524 | GetSelection( &from, &to ); |
| 525 | if (from != -1 && to != -1) |
| 526 | Remove( from, to ); |
| 527 | } |
| 528 | |
| 529 | void wxTextCtrl::OnSelectAll(wxCommandEvent& WXUNUSED(event)) |
| 530 | { |
| 531 | SetSelection(-1, -1); |
| 532 | } |
| 533 | |
| 534 | void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event) |
| 535 | { |
| 536 | event.Enable( CanCut() ); |
| 537 | } |
| 538 | |
| 539 | void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event) |
| 540 | { |
| 541 | event.Enable( CanCopy() ); |
| 542 | } |
| 543 | |
| 544 | void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event) |
| 545 | { |
| 546 | event.Enable( CanPaste() ); |
| 547 | } |
| 548 | |
| 549 | void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event) |
| 550 | { |
| 551 | event.Enable( CanUndo() ); |
| 552 | } |
| 553 | |
| 554 | void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event) |
| 555 | { |
| 556 | event.Enable( CanRedo() ); |
| 557 | } |
| 558 | |
| 559 | void wxTextCtrl::OnUpdateDelete(wxUpdateUIEvent& event) |
| 560 | { |
| 561 | long from, to; |
| 562 | |
| 563 | GetSelection( &from, &to ); |
| 564 | event.Enable( from != -1 && to != -1 && from != to && IsEditable() ) ; |
| 565 | } |
| 566 | |
| 567 | void wxTextCtrl::OnUpdateSelectAll(wxUpdateUIEvent& event) |
| 568 | { |
| 569 | event.Enable(GetLastPosition() > 0); |
| 570 | } |
| 571 | |
| 572 | void wxTextCtrl::OnContextMenu(wxContextMenuEvent& event) |
| 573 | { |
| 574 | if ( GetTextPeer()->HasOwnContextMenu() ) |
| 575 | { |
| 576 | event.Skip() ; |
| 577 | return ; |
| 578 | } |
| 579 | |
| 580 | #if wxUSE_MENUS |
| 581 | if (m_privateContextMenu == NULL) |
| 582 | { |
| 583 | m_privateContextMenu = new wxMenu; |
| 584 | m_privateContextMenu->Append(wxID_UNDO, _("&Undo")); |
| 585 | m_privateContextMenu->Append(wxID_REDO, _("&Redo")); |
| 586 | m_privateContextMenu->AppendSeparator(); |
| 587 | m_privateContextMenu->Append(wxID_CUT, _("Cu&t")); |
| 588 | m_privateContextMenu->Append(wxID_COPY, _("&Copy")); |
| 589 | m_privateContextMenu->Append(wxID_PASTE, _("&Paste")); |
| 590 | m_privateContextMenu->Append(wxID_CLEAR, _("&Delete")); |
| 591 | m_privateContextMenu->AppendSeparator(); |
| 592 | m_privateContextMenu->Append(wxID_SELECTALL, _("Select &All")); |
| 593 | } |
| 594 | |
| 595 | PopupMenu(m_privateContextMenu); |
| 596 | #endif |
| 597 | } |
| 598 | |
| 599 | bool wxTextCtrl::MacSetupCursor( const wxPoint& pt ) |
| 600 | { |
| 601 | if ( !GetTextPeer()->SetupCursor( pt ) ) |
| 602 | return wxWindow::MacSetupCursor( pt ) ; |
| 603 | else |
| 604 | return true ; |
| 605 | } |
| 606 | |
| 607 | // ---------------------------------------------------------------------------- |
| 608 | // implementation base class |
| 609 | // ---------------------------------------------------------------------------- |
| 610 | |
| 611 | bool wxTextWidgetImpl::GetStyle(long WXUNUSED(position), |
| 612 | wxTextAttr& WXUNUSED(style)) |
| 613 | { |
| 614 | return false; |
| 615 | } |
| 616 | |
| 617 | void wxTextWidgetImpl::SetStyle(long WXUNUSED(start), |
| 618 | long WXUNUSED(end), |
| 619 | const wxTextAttr& WXUNUSED(style)) |
| 620 | { |
| 621 | } |
| 622 | |
| 623 | void wxTextWidgetImpl::Copy() |
| 624 | { |
| 625 | } |
| 626 | |
| 627 | void wxTextWidgetImpl::Cut() |
| 628 | { |
| 629 | } |
| 630 | |
| 631 | void wxTextWidgetImpl::Paste() |
| 632 | { |
| 633 | } |
| 634 | |
| 635 | bool wxTextWidgetImpl::CanPaste() const |
| 636 | { |
| 637 | return false ; |
| 638 | } |
| 639 | |
| 640 | void wxTextWidgetImpl::SetEditable(bool WXUNUSED(editable)) |
| 641 | { |
| 642 | } |
| 643 | |
| 644 | long wxTextWidgetImpl::GetLastPosition() const |
| 645 | { |
| 646 | return GetStringValue().length() ; |
| 647 | } |
| 648 | |
| 649 | void wxTextWidgetImpl::Replace( long from , long to , const wxString &val ) |
| 650 | { |
| 651 | SetSelection( from , to ) ; |
| 652 | WriteText( val ) ; |
| 653 | } |
| 654 | |
| 655 | void wxTextWidgetImpl::Remove( long from , long to ) |
| 656 | { |
| 657 | SetSelection( from , to ) ; |
| 658 | WriteText( wxEmptyString) ; |
| 659 | } |
| 660 | |
| 661 | void wxTextWidgetImpl::Clear() |
| 662 | { |
| 663 | SetStringValue( wxEmptyString ) ; |
| 664 | } |
| 665 | |
| 666 | bool wxTextWidgetImpl::CanUndo() const |
| 667 | { |
| 668 | return false ; |
| 669 | } |
| 670 | |
| 671 | void wxTextWidgetImpl::Undo() |
| 672 | { |
| 673 | } |
| 674 | |
| 675 | bool wxTextWidgetImpl::CanRedo() const |
| 676 | { |
| 677 | return false ; |
| 678 | } |
| 679 | |
| 680 | void wxTextWidgetImpl::Redo() |
| 681 | { |
| 682 | } |
| 683 | |
| 684 | long wxTextWidgetImpl::XYToPosition(long WXUNUSED(x), long WXUNUSED(y)) const |
| 685 | { |
| 686 | return 0 ; |
| 687 | } |
| 688 | |
| 689 | bool wxTextWidgetImpl::PositionToXY(long WXUNUSED(pos), |
| 690 | long *WXUNUSED(x), |
| 691 | long *WXUNUSED(y)) const |
| 692 | { |
| 693 | return false ; |
| 694 | } |
| 695 | |
| 696 | void wxTextWidgetImpl::ShowPosition( long WXUNUSED(pos) ) |
| 697 | { |
| 698 | } |
| 699 | |
| 700 | int wxTextWidgetImpl::GetNumberOfLines() const |
| 701 | { |
| 702 | wxString content = GetStringValue() ; |
| 703 | ItemCount lines = 1; |
| 704 | |
| 705 | for (size_t i = 0; i < content.length() ; i++) |
| 706 | { |
| 707 | #if wxOSX_USE_COCOA |
| 708 | if (content[i] == '\n') |
| 709 | #else |
| 710 | if (content[i] == '\r') |
| 711 | #endif |
| 712 | lines++; |
| 713 | } |
| 714 | |
| 715 | return lines ; |
| 716 | } |
| 717 | |
| 718 | wxString wxTextWidgetImpl::GetLineText(long lineNo) const |
| 719 | { |
| 720 | // TODO: change this if possible to reflect real lines |
| 721 | wxString content = GetStringValue() ; |
| 722 | |
| 723 | // Find line first |
| 724 | int count = 0; |
| 725 | for (size_t i = 0; i < content.length() ; i++) |
| 726 | { |
| 727 | if (count == lineNo) |
| 728 | { |
| 729 | // Add chars in line then |
| 730 | wxString tmp; |
| 731 | |
| 732 | for (size_t j = i; j < content.length(); j++) |
| 733 | { |
| 734 | if (content[j] == '\n') |
| 735 | return tmp; |
| 736 | |
| 737 | tmp += content[j]; |
| 738 | } |
| 739 | |
| 740 | return tmp; |
| 741 | } |
| 742 | |
| 743 | if (content[i] == '\n') |
| 744 | count++; |
| 745 | } |
| 746 | |
| 747 | return wxEmptyString ; |
| 748 | } |
| 749 | |
| 750 | int wxTextWidgetImpl::GetLineLength(long lineNo) const |
| 751 | { |
| 752 | // TODO: change this if possible to reflect real lines |
| 753 | wxString content = GetStringValue() ; |
| 754 | |
| 755 | // Find line first |
| 756 | int count = 0; |
| 757 | for (size_t i = 0; i < content.length() ; i++) |
| 758 | { |
| 759 | if (count == lineNo) |
| 760 | { |
| 761 | // Count chars in line then |
| 762 | count = 0; |
| 763 | for (size_t j = i; j < content.length(); j++) |
| 764 | { |
| 765 | count++; |
| 766 | if (content[j] == '\n') |
| 767 | return count; |
| 768 | } |
| 769 | |
| 770 | return count; |
| 771 | } |
| 772 | |
| 773 | if (content[i] == '\n') |
| 774 | count++; |
| 775 | } |
| 776 | |
| 777 | return 0 ; |
| 778 | } |
| 779 | |
| 780 | #endif // wxUSE_TEXTCTRL |