?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push 5bc4839baba05cc4333240c25295b8dd6e351557
[wine/hacks.git] / programs / wineconsole / user.c
blob15626d4ac3f066c6c77142021a1220b67faed2d9
1 /*
2 * a GUI application for displaying a console
3 * USER32 back end
4 * Copyright 2001 Eric Pouech
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 #include <stdio.h>
22 #include <stdlib.h>
23 #include "winecon_user.h"
24 #include "winnls.h"
25
26 #include "wine/debug.h"
27
28 WINE_DEFAULT_DEBUG_CHANNEL(wineconsole);
29 WINE_DECLARE_DEBUG_CHANNEL(wc_font);
30
31 UINT g_uiDefaultCharset;
32
33 /* mapping console colors to RGB values */
34 const COLORREF WCUSER_ColorMap[16] =
35 {
36 RGB(0x00, 0x00, 0x00), RGB(0x00, 0x00, 0x80), RGB(0x00, 0x80, 0x00), RGB(0x00, 0x80, 0x80),
37 RGB(0x80, 0x00, 0x00), RGB(0x80, 0x00, 0x80), RGB(0x80, 0x80, 0x00), RGB(0x80, 0x80, 0x80),
38 RGB(0xC0, 0xC0, 0xC0), RGB(0x00, 0x00, 0xFF), RGB(0x00, 0xFF, 0x00), RGB(0x00, 0xFF, 0xFF),
39 RGB(0xFF, 0x00, 0x00), RGB(0xFF, 0x00, 0xFF), RGB(0xFF, 0xFF, 0x00), RGB(0xFF, 0xFF, 0xFF),
40 };
41
42 static BOOL WCUSER_SetFont(struct inner_data* data, const LOGFONT* font);
43
44 /******************************************************************
45 * WCUSER_FillMemDC
46 *
47 * Fills the Mem DC with current cells values
48 */
49 static void WCUSER_FillMemDC(const struct inner_data* data, int upd_tp, int upd_bm)
50 {
51 unsigned i, j, k;
52 CHAR_INFO* cell;
53 HFONT hOldFont;
54 WORD attr;
55 WCHAR* line;
56 RECT r;
57 HBRUSH hbr;
58
59 /* no font has been set up yet, don't worry about filling the bitmap,
60 * we'll do it once a font is chosen
61 */
62 if (!PRIVATE(data)->hFont) return;
63
64 /* FIXME: could set up a mechanism to reuse the line between different
65 * calls to this function
66 */
67 if (!(line = HeapAlloc(GetProcessHeap(), 0, data->curcfg.sb_width * sizeof(WCHAR))))
68 WINECON_Fatal("OOM\n");
69
70 hOldFont = SelectObject(PRIVATE(data)->hMemDC, PRIVATE(data)->hFont);
71 for (j = upd_tp; j <= upd_bm; j++)
72 {
73 cell = &data->cells[j * data->curcfg.sb_width];
74 for (i = 0; i < data->curcfg.sb_width; i++)
75 {
76 attr = cell[i].Attributes;
77 SetBkColor(PRIVATE(data)->hMemDC, WCUSER_ColorMap[(attr>>4)&0x0F]);
78 SetTextColor(PRIVATE(data)->hMemDC, WCUSER_ColorMap[attr&0x0F]);
79 for (k = i; k < data->curcfg.sb_width && cell[k].Attributes == attr; k++)
80 {
81 line[k - i] = cell[k].Char.UnicodeChar;
82 }
83 TextOut(PRIVATE(data)->hMemDC, i * data->curcfg.cell_width, j * data->curcfg.cell_height,
84 line, k - i);
85 if (PRIVATE(data)->ext_leading &&
86 (hbr = CreateSolidBrush(WCUSER_ColorMap[(attr>>4)&0x0F])))
87 {
88 r.left = i * data->curcfg.cell_width;
89 r.top = (j + 1) * data->curcfg.cell_height - PRIVATE(data)->ext_leading;
90 r.right = k * data->curcfg.cell_width;
91 r.bottom = (j + 1) * data->curcfg.cell_height;
92 FillRect(PRIVATE(data)->hMemDC, &r, hbr);
93 DeleteObject(hbr);
94 }
95 i = k - 1;
96 }
97 }
98 SelectObject(PRIVATE(data)->hMemDC, hOldFont);
99 HeapFree(GetProcessHeap(), 0, line);
100 }
101
102 /******************************************************************
103 * WCUSER_NewBitmap
104 *
105 * Either the font geometry or the sb geometry has changed. we need
106 * to recreate the bitmap geometry.
107 */
108 static void WCUSER_NewBitmap(struct inner_data* data)
109 {
110 HDC hDC;
111 HBITMAP hnew, hold;
112
113 if (!data->curcfg.sb_width || !data->curcfg.sb_height ||
114 !PRIVATE(data)->hFont || !(hDC = GetDC(data->hWnd)))
115 return;
116 hnew = CreateCompatibleBitmap(hDC,
117 data->curcfg.sb_width * data->curcfg.cell_width,
118 data->curcfg.sb_height * data->curcfg.cell_height);
119 ReleaseDC(data->hWnd, hDC);
120 hold = SelectObject(PRIVATE(data)->hMemDC, hnew);
121
122 if (PRIVATE(data)->hBitmap)
123 {
124 if (hold == PRIVATE(data)->hBitmap)
125 DeleteObject(PRIVATE(data)->hBitmap);
126 else
127 WINE_FIXME("leak\n");
128 }
129 PRIVATE(data)->hBitmap = hnew;
130 WCUSER_FillMemDC(data, 0, data->curcfg.sb_height - 1);
131 }
132
133 /******************************************************************
134 * WCUSER_ResizeScreenBuffer
135 *
136 *
137 */
138 static void WCUSER_ResizeScreenBuffer(struct inner_data* data)
139 {
140 WCUSER_NewBitmap(data);
141 }
142
143 /******************************************************************
144 * WCUSER_PosCursor
145 *
146 * Set a new position for the cursor
147 */
148 static void WCUSER_PosCursor(const struct inner_data* data)
149 {
150 if (data->hWnd != GetFocus() || !data->curcfg.cursor_visible) return;
151
152 SetCaretPos((data->cursor.X - data->curcfg.win_pos.X) * data->curcfg.cell_width,
153 (data->cursor.Y - data->curcfg.win_pos.Y) * data->curcfg.cell_height);
154 ShowCaret(data->hWnd);
155 }
156
157 /******************************************************************
158 * WCUSER_ShapeCursor
159 *
160 * Sets a new shape for the cursor
161 */
162 static void WCUSER_ShapeCursor(struct inner_data* data, int size, int vis, BOOL force)
163 {
164 if (force || size != data->curcfg.cursor_size)
165 {
166 if (data->curcfg.cursor_visible && data->hWnd == GetFocus()) DestroyCaret();
167 if (PRIVATE(data)->cursor_bitmap) DeleteObject(PRIVATE(data)->cursor_bitmap);
168 PRIVATE(data)->cursor_bitmap = NULL;
169 if (size != 100)
170 {
171 int w16b; /* number of bytes per row, aligned on word size */
172 BYTE* ptr;
173 int i, j, nbl;
174
175 w16b = ((data->curcfg.cell_width + 15) & ~15) / 8;
176 ptr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, w16b * data->curcfg.cell_height);
177 if (!ptr) WINECON_Fatal("OOM");
178 nbl = max((data->curcfg.cell_height * size) / 100, 1);
179 for (j = data->curcfg.cell_height - nbl; j < data->curcfg.cell_height; j++)
180 {
181 for (i = 0; i < data->curcfg.cell_width; i++)
182 {
183 ptr[w16b * j + (i / 8)] |= 0x80 >> (i & 7);
184 }
185 }
186 PRIVATE(data)->cursor_bitmap = CreateBitmap(data->curcfg.cell_width,
187 data->curcfg.cell_height, 1, 1, ptr);
188 HeapFree(GetProcessHeap(), 0, ptr);
189 }
190 data->curcfg.cursor_size = size;
191 data->curcfg.cursor_visible = -1;
192 }
193
194 vis = (vis) ? TRUE : FALSE;
195 if (force || vis != data->curcfg.cursor_visible)
196 {
197 data->curcfg.cursor_visible = vis;
198 if (data->hWnd == GetFocus())
199 {
200 if (vis)
201 {
202 CreateCaret(data->hWnd, PRIVATE(data)->cursor_bitmap,
203 data->curcfg.cell_width, data->curcfg.cell_height);
204 WCUSER_PosCursor(data);
205 }
206 else
207 {
208 DestroyCaret();
209 }
210 }
211 }
212 WINECON_DumpConfig("crsr", &data->curcfg);
213 }
214
215 /******************************************************************
216 * WCUSER_ComputePositions
217 *
218 * Recomputes all the components (mainly scroll bars) positions
219 */
220 static void WCUSER_ComputePositions(struct inner_data* data)
221 {
222 RECT r;
223 int dx, dy;
224
225 /* compute window size from desired client size */
226 r.left = r.top = 0;
227 r.right = data->curcfg.win_width * data->curcfg.cell_width;
228 r.bottom = data->curcfg.win_height * data->curcfg.cell_height;
229
230 if (IsRectEmpty(&r)) return;
231
232 AdjustWindowRect(&r, GetWindowLong(data->hWnd, GWL_STYLE), FALSE);
233
234 dx = dy = 0;
235 if (data->curcfg.sb_width > data->curcfg.win_width)
236 {
237 dy = GetSystemMetrics(SM_CYHSCROLL);
238 SetScrollRange(data->hWnd, SB_HORZ, 0,
239 data->curcfg.sb_width - data->curcfg.win_width, FALSE);
240 SetScrollPos(data->hWnd, SB_HORZ, 0, FALSE); /* FIXME */
241 ShowScrollBar(data->hWnd, SB_HORZ, TRUE);
242 }
243 else
244 {
245 ShowScrollBar(data->hWnd, SB_HORZ, FALSE);
246 }
247
248 if (data->curcfg.sb_height > data->curcfg.win_height)
249 {
250 dx = GetSystemMetrics(SM_CXVSCROLL);
251 SetScrollRange(data->hWnd, SB_VERT, 0,
252 data->curcfg.sb_height - data->curcfg.win_height, FALSE);
253 SetScrollPos(data->hWnd, SB_VERT, 0, FALSE); /* FIXME */
254 ShowScrollBar(data->hWnd, SB_VERT, TRUE);
255 }
256 else
257 {
258 ShowScrollBar(data->hWnd, SB_VERT, FALSE);
259 }
260
261 SetWindowPos(data->hWnd, 0, 0, 0, r.right - r.left + dx, r.bottom - r.top + dy,
262 SWP_NOMOVE|SWP_NOZORDER);
263 WCUSER_ShapeCursor(data, data->curcfg.cursor_size, data->curcfg.cursor_visible, TRUE);
264 WCUSER_PosCursor(data);
265 }
266
267 /******************************************************************
268 * WCUSER_SetTitle
269 *
270 * Sets the title to the wine console
271 */
272 static void WCUSER_SetTitle(const struct inner_data* data)
273 {
274 WCHAR buffer[256];
275
276 if (WINECON_GetConsoleTitle(data->hConIn, buffer, sizeof(buffer)))
277 SetWindowText(data->hWnd, buffer);
278 }
279
280 void WCUSER_DumpLogFont(const char* pfx, const LOGFONT* lf, DWORD ft)
281 {
282 WINE_TRACE_(wc_font)("%s %s%s%s%s\n"
283 "\tlf.lfHeight=%d lf.lfWidth=%d lf.lfEscapement=%d lf.lfOrientation=%d\n"
284 "\tlf.lfWeight=%d lf.lfItalic=%u lf.lfUnderline=%u lf.lfStrikeOut=%u\n"
285 "\tlf.lfCharSet=%u lf.lfOutPrecision=%u lf.lfClipPrecision=%u lf.lfQuality=%u\n"
286 "\tlf->lfPitchAndFamily=%u lf.lfFaceName=%s\n",
287 pfx,
288 (ft & RASTER_FONTTYPE) ? "raster" : "",
289 (ft & TRUETYPE_FONTTYPE) ? "truetype" : "",
290 ((ft & (RASTER_FONTTYPE|TRUETYPE_FONTTYPE)) == 0) ? "vector" : "",
291 (ft & DEVICE_FONTTYPE) ? "|device" : "",
292 lf->lfHeight, lf->lfWidth, lf->lfEscapement, lf->lfOrientation,
293 lf->lfWeight, lf->lfItalic, lf->lfUnderline, lf->lfStrikeOut, lf->lfCharSet,
294 lf->lfOutPrecision, lf->lfClipPrecision, lf->lfQuality, lf->lfPitchAndFamily,
295 wine_dbgstr_w(lf->lfFaceName));
296 }
297
298 void WCUSER_DumpTextMetric(const TEXTMETRIC* tm, DWORD ft)
299 {
300 WINE_TRACE_(wc_font)("%s%s%s%s\n"
301 "\ttmHeight=%d tmAscent=%d tmDescent=%d tmInternalLeading=%d tmExternalLeading=%d\n"
302 "\ttmAveCharWidth=%d tmMaxCharWidth=%d tmWeight=%d tmOverhang=%d\n"
303 "\ttmDigitizedAspectX=%d tmDigitizedAspectY=%d\n"
304 "\ttmFirstChar=%d tmLastChar=%d tmDefaultChar=%d tmBreakChar=%d\n"
305 "\ttmItalic=%u tmUnderlined=%u tmStruckOut=%u tmPitchAndFamily=%u tmCharSet=%u\n",
306 (ft & RASTER_FONTTYPE) ? "raster" : "",
307 (ft & TRUETYPE_FONTTYPE) ? "truetype" : "",
308 ((ft & (RASTER_FONTTYPE|TRUETYPE_FONTTYPE)) == 0) ? "vector" : "",
309 (ft & DEVICE_FONTTYPE) ? "|device" : "",
310 tm->tmHeight, tm->tmAscent, tm->tmDescent, tm->tmInternalLeading, tm->tmExternalLeading, tm->tmAveCharWidth,
311 tm->tmMaxCharWidth, tm->tmWeight, tm->tmOverhang, tm->tmDigitizedAspectX, tm->tmDigitizedAspectY,
312 tm->tmFirstChar, tm->tmLastChar, tm->tmDefaultChar, tm->tmBreakChar, tm->tmItalic, tm->tmUnderlined, tm->tmStruckOut,
313 tm->tmPitchAndFamily, tm->tmCharSet);
314 }
315
316 /******************************************************************
317 * WCUSER_AreFontsEqual
318 *
319 *
320 */
321 static BOOL WCUSER_AreFontsEqual(const struct config_data* config, const LOGFONT* lf)
322 {
323 return lf->lfHeight == config->cell_height &&
324 lf->lfWeight == config->font_weight &&
325 !lf->lfItalic && !lf->lfUnderline && !lf->lfStrikeOut &&
326 !lstrcmp(lf->lfFaceName, config->face_name);
327 }
328
329 struct font_chooser
330 {
331 struct inner_data* data;
332 int done;
333 };
334
335 /******************************************************************
336 * WCUSER_ValidateFontMetric
337 *
338 * Returns true if the font described in tm is usable as a font for the renderer
339 */
340 BOOL WCUSER_ValidateFontMetric(const struct inner_data* data, const TEXTMETRIC* tm, DWORD fontType)
341 {
342 BOOL ret = TRUE;
343
344 if (fontType & RASTER_FONTTYPE)
345 ret = (tm->tmMaxCharWidth * data->curcfg.win_width < GetSystemMetrics(SM_CXSCREEN) &&
346 tm->tmHeight * data->curcfg.win_height < GetSystemMetrics(SM_CYSCREEN));
347 return ret && !tm->tmItalic && !tm->tmUnderlined && !tm->tmStruckOut &&
348 (tm->tmCharSet == DEFAULT_CHARSET || tm->tmCharSet == g_uiDefaultCharset);
349 }
350
351 /******************************************************************
352 * WCUSER_ValidateFont
353 *
354 * Returns true if the font family described in lf is usable as a font for the renderer
355 */
356 BOOL WCUSER_ValidateFont(const struct inner_data* data, const LOGFONT* lf)
357 {
358 return (lf->lfPitchAndFamily & 3) == FIXED_PITCH &&
359 /* (lf->lfPitchAndFamily & 0xF0) == FF_MODERN && */
360 (lf->lfCharSet == DEFAULT_CHARSET || lf->lfCharSet == g_uiDefaultCharset);
361 }
362
363 /******************************************************************
364 * get_first_font_enum_2
365 * get_first_font_enum
366 *
367 * Helper functions to get a decent font for the renderer
368 */
369 static int CALLBACK get_first_font_enum_2(const LOGFONT* lf, const TEXTMETRIC* tm,
370 DWORD FontType, LPARAM lParam)
371 {
372 struct font_chooser* fc = (struct font_chooser*)lParam;
373
374 WCUSER_DumpTextMetric(tm, FontType);
375 if (WCUSER_ValidateFontMetric(fc->data, tm, FontType))
376 {
377 LOGFONT mlf = *lf;
378
379 /* Use the default sizes for the font (this is needed, especially for
380 * TrueType fonts, so that we get a decent size, not the max size)
381 */
382 mlf.lfWidth = fc->data->curcfg.cell_width;
383 mlf.lfHeight = fc->data->curcfg.cell_height;
384 if (WCUSER_SetFont(fc->data, &mlf))
385 {
386 struct config_data defcfg;
387
388 WCUSER_DumpLogFont("InitChoosing: ", &mlf, FontType);
389 fc->done = 1;
390 /* since we've modified the current config with new font information,
391 * set this information as the new default.
392 */
393 WINECON_RegLoad(NULL, &defcfg);
394 defcfg.cell_width = fc->data->curcfg.cell_width;
395 defcfg.cell_height = fc->data->curcfg.cell_height;
396 lstrcpyW(defcfg.face_name, fc->data->curcfg.face_name);
397 /* Force also its writing back to the registry so that we can get it
398 * the next time.
399 */
400 WINECON_RegSave(&defcfg);
401 return 0;
402 }
403 }
404 return 1;
405 }
406
407 static int CALLBACK get_first_font_enum(const LOGFONT* lf, const TEXTMETRIC* tm,
408 DWORD FontType, LPARAM lParam)
409 {
410 struct font_chooser* fc = (struct font_chooser*)lParam;
411
412 WCUSER_DumpLogFont("InitFamily: ", lf, FontType);
413 if (WCUSER_ValidateFont(fc->data, lf))
414 {
415 EnumFontFamilies(PRIVATE(fc->data)->hMemDC, lf->lfFaceName,
416 get_first_font_enum_2, lParam);
417 return !fc->done; /* we just need the first matching one... */
418 }
419 return 1;
420 }
421
422 /******************************************************************
423 * WCUSER_CopyFont
424 *
425 * get the relevant information from the font described in lf and store them
426 * in config
427 */
428 HFONT WCUSER_CopyFont(struct config_data* config, HWND hWnd, const LOGFONT* lf, LONG* el)
429 {
430 TEXTMETRIC tm;
431 HDC hDC;
432 HFONT hFont, hOldFont;
433 int w, i, buf[256];
434
435 if (!(hDC = GetDC(hWnd))) return NULL;
436 if (!(hFont = CreateFontIndirect(lf))) goto err1;
437
438 hOldFont = SelectObject(hDC, hFont);
439 GetTextMetrics(hDC, &tm);
440
441 /* FIXME:
442 * the current freetype engine (at least 2.0.x with x <= 8) and its implementation
443 * in Wine don't return adequate values for fixed fonts
444 * In Windows, those fonts are expected to return the same value for
445 * - the average width
446 * - the largest width
447 * - the width of all characters in the font
448 * This isn't true in Wine. As a temporary workaround, we get as the width of the
449 * cell, the width of the first character in the font, after checking that all
450 * characters in the font have the same width (I hear paranoïa coming)
451 * when this gets fixed, the code should be using tm.tmAveCharWidth
452 * or tm.tmMaxCharWidth as the cell width.
453 */
454 GetCharWidth32(hDC, tm.tmFirstChar, tm.tmFirstChar, &w);
455 for (i = tm.tmFirstChar + 1; i <= tm.tmLastChar; i += sizeof(buf) / sizeof(buf[0]))
456 {
457 int j, k;
458
459 k = min(tm.tmLastChar - i, sizeof(buf) / sizeof(buf[0]) - 1);
460 GetCharWidth32(hDC, i, i + k, buf);
461 for (j = 0; j <= k; j++)
462 {
463 if (buf[j] != w)
464 {
465 WINE_WARN("Non uniform cell width: [%d]=%d [%d]=%d\n"
466 "This may be caused by old freetype libraries, >= 2.0.8 is recommended\n",
467 i + j, buf[j], tm.tmFirstChar, w);
468 goto err;
469 }
470 }
471 }
472 SelectObject(hDC, hOldFont);
473 ReleaseDC(hWnd, hDC);
474
475 config->cell_width = w;
476 config->cell_height = tm.tmHeight + tm.tmExternalLeading;
477 config->font_weight = tm.tmWeight;
478 lstrcpy(config->face_name, lf->lfFaceName);
479 if (el) *el = tm.tmExternalLeading;
480
481 return hFont;
482 err:
483 if (hDC && hOldFont) SelectObject(hDC, hOldFont);
484 if (hFont) DeleteObject(hFont);
485 err1:
486 if (hDC) ReleaseDC(hWnd, hDC);
487
488 return NULL;
489 }
490
491 /******************************************************************
492 * WCUSER_FillLogFont
493 *
494 *
495 */
496 void WCUSER_FillLogFont(LOGFONT* lf, const WCHAR* name, UINT height, UINT weight)
497 {
498 lf->lfHeight = height;
499 lf->lfWidth = 0;
500 lf->lfEscapement = 0;
501 lf->lfOrientation = 0;
502 lf->lfWeight = weight;
503 lf->lfItalic = FALSE;
504 lf->lfUnderline = FALSE;
505 lf->lfStrikeOut = FALSE;
506 lf->lfCharSet = DEFAULT_CHARSET;
507 lf->lfOutPrecision = OUT_DEFAULT_PRECIS;
508 lf->lfClipPrecision = CLIP_DEFAULT_PRECIS;
509 lf->lfQuality = DEFAULT_QUALITY;
510 lf->lfPitchAndFamily = FIXED_PITCH | FF_DONTCARE;
511 lstrcpy(lf->lfFaceName, name);
512 }
513
514 /******************************************************************
515 * WCUSER_SetFont
516 *
517 * sets logfont as the new font for the console
518 */
519 BOOL WCUSER_SetFont(struct inner_data* data, const LOGFONT* logfont)
520 {
521 HFONT hFont;
522 LONG el;
523
524 if (PRIVATE(data)->hFont != 0 && WCUSER_AreFontsEqual(&data->curcfg, logfont))
525 return TRUE;
526
527 hFont = WCUSER_CopyFont(&data->curcfg, data->hWnd, logfont, &el);
528 if (!hFont) {WINE_ERR("wrong font\n"); return FALSE;}
529
530 if (PRIVATE(data)->hFont) DeleteObject(PRIVATE(data)->hFont);
531 PRIVATE(data)->hFont = hFont;
532 PRIVATE(data)->ext_leading = el;
533
534 WCUSER_ComputePositions(data);
535 WCUSER_NewBitmap(data);
536 InvalidateRect(data->hWnd, NULL, FALSE);
537 UpdateWindow(data->hWnd);
538
539 return TRUE;
540 }
541
542 /******************************************************************
543 * WCUSER_SetFontPmt
544 *
545 * Sets a new font for the console.
546 * In fact a wrapper for WCUSER_SetFont
547 */
548 static void WCUSER_SetFontPmt(struct inner_data* data, const WCHAR* font,
549 unsigned height, unsigned weight)
550 {
551 LOGFONT lf;
552 struct font_chooser fc;
553
554 WINE_TRACE_(wc_font)("=> %s h=%u w=%u\n",
555 wine_dbgstr_wn(font, -1), height, weight);
556
557 if (font[0] != '\0' && height != 0 && weight != 0)
558 {
559 WCUSER_FillLogFont(&lf, font, height, weight);
560 if (WCUSER_SetFont(data, &lf))
561 {
562 WCUSER_DumpLogFont("InitReuses: ", &lf, 0);
563 return;
564 }
565 }
566
567 /* try to find an acceptable font */
568 WINE_WARN("Couldn't match the font from registry... trying to find one\n");
569 fc.data = data;
570 fc.done = 0;
571 EnumFontFamilies(PRIVATE(data)->hMemDC, NULL, get_first_font_enum, (LPARAM)&fc);
572 if (!fc.done) WINECON_Fatal("Couldn't find a decent font, aborting\n");
573 }
574
575 /******************************************************************
576 * WCUSER_GetCell
577 *
578 * Get a cell from a relative coordinate in window (takes into
579 * account the scrolling)
580 */
581 static COORD WCUSER_GetCell(const struct inner_data* data, LPARAM lParam)
582 {
583 COORD c;
584
585 c.X = data->curcfg.win_pos.X + (short)LOWORD(lParam) / data->curcfg.cell_width;
586 c.Y = data->curcfg.win_pos.Y + (short)HIWORD(lParam) / data->curcfg.cell_height;
587
588 return c;
589 }
590
591 /******************************************************************
592 * WCUSER_GetSelectionRect
593 *
594 * Get the selection rectangle
595 */
596 static void WCUSER_GetSelectionRect(const struct inner_data* data, LPRECT r)
597 {
598 r->left = (min(PRIVATE(data)->selectPt1.X, PRIVATE(data)->selectPt2.X) - data->curcfg.win_pos.X) * data->curcfg.cell_width;
599 r->top = (min(PRIVATE(data)->selectPt1.Y, PRIVATE(data)->selectPt2.Y) - data->curcfg.win_pos.Y) * data->curcfg.cell_height;
600 r->right = (max(PRIVATE(data)->selectPt1.X, PRIVATE(data)->selectPt2.X) + 1 - data->curcfg.win_pos.X) * data->curcfg.cell_width;
601 r->bottom = (max(PRIVATE(data)->selectPt1.Y, PRIVATE(data)->selectPt2.Y) + 1 - data->curcfg.win_pos.Y) * data->curcfg.cell_height;
602 }
603
604 /******************************************************************
605 * WCUSER_SetSelection
606 *
607 *
608 */
609 static void WCUSER_SetSelection(const struct inner_data* data, HDC hRefDC)
610 {
611 HDC hDC;
612 RECT r;
613
614 WCUSER_GetSelectionRect(data, &r);
615 hDC = hRefDC ? hRefDC : GetDC(data->hWnd);
616 if (hDC)
617 {
618 if (data->hWnd == GetFocus() && data->curcfg.cursor_visible)
619 HideCaret(data->hWnd);
620 InvertRect(hDC, &r);
621 if (hDC != hRefDC)
622 ReleaseDC(data->hWnd, hDC);
623 if (data->hWnd == GetFocus() && data->curcfg.cursor_visible)
624 ShowCaret(data->hWnd);
625 }
626 }
627
628 /******************************************************************
629 * WCUSER_MoveSelection
630 *
631 *
632 */
633 static void WCUSER_MoveSelection(struct inner_data* data, COORD c1, COORD c2)
634 {
635 RECT r;
636 HDC hDC;
637
638 if (c1.X < 0 || c1.X >= data->curcfg.sb_width ||
639 c2.X < 0 || c2.X >= data->curcfg.sb_width ||
640 c1.Y < 0 || c1.Y >= data->curcfg.sb_height ||
641 c2.Y < 0 || c2.Y >= data->curcfg.sb_height)
642 return;
643
644 WCUSER_GetSelectionRect(data, &r);
645 hDC = GetDC(data->hWnd);
646 if (hDC)
647 {
648 if (data->hWnd == GetFocus() && data->curcfg.cursor_visible)
649 HideCaret(data->hWnd);
650 InvertRect(hDC, &r);
651 }
652 PRIVATE(data)->selectPt1 = c1;
653 PRIVATE(data)->selectPt2 = c2;
654 if (hDC)
655 {
656 WCUSER_GetSelectionRect(data, &r);
657 InvertRect(hDC, &r);
658 ReleaseDC(data->hWnd, hDC);
659 if (data->hWnd == GetFocus() && data->curcfg.cursor_visible)
660 ShowCaret(data->hWnd);
661 }
662 }
663
664 /******************************************************************
665 * WCUSER_CopySelectionToClipboard
666 *
667 * Copies the current selection into the clipboard
668 */
669 static void WCUSER_CopySelectionToClipboard(const struct inner_data* data)
670 {
671 HANDLE hMem;
672 LPWSTR p;
673 unsigned w, h;
674
675 w = abs(PRIVATE(data)->selectPt1.X - PRIVATE(data)->selectPt2.X) + 2;
676 h = abs(PRIVATE(data)->selectPt1.Y - PRIVATE(data)->selectPt2.Y) + 1;
677
678 if (!OpenClipboard(data->hWnd)) return;
679 EmptyClipboard();
680
681 hMem = GlobalAlloc(GMEM_MOVEABLE, (w * h) * sizeof(WCHAR));
682 if (hMem && (p = GlobalLock(hMem)))
683 {
684 COORD c;
685 int y;
686
687 c.X = min(PRIVATE(data)->selectPt1.X, PRIVATE(data)->selectPt2.X);
688 c.Y = min(PRIVATE(data)->selectPt1.Y, PRIVATE(data)->selectPt2.Y);
689
690 for (y = 0; y < h; y++, c.Y++)
691 {
692 LPWSTR end;
693 ReadConsoleOutputCharacter(data->hConOut, p, w - 1, c, NULL);
694
695 /* strip spaces from the end of the line */
696 end = p + w - 1;
697 while (end > p && *(end - 1) == ' ')
698 end--;
699 *end = (y < h - 1) ? '\n' : '\0';
700 p = end + 1;
701 }
702 GlobalUnlock(hMem);
703 SetClipboardData(CF_UNICODETEXT, hMem);
704 }
705 CloseClipboard();
706 }
707
708 /******************************************************************
709 * WCUSER_PasteFromClipboard
710 *
711 *
712 */
713 static void WCUSER_PasteFromClipboard(struct inner_data* data)
714 {
715 HANDLE h;
716 WCHAR* ptr;
717
718 if (!OpenClipboard(data->hWnd)) return;
719 h = GetClipboardData(CF_UNICODETEXT);
720 if (h && (ptr = GlobalLock(h)))
721 {
722 int i, len = GlobalSize(h) / sizeof(WCHAR);
723 INPUT_RECORD ir[2];
724 DWORD n;
725 SHORT sh;
726
727 ir[0].EventType = KEY_EVENT;
728 ir[0].Event.KeyEvent.wRepeatCount = 0;
729 ir[0].Event.KeyEvent.dwControlKeyState = 0;
730 ir[0].Event.KeyEvent.bKeyDown = TRUE;
731
732 /* generate the corresponding input records */
733 for (i = 0; i < len; i++)
734 {
735 /* FIXME: the modifying keys are not generated (shift, ctrl...) */
736 sh = VkKeyScan(ptr[i]);
737 ir[0].Event.KeyEvent.wVirtualKeyCode = LOBYTE(sh);
738 ir[0].Event.KeyEvent.wVirtualScanCode = MapVirtualKey(LOBYTE(sh), 0);
739 ir[0].Event.KeyEvent.uChar.UnicodeChar = ptr[i];
740
741 ir[1] = ir[0];
742 ir[1].Event.KeyEvent.bKeyDown = FALSE;
743
744 WriteConsoleInput(data->hConIn, ir, 2, &n);
745 }
746 GlobalUnlock(h);
747 }
748 CloseClipboard();
749 }
750
751 /******************************************************************
752 * WCUSER_Refresh
753 *
754 *
755 */
756 static void WCUSER_Refresh(const struct inner_data* data, int tp, int bm)
757 {
758 WCUSER_FillMemDC(data, tp, bm);
759 if (data->curcfg.win_pos.Y <= bm && data->curcfg.win_pos.Y + data->curcfg.win_height >= tp)
760 {
761 RECT r;
762
763 r.left = 0;
764 r.right = data->curcfg.win_width * data->curcfg.cell_width;
765 r.top = (tp - data->curcfg.win_pos.Y) * data->curcfg.cell_height;
766 r.bottom = (bm - data->curcfg.win_pos.Y + 1) * data->curcfg.cell_height;
767 InvalidateRect(data->hWnd, &r, FALSE);
768 UpdateWindow(data->hWnd);
769 }
770 }
771
772 /******************************************************************
773 * WCUSER_Paint
774 *
775 *
776 */
777 static void WCUSER_Paint(const struct inner_data* data)
778 {
779 PAINTSTRUCT ps;
780
781 BeginPaint(data->hWnd, &ps);
782 BitBlt(ps.hdc, 0, 0,
783 data->curcfg.win_width * data->curcfg.cell_width,
784 data->curcfg.win_height * data->curcfg.cell_height,
785 PRIVATE(data)->hMemDC,
786 data->curcfg.win_pos.X * data->curcfg.cell_width,
787 data->curcfg.win_pos.Y * data->curcfg.cell_height,
788 SRCCOPY);
789 if (PRIVATE(data)->has_selection)
790 WCUSER_SetSelection(data, ps.hdc);
791 EndPaint(data->hWnd, &ps);
792 }
793
794 /******************************************************************
795 * WCUSER_Scroll
796 *
797 *
798 */
799 static void WCUSER_Scroll(struct inner_data* data, int pos, BOOL horz)
800 {
801 if (horz)
802 {
803 SetScrollPos(data->hWnd, SB_HORZ, pos, TRUE);
804 data->curcfg.win_pos.X = pos;
805 }
806 else
807 {
808 SetScrollPos(data->hWnd, SB_VERT, pos, TRUE);
809 data->curcfg.win_pos.Y = pos;
810 }
811 InvalidateRect(data->hWnd, NULL, FALSE);
812 }
813
814 /******************************************************************
815 * WCUSER_FillMenu
816 *
817 *
818 */
819 static BOOL WCUSER_FillMenu(HMENU hMenu, BOOL sep)
820 {
821 HMENU hSubMenu;
822 HINSTANCE hInstance = GetModuleHandle(NULL);
823 WCHAR buff[256];
824
825 if (!hMenu) return FALSE;
826
827 /* FIXME: error handling & memory cleanup */
828 hSubMenu = CreateMenu();
829 if (!hSubMenu) return FALSE;
830
831 LoadString(hInstance, IDS_MARK, buff, sizeof(buff) / sizeof(WCHAR));
832 InsertMenu(hSubMenu, -1, MF_BYPOSITION|MF_STRING, IDS_MARK, buff);
833 LoadString(hInstance, IDS_COPY, buff, sizeof(buff) / sizeof(WCHAR));
834 InsertMenu(hSubMenu, -1, MF_BYPOSITION|MF_STRING, IDS_COPY, buff);
835 LoadString(hInstance, IDS_PASTE, buff, sizeof(buff) / sizeof(WCHAR));
836 InsertMenu(hSubMenu, -1, MF_BYPOSITION|MF_STRING, IDS_PASTE, buff);
837 LoadString(hInstance, IDS_SELECTALL, buff, sizeof(buff) / sizeof(WCHAR));
838 InsertMenu(hSubMenu, -1, MF_BYPOSITION|MF_STRING, IDS_SELECTALL, buff);
839 LoadString(hInstance, IDS_SCROLL, buff, sizeof(buff) / sizeof(WCHAR));
840 InsertMenu(hSubMenu, -1, MF_BYPOSITION|MF_STRING, IDS_SCROLL, buff);
841 LoadString(hInstance, IDS_SEARCH, buff, sizeof(buff) / sizeof(WCHAR));
842 InsertMenu(hSubMenu, -1, MF_BYPOSITION|MF_STRING, IDS_SEARCH, buff);
843
844 if (sep) InsertMenu(hMenu, -1, MF_BYPOSITION|MF_SEPARATOR, 0, NULL);
845 LoadString(hInstance, IDS_EDIT, buff, sizeof(buff) / sizeof(WCHAR));
846 InsertMenu(hMenu, -1, MF_BYPOSITION|MF_STRING|MF_POPUP, (UINT_PTR)hSubMenu, buff);
847 LoadString(hInstance, IDS_DEFAULT, buff, sizeof(buff) / sizeof(WCHAR));
848 InsertMenu(hMenu, -1, MF_BYPOSITION|MF_STRING, IDS_DEFAULT, buff);
849 LoadString(hInstance, IDS_PROPERTIES, buff, sizeof(buff) / sizeof(WCHAR));
850 InsertMenu(hMenu, -1, MF_BYPOSITION|MF_STRING, IDS_PROPERTIES, buff);
851
852 return TRUE;
853 }
854
855 /******************************************************************
856 * WCUSER_SetMenuDetails
857 *
858 * Grays / ungrays the menu items according to their state
859 */
860 static void WCUSER_SetMenuDetails(const struct inner_data* data, HMENU hMenu)
861 {
862 if (!hMenu) {WINE_ERR("Issue in getting menu bits\n");return;}
863
864 EnableMenuItem(hMenu, IDS_COPY,
865 MF_BYCOMMAND|(PRIVATE(data)->has_selection ? MF_ENABLED : MF_GRAYED));
866 EnableMenuItem(hMenu, IDS_PASTE,
867 MF_BYCOMMAND|(IsClipboardFormatAvailable(CF_UNICODETEXT)
868 ? MF_ENABLED : MF_GRAYED));
869 EnableMenuItem(hMenu, IDS_SCROLL, MF_BYCOMMAND|MF_GRAYED);
870 EnableMenuItem(hMenu, IDS_SEARCH, MF_BYCOMMAND|MF_GRAYED);
871 }
872
873 /******************************************************************
874 * WCUSER_Create
875 *
876 * Creates the window for the rendering
877 */
878 static LRESULT WCUSER_Create(HWND hWnd, LPCREATESTRUCT lpcs)
879 {
880 struct inner_data* data;
881 HMENU hSysMenu;
882
883 data = lpcs->lpCreateParams;
884 SetWindowLongPtr(hWnd, 0L, (DWORD_PTR)data);
885 data->hWnd = hWnd;
886
887 hSysMenu = GetSystemMenu(hWnd, FALSE);
888 if (!hSysMenu) return 0;
889 PRIVATE(data)->hPopMenu = CreatePopupMenu();
890 if (!PRIVATE(data)->hPopMenu) return 0;
891
892 WCUSER_FillMenu(hSysMenu, TRUE);
893 WCUSER_FillMenu(PRIVATE(data)->hPopMenu, FALSE);
894
895 PRIVATE(data)->hMemDC = CreateCompatibleDC(0);
896 if (!PRIVATE(data)->hMemDC) {WINE_ERR("no mem dc\n");return 0;}
897
898 data->curcfg.quick_edit = FALSE;
899 return 0;
900 }
901
902 /******************************************************************
903 * WCUSER_GetCtrlKeyState
904 *
905 * Get the console bit mask equivalent to the VK_ status in keyState
906 */
907 static DWORD WCUSER_GetCtrlKeyState(BYTE* keyState)
908 {
909 DWORD ret = 0;
910
911 GetKeyboardState(keyState);
912 if (keyState[VK_SHIFT] & 0x80) ret |= SHIFT_PRESSED;
913 if (keyState[VK_LCONTROL] & 0x80) ret |= LEFT_CTRL_PRESSED;
914 if (keyState[VK_RCONTROL] & 0x80) ret |= RIGHT_CTRL_PRESSED;
915 if (keyState[VK_LMENU] & 0x80) ret |= LEFT_ALT_PRESSED;
916 if (keyState[VK_RMENU] & 0x80) ret |= RIGHT_ALT_PRESSED;
917 if (keyState[VK_CAPITAL] & 0x01) ret |= CAPSLOCK_ON;
918 if (keyState[VK_NUMLOCK] & 0x01) ret |= NUMLOCK_ON;
919 if (keyState[VK_SCROLL] & 0x01) ret |= SCROLLLOCK_ON;
920
921 return ret;
922 }
923
924 /******************************************************************
925 * WCUSER_HandleSelectionKey
926 *
927 * Handles keys while selecting an area
928 */
929 static void WCUSER_HandleSelectionKey(struct inner_data* data, BOOL down,
930 WPARAM wParam, LPARAM lParam)
931 {
932 BYTE keyState[256];
933 DWORD state = WCUSER_GetCtrlKeyState(keyState) & ~(CAPSLOCK_ON|NUMLOCK_ON|SCROLLLOCK_ON);
934 COORD c1, c2;
935
936 if (!down) return;
937
938 switch (state)
939 {
940 case 0:
941 switch (wParam)
942 {
943 case VK_RETURN:
944 PRIVATE(data)->has_selection = FALSE;
945 WCUSER_SetSelection(data, 0);
946 WCUSER_CopySelectionToClipboard(data);
947 return;
948 case VK_RIGHT:
949 c1 = PRIVATE(data)->selectPt1;
950 c2 = PRIVATE(data)->selectPt2;
951 c1.X++; c2.X++;
952 WCUSER_MoveSelection(data, c1, c2);
953 return;
954 case VK_LEFT:
955 c1 = PRIVATE(data)->selectPt1;
956 c2 = PRIVATE(data)->selectPt2;
957 c1.X--; c2.X--;
958 WCUSER_MoveSelection(data, c1, c2);
959 return;
960 case VK_UP:
961 c1 = PRIVATE(data)->selectPt1;
962 c2 = PRIVATE(data)->selectPt2;
963 c1.Y--; c2.Y--;
964 WCUSER_MoveSelection(data, c1, c2);
965 return;
966 case VK_DOWN:
967 c1 = PRIVATE(data)->selectPt1;
968 c2 = PRIVATE(data)->selectPt2;
969 c1.Y++; c2.Y++;
970 WCUSER_MoveSelection(data, c1, c2);
971 return;
972 }
973 break;
974 case SHIFT_PRESSED:
975 switch (wParam)
976 {
977 case VK_RIGHT:
978 c1 = PRIVATE(data)->selectPt1;
979 c2 = PRIVATE(data)->selectPt2;
980 c2.X++;
981 WCUSER_MoveSelection(data, c1, c2);
982 return;
983 case VK_LEFT:
984 c1 = PRIVATE(data)->selectPt1;
985 c2 = PRIVATE(data)->selectPt2;
986 c2.X--;
987 WCUSER_MoveSelection(data, c1, c2);
988 return;
989 case VK_UP:
990 c1 = PRIVATE(data)->selectPt1;
991 c2 = PRIVATE(data)->selectPt2;
992 c2.Y--;
993 WCUSER_MoveSelection(data, c1, c2);
994 return;
995 case VK_DOWN:
996 c1 = PRIVATE(data)->selectPt1;
997 c2 = PRIVATE(data)->selectPt2;
998 c2.Y++;
999 WCUSER_MoveSelection(data, c1, c2);
1000 return;
1001 }
1002 break;
1003 }
1004
1005 if (wParam < VK_SPACE) /* Shift, Alt, Ctrl, Num Lock etc. */
1006 return;
1007
1008 WCUSER_SetSelection(data, 0);
1009 PRIVATE(data)->has_selection = FALSE;
1010 }
1011
1012 /******************************************************************
1013 * WCUSER_GenerateKeyInputRecord
1014 *
1015 * generates input_record from windows WM_KEYUP/WM_KEYDOWN messages
1016 */
1017 static void WCUSER_GenerateKeyInputRecord(struct inner_data* data, BOOL down,
1018 WPARAM wParam, LPARAM lParam)
1019 {
1020 INPUT_RECORD ir;
1021 DWORD n;
1022 WCHAR buf[2];
1023 static WCHAR last; /* keep last char seen as feed for key up message */
1024 BYTE keyState[256];
1025
1026 ir.EventType = KEY_EVENT;
1027 ir.Event.KeyEvent.bKeyDown = down;
1028 ir.Event.KeyEvent.wRepeatCount = LOWORD(lParam);
1029 ir.Event.KeyEvent.wVirtualKeyCode = wParam;
1030
1031 ir.Event.KeyEvent.wVirtualScanCode = HIWORD(lParam) & 0xFF;
1032
1033 ir.Event.KeyEvent.uChar.UnicodeChar = 0;
1034 ir.Event.KeyEvent.dwControlKeyState = WCUSER_GetCtrlKeyState(keyState);
1035 if (lParam & (1L << 24)) ir.Event.KeyEvent.dwControlKeyState |= ENHANCED_KEY;
1036
1037 if (down)
1038 {
1039 switch (ToUnicode(wParam, HIWORD(lParam), keyState, buf, 2, 0))
1040 {
1041 case 2:
1042 /* FIXME... should generate two events... */
1043 /* fall thru */
1044 case 1:
1045 last = buf[0];
1046 break;
1047 default:
1048 last = 0;
1049 break;
1050 }
1051 }
1052 ir.Event.KeyEvent.uChar.UnicodeChar = last; /* FIXME: HACKY... and buggy because it should be a stack, not a single value */
1053 if (!down) last = 0;
1054
1055 WriteConsoleInput(data->hConIn, &ir, 1, &n);
1056 }
1057
1058 /******************************************************************
1059 * WCUSER_GenerateMouseInputRecord
1060 *
1061 *
1062 */
1063 static void WCUSER_GenerateMouseInputRecord(struct inner_data* data, COORD c,
1064 WPARAM wParam, DWORD event)
1065 {
1066 INPUT_RECORD ir;
1067 BYTE keyState[256];
1068 DWORD mode, n;
1069
1070 /* MOUSE_EVENTs shouldn't be sent unless ENABLE_MOUSE_INPUT is active */
1071 if (!GetConsoleMode(data->hConIn, &mode) || !(mode & ENABLE_MOUSE_INPUT))
1072 return;
1073
1074 ir.EventType = MOUSE_EVENT;
1075 ir.Event.MouseEvent.dwMousePosition = c;
1076 ir.Event.MouseEvent.dwButtonState = 0;
1077 if (wParam & MK_LBUTTON) ir.Event.MouseEvent.dwButtonState |= FROM_LEFT_1ST_BUTTON_PRESSED;
1078 if (wParam & MK_MBUTTON) ir.Event.MouseEvent.dwButtonState |= FROM_LEFT_2ND_BUTTON_PRESSED;
1079 if (wParam & MK_RBUTTON) ir.Event.MouseEvent.dwButtonState |= RIGHTMOST_BUTTON_PRESSED;
1080 if (wParam & MK_CONTROL) ir.Event.MouseEvent.dwButtonState |= LEFT_CTRL_PRESSED;
1081 if (wParam & MK_SHIFT) ir.Event.MouseEvent.dwButtonState |= SHIFT_PRESSED;
1082 if (event == MOUSE_WHEELED) ir.Event.MouseEvent.dwButtonState |= wParam & 0xFFFF0000;
1083 ir.Event.MouseEvent.dwControlKeyState = WCUSER_GetCtrlKeyState(keyState);
1084 ir.Event.MouseEvent.dwEventFlags = event;
1085
1086 WriteConsoleInput(data->hConIn, &ir, 1, &n);
1087 }
1088
1089 /******************************************************************
1090 * WCUSER_Proc
1091 *
1092 *
1093 */
1094 static LRESULT CALLBACK WCUSER_Proc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1095 {
1096 struct inner_data* data = (struct inner_data*)GetWindowLongPtr(hWnd, 0);
1097
1098 switch (uMsg)
1099 {
1100 case WM_CREATE:
1101 return WCUSER_Create(hWnd, (LPCREATESTRUCT)lParam);
1102 case WM_DESTROY:
1103 data->hWnd = 0;
1104 PostQuitMessage(0);
1105 break;
1106 case WM_PAINT:
1107 WCUSER_Paint(data);
1108 break;
1109 case WM_KEYDOWN:
1110 case WM_KEYUP:
1111 if (PRIVATE(data)->has_selection)
1112 WCUSER_HandleSelectionKey(data, uMsg == WM_KEYDOWN, wParam, lParam);
1113 else
1114 WCUSER_GenerateKeyInputRecord(data, uMsg == WM_KEYDOWN, wParam, lParam);
1115 break;
1116 case WM_SYSKEYDOWN:
1117 case WM_SYSKEYUP:
1118 WCUSER_GenerateKeyInputRecord(data, uMsg == WM_SYSKEYDOWN, wParam, lParam);
1119 break;
1120 case WM_LBUTTONDOWN:
1121 if (data->curcfg.quick_edit || PRIVATE(data)->has_selection)
1122 {
1123 if (PRIVATE(data)->has_selection)
1124 WCUSER_SetSelection(data, 0);
1125
1126 if (data->curcfg.quick_edit && PRIVATE(data)->has_selection)
1127 {
1128 PRIVATE(data)->has_selection = FALSE;
1129 }
1130 else
1131 {
1132 PRIVATE(data)->selectPt1 = PRIVATE(data)->selectPt2 = WCUSER_GetCell(data, lParam);
1133 SetCapture(data->hWnd);
1134 WCUSER_SetSelection(data, 0);
1135 PRIVATE(data)->has_selection = TRUE;
1136 }
1137 }
1138 else
1139 {
1140 WCUSER_GenerateMouseInputRecord(data, WCUSER_GetCell(data, lParam), wParam, 0);
1141 }
1142 break;
1143 case WM_MOUSEMOVE:
1144 if (data->curcfg.quick_edit || PRIVATE(data)->has_selection)
1145 {
1146 if (GetCapture() == data->hWnd && PRIVATE(data)->has_selection &&
1147 (wParam & MK_LBUTTON))
1148 {
1149 WCUSER_MoveSelection(data, PRIVATE(data)->selectPt1, WCUSER_GetCell(data, lParam));
1150 }
1151 }
1152 else
1153 {
1154 WCUSER_GenerateMouseInputRecord(data, WCUSER_GetCell(data, lParam), wParam, MOUSE_MOVED);
1155 }
1156 break;
1157 case WM_LBUTTONUP:
1158 if (data->curcfg.quick_edit || PRIVATE(data)->has_selection)
1159 {
1160 if (GetCapture() == data->hWnd && PRIVATE(data)->has_selection)
1161 {
1162 WCUSER_MoveSelection(data, PRIVATE(data)->selectPt1, WCUSER_GetCell(data, lParam));
1163 ReleaseCapture();
1164 }
1165 }
1166 else
1167 {
1168 WCUSER_GenerateMouseInputRecord(data, WCUSER_GetCell(data, lParam), wParam, 0);
1169 }
1170 break;
1171 case WM_RBUTTONDOWN:
1172 if ((wParam & (MK_CONTROL|MK_SHIFT)) == data->curcfg.menu_mask)
1173 {
1174 POINT pt;
1175
1176 pt.x = (short)LOWORD(lParam);
1177 pt.y = (short)HIWORD(lParam);
1178 ClientToScreen(hWnd, &pt);
1179 WCUSER_SetMenuDetails(data, PRIVATE(data)->hPopMenu);
1180 TrackPopupMenu(PRIVATE(data)->hPopMenu, TPM_LEFTALIGN|TPM_TOPALIGN,
1181 pt.x, pt.y, 0, hWnd, NULL);
1182 }
1183 else
1184 {
1185 WCUSER_GenerateMouseInputRecord(data, WCUSER_GetCell(data, lParam), wParam, 0);
1186 }
1187 break;
1188 case WM_RBUTTONUP:
1189 /* no need to track for rbutton up when opening the popup... the event will be
1190 * swallowed by TrackPopupMenu */
1191 case WM_MBUTTONDOWN:
1192 case WM_MBUTTONUP:
1193 WCUSER_GenerateMouseInputRecord(data, WCUSER_GetCell(data, lParam), wParam, 0);
1194 break;
1195 case WM_LBUTTONDBLCLK:
1196 case WM_MBUTTONDBLCLK:
1197 case WM_RBUTTONDBLCLK:
1198 WCUSER_GenerateMouseInputRecord(data, WCUSER_GetCell(data, lParam), wParam, DOUBLE_CLICK);
1199 break;
1200 case WM_MOUSEWHEEL:
1201 WCUSER_GenerateMouseInputRecord(data, WCUSER_GetCell(data, lParam), wParam, MOUSE_WHEELED);
1202 break;
1203 case WM_SETFOCUS:
1204 if (data->curcfg.cursor_visible)
1205 {
1206 CreateCaret(data->hWnd, PRIVATE(data)->cursor_bitmap,
1207 data->curcfg.cell_width, data->curcfg.cell_height);
1208 WCUSER_PosCursor(data);
1209 }
1210 break;
1211 case WM_KILLFOCUS:
1212 if (data->curcfg.cursor_visible)
1213 DestroyCaret();
1214 break;
1215 case WM_HSCROLL:
1216 {
1217 int pos = data->curcfg.win_pos.X;
1218
1219 switch (LOWORD(wParam))
1220 {
1221 case SB_PAGEUP: pos -= 8; break;
1222 case SB_PAGEDOWN: pos += 8; break;
1223 case SB_LINEUP: pos--; break;
1224 case SB_LINEDOWN: pos++; break;
1225 case SB_THUMBTRACK: pos = HIWORD(wParam); break;
1226 default: break;
1227 }
1228 if (pos < 0) pos = 0;
1229 if (pos > data->curcfg.sb_width - data->curcfg.win_width)
1230 pos = data->curcfg.sb_width - data->curcfg.win_width;
1231 if (pos != data->curcfg.win_pos.X)
1232 {
1233 ScrollWindow(hWnd, (data->curcfg.win_pos.X - pos) * data->curcfg.cell_width, 0,
1234 NULL, NULL);
1235 data->curcfg.win_pos.X = pos;
1236 SetScrollPos(hWnd, SB_HORZ, pos, TRUE);
1237 UpdateWindow(hWnd);
1238 WCUSER_PosCursor(data);
1239 WINECON_NotifyWindowChange(data);
1240 }
1241 }
1242 break;
1243 case WM_VSCROLL:
1244 {
1245 int pos = data->curcfg.win_pos.Y;
1246
1247 switch (LOWORD(wParam))
1248 {
1249 case SB_PAGEUP: pos -= 8; break;
1250 case SB_PAGEDOWN: pos += 8; break;
1251 case SB_LINEUP: pos--; break;
1252 case SB_LINEDOWN: pos++; break;
1253 case SB_THUMBTRACK: pos = HIWORD(wParam); break;
1254 default: break;
1255 }
1256 if (pos < 0) pos = 0;
1257 if (pos > data->curcfg.sb_height - data->curcfg.win_height)
1258 pos = data->curcfg.sb_height - data->curcfg.win_height;
1259 if (pos != data->curcfg.win_pos.Y)
1260 {
1261 ScrollWindow(hWnd, 0, (data->curcfg.win_pos.Y - pos) * data->curcfg.cell_height,
1262 NULL, NULL);
1263 data->curcfg.win_pos.Y = pos;
1264 SetScrollPos(hWnd, SB_VERT, pos, TRUE);
1265 UpdateWindow(hWnd);
1266 WCUSER_PosCursor(data);
1267 WINECON_NotifyWindowChange(data);
1268 }
1269
1270 }
1271 case WM_SYSCOMMAND:
1272 switch (wParam)
1273 {
1274 case IDS_DEFAULT:
1275 WCUSER_GetProperties(data, FALSE);
1276 break;
1277 case IDS_PROPERTIES:
1278 WCUSER_GetProperties(data, TRUE);
1279 break;
1280 default:
1281 return DefWindowProc(hWnd, uMsg, wParam, lParam);
1282 }
1283 break;
1284 case WM_COMMAND:
1285 switch (wParam)
1286 {
1287 case IDS_DEFAULT:
1288 WCUSER_GetProperties(data, FALSE);
1289 break;
1290 case IDS_PROPERTIES:
1291 WCUSER_GetProperties(data, TRUE);
1292 break;
1293 case IDS_MARK:
1294 PRIVATE(data)->selectPt1.X = PRIVATE(data)->selectPt1.Y = 0;
1295 PRIVATE(data)->selectPt2.X = PRIVATE(data)->selectPt2.Y = 0;
1296 WCUSER_SetSelection(data, 0);
1297 PRIVATE(data)->has_selection = TRUE;
1298 break;
1299 case IDS_COPY:
1300 if (PRIVATE(data)->has_selection)
1301 {
1302 PRIVATE(data)->has_selection = FALSE;
1303 WCUSER_SetSelection(data, 0);
1304 WCUSER_CopySelectionToClipboard(data);
1305 }
1306 break;
1307 case IDS_PASTE:
1308 WCUSER_PasteFromClipboard(data);
1309 break;
1310 case IDS_SELECTALL:
1311 PRIVATE(data)->selectPt1.X = PRIVATE(data)->selectPt1.Y = 0;
1312 PRIVATE(data)->selectPt2.X = (data->curcfg.sb_width - 1) * data->curcfg.cell_width;
1313 PRIVATE(data)->selectPt2.Y = (data->curcfg.sb_height - 1) * data->curcfg.cell_height;
1314 WCUSER_SetSelection(data, 0);
1315 PRIVATE(data)->has_selection = TRUE;
1316 break;
1317 case IDS_SCROLL:
1318 case IDS_SEARCH:
1319 WINE_FIXME("Unhandled yet command: %lx\n", wParam);
1320 break;
1321 default:
1322 return DefWindowProc(hWnd, uMsg, wParam, lParam);
1323 }
1324 break;
1325 case WM_INITMENUPOPUP:
1326 if (!HIWORD(lParam)) return DefWindowProc(hWnd, uMsg, wParam, lParam);
1327 WCUSER_SetMenuDetails(data, GetSystemMenu(data->hWnd, FALSE));
1328 break;
1329 default:
1330 return DefWindowProc(hWnd, uMsg, wParam, lParam);
1331 }
1332 return 0;
1333 }
1334
1335 /******************************************************************
1336 * WCUSER_DeleteBackend
1337 *
1338 *
1339 */
1340 static void WCUSER_DeleteBackend(struct inner_data* data)
1341 {
1342 if (!PRIVATE(data)) return;
1343 if (PRIVATE(data)->hMemDC) DeleteDC(PRIVATE(data)->hMemDC);
1344 if (data->hWnd) DestroyWindow(data->hWnd);
1345 if (PRIVATE(data)->hFont) DeleteObject(PRIVATE(data)->hFont);
1346 if (PRIVATE(data)->cursor_bitmap) DeleteObject(PRIVATE(data)->cursor_bitmap);
1347 if (PRIVATE(data)->hBitmap) DeleteObject(PRIVATE(data)->hBitmap);
1348 HeapFree(GetProcessHeap(), 0, PRIVATE(data));
1349 }
1350
1351 /******************************************************************
1352 * WCUSER_MainLoop
1353 *
1354 *
1355 */
1356 static int WCUSER_MainLoop(struct inner_data* data)
1357 {
1358 MSG msg;
1359
1360 ShowWindow(data->hWnd, data->nCmdShow);
1361 for (;;)
1362 {
1363 switch (MsgWaitForMultipleObjects(1, &data->hSynchro, FALSE, INFINITE, QS_ALLINPUT))
1364 {
1365 case WAIT_OBJECT_0:
1366 if (!WINECON_GrabChanges(data) && data->curcfg.exit_on_die)
1367 PostQuitMessage(0);
1368 break;
1369 case WAIT_OBJECT_0+1:
1370 /* need to use PeekMessage loop instead of simple GetMessage:
1371 * multiple messages might have arrived in between,
1372 * so GetMessage would lead to delayed processing */
1373 while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
1374 {
1375 if (msg.message == WM_QUIT) return 0;
1376 WINE_TRACE("dispatching msg %04x\n", msg.message);
1377 DispatchMessage(&msg);
1378 }
1379 break;
1380 default:
1381 WINE_ERR("got pb\n");
1382 /* err */
1383 break;
1384 }
1385 }
1386 }
1387
1388 /******************************************************************
1389 * WCUSER_InitBackend
1390 *
1391 * Initialisation part II: creation of window.
1392 *
1393 */
1394 enum init_return WCUSER_InitBackend(struct inner_data* data)
1395 {
1396 static const WCHAR wClassName[] = {'W','i','n','e','C','o','n','s','o','l','e','C','l','a','s','s',0};
1397
1398 WNDCLASS wndclass;
1399 CHARSETINFO ci;
1400
1401 if (!TranslateCharsetInfo((DWORD *)(INT_PTR)GetACP(), &ci, TCI_SRCCODEPAGE))
1402 return init_failed;
1403 g_uiDefaultCharset = ci.ciCharset;
1404 WINE_TRACE_(wc_font)("Code page %d => Default charset: %d\n", GetACP(), g_uiDefaultCharset);
1405
1406 data->private = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct inner_data_user));
1407 if (!data->private) return init_failed;
1408
1409 data->fnMainLoop = WCUSER_MainLoop;
1410 data->fnPosCursor = WCUSER_PosCursor;
1411 data->fnShapeCursor = WCUSER_ShapeCursor;
1412 data->fnComputePositions = WCUSER_ComputePositions;
1413 data->fnRefresh = WCUSER_Refresh;
1414 data->fnResizeScreenBuffer = WCUSER_ResizeScreenBuffer;
1415 data->fnSetTitle = WCUSER_SetTitle;
1416 data->fnSetFont = WCUSER_SetFontPmt;
1417 data->fnScroll = WCUSER_Scroll;
1418 data->fnDeleteBackend = WCUSER_DeleteBackend;
1419
1420 wndclass.style = CS_DBLCLKS;
1421 wndclass.lpfnWndProc = WCUSER_Proc;
1422 wndclass.cbClsExtra = 0;
1423 wndclass.cbWndExtra = sizeof(DWORD_PTR);
1424 wndclass.hInstance = GetModuleHandle(NULL);
1425 wndclass.hIcon = LoadIcon(0, IDI_WINLOGO);
1426 wndclass.hCursor = LoadCursor(0, IDC_ARROW);
1427 wndclass.hbrBackground = GetStockObject(BLACK_BRUSH);
1428 wndclass.lpszMenuName = NULL;
1429 wndclass.lpszClassName = wClassName;
1430
1431 RegisterClass(&wndclass);
1432
1433 data->hWnd = CreateWindow(wndclass.lpszClassName, NULL,
1434 WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_THICKFRAME|WS_MINIMIZEBOX|WS_HSCROLL|WS_VSCROLL,
1435 CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, 0, 0, wndclass.hInstance, data);
1436 if (!data->hWnd) return init_not_supported;
1437
1438 return init_success;
1439 }
useful hacks and other patches not (yet) suitable for mainline