git.oblomov.eu Git - wine/blob - dlls/ttydrv/graphics.c

   1 /*
   2  * TTY DC graphics
   3  *
   4  * Copyright 1999 Patrik Stridvall
   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include "winnls.h"
  24 #include "gdi.h"
  25 #include "wine/debug.h"
  26 #include "ttydrv.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(ttydrv);
  29
  30 /***********************************************************************
  31  *              TTYDRV_DC_Arc
  32  */
  33 BOOL TTYDRV_DC_Arc(TTYDRV_PDEVICE *physDev, INT left, INT top, INT right, INT bottom,
  34                    INT xstart, INT ystart, INT xend, INT yend)
  35 {
  36   FIXME("(%x, %d, %d, %d, %d, %d, %d, %d, %d): stub\n",
  37         physDev->hdc, left, top, right, bottom, xstart, ystart, xend, yend);
  38   return TRUE;
  39 }
  40
  41 /***********************************************************************
  42  *              TTYDRV_DC_Chord
  43  */
  44 BOOL TTYDRV_DC_Chord(TTYDRV_PDEVICE *physDev, INT left, INT top, INT right, INT bottom,
  45                      INT xstart, INT ystart, INT xend, INT yend)
  46 {
  47   FIXME("(%x, %d, %d, %d, %d, %d, %d, %d, %d): stub\n",
  48         physDev->hdc, left, top, right, bottom, xstart, ystart, xend, yend);
  49   return TRUE;
  50 }
  51
  52 /***********************************************************************
  53  *              TTYDRV_DC_Ellipse
  54  */
  55 BOOL TTYDRV_DC_Ellipse(TTYDRV_PDEVICE *physDev, INT left, INT top, INT right, INT bottom)
  56 {
  57   FIXME("(%x, %d, %d, %d, %d): stub\n", physDev->hdc, left, top, right, bottom);
  58   return TRUE;
  59 }
  60
  61 /***********************************************************************
  62  *              TTYDRV_DC_ExtFloodFill
  63  */
  64 BOOL TTYDRV_DC_ExtFloodFill(TTYDRV_PDEVICE *physDev, INT x, INT y,
  65                             COLORREF color, UINT fillType)
  66 {
  67   FIXME("(%x, %d, %d, 0x%08lx, %u): stub\n", physDev->hdc, x, y, color, fillType);
  68   return TRUE;
  69 }
  70
  71 /***********************************************************************
  72  *              TTYDRV_DC_GetPixel
  73  */
  74 COLORREF TTYDRV_DC_GetPixel(TTYDRV_PDEVICE *physDev, INT x, INT y)
  75 {
  76   FIXME("(%x, %d, %d): stub\n", physDev->hdc, x, y);
  77   return RGB(0,0,0); /* FIXME: Always returns black */
  78 }
  79
  80 /***********************************************************************
  81  *              TTYDRV_DC_LineTo
  82  */
  83 BOOL TTYDRV_DC_LineTo(TTYDRV_PDEVICE *physDev, INT x, INT y)
  84 {
  85 #ifdef WINE_CURSES
  86   INT row1, col1, row2, col2;
  87   DC *dc = physDev->dc;
  88
  89   TRACE("(%x, %d, %d)\n", physDev->hdc, x, y);
  90
  91   if(!physDev->window)
  92     return FALSE;
  93
  94   row1 = (dc->DCOrgY + XLPTODP(dc, dc->CursPosY)) / physDev->cellHeight;
  95   col1 = (dc->DCOrgX + XLPTODP(dc, dc->CursPosX)) / physDev->cellWidth;
  96   row2 = (dc->DCOrgY + XLPTODP(dc, y)) / physDev->cellHeight;
  97   col2 = (dc->DCOrgX + XLPTODP(dc, x)) / physDev->cellWidth;
  98
  99   if(row1 > row2) {
 100     INT tmp = row1;
 101     row1 = row2;
 102     row2 = tmp;
 103   }
 104
 105   if(col1 > col2) {
 106     INT tmp = col1;
 107     col1 = col2;
 108     col2 = tmp;
 109   }
 110
 111   wmove(physDev->window, row1, col1);
 112   if(col1 == col2) {
 113     wvline(physDev->window, ACS_VLINE, row2-row1);
 114   } else if(row1 == row2) {
 115     whline(physDev->window, ACS_HLINE, col2-col1);
 116   } else {
 117     FIXME("Diagonal line drawing not yet supported\n");
 118   }
 119   wrefresh(physDev->window);
 120
 121   return TRUE;
 122 #else /* defined(WINE_CURSES) */
 123   FIXME("(%x, %d, %d): stub\n", physDev->hdc, x, y);
 124
 125   return TRUE;
 126 #endif /* defined(WINE_CURSES) */
 127 }
 128
 129 /***********************************************************************
 130  *              TTYDRV_DC_PaintRgn
 131  */
 132 BOOL TTYDRV_DC_PaintRgn(TTYDRV_PDEVICE *physDev, HRGN hrgn)
 133 {
 134   FIXME("(%x, 0x%04x): stub\n", physDev->hdc, hrgn);
 135   return TRUE;
 136 }
 137
 138 /***********************************************************************
 139  *              TTYDRV_DC_Pie
 140  */
 141 BOOL TTYDRV_DC_Pie(TTYDRV_PDEVICE *physDev, INT left, INT top, INT right, INT bottom,
 142                    INT xstart, INT ystart, INT xend, INT yend)
 143 {
 144   FIXME("(%x, %d, %d, %d, %d, %d, %d, %d, %d): stub\n",
 145         physDev->hdc, left, top, right, bottom, xstart, ystart, xend, yend);
 146   return TRUE;
 147 }
 148
 149 /***********************************************************************
 150  *              TTYDRV_DC_Polygon
 151  */
 152 BOOL TTYDRV_DC_Polygon(TTYDRV_PDEVICE *physDev, const POINT* pt, INT count)
 153 {
 154   FIXME("(%x, %p, %d): stub\n", physDev->hdc, pt, count);
 155   return TRUE;
 156 }
 157
 158 /***********************************************************************
 159  *              TTYDRV_DC_Polyline
 160  */
 161 BOOL TTYDRV_DC_Polyline(TTYDRV_PDEVICE *physDev, const POINT* pt, INT count)
 162 {
 163   FIXME("(%x, %p, %d): stub\n", physDev->hdc, pt, count);
 164   return TRUE;
 165 }
 166
 167 /***********************************************************************
 168  *              TTYDRV_DC_PolyPolygon
 169  */
 170 BOOL TTYDRV_DC_PolyPolygon(TTYDRV_PDEVICE *physDev, const POINT* pt, const INT* counts, UINT polygons)
 171 {
 172   FIXME("(%x, %p, %p, %u): stub\n", physDev->hdc, pt, counts, polygons);
 173   return TRUE;
 174 }
 175
 176 /***********************************************************************
 177  *              TTYDRV_DC_PolyPolyline
 178  */
 179 BOOL TTYDRV_DC_PolyPolyline(TTYDRV_PDEVICE *physDev, const POINT* pt, const DWORD* counts, DWORD polylines)
 180 {
 181   FIXME("(%x, %p, %p, %lu): stub\n", physDev->hdc, pt, counts, polylines);
 182
 183   return TRUE;
 184 }
 185
 186 /***********************************************************************
 187  *              TTYDRV_DC_Rectangle
 188  */
 189 BOOL TTYDRV_DC_Rectangle(TTYDRV_PDEVICE *physDev, INT left, INT top, INT right, INT bottom)
 190 {
 191 #ifdef WINE_CURSES
 192   INT row1, col1, row2, col2;
 193   DC *dc = physDev->dc;
 194
 195   TRACE("(%x, %d, %d, %d, %d)\n", physDev->hdc, left, top, right, bottom);
 196
 197   if(!physDev->window)
 198     return FALSE;
 199
 200   row1 = (dc->DCOrgY + XLPTODP(dc, top)) / physDev->cellHeight;
 201   col1 = (dc->DCOrgX + XLPTODP(dc, left)) / physDev->cellWidth;
 202   row2 = (dc->DCOrgY + XLPTODP(dc, bottom)) / physDev->cellHeight;
 203   col2 = (dc->DCOrgX + XLPTODP(dc, right)) / physDev->cellWidth;
 204
 205   if(row1 > row2) {
 206     INT tmp = row1;
 207     row1 = row2;
 208     row2 = tmp;
 209   }
 210   if(col1 > col2) {
 211     INT tmp = col1;
 212     col1 = col2;
 213     col2 = tmp;
 214   }
 215
 216   wmove(physDev->window, row1, col1);
 217   whline(physDev->window, ACS_HLINE, col2-col1);
 218
 219   wmove(physDev->window, row1, col2);
 220   wvline(physDev->window, ACS_VLINE, row2-row1);
 221
 222   wmove(physDev->window, row2, col1);
 223   whline(physDev->window, ACS_HLINE, col2-col1);
 224
 225   wmove(physDev->window, row1, col1);
 226   wvline(physDev->window, ACS_VLINE, row2-row1);
 227
 228   mvwaddch(physDev->window, row1, col1, ACS_ULCORNER);
 229   mvwaddch(physDev->window, row1, col2, ACS_URCORNER);
 230   mvwaddch(physDev->window, row2, col2, ACS_LRCORNER);
 231   mvwaddch(physDev->window, row2, col1, ACS_LLCORNER);
 232
 233   wrefresh(physDev->window);
 234
 235   return TRUE;
 236 #else /* defined(WINE_CURSES) */
 237   FIXME("(%x, %d, %d, %d, %d): stub\n", physDev->hdc, left, top, right, bottom);
 238
 239   return TRUE;
 240 #endif /* defined(WINE_CURSES) */
 241 }
 242
 243 /***********************************************************************
 244  *              TTYDRV_DC_RoundRect
 245  */
 246 BOOL TTYDRV_DC_RoundRect(TTYDRV_PDEVICE *physDev, INT left, INT top, INT right,
 247                          INT bottom, INT ell_width, INT ell_height)
 248 {
 249   FIXME("(%x, %d, %d, %d, %d, %d, %d): stub\n",
 250         physDev->hdc, left, top, right, bottom, ell_width, ell_height);
 251
 252   return TRUE;
 253 }
 254
 255 /***********************************************************************
 256  *              TTYDRV_DC_SetPixel
 257  */
 258 COLORREF TTYDRV_DC_SetPixel(TTYDRV_PDEVICE *physDev, INT x, INT y, COLORREF color)
 259 {
 260 #ifdef WINE_CURSES
 261   INT row, col;
 262   DC *dc = physDev->dc;
 263
 264   TRACE("(%x, %d, %d, 0x%08lx)\n", physDev->hdc, x, y, color);
 265
 266   if(!physDev->window)
 267     return FALSE;
 268
 269   row = (dc->DCOrgY + XLPTODP(dc, y)) / physDev->cellHeight;
 270   col = (dc->DCOrgX + XLPTODP(dc, x)) / physDev->cellWidth;
 271
 272   mvwaddch(physDev->window, row, col, ACS_BULLET);
 273   wrefresh(physDev->window);
 274
 275   return RGB(0,0,0); /* FIXME: Always returns black */
 276 #else /* defined(WINE_CURSES) */
 277   FIXME("(%x, %d, %d, 0x%08lx): stub\n", physDev->hdc, x, y, color);
 278
 279   return RGB(0,0,0); /* FIXME: Always returns black */
 280 #endif /* defined(WINE_CURSES) */
 281 }
 282
 283 /***********************************************************************
 284  *              TTYDRV_DC_BitBlt
 285  */
 286 BOOL TTYDRV_DC_BitBlt(TTYDRV_PDEVICE *physDevDst, INT xDst, INT yDst,
 287                       INT width, INT height, TTYDRV_PDEVICE *physDevSrc,
 288                       INT xSrc, INT ySrc, DWORD rop)
 289 {
 290   FIXME("(%x, %d, %d, %d, %d, %x, %d, %d, %lu): stub\n",
 291         physDevDst->hdc, xDst, yDst, width, height, physDevSrc->hdc, xSrc, ySrc, rop );
 292   return TRUE;
 293 }
 294
 295 /***********************************************************************
 296  *              TTYDRV_DC_PatBlt
 297  */
 298 BOOL TTYDRV_DC_PatBlt(TTYDRV_PDEVICE *physDev, INT left, INT top,
 299                       INT width, INT height, DWORD rop)
 300 {
 301   FIXME("(%x, %d, %d, %d, %d, %lu): stub\n", physDev->hdc, left, top, width, height, rop );
 302   return TRUE;
 303 }
 304
 305 /***********************************************************************
 306  *              TTYDRV_DC_StretchBlt
 307  */
 308 BOOL TTYDRV_DC_StretchBlt(TTYDRV_PDEVICE *physDevDst, INT xDst, INT yDst,
 309                           INT widthDst, INT heightDst,
 310                           TTYDRV_PDEVICE *physDevSrc, INT xSrc, INT ySrc,
 311                           INT widthSrc, INT heightSrc, DWORD rop)
 312 {
 313   FIXME("(%x, %d, %d, %d, %d, %x, %d, %d, %d, %d, %lu): stub\n",
 314         physDevDst->hdc, xDst, yDst, widthDst, heightDst,
 315         physDevSrc->hdc, xSrc, ySrc, widthSrc, heightSrc, rop );
 316
 317   return TRUE;
 318 }
 319
 320 /***********************************************************************
 321  *              TTYDRV_DC_ExtTextOut
 322  */
 323 BOOL TTYDRV_DC_ExtTextOut(TTYDRV_PDEVICE *physDev, INT x, INT y, UINT flags,
 324                           const RECT *lpRect, LPCWSTR str, UINT count,
 325                           const INT *lpDx)
 326 {
 327 #ifdef WINE_CURSES
 328   INT row, col;
 329   LPSTR ascii;
 330   DWORD len;
 331   DC *dc = physDev->dc;
 332
 333   TRACE("(%x, %d, %d, 0x%08x, %p, %s, %d, %p)\n",
 334         physDev->hdc, x, y, flags, lpRect, debugstr_wn(str, count), count, lpDx);
 335
 336   if(!physDev->window)
 337     return FALSE;
 338
 339   /* FIXME: Is this really correct? */
 340   if(dc->textAlign & TA_UPDATECP) {
 341     x = dc->CursPosX;
 342     y = dc->CursPosY;
 343   }
 344
 345   x = XLPTODP(dc, x);
 346   y = YLPTODP(dc, y);
 347
 348   row = (dc->DCOrgY + y) / physDev->cellHeight;
 349   col = (dc->DCOrgX + x) / physDev->cellWidth;
 350   len = WideCharToMultiByte( CP_ACP, 0, str, count, NULL, 0, NULL, NULL );
 351   ascii = HeapAlloc( GetProcessHeap(), 0, len );
 352   WideCharToMultiByte( CP_ACP, 0, str, count, ascii, len, NULL, NULL );
 353   mvwaddnstr(physDev->window, row, col, ascii, len);
 354   HeapFree( GetProcessHeap(), 0, ascii );
 355   wrefresh(physDev->window);
 356
 357   if(dc->textAlign & TA_UPDATECP) {
 358     dc->CursPosX += count * physDev->cellWidth;
 359     dc->CursPosY += physDev->cellHeight;
 360   }
 361
 362   return TRUE;
 363 #else /* defined(WINE_CURSES) */
 364   FIXME("(%x, %d, %d, 0x%08x, %p, %s, %d, %p): stub\n",
 365         physDev->hdc, x, y, flags, lpRect, debugstr_wn(str,count), count, lpDx);
 366
 367   return TRUE;
 368 #endif /* defined(WINE_CURSES) */
 369 }
 370
 371 /***********************************************************************
 372  *              TTYDRV_DC_GetCharWidth
 373  */
 374 BOOL TTYDRV_DC_GetCharWidth(TTYDRV_PDEVICE *physDev, UINT firstChar, UINT lastChar,
 375                             LPINT buffer)
 376 {
 377   UINT c;
 378
 379   FIXME("(%x, %u, %u, %p): semistub\n", physDev->hdc, firstChar, lastChar, buffer);
 380
 381   for(c=firstChar; c<=lastChar; c++) {
 382     buffer[c-firstChar] = physDev->cellWidth;
 383   }
 384
 385   return TRUE;
 386 }
 387
 388 /***********************************************************************
 389  *              TTYDRV_DC_GetTextExtentPoint
 390  */
 391 BOOL TTYDRV_DC_GetTextExtentPoint(TTYDRV_PDEVICE *physDev, LPCWSTR str, INT count,
 392                                   LPSIZE size)
 393 {
 394   TRACE("(%x, %s, %d, %p)\n", physDev->hdc, debugstr_wn(str, count), count, size);
 395
 396   size->cx = count * physDev->cellWidth;
 397   size->cy = physDev->cellHeight;
 398
 399   return TRUE;
 400 }
 401
 402 /***********************************************************************
 403  *              TTYDRV_DC_GetTextMetrics
 404  */
 405 BOOL TTYDRV_DC_GetTextMetrics(TTYDRV_PDEVICE *physDev, LPTEXTMETRICW lptm)
 406 {
 407   TRACE("(%x, %p)\n", physDev->hdc, lptm);
 408
 409   lptm->tmHeight = physDev->cellHeight;
 410   lptm->tmAscent = 0;
 411   lptm->tmDescent = 0;
 412   lptm->tmInternalLeading = 0;
 413   lptm->tmExternalLeading = 0;
 414   lptm->tmAveCharWidth = physDev->cellWidth;
 415   lptm->tmMaxCharWidth = physDev->cellWidth;
 416   lptm->tmWeight = FW_MEDIUM;
 417   lptm->tmOverhang = 0;
 418   lptm->tmDigitizedAspectX = physDev->cellWidth;
 419   lptm->tmDigitizedAspectY = physDev->cellHeight;
 420   lptm->tmFirstChar = 32;
 421   lptm->tmLastChar = 255;
 422   lptm->tmDefaultChar = 0;
 423   lptm->tmBreakChar = 32;
 424   lptm->tmItalic = FALSE;
 425   lptm->tmUnderlined = FALSE;
 426   lptm->tmStruckOut = FALSE;
 427   lptm->tmPitchAndFamily = TMPF_FIXED_PITCH|TMPF_DEVICE;
 428   lptm->tmCharSet = ANSI_CHARSET;
 429
 430   return TRUE;
 431 }