@univerjs/engine-render 0.6.1 → 0.6.2

package/lib/types/components/sheets/sheet.render-skeleton.d.ts

@@ -52,7 +52,6 @@ export declare class SpreadsheetSkeleton extends SheetSkeleton {
     private _gridlinesColor;
     private _scene;
     constructor(worksheet: Worksheet, _styles: Styles, _localeService: LocaleService, _contextService: IContextService, _configService: IConfigService, _injector: Injector);
-    initConfig(): void;
     setScene(scene: Scene): void;
     _updateLayout(): void;
     /**

package/lib/types/index.d.ts

@@ -40,7 +40,7 @@ export * from './engine';
 export * from './group';
 export * from './layer';
 export { IRenderingEngine, UniverRenderEnginePlugin } from './plugin';
-export { IRenderManagerService, type RenderComponentType, RenderManagerService } from './render-manager/render-manager.service';
+export { getCurrentTypeOfRenderer, IRenderManagerService, type RenderComponentType, RenderManagerService, withCurrentTypeOfRenderer } from './render-manager/render-manager.service';
 export { type IRender, type IRenderContext, type IRenderModule, RenderUnit } from './render-manager/render-unit';
 export * from './scene';
 export { type IChangeObserverConfig } from './scene.transformer';

package/lib/types/render-manager/render-manager.service.d.ts

@@ -8,8 +8,6 @@ import { IRender, RenderUnit } from './render-unit';
 import { Engine } from '../engine';
 export type RenderComponentType = SheetComponent | DocComponent | Slide | BaseObject;
 export interface IRenderManagerService extends IDisposable {
-    currentRender$: Observable<Nullable<string>>;
-    getCurrent(): Nullable<IRender>;
     addRender(unitId: string, renderer: IRender): void;
     /**
      * create renderUnit & init deps from renderDependencies by renderUnit's type.
@@ -18,7 +16,6 @@ export interface IRenderManagerService extends IDisposable {
      */
     createRender(unitId: string): IRender;
     removeRender(unitId: string): void;
-    setCurrent(unitId: string): void;
     /**
      * Get RenderUnit By Id, RenderUnit implements IRender
      * @param unitId
@@ -30,7 +27,6 @@ export interface IRenderManagerService extends IDisposable {
      */
     getRenderUnitById(unitId: string): Nullable<IRender>;
     getAllRenderersOfType(type: UniverInstanceType): RenderUnit[];
-    getCurrentTypeOfRenderer(type: UniverInstanceType): Nullable<RenderUnit>;
     getRenderAll(): Map<string, IRender>;
     defaultEngine: Engine;
     /** @deprecated */
@@ -39,10 +35,7 @@ export interface IRenderManagerService extends IDisposable {
     create(unitId: string): void;
     created$: Observable<IRender>;
     disposed$: Observable<string>;
-    /** @deprecated There will be multi units to render at the same time, so there is no *first*. */
-    getFirst(): Nullable<IRender>;
     has(unitId: string): boolean;
-    withCurrentTypeOfUnit<T>(type: UniverInstanceType, id: DependencyIdentifier<T>): Nullable<T>;
     /**
      * add dep to _renderDependencies(type, dep)
      * @param type
@@ -54,10 +47,7 @@ export declare class RenderManagerService extends Disposable implements IRenderM
     private readonly _injector;
     private readonly _univerInstanceService;
     private _defaultEngine;
-    private _currentUnitId;
     private _renderMap;
-    private readonly _currentRender$;
-    readonly currentRender$: Observable<Nullable<string>>;
     private readonly _createRender$;
     /** @deprecated */
     readonly createRender$: Observable<string>;
@@ -90,8 +80,6 @@ export declare class RenderManagerService extends Disposable implements IRenderM
      */
     createRender(unitId: string): IRender;
     getAllRenderersOfType(type: UniverInstanceType): RenderUnit[];
-    getCurrentTypeOfRenderer(type: UniverInstanceType): Nullable<RenderUnit>;
-    withCurrentTypeOfUnit<T>(type: UniverInstanceType, id: DependencyIdentifier<T>): Nullable<T>;
     /**
      * init deps by injector.get(dep), and injector derives from renderer.
      * @param renderer
@@ -110,9 +98,6 @@ export declare class RenderManagerService extends Disposable implements IRenderM
     private _addRenderUnit;
     removeRender(unitId: string): void;
     has(unitId: string): boolean;
-    setCurrent(unitId: string): void;
-    getCurrent(): Nullable<IRender>;
-    getFirst(): Nullable<IRender>;
     /**
      * @deprecated use getRenderUnitById instead
      * Get RenderUnit from this._renderMap.
@@ -126,3 +111,5 @@ export declare class RenderManagerService extends Disposable implements IRenderM
 }
 export declare const IRenderManagerService: import('@wendellhu/redi').IdentifierDecorator<IRenderManagerService>;
 export declare function isDisposable(thing: unknown): thing is IDisposable;
+export declare function getCurrentTypeOfRenderer(type: UniverInstanceType, instanceService: IUniverInstanceService, renderManageService: IRenderManagerService): Nullable<IRender>;
+export declare function withCurrentTypeOfRenderer<T>(type: UniverInstanceType, id: DependencyIdentifier<T>, instanceService: IUniverInstanceService, renderManagerService: IRenderManagerService): Nullable<T>;

package/lib/types/scene.d.ts

@@ -281,7 +281,7 @@ export declare class Scene extends Disposable {
     };
     dispose(): void;
     /**
-     * Get the object under the pointer, if scene.event is disabled, the object is null.
+     * Get the object under the pointer, if scene.event is disabled, return null.
      * @param {Vector2} coord
      * @return {Nullable<BaseObject | Scene>} object under the pointer
      */
@@ -315,4 +315,8 @@ export declare class Scene extends Disposable {
      */
     disableObjectsEvent(): void;
     enableObjectsEvent(): void;
+    _capturedObject: BaseObject | null;
+    get capturedObject(): BaseObject | null;
+    setCaptureObject(o: BaseObject): void;
+    releaseCapturedObject(): void;
 }

package/lib/types/scene.input-manager.d.ts

@@ -1,3 +1,4 @@
+import { BaseObject } from './base-object';
 import { IDragEvent, IKeyboardEvent, IMouseEvent, IPointerEvent, IWheelEvent } from './basics/i-events';
 import { ISceneInputControlOptions, Scene } from './scene';
 import { Disposable } from '@univerjs/core';
@@ -49,12 +50,20 @@ export declare class InputManager extends Disposable {
      */
     detachControl(): void;
     /**
-     * Just call this._scene.pick, nothing special.
+     * Get the object under the pointer, if scene.event is disabled, return null.
      * @param offsetX
      * @param offsetY
      */
     private _getObjectAtPos;
-    private _checkDirectSceneEventTrigger;
+    /**
+     *
+     * If currentObject is null, return true
+     * @param isTrigger
+     * @param currentObject
+     * @returns
+     */
+    private _shouldDispatchEventToScene;
+    private _isObjectInSceneViewer;
     /**
      * @hidden
      * @returns Boolean if delta for pointer exceeds drag movement threshold
@@ -62,4 +71,5 @@ export declare class InputManager extends Disposable {
     private _isPointerSwiping;
     private _prePointerDoubleOrTripleClick;
     private _resetDoubleClickParam;
+    get capturedObject(): BaseObject | null;
 }

package/lib/types/shape/scroll-bar.d.ts

@@ -1,9 +1,52 @@
+import { Nullable, Disposable } from '@univerjs/core';
 import { Vector2 } from '../basics/vector2';
 import { UniverRenderingContext } from '../context';
+import { Scene } from '../scene';
 import { Viewport } from '../viewport';
-import { IScrollBarProps, BaseScrollBar } from './base-scroll-bar';
 import { Rect } from './rect';
-export declare class ScrollBar extends BaseScrollBar {
+/**
+ * Sadly, the props name here is not the same as the members in Scrollbar.
+ */
+export interface IScrollBarProps {
+    mainScene?: Scene;
+    thumbMargin?: number;
+    thumbLengthRatio?: number;
+    thumbBackgroundColor?: string;
+    thumbHoverBackgroundColor?: string;
+    thumbActiveBackgroundColor?: string;
+    /**
+     * The thickness of a scrolling track(not scrolling thumb).
+     */
+    barSize?: number;
+    /**
+     * The thickness of track border.
+     */
+    barBorder?: number;
+    enableHorizontal?: boolean;
+    enableVertical?: boolean;
+    /**
+     * The min width of horizon thumb
+     */
+    minThumbSizeH?: number;
+    /**
+     * The min height of vertical thumb
+     */
+    minThumbSizeV?: number;
+}
+export declare class ScrollBar extends Disposable {
+    _enableHorizontal: boolean;
+    _enableVertical: boolean;
+    horizontalThumbSize: number;
+    horizontalMinusMiniThumb: number;
+    horizontalTrackWidth: number;
+    horizonScrollTrack: Nullable<Rect>;
+    horizonThumbRect: Nullable<Rect>;
+    verticalThumbSize: number;
+    verticalTrackHeight: number;
+    verticalMinusMiniThumb: number;
+    verticalScrollTrack: Nullable<Rect>;
+    verticalThumbRect: Nullable<Rect>;
+    placeholderBarRect: Nullable<Rect>;
     protected _viewport: Viewport;
     private _mainScene;
     private _lastX;
@@ -14,43 +57,80 @@ export declare class ScrollBar extends BaseScrollBar {
     private _horizonPointerUpSub;
     private _verticalPointerMoveSub;
     private _verticalPointerUpSub;
+    private _thumbDefaultBackgroundColor;
+    private _thumbHoverBackgroundColor;
+    private _thumbActiveBackgroundColor;
+    private _trackBackgroundColor;
+    private _trackBorderColor;
     /**
-     * The thickness of a scrolling bar.
+     * The thickness of a scrolling track
+     * ThumbSize = trackSize - thumbMargin * 2
      */
-    barSize: number;
-    barBorder: number;
-    thumbMargin: number;
-    thumbLengthRatio: number;
+    private _trackThickness;
     /**
-     * todo: @DR-univer。 Mainly inject themeService in order to obtain colors.
+     * The margin between thumb and bar.
+     * ThumbSize = barSize - thumbMargin * 2
      */
-    thumbBackgroundColor: string;
-    thumbHoverBackgroundColor: string;
-    thumbActiveBackgroundColor: string;
-    barBackgroundColor: string;
-    barBorderColor: string;
+    private _vThumbMargin;
+    private _hThumbMargin;
+    private _trackBorderThickness;
+    private _thumbLengthRatio;
     /**
-     * The min width of horizon thumb.
+     * The min width of horizon thumb, Corresponds to minThumbSizeH in props
      */
-    minThumbSizeH: number;
+    private _minThumbSizeH;
     /**
-     * The min height of vertical thumb.
+     * The min height of vertical thumb,  Corresponds to minThumbSizeV in props
      */
-    minThumbSizeV: number;
+    private _minThumbSizeV;
     private _eventSub;
     constructor(view: Viewport, props?: IScrollBarProps);
+    setProps(props?: IScrollBarProps): void;
+    get enableHorizontal(): boolean;
+    set enableHorizontal(val: boolean);
+    get enableVertical(): boolean;
+    set enableVertical(val: boolean);
+    get limitX(): number;
+    get limitY(): number;
+    get ratioScrollX(): number;
+    get ratioScrollY(): number;
+    get miniThumbRatioX(): number;
+    get miniThumbRatioY(): number;
+    hasHorizonThumb(): boolean;
+    hasVerticalThumb(): boolean;
+    get scrollHorizonThumbThickness(): number;
+    get scrollVerticalThumbThickness(): number;
+    set barSize(v: number);
+    get barSize(): number;
+    set trackThickness(v: number);
+    get trackThickness(): number;
     static attachTo(view: Viewport, props?: IScrollBarProps): ScrollBar;
     dispose(): void;
     render(ctx: UniverRenderingContext, left?: number, top?: number): void;
-    resize(parentWidth?: number, parentHeight?: number, contentWidth?: number, contentHeight?: number): void;
+    private _resizeHorizontal;
+    private _resizeVertical;
+    private _resizeRightBottomCorner;
+    private _viewportH;
+    private _viewportW;
+    private _contentW;
+    private _contentH;
+    /**
+     * Adjust scroll track & thumb size based on the viewport size.
+     * @param viewportWidth
+     * @param viewportHeight
+     * @param contentWidth
+     * @param contentHeight
+     */
+    resize(viewportWidth?: number, viewportHeight?: number, contentWidth?: number, contentHeight?: number): void;
     makeDirty(state: boolean): void;
     makeViewDirty(state: boolean): void;
     pick(coord: Vector2): Rect<import('./rect').IRectProps> | null;
-    setProps(props?: IScrollBarProps): void;
-    private _resizeHorizontal;
-    private _resizeVertical;
     private _initialScrollRect;
     private _initialVerticalEvent;
+    private _horizonHoverFunc;
+    private _horizonHoverLeaveFunc;
+    private _verticalHoverFunc;
+    private _verticalHoverLeaveFunc;
     private _hoverFunc;
     private _initialHorizontalEvent;
 }

package/lib/types/viewport.d.ts

@@ -4,7 +4,7 @@ import { IWheelEvent } from './basics/i-events';
 import { IBoundRectNoAngle, IViewportInfo, Vector2 } from './basics/vector2';
 import { UniverRenderingContext } from './context';
 import { Scene } from './scene';
-import { BaseScrollBar } from './shape/base-scroll-bar';
+import { ScrollBar } from './shape/scroll-bar';
 import { Subject } from 'rxjs';
 import { Transform } from './basics/transform';
 import { Canvas as UniverCanvas } from './canvas';
@@ -224,7 +224,7 @@ export declare class Viewport {
      * canvas resize & freeze change would invoke this method
      */
     resetCanvasSizeAndUpdateScroll(): void;
-    setScrollBar(instance: BaseScrollBar): void;
+    setScrollBar(instance: ScrollBar): void;
     removeScrollBar(): void;
     /**
      * NOT same as resetCanvasSizeAndScrollbar
@@ -291,7 +291,7 @@ export declare class Viewport {
         x: number;
         y: number;
     };
-    getScrollBar(): Nullable<BaseScrollBar>;
+    getScrollBar(): Nullable<ScrollBar>;
     /**
      * Just record state of scroll. This method won't scroll viewport and scrollbar.
      * TODO: @lumixraku this method is so wried, viewportMain did not call it, now only called in freeze situation.