Add only property that user put in and write tempolary computed properties to CSS
Change-Id: I0afb49d630ed5d6926c005f21fdba61929d3c3eb
Signed-off-by: seongwon.shim <seongwon.shim@samsung.com>
package org.tizen.webuibuilder.animator.action;
+import java.util.HashMap;
+import java.util.Map;
+
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.gef.GraphicalViewer;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.KeyEvent;
+import org.tizen.webuibuilder.animator.gef.command.AnimationCreateAndChangeFrameCommand;
import org.tizen.webuibuilder.animator.gef.command.AnimatorChangeLayoutCommand;
import org.tizen.webuibuilder.animator.gef.editparts.AnimatorEditPart;
+import org.tizen.webuibuilder.animator.model.AnimatorModelEvent;
+import org.tizen.webuibuilder.animator.model.AnimatorModelManager;
+import org.tizen.webuibuilder.animator.model.AnimatorSelector;
import org.tizen.webuibuilder.animator.model.part.AnimatorPart;
+import org.tizen.webuibuilder.animator.utils.AnimatorUtils;
import org.tizen.webuibuilder.model.Part;
if (editPart instanceof AnimatorEditPart) {
AnimatorPart part = (AnimatorPart) ((AnimatorEditPart) editPart).getModel();
Rectangle originalRect = part.getOriginalPosition();
- Rectangle movedRect =
- new Rectangle(part.getAniPosition().x + delta.x,
- part.getAniPosition().y + delta.y,
- part.getAniPosition().width,
- part.getAniPosition().height);
+// Rectangle movedRect =
+// new Rectangle(part.getAniPosition().x + delta.x,
+// part.getAniPosition().y + delta.y,
+// part.getAniPosition().width,
+// part.getAniPosition().height);
+//
+// command.add(new AnimatorChangeLayoutCommand(part, movedRect, originalRect));
+
+ int left = 0;
+ int top = 0;
+ if (part.getPositionMode() == Part.PositionMode.ABSOLUTE_POSITION) {
+ left = part.getAniPosition().x + delta.x;
+ top = part.getAniPosition().y + delta.y;
+ } else if (part.getPositionMode() == Part.PositionMode.RELATIVE_POSITION) {
+ left = part.getAniPosition().x + delta.x - originalRect.x;
+ top = part.getAniPosition().y + delta.y - originalRect.y;
+ }
+
+ AnimatorModelManager animatorModelManager =
+ AnimatorModelManager.getInstance(AnimatorUtils.getAppManager());
+ String animationGroupId =
+ AnimatorUtils.getActiveAnimatorBrowserViewer().getCurrentAnimationGroupId();
- command.add(new AnimatorChangeLayoutCommand(part, movedRect, originalRect));
+ AnimatorSelector selector =
+ animatorModelManager.findAnimatorSelector(animationGroupId, part,
+ part.getUiSelector());
+
+ double currentTime = AnimatorUtils.getActiveAnimatorBrowserViewer().getPointTime();
+
+ Map<String, String> properties = new HashMap<String, String>();
+ properties.put("translateX", left + "px");
+ properties.put("translateY", top + "px");
+
+ command.add(new AnimationCreateAndChangeFrameCommand(selector, currentTime, properties,
+ AnimatorModelEvent.Origin.EDITOR));
}
}
package org.tizen.webuibuilder.animator.gef.command;
+import java.util.HashMap;
import java.util.Map;
import org.eclipse.gef.commands.Command;
private double currentTime = 0.0;
private Map<String, String> properties = null;
private AnimatorModelEvent.Origin origin = null;
- private Map<String, String> oldProperties = null;
+ private Map<String, String> oldProperties = new HashMap<String, String>();
+ private boolean isCreate;
/**
* Constructor
public void execute() {
AnimatorModelManager animatorModelManager =
AnimatorModelManager.getInstance(AnimatorUtils.getAppManager());
- oldProperties =
- animatorModelManager.createOrEditAnimatorFrame(animatorModelManager.getModelFactory(), selector, currentTime, properties,
+ isCreate =
+ animatorModelManager.createOrEditAnimatorFrame(selector, currentTime, oldProperties, properties,
origin);
}
AnimatorModelManager animatorModelManager =
AnimatorModelManager.getInstance(AnimatorUtils.getAppManager());
animatorModelManager.removeOrEditAnimatorFrame(selector, currentTime, oldProperties,
- properties, origin);
+ properties, isCreate, origin);
}
}
import org.eclipse.gef.requests.ChangeBoundsRequest;
import org.eclipse.swt.graphics.Color;
import org.tizen.webuibuilder.animator.gef.command.AnimationCreateAndChangeFrameCommand;
-import org.tizen.webuibuilder.animator.gef.command.AnimatorChangeLayoutCommand;
import org.tizen.webuibuilder.animator.gef.editparts.AnimatorEditPart;
import org.tizen.webuibuilder.animator.gef.editparts.AnimatorRootEditPart;
import org.tizen.webuibuilder.animator.gef.tools.AnimatorDragEditPartsTracker;
@Override
public Command getCommand(Request request) {
if (REQ_MOVE.equals(request.getType())) {
- Point moveDelta = ((ChangeBoundsRequest) request).getMoveDelta();
+ /*Point moveDelta = ((ChangeBoundsRequest) request).getMoveDelta();
moveDelta.x /= ((AnimatorRootEditPart) getHost().getRoot()).getZoomManager().getZoom();
moveDelta.y /= ((AnimatorRootEditPart) getHost().getRoot()).getZoomManager().getZoom();
((ChangeBoundsRequest) request).setMoveDelta(moveDelta);
return new AnimatorChangeLayoutCommand(getHost().getModel(),
((ChangeBoundsRequest) request)
.getTransformedRectangle(rect),
- originalRect);
+ originalRect);*/
+
+ Point moveDelta = ((ChangeBoundsRequest) request).getMoveDelta();
+ moveDelta.x /= ((AnimatorRootEditPart) getHost().getRoot()).getZoomManager().getZoom();
+ moveDelta.y /= ((AnimatorRootEditPart) getHost().getRoot()).getZoomManager().getZoom();
+ ((ChangeBoundsRequest) request).setMoveDelta(moveDelta);
+ AnimatorPart part = (AnimatorPart) (getHost().getModel());
+ Rectangle rect = new Rectangle(part.getAniPosition());
+
+ Rectangle layout = ((ChangeBoundsRequest) request)
+ .getTransformedRectangle(rect);
+ Rectangle originalRect = part.getOriginalPosition();
+ int left = 0;
+ int top = 0;
+
+ if (part.getPositionMode() == Part.PositionMode.ABSOLUTE_POSITION) {
+ left = layout.x;
+ top = layout.y;
+ } else if (part.getPositionMode() == Part.PositionMode.RELATIVE_POSITION) {
+ left = layout.x - originalRect.x;
+ top = layout.y - originalRect.y;
+ }
+
+ AnimatorModelManager animatorModelManager =
+ AnimatorModelManager.getInstance(AnimatorUtils.getAppManager());
+ String animationGroupId =
+ AnimatorUtils.getActiveAnimatorBrowserViewer().getCurrentAnimationGroupId();
+
+ AnimatorSelector selector =
+ animatorModelManager.findAnimatorSelector(animationGroupId, part,
+ part.getUiSelector());
+
+ double currentTime = AnimatorUtils.getActiveAnimatorBrowserViewer().getPointTime();
+
+ Map<String, String> properties = new HashMap<String, String>();
+ properties.put("translateX", left + "px");
+ properties.put("translateY", top + "px");
+
+ return new AnimationCreateAndChangeFrameCommand(selector, currentTime, properties,
+ AnimatorModelEvent.Origin.EDITOR);
+
} else if (REQ_RESIZE.equals(request.getType())) {
Dimension sizeDelta = ((ChangeBoundsRequest) request).getSizeDelta();
sizeDelta.width /=
*/
private void updateAnimationFW(AnimatorSelector selector, String animationGroupId,
double pointTime) {
- selector.getMergedFrames();
+ selector.updateSelectorTime();
int delay = (int) (selector.getDelay() * 1000);
int duration = (int) (selector.getDuration() * 1000);
String keyFrameId = selector.getId();
*/
private void updateAnimationFWAndDetect(AnimatorSelector selector, String animationGroupId,
double pointTime) {
- selector.getMergedFrames();
+ selector.updateSelectorTime();
int delay = (int) (selector.getDelay() * 1000);
int duration = (int) (selector.getDuration() * 1000);
String keyFrameId = selector.getId();
int top = translateInDesigner.height;
int i = 0;
- List<AnimatorFrame> mergedFrames = selector.getMergedFrames();
+ List<AnimatorFrame> mergedFrames = selector.getMergedPropertyWithWidgetProperty();
Set<String> propertiesUsed = selector.getAllPropertiesUsed(mergedFrames);
for (AnimatorFrame frame : mergedFrames) {
int originX = 50;
int originY = 50;
- List<AnimatorFrame> frameList = selector.getMergedFrames();
+ List<AnimatorFrame> frameList = selector.getMergedPropertyWithWidgetProperty();
for (AnimatorModel frameElement : frameList) {
AnimatorFrame frame = ((AnimatorFrame) frameElement).getFrameLink();
- left = getPixelProperty(frame, Constants.translateX, translateInDesigner.width);
- top = getPixelProperty(frame, Constants.translateY, translateInDesigner.height);
- width = getPixelProperty(frame, "width", width);
- height = getPixelProperty(frame, "height", height);
+ left = getPixelProperty(((AnimatorFrame) frameElement), Constants.translateX, translateInDesigner.width);
+ top = getPixelProperty(((AnimatorFrame) frameElement), Constants.translateY, translateInDesigner.height);
+ width = getPixelProperty(((AnimatorFrame) frameElement), "width", width);
+ height = getPixelProperty(((AnimatorFrame) frameElement), "height", height);
Point point = calculatePathPoint(left, top, width, height, originX, originY);
// if (prevPoint == null || !prevPoint.equals(point)) {
int curveIndex = 0;
CssValueForLocation css =
new CssValueForLocation(0, 0, width, height, originX, originY);
- for (AnimatorCurveFrame curve : frame.getCurveFrames()) {
+ if(!frameElement.equals(frameList.get(frameList.size() -1))) {
+ for (AnimatorCurveFrame curve : frame.getCurveFrames()) {
- AnimationPathCurve curveForView = new AnimationPathCurve();
- convertCurveFromModel(css, curveForView, curve);
+ AnimationPathCurve curveForView = new AnimationPathCurve();
+ convertCurveFromModel(css, curveForView, curve);
- frameForView.insertCurve(curveIndex++, curveForView);
- }
+ frameForView.insertCurve(curveIndex++, curveForView);
+ }
+ }
points.add(frameForView);
// }
}
import java.util.ArrayList;
import java.util.HashMap;
+import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
+import org.eclipse.draw2d.geometry.Point;
import org.tizen.webuibuilder.animator.utils.AnimatorUtils;
+import org.tizen.webuibuilder.animator.utils.Constants;
/**
public void subtractFrameTime(double time) {
this.frameTime -= time;
}
+
+ /**
+ * Whether contains key or not
+ *
+ * @param key
+ * @return true false
+ */
+ public boolean containsKey(String key) {
+ return this.properties.containsKey(key);
+ }
+
+ /**
+ * Get Curve Frames
+ *
+ * @return List of curve frames
+ */
+ public List<AnimatorCurveFrame> getCurveFrames() {
+ return curveFrames;
+ }
+
+ /**
+ * Get Curve Frame by index
+ *
+ * @param index
+ * @return curve frame
+ */
+ public AnimatorCurveFrame getCurveFrame(int index) {
+ return curveFrames.get(index);
+ }
+
+ /**
+ * Set Curve Frames
+ *
+ * @param curveFrames
+ */
+ public void setCurveFrames(List<AnimatorCurveFrame> curveFrames) {
+ this.curveFrames = curveFrames;
+ }
+
+ /**
+ * Get Curve Frame size
+ *
+ * @return size of curve frame
+ */
+ public int getCurveFrameSize() {
+ return this.curveFrames.size();
+ }
+
+ /**
+ * Add Curve Frame
+ *
+ * @param curveFrame
+ */
+ public void addCurveFrame(AnimatorCurveFrame curveFrame) {
+ this.curveFrames.add(curveFrame);
+ }
+
+ /**
+ * Add Curve frame by index
+ *
+ * @param index
+ * @param curveFrame
+ */
+ public void addCurveFrame(int index, AnimatorCurveFrame curveFrame) {
+ this.curveFrames.add(index, curveFrame);
+ }
+
+ /**
+ * Remove Curve frame by index
+ *
+ * @param index
+ */
+ public void removeCurveFrame(int index) {
+ this.curveFrames.remove(index);
+ }
+
+ /**
+ * Get easing Property
+ *
+ * @return easing Property
+ */
+ public String getEasingProperty() {
+ String easeData = getProperty("-webkit-animation-timing-function");
+ if (easeData == null) {
+ easeData = "ease";
+ }
+ return easeData;
+ }
+
+ /**
+ * Get Frame Link
+ *
+ * @return frame
+ */
+ public AnimatorFrame getFrameLink() {
+ return this.frameLink;
+ }
+
+ /**
+ * Get Frame Link
+ *
+ * @param AnimatorFrame
+ *
+ */
+ public void setFrameLink(AnimatorFrame frame) {
+ this.frameLink = frame;
+ }
/**
* Get Properties
Iterator<String> keyIterator = keySet.iterator();
while (keyIterator.hasNext()) {
String key = keyIterator.next();
- results.put(key, getProperty(key));
+ if(getProperty(key) != null) {
+ results.put(key, getProperty(key));
+ }
}
return results;
return this.getComputedProperties().equals(animatorFrame.getComputedProperties());
}
- /**
- * Whether contains key or not
- *
- * @param key
- * @return true false
- */
- public boolean containsKey(String key) {
- return this.properties.containsKey(key);
- }
-
- /**
- * Get Curve Frames
- *
- * @return List of curve frames
- */
- public List<AnimatorCurveFrame> getCurveFrames() {
- return curveFrames;
- }
-
- /**
- * Get Curve Frame by index
- *
- * @param index
- * @return curve frame
- */
- public AnimatorCurveFrame getCurveFrame(int index) {
- return curveFrames.get(index);
- }
-
- /**
- * Set Curve Frames
- *
- * @param curveFrames
- */
- public void setCurveFrames(List<AnimatorCurveFrame> curveFrames) {
- this.curveFrames = curveFrames;
- }
-
- /**
- * Get Curve Frame size
- *
- * @return size of curve frame
- */
- public int getCurveFrameSize() {
- return this.curveFrames.size();
- }
-
- /**
- * Add Curve Frame
- *
- * @param curveFrame
- */
- public void addCurveFrame(AnimatorCurveFrame curveFrame) {
- this.curveFrames.add(curveFrame);
- }
-
- /**
- * Add Curve frame by index
- *
- * @param index
- * @param curveFrame
- */
- public void addCurveFrame(int index, AnimatorCurveFrame curveFrame) {
- this.curveFrames.add(index, curveFrame);
- }
-
- /**
- * Remove Curve frame by index
- *
- * @param index
- */
- public void removeCurveFrame(int index) {
- this.curveFrames.remove(index);
- }
-
- /**
- * Get easing Property
- *
- * @return easing Property
- */
- public String getEasingProperty() {
- String easeData = getProperty("-webkit-animation-timing-function");
- if (easeData == null) {
- easeData = "ease";
- }
- return easeData;
- }
-
- /**
- * Get Frame Link
- *
- * @return frame
- */
- public AnimatorFrame getFrameLink() {
- return this.frameLink;
- }
-
- /**
- * Get Frame Link
- *
- * @param AnimatorFrame
- *
- */
- public void setFrameLink(AnimatorFrame frame) {
- this.frameLink = frame;
- }
/**
* Get css string
* @return css string from animation for this frame
*
*/
- public String getCssString(Set<String> propertiesUsed, AnimatorSelector selector) {
- // if(properties.size() == 0){//TODO this should be omitted if ...
- // return "";
- // }
+ /*public String getCssString(Set<String> propertiesUsed, AnimatorSelector selector) {
+
Map<String, String> widgetProperties = selector.getWidgetProperties(propertiesUsed);
double duration = selector.getDuration();
builder.append("}");
builder.append("\n");
return builder.toString();
+ }*/
+
+ public String getCssString(Set<String> propertiesUsed, AnimatorSelector selector) {
+
+ Map<String, String> widgetProperties = selector.getWidgetProperties(propertiesUsed);
+ double duration = selector.getDuration();
+
+ StringBuilder builder = new StringBuilder();
+ String percent =
+ AnimatorUtils.convertPercentToString(frameTime == 0.0 ? 0.0 : frameTime / duration
+ * 100);
+ builder.append("\n");
+ builder.append(percent);
+ builder.append("{");
+ Map<String, String> transformRelatedProperties = new HashMap<String, String>();
+ for (String key : propertiesUsed) {
+
+ if (isTransformRelatedProperties(key)) {
+ transformRelatedProperties.put(key, properties.get(key));
+ } else {
+ builder.append("\n\t");
+ builder.append(key);
+ builder.append(":");
+ builder.append(properties.get(key));
+ builder.append(";");
+ builder.append("\n");
+ }
+ }
+ if (transformRelatedProperties.size() > 0) {
+ builder.append(createTransformProperty(transformRelatedProperties,
+ (frameLink != null) ? widgetProperties : null));
+ }
+ builder.append("}");
+ builder.append("\n");
+ return builder.toString();
}
/**
if (getUsedPropertiesInThisFrame().contains(key)) {
computedProperties.put(key, properties.get(key));
} else {
- computedProperties.put(key, widgetProperties.get(key));
+ String computedProperty = getComputedPropertiesFromPreviousFrame(key);
+ if(computedProperty != null) {
+ computedProperties.put(key, computedProperty);
+ } else {
+// computedProperty = getComputedPropertiesFromNextFrame(key);
+// if(computedProperty != null) {
+// computedProperties.put(key, computedProperty);
+// } else {
+ computedProperties.put(key, widgetProperties.get(key));
+// }
+ }
}
}
}
return this.computedProperties;
}
+
+ public String getComputedPropertiesFromPreviousFrame(String key) {
+ AnimatorFrame previousFrame = getPreviousAnimatorFrame(this);
+ while(previousFrame != null) {
+ String value = previousFrame.getProperty(key);
+ if(value != null) {
+ return value;
+ }
+ previousFrame = getPreviousAnimatorFrame(previousFrame);
+ }
+
+ return null;
+ }
+
+ private static AnimatorFrame getPreviousAnimatorFrame(AnimatorFrame frame) {
+
+ AnimatorFrame previousFrame = null;
+ AnimatorKeyframe currentKeyframe = (AnimatorKeyframe)frame.getParent();
+ previousFrame = (AnimatorFrame)currentKeyframe.getPrevChild(frame);
+ if(previousFrame == null) {
+ AnimatorKeyframe previousKeyframe = (AnimatorKeyframe)currentKeyframe.getParent().getPrevChild(currentKeyframe);
+ if(previousKeyframe != null) {
+ previousFrame = previousKeyframe.getLastFrame();
+ }
+ }
+
+ return previousFrame;
+ }
+
+ private static AnimatorFrame getNextAnimatorFrame(AnimatorFrame frame) {
+
+ AnimatorFrame nextFrame = null;
+ AnimatorKeyframe currentKeyframe = (AnimatorKeyframe)frame.getParent();
+ nextFrame = (AnimatorFrame)currentKeyframe.getPrevChild(frame);
+ if(nextFrame == null) {
+ AnimatorKeyframe nextKeyframe = (AnimatorKeyframe)currentKeyframe.getParent().getNextChild(currentKeyframe);
+ if(nextKeyframe != null) {
+ nextFrame = nextKeyframe.getFirstFrame();
+ }
+ }
+
+ return nextFrame;
+ }
+
+ public String getComputedPropertiesFromNextFrame(String key) {
+ AnimatorFrame nextFrame = getNextAnimatorFrame(this);
+ while(nextFrame != null) {
+ String value = nextFrame.getProperty(key);
+ if(value != null) {
+ return value;
+ }
+ nextFrame = getNextAnimatorFrame(nextFrame);
+ }
+
+ return null;
+ }
/**
* Get Computed Properties
Set<String> propertiesUsed = selector.getAllPropertiesUsed(selector.getMergedFrames());
return getComputedProperties(propertiesUsed);
}
+
+ public void addComputedPropertiesIfNotExist(Set<String> properties) {
+ Map<String, String> computedProperties = getComputedProperties(properties);
+ Iterator<Entry<String, String>> computedPropertiesIterator =
+ computedProperties.entrySet().iterator();
+ while (computedPropertiesIterator.hasNext()) {
+ Entry<String, String> propertyNext = computedPropertiesIterator.next();
+ String key = propertyNext.getKey();
+ if(!getProperties().containsKey(key)) {
+ addProperty(key, propertyNext.getValue());
+ }
+ }
+ }
private String createTransformProperty(Map<String, String> transformRelatedProperties,
Map<String, String> widgetProperties) {
new TransformationProperty(transformRelatedProperties, widgetProperties);
return property.toPropertyString();
}
+
+
+ /**
+ * find animated properties
+ *
+ * @param frame
+ * @param keyframe
+ */
+ public void findAnimatedPropertyAndSetInFrame(AnimatorFrame previousFrame, AnimatorFrame nextFrame) {
+ if(previousFrame == null || nextFrame == null) {
+ return;
+ }
+
+ Set<String> animatedProperties = getAnimatedProperties(previousFrame, nextFrame);
+ // set the interpolated value
+ double middle =
+ (getFrameTime() - previousFrame.getFrameTime())
+ / (nextFrame.getFrameTime() - previousFrame.getFrameTime()) * 100.0;
+ String easingProperty = previousFrame.getEasingProperty();
+ Map<String, String> previousFrameProperties = previousFrame.getComputedProperties();
+ Map<String, String> nextFrameProperties = nextFrame.getComputedProperties();
+ for (String key : animatedProperties) {
+ if (key.indexOf("color") >= 0) // TODO remove this after fixing color property
+ continue;
+ if(key.indexOf("timing-function") >=0) {
+// frame.addProperty(key, easingProperty);
+ continue;
+ }
+ String start = previousFrameProperties.get(key);
+ String end = nextFrameProperties.get(key);
+ String interpolatedValue =
+ getInterpolatedValue(key, start, end, middle, easingProperty);
+ addProperty(key, interpolatedValue);
+ }
+ if (previousFrame.getCurveFrames().size() > 0) {
+ Point p;
+ p =
+ AnimationPathModel
+ .findTranslateValueAtTime(getModelFactory(), getFrameTime(), previousFrame,
+ nextFrame,
+ AnimatorUtils.getEasingMethod(easingProperty));
+
+ addProperty(Constants.translateX, AnimatorUtils.convertPixToString(p.x));
+ addProperty(Constants.translateY, AnimatorUtils.convertPixToString(p.y));
+ }
+ }
+
+ private String getInterpolatedValue(String key, String start, String end, double middle,
+ String easingProperty) {
+ CSSProperty startValue = new CSSProperty(key, start);
+ return startValue.getInterpolcatedValue(new CSSProperty(key, end), middle,
+ AnimatorUtils.getEasingMethod(easingProperty));
+ }
+
+ /**
+ *
+ * @param previousFrame
+ * @param nextFrame
+ * @return a set of animated properties
+ */
+ private Set<String> getAnimatedProperties(AnimatorFrame previousFrame, AnimatorFrame nextFrame) {
+ Set<String> properties1 = previousFrame.getProperties().keySet();
+ Set<String> properties2 = nextFrame.getProperties().keySet();
+ Set<String> union = new HashSet<String>(properties1);
+ union.addAll(properties2);
+ return union;
+ }
}
private List<String> names = new ArrayList<String>();
private double duration = 0.0;
private double delay = 0.0;
-
+
public AnimatorKeyframe() {
// TODO Auto-generated constructor stub
}
+
/**
* Set initial property member value
* @param duration
* @param delay
*/
- public void setNames(String name) {
+ public void setName(String name) {
if (name != null) {
String[] array = name.split(",");
}
}
}
-
- /**
+
+
+ /**
* Get merged animation names
*
* @return String
*/
public String getName() {
String result = "";
+ String previousElement = null;
for (int i = 0; i < names.size(); i++) {
String element = names.get(i);
if (i == 0)
result += element;
- else
- result += "," + element;
+ else {
+ if(previousElement != null) {
+ if(previousElement.equals("custom") && element.equals("custom")) {
+
+ } else {
+ result += "," + element;
+ }
+ }
+
+ }
+ previousElement = names.get(i);
}
return result;
}
+
/**
* Add animation name If last name is custom just skip operation
* @param name
*/
public void addName(String name) {
- if (!name.equals("custom")) {
+ /*if (!name.equals("custom")) {
this.names.add(name);
} else {
if (!names.get(names.size() - 1).equals("custom"))
this.names.add(name);
- }
+ }*/
+
+
+ this.names.add(name);
}
/**
return this.names.get(this.names.size() - 1);
return null;
}
-
+
+
+
+
/**
* Remove last animation name
*/
public void removeLastName() {
- this.names.remove(this.names.size() - 1);
+ if(this.names.size() != 0) {
+ this.names.remove(this.names.size() - 1);
+ }
}
+
/**
* Get keyframe duration
*
}
if (nextParent != null) {
AnimatorFrame nextFrame = nextParent.getFirstFrame();
- assert !nextFrame.hasSamePropertyValue(frame) : "This should be always true, if not previous logic is corrupt";
+// assert !nextFrame.hasSamePropertyValue(frame) : "This should be always true, if not previous logic is corrupt";
// if (!nextFrame.hasSamePropertyValue(this)) {// doesn't need to, because
// always true; confirmation required
- if (merged) {
- previousParent.mergeFrame(nextFrame, true);
- } else {
- mergeFrame(nextFrame, true);
+ if (!nextFrame.hasSamePropertyValue(frame)) {
+ if (merged) {
+ previousParent.mergeFrame(nextFrame, true);
+ } else {
+ mergeFrame(nextFrame, true);
+ }
}
- // }
}
}
} else if (keyframeChildrenSize > 1) {// case 2
- if (getChildIndex(this) == 0) { // case 2.1 (left most case)
+ if (getChildIndex(frame) == 0) { // case 2.1 (left most case)
// merge left and check right
if (previousParent != null) {
AnimatorFrame previousFrame = previousParent.getLastFrame();
}
}
// TODO check right
- } else if (getChildIndex(this) == (keyframeChildrenSize - 1)) { // case 2.2 (right most
+ } else if (getChildIndex(frame) == (keyframeChildrenSize - 1)) { // case 2.2 (right most
// case)
// merge next frame
if (nextParent != null) {
if (nextFrame.hasSamePropertyValue(frame)) {
AnimatorKeyframe nextKeyframe =
selector.createKeyframe(getLastName(), frame.getFrameTime());
- splitFrame(nextKeyframe, nextFrame, true);
removeLastName();
+ splitFrame(nextKeyframe, nextFrame, true);
selector.addChild(nextKeyframe);
}
}
if (previousFrame.hasSamePropertyValue(frame)) {
AnimatorKeyframe currentKeyframe =
selector.createKeyframe(getLastName(), frame.getFrameTime());
- splitFrame(currentKeyframe, frame, true);
removeLastName();
+ splitFrame(currentKeyframe, frame, true);
selector.addChild(currentKeyframe);
}
}
package org.tizen.webuibuilder.animator.model;
import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import java.util.Set;
-import org.eclipse.draw2d.geometry.Point;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IEditorPart;
import org.tizen.webuibuilder.animator.model.part.AnimatorPagePart;
import org.tizen.webuibuilder.animator.model.part.AnimatorPart;
import org.tizen.webuibuilder.animator.utils.AnimatorUtils;
-import org.tizen.webuibuilder.animator.utils.Constants;
import org.tizen.webuibuilder.model.Part;
import org.tizen.webuibuilder.model.app.AppManager;
import org.tizen.webuibuilder.model.app.AppManagerForHTML;
for (AnimatorFrame frame : frames) {
keyframe.addChild(frame, false);
}
- }
- }
-
- if (keyframe != null) {
- animatorSelector.addChild(keyframe);
- if (animatorSelector.mergeKeyframe(keyframe)) {
- animatorSelector.removeChild(keyframe);
- eventSource.fireEvent(AnimatorModelEvent.EventType.KEYFRAME_REMOVE, origin,
- keyframe);
- } else {
- eventSource.fireEvent(true, animatorSelector,
- AnimatorModelEvent.EventType.KEYFRAME_ADD, origin, keyframe);
+
+ animatorSelector.addChild(keyframe);
+ if (animatorSelector.mergeKeyframe(keyframe)) {
+ animatorSelector.removeChild(keyframe);
+ eventSource.fireEvent(AnimatorModelEvent.EventType.KEYFRAME_REMOVE, origin,
+ keyframe);
+ } else {
+ eventSource.fireEvent(true, animatorSelector,
+ AnimatorModelEvent.EventType.KEYFRAME_ADD, origin, keyframe);
+ }
}
}
}
selector.addChild(keyframe);
// copyPropertiesInLeftOrRightFrame(frame, keyframe);
} else {// case 2
- findAnimatedPropertyAndSetInFrame(frame, keyframe);
+ frame.findAnimatedPropertyAndSetInFrame((AnimatorFrame) keyframe.getPrevChild(frame),
+ (AnimatorFrame) keyframe.getNextChild(frame));
+// findAnimatedPropertyAndSetInFrame(frame, keyframe);
}
eventSource.fireEvent(AnimatorModelEvent.EventType.FRAME_ADD, origin, frame);
* @param frame
* @param keyframe
*/
- private void findAnimatedPropertyAndSetInFrame(AnimatorFrame frame, AnimatorKeyframe keyframe) {
+/* private void findAnimatedPropertyAndSetInFrame(AnimatorFrame frame, AnimatorKeyframe keyframe) {
AnimatorFrame previousFrame = (AnimatorFrame) keyframe.getPrevChild(frame);
AnimatorFrame nextFrame = (AnimatorFrame) keyframe.getNextChild(frame);
if(previousFrame == null || nextFrame == null) {
CSSProperty startValue = new CSSProperty(key, start);
return startValue.getInterpolcatedValue(new CSSProperty(key, end), middle,
AnimatorUtils.getEasingMethod(easingProperty));
- }
+ }*/
/**
*
* @param nextFrame
* @return a set of animated properties
*/
- private Set<String> getAnimatedProperties(AnimatorFrame previousFrame, AnimatorFrame nextFrame) {
+ /*private Set<String> getAnimatedProperties(AnimatorFrame previousFrame, AnimatorFrame nextFrame) {
Set<String> properties1 = previousFrame.getProperties().keySet();
Set<String> properties2 = nextFrame.getProperties().keySet();
Set<String> union = new HashSet<String>(properties1);
union.addAll(properties2);
return union;
- }
+ }*/
/**
* Edit Animator frame
* @param properties
* @param origin
*/
- public Map<String, String> createOrEditAnimatorFrame(AnimatorModelFactory modelFactory,
- AnimatorSelector selector,
+ public boolean createOrEditAnimatorFrame(AnimatorSelector selector,
double currentTime,
+ Map<String, String> oldProperties,
Map<String, String> properties,
Origin origin) {
- Map<String, String> oldProperties = new HashMap<String, String>();
- AnimatorFrame frame = selector.getOrCreateAnimatorFrame(currentTime);
+ boolean isCreate = true;
+ AnimatorFrame frame = selector.getAnimatorFrameByCurrentTime(currentTime);
+ if(frame != null) {
+ isCreate = false;
+ } else {
+ frame = selector.getOrCreateAnimatorFrame(currentTime);
+ }
+
if (frame != null) {
+ AnimatorKeyframe currentKeyframe = (AnimatorKeyframe)frame.getParent();
+ AnimatorKeyframe previousParent = (AnimatorKeyframe) selector.getPrevChild(currentKeyframe);
+ int keyframeChildrenSize = currentKeyframe.getChildrenSize();
+ if (keyframeChildrenSize == 1) {
+ if (currentKeyframe.getChildIndex(frame) == 0) {
+ if (previousParent != null) {
+ if(previousParent.getChildrenSize() == 1) {
+ AnimatorFrame previousFrame = previousParent.getLastFrame();
+ previousFrame.addComputedPropertiesIfNotExist(properties.keySet());
+ }
+ }
+ }
+ }
oldProperties = frame.getProperties(properties.keySet());
frame.addOrEditProperties(properties);
}
eventSource.fireEvent(AnimatorModelEvent.EventType.FRAME_EDIT, origin, frame);
- return oldProperties;
+ return isCreate;
}
/**
*/
public void removeOrEditAnimatorFrame(AnimatorSelector selector, double currentTime,
Map<String, String> oldProperties,
- Map<String, String> properties, Origin origin) {
+ Map<String, String> properties, boolean isCreate, Origin origin) {
AnimatorKeyframe keyframe = selector.getCurrentKeyframe(currentTime);
if (keyframe != null) {
AnimatorFrame frame = keyframe.getFrameByCurrentTime(currentTime);
if (frame != null) {
frame.removeOrReplaceProperties(oldProperties, properties);
+ if (frame.getPropertySize() == 0 && isCreate) {
+ AnimatorKeyframe currentKeyframe = (AnimatorKeyframe)frame.getParent();
+ currentKeyframe.removeChild(frame, true);
+ currentKeyframe.removeLastName();
+ }
if (frame.getPropertySize() == 0) {
- keyframe.removeChild(frame, true);
eventSource.fireEvent(AnimatorModelEvent.EventType.FRAME_REMOVE, origin, frame);
} else
eventSource.fireEvent(AnimatorModelEvent.EventType.FRAME_EDIT, origin, frame);
public void removeAnimatorFrame(AnimatorModel model, String name, Origin origin) {
AnimatorFrame frame = (AnimatorFrame) model;
AnimatorKeyframe keyframe = (AnimatorKeyframe) frame.getParent();
- keyframe.removeName(name);
+// keyframe.removeName(name);
+// keyframe.removeLastName();
keyframe.removeChild(frame, true);
eventSource.fireEvent(AnimatorModelEvent.EventType.FRAME_REMOVE, origin, frame);
public double calculateMergeFrameTime(double currentTime) {
return currentTime - getDelay();
}
+
/*
* (non-Javadoc)
}
}
- private void updateSelectorTime() {
+ public void updateSelectorTime() {
// TODO find max delay value
double maxDelay = AnimatorConstants.ANIMATOR_MAX_START_TIME;
}
return frames;
}
+
+ public List<AnimatorFrame> getMergedPropertyWithWidgetProperty() {
+
+ List<AnimatorFrame> mergedFrames = getMergedFrames();
+ Set<String> propertiesUsed = getAllPropertiesUsed(mergedFrames);
+ Map<String, String> widgetProperties = getWidgetProperties(propertiesUsed);
+
+ for(AnimatorFrame mergedFrame : mergedFrames) {
+ for(String key : propertiesUsed) {
+ if(!mergedFrame.getUsedPropertiesInThisFrame().contains(key)) {
+ int index = mergedFrames.indexOf(mergedFrame);
+ if(index != 0) { // not first frame
+ if(index == mergedFrames.size() -1){ //last frame
+ AnimatorFrame previousFrame = mergedFrames.get((mergedFrames.indexOf(mergedFrame) - 1));
+ mergedFrame.addProperty(key, previousFrame.getProperty(key));
+ } else { //middle frame
+ AnimatorFrame previousFrame = mergedFrames.get(index - 1);
+ mergedFrame.addProperty(key, previousFrame.getProperty(key));
+ }
+ } else { //first frame
+ if(mergedFrame.getParent().getChildrenSize() == 1) { // if it is only frame in keyframe
+ AnimatorFrame nextFrame = mergedFrames.get(index + 1);
+ if(nextFrame != null) {
+ mergedFrame.addProperty(key, nextFrame.getProperty(key));
+ } else {
+ mergedFrame.addProperty(key, widgetProperties.get(key));
+ }
+ } else {
+ mergedFrame.addProperty(key, widgetProperties.get(key));
+ }
+ }
+ }
+ }
+ }
+
+ return mergedFrames;
+ }
/**
* Create keyframe
*/
public AnimatorKeyframe createKeyframe(String name, double frameTime) {
AnimatorKeyframe keyframe = (AnimatorKeyframe)getModelFactory().createAnimatorModel(AnimatorModelType.KEYFRAME);
- keyframe.setNames(name);
+ keyframe.setName(name);
keyframe.setDuration(0.0);
keyframe.setDelay(frameTime);
keyframe.setParent(this);
if (previousKeyframe != null) {
AnimatorFrame previousFrame = previousKeyframe.getLastFrame();
- copyLeftPropertiesToAllFramesInKeyframe(previousFrame, keyframe);
+// copyLeftPropertiesToAllFramesInKeyframe(previousFrame, keyframe);
if (previousFrame != null) {
if (!previousFrame.hasSamePropertyValue(keyframe.getFirstFrame())) {
previousKeyframe.mergeFrame(keyframe.getFirstFrame(), true);
keyframe = previousKeyframe;
result = true;
-
}
}
}
* @param previousFrame
* @param keyframe
*/
- private void copyLeftPropertiesToAllFramesInKeyframe(AnimatorFrame previousFrame,
+/* private void copyLeftPropertiesToAllFramesInKeyframe(AnimatorFrame previousFrame,
AnimatorKeyframe keyframe) {
List<AnimatorModel> frames = keyframe.getChildren();
for (AnimatorModel frameModel : frames) {
}
}
}
- }
+ }*/
/**
* Get css string
* @return css string from animation for this selector
*/
public String getCssString(AnimatorModelFactory modelFactory) {
- // String separator = System.getProperty( "line.separator" );
StringBuilder builder = new StringBuilder("\n");
if (getChildrenSize() > 0) {
String id = this.getId();
}
/**
- * Create Predefined frames for predefined animation
- *
- * @param preDefinedAnimationDescriptor
- * @param delay
- * @return
- */
- /*public List<AnimatorFrame> createPredefinedFrames(CssAnimationDescriptor preDefinedAnimationDescriptor,
- double delay) {
-
- List<AnimatorFrame> frames = new ArrayList<AnimatorFrame>();
- List<CssAnimationPropertyDescriptor> defaultKeyFrames =
- preDefinedAnimationDescriptor.getDefaultKeyFrames();
-
- double duration =
- AnimatorUtils.convertTimeToDouble(preDefinedAnimationDescriptor
- .getPropertyValueByName(AnimatorConstants.PROPERTY_NAME_DURATION));
-
- for (CssAnimationPropertyDescriptor property : defaultKeyFrames) {
- AnimatorFrame frame =
- new AnimatorFrame(AnimatorUtils.doubleRoundCeiling(AnimatorUtils
- .convertPercentToDouble(property.getName()) / 100 * duration));
- List<CssAnimationPropertyDescriptor> childProperties = property.getChildProperties();
- for (CssAnimationPropertyDescriptor childProperty : childProperties) {
- String name = childProperty.getName();
- String value = childProperty.getDefaultValue();
- frame.addProperty(name, value);
- }
-
- frame.setFrameTime(frame.getFrameTime() + delay);
- addListByFrameTime(frames, frame);
- }
- return frames;
- }*/
-
- /*private void addListByFrameTime(List<AnimatorFrame> frames, AnimatorFrame addFrame) {
- int index = 0;
- for (AnimatorModel model : frames) {
- AnimatorFrame frame = (AnimatorFrame) model;
- if (frame.getFrameTime() < addFrame.getFrameTime())
- index++;
- else
- break;
- }
-
- frames.add(index, addFrame);
- }*/
-
- /**
* if there exists a Frame, return exist frame. if not, create and return it.
*
* @param model
*/
public AnimatorFrame getOrCreateAnimatorFrame(double currentTime) {
AnimatorKeyframe keyframe = getCurrentKeyframe(currentTime);
- if (keyframe == null)
+ if (keyframe == null) {
keyframe = createKeyframe("custom", currentTime);
+ addChild(keyframe);
+ }
AnimatorFrame frame = keyframe.getFrameByCurrentTime(currentTime);
if (frame == null) {
- keyframe.createAnimatorFrame(currentTime);
+ frame = keyframe.createAnimatorFrame(currentTime);
+ keyframe.addChild(frame, true);
}
return frame;
if (property.equals("translateX") || property.equals("translateY")
|| property.equals("scaleX") || property.equals("scaleY")
|| property.equals("skewX") || property.equals("skewY")
- || property.equals("rotateZ")) {
+ || property.equals("rotateZ") || property.equals("perspective")) {
fillTransformProperties(properties, cssSelector);
} else {
CssStyle style = cssSelector.getCssStyle(property);
JsonObject jobject = (JsonObject) json;
AnimatorKeyframe keyframe = (AnimatorKeyframe)getModelFactory().createAnimatorModel(AnimatorModelType.KEYFRAME);
- keyframe.setNames(jobject.get("name").getAsString());
+ keyframe.setName(jobject.get("name").getAsString());
keyframe.setDuration(AnimatorUtils.convertTimeToDouble(jobject.get("duration").getAsString()));
keyframe.setDelay( AnimatorUtils.convertTimeToDouble(jobject.get("start").getAsString()));
}
Pattern p =
- Pattern.compile(".*translate\\((\\-?\\d*\\.?\\d+)px,\\s*(\\-?\\d*\\.?\\d+)px\\).*rotate\\((\\-?\\d*\\.?\\d+)deg\\).*scale\\((\\-?\\d*\\.?\\d+),\\s*(\\-?\\d*\\.?\\d+)\\).*skew\\((\\-?\\d*\\.?\\d+)deg,\\s*(\\-?\\d*)deg\\).*");
+ Pattern.compile(".*translate\\((\\-?\\d*\\.?\\d+)px,\\s*(\\-?\\d*\\.?\\d+)px\\).*rotate\\((\\-?\\d*\\.?\\d+)deg\\).*scale\\((\\-?\\d*\\.?\\d+),\\s*(\\-?\\d*\\.?\\d+)\\).*skew\\((\\-?\\d*\\.?\\d+)deg,\\s*(\\-?\\d*)deg\\).*perspective\\((\\-?\\d*\\.?\\d+)px\\)");
Matcher m = p.matcher(fullTransform);
if (m.find()) {
String matchValue = m.group(1);
matchValue = m.group(7);
properties.put(Constants.skewY, matchValue + "deg");
+
+ matchValue = m.group(8);
+ properties.put(Constants.perspective, matchValue + "px");
}
}
public static String skewY = "skewY";
public static String scaleX = "scaleX";
public static String scaleY = "scaleY";
+ public static String perspective = "perspective";
// css Property default value
public static String none = "none";
projects / sdk / ide / web-ui-builder-eplugin.git / commitdiff