]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/os2/textctrl.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Only call use uppercase letter if control, alt, or shift is held down,
[wxWidgets.git] / src / os2 / textctrl.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: textctrl.cpp
3// Purpose: wxTextCtrl
4// Author: David Webster
5// Modified by:
6// Created: 10/17/99
7// RCS-ID: $Id$
8// Copyright: (c) David Webster
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12// ----------------------------------------------------------------------------
13// headers
14// ----------------------------------------------------------------------------
15
16// For compilers that support precompilation, includes "wx.h".
17#include "wx/wxprec.h"
18
19#ifndef WX_PRECOMP
20 #include "wx/textctrl.h"
21 #include "wx/scrolwin.h"
22 #include "wx/settings.h"
23 #include "wx/brush.h"
24 #include "wx/utils.h"
25 #include "wx/log.h"
26#endif
27
28#if wxUSE_CLIPBOARD
29 #include "wx/app.h"
30 #include "wx/clipbrd.h"
31#endif
32
33#include "wx/textfile.h"
34
35#include "wx/os2/private.h"
36
37#include <string.h>
38#include <stdlib.h>
39#include <sys/types.h>
40
41#if wxUSE_IOSTREAMH
42# include <fstream.h>
43#else
44# include <fstream>
45#endif
46
47#if !defined(MLE_INDEX)
48#define MLE_INDEX 0
49#define MLE_RGB 1
50#endif
51
52
53// ----------------------------------------------------------------------------
54// event tables and other macros
55// ----------------------------------------------------------------------------
56
57IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)
58
59BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
60 EVT_CHAR(wxTextCtrl::OnChar)
61 EVT_DROP_FILES(wxTextCtrl::OnDropFiles)
62
63 EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
64 EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
65 EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
66 EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
67 EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
68
69 EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
70 EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
71 EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
72 EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
73 EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
74END_EVENT_TABLE()
75
76
77// ============================================================================
78// implementation
79// ============================================================================
80
81// ----------------------------------------------------------------------------
82// creation
83// ----------------------------------------------------------------------------
84
85wxTextCtrl::wxTextCtrl()
86{
87}
88
89wxTextCtrl::~wxTextCtrl()
90{
91}
92
93bool wxTextCtrl::Create(
94 wxWindow* pParent
95, wxWindowID vId
96, const wxString& rsValue
97, const wxPoint& rPos
98, const wxSize& rSize
99, long lStyle
100, const wxValidator& rValidator
101, const wxString& rsName
102)
103{
104 HWND hParent;
105 int nTempy;
106
107 //
108 // Base initialization
109 //
110 if ( !CreateBase( pParent
111 ,vId
112 ,rPos
113 ,rSize
114 ,lStyle
115 ,rValidator
116 ,rsName
117 ))
118 return FALSE;
119
120 wxPoint vPos = rPos; // The OS/2 position
121 SWP vSwp;
122
123 if (pParent )
124 {
125 pParent->AddChild(this);
126 }
127
128 m_windowStyle = lStyle;
129 m_bIsMLE = FALSE;
130
131 long lSstyle = WS_VISIBLE | WS_TABSTOP;
132
133 //
134 // Single and multiline edit fields are two different controls in PM
135 //
136 if ( m_windowStyle & wxTE_MULTILINE )
137 {
138 lSstyle |= MLS_BORDER | MLS_WORDWRAP;
139 m_bIsMLE = TRUE;
140
141 if ((m_windowStyle & wxTE_NO_VSCROLL) == 0)
142 lSstyle |= MLS_VSCROLL;
143 if (m_windowStyle & wxHSCROLL)
144 lSstyle |= MLS_HSCROLL;
145 if (m_windowStyle & wxTE_READONLY)
146 lSstyle |= MLS_READONLY;
147 }
148 else
149 {
150 lSstyle |= ES_LEFT | ES_AUTOSCROLL | ES_MARGIN;
151
152 if (m_windowStyle & wxHSCROLL)
153 lSstyle |= ES_AUTOSCROLL;
154 if (m_windowStyle & wxTE_READONLY)
155 lSstyle |= ES_READONLY;
156 if (m_windowStyle & wxTE_PASSWORD) // hidden input
157 lSstyle |= ES_UNREADABLE;
158 }
159
160 if (m_bIsMLE)
161 {
162 m_hWnd = (WXHWND)::WinCreateWindow( (HWND)GetHwndOf(pParent) // Parent window handle
163 ,WC_MLE // Window class
164 ,(PSZ)rsValue.c_str() // Initial Text
165 ,(ULONG)lSstyle // Style flags
166 ,(LONG)0 // X pos of origin
167 ,(LONG)0 // Y pos of origin
168 ,(LONG)0 // field width
169 ,(LONG)0 // field height
170 ,(HWND)GetHwndOf(pParent) // owner window handle (same as parent
171 ,HWND_TOP // initial z position
172 ,(ULONG)vId // Window identifier
173 ,NULL // no control data
174 ,NULL // no Presentation parameters
175 );
176 }
177 else
178 {
179 m_hWnd = (WXHWND)::WinCreateWindow( (HWND)GetHwndOf(pParent) // Parent window handle
180 ,WC_ENTRYFIELD // Window class
181 ,(PSZ)rsValue.c_str() // Initial Text
182 ,(ULONG)lSstyle // Style flags
183 ,(LONG)0 // X pos of origin
184 ,(LONG)0 // Y pos of origin
185 ,(LONG)0 // field width
186 ,(LONG)0 // field height
187 ,(HWND)GetHwndOf(pParent) // owner window handle (same as parent
188 ,HWND_TOP // initial z position
189 ,(ULONG)vId // Window identifier
190 ,NULL // no control data
191 ,NULL // no Presentation parameters
192 );
193 }
194
195 if (m_hWnd == 0)
196 {
197 return FALSE;
198 }
199
200 SubclassWin(GetHWND());
201
202 //
203 // Set font, position, size and initial value
204 //
205 wxFont* pTextFont = new wxFont( 8
206 ,wxMODERN
207 ,wxNORMAL
208 ,wxNORMAL
209 );
210 SetFont(*pTextFont);
211 if (!rsValue.IsEmpty())
212 {
213 SetValue(rsValue);
214 }
215 SetupColours();
216 //
217 // If X and/or Y are not zero the difference is the compensation value
218 // for margins for OS/2 controls.
219 //
220 ::WinQueryWindowPos(m_hWnd, &vSwp);
221 SetXComp(vSwp.x);
222 SetYComp(vSwp.y);
223 SetSize( vPos.x - GetXComp()
224 ,vPos.y - GetYComp()
225 ,rSize.x
226 ,rSize.y
227 );
228 delete pTextFont;
229 return TRUE;
230} // end of wxTextCtrl::Create
231
232//
233// Make sure the window style (etc.) reflects the HWND style (roughly)
234//
235void wxTextCtrl::AdoptAttributesFromHWND()
236{
237 HWND hWnd = GetHwnd();
238 LONG lStyle = ::WinQueryWindowULong(hWnd, QWL_STYLE);
239
240 wxWindow::AdoptAttributesFromHWND();
241
242 if (m_bIsMLE)
243 {
244 m_windowStyle |= wxTE_MULTILINE;
245 if (lStyle & MLS_READONLY)
246 m_windowStyle |= wxTE_READONLY;
247 }
248 else
249 {
250 if (lStyle & ES_UNREADABLE)
251 m_windowStyle |= wxTE_PASSWORD;
252 if (lStyle & ES_READONLY)
253 m_windowStyle |= wxTE_READONLY;
254 }
255} // end of wxTextCtrl::AdoptAttributesFromHWND
256
257WXDWORD wxTextCtrl::OS2GetStyle(
258 long lStyle
259, WXDWORD* pdwExstyle
260) const
261{
262 //
263 // Default border for the text controls is the sunken one
264 //
265 if ((lStyle & wxBORDER_MASK) == wxBORDER_DEFAULT )
266 {
267 lStyle |= wxBORDER_SUNKEN;
268 }
269
270 long dwStyle = wxControl::OS2GetStyle( lStyle
271 ,pdwExstyle
272 );
273
274 dwStyle = WS_VISIBLE | WS_TABSTOP;
275
276 //
277 // Single and multiline edit fields are two different controls in PM
278 //
279 if ( m_windowStyle & wxTE_MULTILINE )
280 {
281 dwStyle |= MLS_BORDER | MLS_WORDWRAP;
282 if ((m_windowStyle & wxTE_NO_VSCROLL) == 0)
283 dwStyle |= MLS_VSCROLL;
284 if (m_windowStyle & wxHSCROLL)
285 dwStyle |= MLS_HSCROLL;
286 if (m_windowStyle & wxTE_READONLY)
287 dwStyle |= MLS_READONLY;
288 }
289 else
290 {
291 dwStyle |= ES_LEFT | ES_AUTOSCROLL | ES_MARGIN;
292 if (m_windowStyle & wxHSCROLL)
293 dwStyle |= ES_AUTOSCROLL;
294 if (m_windowStyle & wxTE_READONLY)
295 dwStyle |= ES_READONLY;
296 if (m_windowStyle & wxTE_PASSWORD) // hidden input
297 dwStyle |= ES_UNREADABLE;
298 }
299 return dwStyle;
300} // end of wxTextCtrl::OS2GetStyle
301
302void wxTextCtrl::SetWindowStyleFlag(
303 long lStyle
304)
305{
306 wxControl::SetWindowStyleFlag(lStyle);
307} // end of wxTextCtrl::SetWindowStyleFlag
308
309void wxTextCtrl::SetupColours()
310{
311 wxColour vBkgndColour;
312
313 vBkgndColour = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW);
314 SetBackgroundColour(vBkgndColour);
315 SetForegroundColour(GetParent()->GetForegroundColour());
316 if (m_bIsMLE)
317 {
318 ::WinSendMsg( GetHwnd()
319 ,MLM_SETTEXTCOLOR
320 ,(MPARAM)GetParent()->GetForegroundColour().GetPixel()
321 ,(MPARAM)MLE_RGB
322 );
323 }
324} // end of wxTextCtrl::SetupColours
325
326// ----------------------------------------------------------------------------
327// set/get the controls text
328// ----------------------------------------------------------------------------
329
330wxString wxTextCtrl::GetValue() const
331{
332 wxString sStr = wxGetWindowText(GetHWND());
333 char* zStr = (char*)sStr.c_str();
334
335 for ( ; *zStr; zStr++ )
336 {
337 //
338 // this will replace \r\n with just \n
339 //
340 if (*zStr == '\n')
341 *zStr = '\0';
342 if (*zStr == '\r')
343 *zStr = '\n';
344 }
345 return sStr;
346} // end of wxTextCtrl::GetValue
347
348void wxTextCtrl::SetValue(
349 const wxString& rsValue
350)
351{
352 //
353 // If the text is long enough, it's faster to just set it instead of first
354 // comparing it with the old one (chances are that it will be different
355 // anyhow, this comparison is there to avoid flicker for small single-line
356 // edit controls mostly)
357 //
358 if ((rsValue.length() > 0x400) || (rsValue != GetValue()))
359 {
360 ::WinSetWindowText(GetHwnd(), rsValue.c_str());
361 AdjustSpaceLimit();
362 }
363} // end of wxTextCtrl::SetValue
364
365void wxTextCtrl::WriteText(
366 const wxString& rsValue
367)
368{
369 if (m_bIsMLE)
370 ::WinSendMsg(GetHwnd(), MLM_INSERT, MPARAM((PCHAR)rsValue.c_str()), MPARAM(0));
371 else
372 ::WinSetWindowText(GetHwnd(), rsValue.c_str());
373 AdjustSpaceLimit();
374} // end of wxTextCtrl::WriteText
375
376void wxTextCtrl::AppendText(
377 const wxString& rsText
378)
379{
380 SetInsertionPointEnd();
381 WriteText(rsText);
382} // end of wxTextCtrl::AppendText
383
384void wxTextCtrl::Clear()
385{
386 ::WinSetWindowText(GetHwnd(), "");
387} // end of wxTextCtrl::Clear
388
389bool wxTextCtrl::EmulateKeyPress(
390 const wxKeyEvent& rEvent
391)
392{
393 SetFocus();
394 return(wxTextCtrlBase::EmulateKeyPress(rEvent));
395} // end of wxTextCtrl::EmulateKeyPress
396
397// ----------------------------------------------------------------------------
398// Clipboard operations
399// ----------------------------------------------------------------------------
400
401void wxTextCtrl::Copy()
402{
403 if (CanCopy())
404 {
405 HWND hWnd = GetHwnd();
406 if (m_bIsMLE)
407 ::WinSendMsg(hWnd, MLM_COPY, 0, 0);
408 else
409 ::WinSendMsg(hWnd, EM_COPY, 0, 0);
410 }
411} // end of wxTextCtrl::Copy
412
413void wxTextCtrl::Cut()
414{
415 if (CanCut())
416 {
417 HWND hWnd = GetHwnd();
418
419 if (m_bIsMLE)
420 ::WinSendMsg(hWnd, MLM_CUT, 0, 0);
421 else
422 ::WinSendMsg(hWnd, EM_CUT, 0, 0);
423 }
424} // end of wxTextCtrl::Cut
425
426void wxTextCtrl::Paste()
427{
428 if (CanPaste())
429 {
430 HWND hWnd = GetHwnd();
431
432 ::WinSendMsg(hWnd, EM_PASTE, 0, 0);
433 }
434} // end of wxTextCtrl::Paste
435
436bool wxTextCtrl::CanCopy() const
437{
438 //
439 // Can copy if there's a selection
440 //
441 long lFrom = 0L;
442 long lTo = 0L;
443
444 GetSelection(&lFrom, &lTo);
445 return (lFrom != lTo);
446} // end of wxTextCtrl::CanCopy
447
448bool wxTextCtrl::CanCut() const
449{
450 //
451 // Can cut if there's a selection
452 //
453 long lFrom = 0L;
454 long lTo = 0L;
455
456 GetSelection(&lFrom, &lTo);
457 return (lFrom != lTo);
458} // end of wxTextCtrl::CanCut
459
460bool wxTextCtrl::CanPaste() const
461{
462 bool bIsTextAvailable = FALSE;
463
464 if (!IsEditable())
465 return FALSE;
466
467 //
468 // Check for straight text on clipboard
469 //
470 if (::WinOpenClipbrd(vHabmain))
471 {
472 bIsTextAvailable = (::WinQueryClipbrdData(vHabmain, CF_TEXT) != 0);
473 ::WinCloseClipbrd(vHabmain);
474 }
475 return bIsTextAvailable;
476} // end of wxTextCtrl::CanPaste
477
478// ----------------------------------------------------------------------------
479// Accessors
480// ----------------------------------------------------------------------------
481
482void wxTextCtrl::SetEditable(
483 bool bEditable
484)
485{
486 HWND hWnd = GetHwnd();
487
488 if (m_bIsMLE)
489 ::WinSendMsg(hWnd, MLM_SETREADONLY, MPFROMLONG(!bEditable), (MPARAM)0);
490 else
491 ::WinSendMsg(hWnd, EM_SETREADONLY, MPFROMLONG(!bEditable), (MPARAM)0);
492} // end of wxTextCtrl::SetEditable
493
494void wxTextCtrl::SetInsertionPoint(
495 long lPos
496)
497{
498 HWND hWnd = GetHwnd();
499
500 if (m_bIsMLE)
501 ::WinSendMsg(hWnd, MLM_SETSEL, (MPARAM)lPos, (MPARAM)lPos);
502 else
503 ::WinSendMsg(hWnd, EM_SETSEL, MPFROM2SHORT((USHORT)lPos, (USHORT)lPos), (MPARAM)0);
504} // end of wxTextCtrl::SetInsertionPoint
505
506void wxTextCtrl::SetInsertionPointEnd()
507{
508 long lPos = GetLastPosition();
509
510 SetInsertionPoint(lPos);
511} // end of wxTextCtrl::SetInsertionPointEnd
512
513long wxTextCtrl::GetInsertionPoint() const
514{
515 WXDWORD dwPos = 0L;
516
517 if (m_bIsMLE)
518 dwPos = (WXDWORD)::WinSendMsg(GetHwnd(), MLM_QUERYSEL, (MPARAM)MLFQS_MINSEL, 0);
519 else
520 {
521 dwPos = (WXDWORD)::WinSendMsg(GetHwnd(), EM_QUERYSEL, 0, 0);
522 dwPos = SHORT1FROMMP((MPARAM)dwPos); // the first 16 bit value is the min pos
523 }
524 return (dwPos & 0xFFFF);
525} // end of wxTextCtrl::GetInsertionPoint
526
527long wxTextCtrl::GetLastPosition() const
528{
529 HWND hWnd = GetHwnd();
530 long lCharIndex;
531 long lLineLength;
532
533 if (m_bIsMLE)
534 {
535 lCharIndex = 0;
536
537 //
538 // This just gets the total text length. The last will be this value
539 //
540 lLineLength = (long)::WinSendMsg(hWnd, MLM_QUERYTEXTLENGTH, 0, 0);
541 }
542 else
543 {
544 WNDPARAMS vParams;
545
546 lCharIndex = 0;
547 vParams.fsStatus = WPM_CCHTEXT;
548 if (::WinSendMsg( GetHwnd()
549 ,WM_QUERYWINDOWPARAMS
550 ,&vParams
551 ,0
552 ))
553 {
554 lLineLength = (long)vParams.cchText;
555 }
556 else
557 lLineLength = 0;
558 }
559 return(lCharIndex + lLineLength);
560} // end of wxTextCtrl::GetLastPosition
561
562// If the return values from and to are the same, there is no
563// selection.
564void wxTextCtrl::GetSelection(
565 long* plFrom
566, long* plTo
567) const
568{
569 WXDWORD dwPos;
570
571 if (m_bIsMLE)
572 dwPos = (WXDWORD)::WinSendMsg(GetHwnd(), MLM_QUERYSEL, (MPARAM)MLFQS_MINSEL, 0);
573 else
574 {
575 dwPos = (WXDWORD)::WinSendMsg(GetHwnd(), EM_QUERYSEL, 0, 0);
576 }
577 *plFrom = SHORT1FROMMP((MPARAM)dwPos); // the first 16 bit value is the min pos
578 *plTo = SHORT2FROMMP((MPARAM)dwPos); // the first 16 bit value is the min pos
579} // end of wxTextCtrl::GetSelection
580
581bool wxTextCtrl::IsEditable() const
582{
583 if (m_bIsMLE)
584 return((bool)LONGFROMMR(::WinSendMsg(GetHwnd(), MLM_QUERYREADONLY, 0, 0)));
585 else
586 return((bool)LONGFROMMR(::WinSendMsg(GetHwnd(), EM_QUERYREADONLY, 0, 0)));
587} // end of wxTextCtrl::IsEditable
588
589// ----------------------------------------------------------------------------
590// Editing
591// ----------------------------------------------------------------------------
592
593void wxTextCtrl::Replace(
594 long lFrom
595, long lTo
596, const wxString& rsValue
597)
598{
599#if wxUSE_CLIPBOARD
600 HWND hWnd = GetHwnd();
601 long lFromChar = lFrom;
602 long lToChar = lTo;
603
604 //
605 // Set selection and remove it
606 //
607 if (m_bIsMLE)
608 {
609 ::WinSendMsg(hWnd, MLM_SETSEL, MPFROM2SHORT((USHORT)lFrom, (USHORT)lTo), 0);
610 ::WinSendMsg(hWnd, MLM_CUT, 0, 0);
611 }
612 else
613 {
614 ::WinSendMsg(hWnd, EM_SETSEL, MPFROM2SHORT((USHORT)lFrom, (USHORT)lTo), 0);
615 ::WinSendMsg(hWnd, EM_CUT, 0, 0);
616 }
617
618 //
619 // Now replace with 'value', by pasting.
620 //
621 wxSetClipboardData(wxDF_TEXT, (wxObject *) (const wxChar *)rsValue, 0, 0);
622
623 // Paste into edit control
624 if (m_bIsMLE)
625 ::WinSendMsg(hWnd, MLM_PASTE, (MPARAM)0, (MPARAM)0);
626 else
627 ::WinSendMsg(hWnd, EM_PASTE, (MPARAM)0, (MPARAM)0);
628#else
629 wxFAIL_MSG("wxTextCtrl::Replace not implemented if wxUSE_CLIPBOARD is 0.");
630#endif
631} // end of wxTextCtrl::Replace
632
633void wxTextCtrl::Remove(
634 long lFrom
635, long lTo
636)
637{
638 HWND hWnd = GetHwnd();
639 long lFromChar = lFrom;
640 long lToChar = lTo;
641
642 if (m_bIsMLE)
643 {
644 ::WinSendMsg(hWnd, MLM_SETSEL, MPFROM2SHORT((USHORT)lFrom, (USHORT)lTo), 0);
645 ::WinSendMsg(hWnd, MLM_CUT, 0, 0);
646 }
647 else
648 {
649 ::WinSendMsg(hWnd, EM_SETSEL, MPFROM2SHORT((USHORT)lFrom, (USHORT)lTo), 0);
650 ::WinSendMsg(hWnd, EM_CUT, 0, 0);
651 }
652} // end of wxTextCtrl::Remove
653
654void wxTextCtrl::SetSelection(
655 long lFrom
656, long lTo
657)
658{
659 HWND hWnd = GetHwnd();
660 long lFromChar = lFrom;
661 long lToChar = lTo;
662
663 //
664 // If from and to are both -1, it means (in wxWindows) that all text should
665 // be selected. Translate into Windows convention
666 //
667 if ((lFrom == -1L) && (lTo == -1L))
668 {
669 lFromChar = 0L;
670 lToChar = -1L;
671 }
672 if (m_bIsMLE)
673 ::WinSendMsg(hWnd, MLM_SETSEL, (MPARAM)lFromChar, (MPARAM)lToChar);
674 else
675 ::WinSendMsg(hWnd, EM_SETSEL, MPFROM2SHORT((USHORT)lFromChar, (USHORT)lToChar), (MPARAM)0);
676} // end of wxTextCtrl::SetSelection
677
678bool wxTextCtrl::LoadFile(
679 const wxString& rsFile
680)
681{
682 if ( wxTextCtrlBase::LoadFile(rsFile) )
683 {
684 //
685 // Update the size limit if needed
686 //
687 AdjustSpaceLimit();
688 return TRUE;
689 }
690 return FALSE;
691} // end of wxTextCtrl::LoadFile
692
693bool wxTextCtrl::IsModified() const
694{
695 bool bRc;
696
697 if (m_bIsMLE)
698 bRc = (bool)LONGFROMMR(::WinSendMsg(GetHwnd(), MLM_QUERYCHANGED, 0, 0));
699 else
700 bRc = (bool)LONGFROMMR(::WinSendMsg(GetHwnd(), EM_QUERYCHANGED, 0, 0));
701 return bRc;
702} // end of wxTextCtrl::IsModified
703
704//
705// Makes 'unmodified'
706//
707void wxTextCtrl::DiscardEdits()
708{
709 if (m_bIsMLE)
710 ::WinSendMsg(GetHwnd(), MLM_SETCHANGED, MPFROMLONG(FALSE), 0);
711 else
712 //
713 // EM controls do not have a SETCHANGED but issuing a query should reset it
714 //
715 ::WinSendMsg(GetHwnd(), EM_QUERYCHANGED, 0, 0);
716} // end of wxTextCtrl::DiscardEdits
717
718int wxTextCtrl::GetNumberOfLines() const
719{
720 int nNumLines;
721
722 if (m_bIsMLE)
723 nNumLines = (int)::WinSendMsg(GetHwnd(), MLM_QUERYLINECOUNT, 0, 0);
724 else
725 nNumLines = 1;
726 return nNumLines;
727} // end of wxTextCtrl::GetNumberOfLines
728
729long wxTextCtrl::XYToPosition(
730 long lX
731, long lY
732) const
733{
734 HWND hWnd = GetHwnd();
735 long lCharIndex = 0L;
736 long lLen;
737
738 if (m_bIsMLE)
739 {
740 lLen = (long)::WinSendMsg(GetHwnd(), MLM_QUERYLINELENGTH, 0, 0);
741 lCharIndex = ((lLen * lY) + lX);
742 }
743 else
744 lCharIndex = lX;
745 return lCharIndex;
746} // end of wxTextCtrl::XYToPosition
747
748bool wxTextCtrl::PositionToXY(
749 long lPos
750, long* plX
751, long* plY
752) const
753{
754 HWND hWnd = GetHwnd();
755 long nLineNo = -1;
756 long lCharIndex = 0;
757
758 if (m_bIsMLE)
759 nLineNo = (long)::WinSendMsg(hWnd, MLM_LINEFROMCHAR, (MPARAM)lPos, 0);
760 else
761 nLineNo = 0;
762
763 if (nLineNo == -1)
764 {
765 // no such line
766 return FALSE;
767 }
768
769 //
770 // This gets the char index for the _beginning_ of this line
771 //
772 long lLineWidth;
773
774 if (m_bIsMLE)
775 {
776 lLineWidth = (long)::WinSendMsg(hWnd, MLM_QUERYLINELENGTH, (MPARAM)0, (MPARAM)0);
777 lCharIndex = (nLineNo + 1) * lLineWidth;
778 }
779 else
780 {
781 WNDPARAMS vParams;
782
783 vParams.fsStatus = WPM_CCHTEXT;
784 if (::WinSendMsg( hWnd
785 ,WM_QUERYWINDOWPARAMS
786 ,&vParams
787 ,0
788 ))
789 {
790 lCharIndex = vParams.cchText;
791 }
792 else
793 lCharIndex = 32;
794 }
795
796 if (lCharIndex == -1)
797 {
798 return FALSE;
799 }
800
801 //
802 // The X position must therefore be the difference between pos and charIndex
803 //
804 if (plX)
805 *plX = lPos - lCharIndex;
806 if (plY)
807 *plY = nLineNo;
808
809 return TRUE;
810} // end of wxTextCtrl::PositionToXY
811
812void wxTextCtrl::ShowPosition(
813 long lPos
814)
815{
816 HWND hWnd = GetHwnd();
817 long lCurrentLineLineNo = 0L;
818
819 // To scroll to a position, we pass the number of lines and characters
820 // to scroll *by*. This means that we need to:
821 // (1) Find the line position of the current line.
822 // (2) Find the line position of pos.
823 // (3) Scroll by (pos - current).
824 // For now, ignore the horizontal scrolling.
825
826 //
827 // Is this where scrolling is relative to - the line containing the caret?
828 // Or is the first visible line??? Try first visible line.
829 //
830 if (m_bIsMLE)
831 {
832 //
833 // In PM this is the actual char position
834 //
835 lCurrentLineLineNo = (long)::WinSendMsg(hWnd, MLM_QUERYFIRSTCHAR, (MPARAM)0, (MPARAM)0);
836
837 //
838 // This will cause a scroll to the selected position
839 //
840 ::WinSendMsg(hWnd, MLM_SETSEL, (MPARAM)lCurrentLineLineNo, (MPARAM)lCurrentLineLineNo);
841 }
842} // end of wxTextCtrl::ShowPosition
843
844int wxTextCtrl::GetLineLength(
845 long lLineNo
846) const
847{
848 long lLen = 0L;
849
850 if (m_bIsMLE)
851 lLen = (long)::WinSendMsg(GetHwnd(), MLM_QUERYLINELENGTH, 0, 0);
852 else
853 {
854 WNDPARAMS vParams;
855
856 vParams.fsStatus = WPM_CCHTEXT;
857 if (::WinSendMsg( GetHwnd()
858 ,WM_QUERYWINDOWPARAMS
859 ,&vParams
860 ,0
861 ))
862 {
863 lLen = vParams.cchText;
864 }
865 else
866 lLen = 32;
867 }
868 return lLen;
869} // end ofwxTextCtrl::GetLineLength
870
871wxString wxTextCtrl::GetLineText(
872 long lLineNo
873) const
874{
875 long lLen = (long)GetLineLength((long)lLineNo) + 1;
876 wxString sStr;
877 char* zBuf;
878
879 //
880 // There must be at least enough place for the length WORD in the
881 // buffer
882 //
883 lLen += sizeof(WORD);
884 zBuf = new char[lLen];
885 if (m_bIsMLE)
886 {
887 long lIndex;
888 long lBuflen;
889 long lCopied;
890
891 lLen = (long)::WinSendMsg(GetHwnd(), MLM_QUERYLINELENGTH, 0, 0);
892 lIndex = lLen * lLineNo;
893
894 ::WinSendMsg(GetHwnd(), MLM_SETSEL, (MPARAM)lIndex, (MPARAM)lIndex);
895 ::WinSendMsg(GetHwnd(), MLM_SETIMPORTEXPORT, MPFROMP(zBuf), MPFROMSHORT((USHORT)sizeof(zBuf)));
896 lBuflen = (long)::WinSendMsg(GetHwnd(), MLM_QUERYFORMATTEXTLENGTH, MPFROMLONG(lIndex), MPFROMLONG(-1));
897 lCopied = (long)::WinSendMsg(GetHwnd(), MLM_EXPORT, MPFROMP(&lIndex), MPFROMP(&lBuflen));
898 zBuf[lCopied] = '\0';
899 }
900 else
901 {
902 WNDPARAMS vParams;
903
904 vParams.fsStatus = WPM_CCHTEXT;
905 if (::WinSendMsg( GetHwnd()
906 ,WM_QUERYWINDOWPARAMS
907 ,&vParams
908 ,0
909 ))
910 memcpy(zBuf, vParams.pszText, vParams.cchText);
911 zBuf[vParams.cchText] = '\0';
912 }
913 sStr = zBuf;
914 delete [] zBuf;
915 return sStr;
916} // end of wxTextCtrl::GetLineText
917
918// ----------------------------------------------------------------------------
919// Undo/redo
920// ----------------------------------------------------------------------------
921
922void wxTextCtrl::Undo()
923{
924 if (CanUndo())
925 {
926 if (m_bIsMLE)
927 ::WinSendMsg(GetHwnd(), MLM_UNDO, 0, 0);
928 // Simple entryfields cannot be undone
929 }
930} // end of wxTextCtrl::Undo
931
932void wxTextCtrl::Redo()
933{
934 if (CanRedo())
935 {
936 if (m_bIsMLE)
937 ::WinSendMsg(GetHwnd(), MLM_UNDO, 0, 0);
938 // Simple entryfields cannot be undone
939 }
940} // end of wxTextCtrl::Redo
941
942bool wxTextCtrl::CanUndo() const
943{
944 bool bOk;
945
946 if (m_bIsMLE)
947 bOk = (::WinSendMsg(GetHwnd(), MLM_QUERYUNDO, 0, 0) != 0);
948 else
949 bOk = FALSE; // can't undo regular edit fields in PM
950 return bOk;
951} // end of wxTextCtrl::CanUndo
952
953bool wxTextCtrl::CanRedo() const
954{
955 bool bOk;
956
957 if (m_bIsMLE)
958 bOk = (::WinSendMsg(GetHwnd(), MLM_QUERYUNDO, 0, 0) != 0);
959 else
960 bOk = FALSE; // can't undo regular edit fields in PM
961 return bOk;
962} // end of wxTextCtrl::CanRedo
963
964// ----------------------------------------------------------------------------
965// implemenation details
966// ----------------------------------------------------------------------------
967
968void wxTextCtrl::Command(
969 wxCommandEvent& rEvent
970)
971{
972 SetValue(rEvent.GetString());
973 ProcessCommand (rEvent);
974} // end of wxTextCtrl::Command
975
976void wxTextCtrl::OnDropFiles(
977 wxDropFilesEvent& rEvent
978)
979{
980 // By default, load the first file into the text window.
981 if (rEvent.GetNumberOfFiles() > 0)
982 {
983 LoadFile(rEvent.GetFiles()[0]);
984 }
985} // end of wxTextCtrl::OnDropFiles
986
987WXHBRUSH wxTextCtrl::OnCtlColor(
988 WXHDC hWxDC
989, WXHWND hWnd
990, WXUINT uCtlColor
991, WXUINT uMessage
992, WXWPARAM wParam
993, WXLPARAM lParam
994)
995{
996 HPS hPS = (HPS)hWxDC;
997 wxBrush* pBrush = NULL;
998 wxColour vColBack = GetBackgroundColour();
999 wxColour vColFore = GetForegroundColour();
1000 wxBrush* pBackgroundBrush = wxTheBrushList->FindOrCreateBrush( GetBackgroundColour()
1001 ,wxSOLID
1002 );
1003
1004 if (m_bUseCtl3D)
1005 {
1006 HBRUSH hBrush = NULLHANDLE;
1007
1008 return hBrush;
1009 }
1010 if (GetParent()->GetTransparentBackground())
1011 ::GpiSetBackMix(hPS, BM_LEAVEALONE);
1012 else
1013 ::GpiSetBackMix(hPS, BM_OVERPAINT);
1014 if (!IsEnabled() && (GetWindowStyle() & wxTE_MULTILINE) == 0)
1015 vColBack = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
1016 ::GpiSetBackColor(hPS, vColBack.GetPixel());
1017 ::GpiSetColor(hPS, vColFore.GetPixel());
1018 return (WXHBRUSH)pBackgroundBrush->GetResourceHandle();
1019} // end of wxTextCtrl::OnCtlColor
1020
1021bool wxTextCtrl::OS2ShouldPreProcessMessage(
1022 WXMSG* pMsg
1023)
1024{
1025 return wxControl::OS2ShouldPreProcessMessage(pMsg);
1026} // end of wxTextCtrl::OS2ShouldPreProcessMessage
1027
1028void wxTextCtrl::OnChar(
1029 wxKeyEvent& rEvent
1030)
1031{
1032 switch (rEvent.KeyCode())
1033 {
1034 case WXK_RETURN:
1035 if ( !(m_windowStyle & wxTE_MULTILINE) )
1036 {
1037 wxCommandEvent vEvent(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
1038
1039 vEvent.SetEventObject(this);
1040 if ( GetEventHandler()->ProcessEvent(vEvent))
1041 return;
1042 }
1043 //else: multiline controls need Enter for themselves
1044
1045 break;
1046
1047 case WXK_TAB:
1048 // always produce navigation event - even if we process TAB
1049 // ourselves the fact that we got here means that the user code
1050 // decided to skip processing of this TAB - probably to let it
1051 // do its default job.
1052 //
1053 // NB: Notice that Ctrl-Tab is handled elsewhere and Alt-Tab is
1054 // handled by Windows
1055 {
1056 wxNavigationKeyEvent vEventNav;
1057
1058 vEventNav.SetDirection(!rEvent.ShiftDown());
1059 vEventNav.SetWindowChange(FALSE);
1060 vEventNav.SetEventObject(this);
1061
1062 if ( GetEventHandler()->ProcessEvent(vEventNav) )
1063 return;
1064 }
1065 break;
1066 }
1067 rEvent.Skip();
1068} // end of wxTextCtrl::OnChar
1069
1070bool wxTextCtrl::OS2Command(
1071 WXUINT uParam
1072, WXWORD WXUNUSED(vId)
1073)
1074{
1075 switch (uParam)
1076 {
1077 case EN_SETFOCUS:
1078 case EN_KILLFOCUS:
1079 {
1080 wxFocusEvent vEvent( uParam == EN_KILLFOCUS ? wxEVT_KILL_FOCUS
1081 : wxEVT_SET_FOCUS
1082 ,m_windowId
1083 );
1084
1085 vEvent.SetEventObject(this);
1086 GetEventHandler()->ProcessEvent(vEvent);
1087 }
1088 break;
1089
1090 case EN_CHANGE:
1091 {
1092 wxCommandEvent vEvent( wxEVT_COMMAND_TEXT_UPDATED
1093 ,m_windowId
1094 );
1095
1096 InitCommandEvent(vEvent);
1097 vEvent.SetString((char*)GetValue().c_str());
1098 ProcessCommand(vEvent);
1099 }
1100 break;
1101
1102 case EN_OVERFLOW:
1103 //
1104 // The text size limit has been hit - increase it
1105 //
1106 AdjustSpaceLimit();
1107 break;
1108
1109 case EN_SCROLL:
1110 case EN_INSERTMODETOGGLE:
1111 case EN_MEMERROR:
1112 return FALSE;
1113 default:
1114 return FALSE;
1115 }
1116
1117 //
1118 // Processed
1119 //
1120 return TRUE;
1121} // end of wxTextCtrl::OS2Command
1122
1123void wxTextCtrl::AdjustSpaceLimit()
1124{
1125 unsigned int uLen = 0;
1126 unsigned int uLimit = 0;
1127
1128 uLen = ::WinQueryWindowTextLength(GetHwnd());
1129 if (m_bIsMLE)
1130 {
1131 uLimit = (unsigned int)::WinSendMsg( GetHwnd()
1132 ,MLM_QUERYTEXTLIMIT
1133 ,0
1134 ,0
1135 );
1136 }
1137 else
1138 {
1139 ENTRYFDATA* pEfd;
1140 WNDPARAMS vParams;
1141
1142 vParams.fsStatus = WPM_CBCTLDATA;
1143 vParams.cbCtlData = sizeof(ENTRYFDATA);
1144
1145 if (::WinSendMsg( GetHwnd()
1146 ,WM_QUERYWINDOWPARAMS
1147 ,&vParams
1148 ,0
1149 ))
1150 {
1151 pEfd = (ENTRYFDATA*)vParams.pCtlData;
1152 uLimit = (unsigned int)pEfd->cchEditLimit;
1153 }
1154 else
1155 uLimit = 32; //PM's default
1156 }
1157 if (uLen >= uLimit)
1158 {
1159 uLimit = uLen + 0x8000; // 32Kb
1160 if (uLimit > 0xffff)
1161 {
1162 uLimit = 0L;
1163 }
1164 if (m_bIsMLE)
1165 ::WinSendMsg(GetHwnd(), MLM_SETTEXTLIMIT, MPFROMLONG(uLimit), 0);
1166 else
1167 ::WinSendMsg(GetHwnd(), EM_SETTEXTLIMIT, MPFROMLONG(uLimit), 0);
1168 }
1169} // end of wxTextCtrl::AdjustSpaceLimit
1170
1171bool wxTextCtrl::AcceptsFocus() const
1172{
1173 //
1174 // We don't want focus if we can't be edited unless we're a multiline
1175 // control because then it might be still nice to get focus from keyboard
1176 // to be able to scroll it without mouse
1177 //
1178 return (IsEditable() || IsMultiLine()) && wxControl::AcceptsFocus();
1179} // end of wxTextCtrl::Command
1180
1181wxSize wxTextCtrl::DoGetBestSize() const
1182{
1183 int nCx;
1184 int nCy;
1185
1186 wxGetCharSize(GetHWND(), &nCx, &nCy, (wxFont*)&GetFont());
1187
1188 int wText = DEFAULT_ITEM_WIDTH;
1189 int hText = (EDIT_HEIGHT_FROM_CHAR_HEIGHT(nCy) * .8);
1190
1191 if (m_windowStyle & wxTE_MULTILINE)
1192 {
1193 hText *= wxMax(GetNumberOfLines(), 5);
1194 }
1195 //else: for single line control everything is ok
1196 return wxSize(wText, hText);
1197} // end of wxTextCtrl::DoGetBestSize
1198
1199// ----------------------------------------------------------------------------
1200// standard handlers for standard edit menu events
1201// ----------------------------------------------------------------------------
1202
1203void wxTextCtrl::OnCut(
1204 wxCommandEvent& rEvent
1205)
1206{
1207 Cut();
1208} // end of wxTextCtrl::OnCut
1209
1210void wxTextCtrl::OnCopy(
1211 wxCommandEvent& rEvent
1212)
1213{
1214 Copy();
1215} // end of wxTextCtrl::OnCopy
1216
1217void wxTextCtrl::OnPaste(
1218 wxCommandEvent& rEvent
1219)
1220{
1221 Paste();
1222} // end of wxTextCtrl::OnPaste
1223
1224void wxTextCtrl::OnUndo(
1225 wxCommandEvent& rEvent
1226)
1227{
1228 Undo();
1229} // end of wxTextCtrl::OnUndo
1230
1231void wxTextCtrl::OnRedo(
1232 wxCommandEvent& rEvent
1233)
1234{
1235 Redo();
1236} // end of wxTextCtrl::OnRedo
1237
1238void wxTextCtrl::OnDelete(
1239 wxCommandEvent& rEvent
1240)
1241{
1242 long lFrom;
1243 long lTo;
1244
1245 GetSelection( &lFrom
1246 ,&lTo
1247 );
1248 if (lFrom != -1 && lTo != -1)
1249 Remove( lFrom
1250 ,lTo
1251 );
1252} // end of wxTextCtrl::OnDelete
1253
1254void wxTextCtrl::OnSelectAll(
1255 wxCommandEvent& rEvent
1256)
1257{
1258 SetSelection(-1, -1);
1259} // end of wxTextCtrl::OnSelectAll
1260
1261void wxTextCtrl::OnUpdateCut(
1262 wxUpdateUIEvent& rEvent
1263)
1264{
1265 rEvent.Enable(CanCut());
1266} // end of wxTextCtrl::OnUpdateCut
1267
1268void wxTextCtrl::OnUpdateCopy(
1269 wxUpdateUIEvent& rEvent
1270)
1271{
1272 rEvent.Enable(CanCopy());
1273} // end of wxTextCtrl::OnUpdateCopy
1274
1275void wxTextCtrl::OnUpdatePaste(
1276 wxUpdateUIEvent& rEvent
1277)
1278{
1279 rEvent.Enable(CanPaste());
1280} // end of wxTextCtrl::OnUpdatePaste
1281
1282void wxTextCtrl::OnUpdateUndo(
1283 wxUpdateUIEvent& rEvent
1284)
1285{
1286 rEvent.Enable(CanUndo());
1287} // end of wxTextCtrl::OnUpdateUndo
1288
1289void wxTextCtrl::OnUpdateRedo(
1290 wxUpdateUIEvent& rEvent
1291)
1292{
1293 rEvent.Enable(CanRedo());
1294} // end of wxTextCtrl::OnUpdateRedo
1295
1296void wxTextCtrl::OnUpdateDelete(
1297 wxUpdateUIEvent& rEvent
1298)
1299{
1300 long lFrom;
1301 long lTo;
1302
1303 GetSelection( &lFrom
1304 ,&lTo
1305 );
1306 rEvent.Enable( lFrom != -1L && lTo != -1L && lFrom != lTo && IsEditable()) ;
1307} // end of wxTextCtrl::OnUpdateDelete
1308
1309void wxTextCtrl::OnUpdateSelectAll(
1310 wxUpdateUIEvent& rEvent
1311)
1312{
1313 rEvent.Enable(GetLastPosition() > 0);
1314} // end of wxTextCtrl::OnUpdateSelectAll
1315
1316bool wxTextCtrl::SetBackgroundColour(
1317 const wxColour& rColour
1318)
1319{
1320 if (m_bIsMLE)
1321 ::WinSendMsg(GetHwnd(), MLM_SETBACKCOLOR, (MPARAM)rColour.GetPixel(), MLE_INDEX);
1322 return TRUE;
1323} // end of wxTextCtrl::SetBackgroundColour
1324
1325bool wxTextCtrl::SetForegroundColour(
1326 const wxColour& rColour
1327)
1328{
1329 if (m_bIsMLE)
1330 ::WinSendMsg(GetHwnd(), MLM_SETTEXTCOLOR, (MPARAM)rColour.GetPixel(), MLE_INDEX);
1331 return TRUE;
1332} // end of wxTextCtrl::SetForegroundColour
1333
1334bool wxTextCtrl::SetStyle(
1335 long lStart
1336, long lEnd
1337, const wxTextAttr& rStyle
1338)
1339{
1340 HWND hWnd = GetHwnd();
1341
1342 if (lStart > lEnd)
1343 {
1344 long lTmp = lStart;
1345
1346 lStart = lEnd;
1347 lEnd = lTmp;
1348 }
1349
1350 //
1351 // We can only change the format of the selection, so select the range we
1352 // want and restore the old selection later
1353 //
1354 long lStartOld;
1355 long lEndOld;
1356
1357 GetSelection( &lStartOld
1358 ,&lEndOld
1359 );
1360
1361 //
1362 // But do we really have to change the selection?
1363 //
1364 bool bChangeSel = lStart != lStartOld ||
1365 lEnd != lEndOld;
1366
1367 if (bChangeSel)
1368 {
1369 if (m_bIsMLE)
1370 ::WinSendMsg(hWnd, MLM_SETSEL, MPFROM2SHORT((USHORT)lStart, (USHORT)lEnd), 0);
1371 else
1372 ::WinSendMsg(hWnd, EM_SETSEL, MPFROM2SHORT((USHORT)lStart, (USHORT)lEnd), 0);
1373 }
1374
1375 //
1376 // TODO:: finish this part
1377 //
1378 return TRUE;
1379} // end of wxTextCtrl::SetStyle
1380
wxWidgets (Impactor)