]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: textctrl.cpp | |
3 | // Purpose: wxTextCtrl | |
4 | // Author: Julian Smart | |
5 | // Modified by: | |
6 | // Created: 04/01/98 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) Julian Smart and Markus Holzem | |
9 | // Licence: wxWindows license | |
10 | ///////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | #ifdef __GNUG__ | |
13 | #pragma implementation "textctrl.h" | |
14 | #endif | |
15 | ||
16 | // For compilers that support precompilation, includes "wx.h". | |
17 | #include "wx/wxprec.h" | |
18 | ||
19 | #ifdef __BORLANDC__ | |
20 | #pragma hdrstop | |
21 | #endif | |
22 | ||
23 | #ifndef WX_PRECOMP | |
24 | #include "wx/textctrl.h" | |
25 | #include "wx/settings.h" | |
26 | #include "wx/brush.h" | |
27 | #include "wx/utils.h" | |
28 | #include "wx/log.h" | |
29 | #endif | |
30 | ||
31 | #if wxUSE_CLIPBOARD | |
32 | #include "wx/app.h" | |
33 | #include "wx/clipbrd.h" | |
34 | #endif | |
35 | ||
36 | #include "wx/msw/private.h" | |
37 | ||
38 | #include <windows.h> | |
39 | #include <stdlib.h> | |
40 | ||
41 | #if wxUSE_IOSTREAMH | |
42 | # include <fstream.h> | |
43 | #else | |
44 | # include <fstream> | |
45 | #endif | |
46 | ||
47 | #include <sys/types.h> | |
48 | #ifndef __MWERKS__ | |
49 | #include <sys/stat.h> | |
50 | #else | |
51 | #include <stat.h> | |
52 | #endif | |
53 | #if defined(__BORLANDC__) && !defined(__WIN32__) | |
54 | #include <alloc.h> | |
55 | #else | |
56 | #if !defined(__GNUWIN32__) && !defined(__SALFORDC__) | |
57 | #include <malloc.h> | |
58 | #endif | |
59 | #define farmalloc malloc | |
60 | #define farfree free | |
61 | #endif | |
62 | #include <windowsx.h> | |
63 | ||
64 | #include <string.h> | |
65 | ||
66 | #if wxUSE_RICHEDIT && !defined(__GNUWIN32__) | |
67 | #include <richedit.h> | |
68 | #endif | |
69 | ||
70 | #if !USE_SHARED_LIBRARY | |
71 | IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl) | |
72 | ||
73 | BEGIN_EVENT_TABLE(wxTextCtrl, wxControl) | |
74 | EVT_CHAR(wxTextCtrl::OnChar) | |
75 | EVT_DROP_FILES(wxTextCtrl::OnDropFiles) | |
76 | EVT_ERASE_BACKGROUND(wxTextCtrl::OnEraseBackground) | |
77 | END_EVENT_TABLE() | |
78 | #endif // USE_SHARED_LIBRARY | |
79 | ||
80 | // Text item | |
81 | wxTextCtrl::wxTextCtrl() | |
82 | #ifndef NO_TEXT_WINDOW_STREAM | |
83 | : streambuf() | |
84 | #endif | |
85 | { | |
86 | #if wxUSE_RICHEDIT | |
87 | m_isRich = FALSE; | |
88 | #endif | |
89 | } | |
90 | ||
91 | bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id, | |
92 | const wxString& value, | |
93 | const wxPoint& pos, | |
94 | const wxSize& size, long style, | |
95 | const wxValidator& validator, | |
96 | const wxString& name) | |
97 | { | |
98 | SetName(name); | |
99 | SetValidator(validator); | |
100 | if (parent) parent->AddChild(this); | |
101 | ||
102 | m_windowStyle = style; | |
103 | ||
104 | // Should this be taken from the system colours? | |
105 | // SetBackgroundColour(wxColour(255, 255, 255)); | |
106 | ||
107 | SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW)); | |
108 | ||
109 | SetForegroundColour(parent->GetForegroundColour()) ; | |
110 | ||
111 | if ( id == -1 ) | |
112 | m_windowId = (int)NewControlId(); | |
113 | else | |
114 | m_windowId = id; | |
115 | ||
116 | int x = pos.x; | |
117 | int y = pos.y; | |
118 | int width = size.x; | |
119 | int height = size.y; | |
120 | ||
121 | long msStyle = ES_LEFT | WS_VISIBLE | WS_CHILD | WS_TABSTOP; | |
122 | if (m_windowStyle & wxTE_MULTILINE) | |
123 | { | |
124 | wxASSERT_MSG( !(m_windowStyle & wxTE_PROCESS_ENTER), | |
125 | "wxTE_PROCESS_ENTER style is ignored for multiline controls" ); | |
126 | ||
127 | msStyle |= ES_MULTILINE | ES_WANTRETURN | WS_VSCROLL ; // WS_BORDER | |
128 | m_windowStyle |= wxTE_PROCESS_ENTER; | |
129 | } | |
130 | else | |
131 | msStyle |= ES_AUTOHSCROLL ; | |
132 | ||
133 | if (m_windowStyle & wxTE_READONLY) | |
134 | msStyle |= ES_READONLY; | |
135 | ||
136 | if (m_windowStyle & wxHSCROLL) | |
137 | msStyle |= (WS_HSCROLL | ES_AUTOHSCROLL) ; | |
138 | if (m_windowStyle & wxTE_PASSWORD) // hidden input | |
139 | msStyle |= ES_PASSWORD; | |
140 | ||
141 | const char *windowClass = "EDIT"; | |
142 | ||
143 | #if wxUSE_RICHEDIT | |
144 | if ( m_windowStyle & wxTE_MULTILINE ) | |
145 | { | |
146 | msStyle |= ES_AUTOVSCROLL; | |
147 | m_isRich = TRUE; | |
148 | windowClass = "RichEdit" ; | |
149 | } | |
150 | else | |
151 | m_isRich = FALSE; | |
152 | #endif | |
153 | ||
154 | bool want3D; | |
155 | WXDWORD exStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &want3D) ; | |
156 | ||
157 | // If we're in Win95, and we want a simple 2D border, | |
158 | // then make it an EDIT control instead. | |
159 | #if wxUSE_RICHEDIT | |
160 | if (m_windowStyle & wxSIMPLE_BORDER) | |
161 | { | |
162 | windowClass = "EDIT"; | |
163 | m_isRich = FALSE; | |
164 | } | |
165 | #endif | |
166 | ||
167 | // Even with extended styles, need to combine with WS_BORDER | |
168 | // for them to look right. | |
169 | if ( want3D || wxStyleHasBorder(m_windowStyle) ) | |
170 | msStyle |= WS_BORDER; | |
171 | ||
172 | m_hWnd = (WXHWND)::CreateWindowEx(exStyle, windowClass, NULL, | |
173 | msStyle, | |
174 | 0, 0, 0, 0, (HWND) ((wxWindow*)parent)->GetHWND(), (HMENU)m_windowId, | |
175 | wxGetInstance(), NULL); | |
176 | ||
177 | wxCHECK_MSG( m_hWnd, FALSE, "Failed to create text ctrl" ); | |
178 | ||
179 | #if wxUSE_CTL3D | |
180 | if ( want3D ) | |
181 | { | |
182 | Ctl3dSubclassCtl((HWND)m_hWnd); | |
183 | m_useCtl3D = TRUE; | |
184 | } | |
185 | #endif | |
186 | ||
187 | #if wxUSE_RICHEDIT | |
188 | if (m_isRich) | |
189 | { | |
190 | // Have to enable events | |
191 | ::SendMessage((HWND)m_hWnd, EM_SETEVENTMASK, 0, | |
192 | ENM_CHANGE | ENM_DROPFILES | ENM_SELCHANGE | ENM_UPDATE); | |
193 | } | |
194 | #endif | |
195 | ||
196 | SubclassWin(GetHWND()); | |
197 | ||
198 | if ( parent->GetFont().Ok() && parent->GetFont().Ok() ) | |
199 | { | |
200 | SetFont(parent->GetFont()); | |
201 | } | |
202 | else | |
203 | { | |
204 | SetFont(wxSystemSettings::GetSystemFont(wxSYS_SYSTEM_FONT)); | |
205 | } | |
206 | ||
207 | SetSize(x, y, width, height); | |
208 | ||
209 | // Causes a crash for Symantec C++ and WIN32 for some reason | |
210 | #if !(defined(__SC__) && defined(__WIN32__)) | |
211 | if ( !value.IsEmpty() ) | |
212 | { | |
213 | SetValue(value); | |
214 | } | |
215 | #endif | |
216 | ||
217 | return TRUE; | |
218 | } | |
219 | ||
220 | // Make sure the window style (etc.) reflects the HWND style (roughly) | |
221 | void wxTextCtrl::AdoptAttributesFromHWND() | |
222 | { | |
223 | wxWindow::AdoptAttributesFromHWND(); | |
224 | ||
225 | HWND hWnd = (HWND) GetHWND(); | |
226 | long style = GetWindowLong((HWND) hWnd, GWL_STYLE); | |
227 | ||
228 | // retrieve the style to see whether this is an edit or richedit ctrl | |
229 | #if wxUSE_RICHEDIT | |
230 | char buf[256]; | |
231 | ||
232 | #ifndef __WIN32__ | |
233 | GetClassName((HWND) hWnd, buf, 256); | |
234 | #else | |
235 | #ifdef UNICODE | |
236 | GetClassNameW((HWND) hWnd, buf, 256); | |
237 | #else | |
238 | #ifdef __TWIN32__ | |
239 | GetClassName((HWND) hWnd, buf, 256); | |
240 | #else | |
241 | GetClassNameA((HWND) hWnd, buf, 256); | |
242 | #endif | |
243 | #endif | |
244 | #endif | |
245 | ||
246 | wxString str(buf); | |
247 | str.UpperCase(); | |
248 | ||
249 | if (str == "EDIT") | |
250 | m_isRich = FALSE; | |
251 | else | |
252 | m_isRich = TRUE; | |
253 | #endif | |
254 | ||
255 | if (style & ES_MULTILINE) | |
256 | m_windowStyle |= wxTE_MULTILINE; | |
257 | if (style & ES_PASSWORD) | |
258 | m_windowStyle |= wxTE_PASSWORD; | |
259 | if (style & ES_READONLY) | |
260 | m_windowStyle |= wxTE_READONLY; | |
261 | if (style & ES_WANTRETURN) | |
262 | m_windowStyle |= wxTE_PROCESS_ENTER; | |
263 | } | |
264 | ||
265 | void wxTextCtrl::SetupColours() | |
266 | { | |
267 | SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW)); | |
268 | SetForegroundColour(GetParent()->GetForegroundColour()); | |
269 | } | |
270 | ||
271 | wxString wxTextCtrl::GetValue() const | |
272 | { | |
273 | int length = GetWindowTextLength((HWND) GetHWND()); | |
274 | char *s = new char[length+1]; | |
275 | GetWindowText((HWND) GetHWND(), s, length+1); | |
276 | wxString str(s); | |
277 | delete[] s; | |
278 | return str; | |
279 | } | |
280 | ||
281 | void wxTextCtrl::SetValue(const wxString& value) | |
282 | { | |
283 | // If newlines are denoted by just 10, must stick 13 in front. | |
284 | int singletons = 0; | |
285 | int len = value.Length(); | |
286 | int i; | |
287 | for (i = 0; i < len; i ++) | |
288 | { | |
289 | if ((i > 0) && (value[i] == 10) && (value[i-1] != 13)) | |
290 | singletons ++; | |
291 | } | |
292 | if (singletons > 0) | |
293 | { | |
294 | char *tmp = new char[len + singletons + 1]; | |
295 | int j = 0; | |
296 | for (i = 0; i < len; i ++) | |
297 | { | |
298 | if ((i > 0) && (value[i] == 10) && (value[i-1] != 13)) | |
299 | { | |
300 | tmp[j] = 13; | |
301 | j ++; | |
302 | } | |
303 | tmp[j] = value[i]; | |
304 | j ++; | |
305 | } | |
306 | tmp[j] = 0; | |
307 | SetWindowText((HWND) GetHWND(), tmp); | |
308 | delete[] tmp; | |
309 | } | |
310 | else | |
311 | SetWindowText((HWND) GetHWND(), (const char *)value); | |
312 | } | |
313 | ||
314 | void wxTextCtrl::DoSetSize(int x, int y, int width, int height, int sizeFlags) | |
315 | { | |
316 | int currentX, currentY; | |
317 | GetPosition(¤tX, ¤tY); | |
318 | int x1 = x; | |
319 | int y1 = y; | |
320 | int w1 = width; | |
321 | int h1 = height; | |
322 | ||
323 | if (x == -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE)) | |
324 | x1 = currentX; | |
325 | if (y == -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE)) | |
326 | y1 = currentY; | |
327 | ||
328 | AdjustForParentClientOrigin(x1, y1, sizeFlags); | |
329 | ||
330 | int cx; // button font dimensions | |
331 | int cy; | |
332 | ||
333 | wxGetCharSize(GetHWND(), &cx, &cy, & this->GetFont()); | |
334 | ||
335 | int control_width, control_height, control_x, control_y; | |
336 | ||
337 | // If we're prepared to use the existing size, then... | |
338 | if (width == -1 && height == -1 && ((sizeFlags & wxSIZE_AUTO) != wxSIZE_AUTO)) | |
339 | { | |
340 | GetSize(&w1, &h1); | |
341 | } | |
342 | ||
343 | // Deal with default size (using -1 values) | |
344 | if (w1<=0) | |
345 | w1 = DEFAULT_ITEM_WIDTH; | |
346 | ||
347 | control_x = x1; | |
348 | control_y = y1; | |
349 | control_width = w1; | |
350 | control_height = h1; | |
351 | ||
352 | // Calculations may have made text size too small | |
353 | if (control_height <= 0) | |
354 | control_height = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy); | |
355 | ||
356 | if (control_width <= 0) | |
357 | control_width = DEFAULT_ITEM_WIDTH; | |
358 | ||
359 | MoveWindow((HWND) GetHWND(), (int)control_x, (int)control_y, | |
360 | (int)control_width, (int)control_height, TRUE); | |
361 | } | |
362 | ||
363 | // Clipboard operations | |
364 | void wxTextCtrl::Copy() | |
365 | { | |
366 | HWND hWnd = (HWND) GetHWND(); | |
367 | SendMessage(hWnd, WM_COPY, 0, 0L); | |
368 | } | |
369 | ||
370 | void wxTextCtrl::Cut() | |
371 | { | |
372 | HWND hWnd = (HWND) GetHWND(); | |
373 | SendMessage(hWnd, WM_CUT, 0, 0L); | |
374 | } | |
375 | ||
376 | void wxTextCtrl::Paste() | |
377 | { | |
378 | HWND hWnd = (HWND) GetHWND(); | |
379 | SendMessage(hWnd, WM_PASTE, 0, 0L); | |
380 | } | |
381 | ||
382 | void wxTextCtrl::SetEditable(bool editable) | |
383 | { | |
384 | HWND hWnd = (HWND) GetHWND(); | |
385 | SendMessage(hWnd, EM_SETREADONLY, (WPARAM)!editable, (LPARAM)0L); | |
386 | } | |
387 | ||
388 | void wxTextCtrl::SetInsertionPoint(long pos) | |
389 | { | |
390 | HWND hWnd = (HWND) GetHWND(); | |
391 | #ifdef __WIN32__ | |
392 | #if wxUSE_RICHEDIT | |
393 | if ( m_isRich) | |
394 | { | |
395 | CHARRANGE range; | |
396 | range.cpMin = pos; | |
397 | range.cpMax = pos; | |
398 | SendMessage(hWnd, EM_EXSETSEL, 0, (LPARAM) &range); | |
399 | SendMessage(hWnd, EM_SCROLLCARET, (WPARAM)0, (LPARAM)0); | |
400 | } | |
401 | else | |
402 | #endif | |
403 | { | |
404 | SendMessage(hWnd, EM_SETSEL, pos, pos); | |
405 | SendMessage(hWnd, EM_SCROLLCARET, (WPARAM)0, (LPARAM)0); | |
406 | } | |
407 | #else | |
408 | SendMessage(hWnd, EM_SETSEL, 0, MAKELPARAM(pos, pos)); | |
409 | #endif | |
410 | char *nothing = ""; | |
411 | SendMessage(hWnd, EM_REPLACESEL, 0, (LPARAM)nothing); | |
412 | } | |
413 | ||
414 | void wxTextCtrl::SetInsertionPointEnd() | |
415 | { | |
416 | long pos = GetLastPosition(); | |
417 | SetInsertionPoint(pos); | |
418 | } | |
419 | ||
420 | long wxTextCtrl::GetInsertionPoint() const | |
421 | { | |
422 | #if wxUSE_RICHEDIT | |
423 | if (m_isRich) | |
424 | { | |
425 | CHARRANGE range; | |
426 | range.cpMin = 0; | |
427 | range.cpMax = 0; | |
428 | SendMessage((HWND) GetHWND(), EM_EXGETSEL, 0, (LPARAM) &range); | |
429 | return range.cpMin; | |
430 | } | |
431 | #endif | |
432 | ||
433 | DWORD Pos=(DWORD)SendMessage((HWND) GetHWND(), EM_GETSEL, 0, 0L); | |
434 | return Pos&0xFFFF; | |
435 | } | |
436 | ||
437 | long wxTextCtrl::GetLastPosition() const | |
438 | { | |
439 | HWND hWnd = (HWND) GetHWND(); | |
440 | ||
441 | // Will always return a number > 0 (according to docs) | |
442 | int noLines = (int)SendMessage(hWnd, EM_GETLINECOUNT, (WPARAM)0, (LPARAM)0L); | |
443 | ||
444 | // This gets the char index for the _beginning_ of the last line | |
445 | int charIndex = (int)SendMessage(hWnd, EM_LINEINDEX, (WPARAM)(noLines-1), (LPARAM)0L); | |
446 | ||
447 | // Get number of characters in the last line. We'll add this to the character | |
448 | // index for the last line, 1st position. | |
449 | int lineLength = (int)SendMessage(hWnd, EM_LINELENGTH, (WPARAM)charIndex, (LPARAM)0L); | |
450 | ||
451 | return (long)(charIndex + lineLength); | |
452 | } | |
453 | ||
454 | void wxTextCtrl::Replace(long from, long to, const wxString& value) | |
455 | { | |
456 | #if wxUSE_CLIPBOARD | |
457 | HWND hWnd = (HWND) GetHWND(); | |
458 | long fromChar = from; | |
459 | long toChar = to; | |
460 | ||
461 | // Set selection and remove it | |
462 | #ifdef __WIN32__ | |
463 | SendMessage(hWnd, EM_SETSEL, fromChar, toChar); | |
464 | #else | |
465 | SendMessage(hWnd, EM_SETSEL, (WPARAM)0, (LPARAM)MAKELONG(fromChar, toChar)); | |
466 | #endif | |
467 | SendMessage(hWnd, WM_CUT, (WPARAM)0, (LPARAM)0); | |
468 | ||
469 | // Now replace with 'value', by pasting. | |
470 | wxSetClipboardData(wxDF_TEXT, (wxObject *) (const char *)value, 0, 0); | |
471 | ||
472 | // Paste into edit control | |
473 | SendMessage(hWnd, WM_PASTE, (WPARAM)0, (LPARAM)0L); | |
474 | #else | |
475 | wxFAIL_MSG("wxTextCtrl::Replace not implemented if wxUSE_CLIPBOARD is 0."); | |
476 | #endif | |
477 | } | |
478 | ||
479 | void wxTextCtrl::Remove(long from, long to) | |
480 | { | |
481 | HWND hWnd = (HWND) GetHWND(); | |
482 | long fromChar = from; | |
483 | long toChar = to; | |
484 | ||
485 | // Cut all selected text | |
486 | #ifdef __WIN32__ | |
487 | SendMessage(hWnd, EM_SETSEL, fromChar, toChar); | |
488 | #else | |
489 | SendMessage(hWnd, EM_SETSEL, (WPARAM)0, (LPARAM)MAKELONG(fromChar, toChar)); | |
490 | #endif | |
491 | SendMessage(hWnd, WM_CUT, (WPARAM)0, (LPARAM)0); | |
492 | } | |
493 | ||
494 | void wxTextCtrl::SetSelection(long from, long to) | |
495 | { | |
496 | HWND hWnd = (HWND) GetHWND(); | |
497 | long fromChar = from; | |
498 | long toChar = to; | |
499 | // if from and to are both -1, it means | |
500 | // (in wxWindows) that all text should be selected. | |
501 | // This translates into Windows convention | |
502 | if ((from == -1) && (to == -1)) | |
503 | { | |
504 | fromChar = 0; | |
505 | toChar = -1; | |
506 | } | |
507 | ||
508 | #ifdef __WIN32__ | |
509 | SendMessage(hWnd, EM_SETSEL, (WPARAM)fromChar, (LPARAM)toChar); | |
510 | SendMessage(hWnd, EM_SCROLLCARET, (WPARAM)0, (LPARAM)0); | |
511 | #else | |
512 | // WPARAM is 0: selection is scrolled into view | |
513 | SendMessage(hWnd, EM_SETSEL, (WPARAM)0, (LPARAM)MAKELONG(fromChar, toChar)); | |
514 | #endif | |
515 | } | |
516 | ||
517 | bool wxTextCtrl::LoadFile(const wxString& file) | |
518 | { | |
519 | if (!wxFileExists(WXSTRINGCAST file)) | |
520 | return FALSE; | |
521 | ||
522 | m_fileName = file; | |
523 | ||
524 | Clear(); | |
525 | ||
526 | // ifstream input(WXSTRINGCAST file, ios::nocreate | ios::in); | |
527 | ifstream input(WXSTRINGCAST file, ios::in); | |
528 | ||
529 | if (!input.bad()) | |
530 | { | |
531 | // Previously a SETSEL/REPLACESEL call-pair were done to insert | |
532 | // line by line into the control. Apart from being very slow this | |
533 | // was limited to 32K of text by the external interface presenting | |
534 | // positions as signed shorts. Now load in one chunk... | |
535 | // Note use of 'farmalloc' as in Borland 3.1 'size_t' is 16-bits... | |
536 | ||
537 | #ifdef __SALFORDC__ | |
538 | struct _stat stat_buf; | |
539 | if (stat((char*) (const char*) file, &stat_buf) < 0) | |
540 | return FALSE; | |
541 | #else | |
542 | struct stat stat_buf; | |
543 | if (stat(file, &stat_buf) < 0) | |
544 | return FALSE; | |
545 | #endif | |
546 | ||
547 | // char *tmp_buffer = (char*)farmalloc(stat_buf.st_size+1); | |
548 | // This may need to be a bigger buffer than the file size suggests, | |
549 | // if it's a UNIX file. Give it an extra 1000 just in case. | |
550 | char *tmp_buffer = (char*)farmalloc((size_t)(stat_buf.st_size+1+1000)); | |
551 | long no_lines = 0; | |
552 | long pos = 0; | |
553 | while (!input.eof() && input.peek() != EOF) | |
554 | { | |
555 | input.getline(wxBuffer, 500); | |
556 | int len = strlen(wxBuffer); | |
557 | wxBuffer[len] = 13; | |
558 | wxBuffer[len+1] = 10; | |
559 | wxBuffer[len+2] = 0; | |
560 | strcpy(tmp_buffer+pos, wxBuffer); | |
561 | pos += strlen(wxBuffer); | |
562 | no_lines++; | |
563 | } | |
564 | ||
565 | // SendMessage((HWND) GetHWND(), WM_SETTEXT, 0, (LPARAM)tmp_buffer); | |
566 | SetWindowText((HWND) GetHWND(), tmp_buffer); | |
567 | SendMessage((HWND) GetHWND(), EM_SETMODIFY, FALSE, 0L); | |
568 | farfree(tmp_buffer); | |
569 | ||
570 | return TRUE; | |
571 | } | |
572 | return FALSE; | |
573 | } | |
574 | ||
575 | // If file is null, try saved file name first | |
576 | // Returns TRUE if succeeds. | |
577 | bool wxTextCtrl::SaveFile(const wxString& file) | |
578 | { | |
579 | wxString theFile(file); | |
580 | ||
581 | if (theFile == "") | |
582 | theFile = m_fileName; | |
583 | ||
584 | if (theFile == "") | |
585 | return FALSE; | |
586 | ||
587 | m_fileName = theFile; | |
588 | ||
589 | ofstream output((char*) (const char*) theFile); | |
590 | if (output.bad()) | |
591 | return FALSE; | |
592 | ||
593 | // This will only save 64K max | |
594 | unsigned long nbytes = SendMessage((HWND) GetHWND(), WM_GETTEXTLENGTH, 0, 0); | |
595 | char *tmp_buffer = (char*)farmalloc((size_t)(nbytes+1)); | |
596 | SendMessage((HWND) GetHWND(), WM_GETTEXT, (WPARAM)(nbytes+1), (LPARAM)tmp_buffer); | |
597 | char *pstr = tmp_buffer; | |
598 | ||
599 | // Convert \r\n to just \n | |
600 | while (*pstr) | |
601 | { | |
602 | if (*pstr != '\r') | |
603 | output << *pstr; | |
604 | pstr++; | |
605 | } | |
606 | ||
607 | farfree(tmp_buffer); | |
608 | SendMessage((HWND) GetHWND(), EM_SETMODIFY, FALSE, 0L); | |
609 | ||
610 | return TRUE; | |
611 | } | |
612 | ||
613 | void wxTextCtrl::WriteText(const wxString& text) | |
614 | { | |
615 | // Covert \n to \r\n | |
616 | int len = text.Length(); | |
617 | char *newtext = new char[(len*2)+1]; | |
618 | int i = 0; | |
619 | int j = 0; | |
620 | while (i < len) | |
621 | { | |
622 | if (text[i] == '\n') | |
623 | { | |
624 | newtext[j] = '\r'; | |
625 | j ++; | |
626 | } | |
627 | newtext[j] = text[i]; | |
628 | i ++; | |
629 | j ++; | |
630 | } | |
631 | newtext[j] = 0; | |
632 | SendMessage((HWND) GetHWND(), EM_REPLACESEL, 0, (LPARAM)newtext); | |
633 | delete[] newtext; | |
634 | } | |
635 | ||
636 | void wxTextCtrl::AppendText(const wxString& text) | |
637 | { | |
638 | SetInsertionPointEnd(); | |
639 | WriteText(text); | |
640 | } | |
641 | ||
642 | void wxTextCtrl::Clear() | |
643 | { | |
644 | SetWindowText((HWND) GetHWND(), ""); | |
645 | } | |
646 | ||
647 | bool wxTextCtrl::IsModified() const | |
648 | { | |
649 | return (SendMessage((HWND) GetHWND(), EM_GETMODIFY, 0, 0) != 0); | |
650 | } | |
651 | ||
652 | // Makes 'unmodified' | |
653 | void wxTextCtrl::DiscardEdits() | |
654 | { | |
655 | SendMessage((HWND) GetHWND(), EM_SETMODIFY, FALSE, 0L); | |
656 | } | |
657 | ||
658 | /* | |
659 | * Some of the following functions are yet to be implemented | |
660 | * | |
661 | */ | |
662 | ||
663 | int wxTextCtrl::GetNumberOfLines() const | |
664 | { | |
665 | return (int)SendMessage((HWND) GetHWND(), EM_GETLINECOUNT, (WPARAM)0, (LPARAM)0); | |
666 | } | |
667 | ||
668 | long wxTextCtrl::XYToPosition(long x, long y) const | |
669 | { | |
670 | HWND hWnd = (HWND) GetHWND(); | |
671 | ||
672 | // This gets the char index for the _beginning_ of this line | |
673 | int charIndex = (int)SendMessage(hWnd, EM_LINEINDEX, (WPARAM)y, (LPARAM)0); | |
674 | return (long)(x + charIndex); | |
675 | } | |
676 | ||
677 | void wxTextCtrl::PositionToXY(long pos, long *x, long *y) const | |
678 | { | |
679 | HWND hWnd = (HWND) GetHWND(); | |
680 | ||
681 | // This gets the line number containing the character | |
682 | int lineNo = (int)SendMessage(hWnd, EM_LINEFROMCHAR, (WPARAM)pos, (LPARAM)0); | |
683 | // This gets the char index for the _beginning_ of this line | |
684 | int charIndex = (int)SendMessage(hWnd, EM_LINEINDEX, (WPARAM)lineNo, (LPARAM)0); | |
685 | // The X position must therefore be the different between pos and charIndex | |
686 | *x = (long)(pos - charIndex); | |
687 | *y = (long)lineNo; | |
688 | } | |
689 | ||
690 | void wxTextCtrl::ShowPosition(long pos) | |
691 | { | |
692 | HWND hWnd = (HWND) GetHWND(); | |
693 | ||
694 | // To scroll to a position, we pass the number of lines and characters | |
695 | // to scroll *by*. This means that we need to: | |
696 | // (1) Find the line position of the current line. | |
697 | // (2) Find the line position of pos. | |
698 | // (3) Scroll by (pos - current). | |
699 | // For now, ignore the horizontal scrolling. | |
700 | ||
701 | // Is this where scrolling is relative to - the line containing the caret? | |
702 | // Or is the first visible line??? Try first visible line. | |
703 | // int currentLineLineNo1 = (int)SendMessage(hWnd, EM_LINEFROMCHAR, (WPARAM)-1, (LPARAM)0L); | |
704 | ||
705 | int currentLineLineNo = (int)SendMessage(hWnd, EM_GETFIRSTVISIBLELINE, (WPARAM)0, (LPARAM)0L); | |
706 | ||
707 | int specifiedLineLineNo = (int)SendMessage(hWnd, EM_LINEFROMCHAR, (WPARAM)pos, (LPARAM)0L); | |
708 | ||
709 | int linesToScroll = specifiedLineLineNo - currentLineLineNo; | |
710 | ||
711 | if (linesToScroll != 0) | |
712 | (void)SendMessage(hWnd, EM_LINESCROLL, (WPARAM)0, (LPARAM)MAKELPARAM(linesToScroll, 0)); | |
713 | } | |
714 | ||
715 | int wxTextCtrl::GetLineLength(long lineNo) const | |
716 | { | |
717 | long charIndex = XYToPosition(0, lineNo); | |
718 | HWND hWnd = (HWND) GetHWND(); | |
719 | int len = (int)SendMessage(hWnd, EM_LINELENGTH, (WPARAM)charIndex, (LPARAM)0); | |
720 | return len; | |
721 | } | |
722 | ||
723 | wxString wxTextCtrl::GetLineText(long lineNo) const | |
724 | { | |
725 | HWND hWnd = (HWND) GetHWND(); | |
726 | *(WORD *)wxBuffer = 512; | |
727 | int noChars = (int)SendMessage(hWnd, EM_GETLINE, (WPARAM)lineNo, (LPARAM)wxBuffer); | |
728 | wxBuffer[noChars] = 0; | |
729 | return wxString(wxBuffer); | |
730 | } | |
731 | ||
732 | /* | |
733 | * Text item | |
734 | */ | |
735 | ||
736 | void wxTextCtrl::Command(wxCommandEvent & event) | |
737 | { | |
738 | SetValue (event.GetString()); | |
739 | ProcessCommand (event); | |
740 | } | |
741 | ||
742 | void wxTextCtrl::OnDropFiles(wxDropFilesEvent& event) | |
743 | { | |
744 | // By default, load the first file into the text window. | |
745 | if (event.GetNumberOfFiles() > 0) | |
746 | { | |
747 | LoadFile(event.GetFiles()[0]); | |
748 | } | |
749 | } | |
750 | ||
751 | // The streambuf code was partly taken from chapter 3 by Jerry Schwarz of | |
752 | // AT&T's "C++ Lanuage System Release 3.0 Library Manual" - Stein Somers | |
753 | ||
754 | //========================================================================= | |
755 | // Called then the buffer is full (gcc 2.6.3) | |
756 | // or when "endl" is output (Borland 4.5) | |
757 | //========================================================================= | |
758 | // Class declaration using multiple inheritance doesn't work properly for | |
759 | // Borland. See note in textctrl.h. | |
760 | #ifndef NO_TEXT_WINDOW_STREAM | |
761 | int wxTextCtrl::overflow(int c) | |
762 | { | |
763 | // Make sure there is a holding area | |
764 | // this is not needed in <iostream> usage as it automagically allocates | |
765 | // it, but does someone want to emulate it for safety's sake? | |
766 | #if wxUSE_IOSTREAMH | |
767 | if ( allocate()==EOF ) | |
768 | { | |
769 | wxLogError("Streambuf allocation failed"); | |
770 | return EOF; | |
771 | } | |
772 | #endif | |
773 | ||
774 | // Verify that there are no characters in get area | |
775 | if ( gptr() && gptr() < egptr() ) | |
776 | { | |
777 | wxError("Who's trespassing my get area?","Internal error"); | |
778 | return EOF; | |
779 | } | |
780 | ||
781 | // Reset get area | |
782 | setg(0,0,0); | |
783 | ||
784 | // Make sure there is a put area | |
785 | if ( ! pptr() ) | |
786 | { | |
787 | /* This doesn't seem to be fatal so comment out error message */ | |
788 | // wxError("Put area not opened","Internal error"); | |
789 | ||
790 | #if wxUSE_IOSTREAMH | |
791 | setp( base(), base() ); | |
792 | #else | |
793 | setp( pbase(), pbase() ); | |
794 | #endif | |
795 | } | |
796 | ||
797 | // Determine how many characters have been inserted but no consumed | |
798 | int plen = pptr() - pbase(); | |
799 | ||
800 | // Now Jerry relies on the fact that the buffer is at least 2 chars | |
801 | // long, but the holding area "may be as small as 1" ??? | |
802 | // And we need an additional \0, so let's keep this inefficient but | |
803 | // safe copy. | |
804 | ||
805 | // If c!=EOF, it is a character that must also be comsumed | |
806 | int xtra = c==EOF? 0 : 1; | |
807 | ||
808 | // Write temporary C-string to wxTextWindow | |
809 | { | |
810 | char *txt = new char[plen+xtra+1]; | |
811 | memcpy(txt, pbase(), plen); | |
812 | txt[plen] = (char)c; // append c | |
813 | txt[plen+xtra] = '\0'; // append '\0' or overwrite c | |
814 | // If the put area already contained \0, output will be truncated there | |
815 | AppendText(txt); | |
816 | delete[] txt; | |
817 | } | |
818 | ||
819 | // Reset put area | |
820 | setp(pbase(), epptr()); | |
821 | ||
822 | #if defined(__WATCOMC__) | |
823 | return __NOT_EOF; | |
824 | #elif defined(zapeof) // HP-UX (all cfront based?) | |
825 | return zapeof(c); | |
826 | #else | |
827 | return c!=EOF ? c : 0; // this should make everybody happy | |
828 | #endif | |
829 | ||
830 | /* OLD CODE | |
831 | int len = pptr() - pbase(); | |
832 | char *txt = new char[len+1]; | |
833 | strncpy(txt, pbase(), len); | |
834 | txt[len] = '\0'; | |
835 | (*this) << txt; | |
836 | setp(pbase(), epptr()); | |
837 | delete[] txt; | |
838 | return EOF; | |
839 | */ | |
840 | } | |
841 | ||
842 | //========================================================================= | |
843 | // called then "endl" is output (gcc) or then explicit sync is done (Borland) | |
844 | //========================================================================= | |
845 | int wxTextCtrl::sync() | |
846 | { | |
847 | // Verify that there are no characters in get area | |
848 | if ( gptr() && gptr() < egptr() ) | |
849 | { | |
850 | wxError("Who's trespassing my get area?","Internal error"); | |
851 | return EOF; | |
852 | } | |
853 | ||
854 | if ( pptr() && pptr() > pbase() ) return overflow(EOF); | |
855 | ||
856 | return 0; | |
857 | /* OLD CODE | |
858 | int len = pptr() - pbase(); | |
859 | char *txt = new char[len+1]; | |
860 | strncpy(txt, pbase(), len); | |
861 | txt[len] = '\0'; | |
862 | (*this) << txt; | |
863 | setp(pbase(), epptr()); | |
864 | delete[] txt; | |
865 | return 0; | |
866 | */ | |
867 | } | |
868 | ||
869 | //========================================================================= | |
870 | // Should not be called by a "ostream". Used by a "istream" | |
871 | //========================================================================= | |
872 | int wxTextCtrl::underflow() | |
873 | { | |
874 | return EOF; | |
875 | } | |
876 | #endif | |
877 | ||
878 | wxTextCtrl& wxTextCtrl::operator<<(const wxString& s) | |
879 | { | |
880 | AppendText(s); | |
881 | return *this; | |
882 | } | |
883 | ||
884 | wxTextCtrl& wxTextCtrl::operator<<(float f) | |
885 | { | |
886 | wxString str; | |
887 | str.Printf("%.2f", f); | |
888 | AppendText(str); | |
889 | return *this; | |
890 | } | |
891 | ||
892 | wxTextCtrl& wxTextCtrl::operator<<(double d) | |
893 | { | |
894 | wxString str; | |
895 | str.Printf("%.2f", d); | |
896 | AppendText(str); | |
897 | return *this; | |
898 | } | |
899 | ||
900 | wxTextCtrl& wxTextCtrl::operator<<(int i) | |
901 | { | |
902 | wxString str; | |
903 | str.Printf("%d", i); | |
904 | AppendText(str); | |
905 | return *this; | |
906 | } | |
907 | ||
908 | wxTextCtrl& wxTextCtrl::operator<<(long i) | |
909 | { | |
910 | wxString str; | |
911 | str.Printf("%ld", i); | |
912 | AppendText(str); | |
913 | return *this; | |
914 | } | |
915 | ||
916 | wxTextCtrl& wxTextCtrl::operator<<(const char c) | |
917 | { | |
918 | char buf[2]; | |
919 | ||
920 | buf[0] = c; | |
921 | buf[1] = 0; | |
922 | AppendText(buf); | |
923 | return *this; | |
924 | } | |
925 | ||
926 | WXHBRUSH wxTextCtrl::OnCtlColor(WXHDC pDC, WXHWND pWnd, WXUINT nCtlColor, | |
927 | WXUINT message, WXWPARAM wParam, WXLPARAM lParam) | |
928 | { | |
929 | #if wxUSE_CTL3D | |
930 | if ( m_useCtl3D ) | |
931 | { | |
932 | HBRUSH hbrush = Ctl3dCtlColorEx(message, wParam, lParam); | |
933 | return (WXHBRUSH) hbrush; | |
934 | } | |
935 | #endif | |
936 | ||
937 | if (GetParent()->GetTransparentBackground()) | |
938 | SetBkMode((HDC) pDC, TRANSPARENT); | |
939 | else | |
940 | SetBkMode((HDC) pDC, OPAQUE); | |
941 | ||
942 | ::SetBkColor((HDC) pDC, RGB(GetBackgroundColour().Red(), GetBackgroundColour().Green(), GetBackgroundColour().Blue())); | |
943 | ::SetTextColor((HDC) pDC, RGB(GetForegroundColour().Red(), GetForegroundColour().Green(), GetForegroundColour().Blue())); | |
944 | ||
945 | wxBrush *backgroundBrush = wxTheBrushList->FindOrCreateBrush(GetBackgroundColour(), wxSOLID); | |
946 | ||
947 | // Note that this will be cleaned up in wxApp::OnIdle, if backgroundBrush | |
948 | // has a zero usage count. | |
949 | // NOT NOW - will be cleaned up at end of app. | |
950 | // backgroundBrush->RealizeResource(); | |
951 | return (WXHBRUSH) backgroundBrush->GetResourceHandle(); | |
952 | } | |
953 | ||
954 | void wxTextCtrl::OnChar(wxKeyEvent& event) | |
955 | { | |
956 | switch( event.KeyCode() ) | |
957 | { | |
958 | // Fix by Marcel Rasche to allow Alt-Ctrl insertion of special characters | |
959 | case '{': | |
960 | case '}': | |
961 | case '[': | |
962 | case ']': | |
963 | case '|': | |
964 | case '~': | |
965 | case '\\': | |
966 | { | |
967 | char c = (char)event.KeyCode(); | |
968 | WriteText(c); | |
969 | } | |
970 | break; | |
971 | ||
972 | case WXK_RETURN: | |
973 | { | |
974 | /* Oh yes it will, because we also specify DLGC_WANTCHARS | |
975 | wxASSERT_MSG( m_windowStyle & wxTE_PROCESS_ENTER, | |
976 | "this text ctrl should never receive return" ); | |
977 | */ | |
978 | ||
979 | if ( (m_windowStyle & wxTE_MULTILINE) == 0 ) | |
980 | { | |
981 | wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId); | |
982 | event.SetEventObject( this ); | |
983 | if ( GetEventHandler()->ProcessEvent(event) ) | |
984 | return; | |
985 | } | |
986 | //else: multiline controls need Enter for themselves | |
987 | ||
988 | break; | |
989 | } | |
990 | case WXK_TAB: | |
991 | // only produce navigation event if we don't process TAB ourself or | |
992 | // if it's a Shift-Tab keypress (we assume nobody will ever need | |
993 | // this key combo for himself) | |
994 | // | |
995 | // NB: Notice that Ctrl-Tab is handled elsewhere and Alt-Tab is | |
996 | // handled by Windows | |
997 | if ( event.ShiftDown() || !(m_windowStyle & wxTE_PROCESS_TAB) ) | |
998 | { | |
999 | wxNavigationKeyEvent eventNav; | |
1000 | eventNav.SetDirection(!event.ShiftDown()); | |
1001 | eventNav.SetWindowChange(FALSE); | |
1002 | eventNav.SetEventObject(this); | |
1003 | ||
1004 | if ( GetEventHandler()->ProcessEvent(eventNav) ) | |
1005 | return; | |
1006 | } | |
1007 | break; | |
1008 | } | |
1009 | ||
1010 | // don't just call event.Skip() because this will cause TABs and ENTERs | |
1011 | // be passed upwards and we don't always want this - instead process it | |
1012 | // right here | |
1013 | Default(); | |
1014 | // event.Skip(); | |
1015 | } | |
1016 | ||
1017 | long wxTextCtrl::MSWGetDlgCode() | |
1018 | { | |
1019 | // we always want the characters and the arrows | |
1020 | long lRc = DLGC_WANTCHARS | DLGC_WANTARROWS; | |
1021 | ||
1022 | // we may have several different cases: | |
1023 | // 1. normal case: both TAB and ENTER are used for dialog navigation | |
1024 | // 2. ctrl which wants TAB for itself: ENTER is used to pass to the next | |
1025 | // control in the dialog | |
1026 | // 3. ctrl which wants ENTER for itself: TAB is used for dialog navigation | |
1027 | // 4. ctrl which wants both TAB and ENTER: Ctrl-ENTER is used to pass to | |
1028 | // the next control | |
1029 | if ( m_windowStyle & wxTE_PROCESS_ENTER ) | |
1030 | lRc |= DLGC_WANTMESSAGE; | |
1031 | if ( m_windowStyle & wxTE_PROCESS_TAB ) | |
1032 | lRc |= DLGC_WANTTAB; | |
1033 | ||
1034 | return lRc; | |
1035 | } | |
1036 | ||
1037 | void wxTextCtrl::OnEraseBackground(wxEraseEvent& event) | |
1038 | { | |
1039 | if ( m_windowStyle & wxTE_MULTILINE ) | |
1040 | { | |
1041 | // No flicker - only problem is we probably can't change the background | |
1042 | Default(); | |
1043 | /* | |
1044 | RECT rect; | |
1045 | ::GetClientRect((HWND) GetHWND(), &rect); | |
1046 | ||
1047 | HBRUSH hBrush = ::CreateSolidBrush(PALETTERGB(GetBackgroundColour().Red(), GetBackgroundColour().Green(), GetBackgroundColour().Blue())); | |
1048 | int mode = ::SetMapMode((HDC) event.GetDC()->GetHDC(), MM_TEXT); | |
1049 | ||
1050 | ::FillRect ((HDC) event.GetDC()->GetHDC(), &rect, hBrush); | |
1051 | ::DeleteObject(hBrush); | |
1052 | ::SetMapMode((HDC) event.GetDC()->GetHDC(), mode); | |
1053 | */ | |
1054 | } | |
1055 | // wxWindow::OnEraseBackground(event); | |
1056 | } | |
1057 | ||
1058 | bool wxTextCtrl::MSWCommand(WXUINT param, WXWORD WXUNUSED(id)) | |
1059 | { | |
1060 | /* | |
1061 | // Debugging | |
1062 | wxDebugMsg("Edit control %d: ", (int)id); | |
1063 | switch (param) | |
1064 | { | |
1065 | case EN_SETFOCUS: | |
1066 | wxDebugMsg("EN_SETFOCUS\n"); | |
1067 | break; | |
1068 | case EN_KILLFOCUS: | |
1069 | wxDebugMsg("EN_KILLFOCUS\n"); | |
1070 | break; | |
1071 | case EN_CHANGE: | |
1072 | wxDebugMsg("EN_CHANGE\n"); | |
1073 | break; | |
1074 | case EN_UPDATE: | |
1075 | wxDebugMsg("EN_UPDATE\n"); | |
1076 | break; | |
1077 | case EN_ERRSPACE: | |
1078 | wxDebugMsg("EN_ERRSPACE\n"); | |
1079 | break; | |
1080 | case EN_MAXTEXT: | |
1081 | wxDebugMsg("EN_MAXTEXT\n"); | |
1082 | break; | |
1083 | case EN_HSCROLL: | |
1084 | wxDebugMsg("EN_HSCROLL\n"); | |
1085 | break; | |
1086 | case EN_VSCROLL: | |
1087 | wxDebugMsg("EN_VSCROLL\n"); | |
1088 | break; | |
1089 | default: | |
1090 | wxDebugMsg("Unknown EDIT notification\n"); | |
1091 | break; | |
1092 | } | |
1093 | */ | |
1094 | switch (param) | |
1095 | { | |
1096 | case EN_SETFOCUS: | |
1097 | case EN_KILLFOCUS: | |
1098 | { | |
1099 | wxFocusEvent event(param == EN_KILLFOCUS ? wxEVT_KILL_FOCUS | |
1100 | : wxEVT_SET_FOCUS, | |
1101 | m_windowId); | |
1102 | event.SetEventObject( this ); | |
1103 | GetEventHandler()->ProcessEvent(event); | |
1104 | } | |
1105 | break; | |
1106 | ||
1107 | case EN_CHANGE: | |
1108 | { | |
1109 | wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId); | |
1110 | wxString val(GetValue()); | |
1111 | if ( !val.IsNull() ) | |
1112 | event.m_commandString = WXSTRINGCAST val; | |
1113 | event.SetEventObject( this ); | |
1114 | ProcessCommand(event); | |
1115 | } | |
1116 | break; | |
1117 | ||
1118 | // the other notification messages are not processed | |
1119 | case EN_UPDATE: | |
1120 | case EN_ERRSPACE: | |
1121 | case EN_MAXTEXT: | |
1122 | case EN_HSCROLL: | |
1123 | case EN_VSCROLL: | |
1124 | default: | |
1125 | return FALSE; | |
1126 | } | |
1127 | ||
1128 | // processed | |
1129 | return TRUE; | |
1130 | } | |
1131 | ||
1132 | ||
1133 | // For Rich Edit controls. Do we need it? | |
1134 | #if 0 | |
1135 | #if wxUSE_RICHEDIT | |
1136 | bool wxTextCtrl::MSWNotify(WXWPARAM wParam, WXLPARAM lParam) | |
1137 | { | |
1138 | wxCommandEvent event(0, m_windowId); | |
1139 | int eventType = 0; | |
1140 | NMHDR *hdr1 = (NMHDR *) lParam; | |
1141 | switch ( hdr1->code ) | |
1142 | { | |
1143 | // Insert case code here | |
1144 | default : | |
1145 | return wxControl::MSWNotify(wParam, lParam); | |
1146 | break; | |
1147 | } | |
1148 | ||
1149 | event.SetEventObject( this ); | |
1150 | event.SetEventType(eventType); | |
1151 | ||
1152 | if ( !GetEventHandler()->ProcessEvent(event) ) | |
1153 | return FALSE; | |
1154 | ||
1155 | return TRUE; | |
1156 | } | |
1157 | #endif | |
1158 | #endif | |
1159 |