The Tor Browser / file comparison

comparison: widget/windows/nsIMM32Handler.cpp

widget/windows/nsIMM32Handler.cpp

branch
TOR_BUG_9701
changeset 10
ac0c01689b40
equal deleted inserted replaced
-1:000000000000 0:de2f854eb72d
1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim:set ts=2 sts=2 sw=2 et cin: */
3 /* This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6
7 #ifdef MOZ_LOGGING
8 #define FORCE_PR_LOG /* Allow logging in the release build */
9 #endif // MOZ_LOGGING
10 #include "prlog.h"
11
12 #include "nsIMM32Handler.h"
13 #include "nsWindow.h"
14 #include "nsWindowDefs.h"
15 #include "WinUtils.h"
16 #include "KeyboardLayout.h"
17 #include <algorithm>
18
19 #include "mozilla/MiscEvents.h"
20 #include "mozilla/TextEvents.h"
21
22 using namespace mozilla;
23 using namespace mozilla::widget;
24
25 static nsIMM32Handler* gIMM32Handler = nullptr;
26
27 #ifdef PR_LOGGING
28 PRLogModuleInfo* gIMM32Log = nullptr;
29 #endif
30
31 static UINT sWM_MSIME_MOUSE = 0; // mouse message for MSIME 98/2000
32
33 //-------------------------------------------------------------------------
34 //
35 // from http://download.microsoft.com/download/6/0/9/60908e9e-d2c1-47db-98f6-216af76a235f/msime.h
36 // The document for this has been removed from MSDN...
37 //
38 //-------------------------------------------------------------------------
39
40 #define RWM_MOUSE TEXT("MSIMEMouseOperation")
41
42 #define IMEMOUSE_NONE 0x00 // no mouse button was pushed
43 #define IMEMOUSE_LDOWN 0x01
44 #define IMEMOUSE_RDOWN 0x02
45 #define IMEMOUSE_MDOWN 0x04
46 #define IMEMOUSE_WUP 0x10 // wheel up
47 #define IMEMOUSE_WDOWN 0x20 // wheel down
48
49 UINT nsIMM32Handler::sCodePage = 0;
50 DWORD nsIMM32Handler::sIMEProperty = 0;
51
52 /* static */ void
53 nsIMM32Handler::EnsureHandlerInstance()
54 {
55 if (!gIMM32Handler) {
56 gIMM32Handler = new nsIMM32Handler();
57 }
58 }
59
60 /* static */ void
61 nsIMM32Handler::Initialize()
62 {
63 #ifdef PR_LOGGING
64 if (!gIMM32Log)
65 gIMM32Log = PR_NewLogModule("nsIMM32HandlerWidgets");
66 #endif
67
68 if (!sWM_MSIME_MOUSE) {
69 sWM_MSIME_MOUSE = ::RegisterWindowMessage(RWM_MOUSE);
70 }
71 InitKeyboardLayout(::GetKeyboardLayout(0));
72 }
73
74 /* static */ void
75 nsIMM32Handler::Terminate()
76 {
77 if (!gIMM32Handler)
78 return;
79 delete gIMM32Handler;
80 gIMM32Handler = nullptr;
81 }
82
83 /* static */ bool
84 nsIMM32Handler::IsComposingOnOurEditor()
85 {
86 return gIMM32Handler && gIMM32Handler->mIsComposing;
87 }
88
89 /* static */ bool
90 nsIMM32Handler::IsComposingOnPlugin()
91 {
92 return gIMM32Handler && gIMM32Handler->mIsComposingOnPlugin;
93 }
94
95 /* static */ bool
96 nsIMM32Handler::IsComposingWindow(nsWindow* aWindow)
97 {
98 return gIMM32Handler && gIMM32Handler->mComposingWindow == aWindow;
99 }
100
101 /* static */ bool
102 nsIMM32Handler::IsTopLevelWindowOfComposition(nsWindow* aWindow)
103 {
104 if (!gIMM32Handler || !gIMM32Handler->mComposingWindow) {
105 return false;
106 }
107 HWND wnd = gIMM32Handler->mComposingWindow->GetWindowHandle();
108 return WinUtils::GetTopLevelHWND(wnd, true) == aWindow->GetWindowHandle();
109 }
110
111 /* static */ bool
112 nsIMM32Handler::ShouldDrawCompositionStringOurselves()
113 {
114 // If current IME has special UI or its composition window should not
115 // positioned to caret position, we should now draw composition string
116 // ourselves.
117 return !(sIMEProperty & IME_PROP_SPECIAL_UI) &&
118 (sIMEProperty & IME_PROP_AT_CARET);
119 }
120
121 /* static */ void
122 nsIMM32Handler::InitKeyboardLayout(HKL aKeyboardLayout)
123 {
124 WORD langID = LOWORD(aKeyboardLayout);
125 ::GetLocaleInfoW(MAKELCID(langID, SORT_DEFAULT),
126 LOCALE_IDEFAULTANSICODEPAGE | LOCALE_RETURN_NUMBER,
127 (PWSTR)&sCodePage, sizeof(sCodePage) / sizeof(WCHAR));
128 sIMEProperty = ::ImmGetProperty(aKeyboardLayout, IGP_PROPERTY);
129 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
130 ("IMM32: InitKeyboardLayout, aKeyboardLayout=%08x, sCodePage=%lu, "
131 "sIMEProperty=%08x",
132 aKeyboardLayout, sCodePage, sIMEProperty));
133 }
134
135 /* static */ UINT
136 nsIMM32Handler::GetKeyboardCodePage()
137 {
138 return sCodePage;
139 }
140
141 /* static */
142 nsIMEUpdatePreference
143 nsIMM32Handler::GetIMEUpdatePreference()
144 {
145 return nsIMEUpdatePreference(nsIMEUpdatePreference::NOTIFY_POSITION_CHANGE);
146 }
147
148 // used for checking the lParam of WM_IME_COMPOSITION
149 #define IS_COMPOSING_LPARAM(lParam) \
150 ((lParam) & (GCS_COMPSTR | GCS_COMPATTR | GCS_COMPCLAUSE | GCS_CURSORPOS))
151 #define IS_COMMITTING_LPARAM(lParam) ((lParam) & GCS_RESULTSTR)
152 // Some IMEs (e.g., the standard IME for Korean) don't have caret position,
153 // then, we should not set caret position to text event.
154 #define NO_IME_CARET -1
155
156 nsIMM32Handler::nsIMM32Handler() :
157 mComposingWindow(nullptr), mCursorPosition(NO_IME_CARET), mCompositionStart(0),
158 mIsComposing(false), mIsComposingOnPlugin(false),
159 mNativeCaretIsCreated(false)
160 {
161 PR_LOG(gIMM32Log, PR_LOG_ALWAYS, ("IMM32: nsIMM32Handler is created\n"));
162 }
163
164 nsIMM32Handler::~nsIMM32Handler()
165 {
166 if (mIsComposing) {
167 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
168 ("IMM32: ~nsIMM32Handler, ERROR, the instance is still composing\n"));
169 }
170 PR_LOG(gIMM32Log, PR_LOG_ALWAYS, ("IMM32: nsIMM32Handler is destroyed\n"));
171 }
172
173 nsresult
174 nsIMM32Handler::EnsureClauseArray(int32_t aCount)
175 {
176 NS_ENSURE_ARG_MIN(aCount, 0);
177 mClauseArray.SetCapacity(aCount + 32);
178 return NS_OK;
179 }
180
181 nsresult
182 nsIMM32Handler::EnsureAttributeArray(int32_t aCount)
183 {
184 NS_ENSURE_ARG_MIN(aCount, 0);
185 mAttributeArray.SetCapacity(aCount + 64);
186 return NS_OK;
187 }
188
189 /* static */ void
190 nsIMM32Handler::CommitComposition(nsWindow* aWindow, bool aForce)
191 {
192 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
193 ("IMM32: CommitComposition, aForce=%s, aWindow=%p, hWnd=%08x, mComposingWindow=%p%s\n",
194 aForce ? "TRUE" : "FALSE",
195 aWindow, aWindow->GetWindowHandle(),
196 gIMM32Handler ? gIMM32Handler->mComposingWindow : nullptr,
197 gIMM32Handler && gIMM32Handler->mComposingWindow ?
198 IsComposingOnOurEditor() ? " (composing on editor)" :
199 " (composing on plug-in)" : ""));
200 if (!aForce && !IsComposingWindow(aWindow)) {
201 return;
202 }
203
204 nsIMEContext IMEContext(aWindow->GetWindowHandle());
205 bool associated = IMEContext.AssociateDefaultContext();
206 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
207 ("IMM32: CommitComposition, associated=%s\n",
208 associated ? "YES" : "NO"));
209
210 if (IMEContext.IsValid()) {
211 ::ImmNotifyIME(IMEContext.get(), NI_COMPOSITIONSTR, CPS_COMPLETE, 0);
212 ::ImmNotifyIME(IMEContext.get(), NI_COMPOSITIONSTR, CPS_CANCEL, 0);
213 }
214
215 if (associated) {
216 IMEContext.Disassociate();
217 }
218 }
219
220 /* static */ void
221 nsIMM32Handler::CancelComposition(nsWindow* aWindow, bool aForce)
222 {
223 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
224 ("IMM32: CancelComposition, aForce=%s, aWindow=%p, hWnd=%08x, mComposingWindow=%p%s\n",
225 aForce ? "TRUE" : "FALSE",
226 aWindow, aWindow->GetWindowHandle(),
227 gIMM32Handler ? gIMM32Handler->mComposingWindow : nullptr,
228 gIMM32Handler && gIMM32Handler->mComposingWindow ?
229 IsComposingOnOurEditor() ? " (composing on editor)" :
230 " (composing on plug-in)" : ""));
231 if (!aForce && !IsComposingWindow(aWindow)) {
232 return;
233 }
234
235 nsIMEContext IMEContext(aWindow->GetWindowHandle());
236 bool associated = IMEContext.AssociateDefaultContext();
237 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
238 ("IMM32: CancelComposition, associated=%s\n",
239 associated ? "YES" : "NO"));
240
241 if (IMEContext.IsValid()) {
242 ::ImmNotifyIME(IMEContext.get(), NI_COMPOSITIONSTR, CPS_CANCEL, 0);
243 }
244
245 if (associated) {
246 IMEContext.Disassociate();
247 }
248 }
249
250 // static
251 void
252 nsIMM32Handler::OnUpdateComposition(nsWindow* aWindow)
253 {
254 if (!gIMM32Handler) {
255 return;
256 }
257
258 if (aWindow->PluginHasFocus()) {
259 return;
260 }
261
262 nsIMEContext IMEContext(aWindow->GetWindowHandle());
263 gIMM32Handler->SetIMERelatedWindowsPos(aWindow, IMEContext);
264 }
265
266
267 /* static */ bool
268 nsIMM32Handler::ProcessInputLangChangeMessage(nsWindow* aWindow,
269 WPARAM wParam,
270 LPARAM lParam,
271 MSGResult& aResult)
272 {
273 aResult.mResult = 0;
274 aResult.mConsumed = false;
275 // We don't need to create the instance of the handler here.
276 if (gIMM32Handler) {
277 gIMM32Handler->OnInputLangChange(aWindow, wParam, lParam, aResult);
278 }
279 InitKeyboardLayout(reinterpret_cast<HKL>(lParam));
280 // We can release the instance here, because the instance may be never
281 // used. E.g., the new keyboard layout may not use IME, or it may use TSF.
282 Terminate();
283 // Don't return as "processed", the messages should be processed on nsWindow
284 // too.
285 return false;
286 }
287
288 /* static */ bool
289 nsIMM32Handler::ProcessMessage(nsWindow* aWindow, UINT msg,
290 WPARAM &wParam, LPARAM &lParam,
291 MSGResult& aResult)
292 {
293 // XXX We store the composing window in mComposingWindow. If IME messages are
294 // sent to different window, we should commit the old transaction. And also
295 // if the new window handle is not focused, probably, we should not start
296 // the composition, however, such case should not be, it's just bad scenario.
297
298 // When a plug-in has focus or compsition, we should dispatch the IME events
299 // to the plug-in.
300 if (aWindow->PluginHasFocus() || IsComposingOnPlugin()) {
301 return ProcessMessageForPlugin(aWindow, msg, wParam, lParam, aResult);
302 }
303
304 aResult.mResult = 0;
305 switch (msg) {
306 case WM_LBUTTONDOWN:
307 case WM_MBUTTONDOWN:
308 case WM_RBUTTONDOWN: {
309 // We don't need to create the instance of the handler here.
310 if (!gIMM32Handler) {
311 return false;
312 }
313 return gIMM32Handler->OnMouseEvent(aWindow, lParam,
314 msg == WM_LBUTTONDOWN ? IMEMOUSE_LDOWN :
315 msg == WM_MBUTTONDOWN ? IMEMOUSE_MDOWN :
316 IMEMOUSE_RDOWN, aResult);
317 }
318 case WM_INPUTLANGCHANGE:
319 return ProcessInputLangChangeMessage(aWindow, wParam, lParam, aResult);
320 case WM_IME_STARTCOMPOSITION:
321 EnsureHandlerInstance();
322 return gIMM32Handler->OnIMEStartComposition(aWindow, aResult);
323 case WM_IME_COMPOSITION:
324 EnsureHandlerInstance();
325 return gIMM32Handler->OnIMEComposition(aWindow, wParam, lParam, aResult);
326 case WM_IME_ENDCOMPOSITION:
327 EnsureHandlerInstance();
328 return gIMM32Handler->OnIMEEndComposition(aWindow, aResult);
329 case WM_IME_CHAR:
330 return OnIMEChar(aWindow, wParam, lParam, aResult);
331 case WM_IME_NOTIFY:
332 return OnIMENotify(aWindow, wParam, lParam, aResult);
333 case WM_IME_REQUEST:
334 EnsureHandlerInstance();
335 return gIMM32Handler->OnIMERequest(aWindow, wParam, lParam, aResult);
336 case WM_IME_SELECT:
337 return OnIMESelect(aWindow, wParam, lParam, aResult);
338 case WM_IME_SETCONTEXT:
339 return OnIMESetContext(aWindow, wParam, lParam, aResult);
340 case WM_KEYDOWN:
341 return OnKeyDownEvent(aWindow, wParam, lParam, aResult);
342 case WM_CHAR:
343 if (!gIMM32Handler) {
344 return false;
345 }
346 return gIMM32Handler->OnChar(aWindow, wParam, lParam, aResult);
347 default:
348 return false;
349 };
350 }
351
352 /* static */ bool
353 nsIMM32Handler::ProcessMessageForPlugin(nsWindow* aWindow, UINT msg,
354 WPARAM &wParam, LPARAM &lParam,
355 MSGResult& aResult)
356 {
357 aResult.mResult = 0;
358 aResult.mConsumed = false;
359 switch (msg) {
360 case WM_INPUTLANGCHANGEREQUEST:
361 case WM_INPUTLANGCHANGE:
362 aWindow->DispatchPluginEvent(msg, wParam, lParam, false);
363 return ProcessInputLangChangeMessage(aWindow, wParam, lParam, aResult);
364 case WM_IME_COMPOSITION:
365 EnsureHandlerInstance();
366 return gIMM32Handler->OnIMECompositionOnPlugin(aWindow, wParam, lParam,
367 aResult);
368 case WM_IME_STARTCOMPOSITION:
369 EnsureHandlerInstance();
370 return gIMM32Handler->OnIMEStartCompositionOnPlugin(aWindow, wParam,
371 lParam, aResult);
372 case WM_IME_ENDCOMPOSITION:
373 EnsureHandlerInstance();
374 return gIMM32Handler->OnIMEEndCompositionOnPlugin(aWindow, wParam, lParam,
375 aResult);
376 case WM_IME_CHAR:
377 EnsureHandlerInstance();
378 return gIMM32Handler->OnIMECharOnPlugin(aWindow, wParam, lParam, aResult);
379 case WM_IME_SETCONTEXT:
380 return OnIMESetContextOnPlugin(aWindow, wParam, lParam, aResult);
381 case WM_CHAR:
382 if (!gIMM32Handler) {
383 return false;
384 }
385 return gIMM32Handler->OnCharOnPlugin(aWindow, wParam, lParam, aResult);
386 case WM_IME_COMPOSITIONFULL:
387 case WM_IME_CONTROL:
388 case WM_IME_KEYDOWN:
389 case WM_IME_KEYUP:
390 case WM_IME_REQUEST:
391 case WM_IME_SELECT:
392 aResult.mConsumed =
393 aWindow->DispatchPluginEvent(msg, wParam, lParam, false);
394 return true;
395 }
396 return false;
397 }
398
399 /****************************************************************************
400 * message handlers
401 ****************************************************************************/
402
403 void
404 nsIMM32Handler::OnInputLangChange(nsWindow* aWindow,
405 WPARAM wParam,
406 LPARAM lParam,
407 MSGResult& aResult)
408 {
409 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
410 ("IMM32: OnInputLangChange, hWnd=%08x, wParam=%08x, lParam=%08x\n",
411 aWindow->GetWindowHandle(), wParam, lParam));
412
413 aWindow->NotifyIME(REQUEST_TO_COMMIT_COMPOSITION);
414 NS_ASSERTION(!mIsComposing, "ResetInputState failed");
415
416 if (mIsComposing) {
417 HandleEndComposition(aWindow);
418 }
419
420 aResult.mConsumed = false;
421 }
422
423 bool
424 nsIMM32Handler::OnIMEStartComposition(nsWindow* aWindow,
425 MSGResult& aResult)
426 {
427 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
428 ("IMM32: OnIMEStartComposition, hWnd=%08x, mIsComposing=%s\n",
429 aWindow->GetWindowHandle(), mIsComposing ? "TRUE" : "FALSE"));
430 aResult.mConsumed = ShouldDrawCompositionStringOurselves();
431 if (mIsComposing) {
432 NS_WARNING("Composition has been already started");
433 return true;
434 }
435
436 nsIMEContext IMEContext(aWindow->GetWindowHandle());
437 HandleStartComposition(aWindow, IMEContext);
438 return true;
439 }
440
441 bool
442 nsIMM32Handler::OnIMEComposition(nsWindow* aWindow,
443 WPARAM wParam,
444 LPARAM lParam,
445 MSGResult& aResult)
446 {
447 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
448 ("IMM32: OnIMEComposition, hWnd=%08x, lParam=%08x, mIsComposing=%s\n",
449 aWindow->GetWindowHandle(), lParam, mIsComposing ? "TRUE" : "FALSE"));
450 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
451 ("IMM32: OnIMEComposition, GCS_RESULTSTR=%s, GCS_COMPSTR=%s, GCS_COMPATTR=%s, GCS_COMPCLAUSE=%s, GCS_CURSORPOS=%s\n",
452 lParam & GCS_RESULTSTR ? "YES" : "no",
453 lParam & GCS_COMPSTR ? "YES" : "no",
454 lParam & GCS_COMPATTR ? "YES" : "no",
455 lParam & GCS_COMPCLAUSE ? "YES" : "no",
456 lParam & GCS_CURSORPOS ? "YES" : "no"));
457
458 NS_PRECONDITION(!aWindow->PluginHasFocus(),
459 "OnIMEComposition should not be called when a plug-in has focus");
460
461 nsIMEContext IMEContext(aWindow->GetWindowHandle());
462 aResult.mConsumed = HandleComposition(aWindow, IMEContext, lParam);
463 return true;
464 }
465
466 bool
467 nsIMM32Handler::OnIMEEndComposition(nsWindow* aWindow,
468 MSGResult& aResult)
469 {
470 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
471 ("IMM32: OnIMEEndComposition, hWnd=%08x, mIsComposing=%s\n",
472 aWindow->GetWindowHandle(), mIsComposing ? "TRUE" : "FALSE"));
473
474 aResult.mConsumed = ShouldDrawCompositionStringOurselves();
475 if (!mIsComposing) {
476 return true;
477 }
478
479 // Korean IME posts WM_IME_ENDCOMPOSITION first when we hit space during
480 // composition. Then, we should ignore the message and commit the composition
481 // string at following WM_IME_COMPOSITION.
482 MSG compositionMsg;
483 if (WinUtils::PeekMessage(&compositionMsg, aWindow->GetWindowHandle(),
484 WM_IME_STARTCOMPOSITION, WM_IME_COMPOSITION,
485 PM_NOREMOVE) &&
486 compositionMsg.message == WM_IME_COMPOSITION &&
487 IS_COMMITTING_LPARAM(compositionMsg.lParam)) {
488 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
489 ("IMM32: OnIMEEndComposition, WM_IME_ENDCOMPOSITION is followed by "
490 "WM_IME_COMPOSITION, ignoring the message..."));
491 return true;
492 }
493
494 // Otherwise, e.g., ChangJie doesn't post WM_IME_COMPOSITION before
495 // WM_IME_ENDCOMPOSITION when composition string becomes empty.
496 // Then, we should dispatch a compositionupdate event, a text event and
497 // a compositionend event.
498 // XXX Shouldn't we dispatch the text event with actual or latest composition
499 // string?
500 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
501 ("IMM32: OnIMEEndComposition, mCompositionString=\"%s\"%s",
502 NS_ConvertUTF16toUTF8(mCompositionString).get(),
503 mCompositionString.IsEmpty() ? "" : ", but canceling it..."));
504
505 mCompositionString.Truncate();
506
507 nsIMEContext IMEContext(aWindow->GetWindowHandle());
508 DispatchTextEvent(aWindow, IMEContext, false);
509
510 HandleEndComposition(aWindow);
511
512 return true;
513 }
514
515 /* static */ bool
516 nsIMM32Handler::OnIMEChar(nsWindow* aWindow,
517 WPARAM wParam,
518 LPARAM lParam,
519 MSGResult& aResult)
520 {
521 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
522 ("IMM32: OnIMEChar, hWnd=%08x, char=%08x\n",
523 aWindow->GetWindowHandle(), wParam));
524
525 // We don't need to fire any text events from here. This method will be
526 // called when the composition string of the current IME is not drawn by us
527 // and some characters are committed. In that case, the committed string was
528 // processed in nsWindow::OnIMEComposition already.
529
530 // We need to consume the message so that Windows don't send two WM_CHAR msgs
531 aResult.mConsumed = true;
532 return true;
533 }
534
535 /* static */ bool
536 nsIMM32Handler::OnIMECompositionFull(nsWindow* aWindow,
537 MSGResult& aResult)
538 {
539 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
540 ("IMM32: OnIMECompositionFull, hWnd=%08x\n",
541 aWindow->GetWindowHandle()));
542
543 // not implement yet
544 aResult.mConsumed = false;
545 return true;
546 }
547
548 /* static */ bool
549 nsIMM32Handler::OnIMENotify(nsWindow* aWindow,
550 WPARAM wParam,
551 LPARAM lParam,
552 MSGResult& aResult)
553 {
554 #ifdef PR_LOGGING
555 switch (wParam) {
556 case IMN_CHANGECANDIDATE:
557 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
558 ("IMM32: OnIMENotify, hWnd=%08x, IMN_CHANGECANDIDATE, lParam=%08x\n",
559 aWindow->GetWindowHandle(), lParam));
560 break;
561 case IMN_CLOSECANDIDATE:
562 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
563 ("IMM32: OnIMENotify, hWnd=%08x, IMN_CLOSECANDIDATE, lParam=%08x\n",
564 aWindow->GetWindowHandle(), lParam));
565 break;
566 case IMN_CLOSESTATUSWINDOW:
567 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
568 ("IMM32: OnIMENotify, hWnd=%08x, IMN_CLOSESTATUSWINDOW\n",
569 aWindow->GetWindowHandle()));
570 break;
571 case IMN_GUIDELINE:
572 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
573 ("IMM32: OnIMENotify, hWnd=%08x, IMN_GUIDELINE\n",
574 aWindow->GetWindowHandle()));
575 break;
576 case IMN_OPENCANDIDATE:
577 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
578 ("IMM32: OnIMENotify, hWnd=%08x, IMN_OPENCANDIDATE, lParam=%08x\n",
579 aWindow->GetWindowHandle(), lParam));
580 break;
581 case IMN_OPENSTATUSWINDOW:
582 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
583 ("IMM32: OnIMENotify, hWnd=%08x, IMN_OPENSTATUSWINDOW\n",
584 aWindow->GetWindowHandle()));
585 break;
586 case IMN_SETCANDIDATEPOS:
587 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
588 ("IMM32: OnIMENotify, hWnd=%08x, IMN_SETCANDIDATEPOS, lParam=%08x\n",
589 aWindow->GetWindowHandle(), lParam));
590 break;
591 case IMN_SETCOMPOSITIONFONT:
592 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
593 ("IMM32: OnIMENotify, hWnd=%08x, IMN_SETCOMPOSITIONFONT\n",
594 aWindow->GetWindowHandle()));
595 break;
596 case IMN_SETCOMPOSITIONWINDOW:
597 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
598 ("IMM32: OnIMENotify, hWnd=%08x, IMN_SETCOMPOSITIONWINDOW\n",
599 aWindow->GetWindowHandle()));
600 break;
601 case IMN_SETCONVERSIONMODE:
602 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
603 ("IMM32: OnIMENotify, hWnd=%08x, IMN_SETCONVERSIONMODE\n",
604 aWindow->GetWindowHandle()));
605 break;
606 case IMN_SETOPENSTATUS:
607 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
608 ("IMM32: OnIMENotify, hWnd=%08x, IMN_SETOPENSTATUS\n",
609 aWindow->GetWindowHandle()));
610 break;
611 case IMN_SETSENTENCEMODE:
612 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
613 ("IMM32: OnIMENotify, hWnd=%08x, IMN_SETSENTENCEMODE\n",
614 aWindow->GetWindowHandle()));
615 break;
616 case IMN_SETSTATUSWINDOWPOS:
617 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
618 ("IMM32: OnIMENotify, hWnd=%08x, IMN_SETSTATUSWINDOWPOS\n",
619 aWindow->GetWindowHandle()));
620 break;
621 case IMN_PRIVATE:
622 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
623 ("IMM32: OnIMENotify, hWnd=%08x, IMN_PRIVATE\n",
624 aWindow->GetWindowHandle()));
625 break;
626 }
627 #endif // PR_LOGGING
628
629 // not implement yet
630 aResult.mConsumed = false;
631 return true;
632 }
633
634 bool
635 nsIMM32Handler::OnIMERequest(nsWindow* aWindow,
636 WPARAM wParam,
637 LPARAM lParam,
638 MSGResult& aResult)
639 {
640 switch (wParam) {
641 case IMR_RECONVERTSTRING:
642 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
643 ("IMM32: OnIMERequest, hWnd=%08x, IMR_RECONVERTSTRING\n",
644 aWindow->GetWindowHandle()));
645 aResult.mConsumed = HandleReconvert(aWindow, lParam, &aResult.mResult);
646 return true;
647 case IMR_QUERYCHARPOSITION:
648 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
649 ("IMM32: OnIMERequest, hWnd=%08x, IMR_QUERYCHARPOSITION\n",
650 aWindow->GetWindowHandle()));
651 aResult.mConsumed =
652 HandleQueryCharPosition(aWindow, lParam, &aResult.mResult);
653 return true;
654 case IMR_DOCUMENTFEED:
655 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
656 ("IMM32: OnIMERequest, hWnd=%08x, IMR_DOCUMENTFEED\n",
657 aWindow->GetWindowHandle()));
658 aResult.mConsumed = HandleDocumentFeed(aWindow, lParam, &aResult.mResult);
659 return true;
660 default:
661 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
662 ("IMM32: OnIMERequest, hWnd=%08x, wParam=%08x\n",
663 aWindow->GetWindowHandle(), wParam));
664 aResult.mConsumed = false;
665 return true;
666 }
667 }
668
669 /* static */ bool
670 nsIMM32Handler::OnIMESelect(nsWindow* aWindow,
671 WPARAM wParam,
672 LPARAM lParam,
673 MSGResult& aResult)
674 {
675 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
676 ("IMM32: OnIMESelect, hWnd=%08x, wParam=%08x, lParam=%08x\n",
677 aWindow->GetWindowHandle(), wParam, lParam));
678
679 // not implement yet
680 aResult.mConsumed = false;
681 return true;
682 }
683
684 /* static */ bool
685 nsIMM32Handler::OnIMESetContext(nsWindow* aWindow,
686 WPARAM wParam,
687 LPARAM lParam,
688 MSGResult& aResult)
689 {
690 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
691 ("IMM32: OnIMESetContext, hWnd=%08x, %s, lParam=%08x\n",
692 aWindow->GetWindowHandle(), wParam ? "Active" : "Deactive", lParam));
693
694 aResult.mConsumed = false;
695
696 // NOTE: If the aWindow is top level window of the composing window because
697 // when a window on deactive window gets focus, WM_IME_SETCONTEXT (wParam is
698 // TRUE) is sent to the top level window first. After that,
699 // WM_IME_SETCONTEXT (wParam is FALSE) is sent to the top level window.
700 // Finally, WM_IME_SETCONTEXT (wParam is TRUE) is sent to the focused window.
701 // The top level window never becomes composing window, so, we can ignore
702 // the WM_IME_SETCONTEXT on the top level window.
703 if (IsTopLevelWindowOfComposition(aWindow)) {
704 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
705 ("IMM32: OnIMESetContext, hWnd=%08x is top level window\n"));
706 return true;
707 }
708
709 // When IME context is activating on another window,
710 // we should commit the old composition on the old window.
711 bool cancelComposition = false;
712 if (wParam && gIMM32Handler) {
713 cancelComposition =
714 gIMM32Handler->CommitCompositionOnPreviousWindow(aWindow);
715 }
716
717 if (wParam && (lParam & ISC_SHOWUICOMPOSITIONWINDOW) &&
718 ShouldDrawCompositionStringOurselves()) {
719 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
720 ("IMM32: OnIMESetContext, ISC_SHOWUICOMPOSITIONWINDOW is removed\n"));
721 lParam &= ~ISC_SHOWUICOMPOSITIONWINDOW;
722 }
723
724 // We should sent WM_IME_SETCONTEXT to the DefWndProc here because the
725 // ancestor windows shouldn't receive this message. If they receive the
726 // message, we cannot know whether which window is the target of the message.
727 aResult.mResult = ::DefWindowProc(aWindow->GetWindowHandle(),
728 WM_IME_SETCONTEXT, wParam, lParam);
729
730 // Cancel composition on the new window if we committed our composition on
731 // another window.
732 if (cancelComposition) {
733 CancelComposition(aWindow, true);
734 }
735
736 aResult.mConsumed = true;
737 return true;
738 }
739
740 bool
741 nsIMM32Handler::OnChar(nsWindow* aWindow,
742 WPARAM wParam,
743 LPARAM lParam,
744 MSGResult& aResult)
745 {
746 // The return value must be same as aResult.mConsumed because only when we
747 // consume the message, the caller shouldn't do anything anymore but
748 // otherwise, the caller should handle the message.
749 aResult.mConsumed = false;
750 if (IsIMECharRecordsEmpty()) {
751 return aResult.mConsumed;
752 }
753 WPARAM recWParam;
754 LPARAM recLParam;
755 DequeueIMECharRecords(recWParam, recLParam);
756 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
757 ("IMM32: OnChar, aWindow=%p, wParam=%08x, lParam=%08x,\n",
758 aWindow->GetWindowHandle(), wParam, lParam));
759 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
760 (" recorded: wParam=%08x, lParam=%08x\n",
761 recWParam, recLParam));
762 // If an unexpected char message comes, we should reset the records,
763 // of course, this shouldn't happen.
764 if (recWParam != wParam || recLParam != lParam) {
765 ResetIMECharRecords();
766 return aResult.mConsumed;
767 }
768 // Eat the char message which is caused by WM_IME_CHAR because we should
769 // have processed the IME messages, so, this message could be come from
770 // a windowless plug-in.
771 aResult.mConsumed = true;
772 return aResult.mConsumed;
773 }
774
775 /****************************************************************************
776 * message handlers for plug-in
777 ****************************************************************************/
778
779 bool
780 nsIMM32Handler::OnIMEStartCompositionOnPlugin(nsWindow* aWindow,
781 WPARAM wParam,
782 LPARAM lParam,
783 MSGResult& aResult)
784 {
785 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
786 ("IMM32: OnIMEStartCompositionOnPlugin, hWnd=%08x, mIsComposingOnPlugin=%s\n",
787 aWindow->GetWindowHandle(), mIsComposingOnPlugin ? "TRUE" : "FALSE"));
788 mIsComposingOnPlugin = true;
789 mComposingWindow = aWindow;
790 nsIMEContext IMEContext(aWindow->GetWindowHandle());
791 SetIMERelatedWindowsPosOnPlugin(aWindow, IMEContext);
792 aResult.mConsumed =
793 aWindow->DispatchPluginEvent(WM_IME_STARTCOMPOSITION, wParam, lParam,
794 false);
795 return true;
796 }
797
798 bool
799 nsIMM32Handler::OnIMECompositionOnPlugin(nsWindow* aWindow,
800 WPARAM wParam,
801 LPARAM lParam,
802 MSGResult& aResult)
803 {
804 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
805 ("IMM32: OnIMECompositionOnPlugin, hWnd=%08x, lParam=%08x, mIsComposingOnPlugin=%s\n",
806 aWindow->GetWindowHandle(), lParam,
807 mIsComposingOnPlugin ? "TRUE" : "FALSE"));
808 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
809 ("IMM32: OnIMECompositionOnPlugin, GCS_RESULTSTR=%s, GCS_COMPSTR=%s, GCS_COMPATTR=%s, GCS_COMPCLAUSE=%s, GCS_CURSORPOS=%s\n",
810 lParam & GCS_RESULTSTR ? "YES" : "no",
811 lParam & GCS_COMPSTR ? "YES" : "no",
812 lParam & GCS_COMPATTR ? "YES" : "no",
813 lParam & GCS_COMPCLAUSE ? "YES" : "no",
814 lParam & GCS_CURSORPOS ? "YES" : "no"));
815 // We should end composition if there is a committed string.
816 if (IS_COMMITTING_LPARAM(lParam)) {
817 mIsComposingOnPlugin = false;
818 mComposingWindow = nullptr;
819 }
820 // Continue composition if there is still a string being composed.
821 if (IS_COMPOSING_LPARAM(lParam)) {
822 mIsComposingOnPlugin = true;
823 mComposingWindow = aWindow;
824 nsIMEContext IMEContext(aWindow->GetWindowHandle());
825 SetIMERelatedWindowsPosOnPlugin(aWindow, IMEContext);
826 }
827 aResult.mConsumed =
828 aWindow->DispatchPluginEvent(WM_IME_COMPOSITION, wParam, lParam, true);
829 return true;
830 }
831
832 bool
833 nsIMM32Handler::OnIMEEndCompositionOnPlugin(nsWindow* aWindow,
834 WPARAM wParam,
835 LPARAM lParam,
836 MSGResult& aResult)
837 {
838 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
839 ("IMM32: OnIMEEndCompositionOnPlugin, hWnd=%08x, mIsComposingOnPlugin=%s\n",
840 aWindow->GetWindowHandle(), mIsComposingOnPlugin ? "TRUE" : "FALSE"));
841
842 mIsComposingOnPlugin = false;
843 mComposingWindow = nullptr;
844
845 if (mNativeCaretIsCreated) {
846 ::DestroyCaret();
847 mNativeCaretIsCreated = false;
848 }
849
850 aResult.mConsumed =
851 aWindow->DispatchPluginEvent(WM_IME_ENDCOMPOSITION, wParam, lParam,
852 false);
853 return true;
854 }
855
856 bool
857 nsIMM32Handler::OnIMECharOnPlugin(nsWindow* aWindow,
858 WPARAM wParam,
859 LPARAM lParam,
860 MSGResult& aResult)
861 {
862 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
863 ("IMM32: OnIMECharOnPlugin, hWnd=%08x, char=%08x, scancode=%08x\n",
864 aWindow->GetWindowHandle(), wParam, lParam));
865
866 aResult.mConsumed =
867 aWindow->DispatchPluginEvent(WM_IME_CHAR, wParam, lParam, true);
868
869 if (!aResult.mConsumed) {
870 // Record the WM_CHAR messages which are going to be coming.
871 EnsureHandlerInstance();
872 EnqueueIMECharRecords(wParam, lParam);
873 }
874 return true;
875 }
876
877 /* static */ bool
878 nsIMM32Handler::OnIMESetContextOnPlugin(nsWindow* aWindow,
879 WPARAM wParam,
880 LPARAM lParam,
881 MSGResult& aResult)
882 {
883 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
884 ("IMM32: OnIMESetContextOnPlugin, hWnd=%08x, %s, lParam=%08x\n",
885 aWindow->GetWindowHandle(), wParam ? "Active" : "Deactive", lParam));
886
887 // If the IME context becomes active on a plug-in, we should commit
888 // our composition. And also we should cancel the composition on new
889 // window. Note that if IsTopLevelWindowOfComposition(aWindow) returns
890 // true, we should ignore the message here, see the comment in
891 // OnIMESetContext() for the detail.
892 if (wParam && gIMM32Handler && !IsTopLevelWindowOfComposition(aWindow)) {
893 if (gIMM32Handler->CommitCompositionOnPreviousWindow(aWindow)) {
894 CancelComposition(aWindow);
895 }
896 }
897
898 // Dispatch message to the plug-in.
899 // XXX When a windowless plug-in gets focus, we should send
900 // WM_IME_SETCONTEXT
901 aWindow->DispatchPluginEvent(WM_IME_SETCONTEXT, wParam, lParam, false);
902
903 // We should send WM_IME_SETCONTEXT to the DefWndProc here. It shouldn't
904 // be received on ancestor windows, see OnIMESetContext() for the detail.
905 aResult.mResult = ::DefWindowProc(aWindow->GetWindowHandle(),
906 WM_IME_SETCONTEXT, wParam, lParam);
907
908 // Don't synchronously dispatch the pending events when we receive
909 // WM_IME_SETCONTEXT because we get it during plugin destruction.
910 // (bug 491848)
911 aResult.mConsumed = true;
912 return true;
913 }
914
915 bool
916 nsIMM32Handler::OnCharOnPlugin(nsWindow* aWindow,
917 WPARAM wParam,
918 LPARAM lParam,
919 MSGResult& aResult)
920 {
921 // We should never consume char message on windowless plugin.
922 aResult.mConsumed = false;
923 if (IsIMECharRecordsEmpty()) {
924 return false;
925 }
926
927 WPARAM recWParam;
928 LPARAM recLParam;
929 DequeueIMECharRecords(recWParam, recLParam);
930 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
931 ("IMM32: OnCharOnPlugin, aWindow=%p, wParam=%08x, lParam=%08x,\n",
932 aWindow->GetWindowHandle(), wParam, lParam));
933 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
934 (" recorded: wParam=%08x, lParam=%08x\n",
935 recWParam, recLParam));
936 // If an unexpected char message comes, we should reset the records,
937 // of course, this shouldn't happen.
938 if (recWParam != wParam || recLParam != lParam) {
939 ResetIMECharRecords();
940 }
941 // WM_CHAR on plug-in is always handled by nsWindow.
942 return false;
943 }
944
945 /****************************************************************************
946 * others
947 ****************************************************************************/
948
949 void
950 nsIMM32Handler::HandleStartComposition(nsWindow* aWindow,
951 const nsIMEContext &aIMEContext)
952 {
953 NS_PRECONDITION(!mIsComposing,
954 "HandleStartComposition is called but mIsComposing is TRUE");
955 NS_PRECONDITION(!aWindow->PluginHasFocus(),
956 "HandleStartComposition should not be called when a plug-in has focus");
957
958 WidgetQueryContentEvent selection(true, NS_QUERY_SELECTED_TEXT, aWindow);
959 nsIntPoint point(0, 0);
960 aWindow->InitEvent(selection, &point);
961 aWindow->DispatchWindowEvent(&selection);
962 if (!selection.mSucceeded) {
963 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
964 ("IMM32: HandleStartComposition, FAILED (NS_QUERY_SELECTED_TEXT)\n"));
965 return;
966 }
967
968 mCompositionStart = selection.mReply.mOffset;
969 mLastDispatchedCompositionString.Truncate();
970
971 WidgetCompositionEvent event(true, NS_COMPOSITION_START, aWindow);
972 aWindow->InitEvent(event, &point);
973 aWindow->DispatchWindowEvent(&event);
974
975 mIsComposing = true;
976 mComposingWindow = aWindow;
977
978 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
979 ("IMM32: HandleStartComposition, START composition, mCompositionStart=%ld\n",
980 mCompositionStart));
981 }
982
983 bool
984 nsIMM32Handler::HandleComposition(nsWindow* aWindow,
985 const nsIMEContext &aIMEContext,
986 LPARAM lParam)
987 {
988 NS_PRECONDITION(!aWindow->PluginHasFocus(),
989 "HandleComposition should not be called when a plug-in has focus");
990
991 // for bug #60050
992 // MS-IME 95/97/98/2000 may send WM_IME_COMPOSITION with non-conversion
993 // mode before it send WM_IME_STARTCOMPOSITION.
994 // However, ATOK sends a WM_IME_COMPOSITION before WM_IME_STARTCOMPOSITION,
995 // and if we access ATOK via some APIs, ATOK will sometimes fail to
996 // initialize its state. If WM_IME_STARTCOMPOSITION is already in the
997 // message queue, we should ignore the strange WM_IME_COMPOSITION message and
998 // skip to the next. So, we should look for next composition message
999 // (WM_IME_STARTCOMPOSITION or WM_IME_ENDCOMPOSITION or WM_IME_COMPOSITION),
1000 // and if it's WM_IME_STARTCOMPOSITION, and one more next composition message
1001 // is WM_IME_COMPOSITION, current IME is ATOK, probably. Otherwise, we
1002 // should start composition forcibly.
1003 if (!mIsComposing) {
1004 MSG msg1, msg2;
1005 HWND wnd = aWindow->GetWindowHandle();
1006 if (WinUtils::PeekMessage(&msg1, wnd, WM_IME_STARTCOMPOSITION,
1007 WM_IME_COMPOSITION, PM_NOREMOVE) &&
1008 msg1.message == WM_IME_STARTCOMPOSITION &&
1009 WinUtils::PeekMessage(&msg2, wnd, WM_IME_ENDCOMPOSITION,
1010 WM_IME_COMPOSITION, PM_NOREMOVE) &&
1011 msg2.message == WM_IME_COMPOSITION) {
1012 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1013 ("IMM32: HandleComposition, Ignores due to find a WM_IME_STARTCOMPOSITION\n"));
1014 return ShouldDrawCompositionStringOurselves();
1015 }
1016 }
1017
1018 bool startCompositionMessageHasBeenSent = mIsComposing;
1019
1020 //
1021 // This catches a fixed result
1022 //
1023 if (IS_COMMITTING_LPARAM(lParam)) {
1024 if (!mIsComposing) {
1025 HandleStartComposition(aWindow, aIMEContext);
1026 }
1027
1028 GetCompositionString(aIMEContext, GCS_RESULTSTR);
1029
1030 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1031 ("IMM32: HandleComposition, GCS_RESULTSTR\n"));
1032
1033 DispatchTextEvent(aWindow, aIMEContext, false);
1034 HandleEndComposition(aWindow);
1035
1036 if (!IS_COMPOSING_LPARAM(lParam)) {
1037 return ShouldDrawCompositionStringOurselves();
1038 }
1039 }
1040
1041
1042 //
1043 // This provides us with a composition string
1044 //
1045 if (!mIsComposing) {
1046 HandleStartComposition(aWindow, aIMEContext);
1047 }
1048
1049 //--------------------------------------------------------
1050 // 1. Get GCS_COMPSTR
1051 //--------------------------------------------------------
1052 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1053 ("IMM32: HandleComposition, GCS_COMPSTR\n"));
1054
1055 GetCompositionString(aIMEContext, GCS_COMPSTR);
1056
1057 if (!IS_COMPOSING_LPARAM(lParam)) {
1058 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1059 ("IMM32: HandleComposition, lParam doesn't indicate composing, "
1060 "mCompositionString=\"%s\", mLastDispatchedCompositionString=\"%s\"",
1061 NS_ConvertUTF16toUTF8(mCompositionString).get(),
1062 NS_ConvertUTF16toUTF8(mLastDispatchedCompositionString).get()));
1063
1064 // If composition string isn't changed, we can trust the lParam.
1065 // So, we need to do nothing.
1066 if (mLastDispatchedCompositionString == mCompositionString) {
1067 return ShouldDrawCompositionStringOurselves();
1068 }
1069
1070 // IME may send WM_IME_COMPOSITION without composing lParam values
1071 // when composition string becomes empty (e.g., using Backspace key).
1072 // If composition string is empty, we should dispatch a text event with
1073 // empty string.
1074 if (mCompositionString.IsEmpty()) {
1075 DispatchTextEvent(aWindow, aIMEContext, false);
1076 return ShouldDrawCompositionStringOurselves();
1077 }
1078
1079 // Otherwise, we cannot trust the lParam value. We might need to
1080 // dispatch text event with the latest composition string information.
1081 }
1082
1083 // See https://bugzilla.mozilla.org/show_bug.cgi?id=296339
1084 if (mCompositionString.IsEmpty() && !startCompositionMessageHasBeenSent) {
1085 // In this case, maybe, the sender is MSPinYin. That sends *only*
1086 // WM_IME_COMPOSITION with GCS_COMP* and GCS_RESULT* when
1087 // user inputted the Chinese full stop. So, that doesn't send
1088 // WM_IME_STARTCOMPOSITION and WM_IME_ENDCOMPOSITION.
1089 // If WM_IME_STARTCOMPOSITION was not sent and the composition
1090 // string is null (it indicates the composition transaction ended),
1091 // WM_IME_ENDCOMPOSITION may not be sent. If so, we cannot run
1092 // HandleEndComposition() in other place.
1093 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1094 ("IMM32: HandleComposition, Aborting GCS_COMPSTR\n"));
1095 HandleEndComposition(aWindow);
1096 return IS_COMMITTING_LPARAM(lParam);
1097 }
1098
1099 //--------------------------------------------------------
1100 // 2. Get GCS_COMPCLAUSE
1101 //--------------------------------------------------------
1102 long clauseArrayLength =
1103 ::ImmGetCompositionStringW(aIMEContext.get(), GCS_COMPCLAUSE, nullptr, 0);
1104 clauseArrayLength /= sizeof(uint32_t);
1105
1106 if (clauseArrayLength > 0) {
1107 nsresult rv = EnsureClauseArray(clauseArrayLength);
1108 NS_ENSURE_SUCCESS(rv, false);
1109
1110 // Intelligent ABC IME (Simplified Chinese IME, the code page is 936)
1111 // will crash in ImmGetCompositionStringW for GCS_COMPCLAUSE (bug 424663).
1112 // See comment 35 of the bug for the detail. Therefore, we should use A
1113 // API for it, however, we should not kill Unicode support on all IMEs.
1114 bool useA_API = !(sIMEProperty & IME_PROP_UNICODE);
1115
1116 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1117 ("IMM32: HandleComposition, GCS_COMPCLAUSE, useA_API=%s\n",
1118 useA_API ? "TRUE" : "FALSE"));
1119
1120 long clauseArrayLength2 =
1121 useA_API ?
1122 ::ImmGetCompositionStringA(aIMEContext.get(), GCS_COMPCLAUSE,
1123 mClauseArray.Elements(),
1124 mClauseArray.Capacity() * sizeof(uint32_t)) :
1125 ::ImmGetCompositionStringW(aIMEContext.get(), GCS_COMPCLAUSE,
1126 mClauseArray.Elements(),
1127 mClauseArray.Capacity() * sizeof(uint32_t));
1128 clauseArrayLength2 /= sizeof(uint32_t);
1129
1130 if (clauseArrayLength != clauseArrayLength2) {
1131 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1132 ("IMM32: HandleComposition, GCS_COMPCLAUSE, clauseArrayLength=%ld but clauseArrayLength2=%ld\n",
1133 clauseArrayLength, clauseArrayLength2));
1134 if (clauseArrayLength > clauseArrayLength2)
1135 clauseArrayLength = clauseArrayLength2;
1136 }
1137
1138 if (useA_API) {
1139 // Convert each values of sIMECompClauseArray. The values mean offset of
1140 // the clauses in ANSI string. But we need the values in Unicode string.
1141 nsAutoCString compANSIStr;
1142 if (ConvertToANSIString(mCompositionString, GetKeyboardCodePage(),
1143 compANSIStr)) {
1144 uint32_t maxlen = compANSIStr.Length();
1145 mClauseArray[0] = 0; // first value must be 0
1146 for (int32_t i = 1; i < clauseArrayLength; i++) {
1147 uint32_t len = std::min(mClauseArray[i], maxlen);
1148 mClauseArray[i] = ::MultiByteToWideChar(GetKeyboardCodePage(),
1149 MB_PRECOMPOSED,
1150 (LPCSTR)compANSIStr.get(),
1151 len, nullptr, 0);
1152 }
1153 }
1154 }
1155 }
1156 // compClauseArrayLength may be negative. I.e., ImmGetCompositionStringW
1157 // may return an error code.
1158 mClauseArray.SetLength(std::max<long>(0, clauseArrayLength));
1159
1160 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1161 ("IMM32: HandleComposition, GCS_COMPCLAUSE, mClauseLength=%ld\n",
1162 mClauseArray.Length()));
1163
1164 //--------------------------------------------------------
1165 // 3. Get GCS_COMPATTR
1166 //--------------------------------------------------------
1167 // This provides us with the attribute string necessary
1168 // for doing hiliting
1169 long attrArrayLength =
1170 ::ImmGetCompositionStringW(aIMEContext.get(), GCS_COMPATTR, nullptr, 0);
1171 attrArrayLength /= sizeof(uint8_t);
1172
1173 if (attrArrayLength > 0) {
1174 nsresult rv = EnsureAttributeArray(attrArrayLength);
1175 NS_ENSURE_SUCCESS(rv, false);
1176 attrArrayLength =
1177 ::ImmGetCompositionStringW(aIMEContext.get(), GCS_COMPATTR,
1178 mAttributeArray.Elements(),
1179 mAttributeArray.Capacity() * sizeof(uint8_t));
1180 }
1181
1182 // attrStrLen may be negative. I.e., ImmGetCompositionStringW may return an
1183 // error code.
1184 mAttributeArray.SetLength(std::max<long>(0, attrArrayLength));
1185
1186 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1187 ("IMM32: HandleComposition, GCS_COMPATTR, mAttributeLength=%ld\n",
1188 mAttributeArray.Length()));
1189
1190 //--------------------------------------------------------
1191 // 4. Get GCS_CURSOPOS
1192 //--------------------------------------------------------
1193 // Some IMEs (e.g., the standard IME for Korean) don't have caret position.
1194 if (lParam & GCS_CURSORPOS) {
1195 mCursorPosition =
1196 ::ImmGetCompositionStringW(aIMEContext.get(), GCS_CURSORPOS, nullptr, 0);
1197 if (mCursorPosition < 0) {
1198 mCursorPosition = NO_IME_CARET; // The result is error
1199 }
1200 } else {
1201 mCursorPosition = NO_IME_CARET;
1202 }
1203
1204 NS_ASSERTION(mCursorPosition <= (long)mCompositionString.Length(),
1205 "illegal pos");
1206
1207 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1208 ("IMM32: HandleComposition, GCS_CURSORPOS, mCursorPosition=%d\n",
1209 mCursorPosition));
1210
1211 //--------------------------------------------------------
1212 // 5. Send the text event
1213 //--------------------------------------------------------
1214 DispatchTextEvent(aWindow, aIMEContext);
1215
1216 return ShouldDrawCompositionStringOurselves();
1217 }
1218
1219 void
1220 nsIMM32Handler::HandleEndComposition(nsWindow* aWindow)
1221 {
1222 NS_PRECONDITION(mIsComposing,
1223 "HandleEndComposition is called but mIsComposing is FALSE");
1224 NS_PRECONDITION(!aWindow->PluginHasFocus(),
1225 "HandleComposition should not be called when a plug-in has focus");
1226
1227 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1228 ("IMM32: HandleEndComposition\n"));
1229
1230 WidgetCompositionEvent event(true, NS_COMPOSITION_END, aWindow);
1231 nsIntPoint point(0, 0);
1232
1233 if (mNativeCaretIsCreated) {
1234 ::DestroyCaret();
1235 mNativeCaretIsCreated = false;
1236 }
1237
1238 aWindow->InitEvent(event, &point);
1239 // The last dispatched composition string must be the committed string.
1240 event.data = mLastDispatchedCompositionString;
1241 aWindow->DispatchWindowEvent(&event);
1242 mIsComposing = false;
1243 mComposingWindow = nullptr;
1244 mLastDispatchedCompositionString.Truncate();
1245 }
1246
1247 static void
1248 DumpReconvertString(RECONVERTSTRING* aReconv)
1249 {
1250 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1251 (" dwSize=%ld, dwVersion=%ld, dwStrLen=%ld, dwStrOffset=%ld\n",
1252 aReconv->dwSize, aReconv->dwVersion,
1253 aReconv->dwStrLen, aReconv->dwStrOffset));
1254 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1255 (" dwCompStrLen=%ld, dwCompStrOffset=%ld, dwTargetStrLen=%ld, dwTargetStrOffset=%ld\n",
1256 aReconv->dwCompStrLen, aReconv->dwCompStrOffset,
1257 aReconv->dwTargetStrLen, aReconv->dwTargetStrOffset));
1258 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1259 (" result str=\"%s\"\n",
1260 NS_ConvertUTF16toUTF8(
1261 nsAutoString((char16_t*)((char*)(aReconv) + aReconv->dwStrOffset),
1262 aReconv->dwStrLen)).get()));
1263 }
1264
1265 bool
1266 nsIMM32Handler::HandleReconvert(nsWindow* aWindow,
1267 LPARAM lParam,
1268 LRESULT *oResult)
1269 {
1270 *oResult = 0;
1271 RECONVERTSTRING* pReconv = reinterpret_cast<RECONVERTSTRING*>(lParam);
1272
1273 WidgetQueryContentEvent selection(true, NS_QUERY_SELECTED_TEXT, aWindow);
1274 nsIntPoint point(0, 0);
1275 aWindow->InitEvent(selection, &point);
1276 aWindow->DispatchWindowEvent(&selection);
1277 if (!selection.mSucceeded) {
1278 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1279 ("IMM32: HandleReconvert, FAILED (NS_QUERY_SELECTED_TEXT)\n"));
1280 return false;
1281 }
1282
1283 uint32_t len = selection.mReply.mString.Length();
1284 uint32_t needSize = sizeof(RECONVERTSTRING) + len * sizeof(WCHAR);
1285
1286 if (!pReconv) {
1287 // Return need size to reconvert.
1288 if (len == 0) {
1289 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1290 ("IMM32: HandleReconvert, There are not selected text\n"));
1291 return false;
1292 }
1293 *oResult = needSize;
1294 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1295 ("IMM32: HandleReconvert, SUCCEEDED result=%ld\n",
1296 *oResult));
1297 return true;
1298 }
1299
1300 if (pReconv->dwSize < needSize) {
1301 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1302 ("IMM32: HandleReconvert, FAILED pReconv->dwSize=%ld, needSize=%ld\n",
1303 pReconv->dwSize, needSize));
1304 return false;
1305 }
1306
1307 *oResult = needSize;
1308
1309 // Fill reconvert struct
1310 pReconv->dwVersion = 0;
1311 pReconv->dwStrLen = len;
1312 pReconv->dwStrOffset = sizeof(RECONVERTSTRING);
1313 pReconv->dwCompStrLen = len;
1314 pReconv->dwCompStrOffset = 0;
1315 pReconv->dwTargetStrLen = len;
1316 pReconv->dwTargetStrOffset = 0;
1317
1318 ::CopyMemory(reinterpret_cast<LPVOID>(lParam + sizeof(RECONVERTSTRING)),
1319 selection.mReply.mString.get(), len * sizeof(WCHAR));
1320
1321 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1322 ("IMM32: HandleReconvert, SUCCEEDED result=%ld\n",
1323 *oResult));
1324 DumpReconvertString(pReconv);
1325
1326 return true;
1327 }
1328
1329 bool
1330 nsIMM32Handler::HandleQueryCharPosition(nsWindow* aWindow,
1331 LPARAM lParam,
1332 LRESULT *oResult)
1333 {
1334 uint32_t len = mIsComposing ? mCompositionString.Length() : 0;
1335 *oResult = false;
1336 IMECHARPOSITION* pCharPosition = reinterpret_cast<IMECHARPOSITION*>(lParam);
1337 if (!pCharPosition) {
1338 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1339 ("IMM32: HandleQueryCharPosition, FAILED (pCharPosition is null)\n"));
1340 return false;
1341 }
1342 if (pCharPosition->dwSize < sizeof(IMECHARPOSITION)) {
1343 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1344 ("IMM32: HandleReconvert, FAILED, pCharPosition->dwSize=%ld, sizeof(IMECHARPOSITION)=%ld\n",
1345 pCharPosition->dwSize, sizeof(IMECHARPOSITION)));
1346 return false;
1347 }
1348 if (::GetFocus() != aWindow->GetWindowHandle()) {
1349 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1350 ("IMM32: HandleReconvert, FAILED, ::GetFocus()=%08x, OurWindowHandle=%08x\n",
1351 ::GetFocus(), aWindow->GetWindowHandle()));
1352 return false;
1353 }
1354 if (pCharPosition->dwCharPos > len) {
1355 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1356 ("IMM32: HandleQueryCharPosition, FAILED, pCharPosition->dwCharPos=%ld, len=%ld\n",
1357 pCharPosition->dwCharPos, len));
1358 return false;
1359 }
1360
1361 nsIntRect r;
1362 bool ret =
1363 GetCharacterRectOfSelectedTextAt(aWindow, pCharPosition->dwCharPos, r);
1364 NS_ENSURE_TRUE(ret, false);
1365
1366 nsIntRect screenRect;
1367 // We always need top level window that is owner window of the popup window
1368 // even if the content of the popup window has focus.
1369 ResolveIMECaretPos(aWindow->GetTopLevelWindow(false),
1370 r, nullptr, screenRect);
1371 pCharPosition->pt.x = screenRect.x;
1372 pCharPosition->pt.y = screenRect.y;
1373
1374 pCharPosition->cLineHeight = r.height;
1375
1376 // XXX we should use NS_QUERY_EDITOR_RECT event here.
1377 ::GetWindowRect(aWindow->GetWindowHandle(), &pCharPosition->rcDocument);
1378
1379 *oResult = TRUE;
1380
1381 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1382 ("IMM32: HandleQueryCharPosition, SUCCEEDED\n"));
1383 return true;
1384 }
1385
1386 bool
1387 nsIMM32Handler::HandleDocumentFeed(nsWindow* aWindow,
1388 LPARAM lParam,
1389 LRESULT *oResult)
1390 {
1391 *oResult = 0;
1392 RECONVERTSTRING* pReconv = reinterpret_cast<RECONVERTSTRING*>(lParam);
1393
1394 nsIntPoint point(0, 0);
1395
1396 bool hasCompositionString =
1397 mIsComposing && ShouldDrawCompositionStringOurselves();
1398
1399 int32_t targetOffset, targetLength;
1400 if (!hasCompositionString) {
1401 WidgetQueryContentEvent selection(true, NS_QUERY_SELECTED_TEXT, aWindow);
1402 aWindow->InitEvent(selection, &point);
1403 aWindow->DispatchWindowEvent(&selection);
1404 if (!selection.mSucceeded) {
1405 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1406 ("IMM32: HandleDocumentFeed, FAILED (NS_QUERY_SELECTED_TEXT)\n"));
1407 return false;
1408 }
1409 targetOffset = int32_t(selection.mReply.mOffset);
1410 targetLength = int32_t(selection.mReply.mString.Length());
1411 } else {
1412 targetOffset = int32_t(mCompositionStart);
1413 targetLength = int32_t(mCompositionString.Length());
1414 }
1415
1416 // XXX nsString::Find and nsString::RFind take int32_t for offset, so,
1417 // we cannot support this message when the current offset is larger than
1418 // INT32_MAX.
1419 if (targetOffset < 0 || targetLength < 0 ||
1420 targetOffset + targetLength < 0) {
1421 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1422 ("IMM32: HandleDocumentFeed, FAILED (The selection is out of range)\n"));
1423 return false;
1424 }
1425
1426 // Get all contents of the focused editor.
1427 WidgetQueryContentEvent textContent(true, NS_QUERY_TEXT_CONTENT, aWindow);
1428 textContent.InitForQueryTextContent(0, UINT32_MAX);
1429 aWindow->InitEvent(textContent, &point);
1430 aWindow->DispatchWindowEvent(&textContent);
1431 if (!textContent.mSucceeded) {
1432 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1433 ("IMM32: HandleDocumentFeed, FAILED (NS_QUERY_TEXT_CONTENT)\n"));
1434 return false;
1435 }
1436
1437 nsAutoString str(textContent.mReply.mString);
1438 if (targetOffset > int32_t(str.Length())) {
1439 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1440 ("IMM32: HandleDocumentFeed, FAILED (The caret offset is invalid)\n"));
1441 return false;
1442 }
1443
1444 // Get the focused paragraph, we decide that it starts from the previous CRLF
1445 // (or start of the editor) to the next one (or the end of the editor).
1446 int32_t paragraphStart = str.RFind("\n", false, targetOffset, -1) + 1;
1447 int32_t paragraphEnd =
1448 str.Find("\r", false, targetOffset + targetLength, -1);
1449 if (paragraphEnd < 0) {
1450 paragraphEnd = str.Length();
1451 }
1452 nsDependentSubstring paragraph(str, paragraphStart,
1453 paragraphEnd - paragraphStart);
1454
1455 uint32_t len = paragraph.Length();
1456 uint32_t needSize = sizeof(RECONVERTSTRING) + len * sizeof(WCHAR);
1457
1458 if (!pReconv) {
1459 *oResult = needSize;
1460 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1461 ("IMM32: HandleDocumentFeed, SUCCEEDED result=%ld\n",
1462 *oResult));
1463 return true;
1464 }
1465
1466 if (pReconv->dwSize < needSize) {
1467 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1468 ("IMM32: HandleDocumentFeed, FAILED pReconv->dwSize=%ld, needSize=%ld\n",
1469 pReconv->dwSize, needSize));
1470 return false;
1471 }
1472
1473 // Fill reconvert struct
1474 pReconv->dwVersion = 0;
1475 pReconv->dwStrLen = len;
1476 pReconv->dwStrOffset = sizeof(RECONVERTSTRING);
1477 if (hasCompositionString) {
1478 pReconv->dwCompStrLen = targetLength;
1479 pReconv->dwCompStrOffset =
1480 (targetOffset - paragraphStart) * sizeof(WCHAR);
1481 // Set composition target clause information
1482 uint32_t offset, length;
1483 if (!GetTargetClauseRange(&offset, &length)) {
1484 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1485 ("IMM32: HandleDocumentFeed, FAILED, by GetTargetClauseRange\n"));
1486 return false;
1487 }
1488 pReconv->dwTargetStrLen = length;
1489 pReconv->dwTargetStrOffset = (offset - paragraphStart) * sizeof(WCHAR);
1490 } else {
1491 pReconv->dwTargetStrLen = targetLength;
1492 pReconv->dwTargetStrOffset =
1493 (targetOffset - paragraphStart) * sizeof(WCHAR);
1494 // There is no composition string, so, the length is zero but we should
1495 // set the cursor offset to the composition str offset.
1496 pReconv->dwCompStrLen = 0;
1497 pReconv->dwCompStrOffset = pReconv->dwTargetStrOffset;
1498 }
1499
1500 *oResult = needSize;
1501 ::CopyMemory(reinterpret_cast<LPVOID>(lParam + sizeof(RECONVERTSTRING)),
1502 paragraph.BeginReading(), len * sizeof(WCHAR));
1503
1504 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1505 ("IMM32: HandleDocumentFeed, SUCCEEDED result=%ld\n",
1506 *oResult));
1507 DumpReconvertString(pReconv);
1508
1509 return true;
1510 }
1511
1512 bool
1513 nsIMM32Handler::CommitCompositionOnPreviousWindow(nsWindow* aWindow)
1514 {
1515 if (!mComposingWindow || mComposingWindow == aWindow) {
1516 return false;
1517 }
1518
1519 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1520 ("IMM32: CommitCompositionOnPreviousWindow, mIsComposing=%s, mIsComposingOnPlugin=%s\n",
1521 mIsComposing ? "TRUE" : "FALSE", mIsComposingOnPlugin ? "TRUE" : "FALSE"));
1522
1523 // If we have composition, we should dispatch composition events internally.
1524 if (mIsComposing) {
1525 nsIMEContext IMEContext(mComposingWindow->GetWindowHandle());
1526 NS_ASSERTION(IMEContext.IsValid(), "IME context must be valid");
1527
1528 DispatchTextEvent(mComposingWindow, IMEContext, false);
1529 HandleEndComposition(mComposingWindow);
1530 return true;
1531 }
1532
1533 // XXX When plug-in has composition, we should commit composition on the
1534 // plug-in. However, we need some more work for that.
1535 return mIsComposingOnPlugin;
1536 }
1537
1538 static uint32_t
1539 PlatformToNSAttr(uint8_t aAttr)
1540 {
1541 switch (aAttr)
1542 {
1543 case ATTR_INPUT_ERROR:
1544 // case ATTR_FIXEDCONVERTED:
1545 case ATTR_INPUT:
1546 return NS_TEXTRANGE_RAWINPUT;
1547 case ATTR_CONVERTED:
1548 return NS_TEXTRANGE_CONVERTEDTEXT;
1549 case ATTR_TARGET_NOTCONVERTED:
1550 return NS_TEXTRANGE_SELECTEDRAWTEXT;
1551 case ATTR_TARGET_CONVERTED:
1552 return NS_TEXTRANGE_SELECTEDCONVERTEDTEXT;
1553 default:
1554 NS_ASSERTION(false, "unknown attribute");
1555 return NS_TEXTRANGE_CARETPOSITION;
1556 }
1557 }
1558
1559 #ifdef PR_LOGGING
1560 static const char*
1561 GetRangeTypeName(uint32_t aRangeType)
1562 {
1563 switch (aRangeType) {
1564 case NS_TEXTRANGE_RAWINPUT:
1565 return "NS_TEXTRANGE_RAWINPUT";
1566 case NS_TEXTRANGE_CONVERTEDTEXT:
1567 return "NS_TEXTRANGE_CONVERTEDTEXT";
1568 case NS_TEXTRANGE_SELECTEDRAWTEXT:
1569 return "NS_TEXTRANGE_SELECTEDRAWTEXT";
1570 case NS_TEXTRANGE_SELECTEDCONVERTEDTEXT:
1571 return "NS_TEXTRANGE_SELECTEDCONVERTEDTEXT";
1572 case NS_TEXTRANGE_CARETPOSITION:
1573 return "NS_TEXTRANGE_CARETPOSITION";
1574 default:
1575 return "UNKNOWN SELECTION TYPE!!";
1576 }
1577 }
1578 #endif
1579
1580 void
1581 nsIMM32Handler::DispatchTextEvent(nsWindow* aWindow,
1582 const nsIMEContext &aIMEContext,
1583 bool aCheckAttr)
1584 {
1585 NS_ASSERTION(mIsComposing, "conflict state");
1586 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1587 ("IMM32: DispatchTextEvent, aCheckAttr=%s\n",
1588 aCheckAttr ? "TRUE": "FALSE"));
1589
1590 // If we don't need to draw composition string ourselves and this is not
1591 // commit event (i.e., under composing), we don't need to fire text event
1592 // during composing.
1593 if (aCheckAttr && !ShouldDrawCompositionStringOurselves()) {
1594 // But we need to adjust composition window pos and native caret pos, here.
1595 SetIMERelatedWindowsPos(aWindow, aIMEContext);
1596 return;
1597 }
1598
1599 nsRefPtr<nsWindow> kungFuDeathGrip(aWindow);
1600
1601 nsIntPoint point(0, 0);
1602
1603 if (mCompositionString != mLastDispatchedCompositionString) {
1604 WidgetCompositionEvent compositionUpdate(true, NS_COMPOSITION_UPDATE,
1605 aWindow);
1606 aWindow->InitEvent(compositionUpdate, &point);
1607 compositionUpdate.data = mCompositionString;
1608 mLastDispatchedCompositionString = mCompositionString;
1609
1610 aWindow->DispatchWindowEvent(&compositionUpdate);
1611
1612 if (!mIsComposing || aWindow->Destroyed()) {
1613 return;
1614 }
1615 SetIMERelatedWindowsPos(aWindow, aIMEContext);
1616 }
1617
1618 WidgetTextEvent event(true, NS_TEXT_TEXT, aWindow);
1619
1620 aWindow->InitEvent(event, &point);
1621
1622 if (aCheckAttr) {
1623 event.mRanges = CreateTextRangeArray();
1624 }
1625
1626 event.theText = mCompositionString.get();
1627
1628 aWindow->DispatchWindowEvent(&event);
1629
1630 // Calling SetIMERelatedWindowsPos will be failure on e10s at this point.
1631 // text event will notify NOTIFY_IME_OF_COMPOSITION_UPDATE, then
1632 // it will call SetIMERelatedWindowsPos.
1633 }
1634
1635 already_AddRefed<TextRangeArray>
1636 nsIMM32Handler::CreateTextRangeArray()
1637 {
1638 // Sogou (Simplified Chinese IME) returns contradictory values: The cursor
1639 // position is actual cursor position. However, other values (composition
1640 // string and attributes) are empty. So, if you want to remove following
1641 // assertion, be careful.
1642 NS_ASSERTION(ShouldDrawCompositionStringOurselves(),
1643 "CreateTextRangeArray is called when we don't need to fire text event");
1644
1645 nsRefPtr<TextRangeArray> textRangeArray = new TextRangeArray();
1646
1647 TextRange range;
1648 if (mClauseArray.Length() == 0) {
1649 // Some IMEs don't return clause array information, then, we assume that
1650 // all characters in the composition string are in one clause.
1651 range.mStartOffset = 0;
1652 range.mEndOffset = mCompositionString.Length();
1653 range.mRangeType = NS_TEXTRANGE_RAWINPUT;
1654 textRangeArray->AppendElement(range);
1655
1656 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1657 ("IMM32: CreateTextRangeArray, mClauseLength=0\n"));
1658 } else {
1659 // iterate over the attributes
1660 uint32_t lastOffset = 0;
1661 for (uint32_t i = 0; i < mClauseArray.Length() - 1; i++) {
1662 uint32_t current = mClauseArray[i + 1];
1663 if (current > mCompositionString.Length()) {
1664 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1665 ("IMM32: CreateTextRangeArray, mClauseArray[%ld]=%lu. "
1666 "This is larger than mCompositionString.Length()=%lu\n",
1667 i + 1, current, mCompositionString.Length()));
1668 current = int32_t(mCompositionString.Length());
1669 }
1670
1671 range.mRangeType = PlatformToNSAttr(mAttributeArray[lastOffset]);
1672 range.mStartOffset = lastOffset;
1673 range.mEndOffset = current;
1674 textRangeArray->AppendElement(range);
1675
1676 lastOffset = current;
1677
1678 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1679 ("IMM32: CreateTextRangeArray, index=%ld, rangeType=%s, range=[%lu-%lu]\n",
1680 i, GetRangeTypeName(range.mRangeType), range.mStartOffset,
1681 range.mEndOffset));
1682 }
1683 }
1684
1685 if (mCursorPosition == NO_IME_CARET) {
1686 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1687 ("IMM32: CreateTextRangeArray, no caret\n"));
1688 return textRangeArray.forget();
1689 }
1690
1691 int32_t cursor = mCursorPosition;
1692 if (uint32_t(cursor) > mCompositionString.Length()) {
1693 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1694 ("IMM32: CreateTextRangeArray, mCursorPosition=%ld. "
1695 "This is larger than mCompositionString.Length()=%lu\n",
1696 mCursorPosition, mCompositionString.Length()));
1697 cursor = mCompositionString.Length();
1698 }
1699
1700 range.mStartOffset = range.mEndOffset = cursor;
1701 range.mRangeType = NS_TEXTRANGE_CARETPOSITION;
1702 textRangeArray->AppendElement(range);
1703
1704 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1705 ("IMM32: CreateTextRangeArray, caret position=%ld\n",
1706 range.mStartOffset));
1707
1708 return textRangeArray.forget();
1709 }
1710
1711 void
1712 nsIMM32Handler::GetCompositionString(const nsIMEContext &aIMEContext,
1713 DWORD aIndex)
1714 {
1715 // Retrieve the size of the required output buffer.
1716 long lRtn = ::ImmGetCompositionStringW(aIMEContext.get(), aIndex, nullptr, 0);
1717 if (lRtn < 0 ||
1718 !mCompositionString.SetLength((lRtn / sizeof(WCHAR)) + 1, mozilla::fallible_t())) {
1719 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1720 ("IMM32: GetCompositionString, FAILED by OOM\n"));
1721 return; // Error or out of memory.
1722 }
1723
1724 // Actually retrieve the composition string information.
1725 lRtn = ::ImmGetCompositionStringW(aIMEContext.get(), aIndex,
1726 (LPVOID)mCompositionString.BeginWriting(),
1727 lRtn + sizeof(WCHAR));
1728 mCompositionString.SetLength(lRtn / sizeof(WCHAR));
1729
1730 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1731 ("IMM32: GetCompositionString, SUCCEEDED mCompositionString=\"%s\"\n",
1732 NS_ConvertUTF16toUTF8(mCompositionString).get()));
1733 }
1734
1735 bool
1736 nsIMM32Handler::GetTargetClauseRange(uint32_t *aOffset, uint32_t *aLength)
1737 {
1738 NS_ENSURE_TRUE(aOffset, false);
1739 NS_ENSURE_TRUE(mIsComposing, false);
1740 NS_ENSURE_TRUE(ShouldDrawCompositionStringOurselves(), false);
1741
1742 bool found = false;
1743 *aOffset = mCompositionStart;
1744 for (uint32_t i = 0; i < mAttributeArray.Length(); i++) {
1745 if (mAttributeArray[i] == ATTR_TARGET_NOTCONVERTED ||
1746 mAttributeArray[i] == ATTR_TARGET_CONVERTED) {
1747 *aOffset = mCompositionStart + i;
1748 found = true;
1749 break;
1750 }
1751 }
1752
1753 if (!aLength) {
1754 return true;
1755 }
1756
1757 if (!found) {
1758 // The all composition string is targetted when there is no ATTR_TARGET_*
1759 // clause. E.g., there is only ATTR_INPUT
1760 *aLength = mCompositionString.Length();
1761 return true;
1762 }
1763
1764 uint32_t offsetInComposition = *aOffset - mCompositionStart;
1765 *aLength = mCompositionString.Length() - offsetInComposition;
1766 for (uint32_t i = offsetInComposition; i < mAttributeArray.Length(); i++) {
1767 if (mAttributeArray[i] != ATTR_TARGET_NOTCONVERTED &&
1768 mAttributeArray[i] != ATTR_TARGET_CONVERTED) {
1769 *aLength = i - offsetInComposition;
1770 break;
1771 }
1772 }
1773 return true;
1774 }
1775
1776 bool
1777 nsIMM32Handler::ConvertToANSIString(const nsAFlatString& aStr, UINT aCodePage,
1778 nsACString& aANSIStr)
1779 {
1780 int len = ::WideCharToMultiByte(aCodePage, 0,
1781 (LPCWSTR)aStr.get(), aStr.Length(),
1782 nullptr, 0, nullptr, nullptr);
1783 NS_ENSURE_TRUE(len >= 0, false);
1784
1785 if (!aANSIStr.SetLength(len, mozilla::fallible_t())) {
1786 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1787 ("IMM32: ConvertToANSIString, FAILED by OOM\n"));
1788 return false;
1789 }
1790 ::WideCharToMultiByte(aCodePage, 0, (LPCWSTR)aStr.get(), aStr.Length(),
1791 (LPSTR)aANSIStr.BeginWriting(), len, nullptr, nullptr);
1792 return true;
1793 }
1794
1795 bool
1796 nsIMM32Handler::GetCharacterRectOfSelectedTextAt(nsWindow* aWindow,
1797 uint32_t aOffset,
1798 nsIntRect &aCharRect)
1799 {
1800 nsIntPoint point(0, 0);
1801
1802 WidgetQueryContentEvent selection(true, NS_QUERY_SELECTED_TEXT, aWindow);
1803 aWindow->InitEvent(selection, &point);
1804 aWindow->DispatchWindowEvent(&selection);
1805 if (!selection.mSucceeded) {
1806 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1807 ("IMM32: GetCharacterRectOfSelectedTextAt, aOffset=%lu, FAILED (NS_QUERY_SELECTED_TEXT)\n",
1808 aOffset));
1809 return false;
1810 }
1811
1812 uint32_t offset = selection.mReply.mOffset + aOffset;
1813 bool useCaretRect = selection.mReply.mString.IsEmpty();
1814 if (useCaretRect && ShouldDrawCompositionStringOurselves() &&
1815 mIsComposing && !mCompositionString.IsEmpty()) {
1816 // There is not a normal selection, but we have composition string.
1817 // XXX mnakano - Should we implement NS_QUERY_IME_SELECTED_TEXT?
1818 useCaretRect = false;
1819 if (mCursorPosition != NO_IME_CARET) {
1820 uint32_t cursorPosition =
1821 std::min<uint32_t>(mCursorPosition, mCompositionString.Length());
1822 NS_ASSERTION(offset >= cursorPosition, "offset is less than cursorPosition!");
1823 offset -= cursorPosition;
1824 }
1825 }
1826
1827 nsIntRect r;
1828 if (!useCaretRect) {
1829 WidgetQueryContentEvent charRect(true, NS_QUERY_TEXT_RECT, aWindow);
1830 charRect.InitForQueryTextRect(offset, 1);
1831 aWindow->InitEvent(charRect, &point);
1832 aWindow->DispatchWindowEvent(&charRect);
1833 if (charRect.mSucceeded) {
1834 aCharRect = charRect.mReply.mRect;
1835 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1836 ("IMM32: GetCharacterRectOfSelectedTextAt, aOffset=%lu, SUCCEEDED\n",
1837 aOffset));
1838 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1839 ("IMM32: GetCharacterRectOfSelectedTextAt, aCharRect={ x: %ld, y: %ld, width: %ld, height: %ld }\n",
1840 aCharRect.x, aCharRect.y, aCharRect.width, aCharRect.height));
1841 return true;
1842 }
1843 }
1844
1845 return GetCaretRect(aWindow, aCharRect);
1846 }
1847
1848 bool
1849 nsIMM32Handler::GetCaretRect(nsWindow* aWindow, nsIntRect &aCaretRect)
1850 {
1851 nsIntPoint point(0, 0);
1852
1853 WidgetQueryContentEvent selection(true, NS_QUERY_SELECTED_TEXT, aWindow);
1854 aWindow->InitEvent(selection, &point);
1855 aWindow->DispatchWindowEvent(&selection);
1856 if (!selection.mSucceeded) {
1857 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1858 ("IMM32: GetCaretRect, FAILED (NS_QUERY_SELECTED_TEXT)\n"));
1859 return false;
1860 }
1861
1862 uint32_t offset = selection.mReply.mOffset;
1863
1864 WidgetQueryContentEvent caretRect(true, NS_QUERY_CARET_RECT, aWindow);
1865 caretRect.InitForQueryCaretRect(offset);
1866 aWindow->InitEvent(caretRect, &point);
1867 aWindow->DispatchWindowEvent(&caretRect);
1868 if (!caretRect.mSucceeded) {
1869 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1870 ("IMM32: GetCaretRect, FAILED (NS_QUERY_CARET_RECT)\n"));
1871 return false;
1872 }
1873 aCaretRect = caretRect.mReply.mRect;
1874 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1875 ("IMM32: GetCaretRect, SUCCEEDED, aCaretRect={ x: %ld, y: %ld, width: %ld, height: %ld }\n",
1876 aCaretRect.x, aCaretRect.y, aCaretRect.width, aCaretRect.height));
1877 return true;
1878 }
1879
1880 bool
1881 nsIMM32Handler::SetIMERelatedWindowsPos(nsWindow* aWindow,
1882 const nsIMEContext &aIMEContext)
1883 {
1884 nsIntRect r;
1885 // Get first character rect of current a normal selected text or a composing
1886 // string.
1887 bool ret = GetCharacterRectOfSelectedTextAt(aWindow, 0, r);
1888 NS_ENSURE_TRUE(ret, false);
1889 nsWindow* toplevelWindow = aWindow->GetTopLevelWindow(false);
1890 nsIntRect firstSelectedCharRect;
1891 ResolveIMECaretPos(toplevelWindow, r, aWindow, firstSelectedCharRect);
1892
1893 // Set native caret size/position to our caret. Some IMEs honor it. E.g.,
1894 // "Intelligent ABC" (Simplified Chinese) and "MS PinYin 3.0" (Simplified
1895 // Chinese) on XP.
1896 nsIntRect caretRect(firstSelectedCharRect);
1897 if (GetCaretRect(aWindow, r)) {
1898 ResolveIMECaretPos(toplevelWindow, r, aWindow, caretRect);
1899 } else {
1900 NS_WARNING("failed to get caret rect");
1901 caretRect.width = 1;
1902 }
1903 if (!mNativeCaretIsCreated) {
1904 mNativeCaretIsCreated = ::CreateCaret(aWindow->GetWindowHandle(), nullptr,
1905 caretRect.width, caretRect.height);
1906 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1907 ("IMM32: SetIMERelatedWindowsPos, mNativeCaretIsCreated=%s, width=%ld height=%ld\n",
1908 mNativeCaretIsCreated ? "TRUE" : "FALSE",
1909 caretRect.width, caretRect.height));
1910 }
1911 ::SetCaretPos(caretRect.x, caretRect.y);
1912
1913 if (ShouldDrawCompositionStringOurselves()) {
1914 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1915 ("IMM32: SetIMERelatedWindowsPos, Set candidate window\n"));
1916
1917 // Get a rect of first character in current target in composition string.
1918 if (mIsComposing && !mCompositionString.IsEmpty()) {
1919 // If there are no targetted selection, we should use it's first character
1920 // rect instead.
1921 uint32_t offset;
1922 if (!GetTargetClauseRange(&offset)) {
1923 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1924 ("IMM32: SetIMERelatedWindowsPos, FAILED, by GetTargetClauseRange\n"));
1925 return false;
1926 }
1927 ret = GetCharacterRectOfSelectedTextAt(aWindow,
1928 offset - mCompositionStart, r);
1929 NS_ENSURE_TRUE(ret, false);
1930 } else {
1931 // If there are no composition string, we should use a first character
1932 // rect.
1933 ret = GetCharacterRectOfSelectedTextAt(aWindow, 0, r);
1934 NS_ENSURE_TRUE(ret, false);
1935 }
1936 nsIntRect firstTargetCharRect;
1937 ResolveIMECaretPos(toplevelWindow, r, aWindow, firstTargetCharRect);
1938
1939 // Move the candidate window to first character position of the target.
1940 CANDIDATEFORM candForm;
1941 candForm.dwIndex = 0;
1942 candForm.dwStyle = CFS_EXCLUDE;
1943 candForm.ptCurrentPos.x = firstTargetCharRect.x;
1944 candForm.ptCurrentPos.y = firstTargetCharRect.y;
1945 candForm.rcArea.right = candForm.rcArea.left = candForm.ptCurrentPos.x;
1946 candForm.rcArea.top = candForm.ptCurrentPos.y;
1947 candForm.rcArea.bottom = candForm.ptCurrentPos.y +
1948 firstTargetCharRect.height;
1949 ::ImmSetCandidateWindow(aIMEContext.get(), &candForm);
1950 } else {
1951 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1952 ("IMM32: SetIMERelatedWindowsPos, Set composition window\n"));
1953
1954 // Move the composition window to caret position (if selected some
1955 // characters, we should use first character rect of them).
1956 // And in this mode, IME adjusts the candidate window position
1957 // automatically. So, we don't need to set it.
1958 COMPOSITIONFORM compForm;
1959 compForm.dwStyle = CFS_POINT;
1960 compForm.ptCurrentPos.x = firstSelectedCharRect.x;
1961 compForm.ptCurrentPos.y = firstSelectedCharRect.y;
1962 ::ImmSetCompositionWindow(aIMEContext.get(), &compForm);
1963 }
1964
1965 return true;
1966 }
1967
1968 void
1969 nsIMM32Handler::SetIMERelatedWindowsPosOnPlugin(nsWindow* aWindow,
1970 const nsIMEContext& aIMEContext)
1971 {
1972 WidgetQueryContentEvent editorRectEvent(true, NS_QUERY_EDITOR_RECT, aWindow);
1973 aWindow->InitEvent(editorRectEvent);
1974 aWindow->DispatchWindowEvent(&editorRectEvent);
1975 if (!editorRectEvent.mSucceeded) {
1976 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
1977 ("IMM32: SetIMERelatedWindowsPosOnPlugin, "
1978 "FAILED (NS_QUERY_EDITOR_RECT)"));
1979 return;
1980 }
1981
1982 // Clip the plugin rect by the client rect of the window because composition
1983 // window needs to be specified the position in the client area.
1984 nsWindow* toplevelWindow = aWindow->GetTopLevelWindow(false);
1985 nsIntRect pluginRectInScreen =
1986 editorRectEvent.mReply.mRect + toplevelWindow->WidgetToScreenOffset();
1987 nsIntRect winRectInScreen;
1988 aWindow->GetClientBounds(winRectInScreen);
1989 // composition window cannot be positioned on the edge of client area.
1990 winRectInScreen.width--;
1991 winRectInScreen.height--;
1992 nsIntRect clippedPluginRect;
1993 clippedPluginRect.x =
1994 std::min(std::max(pluginRectInScreen.x, winRectInScreen.x),
1995 winRectInScreen.XMost());
1996 clippedPluginRect.y =
1997 std::min(std::max(pluginRectInScreen.y, winRectInScreen.y),
1998 winRectInScreen.YMost());
1999 int32_t xMost = std::min(pluginRectInScreen.XMost(), winRectInScreen.XMost());
2000 int32_t yMost = std::min(pluginRectInScreen.YMost(), winRectInScreen.YMost());
2001 clippedPluginRect.width = std::max(0, xMost - clippedPluginRect.x);
2002 clippedPluginRect.height = std::max(0, yMost - clippedPluginRect.y);
2003 clippedPluginRect -= aWindow->WidgetToScreenOffset();
2004
2005 // Cover the plugin with native caret. This prevents IME's window and plugin
2006 // overlap.
2007 if (mNativeCaretIsCreated) {
2008 ::DestroyCaret();
2009 }
2010 mNativeCaretIsCreated =
2011 ::CreateCaret(aWindow->GetWindowHandle(), nullptr,
2012 clippedPluginRect.width, clippedPluginRect.height);
2013 ::SetCaretPos(clippedPluginRect.x, clippedPluginRect.y);
2014
2015 // Set the composition window to bottom-left of the clipped plugin.
2016 // As far as we know, there is no IME for RTL language. Therefore, this code
2017 // must not need to take care of RTL environment.
2018 COMPOSITIONFORM compForm;
2019 compForm.dwStyle = CFS_POINT;
2020 compForm.ptCurrentPos.x = clippedPluginRect.BottomLeft().x;
2021 compForm.ptCurrentPos.y = clippedPluginRect.BottomLeft().y;
2022 if (!::ImmSetCompositionWindow(aIMEContext.get(), &compForm)) {
2023 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
2024 ("IMM32: SetIMERelatedWindowsPosOnPlugin, "
2025 "FAILED to set composition window"));
2026 return;
2027 }
2028 }
2029
2030 void
2031 nsIMM32Handler::ResolveIMECaretPos(nsIWidget* aReferenceWidget,
2032 nsIntRect& aCursorRect,
2033 nsIWidget* aNewOriginWidget,
2034 nsIntRect& aOutRect)
2035 {
2036 aOutRect = aCursorRect;
2037
2038 if (aReferenceWidget == aNewOriginWidget)
2039 return;
2040
2041 if (aReferenceWidget)
2042 aOutRect.MoveBy(aReferenceWidget->WidgetToScreenOffset());
2043
2044 if (aNewOriginWidget)
2045 aOutRect.MoveBy(-aNewOriginWidget->WidgetToScreenOffset());
2046 }
2047
2048 bool
2049 nsIMM32Handler::OnMouseEvent(nsWindow* aWindow, LPARAM lParam, int aAction,
2050 MSGResult& aResult)
2051 {
2052 aResult.mConsumed = false; // always call next wndprc
2053
2054 if (!sWM_MSIME_MOUSE || !mIsComposing ||
2055 !ShouldDrawCompositionStringOurselves()) {
2056 return false;
2057 }
2058
2059 nsIntPoint cursor(LOWORD(lParam), HIWORD(lParam));
2060 WidgetQueryContentEvent charAtPt(true, NS_QUERY_CHARACTER_AT_POINT, aWindow);
2061 aWindow->InitEvent(charAtPt, &cursor);
2062 aWindow->DispatchWindowEvent(&charAtPt);
2063 if (!charAtPt.mSucceeded ||
2064 charAtPt.mReply.mOffset == WidgetQueryContentEvent::NOT_FOUND ||
2065 charAtPt.mReply.mOffset < mCompositionStart ||
2066 charAtPt.mReply.mOffset >
2067 mCompositionStart + mCompositionString.Length()) {
2068 return false;
2069 }
2070
2071 // calcurate positioning and offset
2072 // char : JCH1|JCH2|JCH3
2073 // offset: 0011 1122 2233
2074 // positioning: 2301 2301 2301
2075 nsIntRect cursorInTopLevel, cursorRect(cursor, nsIntSize(0, 0));
2076 ResolveIMECaretPos(aWindow, cursorRect,
2077 aWindow->GetTopLevelWindow(false), cursorInTopLevel);
2078 int32_t cursorXInChar = cursorInTopLevel.x - charAtPt.mReply.mRect.x;
2079 // The event might hit to zero-width character, see bug 694913.
2080 // The reason might be:
2081 // * There are some zero-width characters are actually.
2082 // * font-size is specified zero.
2083 // But nobody reproduced this bug actually...
2084 // We should assume that user clicked on right most of the zero-width
2085 // character in such case.
2086 int positioning = 1;
2087 if (charAtPt.mReply.mRect.width > 0) {
2088 positioning = cursorXInChar * 4 / charAtPt.mReply.mRect.width;
2089 positioning = (positioning + 2) % 4;
2090 }
2091
2092 int offset = charAtPt.mReply.mOffset - mCompositionStart;
2093 if (positioning < 2) {
2094 offset++;
2095 }
2096
2097 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
2098 ("IMM32: OnMouseEvent, x,y=%ld,%ld, offset=%ld, positioning=%ld\n",
2099 cursor.x, cursor.y, offset, positioning));
2100
2101 // send MS_MSIME_MOUSE message to default IME window.
2102 HWND imeWnd = ::ImmGetDefaultIMEWnd(aWindow->GetWindowHandle());
2103 nsIMEContext IMEContext(aWindow->GetWindowHandle());
2104 return ::SendMessageW(imeWnd, sWM_MSIME_MOUSE,
2105 MAKELONG(MAKEWORD(aAction, positioning), offset),
2106 (LPARAM) IMEContext.get()) == 1;
2107 }
2108
2109 /* static */ bool
2110 nsIMM32Handler::OnKeyDownEvent(nsWindow* aWindow, WPARAM wParam, LPARAM lParam,
2111 MSGResult& aResult)
2112 {
2113 PR_LOG(gIMM32Log, PR_LOG_ALWAYS,
2114 ("IMM32: OnKeyDownEvent, hWnd=%08x, wParam=%08x, lParam=%08x\n",
2115 aWindow->GetWindowHandle(), wParam, lParam));
2116 aResult.mConsumed = false;
2117 switch (wParam) {
2118 case VK_TAB:
2119 case VK_PRIOR:
2120 case VK_NEXT:
2121 case VK_END:
2122 case VK_HOME:
2123 case VK_LEFT:
2124 case VK_UP:
2125 case VK_RIGHT:
2126 case VK_DOWN:
2127 // If IME didn't process the key message (the virtual key code wasn't
2128 // converted to VK_PROCESSKEY), and the virtual key code event causes
2129 // to move caret, we should cancel the composition here. Then, this
2130 // event will be dispatched.
2131 // XXX I think that we should dispatch all key events during composition,
2132 // and nsEditor should cancel/commit the composition if it *thinks*
2133 // it's needed.
2134 if (IsComposingOnOurEditor()) {
2135 // NOTE: We don't need to cancel the composition on another window.
2136 CancelComposition(aWindow, false);
2137 }
2138 return false;
2139 default:
2140 return false;
2141 }
2142 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial