##// END OF EJS Templates
implab » implabjs-dojo-typings
RSS
Initial commit, project structure.
Initial commit, project structure.
cin - - Load All Authors

File last commit:

r0:ab570232df7d default
r0:ab570232df7d default
Show More
layout.d.ts
670 lines | 18.9 KiB | video/mp2t | TypeScriptLexer
/ dojo-typings / src / main / typings / dijit / layout.d.ts
History | Source | Raw |Copy content |Copy permalink
cin
Initial commit, project structure.
 r0 declare namespace dijit {
namespace layout {
/* dijit/_LayoutWidget */
/* tslint:disable:class-name */
interface _LayoutWidget extends _Widget, _Container, _Contained {
/**
* Base class for a _Container widget which is responsible for laying
* out its children. Widgets which mixin this code must define layout()
* to manage placement and sizing of the children.
*/
baseClass: string;
/**
* Indicates that this widget is going to call resize() on its
* children widgets, setting their size, when they become visible.
*/
isLayoutContainer: boolean;
/**
* Call this to resize a widget, or after its size has changed.
*
* ####Change size mode:
*
* When changeSize is specified, changes the marginBox of this widget
* and forces it to re-layout its contents accordingly.
* changeSize may specify height, width, or both.
*
* If resultSize is specified it indicates the size the widget will
* become after changeSize has been applied.
*
* ####Notification mode:
*
* When changeSize is null, indicates that the caller has already changed
* the size of the widget, or perhaps it changed because the browser
* window was resized. Tells widget to re-layout its contents accordingly.
*
* If resultSize is also specified it indicates the size the widget has
* become.
*
* In either mode, this method also:
*
* 1. Sets this._borderBox and this._contentBox to the new size of
* the widget. Queries the current domNode size if necessary.
* 2. Calls layout() to resize contents (and maybe adjust child widgets).
*/
resize(changeSize?: dojo.DomGeometryBox, resultSize?: dojo.DomGeometryWidthHeight): void;
/**
* Widgets override this method to size and position their contents/children.
* When this is called, this._contentBox is guaranteed to be set (see resize()).
*
* This is called after startup(), and also when the widget's size has been
* changed.
*/
layout(): void;
}
interface _LayoutWidgetConstructor extends _WidgetBaseConstructor<_LayoutWidget> { }
/* dijit/layout/_TabContainerBase */
interface _TabContainerBase extends StackContainer, _TemplatedMixin {
/**
* Defines where tabs go relative to tab content.
* "top", "bottom", "left-h", "right-h"
*/
tabPosition: string;
// tabPosition: 'top' | 'bottom' | 'left-h' | 'right-h';
/**
* Defines whether the tablist gets an extra class for layouting, putting a border/shading
* around the set of tabs. Not supported by claro theme.
*/
tabStrip: boolean;
/**
* If true, use styling for a TabContainer nested inside another TabContainer.
* For tundra etc., makes tabs look like links, and hides the outer
* border since the outer TabContainer already has a border.
*/
nested: boolean;
}
/* dijit/layout/LayoutContainer */
interface LayoutContainer extends _LayoutWidget {
/**
* Which design is used for the layout:
*
* - "headline" (default) where the top and bottom extend the full width of the container
* - "sidebar" where the left and right sides extend from top to bottom.
*
* However, a `layoutPriority` setting on child panes overrides the `design` attribute on the parent.
* In other words, if the top and bottom sections have a lower `layoutPriority` than the left and right
* panes, the top and bottom panes will extend the entire width of the box.
*/
design: string;
// design: 'headline' | 'sidebar';
addChild<T extends _WidgetBase>(child: T, insertIndex?: number): void;
removeChild<T extends _WidgetBase>(child: T): void;
}
interface LayoutContainerConstructor extends _WidgetBaseConstructor<LayoutContainer> { }
/* dijit/layout/AccordionContainer */
interface _AccordionButton extends _WidgetBase, _TemplatedMixin, _CssStateMixin {
/**
* Title of the pane.
*/
label: string;
/**
* Tooltip that appears on hover.
*/
title: string;
/**
* CSS class for icon to left of label.
*/
iconClassAttr: string;
/**
* Returns the height of the title dom node.
*/
getTitleHeight(): number;
}
interface _AccordionButtonConstructor extends _WidgetBaseConstructor<_AccordionButton> { }
interface AccordionContainer extends StackContainer {
/**
* Amount of time (in ms) it takes to slide panes.
*/
duration: number;
/**
* The name of the widget used to display the title of each pane.
*/
buttonWidget: _AccordionButtonConstructor;
}
interface AccordionContainerConstructor extends _WidgetBaseConstructor<AccordionContainer> { }
/* dijit/layout/AccordionPane */
interface AccordionPane extends ContentPane {
/**
* Called when this pane is selected.
*/
onSelected(): void;
}
interface AccordionPaneConstructor extends _WidgetBaseConstructor<AccordionPane> { }
/* dijit/layout/BorderContainer */
interface BorderContainer extends LayoutContainer {
/**
* Give each pane a border and margin.
* Margin determined by domNode.paddingLeft.
* When false, only resizable panes have a gutter (i.e. draggable splitter) for resizing.
*/
gutters: boolean;
/**
* Specifies whether splitters resize as you drag (true) or only upon mouseup (false)
*/
liveSplitters: boolean;
/**
* Save splitter positions in a cookie.
*/
persist: boolean;
/**
* Returns the widget responsible for rendering the splitter associated with region.with
*/
getSplitter(region: string): any;
destroyRecursive(): void;
}
interface BorderContainerConstructor extends _WidgetBaseConstructor<BorderContainer> { }
/* dijit/ContentPane */
interface ContentPane extends _Widget, _Container, _ContentPaneResizeMixin {
/**
* The href of the content that displays now
* Set this at construction if you want to load data externally when th
* pane is shown. (Set preload=true to load it immediately.
* Changing href after creation doesn't have any effect; Use set('href', ...);
*/
href: string;
/**
* The innerHTML of the ContentPane
* Note that the initialization parameter / argument to set("content", ...
* can be a String, DomNode, Nodelist, or _Widget.
*/
content: dojo.ContentSetterContent | dijit._Widget;
/**
* Extract visible content from inside of `<body> .... </body>`
* I.e., strip `<html>` and `<head>` (and it's contents) from the href
*/
extractContent: boolean;
/**
* Parse content and create the widgets, if any.
*/
parseOnLoad: boolean;
/**
* Flag passed to parser. Root for attribute names to search for. If scopeName is dojo
* will search for data-dojo-type (or dojoType). For backwards compatibilit
* reasons defaults to dojo._scopeName (which is "dojo" except whe
* multi-version support is used, when it will be something like dojo16, dojo20, etc.)
*/
parserScope: string;
/**
* Prevent caching of data from href's by appending a timestamp to the href.
*/
preventCache: boolean;
/**
* Force load of data on initialization even if pane is hidden.
*/
preload: boolean;
/**
* Refresh (re-download) content when pane goes from hidden to shown
*/
refreshOnShow: boolean;
/**
* Message that shows while downloading
*/
loadingMessage: string;
/**
* Message that shows if an error occurs
*/
errorMessage: string;
/**
* True if the ContentPane has data in it, either specifie
* during initialization (via href or inline content), or se
* via set('content', ...) / set('href', ...
* False if it doesn't have any content, or if ContentPane i
* still in the process of downloading href.
*/
isLoaded: boolean;
baseClass: string;
/**
* Function that should grab the content specified via href.
*/
ioMethod<T>(url: string, options?: dojo.request.XhrBaseOptions): dojo.request.Promise<T>;
/**
* Parameters to pass to xhrGet() request, for example:
* | <div data-dojo-type="dijit/layout/ContentPane" data-dojo-props="href: './bar', ioArgs: {timeout: 500}">
*/
ioArgs: { [arg: string]: string | number };
/**
* This is the `dojo.Deferred` returned by set('href', ...) and refresh()
* Calling onLoadDeferred.then() registers you
* callback to be called only once, when the prior set('href', ...) call o
* the initial href parameter to the constructor finishes loading
* This is different than an onLoad() handler which gets called any time any hre
* or content is loaded.
*/
onLoadDeferred: dojo.Deferred<any>;
/**
* Flag to parser that I'll parse my contents, so it shouldn't.
*/
stopParser: boolean;
/**
* Flag from the parser that this ContentPane is inside a templat
* so the contents are pre-parsed.
*/
template: boolean;
markupFactory<T>(params: any, node: HTMLElement, ctor: dojo.GenericConstructor<T>): T;
postMixInProperties(): void;
buildRendering(): void;
/**
* Call startup() on all children including non _Widget ones like dojo/dnd/Source objects
*/
startup(): void;
/**
* Deprecated. Use set('href', ...) instead.
*/
setHref(href: string | URL): ContentPane;
/**
* Deprecated. Use set('content', ...) instead.
*/
setContent(data: dojo.ContentSetterContent): ContentPane;
/**
* Cancels an in-flight download of content
*/
cancel(): void;
/**
* [Re]download contents of href and display
*/
refresh(): dojo.Deferred<any>;
/**
* Destroy all the widgets inside the ContentPane and empty containerNode
*/
destroyDescendants(preserveDom?: boolean): void;
/**
* Event hook, is called after everything is loaded and widgetified
*/
onLoad(data?: any): void;
/**
* Event hook, is called before old content is cleared
*/
onUnload(): void;
/**
* Called before download starts.
*/
onDownloadStart(): string;
/**
* Called on DOM faults, require faults etc. in content.
* In order to display an error message in the pane, return
* the error message from this method, as an HTML string.
* By default (if this method is not overriden), it returns
* nothing, so the error message is just printed to the console.
*/
onContentError(error: Error): void;
/**
* Called when download error occurs.
* In order to display an error message in the pane, return
* the error message from this method, as an HTML string.
* Default behavior (if this method is not overriden) is to display
* the error message inside the pane.
*/
onDownloadError(error: Error): void;
/**
* Called when download is finished.
*/
onDownloadEnd(): void;
}
interface ContentPaneConstructor extends _WidgetBaseConstructor<ContentPane> { }
/* dijit/layout/_ContentPaneResizeMixin */
/* tslint:disable:class-name */
interface _ContentPaneResizeMixin {
/**
* - false - don't adjust size of children
* - true - if there is a single visible child widget, set it's size to however big the ContentPane is
*/
doLayout: boolean;
/**
* Indicates that this widget will call resize() on it's child widgets
* when they become visible.
*/
isLayoutContainer: boolean;
/**
* See `dijit/layout/_LayoutWidget.startup()` for description.
* Although ContentPane doesn't extend _LayoutWidget, it does implement
* the same API.
*/
startup(): void;
/**
* See `dijit/layout/_LayoutWidget.resize()` for description.
* Although ContentPane doesn't extend _LayoutWidget, it does implement
* the same API.
*/
resize(changeSize?: dojo.DomGeometryBox, resultSize?: dojo.DomGeometryWidthHeight): void;
}
interface _ContentPaneResizeMixinConstructor extends _WidgetBaseConstructor<_ContentPaneResizeMixin> { }
/* dijit/layout/LinkPane */
interface LinkPane extends ContentPane, _TemplatedMixin {
/**
* A ContentPane with an href where (when declared in markup) the
* title is specified as innerHTML rather than as a title attribute.
*/
}
interface LinkPaneConstructor extends _WidgetBaseConstructor<LinkPane> { }
/* dijit/layout/ScrollingTabController */
interface ScrollingTabController extends TabController, _WidgetsInTemplateMixin {
/**
* True if a menu should be used to select tabs when they are too
* wide to fit the TabContainer, false otherwise.
*/
useMenu: boolean;
/**
* True if a slider should be used to select tabs when they are too
* wide to fit the TabContainer, false otherwise.
*/
useSlider: boolean;
/**
* The css class to apply to the tab strip, if it is visible.
*/
tabStripClass: string;
/**
* Creates an Animation object that smoothly scrolls the tab list
* either to a fixed horizontal pixel value, or to the selected tab.
*/
createSmoothScroll(pixels?: number): dojo._base.Animation;
/**
* Scrolls the menu to the right.
*/
doSlideRight(e: MouseEvent): void;
/**
* Scrolls the menu to the left.
*/
doSlideLeft(e: MouseEvent): void;
/**
* Scrolls the tab list to the left or right by 75% of the widget
* width.
*/
doSlide(direction: number, node: HTMLElement): void;
}
interface ScrollingTabControllerConstructor extends _WidgetBaseConstructor<ScrollingTabController> { }
/* dijit/layout/StackContainer */
interface StackContainer extends _LayoutWidget {
/**
* If true, change the size of my currently displayed child to match my size.
*/
doLayout: boolean;
/**
* Remembers the selected child across sessions.
*/
persist: boolean;
/**
* References the currently selected child widget, if any.
* Adjust selected child with selectChild() method.
*/
selectedChildWidget: _Widget;
selectChild<T extends _WidgetBase>(page: T | string, animate: boolean): dojo.promise.Promise<any>;
forward(): dojo.promise.Promise<any>;
back(): dojo.promise.Promise<any>;
closeChild<T extends _WidgetBase>(page: T): void;
/**
* Destroy all the widgets inside the StackContainer and empty containerNode
*/
destroyDescendants(preserveDom?: boolean): void;
}
interface StackContainerConstructor extends _WidgetBaseConstructor<StackContainer> { }
interface StackContainerChildWidget extends _WidgetBase {
/**
* Specifies that this widget should be the initially displayed pane.
* Note: to change the selected child use `dijit/layout/StackContainer.selectChild`
*/
selected: boolean;
/**
* Specifies that the button to select this pane should be disabled.
* Doesn't affect programmatic selection of the pane, nor does it deselect the pane if it is currently selected.
*/
disabled: boolean;
/**
* True if user can close (destroy) this child, such as (for example) clicking the X on the tab.
*/
closable: boolean;
/**
* CSS class specifying icon to use in label associated with this pane.
*/
iconClass: string;
/**
* When true, display title of this widget as tab label etc., rather than just using
* icon specified in iconClass.
*/
showTitle: boolean;
}
/* dijit/layout/StackController */
interface _StackButton extends dijit.form.ToggleButton {
/**
* When true, display close button for this tab.
*/
closeButton: boolean;
}
interface _StackButtonConstructor extends _WidgetBaseConstructor<_StackButton> { }
interface StackControllerBase extends _Widget, _TemplatedMixin, _Container {
/**
* The id of the page container I point to.
*/
containerId: string;
/**
* CSS class of [x] close icon used by event delegation code to tell when
* the close button was clicked.
*/
buttonWidgetCloseClass: string;
/**
* Returns the button corresponding to the pane with the given id.
*/
pane2button<T extends _WidgetBase>(id: string): T;
/**
* Called after the StackContainer has finished initializing.
*/
onStartup(info: Object): void;
/**
* Called whenever a page is added to the container. Create button
* corresponding to the page.
*/
onAddChild<T extends _WidgetBase>(page: T, insertIndex?: number): void;
/**
* Called whenever a page is removed from the container. Remove the
* button corresponding to the page.
*/
onRemoveChild<T extends _WidgetBase>(page: T): void;
/**
* Called when a page has been selected in the StackContainer, either
* by me or by another StackController.
*/
onSelectChild<T extends _WidgetBase>(page: T): void;
/**
* Called whenever one of my child buttons is pressed in an attempt to
* select a page.
*/
onButtonClick<T extends _WidgetBase>(page: T): void;
/**
* Called whenever one of my child buttons [X] is pressed in an attempt
* to close a page.
*/
onCloseButtonClick<T extends _WidgetBase>(page: T): void;
/**
* Helper for onkeydown to find next/previous button.
*/
adjacent(forward: boolean): _WidgetBase;
/**
* Handle keystrokes on the page list, for advancing to next/previous
* button and closing the page in the page is closable.
*/
onkeydown(e: Event, fromContainer?: boolean): void;
/**
* Called when there was a keydown on the container.
*/
onContainerKeyDown(info: Object): void;
}
interface StackController extends StackControllerBase {
/**
* The button widget to create to correspond to each page.
*/
buttonWidget: _StackButtonConstructor;
}
interface StackControllerConstructor extends _WidgetBaseConstructor<StackController> { }
/* dijit/layout/TabContainer */
interface TabContainer extends _TabContainerBase {
/**
* True if a menu should be used to select tabs when they are too
* wide to fit the TabContainer, false otherwise.
*/
useMenu: boolean;
/**
* True if a slider should be used to select tabs when they are too
* wide to fit the TabContainer, false otherwise.
*/
useSlider: boolean;
/**
* An optional parameter to override the widget used to display the tab labels.
*/
controllerWidget: string;
}
interface TabContainerConstructor extends _WidgetBaseConstructor<TabContainer> { }
/* dijit/layout/TabController */
interface _TabButton extends _StackButton { }
interface _TabButtonConstructor extends _WidgetBaseConstructor<_TabButton> { }
interface TabController extends StackControllerBase {
/**
* Defines where tabs go relative to the content.
* "top", "bottom", "left-h", "right-h"
*/
tabPosition: string;
// tabPosition: 'top' | 'bottom' | 'left-h' | 'right-h';
/**
* The tab widget to create to correspond to each page.
*/
buttonWidget: _TabButtonConstructor;
/**
* Class of [x] close icon, used by event delegation code to tell
* when close button was clicked.
*/
buttonWidgetCloseClass: string;
}
interface TabControllerConstructor extends _WidgetBaseConstructor<TabController> {
TabButton: _TabButton;
}
}
}