@shijiu/jsview 1.9.719

package/dom/jsview-dom/src/engine-js/ForgeExtensionDefine.js

@@ -0,0 +1,14 @@
+/**
+ * Created by luocf on 2020/1/17.
+ */
+
+/* eslint-disable no-extra-boolean-cast */
+var ForgeExtension = {}
+if (!!window.JsView) {
+    if (!(window.JsView.Dom&&window.JsView.Dom.Extension)) {
+        window.JsView.Dom.Extension = ForgeExtension
+    }
+    ForgeExtension = window.JsView.Dom.Extension
+}
+
+export default ForgeExtension

package/dom/jsview-dom/src/engine-js/browser/PlatformUtils.js

@@ -0,0 +1,100 @@
+/* eslint-disable no-unused-vars */
+class PlatformUtils {
+  static getTextPixelWith(text, fontStyle) {
+    if (PlatformUtils.sCanvas === null) {
+      PlatformUtils.sCanvas = window.originDocument.createElement("canvas"); // 创建 canvas 画布
+    }
+
+    const context = PlatformUtils.sCanvas.getContext("2d"); // 获取 canvas 绘图上下文环境
+    context.font = fontStyle; // 设置字体样式，使用前设置好对应的 font 样式才能准确获取文字的像素长度
+    const dimension = context.measureText(text); // 测量文字
+    return Math.ceil(dimension.width);
+  }
+
+  static GetTextWidth(font_params) {
+    let bold = "";
+    if (font_params.bold) {
+      bold = "bold";
+    }
+    let italic = "";
+    if (font_params.italic) {
+      italic = "italic";
+    }
+    return this.getTextPixelWith(font_params.str, `${bold} ${italic} ${font_params.size}px ${font_params.font}`);
+  }
+
+  static GetTextRect(str, max_rect, font_params, text_attr, line_height) {
+    const rows = Math.ceil((font_params.size * str.length) / max_rect.width);
+    let height = rows * line_height;
+    if (height > max_rect.height) {
+      height = max_rect.height;
+    }
+    const ret_json = {
+      width: max_rect.width,
+      height
+    };
+    return ret_json;
+  }
+
+  static GetCursorOffset(str, max_rect, font_params, text_attr, line_height, pos_x, pos_y) {
+    // TODO 目前只考虑单行
+    let bold = "";
+    if (font_params.bold) {
+      bold = "bold";
+    }
+    let italic = "";
+    if (font_params.italic) {
+      italic = "italic";
+    }
+    let cursor_offset = 0;
+    if (font_params.alignment === "right") {
+      const width = this.getTextPixelWith(str, `${bold} ${italic} ${font_params.size}px ${font_params.font}`);
+      pos_x -= (max_rect.width - width);
+      if (pos_x < 0) {
+        pos_x = 0;
+      }
+    }
+
+    let sub_width = 0;
+    while (pos_x >= sub_width) {
+      if (cursor_offset === str.length) {
+        break;
+      }
+      sub_width = this.getTextPixelWith(str.substr(0, cursor_offset + 1), `${bold} ${italic} ${font_params.size}px ${font_params.font}`);
+      if (pos_x >= sub_width) {
+        cursor_offset++;
+      }
+    }
+
+    return cursor_offset;
+  }
+
+  static GetCursorPosition(str, max_rect, font_params, text_attr, line_height, cursor_offset) {
+    // TODO 目前只考虑单行
+    let bold = "";
+    if (font_params.bold) {
+      bold = "bold";
+    }
+    let italic = "";
+    if (font_params.italic) {
+      italic = "italic";
+    }
+
+    let width = 0;
+    let sub_str = str;
+    if (cursor_offset < str.length) {
+      sub_str = sub_str.substr(0, cursor_offset);
+    }
+
+    width = this.getTextPixelWith(sub_str, `${bold} ${italic} ${font_params.size}px ${font_params.font}`);
+    if (font_params.alignment === "right") {
+      // 总长度
+      const total_width = this.getTextPixelWith(str, `${bold} ${italic} ${font_params.size}px ${font_params.font}`);
+      width = max_rect.width - total_width + width;
+    }
+
+    return { x: width, y: 0 };
+  }
+}
+PlatformUtils.sCanvas = null;
+window.PlatformUtils = PlatformUtils;

package/dom/jsview-dom/src/engine-js/browser/animation_base.js

@@ -0,0 +1,313 @@
+/* eslint-disable no-unused-vars */
+import Forge from "../ForgeDefine";
+
+let sIdTokenGenerator = 0;
+
+class AnimationBase {
+  constructor() {
+    this.IdToken = sIdTokenGenerator++;
+    this._AttachedGroup = null;
+    this.AnimationListenerObj = null;
+    this._AnimationClose = false;
+    this._LayoutViewRef = null;
+    this._IsTextureAnim = false;
+  }
+
+  /**
+     * 设置动画起始/结束的监听回调
+     *
+     * @public
+     * @func SetAnimationListener
+     * @memberof Forge.AnimationBase
+     * @instance
+     * @param {Forge.AnimationListener} listener    动画起始/结束的监听回调
+     * */
+  SetAnimationListener(listener) {
+    this.AnimationListenerObj = listener;
+    this.OnNewListener(listener);
+  }
+
+  /**
+     * 追加动画起始/结束的监听回调
+     *
+     * @public
+     * @func AddAnimationListener
+     * @memberof Forge.AnimationBase
+     * @instance
+     * @param {Forge.AnimationListener} listener    动画起始/结束的监听回调
+     * */
+  AddAnimationListener(listener) {
+    if (this.AnimationListenerObj) {
+      listener.AddInherit(this.AnimationListenerObj);
+    }
+
+    this.AnimationListenerObj = listener;
+    this.OnNewListener(listener);
+  }
+
+  OnNewListener(listener) {
+    // Can override if needed
+  }
+
+  /**
+     * 获得当前动画的启动/结束监听接口
+     *
+     * @public
+     * @func GetAnimationListener
+     * @memberof Forge.AnimationBase
+     * @instance
+     * @return {Forge.AnimationListener} 动画起始/结束的监听回调
+     * */
+  GetAnimationListener() {
+    return this.AnimationListenerObj;
+  }
+
+  // public from customer
+  Cancel(by_other_animation) {
+    if (this._LayoutViewRef) {
+      this._LayoutViewRef.DetachAnimation(this);
+    }
+    const listener = this.AnimationListenerObj;
+    if (listener && listener.OnAnimationEnd && !this._AnimationClose) {
+      this._AnimationClose = true;
+      listener.OnAnimationEnd(false);
+    }
+
+    if (this._AttachedGroup) {
+      let cancel_whole_group = true;
+      if (by_other_animation) {
+        cancel_whole_group = (by_other_animation._AttachedGroup !== this._AttachedGroup);
+      }
+
+      if (cancel_whole_group) {
+        this._AttachedGroup.CancelFromInternalAnimation(this);
+        this._AttachedGroup = null;
+      }
+    }
+  }
+
+  /**
+     * 将当前动画加入动画组
+     * hide public
+     *
+     * @func AttachToGroup
+     * @memberof Forge.AnimationBase
+     * @instance
+     * @param {Forge.AnimationGroup} group  要加入的动画组
+     * */
+  AttachToGroup(group) {
+    if (this._AttachedGroup !== null) {
+      Forge.ThrowError("ERROR: In TransformAnimation.AttachToGroup(), animation already attached to other group");
+    }
+    this._AttachedGroup = group;
+  }
+
+  /**
+     * 从动画组脱离
+     * hide public
+     *
+     * @func RemoveFromGroup
+     * @memberof Forge.AnimationBase
+     * @instance
+     * */
+  RemoveFromGroup() {
+    this._AttachedGroup = null;
+  }
+
+  // hide public
+  AsTextureAnimation() {
+    this._IsTextureAnim = true;
+  }
+
+  Start(layout_view) {
+    this._LayoutViewRef = layout_view;
+  }
+
+  SetCannotDisable(can_disable) {
+
+  }
+
+  // hide public
+  OnStart() {
+    const listener = this.AnimationListenerObj;
+    if (listener && listener.OnAnimationStart) {
+      listener.OnAnimationStart();
+    }
+  }
+
+  // hide public
+  OnEnd(keep_animation) {
+    if (this._LayoutViewRef && !keep_animation) {
+      this._LayoutViewRef.DetachAnimation(this);
+      this._LayoutViewRef = null;
+    }
+
+    const listener = this.AnimationListenerObj;
+    if (listener && listener.OnAnimationEnd && !this._AnimationClose) {
+      this._AnimationClose = true;
+      listener.OnAnimationEnd(true);
+    }
+  }
+
+  // hide public
+  OnRepeatEvent() {
+    const listener = this.AnimationListenerObj;
+    if (listener && listener.OnAnimRepeat) {
+      listener.OnAnimRepeat();
+    }
+  }
+
+  // hide public
+  OnViewHide() {
+    const listener = this.AnimationListenerObj;
+    if (listener && listener.OnViewNoVisible) {
+      listener.OnViewNoVisible();
+    }
+  }
+
+  // hide public
+  OnFinalProgress(progress) {
+    const listener = this.AnimationListenerObj;
+    if (listener && listener.OnAnimFinal) {
+      listener.OnAnimFinal(progress);
+    }
+  }
+
+  OnAnimAdvance(progress) {
+    const listener = this.AnimationListenerObj;
+    if (listener && listener.OnAnimAdvance) {
+      listener.OnAnimAdvance(progress);
+    }
+  }
+}
+Forge.AnimationBase = AnimationBase;
+
+class AnimationListener {
+  /**
+     * 监听动画启动和结束时间的接口
+     *
+     * @public
+     * @constructor Forge.AnimationListener
+     * @author donglin donglin.lu@qcast.cn
+     * @param {function} on_start   监听动画启动事件（无参数）
+     * @param {function} on_end     监听动画结束事件（无参数）
+     * @param {function} on_view_hide    当更新过程中检测到动画对应的View已经不可见的回调<br>
+     *                                   需要和LayoutView.OnDrawResumed(callback)配合使用<br>
+     *                                   参数(LayoutView：对象View, TransformAnimation：监听的动画句柄)
+     * */
+  constructor(on_start, on_end, on_view_hide) {
+    this.OnAnimationStart = on_start;
+    this._OnAnimationStart = on_start;
+    this.OnAnimationEnd = on_end;
+    this._OnAnimationEnd = on_end;
+    this.OnViewNoVisible = on_view_hide;
+    this._OnViewNoVisible = on_view_hide;
+    this.OnAnimFinal = null;
+    this._OnAnimFinal = null;
+    this.OnAnimRepeat = null;
+    this._OnAnimRepeat = null;
+    this._AttachedGroup = null;
+    this._InheritListener = [];
+    this._OnAnimAdvance = null;
+    this.OnAnimAdvance = null;
+  }
+
+  OnStart(on_start) {
+    this._OnAnimationStart = on_start;
+    this.OnAnimationStart = on_start;
+    return this;
+  }
+
+  OnEnd(on_end) {
+    this._OnAnimationEnd = on_end;
+    this.OnAnimationEnd = on_end;
+    return this;
+  }
+
+  OnAdvance(on_advance) {
+    this._OnAnimAdvance = on_advance;
+    this.OnAnimAdvance = on_advance;
+    return this;
+  }
+
+  OnFinalProgress(on_final) {
+    this._OnAnimFinal = on_final;
+    this.OnAnimFinal = on_final;
+    return this;
+  }
+
+  OnRepeat(on_repeat) {
+    this._OnAnimRepeat = on_repeat;
+    this.OnAnimRepeat = on_repeat;
+    return this;
+  }
+
+  /**
+     * 添加继承的监听者，当本监听接口被调用后，会继续调用继承者的监听接口
+     *
+     * @public
+     * @param {Forge.AnimationListener} inherit_listener   继承的监听者
+     * */
+  AddInherit(inherit_listener) {
+    if (!inherit_listener) {
+      return;
+    }
+
+    if (this._InheritListener.length === 0) {
+      // Init for first inherit
+      const that = this;
+      this.OnAnimationStart = function() {
+        if (that._OnAnimationStart) that._OnAnimationStart();
+        for (let i = 0; i < that._InheritListener.length; i++) {
+          if (that._InheritListener[i].OnAnimationStart) {
+            that._InheritListener[i].OnAnimationStart();
+          }
+        }
+      };
+      this.OnAnimationEnd = function(normal_end) {
+        if (that._OnAnimationEnd) that._OnAnimationEnd(normal_end);
+        for (let i = 0; i < that._InheritListener.length; i++) {
+          if (that._InheritListener[i].OnAnimationEnd) {
+            that._InheritListener[i].OnAnimationEnd(normal_end);
+          }
+        }
+      };
+      this.OnViewNoVisible = function() {
+        if (that._OnViewNoVisible) that._OnViewNoVisible();
+        for (let i = 0; i < that._InheritListener.length; i++) {
+          if (that._InheritListener[i].OnViewNoVisible) {
+            that._InheritListener[i].OnViewNoVisible();
+          }
+        }
+      };
+      this.OnAnimFinal = function(progress) {
+        if (that._OnAnimFinal) that._OnAnimFinal(progress);
+        for (let i = 0; i < that._InheritListener.length; i++) {
+          if (that._InheritListener[i].OnAnimFinal) {
+            that._InheritListener[i].OnAnimFinal(progress);
+          }
+        }
+      };
+      this.OnAnimRepeat = function() {
+        if (that._OnAnimRepeat) that._OnAnimRepeat();
+        for (let i = 0; i < that._InheritListener.length; i++) {
+          if (that._InheritListener[i].OnAnimRepeat) {
+            that._InheritListener[i].OnAnimRepeat();
+          }
+        }
+      };
+
+      this.OnAnimAdvance = function() {
+        if (that._OnAnimAdvance) that._OnAnimAdvance();
+        for (let i = 0; i < that._InheritListener.length; i++) {
+          if (that._InheritListener[i].OnAnimAdvance) {
+            that._InheritListener[i].OnAnimAdvance();
+          }
+        }
+      };
+    }
+
+    this._InheritListener.push(inherit_listener);
+  }
+}
+Forge.AnimationListener = AnimationListener;

package/dom/jsview-dom/src/engine-js/browser/animation_keyframe.js

@@ -0,0 +1,64 @@
+/**
+ * Created by ludl on 6/11/20.
+ */
+// 工具类，用于将Animation配置转换成KeyFrame
+import Forge from "../ForgeDefine";
+import { getKeyFramesGroup } from "./dynamic_key_frames";
+
+let sKeyFrameControl = null;
+function getStaticFrameControl() {
+  if (sKeyFrameControl === null) {
+    sKeyFrameControl = getKeyFramesGroup();
+  }
+  return sKeyFrameControl;
+}
+
+function _ConvertTimingFunc(easing_info) {
+  let timing_function = "linear";
+  if (easing_info && typeof easing_info.T !== "undefined") {
+    switch (easing_info.T) {
+      case Forge.EasingTypeIn:
+        timing_function = "ease-in";
+        break;
+      case Forge.EasingTypeOut:
+        timing_function = "ease-out";
+        break;
+      case Forge.EasingTypeInOut:
+        timing_function = "ease-in-out";
+        break;
+      case Forge.EasingTypeBezier:
+        timing_function = `cubic-bezier(${easing_info.St.X1},${easing_info.St.Y1},${easing_info.St.X2},${easing_info.St.Y2})`;
+        break;
+      case Forge.EasingTypeSteps:
+        timing_function = `steps(${easing_info.St.S},${easing_info.St.T === 0 ? "start" : "end"})`;
+        break;
+      case Forge.EasingTypeBlink:
+      case Forge.EasingTypeDeceleration:
+      default:
+        break;
+    }
+  }
+  return timing_function;
+}
+
+// 将Forge.AnimationDelegate信息转化成style.animation的填写内容
+function animationToStyle(animation_ref, keyframe_name) {
+  const repeat = (animation_ref.repeatTimes === -1 ? "infinite" : animation_ref.repeatTimes);
+  let timing_func = "linear";
+  if (animation_ref.easing) {
+    timing_func = _ConvertTimingFunc(animation_ref.easing);
+  }
+
+  const style_animation = `${keyframe_name} ${animation_ref.duration / 1000}s ${
+    timing_func} ${animation_ref.delayedTime / 1000}s ${
+    repeat}`;
+  // console.log(`animationToStyle style_anim:${style_animation}`);
+
+  return style_animation;
+}
+
+export {
+  getStaticFrameControl,
+  animationToStyle,
+  _ConvertTimingFunc as convertTimingFunc,
+};