| OLD | NEW |
|---|
| (Empty) |
| 1 /* libs/graphics/animator/SkDrawMatrix.cpp | |
| 2 ** | |
| 3 ** Copyright 2006, The Android Open Source Project | |
| 4 ** | |
| 5 ** Licensed under the Apache License, Version 2.0 (the "License"); | |
| 6 ** you may not use this file except in compliance with the License. | |
| 7 ** You may obtain a copy of the License at | |
| 8 ** | |
| 9 ** http://www.apache.org/licenses/LICENSE-2.0 | |
| 10 ** | |
| 11 ** Unless required by applicable law or agreed to in writing, software | |
| 12 ** distributed under the License is distributed on an "AS IS" BASIS, | |
| 13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| 14 ** See the License for the specific language governing permissions and | |
| 15 ** limitations under the License. | |
| 16 */ | |
| 17 | |
| 18 #include "SkDrawMatrix.h" | |
| 19 #include "SkAnimateMaker.h" | |
| 20 #include "SkCanvas.h" | |
| 21 #include "SkPaint.h" | |
| 22 #include "SkParse.h" | |
| 23 #include "SkMatrixParts.h" | |
| 24 #include "SkScript.h" | |
| 25 #include "SkTypedArray.h" | |
| 26 | |
| 27 enum SkDrawMatrix_Properties { | |
| 28 SK_PROPERTY(perspectX), | |
| 29 SK_PROPERTY(perspectY), | |
| 30 SK_PROPERTY(rotate), | |
| 31 SK_PROPERTY(scale), | |
| 32 SK_PROPERTY(scaleX), | |
| 33 SK_PROPERTY(scaleY), | |
| 34 SK_PROPERTY(skewX), | |
| 35 SK_PROPERTY(skewY), | |
| 36 SK_PROPERTY(translate), | |
| 37 SK_PROPERTY(translateX), | |
| 38 SK_PROPERTY(translateY) | |
| 39 }; | |
| 40 | |
| 41 #if SK_USE_CONDENSED_INFO == 0 | |
| 42 | |
| 43 const SkMemberInfo SkDrawMatrix::fInfo[] = { | |
| 44 SK_MEMBER_ARRAY(matrix, Float), | |
| 45 SK_MEMBER_PROPERTY(perspectX, Float), | |
| 46 SK_MEMBER_PROPERTY(perspectY, Float), | |
| 47 SK_MEMBER_PROPERTY(rotate, Float), | |
| 48 SK_MEMBER_PROPERTY(scale, Float), | |
| 49 SK_MEMBER_PROPERTY(scaleX, Float), | |
| 50 SK_MEMBER_PROPERTY(scaleY, Float), | |
| 51 SK_MEMBER_PROPERTY(skewX, Float), | |
| 52 SK_MEMBER_PROPERTY(skewY, Float), | |
| 53 SK_MEMBER_PROPERTY(translate, Point), | |
| 54 SK_MEMBER_PROPERTY(translateX, Float), | |
| 55 SK_MEMBER_PROPERTY(translateY, Float) | |
| 56 }; | |
| 57 | |
| 58 #endif | |
| 59 | |
| 60 DEFINE_GET_MEMBER(SkDrawMatrix); | |
| 61 | |
| 62 SkDrawMatrix::SkDrawMatrix() : fChildHasID(false), fDirty(false) { | |
| 63 fConcat.reset(); | |
| 64 fMatrix.reset(); | |
| 65 } | |
| 66 | |
| 67 SkDrawMatrix::~SkDrawMatrix() { | |
| 68 for (SkMatrixPart** part = fParts.begin(); part < fParts.end(); part++) | |
| 69 delete *part; | |
| 70 } | |
| 71 | |
| 72 bool SkDrawMatrix::add(SkAnimateMaker& maker, SkDisplayable* child) { | |
| 73 SkASSERT(child && child->isMatrixPart()); | |
| 74 SkMatrixPart* part = (SkMatrixPart*) child; | |
| 75 *fParts.append() = part; | |
| 76 if (part->add()) | |
| 77 maker.setErrorCode(SkDisplayXMLParserError::kErrorAddingToMatrix); | |
| 78 return true; | |
| 79 } | |
| 80 | |
| 81 bool SkDrawMatrix::childrenNeedDisposing() const { | |
| 82 return false; | |
| 83 } | |
| 84 | |
| 85 SkDisplayable* SkDrawMatrix::deepCopy(SkAnimateMaker* maker) { | |
| 86 SkDrawMatrix* copy = (SkDrawMatrix*) | |
| 87 SkDisplayType::CreateInstance(maker, SkType_Matrix); | |
| 88 SkASSERT(fParts.count() == 0); | |
| 89 copy->fMatrix = fMatrix; | |
| 90 copy->fConcat = fConcat; | |
| 91 return copy; | |
| 92 } | |
| 93 | |
| 94 void SkDrawMatrix::dirty() { | |
| 95 fDirty = true; | |
| 96 } | |
| 97 | |
| 98 bool SkDrawMatrix::draw(SkAnimateMaker& maker) { | |
| 99 SkMatrix& concat = getMatrix(); | |
| 100 maker.fCanvas->concat(concat); | |
| 101 return false; | |
| 102 } | |
| 103 | |
| 104 #ifdef SK_DUMP_ENABLED | |
| 105 void SkDrawMatrix::dump(SkAnimateMaker* maker) { | |
| 106 dumpBase(maker); | |
| 107 if (fMatrix.isIdentity()) { | |
| 108 SkDebugf("matrix=\"identity\"/>\n"); | |
| 109 return; | |
| 110 } | |
| 111 SkScalar result; | |
| 112 result = fMatrix[SkMatrix::kMScaleX]; | |
| 113 if (result != SK_Scalar1) | |
| 114 SkDebugf("sx=\"%g\" ", SkScalarToFloat(result)); | |
| 115 result = fMatrix.getScaleY(); | |
| 116 if (result != SK_Scalar1) | |
| 117 SkDebugf("sy=\"%g\" ", SkScalarToFloat(result)); | |
| 118 result = fMatrix.getSkewX(); | |
| 119 if (result) | |
| 120 SkDebugf("skew-x=\"%g\" ", SkScalarToFloat(result)); | |
| 121 result = fMatrix.getSkewY(); | |
| 122 if (result) | |
| 123 SkDebugf("skew-y=\"%g\" ", SkScalarToFloat(result)); | |
| 124 result = fMatrix.getTranslateX(); | |
| 125 if (result) | |
| 126 SkDebugf("tx=\"%g\" ", SkScalarToFloat(result)); | |
| 127 result = fMatrix.getTranslateY(); | |
| 128 if (result) | |
| 129 SkDebugf("ty=\"%g\" ", SkScalarToFloat(result)); | |
| 130 result = fMatrix.getPerspX(); | |
| 131 if (result) | |
| 132 SkDebugf("perspect-x=\"%g\" ", SkScalarToFloat(result)); | |
| 133 result = fMatrix.getPerspY(); | |
| 134 if (result) | |
| 135 SkDebugf("perspect-y=\"%g\" ", SkScalarToFloat(result)); | |
| 136 SkDebugf("/>\n"); | |
| 137 } | |
| 138 #endif | |
| 139 | |
| 140 SkMatrix& SkDrawMatrix::getMatrix() { | |
| 141 if (fDirty == false) | |
| 142 return fConcat; | |
| 143 fMatrix.reset(); | |
| 144 for (SkMatrixPart** part = fParts.begin(); part < fParts.end(); part++) { | |
| 145 (*part)->add(); | |
| 146 fConcat = fMatrix; | |
| 147 } | |
| 148 fDirty = false; | |
| 149 return fConcat; | |
| 150 } | |
| 151 | |
| 152 bool SkDrawMatrix::getProperty(int index, SkScriptValue* value) const { | |
| 153 value->fType = SkType_Float; | |
| 154 SkScalar result; | |
| 155 switch (index) { | |
| 156 case SK_PROPERTY(perspectX): | |
| 157 result = fMatrix.getPerspX(); | |
| 158 break; | |
| 159 case SK_PROPERTY(perspectY): | |
| 160 result = fMatrix.getPerspY(); | |
| 161 break; | |
| 162 case SK_PROPERTY(scaleX): | |
| 163 result = fMatrix.getScaleX(); | |
| 164 break; | |
| 165 case SK_PROPERTY(scaleY): | |
| 166 result = fMatrix.getScaleY(); | |
| 167 break; | |
| 168 case SK_PROPERTY(skewX): | |
| 169 result = fMatrix.getSkewX(); | |
| 170 break; | |
| 171 case SK_PROPERTY(skewY): | |
| 172 result = fMatrix.getSkewY(); | |
| 173 break; | |
| 174 case SK_PROPERTY(translateX): | |
| 175 result = fMatrix.getTranslateX(); | |
| 176 break; | |
| 177 case SK_PROPERTY(translateY): | |
| 178 result = fMatrix.getTranslateY(); | |
| 179 break; | |
| 180 default: | |
| 181 // SkASSERT(0); | |
| 182 return false; | |
| 183 } | |
| 184 value->fOperand.fScalar = result; | |
| 185 return true; | |
| 186 } | |
| 187 | |
| 188 void SkDrawMatrix::initialize() { | |
| 189 fConcat = fMatrix; | |
| 190 } | |
| 191 | |
| 192 void SkDrawMatrix::onEndElement(SkAnimateMaker& ) { | |
| 193 if (matrix.count() > 0) { | |
| 194 SkScalar* vals = matrix.begin(); | |
| 195 fMatrix.setScaleX(vals[0]); | |
| 196 fMatrix.setSkewX(vals[1]); | |
| 197 fMatrix.setTranslateX(vals[2]); | |
| 198 fMatrix.setSkewY(vals[3]); | |
| 199 fMatrix.setScaleY(vals[4]); | |
| 200 fMatrix.setTranslateY(vals[5]); | |
| 201 #ifdef SK_SCALAR_IS_FIXED | |
| 202 fMatrix.setPerspX(SkFixedToFract(vals[6])); | |
| 203 fMatrix.setPerspY(SkFixedToFract(vals[7])); | |
| 204 #else | |
| 205 fMatrix.setPerspX(vals[6]); | |
| 206 fMatrix.setPerspY(vals[7]); | |
| 207 #endif | |
| 208 // fMatrix.setPerspW(vals[8]); | |
| 209 goto setConcat; | |
| 210 } | |
| 211 if (fChildHasID == false) { | |
| 212 { | |
| 213 for (SkMatrixPart** part = fParts.begin(); part < fParts.end(); par
t++) | |
| 214 delete *part; | |
| 215 } | |
| 216 fParts.reset(); | |
| 217 setConcat: | |
| 218 fConcat = fMatrix; | |
| 219 fDirty = false; | |
| 220 } | |
| 221 } | |
| 222 | |
| 223 void SkDrawMatrix::setChildHasID() { | |
| 224 fChildHasID = true; | |
| 225 } | |
| 226 | |
| 227 bool SkDrawMatrix::setProperty(int index, SkScriptValue& scriptValue) { | |
| 228 SkScalar number = scriptValue.fOperand.fScalar; | |
| 229 switch (index) { | |
| 230 case SK_PROPERTY(translate): | |
| 231 // SkScalar xy[2]; | |
| 232 SkASSERT(scriptValue.fType == SkType_Array); | |
| 233 SkASSERT(scriptValue.fOperand.fArray->getType() == SkType_Float); | |
| 234 SkASSERT(scriptValue.fOperand.fArray->count() == 2); | |
| 235 // SkParse::FindScalars(scriptValue.fOperand.fString->c_str(), xy, 2); | |
| 236 fMatrix.setTranslateX((*scriptValue.fOperand.fArray)[0].fScalar); | |
| 237 fMatrix.setTranslateY((*scriptValue.fOperand.fArray)[1].fScalar); | |
| 238 return true; | |
| 239 case SK_PROPERTY(perspectX): | |
| 240 #ifdef SK_SCALAR_IS_FIXED | |
| 241 fMatrix.setPerspX(SkFixedToFract(number)); | |
| 242 #else | |
| 243 fMatrix.setPerspX(number); | |
| 244 #endif | |
| 245 break; | |
| 246 case SK_PROPERTY(perspectY): | |
| 247 #ifdef SK_SCALAR_IS_FIXED | |
| 248 fMatrix.setPerspY(SkFixedToFract(number)); | |
| 249 #else | |
| 250 fMatrix.setPerspY(number); | |
| 251 #endif | |
| 252 break; | |
| 253 case SK_PROPERTY(rotate): { | |
| 254 SkMatrix temp; | |
| 255 temp.setRotate(number, 0, 0); | |
| 256 fMatrix.setScaleX(temp.getScaleX()); | |
| 257 fMatrix.setScaleY(temp.getScaleY()); | |
| 258 fMatrix.setSkewX(temp.getSkewX()); | |
| 259 fMatrix.setSkewY(temp.getSkewY()); | |
| 260 } break; | |
| 261 case SK_PROPERTY(scale): | |
| 262 fMatrix.setScaleX(number); | |
| 263 fMatrix.setScaleY(number); | |
| 264 break; | |
| 265 case SK_PROPERTY(scaleX): | |
| 266 fMatrix.setScaleX(number); | |
| 267 break; | |
| 268 case SK_PROPERTY(scaleY): | |
| 269 fMatrix.setScaleY(number); | |
| 270 break; | |
| 271 case SK_PROPERTY(skewX): | |
| 272 fMatrix.setSkewX(number); | |
| 273 break; | |
| 274 case SK_PROPERTY(skewY): | |
| 275 fMatrix.setSkewY(number); | |
| 276 break; | |
| 277 case SK_PROPERTY(translateX): | |
| 278 fMatrix.setTranslateX(number); | |
| 279 break; | |
| 280 case SK_PROPERTY(translateY): | |
| 281 fMatrix.setTranslateY(number); | |
| 282 break; | |
| 283 default: | |
| 284 SkASSERT(0); | |
| 285 return false; | |
| 286 } | |
| 287 fConcat = fMatrix; | |
| 288 return true; | |
| 289 } | |
| 290 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 113827:
Remove the remainder of the skia source code from the Chromium repo.... (Closed)
Base URL: svn://chrome-svn/chrome/trunk/src/