WINGs/wmisc.c

   1
   2 #include "WINGsP.h"
   3
   4 #include <wraster.h>
   5 #include <ctype.h>
   6
   7 void
   8 W_DrawRelief(W_Screen * scr, Drawable d, int x, int y, unsigned int width,
   9              unsigned int height, WMReliefType relief)
  10 {
  11         W_DrawReliefWithGC(scr, d, x, y, width, height, relief,
  12                            WMColorGC(scr->black), WMColorGC(scr->darkGray),
  13                            WMColorGC(scr->gray), WMColorGC(scr->white));
  14 }
  15
  16 void
  17 W_DrawReliefWithGC(W_Screen * scr, Drawable d, int x, int y, unsigned int width,
  18                    unsigned int height, WMReliefType relief, GC black, GC dark, GC light, GC white)
  19 {
  20         Display *dpy = scr->display;
  21         GC bgc;
  22         GC wgc;
  23         GC lgc;
  24         GC dgc;
  25
  26         switch (relief) {
  27         case WRSimple:
  28                 XDrawRectangle(dpy, d, black, x, y, width - 1, height - 1);
  29                 return;
  30
  31         case WRRaised:
  32                 bgc = black;
  33                 dgc = dark;
  34                 wgc = white;
  35                 lgc = light;
  36                 break;
  37
  38         case WRSunken:
  39                 wgc = dark;
  40                 lgc = black;
  41                 bgc = white;
  42                 dgc = light;
  43                 break;
  44
  45         case WRPushed:
  46                 lgc = wgc = black;
  47                 dgc = bgc = white;
  48                 break;
  49
  50         case WRRidge:
  51                 lgc = bgc = dark;
  52                 dgc = wgc = white;
  53                 break;
  54
  55         case WRGroove:
  56                 wgc = dgc = dark;
  57                 lgc = bgc = white;
  58                 break;
  59
  60         default:
  61                 return;
  62         }
  63         /* top left */
  64         XDrawLine(dpy, d, wgc, x, y, x + width - 1, y);
  65         if (width > 2 && relief != WRRaised && relief != WRPushed) {
  66                 XDrawLine(dpy, d, lgc, x + 1, y + 1, x + width - 3, y + 1);
  67         }
  68
  69         XDrawLine(dpy, d, wgc, x, y, x, y + height - 1);
  70         if (height > 2 && relief != WRRaised && relief != WRPushed) {
  71                 XDrawLine(dpy, d, lgc, x + 1, y + 1, x + 1, y + height - 3);
  72         }
  73
  74         /* bottom right */
  75         XDrawLine(dpy, d, bgc, x, y + height - 1, x + width - 1, y + height - 1);
  76         if (width > 2 && relief != WRPushed) {
  77                 XDrawLine(dpy, d, dgc, x + 1, y + height - 2, x + width - 2, y + height - 2);
  78         }
  79
  80         XDrawLine(dpy, d, bgc, x + width - 1, y, x + width - 1, y + height - 1);
  81         if (height > 2 && relief != WRPushed) {
  82                 XDrawLine(dpy, d, dgc, x + width - 2, y + 1, x + width - 2, y + height - 2);
  83         }
  84 }
  85
  86 static int findNextWord(const char *text, int limit)
  87 {
  88         int pos, len;
  89
  90         len = strcspn(text, " \t\n\r");
  91         pos = len + strspn(text + len, " \t\n\r");
  92         if (pos > limit)
  93                 pos = limit;
  94
  95         return pos;
  96 }
  97
  98 static int fitText(const char *text, WMFont * font, int width, int wrap)
  99 {
 100         int i, w, beforecrlf, word1, word2;
 101
 102         /* text length before first cr/lf */
 103         beforecrlf = strcspn(text, "\n");
 104
 105         if (!wrap || beforecrlf == 0)
 106                 return beforecrlf;
 107
 108         w = WMWidthOfString(font, text, beforecrlf);
 109         if (w <= width) {
 110                 /* text up to first crlf fits */
 111                 return beforecrlf;
 112         }
 113
 114         word1 = 0;
 115         while (1) {
 116                 word2 = word1 + findNextWord(text + word1, beforecrlf - word1);
 117                 if (word2 >= beforecrlf)
 118                         break;
 119                 w = WMWidthOfString(font, text, word2);
 120                 if (w > width)
 121                         break;
 122                 word1 = word2;
 123         }
 124
 125         for (i = word1; i < word2; i++) {
 126                 w = WMWidthOfString(font, text, i);
 127                 if (w > width) {
 128                         break;
 129                 }
 130         }
 131
 132         /* keep words complete if possible */
 133         if (!isspace(text[i]) && word1 > 0) {
 134                 i = word1;
 135         } else if (isspace(text[i]) && i < beforecrlf) {
 136                 /* keep space on current row, so new row has next word in column 1 */
 137                 i++;
 138         }
 139
 140         return i;
 141 }
 142
 143 int W_GetTextHeight(WMFont * font, const char *text, int width, int wrap)
 144 {
 145         const char *ptr = text;
 146         int count;
 147         int length = strlen(text);
 148         int h;
 149         int fheight = WMFontHeight(font);
 150
 151         h = 0;
 152         while (length > 0) {
 153                 count = fitText(ptr, font, width, wrap);
 154
 155                 h += fheight;
 156
 157                 if (isspace(ptr[count]))
 158                         count++;
 159
 160                 ptr += count;
 161                 length -= count;
 162         }
 163         return h;
 164 }
 165
 166 void
 167 W_PaintText(W_View * view, Drawable d, WMFont * font, int x, int y,
 168             int width, WMAlignment alignment, WMColor * color, int wrap,
 169             const char *text, int length)
 170 {
 171         const char *ptr = text;
 172         int line_width;
 173         int line_x;
 174         int count;
 175         int fheight = WMFontHeight(font);
 176
 177         while (length > 0) {
 178                 count = fitText(ptr, font, width, wrap);
 179
 180                 line_width = WMWidthOfString(font, ptr, count);
 181                 if (alignment == WALeft)
 182                         line_x = x;
 183                 else if (alignment == WARight)
 184                         line_x = x + width - line_width;
 185                 else
 186                         line_x = x + (width - line_width) / 2;
 187
 188                 WMDrawString(view->screen, d, color, font, line_x, y, ptr, count);
 189
 190                 if (wrap && ptr[count] != '\n')
 191                         y += fheight;
 192
 193                 while (ptr[count] && ptr[count] == '\n') {
 194                         y += fheight;
 195                         count++;
 196                 }
 197
 198                 ptr += count;
 199                 length -= count;
 200         }
 201 }
 202
 203 void
 204 W_PaintTextAndImage(W_View * view, int wrap, WMColor * textColor, W_Font * font,
 205                     WMReliefType relief, const char *text,
 206                     WMAlignment alignment, W_Pixmap * image,
 207                     WMImagePosition position, WMColor * backColor, int ofs)
 208 {
 209         W_Screen *screen = view->screen;
 210         int ix, iy;
 211         int x, y, w, h;
 212         Drawable d = view->window;
 213
 214 #ifdef DOUBLE_BUFFER
 215         d = XCreatePixmap(screen->display, view->window, view->size.width, view->size.height, screen->depth);
 216 #endif
 217
 218         /* background */
 219         if (backColor) {
 220                 XFillRectangle(screen->display, d, WMColorGC(backColor),
 221                                0, 0, view->size.width, view->size.height);
 222         } else {
 223 #ifndef DOUBLE_BUFFER
 224                 XClearWindow(screen->display, d);
 225 #else
 226                 XSetForeground(screen->display, screen->copyGC, view->attribs.background_pixel);
 227                 XFillRectangle(screen->display, d, screen->copyGC, 0, 0, view->size.width, view->size.height);
 228 #endif
 229         }
 230
 231         if (relief == WRFlat) {
 232                 x = 0;
 233                 y = 0;
 234                 w = view->size.width;
 235                 h = view->size.height;
 236         } else {
 237                 x = 1;
 238                 y = 1;
 239                 w = view->size.width - 3;
 240                 h = view->size.height - 3;
 241         }
 242
 243         /* calc. image alignment */
 244         if (position != WIPNoImage && image != NULL) {
 245                 switch (position) {
 246                 case WIPOverlaps:
 247                 case WIPImageOnly:
 248                         ix = (view->size.width - image->width) / 2;
 249                         iy = (view->size.height - image->height) / 2;
 250                         /*
 251                            x = 2;
 252                            y = 0;
 253                          */
 254                         break;
 255
 256                 case WIPLeft:
 257                         ix = x;
 258                         iy = y + (h - image->height) / 2;
 259                         x = x + image->width + 5;
 260                         y = 0;
 261                         w -= image->width + 5;
 262                         break;
 263
 264                 case WIPRight:
 265                         ix = view->size.width - image->width - x;
 266                         iy = y + (h - image->height) / 2;
 267                         w -= image->width + 5;
 268                         break;
 269
 270                 case WIPBelow:
 271                         ix = (view->size.width - image->width) / 2;
 272                         iy = h - image->height;
 273                         y = 0;
 274                         h -= image->height;
 275                         break;
 276
 277                 default:
 278                 case WIPAbove:
 279                         ix = (view->size.width - image->width) / 2;
 280                         iy = y;
 281                         y = image->height;
 282                         h -= image->height;
 283                         break;
 284                 }
 285
 286                 ix += ofs;
 287                 iy += ofs;
 288
 289                 XSetClipOrigin(screen->display, screen->clipGC, ix, iy);
 290                 XSetClipMask(screen->display, screen->clipGC, image->mask);
 291
 292                 if (image->depth == 1)
 293                         XCopyPlane(screen->display, image->pixmap, d, screen->clipGC,
 294                                    0, 0, image->width, image->height, ix, iy, 1);
 295                 else
 296                         XCopyArea(screen->display, image->pixmap, d, screen->clipGC,
 297                                   0, 0, image->width, image->height, ix, iy);
 298         }
 299
 300         /* draw text */
 301         if (position != WIPImageOnly && text != NULL) {
 302                 int textHeight;
 303
 304                 textHeight = W_GetTextHeight(font, text, w - 8, wrap);
 305                 W_PaintText(view, d, font, x + ofs + 4, y + ofs + (h - textHeight) / 2, w - 8,
 306                             alignment, textColor, wrap, text, strlen(text));
 307         }
 308
 309         /* draw relief */
 310         W_DrawRelief(screen, d, 0, 0, view->size.width, view->size.height, relief);
 311
 312 #ifdef DOUBLE_BUFFER
 313         XCopyArea(screen->display, d, view->window, screen->copyGC, 0, 0,
 314                   view->size.width, view->size.height, 0, 0);
 315         XFreePixmap(screen->display, d);
 316 #endif
 317 }
 318
 319 WMPoint wmkpoint(int x, int y)
 320 {
 321         WMPoint point;
 322
 323         point.x = x;
 324         point.y = y;
 325
 326         return point;
 327 }
 328
 329 WMSize wmksize(unsigned int width, unsigned int height)
 330 {
 331         WMSize size;
 332
 333         size.width = width;
 334         size.height = height;
 335
 336         return size;
 337 }
 338
 339 WMRect wmkrect(int x, int y, unsigned int width, unsigned int height)
 340 {
 341         WMRect rect;
 342
 343         rect.pos.x = x;
 344         rect.pos.y = y;
 345         rect.size.width = width;
 346         rect.size.height = height;
 347
 348         return rect;
 349 }