git.oblomov.eu Git - wine/blob - programs/wineconsole/user.c

   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 }