dlls/winedib.drv/primitives_font.c

   1 /*
   2  * DIB Engine Font Primitives
   3  *
   4  * Copyright 2009 Massimo Del Fedele
   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 "config.h"
  22 #include "wine/port.h"
  23
  24 #include "dibdrv.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(dibdrv);
  27
  28 /* ------------------------------------------------------------*/
  29 /*               FREETYPE FONT BITMAP BLITTING                 */
  30 void _DIBDRV_freetype_blit_8888(DIBDRVPHYSDEV *physDev, int x, int y, FT_Bitmap *bmp)
  31 {
  32     /* FIXME : MUST BE OPTIMIZED !!! */
  33
  34     DIBDRVBITMAP *dib = &physDev->physBitmap;
  35     int bmpX, bmpY;
  36     BYTE *buf;
  37     int dibX, dibY;
  38     int DIBX, DIBY;
  39     DWORD c;
  40     DWORD *ptr;
  41
  42     /* gets DIB limits */
  43     DIBX = dib->width;
  44     DIBY = dib->height;
  45
  46     /* loop for every pixel in bitmap */
  47     buf = bmp->buffer;
  48     for(bmpY = 0, dibY = y; bmpY < bmp->rows; bmpY++, dibY++)
  49     {
  50         ptr = (DWORD *)((BYTE *)dib->bits + (dibY * dib->stride) + x * 4);
  51         for(bmpX = 0, dibX = x; bmpX < bmp->width; bmpX++, dibX++)
  52         {
  53             if(dibX < DIBX && dibY < DIBY && dibX > 0 && dibY > 0 && *buf)
  54             {
  55                 c = physDev->textColorTable[*buf];
  56                 *ptr = c;
  57             }
  58             buf++;
  59             ptr++;
  60         }
  61     }
  62 }
  63
  64 void _DIBDRV_freetype_blit_32_RGB(DIBDRVPHYSDEV *physDev, int x, int y, FT_Bitmap *bmp)
  65 {
  66     /* FIXME : MUST BE OPTIMIZED !!! */
  67
  68     DIBDRVBITMAP *dib = &physDev->physBitmap;
  69     int bmpX, bmpY;
  70     BYTE *buf;
  71     int dibX, dibY;
  72     int DIBX, DIBY;
  73     DWORD c;
  74
  75     /* gets DIB limits */
  76     DIBX = dib->width;
  77     DIBY = dib->height;
  78
  79     /* loop for every pixel in bitmap */
  80     buf = bmp->buffer;
  81     for(bmpY = 0, dibY = y; bmpY < bmp->rows; bmpY++, dibY++)
  82     {
  83         for(bmpX = 0, dibX = x; bmpX < bmp->width; bmpX++, dibX++)
  84         {
  85             if(dibX < DIBX && dibY < DIBY && dibX > 0 && dibY > 0 && *buf)
  86             {
  87                 c = physDev->textColorTable[*buf];
  88                 dib->funcs->SetPixel(dib, dibX, dibY, 0, c);
  89             }
  90             buf++;
  91         }
  92     }
  93 }
  94
  95 void _DIBDRV_freetype_blit_32_BITFIELDS(DIBDRVPHYSDEV *physDev, int x, int y, FT_Bitmap *bmp)
  96 {
  97     /* FIXME : MUST BE OPTIMIZED !!! */
  98
  99     DIBDRVBITMAP *dib = &physDev->physBitmap;
 100     int bmpX, bmpY;
 101     BYTE *buf;
 102     int dibX, dibY;
 103     int DIBX, DIBY;
 104     DWORD c;
 105
 106     /* gets DIB limits */
 107     DIBX = dib->width;
 108     DIBY = dib->height;
 109
 110     /* loop for every pixel in bitmap */
 111     buf = bmp->buffer;
 112     for(bmpY = 0, dibY = y; bmpY < bmp->rows; bmpY++, dibY++)
 113     {
 114         for(bmpX = 0, dibX = x; bmpX < bmp->width; bmpX++, dibX++)
 115         {
 116             if(dibX < DIBX && dibY < DIBY && dibX > 0 && dibY > 0 && *buf)
 117             {
 118                 c = physDev->textColorTable[*buf];
 119                 dib->funcs->SetPixel(dib, dibX, dibY, 0, c);
 120             }
 121             buf++;
 122         }
 123     }
 124 }
 125
 126 void _DIBDRV_freetype_blit_24(DIBDRVPHYSDEV *physDev, int x, int y, FT_Bitmap *bmp)
 127 {
 128     /* FIXME : MUST BE OPTIMIZED !!! */
 129
 130     DIBDRVBITMAP *dib = &physDev->physBitmap;
 131     int bmpX, bmpY;
 132     BYTE *buf;
 133     int dibX, dibY;
 134     int DIBX, DIBY;
 135     DWORD c;
 136
 137     /* gets DIB limits */
 138     DIBX = dib->width;
 139     DIBY = dib->height;
 140
 141     /* loop for every pixel in bitmap */
 142     buf = bmp->buffer;
 143     for(bmpY = 0, dibY = y; bmpY < bmp->rows; bmpY++, dibY++)
 144     {
 145         for(bmpX = 0, dibX = x; bmpX < bmp->width; bmpX++, dibX++)
 146         {
 147             if(dibX < DIBX && dibY < DIBY && dibX > 0 && dibY > 0 && *buf)
 148             {
 149                 c = physDev->textColorTable[*buf];
 150                 dib->funcs->SetPixel(dib, dibX, dibY, 0, c);
 151             }
 152             buf++;
 153         }
 154     }
 155 }
 156
 157 void _DIBDRV_freetype_blit_16_RGB(DIBDRVPHYSDEV *physDev, int x, int y, FT_Bitmap *bmp)
 158 {
 159     /* FIXME : MUST BE OPTIMIZED !!! */
 160
 161     DIBDRVBITMAP *dib = &physDev->physBitmap;
 162     int bmpX, bmpY;
 163     BYTE *buf;
 164     int dibX, dibY;
 165     int DIBX, DIBY;
 166     DWORD c;
 167
 168     /* gets DIB limits */
 169     DIBX = dib->width;
 170     DIBY = dib->height;
 171
 172     /* loop for every pixel in bitmap */
 173     buf = bmp->buffer;
 174     for(bmpY = 0, dibY = y; bmpY < bmp->rows; bmpY++, dibY++)
 175     {
 176         for(bmpX = 0, dibX = x; bmpX < bmp->width; bmpX++, dibX++)
 177         {
 178             if(dibX < DIBX && dibY < DIBY && dibX > 0 && dibY > 0 && *buf)
 179             {
 180                 c = physDev->textColorTable[*buf];
 181                 dib->funcs->SetPixel(dib, dibX, dibY, 0, c);
 182             }
 183             buf++;
 184         }
 185     }
 186 }
 187
 188 void _DIBDRV_freetype_blit_16_BITFIELDS(DIBDRVPHYSDEV *physDev, int x, int y, FT_Bitmap *bmp)
 189 {
 190     /* FIXME : MUST BE OPTIMIZED !!! */
 191
 192     DIBDRVBITMAP *dib = &physDev->physBitmap;
 193     int bmpX, bmpY;
 194     BYTE *buf;
 195     int dibX, dibY;
 196     int DIBX, DIBY;
 197     DWORD c;
 198
 199     /* gets DIB limits */
 200     DIBX = dib->width;
 201     DIBY = dib->height;
 202
 203     /* loop for every pixel in bitmap */
 204     buf = bmp->buffer;
 205     for(bmpY = 0, dibY = y; bmpY < bmp->rows; bmpY++, dibY++)
 206     {
 207         for(bmpX = 0, dibX = x; bmpX < bmp->width; bmpX++, dibX++)
 208         {
 209             if(dibX < DIBX && dibY < DIBY && dibX > 0 && dibY > 0 && *buf)
 210             {
 211                 c = physDev->textColorTable[*buf];
 212                 dib->funcs->SetPixel(dib, dibX, dibY, 0, c);
 213             }
 214             buf++;
 215         }
 216     }
 217 }
 218
 219 void _DIBDRV_freetype_blit_8(DIBDRVPHYSDEV *physDev, int x, int y, FT_Bitmap *bmp)
 220 {
 221     /* FIXME : MUST BE OPTIMIZED !!! */
 222
 223     DIBDRVBITMAP *dib = &physDev->physBitmap;
 224     int bmpX, bmpY;
 225     BYTE *buf;
 226     int dibX, dibY;
 227     int DIBX, DIBY;
 228     DWORD c;
 229
 230     /* gets DIB limits */
 231     DIBX = dib->width;
 232     DIBY = dib->height;
 233
 234     /* loop for every pixel in bitmap */
 235     buf = bmp->buffer;
 236     for(bmpY = 0, dibY = y; bmpY < bmp->rows; bmpY++, dibY++)
 237     {
 238         for(bmpX = 0, dibX = x; bmpX < bmp->width; bmpX++, dibX++)
 239         {
 240             if(dibX < DIBX && dibY < DIBY && dibX > 0 && dibY > 0 && *buf)
 241             {
 242                 c = physDev->textColorTable[*buf];
 243                 dib->funcs->SetPixel(dib, dibX, dibY, 0, c);
 244             }
 245             buf++;
 246         }
 247     }
 248 }
 249
 250 void _DIBDRV_freetype_blit_4(DIBDRVPHYSDEV *physDev, int x, int y, FT_Bitmap *bmp)
 251 {
 252     /* FIXME : MUST BE OPTIMIZED !!! */
 253
 254     DIBDRVBITMAP *dib = &physDev->physBitmap;
 255     int bmpX, bmpY;
 256     BYTE *buf;
 257     int dibX, dibY;
 258     int DIBX, DIBY;
 259     DWORD c;
 260
 261     /* gets DIB limits */
 262     DIBX = dib->width;
 263     DIBY = dib->height;
 264
 265     /* loop for every pixel in bitmap */
 266     buf = bmp->buffer;
 267     for(bmpY = 0, dibY = y; bmpY < bmp->rows; bmpY++, dibY++)
 268     {
 269         for(bmpX = 0, dibX = x; bmpX < bmp->width; bmpX++, dibX++)
 270         {
 271             if(dibX < DIBX && dibY < DIBY && dibX > 0 && dibY > 0 && *buf)
 272             {
 273                 c = physDev->textColorTable[*buf];
 274                 dib->funcs->SetPixel(dib, dibX, dibY, 0, c);
 275             }
 276             buf++;
 277         }
 278     }
 279 }
 280
 281 void _DIBDRV_freetype_blit_1(DIBDRVPHYSDEV *physDev, int x, int y, FT_Bitmap *bmp)
 282 {
 283     /* FIXME : MUST BE OPTIMIZED !!! */
 284
 285     DIBDRVBITMAP *dib = &physDev->physBitmap;
 286     int bmpX, bmpY;
 287     BYTE *buf;
 288     int dibX, dibY;
 289     int DIBX, DIBY;
 290     DWORD c;
 291
 292     /* gets DIB limits */
 293     DIBX = dib->width;
 294     DIBY = dib->height;
 295
 296     /* loop for every pixel in bitmap */
 297     buf = bmp->buffer;
 298     for(bmpY = 0, dibY = y; bmpY < bmp->rows; bmpY++, dibY++)
 299     {
 300         for(bmpX = 0, dibX = x; bmpX < bmp->width; bmpX++, dibX++)
 301         {
 302             if(dibX < DIBX && dibY < DIBY && dibX > 0 && dibY > 0 && *buf)
 303             {
 304                 c = physDev->textColorTable[*buf];
 305                 dib->funcs->SetPixel(dib, dibX, dibY, 0, c);
 306             }
 307             buf++;
 308         }
 309     }
 310 }