Skip to content

Build your own AI office with Univer Office SDK. Bring editing, calculation, collaboration, and file processing into your product for people and AI agents. Built on an extensible open-source core.

fix: slide canvasview to slide render controller (#3032)

lumixdbdd85c705c9
diff --git a/packages-experimental/uni-formula-ui/src/services/uni-formula.service.ts b/packages-experimental/uni-formula-ui/src/services/uni-formula.service.ts
index 5df42c451d..8b59949860 100644
--- a/packages-experimental/uni-formula-ui/src/services/uni-formula.service.ts
+++ b/packages-experimental/uni-formula-ui/src/services/uni-formula.service.ts
@@ -39,11 +39,11 @@ import {
import { makeSelection, replaceSelectionFactory } from '@univerjs/docs';
import { DataSyncPrimaryController } from '@univerjs/rpc';
import { RegisterOtherFormulaService } from '@univerjs/sheets-formula';
-import { CanvasView } from '@univerjs/slides';
import type { IDocFormulaCache, ISlideFormulaCache } from '@univerjs/uni-formula';
import { DumbUniFormulaService, IUniFormulaService } from '@univerjs/uni-formula';
import { take } from 'rxjs';
import { RichText } from '@univerjs/engine-render';
+import { CanvasView } from '@univerjs/slides-ui';
import { type IDocPopupPosition, type ISlidePopupPosition, isSlidePosition } from '../commands/operations/operation';
const PSEUDO_SUBUNIT = 'PSEUDO_SUBUNIT';
diff --git a/packages/engine-render/src/components/slides/slide.ts b/packages/engine-render/src/components/slides/slide.ts
index 75924a4171..75dc970a96 100644
--- a/packages/engine-render/src/components/slides/slide.ts
+++ b/packages/engine-render/src/components/slides/slide.ts
@@ -37,6 +37,8 @@ const arrowPath =
export class Slide extends SceneViewer {
slideChangePageByNavigation$ = new EventSubject<Nullable<string>>();
+ subSceneChanged$ = new EventSubject<Scene>();
+
private _navigationEnabled = false;
activeFirstPage() {
@@ -48,13 +50,17 @@ export class Slide extends SceneViewer {
this.changePage(firstKey);
}
- addPage(scene: Scene) {
- const key = scene.sceneKey;
- if (this.getSubScene(key) != null) {
- return;
+ /**
+ * add pageScene to this._subScenes
+ * @param pageScene
+ */
+ addPageScene(pageScene: Scene) {
+ const key = pageScene.sceneKey;
+ if (!this.getSubScene(key)) {
+ this.addSubScene(pageScene);
}
- this.addSubScene(scene);
this.addNavigation();
+ this.subSceneChanged$.emitEvent(pageScene);
}
changePage(id?: string) {
diff --git a/packages/engine-render/src/render-manager/render-manager.service.ts b/packages/engine-render/src/render-manager/render-manager.service.ts
index 8bd04bcdea..21e7ec6b38 100644
--- a/packages/engine-render/src/render-manager/render-manager.service.ts
+++ b/packages/engine-render/src/render-manager/render-manager.service.ts
@@ -34,6 +34,12 @@ export interface IRenderManagerService extends IDisposable {
currentRender$: Observable<Nullable<string>>;
addRender(unitId: string, renderer: IRender): void;
+
+ /**
+ * create renderUnit & init deps from renderDependencies by renderUnit's type.
+ * @param unitId
+ * @returns renderUnit:IRender
+ */
createRender(unitId: string): IRender;
removeRender(unitId: string): void;
setCurrent(unitId: string): void;
@@ -68,6 +74,11 @@ export interface IRenderManagerService extends IDisposable {
has(unitId: string): boolean;
withCurrentTypeOfUnit<T>(type: UniverInstanceType, id: DependencyIdentifier<T>): Nullable<T>;
+ /**
+ * add dep to _renderDependencies(type, dep)
+ * @param type
+ * @param depCtor
+ */
registerRenderModule<T extends UnitModel>(type: UnitType, dep: Dependency<T>): IDisposable;
}
@@ -143,25 +154,35 @@ export class RenderManagerService extends Disposable implements IRenderManagerSe
});
}
- registerRenderModule(type: UnitType, ctor: Dependency): IDisposable {
+ /**
+ * add dep to _renderDependencies(type, dep)
+ * @param type
+ * @param depCtor
+ */
+ registerRenderModule(type: UnitType, depCtor: Dependency): IDisposable {
if (!this._renderDependencies.has(type)) {
this._renderDependencies.set(type, []);
}
const dependencies = this._renderDependencies.get(type)!;
- dependencies.push(ctor);
+ dependencies.push(depCtor);
for (const [_, render] of this._renderMap) {
const renderType = render.type;
if (renderType === type) {
- this._tryAddRenderDependencies(render, [ctor]);
+ this._tryAddRenderDependencies(render, [depCtor]);
}
}
- return toDisposable(() => remove(dependencies, ctor));
+ return toDisposable(() => remove(dependencies, depCtor));
}
- private _getRenderControllersForType(type: UnitType): Array<Dependency> {
+ /**
+ * get render dependencies from _renderDependencies
+ * @param type
+ * @returns Dependency[]
+ */
+ private _getRenderDepsByType(type: UnitType): Array<Dependency> {
return Array.from(this._renderDependencies.get(type) ?? []);
}
@@ -169,6 +190,11 @@ export class RenderManagerService extends Disposable implements IRenderManagerSe
this._createRender$.next(unitId);
}
+ /**
+ * create renderUnit & init deps from renderDependencies
+ * @param unitId
+ * @returns renderUnit:IRender
+ */
createRender(unitId: string): IRender {
const renderer = this._createRender(unitId, new Engine());
this._renderCreated$.next(renderer);
@@ -201,12 +227,24 @@ export class RenderManagerService extends Disposable implements IRenderManagerSe
return this.getRenderById(current.getUnitId())?.with(id);
}
+ /**
+ * init deps by injector.get(dep), and injector derives from renderer.
+ * @param renderer
+ * @param deps
+ */
private _tryAddRenderDependencies(renderer: IRender, deps: Dependency[]): void {
if (renderer instanceof RenderUnit) {
renderer.addRenderDependencies(deps);
}
}
+ /**
+ * create renderUnit & init deps from renderDependencies by renderUnit's type
+ * @param unitId
+ * @param engine
+ * @param isMainScene
+ * @returns renderUnit:IRender
+ */
private _createRender(unitId: string, engine: Engine, isMainScene: boolean = true): IRender {
const existItem = this.getRenderById(unitId);
let shouldDestroyEngine = true;
@@ -232,7 +270,8 @@ export class RenderManagerService extends Disposable implements IRenderManagerSe
if (unit) {
const type = this._univerInstanceService.getUnitType(unitId);
- const ctors = this._getRenderControllersForType(type);
+ const ctorOfDeps = this._getRenderDepsByType(type);
+
renderUnit = this._injector.createInstance(RenderUnit, {
unit,
engine,
@@ -240,7 +279,8 @@ export class RenderManagerService extends Disposable implements IRenderManagerSe
isMainScene,
});
- this._tryAddRenderDependencies(renderUnit, ctors);
+ // init deps
+ this._tryAddRenderDependencies(renderUnit, ctorOfDeps);
} else {
// For slide pages
renderUnit = {
@@ -256,7 +296,7 @@ export class RenderManagerService extends Disposable implements IRenderManagerSe
with(_dependency) {
return null;
},
- };
+ } as IRender;
}
this._addRenderUnit(unitId, renderUnit);
@@ -298,6 +338,11 @@ export class RenderManagerService extends Disposable implements IRenderManagerSe
return [...this.getRenderAll().values()][0];
}
+ /**
+ * get RenderUnit from this._renderMap
+ * @param unitId
+ * @returns RenderUnit, aka IRender
+ */
getRenderById(unitId: string): Nullable<IRender> {
return this._renderMap.get(unitId);
}
diff --git a/packages/engine-render/src/scene.ts b/packages/engine-render/src/scene.ts
index 3aa9b6e3fd..2b3318a6ea 100644
--- a/packages/engine-render/src/scene.ts
+++ b/packages/engine-render/src/scene.ts
@@ -565,6 +565,10 @@ export class Scene extends ThinScene {
});
}
+ /**
+ * create transformer if not exist, and then transformer attach to object that passed in by parameter.
+ * @param o
+ */
override attachTransformerTo(o: BaseObject) {
if (!this._transformer) {
this.initTransformer();
diff --git a/packages/sheets-ui/src/services/sheets-render.service.ts b/packages/sheets-ui/src/services/sheets-render.service.ts
index 0e18fe2678..bd14644f9a 100644
--- a/packages/sheets-ui/src/services/sheets-render.service.ts
+++ b/packages/sheets-ui/src/services/sheets-render.service.ts
@@ -72,7 +72,11 @@ export class SheetsRenderService extends RxDisposable {
private _initWorkbookListener(): void {
this._instanceSrv.getTypeOfUnitAdded$<Workbook>(UniverInstanceType.UNIVER_SHEET)
.pipe(takeUntil(this.dispose$))
- .subscribe((workbook) => this._createRenderer(workbook));
+ .subscribe((workbook) => {
+ // TODO when does this function get called?
+ this._createRenderer(workbook);
+ });
+
this._instanceSrv.getAllUnitsForType<Workbook>(UniverInstanceType.UNIVER_SHEET)
.forEach((workbook) => this._createRenderer(workbook));
diff --git a/packages/slides-ui/src/commands/operations/activate.operation.ts b/packages/slides-ui/src/commands/operations/activate.operation.ts
index 6e600fc75f..573178d9d0 100644
--- a/packages/slides-ui/src/commands/operations/activate.operation.ts
+++ b/packages/slides-ui/src/commands/operations/activate.operation.ts
@@ -16,7 +16,7 @@
import type { IAccessor, IOperation, SlideDataModel } from '@univerjs/core';
import { CommandType, IUniverInstanceService, UniverInstanceType } from '@univerjs/core';
-import { CanvasView } from '@univerjs/slides';
+import { CanvasView } from '../../controllers/canvas-view';
export interface IActiveSlidePageOperationParams {
unitId: string;
@@ -34,6 +34,7 @@ export const ActivateSlidePageOperation: IOperation<IActiveSlidePageOperationPar
if (!id) return false;
const page = canvasView.getRenderUnitByPageId(id);
+ if (!page) return false;
const transformer = page.scene?.getTransformer();
if (transformer) {
transformer.clearControls();
diff --git a/packages/slides-ui/src/commands/operations/append-slide.operation.ts b/packages/slides-ui/src/commands/operations/append-slide.operation.ts
index e55ffa5823..b2ebf5da80 100644
--- a/packages/slides-ui/src/commands/operations/append-slide.operation.ts
+++ b/packages/slides-ui/src/commands/operations/append-slide.operation.ts
@@ -16,7 +16,9 @@
import type { IOperation, SlideDataModel } from '@univerjs/core';
import { CommandType, IUniverInstanceService, UniverInstanceType } from '@univerjs/core';
-import { CanvasView } from '@univerjs/slides';
+import { IRenderManagerService } from '@univerjs/engine-render';
+
+import { SlideRenderController } from '../../controllers/slide.render-controller';
export interface IAppendSlideOperationParams {
unitId: string;
@@ -27,11 +29,15 @@ export const AppendSlideOperation: IOperation<IAppendSlideOperationParams> = {
type: CommandType.OPERATION,
handler: (accessor) => {
const univerInstanceService = accessor.get(IUniverInstanceService);
- const canvasView = accessor.get(CanvasView);
const slideData = univerInstanceService.getCurrentUnitForType<SlideDataModel>(UniverInstanceType.UNIVER_SLIDE);
-
if (!slideData) return false;
- canvasView.appendPage();
+
+ // const canvasView = accessor.get(CanvasView);
+ const renderManagerService = accessor.get(IRenderManagerService);
+ const renderUnit = renderManagerService
+ .getRenderById(univerInstanceService.getCurrentUnitForType(UniverInstanceType.UNIVER_SLIDE)!.getUnitId())!;
+ const slideRC = renderUnit.with(SlideRenderController);
+ slideRC.appendPage();
return true;
},
diff --git a/packages/slides-ui/src/commands/operations/delete-element.operation.ts b/packages/slides-ui/src/commands/operations/delete-element.operation.ts
index 414e9295a4..3e0abe32da 100644
--- a/packages/slides-ui/src/commands/operations/delete-element.operation.ts
+++ b/packages/slides-ui/src/commands/operations/delete-element.operation.ts
@@ -16,7 +16,7 @@
import type { ICommand, SlideDataModel } from '@univerjs/core';
import { CommandType, IUniverInstanceService, UniverInstanceType } from '@univerjs/core';
-import { CanvasView } from '@univerjs/slides';
+import { CanvasView } from '../../controllers/canvas-view';
export interface IDeleteElementOperationParams {
unitId: string;
diff --git a/packages/slides-ui/src/commands/operations/insert-image.operation.ts b/packages/slides-ui/src/commands/operations/insert-image.operation.ts
index 674e6a6922..4d85b599d8 100644
--- a/packages/slides-ui/src/commands/operations/insert-image.operation.ts
+++ b/packages/slides-ui/src/commands/operations/insert-image.operation.ts
@@ -17,7 +17,7 @@
import type { ICommand, Nullable, SlideDataModel } from '@univerjs/core';
import { CommandType, IUniverInstanceService, PageElementType, UniverInstanceType } from '@univerjs/core';
import { getImageSize, IImageIoService } from '@univerjs/drawing';
-import { CanvasView } from '@univerjs/slides';
+import { CanvasView } from '../../controllers/canvas-view';
export interface IInsertImageOperationParams {
files: Nullable<File[]>;
diff --git a/packages/slides-ui/src/commands/operations/insert-shape.operation.ts b/packages/slides-ui/src/commands/operations/insert-shape.operation.ts
index dcbaa3c138..c9528d86fc 100644
--- a/packages/slides-ui/src/commands/operations/insert-shape.operation.ts
+++ b/packages/slides-ui/src/commands/operations/insert-shape.operation.ts
@@ -17,9 +17,10 @@
import type { IAccessor, ICommand, SlideDataModel } from '@univerjs/core';
import { BasicShapes, CommandType, generateRandomId, ICommandService, IUniverInstanceService, LocaleService, PageElementType, UniverInstanceType } from '@univerjs/core';
import { ObjectType } from '@univerjs/engine-render';
-import { CanvasView } from '@univerjs/slides';
+
import { ISidebarService } from '@univerjs/ui';
import { COMPONENT_SLIDE_SIDEBAR } from '../../components/sidebar/Sidebar';
+import { CanvasView } from '../../controllers/canvas-view';
export interface IInsertShapeOperationParams {
unitId: string;
diff --git a/packages/slides-ui/src/commands/operations/insert-text.operation.ts b/packages/slides-ui/src/commands/operations/insert-text.operation.ts
index d2c4654d52..8b0e36a0ba 100644
--- a/packages/slides-ui/src/commands/operations/insert-text.operation.ts
+++ b/packages/slides-ui/src/commands/operations/insert-text.operation.ts
@@ -16,7 +16,7 @@
import type { ICommand, IPageElement, SlideDataModel } from '@univerjs/core';
import { CommandType, ICommandService, IUniverInstanceService, PageElementType, Tools, UniverInstanceType } from '@univerjs/core';
-import { CanvasView } from '@univerjs/slides';
+import { CanvasView } from '../../controllers/canvas-view';
export interface ISlideAddTextParam {
text: string;
diff --git a/packages/slides-ui/src/commands/operations/set-thumb.operation.ts b/packages/slides-ui/src/commands/operations/set-thumb.operation.ts
index 216429616e..c3cfa93841 100644
--- a/packages/slides-ui/src/commands/operations/set-thumb.operation.ts
+++ b/packages/slides-ui/src/commands/operations/set-thumb.operation.ts
@@ -16,7 +16,7 @@
import type { IAccessor, IOperation } from '@univerjs/core';
import { CommandType } from '@univerjs/core';
-import { CanvasView } from '@univerjs/slides';
+import { CanvasView } from '../../controllers/canvas-view';
export const SetSlidePageThumbOperation: IOperation = {
id: 'slide.operation.set-slide-page-thumb',
diff --git a/packages/slides-ui/src/components/panels/ArrangePanel.tsx b/packages/slides-ui/src/components/panels/ArrangePanel.tsx
index 0feb12a63e..0f839b65f4 100644
--- a/packages/slides-ui/src/components/panels/ArrangePanel.tsx
+++ b/packages/slides-ui/src/components/panels/ArrangePanel.tsx
@@ -21,9 +21,10 @@ import { ICommandService, LocaleService, useDependency } from '@univerjs/core';
import clsx from 'clsx';
import { Button } from '@univerjs/design';
import { BottomSingle, MoveDownSingle, MoveUpSingle, TopmostSingle } from '@univerjs/icons';
-import { CanvasView } from '@univerjs/slides';
+
import type { Image, Rect, RichText } from '@univerjs/engine-render';
import { UpdateSlideElementOperation } from '../../commands/operations/update-element.operation';
+import { CanvasView } from '../../controllers/canvas-view';
import styles from './index.module.less';
enum ArrangeTypeEnum {
diff --git a/packages/slides-ui/src/components/panels/FillPanel.tsx b/packages/slides-ui/src/components/panels/FillPanel.tsx
index 29e049b69b..e0c5f44c17 100644
--- a/packages/slides-ui/src/components/panels/FillPanel.tsx
+++ b/packages/slides-ui/src/components/panels/FillPanel.tsx
@@ -21,9 +21,10 @@ import { ICommandService, LocaleService, useDependency } from '@univerjs/core';
import clsx from 'clsx';
import { ColorPicker, Dropdown } from '@univerjs/design';
import { MoreDownSingle, PaintBucket } from '@univerjs/icons';
-import { CanvasView } from '@univerjs/slides';
+
import type { Rect } from '@univerjs/engine-render';
import { UpdateSlideElementOperation } from '../../commands/operations/update-element.operation';
+import { CanvasView } from '../../controllers/canvas-view';
import styles from './index.module.less';
interface IProps {
diff --git a/packages/slides-ui/src/components/panels/TransformPanel.tsx b/packages/slides-ui/src/components/panels/TransformPanel.tsx
index 4c22d0a0cf..a7ca802f55 100644
--- a/packages/slides-ui/src/components/panels/TransformPanel.tsx
+++ b/packages/slides-ui/src/components/panels/TransformPanel.tsx
@@ -21,8 +21,8 @@ import { ICommandService, LocaleService, useDependency } from '@univerjs/core';
import clsx from 'clsx';
import { InputNumber } from '@univerjs/design';
import type { BaseObject, IChangeObserverConfig, Image, Rect, RichText } from '@univerjs/engine-render';
-import { CanvasView } from '@univerjs/slides';
import { UpdateSlideElementOperation } from '../../commands/operations/update-element.operation';
+import { CanvasView } from '../../controllers/canvas-view';
import styles from './index.module.less';
interface IProps {
diff --git a/packages/slides-ui/src/components/sidebar/Sidebar.tsx b/packages/slides-ui/src/components/sidebar/Sidebar.tsx
index b3bb6279f3..70e4510c94 100644
--- a/packages/slides-ui/src/components/sidebar/Sidebar.tsx
+++ b/packages/slides-ui/src/components/sidebar/Sidebar.tsx
@@ -17,11 +17,12 @@
import type { Nullable, SlideDataModel } from '@univerjs/core';
import { IUniverInstanceService, UniverInstanceType, useDependency } from '@univerjs/core';
import { type BaseObject, ObjectType } from '@univerjs/engine-render';
-import { CanvasView } from '@univerjs/slides';
+
import React from 'react';
import ArrangePanel from '../panels/ArrangePanel';
import TransformPanel from '../panels/TransformPanel';
import FillPanel from '../panels/FillPanel';
+import { CanvasView } from '../../controllers/canvas-view';
import styles from './index.module.less';
export const COMPONENT_SLIDE_SIDEBAR = 'COMPONENT_SLIDE_SIDEBAR';
diff --git a/packages/slides-ui/src/controllers/canvas-view.ts b/packages/slides-ui/src/controllers/canvas-view.ts
new file mode 100644
index 0000000000..781325fed9
--- /dev/null
+++ b/packages/slides-ui/src/controllers/canvas-view.ts
@@ -0,0 +1,130 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { IPageElement, Nullable } from '@univerjs/core';
+import { Inject, Injector, IUniverInstanceService, LifecycleStages, OnLifecycle, RxDisposable, UniverInstanceType } from '@univerjs/core';
+import type {
+ BaseObject,
+ IRenderModule,
+ Scene,
+ ScrollBar,
+ Slide,
+ Viewport,
+} from '@univerjs/engine-render';
+import {
+ IRenderManagerService,
+} from '@univerjs/engine-render';
+
+import { SlideRenderController } from './slide.render-controller';
+
+export enum SLIDE_KEY {
+ COMPONENT = '__slideRender__',
+ SCENE = '__mainScene__',
+ VIEW = '__mainView__',
+}
+
+export type PageID = string;
+
+// export const ICanvasView = createIdentifier<IUniverInstanceService>('univer.slide.canvas-view');
+@OnLifecycle(LifecycleStages.Ready, CanvasView)
+export class CanvasView extends RxDisposable implements IRenderModule {
+ constructor(
+ // this controller needs by commands. The injector in Commands is root injector. T
+ // That means this controller is not init by renderUnit, no renderContext.
+ // private readonly _renderContext: IRenderContext<UnitModel>,
+ @Inject(Injector) private readonly _injector: Injector,
+ @IUniverInstanceService private readonly _instanceSrv: IUniverInstanceService,
+ @IRenderManagerService private readonly _renderManagerService: IRenderManagerService
+ ) {
+ super();
+ this._initialize();
+ }
+
+ private _scene: Scene | null = null;
+ private _viewport: Viewport | null = null;
+ private _slide: Slide | null = null;
+ private _scrollBar: ScrollBar | null = null;
+
+ get Scene() {
+ return this._scene;
+ }
+
+ get Viewport() {
+ return this._viewport;
+ }
+
+ get Slide() {
+ return this._slide;
+ }
+
+ get ScrollBar() {
+ return this._scrollBar;
+ }
+
+ private _initialize() {
+ //...
+ }
+
+ private _getSlideRenderControllerFromRenderUnit() {
+ const renderUnit = this._renderManagerService
+ .getRenderById(this._instanceSrv.getCurrentUnitForType(UniverInstanceType.UNIVER_SLIDE)!.getUnitId())!;
+ const slideRC = renderUnit.with(SlideRenderController);
+ return slideRC;
+ }
+
+ private _getRenderUnitByPageId(pageId: PageID) {
+ const slideRC = this._getSlideRenderControllerFromRenderUnit();
+ return slideRC.getPageRenderUnit(pageId);
+ }
+
+ createThumbs() {
+ const slideRC = this._getSlideRenderControllerFromRenderUnit();
+ slideRC.createThumbs();
+ }
+
+ activePage(_pageId?: string) {
+ const slideRC = this._getSlideRenderControllerFromRenderUnit();
+ slideRC.activePage(_pageId);
+ }
+
+ getRenderUnitByPageId(pageId: PageID) {
+ const slideRC = this._getSlideRenderControllerFromRenderUnit();
+ return slideRC.getPageRenderUnit(pageId);
+ }
+
+ createObjectToPage(element: IPageElement, pageID: PageID): Nullable<BaseObject> {
+ const slideRC = this._getSlideRenderControllerFromRenderUnit();
+ return slideRC.createObjectToPage(element, pageID);
+ }
+
+ setObjectActiveByPage(obj: BaseObject, pageID: PageID) {
+ const slideRC = this._getSlideRenderControllerFromRenderUnit();
+ return slideRC.setObjectActiveByPage(obj, pageID);
+ }
+
+ removeObjectById(id: string, pageID: PageID) {
+ const slideRC = this._getSlideRenderControllerFromRenderUnit();
+ slideRC.removeObjectById(id, pageID);
+ }
+
+ /**
+ * append blank page
+ */
+ appendPage() {
+ const slideRC = this._getSlideRenderControllerFromRenderUnit();
+ slideRC.appendPage();
+ }
+}
diff --git a/packages/slides-ui/src/controllers/popup-menu.controller.ts b/packages/slides-ui/src/controllers/popup-menu.controller.ts
index 6ebca091d1..0ff172e4d0 100644
--- a/packages/slides-ui/src/controllers/popup-menu.controller.ts
+++ b/packages/slides-ui/src/controllers/popup-menu.controller.ts
@@ -19,12 +19,13 @@ import { FOCUSING_COMMON_DRAWINGS, ICommandService, IContextService, Inject, IUn
import type { BaseObject, ObjectType, Scene } from '@univerjs/engine-render';
import { IRenderManagerService } from '@univerjs/engine-render';
import { ISidebarService } from '@univerjs/ui';
-import { CanvasView } from '@univerjs/slides';
+
import { SlideCanvasPopMangerService } from '../services/slide-popup-manager.service';
import { COMPONENT_SLIDE_IMAGE_POPUP_MENU } from '../components/image-popup-menu/component-name';
import { DeleteSlideElementOperation } from '../commands/operations/delete-element.operation';
import { ToggleSlideEditSidebarOperation } from '../commands/operations/insert-shape.operation';
import { UpdateSlideElementOperation } from '../commands/operations/update-element.operation';
+import { CanvasView } from './canvas-view';
@OnLifecycle(LifecycleStages.Steady, SlidePopupMenuController)
export class SlidePopupMenuController extends RxDisposable {
diff --git a/packages/slides-ui/src/controllers/slide-editing.render-controller.ts b/packages/slides-ui/src/controllers/slide-editing.render-controller.ts
index 0777bdad6d..0d64076f5f 100644
--- a/packages/slides-ui/src/controllers/slide-editing.render-controller.ts
+++ b/packages/slides-ui/src/controllers/slide-editing.render-controller.ts
@@ -82,6 +82,8 @@ import { ISlideEditorBridgeService } from '../services/slide-editor-bridge.servi
import { ISlideEditorManagerService } from '../services/slide-editor-manager.service';
import { SetTextEditArrowOperation } from '../commands/operations/text-edit.operation';
+import { CursorChange } from '../type';
+import { SLIDE_EDITOR_ID } from '../const';
const HIDDEN_EDITOR_POSITION = -1000;
@@ -94,12 +96,6 @@ interface ICanvasOffset {
top: number;
}
-enum CursorChange {
- InitialState,
- StartEditor,
- CursorChange,
-}
-
export class SlideEditingRenderController extends Disposable implements IRenderModule {
/**
* It is used to distinguish whether the user has actively moved the cursor in the editor, mainly through mouse clicks.
@@ -473,7 +469,9 @@ export class SlideEditingRenderController extends Disposable implements IRenderM
physicHeight = clientHeight;
if (scrollBar == null) {
- viewportMain && new ScrollBar(viewportMain, { enableHorizontal: false, barSize: 8 });
+ if (viewportMain) {
+ const sb = new ScrollBar(viewportMain, { enableHorizontal: false, barSize: 8 });
+ }
} else {
viewportMain?.resetCanvasSizeAndUpdateScroll();
}
@@ -719,7 +717,8 @@ export class SlideEditingRenderController extends Disposable implements IRenderM
// Only should do something when it is the current editor.
// FIXME: listen to command execution is pretty expensive. We should
// have multi editor instances and only handle event from a single editor.
- if (this._editorService.getFocusId() !== this._renderContext.unitId) {
+ if (this._editorService.getFocusId() !== SLIDE_EDITOR_ID) {
+ // if (this._editorService.getFocusId() !== this._renderContext.unitId) {
return;
}
diff --git a/packages/slides-ui/src/controllers/slide-editor-bridge.render-controller.ts b/packages/slides-ui/src/controllers/slide-editor-bridge.render-controller.ts
index dd6bf3f3db..01556a1dd9 100644
--- a/packages/slides-ui/src/controllers/slide-editor-bridge.render-controller.ts
+++ b/packages/slides-ui/src/controllers/slide-editor-bridge.render-controller.ts
@@ -19,34 +19,33 @@ import { DisposableCollection, ICommandService, IContextService, Inject, IUniver
import {
TextSelectionManagerService,
} from '@univerjs/docs';
-import type { BaseObject, IChangeObserverConfig, IRenderContext, IRenderModule, RichText } from '@univerjs/engine-render';
+import type { BaseObject, IRenderContext, IRenderModule, RichText, Scene, Slide } from '@univerjs/engine-render';
import { DeviceInputEventType, ITextSelectionRenderManager, ObjectType } from '@univerjs/engine-render';
-import { CanvasView } from '@univerjs/slides';
import { Subject } from 'rxjs';
+import { UpdateSlideElementOperation } from '../commands/operations/update-element.operation';
import type { ISetEditorInfo } from '../services/slide-editor-bridge.service';
import { ISlideEditorBridgeService } from '../services/slide-editor-bridge.service';
import type { ISlideRichTextProps } from '../type';
-import { UpdateSlideElementOperation } from '../commands/operations/update-element.operation';
// interface ICanvasOffset {
// left: number;
// top: number;
// }
-enum CursorChange {
- InitialState,
- StartEditor,
- CursorChange,
-}
+// enum CursorChange {
+// InitialState,
+// StartEditor,
+// CursorChange,
+// }
export class SlideEditorBridgeRenderController extends RxDisposable implements IRenderModule {
/**
* It is used to distinguish whether the user has actively moved the cursor in the editor, mainly through mouse clicks.
*/
- private _cursorChange: CursorChange = CursorChange.InitialState;
+ // private _cursorChange: CursorChange = CursorChange.InitialState;
/** If the corresponding unit is active and prepared for editing. */
- private _isUnitEditing = false;
+ // private _isUnitEditing = false;
setSlideTextEditor$: Subject<ISlideRichTextProps> = new Subject();
@@ -58,8 +57,7 @@ export class SlideEditorBridgeRenderController extends RxDisposable implements I
@ICommandService private readonly _commandService: ICommandService,
@ISlideEditorBridgeService private readonly _editorBridgeService: ISlideEditorBridgeService,
@Inject(TextSelectionManagerService) private readonly _textSelectionManagerService: TextSelectionManagerService,
- @ITextSelectionRenderManager private readonly _textSelectionRenderManager: ITextSelectionRenderManager,
- @Inject(CanvasView) private readonly _canvasView: CanvasView
+ @ITextSelectionRenderManager private readonly _textSelectionRenderManager: ITextSelectionRenderManager
) {
super();
//wait for sceneMap
@@ -88,42 +86,36 @@ export class SlideEditorBridgeRenderController extends RxDisposable implements I
scene,
engine,
unitId,
- pageId, // FIXME: wtf this is an empty string?
+ pageId,
richTextObj: targetObject,
};
- // editorBridgeRenderController@startEditing ---> editorBridgeRenderController@_updateEditor
+ // invoked by editorBridgeRenderController@startEditing ---> editorBridgeRenderController@_updateEditor
this._editorBridgeService.setEditorRect(setEditorRect);
}
private _initEventListener(d: DisposableCollection) {
- const model = this._instanceSrv.getCurrentUnitForType<SlideDataModel>(UniverInstanceType.UNIVER_SLIDE);
- const pagesMap = model?.getPages() ?? {};
- const pages = Object.values(pagesMap);
- for (let i = 0; i < pages.length; i++) {
- const page = pages[i];
- const { scene } = this._canvasView.getRenderUnitByPageId(page.id);
- if (!scene) break;
-
+ const listenersForPageScene = (scene: Scene) => {
const transformer = scene.getTransformer();
- if (!transformer) break;
+ if (!transformer) return;
d.add(transformer.clearControl$.subscribe(() => {
this.setEditorVisible(false);
+ this.pickOtherObjects();
}));
d.add(transformer.createControl$.subscribe(() => {
this.setEditorVisible(false);
}));
- d.add(transformer.changeStart$.subscribe((param: IChangeObserverConfig) => {
- const target = param.target;
- if (!target) return;
- if (target === this._curRichText) {
- // do nothing
- } else {
- this.pickOtherObjects();
- }
- }));
+ // d.add(transformer.changeStart$.subscribe((param: IChangeObserverConfig) => {
+ // const target = param.target;
+ // if (!target) return;
+ // if (target === this._curRichText) {
+ // // do nothing
+ // } else {
+ // this.pickOtherObjects();
+ // }
+ // }));
d.add(scene.onDblclick$.subscribeEvent(() => {
transformer.clearControls();
@@ -134,13 +126,34 @@ export class SlideEditorBridgeRenderController extends RxDisposable implements I
if (object.objectType !== ObjectType.RICH_TEXT) {
this.pickOtherObjects();
} else {
- this.startEditing(page.id, object as RichText);
+ this.startEditing(scene.sceneKey, object as RichText);
}
}));
d.add(this._instanceSrv.focused$.subscribe((fc: Nullable<string>) => {
this.endEditing();
}));
+ };
+
+ // const model = this._instanceSrv.getCurrentUnitForType<SlideDataModel>(UniverInstanceType.UNIVER_SLIDE);
+ // const pagesMap = model?.getPages() ?? {};
+ // const pages = Object.values(pagesMap);
+
+ const { mainComponent } = this._renderContext;
+ const slide = mainComponent as Slide;
+
+ // for new pages created by user
+ // TODO: better only one pageScene listener. but how?
+ // TODO: this controller is in render stage. but default page created in ready stage.
+ slide.subSceneChanged$.subscribeEvent((pageScene: Scene) => {
+ listenersForPageScene(pageScene);
+ });
+
+ // for default pages that already exist
+ const pageSceneList = Array.from((mainComponent as Slide).getSubScenes().values());
+ for (let i = 0; i < pageSceneList.length; i++) {
+ const pageScene = pageSceneList[i] as Scene;
+ listenersForPageScene(pageScene);
}
}
@@ -203,6 +216,7 @@ export class SlideEditorBridgeRenderController extends RxDisposable implements I
}
setEditorVisible(visible: boolean) {
+ // if editor is visible, hide curr RichTerxtObject
if (visible) {
this._curRichText?.hide();
} else {
diff --git a/packages/slides-ui/src/controllers/slide.render-controller.ts b/packages/slides-ui/src/controllers/slide.render-controller.ts
index 3721e5af8c..2b0fedb347 100644
--- a/packages/slides-ui/src/controllers/slide.render-controller.ts
+++ b/packages/slides-ui/src/controllers/slide.render-controller.ts
@@ -14,20 +14,484 @@
* limitations under the License.
*/
-import type { UnitModel } from '@univerjs/core';
-import { Inject, RxDisposable } from '@univerjs/core';
-import type { IRenderContext, IRenderModule } from '@univerjs/engine-render';
-import { ISlideEditorBridgeService } from '../services/slide-editor-bridge.service';
+import type { EventState, IColorStyle, IPageElement, ISlidePage, Nullable, SlideDataModel, UnitModel } from '@univerjs/core';
+import { debounce, getColorStyle, Inject, Injector, IUniverInstanceService, RxDisposable, UniverInstanceType } from '@univerjs/core';
+import type { BaseObject, IRenderContext, IRenderModule, IWheelEvent } from '@univerjs/engine-render';
+import {
+ IRenderManagerService,
+ Rect,
+ Scene,
+ ScrollBar,
+ Slide,
+ Viewport,
+} from '@univerjs/engine-render';
+import { ObjectProvider } from '@univerjs/slides';
+
+export enum SLIDE_KEY {
+ COMPONENT = '__slideRender__',
+ SCENE = '__mainScene__',
+ VIEW = '__mainView__',
+}
+
+export type PageID = string;
+
+// export const ICanvasView = createIdentifier<IUniverInstanceService>('univer.slide.canvas-view');
export class SlideRenderController extends RxDisposable implements IRenderModule {
+ private _objectProvider: ObjectProvider | null = null;
+
+ /**
+ * As a dep of UNIVER_SLIDE, init by RenderManagerService@createRender --> injector.get(dep)
+ * @param _renderContext
+ * @param _injector
+ * @param _univerInstanceService
+ * @param _renderManagerService
+ */
constructor(
- private readonly _context: IRenderContext<UnitModel<object, number>>,
- @Inject(ISlideEditorBridgeService) private _editorBridgeService: ISlideEditorBridgeService
+ private readonly _renderContext: IRenderContext<UnitModel>,
+ @Inject(Injector) private readonly _injector: Injector,
+ @IUniverInstanceService private readonly _univerInstanceService: IUniverInstanceService,
+ @IRenderManagerService private readonly _renderManagerService: IRenderManagerService
+
) {
super();
+ this._objectProvider = this._injector.createInstance(ObjectProvider);
+ this._addNewRender();
+ }
+
+ /**
+ * _initialize --> _create --> _addNewRender
+ */
+ private _addNewRender() {
+ const { unitId, engine, scene } = this._renderContext;
+ const slideDataModel = this._univerInstanceService.getUnit<SlideDataModel>(unitId, UniverInstanceType.UNIVER_SLIDE);
+
+ if (!slideDataModel) return;
+
+ // moved to slideRenderService@this._instanceSrv.getAllUnitsForType<SlideDataModel>(UniverInstanceType.UNIVER_SLIDE).forEach((slideModel)
+ // this._renderManagerService.createRender(unitId);
+
+ //#region scene subscribe
+ // const { engine, scene } = currentRender;
+ const observer = engine.onTransformChange$.subscribeEvent(() => {
+ this._scrollToCenter();
+ // add once
+ observer?.unsubscribe();
+ });
+ engine.onTransformChange$.subscribeEvent(() => {
+ setTimeout(() => {
+ this.createThumbs();
+ }, 300);
+ });
+
+ const viewMain = new Viewport(SLIDE_KEY.VIEW, scene, {
+ left: 0,
+ top: 0,
+ bottom: 0,
+ right: 0,
+ isRelativeX: true,
+ isRelativeY: true,
+ isWheelPreventDefaultX: true,
+ });
+ scene.attachControl();
+ scene.onMouseWheel$.subscribeEvent((evt: unknown, state: EventState) => {
+ const e = evt as IWheelEvent;
+ if (e.ctrlKey) {
+ const deltaFactor = Math.abs(e.deltaX);
+ let scrollNum = deltaFactor < 40 ? 0.2 : deltaFactor < 80 ? 0.4 : 0.2;
+ scrollNum *= e.deltaY > 0 ? -1 : 1;
+ if (scene.scaleX < 1) {
+ scrollNum /= 2;
+ }
+
+ if (scene.scaleX + scrollNum > 4) {
+ scene.scale(4, 4);
+ } else if (scene.scaleX + scrollNum < 0.1) {
+ scene.scale(0.1, 0.1);
+ } else {
+ const value = e.deltaY > 0 ? 0.1 : -0.1;
+ // scene.scaleBy(scrollNum, scrollNum);
+ e.preventDefault();
+ }
+ } else {
+ viewMain.onMouseWheel(e, state);
+ }
+ });
+ scene.onFileLoaded$.subscribeEvent(() => {
+ this._refreshThumb();
+ });
+ //#endregion
+
+ ScrollBar.attachTo(viewMain);
+ this._renderManagerService.setCurrent(unitId);
+
+ // #region create slide
+ const slide = this._createSlide(scene);
+ this._renderContext.mainComponent = slide;
+ this._createSlidePages(slideDataModel, slide);
+ this.createThumbs();
+ // #endregion
+
+ engine.runRenderLoop(() => {
+ scene.render();
+ });
+ }
+
+ get objectProvider() {
+ return this._objectProvider;
+ }
+
+ activePage(_pageId?: string) {
+ let pageId = _pageId;
+ const model = this._univerInstanceService.getCurrentUnitForType<SlideDataModel>(UniverInstanceType.UNIVER_SLIDE)!;
+ let page: Nullable<ISlidePage>;
+ if (pageId) {
+ page = model.getPage(pageId);
+ } else {
+ const pageElements = model.getPages();
+ const pageOrder = model.getPageOrder();
+ if (pageOrder == null || pageElements == null) {
+ return;
+ }
+ page = pageElements[pageOrder[0]];
+
+ pageId = page.id;
+ }
+
+ const render = this._currentRender();
+
+ if (page == null || render == null || render.mainComponent == null) {
+ return;
+ }
+
+ const { id } = page;
+
+ const slide = render.mainComponent as Slide;
+
+ model.setActivePage(page);
+
+ if (slide?.hasPage(id)) {
+ slide.changePage(id);
+ return;
+ }
+
+ this.createPageScene(id, page);
+ }
+
+ private _scrollToCenter() {
+ const mainScene = this._currentRender()?.scene;
+ const viewMain = mainScene?.getViewport(SLIDE_KEY.VIEW);
+ const getCenterPositionViewPort = this._getCenterPositionViewPort(mainScene);
+ if (!viewMain || !getCenterPositionViewPort) return;
+ const { left: viewPortLeft, top: viewPortTop } = getCenterPositionViewPort;
+
+ const { x, y } = viewMain.transViewportScroll2ScrollValue(viewPortLeft, viewPortTop);
+
+ viewMain.scrollToBarPos({
+ x,
+ y,
+ });
+ }
+
+ private _currentRender() {
+ const slideDataModel = this._univerInstanceService.getCurrentUnitForType<SlideDataModel>(UniverInstanceType.UNIVER_SLIDE)!;
+ return this._renderManagerService.getRenderById(slideDataModel.getUnitId());
+ }
+
+ private _refreshThumb = debounce(() => {
+ this.createThumbs();
+ }, 300);
+
+ /**
+ * init --> _addNewRender
+ * @param mainScene
+ */
+ private _createSlide(mainScene: Scene) {
+ const model = this._univerInstanceService.getCurrentUnitForType<SlideDataModel>(UniverInstanceType.UNIVER_SLIDE)!;
+
+ const { width: sceneWidth, height: sceneHeight } = mainScene;
+
+ const pageSize = model.getPageSize();
+
+ const { width = 100, height = 100 } = pageSize;
+
+ const slideComponent = new Slide(SLIDE_KEY.COMPONENT, {
+ left: (sceneWidth - width) / 2,
+ top: (sceneHeight - height) / 2,
+ width,
+ height,
+ zIndex: 10,
+ });
+
+ // slideComponent.enableNav();
+
+ slideComponent.enableSelectedClipElement();
+
+ mainScene.addObject(slideComponent);
+
+ return slideComponent;
+ }
+
+ private _addBackgroundRect(scene: Scene, fill: IColorStyle) {
+ const model = this._univerInstanceService.getCurrentUnitForType<SlideDataModel>(UniverInstanceType.UNIVER_SLIDE)!;
+
+ const pageSize = model.getPageSize();
+
+ const { width: pageWidth = 0, height: pageHeight = 0 } = pageSize;
+
+ const page = new Rect('canvas', {
+ left: 0,
+ top: 0,
+ width: pageWidth,
+ height: pageHeight,
+ strokeWidth: 1,
+ stroke: 'rgba(198,198,198,1)',
+ fill: getColorStyle(fill) || 'rgba(255,255,255,1)',
+ zIndex: 0,
+ evented: false,
+ });
+ scene.addObject(page, 0);
+ }
+
+ private _getCenterPositionViewPort(mainScene?: Scene) {
+ if (!mainScene) return { left: 0, top: 0 };
+ const { width, height } = mainScene;
+
+ const engine = mainScene.getEngine();
+
+ const canvasWidth = engine?.width || 0;
+ const canvasHeight = engine?.height || 0;
+
+ return {
+ left: (width - canvasWidth) / 2,
+ top: (height - canvasHeight) / 2,
+ };
+ }
+
+ private _thumbSceneRender(pageId: string, slide: Slide) {
+ const render = this._renderManagerService.getRenderById(pageId);
+
+ if (render == null) {
+ return;
+ }
+
+ const { engine: thumbEngine } = render;
+
+ if (thumbEngine == null) {
+ return;
+ }
+
+ const { width, height } = slide;
+
+ const { width: pageWidth = width, height: pageHeight = height } = thumbEngine;
+
+ const thumbContext = thumbEngine.getCanvas().getContext();
+
+ slide.renderToThumb(thumbContext, pageId, pageWidth / width, pageHeight / height);
+ }
+
+ /**
+ * _createScene by pages, createScene --> set sceneMap
+ * invoked stack: initialize --> _create --> _addNewRender --> _createSlidePages
+ * @param slideDataModel
+ * @param slide
+ */
+ private _createSlidePages(slideDataModel: SlideDataModel, slide: Slide) {
+ const pages = slideDataModel.getPages();
+
+ const pageOrder = slideDataModel.getPageOrder();
+
+ if (!pages || !pageOrder) {
+ return;
+ }
+
+ if (pageOrder.length === 0) {
+ return;
+ }
+
+ for (let i = 0, len = pageOrder.length; i < len; i++) {
+ const pageId = pageOrder[i];
+
+ this.createPageScene(pageId, pages[pageId]);
+
+ this._createThumb(pageId);
+ }
+
+ // setTimeout(() => {
+ // for (let i = 0, len = pageOrder.length; i < len; i++) {
+ // const pageId = pageOrder[i];
+
+ // this._thumbSceneRender(pageId, slide);
+ // }
+ // }, 0);
+
+ slide.activeFirstPage();
}
- override dispose() {
- //...
+ createThumbs() {
+ const slideDataModel = this._univerInstanceService.getCurrentUnitForType<SlideDataModel>(UniverInstanceType.UNIVER_SLIDE)!;
+
+ const pageOrder = slideDataModel.getPageOrder();
+
+ const render = this._currentRender();
+
+ if (!pageOrder || !render) {
+ return;
+ }
+
+ if (pageOrder.length === 0) {
+ return;
+ }
+
+ for (let i = 0, len = pageOrder.length; i < len; i++) {
+ const pageId = pageOrder[i];
+
+ this._thumbSceneRender(pageId, render.mainComponent as Slide);
+ }
+ }
+
+ private _createThumb(pageId: string) {
+ this._renderManagerService.createRender(pageId);
+ }
+
+ // private _sceneMap = new Map<string, Scene>();
+ // setSceneMap$ = new Subject<Scene>();
+
+ /**
+ * _initialize --> _create --> _addNewRender --> _createSlidePages --> page forEach --> createPageScene
+ * _sceneMap.set(pageId, pageScene);
+ *
+ * @param pageId
+ * @param page
+ * @returns pageScene: Scene
+ */
+ createPageScene(pageId: string, page: ISlidePage) {
+ // const render = this._currentRender();
+ const render = this._renderContext;
+ if (!render || !this.objectProvider) {
+ return;
+ }
+
+ const { scene: mainScene, mainComponent } = render;
+
+ const slide = mainComponent as Slide;
+ const { width, height } = slide;
+
+ // new Scene ----> add SubScene.
+ const pageScene = new Scene(pageId, slide, {
+ width,
+ height,
+ });
+
+ const viewMain = new Viewport(`PageViewer_${pageId}`, pageScene, {
+ left: 0,
+ top: 0,
+ bottom: 0,
+ right: 0,
+ isRelativeX: true,
+ isRelativeY: true,
+ });
+ viewMain.closeClip();
+
+ const { pageElements, pageBackgroundFill } = page;
+
+ // SceneViewers
+ const objects = this.objectProvider.convertToRenderObjects(pageElements, mainScene);
+ if (!objects || !slide) return;
+
+ this._addBackgroundRect(pageScene, pageBackgroundFill);
+ pageScene.addObjects(objects);
+
+ pageScene.initTransformer();
+ objects.forEach((object) => {
+ pageScene.attachTransformerTo(object);
+ });
+
+ const transformer = pageScene.getTransformer();
+
+ transformer?.changeEnd$.subscribe(() => {
+ this._thumbSceneRender(pageId, slide);
+ });
+
+ transformer?.clearControl$.subscribe(() => {
+ this._thumbSceneRender(pageId, slide);
+ });
+
+ // add SubScene
+ slide.addPageScene(pageScene);
+
+ return pageScene;
+ }
+
+ /**
+ * get pageScene from Slide
+ * pageScene was added to the mainComponent(Slide) in createPageScene --> slide.addPageScene
+ * @param pageId
+ * @returns {Scene, Engine, UnitModel}
+ */
+ getPageRenderUnit(pageId: PageID) {
+ const subsceneMap = (this._renderContext.mainComponent as Slide).getSubScenes();
+ const pageScene = subsceneMap.get(pageId) as unknown as Scene;
+ const { engine, unit } = this._renderContext;
+ return {
+ scene: pageScene,
+ engine,
+ unit,
+ };
+ }
+
+ createObjectToPage(element: IPageElement, pageID: PageID): Nullable<BaseObject> {
+ const render = this._renderContext; //this._currentRender();
+
+ if (!render || !this.objectProvider) {
+ return;
+ }
+ const { scene } = this.getPageRenderUnit(pageID);
+ if (!scene) return;
+
+ const object = this.objectProvider.convertToRenderObject(element, scene);
+ if (object) {
+ scene.addObject(object);
+ scene.attachTransformerTo(object);
+ scene.getLayer().makeDirty();
+ return object;
+ }
+ }
+
+ setObjectActiveByPage(obj: BaseObject, pageID: PageID) {
+ const { scene } = this.getPageRenderUnit(pageID);
+ if (!scene) return;
+ const transformer = scene.getTransformer();
+ transformer?.activeAnObject(obj);
+ }
+
+ removeObjectById(id: string, pageID: PageID) {
+ const { scene } = this.getPageRenderUnit(pageID);
+ if (!scene) return;
+ scene.removeObject(id);
+ const transformer = scene.getTransformer();
+ transformer?.clearControls();
+ }
+
+ appendPage() {
+ const model = this._univerInstanceService.getCurrentUnitForType<SlideDataModel>(UniverInstanceType.UNIVER_SLIDE)!;
+ const page = model.getBlankPage();
+
+ const render = this._currentRender();
+
+ if (page == null || render == null || render.mainComponent == null) {
+ return;
+ }
+
+ const { id } = page;
+
+ const slide = render.mainComponent as Slide;
+
+ const scene = this.createPageScene(id, page);
+
+ scene && slide?.addPageScene(scene);
+
+ model.appendPage(page);
+ model.setActivePage(page);
}
}
diff --git a/packages/slides-ui/src/index.ts b/packages/slides-ui/src/index.ts
index 4747e552af..e9bad3001f 100644
--- a/packages/slides-ui/src/index.ts
+++ b/packages/slides-ui/src/index.ts
@@ -39,3 +39,5 @@ export { UpdateSlideElementOperation } from './commands/operations/update-elemen
export { SlideEditorContainer } from './views/editor-container/EditorContainer';
export { SLIDE_EDITOR_ID } from './const';
+
+export { CanvasView } from './controllers/canvas-view';
diff --git a/packages/slides-ui/src/services/slide-render.service.ts b/packages/slides-ui/src/services/slide-render.service.ts
new file mode 100644
index 0000000000..2105f94333
--- /dev/null
+++ b/packages/slides-ui/src/services/slide-render.service.ts
@@ -0,0 +1,102 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { SlideDataModel, Workbook } from '@univerjs/core';
+import {
+ IContextService,
+ IUniverInstanceService,
+ LifecycleStages,
+ OnLifecycle,
+ RxDisposable,
+ UniverInstanceType,
+} from '@univerjs/core';
+import { IRenderManagerService } from '@univerjs/engine-render';
+import { takeUntil } from 'rxjs';
+
+/**
+ * This controller is responsible for managing units of a specific kind to be rendered on the canvas.
+ */
+@OnLifecycle(LifecycleStages.Ready, SlideRenderService)
+export class SlideRenderService extends RxDisposable {
+ // private _skeletonChangeMutations = new Set<string>();
+
+ constructor(
+ @IContextService private readonly _contextService: IContextService,
+ @IUniverInstanceService private readonly _instanceSrv: IUniverInstanceService,
+ @IRenderManagerService private readonly _renderManagerService: IRenderManagerService
+ ) {
+ super();
+
+ // It should be initialized after all other plugins are ready.
+ Promise.resolve().then(() => this._init());
+ }
+
+ private _init() {
+ this._initSlideDataListener();
+ this._initContextListener();
+ }
+
+ private _initSlideDataListener(): void {
+ this._instanceSrv.getTypeOfUnitAdded$<Workbook>(UniverInstanceType.UNIVER_SLIDE)
+ .pipe(takeUntil(this.dispose$))
+ .subscribe((slideModel) => {
+ // TODO when does this function get called?
+ this._createRenderer(slideModel?.getUnitId());
+ });
+
+ this._instanceSrv.getAllUnitsForType<SlideDataModel>(UniverInstanceType.UNIVER_SLIDE).forEach((slideModel) => {
+ this._createRenderer(slideModel.getUnitId());
+ });
+
+ this._instanceSrv.getTypeOfUnitDisposed$<Workbook>(UniverInstanceType.UNIVER_SLIDE)
+ .pipe(takeUntil(this.dispose$))
+ .subscribe((workbook) => this._disposeRenderer(workbook));
+ }
+
+ private _createRenderer(unitId: string): void {
+ if (unitId == null) {
+ return;
+ }
+
+ const model = this._instanceSrv.getUnit(unitId, UniverInstanceType.UNIVER_SLIDE);
+ if (model == null) {
+ return;
+ }
+
+ this._renderManagerService.createRender(unitId);
+
+ // NOTE@wzhudev: maybe not in univer mode
+ this._renderManagerService.setCurrent(unitId);
+ }
+
+ private _disposeRenderer(workbook: Workbook): void {
+ const unitId = workbook.getUnitId();
+ this._renderManagerService.removeRender(unitId);
+ }
+
+ private _initContextListener(): void {
+ // If we toggle the raw formula, we need to refresh all spreadsheets.
+ // this._contextService.subscribeContextValue$(RENDER_RAW_FORMULA_KEY)
+ // .pipe(distinctUntilChanged(), takeUntil(this.dispose$))
+ // .subscribe(() => {
+ // this._renderManagerService.getRenderAll().forEach((renderer) => {
+ // if (renderer.mainComponent instanceof Spreadsheet) {
+ // (renderer.mainComponent as Spreadsheet).makeForceDirty(true);
+ // }
+ // });
+ // });
+ }
+}
diff --git a/packages/slides-ui/src/slides-ui-plugin.ts b/packages/slides-ui/src/slides-ui-plugin.ts
index 07011a4606..a50c087262 100644
--- a/packages/slides-ui/src/slides-ui-plugin.ts
+++ b/packages/slides-ui/src/slides-ui-plugin.ts
@@ -18,6 +18,7 @@ import type { Dependency, SlideDataModel } from '@univerjs/core';
import { Inject, Injector, IUniverInstanceService, mergeOverrideWithDependencies, Plugin, UniverInstanceType } from '@univerjs/core';
import { IRenderManagerService } from '@univerjs/engine-render';
+
import type { IUniverSlidesDrawingConfig } from './controllers/slide-ui.controller';
import { SlidesUIController } from './controllers/slide-ui.controller';
import { SlideRenderController } from './controllers/slide.render-controller';
@@ -27,6 +28,8 @@ import { ISlideEditorBridgeService, SlideEditorBridgeService } from './services/
import { SlideEditorBridgeRenderController } from './controllers/slide-editor-bridge.render-controller';
import { ISlideEditorManagerService, SlideEditorManagerService } from './services/slide-editor-manager.service';
import { SlideEditingRenderController } from './controllers/slide-editing.render-controller';
+import { SlideRenderService } from './services/slide-render.service';
+import { CanvasView } from './controllers/canvas-view';
export const SLIDE_UI_PLUGIN_NAME = 'SLIDE_UI';
@@ -45,31 +48,41 @@ export class UniverSlidesUIPlugin extends Plugin {
override onStarting(): void {
mergeOverrideWithDependencies([
+ [SlideRenderService],
[ISlideEditorBridgeService, { useClass: SlideEditorBridgeService }],
// used by SlideUIController --> EditorContainer
[ISlideEditorManagerService, { useClass: SlideEditorManagerService }],
[SlideCanvasPopMangerService],
- ] as Dependency[], this._config.override).forEach((d) => this._injector.add(d));
+ ] as Dependency[], this._config.override)
+ .forEach((d) => this._injector.add(d));
}
override onReady(): void {
+ ([
+ // SlideRenderService will be init in ready stage, and then calling RenderManagerService@createRender --> init all deps in this rendering register block.
+
+ [SlideRenderController],
+ ] as Dependency[]).forEach((m) => {
+ this.disposeWithMe(this._renderManagerService.registerRenderModule(UniverInstanceType.UNIVER_SLIDE, m));
+ });
mergeOverrideWithDependencies([
+ [CanvasView],
// cannot register in _renderManagerService now.
// [ISlideEditorBridgeService, { useClass: SlideEditorBridgeService }],
// // used by SlideUIController --> EditorContainer
// [ISlideEditorManagerService, { useClass: SlideEditorManagerService }],
- // This controller should be registered in Ready stage.
- // this controller would add a new RenderUnit (__INTERNAL_EDITOR__DOCS_NORMAL)
- // so this new RenderUnit does not have ISlideEditorBridgeService & ISlideEditorManagerService if
+ // SlidesUIController controller should be registered in Ready stage.
+ // SlidesUIController controller would add a new RenderUnit (__INTERNAL_EDITOR__DOCS_NORMAL)
[SlidesUIController, {
useFactory: () => this._injector.createInstance(SlidesUIController, this._config),
- }], // editor service were create in renderManagerService
+ }], // editor service was create in renderManagerService
[SlideRenderController],
[SlidePopupMenuController],
] as Dependency[], this._config.override).forEach((m) => {
this._injector.add(m);
});
+ this._injector.get(CanvasView);
}
override onRendered(): void {
@@ -90,8 +103,8 @@ export class UniverSlidesUIPlugin extends Plugin {
private _markSlideAsFocused() {
const currentService = this._univerInstanceService;
try {
- const slide = currentService.getCurrentUnitForType<SlideDataModel>(UniverInstanceType.UNIVER_SLIDE)!;
- currentService.focusUnit(slide.getUnitId());
+ const slideDataModel = currentService.getCurrentUnitForType<SlideDataModel>(UniverInstanceType.UNIVER_SLIDE)!;
+ currentService.focusUnit(slideDataModel.getUnitId());
} catch (e) {
}
}
diff --git a/packages/slides-ui/src/type.ts b/packages/slides-ui/src/type.ts
index 148cc8a8f3..ae1f0e8f25 100644
--- a/packages/slides-ui/src/type.ts
+++ b/packages/slides-ui/src/type.ts
@@ -31,3 +31,9 @@ export interface ISlideRichTextProps {
fs: number;
//... align margin...
};
+
+export enum CursorChange {
+ InitialState,
+ StartEditor,
+ CursorChange,
+}
diff --git a/packages/slides/src/slides-plugin.ts b/packages/slides/src/slides-plugin.ts
index 3e7da9f1e3..358f341ec5 100644
--- a/packages/slides/src/slides-plugin.ts
+++ b/packages/slides/src/slides-plugin.ts
@@ -19,7 +19,7 @@ import type { Engine } from '@univerjs/engine-render';
import { IRenderingEngine, IRenderManagerService } from '@univerjs/engine-render';
import type { Dependency } from '@univerjs/core';
// import { TextSelectionManagerService } from '@univerjs/docs';
-import { CanvasView } from './views/render';
+// import { CanvasView } from './views/render';
export interface IUniverSlidesConfig {}
@@ -74,7 +74,7 @@ export class UniverSlidesPlugin extends Plugin {
private _initializeDependencies(slideInjector: Injector) {
const dependencies: Dependency[] = [
- [CanvasView],
+ // [CanvasView],
// [TextSelectionManagerService],
];
diff --git a/packages/slides/src/views/render/adaptors/slide-adaptor.ts b/packages/slides/src/views/render/adaptors/slide-adaptor.ts
index 36d6354f01..3b571b7039 100644
--- a/packages/slides/src/views/render/adaptors/slide-adaptor.ts
+++ b/packages/slides/src/views/render/adaptors/slide-adaptor.ts
@@ -107,7 +107,7 @@ export class SlideAdaptor extends ObjectAdaptor {
for (let i = 0, len = pageOrder.length; i < len; i++) {
const page = pages[pageOrder[i]];
const { id } = page;
- slideComponent.addPage(this._createScene(id, slideComponent, page, mainScene, model));
+ slideComponent.addPageScene(this._createScene(id, slideComponent, page, mainScene, model));
}
slideComponent.activeFirstPage();
diff --git a/packages/slides/src/views/render/canvas-view.ts b/packages/slides/src/views/render/canvas-view.ts
deleted file mode 100644
index 191da52200..0000000000
--- a/packages/slides/src/views/render/canvas-view.ts
+++ /dev/null
@@ -1,518 +0,0 @@
-/**
- * Copyright 2023-present DreamNum Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import type { EventState, IColorStyle, IPageElement, ISlidePage, Nullable, SlideDataModel } from '@univerjs/core';
-import { debounce, getColorStyle, Inject, Injector, IUniverInstanceService, LifecycleStages, OnLifecycle, RxDisposable, UniverInstanceType } from '@univerjs/core';
-import type { BaseObject, IRenderModule, IWheelEvent } from '@univerjs/engine-render';
-import {
- IRenderManagerService,
- Rect,
- Scene,
- ScrollBar,
- Slide,
- Viewport,
-} from '@univerjs/engine-render';
-
-import { takeUntil } from 'rxjs';
-import { ObjectProvider } from './object-provider';
-
-export enum SLIDE_KEY {
- COMPONENT = '__slideRender__',
- SCENE = '__mainScene__',
- VIEW = '__mainView__',
-}
-
-export type PageID = string;
-
-// export const ICanvasView = createIdentifier<IUniverInstanceService>('univer.slide.canvas-view');
-@OnLifecycle(LifecycleStages.Ready, CanvasView)
-export class CanvasView extends RxDisposable implements IRenderModule {
- private _objectProvider: ObjectProvider | null = null;
-
- constructor(
- @Inject(Injector) private readonly _injector: Injector,
- @IUniverInstanceService private readonly _univerInstanceService: IUniverInstanceService,
- @IRenderManagerService private readonly _renderManagerService: IRenderManagerService
- ) {
- super();
- this._initializeDependencies(this._injector);
- this._initialize();
- }
-
- private _initialize() {
- this._renderManagerService.createRender$.pipe(takeUntil(this.dispose$)).subscribe((unitId) => {
- this._create(unitId);
- });
-
- this._univerInstanceService.getCurrentTypeOfUnit$<SlideDataModel>(UniverInstanceType.UNIVER_SLIDE).pipe(takeUntil(this.dispose$)).subscribe((slideModel) => {
- this._create(slideModel?.getUnitId());
- });
-
- this._univerInstanceService.getAllUnitsForType<SlideDataModel>(UniverInstanceType.UNIVER_SLIDE).forEach((slideModel) => {
- this._create(slideModel.getUnitId());
- });
- }
-
- activePage(_pageId?: string) {
- let pageId = _pageId;
- const model = this._univerInstanceService.getCurrentUnitForType<SlideDataModel>(UniverInstanceType.UNIVER_SLIDE)!;
- let page: Nullable<ISlidePage>;
- if (pageId) {
- page = model.getPage(pageId);
- } else {
- const pageElements = model.getPages();
- const pageOrder = model.getPageOrder();
- if (pageOrder == null || pageElements == null) {
- return;
- }
- page = pageElements[pageOrder[0]];
-
- pageId = page.id;
- }
-
- const render = this._currentRender();
-
- if (page == null || render == null || render.mainComponent == null) {
- return;
- }
-
- const { id } = page;
-
- const slide = render.mainComponent as Slide;
-
- model.setActivePage(page);
-
- if (slide?.hasPage(id)) {
- slide.changePage(id);
- return;
- }
-
- this._createScene(id, page);
- }
-
- private _scrollToCenter() {
- const mainScene = this._currentRender()?.scene;
- const viewMain = mainScene?.getViewport(SLIDE_KEY.VIEW);
- const getCenterPositionViewPort = this._getCenterPositionViewPort(mainScene);
- if (!viewMain || !getCenterPositionViewPort) return;
- const { left: viewPortLeft, top: viewPortTop } = getCenterPositionViewPort;
-
- const { x, y } = viewMain.transViewportScroll2ScrollValue(viewPortLeft, viewPortTop);
-
- viewMain.scrollToBarPos({
- x,
- y,
- });
- }
-
- private _create(unitId: Nullable<string>) {
- if (unitId == null) {
- return;
- }
-
- const model = this._univerInstanceService.getUnit(unitId, UniverInstanceType.UNIVER_SLIDE);
- if (model == null) {
- return;
- }
-
- if (!this._renderManagerService.has(unitId)) {
- this._addNewRender(unitId);
- }
- }
-
- private _currentRender() {
- const slideDataModel = this._univerInstanceService.getCurrentUnitForType<SlideDataModel>(UniverInstanceType.UNIVER_SLIDE)!;
- return this._renderManagerService.getRenderById(slideDataModel.getUnitId());
- }
-
- // eslint-disable-next-line max-lines-per-function
- private _addNewRender(unitId: string) {
- const slideDataModel = this._univerInstanceService.getUnit<SlideDataModel>(unitId, UniverInstanceType.UNIVER_SLIDE);
-
- if (slideDataModel == null) {
- return;
- }
-
- this._renderManagerService.createRender(unitId);
-
- const currentRender = this._renderManagerService.getRenderById(unitId);
-
- if (currentRender == null) {
- return;
- }
-
- const { scene, engine } = currentRender;
-
- const observer = engine.onTransformChange$.subscribeEvent(() => {
- this._scrollToCenter();
- // add once
- observer?.unsubscribe();
- });
-
- engine.onTransformChange$.subscribeEvent(() => {
- setTimeout(() => {
- this.createThumbs();
- }, 300);
- });
-
- const viewMain = new Viewport(SLIDE_KEY.VIEW, scene, {
- left: 0,
- top: 0,
- bottom: 0,
- right: 0,
- isRelativeX: true,
- isRelativeY: true,
- isWheelPreventDefaultX: true,
- });
-
- scene.attachControl();
-
- scene.onMouseWheel$.subscribeEvent((evt: unknown, state: EventState) => {
- const e = evt as IWheelEvent;
- if (e.ctrlKey) {
- const deltaFactor = Math.abs(e.deltaX);
- let scrollNum = deltaFactor < 40 ? 0.2 : deltaFactor < 80 ? 0.4 : 0.2;
- scrollNum *= e.deltaY > 0 ? -1 : 1;
- if (scene.scaleX < 1) {
- scrollNum /= 2;
- }
-
- if (scene.scaleX + scrollNum > 4) {
- scene.scale(4, 4);
- } else if (scene.scaleX + scrollNum < 0.1) {
- scene.scale(0.1, 0.1);
- } else {
- const value = e.deltaY > 0 ? 0.1 : -0.1;
- // scene.scaleBy(scrollNum, scrollNum);
- e.preventDefault();
- }
- } else {
- viewMain.onMouseWheel(e, state);
- }
- });
-
- scene.onFileLoaded$.subscribeEvent(() => {
- this._refreshThumb();
- });
-
- ScrollBar.attachTo(viewMain);
-
- this._renderManagerService.setCurrent(unitId);
-
- // const getCenterPositionViewPort = this._getCenterPositionViewPort();
- // const { left: viewPortLeft = 0, top: viewPortTop = 0 } = getCenterPositionViewPort;
-
- // const { x, y } = viewMain.getBarScroll(viewPortLeft, viewPortTop);
-
- // viewMain.scrollTo({
- // x,
- // y,
- // });
-
- // scene.addObject(new Rect('canvasTest', { left: 333, top: 333, width: 400, height: 300, fill: 'rgba(22,22,22, 1)' }));
-
- const slideComponent = this._createSlide(scene);
-
- currentRender.mainComponent = slideComponent;
-
- currentRender.components.set(SLIDE_KEY.COMPONENT, slideComponent);
-
- this._createSlidePages(slideDataModel, slideComponent);
-
- engine.runRenderLoop(() => {
- scene.render();
- });
- }
-
- private _refreshThumb = debounce(() => {
- this.createThumbs();
- }, 300);
-
- private _createSlide(mainScene: Scene) {
- const model = this._univerInstanceService.getCurrentUnitForType<SlideDataModel>(UniverInstanceType.UNIVER_SLIDE)!;
-
- const { width: sceneWidth, height: sceneHeight } = mainScene;
-
- const pageSize = model.getPageSize();
-
- const { width = 100, height = 100 } = pageSize;
-
- const slideComponent = new Slide(SLIDE_KEY.COMPONENT, {
- left: (sceneWidth - width) / 2,
- top: (sceneHeight - height) / 2,
- width,
- height,
- zIndex: 10,
- });
-
- // slideComponent.enableNav();
-
- slideComponent.enableSelectedClipElement();
-
- mainScene.addObject(slideComponent);
-
- return slideComponent;
- }
-
- private _addBackgroundRect(scene: Scene, fill: IColorStyle) {
- const model = this._univerInstanceService.getCurrentUnitForType<SlideDataModel>(UniverInstanceType.UNIVER_SLIDE)!;
-
- const pageSize = model.getPageSize();
-
- const { width: pageWidth = 0, height: pageHeight = 0 } = pageSize;
-
- const page = new Rect('canvas', {
- left: 0,
- top: 0,
- width: pageWidth,
- height: pageHeight,
- strokeWidth: 1,
- stroke: 'rgba(198,198,198,1)',
- fill: getColorStyle(fill) || 'rgba(255,255,255,1)',
- zIndex: 0,
- evented: false,
- });
- scene.addObject(page, 0);
- }
-
- private _getCenterPositionViewPort(mainScene?: Scene) {
- if (!mainScene) return { left: 0, top: 0 };
- const { width, height } = mainScene;
-
- const engine = mainScene.getEngine();
-
- const canvasWidth = engine?.width || 0;
- const canvasHeight = engine?.height || 0;
-
- return {
- left: (width - canvasWidth) / 2,
- top: (height - canvasHeight) / 2,
- };
- }
-
- private _thumbSceneRender(pageId: string, slide: Slide) {
- const render = this._renderManagerService.getRenderById(pageId);
-
- if (render == null) {
- return;
- }
-
- const { engine: thumbEngine } = render;
-
- if (thumbEngine == null) {
- return;
- }
-
- const { width, height } = slide;
-
- const { width: pageWidth = width, height: pageHeight = height } = thumbEngine;
-
- const thumbContext = thumbEngine.getCanvas().getContext();
-
- slide.renderToThumb(thumbContext, pageId, pageWidth / width, pageHeight / height);
- }
-
- private _createSlidePages(slideDataModel: SlideDataModel, slide: Slide) {
- const pages = slideDataModel.getPages();
-
- const pageOrder = slideDataModel.getPageOrder();
-
- if (!pages || !pageOrder) {
- return;
- }
-
- if (pageOrder.length === 0) {
- return;
- }
-
- for (let i = 0, len = pageOrder.length; i < len; i++) {
- const pageId = pageOrder[i];
-
- this._createScene(pageId, pages[pageId]);
-
- this._createThumb(pageId);
- }
-
- // setTimeout(() => {
- // for (let i = 0, len = pageOrder.length; i < len; i++) {
- // const pageId = pageOrder[i];
-
- // this._thumbSceneRender(pageId, slide);
- // }
- // }, 0);
-
- slide.activeFirstPage();
- }
-
- createThumbs() {
- const slideDataModel = this._univerInstanceService.getCurrentUnitForType<SlideDataModel>(UniverInstanceType.UNIVER_SLIDE)!;
-
- const pageOrder = slideDataModel.getPageOrder();
-
- const render = this._currentRender();
-
- if (!pageOrder || !render) {
- return;
- }
-
- if (pageOrder.length === 0) {
- return;
- }
-
- for (let i = 0, len = pageOrder.length; i < len; i++) {
- const pageId = pageOrder[i];
-
- this._thumbSceneRender(pageId, render.mainComponent as Slide);
- }
- }
-
- private _createThumb(pageId: string) {
- this._renderManagerService.createRender(pageId);
- }
-
- private _sceneMap = new Map<string, Scene>();
-
- /**
- * @param pageId
- * @param page
- * @returns pageScene: Scene
- */
- private _createScene(pageId: string, page: ISlidePage) {
- const render = this._currentRender();
- if (!render || !this._objectProvider) {
- return;
- }
-
- const { scene: mainScene, mainComponent } = render;
-
- const slide = mainComponent as Slide;
- const { width, height } = slide;
- const pageScene = new Scene(pageId, slide, {
- width,
- height,
- });
- this._sceneMap.set(pageId, pageScene);
-
- const viewMain = new Viewport(`PageViewer_${pageId}`, pageScene, {
- left: 0,
- top: 0,
- bottom: 0,
- right: 0,
- isRelativeX: true,
- isRelativeY: true,
- });
- viewMain.closeClip();
-
- const { pageElements, pageBackgroundFill } = page;
-
- // SceneViewers
- const objects = this._objectProvider.convertToRenderObjects(pageElements, mainScene);
- if (!objects || !slide) return;
-
- this._addBackgroundRect(pageScene, pageBackgroundFill);
- // So finally SceneViewers are added to the scene as objects. How can we do optimizations on this?
- pageScene.addObjects(objects);
-
- objects.forEach((object) => {
- pageScene.attachTransformerTo(object);
- });
-
- const transformer = pageScene.getTransformer();
-
- transformer?.changeEnd$.subscribe(() => {
- this._thumbSceneRender(pageId, slide);
- });
-
- transformer?.clearControl$.subscribe(() => {
- this._thumbSceneRender(pageId, slide);
- });
-
- slide.addPage(pageScene);
-
- return pageScene;
- }
-
- private _initializeDependencies(slideInjector: Injector) {
- this._objectProvider = slideInjector.createInstance(ObjectProvider);
- }
-
- getRenderUnitByPageId(pageId: PageID) {
- const scene = this._sceneMap.get(pageId);
- // no render context
- // const { engine, unit } = this._renderContext;
- return {
- scene,
- // engine,
- // unit,
- };
- }
-
- createObjectToPage(element: IPageElement, pageID: PageID): Nullable<BaseObject> {
- const render = this._currentRender();
-
- if (!render || !this._objectProvider) {
- return;
- }
- const { scene } = this.getRenderUnitByPageId(pageID);
- if (!scene) return;
-
- const object = this._objectProvider.convertToRenderObject(element, scene);
- if (object) {
- scene.addObject(object);
- scene.attachTransformerTo(object);
- scene.getLayer().makeDirty();
- return object;
- }
- }
-
- setObjectActiveByPage(obj: BaseObject, pageID: PageID) {
- const { scene } = this.getRenderUnitByPageId(pageID);
- // console.log(obj);
- if (!scene) return;
- const transformer = scene.getTransformer();
- transformer?.activeAnObject(obj);
- }
-
- removeObjectById(id: string, pageID: PageID) {
- const { scene } = this.getRenderUnitByPageId(pageID);
- if (!scene) return;
- scene.removeObject(id);
- const transformer = scene.getTransformer();
- transformer?.clearControls();
- }
-
- appendPage() {
- const model = this._univerInstanceService.getCurrentUnitForType<SlideDataModel>(UniverInstanceType.UNIVER_SLIDE)!;
- const page = model.getBlankPage();
-
- const render = this._currentRender();
-
- if (page == null || render == null || render.mainComponent == null) {
- return;
- }
-
- const { id } = page;
-
- const slide = render.mainComponent as Slide;
-
- const scene = this._createScene(id, page);
-
- scene && slide?.addPage(scene);
-
- model.appendPage(page);
- model.setActivePage(page);
- }
-}
diff --git a/packages/slides/src/views/render/index.ts b/packages/slides/src/views/render/index.ts
index d72647c319..39762100d0 100644
--- a/packages/slides/src/views/render/index.ts
+++ b/packages/slides/src/views/render/index.ts
@@ -14,4 +14,15 @@
* limitations under the License.
*/
-export * from './canvas-view';
+export { SLIDE_VIEW_KEY } from './adaptors';
+
+// export * from '../../../../slides-ui/src/controllers/canvas-view';
+export * from './adaptor';
+export * from './object-provider';
+
+export enum SLIDE_KEY {
+ COMPONENT = '__slideRender__',
+ SCENE = '__mainScene__',
+ VIEW = '__mainView__',
+}
+export type PageID = string;