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 (image == NULL)
  89                 return NULL;
  90
  91         if (!RConvertImageMask(scrPtr->rcontext, image, &pixmap, &mask, threshold)) {
  92                 return NULL;
  93         }
  94
  95         pixPtr = wmalloc(sizeof(WMPixmap));
  96         pixPtr->screen = scrPtr;
  97         pixPtr->pixmap = pixmap;
  98         pixPtr->mask = mask;
  99         pixPtr->width = image->width;
 100         pixPtr->height = image->height;
 101         pixPtr->depth = scrPtr->depth;
 102         pixPtr->refCount = 1;
 103
 104         return pixPtr;
 105 }
 106
 107 WMPixmap *WMCreateBlendedPixmapFromRImage(WMScreen * scrPtr, RImage * image, const RColor * color)
 108 {
 109         WMPixmap *pixPtr;
 110         RImage *copy;
 111
 112         copy = RCloneImage(image);
 113         if (!copy)
 114                 return NULL;
 115
 116         RCombineImageWithColor(copy, color);
 117         pixPtr = WMCreatePixmapFromRImage(scrPtr, copy, 0);
 118         RReleaseImage(copy);
 119
 120         return pixPtr;
 121 }
 122
 123 WMPixmap *WMCreateBlendedPixmapFromFile(WMScreen * scrPtr, const char *fileName, const RColor * color)
 124 {
 125         return WMCreateScaledBlendedPixmapFromFile(scrPtr, fileName, color, 0, 0);
 126 }
 127
 128 WMPixmap *WMCreateScaledBlendedPixmapFromFile(WMScreen *scrPtr, const char *fileName, const RColor *color,
 129                                               unsigned int width, unsigned int height)
 130 {
 131         WMPixmap *pixPtr;
 132         RImage *image;
 133
 134         image = RLoadImage(scrPtr->rcontext, fileName, 0);
 135         if (!image)
 136                 return NULL;
 137
 138         /* scale it if needed to fit in the specified box */
 139         if ((width > 0) && (height > 0) && ((image->width > width) || (image->height > height))) {
 140                 int new_width, new_height;
 141                 RImage *new_image;
 142
 143                 new_width  = image->width;
 144                 new_height = image->height;
 145                 if (new_width > width) {
 146                         new_width  = width;
 147                         new_height = width * image->height / image->width;
 148                 }
 149                 if (new_height > height) {
 150                         new_width  = height * image->width / image->height;
 151                         new_height = height;
 152                 }
 153
 154                 new_image = RScaleImage(image, new_width, new_height);
 155                 RReleaseImage(image);
 156                 image = new_image;
 157         }
 158
 159         RCombineImageWithColor(image, color);
 160         pixPtr = WMCreatePixmapFromRImage(scrPtr, image, 0);
 161         RReleaseImage(image);
 162
 163         return pixPtr;
 164 }
 165
 166 WMPixmap *WMCreatePixmapFromXPMData(WMScreen * scrPtr, char **data)
 167 {
 168         WMPixmap *pixPtr;
 169         RImage *image;
 170
 171         image = RGetImageFromXPMData(scrPtr->rcontext, data);
 172         if (!image)
 173                 return NULL;
 174
 175         pixPtr = WMCreatePixmapFromRImage(scrPtr, image, 127);
 176
 177         RReleaseImage(image);
 178
 179         return pixPtr;
 180 }
 181
 182 Pixmap WMGetPixmapXID(WMPixmap * pixmap)
 183 {
 184         wassertrv(pixmap != NULL, None);
 185
 186         return pixmap->pixmap;
 187 }
 188
 189 Pixmap WMGetPixmapMaskXID(WMPixmap * pixmap)
 190 {
 191         wassertrv(pixmap != NULL, None);
 192
 193         return pixmap->mask;
 194 }
 195
 196 WMSize WMGetPixmapSize(WMPixmap * pixmap)
 197 {
 198         WMSize size = { 0, 0 };
 199
 200         wassertrv(pixmap != NULL, size);
 201
 202         size.width = pixmap->width;
 203         size.height = pixmap->height;
 204
 205         return size;
 206 }
 207
 208 WMPixmap *WMGetSystemPixmap(WMScreen * scr, int image)
 209 {
 210         switch (image) {
 211         case WSIReturnArrow:
 212                 return WMRetainPixmap(scr->buttonArrow);
 213
 214         case WSIHighlightedReturnArrow:
 215                 return WMRetainPixmap(scr->pushedButtonArrow);
 216
 217         case WSIScrollerDimple:
 218                 return WMRetainPixmap(scr->scrollerDimple);
 219
 220         case WSIArrowLeft:
 221                 return WMRetainPixmap(scr->leftArrow);
 222
 223         case WSIHighlightedArrowLeft:
 224                 return WMRetainPixmap(scr->hiLeftArrow);
 225
 226         case WSIArrowRight:
 227                 return WMRetainPixmap(scr->rightArrow);
 228
 229         case WSIHighlightedArrowRight:
 230                 return WMRetainPixmap(scr->hiRightArrow);
 231
 232         case WSIArrowUp:
 233                 return WMRetainPixmap(scr->upArrow);
 234
 235         case WSIHighlightedArrowUp:
 236                 return WMRetainPixmap(scr->hiUpArrow);
 237
 238         case WSIArrowDown:
 239                 return WMRetainPixmap(scr->downArrow);
 240
 241         case WSIHighlightedArrowDown:
 242                 return WMRetainPixmap(scr->hiDownArrow);
 243
 244         case WSICheckMark:
 245                 return WMRetainPixmap(scr->checkMark);
 246
 247         default:
 248                 return NULL;
 249         }
 250 }
 251
 252 void WMDrawPixmap(WMPixmap * pixmap, Drawable d, int x, int y)
 253 {
 254         WMScreen *scr = pixmap->screen;
 255
 256         XSetClipMask(scr->display, scr->clipGC, pixmap->mask);
 257         XSetClipOrigin(scr->display, scr->clipGC, x, y);
 258
 259         XCopyArea(scr->display, pixmap->pixmap, d, scr->clipGC, 0, 0, pixmap->width, pixmap->height, x, y);
 260 }