Options
All
  • Public
  • Public/Protected
  • All
Menu

Module layout/types

Index

Type Aliases

Type Aliases

AnyIndex

AnyIndex: {}

Index of arbitrary values

Type declaration

  • [key: string]: any

PaneIndex

PaneIndex: {}

Index of Panes mapped with id of the Pane

Type declaration

PanelIndex

PanelIndex: {}

Index of Panels mapped with id of the Panel

Type declaration

BoundsIndex

BoundsIndex: {}

Index of Panel Bounds mapped with id of the Panel

Type declaration

  • [key: string]: DOMRect

SizeIndex

SizeIndex: {}

Index of Panel Sizes mapped with id of the Panel

Type declaration

  • [key: string]: number

FlagIndex

FlagIndex: {}

Utility type to create key:boolean index object

Type declaration

  • [key: string]: boolean

ActiveDrag

ActiveDrag: { isMouseDown: boolean; preventDrop: boolean }

Active drag status

Type declaration

  • isMouseDown: boolean

    This flag is set to true when drag starts

  • preventDrop: boolean

    This flag is set to true when a drop is prevented based on some conditions

ActiveDND

ActiveDND: { isMouseDown: boolean; currentPane: PanelConfig; type: string; edge: string; source: HTMLElement; sourceBounds: DOMRect; sourceIndex: number; sourceProxy: HTMLElement; sourceCopy: HTMLElement; target: HTMLElement; targetProxy: HTMLElement; stageBounds: DOMRect; startX: number; startY: number; x: number; y: number; offX: number; offY: number }

Type declaration

  • isMouseDown: boolean

    This flag is set to true when drag starts

  • currentPane: PanelConfig

    The Pane on which mouse is moving now

  • type: string

    Type of the item being dragged - tab or pane

  • edge: string

    Target window edge

  • source: HTMLElement

    HTML element of the item being dragged

  • sourceBounds: DOMRect

    Bounds of the item being dragged

  • sourceIndex: number

    Index of the item being dragged

  • sourceProxy: HTMLElement

    Clone of the HTML element of the item being dragged

  • sourceCopy: HTMLElement

    2nd Clone of the HTML element of the item being dragged

  • target: HTMLElement

    HTML element of the drop target

  • targetProxy: HTMLElement

    Clone of the HTML element of the drop target

  • stageBounds: DOMRect

    Bounds of the drag stage

  • startX: number

    X position of drag start

  • startY: number

    Y position of drag start

  • x: number

    Current X position of drag

  • y: number

    Current Y position of drag

  • offX: number

    X offset of drag with respect to the origin of the item being dragged

  • offY: number

    Y offset of drag with respect to the origin of the item being dragged

DragContext

DragContext: { drag: ActiveDrag; dnd: ActiveDND }

Details of the active drag operation

Type declaration

DNDContext

DNDContext: { dragStage: HTMLElement; drag: Writable<ActiveDrag>; dnd: ActiveDND; from: {}; to: {}; change: any; reset: any; update: any }

State of the active drag and drop

Type declaration

  • dragStage: HTMLElement

    Instance of the HTMLElement that holds drag and drop elements

  • drag: Writable<ActiveDrag>

    State of the active drag

  • dnd: ActiveDND

    State of the active drag and drop

  • from: {}

    Details of the drag source

    • to: {}

      Details of the drop target

      • change:function
        • change(dnd?: any, drag?: any): void

        • Method that updates the changes in drag and drop as the mouse moves

          Parameters

          • dnd: any = null
          • drag: any = null

          Returns void

      • reset:function
        • reset(): any

        • Method that resets drag and drop status

          Returns any

      • update:function
        • update(): any

        • Method that applies the changes caused by the drag and drop operation

          Returns any

      PanelResize

      PanelResize: { initialized: boolean; initialParams: { x?: number; y?: number; divider?: HTMLElement; pane?: Pane; paneIndex?: number; type?: string; equal?: boolean; onResize?: Function }; source: Pane; parent: Pane; divider: HTMLElement; paneXIndex: number; paneYIndex: number; paneX: PanelConfig; paneY: PanelConfig; paneXBounds: DOMRect; paneYBounds: DOMRect; paneXElement: HTMLElement; paneYElement: HTMLElement; panes: PanelConfig[]; paneElements: AnyIndex; paneBounds: BoundsIndex; paneMinSizes: SizeIndex; panesCount: number; panesSkip: PanelIndex; panesSkipped: number; totalSize: number; availableSize: number; borderAdjust: number; type: string; startX: number; startY: number; currentX: number; currentY: number; markers: ResizeMarker[]; userSelect: string; direction: string; maxXReached: boolean; maxYReached: boolean; onResize: Function }

      Details of the active resize operation

      Type declaration

      • initialized: boolean

        This flag is set to true when a resize is initilized

      • initialParams: { x?: number; y?: number; divider?: HTMLElement; pane?: Pane; paneIndex?: number; type?: string; equal?: boolean; onResize?: Function }

        Various parameters at the beginning of the resize operation

        • Optional x?: number

          X position of mouse pointer

        • Optional y?: number

          Y position of mouse pointer

        • Optional divider?: HTMLElement

          Pane Divider element which triggered the resize operation

        • Optional pane?: Pane

          Pane instance which contains the divider

        • Optional paneIndex?: number

          Index of the Pane in the parent PaneGroup

        • Optional type?: string

          Resize type - horizontal or vertical

        • Optional equal?: boolean

          Whether there resize will just divide the available space in half

        • Optional onResize?: Function

          Callback function to handle Resize complete event

      • source: Pane

        Pane instance which contains the divider

      • parent: Pane

        Parent Pane of the source

      • divider: HTMLElement

        Pane Divider element which triggered the resize operation

      • paneXIndex: number

        Index of the Pane on the left/top of the divider

      • paneYIndex: number

        Index of the Pane on the right/bottom of the divider

      • paneX: PanelConfig

        Pane on the left/top of the divider

      • paneY: PanelConfig

        Pane on the right/bottom of the divider

      • paneXBounds: DOMRect

        Bounds of the Pane on the left/top of the divider

      • paneYBounds: DOMRect

        Bounds of the Pane on the right/bottom of the divider

      • paneXElement: HTMLElement

        HTMLElement of the Pane on the left/top of the divider

      • paneYElement: HTMLElement

        HTMLElement of the Pane on the right/bottom of the divider

      • panes: PanelConfig[]

        All children of the parent of paneX and paneY

      • paneElements: AnyIndex

        HTMLElements of all children of the parent of paneX and paneY

      • paneBounds: BoundsIndex

        Bounds of all children of the parent of paneX and paneY

      • paneMinSizes: SizeIndex

        Minumum sizes of all children of the parent of paneX and paneY

      • panesCount: number

        Count of the children of the parent of paneX and paneY

      • panesSkip: PanelIndex

        Panes to be skipped in the resize operation

      • panesSkipped: number

        Panes skipped in the resize operation

      • totalSize: number

        Total size of paneX and paneY

      • availableSize: number

        Space available for the resize operation

      • borderAdjust: number

        Amount of size to adjusted to render border after resize

      • type: string

        Resize type - horizontal or vertical

      • startX: number

        Initial X position of mouse pointer

      • startY: number

        Initial Y position of mouse pointer

      • currentX: number

        Current X position of mouse pointer

      • currentY: number

        Current Y position of mouse pointer

      • markers: ResizeMarker[]

        List of start and end positions of each Pane

      • userSelect: string

        HTML user select current status

      • direction: string

        Current direction of resize

      • maxXReached: boolean

        This flag indicates whether furthere resizing is possible towards top/left

      • maxYReached: boolean

        This flag indicates whether furthere resizing is possible towards bottom/right

      • onResize: Function

        Callback function to handle Resize complete event

      PaneTransform

      PaneTransform: { resize: PanelResize }

      Used to track the changes in Pane Transforms

      Type declaration

      EdgeArgs

      EdgeArgs: [string, DOMRect, boolean, number, number, number, FlagIndex?]

      Parameters used in the calculation of Pane/Window edges in drag and drop

      ResizeMarker

      ResizeMarker: { id: string; index: number; from: number; start: number; position: number; at: number; original: number; size: number; minimum: number; isClosable: boolean }

      List of start and end positions and other details of Panes being resized

      Type declaration

      • id: string

        Unique id of the Pane

      • index: number

        Index of the Pane

      • from: number

        Original starting position of the Pane

      • start: number

        Current starting position of the Pane

      • position: number

        Current resize position of the Pane

      • at: number

        Current ending position of the Pane

      • original: number

        Original ending position of the Pane

      • size: number

        Current size position of the Pane

      • minimum: number

        Minimum size position of the Pane

      • isClosable: boolean

        Whether the Pane can be closed while resizing

      Workspace

      Workspace: { root?: Pane }

      Rendered Workspace which contains the tree of Panes

      Type declaration

      • Optional root?: Pane

        Pane at the root. This Pane contains the whole Workspace

      PanesContext

      PanesContext: { expand: any; collapse: any; getPane: any; clearMovedPane: any; activeTabChange: any; addByName: any; removeByName: any; removePane: any; reorderModalTabs: any; toggleCollapsedQueryToolbar: any; resizeQueryToolbar: any }

      Context which handles all the interactions with the Panes

      Type declaration

      • expand:function
        • expand(pane: Pane, index: number, size: string | number, apply?: boolean): void

        • Parameters

          • pane: Pane
          • index: number
          • size: string | number
          • Optional apply: boolean

          Returns void

      • collapse:function
        • collapse(pane: Pane, index: number, quick: boolean, apply?: boolean): void

        • Parameters

          • pane: Pane
          • index: number
          • quick: boolean
          • Optional apply: boolean

          Returns void

      • getPane:function
      • clearMovedPane:function
        • clearMovedPane(pane: Pane): void

        • Parameters

          Returns void

      • activeTabChange:function
        • activeTabChange(pane: Pane, index: number): void

        • Parameters

          • pane: Pane
          • index: number

          Returns void

      • addByName:function
        • addByName(panelName: string): void

        • Parameters

          • panelName: string

          Returns void

      • removeByName:function
        • removeByName(panelName: string): void

        • Parameters

          • panelName: string

          Returns void

      • removePane:function
        • removePane(pane: Pane): void

        • Parameters

          Returns void

      • reorderModalTabs:function
        • reorderModalTabs(toPane: Pane, newTabs: PanelConfig[], active: number): void
      • toggleCollapsedQueryToolbar:function
        • toggleCollapsedQueryToolbar(isCollapsed: boolean): void

        • Parameters

          • isCollapsed: boolean

          Returns void

      • resizeQueryToolbar:function
        • resizeQueryToolbar(height: number, layoutChange: boolean): void

        • Parameters

          • height: number
          • layoutChange: boolean

          Returns void

      TransformContext

      TransformContext: { startResize: any; initialize: any; updateResize: any; splitSize: any; setResizePanes: any; setResizeInnerPanes: any; saveResizePanes: any; shrinkPane: any; doResize: any; stopResize: any }

      Type declaration

      • startResize:function
        • startResize(x: number, y: number, divider: HTMLElement, pane: Pane, paneIndex: number, type: string, equal: boolean, onResize: (() => {})): void

        • Start resing Panes when mouse pointer holds a divider

          Parameters

          • x: number
          • y: number
          • divider: HTMLElement
          • pane: Pane
          • paneIndex: number
          • type: string
          • equal: boolean
          • onResize: (() => {})
              • (): {}

              • Returns {}

            Returns void

        • initialize:function
          • initialize(): void

          • Initialize Resize by setting parameters

            Returns void

        • updateResize:function
          • updateResize(type: string, equal?: boolean): void

          • Update Resize by updating parameters

            Parameters

            • type: string
            • Optional equal: boolean

            Returns void

        • splitSize:function
          • splitSize(): any

          • Equally divide the Pane sizes

            Returns any

        • setResizePanes:function
          • setResizePanes(type: string): any

          • Set the Panes which will be affected by the Resize

            Parameters

            • type: string

            Returns any

        • setResizeInnerPanes:function
          • setResizeInnerPanes(): any

          • Set the Inner Panes which will be affected by the Resize

            Returns any

        • saveResizePanes:function
          • saveResizePanes(type: string, resizing?: boolean): void

          • Apply the new sizes to Panes after Resize

            Parameters

            • type: string
            • Optional resizing: boolean

            Returns void

        • shrinkPane:function
          • shrinkPane(marker: ResizeMarker, newPosition: number, direction: string, property: string, forwarded: boolean, reverse?: boolean): number

          • Adjust the sizes of adjacent Panes if needed

            Parameters

            • marker: ResizeMarker
            • newPosition: number
            • direction: string
            • property: string
            • forwarded: boolean
            • Optional reverse: boolean

            Returns number

        • doResize:function
          • doResize(event: MouseEvent): void

          • Calculate new sizes of the Panes as the divider is dragged

            Parameters

            • event: MouseEvent

            Returns void

        • stopResize:function
          • stopResize(): void

          • Stop the Resize operation

            Returns void

        Generated using TypeDoc