]> git.saurik.com Git - wxWidgets.git/blob - src/motif/textctrl.cpp
Changed m_children to GetChildren() -- not all ports are the same!
[wxWidgets.git] / src / motif / textctrl.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: textctrl.cpp
3 // Purpose: wxTextCtrl
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 17/09/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifdef __GNUG__
13 #pragma implementation "textctrl.h"
14 #endif
15
16 #include <sys/types.h>
17 #include <sys/stat.h>
18 #include <fstream.h>
19
20 #include "wx/textctrl.h"
21 #include "wx/settings.h"
22 #include "wx/filefn.h"
23 #include "wx/utils.h"
24
25 #if defined(__BORLANDC__) && !defined(__WIN32__)
26 #include <alloc.h>
27 #else
28 #ifndef __GNUWIN32__
29 #include <malloc.h>
30 #endif
31 #endif
32
33 #include <Xm/Text.h>
34 #include <sys/types.h>
35 #include <sys/stat.h>
36 #include <ctype.h>
37
38 #include "wx/motif/private.h"
39
40 static void
41 wxTextWindowChangedProc (Widget w, XtPointer clientData, XtPointer ptr);
42 static void
43 wxTextWindowModifyProc (Widget w, XtPointer clientData, XmTextVerifyCallbackStruct *cbs);
44 static void
45 wxTextWindowGainFocusProc (Widget w, XtPointer clientData, XmAnyCallbackStruct *cbs);
46 static void
47 wxTextWindowLoseFocusProc (Widget w, XtPointer clientData, XmAnyCallbackStruct *cbs);
48 static void wxTextWindowActivateProc(Widget w, XtPointer clientData,
49 XmAnyCallbackStruct *ptr);
50
51 #if !USE_SHARED_LIBRARY
52 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)
53
54 BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
55 EVT_DROP_FILES(wxTextCtrl::OnDropFiles)
56 EVT_CHAR(wxTextCtrl::OnChar)
57 END_EVENT_TABLE()
58 #endif
59
60 // Text item
61 wxTextCtrl::wxTextCtrl()
62 #ifndef NO_TEXT_WINDOW_STREAM
63 :streambuf()
64 #endif
65 {
66 m_fileName = "";
67 m_tempCallbackStruct = (void*) NULL;
68 m_modified = FALSE;
69 m_processedDefault = FALSE;
70 }
71
72 bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
73 const wxString& value,
74 const wxPoint& pos,
75 const wxSize& size, long style,
76 const wxValidator& validator,
77 const wxString& name)
78 {
79 m_tempCallbackStruct = (void*) NULL;
80 m_modified = FALSE;
81 m_processedDefault = FALSE;
82 m_fileName = "";
83 m_backgroundColour = parent->GetBackgroundColour();
84 m_foregroundColour = parent->GetForegroundColour();
85
86 SetName(name);
87 SetValidator(validator);
88 if (parent) parent->AddChild(this);
89
90 m_windowStyle = style;
91
92 if ( id == -1 )
93 m_windowId = (int)NewControlId();
94 else
95 m_windowId = id;
96
97 Widget parentWidget = (Widget) parent->GetClientWidget();
98
99 bool wantHorizScrolling = ((m_windowStyle & wxHSCROLL) != 0);
100
101 // If we don't have horizontal scrollbars, we want word wrap.
102 bool wantWordWrap = !wantHorizScrolling;
103
104 if (m_windowStyle & wxTE_MULTILINE)
105 {
106 Arg args[2];
107 XtSetArg (args[0], XmNscrollHorizontal, wantHorizScrolling ? True : False);
108 XtSetArg (args[1], XmNwordWrap, wantWordWrap ? True : False);
109
110 m_mainWidget = (WXWidget) XmCreateScrolledText (parentWidget, (char*) (const char*) name, args, 2);
111
112 XtVaSetValues ((Widget) m_mainWidget,
113 XmNeditable, ((style & wxTE_READONLY) ? False : True),
114 XmNeditMode, XmMULTI_LINE_EDIT,
115 NULL);
116 XtManageChild ((Widget) m_mainWidget);
117 }
118 else
119 {
120 m_mainWidget = (WXWidget) XtVaCreateManagedWidget ((char*) (const char*) name,
121 xmTextWidgetClass, parentWidget,
122 NULL);
123
124 // TODO: Is this relevant? What does it do?
125 int noCols = 2;
126 if (!value.IsNull() && (value.Length() > (unsigned int) noCols))
127 noCols = value.Length();
128 XtVaSetValues ((Widget) m_mainWidget,
129 XmNcolumns, noCols,
130 NULL);
131 }
132
133 if (!value.IsNull())
134 XmTextSetString ((Widget) m_mainWidget, (char*) (const char*) value);
135
136 XtAddCallback((Widget) m_mainWidget, XmNvalueChangedCallback, (XtCallbackProc)wxTextWindowChangedProc, (XtPointer)this);
137
138 XtAddCallback((Widget) m_mainWidget, XmNmodifyVerifyCallback, (XtCallbackProc)wxTextWindowModifyProc, (XtPointer)this);
139
140 XtAddCallback((Widget) m_mainWidget, XmNactivateCallback, (XtCallbackProc)wxTextWindowActivateProc, (XtPointer)this);
141
142 XtAddCallback((Widget) m_mainWidget, XmNfocusCallback, (XtCallbackProc)wxTextWindowGainFocusProc, (XtPointer)this);
143
144 XtAddCallback((Widget) m_mainWidget, XmNlosingFocusCallback, (XtCallbackProc)wxTextWindowLoseFocusProc, (XtPointer)this);
145
146 m_windowFont = parent->GetFont();
147 ChangeFont(FALSE);
148
149 SetCanAddEventHandler(TRUE);
150 AttachWidget (parent, m_mainWidget, (WXWidget) NULL, pos.x, pos.y, size.x, size.y);
151
152 ChangeBackgroundColour();
153
154 return TRUE;
155 }
156
157 WXWidget wxTextCtrl::GetTopWidget() const
158 {
159 return ((m_windowStyle & wxTE_MULTILINE) ? (WXWidget) XtParent((Widget) m_mainWidget) : m_mainWidget);
160 }
161
162 wxString wxTextCtrl::GetValue() const
163 {
164 if (m_windowStyle & wxTE_PASSWORD)
165 return m_value;
166 else
167 {
168 char *s = XmTextGetString ((Widget) m_mainWidget);
169 if (s)
170 {
171 wxString str(s);
172 XtFree (s);
173 return str;
174 }
175 else
176 {
177 return wxEmptyString;
178 }
179 }
180 }
181
182 void wxTextCtrl::SetValue(const wxString& value)
183 {
184 // This assert is wrong -- means that you can't set an empty
185 // string (IsNull == IsEmpty).
186 // wxASSERT_MSG( (!value.IsNull()), "Must not pass a null string to wxTextCtrl::SetValue." ) ;
187 m_inSetValue = TRUE;
188
189 XmTextSetString ((Widget) m_mainWidget, (char*) (const char*) value);
190
191 m_inSetValue = FALSE;
192 }
193
194 // Clipboard operations
195 void wxTextCtrl::Copy()
196 {
197 XmTextCopy((Widget) m_mainWidget, CurrentTime);
198 }
199
200 void wxTextCtrl::Cut()
201 {
202 XmTextCut((Widget) m_mainWidget, CurrentTime);
203 }
204
205 void wxTextCtrl::Paste()
206 {
207 XmTextPaste((Widget) m_mainWidget);
208 }
209
210 void wxTextCtrl::SetEditable(bool editable)
211 {
212 XmTextSetEditable((Widget) m_mainWidget, (Boolean) editable);
213 }
214
215 void wxTextCtrl::SetInsertionPoint(long pos)
216 {
217 XmTextSetInsertionPosition ((Widget) m_mainWidget, (XmTextPosition) pos);
218 }
219
220 void wxTextCtrl::SetInsertionPointEnd()
221 {
222 long pos = GetLastPosition();
223 SetInsertionPoint(pos);
224 }
225
226 long wxTextCtrl::GetInsertionPoint() const
227 {
228 return (long) XmTextGetInsertionPosition ((Widget) m_mainWidget);
229 }
230
231 long wxTextCtrl::GetLastPosition() const
232 {
233 return (long) XmTextGetLastPosition ((Widget) m_mainWidget);
234 }
235
236 void wxTextCtrl::Replace(long from, long to, const wxString& value)
237 {
238 XmTextReplace ((Widget) m_mainWidget, (XmTextPosition) from, (XmTextPosition) to,
239 (char*) (const char*) value);
240 }
241
242 void wxTextCtrl::Remove(long from, long to)
243 {
244 XmTextSetSelection ((Widget) m_mainWidget, (XmTextPosition) from, (XmTextPosition) to,
245 (Time) 0);
246 XmTextRemove ((Widget) m_mainWidget);
247 }
248
249 void wxTextCtrl::SetSelection(long from, long to)
250 {
251 XmTextSetSelection ((Widget) m_mainWidget, (XmTextPosition) from, (XmTextPosition) to,
252 (Time) 0);
253 }
254
255 bool wxTextCtrl::LoadFile(const wxString& file)
256 {
257 if (!wxFileExists(file))
258 return FALSE;
259
260 m_fileName = file;
261
262 Clear();
263
264 Widget textWidget = (Widget) m_mainWidget;
265 FILE *fp;
266
267 struct stat statb;
268 if ((stat ((char*) (const char*) file, &statb) == -1) || (statb.st_mode & S_IFMT) != S_IFREG ||
269 !(fp = fopen ((char*) (const char*) file, "r")))
270 {
271 return FALSE;
272 }
273 else
274 {
275 long len = statb.st_size;
276 char *text;
277 if (!(text = XtMalloc ((unsigned) (len + 1))))
278 {
279 fclose (fp);
280 return FALSE;
281 }
282 if (fread (text, sizeof (char), len, fp) != (size_t) len)
283 {
284 }
285 fclose (fp);
286
287 text[len] = 0;
288 XmTextSetString (textWidget, text);
289 // m_textPosition = len;
290 XtFree (text);
291 m_modified = FALSE;
292 return TRUE;
293 }
294 }
295
296 // If file is null, try saved file name first
297 // Returns TRUE if succeeds.
298 bool wxTextCtrl::SaveFile(const wxString& file)
299 {
300 wxString theFile(file);
301 if (theFile == "")
302 theFile = m_fileName;
303 if (theFile == "")
304 return FALSE;
305 m_fileName = theFile;
306
307 Widget textWidget = (Widget) m_mainWidget;
308 FILE *fp;
309
310 if (!(fp = fopen ((char*) (const char*) theFile, "w")))
311 {
312 return FALSE;
313 }
314 else
315 {
316 char *text = XmTextGetString (textWidget);
317 long len = XmTextGetLastPosition (textWidget);
318
319 if (fwrite (text, sizeof (char), len, fp) != (size_t) len)
320 {
321 // Did not write whole file
322 }
323 // Make sure newline terminates the file
324 if (text[len - 1] != '\n')
325 fputc ('\n', fp);
326
327 fclose (fp);
328 XtFree (text);
329 m_modified = FALSE;
330 return TRUE;
331 }
332 }
333
334 void wxTextCtrl::WriteText(const wxString& text)
335 {
336 long textPosition = GetInsertionPoint() + strlen (text);
337 XmTextInsert ((Widget) m_mainWidget, GetInsertionPoint(), (char*) (const char*) text);
338 XtVaSetValues ((Widget) m_mainWidget, XmNcursorPosition, textPosition, NULL);
339 SetInsertionPoint(textPosition);
340 XmTextShowPosition ((Widget) m_mainWidget, textPosition);
341 m_modified = TRUE;
342 }
343
344 void wxTextCtrl::Clear()
345 {
346 XmTextSetString ((Widget) m_mainWidget, "");
347 m_modified = FALSE;
348 }
349
350 bool wxTextCtrl::IsModified() const
351 {
352 return m_modified;
353 }
354
355 // Makes 'unmodified'
356 void wxTextCtrl::DiscardEdits()
357 {
358 XmTextSetString ((Widget) m_mainWidget, "");
359 m_modified = FALSE;
360 }
361
362 int wxTextCtrl::GetNumberOfLines() const
363 {
364 // HIDEOUSLY inefficient, but we have no choice.
365 char *s = XmTextGetString ((Widget) m_mainWidget);
366 if (s)
367 {
368 long i = 0;
369 int currentLine = 0;
370 bool finished = FALSE;
371 while (!finished)
372 {
373 int ch = s[i];
374 if (ch == '\n')
375 {
376 currentLine++;
377 i++;
378 }
379 else if (ch == 0)
380 {
381 finished = TRUE;
382 }
383 else
384 i++;
385 }
386
387 XtFree (s);
388 return currentLine;
389 }
390 return 0;
391 }
392
393 long wxTextCtrl::XYToPosition(long x, long y) const
394 {
395 /* It seems, that there is a bug in some versions of the Motif library,
396 so the original wxWin-Code doesn't work. */
397 /*
398 Widget textWidget = (Widget) handle;
399 return (long) XmTextXYToPos (textWidget, (Position) x, (Position) y);
400 */
401 /* Now a little workaround: */
402 long r=0;
403 for (int i=0; i<y; i++) r+=(GetLineLength(i)+1);
404 return r+x;
405 }
406
407 void wxTextCtrl::PositionToXY(long pos, long *x, long *y) const
408 {
409 Position xx, yy;
410 XmTextPosToXY((Widget) m_mainWidget, pos, &xx, &yy);
411 *x = xx; *y = yy;
412 }
413
414 void wxTextCtrl::ShowPosition(long pos)
415 {
416 XmTextShowPosition ((Widget) m_mainWidget, (XmTextPosition) pos);
417 }
418
419 int wxTextCtrl::GetLineLength(long lineNo) const
420 {
421 wxString str = GetLineText (lineNo);
422 return (int) str.Length();
423 }
424
425 wxString wxTextCtrl::GetLineText(long lineNo) const
426 {
427 // HIDEOUSLY inefficient, but we have no choice.
428 char *s = XmTextGetString ((Widget) m_mainWidget);
429
430 if (s)
431 {
432 wxString buf("");
433 long i;
434 int currentLine = 0;
435 for (i = 0; currentLine != lineNo && s[i]; i++ )
436 if (s[i] == '\n')
437 currentLine++;
438 // Now get the text
439 int j;
440 for (j = 0; s[i] && s[i] != '\n'; i++, j++ )
441 buf += s[i];
442
443 XtFree(s);
444 return buf;
445 }
446 else
447 return wxEmptyString;
448 }
449
450 /*
451 * Text item
452 */
453
454 void wxTextCtrl::Command(wxCommandEvent & event)
455 {
456 SetValue (event.GetString());
457 ProcessCommand (event);
458 }
459
460 void wxTextCtrl::OnDropFiles(wxDropFilesEvent& event)
461 {
462 // By default, load the first file into the text window.
463 if (event.GetNumberOfFiles() > 0)
464 {
465 LoadFile(event.GetFiles()[0]);
466 }
467 }
468
469 // The streambuf code was partly taken from chapter 3 by Jerry Schwarz of
470 // AT&T's "C++ Lanuage System Release 3.0 Library Manual" - Stein Somers
471
472 //=========================================================================
473 // Called then the buffer is full (gcc 2.6.3)
474 // or when "endl" is output (Borland 4.5)
475 //=========================================================================
476 // Class declaration using multiple inheritance doesn't work properly for
477 // Borland. See note in wb_text.h.
478 #ifndef NO_TEXT_WINDOW_STREAM
479 int wxTextCtrl::overflow(int c)
480 {
481 // Make sure there is a holding area
482 if ( allocate()==EOF )
483 {
484 wxError("Streambuf allocation failed","Internal error");
485 return EOF;
486 }
487
488 // Verify that there are no characters in get area
489 if ( gptr() && gptr() < egptr() )
490 {
491 wxError("wxTextCtrl::overflow: Who's trespassing my get area?","Internal error");
492 return EOF;
493 }
494
495 // Reset get area
496 setg(0,0,0);
497
498 // Make sure there is a put area
499 if ( ! pptr() )
500 {
501 /* This doesn't seem to be fatal so comment out error message */
502 // wxError("Put area not opened","Internal error");
503 setp( base(), base() );
504 }
505
506 // Determine how many characters have been inserted but no consumed
507 int plen = pptr() - pbase();
508
509 // Now Jerry relies on the fact that the buffer is at least 2 chars
510 // long, but the holding area "may be as small as 1" ???
511 // And we need an additional \0, so let's keep this inefficient but
512 // safe copy.
513
514 // If c!=EOF, it is a character that must also be comsumed
515 int xtra = c==EOF? 0 : 1;
516
517 // Write temporary C-string to wxTextWindow
518 {
519 char *txt = new char[plen+xtra+1];
520 memcpy(txt, pbase(), plen);
521 txt[plen] = (char)c; // append c
522 txt[plen+xtra] = '\0'; // append '\0' or overwrite c
523 // If the put area already contained \0, output will be truncated there
524 WriteText(txt);
525 delete[] txt;
526 }
527
528 // Reset put area
529 setp(pbase(), epptr());
530
531 #if defined(__WATCOMC__)
532 return __NOT_EOF;
533 #elif defined(zapeof) // HP-UX (all cfront based?)
534 return zapeof(c);
535 #else
536 return c!=EOF ? c : 0; // this should make everybody happy
537 #endif
538 }
539
540 //=========================================================================
541 // called then "endl" is output (gcc) or then explicit sync is done (Borland)
542 //=========================================================================
543 int wxTextCtrl::sync()
544 {
545 // Verify that there are no characters in get area
546 if ( gptr() && gptr() < egptr() )
547 {
548 wxError("Who's trespassing my get area?","Internal error");
549 return EOF;
550 }
551
552 if ( pptr() && pptr() > pbase() ) return overflow(EOF);
553
554 return 0;
555 /* OLD CODE
556 int len = pptr() - pbase();
557 char *txt = new char[len+1];
558 strncpy(txt, pbase(), len);
559 txt[len] = '\0';
560 (*this) << txt;
561 setp(pbase(), epptr());
562 delete[] txt;
563 return 0;
564 */
565 }
566
567 //=========================================================================
568 // Should not be called by a "ostream". Used by a "istream"
569 //=========================================================================
570 int wxTextCtrl::underflow()
571 {
572 return EOF;
573 }
574 #endif
575
576 wxTextCtrl& wxTextCtrl::operator<<(const wxString& s)
577 {
578 WriteText(s);
579 return *this;
580 }
581
582 wxTextCtrl& wxTextCtrl::operator<<(float f)
583 {
584 wxString str;
585 str.Printf("%.2f", f);
586 WriteText(str);
587 return *this;
588 }
589
590 wxTextCtrl& wxTextCtrl::operator<<(double d)
591 {
592 wxString str;
593 str.Printf("%.2f", d);
594 WriteText(str);
595 return *this;
596 }
597
598 wxTextCtrl& wxTextCtrl::operator<<(int i)
599 {
600 wxString str;
601 str.Printf("%d", i);
602 WriteText(str);
603 return *this;
604 }
605
606 wxTextCtrl& wxTextCtrl::operator<<(long i)
607 {
608 wxString str;
609 str.Printf("%ld", i);
610 WriteText(str);
611 return *this;
612 }
613
614 wxTextCtrl& wxTextCtrl::operator<<(const char c)
615 {
616 char buf[2];
617
618 buf[0] = c;
619 buf[1] = 0;
620 WriteText(buf);
621 return *this;
622 }
623
624 void wxTextCtrl::OnChar(wxKeyEvent& event)
625 {
626 // Indicates that we should generate a normal command, because
627 // we're letting default behaviour happen (otherwise it's vetoed
628 // by virtue of overriding OnChar)
629 m_processedDefault = TRUE;
630
631 if (m_tempCallbackStruct)
632 {
633 XmTextVerifyCallbackStruct *textStruct =
634 (XmTextVerifyCallbackStruct *) m_tempCallbackStruct;
635 textStruct->doit = True;
636 if (isascii(event.m_keyCode) && (textStruct->text->length == 1))
637 {
638 textStruct->text->ptr[0] = ((event.m_keyCode == WXK_RETURN) ? 10 : event.m_keyCode);
639 }
640 }
641 }
642
643 void wxTextCtrl::ChangeFont(bool keepOriginalSize)
644 {
645 wxWindow::ChangeFont(keepOriginalSize);
646 }
647
648 void wxTextCtrl::ChangeBackgroundColour()
649 {
650 wxWindow::ChangeBackgroundColour();
651
652 Widget parent = XtParent ((Widget) m_mainWidget);
653 Widget hsb, vsb;
654
655 XtVaGetValues (parent,
656 XmNhorizontalScrollBar, &hsb,
657 XmNverticalScrollBar, &vsb,
658 NULL);
659
660 /* TODO: should scrollbars be affected? Should probably have separate
661 * function to change them (by default, taken from wxSystemSettings)
662 if (hsb)
663 DoChangeBackgroundColour((WXWidget) hsb, m_backgroundColour, TRUE);
664 if (vsb)
665 DoChangeBackgroundColour((WXWidget) vsb, m_backgroundColour, TRUE);
666 */
667
668 DoChangeBackgroundColour((WXWidget) parent, m_backgroundColour, TRUE);
669 }
670
671 void wxTextCtrl::ChangeForegroundColour()
672 {
673 wxWindow::ChangeForegroundColour();
674
675
676 Widget parent = XtParent ((Widget) m_mainWidget);
677 Widget hsb, vsb;
678
679 XtVaGetValues (parent,
680 XmNhorizontalScrollBar, &hsb,
681 XmNverticalScrollBar, &vsb,
682 NULL);
683
684 /* TODO: should scrollbars be affected? Should probably have separate
685 * function to change them (by default, taken from wxSystemSettings)
686 if (hsb)
687 DoChangeForegroundColour((WXWidget) hsb, m_foregroundColour);
688 if (vsb)
689 DoChangeForegroundColour((WXWidget) vsb, m_foregroundColour);
690 */
691 DoChangeForegroundColour((WXWidget) parent, m_foregroundColour);
692 }
693
694 static void wxTextWindowChangedProc (Widget w, XtPointer clientData, XtPointer ptr)
695 {
696 if (!wxGetWindowFromTable(w))
697 // Widget has been deleted!
698 return;
699
700 wxTextCtrl *tw = (wxTextCtrl *) clientData;
701 tw->SetModified(TRUE);
702 }
703
704 static void
705 wxTextWindowModifyProc (Widget w, XtPointer clientData, XmTextVerifyCallbackStruct *cbs)
706 {
707 wxTextCtrl *tw = (wxTextCtrl *) clientData;
708 tw->m_processedDefault = FALSE;
709
710 // First, do some stuff if it's a password control.
711 // (What does this do exactly?)
712
713 if (tw->GetWindowStyleFlag() & wxTE_PASSWORD)
714 {
715 /* _sm_
716 * At least on my system (SunOS 4.1.3 + Motif 1.2), you need to think of
717 * every event as a replace event. cbs->text->ptr gives the replacement
718 * text, cbs->startPos gives the index of the first char affected by the
719 * replace, and cbs->endPos gives the index one more than the last char
720 * affected by the replace (startPos == endPos implies an empty range).
721 * Hence, a deletion is represented by replacing all input text with a
722 * blank string ("", *not* NULL!). A simple insertion that does not
723 * overwrite any text has startPos == endPos.
724 */
725
726 if (tw->m_value.IsNull())
727 {
728 tw->m_value = cbs->text->ptr;
729 }
730 else
731 {
732 char * passwd = (char*) (const char*) tw->m_value; // Set up a more convenient alias.
733
734 int len = passwd ? strlen(passwd) : 0; // Enough room for old text
735 len += strlen(cbs->text->ptr) + 1; // + new text (if any) + NUL
736 len -= cbs->endPos - cbs->startPos; // - text from affected region.
737
738 char * newS = new char [len];
739 char * p = passwd, * dest = newS, * insert = cbs->text->ptr;
740
741 // Copy (old) text from passwd, up to the start posn of the change.
742 int i;
743 for (i = 0; i < cbs->startPos; ++i)
744 *dest++ = *p++;
745
746 // Copy the text to be inserted).
747 while (*insert)
748 *dest++ = *insert++;
749
750 // Finally, copy into newS any remaining text from passwd[endPos] on.
751 for (p = passwd + cbs->endPos; *p; )
752 *dest++ = *p++;
753 *dest = 0;
754
755 tw->m_value = newS;
756
757 delete[] newS;
758 }
759
760 if (cbs->text->length>0)
761 {
762 int i;
763 for (i = 0; i < cbs->text->length; ++i)
764 cbs->text->ptr[i] = '*';
765 cbs->text->ptr[i] = 0;
766 }
767 }
768
769 // If we're already within an OnChar, return: probably
770 // a programmatic insertion.
771 if (tw->m_tempCallbackStruct)
772 return;
773
774 // Check for a backspace
775 if (cbs->startPos == (cbs->currInsert - 1))
776 {
777 tw->m_tempCallbackStruct = (void*) cbs;
778
779 wxKeyEvent event (wxEVT_CHAR);
780 event.SetId(tw->GetId());
781 event.m_keyCode = WXK_DELETE;
782 event.SetEventObject(tw);
783
784 // Only if wxTextCtrl::OnChar is called
785 // will this be set to True (and the character
786 // passed through)
787 cbs->doit = False;
788
789 tw->GetEventHandler()->ProcessEvent(event);
790
791 tw->m_tempCallbackStruct = NULL;
792
793 if (tw->InSetValue())
794 return;
795
796 if (tw->m_processedDefault)
797 {
798 // Can generate a command
799 wxCommandEvent commandEvent(wxEVT_COMMAND_TEXT_UPDATED, tw->GetId());
800 commandEvent.SetEventObject(tw);
801 tw->ProcessCommand(commandEvent);
802 }
803
804 return;
805 }
806
807 // Pasting operation: let it through without
808 // calling OnChar
809 if (cbs->text->length > 1)
810 return;
811
812 // Something other than text
813 if (cbs->text->ptr == NULL)
814 return;
815
816 tw->m_tempCallbackStruct = (void*) cbs;
817
818 wxKeyEvent event (wxEVT_CHAR);
819 event.SetId(tw->GetId());
820 event.SetEventObject(tw);
821 event.m_keyCode = (cbs->text->ptr[0] == 10 ? 13 : cbs->text->ptr[0]);
822
823 // Only if wxTextCtrl::OnChar is called
824 // will this be set to True (and the character
825 // passed through)
826 cbs->doit = False;
827
828 tw->GetEventHandler()->ProcessEvent(event);
829
830 tw->m_tempCallbackStruct = NULL;
831
832 if (tw->InSetValue())
833 return;
834
835 if (tw->m_processedDefault)
836 {
837 // Can generate a command
838 wxCommandEvent commandEvent(wxEVT_COMMAND_TEXT_UPDATED, tw->GetId());
839 commandEvent.SetEventObject(tw);
840 tw->ProcessCommand(commandEvent);
841 }
842 }
843
844 static void
845 wxTextWindowGainFocusProc (Widget w, XtPointer clientData, XmAnyCallbackStruct *cbs)
846 {
847 if (!wxGetWindowFromTable(w))
848 return;
849
850 wxTextCtrl *tw = (wxTextCtrl *) clientData;
851 wxFocusEvent event(wxEVT_SET_FOCUS, tw->GetId());
852 event.SetEventObject(tw);
853 tw->GetEventHandler()->ProcessEvent(event);
854 }
855
856 static void
857 wxTextWindowLoseFocusProc (Widget w, XtPointer clientData, XmAnyCallbackStruct *cbs)
858 {
859 if (!wxGetWindowFromTable(w))
860 return;
861
862 wxTextCtrl *tw = (wxTextCtrl *) clientData;
863 wxFocusEvent event(wxEVT_KILL_FOCUS, tw->GetId());
864 event.SetEventObject(tw);
865 tw->GetEventHandler()->ProcessEvent(event);
866 }
867
868 static void wxTextWindowActivateProc(Widget w, XtPointer clientData,
869 XmAnyCallbackStruct *ptr)
870 {
871 if (!wxGetWindowFromTable(w))
872 return;
873
874 wxTextCtrl *tw = (wxTextCtrl *) clientData;
875 /*
876 case XmCR_ACTIVATE:
877 type_event = wxEVENT_TYPE_TEXT_ENTER_COMMAND ;
878 break;
879 default:
880 type_event = wxEVENT_TYPE_TEXT_COMMAND ;
881 break;
882 }
883 */
884
885 if (tw->InSetValue())
886 return;
887
888 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER);
889 event.SetId(tw->GetId());
890 event.SetEventObject(tw);
891 tw->ProcessCommand(event);
892 }