WINGs/wprogressindicator.c

   1 /*
   2  * Original idea and implementation by Frederik Schueler <fr.schueler@netsurf.de>
   3  * Rewritten by Pascal Hofstee <daeron@windowmaker.org>
   4  * - Added options to set min/max values
   5  * - centralized drawing into one pain function
   6  */
   7
   8 #include "WINGsP.h"
   9
  10 typedef struct W_ProgressIndicator {
  11     W_Class     widgetClass;
  12     W_View      *view;
  13
  14     int value;
  15     int minValue;
  16     int maxValue;
  17
  18     void        *clientData;
  19 } ProgressIndicator;
  20
  21
  22 #define DEFAULT_PROGRESS_INDICATOR_WIDTH        276
  23 #define DEFAULT_PROGRESS_INDICATOR_HEIGHT       16
  24
  25 /* define if only the ticks within the progress region should be displayed */
  26 #undef SHOW_PROGRESS_TICKS_ONLY
  27
  28
  29 static void didResizeProgressIndicator();
  30
  31
  32 W_ViewDelegate _ProgressIndicatorDelegate = {
  33     NULL,
  34     NULL,
  35     didResizeProgressIndicator,
  36     NULL,
  37     NULL
  38 };
  39
  40
  41 static void destroyProgressIndicator(ProgressIndicator *pPtr);
  42 static void paintProgressIndicator(ProgressIndicator *pPtr);
  43 static void handleEvents(XEvent *event, void *data);
  44
  45
  46
  47 WMProgressIndicator*
  48 WMCreateProgressIndicator(WMWidget *parent)
  49 {
  50     ProgressIndicator *pPtr;
  51
  52     pPtr = wmalloc(sizeof(ProgressIndicator));
  53     memset(pPtr, 0, sizeof(ProgressIndicator));
  54
  55     pPtr->widgetClass = WC_ProgressIndicator;
  56
  57     pPtr->view = W_CreateView(W_VIEW(parent));
  58     if (!pPtr->view) {
  59         wfree(pPtr);
  60         return NULL;
  61     }
  62
  63     pPtr->view->self = pPtr;
  64
  65     pPtr->view->delegate = &_ProgressIndicatorDelegate;
  66
  67     WMCreateEventHandler(pPtr->view, ExposureMask|StructureNotifyMask,
  68                          handleEvents, pPtr);
  69
  70
  71     W_ResizeView(pPtr->view, DEFAULT_PROGRESS_INDICATOR_WIDTH,
  72                  DEFAULT_PROGRESS_INDICATOR_HEIGHT);
  73
  74     /* Initialize ProgressIndicator Values */
  75     pPtr->value = 0;
  76     pPtr->minValue = 0;
  77     pPtr->maxValue = 100;
  78
  79     return pPtr;
  80 }
  81
  82
  83 void
  84 WMSetProgressIndicatorMinValue(WMProgressIndicator *progressindicator, int value)
  85 {
  86     CHECK_CLASS(progressindicator, WC_ProgressIndicator);
  87
  88     progressindicator->minValue = value;
  89     if (progressindicator->value < value) {
  90         progressindicator->value = value;
  91         if (progressindicator->view->flags.mapped) {
  92             paintProgressIndicator(progressindicator);
  93         }
  94     }
  95 }
  96
  97
  98 void
  99 WMSetProgressIndicatorMaxValue(WMProgressIndicator *progressindicator, int value)
 100 {
 101     CHECK_CLASS(progressindicator, WC_ProgressIndicator);
 102
 103     progressindicator->maxValue = value;
 104     if (progressindicator->value > value) {
 105         progressindicator->value = value;
 106         if (progressindicator->view->flags.mapped) {
 107             paintProgressIndicator(progressindicator);
 108         }
 109     }
 110 }
 111
 112
 113 void
 114 WMSetProgressIndicatorValue(WMProgressIndicator *progressindicator, int value)
 115 {
 116     CHECK_CLASS(progressindicator, WC_ProgressIndicator);
 117
 118     progressindicator->value = value;
 119
 120     /* Check if value is within min/max-range */
 121     if (progressindicator->minValue > value)
 122         progressindicator->value = progressindicator->minValue;
 123
 124     if (progressindicator->maxValue < value)
 125         progressindicator->value = progressindicator->maxValue;
 126
 127
 128     if (progressindicator->view->flags.mapped) {
 129         paintProgressIndicator(progressindicator);
 130     }
 131 }
 132
 133
 134 int
 135 WMGetProgressIndicatorMinValue(WMProgressIndicator *progressindicator)
 136 {
 137     CHECK_CLASS(progressindicator, WC_ProgressIndicator);
 138
 139     return progressindicator->minValue;
 140 }
 141
 142
 143 int
 144 WMGetProgressIndicatorMaxValue(WMProgressIndicator *progressindicator)
 145 {
 146     CHECK_CLASS(progressindicator, WC_ProgressIndicator);
 147
 148     return progressindicator->maxValue;
 149 }
 150
 151
 152 int
 153 WMGetProgressIndicatorValue(WMProgressIndicator *progressindicator)
 154 {
 155     CHECK_CLASS(progressindicator, WC_ProgressIndicator);
 156
 157     return progressindicator->value;
 158 }
 159
 160
 161 static void
 162 didResizeProgressIndicator(W_ViewDelegate *self, WMView *view)
 163 {
 164     WMProgressIndicator *pPtr = (WMProgressIndicator*)view->self;
 165     int width = pPtr->view->size.width;
 166     int height = pPtr->view->size.height;
 167
 168     assert(width > 0);
 169     assert(height > 0);
 170 }
 171
 172
 173 static void
 174 paintProgressIndicator(ProgressIndicator *pPtr)
 175 {
 176     W_Screen *scr = pPtr->view->screen;
 177     GC bgc;
 178     GC wgc;
 179     GC lgc;
 180     GC dgc;
 181     WMSize size = pPtr->view->size;
 182     int perc, w, h;
 183     double unit, i;
 184     Pixmap buffer;
 185
 186     bgc = WMColorGC(scr->black);
 187     wgc = WMColorGC(scr->white);
 188     lgc = WMColorGC(scr->gray);
 189     dgc = WMColorGC(scr->darkGray);
 190
 191     unit = (double)(size.width - 3.0) / 100;
 192
 193     buffer = XCreatePixmap(scr->display, pPtr->view->window,
 194                            size.width, size.height, scr->depth);
 195
 196     XFillRectangle(scr->display, buffer, lgc, 0, 0, size.width, size.height);
 197
 198     /* Calculate size of Progress to draw and paint ticks*/
 199     perc = (pPtr->value - pPtr->minValue) * 100 / (pPtr->maxValue - pPtr->minValue);
 200
 201     w = (int)((double)(perc * unit));
 202     h = size.height - 2;
 203
 204     if (w > (size.width - 3))
 205         w = size.width - 3;
 206
 207     if (w > 0) {
 208         XFillRectangle(scr->display, buffer, lgc, 2, 1, w, h);
 209         XFillRectangle(scr->display, buffer, scr->stippleGC, 2, 1, w, h);
 210         W_DrawRelief(scr, buffer, 2, 1, w, h, WRFlat);
 211
 212         /* Draw Progress Marks */
 213         i=(5.0*unit);
 214
 215 #ifdef SHOW_PROGRESS_TICKS_ONLY
 216         while((int)i<w+5) {
 217 #else
 218         while ((int)i < (size.width - 3)) {
 219 #endif
 220             XDrawLine(scr->display, buffer, dgc, (int)i+2, h-1, i+2, h-3);
 221
 222             i+=(5.0*unit);
 223
 224 #ifdef SHOW_PROGRESS_TICKS_ONLY
 225             if((int)i>=w)
 226                 break;
 227 #endif
 228
 229             XDrawLine(scr->display, buffer, dgc, (int)i+2, h-1, i+2, h-6);
 230
 231             i+=(5.0*unit);
 232         }
 233     }
 234
 235     XDrawLine(scr->display, buffer, bgc, w+2, 1, w+2, h+1);
 236     XDrawLine(scr->display, buffer, lgc, 2, h, w+2, h);
 237
 238
 239     XDrawLine(scr->display, buffer, dgc, 0, 0, 0, size.height-1);
 240     XDrawLine(scr->display, buffer, dgc, 0, 0, size.width, 0);
 241     XDrawLine(scr->display, buffer, bgc, 1, 1, 1, size.height-1);
 242     XDrawLine(scr->display, buffer, bgc, 1, 1, size.width-1, 1);
 243
 244     XDrawLine(scr->display, buffer, wgc, size.width-1, 0,
 245               size.width-1, size.height-1);
 246     XDrawLine(scr->display, buffer, wgc, 0, size.height-1,
 247               size.width-1, size.height-1);
 248
 249     XCopyArea(scr->display, buffer, pPtr->view->window, scr->copyGC, 0, 0,
 250               size.width, size.height, 0, 0);
 251
 252     XFreePixmap(scr->display, buffer);
 253 }
 254
 255
 256 static void
 257 handleEvents(XEvent *event, void *data)
 258 {
 259     ProgressIndicator *pPtr = (ProgressIndicator*)data;
 260
 261     CHECK_CLASS(data, WC_ProgressIndicator);
 262
 263     switch (event->type) {
 264      case Expose:
 265         if (event->xexpose.count!=0)
 266             break;
 267         paintProgressIndicator(pPtr);
 268         break;
 269      case DestroyNotify:
 270         destroyProgressIndicator(pPtr);
 271         break;
 272     }
 273 }
 274
 275
 276 static void
 277 destroyProgressIndicator(ProgressIndicator *pPtr)
 278 {
 279     WMRemoveNotificationObserver(pPtr);
 280
 281     wfree(pPtr);
 282 }
 283