src/apps/icon-o-matic/import_export/svg/SVGGradients.cpp

   1 /*
   2  * Copyright 2006, Haiku. All rights reserved.
   3  * Distributed under the terms of the MIT License.
   4  *
   5  * Authors:
   6  *              Stephan Aßmus <superstippi@gmx.de>
   7  */
   8
   9
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12
  13 #include "GradientTransformable.h"
  14
  15 #include "SVGGradients.h"
  16
  17 namespace agg {
  18 namespace svg {
  19
  20 // constructor
  21 SVGGradient::SVGGradient()
  22         : BMessage(),
  23           fGradient(NULL),
  24           fID(""),
  25           fGradientUnits(UNSPECIFIED)
  26 {
  27 }
  28
  29 // destructor
  30 SVGGradient::~SVGGradient()
  31 {
  32 }
  33
  34 // SetID
  35 void
  36 SVGGradient::SetID(const char* id)
  37 {
  38         fID = id;
  39 }
  40
  41 // ID
  42 const char*
  43 SVGGradient::ID() const
  44 {
  45         return fID.String();
  46 }
  47
  48 // AddStop
  49 void
  50 SVGGradient::AddStop(float offset, rgba8 color)
  51 {
  52         if (!fGradient)
  53                 fGradient = MakeGradient();
  54
  55         rgb_color c = { color.r, color.g, color.b, color.a };
  56         fGradient->AddColor(c, offset);
  57 }
  58
  59 // SetTransformation
  60 void
  61 SVGGradient::SetTransformation(const trans_affine& transform)
  62 {
  63 //printf("SVGGradient::SetTransformation()\n");
  64         if (!fGradient)
  65                 fGradient = MakeGradient();
  66
  67         fGradient->multiply(transform);
  68 }
  69
  70 // GetGradient
  71 Gradient*
  72 SVGGradient::GetGradient(BRect objectBounds)
  73 {
  74         if (fGradient) {
  75                 Gradient* gradient = new Gradient(*fGradient);
  76
  77                 IdentifyGradientUnits();
  78                 if (fGradientUnits == OBJECT_BOUNDING_BOX) {
  79                         gradient->FitToBounds(objectBounds);
  80                 }
  81
  82                 return gradient;
  83         }
  84         return NULL;
  85 }
  86
  87 // IdentifyGradientUnits
  88 void
  89 SVGGradient::IdentifyGradientUnits()
  90 {
  91         if (fGradientUnits == UNSPECIFIED) {
  92                 const char* units;
  93                 if (FindString("gradientUnits", &units) >= B_OK) {
  94                         if (strcmp(units, "objectBoundingBox") == 0)
  95                                 fGradientUnits = OBJECT_BOUNDING_BOX;
  96                 }
  97         }
  98 }
  99
 100 // constructor
 101 SVGLinearGradient::SVGLinearGradient()
 102         : SVGGradient()
 103 {
 104 }
 105
 106 // destructor
 107 SVGLinearGradient::~SVGLinearGradient()
 108 {
 109 }
 110
 111 // MakeGradient
 112 Gradient*
 113 SVGLinearGradient::MakeGradient() const
 114 {
 115 //printf("SVGLinearGradient::MakeGradient()\n");
 116 //PrintToStream();
 117
 118         Gradient* gradient = new Gradient(true);
 119         gradient->SetType(GRADIENT_LINEAR);
 120         gradient->SetInterpolation(INTERPOLATION_LINEAR);
 121         // setup the gradient transform
 122         BPoint start(-64.0, -64.0);
 123         BPoint end(64.0, -64.0);
 124         BString coordinate;
 125         if (FindString("x1", &coordinate) >= B_OK)
 126                 start.x = atof(coordinate.String());
 127         if (FindString("y1", &coordinate) >= B_OK)
 128                 start.y = atof(coordinate.String());
 129         if (FindString("x2", &coordinate) >= B_OK)
 130                 end.x = atof(coordinate.String());
 131         if (FindString("y2", &coordinate) >= B_OK)
 132                 end.y = atof(coordinate.String());
 133
 134         // the transformed parallelogram
 135         double parl[6];
 136         parl[0] = start.x;
 137         parl[1] = start.y;
 138         parl[2] = end.x;
 139         parl[3] = end.y;
 140         parl[4] = end.x - (end.y - start.y);
 141         parl[5] = end.y + (end.x - start.x);
 142
 143         trans_affine transform(-64.0, -64.0, 64.0, 64.0, parl);
 144         gradient->multiply(transform);
 145
 146         return gradient;
 147 }
 148
 149 // constructor
 150 SVGRadialGradient::SVGRadialGradient()
 151         : SVGGradient()
 152 {
 153 }
 154
 155 // destructor
 156 SVGRadialGradient::~SVGRadialGradient()
 157 {
 158 }
 159
 160 // MakeGradient
 161 Gradient*
 162 SVGRadialGradient::MakeGradient() const
 163 {
 164 //printf("SVGRadialGradient::MakeGradient()\n");
 165         // TODO: handle userSpaceOnUse/objectBoundingBox
 166         Gradient* gradient = new Gradient(true);
 167         gradient->SetType(GRADIENT_CIRCULAR);
 168         gradient->SetInterpolation(INTERPOLATION_LINEAR);
 169
 170         double cx = 0.0;
 171         double cy = 0.0;
 172         double r = 100.0;
 173
 174         BString value;
 175         if (FindString("cx", &value) >= B_OK)
 176                 cx = atof(value.String());
 177         if (FindString("cy", &value) >= B_OK)
 178                 cy = atof(value.String());
 179         if (FindString("r", &value) >= B_OK)
 180                 r = atof(value.String());
 181
 182         // the transformed parallelogram
 183         double parl[6];
 184         parl[0] = cx - r;
 185         parl[1] = cy - r;
 186         parl[2] = cx + r;
 187         parl[3] = cy - r;
 188         parl[4] = cx + r;
 189         parl[5] = cy + r;
 190
 191         trans_affine transform(-64.0, -64.0, 64.0, 64.0, parl);
 192         gradient->multiply(transform);
 193
 194         return gradient;
 195 }
 196
 197 } // namespace svg
 198 } // namespace agg
 199