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