1 /*
2 * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 #include "awt_Toolkit.h"
27 #include "awt_TextComponent.h"
28 #include "awt_TextArea.h"
29 #include "awt_TextField.h"
30 #include "awt_Canvas.h"
31
32 #include "jni.h"
33 #include "awt_Font.h"
34
35
36 /***********************************************************************/
37 // struct for _SetText() method
38 struct SetTextStruct {
39 jobject textcomponent;
40 jstring text;
41 };
42 // struct for _Select() method
43 struct SelectStruct {
44 jobject textcomponent;
45 jint start, end;
46 };
47 // struct for _EnableEditing() method
48 struct EnableEditingStruct {
49 jobject textcomponent;
50 jboolean on;
51 };
52 /************************************************************************
53 * AwtTextComponent fields
54 */
55
56 /************************************************************************
57 * AwtTextComponent methods
58 */
59
60 jmethodID AwtTextComponent::canAccessClipboardMID;
61
62 AwtTextComponent::AwtTextComponent() {
63 m_synthetic = FALSE;
64 m_lStartPos = -1;
65 m_lEndPos = -1;
66 m_lLastPos = -1;
67 m_isLFonly = FALSE;
68 m_EOLchecked = FALSE;
69 m_hEditCtrl = NULL;
70 m_bIgnoreEnChange = FALSE;
71 // javaEventsMask = 0; // accessibility support
72 }
73
74 LPCTSTR AwtTextComponent::GetClassName() {
75 static BOOL richedLibraryLoaded = FALSE;
76 if (!richedLibraryLoaded) {
77 JDK_LoadSystemLibrary("RICHED20.DLL");
78 richedLibraryLoaded = TRUE;
79 }
80 return RICHEDIT_CLASS;
81 }
82
83 /* Create a new AwtTextArea or AwtTextField object and window. */
84 AwtTextComponent* AwtTextComponent::Create(jobject peer, jobject parent, BOOL isMultiline)
85 {
86 JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
87
88 jobject target = NULL;
89 AwtTextComponent* c = NULL;
90
91 try {
92 if (env->EnsureLocalCapacity(1) < 0) {
93 return NULL;
94 }
95
96 PDATA pData;
97 AwtCanvas* awtParent;
98 JNI_CHECK_PEER_GOTO(parent, done);
99
100 awtParent = (AwtCanvas*)pData;
101 JNI_CHECK_NULL_GOTO(awtParent, "null awtParent", done);
102
103 target = env->GetObjectField(peer, AwtObject::targetID);
104 JNI_CHECK_NULL_GOTO(target, "null target", done);
105
106 if(isMultiline){
107 c = new AwtTextArea();
108 }else{
109 c = new AwtTextField();
110 }
111
112 {
113 /* Adjust style for scrollbar visibility and word wrap */
114 DWORD scroll_style;
115
116 if(isMultiline){
117
118 jint scrollbarVisibility =
119 env->GetIntField(target, AwtTextArea::scrollbarVisibilityID);
120
121 switch (scrollbarVisibility) {
122 case java_awt_TextArea_SCROLLBARS_NONE:
123 scroll_style = ES_AUTOVSCROLL;
124 break;
125 case java_awt_TextArea_SCROLLBARS_VERTICAL_ONLY:
126 scroll_style = WS_VSCROLL | ES_AUTOVSCROLL;
127 break;
128 case java_awt_TextArea_SCROLLBARS_HORIZONTAL_ONLY:
129 scroll_style = WS_HSCROLL | ES_AUTOHSCROLL | ES_AUTOVSCROLL;
130 break;
131 case java_awt_TextArea_SCROLLBARS_BOTH:
132 scroll_style = WS_VSCROLL | WS_HSCROLL |
133 ES_AUTOVSCROLL | ES_AUTOHSCROLL;
134 break;
135 }
136 }
137
138 DWORD style = WS_CHILD | WS_CLIPSIBLINGS | ES_LEFT;
139
140 /*
141 * Specify ES_DISABLENOSCROLL - RichEdit control style to disable
142 * scrollbars instead of hiding them when not needed.
143 */
144 style |= isMultiline ? ES_MULTILINE | ES_WANTRETURN | scroll_style
145 | ES_DISABLENOSCROLL : ES_AUTOHSCROLL;
146
147
148 DWORD exStyle = WS_EX_CLIENTEDGE;
149 if (GetRTL()) {
150 exStyle |= WS_EX_RIGHT | WS_EX_LEFTSCROLLBAR;
151 if (GetRTLReadingOrder())
152 exStyle |= WS_EX_RTLREADING;
153 }
154
155
156 jint x = env->GetIntField(target, AwtComponent::xID);
157 jint y = env->GetIntField(target, AwtComponent::yID);
158 jint width = env->GetIntField(target, AwtComponent::widthID);
159 jint height = env->GetIntField(target, AwtComponent::heightID);
160
161 c->CreateHWnd(env, L"", style, exStyle,
162 x, y, width, height,
163 awtParent->GetHWnd(),
164 reinterpret_cast<HMENU>(static_cast<INT_PTR>(
165 awtParent->CreateControlID())),
166 ::GetSysColor(COLOR_WINDOWTEXT),
167 ::GetSysColor(COLOR_WINDOW),
168 peer);
169
170 // Fix for 4753116.
171 // If it is not win95 (we are using Richedit 2.0)
172 // we set plain text mode, in which the control is
173 // similar to a standard edit control:
174 // - The text in a plain text control can have only
175 // one format.
176 // - The user cannot paste rich text formats, such as RTF
177 // or embedded objects into a plain text control.
178 // - Rich text mode controls always have a default
179 // end-of-document marker or carriage return,
180 // to format paragraphs.
181 // kdm@sparc.spb.su
182 c->SendMessage(EM_SETTEXTMODE, TM_PLAINTEXT, 0);
183
184 c->m_backgroundColorSet = TRUE;
185 /* suppress inheriting parent's color. */
186 c->UpdateBackground(env, target);
187 c->SendMessage(EM_SETMARGINS, EC_LEFTMARGIN | EC_RIGHTMARGIN,
188 MAKELPARAM(1, 1));
189 /*
190 * Fix for BugTraq Id 4260109.
191 * Set the text limit to the maximum.
192 * Use EM_EXLIMITTEXT for RichEdit controls.
193 * For some reason RichEdit 1.0 becomes read-only if the
194 * specified limit is greater than 0x7FFFFFFD.
195 */
196 c->SendMessage(EM_EXLIMITTEXT, 0, 0x7FFFFFFD);
197
198 /* Unregister RichEdit built-in drop target. */
199 VERIFY(::RevokeDragDrop(c->GetHWnd()) != DRAGDROP_E_INVALIDHWND);
200
201 /* To enforce CF_TEXT format for paste operations. */
202 VERIFY(c->SendMessage(EM_SETOLECALLBACK, 0,
203 (LPARAM)&GetOleCallback()));
204
205 c->SendMessage(EM_SETEVENTMASK, 0, ENM_CHANGE);
206 }
207 } catch (...) {
208 env->DeleteLocalRef(target);
209 throw;
210 }
211
212 done:
213 env->DeleteLocalRef(target);
214
215 return c;
216 }
217
218 void AwtTextComponent::Dispose()
219 {
220 if (m_hEditCtrl != NULL) {
221 VERIFY(::DestroyWindow(m_hEditCtrl));
222 m_hEditCtrl = NULL;
223 }
224 AwtComponent::Dispose();
225 }
226
227
228 LRESULT
229 AwtTextComponent::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) {
230
231 switch (message) {
232 case WM_PRINTCLIENT:
233 {
234 FORMATRANGE fr;
235 HDC hPrinterDC = (HDC)wParam;
236 int nHorizRes = ::GetDeviceCaps(hPrinterDC, HORZRES);
237 int nVertRes = ::GetDeviceCaps(hPrinterDC, VERTRES);
238 int nLogPixelsX = ::GetDeviceCaps(hPrinterDC, LOGPIXELSX);
239 int nLogPixelsY = ::GetDeviceCaps(hPrinterDC, LOGPIXELSY);
240
241 // Ensure the printer DC is in MM_TEXT mode.
242 ::SetMapMode ( hPrinterDC, MM_TEXT );
243
244 // Rendering to the same DC we are measuring.
245 ::ZeroMemory(&fr, sizeof(fr));
246 fr.hdc = fr.hdcTarget = hPrinterDC;
247 // Set up the page.
248 fr.rcPage.left = fr.rcPage.top = 0;
249 fr.rcPage.right = (nHorizRes/nLogPixelsX) * 1440; // in twips
250 fr.rcPage.bottom = (nVertRes/nLogPixelsY) * 1440;
251 fr.rc.left = fr.rcPage.left;
252 fr.rc.top = fr.rcPage.top;
253 fr.rc.right = fr.rcPage.right;
254 fr.rc.bottom = fr.rcPage.bottom;
255
256 // start printing from the first visible line
257 LRESULT nLine = SendMessage(EM_GETFIRSTVISIBLELINE, 0, 0);
258 LONG startCh = static_cast<LONG>(SendMessage(EM_LINEINDEX,
259 (WPARAM)nLine, 0));
260 fr.chrg.cpMin = startCh;
261 fr.chrg.cpMax = -1;
262
263 SendMessage(EM_FORMATRANGE, TRUE, (LPARAM)&fr);
264 }
265
266 break;
267 }
268
269 return AwtComponent::WindowProc(message, wParam, lParam);
270 }
271
272 LONG AwtTextComponent::EditGetCharFromPos(POINT& pt) {
273 return static_cast<LONG>(SendMessage(EM_CHARFROMPOS, 0,
274 reinterpret_cast<LPARAM>(&pt)));
275 }
276
277 /* Set a suitable font to IME against the component font. */
278 void AwtTextComponent::SetFont(AwtFont* font)
279 {
280 DASSERT(font != NULL);
281 if (font->GetAscent() < 0) {
282 AwtFont::SetupAscent(font);
283 }
284
285 int index = font->GetInputHFontIndex();
286 if (index < 0)
287 /* In this case, user cannot get any suitable font for input. */
288 index = 0;
289
290 //im --- changed for over the spot composing
291 m_hFont = font->GetHFont(index);
292 SendMessage(WM_SETFONT, (WPARAM)m_hFont, MAKELPARAM(FALSE, 0));
293 SendMessage(EM_SETMARGINS, EC_LEFTMARGIN | EC_RIGHTMARGIN,
294 MAKELPARAM(1, 1));
295
296 /*
297 * WM_SETFONT reverts foreground color to the default for
298 * rich edit controls. So we have to restore it manually.
299 */
300 SetColor(GetColor());
301 VERIFY(::InvalidateRect(GetHWnd(), NULL, TRUE));
302 //im --- end
303
304 }
305
306 int AwtTextComponent::RemoveCR(WCHAR *pStr)
307 {
308 int i, nLen = 0;
309
310 if (pStr) {
311 /* check to see if there are any CR's */
312 if (wcschr(pStr, L'\r') == NULL) {
313 return static_cast<int>(wcslen(pStr));
314 }
315
316 for (i=0; pStr[i] != 0; i++) {
317 if (m_isLFonly == TRUE) {
318 if (pStr[i] == L'\r') {
319 continue;
320 }
321 } else {
322 if (pStr[i] == L'\r' && pStr[i + 1] != L'\n') {
323 continue;
324 }
325 }
326 pStr[nLen++] = pStr[i];
327 }
328 pStr[nLen] = 0;
329 }
330 return nLen;
331 }
332
333 MsgRouting
334 AwtTextComponent::WmNotify(UINT notifyCode)
335 {
336 if (notifyCode == EN_CHANGE) {
337 /*
338 * Ignore notifications if the text hasn't been changed.
339 * EN_CHANGE sent on character formatting changes as well.
340 */
341 if (m_bIgnoreEnChange == FALSE) {
342 m_bCanUndo = TRUE;
343 DoCallback("valueChanged", "()V");
344 } else {
345 m_bCanUndo = FALSE;
346 }
347 }
348 return mrDoDefault;
349 }
350
351 BOOL AwtTextComponent::IsFocusingMouseMessage(MSG *pMsg)
352 {
353 return pMsg->message == WM_LBUTTONDOWN || pMsg->message == WM_LBUTTONDBLCLK;
354 }
355
356 MsgRouting
357 AwtTextComponent::HandleEvent(MSG *msg, BOOL synthetic)
358 {
359 MsgRouting returnVal;
360
361 if (msg->message == WM_RBUTTONUP ||
362 (msg->message == WM_SYSKEYDOWN && msg->wParam == VK_F10 &&
363 HIBYTE(::GetKeyState(VK_SHIFT)))) {
364 POINT p;
365 if (msg->message == WM_RBUTTONUP) {
366 VERIFY(::GetCursorPos(&p));
367 } else {
368 p.x = -1;
369 p.y = -1;
370 }
371
372 if (!::PostMessage(GetHWnd(), WM_CONTEXTMENU, (WPARAM)GetHWnd(),
373 MAKELPARAM(p.x, p.y))) {
374 JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
375 JNU_ThrowInternalError(env, "Message not posted, native event queue may be full.");
376 env->ExceptionDescribe();
377 env->ExceptionClear();
378 }
379 delete msg;
380 return mrConsume;
381 }
382
383 /*
384 * Store the 'synthetic' parameter so that the WM_PASTE security check
385 * happens only for synthetic events.
386 */
387 m_synthetic = synthetic;
388 returnVal = AwtComponent::HandleEvent(msg, synthetic);
389 m_synthetic = FALSE;
390 return returnVal;
391 }
392
393 /*
394 * If this Paste is occurring because of a synthetic Java event (e.g.,
395 * a synthesized <CTRL>-V KeyEvent), then verify that the TextComponent
396 * has permission to access the Clipboard before pasting. If permission
397 * is denied, we should throw a SecurityException, but currently do not
398 * because when we detect the security violation, we are in the Toolkit
399 * thread, not the thread which dispatched the illegal event.
400 */
401 MsgRouting
402 AwtTextComponent::WmPaste()
403 {
404 if (m_synthetic) {
405 JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
406 if (env->EnsureLocalCapacity(1) < 0) {
407 return mrConsume;
408 }
409 jobject target = GetTarget(env);
410 jboolean canAccessClipboard =
411 env->CallBooleanMethod (target, AwtTextComponent::canAccessClipboardMID);
412 env->DeleteLocalRef(target);
413 return (canAccessClipboard) ? mrDoDefault : mrConsume;
414 }
415 else {
416 return mrDoDefault;
417 }
418 }
419
420 //im --- override to over the spot composition
421 void AwtTextComponent::SetCompositionWindow(RECT& rc)
422 {
423 HWND hwnd = ImmGetHWnd();
424 HIMC hIMC = ImmGetContext(hwnd);
425 // rc is not used for text component.
426 COMPOSITIONFORM cf = { CFS_FORCE_POSITION, {0,0}, {0,0,0,0} };
427 GetCaretPos(&(cf.ptCurrentPos));
428 // the proxy is the native focus owner and it contains the composition window
429 // let's convert the position to a coordinate space relative to proxy
430 ::MapWindowPoints(GetHWnd(), GetProxyFocusOwner(), (LPPOINT)&cf.ptCurrentPos, 1);
431 ImmSetCompositionWindow(hIMC, &cf);
432
433 LOGFONT lf;
434 GetObject(m_hFont, sizeof(LOGFONT), &lf);
435 ImmSetCompositionFont(hIMC, &lf);
436 ImmReleaseContext(hwnd, hIMC);
437 }
438 //im --- end
439
440 LONG AwtTextComponent::getJavaSelPos(LONG orgPos)
441 {
442 long wlen;
443 long pos = 0;
444 long cur = 0;
445 LPTSTR wbuf;
446
447 if ((wlen = GetTextLength()) == 0)
448 return 0;
449 wbuf = new TCHAR[wlen + 1];
450 GetText(wbuf, wlen + 1);
451 if (m_isLFonly == TRUE) {
452 wlen = RemoveCR(wbuf);
453 }
454
455 while (cur < orgPos && pos++ < wlen) {
456 if (wbuf[cur] == _T('\r') && wbuf[cur + 1] == _T('\n')) {
457 cur++;
458 }
459 cur++;
460 }
461 delete[] wbuf;
462 return pos;
463 }
464
465 LONG AwtTextComponent::getWin32SelPos(LONG orgPos)
466 {
467 long wlen;
468 long pos = 0;
469 long cur = 0;
470 LPTSTR wbuf;
471
472 if ((wlen = GetTextLength()) == 0)
473 return 0;
474 wbuf = new TCHAR[wlen + 1];
475 GetText(wbuf, wlen + 1);
476 if (m_isLFonly == TRUE) {
477 RemoveCR(wbuf);
478 }
479
480 while (cur < orgPos && pos < wlen) {
481 if (wbuf[pos] == _T('\r') && wbuf[pos + 1] == _T('\n')) {
482 pos++;
483 }
484 pos++;
485 cur++;
486 }
487 delete[] wbuf;
488 return pos;
489 }
490
491 void AwtTextComponent::CheckLineSeparator(WCHAR *pStr)
492 {
493 if (pStr == NULL) {
494 return;
495 }
496
497 if (GetTextLength() == 0) {
498 m_EOLchecked = FALSE;
499 }
500
501 // check to see if there are any LF's
502 if (m_EOLchecked == TRUE || wcschr(pStr, L'\n') == NULL) {
503 return;
504 }
505
506 for (int i=0; pStr[i] != 0; i++) {
507 if (pStr[i] == L'\n') {
508 if (i > 0 && pStr[i-1] == L'\r') {
509 m_isLFonly = FALSE;
510 } else {
511 m_isLFonly = TRUE;
512 }
513 m_EOLchecked = TRUE;
514 return;
515 }
516 }
517 }
518
519 void AwtTextComponent::SetSelRange(LONG start, LONG end)
520 {
521 SendMessage(EM_SETSEL,
522 getWin32SelPos(start),
523 getWin32SelPos(end));
524 // it isn't necessary to wrap this in EM_HIDESELECTION or setting/clearing
525 // ES_NOHIDESEL, as regular edit control honors EM_SCROLLCARET even when not in focus
526 }
527
528 jstring AwtTextComponent::_GetText(void *param)
529 {
530 JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
531
532 jobject self = (jobject)param;
533
534 AwtTextComponent *c = NULL;
535 jstring result = NULL;
536
537 PDATA pData;
538 JNI_CHECK_PEER_GOTO(self, ret);
539
540 c = (AwtTextComponent *)pData;
541 if (::IsWindow(c->GetHWnd()))
542 {
543 int len = ::GetWindowTextLength(c->GetHWnd());
544 if (len == 0) {
545 /* Make java null string */
546 jchar *jc = new jchar[0];
547 result = env->NewString(jc, 0);
548 delete [] jc;
549 } else {
550 WCHAR* buf = new WCHAR[len + 1];
551 c->GetText(buf, len + 1);
552 c->RemoveCR(buf);
553 result = JNU_NewStringPlatform(env, buf);
554 delete [] buf;
555 }
556 }
557 ret:
558 env->DeleteGlobalRef(self);
559
560 if (result != NULL)
561 {
562 jstring globalRef = (jstring)env->NewGlobalRef(result);
563 env->DeleteLocalRef(result);
564 return globalRef;
565 }
566 else
567 {
568 return NULL;
569 }
570 }
571
572 void AwtTextComponent::_SetText(void *param)
573 {
574 JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
575
576 SetTextStruct *sts = (SetTextStruct *)param;
577 jobject self = sts->textcomponent;
578 jstring text = sts->text;
579
580 AwtTextComponent *c = NULL;
581
582 PDATA pData;
583 JNI_CHECK_PEER_GOTO(self, ret);
584 c = (AwtTextComponent *)pData;
585 if (::IsWindow(c->GetHWnd()))
586 {
587 int length = env->GetStringLength(text);
588 WCHAR* buffer = new WCHAR[length + 1];
589 env->GetStringRegion(text, 0, length, reinterpret_cast<jchar*>(buffer));
590 buffer[length] = 0;
591 c->CheckLineSeparator(buffer);
592 c->RemoveCR(buffer);
593 c->SetText(buffer);
594 delete[] buffer;
595 }
596 ret:
597 env->DeleteGlobalRef(self);
598 env->DeleteGlobalRef(text);
599
600 delete sts;
601 }
602
603 jint AwtTextComponent::_GetSelectionStart(void *param)
604 {
605 JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
606
607 jobject self = (jobject)param;
608
609 jint result = 0;
610 AwtTextComponent *c = NULL;
611
612 PDATA pData;
613 JNI_CHECK_PEER_GOTO(self, ret);
614 c = (AwtTextComponent *)pData;
615 if (::IsWindow(c->GetHWnd()))
616 {
617 long start;
618 c->SendMessage(EM_GETSEL, (WPARAM)&start);
619 result = c->getJavaSelPos(start);
620 }
621 ret:
622 env->DeleteGlobalRef(self);
623
624 return result;
625 }
626
627 jint AwtTextComponent::_GetSelectionEnd(void *param)
628 {
629 JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
630
631 jobject self = (jobject)param;
632
633 jint result = 0;
634 AwtTextComponent *c = NULL;
635
636 PDATA pData;
637 JNI_CHECK_PEER_GOTO(self, ret);
638 c = (AwtTextComponent *)pData;
639 if (::IsWindow(c->GetHWnd()))
640 {
641 long end;
642 c->SendMessage(EM_GETSEL, 0, (LPARAM)&end);
643 result = c->getJavaSelPos(end);
644 }
645 ret:
646 env->DeleteGlobalRef(self);
647
648 return result;
649 }
650
651 void AwtTextComponent::_Select(void *param)
652 {
653 JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
654
655 SelectStruct *ss = (SelectStruct *)param;
656 jobject self = ss->textcomponent;
657 jint start = ss->start;
658 jint end = ss->end;
659
660 AwtTextComponent *c = NULL;
661
662 PDATA pData;
663 JNI_CHECK_PEER_GOTO(self, ret);
664 c = (AwtTextComponent *)pData;
665 if (::IsWindow(c->GetHWnd()))
666 {
667 c->SetSelRange(start, end);
668 c->SendMessage(EM_SCROLLCARET);
669 }
670 ret:
671 env->DeleteGlobalRef(self);
672
673 delete ss;
674 }
675
676 void AwtTextComponent::_EnableEditing(void *param)
677 {
678 JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
679
680 EnableEditingStruct *ees = (EnableEditingStruct *)param;
681 jobject self = ees->textcomponent;
682 jboolean on = ees->on;
683
684 AwtTextComponent *c = NULL;
685
686 PDATA pData;
687 JNI_CHECK_PEER_GOTO(self, ret);
688 c = (AwtTextComponent *)pData;
689 if (::IsWindow(c->GetHWnd()))
690 {
691 c->SendMessage(EM_SETREADONLY, !on);
692 }
693 ret:
694 env->DeleteGlobalRef(self);
695
696 delete ees;
697 }
698
699 /*
700 * Disabled edit control has grayed foreground.
701 * Disabled RichEdit 1.0 control has original foreground.
702 * Thus we have to set grayed foreground manually.
703 */
704 void AwtTextComponent::Enable(BOOL bEnable)
705 {
706 AwtComponent::Enable(bEnable);
707 SetColor(GetColor());
708 }
709
710
711 /*
712 * WM_CTLCOLOR is not sent by rich edit controls.
713 * Use EM_SETCHARFORMAT and EM_SETBKGNDCOLOR to set
714 * respectively foreground and background color.
715 */
716 void AwtTextComponent::SetColor(COLORREF c) {
717 AwtComponent::SetColor(c);
718
719 CHARFORMAT cf;
720 memset(&cf, 0, sizeof(cf));
721 cf.cbSize = sizeof(cf);
722 cf.dwMask = CFM_COLOR;
723
724 cf.crTextColor = ::IsWindowEnabled(GetHWnd()) ? GetColor() : ::GetSysColor(COLOR_3DSHADOW);
725
726 /*
727 * The documentation for EM_GETCHARFORMAT is not exactly
728 * correct. It appears that wParam has the same meaning
729 * as for EM_SETCHARFORMAT. Our task is to secure that
730 * all the characters in the control have the required
731 * formatting. That's why we use SCF_ALL.
732 */
733 VERIFY(SendMessage(EM_SETCHARFORMAT, SCF_ALL, (LPARAM)&cf));
734 VERIFY(SendMessage(EM_SETCHARFORMAT, SCF_DEFAULT, (LPARAM)&cf));
735 }
736
737 /*
738 * In responce to EM_SETBKGNDCOLOR rich edit changes
739 * its bg color and repaints itself so we don't need
740 * to force repaint.
741 */
742 void AwtTextComponent::SetBackgroundColor(COLORREF c) {
743 AwtComponent::SetBackgroundColor(c);
744 SendMessage(EM_SETBKGNDCOLOR, (WPARAM)FALSE, (LPARAM)GetBackgroundColor());
745 }
746
747 void AwtTextComponent::EditGetSel(CHARRANGE &cr) {
748 SendMessage(EM_EXGETSEL, 0, reinterpret_cast<LPARAM>(&cr));
749 }
750
751
752 /************************************************************************
753 * WTextComponentPeer native methods
754 */
755
756 extern "C" {
757
758 /*
759 * Class: sun_awt_windows_WTextComponentPeer
760 * Method: getText
761 * Signature: ()Ljava/lang/String;
762 */
763 JNIEXPORT jstring JNICALL
764 Java_sun_awt_windows_WTextComponentPeer_getText(JNIEnv *env, jobject self)
765 {
766 TRY;
767
768 jobject selfGlobalRef = env->NewGlobalRef(self);
769
770 jstring globalRef = (jstring)AwtToolkit::GetInstance().SyncCall(
771 (void*(*)(void*))AwtTextComponent::_GetText,
772 (void *)selfGlobalRef);
773 // selfGlobalRef is deleted in _GetText
774 if (globalRef != NULL)
775 {
776 jstring localRef = (jstring)env->NewLocalRef(globalRef);
777 env->DeleteGlobalRef(globalRef);
778 return localRef;
779 }
780 else
781 {
782 return NULL;
783 }
784
785 CATCH_BAD_ALLOC_RET(NULL);
786 }
787
788 /*
789 * Class: sun_awt_windows_WTextComponentPeer
790 * Method: setText
791 * Signature: (Ljava/lang/String;)V
792 */
793 JNIEXPORT void JNICALL
794 Java_sun_awt_windows_WTextComponentPeer_setText(JNIEnv *env, jobject self,
795 jstring text)
796 {
797 TRY;
798
799 SetTextStruct *sts = new SetTextStruct;
800 sts->textcomponent = env->NewGlobalRef(self);
801 sts->text = (jstring)env->NewGlobalRef(text);
802
803 AwtToolkit::GetInstance().SyncCall(AwtTextComponent::_SetText, sts);
804 // global refs and sts are deleted in _SetText
805
806 CATCH_BAD_ALLOC;
807 }
808
809 /*
810 * Class: sun_awt_windows_WTextComponentPeer
811 * Method: getSelectionStart
812 * Signature: ()I
813 */
814 JNIEXPORT jint JNICALL
815 Java_sun_awt_windows_WTextComponentPeer_getSelectionStart(JNIEnv *env,
816 jobject self)
817 {
818 TRY;
819
820 return static_cast<jint>(reinterpret_cast<INT_PTR>(AwtToolkit::GetInstance().SyncCall(
821 (void *(*)(void *))AwtTextComponent::_GetSelectionStart,
822 env->NewGlobalRef(self))));
823 // global ref is deleted in _GetSelectionStart()
824
825 CATCH_BAD_ALLOC_RET(0);
826 }
827
828 /*
829 * Class: sun_awt_windows_WTextComponentPeer
830 * Method: getSelectionEnd
831 * Signature: ()I
832 */
833 JNIEXPORT jint JNICALL
834 Java_sun_awt_windows_WTextComponentPeer_getSelectionEnd(JNIEnv *env,
835 jobject self)
836 {
837 TRY;
838
839 return static_cast<jint>(reinterpret_cast<INT_PTR>(AwtToolkit::GetInstance().SyncCall(
840 (void *(*)(void *))AwtTextComponent::_GetSelectionEnd,
841 env->NewGlobalRef(self))));
842 // global ref is deleted in _GetSelectionEnd()
843
844 CATCH_BAD_ALLOC_RET(0);
845 }
846
847 /*
848 * Class: sun_awt_windows_WTextComponentPeer
849 * Method: select
850 * Signature: (II)V
851 */
852 JNIEXPORT void JNICALL
853 Java_sun_awt_windows_WTextComponentPeer_select(JNIEnv *env, jobject self,
854 jint start, jint end)
855 {
856 TRY;
857
858 SelectStruct *ss = new SelectStruct;
859 ss->textcomponent = env->NewGlobalRef(self);
860 ss->start = start;
861 ss->end = end;
862
863 AwtToolkit::GetInstance().SyncCall(AwtTextComponent::_Select, ss);
864 // global ref and ss are deleted in _Select
865
866 CATCH_BAD_ALLOC;
867 }
868
869 /*
870 * Class: sun_awt_windows_WTextComponentPeer
871 * Method: enableEditing
872 * Signature: (Z)V
873 */
874 JNIEXPORT void JNICALL
875 Java_sun_awt_windows_WTextComponentPeer_enableEditing(JNIEnv *env,
876 jobject self,
877 jboolean on)
878 {
879 TRY;
880
881 EnableEditingStruct *ees = new EnableEditingStruct;
882 ees->textcomponent = env->NewGlobalRef(self);
883 ees->on = on;
884
885 AwtToolkit::GetInstance().SyncCall(AwtTextComponent::_EnableEditing, ees);
886 // global ref and ees are deleted in _EnableEditing()
887
888 CATCH_BAD_ALLOC;
889 }
890
891 /*
892 * Class: sun_awt_windows_WTextComponentPeer
893 * Method: initIDs
894 * Signature: ()V
895 */
896 JNIEXPORT void JNICALL
897 Java_sun_awt_windows_WTextComponentPeer_initIDs(JNIEnv *env, jclass cls)
898 {
899 TRY;
900
901 jclass textComponentClassID = env->FindClass("java/awt/TextComponent");
902 CHECK_NULL(textComponentClassID);
903
904 AwtTextComponent::canAccessClipboardMID =
905 env->GetMethodID(textComponentClassID, "canAccessClipboard", "()Z");
906 env->DeleteLocalRef(textComponentClassID);
907
908 DASSERT(AwtTextComponent::canAccessClipboardMID != NULL);
909
910 CATCH_BAD_ALLOC;
911 }
912
913
914 AwtTextComponent::OleCallback AwtTextComponent::sm_oleCallback;
915
916 /************************************************************************
917 * Inner class OleCallback definition.
918 */
919
920 AwtTextComponent::OleCallback::OleCallback() {
921 m_refs = 0;
922 AddRef();
923 }
924
925 STDMETHODIMP
926 AwtTextComponent::OleCallback::QueryInterface(REFIID riid, LPVOID * ppvObj) {
927 if (::IsEqualIID(riid, IID_IUnknown) ||::IsEqualIID(riid, IID_IRichEditOleCallback) ) {
928 *ppvObj = static_cast<IRichEditOleCallback*>(this);
929 AddRef();
930 return S_OK;
931 }
932 *ppvObj = NULL;
933 return E_NOINTERFACE;
934 }
935
936
937 STDMETHODIMP_(ULONG)
938 AwtTextComponent::OleCallback::AddRef() {
939 return ++m_refs;
940 }
941
942 STDMETHODIMP_(ULONG)
943 AwtTextComponent::OleCallback::Release() {
944 return (ULONG)--m_refs;
945 }
946
947 STDMETHODIMP
948 AwtTextComponent::OleCallback::GetNewStorage(LPSTORAGE FAR * ppstg) {
949 return E_NOTIMPL;
950 }
951
952 STDMETHODIMP
953 AwtTextComponent::OleCallback::GetInPlaceContext(LPOLEINPLACEFRAME FAR * ppipframe,
954 LPOLEINPLACEUIWINDOW FAR* ppipuiDoc,
955 LPOLEINPLACEFRAMEINFO pipfinfo)
956 {
957 return E_NOTIMPL;
958 }
959
960 STDMETHODIMP
961 AwtTextComponent::OleCallback::ShowContainerUI(BOOL fShow) {
962 return E_NOTIMPL;
963 }
964
965 STDMETHODIMP
966 AwtTextComponent::OleCallback::QueryInsertObject(LPCLSID pclsid,
967 LPSTORAGE pstg,
968 LONG cp) {
969 return S_OK;
970 }
971
972 STDMETHODIMP
973 AwtTextComponent::OleCallback::DeleteObject(LPOLEOBJECT poleobj) {
974 return S_OK;
975 }
976
977 STDMETHODIMP
978 AwtTextComponent::OleCallback::QueryAcceptData(LPDATAOBJECT pdataobj,
979 CLIPFORMAT *pcfFormat,
980 DWORD reco,
981 BOOL fReally,
982 HGLOBAL hMetaPict) {
983 if (reco == RECO_PASTE) {
984 // If CF_TEXT format is available edit controls will select it,
985 // otherwise if it is CF_UNICODETEXT is available it will be
986 // selected, otherwise if CF_OEMTEXT is available it will be selected.
987 if (::IsClipboardFormatAvailable(CF_TEXT)) {
988 *pcfFormat = CF_TEXT;
989 } else if (::IsClipboardFormatAvailable(CF_UNICODETEXT)) {
990 *pcfFormat = CF_UNICODETEXT;
991 } else if (::IsClipboardFormatAvailable(CF_OEMTEXT)) {
992 *pcfFormat = CF_OEMTEXT;
993 } else {
994 // Don't allow rich edit to paste clipboard data
995 // in other formats.
996 *pcfFormat = CF_TEXT;
997 }
998 }
999
1000 return S_OK;
1001 }
1002
1003 STDMETHODIMP
1004 AwtTextComponent::OleCallback::ContextSensitiveHelp(BOOL fEnterMode) {
1005 return S_OK;
1006 }
1007
1008 STDMETHODIMP
1009 AwtTextComponent::OleCallback::GetClipboardData(CHARRANGE *pchrg,
1010 DWORD reco,
1011 LPDATAOBJECT *ppdataobj) {
1012 return E_NOTIMPL;
1013 }
1014
1015 STDMETHODIMP
1016 AwtTextComponent::OleCallback::GetDragDropEffect(BOOL fDrag,
1017 DWORD grfKeyState,
1018 LPDWORD pdwEffect) {
1019
1020 return E_NOTIMPL;
1021 }
1022
1023
1024 STDMETHODIMP
1025 AwtTextComponent::OleCallback::GetContextMenu(WORD seltype,
1026 LPOLEOBJECT lpoleobj,
1027 CHARRANGE FAR * lpchrg,
1028 HMENU FAR * lphmenu) {
1029 return E_NOTIMPL;
1030 }
1031
1032
1033 /*
1034 * This routine is a window procedure for the subclass of the standard edit control
1035 * used to generate context menu. RichEdit controls don't have built-in context menu.
1036 * To implement this functionality we have to create an invisible edit control and
1037 * forward WM_CONTEXTMENU messages from a RichEdit control to this helper edit control.
1038 * While the edit control context menu is active we intercept the message generated in
1039 * response to particular item selection and forward it back to the RichEdit control.
1040 * (See AwtTextArea::WmContextMenu for more details).
1041 */
1042
1043 WNDPROC AwtTextComponent::sm_pDefWindowProc = NULL;
1044
1045 LRESULT
1046 AwtTextComponent::EditProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
1047
1048 static BOOL bContextMenuActive = FALSE;
1049
1050 LRESULT retValue = 0;
1051 MsgRouting mr = mrDoDefault;
1052
1053 DASSERT(::IsWindow(::GetParent(hWnd)));
1054
1055 switch (message) {
1056 case WM_UNDO:
1057 case WM_CUT:
1058 case WM_COPY:
1059 case WM_PASTE:
1060 case WM_CLEAR:
1061 case EM_SETSEL:
1062 if (bContextMenuActive) {
1063 ::SendMessage(::GetParent(hWnd), message, wParam, lParam);
1064 mr = mrConsume;
1065 }
1066 break;
1067 case WM_CONTEXTMENU:
1068 bContextMenuActive = TRUE;
1069 break;
1070 }
1071
1072 if (mr == mrDoDefault) {
1073 DASSERT(sm_pDefWindowProc != NULL);
1074 retValue = ::CallWindowProc(sm_pDefWindowProc,
1075 hWnd, message, wParam, lParam);
1076 }
1077
1078 if (message == WM_CONTEXTMENU) {
1079 bContextMenuActive = FALSE;
1080 }
1081
1082 return retValue;
1083 }
1084
1085 MsgRouting
1086 AwtTextComponent::WmContextMenu(HWND hCtrl, UINT xPos, UINT yPos) {
1087 /* Use the system provided edit control class to generate context menu. */
1088 if (m_hEditCtrl == NULL) {
1089 DWORD dwStyle = WS_CHILD;
1090 DWORD dwExStyle = 0;
1091 m_hEditCtrl = ::CreateWindowEx(dwExStyle,
1092 L"EDIT",
1093 L"TEXT",
1094 dwStyle,
1095 0, 0, 0, 0,
1096 GetHWnd(),
1097 reinterpret_cast<HMENU>(
1098 static_cast<INT_PTR>(
1099 CreateControlID())),
1100 AwtToolkit::GetInstance().GetModuleHandle(),
1101 NULL);
1102 DASSERT(m_hEditCtrl != NULL);
1103 if (sm_pDefWindowProc == NULL) {
1104 sm_pDefWindowProc = (WNDPROC)::GetWindowLongPtr(m_hEditCtrl,
1105 GWLP_WNDPROC);
1106 }
1107 ::SetLastError(0);
1108 INT_PTR ret = ::SetWindowLongPtr(m_hEditCtrl, GWLP_WNDPROC,
1109 (INT_PTR)AwtTextArea::EditProc);
1110 DASSERT(ret != 0 || ::GetLastError() == 0);
1111 }
1112
1113 /*
1114 * Tricks on the edit control to ensure that its context menu has
1115 * the correct set of enabled items according to the RichEdit state.
1116 */
1117 ::SetWindowText(m_hEditCtrl, TEXT("TEXT"));
1118
1119 if (m_bCanUndo == TRUE && SendMessage(EM_CANUNDO)) {
1120 /* Enable 'Undo' item. */
1121 ::SendMessage(m_hEditCtrl, WM_CHAR, 'A', 0);
1122 }
1123
1124 {
1125 /*
1126 * Initial selection for the edit control - (0,1).
1127 * This enables 'Cut', 'Copy' and 'Delete' and 'Select All'.
1128 */
1129 INT nStart = 0;
1130 INT nEnd = 1;
1131 if (SendMessage(EM_SELECTIONTYPE) == SEL_EMPTY) {
1132 /*
1133 * RichEdit selection is empty - clear selection of the edit control.
1134 * This disables 'Cut', 'Copy' and 'Delete'.
1135 */
1136 nStart = -1;
1137 nEnd = 0;
1138 } else {
1139
1140 CHARRANGE cr;
1141 EditGetSel(cr);
1142 /* Check if all the text is selected. */
1143 if (cr.cpMin == 0) {
1144
1145 int len = ::GetWindowTextLength(GetHWnd());
1146 if (cr.cpMin == 0 && cr.cpMax >= len) {
1147 /*
1148 * All the text is selected in RichEdit - select all the
1149 * text in the edit control. This disables 'Select All'.
1150 */
1151 nStart = 0;
1152 nEnd = -1;
1153 }
1154 }
1155 }
1156 ::SendMessage(m_hEditCtrl, EM_SETSEL, (WPARAM)nStart, (LPARAM)nEnd);
1157 }
1158
1159 /* Disable 'Paste' item if the RichEdit control is read-only. */
1160 ::SendMessage(m_hEditCtrl, EM_SETREADONLY,
1161 GetStyle() & ES_READONLY ? TRUE : FALSE, 0);
1162
1163 POINT p;
1164 p.x = xPos;
1165 p.y = yPos;
1166
1167 /*
1168 * If the context menu is requested with SHIFT+F10 or VK_APPS key,
1169 * we position its top left corner to the center of the RichEdit
1170 * client rect.
1171 */
1172 if (p.x == -1 && p.y == -1) {
1173 RECT r;
1174 VERIFY(::GetClientRect(GetHWnd(), &r));
1175 p.x = (r.left + r.right) / 2;
1176 p.y = (r.top + r.bottom) / 2;
1177 VERIFY(::ClientToScreen(GetHWnd(), &p));
1178 }
1179
1180 // The context menu steals focus from the proxy.
1181 // So, set the focus-restore flag up.
1182 SetRestoreFocus(TRUE);
1183 ::SendMessage(m_hEditCtrl, WM_CONTEXTMENU, (WPARAM)m_hEditCtrl, MAKELPARAM(p.x, p.y));
1184 SetRestoreFocus(FALSE);
1185
1186 return mrConsume;
1187 }
1188
1189 //
1190 // Accessibility support
1191 //
1192
1193 // [[[FIXME]]] need to switch to rich edit field; look for EN_SELCHANGE event instead
1194 /*
1195 * Handle WmKeyDown to catch keystrokes which may move the caret,
1196 * and fire events as appropriate when that happens, if they are wanted
1197 *
1198 * Note: mouse clicks come through WmKeyDown as well (do they??!?!)
1199 *
1200 MsgRouting AwtTextComponent::WmKeyDown(UINT wkey, UINT repCnt,
1201 UINT flags, BOOL system) {
1202
1203 printf("AwtTextComponent::WmKeyDown called\r\n");
1204
1205
1206 // NOTE: WmKeyDown won't be processed 'till well after we return
1207 // so we need to modify the values based on the keystroke
1208 //
1209 static long oldStart = -1;
1210 static long oldEnd = -1;
1211
1212 // most keystrokes can move the caret
1213 // so we'll simply check to see if the caret has moved!
1214 if (javaEventsMask & (jlong) java_awt_TextComponent_textSelectionMask) {
1215 long start;
1216 long end;
1217 SendMessage(EM_GETSEL, (WPARAM)&start, (LPARAM)&end);
1218 if (start != oldStart || end != oldEnd) {
1219
1220 printf(" -> calling TextComponent.selectionValuesChanged()\r\n");
1221 printf(" -> old = (%d, %d); new = (%d, %d)\r\n",
1222 oldStart, oldEnd, start, end);
1223
1224 DoCallback("selectionValuesChanged", "(II)V", start, end); // let Java-side track details...
1225 oldStart = start;
1226 oldEnd = end;
1227 }
1228 }
1229
1230 return AwtComponent::WmKeyDown(wkey, repCnt, flags, system);
1231 }
1232 */
1233 } /* extern "C" */