inline bool BasicColorMatrixFilterOperation::operator==(const FilterOperation& operation) const { if (!isSameType(operation)) return false; const BasicColorMatrixFilterOperation& other = downcast<BasicColorMatrixFilterOperation>(operation); return m_amount == other.m_amount; }
bool BoxReflectFilterOperation::operator==(const FilterOperation& o) const { if (!isSameType(o)) return false; const auto& other = static_cast<const BoxReflectFilterOperation&>(o); return m_direction == other.m_direction && m_offset == other.m_offset; }
bool DefaultFilterOperation::operator==(const FilterOperation& operation) const { if (!isSameType(operation)) return false; return representedType() == downcast<DefaultFilterOperation>(operation).representedType(); }
bool ReferenceFilterOperation::operator==(const FilterOperation& operation) const { if (!isSameType(operation)) return false; return m_url == downcast<ReferenceFilterOperation>(operation).m_url; }
bool BlurFilterOperation::operator==(const FilterOperation& operation) const { if (!isSameType(operation)) return false; return m_stdDeviation == downcast<BlurFilterOperation>(operation).stdDeviation(); }
bool RotateTransformOperation::operator==(const TransformOperation& other) const { if (!isSameType(other)) return false; const RotateTransformOperation& r = downcast<RotateTransformOperation>(other); return m_x == r.m_x && m_y == r.m_y && m_z == r.m_z && m_angle == r.m_angle; }
bool MatrixTransformOperation::operator==(const TransformOperation& o) const { if (!isSameType(o)) return false; const MatrixTransformOperation& m = toMatrixTransformOperation(o); return m_a == m.m_a && m_b == m.m_b && m_c == m.m_c && m_d == m.m_d && m_e == m.m_e && m_f == m.m_f; }
bool RotateTransformOperation::operator==(const TransformOperation& other) const { if (!isSameType(other)) return false; const Rotation& otherRotation = toRotateTransformOperation(other).m_rotation; return m_rotation.axis == otherRotation.axis && m_rotation.angle == otherRotation.angle; }
bool ReferenceFilterOperation::operator==(const FilterOperation& o) const { if (!isSameType(o)) return false; return m_url == toReferenceFilterOperation(o).m_url; }
bool ScaleTransformOperation::operator==(const TransformOperation& o) const { if (!isSameType(o)) return false; const ScaleTransformOperation& s = toScaleTransformOperation(o); return m_x == s.m_x && m_y == s.m_y && m_z == s.m_z; }
inline bool BasicColorMatrixFilterOperation::operator==(const FilterOperation& o) const { if (!isSameType(o)) return false; const BasicColorMatrixFilterOperation& other = toBasicColorMatrixFilterOperation(o); return m_amount == other.m_amount; }
bool BasicShape::canBlend(const BasicShape* other) const { // FIXME: Support animations between different shapes in the future. if (!other || !isSameType(*other)) return false; // Just polygons with same number of vertices can be animated. if (type() == BasicShape::BasicShapePolygonType && (toBasicShapePolygon(this)->values().size() != toBasicShapePolygon(other)->values().size() || toBasicShapePolygon(this)->windRule() != toBasicShapePolygon(other)->windRule())) return false; // Circles with keywords for radii or center coordinates cannot be animated. if (type() == BasicShape::BasicShapeCircleType) { if (!toBasicShapeCircle(this)->radius().canBlend(toBasicShapeCircle(other)->radius())) return false; } // Ellipses with keywords for radii or center coordinates cannot be animated. if (type() != BasicShape::BasicShapeEllipseType) return true; return (toBasicShapeEllipse(this)->radiusX().canBlend(toBasicShapeEllipse(other)->radiusX()) && toBasicShapeEllipse(this)->radiusY().canBlend(toBasicShapeEllipse(other)->radiusY())); }
bool BasicShapeCircle::operator==(const BasicShape& o) const { if (!isSameType(o)) return false; const BasicShapeCircle& other = toBasicShapeCircle(o); return m_centerX == other.m_centerX && m_centerY == other.m_centerY && m_radius == other.m_radius; }
bool DropShadowFilterOperation::operator==(const FilterOperation& o) const { if (!isSameType(o)) return false; const DropShadowFilterOperation& other = toDropShadowFilterOperation(o); return m_location == other.m_location && m_stdDeviation == other.m_stdDeviation && m_color == other.m_color; }
bool BlurFilterOperation::operator==(const FilterOperation& o) const { if (!isSameType(o)) return false; return m_stdDeviation == toBlurFilterOperation(o).stdDeviation(); }
bool SkewTransformOperation::operator==(const TransformOperation& other) const { if (!isSameType(other)) return false; const SkewTransformOperation& s = downcast<SkewTransformOperation>(other); return m_angleX == s.m_angleX && m_angleY == s.m_angleY; }
bool BasicShapePolygon::operator==(const BasicShape& o) const { if (!isSameType(o)) return false; const BasicShapePolygon& other = toBasicShapePolygon(o); return m_windRule == other.m_windRule && m_values == other.m_values; }
bool BasicShapeEllipse::operator==(const BasicShape& o) const { if (!isSameType(o)) return false; const BasicShapeEllipse& other = toBasicShapeEllipse(o); return m_centerX == other.m_centerX && m_centerY == other.m_centerY && m_radiusX == other.m_radiusX && m_radiusY == other.m_radiusY; }
bool TranslateTransformOperation::operator==(const TransformOperation& other) const { if (!isSameType(other)) return false; const TranslateTransformOperation& t = downcast<TranslateTransformOperation>(other); return m_x == t.m_x && m_y == t.m_y && m_z == t.m_z; }
bool DefaultFilterOperation::operator==(const FilterOperation& o) const { if (!isSameType(o)) return false; return representedType() == toDefaultFilterOperation(o).representedType(); }
bool InterpolatedTransformOperation::operator==(const TransformOperation& o) const { if (!isSameType(o)) return false; const InterpolatedTransformOperation* t = static_cast<const InterpolatedTransformOperation*>(&o); return progress == t->progress && from == t->from && to == t->to; }
Point Board::isNeighbourTheSameType(Point current, Point neighbour) { if(existsIndex(neighbour)) { Gem* currentGem = mTiles[XYCoordinatesToIndex(current)]; Gem* upperGem = mTiles[XYCoordinatesToIndex(neighbour)]; if(isSameType(currentGem,upperGem)) return neighbour; } return NULL_POINT;// Point(-1,-1); }
int OSM_Crusher::setFeed( OSM_Stream& modelFeed ) { int setOk = 0; // Default fail if( isSameType(modelFeed) ) // Check StreamTypes { feedStream = &modelFeed; // Save pointer to modelFeed setOk = 1; // Succeed } return setOk; }
bool BasicShapeInset::operator==(const BasicShape& o) const { if (!isSameType(o)) return false; const BasicShapeInset& other = toBasicShapeInset(o); return m_right == other.m_right && m_top == other.m_top && m_bottom == other.m_bottom && m_left == other.m_left && m_topLeftRadius == other.m_topLeftRadius && m_topRightRadius == other.m_topRightRadius && m_bottomRightRadius == other.m_bottomRightRadius && m_bottomLeftRadius == other.m_bottomLeftRadius; }
PassRefPtr<BasicShape> BasicShapeInset::blend(const BasicShape* other, double progress) const { ASSERT(other && isSameType(*other)); const BasicShapeInset& otherInset = toBasicShapeInset(*other); RefPtr<BasicShapeInset> result = BasicShapeInset::create(); result->setTop(m_top.blend(otherInset.top(), progress, ValueRangeAll)); result->setRight(m_right.blend(otherInset.right(), progress, ValueRangeAll)); result->setBottom(m_bottom.blend(otherInset.bottom(), progress, ValueRangeAll)); result->setLeft(m_left.blend(otherInset.left(), progress, ValueRangeAll)); result->setTopLeftRadius(blendLengthSize(m_topLeftRadius, otherInset.topLeftRadius(), progress)); result->setTopRightRadius(blendLengthSize(m_topRightRadius, otherInset.topRightRadius(), progress)); result->setBottomRightRadius(blendLengthSize(m_bottomRightRadius, otherInset.bottomRightRadius(), progress)); result->setBottomLeftRadius(blendLengthSize(m_bottomLeftRadius, otherInset.bottomLeftRadius(), progress)); return result.release(); }
PassRefPtr<BasicShape> BasicShapePolygon::blend(const BasicShape* other, double progress) const { ASSERT(other && isSameType(*other)); const BasicShapePolygon* o = toBasicShapePolygon(other); ASSERT(m_values.size() == o->values().size()); ASSERT(!(m_values.size() % 2)); size_t length = m_values.size(); RefPtr<BasicShapePolygon> result = BasicShapePolygon::create(); if (!length) return result.release(); result->setWindRule(o->windRule()); for (size_t i = 0; i < length; i = i + 2) { result->appendPoint(m_values.at(i).blend(o->values().at(i), progress, ValueRangeAll), m_values.at(i + 1).blend(o->values().at(i + 1), progress, ValueRangeAll)); } return result.release(); }
UnicodeString FieldsSet::diffFrom(const FieldsSet& other, UErrorCode& status) const { UnicodeString str; if(!isSameType(other)) { status = U_ILLEGAL_ARGUMENT_ERROR; return UnicodeString("U_ILLEGAL_ARGUMENT_ERROR: FieldsSet of a different type!"); } for (int i=0; i<fieldCount(); i++) { if (isSet((UCalendarDateFields)i)) { int32_t myVal = get(i); int32_t theirVal = other.get(i); if(fEnum != -1) { const UnicodeString& fieldName = udbg_enumString( fEnum, i); str = str + fieldName + UnicodeString("=")+myVal+UnicodeString(" not ")+theirVal+UnicodeString(", "); } else { str = str + UnicodeString("some field") + "=" + myVal+" not " + theirVal+", "; } } } return str; }
bool ReferenceClipPathOperation::operator==(const ClipPathOperation& o) const { if (!isSameType(o)) return false; const ReferenceClipPathOperation& other = toReferenceClipPathOperation(o); return m_elementProxy == other.m_elementProxy && m_url == other.m_url; }
bool ExponentOp::canCombineWith(const OpRcPtr & op) const { return isSameType(op); }
bool PerspectiveTransformOperation::operator==(const TransformOperation& other) const { if (!isSameType(other)) return false; return m_p == downcast<PerspectiveTransformOperation>(other).m_p; }