WINGs/wpixmap.c

   1
   2 #include "WINGsP.h"
   3
   4 #include <wraster.h>
   5
   6 WMPixmap *WMRetainPixmap(WMPixmap * pixmap)
   7 {
   8         if (pixmap)
   9                 pixmap->refCount++;
  10
  11         return pixmap;
  12 }
  13
  14 void WMReleasePixmap(WMPixmap * pixmap)
  15 {
  16         wassertr(pixmap != NULL);
  17
  18         pixmap->refCount--;
  19
  20         if (pixmap->refCount < 1) {
  21                 if (pixmap->pixmap)
  22                         XFreePixmap(pixmap->screen->display, pixmap->pixmap);
  23                 if (pixmap->mask)
  24                         XFreePixmap(pixmap->screen->display, pixmap->mask);
  25                 wfree(pixmap);
  26         }
  27 }
  28
  29 WMPixmap *WMCreatePixmap(WMScreen * scrPtr, int width, int height, int depth, Bool masked)
  30 {
  31         WMPixmap *pixPtr;
  32
  33         pixPtr = wmalloc(sizeof(WMPixmap));
  34         pixPtr->screen = scrPtr;
  35         pixPtr->width = width;
  36         pixPtr->height = height;
  37         pixPtr->depth = depth;
  38         pixPtr->refCount = 1;
  39
  40         pixPtr->pixmap = XCreatePixmap(scrPtr->display, W_DRAWABLE(scrPtr), width, height, depth);
  41         if (masked) {
  42                 pixPtr->mask = XCreatePixmap(scrPtr->display, W_DRAWABLE(scrPtr), width, height, 1);
  43         } else {
  44                 pixPtr->mask = None;
  45         }
  46
  47         return pixPtr;
  48 }
  49
  50 WMPixmap *WMCreatePixmapFromXPixmaps(WMScreen * scrPtr, Pixmap pixmap, Pixmap mask,
  51                                      int width, int height, int depth)
  52 {
  53         WMPixmap *pixPtr;
  54
  55         pixPtr = wmalloc(sizeof(WMPixmap));
  56         pixPtr->screen = scrPtr;
  57         pixPtr->pixmap = pixmap;
  58         pixPtr->mask = mask;
  59         pixPtr->width = width;
  60         pixPtr->height = height;
  61         pixPtr->depth = depth;
  62         pixPtr->refCount = 1;
  63
  64         return pixPtr;
  65 }
  66
  67 WMPixmap *WMCreatePixmapFromFile(WMScreen * scrPtr, const char *fileName)
  68 {
  69         WMPixmap *pixPtr;
  70         RImage *image;
  71
  72         image = RLoadImage(scrPtr->rcontext, fileName, 0);
  73         if (!image)
  74                 return NULL;
  75
  76         pixPtr = WMCreatePixmapFromRImage(scrPtr, image, 127);
  77
  78         RReleaseImage(image);
  79
  80         return pixPtr;
  81 }
  82
  83 WMPixmap *WMCreatePixmapFromRImage(WMScreen * scrPtr, RImage * image, int threshold)
  84 {
  85         WMPixmap *pixPtr;
  86         Pixmap pixmap, mask;
  87
  88         if (!RConvertImageMask(scrPtr->rcontext, image, &pixmap, &mask, threshold)) {
  89                 return NULL;
  90         }
  91
  92         pixPtr = wmalloc(sizeof(WMPixmap));
  93         pixPtr->screen = scrPtr;
  94         pixPtr->pixmap = pixmap;
  95         pixPtr->mask = mask;
  96         pixPtr->width = image->width;
  97         pixPtr->height = image->height;
  98         pixPtr->depth = scrPtr->depth;
  99         pixPtr->refCount = 1;
 100
 101         return pixPtr;
 102 }
 103
 104 WMPixmap *WMCreateBlendedPixmapFromRImage(WMScreen * scrPtr, RImage * image, const RColor * color)
 105 {
 106         WMPixmap *pixPtr;
 107         RImage *copy;
 108
 109         copy = RCloneImage(image);
 110         if (!copy)
 111                 return NULL;
 112
 113         RCombineImageWithColor(copy, color);
 114         pixPtr = WMCreatePixmapFromRImage(scrPtr, copy, 0);
 115         RReleaseImage(copy);
 116
 117         return pixPtr;
 118 }
 119
 120 WMPixmap *WMCreateBlendedPixmapFromFile(WMScreen * scrPtr, const char *fileName, const RColor * color)
 121 {
 122         return WMCreateScaledBlendedPixmapFromFile(scrPtr, fileName, color, 0, 0);
 123 }
 124
 125 WMPixmap *WMCreateScaledBlendedPixmapFromFile(WMScreen *scrPtr, const char *fileName, const RColor *color,
 126                                               unsigned int width, unsigned int height)
 127 {
 128         WMPixmap *pixPtr;
 129         RImage *image;
 130
 131         image = RLoadImage(scrPtr->rcontext, fileName, 0);
 132         if (!image)
 133                 return NULL;
 134
 135         /* scale it if needed to fit in the specified box */
 136         if ((width > 0) && (height > 0) && ((image->width > width) || (image->height > height))) {
 137                 int new_width, new_height;
 138                 RImage *new_image;
 139
 140                 new_width  = image->width;
 141                 new_height = image->height;
 142                 if (new_width > width) {
 143                         new_width  = width;
 144                         new_height = width * image->height / image->width;
 145                 }
 146                 if (new_height > height) {
 147                         new_width  = height * image->width / image->height;
 148                         new_height = height;
 149                 }
 150
 151                 new_image = RScaleImage(image, new_width, new_height);
 152                 RReleaseImage(image);
 153                 image = new_image;
 154         }
 155
 156         RCombineImageWithColor(image, color);
 157         pixPtr = WMCreatePixmapFromRImage(scrPtr, image, 0);
 158         RReleaseImage(image);
 159
 160         return pixPtr;
 161 }
 162
 163 WMPixmap *WMCreatePixmapFromXPMData(WMScreen * scrPtr, char **data)
 164 {
 165         WMPixmap *pixPtr;
 166         RImage *image;
 167
 168         image = RGetImageFromXPMData(scrPtr->rcontext, data);
 169         if (!image)
 170                 return NULL;
 171
 172         pixPtr = WMCreatePixmapFromRImage(scrPtr, image, 127);
 173
 174         RReleaseImage(image);
 175
 176         return pixPtr;
 177 }
 178
 179 Pixmap WMGetPixmapXID(WMPixmap * pixmap)
 180 {
 181         wassertrv(pixmap != NULL, None);
 182
 183         return pixmap->pixmap;
 184 }
 185
 186 Pixmap WMGetPixmapMaskXID(WMPixmap * pixmap)
 187 {
 188         wassertrv(pixmap != NULL, None);
 189
 190         return pixmap->mask;
 191 }
 192
 193 WMSize WMGetPixmapSize(WMPixmap * pixmap)
 194 {
 195         WMSize size = { 0, 0 };
 196
 197         wassertrv(pixmap != NULL, size);
 198
 199         size.width = pixmap->width;
 200         size.height = pixmap->height;
 201
 202         return size;
 203 }
 204
 205 WMPixmap *WMGetSystemPixmap(WMScreen * scr, int image)
 206 {
 207         switch (image) {
 208         case WSIReturnArrow:
 209                 return WMRetainPixmap(scr->buttonArrow);
 210
 211         case WSIHighlightedReturnArrow:
 212                 return WMRetainPixmap(scr->pushedButtonArrow);
 213
 214         case WSIScrollerDimple:
 215                 return WMRetainPixmap(scr->scrollerDimple);
 216
 217         case WSIArrowLeft:
 218                 return WMRetainPixmap(scr->leftArrow);
 219
 220         case WSIHighlightedArrowLeft:
 221                 return WMRetainPixmap(scr->hiLeftArrow);
 222
 223         case WSIArrowRight:
 224                 return WMRetainPixmap(scr->rightArrow);
 225
 226         case WSIHighlightedArrowRight:
 227                 return WMRetainPixmap(scr->hiRightArrow);
 228
 229         case WSIArrowUp:
 230                 return WMRetainPixmap(scr->upArrow);
 231
 232         case WSIHighlightedArrowUp:
 233                 return WMRetainPixmap(scr->hiUpArrow);
 234
 235         case WSIArrowDown:
 236                 return WMRetainPixmap(scr->downArrow);
 237
 238         case WSIHighlightedArrowDown:
 239                 return WMRetainPixmap(scr->hiDownArrow);
 240
 241         case WSICheckMark:
 242                 return WMRetainPixmap(scr->checkMark);
 243
 244         default:
 245                 return NULL;
 246         }
 247 }
 248
 249 void WMDrawPixmap(WMPixmap * pixmap, Drawable d, int x, int y)
 250 {
 251         WMScreen *scr = pixmap->screen;
 252
 253         XSetClipMask(scr->display, scr->clipGC, pixmap->mask);
 254         XSetClipOrigin(scr->display, scr->clipGC, x, y);
 255
 256         XCopyArea(scr->display, pixmap->pixmap, d, scr->clipGC, 0, 0, pixmap->width, pixmap->height, x, y);
 257 }