src/display/sodipodi-ctrlrect.cpp

   1 #define __INKSCAPE_CTRLRECT_C__
   2
   3 /*
   4  * Simple non-transformed rectangle, usable for rubberband
   5  *
   6  * Author:
   7  *   Lauris Kaplinski <lauris@ximian.com>
   8  *   bulia byak <buliabyak@users.sf.net>
   9  *   Carl Hetherington <inkscape@carlh.net>
  10  *
  11  * Copyright (C) 1999-2001 Lauris Kaplinski
  12  * Copyright (C) 2000-2001 Ximian, Inc.
  13  *
  14  * Released under GNU GPL
  15  *
  16  */
  17
  18 #include "display-forward.h"
  19 #include "sp-canvas-util.h"
  20 #include "sodipodi-ctrlrect.h"
  21
  22 /*
  23  * Currently we do not have point method, as it should always be painted
  24  * during some transformation, which takes care of events...
  25  *
  26  * Corner coords can be in any order - i.e. x1 < x0 is allowed
  27  */
  28
  29 static void sp_ctrlrect_class_init(SPCtrlRectClass *c);
  30 static void sp_ctrlrect_init(CtrlRect *ctrlrect);
  31 static void sp_ctrlrect_destroy(GtkObject *object);
  32
  33 static void sp_ctrlrect_update(SPCanvasItem *item, NR::Matrix const &affine, unsigned int flags);
  34 static void sp_ctrlrect_render(SPCanvasItem *item, SPCanvasBuf *buf);
  35
  36 static SPCanvasItemClass *parent_class;
  37
  38 static const guint DASH_LENGTH = 4;
  39
  40 GtkType sp_ctrlrect_get_type()
  41 {
  42     static GtkType ctrlrect_type = 0;
  43
  44     if (!ctrlrect_type) {
  45         GtkTypeInfo ctrlrect_info = {
  46             "SPCtrlRect",
  47             sizeof(CtrlRect),
  48             sizeof(SPCtrlRectClass),
  49             (GtkClassInitFunc) sp_ctrlrect_class_init,
  50             (GtkObjectInitFunc) sp_ctrlrect_init,
  51             NULL, NULL, NULL
  52         };
  53         ctrlrect_type = gtk_type_unique(SP_TYPE_CANVAS_ITEM, &ctrlrect_info);
  54     }
  55     return ctrlrect_type;
  56 }
  57
  58 static void sp_ctrlrect_class_init(SPCtrlRectClass *c)
  59 {
  60     GtkObjectClass *object_class = (GtkObjectClass *) c;
  61     SPCanvasItemClass *item_class = (SPCanvasItemClass *) c;
  62
  63     parent_class = (SPCanvasItemClass*) gtk_type_class(sp_canvas_item_get_type());
  64
  65     object_class->destroy = sp_ctrlrect_destroy;
  66
  67     item_class->update = sp_ctrlrect_update;
  68     item_class->render = sp_ctrlrect_render;
  69 }
  70
  71 static void sp_ctrlrect_init(CtrlRect *cr)
  72 {
  73     cr->init();
  74 }
  75
  76 static void sp_ctrlrect_destroy(GtkObject *object)
  77 {
  78     if (GTK_OBJECT_CLASS(parent_class)->destroy) {
  79         (* GTK_OBJECT_CLASS(parent_class)->destroy)(object);
  80     }
  81 }
  82
  83 /* FIXME: use definitions from somewhere else */
  84 #define RGBA_R(v) ((v) >> 24)
  85 #define RGBA_G(v) (((v) >> 16) & 0xff)
  86 #define RGBA_B(v) (((v) >> 8) & 0xff)
  87 #define RGBA_A(v) ((v) & 0xff)
  88 #define COMPOSE(b,f,a) ( ( ((guchar) b) * ((guchar) (0xff - a)) + ((guchar) ((b ^ ~f) + b/4 - (b>127? 63 : 0))) * ((guchar) a) ) / 0xff )
  89
  90 static void sp_ctrlrect_hline(SPCanvasBuf *buf, gint y, gint xs, gint xe, guint32 rgba, guint dashed)
  91 {
  92     if (y >= buf->rect.y0 && y < buf->rect.y1) {
  93         guint const r = RGBA_R(rgba);
  94         guint const g = RGBA_G(rgba);
  95         guint const b = RGBA_B(rgba);
  96         guint const a = RGBA_A(rgba);
  97         gint const x0 = MAX(buf->rect.x0, xs);
  98         gint const x1 = MIN(buf->rect.x1, xe + 1);
  99         guchar *p = buf->buf + (y - buf->rect.y0) * buf->buf_rowstride + (x0 - buf->rect.x0) * 3;
 100         for (gint x = x0; x < x1; x++) {
 101             if (!dashed || ((x / DASH_LENGTH) % 2)) {
 102                 p[0] = COMPOSE(p[0], r, a);
 103                 p[1] = COMPOSE(p[1], g, a);
 104                 p[2] = COMPOSE(p[2], b, a);
 105             }
 106             p += 3;
 107         }
 108     }
 109 }
 110
 111 static void sp_ctrlrect_vline(SPCanvasBuf *buf, gint x, gint ys, gint ye, guint32 rgba, guint dashed)
 112 {
 113     if (x >= buf->rect.x0 && x < buf->rect.x1) {
 114         guint const r = RGBA_R(rgba);
 115         guint const g = RGBA_G(rgba);
 116         guint const b = RGBA_B(rgba);
 117         guint const a = RGBA_A(rgba);
 118         gint const y0 = MAX(buf->rect.y0, ys);
 119         gint const y1 = MIN(buf->rect.y1, ye + 1);
 120         guchar *p = buf->buf + (y0 - buf->rect.y0) * buf->buf_rowstride + (x - buf->rect.x0) * 3;
 121         for (gint y = y0; y < y1; y++) {
 122             if (!dashed || ((y / DASH_LENGTH) % 2)) {
 123                 p[0] = COMPOSE(p[0], r, a);
 124                 p[1] = COMPOSE(p[1], g, a);
 125                 p[2] = COMPOSE(p[2], b, a);
 126             }
 127             p += buf->buf_rowstride;
 128         }
 129     }
 130 }
 131
 132 /** Fills the pixels in [xs, xe)*[ys,ye) clipped to the tile with rgb * a. */
 133 static void sp_ctrlrect_area(SPCanvasBuf *buf, gint xs, gint ys, gint xe, gint ye, guint32 rgba)
 134 {
 135     guint const r = RGBA_R(rgba);
 136     guint const g = RGBA_G(rgba);
 137     guint const b = RGBA_B(rgba);
 138     guint const a = RGBA_A(rgba);
 139     gint const x0 = MAX(buf->rect.x0, xs);
 140     gint const x1 = MIN(buf->rect.x1, xe + 1);
 141     gint const y0 = MAX(buf->rect.y0, ys);
 142     gint const y1 = MIN(buf->rect.y1, ye + 1);
 143     for (gint y = y0; y < y1; y++) {
 144         guchar *p = buf->buf + (y - buf->rect.y0) * buf->buf_rowstride + (x0 - buf->rect.x0) * 3;
 145         for (gint x = x0; x < x1; x++) {
 146             p[0] = COMPOSE(p[0], r, a);
 147             p[1] = COMPOSE(p[1], g, a);
 148             p[2] = COMPOSE(p[2], b, a);
 149             p += 3;
 150         }
 151     }
 152 }
 153
 154 static void sp_ctrlrect_render(SPCanvasItem *item, SPCanvasBuf *buf)
 155 {
 156     SP_CTRLRECT(item)->render(buf);
 157 }
 158
 159
 160 static void sp_ctrlrect_update(SPCanvasItem *item, NR::Matrix const &affine, unsigned int flags)
 161 {
 162     SP_CTRLRECT(item)->update(affine, flags);
 163 }
 164
 165
 166
 167 void CtrlRect::init()
 168 {
 169     _has_fill = false;
 170     _dashed = false;
 171     _shadow = 0;
 172
 173     _area.x0 = _area.y0 = 0;
 174     _area.x1 = _area.y1 = -1;
 175
 176     _shadow_size = 0;
 177
 178     _border_color = 0x000000ff;
 179     _fill_color = 0xffffffff;
 180     _shadow_color = 0x000000ff;
 181 }
 182
 183
 184 void CtrlRect::render(SPCanvasBuf *buf)
 185 {
 186     if ((_area.x0 < buf->rect.x1) &&
 187         (_area.y0 < buf->rect.y1) &&
 188         ((_area.x1 + _shadow_size) >= buf->rect.x0) &&
 189         ((_area.y1 + _shadow_size) >= buf->rect.y0)) {
 190         sp_canvas_prepare_buffer(buf);
 191
 192         /* Top */
 193         sp_ctrlrect_hline(buf, _area.y0, _area.x0, _area.x1, _border_color, _dashed);
 194         /* Bottom */
 195         sp_ctrlrect_hline(buf, _area.y1, _area.x0, _area.x1, _border_color, _dashed);
 196         /* Left */
 197         sp_ctrlrect_vline(buf, _area.x0, _area.y0 + 1, _area.y1 - 1, _border_color, _dashed);
 198         /* Right */
 199         sp_ctrlrect_vline(buf, _area.x1, _area.y0 + 1, _area.y1 - 1, _border_color, _dashed);
 200         if (_shadow_size > 0) {
 201             /* Right shadow */
 202             sp_ctrlrect_area(buf, _area.x1 + 1, _area.y0 + _shadow_size,
 203                              _area.x1 + _shadow_size, _area.y1 + _shadow_size, _shadow_color);
 204             /* Bottom shadow */
 205             sp_ctrlrect_area(buf, _area.x0 + _shadow_size, _area.y1 + 1,
 206                              _area.x1, _area.y1 + _shadow_size, _shadow_color);
 207         }
 208         if (_has_fill) {
 209             /* Fill */
 210             sp_ctrlrect_area(buf, _area.x0 + 1, _area.y0 + 1,
 211                              _area.x1 - 1, _area.y1 - 1, _fill_color);
 212         }
 213     }
 214 }
 215
 216
 217 void CtrlRect::update(NR::Matrix const &affine, unsigned int flags)
 218 {
 219     if (((SPCanvasItemClass *) parent_class)->update) {
 220         ((SPCanvasItemClass *) parent_class)->update(this, affine, flags);
 221     }
 222
 223     sp_canvas_item_reset_bounds(this);
 224
 225     /* Request redraw old */
 226     if (!_has_fill) {
 227         /* Top */
 228         sp_canvas_request_redraw(canvas,
 229                                  _area.x0 - 1, _area.y0 - 1,
 230                                  _area.x1 + 1, _area.y0 + 1);
 231         /* Left */
 232         sp_canvas_request_redraw(canvas,
 233                                  _area.x0 - 1, _area.y0 - 1,
 234                                  _area.x0 + 1, _area.y1 + 1);
 235         /* Right */
 236         sp_canvas_request_redraw(canvas,
 237                                  _area.x1 - 1, _area.y0 - 1,
 238                                  _area.x1 + _shadow_size + 1, _area.y1 + _shadow_size + 1);
 239         /* Bottom */
 240         sp_canvas_request_redraw(canvas,
 241                                  _area.x0 - 1, _area.y1 - 1,
 242                                  _area.x1 + _shadow_size + 1, _area.y1 + _shadow_size + 1);
 243     } else {
 244         sp_canvas_request_redraw(canvas,
 245                                  _area.x0 - 1, _area.y0 - 1,
 246                                  _area.x1 + _shadow_size + 1, _area.y1 + _shadow_size + 1);
 247     }
 248
 249     NR::Rect bbox(_rect.min() * affine, _rect.max() * affine);
 250
 251     _area.x0 = (int) floor(bbox.min()[NR::X] + 0.5);
 252     _area.y0 = (int) floor(bbox.min()[NR::Y] + 0.5);
 253     _area.x1 = (int) floor(bbox.max()[NR::X] + 0.5);
 254     _area.y1 = (int) floor(bbox.max()[NR::Y] + 0.5);
 255
 256     _shadow_size = _shadow;
 257
 258     /* Request redraw new */
 259     if (!_has_fill) {
 260         /* Top */
 261         sp_canvas_request_redraw(canvas,
 262                                  _area.x0 - 1, _area.y0 - 1,
 263                                  _area.x1 + 1, _area.y0 + 1);
 264         /* Left */
 265         sp_canvas_request_redraw(canvas,
 266                                  _area.x0 - 1, _area.y0 - 1,
 267                                  _area.x0 + 1, _area.y1 + 1);
 268         /* Right */
 269         sp_canvas_request_redraw(canvas,
 270                                  _area.x1 - 1, _area.y0 - 1,
 271                                  _area.x1 + _shadow_size + 1, _area.y1 + _shadow_size + 1);
 272         /* Bottom */
 273         sp_canvas_request_redraw(canvas,
 274                                  _area.x0 - 1, _area.y1 - 1,
 275                                  _area.x1 + _shadow_size + 1, _area.y1 + _shadow_size + 1);
 276     } else {
 277         sp_canvas_request_redraw(canvas,
 278                                  _area.x0 - 1, _area.y0 - 1,
 279                                  _area.x1 + _shadow_size + 1, _area.y1 + _shadow_size + 1);
 280     }
 281
 282     x1 = _area.x0 - 1;
 283     y1 = _area.y0 - 1;
 284     x2 = _area.x1 + _shadow_size + 1;
 285     y2 = _area.y1 + _shadow_size + 1;
 286 }
 287
 288
 289 void CtrlRect::setColor(guint32 b, bool h, guint f)
 290 {
 291     _border_color = b;
 292     _has_fill = h;
 293     _fill_color = f;
 294     _requestUpdate();
 295 }
 296
 297 void CtrlRect::setShadow(int s, guint c)
 298 {
 299     _shadow = s;
 300     _shadow_color = c;
 301     _requestUpdate();
 302 }
 303
 304 void CtrlRect::setRectangle(NR::Rect const &r)
 305 {
 306     _rect = r;
 307     _requestUpdate();
 308 }
 309
 310 void CtrlRect::setDashed(bool d)
 311 {
 312     _dashed = d;
 313     _requestUpdate();
 314 }
 315
 316 void CtrlRect::_requestUpdate()
 317 {
 318     sp_canvas_item_request_update(SP_CANVAS_ITEM(this));
 319 }
 320
 321 /*
 322   Local Variables:
 323   mode:c++
 324   c-file-style:"stroustrup"
 325   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 326   indent-tabs-mode:nil
 327   fill-column:99
 328   End:
 329 */
 330 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :