X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/4bb6408c2631988fab9925014c6619358bf867de..a83ea9c15a7ac7bbdc6686164cfcbbc21ae5031a:/src/motif/textctrl.cpp diff --git a/src/motif/textctrl.cpp b/src/motif/textctrl.cpp index 6727160c89..090da09f5a 100644 --- a/src/motif/textctrl.cpp +++ b/src/motif/textctrl.cpp @@ -6,266 +6,531 @@ // Created: 17/09/98 // RCS-ID: $Id$ // Copyright: (c) Julian Smart -// Licence: wxWindows licence +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// -#ifdef __GNUG__ -#pragma implementation "textctrl.h" +// ============================================================================ +// declarations +// ============================================================================ + +// ---------------------------------------------------------------------------- +// headers +// ---------------------------------------------------------------------------- + +#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) + #pragma implementation "textctrl.h" #endif +// For compilers that support precompilation, includes "wx.h". +#include "wx/wxprec.h" + +#ifdef __VMS +#define XtParent XTPARENT +#endif + +#include "wx/defs.h" + #include #include -#include +#include #include "wx/textctrl.h" #include "wx/settings.h" #include "wx/filefn.h" #include "wx/utils.h" -#if defined(__BORLANDC__) && !defined(__WIN32__) -#include -#else -#ifndef __GNUWIN32__ -#include +#ifdef __VMS__ +#pragma message disable nosimpint #endif +#include +#ifdef __VMS__ +#pragma message enable nosimpint #endif -#if !USE_SHARED_LIBRARY -IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl) +#include "wx/motif/private.h" -BEGIN_EVENT_TABLE(wxTextCtrl, wxControl) - EVT_DROP_FILES(wxTextCtrl::OnDropFiles) -END_EVENT_TABLE() -#endif +// ---------------------------------------------------------------------------- +// private functions +// ---------------------------------------------------------------------------- + +// helper: inserts the new text in the value of the text ctrl and returns the +// result in place +static void MergeChangesIntoString(wxString& value, + XmTextVerifyCallbackStruct *textStruct); + +// callbacks +static void wxTextWindowChangedProc(Widget w, XtPointer clientData, XtPointer ptr); +static void wxTextWindowModifyProc(Widget w, XtPointer clientData, XmTextVerifyCallbackStruct *cbs); +static void wxTextWindowGainFocusProc(Widget w, XtPointer clientData, XmAnyCallbackStruct *cbs); +static void wxTextWindowLoseFocusProc(Widget w, XtPointer clientData, XmAnyCallbackStruct *cbs); +static void wxTextWindowActivateProc(Widget w, XtPointer clientData, XmAnyCallbackStruct *ptr); + + IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl) + + BEGIN_EVENT_TABLE(wxTextCtrl, wxControl) + EVT_DROP_FILES(wxTextCtrl::OnDropFiles) + EVT_CHAR(wxTextCtrl::OnChar) + + EVT_MENU(wxID_CUT, wxTextCtrl::OnCut) + EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy) + EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste) + EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo) + EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo) + + EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut) + EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy) + EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste) + EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo) + EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo) + + END_EVENT_TABLE() + +// ============================================================================ +// implementation +// ============================================================================ + +// ---------------------------------------------------------------------------- +// wxTextCtrl +// ---------------------------------------------------------------------------- // Text item wxTextCtrl::wxTextCtrl() -#ifndef NO_TEXT_WINDOW_STREAM - :streambuf() -#endif { - m_fileName = ""; + m_tempCallbackStruct = (void*) NULL; + m_modified = FALSE; + m_processedDefault = FALSE; } -bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id, - const wxString& value, - const wxPoint& pos, - const wxSize& size, long style, - const wxValidator& validator, - const wxString& name) +bool wxTextCtrl::Create(wxWindow *parent, + wxWindowID id, + const wxString& value, + const wxPoint& pos, + const wxSize& size, + long style, + const wxValidator& validator, + const wxString& name) { - m_fileName = ""; - SetName(name); - SetValidator(validator); - if (parent) parent->AddChild(this); + if( !CreateControl( parent, id, pos, size, style, validator, name ) ) + return false; + + m_tempCallbackStruct = (void*) NULL; + m_modified = FALSE; + m_processedDefault = FALSE; + + m_backgroundColour = *wxWHITE; + + Widget parentWidget = (Widget) parent->GetClientWidget(); + + bool wantHorizScrolling = ((m_windowStyle & wxHSCROLL) != 0); - m_windowStyle = style; + // If we don't have horizontal scrollbars, we want word wrap. + bool wantWordWrap = !wantHorizScrolling; - if ( id == -1 ) - m_windowId = (int)NewControlId(); + if (m_windowStyle & wxTE_MULTILINE) + { + Arg args[2]; + XtSetArg (args[0], XmNscrollHorizontal, wantHorizScrolling ? True : False); + XtSetArg (args[1], XmNwordWrap, wantWordWrap ? True : False); + + m_mainWidget = (WXWidget) XmCreateScrolledText(parentWidget, + wxConstCast(name.c_str(), char), + args, 2); + + XtVaSetValues ((Widget) m_mainWidget, + XmNeditable, ((style & wxTE_READONLY) ? False : True), + XmNeditMode, XmMULTI_LINE_EDIT, + NULL); + XtManageChild ((Widget) m_mainWidget); + } else - m_windowId = id; + { + m_mainWidget = (WXWidget)XtVaCreateManagedWidget + ( + wxConstCast(name.c_str(), char), + xmTextWidgetClass, + parentWidget, + NULL + ); + + XtVaSetValues ((Widget) m_mainWidget, + XmNeditable, ((style & wxTE_READONLY) ? False : True), + NULL); + + // TODO: Is this relevant? What does it do? + int noCols = 2; + if (!value.IsNull() && (value.Length() > (unsigned int) noCols)) + noCols = value.Length(); + XtVaSetValues((Widget) m_mainWidget, + XmNcolumns, noCols, + NULL); + } + + // remove border if asked for + if ( style & wxNO_BORDER ) + { + XtVaSetValues((Widget)m_mainWidget, + XmNshadowThickness, 0, + NULL); + } + + if ( !value.empty() ) + { + // do this instead... MB + // + XtVaSetValues( (Widget) m_mainWidget, + XmNvalue, wxConstCast(value.c_str(), char), + NULL); + } + + // install callbacks + XtAddCallback((Widget) m_mainWidget, XmNvalueChangedCallback, (XtCallbackProc)wxTextWindowChangedProc, (XtPointer)this); + + XtAddCallback((Widget) m_mainWidget, XmNmodifyVerifyCallback, (XtCallbackProc)wxTextWindowModifyProc, (XtPointer)this); + + XtAddCallback((Widget) m_mainWidget, XmNactivateCallback, (XtCallbackProc)wxTextWindowActivateProc, (XtPointer)this); + + XtAddCallback((Widget) m_mainWidget, XmNfocusCallback, (XtCallbackProc)wxTextWindowGainFocusProc, (XtPointer)this); + + XtAddCallback((Widget) m_mainWidget, XmNlosingFocusCallback, (XtCallbackProc)wxTextWindowLoseFocusProc, (XtPointer)this); + + // font + ChangeFont(FALSE); + + wxSize best = GetBestSize(); + if( size.x != -1 ) best.x = size.x; + if( size.y != -1 ) best.y = size.y; + + AttachWidget (parent, m_mainWidget, (WXWidget) NULL, + pos.x, pos.y, best.x, best.y); + + ChangeBackgroundColour(); return TRUE; } -wxString wxTextCtrl::GetValue() const +WXWidget wxTextCtrl::GetTopWidget() const { - // TODO - return wxString(""); + return IsMultiLine() ? (WXWidget)XtParent((Widget)m_mainWidget) + : m_mainWidget; } -void wxTextCtrl::SetValue(const wxString& value) +wxString wxTextCtrl::GetValue() const { - // TODO + wxString str; // result + + if (m_windowStyle & wxTE_PASSWORD) + { + // the value is stored always in m_value because it can't be retrieved + // from the text control + str = m_value; + } + else + { + // just get the string from Motif + char *s = XmTextGetString ((Widget) m_mainWidget); + if ( s ) + { + str = s; + XtFree (s); + } + //else: return empty string + + if ( m_tempCallbackStruct ) + { + // the string in the control isn't yet updated, can't use it as is + MergeChangesIntoString(str, (XmTextVerifyCallbackStruct *) + m_tempCallbackStruct); + } + } + + return str; } -void wxTextCtrl::SetSize(int x, int y, int width, int height, int sizeFlags) +void wxTextCtrl::SetValue(const wxString& value) { - // TODO + m_inSetValue = TRUE; + + // do this instead... MB + // + // with (at least) OpenMotif 2.1 this causes a lot of flicker +#if 0 + XtVaSetValues( (Widget) m_mainWidget, + XmNvalue, wxConstCast(value.c_str(), char), + NULL); +#endif + + Clear(); + AppendText( value ); + + m_inSetValue = FALSE; } // Clipboard operations void wxTextCtrl::Copy() { - // TODO + XmTextCopy((Widget) m_mainWidget, CurrentTime); } void wxTextCtrl::Cut() { - // TODO + XmTextCut((Widget) m_mainWidget, CurrentTime); } void wxTextCtrl::Paste() { - // TODO + XmTextPaste((Widget) m_mainWidget); } -void wxTextCtrl::SetEditable(bool editable) +bool wxTextCtrl::CanCopy() const { - // TODO + // Can copy if there's a selection + long from, to; + GetSelection(& from, & to); + return (from != to) ; } -void wxTextCtrl::SetInsertionPoint(long pos) +bool wxTextCtrl::CanCut() const { - // TODO + // Can cut if there's a selection + long from, to; + GetSelection(& from, & to); + return (from != to) && (IsEditable()); } -void wxTextCtrl::SetInsertionPointEnd() +bool wxTextCtrl::CanPaste() const { - long pos = GetLastPosition(); - SetInsertionPoint(pos); + return IsEditable() ; } -long wxTextCtrl::GetInsertionPoint() const +// Undo/redo +void wxTextCtrl::Undo() { - // TODO - return 0; + // Not possible in Motif } -long wxTextCtrl::GetLastPosition() const +void wxTextCtrl::Redo() { - // TODO - return 0; + // Not possible in Motif } -void wxTextCtrl::Replace(long from, long to, const wxString& value) +bool wxTextCtrl::CanUndo() const { - // TODO + // No Undo in Motif + return FALSE; } -void wxTextCtrl::Remove(long from, long to) +bool wxTextCtrl::CanRedo() const { - // TODO + // No Redo in Motif + return FALSE; } -void wxTextCtrl::SetSelection(long from, long to) +// If the return values from and to are the same, there is no +// selection. +void wxTextCtrl::GetSelection(long* from, long* to) const { - // TODO -} + XmTextPosition left, right; -bool wxTextCtrl::LoadFile(const wxString& file) -{ - if (!wxFileExists(file)) - return FALSE; + XmTextGetSelectionPosition((Widget) m_mainWidget, & left, & right); - m_fileName = file; + *from = (long) left; + *to = (long) right; +} - Clear(); +bool wxTextCtrl::IsEditable() const +{ + return (XmTextGetEditable((Widget) m_mainWidget) != 0); +} - ifstream input((char*) (const char*) file, ios::nocreate | ios::in); +void wxTextCtrl::SetEditable(bool editable) +{ + XmTextSetEditable((Widget) m_mainWidget, (Boolean) editable); +} - if (!input.bad()) - { - struct stat stat_buf; - if (stat(file, &stat_buf) < 0) - return FALSE; - // This may need to be a bigger buffer than the file size suggests, - // if it's a UNIX file. Give it an extra 1000 just in case. - char *tmp_buffer = (char*)malloc((size_t)(stat_buf.st_size+1+1000)); - long no_lines = 0; - long pos = 0; - while (!input.eof() && input.peek() != EOF) - { - input.getline(wxBuffer, 500); - int len = strlen(wxBuffer); - wxBuffer[len] = 13; - wxBuffer[len+1] = 10; - wxBuffer[len+2] = 0; - strcpy(tmp_buffer+pos, wxBuffer); - pos += strlen(wxBuffer); - no_lines++; - } +void wxTextCtrl::SetInsertionPoint(long pos) +{ + XmTextSetInsertionPosition ((Widget) m_mainWidget, (XmTextPosition) pos); +} - // TODO add line +void wxTextCtrl::SetInsertionPointEnd() +{ + long pos = GetLastPosition(); + SetInsertionPoint(pos); +} - free(tmp_buffer); +long wxTextCtrl::GetInsertionPoint() const +{ + return (long) XmTextGetInsertionPosition ((Widget) m_mainWidget); +} - return TRUE; - } - return FALSE; +long wxTextCtrl::GetLastPosition() const +{ + return (long) XmTextGetLastPosition ((Widget) m_mainWidget); } -// If file is null, try saved file name first -// Returns TRUE if succeeds. -bool wxTextCtrl::SaveFile(const wxString& file) +void wxTextCtrl::Replace(long from, long to, const wxString& value) { - wxString theFile(file); - if (theFile == "") - theFile = m_fileName; - if (theFile == "") - return FALSE; - m_fileName = theFile; + XmTextReplace ((Widget) m_mainWidget, (XmTextPosition) from, (XmTextPosition) to, + wxConstCast(value.c_str(), char)); +} - ofstream output((char*) (const char*) theFile); - if (output.bad()) - return FALSE; +void wxTextCtrl::Remove(long from, long to) +{ + XmTextSetSelection ((Widget) m_mainWidget, (XmTextPosition) from, (XmTextPosition) to, + (Time) 0); + XmTextRemove ((Widget) m_mainWidget); +} - // TODO get and save text +void wxTextCtrl::SetSelection(long from, long to) +{ + if( to == -1 ) + to = GetLastPosition(); - return FALSE; + XmTextSetSelection ((Widget) m_mainWidget, (XmTextPosition) from, (XmTextPosition) to, + (Time) 0); } void wxTextCtrl::WriteText(const wxString& text) { - // TODO write text to control + long textPosition = GetInsertionPoint() + strlen (text); + XmTextInsert ((Widget) m_mainWidget, GetInsertionPoint(), + wxConstCast(text.c_str(), char)); + XtVaSetValues ((Widget) m_mainWidget, XmNcursorPosition, textPosition, NULL); + SetInsertionPoint(textPosition); + XmTextShowPosition ((Widget) m_mainWidget, textPosition); + m_modified = TRUE; +} + +void wxTextCtrl::AppendText(const wxString& text) +{ + long textPosition = GetLastPosition() + text.length(); + XmTextInsert ((Widget) m_mainWidget, GetLastPosition(), + wxConstCast(text.c_str(), char)); + XtVaSetValues ((Widget) m_mainWidget, XmNcursorPosition, textPosition, NULL); + SetInsertionPoint(textPosition); + XmTextShowPosition ((Widget) m_mainWidget, textPosition); + m_modified = TRUE; } void wxTextCtrl::Clear() { - // TODO + XmTextSetString ((Widget) m_mainWidget, ""); + m_modified = FALSE; } bool wxTextCtrl::IsModified() const { - // TODO - return FALSE; + return m_modified; +} + +// Makes modified or unmodified +void wxTextCtrl::MarkDirty() +{ + m_modified = TRUE; } -// Makes 'unmodified' void wxTextCtrl::DiscardEdits() { - // TODO + m_modified = FALSE; } int wxTextCtrl::GetNumberOfLines() const { - // TODO + // HIDEOUSLY inefficient, but we have no choice. + char *s = XmTextGetString ((Widget) m_mainWidget); + if (s) + { + long i = 0; + int currentLine = 0; + bool finished = FALSE; + while (!finished) + { + int ch = s[i]; + if (ch == '\n') + { + currentLine++; + i++; + } + else if (ch == 0) + { + finished = TRUE; + } + else + i++; + } + + XtFree (s); + return currentLine; + } return 0; } long wxTextCtrl::XYToPosition(long x, long y) const { - // TODO - return 0; +/* It seems, that there is a bug in some versions of the Motif library, + so the original wxWin-Code doesn't work. */ + /* + Widget textWidget = (Widget) handle; + return (long) XmTextXYToPos (textWidget, (Position) x, (Position) y); + */ + /* Now a little workaround: */ + long r=0; + for (int i=0; idoit = True; + if (isascii(event.m_keyCode) && (textStruct->text->length == 1)) + { + textStruct->text->ptr[0] = ((event.m_keyCode == WXK_RETURN) ? 10 : event.m_keyCode); + } + } } -//========================================================================= -// called then "endl" is output (gcc) or then explicit sync is done (Borland) -//========================================================================= -int wxTextCtrl::sync() -{ - // Verify that there are no characters in get area - if ( gptr() && gptr() < egptr() ) - { - wxError("Who's trespassing my get area?","Internal error"); - return EOF; - } - - if ( pptr() && pptr() > pbase() ) return overflow(EOF); - - return 0; -/* OLD CODE - int len = pptr() - pbase(); - char *txt = new char[len+1]; - strncpy(txt, pbase(), len); - txt[len] = '\0'; - (*this) << txt; - setp(pbase(), epptr()); - delete[] txt; - return 0; -*/ +void wxTextCtrl::ChangeFont(bool keepOriginalSize) +{ + wxWindow::ChangeFont(keepOriginalSize); } -//========================================================================= -// Should not be called by a "ostream". Used by a "istream" -//========================================================================= -int wxTextCtrl::underflow() +void wxTextCtrl::ChangeBackgroundColour() { - return EOF; + wxWindow::ChangeBackgroundColour(); + + /* TODO: should scrollbars be affected? Should probably have separate + * function to change them (by default, taken from wxSystemSettings) + */ + if (m_windowStyle & wxTE_MULTILINE) + { + Widget parent = XtParent ((Widget) m_mainWidget); + Widget hsb, vsb; + + XtVaGetValues (parent, + XmNhorizontalScrollBar, &hsb, + XmNverticalScrollBar, &vsb, + NULL); + wxColour backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE); + if (hsb) + wxDoChangeBackgroundColour((WXWidget) hsb, backgroundColour, TRUE); + if (vsb) + wxDoChangeBackgroundColour((WXWidget) vsb, backgroundColour, TRUE); + + // MBN: why change parent background? + // DoChangeBackgroundColour((WXWidget) parent, m_backgroundColour, TRUE); + } } -#endif -wxTextCtrl& wxTextCtrl::operator<<(const wxString& s) +void wxTextCtrl::ChangeForegroundColour() { - WriteText(s); - return *this; + wxWindow::ChangeForegroundColour(); + + if (m_windowStyle & wxTE_MULTILINE) + { + Widget parent = XtParent ((Widget) m_mainWidget); + Widget hsb, vsb; + + XtVaGetValues (parent, + XmNhorizontalScrollBar, &hsb, + XmNverticalScrollBar, &vsb, + NULL); + + /* TODO: should scrollbars be affected? Should probably have separate + * function to change them (by default, taken from wxSystemSettings) + if (hsb) + DoChangeForegroundColour((WXWidget) hsb, m_foregroundColour); + if (vsb) + DoChangeForegroundColour((WXWidget) vsb, m_foregroundColour); + */ + wxDoChangeForegroundColour((WXWidget) parent, m_foregroundColour); + } } -wxTextCtrl& wxTextCtrl::operator<<(float f) +void wxTextCtrl::DoSendEvents(void *wxcbs, long keycode) { - wxString str; - str.Printf("%.2f", f); - WriteText(str); - return *this; + // we're in process of updating the text control + m_tempCallbackStruct = wxcbs; + + XmTextVerifyCallbackStruct *cbs = (XmTextVerifyCallbackStruct *)wxcbs; + + wxKeyEvent event (wxEVT_CHAR); + event.SetId(GetId()); + event.m_keyCode = keycode; + event.SetEventObject(this); + + // Only if wxTextCtrl::OnChar is called will this be set to True (and + // the character passed through) + cbs->doit = False; + + GetEventHandler()->ProcessEvent(event); + + if ( !InSetValue() && m_processedDefault ) + { + // Can generate a command + wxCommandEvent commandEvent(wxEVT_COMMAND_TEXT_UPDATED, GetId()); + commandEvent.SetEventObject(this); + ProcessCommand(commandEvent); + } + + // do it after the (user) event handlers processed the events because + // otherwise GetValue() would return incorrect (not yet updated value) + m_tempCallbackStruct = NULL; } -wxTextCtrl& wxTextCtrl::operator<<(double d) +wxSize wxDoGetSingleTextCtrlBestSize( Widget textWidget, + const wxWindow* window ) { - wxString str; - str.Printf("%.2f", d); - WriteText(str); - return *this; + Dimension xmargin, ymargin, highlight, shadow; + char* value; + + XtVaGetValues( textWidget, + XmNmarginWidth, &xmargin, + XmNmarginHeight, &ymargin, + XmNvalue, &value, + XmNhighlightThickness, &highlight, + XmNshadowThickness, &shadow, + NULL ); + + if( !value ) + value = "|"; + + int x, y; + window->GetTextExtent( value, &x, &y ); + + if( x < 100 ) x = 100; + + return wxSize( x + 2 * xmargin + 2 * highlight + 2 * shadow, + // MBN: +2 necessary: Lesstif bug or mine? + y + 2 * ymargin + 2 * highlight + 2 * shadow + 2 ); } -wxTextCtrl& wxTextCtrl::operator<<(int i) +wxSize wxTextCtrl::DoGetBestSize() const { - wxString str; - str.Printf("%d", i); - WriteText(str); - return *this; + if( IsSingleLine() ) + return wxDoGetSingleTextCtrlBestSize( (Widget)m_mainWidget, this ); + else + return wxWindow::DoGetBestSize(); } -wxTextCtrl& wxTextCtrl::operator<<(long i) +// ---------------------------------------------------------------------------- +// helpers and Motif callbacks +// ---------------------------------------------------------------------------- + +static void MergeChangesIntoString(wxString& value, + XmTextVerifyCallbackStruct *cbs) { - wxString str; - str.Printf("%ld", i); - WriteText(str); - return *this; + /* _sm_ + * At least on my system (SunOS 4.1.3 + Motif 1.2), you need to think of + * every event as a replace event. cbs->text->ptr gives the replacement + * text, cbs->startPos gives the index of the first char affected by the + * replace, and cbs->endPos gives the index one more than the last char + * affected by the replace (startPos == endPos implies an empty range). + * Hence, a deletion is represented by replacing all input text with a + * blank string ("", *not* NULL!). A simple insertion that does not + * overwrite any text has startPos == endPos. + */ + + if ( !value ) + { + // easy case: the ol value was empty + value = cbs->text->ptr; + } + else + { + // merge the changes into the value + const char * const passwd = value; + int len = value.length(); + + len += ( cbs->text->ptr ? + strlen(cbs->text->ptr) : + 0 ) + 1; // + new text (if any) + NUL + len -= cbs->endPos - cbs->startPos; // - text from affected region. + + char * newS = new char [len]; + char * dest = newS, + * insert = cbs->text->ptr; + + // Copy (old) text from passwd, up to the start posn of the change. + int i; + const char * p = passwd; + for (i = 0; i < cbs->startPos; ++i) + *dest++ = *p++; + + // Copy the text to be inserted). + if (insert) + while (*insert) + *dest++ = *insert++; + + // Finally, copy into newS any remaining text from passwd[endPos] on. + for (p = passwd + cbs->endPos; *p; ) + *dest++ = *p++; + *dest = 0; + + value = newS; + + delete[] newS; + } } -wxTextCtrl& wxTextCtrl::operator<<(const char c) +static void +wxTextWindowChangedProc (Widget w, XtPointer clientData, XtPointer WXUNUSED(ptr)) { - char buf[2]; + if (!wxGetWindowFromTable(w)) + // Widget has been deleted! + return; - buf[0] = c; - buf[1] = 0; - WriteText(buf); - return *this; + wxTextCtrl *tw = (wxTextCtrl *) clientData; + tw->SetModified(TRUE); } +static void +wxTextWindowModifyProc (Widget WXUNUSED(w), XtPointer clientData, XmTextVerifyCallbackStruct *cbs) +{ + wxTextCtrl *tw = (wxTextCtrl *) clientData; + tw->m_processedDefault = FALSE; + + // First, do some stuff if it's a password control: in this case, we need + // to store the string inside the class because GetValue() can't retrieve + // it from the text ctrl. We do *not* do it in other circumstances because + // it would double the amount of memory needed. + + if ( tw->GetWindowStyleFlag() & wxTE_PASSWORD ) + { + MergeChangesIntoString(tw->m_value, cbs); + + if ( cbs->text->length > 0 ) + { + int i; + for (i = 0; i < cbs->text->length; ++i) + cbs->text->ptr[i] = '*'; + cbs->text->ptr[i] = '\0'; + } + } + + if(tw->InSetValue()) + return; + + // If we're already within an OnChar, return: probably a programmatic + // insertion. + if (tw->m_tempCallbackStruct) + return; + + // Check for a backspace + if (cbs->startPos == (cbs->currInsert - 1)) + { + tw->DoSendEvents((void *)cbs, WXK_DELETE); + + return; + } + + // Pasting operation: let it through without calling OnChar + if (cbs->text->length > 1) + return; + + // Something other than text + if (cbs->text->ptr == NULL) + return; + + // normal key press + char ch = cbs->text->ptr[0]; + tw->DoSendEvents((void *)cbs, ch == '\n' ? '\r' : ch); +} + +static void +wxTextWindowGainFocusProc (Widget w, XtPointer clientData, XmAnyCallbackStruct *WXUNUSED(cbs)) +{ + if (!wxGetWindowFromTable(w)) + return; + + wxTextCtrl *tw = (wxTextCtrl *) clientData; + wxFocusEvent event(wxEVT_SET_FOCUS, tw->GetId()); + event.SetEventObject(tw); + tw->GetEventHandler()->ProcessEvent(event); +} + +static void +wxTextWindowLoseFocusProc (Widget w, XtPointer clientData, XmAnyCallbackStruct *WXUNUSED(cbs)) +{ + if (!wxGetWindowFromTable(w)) + return; + + wxTextCtrl *tw = (wxTextCtrl *) clientData; + wxFocusEvent event(wxEVT_KILL_FOCUS, tw->GetId()); + event.SetEventObject(tw); + tw->GetEventHandler()->ProcessEvent(event); +} + +static void wxTextWindowActivateProc(Widget w, XtPointer clientData, + XmAnyCallbackStruct *WXUNUSED(ptr)) +{ + if (!wxGetWindowFromTable(w)) + return; + + wxTextCtrl *tw = (wxTextCtrl *) clientData; + + if (tw->InSetValue()) + return; + + wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER); + event.SetId(tw->GetId()); + event.SetEventObject(tw); + tw->ProcessCommand(event); +} + +void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event)) +{ + Cut(); +} + +void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event)) +{ + Copy(); +} + +void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event)) +{ + Paste(); +} + +void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event)) +{ + Undo(); +} + +void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event)) +{ + Redo(); +} + +void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event) +{ + event.Enable( CanCut() ); +} + +void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event) +{ + event.Enable( CanCopy() ); +} + +void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event) +{ + event.Enable( CanPaste() ); +} + +void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event) +{ + event.Enable( CanUndo() ); +} + +void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event) +{ + event.Enable( CanRedo() ); +}