##// END OF EJS Templates
implab » implabjs-djx
RSS
sync
sync
cin - - Load All Authors

File last commit:

r3:fb4d13ff05ae default
r8:6d80d7901b4c v1.0.0-rc3 default
Show More
_WidgetBase.d.ts
241 lines | 8.2 KiB | video/mp2t | TypeScriptLexer
/ src / typings / dijit / _WidgetBase.d.ts
History | Source | Raw |Copy content |Copy permalink
cin
created typings for basic part of dojo and dijit further work is required to...
 r2 import Stateful = require("dojo/Stateful");
import Destroyable = require("./Destroyable");
import { ExtensionEvent } from "dojo/on";
import { NodeFragmentOrString, Handle, NodeOrString, WatchHandle } from "dojo/interfaces";
import { DeclareConstructor } from "dojo/_base/declare";
declare namespace _WidgetBase {
interface _WidgetBase extends Stateful, Destroyable {
/**
* A unique, opaque ID string that can be assigned by users or by the
* system. If the developer passes an ID which is known not to be
* unique, the specified ID is ignored and the system-generated ID is
* used instead.
*/
id: string;
/**
* Rarely used. Overrides the default Dojo locale used to render this widget,
* as defined by the [HTML LANG](http://www.w3.org/TR/html401/struct/dirlang.html#adef-lang) attribute.
* Value must be among the list of locales specified during by the Dojo bootstrap,
* formatted according to [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt) (like en-us).
*/
lang: string;
/**
* Bi-directional support, as defined by the [HTML DIR](http://www.w3.org/TR/html401/struct/dirlang.html#adef-dir)
* attribute. Either left-to-right "ltr" or right-to-left "rtl". If undefined, widgets renders in page's
* default direction.
*/
dir: string;
/**
* HTML class attribute
*/
class: string;
/**
* HTML style attributes as cssText string or name/value hash
*/
style: string;
/**
* HTML title attribute.
*
* For form widgets this specifies a tooltip to display when hovering over
* the widget (just like the native HTML title attribute).
*
* For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
* etc., it's used to specify the tab label, accordion pane title, etc. In this case it's
* interpreted as HTML.
*/
title: string;
/**
* When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
* this specifies the tooltip to appear when the mouse is hovered over that text.
*/
tooltip: string;
/**
* Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
* widget state.
*/
baseClass: string;
/**
* pointer to original DOM node
*/
srcNodeRef: HTMLElement;
/**
* This is our visible representation of the widget! Other DOM
* Nodes may by assigned to other properties, usually through the
* template system's data-dojo-attach-point syntax, but the domNode
* property is the canonical "top level" node in widget UI.
*/
domNode: HTMLElement;
/**
* Designates where children of the source DOM node will be placed.
* "Children" in this case refers to both DOM nodes and widgets.
*/
containerNode: HTMLElement;
/**
* The document this widget belongs to. If not specified to constructor, will default to
* srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
*/
ownerDocument: HTMLElement;
/**
* Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
* for each XXX attribute to be mapped to the DOM.
*/
attributeMap: { [attribute: string]: any };
/**
* Bi-directional support, the main variable which is responsible for the direction of the text.
* The text direction can be different than the GUI direction by using this parameter in creation
* of a widget.
*/
textDir: string;
/**
* Kicks off widget instantiation. See create() for details.
*/
postscript(params?: any, srcNodeRef?: HTMLElement): void;
/**
* Kick off the life-cycle of a widget
*/
create(params?: any, srcNodeRef?: HTMLElement): void;
/**
* Called after the parameters to the widget have been read-in,
* but before the widget template is instantiated. Especially
* useful to set properties that are referenced in the widget
* template.
*/
postMixInProperties(): void;
/**
* Construct the UI for this widget, setting this.domNode.
* Most widgets will mixin `dijit._TemplatedMixin`, which implements this method.
*/
buildRendering(): void;
/**
* Processing after the DOM fragment is created
*/
postCreate(): void;
/**
* Processing after the DOM fragment is added to the document
*/
startup(): void;
/**
* Destroy this widget and its descendants
*/
destroyRecursive(preserveDom?: boolean): void;
/**
* Destroys the DOM nodes associated with this widget.
*/
destroyRendering(preserveDom?: boolean): void;
/**
* Recursively destroy the children of this widget and their
* descendants.
*/
destroyDescendants(preserveDom?: boolean): void;
/**
* Deprecated. Override destroy() instead to implement custom widget tear-down
* behavior.
*/
uninitialize(): boolean;
/**
* Used by widgets to signal that a synthetic event occurred, ex:
* | myWidget.emit("attrmodified-selectedChildWidget", {}).
*/
emit(type: string, eventObj?: any, callbackArgs?: any[]): any;
/**
* Call specified function when event occurs, ex: myWidget.on("click", function(){ ... }).
*/
on(type: string | ExtensionEvent, func: EventListener | Function): WatchHandle;
/**
* Returns a string that represents the widget.
*/
toString(): string;
/**
* Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
* is this widget. Note that it does not return all descendants, but rather just direct children.
*/
getChildren<T extends _WidgetBase>(): T[];
/**
* Returns the parent widget of this widget.
*/
getParent<T extends _WidgetBase>(): T;
/**
* Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
*/
connect(obj: any, event: string | ExtensionEvent, method: string | EventListener): WatchHandle;
/**
* Deprecated, will be removed in 2.0, use handle.remove() instead.
*/
disconnect(handle: WatchHandle): void;
/**
* Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
*/
subscribe(t: string, method: EventListener): WatchHandle;
/**
* Deprecated, will be removed in 2.0, use handle.remove() instead.
*/
unsubscribe(handle: WatchHandle): void;
/**
* Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
*/
isLeftToRight(): boolean;
/**
* Return true if this widget can currently be focused
* and false if not
*/
isFocusable(): boolean;
/**
* Place this widget somewhere in the DOM based
* on standard domConstruct.place() conventions.
*/
placeAt<T extends _WidgetBase>(reference: NodeFragmentOrString | T, position?: string | number): this;
/**
* Wrapper to setTimeout to avoid deferred functions executing
* after the originating widget has been destroyed.
* Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
*/
defer(fcn: Function, delay?: number): Handle;
}
interface _WidgetBaseConstructor<W = _WidgetBase> extends DeclareConstructor<W> {
new(params: Object, srcNodeRef: NodeOrString): W;
}
cin
fixed dependencies
 r3
cin
created typings for basic part of dojo and dijit further work is required to...
 r2 }
type _WidgetBase = _WidgetBase._WidgetBase;
declare const _WidgetBase: _WidgetBase._WidgetBaseConstructor;
export = _WidgetBase;