@ives_xxz/framework 1.0.0

package/expand/FWRollingViewNesting.ts

@@ -0,0 +1,191 @@
+import FWLog from '../log/FWLog';
+
+const { ccclass, property, menu } = cc._decorator;
+
+interface EventTouch extends cc.Event.EventTouch {
+  simulate?: boolean;
+  mock?: boolean; // 是否为模拟事件
+}
+
+@ccclass
+@menu('CustomComponent/FWRollingViewNesting')
+export default class FWRollingViewNesting extends cc.Component {
+  @property({
+    tooltip: '方向判定阈值(像素)，小于该值不触发方向拦截',
+    min: 3,
+    max: 15,
+  })
+  dirThreshold = 15;
+
+  private scrollView: cc.ScrollView = null;
+  private _isBoundaryV = 0; //为没有开启滚动所以没有边界 1为上边界 2为下边界 3为不滑动;
+  private _isBoundaryH = 0; //为没有开启滚动所以没有边界 1为左边界 2为右边界 3为不滑动；
+
+  protected onEnable(): void {
+    this.scrollView = this.node.getComponent(cc.ScrollView);
+    if (this.scrollView) {
+      (this.scrollView as any).hasNestedViewGroup = (event, captureListeners) => {
+        if (event.eventPhase !== cc.Event.CAPTURING_PHASE) return false;
+        const hasNested = this._processNestedEvent(event, captureListeners);
+        // 只处理 TOUCH_END 和 TOUCH_CANCEL，且没有被嵌套拦截时，通知其他嵌套ViewGroup处理事件
+        if (
+          (event.type === cc.Node.EventType.TOUCH_END ||
+            event.type === cc.Node.EventType.TOUCH_CANCEL) &&
+          !hasNested
+        ) {
+          for (const item of captureListeners) {
+            this.onEnd(event, captureListeners, item);
+          }
+
+          this.onEnd(event, captureListeners, event.target);
+        }
+        return hasNested;
+      };
+    }
+  }
+
+  protected onDisable(): void {
+    this.unscheduleAllCallbacks();
+  }
+
+  private onEnd(event, captureListeners, item) {
+    if (item !== this.node) {
+      const viewGroup = item.getComponent(cc.ViewGroup);
+      if (viewGroup) {
+        if (
+          event.type === cc.Node.EventType.TOUCH_END &&
+          typeof viewGroup._onTouchEnded === 'function'
+        ) {
+          let touch = event.touch;
+          if (viewGroup.content) {
+            viewGroup._handleReleaseLogic(touch);
+          }
+        }
+        if (
+          event.type === cc.Node.EventType.TOUCH_CANCEL &&
+          typeof viewGroup._onTouchCancelled === 'function'
+        ) {
+          if (!event.simulate) {
+            let touch = event.touch;
+            if (viewGroup.content) {
+              viewGroup._handleReleaseLogic(touch);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  private _processNestedEvent(event: EventTouch, captureListeners: any[]): boolean {
+    if (!captureListeners) return false;
+
+    for (let i = 0; i < captureListeners.length; ++i) {
+      const item = captureListeners[i];
+      if (this.node === item) {
+        return event.target?.getComponent(cc.ViewGroup)
+          ? this.itemIsView(event.target, event)
+          : false;
+      }
+      if (item.getComponent(cc.ViewGroup)) {
+        return this.itemIsView(item, event);
+      }
+    }
+    return false;
+  }
+
+  itemIsView(target: cc.Node, event: EventTouch): boolean {
+    const scrollView = target.getComponent(cc.ScrollView);
+    if (!scrollView) return false;
+
+    const delta = this._getTouchDelta(event);
+    this._checkBoundary(scrollView);
+
+    return this._shouldIntercept(delta, scrollView);
+  }
+
+  /**
+   * 获取当前触摸的移动距离
+   * @returns {cc.Vec2} 触摸移动的偏移量
+   */
+  private _getTouchDelta(event: EventTouch): cc.Vec2 {
+    if (!event) return cc.v2(0, 0);
+    // 使用事件的起始位置和当前位置计算偏移
+    const startPos = event.getStartLocation ? event.getStartLocation() : cc.v2(0, 0);
+    const currentPos = event.getLocation ? event.getLocation() : cc.v2(0, 0);
+    return currentPos.sub(startPos);
+  }
+  //边界检测
+  private _checkBoundary(scrollView: cc.ScrollView) {
+    const offset = scrollView.getScrollOffset();
+    const maxOffset = scrollView.getMaxScrollOffset();
+
+    // 垂直边界
+    if (!scrollView.vertical) {
+      this._isBoundaryV = 0;
+    } else if (maxOffset.y <= 2) {
+      this._isBoundaryV = 3; //内部不滑动
+    } else if (offset.y <= 10) {
+      this._isBoundaryV = 1; // 顶部边界
+    } else if (offset.y >= maxOffset.y - 10) {
+      this._isBoundaryV = 2; // 底部边界
+    } else {
+      this._isBoundaryV = 0;
+    }
+    // 水平边界
+    if (!scrollView.horizontal) {
+      this._isBoundaryH = 0;
+    } else if (maxOffset.x <= 2) {
+      this._isBoundaryH = 3; //内部不滑动
+    } else if (offset.x >= -10) {
+      this._isBoundaryH = 1; // 左边界
+    } else if (offset.x <= -maxOffset.x + 10) {
+      this._isBoundaryH = 2; // 右边界
+    } else {
+      this._isBoundaryH = 0;
+    }
+
+    // FWLog.response('_isBoundaryV:', this._isBoundaryV);
+    // FWLog.response('_isBoundaryH:', this._isBoundaryH);
+    // console.log('offsetx:%d,offsety:%d', offset.x, offset.y);
+    // console.log('maxOffsetx:%d,maxOffsety:%d', maxOffset.x, maxOffset.y);
+  }
+
+  //方向拦截,边界拦截
+  private _shouldIntercept(delta: cc.Vec2, scrollView: cc.ScrollView): boolean {
+    //console.log('deltax:%d,deltay:%d', delta.x, delta.y);
+    //判断水平方向位移
+    if (scrollView.horizontal && this.scrollView.horizontal) {
+      //同向位移
+      if (Math.abs(delta.x) > this.dirThreshold) {
+        // 左边界且向左滚动，或右边界且向右滚动，交给父级处理
+        if (
+          (this._isBoundaryH === 1 && delta.x > 0) ||
+          (this._isBoundaryH === 2 && delta.x < 0) ||
+          this._isBoundaryH === 3
+        ) {
+          return false;
+        }
+        // 非边界，自己处理
+        return true;
+      }
+    }
+    // 垂直方向拦截
+    if (scrollView.vertical && this.scrollView.vertical) {
+      if (Math.abs(delta.y) > this.dirThreshold) {
+        // 顶部边界且向下滚动，或底部边界且向上滚动，交给父级处理
+        if (
+          (this._isBoundaryV === 1 && delta.y < 0) ||
+          (this._isBoundaryV === 2 && delta.y > 0) ||
+          this._isBoundaryV === 3
+        ) {
+          return false;
+        }
+        // 非边界，自己处理
+        return true;
+      }
+    }
+
+    // 默认不拦截
+    return false;
+  }
+}

package/expand/FWRollingViewNesting.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "3107e3b8-c4c4-41f0-8223-3e85b0b40821",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/expand/FWTweenExpand.ts

@@ -0,0 +1,44 @@
+cc.ActionInterval.prototype.step = function (dt: number) {
+  if (this.paused) {
+    return;
+  }
+  if (this._firstTick && !this._goto) {
+    this._firstTick = false;
+    this._elapsed = 0;
+  } else {
+    this._elapsed += dt;
+  }
+  let t =
+    this._elapsed / (this._duration > 0.0000001192092896 ? this._duration : 0.0000001192092896);
+  t = 1 > t ? t : 1;
+  this.update(t > 0 ? t : 0);
+  //Compatible with repeat class, Discard after can be deleted (this._repeatMethod)
+  if (this._repeatMethod && this._timesForRepeat > 1 && this.isDone()) {
+    if (!this._repeatForever) {
+      this._timesForRepeat--;
+    }
+    this.startWithTarget(this.target);
+    this.step(this._elapsed - this._duration);
+  }
+};
+
+cc.Tween.prototype.pause = function () {
+  this._finalAction.paused = true;
+};
+
+cc.Tween.prototype.resume = function () {
+  this._finalAction.paused = false;
+};
+
+cc.Tween.prototype.setSpeed = function (speed: number) {
+  this._finalAction._speedMethod = true;
+  this._finalAction._speed = speed;
+};
+
+cc.Tween.prototype.getDuration = function () {
+  return this._finalAction._duration;
+};
+
+cc.Tween.prototype.getElapsed = function () {
+  return this._finalAction._elapsed;
+};

package/expand/FWTweenExpand.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "93bd79eb-6b88-4783-a4c8-37d56fe720b4",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/expand.meta

@@ -0,0 +1,13 @@
+{
+  "ver": "1.1.3",
+  "uuid": "3261d225-82a8-4353-bd88-35178ac39c7a",
+  "importer": "folder",
+  "isBundle": false,
+  "bundleName": "",
+  "priority": 1,
+  "compressionType": {},
+  "optimizeHotUpdate": {},
+  "inlineSpriteFrames": {},
+  "isRemoteBundle": {},
+  "subMetas": {}
+}

package/item/FWVirtualListItem.ts

@@ -0,0 +1,150 @@
+import FWVirtualViewComponent from '../component/FWVirtualViewComponent';
+import FWObject from '../utils/FWObject';
+
+/******************************************
+ * @author kL <klk0@qq.com>
+ * @date 2019/6/6
+ * @doc 列表Item组件.
+ * 说明：
+ *      1、此组件须配合List组件使用。（配套的配套的..）
+ * @end
+ ******************************************/
+const { ccclass, property, disallowMultiple, menu, executionOrder } = cc._decorator;
+
+enum SelectedType {
+  NONE = 0,
+  TOGGLE = 1,
+  SWITCH = 2,
+}
+
+@ccclass
+@disallowMultiple()
+@menu('CustomComponent/FWVirtualListItem')
+@executionOrder(-5001) //先于List
+export default class FWVirtualListItem extends FWObject {
+  onGet(args: any) {}
+  onPut() {}
+  onInit() {}
+
+  //选择模式
+  @property({
+    type: cc.Enum(SelectedType),
+    tooltip: CC_DEV && '选择模式',
+  })
+  selectedMode: SelectedType = SelectedType.NONE;
+
+  //自适应尺寸
+  @property({
+    tooltip: CC_DEV && '自适应尺寸（宽或高）',
+  })
+  adaptiveSize: boolean = false;
+
+  //按钮组件
+  private _btnCom: any;
+  get btnCom() {
+    if (!this._btnCom) this._btnCom = this.node.getComponent(cc.Button);
+    return this._btnCom;
+  }
+  //依赖的List组件
+  public list: FWVirtualViewComponent;
+  //是否已经注册过事件
+  private _eventReg = false;
+  //序列id
+  public listId: number;
+
+  onLoad() {}
+
+  onDestroy() {
+    this.node.off(cc.Node.EventType.SIZE_CHANGED, this._onSizeChange, this);
+  }
+
+  _registerEvent() {
+    if (!this._eventReg) {
+      if (this.btnCom && this.list.selectedMode > 0) {
+        this.btnCom.clickEvents.unshift(this.createEvt(this, 'onClickThis'));
+      }
+      if (this.adaptiveSize) {
+        this.node.on(cc.Node.EventType.SIZE_CHANGED, this._onSizeChange, this);
+      }
+      this._eventReg = true;
+    }
+  }
+
+  _onSizeChange() {
+    this.list._onItemAdaptive(this.node);
+  }
+  /**
+   * 创建事件
+   * @param {cc.Component} component 组件脚本
+   * @param {string} handlerName 触发函数名称
+   * @param {cc.Node} node 组件所在node（不传的情况下取component.node）
+   * @returns cc.Component.EventHandler
+   */
+  createEvt(component: cc.Component, handlerName: string, node: cc.Node = null) {
+    if (!component.isValid) return; //有些异步加载的，节点以及销毁了。
+    component['comName'] =
+      component['comName'] ||
+      component.name
+        .match(/\<(.*?)\>/g)
+        .pop()
+        .replace(/\<|>/g, '');
+    let evt = new cc.Component.EventHandler();
+    evt.target = node || component.node;
+    evt.component = component['comName'];
+    evt.handler = handlerName;
+    return evt;
+  }
+
+  showAni(aniType: number, callFunc: Function, del: boolean) {
+    let t: any = this;
+    let tween: cc.Tween;
+    switch (aniType) {
+      case 0: //向上消失
+        tween = cc
+          .tween(t.node)
+          .to(0.2, { scale: 0.7 })
+          .by(0.3, { y: t.node.height * 2 });
+        break;
+      case 1: //向右消失
+        tween = cc
+          .tween(t.node)
+          .to(0.2, { scale: 0.7 })
+          .by(0.3, { x: t.node.width * 2 });
+        break;
+      case 2: //向下消失
+        tween = cc
+          .tween(t.node)
+          .to(0.2, { scale: 0.7 })
+          .by(0.3, { y: t.node.height * -2 });
+        break;
+      case 3: //向左消失
+        tween = cc
+          .tween(t.node)
+          .to(0.2, { scale: 0.7 })
+          .by(0.3, { x: t.node.width * -2 });
+        break;
+      default: //默认：缩小消失
+        tween = cc.tween(t.node).to(0.3, { scale: 0.1 });
+        break;
+    }
+    if (callFunc || del) {
+      tween.call(() => {
+        if (del) {
+          t.list._delSingleItem(t.node);
+          for (let n: number = t.list.displayData.length - 1; n >= 0; n--) {
+            if (t.list.displayData[n].id == t.listId) {
+              t.list.displayData.splice(n, 1);
+              break;
+            }
+          }
+        }
+        callFunc();
+      });
+    }
+    tween.start();
+  }
+
+  onClickThis() {
+    this.list.selectedId = this.listId;
+  }
+}

package/item/FWVirtualListItem.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "32751987-766e-44d4-af5a-4625d46aabf6",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/item.meta

@@ -0,0 +1,13 @@
+{
+  "ver": "1.1.3",
+  "uuid": "8c7436d1-86e8-49f9-86ee-e4a41a6010de",
+  "importer": "folder",
+  "isBundle": false,
+  "bundleName": "",
+  "priority": 1,
+  "compressionType": {},
+  "optimizeHotUpdate": {},
+  "inlineSpriteFrames": {},
+  "isRemoteBundle": {},
+  "subMetas": {}
+}

package/language/FWLanguage.ts

@@ -0,0 +1,69 @@
+import { FWEventDefine } from '../define/FWEventDefine';
+import { FWLodash } from '../utils/FWLodash';
+
+const { ccclass, property, executeInEditMode } = cc._decorator;
+
+@ccclass
+@executeInEditMode
+export default abstract class FWLanguage extends cc.Component {
+  @property
+  protected _language: number = 0;
+
+  @property({
+    type: FWLodash.CCEnum(['请选择语言', ...FW.Entry.languageMgr.getSupportedLanguages()]),
+    displayName: 'language',
+    visible: true,
+    serializable: true,
+  })
+  get language() {
+    return this._language;
+  }
+  set language(value: number) {
+    this._language = value;
+    this.onLanguageChange();
+  }
+  protected refresh() {
+    if (CC_EDITOR) {
+      this.onRefresh();
+      this.refreshInspector();
+    }
+  }
+
+  private refreshInspector() {
+    //@ts-ignore
+    Editor.Utils.refreshSelectedInspector('node', this.node.uuid);
+  }
+
+  protected onLoad(): void {
+    FW.Entry.evtMgr.register(
+      FWEventDefine.LanguageEvent.LANGUAGE_CHANGE,
+      () => {
+        this._language = FW.Entry.languageMgr.getLanguageIndex();
+        this.onLanguageChange();
+      },
+      this,
+    );
+  }
+
+  protected onEnable(): void {
+    if (!CC_EDITOR) {
+      this._language = FW.Entry.languageMgr.getLanguageIndex();
+      this.onLanguageChange();
+    }
+  }
+
+  protected onDestroy(): void {
+    FW.Entry.evtMgr.targetOff(this);
+  }
+
+  protected getSupportedLanguages(): string[] {
+    return FW.Entry.languageMgr.getSupportedLanguages();
+  }
+
+  protected getBundles(): string[] {
+    return FW.Entry.languageMgr.getBundles();
+  }
+
+  protected abstract onRefresh?(): void;
+  protected abstract onLanguageChange?(): void;
+}

package/language/FWLanguage.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "cfffdc57-7607-48db-be11-91ba8da0e96c",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/language/FWLanguageLabelLocalize.ts

@@ -0,0 +1,144 @@
+import { FWLodash } from '../utils/FWLodash';
+import FWLanguage from './FWLanguage';
+
+const { ccclass, property, executeInEditMode, menu, requireComponent } = cc._decorator;
+
+@ccclass
+@menu('Language/FWLanguageLabelLocalize')
+@requireComponent(cc.Label)
+@executeInEditMode
+export default class FWLanguageLabelLocalize extends FWLanguage {
+  @property({
+    type: FWLodash.CCEnum(['请选择语言包']),
+    displayName: 'bundle',
+    visible: true,
+  })
+  get bundle() {
+    return this._bundle;
+  }
+  set bundle(value: number) {
+    this._bundle = value;
+    this.onBundleChange();
+  }
+
+  @property({
+    type: FWLodash.CCEnum(['请选择索引']),
+    displayName: 'key',
+    visible: true,
+  })
+  get key() {
+    return this._key;
+  }
+  set key(value: number) {
+    this._key = value;
+    this.refresh();
+  }
+
+  protected onLoad(): void {
+    super.onLoad?.();
+    this.label = this.node.getComponent(cc.Label);
+  }
+
+  protected onEnable(): void {
+    super.onEnable?.();
+    this.onBundleChange();
+  }
+
+  public onRefresh(): void {
+    const label = this.node.getComponent(cc.Label);
+    if (this._language == 0 || this._bundle == 0 || this._key == 0) {
+      label.string = '';
+      return;
+    }
+    const keys = FW.Entry.languageMgr.getLanguagePackageEnumKeys(this.bundleName);
+    const str = FW.Entry.languageMgr.getLanguagePackageValue(
+      this.bundleName,
+      keys[this.key - 1],
+      this.languageName,
+    );
+    label.string = str;
+  }
+
+  protected onBundleChange(): void {
+    this.updateKeys();
+    this.refreshKes();
+    this.refresh();
+  }
+
+  protected onLanguageChange(): void {
+    if (this._language == 0) {
+      this._bundle = 0;
+      this._key = 0;
+    }
+    this.updateBundles();
+    this.updateKeys();
+    this.refreshBundles();
+    this.refreshKes();
+    this.refresh();
+  }
+
+  protected refreshKes() {
+    if (CC_EDITOR) {
+      //@ts-ignore
+      cc.Class.Attr.setClassAttr(
+        this.constructor,
+        'key',
+        'enumList',
+        //@ts-ignore
+        cc.Enum.getList(CCEnum(this._keys)),
+      );
+    }
+  }
+
+  protected updateKeys() {
+    if (this._language > 0 && this._bundle > 0) {
+      this._keys = [
+        '请选择索引',
+        ...Object.keys(FW.Entry.languageMgr.getLanguagePackageEnum(this.bundleName)),
+      ];
+    } else {
+      this._keys = ['请选择索引'];
+    }
+  }
+
+  get bundleName() {
+    const bundles = this.getBundles();
+    return bundles[this._bundle - 1];
+  }
+
+  get languageName() {
+    const languages = this.getSupportedLanguages();
+    return languages[this._language - 1];
+  }
+
+  protected updateBundles() {
+    if (this._language > 0) {
+      this._bundles = ['请选择语言包', ...this.getBundles()];
+    } else {
+      this._bundles = ['请选择语言包'];
+    }
+  }
+
+  protected refreshBundles() {
+    if (CC_EDITOR) {
+      //@ts-ignore
+      cc.Class.Attr.setClassAttr(
+        this.constructor,
+        'bundle',
+        'enumList',
+        //@ts-ignore
+        cc.Enum.getList(CCEnum(this._bundles)),
+      );
+    }
+  }
+
+  protected label: cc.Label = null;
+  @property
+  protected _key: number = 0;
+  @property
+  protected _keys: string[] = [];
+  @property
+  protected _bundle: number = 0;
+  @property
+  protected _bundles: string[] = [];
+}

package/language/FWLanguageLabelLocalize.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "3fb1f7df-6641-459a-b357-fff3ad37a9d0",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}