src/display/sp-ctrlquadr.cpp

   1 #define __INKSCAPE_CTRLQUADR_C__
   2
   3 /*
   4  * Quadrilateral
   5  *
   6  * Authors:
   7  *   bulia byak
   8  *
   9  * Copyright (C) 2005 authors
  10  *
  11  * Released under GNU GPL
  12  */
  13
  14 #include "display-forward.h"
  15 #include "sp-canvas-util.h"
  16 #include "sp-ctrlquadr.h"
  17
  18 #ifdef HAVE_CONFIG_H
  19 # include "config.h"
  20 #endif
  21 #include "display/inkscape-cairo.h"
  22 #include "color.h"
  23
  24 struct SPCtrlQuadr : public SPCanvasItem{
  25     guint32 rgba;
  26     NR::Point p1, p2, p3, p4;
  27     NR::Matrix affine;
  28 };
  29
  30 struct SPCtrlQuadrClass : public SPCanvasItemClass{};
  31
  32 static void sp_ctrlquadr_class_init (SPCtrlQuadrClass *klass);
  33 static void sp_ctrlquadr_init (SPCtrlQuadr *ctrlquadr);
  34 static void sp_ctrlquadr_destroy (GtkObject *object);
  35
  36 static void sp_ctrlquadr_update (SPCanvasItem *item, NR::Matrix const &affine, unsigned int flags);
  37 static void sp_ctrlquadr_render (SPCanvasItem *item, SPCanvasBuf *buf);
  38
  39 static SPCanvasItemClass *parent_class;
  40
  41 GtkType
  42 sp_ctrlquadr_get_type (void)
  43 {
  44     static GtkType type = 0;
  45
  46     if (!type) {
  47         GtkTypeInfo info = {
  48             "SPCtrlQuadr",
  49             sizeof (SPCtrlQuadr),
  50             sizeof (SPCtrlQuadrClass),
  51             (GtkClassInitFunc) sp_ctrlquadr_class_init,
  52             (GtkObjectInitFunc) sp_ctrlquadr_init,
  53             NULL, NULL, NULL
  54         };
  55         type = gtk_type_unique (SP_TYPE_CANVAS_ITEM, &info);
  56     }
  57     return type;
  58 }
  59
  60 static void
  61 sp_ctrlquadr_class_init (SPCtrlQuadrClass *klass)
  62 {
  63     GtkObjectClass *object_class = (GtkObjectClass *) klass;
  64     SPCanvasItemClass *item_class = (SPCanvasItemClass *) klass;
  65
  66     parent_class = (SPCanvasItemClass*)gtk_type_class (SP_TYPE_CANVAS_ITEM);
  67
  68     object_class->destroy = sp_ctrlquadr_destroy;
  69
  70     item_class->update = sp_ctrlquadr_update;
  71     item_class->render = sp_ctrlquadr_render;
  72 }
  73
  74 static void
  75 sp_ctrlquadr_init (SPCtrlQuadr *ctrlquadr)
  76 {
  77     ctrlquadr->rgba = 0x000000ff;
  78     ctrlquadr->p1 = NR::Point(0, 0);
  79     ctrlquadr->p2 = NR::Point(0, 0);
  80     ctrlquadr->p3 = NR::Point(0, 0);
  81     ctrlquadr->p4 = NR::Point(0, 0);
  82 }
  83
  84 static void
  85 sp_ctrlquadr_destroy (GtkObject *object)
  86 {
  87     g_return_if_fail (object != NULL);
  88     g_return_if_fail (SP_IS_CTRLQUADR (object));
  89
  90     if (GTK_OBJECT_CLASS (parent_class)->destroy)
  91         (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
  92 }
  93
  94 static void
  95 sp_ctrlquadr_render (SPCanvasItem *item, SPCanvasBuf *buf)
  96 {
  97     SPCtrlQuadr *cq = SP_CTRLQUADR (item);
  98
  99     NR::Rect area (NR::Point(buf->rect.x0, buf->rect.y0), NR::Point(buf->rect.x1, buf->rect.y1));
 100
 101     if (!buf->ct)
 102         return;
 103
 104     // RGB / BGR
 105     cairo_new_path(buf->ct);
 106
 107     NR::Point min = NR::Point(buf->rect.x0, buf->rect.y0);
 108
 109     NR::Point p1 = (cq->p1 * cq->affine) - min;
 110     NR::Point p2 = (cq->p2 * cq->affine) - min;
 111     NR::Point p3 = (cq->p3 * cq->affine) - min;
 112     NR::Point p4 = (cq->p4 * cq->affine) - min;
 113
 114     cairo_move_to(buf->ct, p1[NR::X], p1[NR::Y]);
 115     cairo_line_to(buf->ct, p2[NR::X], p2[NR::Y]);
 116     cairo_line_to(buf->ct, p3[NR::X], p3[NR::Y]);
 117     cairo_line_to(buf->ct, p4[NR::X], p4[NR::Y]);
 118     cairo_line_to(buf->ct, p1[NR::X], p1[NR::Y]);
 119
 120     // FIXME: this is supposed to draw inverse but cairo apparently is unable of this trick :(
 121     //cairo_set_operator (buf->ct, CAIRO_OPERATOR_XOR);
 122
 123     cairo_set_source_rgba(buf->ct, SP_RGBA32_B_F(cq->rgba), SP_RGBA32_G_F(cq->rgba), SP_RGBA32_R_F(cq->rgba), SP_RGBA32_A_F(cq->rgba));
 124     cairo_fill(buf->ct);
 125 }
 126
 127 #define MIN4(a,b,c,d)\
 128    ((a <= b && a <= c && a <= d) ? a : \
 129     (b <= a && b <= c && b <= d) ? b : \
 130     (c <= a && c <= b && c <= d) ? c : \
 131     d )
 132
 133 #define MAX4(a,b,c,d)\
 134    ((a >= b && a >= c && a >= d) ? a : \
 135     (b >= a && b >= c && b >= d) ? b : \
 136     (c >= a && c >= b && c >= d) ? c : \
 137     d )
 138
 139
 140 static void
 141 sp_ctrlquadr_update (SPCanvasItem *item, NR::Matrix const &affine, unsigned int flags)
 142 {
 143     SPCtrlQuadr *cq = SP_CTRLQUADR (item);
 144
 145     sp_canvas_request_redraw (item->canvas, (int)item->x1, (int)item->y1, (int)item->x2, (int)item->y2);
 146
 147     if (parent_class->update)
 148         (* parent_class->update) (item, affine, flags);
 149
 150     sp_canvas_item_reset_bounds (item);
 151
 152     cq->affine = affine;
 153
 154     NR::Point p1(cq->p1 * affine);
 155     NR::Point p2(cq->p2 * affine);
 156     NR::Point p3(cq->p3 * affine);
 157     NR::Point p4(cq->p4 * affine);
 158
 159     item->x1 = (int)(MIN4(p1[NR::X], p2[NR::X], p3[NR::X], p4[NR::X]));
 160     item->y1 = (int)(MIN4(p1[NR::Y], p2[NR::Y], p3[NR::Y], p4[NR::Y]));
 161     item->x2 = (int)(MAX4(p1[NR::X], p2[NR::X], p3[NR::X], p4[NR::X]));
 162     item->y2 = (int)(MAX4(p1[NR::Y], p2[NR::Y], p3[NR::Y], p4[NR::Y]));
 163
 164     sp_canvas_request_redraw (item->canvas, (int)item->x1, (int)item->y1, (int)item->x2, (int)item->y2);
 165 }
 166
 167 void
 168 sp_ctrlquadr_set_rgba32 (SPCtrlQuadr *cl, guint32 rgba)
 169 {
 170     g_return_if_fail (cl != NULL);
 171     g_return_if_fail (SP_IS_CTRLQUADR (cl));
 172
 173     if (rgba != cl->rgba) {
 174         SPCanvasItem *item;
 175         cl->rgba = rgba;
 176         item = SP_CANVAS_ITEM (cl);
 177         sp_canvas_request_redraw (item->canvas, (int)item->x1, (int)item->y1, (int)item->x2, (int)item->y2);
 178     }
 179 }
 180
 181 void
 182 sp_ctrlquadr_set_coords (SPCtrlQuadr *cl, NR::Point p1, NR::Point p2, NR::Point p3, NR::Point p4)
 183 {
 184     g_return_if_fail (cl != NULL);
 185     g_return_if_fail (SP_IS_CTRLQUADR (cl));
 186
 187     if (p1 != cl->p1 || p2 != cl->p2 || p3 != cl->p3 || p4 != cl->p4) {
 188         cl->p1 = p1;
 189         cl->p2 = p2;
 190         cl->p3 = p3;
 191         cl->p4 = p4;
 192         sp_canvas_item_request_update (SP_CANVAS_ITEM (cl));
 193     }
 194 }
 195
 196 /*
 197   Local Variables:
 198   mode:c++
 199   c-file-style:"stroustrup"
 200   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 201   indent-tabs-mode:nil
 202   fill-column:99
 203   End:
 204 */
 205 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :