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
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include "winecon_user.h"
  10
  11 /* mapping console colors to RGB values */
  12 COLORREF        WCUSER_ColorMap[16] =
  13 {
  14     RGB(0x00, 0x00, 0x00), RGB(0x00, 0x00, 0x80), RGB(0x00, 0x80, 0x00), RGB(0x00, 0x80, 0x80),
  15     RGB(0x80, 0x00, 0x00), RGB(0x80, 0x00, 0x80), RGB(0x80, 0x80, 0x00), RGB(0x80, 0x80, 0x80),
  16     RGB(0xC0, 0xC0, 0xC0), RGB(0x00, 0x00, 0xFF), RGB(0x00, 0xFF, 0x00), RGB(0x00, 0xFF, 0xFF),
  17     RGB(0xFF, 0x00, 0x00), RGB(0xFF, 0x00, 0xFF), RGB(0xFF, 0xFF, 0x00), RGB(0xFF, 0xFF, 0xFF),
  18 };
  19
  20 /******************************************************************
  21  *              WCUSER_FillMemDC
  22  *
  23  * Fills the Mem DC with current cells values
  24  */
  25 static void WCUSER_FillMemDC(const struct inner_data* data, int upd_tp, int upd_bm)
  26 {
  27     unsigned            i, j, k;
  28     CHAR_INFO*          cell;
  29     HFONT               hOldFont;
  30     WORD                attr;
  31     WCHAR*              line;
  32
  33     if (!(line = HeapAlloc(GetProcessHeap(), 0, data->curcfg.sb_width * sizeof(WCHAR))))
  34     {Trace(0, "OOM\n"); return;}
  35
  36     hOldFont = SelectObject(PRIVATE(data)->hMemDC, PRIVATE(data)->hFont);
  37     for (j = upd_tp; j <= upd_bm; j++)
  38     {
  39         cell = &data->cells[j * data->curcfg.sb_width];
  40         for (i = 0; i < data->curcfg.win_width; i++)
  41         {
  42             attr = cell[i].Attributes;
  43             SetBkColor(PRIVATE(data)->hMemDC,WCUSER_ColorMap[(attr>>4)&0x0F]);
  44             SetTextColor(PRIVATE(data)->hMemDC, WCUSER_ColorMap[attr&0x0F]);
  45             for (k = i; k < data->curcfg.win_width && cell[k].Attributes == attr; k++)
  46             {
  47                 line[k - i] = cell[k].Char.UnicodeChar;
  48             }
  49             TextOut(PRIVATE(data)->hMemDC, i * data->curcfg.cell_width, j * data->curcfg.cell_height,
  50                     line, k - i);
  51             i = k - 1;
  52         }
  53     }
  54     SelectObject(PRIVATE(data)->hMemDC, hOldFont);
  55     HeapFree(GetProcessHeap(), 0, line);
  56 }
  57
  58 /******************************************************************
  59  *              WCUSER_NewBitmap
  60  *
  61  * Either the font geometry or the sb geometry has changed. we need to recreate the
  62  * bitmap geometry
  63  */
  64 static void WCUSER_NewBitmap(struct inner_data* data, BOOL fill)
  65 {
  66     HDC         hDC;
  67     HBITMAP     hnew, hold;
  68
  69     if (!data->curcfg.sb_width || !data->curcfg.sb_height || !(hDC = GetDC(PRIVATE(data)->hWnd)))
  70         return;
  71     hnew = CreateCompatibleBitmap(hDC,
  72                                   data->curcfg.sb_width  * data->curcfg.cell_width,
  73                                   data->curcfg.sb_height * data->curcfg.cell_height);
  74     ReleaseDC(PRIVATE(data)->hWnd, hDC);
  75     hold = SelectObject(PRIVATE(data)->hMemDC, hnew);
  76
  77     if (PRIVATE(data)->hBitmap)
  78     {
  79         if (hold == PRIVATE(data)->hBitmap)
  80             DeleteObject(PRIVATE(data)->hBitmap);
  81         else
  82             Trace(0, "leak\n");
  83     }
  84     PRIVATE(data)->hBitmap = hnew;
  85     if (fill)
  86         WCUSER_FillMemDC(data, 0, data->curcfg.sb_height - 1);
  87 }
  88
  89 /******************************************************************
  90  *              WCUSER_ResizeScreenBuffer
  91  *
  92  *
  93  */
  94 static void WCUSER_ResizeScreenBuffer(struct inner_data* data)
  95 {
  96     WCUSER_NewBitmap(data, FALSE);
  97 }
  98
  99 /******************************************************************
 100  *              WCUSER_PosCursor
 101  *
 102  * Set a new position for the cursor
 103  */
 104 static void     WCUSER_PosCursor(const struct inner_data* data)
 105 {
 106     if (PRIVATE(data)->hWnd != GetFocus() || !data->curcfg.cursor_visible) return;
 107
 108     SetCaretPos((data->cursor.X - data->curcfg.win_pos.X) * data->curcfg.cell_width,
 109                 (data->cursor.Y - data->curcfg.win_pos.Y) * data->curcfg.cell_height);
 110     ShowCaret(PRIVATE(data)->hWnd);
 111 }
 112
 113 /******************************************************************
 114  *              WCUSER_ShapeCursor
 115  *
 116  * Sets a new shape for the cursor
 117  */
 118 void    WCUSER_ShapeCursor(struct inner_data* data, int size, int vis, BOOL force)
 119 {
 120     if (force || size != data->curcfg.cursor_size)
 121     {
 122         if (data->curcfg.cursor_visible && PRIVATE(data)->hWnd == GetFocus()) DestroyCaret();
 123         if (PRIVATE(data)->cursor_bitmap) DeleteObject(PRIVATE(data)->cursor_bitmap);
 124         PRIVATE(data)->cursor_bitmap = (HBITMAP)0;
 125         if (size != 100)
 126         {
 127             int         w16b; /* number of byets per row, aligned on word size */
 128             BYTE*       ptr;
 129             int         i, j, nbl;
 130
 131             w16b = ((data->curcfg.cell_width + 15) & ~15) / 8;
 132             ptr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, w16b * data->curcfg.cell_height);
 133             if (!ptr) {Trace(0, "OOM\n"); return;}
 134             nbl = max((data->curcfg.cell_height * size) / 100, 1);
 135             for (j = data->curcfg.cell_height - nbl; j < data->curcfg.cell_height; j++)
 136             {
 137                 for (i = 0; i < data->curcfg.cell_width; i++)
 138                 {
 139                     ptr[w16b * j + (i / 8)] |= 0x80 >> (i & 7);
 140                 }
 141             }
 142             PRIVATE(data)->cursor_bitmap = CreateBitmap(data->curcfg.cell_width,
 143                                                data->curcfg.cell_height, 1, 1, ptr);
 144             HeapFree(GetProcessHeap(), 0, ptr);
 145         }
 146         data->curcfg.cursor_size = size;
 147         data->curcfg.cursor_visible = -1;
 148     }
 149
 150     vis = (vis) ? TRUE : FALSE;
 151     if (force || vis != data->curcfg.cursor_visible)
 152     {
 153         data->curcfg.cursor_visible = vis;
 154         if (PRIVATE(data)->hWnd == GetFocus())
 155         {
 156             if (vis)
 157             {
 158                 CreateCaret(PRIVATE(data)->hWnd, PRIVATE(data)->cursor_bitmap,
 159                             data->curcfg.cell_width, data->curcfg.cell_height);
 160                 WCUSER_PosCursor(data);
 161             }
 162             else
 163             {
 164                 DestroyCaret();
 165             }
 166         }
 167     }
 168 }
 169
 170 /******************************************************************
 171  *              INECON_ComputePositions
 172  *
 173  * Recomputes all the components (mainly scroll bars) positions
 174  */
 175 void    WCUSER_ComputePositions(struct inner_data* data)
 176 {
 177     RECT                r;
 178     int                 dx, dy;
 179
 180     /* compute window size from desired client size */
 181     r.left = r.top = 0;
 182     r.right = data->curcfg.win_width * data->curcfg.cell_width;
 183     r.bottom = data->curcfg.win_height * data->curcfg.cell_height;
 184
 185     if (IsRectEmpty(&r))
 186     {
 187         ShowWindow(PRIVATE(data)->hWnd, SW_HIDE);
 188         return;
 189     }
 190
 191     AdjustWindowRect(&r, GetWindowLong(PRIVATE(data)->hWnd, GWL_STYLE), FALSE);
 192
 193     dx = dy = 0;
 194     if (data->curcfg.sb_width > data->curcfg.win_width)
 195     {
 196         dy = GetSystemMetrics(SM_CYHSCROLL);
 197         SetScrollRange(PRIVATE(data)->hWnd, SB_HORZ, 0,
 198                        data->curcfg.sb_width - data->curcfg.win_width, FALSE);
 199         SetScrollPos(PRIVATE(data)->hWnd, SB_HORZ, 0, FALSE); /* FIXME */
 200         ShowScrollBar(PRIVATE(data)->hWnd, SB_HORZ, TRUE);
 201     }
 202     else
 203     {
 204         ShowScrollBar(PRIVATE(data)->hWnd, SB_HORZ, FALSE);
 205     }
 206
 207     if (data->curcfg.sb_height > data->curcfg.win_height)
 208     {
 209         dx = GetSystemMetrics(SM_CXVSCROLL);
 210         SetScrollRange(PRIVATE(data)->hWnd, SB_VERT, 0,
 211                        data->curcfg.sb_height - data->curcfg.win_height, FALSE);
 212         SetScrollPos(PRIVATE(data)->hWnd, SB_VERT, 0, FALSE); /* FIXME */
 213         ShowScrollBar(PRIVATE(data)->hWnd, SB_VERT, TRUE);
 214     }
 215     else
 216     {
 217         ShowScrollBar(PRIVATE(data)->hWnd, SB_VERT, FALSE);
 218     }
 219
 220     SetWindowPos(PRIVATE(data)->hWnd, 0, 0, 0, r.right - r.left + dx, r.bottom - r.top + dy,
 221                  SWP_NOMOVE|SWP_NOZORDER|SWP_SHOWWINDOW);
 222     WCUSER_ShapeCursor(data, data->curcfg.cursor_size, data->curcfg.cursor_visible, TRUE);
 223     WCUSER_PosCursor(data);
 224 }
 225
 226 /******************************************************************
 227  *              WCUSER_SetTitle
 228  *
 229  * Sets the title to the wine console
 230  */
 231 static void     WCUSER_SetTitle(const struct inner_data* data)
 232 {
 233     WCHAR       buffer[256];
 234
 235     if (WINECON_GetConsoleTitle(data->hConIn, buffer, sizeof(buffer)))
 236         SetWindowText(PRIVATE(data)->hWnd, buffer);
 237 }
 238
 239 /******************************************************************
 240  *              FontEqual
 241  *
 242  *
 243  */
 244 BOOL WCUSER_AreFontsEqual(const struct config_data* config, const LOGFONT* lf)
 245 {
 246     return lf->lfHeight == config->cell_height &&
 247         lf->lfWidth  == config->cell_width &&
 248         lf->lfWeight == config->font_weight &&
 249         !lf->lfItalic && !lf->lfUnderline && !lf->lfStrikeOut &&
 250         !lstrcmpW(lf->lfFaceName, config->face_name);
 251 }
 252
 253 /******************************************************************
 254  *              CopyFont
 255  *
 256  *
 257  */
 258 void WCUSER_CopyFont(struct config_data* config, const LOGFONT* lf)
 259 {
 260     config->cell_width  = lf->lfWidth;
 261     config->cell_height = lf->lfHeight;
 262     config->font_weight  = lf->lfWeight;
 263     lstrcpyW(config->face_name, lf->lfFaceName);
 264 }
 265
 266 /******************************************************************
 267  *              WCUSER_InitFont
 268  *
 269  * create a hFont from the settings saved in registry...
 270  * (called on init, assuming no font has been created before)
 271  */
 272 BOOL    WCUSER_InitFont(struct inner_data* data)
 273 {
 274     LOGFONT lf;
 275
 276     lf.lfHeight        = -data->curcfg.cell_height;
 277     lf.lfWidth         = data->curcfg.cell_width;
 278     lf.lfEscapement    = 0;
 279     lf.lfOrientation   = 0;
 280     lf.lfWeight        = data->curcfg.font_weight;
 281     lf.lfItalic        = FALSE;
 282     lf.lfUnderline     = FALSE;
 283     lf.lfStrikeOut     = FALSE;
 284     lf.lfCharSet       = DEFAULT_CHARSET;
 285     lf.lfOutPrecision  = OUT_DEFAULT_PRECIS;
 286     lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
 287     lf.lfQuality       = DEFAULT_QUALITY;
 288     lf.lfPitchAndFamily = FIXED_PITCH | FF_DONTCARE;
 289     lstrcpy(lf.lfFaceName, data->curcfg.face_name);
 290     PRIVATE(data)->hFont = CreateFontIndirect(&lf);
 291     if (!PRIVATE(data)->hFont) return FALSE;
 292
 293     WCUSER_ComputePositions(data);
 294     WCUSER_NewBitmap(data, TRUE);
 295     InvalidateRect(PRIVATE(data)->hWnd, NULL, FALSE);
 296     UpdateWindow(PRIVATE(data)->hWnd);
 297     return TRUE;
 298 }
 299
 300 /******************************************************************
 301  *              WCUSER_SetFont
 302  *
 303  * sets logfont as the new font for the console
 304  */
 305 BOOL    WCUSER_SetFont(struct inner_data* data, const LOGFONT* logfont)
 306 {
 307     if (WCUSER_AreFontsEqual(&data->curcfg, logfont)) return TRUE;
 308     if (PRIVATE(data)->hFont) DeleteObject(PRIVATE(data)->hFont);
 309     PRIVATE(data)->hFont = CreateFontIndirect(logfont);
 310     if (!PRIVATE(data)->hFont) {Trace(0, "wrong font\n");return FALSE;}
 311     WCUSER_CopyFont(&data->curcfg, logfont);
 312
 313     WCUSER_ComputePositions(data);
 314     WCUSER_NewBitmap(data, TRUE);
 315     InvalidateRect(PRIVATE(data)->hWnd, NULL, FALSE);
 316     UpdateWindow(PRIVATE(data)->hWnd);
 317     return TRUE;
 318 }
 319
 320 /******************************************************************
 321  *              WCUSER_GetCell
 322  *
 323  * Get a cell from the a relative coordinate in window (takes into
 324  * account the scrolling)
 325  */
 326 static COORD    WCUSER_GetCell(const struct inner_data* data, LPARAM lParam)
 327 {
 328     COORD       c;
 329
 330     c.X = data->curcfg.win_pos.X + (short)LOWORD(lParam) / data->curcfg.cell_width;
 331     c.Y = data->curcfg.win_pos.Y + (short)HIWORD(lParam) / data->curcfg.cell_height;
 332
 333     return c;
 334 }
 335
 336 /******************************************************************
 337  *              WCUSER_GetSelectionRect
 338  *
 339  * Get the selection rectangle
 340  */
 341 static void     WCUSER_GetSelectionRect(const struct inner_data* data, LPRECT r)
 342 {
 343     r->left   = (min(PRIVATE(data)->selectPt1.X, PRIVATE(data)->selectPt2.X)    ) * data->curcfg.cell_width;
 344     r->top    = (min(PRIVATE(data)->selectPt1.Y, PRIVATE(data)->selectPt2.Y)    ) * data->curcfg.cell_height;
 345     r->right  = (max(PRIVATE(data)->selectPt1.X, PRIVATE(data)->selectPt2.X) + 1) * data->curcfg.cell_width;
 346     r->bottom = (max(PRIVATE(data)->selectPt1.Y, PRIVATE(data)->selectPt2.Y) + 1) * data->curcfg.cell_height;
 347 }
 348
 349 /******************************************************************
 350  *              WCUSER_SetSelection
 351  *
 352  *
 353  */
 354 static void     WCUSER_SetSelection(const struct inner_data* data, HDC hRefDC)
 355 {
 356     HDC         hDC;
 357     RECT        r;
 358
 359     WCUSER_GetSelectionRect(data, &r);
 360     hDC = hRefDC ? hRefDC : GetDC(PRIVATE(data)->hWnd);
 361     if (hDC)
 362     {
 363         if (PRIVATE(data)->hWnd == GetFocus() && data->curcfg.cursor_visible)
 364             HideCaret(PRIVATE(data)->hWnd);
 365         InvertRect(hDC, &r);
 366         if (hDC != hRefDC)
 367             ReleaseDC(PRIVATE(data)->hWnd, hDC);
 368         if (PRIVATE(data)->hWnd == GetFocus() && data->curcfg.cursor_visible)
 369             ShowCaret(PRIVATE(data)->hWnd);
 370     }
 371 }
 372
 373 /******************************************************************
 374  *              WCUSER_MoveSelection
 375  *
 376  *
 377  */
 378 static void     WCUSER_MoveSelection(struct inner_data* data, COORD dst, BOOL final)
 379 {
 380     RECT        r;
 381     HDC         hDC;
 382
 383     WCUSER_GetSelectionRect(data, &r);
 384     hDC = GetDC(PRIVATE(data)->hWnd);
 385     if (hDC)
 386     {
 387         if (PRIVATE(data)->hWnd == GetFocus() && data->curcfg.cursor_visible)
 388             HideCaret(PRIVATE(data)->hWnd);
 389         InvertRect(hDC, &r);
 390     }
 391     PRIVATE(data)->selectPt2 = dst;
 392     if (hDC)
 393     {
 394         WCUSER_GetSelectionRect(data, &r);
 395         InvertRect(hDC, &r);
 396         ReleaseDC(PRIVATE(data)->hWnd, hDC);
 397         if (PRIVATE(data)->hWnd == GetFocus() && data->curcfg.cursor_visible)
 398             ShowCaret(PRIVATE(data)->hWnd);
 399     }
 400     if (final)
 401     {
 402         ReleaseCapture();
 403         PRIVATE(data)->hasSelection = TRUE;
 404     }
 405 }
 406
 407 /******************************************************************
 408  *              WCUSER_CopySelectionToClipboard
 409  *
 410  * Copies the current selection into the clipboard
 411  */
 412 static void     WCUSER_CopySelectionToClipboard(const struct inner_data* data)
 413 {
 414     HANDLE      hMem;
 415     LPWSTR      p;
 416     unsigned    w, h;
 417
 418     w = abs(PRIVATE(data)->selectPt1.X - PRIVATE(data)->selectPt2.X) + 2;
 419     h = abs(PRIVATE(data)->selectPt1.Y - PRIVATE(data)->selectPt2.Y) + 1;
 420
 421     if (!OpenClipboard(PRIVATE(data)->hWnd)) return;
 422     EmptyClipboard();
 423
 424     hMem = GlobalAlloc(GMEM_MOVEABLE, (w * h - 1) * sizeof(WCHAR));
 425     if (hMem && (p = GlobalLock(hMem)))
 426     {
 427         COORD   c;
 428         int     y;
 429
 430         c.X = data->curcfg.win_pos.X + min(PRIVATE(data)->selectPt1.X, PRIVATE(data)->selectPt2.X);
 431         c.Y = data->curcfg.win_pos.Y + min(PRIVATE(data)->selectPt1.Y, PRIVATE(data)->selectPt2.Y);
 432
 433         for (y = 0; y < h; y++, c.Y++)
 434         {
 435             ReadConsoleOutputCharacter(data->hConOut, &p[y * w], w - 1, c, NULL);
 436             if (y < h - 1) p[y * w + w - 1] = '\n';
 437         }
 438         GlobalUnlock(hMem);
 439         SetClipboardData(CF_UNICODETEXT, hMem);
 440     }
 441     CloseClipboard();
 442 }
 443
 444 /******************************************************************
 445  *              WCUSER_PasteFromClipboard
 446  *
 447  *
 448  */
 449 static void     WCUSER_PasteFromClipboard(struct inner_data* data)
 450 {
 451     HANDLE      h;
 452     WCHAR*      ptr;
 453
 454     if (!OpenClipboard(PRIVATE(data)->hWnd)) return;
 455     h = GetClipboardData(CF_UNICODETEXT);
 456     if (h && (ptr = GlobalLock(h)))
 457     {
 458         int             i, len = GlobalSize(h) / sizeof(WCHAR);
 459         INPUT_RECORD    ir[2];
 460         DWORD           n;
 461         SHORT           sh;
 462
 463         ir[0].EventType = KEY_EVENT;
 464         ir[0].Event.KeyEvent.wRepeatCount = 0;
 465         ir[0].Event.KeyEvent.dwControlKeyState = 0;
 466         ir[0].Event.KeyEvent.bKeyDown = TRUE;
 467
 468         /* generate the corresponding input records */
 469         for (i = 0; i < len; i++)
 470         {
 471             /* FIXME: the modifying keys are not generated (shift, ctrl...) */
 472             sh = VkKeyScan(ptr[i]);
 473             ir[0].Event.KeyEvent.wVirtualKeyCode = LOBYTE(sh);
 474             ir[0].Event.KeyEvent.wVirtualScanCode = MapVirtualKey(LOBYTE(sh), 0);
 475             ir[0].Event.KeyEvent.uChar.UnicodeChar = ptr[i];
 476
 477             ir[1] = ir[0];
 478             ir[1].Event.KeyEvent.bKeyDown = FALSE;
 479
 480             WriteConsoleInput(data->hConIn, ir, 2, &n);
 481         }
 482         GlobalUnlock(h);
 483     }
 484     CloseClipboard();
 485 }
 486
 487 /******************************************************************
 488  *              Refresh
 489  *
 490  *
 491  */
 492 static void WCUSER_Refresh(const struct inner_data* data, int tp, int bm)
 493 {
 494     if (data->curcfg.win_pos.Y <= bm && data->curcfg.win_pos.Y + data->curcfg.win_height >= tp)
 495     {
 496         RECT    r;
 497
 498         r.left   = 0;
 499         r.right  = data->curcfg.win_width * data->curcfg.cell_width;
 500         r.top    = (tp - data->curcfg.win_pos.Y) * data->curcfg.cell_height;
 501         r.bottom = (bm - data->curcfg.win_pos.Y + 1) * data->curcfg.cell_height;
 502         InvalidateRect(PRIVATE(data)->hWnd, &r, FALSE);
 503         WCUSER_FillMemDC(data, tp, bm);
 504         UpdateWindow(PRIVATE(data)->hWnd);
 505     }
 506 }
 507
 508 /******************************************************************
 509  *              WCUSER_Paint
 510  *
 511  *
 512  */
 513 static void     WCUSER_Paint(const struct inner_data* data)
 514 {
 515     PAINTSTRUCT         ps;
 516
 517     BeginPaint(PRIVATE(data)->hWnd, &ps);
 518     BitBlt(ps.hdc, 0, 0,
 519            data->curcfg.win_width * data->curcfg.cell_width,
 520            data->curcfg.win_height * data->curcfg.cell_height,
 521            PRIVATE(data)->hMemDC,
 522            data->curcfg.win_pos.X * data->curcfg.cell_width,
 523            data->curcfg.win_pos.Y * data->curcfg.cell_height,
 524            SRCCOPY);
 525     if (PRIVATE(data)->hasSelection)
 526         WCUSER_SetSelection(data, ps.hdc);
 527     EndPaint(PRIVATE(data)->hWnd, &ps);
 528 }
 529
 530 /******************************************************************
 531  *              WCUSER_Scroll
 532  *
 533  *
 534  */
 535 static void WCUSER_Scroll(struct inner_data* data, int pos, BOOL horz)
 536 {
 537     if (horz)
 538     {
 539         SetScrollPos(PRIVATE(data)->hWnd, SB_HORZ, pos, TRUE);
 540         data->curcfg.win_pos.X = pos;
 541         InvalidateRect(PRIVATE(data)->hWnd, NULL, FALSE);
 542     }
 543     else
 544     {
 545         SetScrollPos(PRIVATE(data)->hWnd, SB_VERT, pos, TRUE);
 546         data->curcfg.win_pos.Y = pos;
 547     }
 548     InvalidateRect(PRIVATE(data)->hWnd, NULL, FALSE);
 549 }
 550
 551 struct font_chooser {
 552     struct inner_data*  data;
 553     int                 done;
 554 };
 555
 556 /******************************************************************
 557  *              WCUSER_ValidateFontMetric
 558  *
 559  * Returns true if the font described in tm is usable as a font for the renderer
 560  */
 561 BOOL    WCUSER_ValidateFontMetric(const struct inner_data* data, const TEXTMETRIC* tm)
 562 {
 563     return tm->tmMaxCharWidth * data->curcfg.win_width < GetSystemMetrics(SM_CXSCREEN) &&
 564         tm->tmHeight * data->curcfg.win_height < GetSystemMetrics(SM_CYSCREEN) &&
 565         !tm->tmItalic && !tm->tmUnderlined && !tm->tmStruckOut;
 566 }
 567
 568 /******************************************************************
 569  *              WCUSER_ValidateFont
 570  *
 571  * Returns true if the font family described in lf is usable as a font for the renderer
 572  */
 573 BOOL    WCUSER_ValidateFont(const struct inner_data* data, const LOGFONT* lf)
 574 {
 575     return (lf->lfPitchAndFamily & 3) == FIXED_PITCH &&
 576         (lf->lfPitchAndFamily & 0xF0) == FF_MODERN &&
 577         lf->lfCharSet != SYMBOL_CHARSET;
 578 }
 579
 580 /******************************************************************
 581  *              get_first_font_enum_2
 582  *              get_first_font_enum
 583  *
 584  * Helper functions to get a decent font for the renderer
 585  */
 586 static int CALLBACK get_first_font_enum_2(const LOGFONT* lf, const TEXTMETRIC* tm,
 587                                           DWORD FontType, LPARAM lParam)
 588 {
 589     struct font_chooser*        fc = (struct font_chooser*)lParam;
 590
 591     if (WCUSER_ValidateFontMetric(fc->data, tm))
 592     {
 593         WCUSER_SetFont(fc->data, lf);
 594         fc->done = 1;
 595         return 0;
 596     }
 597     return 1;
 598 }
 599
 600 static int CALLBACK get_first_font_enum(const LOGFONT* lf, const TEXTMETRIC* tm,
 601                                         DWORD FontType, LPARAM lParam)
 602 {
 603     struct font_chooser*        fc = (struct font_chooser*)lParam;
 604
 605     if (WCUSER_ValidateFont(fc->data, lf))
 606     {
 607         EnumFontFamilies(PRIVATE(fc->data)->hMemDC, lf->lfFaceName, get_first_font_enum_2, lParam);
 608         return !fc->done; /* we just need the first matching one... */
 609     }
 610     return 1;
 611 }
 612
 613 /******************************************************************
 614  *              WCUSER_FillMenu
 615  *
 616  *
 617  */
 618 static BOOL WCUSER_FillMenu(HMENU hMenu, BOOL sep)
 619 {
 620     HMENU               hSubMenu;
 621     HINSTANCE           hInstance = GetModuleHandle(NULL);
 622     WCHAR               buff[256];
 623
 624     if (!hMenu) return FALSE;
 625
 626     /* FIXME: error handling & memory cleanup */
 627     hSubMenu = CreateMenu();
 628     if (!hSubMenu) return FALSE;
 629
 630     LoadString(hInstance, IDS_MARK, buff, sizeof(buff) / sizeof(WCHAR));
 631     InsertMenu(hSubMenu, -1, MF_BYPOSITION|MF_STRING, IDS_MARK, buff);
 632     LoadString(hInstance, IDS_COPY, buff, sizeof(buff) / sizeof(WCHAR));
 633     InsertMenu(hSubMenu, -1, MF_BYPOSITION|MF_STRING, IDS_COPY, buff);
 634     LoadString(hInstance, IDS_PASTE, buff, sizeof(buff) / sizeof(WCHAR));
 635     InsertMenu(hSubMenu, -1, MF_BYPOSITION|MF_STRING, IDS_PASTE, buff);
 636     LoadString(hInstance, IDS_SELECTALL, buff, sizeof(buff) / sizeof(WCHAR));
 637     InsertMenu(hSubMenu, -1, MF_BYPOSITION|MF_STRING, IDS_SELECTALL, buff);
 638     LoadString(hInstance, IDS_SCROLL, buff, sizeof(buff) / sizeof(WCHAR));
 639     InsertMenu(hSubMenu, -1, MF_BYPOSITION|MF_STRING, IDS_SCROLL, buff);
 640     LoadString(hInstance, IDS_SEARCH, buff, sizeof(buff) / sizeof(WCHAR));
 641     InsertMenu(hSubMenu, -1, MF_BYPOSITION|MF_STRING, IDS_SEARCH, buff);
 642
 643     if (sep) InsertMenu(hMenu, -1, MF_BYPOSITION|MF_SEPARATOR, 0, NULL);
 644     LoadString(hInstance, IDS_EDIT, buff, sizeof(buff) / sizeof(WCHAR));
 645     InsertMenu(hMenu, -1, MF_BYPOSITION|MF_STRING|MF_POPUP, (UINT_PTR)hSubMenu, buff);
 646     LoadString(hInstance, IDS_DEFAULT, buff, sizeof(buff) / sizeof(WCHAR));
 647     InsertMenu(hMenu, -1, MF_BYPOSITION|MF_STRING, IDS_DEFAULT, buff);
 648     LoadString(hInstance, IDS_PROPERTY, buff, sizeof(buff) / sizeof(WCHAR));
 649     InsertMenu(hMenu, -1, MF_BYPOSITION|MF_STRING, IDS_PROPERTY, buff);
 650
 651     return TRUE;
 652 }
 653
 654 /******************************************************************
 655  *              WCUSER_Create
 656  *
 657  * Creates the window for the rendering
 658  */
 659 static LRESULT WCUSER_Create(HWND hWnd, LPCREATESTRUCT lpcs)
 660 {
 661     struct inner_data*  data;
 662     HMENU               hSysMenu;
 663
 664     data = lpcs->lpCreateParams;
 665     SetWindowLong(hWnd, 0L, (DWORD)data);
 666     PRIVATE(data)->hWnd = hWnd;
 667
 668     data->curcfg.cursor_size = 101; /* invalid value, will trigger a complete cleanup */
 669
 670     hSysMenu = GetSystemMenu(hWnd, FALSE);
 671     if (!hSysMenu) return 0;
 672     PRIVATE(data)->hPopMenu = CreatePopupMenu();
 673     if (!PRIVATE(data)->hPopMenu) return 0;
 674
 675     WCUSER_FillMenu(hSysMenu, TRUE);
 676     WCUSER_FillMenu(PRIVATE(data)->hPopMenu, FALSE);
 677
 678     PRIVATE(data)->hMemDC = CreateCompatibleDC(0);
 679     if (!PRIVATE(data)->hMemDC) {Trace(0, "no mem dc\n");return 0;}
 680
 681     return 0;
 682 }
 683
 684 /******************************************************************
 685  *              WCUSER_SetMenuDetails
 686  *
 687  * Grays / ungrays the menu items according to their state
 688  */
 689 static void     WCUSER_SetMenuDetails(const struct inner_data* data)
 690 {
 691     HMENU               hMenu = GetSystemMenu(PRIVATE(data)->hWnd, FALSE);
 692
 693     if (!hMenu) {Trace(0, "Issue in getting menu bits\n");return;}
 694
 695     /* FIXME: set the various menu items to their state (if known) */
 696     EnableMenuItem(hMenu, IDS_DEFAULT, MF_BYCOMMAND|MF_GRAYED);
 697
 698     EnableMenuItem(hMenu, IDS_MARK, MF_BYCOMMAND|MF_GRAYED);
 699     EnableMenuItem(hMenu, IDS_COPY, MF_BYCOMMAND|(PRIVATE(data)->hasSelection ? MF_ENABLED : MF_GRAYED));
 700     EnableMenuItem(hMenu, IDS_PASTE,
 701                    MF_BYCOMMAND|(IsClipboardFormatAvailable(CF_UNICODETEXT)
 702                                  ? MF_ENABLED : MF_GRAYED));
 703     /* Select all: always active */
 704     EnableMenuItem(hMenu, IDS_SCROLL, MF_BYCOMMAND|MF_GRAYED);
 705     EnableMenuItem(hMenu, IDS_SEARCH, MF_BYCOMMAND|MF_GRAYED);
 706 }
 707
 708 /******************************************************************
 709  *              WCUSER_GenerateKeyInputRecord
 710  *
 711  * generates input_record from windows WM_KEYUP/WM_KEYDOWN messages
 712  */
 713 static void    WCUSER_GenerateKeyInputRecord(struct inner_data* data, BOOL down,
 714                                              WPARAM wParam, LPARAM lParam, BOOL sys)
 715 {
 716     INPUT_RECORD        ir;
 717     DWORD               n;
 718     WCHAR               buf[2];
 719     BYTE                keyState[256];
 720     static      WCHAR   last; /* keep last char seen as feed for key up message */
 721
 722     ir.EventType = KEY_EVENT;
 723     ir.Event.KeyEvent.bKeyDown = down;
 724     ir.Event.KeyEvent.wRepeatCount = LOWORD(lParam);
 725     ir.Event.KeyEvent.wVirtualKeyCode = wParam;
 726
 727     ir.Event.KeyEvent.wVirtualScanCode = HIWORD(lParam) & 0xFF;
 728     GetKeyboardState(keyState);
 729
 730     ir.Event.KeyEvent.uChar.UnicodeChar = 0;
 731     ir.Event.KeyEvent.dwControlKeyState = 0;
 732     if (lParam & (1L << 24))            ir.Event.KeyEvent.dwControlKeyState |= ENHANCED_KEY;
 733     if (keyState[VK_SHIFT]    & 0x80)   ir.Event.KeyEvent.dwControlKeyState |= SHIFT_PRESSED;
 734     if (keyState[VK_CONTROL]  & 0x80)   ir.Event.KeyEvent.dwControlKeyState |= LEFT_CTRL_PRESSED; /* FIXME: gotta choose one */
 735     if (keyState[VK_LCONTROL] & 0x80)   ir.Event.KeyEvent.dwControlKeyState |= LEFT_CTRL_PRESSED;
 736     if (keyState[VK_RCONTROL] & 0x80)   ir.Event.KeyEvent.dwControlKeyState |= RIGHT_CTRL_PRESSED;
 737     if (sys)                            ir.Event.KeyEvent.dwControlKeyState |= LEFT_ALT_PRESSED; /* FIXME: gotta choose one */
 738     if (keyState[VK_LMENU]    & 0x80)   ir.Event.KeyEvent.dwControlKeyState |= LEFT_ALT_PRESSED;
 739     if (keyState[VK_RMENU]    & 0x80)   ir.Event.KeyEvent.dwControlKeyState |= RIGHT_ALT_PRESSED;
 740     if (keyState[VK_CAPITAL]  & 0x01)   ir.Event.KeyEvent.dwControlKeyState |= CAPSLOCK_ON;
 741     if (keyState[VK_NUMLOCK]  & 0x01)   ir.Event.KeyEvent.dwControlKeyState |= NUMLOCK_ON;
 742     if (keyState[VK_SCROLL]   & 0x01)   ir.Event.KeyEvent.dwControlKeyState |= SCROLLLOCK_ON;
 743
 744     if (PRIVATE(data)->hasSelection && ir.Event.KeyEvent.dwControlKeyState == 0 &&
 745         ir.Event.KeyEvent.wVirtualKeyCode == VK_RETURN)
 746     {
 747         PRIVATE(data)->hasSelection = FALSE;
 748         WCUSER_SetSelection(data, 0);
 749         WCUSER_CopySelectionToClipboard(data);
 750         return;
 751     }
 752
 753     if (!(ir.Event.KeyEvent.dwControlKeyState & ENHANCED_KEY))
 754     {
 755         if (down)
 756         {
 757             switch (ToUnicode(wParam, HIWORD(lParam), keyState, buf, 2, 0))
 758             {
 759             case 2:
 760                 /* FIXME... should generate two events... */
 761                 /* fall thru */
 762             case 1:
 763                 last = buf[0];
 764                 break;
 765             default:
 766                 last = 0;
 767                 break;
 768             }
 769         }
 770         ir.Event.KeyEvent.uChar.UnicodeChar = last; /* FIXME HACKY... and buggy 'coz it should be a stack, not a single value */
 771         if (!down) last = 0;
 772     }
 773
 774     WriteConsoleInput(data->hConIn, &ir, 1, &n);
 775 }
 776
 777 /******************************************************************
 778  *              WCUSER_Proc
 779  *
 780  *
 781  */
 782 static LRESULT CALLBACK WCUSER_Proc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 783 {
 784     struct inner_data*  data = (struct inner_data*)GetWindowLong(hWnd, 0);
 785
 786     switch (uMsg)
 787     {
 788     case WM_CREATE:
 789         return WCUSER_Create(hWnd, (LPCREATESTRUCT)lParam);
 790     case WM_DESTROY:
 791         PRIVATE(data)->hWnd = 0;
 792         PostQuitMessage(0);
 793         break;
 794     case WM_PAINT:
 795         WCUSER_Paint(data);
 796         break;
 797     case WM_KEYDOWN:
 798     case WM_KEYUP:
 799         WCUSER_GenerateKeyInputRecord(data, uMsg == WM_KEYDOWN, wParam, lParam, FALSE);
 800         break;
 801     case WM_SYSKEYDOWN:
 802     case WM_SYSKEYUP:
 803         WCUSER_GenerateKeyInputRecord(data, uMsg == WM_SYSKEYDOWN, wParam, lParam, TRUE);
 804         break;
 805     case WM_LBUTTONDOWN:
 806         /* EPP if (wParam != MK_LBUTTON) */
 807         if (PRIVATE(data)->hasSelection)
 808         {
 809             PRIVATE(data)->hasSelection = FALSE;
 810         }
 811         else
 812         {
 813             PRIVATE(data)->selectPt1 = PRIVATE(data)->selectPt2 = WCUSER_GetCell(data, lParam);
 814             SetCapture(PRIVATE(data)->hWnd);
 815         }
 816         WCUSER_SetSelection(data, 0);
 817         break;
 818     case WM_MOUSEMOVE:
 819         /* EPP if (wParam != MK_LBUTTON) */
 820         if (GetCapture() == PRIVATE(data)->hWnd)
 821         {
 822             WCUSER_MoveSelection(data, WCUSER_GetCell(data, lParam), FALSE);
 823         }
 824         break;
 825     case WM_LBUTTONUP:
 826         /* EPP if (wParam != MK_LBUTTON) */
 827         if (GetCapture() == PRIVATE(data)->hWnd)
 828         {
 829             WCUSER_MoveSelection(data, WCUSER_GetCell(data, lParam), TRUE);
 830         }
 831         break;
 832     case WM_SETFOCUS:
 833         if (data->curcfg.cursor_visible)
 834         {
 835             CreateCaret(PRIVATE(data)->hWnd, PRIVATE(data)->cursor_bitmap,
 836                         data->curcfg.cell_width, data->curcfg.cell_height);
 837             WCUSER_PosCursor(data);
 838         }
 839         break;
 840     case WM_KILLFOCUS:
 841         if (data->curcfg.cursor_visible)
 842             DestroyCaret();
 843         break;
 844     case WM_HSCROLL:
 845         {
 846             int pos = data->curcfg.win_pos.X;
 847
 848             switch (LOWORD(wParam))
 849             {
 850             case SB_PAGEUP:     pos -= 8;               break;
 851             case SB_PAGEDOWN:   pos += 8;               break;
 852             case SB_LINEUP:     pos--;                  break;
 853             case SB_LINEDOWN:   pos++;                  break;
 854             case SB_THUMBTRACK: pos = HIWORD(wParam);   break;
 855             default:                                    break;
 856             }
 857             if (pos < 0) pos = 0;
 858             if (pos > data->curcfg.sb_width - data->curcfg.win_width)
 859                 pos = data->curcfg.sb_width - data->curcfg.win_width;
 860             if (pos != data->curcfg.win_pos.X)
 861             {
 862                 ScrollWindow(hWnd, (data->curcfg.win_pos.X - pos) * data->curcfg.cell_width, 0,
 863                              NULL, NULL);
 864                 data->curcfg.win_pos.X = pos;
 865                 SetScrollPos(hWnd, SB_HORZ, pos, TRUE);
 866                 UpdateWindow(hWnd);
 867                 WCUSER_PosCursor(data);
 868                 WINECON_NotifyWindowChange(data);
 869             }
 870         }
 871         break;
 872     case WM_VSCROLL:
 873         {
 874             int pos = data->curcfg.win_pos.Y;
 875
 876             switch (LOWORD(wParam))
 877             {
 878             case SB_PAGEUP:     pos -= 8;               break;
 879             case SB_PAGEDOWN:   pos += 8;               break;
 880             case SB_LINEUP:     pos--;                  break;
 881             case SB_LINEDOWN:   pos++;                  break;
 882             case SB_THUMBTRACK: pos = HIWORD(wParam);   break;
 883             default:                                    break;
 884             }
 885             if (pos < 0) pos = 0;
 886             if (pos > data->curcfg.sb_height - data->curcfg.win_height)
 887                 pos = data->curcfg.sb_height - data->curcfg.win_height;
 888             if (pos != data->curcfg.win_pos.Y)
 889             {
 890                 ScrollWindow(hWnd, 0, (data->curcfg.win_pos.Y - pos) * data->curcfg.cell_height,
 891                              NULL, NULL);
 892                 data->curcfg.win_pos.Y = pos;
 893                 SetScrollPos(hWnd, SB_VERT, pos, TRUE);
 894                 UpdateWindow(hWnd);
 895                 WCUSER_PosCursor(data);
 896                 WINECON_NotifyWindowChange(data);
 897             }
 898         }
 899         break;
 900     case WM_SYSCOMMAND:
 901         switch (wParam)
 902         {
 903         case IDS_DEFAULT:
 904             WCUSER_GetProperties(data, FALSE);
 905             break;
 906         case IDS_PROPERTY:
 907             WCUSER_GetProperties(data, TRUE);
 908             break;
 909         default:
 910             return DefWindowProc(hWnd, uMsg, wParam, lParam);
 911         }
 912         break;
 913     case WM_RBUTTONDOWN:
 914         if ((wParam & (MK_CONTROL|MK_SHIFT)) == data->curcfg.menu_mask)
 915         {
 916             RECT        r;
 917
 918             GetWindowRect(hWnd, &r);
 919             TrackPopupMenu(PRIVATE(data)->hPopMenu, TPM_LEFTALIGN|TPM_TOPALIGN,
 920                            r.left + LOWORD(lParam), r.top + HIWORD(lParam), 0, hWnd, NULL);
 921         }
 922         break;
 923     case WM_COMMAND:
 924         switch (wParam)
 925         {
 926         case IDS_DEFAULT:
 927             WCUSER_GetProperties(data, FALSE);
 928             break;
 929         case IDS_PROPERTY:
 930             WCUSER_GetProperties(data, TRUE);
 931             break;
 932         case IDS_MARK:
 933             goto niy;
 934         case IDS_COPY:
 935             PRIVATE(data)->hasSelection = FALSE;
 936             WCUSER_SetSelection(data, 0);
 937             WCUSER_CopySelectionToClipboard(data);
 938             break;
 939         case IDS_PASTE:
 940             WCUSER_PasteFromClipboard(data);
 941             break;
 942         case IDS_SELECTALL:
 943             PRIVATE(data)->selectPt1.X = PRIVATE(data)->selectPt1.Y = 0;
 944             PRIVATE(data)->selectPt2.X = (data->curcfg.sb_width - 1) * data->curcfg.cell_width;
 945             PRIVATE(data)->selectPt2.Y = (data->curcfg.sb_height - 1) * data->curcfg.cell_height;
 946             WCUSER_SetSelection(data, 0);
 947             PRIVATE(data)->hasSelection = TRUE;
 948             break;
 949         case IDS_SCROLL:
 950         case IDS_SEARCH:
 951         niy:
 952             Trace(0, "unhandled yet command: %x\n", wParam);
 953             break;
 954         default:
 955             return DefWindowProc(hWnd, uMsg, wParam, lParam);
 956         }
 957         break;
 958     case WM_INITMENUPOPUP:
 959         if (!HIWORD(lParam))    return DefWindowProc(hWnd, uMsg, wParam, lParam);
 960         WCUSER_SetMenuDetails(data);
 961         break;
 962     default:
 963         return DefWindowProc(hWnd, uMsg, wParam, lParam);
 964     }
 965     return 0;
 966 }
 967
 968 /******************************************************************
 969  *              WCUSER_DeleteBackend
 970  *
 971  *
 972  */
 973 void WCUSER_DeleteBackend(struct inner_data* data)
 974 {
 975     if (!PRIVATE(data)) return;
 976     if (PRIVATE(data)->hWnd)            DestroyWindow(PRIVATE(data)->hWnd);
 977     if (PRIVATE(data)->hFont)           DeleteObject(PRIVATE(data)->hFont);
 978     if (PRIVATE(data)->cursor_bitmap)   DeleteObject(PRIVATE(data)->cursor_bitmap);
 979     if (PRIVATE(data)->hMemDC)          DeleteDC(PRIVATE(data)->hMemDC);
 980     if (PRIVATE(data)->hBitmap)         DeleteObject(PRIVATE(data)->hBitmap);
 981     HeapFree(GetProcessHeap(), 0, PRIVATE(data));
 982 }
 983
 984 /******************************************************************
 985  *              WCUSER_MainLoop
 986  *
 987  *
 988  */
 989 static int WCUSER_MainLoop(struct inner_data* data)
 990 {
 991     MSG         msg;
 992
 993     for (;;)
 994     {
 995         switch (MsgWaitForMultipleObjects(1, &data->hSynchro, FALSE, INFINITE, QS_ALLINPUT))
 996         {
 997         case WAIT_OBJECT_0:
 998             if (!WINECON_GrabChanges(data))
 999                 PostQuitMessage(0);
1000             break;
1001         case WAIT_OBJECT_0+1:
1002             switch (GetMessage(&msg, 0, 0, 0))
1003             {
1004             case -1: /* the event handle became invalid, so exit */
1005                 return -1;
1006             case 0: /* WM_QUIT has been posted */
1007                 return 0;
1008             default:
1009                 DispatchMessage(&msg);
1010                 break;
1011             }
1012             break;
1013         default:
1014             Trace(0, "got pb\n");
1015             /* err */
1016             break;
1017         }
1018     }
1019 }
1020
1021 /******************************************************************
1022  *              WCUSER_InitBackend
1023  *
1024  * Initialisation part II: creation of window.
1025  *
1026  */
1027 BOOL WCUSER_InitBackend(struct inner_data* data)
1028 {
1029     static WCHAR wClassName[] = {'W','i','n','e','C','o','n','s','o','l','e','C','l','a','s','s',0};
1030
1031     WNDCLASS            wndclass;
1032
1033     data->private = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct inner_data_user));
1034     if (!data->private) return FALSE;
1035
1036     data->fnMainLoop = WCUSER_MainLoop;
1037     data->fnPosCursor = WCUSER_PosCursor;
1038     data->fnShapeCursor = WCUSER_ShapeCursor;
1039     data->fnComputePositions = WCUSER_ComputePositions;
1040     data->fnRefresh = WCUSER_Refresh;
1041     data->fnResizeScreenBuffer = WCUSER_ResizeScreenBuffer;
1042     data->fnSetTitle = WCUSER_SetTitle;
1043     data->fnScroll = WCUSER_Scroll;
1044     data->fnDeleteBackend = WCUSER_DeleteBackend;
1045
1046     wndclass.style         = 0;
1047     wndclass.lpfnWndProc   = WCUSER_Proc;
1048     wndclass.cbClsExtra    = 0;
1049     wndclass.cbWndExtra    = sizeof(DWORD);
1050     wndclass.hInstance     = GetModuleHandle(NULL);
1051     wndclass.hIcon         = LoadIcon(0, IDI_WINLOGO);
1052     wndclass.hCursor       = LoadCursor(0, IDC_ARROW);
1053     wndclass.hbrBackground = GetStockObject(BLACK_BRUSH);
1054     wndclass.lpszMenuName  = NULL;
1055     wndclass.lpszClassName = wClassName;
1056
1057     RegisterClass(&wndclass);
1058
1059     CreateWindow(wndclass.lpszClassName, NULL,
1060                  WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_THICKFRAME|WS_MINIMIZEBOX|WS_HSCROLL|WS_VSCROLL,
1061                  CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, 0, 0, wndclass.hInstance, data);
1062     if (!PRIVATE(data)->hWnd) return FALSE;
1063
1064     /* force update of current data */
1065     WINECON_GrabChanges(data);
1066
1067     if (!WCUSER_InitFont(data))
1068     {
1069         struct font_chooser fc;
1070         /* try to find an acceptable font */
1071         fc.data = data;
1072         fc.done = 0;
1073         EnumFontFamilies(PRIVATE(data)->hMemDC, NULL, get_first_font_enum, (LPARAM)&fc);
1074         return fc.done;
1075     }
1076     return TRUE;
1077 }
1078
1079
1080