TypeScript Store.dispatch方法代码示例

 private onSuccess(
   importType: ImportType,
   resetWorkspace: boolean,
   vls: ReadonlyArray<VectorLayer>,
   animation?: Animation,
   hiddenLayerIds?: ReadonlySet<string>,
 ) {
   if (importType === ImportType.Json) {
     ga('send', 'event', 'Import', 'JSON');
     this.store.dispatch(new ResetWorkspace(vls[0], animation, hiddenLayerIds));
   } else {
     if (importType === ImportType.Svg) {
       ga('send', 'event', 'Import', 'SVG');
     } else if (importType === ImportType.VectorDrawable) {
       ga('send', 'event', 'Import', 'Vector Drawable');
     }
     if (resetWorkspace) {
       this.store.dispatch(new ResetWorkspace());
     }
     this.layerTimelineService.importLayers(vls);
     // TODO: count number of individual layers?
     this.snackBarService.show(
       `Imported ${vls.length} layer${vls.length === 1 ? '' : 's'}`,
       'Dismiss',
       Duration.Short,
     );
   }
 }

 /**
  * Replaces an existing layer in the tree with a new layer. Note that
  * this method assumes that both layers still have the same children layers.
  */
 swapLayers(layerId: string, newLayer: Layer) {
   if (layerId === newLayer.id) {
     this.updateLayer(newLayer);
     return;
   }
   const vl = this.getVectorLayer();
   const parent = LayerUtil.findParent(vl, layerId).clone();
   const layerIndex = _.findIndex(parent.children, l => l.id === layerId);
   const children = [...parent.children];
   children.splice(layerIndex, 1, newLayer);
   parent.children = children;
   const actions: Action[] = [
     new SetVectorLayer(LayerUtil.updateLayer(vl, parent)),
     ...this.buildCleanupLayerIdActions(layerId),
   ];
   const animation = this.getAnimation();
   const oldLayerBlocks = animation.blocks.filter(b => b.layerId === layerId);
   const newAnimatableProperties = new Set(newLayer.animatableProperties.keys());
   // Preserve any blocks that are still animatable with the new layer.
   const newLayerBlocks = oldLayerBlocks
     .filter(b => newAnimatableProperties.has(b.propertyName))
     .map(b => {
       b = b.clone();
       b.layerId = newLayer.id;
       return b;
     });
   const newAnimation = animation.clone();
   newAnimation.blocks = [
     ...animation.blocks.filter(b => b.layerId !== layerId),
     ...newLayerBlocks,
   ];
   actions.push(new SetAnimation(newAnimation));
   this.store.dispatch(new BatchAction(...actions));
 }

 toggleSubPathSelection(source: ActionSource, subIdx: number) {
   const selections = [...this.getSelections()];
   _.remove(selections, s => s.type !== SelectionType.SubPath || s.source !== source);
   const type = SelectionType.SubPath;
   const toggledSelections = this.toggleSelections(selections, [{ type, source, subIdx }]);
   this.store.dispatch(new SetActionModeSelections(toggledSelections));
 }

 closeActionMode() {
   const mode = this.getActionMode();
   if (mode === ActionMode.None) {
     return;
   }
   if (mode === ActionMode.Selection) {
     if (this.queryStore(getActionModeSelections).length) {
       // TODO: move this logic out into a component (it's confusing)
       this.store.dispatch(new SetActionModeSelections([]));
     } else {
       this.store.dispatch(new SetActionMode(ActionMode.None));
     }
   } else {
     this.store.dispatch(new SetActionMode(ActionMode.Selection));
   }
 }

 shiftPointToFront() {
   const selections = this.getSelections().filter(s => s.type === SelectionType.Point);
   const { source, subIdx, cmdIdx } = selections[0];
   const activePath = this.getActivePathBlockValue(source);
   const pm = activePath.mutate();
   pm.shiftSubPathForward(subIdx, cmdIdx);
   this.store.dispatch(this.buildUpdatedActivePathBlockAnimationAction(source, pm.build()));
 }

 /**
  * Toggles the specified layer's visibility.
  */
 toggleVisibleLayer(layerId: string) {
   const layerIds = this.getHiddenLayerIds();
   if (layerIds.has(layerId)) {
     layerIds.delete(layerId);
   } else {
     layerIds.add(layerId);
   }
   this.store.dispatch(new SetHiddenLayers(layerIds));
 }

 autoFix() {
   const [from, to] = AutoAwesome.autoFix(
     this.getActivePathBlockValue(ActionSource.From),
     this.getActivePathBlockValue(ActionSource.To),
   );
   let animation = this.buildUpdatedActivePathBlockAnimation(ActionSource.From, from);
   animation = this.buildUpdatedActivePathBlockAnimation(ActionSource.To, to, animation);
   this.store.dispatch(new SetAnimation(animation));
 }

 updateBlocks(blocks: ReadonlyArray<AnimationBlock>) {
   if (!blocks.length) {
     return;
   }
   const animation = this.getAnimation().clone();
   animation.blocks = animation.blocks.map(block => {
     const newBlock = _.find(blocks, b => block.id === b.id);
     return newBlock ? newBlock : block;
   });
   this.store.dispatch(new SetAnimation(animation));
 }

 toggleSegmentSelections(
   source: ActionSource,
   segments: ReadonlyArray<{ subIdx: number; cmdIdx: number }>,
 ) {
   const selections = [...this.getSelections()];
   _.remove(selections, s => s.type !== SelectionType.Segment || s.source !== source);
   const type = SelectionType.Segment;
   const toggledSelections = this.toggleSelections(
     selections,
     segments.map(({ subIdx, cmdIdx }) => ({ type, source, subIdx, cmdIdx })),
   );
   this.store.dispatch(new SetActionModeSelections(toggledSelections));
 }

 splitSelectedPointInHalf() {
   const selections = this.getSelections().filter(s => s.type === SelectionType.Point);
   const { source, subIdx, cmdIdx } = selections[0];
   const activePath = this.getActivePathBlockValue(source);
   const pm = activePath.mutate();
   pm.splitCommandInHalf(subIdx, cmdIdx);
   this.store.dispatch(
     new BatchAction(
       this.buildUpdatedActivePathBlockAnimationAction(source, pm.build()),
       new SetActionModeSelections([]),
       new SetActionModeHover(undefined),
     ),
   );
 }