?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sapi: Add SpMMAudioOut stub.
[wine.git] / dlls / riched20 / txthost.c
blob412733edaeb76b1b37116e8cd36ee3734a760c9f
1 /*
2 * RichEdit - ITextHost implementation for windowed richedit controls
3 *
4 * Copyright 2009 by Dylan Smith
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #define COBJMACROS
22
23 #include "editor.h"
24 #include "ole2.h"
25 #include "richole.h"
26 #include "imm.h"
27 #include "textserv.h"
28 #include "wine/debug.h"
29 #include "editstr.h"
30 #include "rtf.h"
31
32 WINE_DEFAULT_DEBUG_CHANNEL(richedit);
33
34 struct host
35 {
36 ITextHost2 ITextHost_iface;
37 LONG ref;
38 ITextServices *text_srv;
39 HWND window, parent;
40 unsigned int emulate_10 : 1;
41 unsigned int dialog_mode : 1;
42 unsigned int want_return : 1;
43 unsigned int sel_bar : 1;
44 unsigned int client_edge : 1;
45 unsigned int use_set_rect : 1;
46 unsigned int use_back_colour : 1;
47 unsigned int defer_release : 1;
48 PARAFORMAT2 para_fmt;
49 DWORD props, scrollbars, event_mask;
50 RECT client_rect, set_rect;
51 COLORREF back_colour;
52 WCHAR password_char;
53 unsigned int notify_level;
54 };
55
56 static const ITextHost2Vtbl textHostVtbl;
57
58 static BOOL listbox_registered;
59 static BOOL combobox_registered;
60
61 static void host_init_props( struct host *host )
62 {
63 DWORD style;
64
65 style = GetWindowLongW( host->window, GWL_STYLE );
66
67 /* text services assumes the scrollbars are originally not shown, so hide them.
68 However with ES_DISABLENOSCROLL it'll immediately show them, so don't bother */
69 if (!(style & ES_DISABLENOSCROLL)) ShowScrollBar( host->window, SB_BOTH, FALSE );
70
71 host->scrollbars = style & (WS_VSCROLL | WS_HSCROLL | ES_AUTOVSCROLL |
72 ES_AUTOHSCROLL | ES_DISABLENOSCROLL);
73 if (style & WS_VSCROLL) host->scrollbars |= ES_AUTOVSCROLL;
74 if ((style & WS_HSCROLL) && !host->emulate_10) host->scrollbars |= ES_AUTOHSCROLL;
75
76 host->props = TXTBIT_RICHTEXT | TXTBIT_ALLOWBEEP;
77 if (style & ES_MULTILINE) host->props |= TXTBIT_MULTILINE;
78 if (style & ES_READONLY) host->props |= TXTBIT_READONLY;
79 if (style & ES_PASSWORD) host->props |= TXTBIT_USEPASSWORD;
80 if (!(style & ES_NOHIDESEL)) host->props |= TXTBIT_HIDESELECTION;
81 if (style & ES_SAVESEL) host->props |= TXTBIT_SAVESELECTION;
82 if (style & ES_VERTICAL) host->props |= TXTBIT_VERTICAL;
83 if (style & ES_NOOLEDRAGDROP) host->props |= TXTBIT_DISABLEDRAG;
84
85 if (!(host->scrollbars & ES_AUTOHSCROLL)) host->props |= TXTBIT_WORDWRAP;
86
87 host->sel_bar = !!(style & ES_SELECTIONBAR);
88 host->want_return = !!(style & ES_WANTRETURN);
89
90 style = GetWindowLongW( host->window, GWL_EXSTYLE );
91 host->client_edge = !!(style & WS_EX_CLIENTEDGE);
92 }
93
94 struct host *host_create( HWND hwnd, CREATESTRUCTW *cs, BOOL emulate_10 )
95 {
96 struct host *texthost;
97
98 texthost = heap_alloc(sizeof(*texthost));
99 if (!texthost) return NULL;
100
101 texthost->ITextHost_iface.lpVtbl = &textHostVtbl;
102 texthost->ref = 1;
103 texthost->text_srv = NULL;
104 texthost->window = hwnd;
105 texthost->parent = cs->hwndParent;
106 texthost->emulate_10 = emulate_10;
107 texthost->dialog_mode = 0;
108 memset( &texthost->para_fmt, 0, sizeof(texthost->para_fmt) );
109 texthost->para_fmt.cbSize = sizeof(texthost->para_fmt);
110 texthost->para_fmt.dwMask = PFM_ALIGNMENT;
111 texthost->para_fmt.wAlignment = PFA_LEFT;
112 if (cs->style & ES_RIGHT)
113 texthost->para_fmt.wAlignment = PFA_RIGHT;
114 if (cs->style & ES_CENTER)
115 texthost->para_fmt.wAlignment = PFA_CENTER;
116 host_init_props( texthost );
117 texthost->event_mask = 0;
118 texthost->use_set_rect = 0;
119 SetRectEmpty( &texthost->set_rect );
120 GetClientRect( hwnd, &texthost->client_rect );
121 texthost->use_back_colour = 0;
122 texthost->password_char = (texthost->props & TXTBIT_USEPASSWORD) ? '*' : 0;
123 texthost->defer_release = 0;
124 texthost->notify_level = 0;
125
126 return texthost;
127 }
128
129 static inline struct host *impl_from_ITextHost( ITextHost2 *iface )
130 {
131 return CONTAINING_RECORD( iface, struct host, ITextHost_iface );
132 }
133
134 static HRESULT WINAPI ITextHostImpl_QueryInterface( ITextHost2 *iface, REFIID iid, void **obj )
135 {
136 struct host *host = impl_from_ITextHost( iface );
137
138 if (IsEqualIID( iid, &IID_IUnknown ) || IsEqualIID( iid, &IID_ITextHost ) || IsEqualIID( iid, &IID_ITextHost2 ))
139 {
140 *obj = &host->ITextHost_iface;
141 ITextHost_AddRef( (ITextHost *)*obj );
142 return S_OK;
143 }
144
145 FIXME( "Unknown interface: %s\n", debugstr_guid( iid ) );
146 return E_NOINTERFACE;
147 }
148
149 static ULONG WINAPI ITextHostImpl_AddRef( ITextHost2 *iface )
150 {
151 struct host *host = impl_from_ITextHost( iface );
152 ULONG ref = InterlockedIncrement( &host->ref );
153 return ref;
154 }
155
156 static ULONG WINAPI ITextHostImpl_Release( ITextHost2 *iface )
157 {
158 struct host *host = impl_from_ITextHost( iface );
159 ULONG ref = InterlockedDecrement( &host->ref );
160
161 if (!ref)
162 {
163 SetWindowLongPtrW( host->window, 0, 0 );
164 ITextServices_Release( host->text_srv );
165 heap_free( host );
166 }
167 return ref;
168 }
169
170 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxGetDC,4)
171 DECLSPEC_HIDDEN HDC __thiscall ITextHostImpl_TxGetDC( ITextHost2 *iface )
172 {
173 struct host *host = impl_from_ITextHost( iface );
174 return GetDC( host->window );
175 }
176
177 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxReleaseDC,8)
178 DECLSPEC_HIDDEN INT __thiscall ITextHostImpl_TxReleaseDC( ITextHost2 *iface, HDC hdc )
179 {
180 struct host *host = impl_from_ITextHost( iface );
181 return ReleaseDC( host->window, hdc );
182 }
183
184 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxShowScrollBar,12)
185 DECLSPEC_HIDDEN BOOL __thiscall ITextHostImpl_TxShowScrollBar( ITextHost2 *iface, INT bar, BOOL show )
186 {
187 struct host *host = impl_from_ITextHost( iface );
188 return ShowScrollBar( host->window, bar, show );
189 }
190
191 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxEnableScrollBar,12)
192 DECLSPEC_HIDDEN BOOL __thiscall ITextHostImpl_TxEnableScrollBar( ITextHost2 *iface, INT bar, INT arrows )
193 {
194 struct host *host = impl_from_ITextHost( iface );
195 return EnableScrollBar( host->window, bar, arrows );
196 }
197
198 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxSetScrollRange,20)
199 DECLSPEC_HIDDEN BOOL __thiscall ITextHostImpl_TxSetScrollRange( ITextHost2 *iface, INT bar, LONG min_pos, INT max_pos, BOOL redraw )
200 {
201 struct host *host = impl_from_ITextHost( iface );
202 SCROLLINFO info = { .cbSize = sizeof(info), .fMask = SIF_PAGE | SIF_RANGE };
203
204 if (bar != SB_HORZ && bar != SB_VERT)
205 {
206 FIXME( "Unexpected bar %d\n", bar );
207 return FALSE;
208 }
209
210 if (host->scrollbars & ES_DISABLENOSCROLL) info.fMask |= SIF_DISABLENOSCROLL;
211
212 if (host->text_srv) /* This can be called during text services creation */
213 {
214 if (bar == SB_HORZ) ITextServices_TxGetHScroll( host->text_srv, NULL, NULL, NULL, (LONG *)&info.nPage, NULL );
215 else ITextServices_TxGetVScroll( host->text_srv, NULL, NULL, NULL, (LONG *)&info.nPage, NULL );
216 }
217
218 info.nMin = min_pos;
219 info.nMax = max_pos;
220 return SetScrollInfo( host->window, bar, &info, redraw );
221 }
222
223 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxSetScrollPos,16)
224 DECLSPEC_HIDDEN BOOL __thiscall ITextHostImpl_TxSetScrollPos( ITextHost2 *iface, INT bar, INT pos, BOOL redraw )
225 {
226 struct host *host = impl_from_ITextHost( iface );
227 DWORD style = GetWindowLongW( host->window, GWL_STYLE );
228 DWORD mask = (bar == SB_HORZ) ? WS_HSCROLL : WS_VSCROLL;
229 BOOL show = TRUE, shown = style & mask;
230
231 if (bar != SB_HORZ && bar != SB_VERT)
232 {
233 FIXME( "Unexpected bar %d\n", bar );
234 return FALSE;
235 }
236
237 /* If the application has adjusted the scrollbar's visibility it is reset */
238 if (!(host->scrollbars & ES_DISABLENOSCROLL))
239 {
240 if (bar == SB_HORZ) ITextServices_TxGetHScroll( host->text_srv, NULL, NULL, NULL, NULL, &show );
241 else ITextServices_TxGetVScroll( host->text_srv, NULL, NULL, NULL, NULL, &show );
242 }
243
244 if (!show ^ !shown) ShowScrollBar( host->window, bar, show );
245 return SetScrollPos( host->window, bar, pos, redraw ) != 0;
246 }
247
248 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxInvalidateRect,12)
249 DECLSPEC_HIDDEN void __thiscall ITextHostImpl_TxInvalidateRect( ITextHost2 *iface, const RECT *rect, BOOL mode )
250 {
251 struct host *host = impl_from_ITextHost( iface );
252 InvalidateRect( host->window, rect, mode );
253 }
254
255 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxViewChange,8)
256 DECLSPEC_HIDDEN void __thiscall ITextHostImpl_TxViewChange( ITextHost2 *iface, BOOL update )
257 {
258 struct host *host = impl_from_ITextHost( iface );
259 if (update) UpdateWindow( host->window );
260 }
261
262 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxCreateCaret,16)
263 DECLSPEC_HIDDEN BOOL __thiscall ITextHostImpl_TxCreateCaret( ITextHost2 *iface, HBITMAP bitmap, INT width, INT height )
264 {
265 struct host *host = impl_from_ITextHost( iface );
266 return CreateCaret( host->window, bitmap, width, height );
267 }
268
269 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxShowCaret,8)
270 DECLSPEC_HIDDEN BOOL __thiscall ITextHostImpl_TxShowCaret( ITextHost2 *iface, BOOL show )
271 {
272 struct host *host = impl_from_ITextHost( iface );
273 if (show) return ShowCaret( host->window );
274 else return HideCaret( host->window );
275 }
276
277 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxSetCaretPos,12)
278 DECLSPEC_HIDDEN BOOL __thiscall ITextHostImpl_TxSetCaretPos( ITextHost2 *iface, INT x, INT y )
279 {
280 return SetCaretPos(x, y);
281 }
282
283 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxSetTimer,12)
284 DECLSPEC_HIDDEN BOOL __thiscall ITextHostImpl_TxSetTimer( ITextHost2 *iface, UINT id, UINT timeout )
285 {
286 struct host *host = impl_from_ITextHost( iface );
287 return SetTimer( host->window, id, timeout, NULL ) != 0;
288 }
289
290 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxKillTimer,8)
291 DECLSPEC_HIDDEN void __thiscall ITextHostImpl_TxKillTimer( ITextHost2 *iface, UINT id )
292 {
293 struct host *host = impl_from_ITextHost( iface );
294 KillTimer( host->window, id );
295 }
296
297 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxScrollWindowEx,32)
298 DECLSPEC_HIDDEN void __thiscall ITextHostImpl_TxScrollWindowEx( ITextHost2 *iface, INT dx, INT dy, const RECT *scroll,
299 const RECT *clip, HRGN update_rgn, RECT *update_rect,
300 UINT flags )
301 {
302 struct host *host = impl_from_ITextHost( iface );
303 ScrollWindowEx( host->window, dx, dy, scroll, clip, update_rgn, update_rect, flags );
304 }
305
306 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxSetCapture,8)
307 DECLSPEC_HIDDEN void __thiscall ITextHostImpl_TxSetCapture( ITextHost2 *iface, BOOL capture )
308 {
309 struct host *host = impl_from_ITextHost( iface );
310 if (capture) SetCapture( host->window );
311 else ReleaseCapture();
312 }
313
314 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxSetFocus,4)
315 DECLSPEC_HIDDEN void __thiscall ITextHostImpl_TxSetFocus( ITextHost2 *iface )
316 {
317 struct host *host = impl_from_ITextHost( iface );
318 SetFocus( host->window );
319 }
320
321 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxSetCursor,12)
322 DECLSPEC_HIDDEN void __thiscall ITextHostImpl_TxSetCursor( ITextHost2 *iface, HCURSOR cursor, BOOL text )
323 {
324 SetCursor( cursor );
325 }
326
327 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxScreenToClient,8)
328 DECLSPEC_HIDDEN BOOL __thiscall ITextHostImpl_TxScreenToClient( ITextHost2 *iface, POINT *pt )
329 {
330 struct host *host = impl_from_ITextHost( iface );
331 return ScreenToClient( host->window, pt );
332 }
333
334 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxClientToScreen,8)
335 DECLSPEC_HIDDEN BOOL __thiscall ITextHostImpl_TxClientToScreen( ITextHost2 *iface, POINT *pt )
336 {
337 struct host *host = impl_from_ITextHost( iface );
338 return ClientToScreen( host->window, pt );
339 }
340
341 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxActivate,8)
342 DECLSPEC_HIDDEN HRESULT __thiscall ITextHostImpl_TxActivate( ITextHost2 *iface, LONG *old_state )
343 {
344 struct host *host = impl_from_ITextHost( iface );
345 *old_state = HandleToLong( SetActiveWindow( host->window ) );
346 return *old_state ? S_OK : E_FAIL;
347 }
348
349 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxDeactivate,8)
350 DECLSPEC_HIDDEN HRESULT __thiscall ITextHostImpl_TxDeactivate( ITextHost2 *iface, LONG new_state )
351 {
352 HWND ret = SetActiveWindow( LongToHandle( new_state ) );
353 return ret ? S_OK : E_FAIL;
354 }
355
356 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxGetClientRect,8)
357 DECLSPEC_HIDDEN HRESULT __thiscall ITextHostImpl_TxGetClientRect( ITextHost2 *iface, RECT *rect )
358 {
359 struct host *host = impl_from_ITextHost( iface );
360
361 if (!host->use_set_rect)
362 {
363 *rect = host->client_rect;
364 if (host->client_edge) rect->top += 1;
365 InflateRect( rect, -1, 0 );
366 }
367 else *rect = host->set_rect;
368
369 return S_OK;
370 }
371
372 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxGetViewInset,8)
373 DECLSPEC_HIDDEN HRESULT __thiscall ITextHostImpl_TxGetViewInset( ITextHost2 *iface, RECT *rect )
374 {
375 SetRectEmpty( rect );
376 return S_OK;
377 }
378
379 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxGetCharFormat,8)
380 DECLSPEC_HIDDEN HRESULT __thiscall ITextHostImpl_TxGetCharFormat( ITextHost2 *iface, const CHARFORMATW **ppCF )
381 {
382 return E_NOTIMPL;
383 }
384
385 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxGetParaFormat,8)
386 DECLSPEC_HIDDEN HRESULT __thiscall ITextHostImpl_TxGetParaFormat( ITextHost2 *iface, const PARAFORMAT **fmt )
387 {
388 struct host *host = impl_from_ITextHost( iface );
389 *fmt = (const PARAFORMAT *)&host->para_fmt;
390 return S_OK;
391 }
392
393 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxGetSysColor,8)
394 DECLSPEC_HIDDEN COLORREF __thiscall ITextHostImpl_TxGetSysColor( ITextHost2 *iface, int index )
395 {
396 struct host *host = impl_from_ITextHost( iface );
397
398 if (index == COLOR_WINDOW && host->use_back_colour) return host->back_colour;
399 return GetSysColor( index );
400 }
401
402 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxGetBackStyle,8)
403 DECLSPEC_HIDDEN HRESULT __thiscall ITextHostImpl_TxGetBackStyle( ITextHost2 *iface, TXTBACKSTYLE *style )
404 {
405 *style = TXTBACK_OPAQUE;
406 return S_OK;
407 }
408
409 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxGetMaxLength,8)
410 DECLSPEC_HIDDEN HRESULT __thiscall ITextHostImpl_TxGetMaxLength( ITextHost2 *iface, DWORD *length )
411 {
412 *length = INFINITE;
413 return S_OK;
414 }
415
416 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxGetScrollBars,8)
417 DECLSPEC_HIDDEN HRESULT __thiscall ITextHostImpl_TxGetScrollBars( ITextHost2 *iface, DWORD *scrollbars )
418 {
419 struct host *host = impl_from_ITextHost( iface );
420
421 *scrollbars = host->scrollbars;
422 return S_OK;
423 }
424
425 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxGetPasswordChar,8)
426 DECLSPEC_HIDDEN HRESULT __thiscall ITextHostImpl_TxGetPasswordChar( ITextHost2 *iface, WCHAR *c )
427 {
428 struct host *host = impl_from_ITextHost( iface );
429
430 *c = host->password_char;
431 return *c ? S_OK : S_FALSE;
432 }
433
434 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxGetAcceleratorPos,8)
435 DECLSPEC_HIDDEN HRESULT __thiscall ITextHostImpl_TxGetAcceleratorPos( ITextHost2 *iface, LONG *pos )
436 {
437 *pos = -1;
438 return S_OK;
439 }
440
441 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxGetExtent,8)
442 DECLSPEC_HIDDEN HRESULT __thiscall ITextHostImpl_TxGetExtent( ITextHost2 *iface, SIZEL *extent )
443 {
444 return E_NOTIMPL;
445 }
446
447 DEFINE_THISCALL_WRAPPER(ITextHostImpl_OnTxCharFormatChange,8)
448 DECLSPEC_HIDDEN HRESULT __thiscall ITextHostImpl_OnTxCharFormatChange( ITextHost2 *iface, const CHARFORMATW *pcf )
449 {
450 return S_OK;
451 }
452
453 DEFINE_THISCALL_WRAPPER(ITextHostImpl_OnTxParaFormatChange,8)
454 DECLSPEC_HIDDEN HRESULT __thiscall ITextHostImpl_OnTxParaFormatChange( ITextHost2 *iface, const PARAFORMAT *ppf )
455 {
456 return S_OK;
457 }
458
459 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxGetPropertyBits,12)
460 DECLSPEC_HIDDEN HRESULT __thiscall ITextHostImpl_TxGetPropertyBits( ITextHost2 *iface, DWORD mask, DWORD *bits )
461 {
462 struct host *host = impl_from_ITextHost( iface );
463
464 *bits = host->props & mask;
465 return S_OK;
466 }
467
468 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxNotify,12)
469 DECLSPEC_HIDDEN HRESULT __thiscall ITextHostImpl_TxNotify( ITextHost2 *iface, DWORD iNotify, void *pv )
470 {
471 struct host *host = impl_from_ITextHost( iface );
472 UINT id;
473
474 if (!host->parent) return S_OK;
475
476 id = GetWindowLongW( host->window, GWLP_ID );
477
478 switch (iNotify)
479 {
480 case EN_DROPFILES:
481 case EN_LINK:
482 case EN_OLEOPFAILED:
483 case EN_PROTECTED:
484 case EN_REQUESTRESIZE:
485 case EN_SAVECLIPBOARD:
486 case EN_SELCHANGE:
487 case EN_STOPNOUNDO:
488 {
489 /* FIXME: Verify this assumption that pv starts with NMHDR. */
490 NMHDR *info = pv;
491 if (!info)
492 return E_FAIL;
493
494 info->hwndFrom = host->window;
495 info->idFrom = id;
496 info->code = iNotify;
497 SendMessageW( host->parent, WM_NOTIFY, id, (LPARAM)info );
498 break;
499 }
500
501 case EN_UPDATE:
502 /* Only sent when the window is visible. */
503 if (!IsWindowVisible( host->window ))
504 break;
505 /* Fall through */
506 case EN_CHANGE:
507 case EN_ERRSPACE:
508 case EN_HSCROLL:
509 case EN_KILLFOCUS:
510 case EN_MAXTEXT:
511 case EN_SETFOCUS:
512 case EN_VSCROLL:
513 SendMessageW( host->parent, WM_COMMAND, MAKEWPARAM( id, iNotify ), (LPARAM)host->window );
514 break;
515
516 case EN_MSGFILTER:
517 FIXME("EN_MSGFILTER is documented as not being sent to TxNotify\n");
518 /* fall through */
519 default:
520 return E_FAIL;
521 }
522 return S_OK;
523 }
524
525 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxImmGetContext,4)
526 DECLSPEC_HIDDEN HIMC __thiscall ITextHostImpl_TxImmGetContext( ITextHost2 *iface )
527 {
528 struct host *host = impl_from_ITextHost( iface );
529 return ImmGetContext( host->window );
530 }
531
532 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxImmReleaseContext,8)
533 DECLSPEC_HIDDEN void __thiscall ITextHostImpl_TxImmReleaseContext( ITextHost2 *iface, HIMC context )
534 {
535 struct host *host = impl_from_ITextHost( iface );
536 ImmReleaseContext( host->window, context );
537 }
538
539 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxGetSelectionBarWidth,8)
540 DECLSPEC_HIDDEN HRESULT __thiscall ITextHostImpl_TxGetSelectionBarWidth( ITextHost2 *iface, LONG *width )
541 {
542 struct host *host = impl_from_ITextHost( iface );
543
544 *width = host->sel_bar ? 225 : 0; /* in HIMETRIC */
545 return S_OK;
546 }
547
548 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxIsDoubleClickPending,4)
549 DECLSPEC_HIDDEN BOOL __thiscall ITextHostImpl_TxIsDoubleClickPending( ITextHost2 *iface )
550 {
551 return FALSE;
552 }
553
554 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxGetWindow,8)
555 DECLSPEC_HIDDEN HRESULT __thiscall ITextHostImpl_TxGetWindow( ITextHost2 *iface, HWND *hwnd )
556 {
557 struct host *host = impl_from_ITextHost( iface );
558 *hwnd = host->window;
559 return S_OK;
560 }
561
562 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxSetForegroundWindow,4)
563 DECLSPEC_HIDDEN HRESULT __thiscall ITextHostImpl_TxSetForegroundWindow( ITextHost2 *iface )
564 {
565 return E_NOTIMPL;
566 }
567
568 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxGetPalette,4)
569 DECLSPEC_HIDDEN HPALETTE __thiscall ITextHostImpl_TxGetPalette( ITextHost2 *iface )
570 {
571 return NULL;
572 }
573
574 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxGetEastAsianFlags,8)
575 DECLSPEC_HIDDEN HRESULT __thiscall ITextHostImpl_TxGetEastAsianFlags( ITextHost2 *iface, LONG *flags )
576 {
577 return E_NOTIMPL;
578 }
579
580 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxSetCursor2,12)
581 DECLSPEC_HIDDEN HCURSOR __thiscall ITextHostImpl_TxSetCursor2( ITextHost2 *iface, HCURSOR cursor, BOOL text )
582 {
583 return NULL;
584 }
585
586 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxFreeTextServicesNotification,4)
587 DECLSPEC_HIDDEN void __thiscall ITextHostImpl_TxFreeTextServicesNotification( ITextHost2 *iface )
588 {
589 return;
590 }
591
592 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxGetEditStyle,12)
593 DECLSPEC_HIDDEN HRESULT __thiscall ITextHostImpl_TxGetEditStyle( ITextHost2 *iface, DWORD item, DWORD *data )
594 {
595 return E_NOTIMPL;
596 }
597
598 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxGetWindowStyles,12)
599 DECLSPEC_HIDDEN HRESULT __thiscall ITextHostImpl_TxGetWindowStyles( ITextHost2 *iface, DWORD *style, DWORD *ex_style )
600 {
601 return E_NOTIMPL;
602 }
603
604 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxShowDropCaret,16)
605 DECLSPEC_HIDDEN HRESULT __thiscall ITextHostImpl_TxShowDropCaret( ITextHost2 *iface, BOOL show, HDC hdc, const RECT *rect )
606 {
607 return E_NOTIMPL;
608 }
609
610 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxDestroyCaret,4)
611 DECLSPEC_HIDDEN HRESULT __thiscall ITextHostImpl_TxDestroyCaret( ITextHost2 *iface )
612 {
613 return E_NOTIMPL;
614 }
615
616 DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxGetHorzExtent,8)
617 DECLSPEC_HIDDEN HRESULT __thiscall ITextHostImpl_TxGetHorzExtent( ITextHost2 *iface, LONG *horz_extent )
618 {
619 return E_NOTIMPL;
620 }
621
622
623 #ifdef __ASM_USE_THISCALL_WRAPPER
624
625 #define STDCALL(func) (void *) __stdcall_ ## func
626 #ifdef _MSC_VER
627 #define DEFINE_STDCALL_WRAPPER(num,func,args) \
628 __declspec(naked) HRESULT __stdcall_##func(void) \
629 { \
630 __asm pop eax \
631 __asm pop ecx \
632 __asm push eax \
633 __asm mov eax, [ecx] \
634 __asm jmp dword ptr [eax + 4*num] \
635 }
636 #else /* _MSC_VER */
637 #define DEFINE_STDCALL_WRAPPER(num,func,args) \
638 extern HRESULT __stdcall_ ## func(void); \
639 __ASM_GLOBAL_FUNC(__stdcall_ ## func, \
640 "popl %eax\n\t" \
641 "popl %ecx\n\t" \
642 "pushl %eax\n\t" \
643 "movl (%ecx), %eax\n\t" \
644 "jmp *(4*(" #num "))(%eax)" )
645 #endif /* _MSC_VER */
646
647 DEFINE_STDCALL_WRAPPER(3,ITextHostImpl_TxGetDC,4)
648 DEFINE_STDCALL_WRAPPER(4,ITextHostImpl_TxReleaseDC,8)
649 DEFINE_STDCALL_WRAPPER(5,ITextHostImpl_TxShowScrollBar,12)
650 DEFINE_STDCALL_WRAPPER(6,ITextHostImpl_TxEnableScrollBar,12)
651 DEFINE_STDCALL_WRAPPER(7,ITextHostImpl_TxSetScrollRange,20)
652 DEFINE_STDCALL_WRAPPER(8,ITextHostImpl_TxSetScrollPos,16)
653 DEFINE_STDCALL_WRAPPER(9,ITextHostImpl_TxInvalidateRect,12)
654 DEFINE_STDCALL_WRAPPER(10,ITextHostImpl_TxViewChange,8)
655 DEFINE_STDCALL_WRAPPER(11,ITextHostImpl_TxCreateCaret,16)
656 DEFINE_STDCALL_WRAPPER(12,ITextHostImpl_TxShowCaret,8)
657 DEFINE_STDCALL_WRAPPER(13,ITextHostImpl_TxSetCaretPos,12)
658 DEFINE_STDCALL_WRAPPER(14,ITextHostImpl_TxSetTimer,12)
659 DEFINE_STDCALL_WRAPPER(15,ITextHostImpl_TxKillTimer,8)
660 DEFINE_STDCALL_WRAPPER(16,ITextHostImpl_TxScrollWindowEx,32)
661 DEFINE_STDCALL_WRAPPER(17,ITextHostImpl_TxSetCapture,8)
662 DEFINE_STDCALL_WRAPPER(18,ITextHostImpl_TxSetFocus,4)
663 DEFINE_STDCALL_WRAPPER(19,ITextHostImpl_TxSetCursor,12)
664 DEFINE_STDCALL_WRAPPER(20,ITextHostImpl_TxScreenToClient,8)
665 DEFINE_STDCALL_WRAPPER(21,ITextHostImpl_TxClientToScreen,8)
666 DEFINE_STDCALL_WRAPPER(22,ITextHostImpl_TxActivate,8)
667 DEFINE_STDCALL_WRAPPER(23,ITextHostImpl_TxDeactivate,8)
668 DEFINE_STDCALL_WRAPPER(24,ITextHostImpl_TxGetClientRect,8)
669 DEFINE_STDCALL_WRAPPER(25,ITextHostImpl_TxGetViewInset,8)
670 DEFINE_STDCALL_WRAPPER(26,ITextHostImpl_TxGetCharFormat,8)
671 DEFINE_STDCALL_WRAPPER(27,ITextHostImpl_TxGetParaFormat,8)
672 DEFINE_STDCALL_WRAPPER(28,ITextHostImpl_TxGetSysColor,8)
673 DEFINE_STDCALL_WRAPPER(29,ITextHostImpl_TxGetBackStyle,8)
674 DEFINE_STDCALL_WRAPPER(30,ITextHostImpl_TxGetMaxLength,8)
675 DEFINE_STDCALL_WRAPPER(31,ITextHostImpl_TxGetScrollBars,8)
676 DEFINE_STDCALL_WRAPPER(32,ITextHostImpl_TxGetPasswordChar,8)
677 DEFINE_STDCALL_WRAPPER(33,ITextHostImpl_TxGetAcceleratorPos,8)
678 DEFINE_STDCALL_WRAPPER(34,ITextHostImpl_TxGetExtent,8)
679 DEFINE_STDCALL_WRAPPER(35,ITextHostImpl_OnTxCharFormatChange,8)
680 DEFINE_STDCALL_WRAPPER(36,ITextHostImpl_OnTxParaFormatChange,8)
681 DEFINE_STDCALL_WRAPPER(37,ITextHostImpl_TxGetPropertyBits,12)
682 DEFINE_STDCALL_WRAPPER(38,ITextHostImpl_TxNotify,12)
683 DEFINE_STDCALL_WRAPPER(39,ITextHostImpl_TxImmGetContext,4)
684 DEFINE_STDCALL_WRAPPER(40,ITextHostImpl_TxImmReleaseContext,8)
685 DEFINE_STDCALL_WRAPPER(41,ITextHostImpl_TxGetSelectionBarWidth,8)
686 /* ITextHost2 */
687 DEFINE_STDCALL_WRAPPER(42,ITextHostImpl_TxIsDoubleClickPending,4)
688 DEFINE_STDCALL_WRAPPER(43,ITextHostImpl_TxGetWindow,8)
689 DEFINE_STDCALL_WRAPPER(44,ITextHostImpl_TxSetForegroundWindow,4)
690 DEFINE_STDCALL_WRAPPER(45,ITextHostImpl_TxGetPalette,4)
691 DEFINE_STDCALL_WRAPPER(46,ITextHostImpl_TxGetEastAsianFlags,8)
692 DEFINE_STDCALL_WRAPPER(47,ITextHostImpl_TxSetCursor2,12)
693 DEFINE_STDCALL_WRAPPER(48,ITextHostImpl_TxFreeTextServicesNotification,4)
694 DEFINE_STDCALL_WRAPPER(49,ITextHostImpl_TxGetEditStyle,12)
695 DEFINE_STDCALL_WRAPPER(50,ITextHostImpl_TxGetWindowStyles,12)
696 DEFINE_STDCALL_WRAPPER(51,ITextHostImpl_TxShowDropCaret,16)
697 DEFINE_STDCALL_WRAPPER(52,ITextHostImpl_TxDestroyCaret,4)
698 DEFINE_STDCALL_WRAPPER(53,ITextHostImpl_TxGetHorzExtent,8)
699
700 const ITextHost2Vtbl text_host2_stdcall_vtbl =
701 {
702 NULL,
703 NULL,
704 NULL,
705 STDCALL(ITextHostImpl_TxGetDC),
706 STDCALL(ITextHostImpl_TxReleaseDC),
707 STDCALL(ITextHostImpl_TxShowScrollBar),
708 STDCALL(ITextHostImpl_TxEnableScrollBar),
709 STDCALL(ITextHostImpl_TxSetScrollRange),
710 STDCALL(ITextHostImpl_TxSetScrollPos),
711 STDCALL(ITextHostImpl_TxInvalidateRect),
712 STDCALL(ITextHostImpl_TxViewChange),
713 STDCALL(ITextHostImpl_TxCreateCaret),
714 STDCALL(ITextHostImpl_TxShowCaret),
715 STDCALL(ITextHostImpl_TxSetCaretPos),
716 STDCALL(ITextHostImpl_TxSetTimer),
717 STDCALL(ITextHostImpl_TxKillTimer),
718 STDCALL(ITextHostImpl_TxScrollWindowEx),
719 STDCALL(ITextHostImpl_TxSetCapture),
720 STDCALL(ITextHostImpl_TxSetFocus),
721 STDCALL(ITextHostImpl_TxSetCursor),
722 STDCALL(ITextHostImpl_TxScreenToClient),
723 STDCALL(ITextHostImpl_TxClientToScreen),
724 STDCALL(ITextHostImpl_TxActivate),
725 STDCALL(ITextHostImpl_TxDeactivate),
726 STDCALL(ITextHostImpl_TxGetClientRect),
727 STDCALL(ITextHostImpl_TxGetViewInset),
728 STDCALL(ITextHostImpl_TxGetCharFormat),
729 STDCALL(ITextHostImpl_TxGetParaFormat),
730 STDCALL(ITextHostImpl_TxGetSysColor),
731 STDCALL(ITextHostImpl_TxGetBackStyle),
732 STDCALL(ITextHostImpl_TxGetMaxLength),
733 STDCALL(ITextHostImpl_TxGetScrollBars),
734 STDCALL(ITextHostImpl_TxGetPasswordChar),
735 STDCALL(ITextHostImpl_TxGetAcceleratorPos),
736 STDCALL(ITextHostImpl_TxGetExtent),
737 STDCALL(ITextHostImpl_OnTxCharFormatChange),
738 STDCALL(ITextHostImpl_OnTxParaFormatChange),
739 STDCALL(ITextHostImpl_TxGetPropertyBits),
740 STDCALL(ITextHostImpl_TxNotify),
741 STDCALL(ITextHostImpl_TxImmGetContext),
742 STDCALL(ITextHostImpl_TxImmReleaseContext),
743 STDCALL(ITextHostImpl_TxGetSelectionBarWidth),
744 /* ITextHost2 */
745 STDCALL(ITextHostImpl_TxIsDoubleClickPending),
746 STDCALL(ITextHostImpl_TxGetWindow),
747 STDCALL(ITextHostImpl_TxSetForegroundWindow),
748 STDCALL(ITextHostImpl_TxGetPalette),
749 STDCALL(ITextHostImpl_TxGetEastAsianFlags),
750 STDCALL(ITextHostImpl_TxSetCursor2),
751 STDCALL(ITextHostImpl_TxFreeTextServicesNotification),
752 STDCALL(ITextHostImpl_TxGetEditStyle),
753 STDCALL(ITextHostImpl_TxGetWindowStyles),
754 STDCALL(ITextHostImpl_TxShowDropCaret),
755 STDCALL(ITextHostImpl_TxDestroyCaret),
756 STDCALL(ITextHostImpl_TxGetHorzExtent)
757 };
758
759 #endif /* __ASM_USE_THISCALL_WRAPPER */
760
761 static const ITextHost2Vtbl textHostVtbl =
762 {
763 ITextHostImpl_QueryInterface,
764 ITextHostImpl_AddRef,
765 ITextHostImpl_Release,
766 THISCALL(ITextHostImpl_TxGetDC),
767 THISCALL(ITextHostImpl_TxReleaseDC),
768 THISCALL(ITextHostImpl_TxShowScrollBar),
769 THISCALL(ITextHostImpl_TxEnableScrollBar),
770 THISCALL(ITextHostImpl_TxSetScrollRange),
771 THISCALL(ITextHostImpl_TxSetScrollPos),
772 THISCALL(ITextHostImpl_TxInvalidateRect),
773 THISCALL(ITextHostImpl_TxViewChange),
774 THISCALL(ITextHostImpl_TxCreateCaret),
775 THISCALL(ITextHostImpl_TxShowCaret),
776 THISCALL(ITextHostImpl_TxSetCaretPos),
777 THISCALL(ITextHostImpl_TxSetTimer),
778 THISCALL(ITextHostImpl_TxKillTimer),
779 THISCALL(ITextHostImpl_TxScrollWindowEx),
780 THISCALL(ITextHostImpl_TxSetCapture),
781 THISCALL(ITextHostImpl_TxSetFocus),
782 THISCALL(ITextHostImpl_TxSetCursor),
783 THISCALL(ITextHostImpl_TxScreenToClient),
784 THISCALL(ITextHostImpl_TxClientToScreen),
785 THISCALL(ITextHostImpl_TxActivate),
786 THISCALL(ITextHostImpl_TxDeactivate),
787 THISCALL(ITextHostImpl_TxGetClientRect),
788 THISCALL(ITextHostImpl_TxGetViewInset),
789 THISCALL(ITextHostImpl_TxGetCharFormat),
790 THISCALL(ITextHostImpl_TxGetParaFormat),
791 THISCALL(ITextHostImpl_TxGetSysColor),
792 THISCALL(ITextHostImpl_TxGetBackStyle),
793 THISCALL(ITextHostImpl_TxGetMaxLength),
794 THISCALL(ITextHostImpl_TxGetScrollBars),
795 THISCALL(ITextHostImpl_TxGetPasswordChar),
796 THISCALL(ITextHostImpl_TxGetAcceleratorPos),
797 THISCALL(ITextHostImpl_TxGetExtent),
798 THISCALL(ITextHostImpl_OnTxCharFormatChange),
799 THISCALL(ITextHostImpl_OnTxParaFormatChange),
800 THISCALL(ITextHostImpl_TxGetPropertyBits),
801 THISCALL(ITextHostImpl_TxNotify),
802 THISCALL(ITextHostImpl_TxImmGetContext),
803 THISCALL(ITextHostImpl_TxImmReleaseContext),
804 THISCALL(ITextHostImpl_TxGetSelectionBarWidth),
805 /* ITextHost2 */
806 THISCALL(ITextHostImpl_TxIsDoubleClickPending),
807 THISCALL(ITextHostImpl_TxGetWindow),
808 THISCALL(ITextHostImpl_TxSetForegroundWindow),
809 THISCALL(ITextHostImpl_TxGetPalette),
810 THISCALL(ITextHostImpl_TxGetEastAsianFlags),
811 THISCALL(ITextHostImpl_TxSetCursor2),
812 THISCALL(ITextHostImpl_TxFreeTextServicesNotification),
813 THISCALL(ITextHostImpl_TxGetEditStyle),
814 THISCALL(ITextHostImpl_TxGetWindowStyles),
815 THISCALL(ITextHostImpl_TxShowDropCaret),
816 THISCALL(ITextHostImpl_TxDestroyCaret),
817 THISCALL(ITextHostImpl_TxGetHorzExtent)
818 };
819
820 static const char * const edit_messages[] =
821 {
822 "EM_GETSEL", "EM_SETSEL", "EM_GETRECT", "EM_SETRECT",
823 "EM_SETRECTNP", "EM_SCROLL", "EM_LINESCROLL", "EM_SCROLLCARET",
824 "EM_GETMODIFY", "EM_SETMODIFY", "EM_GETLINECOUNT", "EM_LINEINDEX",
825 "EM_SETHANDLE", "EM_GETHANDLE", "EM_GETTHUMB", "EM_UNKNOWN_BF",
826 "EM_UNKNOWN_C0", "EM_LINELENGTH", "EM_REPLACESEL", "EM_UNKNOWN_C3",
827 "EM_GETLINE", "EM_LIMITTEXT", "EM_CANUNDO", "EM_UNDO",
828 "EM_FMTLINES", "EM_LINEFROMCHAR", "EM_UNKNOWN_CA", "EM_SETTABSTOPS",
829 "EM_SETPASSWORDCHAR", "EM_EMPTYUNDOBUFFER", "EM_GETFIRSTVISIBLELINE", "EM_SETREADONLY",
830 "EM_SETWORDBREAKPROC", "EM_GETWORDBREAKPROC", "EM_GETPASSWORDCHAR", "EM_SETMARGINS",
831 "EM_GETMARGINS", "EM_GETLIMITTEXT", "EM_POSFROMCHAR", "EM_CHARFROMPOS",
832 "EM_SETIMESTATUS", "EM_GETIMESTATUS"
833 };
834
835 static const char * const richedit_messages[] =
836 {
837 "EM_CANPASTE", "EM_DISPLAYBAND", "EM_EXGETSEL", "EM_EXLIMITTEXT",
838 "EM_EXLINEFROMCHAR", "EM_EXSETSEL", "EM_FINDTEXT", "EM_FORMATRANGE",
839 "EM_GETCHARFORMAT", "EM_GETEVENTMASK", "EM_GETOLEINTERFACE", "EM_GETPARAFORMAT",
840 "EM_GETSELTEXT", "EM_HIDESELECTION", "EM_PASTESPECIAL", "EM_REQUESTRESIZE",
841 "EM_SELECTIONTYPE", "EM_SETBKGNDCOLOR", "EM_SETCHARFORMAT", "EM_SETEVENTMASK",
842 "EM_SETOLECALLBACK", "EM_SETPARAFORMAT", "EM_SETTARGETDEVICE", "EM_STREAMIN",
843 "EM_STREAMOUT", "EM_GETTEXTRANGE", "EM_FINDWORDBREAK", "EM_SETOPTIONS",
844 "EM_GETOPTIONS", "EM_FINDTEXTEX", "EM_GETWORDBREAKPROCEX", "EM_SETWORDBREAKPROCEX",
845 "EM_SETUNDOLIMIT", "EM_UNKNOWN_USER_83", "EM_REDO", "EM_CANREDO",
846 "EM_GETUNDONAME", "EM_GETREDONAME", "EM_STOPGROUPTYPING", "EM_SETTEXTMODE",
847 "EM_GETTEXTMODE", "EM_AUTOURLDETECT", "EM_GETAUTOURLDETECT", "EM_SETPALETTE",
848 "EM_GETTEXTEX", "EM_GETTEXTLENGTHEX", "EM_SHOWSCROLLBAR", "EM_SETTEXTEX",
849 "EM_UNKNOWN_USER_98", "EM_UNKNOWN_USER_99", "EM_SETPUNCTUATION", "EM_GETPUNCTUATION",
850 "EM_SETWORDWRAPMODE", "EM_GETWORDWRAPMODE", "EM_SETIMECOLOR", "EM_GETIMECOLOR",
851 "EM_SETIMEOPTIONS", "EM_GETIMEOPTIONS", "EM_CONVPOSITION", "EM_UNKNOWN_USER_109",
852 "EM_UNKNOWN_USER_110", "EM_UNKNOWN_USER_111", "EM_UNKNOWN_USER_112", "EM_UNKNOWN_USER_113",
853 "EM_UNKNOWN_USER_114", "EM_UNKNOWN_USER_115", "EM_UNKNOWN_USER_116", "EM_UNKNOWN_USER_117",
854 "EM_UNKNOWN_USER_118", "EM_UNKNOWN_USER_119", "EM_SETLANGOPTIONS", "EM_GETLANGOPTIONS",
855 "EM_GETIMECOMPMODE", "EM_FINDTEXTW", "EM_FINDTEXTEXW", "EM_RECONVERSION",
856 "EM_SETIMEMODEBIAS", "EM_GETIMEMODEBIAS"
857 };
858
859 static const char *get_msg_name( UINT msg )
860 {
861 if (msg >= EM_GETSEL && msg <= EM_CHARFROMPOS)
862 return edit_messages[msg - EM_GETSEL];
863 if (msg >= EM_CANPASTE && msg <= EM_GETIMEMODEBIAS)
864 return richedit_messages[msg - EM_CANPASTE];
865 return "";
866 }
867
868 static BOOL create_windowed_editor( HWND hwnd, CREATESTRUCTW *create, BOOL emulate_10 )
869 {
870 struct host *host = host_create( hwnd, create, emulate_10 );
871 IUnknown *unk;
872 HRESULT hr;
873
874 if (!host) return FALSE;
875
876 hr = create_text_services( NULL, (ITextHost *)&host->ITextHost_iface, &unk, emulate_10 );
877 if (FAILED( hr ))
878 {
879 ITextHost2_Release( &host->ITextHost_iface );
880 return FALSE;
881 }
882 IUnknown_QueryInterface( unk, &IID_ITextServices, (void **)&host->text_srv );
883 IUnknown_Release( unk );
884
885 SetWindowLongPtrW( hwnd, 0, (LONG_PTR)host );
886
887 return TRUE;
888 }
889
890 static HRESULT get_lineA( ITextServices *text_srv, WPARAM wparam, LPARAM lparam, LRESULT *res )
891 {
892 LRESULT len = USHRT_MAX;
893 WORD sizeA;
894 HRESULT hr;
895 WCHAR *buf;
896
897 *res = 0;
898 sizeA = *(WORD *)lparam;
899 *(WORD *)lparam = 0;
900 if (!sizeA) return S_OK;
901 buf = heap_alloc( len * sizeof(WCHAR) );
902 if (!buf) return E_OUTOFMEMORY;
903 *(WORD *)buf = len;
904 hr = ITextServices_TxSendMessage( text_srv, EM_GETLINE, wparam, (LPARAM)buf, &len );
905 if (hr == S_OK && len)
906 {
907 len = WideCharToMultiByte( CP_ACP, 0, buf, len, (char *)lparam, sizeA, NULL, NULL );
908 if (!len && GetLastError() == ERROR_INSUFFICIENT_BUFFER) len = sizeA;
909 if (len < sizeA) ((char *)lparam)[len] = '\0';
910 *res = len;
911 }
912 heap_free( buf );
913 return hr;
914 }
915
916 static HRESULT get_text_rangeA( struct host *host, TEXTRANGEA *rangeA, LRESULT *res )
917 {
918 TEXTRANGEW range;
919 HRESULT hr;
920 unsigned int count;
921 LRESULT len;
922
923 *res = 0;
924 if (rangeA->chrg.cpMin < 0) return S_OK;
925 ITextServices_TxSendMessage( host->text_srv, WM_GETTEXTLENGTH, 0, 0, &len );
926 range.chrg = rangeA->chrg;
927 if ((range.chrg.cpMin == 0 && range.chrg.cpMax == -1) || range.chrg.cpMax > len)
928 range.chrg.cpMax = len;
929 if (range.chrg.cpMin >= range.chrg.cpMax) return S_OK;
930 count = range.chrg.cpMax - range.chrg.cpMin + 1;
931 range.lpstrText = heap_alloc( count * sizeof(WCHAR) );
932 if (!range.lpstrText) return E_OUTOFMEMORY;
933 hr = ITextServices_TxSendMessage( host->text_srv, EM_GETTEXTRANGE, 0, (LPARAM)&range, &len );
934 if (hr == S_OK && len)
935 {
936 if (!host->emulate_10) count = INT_MAX;
937 len = WideCharToMultiByte( CP_ACP, 0, range.lpstrText, -1, rangeA->lpstrText, count, NULL, NULL );
938 if (!host->emulate_10) *res = len - 1;
939 else
940 {
941 *res = count - 1;
942 rangeA->lpstrText[*res] = '\0';
943 }
944 }
945 heap_free( range.lpstrText );
946 return hr;
947 }
948
949 static HRESULT set_options( struct host *host, DWORD op, DWORD value, LRESULT *res )
950 {
951 DWORD style, old_options, new_options, change, props_mask = 0;
952 DWORD mask = ECO_AUTOWORDSELECTION | ECO_AUTOVSCROLL | ECO_AUTOHSCROLL | ECO_NOHIDESEL | ECO_READONLY |
953 ECO_WANTRETURN | ECO_SAVESEL | ECO_SELECTIONBAR | ECO_VERTICAL;
954
955 new_options = old_options = SendMessageW( host->window, EM_GETOPTIONS, 0, 0 );
956
957 switch (op)
958 {
959 case ECOOP_SET:
960 new_options = value;
961 break;
962 case ECOOP_OR:
963 new_options |= value;
964 break;
965 case ECOOP_AND:
966 new_options &= value;
967 break;
968 case ECOOP_XOR:
969 new_options ^= value;
970 }
971 new_options &= mask;
972
973 change = (new_options ^ old_options);
974
975 if (change & ECO_AUTOWORDSELECTION)
976 {
977 host->props ^= TXTBIT_AUTOWORDSEL;
978 props_mask |= TXTBIT_AUTOWORDSEL;
979 }
980 if (change & ECO_AUTOVSCROLL)
981 {
982 host->scrollbars ^= WS_VSCROLL;
983 props_mask |= TXTBIT_SCROLLBARCHANGE;
984 }
985 if (change & ECO_AUTOHSCROLL)
986 {
987 host->scrollbars ^= WS_HSCROLL;
988 props_mask |= TXTBIT_SCROLLBARCHANGE;
989 }
990 if (change & ECO_NOHIDESEL)
991 {
992 host->props ^= TXTBIT_HIDESELECTION;
993 props_mask |= TXTBIT_HIDESELECTION;
994 }
995 if (change & ECO_READONLY)
996 {
997 host->props ^= TXTBIT_READONLY;
998 props_mask |= TXTBIT_READONLY;
999 }
1000 if (change & ECO_SAVESEL)
1001 {
1002 host->props ^= TXTBIT_SAVESELECTION;
1003 props_mask |= TXTBIT_SAVESELECTION;
1004 }
1005 if (change & ECO_SELECTIONBAR)
1006 {
1007 host->sel_bar ^= 1;
1008 props_mask |= TXTBIT_SELBARCHANGE;
1009 if (host->use_set_rect)
1010 {
1011 int width = SELECTIONBAR_WIDTH;
1012 host->set_rect.left += host->sel_bar ? width : -width;
1013 props_mask |= TXTBIT_CLIENTRECTCHANGE;
1014 }
1015 }
1016 if (change & ECO_VERTICAL)
1017 {
1018 host->props ^= TXTBIT_VERTICAL;
1019 props_mask |= TXTBIT_VERTICAL;
1020 }
1021 if (change & ECO_WANTRETURN) host->want_return ^= 1;
1022
1023 if (props_mask)
1024 ITextServices_OnTxPropertyBitsChange( host->text_srv, props_mask, host->props & props_mask );
1025
1026 *res = new_options;
1027
1028 mask &= ~ECO_AUTOWORDSELECTION; /* doesn't correspond to a window style */
1029 style = GetWindowLongW( host->window, GWL_STYLE );
1030 style = (style & ~mask) | (*res & mask);
1031 SetWindowLongW( host->window, GWL_STYLE, style );
1032 return S_OK;
1033 }
1034
1035 /* handle dialog mode VK_RETURN. Returns TRUE if message has been processed */
1036 static BOOL handle_dialog_enter( struct host *host )
1037 {
1038 BOOL ctrl_is_down = GetKeyState( VK_CONTROL ) & 0x8000;
1039
1040 if (ctrl_is_down) return TRUE;
1041
1042 if (host->want_return) return FALSE;
1043
1044 if (host->parent)
1045 {
1046 DWORD id = SendMessageW( host->parent, DM_GETDEFID, 0, 0 );
1047 if (HIWORD( id ) == DC_HASDEFID)
1048 {
1049 HWND ctrl = GetDlgItem( host->parent, LOWORD( id ));
1050 if (ctrl)
1051 {
1052 SendMessageW( host->parent, WM_NEXTDLGCTL, (WPARAM)ctrl, TRUE );
1053 PostMessageW( ctrl, WM_KEYDOWN, VK_RETURN, 0 );
1054 }
1055 }
1056 }
1057 return TRUE;
1058 }
1059
1060 static LRESULT send_msg_filter( struct host *host, UINT msg, WPARAM *wparam, LPARAM *lparam )
1061 {
1062 MSGFILTER msgf;
1063 LRESULT res;
1064
1065 if (!host->parent) return 0;
1066 msgf.nmhdr.hwndFrom = host->window;
1067 msgf.nmhdr.idFrom = GetWindowLongW( host->window, GWLP_ID );
1068 msgf.nmhdr.code = EN_MSGFILTER;
1069 msgf.msg = msg;
1070 msgf.wParam = *wparam;
1071 msgf.lParam = *lparam;
1072 if ((res = SendMessageW( host->parent, WM_NOTIFY, msgf.nmhdr.idFrom, (LPARAM)&msgf )))
1073 return res;
1074 *wparam = msgf.wParam;
1075 *lparam = msgf.lParam;
1076
1077 return 0;
1078 }
1079
1080 static LRESULT RichEditWndProc_common( HWND hwnd, UINT msg, WPARAM wparam,
1081 LPARAM lparam, BOOL unicode )
1082 {
1083 struct host *host;
1084 HRESULT hr = S_OK;
1085 LRESULT res = 0;
1086
1087 TRACE( "enter hwnd %p msg %04x (%s) %Ix %Ix, unicode %d\n",
1088 hwnd, msg, get_msg_name(msg), wparam, lparam, unicode );
1089
1090 host = (struct host *)GetWindowLongPtrW( hwnd, 0 );
1091 if (!host)
1092 {
1093 if (msg == WM_NCCREATE)
1094 {
1095 CREATESTRUCTW *pcs = (CREATESTRUCTW *)lparam;
1096
1097 TRACE( "WM_NCCREATE: hwnd %p style 0x%08lx\n", hwnd, pcs->style );
1098 return create_windowed_editor( hwnd, pcs, FALSE );
1099 }
1100 else return DefWindowProcW( hwnd, msg, wparam, lparam );
1101 }
1102
1103 if ((((host->event_mask & ENM_KEYEVENTS) && msg >= WM_KEYFIRST && msg <= WM_KEYLAST) ||
1104 ((host->event_mask & ENM_MOUSEEVENTS) && msg >= WM_MOUSEFIRST && msg <= WM_MOUSELAST) ||
1105 ((host->event_mask & ENM_SCROLLEVENTS) && msg >= WM_HSCROLL && msg <= WM_VSCROLL)))
1106 {
1107 host->notify_level++;
1108 res = send_msg_filter( host, msg, &wparam, &lparam );
1109 if (!--host->notify_level && host->defer_release)
1110 {
1111 TRACE( "exit (filtered deferred release) hwnd %p msg %04x (%s) %Ix %Ix -> 0\n",
1112 hwnd, msg, get_msg_name(msg), wparam, lparam );
1113 ITextHost2_Release( &host->ITextHost_iface );
1114 return 0;
1115 }
1116
1117 if (res)
1118 {
1119 TRACE( "exit (filtered %Iu) hwnd %p msg %04x (%s) %Ix %Ix -> 0\n",
1120 res, hwnd, msg, get_msg_name(msg), wparam, lparam );
1121 return 0;
1122 }
1123 }
1124
1125 switch (msg)
1126 {
1127 case WM_CHAR:
1128 {
1129 WCHAR wc = wparam;
1130
1131 if (!unicode) MultiByteToWideChar( CP_ACP, 0, (char *)&wparam, 1, &wc, 1 );
1132 if (wparam == '\r' && host->dialog_mode && host->emulate_10 && handle_dialog_enter( host )) break;
1133 hr = ITextServices_TxSendMessage( host->text_srv, msg, wc, lparam, &res );
1134 break;
1135 }
1136
1137 case WM_CREATE:
1138 {
1139 CREATESTRUCTW *createW = (CREATESTRUCTW *)lparam;
1140 CREATESTRUCTA *createA = (CREATESTRUCTA *)lparam;
1141 void *text;
1142 WCHAR *textW = NULL;
1143 LONG codepage = unicode ? CP_UNICODE : CP_ACP;
1144 int len;
1145 LRESULT evmask;
1146
1147 ITextServices_OnTxInPlaceActivate( host->text_srv, NULL );
1148
1149 if (lparam)
1150 {
1151 text = unicode ? (void *)createW->lpszName : (void *)createA->lpszName;
1152 textW = ME_ToUnicode( codepage, text, &len );
1153 }
1154 ITextServices_TxSendMessage( host->text_srv, EM_GETEVENTMASK, 0, 0, &evmask );
1155 ITextServices_TxSendMessage( host->text_srv, EM_SETEVENTMASK, 0, evmask & ~ENM_CHANGE, &evmask );
1156 ITextServices_TxSetText( host->text_srv, textW );
1157 ITextServices_TxSendMessage( host->text_srv, EM_SETEVENTMASK, 0, evmask, NULL );
1158 if (lparam) ME_EndToUnicode( codepage, textW );
1159 break;
1160 }
1161 case WM_DESTROY:
1162 if (!host->notify_level) ITextHost2_Release( &host->ITextHost_iface );
1163 else host->defer_release = 1;
1164 return 0;
1165
1166 case WM_ERASEBKGND:
1167 {
1168 HDC hdc = (HDC)wparam;
1169 RECT rc;
1170 HBRUSH brush;
1171
1172 if (GetUpdateRect( hwnd, &rc, TRUE ))
1173 {
1174 brush = CreateSolidBrush( ITextHost_TxGetSysColor( &host->ITextHost_iface, COLOR_WINDOW ) );
1175 FillRect( hdc, &rc, brush );
1176 DeleteObject( brush );
1177 }
1178 return 1;
1179 }
1180 case EM_FINDTEXT:
1181 {
1182 FINDTEXTW *params = (FINDTEXTW *)lparam;
1183 FINDTEXTW new_params;
1184 int len;
1185
1186 if (!unicode)
1187 {
1188 new_params.chrg = params->chrg;
1189 new_params.lpstrText = ME_ToUnicode( CP_ACP, (char *)params->lpstrText, &len );
1190 params = &new_params;
1191 }
1192 hr = ITextServices_TxSendMessage( host->text_srv, EM_FINDTEXTW, wparam, (LPARAM)params, &res );
1193 if (!unicode) ME_EndToUnicode( CP_ACP, (WCHAR *)new_params.lpstrText );
1194 break;
1195 }
1196 case EM_FINDTEXTEX:
1197 {
1198 FINDTEXTEXA *paramsA = (FINDTEXTEXA *)lparam;
1199 FINDTEXTEXW *params = (FINDTEXTEXW *)lparam;
1200 FINDTEXTEXW new_params;
1201 int len;
1202
1203 if (!unicode)
1204 {
1205 new_params.chrg = params->chrg;
1206 new_params.lpstrText = ME_ToUnicode( CP_ACP, (char *)params->lpstrText, &len );
1207 params = &new_params;
1208 }
1209 hr = ITextServices_TxSendMessage( host->text_srv, EM_FINDTEXTEXW, wparam, (LPARAM)params, &res );
1210 if (!unicode)
1211 {
1212 ME_EndToUnicode( CP_ACP, (WCHAR *)new_params.lpstrText );
1213 paramsA->chrgText = params->chrgText;
1214 }
1215 break;
1216 }
1217 case WM_GETDLGCODE:
1218 if (lparam) host->dialog_mode = TRUE;
1219
1220 res = DLGC_WANTCHARS | DLGC_WANTTAB | DLGC_WANTARROWS;
1221 if (host->props & TXTBIT_MULTILINE) res |= DLGC_WANTMESSAGE;
1222 if (!(host->props & TXTBIT_SAVESELECTION)) res |= DLGC_HASSETSEL;
1223 break;
1224
1225 case EM_GETLINE:
1226 if (unicode) hr = ITextServices_TxSendMessage( host->text_srv, msg, wparam, lparam, &res );
1227 else hr = get_lineA( host->text_srv, wparam, lparam, &res );
1228 break;
1229
1230 case EM_GETPASSWORDCHAR:
1231 ITextHost_TxGetPasswordChar( &host->ITextHost_iface, (WCHAR *)&res );
1232 break;
1233
1234 case EM_GETRECT:
1235 hr = ITextHost_TxGetClientRect( &host->ITextHost_iface, (RECT *)lparam );
1236 break;
1237
1238 case EM_GETSELTEXT:
1239 {
1240 TEXTRANGEA range;
1241
1242 if (unicode) hr = ITextServices_TxSendMessage( host->text_srv, msg, wparam, lparam, &res );
1243 else
1244 {
1245 ITextServices_TxSendMessage( host->text_srv, EM_EXGETSEL, 0, (LPARAM)&range.chrg, &res );
1246 range.lpstrText = (char *)lparam;
1247 range.lpstrText[0] = '\0';
1248 hr = get_text_rangeA( host, &range, &res );
1249 }
1250 break;
1251 }
1252 case EM_GETOPTIONS:
1253 if (host->props & TXTBIT_READONLY) res |= ECO_READONLY;
1254 if (!(host->props & TXTBIT_HIDESELECTION)) res |= ECO_NOHIDESEL;
1255 if (host->props & TXTBIT_SAVESELECTION) res |= ECO_SAVESEL;
1256 if (host->props & TXTBIT_AUTOWORDSEL) res |= ECO_AUTOWORDSELECTION;
1257 if (host->props & TXTBIT_VERTICAL) res |= ECO_VERTICAL;
1258 if (host->scrollbars & ES_AUTOHSCROLL) res |= ECO_AUTOHSCROLL;
1259 if (host->scrollbars & ES_AUTOVSCROLL) res |= ECO_AUTOVSCROLL;
1260 if (host->want_return) res |= ECO_WANTRETURN;
1261 if (host->sel_bar) res |= ECO_SELECTIONBAR;
1262 break;
1263
1264 case WM_GETTEXT:
1265 {
1266 GETTEXTEX params;
1267
1268 params.cb = wparam * (unicode ? sizeof(WCHAR) : sizeof(CHAR));
1269 params.flags = GT_USECRLF;
1270 params.codepage = unicode ? CP_UNICODE : CP_ACP;
1271 params.lpDefaultChar = NULL;
1272 params.lpUsedDefChar = NULL;
1273 hr = ITextServices_TxSendMessage( host->text_srv, EM_GETTEXTEX, (WPARAM)&params, lparam, &res );
1274 break;
1275 }
1276 case WM_GETTEXTLENGTH:
1277 {
1278 GETTEXTLENGTHEX params;
1279
1280 params.flags = GTL_CLOSE | (host->emulate_10 ? 0 : GTL_USECRLF) | GTL_NUMCHARS;
1281 params.codepage = unicode ? CP_UNICODE : CP_ACP;
1282 hr = ITextServices_TxSendMessage( host->text_srv, EM_GETTEXTLENGTHEX, (WPARAM)&params, 0, &res );
1283 break;
1284 }
1285 case EM_GETTEXTRANGE:
1286 if (unicode) hr = ITextServices_TxSendMessage( host->text_srv, msg, wparam, lparam, &res );
1287 else hr = get_text_rangeA( host, (TEXTRANGEA *)lparam, &res );
1288 break;
1289
1290 case WM_KEYDOWN:
1291 switch (LOWORD( wparam ))
1292 {
1293 case VK_ESCAPE:
1294 if (host->dialog_mode && host->parent)
1295 PostMessageW( host->parent, WM_CLOSE, 0, 0 );
1296 break;
1297 case VK_TAB:
1298 if (host->dialog_mode && host->parent)
1299 SendMessageW( host->parent, WM_NEXTDLGCTL, GetKeyState( VK_SHIFT ) & 0x8000, 0 );
1300 break;
1301 case VK_RETURN:
1302 if (host->dialog_mode && !host->emulate_10 && handle_dialog_enter( host )) break;
1303 /* fall through */
1304 default:
1305 hr = ITextServices_TxSendMessage( host->text_srv, msg, wparam, lparam, &res );
1306 }
1307 break;
1308
1309 case WM_PAINT:
1310 case WM_PRINTCLIENT:
1311 {
1312 HDC hdc;
1313 RECT rc, client, update;
1314 PAINTSTRUCT ps;
1315 HBRUSH brush, old_brush;
1316 LONG view_id;
1317
1318 ITextHost_TxGetClientRect( &host->ITextHost_iface, &client );
1319
1320 if (msg == WM_PAINT)
1321 {
1322 /* TODO retrieve if the text document is frozen */
1323 hdc = BeginPaint( hwnd, &ps );
1324 update = ps.rcPaint;
1325 view_id = TXTVIEW_ACTIVE;
1326 }
1327 else
1328 {
1329 hdc = (HDC)wparam;
1330 update = client;
1331 view_id = TXTVIEW_INACTIVE;
1332 }
1333
1334 brush = CreateSolidBrush( ITextHost_TxGetSysColor( &host->ITextHost_iface, COLOR_WINDOW ) );
1335 old_brush = SelectObject( hdc, brush );
1336
1337 /* Erase area outside of the formatting rectangle */
1338 if (update.top < client.top)
1339 {
1340 rc = update;
1341 rc.bottom = client.top;
1342 PatBlt( hdc, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, PATCOPY );
1343 update.top = client.top;
1344 }
1345 if (update.bottom > client.bottom)
1346 {
1347 rc = update;
1348 rc.top = client.bottom;
1349 PatBlt( hdc, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, PATCOPY );
1350 update.bottom = client.bottom;
1351 }
1352 if (update.left < client.left)
1353 {
1354 rc = update;
1355 rc.right = client.left;
1356 PatBlt( hdc, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, PATCOPY );
1357 update.left = client.left;
1358 }
1359 if (update.right > client.right)
1360 {
1361 rc = update;
1362 rc.left = client.right;
1363 PatBlt( hdc, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, PATCOPY );
1364 update.right = client.right;
1365 }
1366
1367 ITextServices_TxDraw( host->text_srv, DVASPECT_CONTENT, 0, NULL, NULL, hdc, NULL, NULL, NULL,
1368 &update, NULL, 0, view_id );
1369 SelectObject( hdc, old_brush );
1370 DeleteObject( brush );
1371 if (msg == WM_PAINT) EndPaint( hwnd, &ps );
1372 return 0;
1373 }
1374 case EM_REPLACESEL:
1375 {
1376 int len;
1377 LONG codepage = unicode ? CP_UNICODE : CP_ACP;
1378 WCHAR *text = ME_ToUnicode( codepage, (void *)lparam, &len );
1379
1380 hr = ITextServices_TxSendMessage( host->text_srv, msg, wparam, (LPARAM)text, &res );
1381 ME_EndToUnicode( codepage, text );
1382 res = len;
1383 break;
1384 }
1385 case EM_SETBKGNDCOLOR:
1386 res = ITextHost_TxGetSysColor( &host->ITextHost_iface, COLOR_WINDOW );
1387 host->use_back_colour = !wparam;
1388 if (host->use_back_colour) host->back_colour = lparam;
1389 InvalidateRect( hwnd, NULL, TRUE );
1390 break;
1391
1392 case WM_SETCURSOR:
1393 {
1394 POINT pos;
1395 RECT rect;
1396
1397 if (hwnd != (HWND)wparam) break;
1398 GetCursorPos( &pos );
1399 ScreenToClient( hwnd, &pos );
1400 ITextHost_TxGetClientRect( &host->ITextHost_iface, &rect );
1401 if (PtInRect( &rect, pos ))
1402 ITextServices_OnTxSetCursor( host->text_srv, DVASPECT_CONTENT, 0, NULL, NULL, NULL, NULL, NULL, pos.x, pos.y );
1403 else ITextHost_TxSetCursor( &host->ITextHost_iface, LoadCursorW( NULL, MAKEINTRESOURCEW( IDC_ARROW ) ), FALSE );
1404 break;
1405 }
1406 case EM_SETEVENTMASK:
1407 host->event_mask = lparam;
1408 hr = ITextServices_TxSendMessage( host->text_srv, msg, wparam, lparam, &res );
1409 break;
1410
1411 case EM_SETOPTIONS:
1412 hr = set_options( host, wparam, lparam, &res );
1413 break;
1414
1415 case EM_SETPASSWORDCHAR:
1416 if (wparam == host->password_char) break;
1417 host->password_char = wparam;
1418 if (wparam) host->props |= TXTBIT_USEPASSWORD;
1419 else host->props &= ~TXTBIT_USEPASSWORD;
1420 ITextServices_OnTxPropertyBitsChange( host->text_srv, TXTBIT_USEPASSWORD, host->props & TXTBIT_USEPASSWORD );
1421 break;
1422
1423 case EM_SETREADONLY:
1424 {
1425 DWORD op = wparam ? ECOOP_OR : ECOOP_AND;
1426 DWORD mask = wparam ? ECO_READONLY : ~ECO_READONLY;
1427
1428 SendMessageW( hwnd, EM_SETOPTIONS, op, mask );
1429 return 1;
1430 }
1431 case EM_SETRECT:
1432 case EM_SETRECTNP:
1433 {
1434 RECT *rc = (RECT *)lparam;
1435
1436 if (!rc) host->use_set_rect = 0;
1437 else
1438 {
1439 if (wparam >= 2) break;
1440 host->set_rect = *rc;
1441 if (host->client_edge)
1442 {
1443 InflateRect( &host->set_rect, 1, 0 );
1444 host->set_rect.top -= 1;
1445 }
1446 if (!wparam) IntersectRect( &host->set_rect, &host->set_rect, &host->client_rect );
1447 host->use_set_rect = 1;
1448 }
1449 ITextServices_OnTxPropertyBitsChange( host->text_srv, TXTBIT_CLIENTRECTCHANGE, 0 );
1450 break;
1451 }
1452 case WM_SETTEXT:
1453 {
1454 char *textA = (char *)lparam;
1455 WCHAR *text = (WCHAR *)lparam;
1456 int len;
1457
1458 if (!unicode && textA && strncmp( textA, "{\\rtf", 5 ) && strncmp( textA, "{\\urtf", 6 ))
1459 text = ME_ToUnicode( CP_ACP, textA, &len );
1460 hr = ITextServices_TxSendMessage( host->text_srv, msg, wparam, (LPARAM)text, &res );
1461 if (text != (WCHAR *)lparam) ME_EndToUnicode( CP_ACP, text );
1462 break;
1463 }
1464 case EM_SHOWSCROLLBAR:
1465 {
1466 DWORD mask = 0, new;
1467
1468 if (wparam == SB_HORZ) mask = WS_HSCROLL;
1469 else if (wparam == SB_VERT) mask = WS_VSCROLL;
1470 else if (wparam == SB_BOTH) mask = WS_HSCROLL | WS_VSCROLL;
1471
1472 if (mask)
1473 {
1474 new = lparam ? mask : 0;
1475 if ((host->scrollbars & mask) != new)
1476 {
1477 host->scrollbars &= ~mask;
1478 host->scrollbars |= new;
1479 ITextServices_OnTxPropertyBitsChange( host->text_srv, TXTBIT_SCROLLBARCHANGE, 0 );
1480 }
1481 }
1482
1483 res = 0;
1484 break;
1485 }
1486 case WM_WINDOWPOSCHANGED:
1487 {
1488 RECT client;
1489 WINDOWPOS *winpos = (WINDOWPOS *)lparam;
1490
1491 hr = S_FALSE; /* call defwndproc */
1492 if (winpos->flags & SWP_NOCLIENTSIZE) break;
1493 GetClientRect( hwnd, &client );
1494 if (host->use_set_rect)
1495 {
1496 host->set_rect.right += client.right - host->client_rect.right;
1497 host->set_rect.bottom += client.bottom - host->client_rect.bottom;
1498 }
1499 host->client_rect = client;
1500 ITextServices_OnTxPropertyBitsChange( host->text_srv, TXTBIT_CLIENTRECTCHANGE, 0 );
1501 break;
1502 }
1503 default:
1504 hr = ITextServices_TxSendMessage( host->text_srv, msg, wparam, lparam, &res );
1505 }
1506
1507 if (hr == S_FALSE)
1508 res = DefWindowProcW( hwnd, msg, wparam, lparam );
1509
1510 TRACE( "exit hwnd %p msg %04x (%s) %Ix %Ix, unicode %d -> %Iu\n",
1511 hwnd, msg, get_msg_name(msg), wparam, lparam, unicode, res );
1512
1513 return res;
1514 }
1515
1516 static LRESULT WINAPI RichEditWndProcW( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
1517 {
1518 BOOL unicode = TRUE;
1519
1520 /* Under Win9x RichEdit20W returns ANSI strings, see the tests. */
1521 if (msg == WM_GETTEXT && (GetVersion() & 0x80000000))
1522 unicode = FALSE;
1523
1524 return RichEditWndProc_common( hwnd, msg, wparam, lparam, unicode );
1525 }
1526
1527 static LRESULT WINAPI RichEditWndProcA( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
1528 {
1529 return RichEditWndProc_common( hwnd, msg, wparam, lparam, FALSE );
1530 }
1531
1532 /******************************************************************
1533 * RichEditANSIWndProc (RICHED20.10)
1534 */
1535 LRESULT WINAPI RichEditANSIWndProc( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
1536 {
1537 return RichEditWndProcA( hwnd, msg, wparam, lparam );
1538 }
1539
1540 /******************************************************************
1541 * RichEdit10ANSIWndProc (RICHED20.9)
1542 */
1543 LRESULT WINAPI RichEdit10ANSIWndProc( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
1544 {
1545 if (msg == WM_NCCREATE && !GetWindowLongPtrW( hwnd, 0 ))
1546 {
1547 CREATESTRUCTW *pcs = (CREATESTRUCTW *)lparam;
1548
1549 TRACE( "WM_NCCREATE: hwnd %p style 0x%08lx\n", hwnd, pcs->style );
1550 return create_windowed_editor( hwnd, pcs, TRUE );
1551 }
1552 return RichEditANSIWndProc( hwnd, msg, wparam, lparam );
1553 }
1554
1555 static LRESULT WINAPI REComboWndProc( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
1556 {
1557 /* FIXME: Not implemented */
1558 TRACE( "hwnd %p msg %04x (%s) %08Ix %08Ix\n",
1559 hwnd, msg, get_msg_name( msg ), wparam, lparam );
1560 return DefWindowProcW( hwnd, msg, wparam, lparam );
1561 }
1562
1563 static LRESULT WINAPI REListWndProc( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
1564 {
1565 /* FIXME: Not implemented */
1566 TRACE( "hwnd %p msg %04x (%s) %08Ix %08Ix\n",
1567 hwnd, msg, get_msg_name( msg ), wparam, lparam );
1568 return DefWindowProcW( hwnd, msg, wparam, lparam );
1569 }
1570
1571 /******************************************************************
1572 * REExtendedRegisterClass (RICHED20.8)
1573 *
1574 * FIXME undocumented
1575 * Need to check for errors and implement controls and callbacks
1576 */
1577 LRESULT WINAPI REExtendedRegisterClass( void )
1578 {
1579 WNDCLASSW wc;
1580 UINT result;
1581
1582 FIXME( "semi stub\n" );
1583 wc.cbClsExtra = 0;
1584 wc.cbWndExtra = 4;
1585 wc.hInstance = NULL;
1586 wc.hIcon = NULL;
1587 wc.hCursor = NULL;
1588 wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
1589 wc.lpszMenuName = NULL;
1590
1591 if (!listbox_registered)
1592 {
1593 wc.style = CS_PARENTDC | CS_DBLCLKS | CS_GLOBALCLASS;
1594 wc.lpfnWndProc = REListWndProc;
1595 wc.lpszClassName = L"REListBox20W";
1596 if (RegisterClassW( &wc )) listbox_registered = TRUE;
1597 }
1598
1599 if (!combobox_registered)
1600 {
1601 wc.style = CS_PARENTDC | CS_DBLCLKS | CS_GLOBALCLASS | CS_VREDRAW | CS_HREDRAW;
1602 wc.lpfnWndProc = REComboWndProc;
1603 wc.lpszClassName = L"REComboBox20W";
1604 if (RegisterClassW( &wc )) combobox_registered = TRUE;
1605 }
1606
1607 result = 0;
1608 if (listbox_registered) result += 1;
1609 if (combobox_registered) result += 2;
1610
1611 return result;
1612 }
1613
1614 static BOOL register_classes( HINSTANCE instance )
1615 {
1616 WNDCLASSW wcW;
1617 WNDCLASSA wcA;
1618
1619 wcW.style = CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW | CS_GLOBALCLASS;
1620 wcW.lpfnWndProc = RichEditWndProcW;
1621 wcW.cbClsExtra = 0;
1622 wcW.cbWndExtra = sizeof(struct host *);
1623 wcW.hInstance = NULL; /* hInstance would register DLL-local class */
1624 wcW.hIcon = NULL;
1625 wcW.hCursor = LoadCursorW( NULL, (LPWSTR)IDC_IBEAM );
1626 wcW.hbrBackground = GetStockObject( NULL_BRUSH );
1627 wcW.lpszMenuName = NULL;
1628
1629 if (!(GetVersion() & 0x80000000))
1630 {
1631 wcW.lpszClassName = RICHEDIT_CLASS20W;
1632 if (!RegisterClassW( &wcW )) return FALSE;
1633 wcW.lpszClassName = MSFTEDIT_CLASS;
1634 if (!RegisterClassW( &wcW )) return FALSE;
1635 }
1636 else
1637 {
1638 /* WNDCLASSA/W have the same layout */
1639 wcW.lpszClassName = (LPCWSTR)"RichEdit20W";
1640 if (!RegisterClassA( (WNDCLASSA *)&wcW )) return FALSE;
1641 wcW.lpszClassName = (LPCWSTR)"RichEdit50W";
1642 if (!RegisterClassA( (WNDCLASSA *)&wcW )) return FALSE;
1643 }
1644
1645 wcA.style = CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW | CS_GLOBALCLASS;
1646 wcA.lpfnWndProc = RichEditWndProcA;
1647 wcA.cbClsExtra = 0;
1648 wcA.cbWndExtra = sizeof(struct host *);
1649 wcA.hInstance = NULL; /* hInstance would register DLL-local class */
1650 wcA.hIcon = NULL;
1651 wcA.hCursor = LoadCursorW( NULL, (LPWSTR)IDC_IBEAM );
1652 wcA.hbrBackground = GetStockObject(NULL_BRUSH);
1653 wcA.lpszMenuName = NULL;
1654 wcA.lpszClassName = RICHEDIT_CLASS20A;
1655 if (!RegisterClassA( &wcA )) return FALSE;
1656 wcA.lpszClassName = "RichEdit50A";
1657 if (!RegisterClassA( &wcA )) return FALSE;
1658
1659 return TRUE;
1660 }
1661
1662 BOOL WINAPI DllMain( HINSTANCE instance, DWORD reason, void *reserved )
1663 {
1664 switch (reason)
1665 {
1666 case DLL_PROCESS_ATTACH:
1667 dll_instance = instance;
1668 DisableThreadLibraryCalls( instance );
1669 if (!register_classes( instance )) return FALSE;
1670 LookupInit();
1671 break;
1672
1673 case DLL_PROCESS_DETACH:
1674 if (reserved) break;
1675 UnregisterClassW( RICHEDIT_CLASS20W, 0 );
1676 UnregisterClassW( MSFTEDIT_CLASS, 0 );
1677 UnregisterClassA( RICHEDIT_CLASS20A, 0 );
1678 UnregisterClassA( "RichEdit50A", 0 );
1679 if (listbox_registered) UnregisterClassW( L"REListBox20W", 0 );
1680 if (combobox_registered) UnregisterClassW( L"REComboBox20W", 0 );
1681 LookupCleanup();
1682 release_typelib();
1683 break;
1684 }
1685 return TRUE;
1686 }
Windows API implementation