?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winemine: Convert menu and string table resources to po files.
[wine.git] / programs / wineconsole / user.c
blobdc60ffdd6101485ef47b852ed34896deec6959bc
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 LOGFONTW* 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 TextOutW(PRIVATE(data)->hMemDC, i * data->curcfg.cell_width,
84 j * data->curcfg.cell_height, 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, GetWindowLongW(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 SetWindowTextW(data->hWnd, buffer);
278 }
279
280 void WCUSER_DumpLogFont(const char* pfx, const LOGFONTW* 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 TEXTMETRICW* 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 LOGFONTW* lf)
322 {
323 return lf->lfHeight == config->cell_height &&
324 lf->lfWeight == config->font_weight &&
325 !lf->lfItalic && !lf->lfUnderline && !lf->lfStrikeOut &&
326 !lstrcmpW(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 TEXTMETRICW* 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 LOGFONTW* 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 LOGFONTW* lf, const TEXTMETRICW* 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 LOGFONTW 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 LOGFONTW* lf, const TEXTMETRICW* 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 EnumFontFamiliesW(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 LOGFONTW* lf, LONG* el)
429 {
430 TEXTMETRICW 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 = CreateFontIndirectW(lf))) goto err1;
437
438 hOldFont = SelectObject(hDC, hFont);
439 GetTextMetricsW(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 GetCharWidth32W(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 GetCharWidth32W(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 lstrcpyW(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(LOGFONTW* 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 lstrcpyW(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 LOGFONTW* 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 LOGFONTW 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 EnumFontFamiliesW(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 ReadConsoleOutputCharacterW(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 = VkKeyScanW(ptr[i]);
737 ir[0].Event.KeyEvent.wVirtualKeyCode = LOBYTE(sh);
738 ir[0].Event.KeyEvent.wVirtualScanCode = MapVirtualKeyW(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 WriteConsoleInputW(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 if (data->in_set_config) return; /* in order to avoid some flicker */
782 BeginPaint(data->hWnd, &ps);
783 BitBlt(ps.hdc, 0, 0,
784 data->curcfg.win_width * data->curcfg.cell_width,
785 data->curcfg.win_height * data->curcfg.cell_height,
786 PRIVATE(data)->hMemDC,
787 data->curcfg.win_pos.X * data->curcfg.cell_width,
788 data->curcfg.win_pos.Y * data->curcfg.cell_height,
789 SRCCOPY);
790 if (PRIVATE(data)->has_selection)
791 WCUSER_SetSelection(data, ps.hdc);
792 EndPaint(data->hWnd, &ps);
793 }
794
795 /******************************************************************
796 * WCUSER_Scroll
797 *
798 *
799 */
800 static void WCUSER_Scroll(struct inner_data* data, int pos, BOOL horz)
801 {
802 if (horz)
803 {
804 ScrollWindow(data->hWnd, (data->curcfg.win_pos.X - pos) * data->curcfg.cell_width, 0, NULL, NULL);
805 SetScrollPos(data->hWnd, SB_HORZ, pos, TRUE);
806 data->curcfg.win_pos.X = pos;
807 }
808 else
809 {
810 ScrollWindow(data->hWnd, 0, (data->curcfg.win_pos.Y - pos) * data->curcfg.cell_height, NULL, NULL);
811 SetScrollPos(data->hWnd, SB_VERT, pos, TRUE);
812 data->curcfg.win_pos.Y = pos;
813 }
814 InvalidateRect(data->hWnd, NULL, FALSE);
815 }
816
817 /******************************************************************
818 * WCUSER_FillMenu
819 *
820 *
821 */
822 static BOOL WCUSER_FillMenu(HMENU hMenu, BOOL sep)
823 {
824 HMENU hSubMenu;
825 HINSTANCE hInstance = GetModuleHandleW(NULL);
826 WCHAR buff[256];
827
828 if (!hMenu) return FALSE;
829
830 /* FIXME: error handling & memory cleanup */
831 hSubMenu = CreateMenu();
832 if (!hSubMenu) return FALSE;
833
834 LoadStringW(hInstance, IDS_MARK, buff, sizeof(buff) / sizeof(buff[0]));
835 InsertMenuW(hSubMenu, -1, MF_BYPOSITION|MF_STRING, IDS_MARK, buff);
836 LoadStringW(hInstance, IDS_COPY, buff, sizeof(buff) / sizeof(buff[0]));
837 InsertMenuW(hSubMenu, -1, MF_BYPOSITION|MF_STRING, IDS_COPY, buff);
838 LoadStringW(hInstance, IDS_PASTE, buff, sizeof(buff) / sizeof(buff[0]));
839 InsertMenuW(hSubMenu, -1, MF_BYPOSITION|MF_STRING, IDS_PASTE, buff);
840 LoadStringW(hInstance, IDS_SELECTALL, buff, sizeof(buff) / sizeof(buff[0]));
841 InsertMenuW(hSubMenu, -1, MF_BYPOSITION|MF_STRING, IDS_SELECTALL, buff);
842 LoadStringW(hInstance, IDS_SCROLL, buff, sizeof(buff) / sizeof(buff[0]));
843 InsertMenuW(hSubMenu, -1, MF_BYPOSITION|MF_STRING, IDS_SCROLL, buff);
844 LoadStringW(hInstance, IDS_SEARCH, buff, sizeof(buff) / sizeof(buff[0]));
845 InsertMenuW(hSubMenu, -1, MF_BYPOSITION|MF_STRING, IDS_SEARCH, buff);
846
847 if (sep) InsertMenuW(hMenu, -1, MF_BYPOSITION|MF_SEPARATOR, 0, NULL);
848 LoadStringW(hInstance, IDS_EDIT, buff, sizeof(buff) / sizeof(buff[0]));
849 InsertMenuW(hMenu, -1, MF_BYPOSITION|MF_STRING|MF_POPUP, (UINT_PTR)hSubMenu, buff);
850 LoadStringW(hInstance, IDS_DEFAULT, buff, sizeof(buff) / sizeof(buff[0]));
851 InsertMenuW(hMenu, -1, MF_BYPOSITION|MF_STRING, IDS_DEFAULT, buff);
852 LoadStringW(hInstance, IDS_PROPERTIES, buff, sizeof(buff) / sizeof(buff[0]));
853 InsertMenuW(hMenu, -1, MF_BYPOSITION|MF_STRING, IDS_PROPERTIES, buff);
854
855 return TRUE;
856 }
857
858 /******************************************************************
859 * WCUSER_SetMenuDetails
860 *
861 * Grays / ungrays the menu items according to their state
862 */
863 static void WCUSER_SetMenuDetails(const struct inner_data* data, HMENU hMenu)
864 {
865 if (!hMenu) {WINE_ERR("Issue in getting menu bits\n");return;}
866
867 EnableMenuItem(hMenu, IDS_COPY,
868 MF_BYCOMMAND|(PRIVATE(data)->has_selection ? MF_ENABLED : MF_GRAYED));
869 EnableMenuItem(hMenu, IDS_PASTE,
870 MF_BYCOMMAND|(IsClipboardFormatAvailable(CF_UNICODETEXT)
871 ? MF_ENABLED : MF_GRAYED));
872 EnableMenuItem(hMenu, IDS_SCROLL, MF_BYCOMMAND|MF_GRAYED);
873 EnableMenuItem(hMenu, IDS_SEARCH, MF_BYCOMMAND|MF_GRAYED);
874 }
875
876 /******************************************************************
877 * WCUSER_Create
878 *
879 * Creates the window for the rendering
880 */
881 static LRESULT WCUSER_Create(HWND hWnd, LPCREATESTRUCTW lpcs)
882 {
883 struct inner_data* data;
884 HMENU hSysMenu;
885
886 data = lpcs->lpCreateParams;
887 SetWindowLongPtrW(hWnd, 0, (DWORD_PTR)data);
888 data->hWnd = hWnd;
889
890 hSysMenu = GetSystemMenu(hWnd, FALSE);
891 if (!hSysMenu) return 0;
892 PRIVATE(data)->hPopMenu = CreatePopupMenu();
893 if (!PRIVATE(data)->hPopMenu) return 0;
894
895 WCUSER_FillMenu(hSysMenu, TRUE);
896 WCUSER_FillMenu(PRIVATE(data)->hPopMenu, FALSE);
897
898 PRIVATE(data)->hMemDC = CreateCompatibleDC(0);
899 if (!PRIVATE(data)->hMemDC) {WINE_ERR("no mem dc\n");return 0;}
900
901 data->curcfg.quick_edit = FALSE;
902 return 0;
903 }
904
905 /******************************************************************
906 * WCUSER_GetCtrlKeyState
907 *
908 * Get the console bit mask equivalent to the VK_ status in keyState
909 */
910 static DWORD WCUSER_GetCtrlKeyState(BYTE* keyState)
911 {
912 DWORD ret = 0;
913
914 GetKeyboardState(keyState);
915 if (keyState[VK_SHIFT] & 0x80) ret |= SHIFT_PRESSED;
916 if (keyState[VK_LCONTROL] & 0x80) ret |= LEFT_CTRL_PRESSED;
917 if (keyState[VK_RCONTROL] & 0x80) ret |= RIGHT_CTRL_PRESSED;
918 if (keyState[VK_LMENU] & 0x80) ret |= LEFT_ALT_PRESSED;
919 if (keyState[VK_RMENU] & 0x80) ret |= RIGHT_ALT_PRESSED;
920 if (keyState[VK_CAPITAL] & 0x01) ret |= CAPSLOCK_ON;
921 if (keyState[VK_NUMLOCK] & 0x01) ret |= NUMLOCK_ON;
922 if (keyState[VK_SCROLL] & 0x01) ret |= SCROLLLOCK_ON;
923
924 return ret;
925 }
926
927 /******************************************************************
928 * WCUSER_HandleSelectionKey
929 *
930 * Handles keys while selecting an area
931 */
932 static void WCUSER_HandleSelectionKey(struct inner_data* data, BOOL down,
933 WPARAM wParam, LPARAM lParam)
934 {
935 BYTE keyState[256];
936 DWORD state = WCUSER_GetCtrlKeyState(keyState) & ~(CAPSLOCK_ON|NUMLOCK_ON|SCROLLLOCK_ON);
937 COORD c1, c2;
938
939 if (!down) return;
940
941 switch (state)
942 {
943 case 0:
944 switch (wParam)
945 {
946 case VK_RETURN:
947 PRIVATE(data)->has_selection = FALSE;
948 WCUSER_SetSelection(data, 0);
949 WCUSER_CopySelectionToClipboard(data);
950 return;
951 case VK_RIGHT:
952 c1 = PRIVATE(data)->selectPt1;
953 c2 = PRIVATE(data)->selectPt2;
954 c1.X++; c2.X++;
955 WCUSER_MoveSelection(data, c1, c2);
956 return;
957 case VK_LEFT:
958 c1 = PRIVATE(data)->selectPt1;
959 c2 = PRIVATE(data)->selectPt2;
960 c1.X--; c2.X--;
961 WCUSER_MoveSelection(data, c1, c2);
962 return;
963 case VK_UP:
964 c1 = PRIVATE(data)->selectPt1;
965 c2 = PRIVATE(data)->selectPt2;
966 c1.Y--; c2.Y--;
967 WCUSER_MoveSelection(data, c1, c2);
968 return;
969 case VK_DOWN:
970 c1 = PRIVATE(data)->selectPt1;
971 c2 = PRIVATE(data)->selectPt2;
972 c1.Y++; c2.Y++;
973 WCUSER_MoveSelection(data, c1, c2);
974 return;
975 }
976 break;
977 case SHIFT_PRESSED:
978 switch (wParam)
979 {
980 case VK_RIGHT:
981 c1 = PRIVATE(data)->selectPt1;
982 c2 = PRIVATE(data)->selectPt2;
983 c2.X++;
984 WCUSER_MoveSelection(data, c1, c2);
985 return;
986 case VK_LEFT:
987 c1 = PRIVATE(data)->selectPt1;
988 c2 = PRIVATE(data)->selectPt2;
989 c2.X--;
990 WCUSER_MoveSelection(data, c1, c2);
991 return;
992 case VK_UP:
993 c1 = PRIVATE(data)->selectPt1;
994 c2 = PRIVATE(data)->selectPt2;
995 c2.Y--;
996 WCUSER_MoveSelection(data, c1, c2);
997 return;
998 case VK_DOWN:
999 c1 = PRIVATE(data)->selectPt1;
1000 c2 = PRIVATE(data)->selectPt2;
1001 c2.Y++;
1002 WCUSER_MoveSelection(data, c1, c2);
1003 return;
1004 }
1005 break;
1006 }
1007
1008 if (wParam < VK_SPACE) /* Shift, Alt, Ctrl, Num Lock etc. */
1009 return;
1010
1011 WCUSER_SetSelection(data, 0);
1012 PRIVATE(data)->has_selection = FALSE;
1013 }
1014
1015 /******************************************************************
1016 * WCUSER_GenerateKeyInputRecord
1017 *
1018 * generates input_record from windows WM_KEYUP/WM_KEYDOWN messages
1019 */
1020 static void WCUSER_GenerateKeyInputRecord(struct inner_data* data, BOOL down,
1021 WPARAM wParam, LPARAM lParam)
1022 {
1023 INPUT_RECORD ir;
1024 DWORD n;
1025 WCHAR buf[2];
1026 static WCHAR last; /* keep last char seen as feed for key up message */
1027 BYTE keyState[256];
1028
1029 ir.EventType = KEY_EVENT;
1030 ir.Event.KeyEvent.bKeyDown = down;
1031 ir.Event.KeyEvent.wRepeatCount = LOWORD(lParam);
1032 ir.Event.KeyEvent.wVirtualKeyCode = wParam;
1033
1034 ir.Event.KeyEvent.wVirtualScanCode = HIWORD(lParam) & 0xFF;
1035
1036 ir.Event.KeyEvent.uChar.UnicodeChar = 0;
1037 ir.Event.KeyEvent.dwControlKeyState = WCUSER_GetCtrlKeyState(keyState);
1038 if (lParam & (1L << 24)) ir.Event.KeyEvent.dwControlKeyState |= ENHANCED_KEY;
1039
1040 if (down)
1041 {
1042 switch (ToUnicode(wParam, HIWORD(lParam), keyState, buf, 2, 0))
1043 {
1044 case 2:
1045 /* FIXME... should generate two events... */
1046 /* fall thru */
1047 case 1:
1048 last = buf[0];
1049 break;
1050 default:
1051 last = 0;
1052 break;
1053 }
1054 }
1055 ir.Event.KeyEvent.uChar.UnicodeChar = last; /* FIXME: HACKY... and buggy because it should be a stack, not a single value */
1056 if (!down) last = 0;
1057
1058 WriteConsoleInputW(data->hConIn, &ir, 1, &n);
1059 }
1060
1061 /******************************************************************
1062 * WCUSER_GenerateMouseInputRecord
1063 *
1064 *
1065 */
1066 static void WCUSER_GenerateMouseInputRecord(struct inner_data* data, COORD c,
1067 WPARAM wParam, DWORD event)
1068 {
1069 INPUT_RECORD ir;
1070 BYTE keyState[256];
1071 DWORD mode, n;
1072
1073 /* MOUSE_EVENTs shouldn't be sent unless ENABLE_MOUSE_INPUT is active */
1074 if (!GetConsoleMode(data->hConIn, &mode) || !(mode & ENABLE_MOUSE_INPUT))
1075 return;
1076
1077 ir.EventType = MOUSE_EVENT;
1078 ir.Event.MouseEvent.dwMousePosition = c;
1079 ir.Event.MouseEvent.dwButtonState = 0;
1080 if (wParam & MK_LBUTTON) ir.Event.MouseEvent.dwButtonState |= FROM_LEFT_1ST_BUTTON_PRESSED;
1081 if (wParam & MK_MBUTTON) ir.Event.MouseEvent.dwButtonState |= FROM_LEFT_2ND_BUTTON_PRESSED;
1082 if (wParam & MK_RBUTTON) ir.Event.MouseEvent.dwButtonState |= RIGHTMOST_BUTTON_PRESSED;
1083 if (wParam & MK_CONTROL) ir.Event.MouseEvent.dwButtonState |= LEFT_CTRL_PRESSED;
1084 if (wParam & MK_SHIFT) ir.Event.MouseEvent.dwButtonState |= SHIFT_PRESSED;
1085 if (event == MOUSE_WHEELED) ir.Event.MouseEvent.dwButtonState |= wParam & 0xFFFF0000;
1086 ir.Event.MouseEvent.dwControlKeyState = WCUSER_GetCtrlKeyState(keyState);
1087 ir.Event.MouseEvent.dwEventFlags = event;
1088
1089 WriteConsoleInputW(data->hConIn, &ir, 1, &n);
1090 }
1091
1092 /******************************************************************
1093 * WCUSER_Proc
1094 *
1095 *
1096 */
1097 static LRESULT CALLBACK WCUSER_Proc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1098 {
1099 struct inner_data* data = (struct inner_data*)GetWindowLongPtrW(hWnd, 0);
1100
1101 switch (uMsg)
1102 {
1103 case WM_CREATE:
1104 return WCUSER_Create(hWnd, (LPCREATESTRUCTW)lParam);
1105 case WM_DESTROY:
1106 data->hWnd = 0;
1107 PostQuitMessage(0);
1108 break;
1109 case WM_PAINT:
1110 WCUSER_Paint(data);
1111 break;
1112 case WM_KEYDOWN:
1113 case WM_KEYUP:
1114 if (PRIVATE(data)->has_selection)
1115 WCUSER_HandleSelectionKey(data, uMsg == WM_KEYDOWN, wParam, lParam);
1116 else
1117 WCUSER_GenerateKeyInputRecord(data, uMsg == WM_KEYDOWN, wParam, lParam);
1118 break;
1119 case WM_SYSKEYDOWN:
1120 case WM_SYSKEYUP:
1121 WCUSER_GenerateKeyInputRecord(data, uMsg == WM_SYSKEYDOWN, wParam, lParam);
1122 break;
1123 case WM_LBUTTONDOWN:
1124 if (data->curcfg.quick_edit || PRIVATE(data)->has_selection)
1125 {
1126 if (PRIVATE(data)->has_selection)
1127 WCUSER_SetSelection(data, 0);
1128
1129 if (data->curcfg.quick_edit && PRIVATE(data)->has_selection)
1130 {
1131 PRIVATE(data)->has_selection = FALSE;
1132 }
1133 else
1134 {
1135 PRIVATE(data)->selectPt1 = PRIVATE(data)->selectPt2 = WCUSER_GetCell(data, lParam);
1136 SetCapture(data->hWnd);
1137 WCUSER_SetSelection(data, 0);
1138 PRIVATE(data)->has_selection = TRUE;
1139 }
1140 }
1141 else
1142 {
1143 WCUSER_GenerateMouseInputRecord(data, WCUSER_GetCell(data, lParam), wParam, 0);
1144 }
1145 break;
1146 case WM_MOUSEMOVE:
1147 if (data->curcfg.quick_edit || PRIVATE(data)->has_selection)
1148 {
1149 if (GetCapture() == data->hWnd && PRIVATE(data)->has_selection &&
1150 (wParam & MK_LBUTTON))
1151 {
1152 WCUSER_MoveSelection(data, PRIVATE(data)->selectPt1, WCUSER_GetCell(data, lParam));
1153 }
1154 }
1155 else
1156 {
1157 WCUSER_GenerateMouseInputRecord(data, WCUSER_GetCell(data, lParam), wParam, MOUSE_MOVED);
1158 }
1159 break;
1160 case WM_LBUTTONUP:
1161 if (data->curcfg.quick_edit || PRIVATE(data)->has_selection)
1162 {
1163 if (GetCapture() == data->hWnd && PRIVATE(data)->has_selection)
1164 {
1165 WCUSER_MoveSelection(data, PRIVATE(data)->selectPt1, WCUSER_GetCell(data, lParam));
1166 ReleaseCapture();
1167 }
1168 }
1169 else
1170 {
1171 WCUSER_GenerateMouseInputRecord(data, WCUSER_GetCell(data, lParam), wParam, 0);
1172 }
1173 break;
1174 case WM_RBUTTONDOWN:
1175 if ((wParam & (MK_CONTROL|MK_SHIFT)) == data->curcfg.menu_mask)
1176 {
1177 POINT pt;
1178
1179 pt.x = (short)LOWORD(lParam);
1180 pt.y = (short)HIWORD(lParam);
1181 ClientToScreen(hWnd, &pt);
1182 WCUSER_SetMenuDetails(data, PRIVATE(data)->hPopMenu);
1183 TrackPopupMenu(PRIVATE(data)->hPopMenu, TPM_LEFTALIGN|TPM_TOPALIGN|TPM_RIGHTBUTTON,
1184 pt.x, pt.y, 0, hWnd, NULL);
1185 }
1186 else
1187 {
1188 WCUSER_GenerateMouseInputRecord(data, WCUSER_GetCell(data, lParam), wParam, 0);
1189 }
1190 break;
1191 case WM_RBUTTONUP:
1192 /* no need to track for rbutton up when opening the popup... the event will be
1193 * swallowed by TrackPopupMenu */
1194 case WM_MBUTTONDOWN:
1195 case WM_MBUTTONUP:
1196 WCUSER_GenerateMouseInputRecord(data, WCUSER_GetCell(data, lParam), wParam, 0);
1197 break;
1198 case WM_LBUTTONDBLCLK:
1199 case WM_MBUTTONDBLCLK:
1200 case WM_RBUTTONDBLCLK:
1201 WCUSER_GenerateMouseInputRecord(data, WCUSER_GetCell(data, lParam), wParam, DOUBLE_CLICK);
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 struct config_data cfg = data->curcfg;
1218
1219 switch (LOWORD(wParam))
1220 {
1221 case SB_PAGEUP: cfg.win_pos.X -= 8; break;
1222 case SB_PAGEDOWN: cfg.win_pos.X += 8; break;
1223 case SB_LINEUP: cfg.win_pos.X--; break;
1224 case SB_LINEDOWN: cfg.win_pos.X++; break;
1225 case SB_THUMBTRACK: cfg.win_pos.X = HIWORD(wParam); break;
1226 default: break;
1227 }
1228 if (cfg.win_pos.X < 0) cfg.win_pos.X = 0;
1229 if (cfg.win_pos.X > data->curcfg.sb_width - data->curcfg.win_width)
1230 cfg.win_pos.X = data->curcfg.sb_width - data->curcfg.win_width;
1231 if (cfg.win_pos.X != data->curcfg.win_pos.X)
1232 {
1233 WINECON_SetConfig(data, &cfg);
1234 }
1235 }
1236 break;
1237 case WM_MOUSEWHEEL:
1238 if (data->curcfg.sb_height <= data->curcfg.win_height)
1239 {
1240 WCUSER_GenerateMouseInputRecord(data, WCUSER_GetCell(data, lParam), wParam, MOUSE_WHEELED);
1241 break;
1242 }
1243 /* else fallthrough */
1244 case WM_VSCROLL:
1245 {
1246 struct config_data cfg = data->curcfg;
1247
1248 if (uMsg == WM_MOUSEWHEEL)
1249 {
1250 UINT scrollLines = 3;
1251 SystemParametersInfoW(SPI_GETWHEELSCROLLLINES, 0, &scrollLines, 0);
1252 scrollLines *= -GET_WHEEL_DELTA_WPARAM(wParam) / WHEEL_DELTA;
1253 cfg.win_pos.Y += scrollLines;
1254 } else {
1255 switch (LOWORD(wParam))
1256 {
1257 case SB_PAGEUP: cfg.win_pos.Y -= 8; break;
1258 case SB_PAGEDOWN: cfg.win_pos.Y += 8; break;
1259 case SB_LINEUP: cfg.win_pos.Y--; break;
1260 case SB_LINEDOWN: cfg.win_pos.Y++; break;
1261 case SB_THUMBTRACK: cfg.win_pos.Y = HIWORD(wParam); break;
1262 default: break;
1263 }
1264 }
1265
1266 if (cfg.win_pos.Y < 0) cfg.win_pos.Y = 0;
1267 if (cfg.win_pos.Y > data->curcfg.sb_height - data->curcfg.win_height)
1268 cfg.win_pos.Y = data->curcfg.sb_height - data->curcfg.win_height;
1269 if (cfg.win_pos.Y != data->curcfg.win_pos.Y)
1270 {
1271 WINECON_SetConfig(data, &cfg);
1272 }
1273 }
1274 break;
1275 case WM_SYSCOMMAND:
1276 switch (wParam)
1277 {
1278 case IDS_DEFAULT:
1279 WCUSER_GetProperties(data, FALSE);
1280 break;
1281 case IDS_PROPERTIES:
1282 WCUSER_GetProperties(data, TRUE);
1283 break;
1284 default:
1285 return DefWindowProcW(hWnd, uMsg, wParam, lParam);
1286 }
1287 break;
1288 case WM_COMMAND:
1289 switch (wParam)
1290 {
1291 case IDS_DEFAULT:
1292 WCUSER_GetProperties(data, FALSE);
1293 break;
1294 case IDS_PROPERTIES:
1295 WCUSER_GetProperties(data, TRUE);
1296 break;
1297 case IDS_MARK:
1298 PRIVATE(data)->selectPt1.X = PRIVATE(data)->selectPt1.Y = 0;
1299 PRIVATE(data)->selectPt2.X = PRIVATE(data)->selectPt2.Y = 0;
1300 WCUSER_SetSelection(data, 0);
1301 PRIVATE(data)->has_selection = TRUE;
1302 break;
1303 case IDS_COPY:
1304 if (PRIVATE(data)->has_selection)
1305 {
1306 PRIVATE(data)->has_selection = FALSE;
1307 WCUSER_SetSelection(data, 0);
1308 WCUSER_CopySelectionToClipboard(data);
1309 }
1310 break;
1311 case IDS_PASTE:
1312 WCUSER_PasteFromClipboard(data);
1313 break;
1314 case IDS_SELECTALL:
1315 PRIVATE(data)->selectPt1.X = PRIVATE(data)->selectPt1.Y = 0;
1316 PRIVATE(data)->selectPt2.X = (data->curcfg.sb_width - 1) * data->curcfg.cell_width;
1317 PRIVATE(data)->selectPt2.Y = (data->curcfg.sb_height - 1) * data->curcfg.cell_height;
1318 WCUSER_SetSelection(data, 0);
1319 PRIVATE(data)->has_selection = TRUE;
1320 break;
1321 case IDS_SCROLL:
1322 case IDS_SEARCH:
1323 WINE_FIXME("Unhandled yet command: %lx\n", wParam);
1324 break;
1325 default:
1326 return DefWindowProcW(hWnd, uMsg, wParam, lParam);
1327 }
1328 break;
1329 case WM_INITMENUPOPUP:
1330 if (!HIWORD(lParam)) return DefWindowProcW(hWnd, uMsg, wParam, lParam);
1331 WCUSER_SetMenuDetails(data, GetSystemMenu(data->hWnd, FALSE));
1332 break;
1333 case WM_SIZE:
1334 WINECON_ResizeWithContainer(data, LOWORD(lParam) / data->curcfg.cell_width,
1335 HIWORD(lParam) / data->curcfg.cell_height);
1336 break;
1337 default:
1338 return DefWindowProcW(hWnd, uMsg, wParam, lParam);
1339 }
1340 return 0;
1341 }
1342
1343 /******************************************************************
1344 * WCUSER_DeleteBackend
1345 *
1346 *
1347 */
1348 static void WCUSER_DeleteBackend(struct inner_data* data)
1349 {
1350 if (!PRIVATE(data)) return;
1351 if (PRIVATE(data)->hMemDC) DeleteDC(PRIVATE(data)->hMemDC);
1352 if (data->hWnd) DestroyWindow(data->hWnd);
1353 if (PRIVATE(data)->hFont) DeleteObject(PRIVATE(data)->hFont);
1354 if (PRIVATE(data)->cursor_bitmap) DeleteObject(PRIVATE(data)->cursor_bitmap);
1355 if (PRIVATE(data)->hBitmap) DeleteObject(PRIVATE(data)->hBitmap);
1356 HeapFree(GetProcessHeap(), 0, PRIVATE(data));
1357 }
1358
1359 /******************************************************************
1360 * WCUSER_MainLoop
1361 *
1362 *
1363 */
1364 static int WCUSER_MainLoop(struct inner_data* data)
1365 {
1366 MSG msg;
1367
1368 ShowWindow(data->hWnd, data->nCmdShow);
1369 for (;;)
1370 {
1371 switch (MsgWaitForMultipleObjects(1, &data->hSynchro, FALSE, INFINITE, QS_ALLINPUT))
1372 {
1373 case WAIT_OBJECT_0:
1374 if (!WINECON_GrabChanges(data) && data->curcfg.exit_on_die)
1375 PostQuitMessage(0);
1376 break;
1377 case WAIT_OBJECT_0+1:
1378 /* need to use PeekMessageW loop instead of simple GetMessage:
1379 * multiple messages might have arrived in between,
1380 * so GetMessage would lead to delayed processing */
1381 while (PeekMessageW(&msg, 0, 0, 0, PM_REMOVE))
1382 {
1383 if (msg.message == WM_QUIT) return 0;
1384 WINE_TRACE("dispatching msg %04x\n", msg.message);
1385 DispatchMessageW(&msg);
1386 }
1387 break;
1388 default:
1389 WINE_ERR("got pb\n");
1390 /* err */
1391 break;
1392 }
1393 }
1394 }
1395
1396 /******************************************************************
1397 * WCUSER_InitBackend
1398 *
1399 * Initialisation part II: creation of window.
1400 *
1401 */
1402 enum init_return WCUSER_InitBackend(struct inner_data* data)
1403 {
1404 static const WCHAR wClassName[] = {'W','i','n','e','C','o','n','s','o','l','e','C','l','a','s','s',0};
1405
1406 WNDCLASSW wndclass;
1407 CHARSETINFO ci;
1408
1409 if (!TranslateCharsetInfo((DWORD *)(INT_PTR)GetACP(), &ci, TCI_SRCCODEPAGE))
1410 return init_failed;
1411 g_uiDefaultCharset = ci.ciCharset;
1412 WINE_TRACE_(wc_font)("Code page %d => Default charset: %d\n", GetACP(), g_uiDefaultCharset);
1413
1414 data->private = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct inner_data_user));
1415 if (!data->private) return init_failed;
1416
1417 data->fnMainLoop = WCUSER_MainLoop;
1418 data->fnPosCursor = WCUSER_PosCursor;
1419 data->fnShapeCursor = WCUSER_ShapeCursor;
1420 data->fnComputePositions = WCUSER_ComputePositions;
1421 data->fnRefresh = WCUSER_Refresh;
1422 data->fnResizeScreenBuffer = WCUSER_ResizeScreenBuffer;
1423 data->fnSetTitle = WCUSER_SetTitle;
1424 data->fnSetFont = WCUSER_SetFontPmt;
1425 data->fnScroll = WCUSER_Scroll;
1426 data->fnDeleteBackend = WCUSER_DeleteBackend;
1427
1428 wndclass.style = CS_DBLCLKS;
1429 wndclass.lpfnWndProc = WCUSER_Proc;
1430 wndclass.cbClsExtra = 0;
1431 wndclass.cbWndExtra = sizeof(DWORD_PTR);
1432 wndclass.hInstance = GetModuleHandleW(NULL);
1433 wndclass.hIcon = LoadIconW(0, (LPCWSTR)IDI_WINLOGO);
1434 wndclass.hCursor = LoadCursorW(0, (LPCWSTR)IDC_ARROW);
1435 wndclass.hbrBackground = GetStockObject(BLACK_BRUSH);
1436 wndclass.lpszMenuName = NULL;
1437 wndclass.lpszClassName = wClassName;
1438
1439 RegisterClassW(&wndclass);
1440
1441 data->hWnd = CreateWindowW(wndclass.lpszClassName, NULL,
1442 WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_THICKFRAME|WS_MINIMIZEBOX|WS_HSCROLL|WS_VSCROLL,
1443 CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, 0, 0, wndclass.hInstance, data);
1444 if (!data->hWnd) return init_not_supported;
1445
1446 return init_success;
1447 }
Windows API implementation