##// END OF EJS Templates
implab » implabjs-dojo-typings
RSS
Added tag v1.0.4 for changeset 03f3149f6507
Added tag v1.0.4 for changeset 03f3149f6507
cin - - Load All Authors

File last commit:

r0:ab570232df7d default
r15:4476d1cdf4fc default
Show More
dnd.d.ts
825 lines | 19.2 KiB | video/mp2t | TypeScriptLexer
/ dojo-typings / src / main / typings / dojo / dnd.d.ts
History | Source | Raw |Copy content |Copy permalink
cin
Initial commit, project structure.
 r0 declare namespace dojo {
namespace dnd {
/* implied types */
interface DndLocation {
t: number;
l: number;
}
/* dojo/dnd/autoscroll */
interface AutoScroll {
getViewport(doc?: Document): DomGeometryBox;
V_TRIGGER_AUTOSCROLL: number;
H_TRIGGER_AUTOSCROLL: number;
V_AUTOSCROLL_VALUE: number;
H_AUTOSCROLL_VALUE: number;
/**
* Called at the start of a drag.
*/
autoScrollStart(d: Document): void;
/**
* a handler for mousemove and touchmove events, which scrolls the window, if
* necessary
*/
autoScroll(e: Event): void;
_validNodes: { div: number; p: number; td: number; };
_validOverflow: { auto: number; scroll: number; };
/**
* a handler for mousemove and touchmove events, which scrolls the first available
* Dom element, it falls back to exports.autoScroll()
*/
autoScrollNodes(e: Event): void;
}
/* dojo/dnd/AutoSource */
interface AutoSource extends Source { }
interface AutoSourceConstructor {
new (node: NodeOrString, params?: SourceArgs): AutoSource;
prototype: AutoSource;
}
/* dojo/dnd/Avatar */
interface Avatar {
/**
* constructor function;
* it is separate so it can be (dynamically) overwritten in case of need
*/
construct(): void;
/**
* destructor for the avatar; called to remove all references so it can be garbage-collected
*/
destroy(): void;
/**
* updates the avatar to reflect the current DnD state
*/
update(): void;
/**
* generates a proper text to reflect copying or moving of items
*/
_generateText(): string;
}
interface AvatarConstructor {
new (manager: Manager): Avatar;
prototype: Avatar;
}
/* dojo/dnd/common */
interface Common {
getCopyKeyState(evt: Event): boolean;
_uniqueId: number;
/**
* returns a unique string for use with any DOM element
*/
getUniqueId(): number;
_empty: { };
/**
* returns true if user clicked on a form element
*/
isFormElement(e: Event): boolean;
}
/* dojo/dnd/Container */
interface ContainerItem<T extends GenericObject> {
type?: string[];
data?: T;
}
interface ContainerArgs {
/**
* a creator function, which takes a data item, and returns an object like that:
* {node: newNode, data: usedData, type: arrayOfStrings}
*/
creator<T>(data?: ContainerItem<T>): { node: Element; data: T; type: string[]; };
/**
* don't start the drag operation, if clicked on form elements
*/
skipForm: boolean;
/**
* node or node's id to use as the parent node for dropped items
* (must be underneath the 'node' parameter in the DOM)
*/
dropParent: NodeOrString;
/**
* skip startup(), which collects children, for deferred initialization
* (this is used in the markup mode)
*/
_skipStartup: boolean;
}
interface Container extends Evented {
/**
* Indicates whether to allow dnd item nodes to be nested within other elements.
* By default this is false, indicating that only direct children of the container can
* be draggable dnd item nodes
*/
skipForm: boolean;
/**
* Indicates whether to allow dnd item nodes to be nested within other elements.
* By default this is false, indicating that only direct children of the container can
* be draggable dnd item nodes
*/
allowNested: boolean;
/**
* The DOM node the mouse is currently hovered over
*/
current: HTMLElement;
/**
* Map from an item's id (which is also the DOMNode's id) to
* the dojo/dnd/Container.Item itself.
*/
map: { [name: string]: ContainerItem<any> };
/**
* creator function, dummy at the moment
*/
creator<T>(data?: ContainerItem<T>): { node: Element; data: T; type: string[]; };
/**
* returns a data item by its key (id)
*/
getItem<T>(key: string): ContainerItem<T>;
/**
* associates a data item with its key (id)
*/
setITem<T>(key: string, data: ContainerItem<T>): void;
/**
* removes a data item from the map by its key (id)
*/
delItem(key: string): void;
/**
* iterates over a data map skipping members that
* are present in the empty object (IE and/or 3rd-party libraries).
*/
forInItems<T, U>(f: (i: ContainerItem<T>, idx?: number, container?: Container) => void, o?: U): U;
/**
* removes all data items from the map
*/
clearItems(): void;
/**
* returns a list (an array) of all valid child nodes
*/
getAllNodes(): NodeList<Node>;
/**
* sync up the node list with the data map
*/
sync(): this;
/**
* inserts an array of new nodes before/after an anchor node
*/
insertNodes(data: ContainerItem<any>[], before?: boolean, anchor?: Element): this;
/**
* prepares this object to be garbage-collected
*/
destroy(): void;
markupFactory<T>(params: ContainerArgs, node: Element, Ctor: GenericConstructor<T>): T;
/**
* collects valid child items and populate the map
*/
startup(): void;
/**
* event processor for onmouseover or touch, to mark that element as the current element
*/
onMouseOver(e: Event): void;
/**
* event processor for onmouseout
*/
onMouseOut(e: Event): void;
/**
* event processor for onselectevent and ondragevent
*/
onSelectStart(e: Event): void;
/**
* this function is called once, when mouse is over our container
*/
onOverEvent(e: Event): void;
/**
* this function is called once, when mouse is out of our container
*/
onOutEvent(e: Event): void;
/**
* changes a named state to new state value
*/
_changeState(type: string, newState: string): void;
/**
* adds a class with prefix "dojoDndItem"
*/
_addItemClass(node: Element, type: string): void;
/**
* removes a class with prefix "dojoDndItem"
*/
_removeItemClass(node: Element, type: string): void;
/**
* gets a child, which is under the mouse at the moment, or null
*/
_getChildByEvent(e: Event): void;
/**
* adds all necessary data to the output of the user-supplied creator function
*/
_normalizedCreator<T>(item: ContainerItem<T>, hint: string): this;
}
interface ContainerConstructor {
/**
* a constructor of the Container
*/
new (node: NodeOrString, params?: ContainerArgs): Container;
prototype: Container;
}
interface Common {
/**
* returns a function, which creates an element of given tag
* (SPAN by default) and sets its innerHTML to given text
*/
_createNode(tag: string): (text: string) => HTMLElement;
/**
* creates a TR/TD structure with given text as an innerHTML of TD
*/
_createTrTd(text: string): HTMLTableRowElement;
/**
* creates a SPAN element with given text as its innerHTML
*/
_createSpan(text: string): HTMLSpanElement;
/**
* a dictionary that maps container tag names to child tag names
*/
_defaultCreatorNodes: { ul: string, ol: string, div: string, p: string };
/**
* takes a parent node, and returns an appropriate creator function
*/
_defaultCreator<T>(node: HTMLElement): { node: HTMLElement; data: T; type: string };
}
/* dojo/dnd/Manager */
interface Manager extends Evented {
OFFSET_X: number;
OFFSET_Y: number;
overSource(source: Source): void;
outSource(source: Source): void;
startDrag(source: Source, nodes: HTMLElement[], copy?: boolean): void;
canDrop(flag: boolean): void;
stopDrag(): void;
makeAvatar(): Avatar;
updateAvatar(): void;
onMouseMove(e: MouseEvent): void;
onMouseUp(e: MouseEvent): void;
onKeyDown(e: KeyboardEvent): void;
onKeyUp(e: KeyboardEvent): void;
_setCopyStatus(copy?: boolean): void;
}
interface ManagerConstructor {
/**
* the manager of DnD operations (usually a singleton)
*/
new (): Manager;
prototype: Manager;
/**
* Returns the current DnD manager. Creates one if it is not created yet.
*/
manager(): Manager;
}
interface Common {
_manager: Manager;
}
/* dojo/dnd/move */
interface Move {
constrainedMoveable: ConstrainedMoveableConstructor;
boxConstrainedMoveable: BoxConstrainedMoveableConstructor;
parentConstrainedMoveable: ParentConstrainedMoveableConstructor;
}
interface ConstrainedMoveableArgs extends MoveableArgs {
/**
* Calculates a constraint box.
* It is called in a context of the moveable object.
*/
constraints?: () => DomGeometryBox;
/**
* restrict move within boundaries.
*/
within?: boolean;
}
interface ConstrainedMoveable extends Moveable {
/**
* Calculates a constraint box.
* It is called in a context of the moveable object.
*/
constraints: () => DomGeometryBox;
/**
* restrict move within boundaries.
*/
within: boolean;
}
interface ConstrainedMoveableConstructor {
/**
* an object that makes a node moveable
*/
new (node: NodeOrString, params?: ConstrainedMoveableArgs): ConstrainedMoveable;
}
interface BoxConstrainedMoveableArgs extends ConstrainedMoveableArgs {
/**
* a constraint box
*/
box?: DomGeometryBox;
}
interface BoxConstrainedMoveable extends ConstrainedMoveable {
/**
* a constraint box
*/
box: DomGeometryBox;
}
interface BoxConstrainedMoveableConstructor {
/**
* an object, which makes a node moveable
*/
new (node: NodeOrString, params?: BoxConstrainedMoveableArgs): BoxConstrainedMoveable;
}
type ConstraintArea = 'border' | 'content' | 'margin' | 'padding';
interface ParentConstrainedMoveableArgs extends ConstrainedMoveableArgs {
/**
* A parent's area to restrict the move.
* Can be "margin", "border", "padding", or "content".
*/
area?: ConstraintArea;
}
interface ParentConstrainedMoveable extends ConstrainedMoveable {
/**
* A parent's area to restrict the move.
* Can be "margin", "border", "padding", or "content".
*/
area: ConstraintArea;
}
interface ParentConstrainedMoveableConstructor {
/**
* an object, which makes a node moveable
*/
new (node: NodeOrString, params?: ParentConstrainedMoveableArgs): ParentConstrainedMoveable;
}
/* dojo/dnd/Moveable */
interface MoveableArgs {
/**
* A node (or node's id), which is used as a mouse handle.
* If omitted, the node itself is used as a handle.
*/
handle?: NodeOrString;
/**
* delay move by this number of pixels
*/
delay?: number;
/**
* skip move of form elements
*/
skip?: boolean;
/**
* a constructor of custom Mover
*/
mover?: MoverConstructor;
}
interface Moveable {
/**
* markup methods
*/
markupFactory<T>(params: MoveableArgs, node: HTMLElement, Ctor: GenericConstructor<T>): T;
/**
* stops watching for possible move, deletes all references, so the object can be garbage-collected
*/
destroy(): void;
/**
* event processor for onmousedown/ontouchstart, creates a Mover for the node
*/
onMouseDown(e: MouseEvent): void;
/**
* event processor for onmousemove/ontouchmove, used only for delayed drags
*/
onMouseMove(e: MouseEvent): void;
/**
* event processor for onmouseup, used only for delayed drags
*/
onMouseUp(e: MouseEvent): void;
/**
* called when the drag is detected;
* responsible for creation of the mover
*/
onDragDetected(e: Event): void;
/**
* called before every move operation
*/
onMoveStart(mover: Mover): void;
/**
* called after every move operation
*/
onMoveStop(mover: Mover): void;
/**
* called during the very first move notification;
* can be used to initialize coordinates, can be overwritten.
*/
onFirstMove(mover: Mover, e: Event): void;
/**
* called during every move notification;
* should actually move the node; can be overwritten.
*/
onMove(mover: Mover, leftTop: DndLocation, e?: Event): void;
/**
* called before every incremental move; can be overwritten.
*/
onMoving(mover: Mover, leftTop: DndLocation): void;
/**
* called after every incremental move; can be overwritten.
*/
onMoved(mover: Mover, leftTop: DndLocation): void;
}
interface MoveableConstructor {
new (node: NodeOrString, params?: MoveableArgs): Moveable;
prototype: Moveable;
}
/* dojo/dnd/Mover */
interface MoverHost extends GenericObject {
onMoveStart(mover: Mover): void;
onMoveStop(mover: Mover): void;
}
interface Mover extends Evented {
/**
* event processor for onmousemove/ontouchmove
*/
onMouseMove(e: MouseEvent): void;
onMouseUp(e: MouseEvent): void;
/**
* makes the node absolute; it is meant to be called only once.
* relative and absolutely positioned nodes are assumed to use pixel units
*/
onFirstMove(e: Event): void;
/**
* stops the move, deletes all references, so the object can be garbage-collected
*/
destroy(): void;
}
interface MoverConstructor {
/**
* an object which makes a node follow the mouse, or touch-drag on touch devices.
* Used as a default mover, and as a base class for custom movers.
*/
new (node: HTMLElement, e: MouseEvent, host: MoverHost): Mover;
prototype: Mover;
}
/* dojo/dnd/Selector */
interface Selector extends Container {
/**
* The set of id's that are currently selected, such that this.selection[id] == 1
* if the node w/that id is selected. Can iterate over selected node's id's like:
* for(var id in this.selection)
*/
selection: { [id: string]: number };
/**
* is singular property
*/
singular: boolean;
/**
* returns a list (an array) of selected nodes
*/
getSelectedNodes(): NodeList<Node>;
/**
* unselects all items
*/
selectNone(): this;
/**
* selects all items
*/
selectAll(): this;
/**
* deletes all selected items
*/
deleteSelectedNodes(): this;
/**
* iterates over selected items;
* see `dojo/dnd/Container.forInItems()` for details
*/
forInSelectedItems<T>(f: (i: ContainerItem<T>, idx?: number, container?: Container) => void, o?: GenericObject): void;
/**
* event processor for onmousemove
*/
onMouseMove(e: Event): void;
/**
* this function is called once, when mouse is over our container
*/
onOverEvent(): void;
/**
* this function is called once, when mouse is out of our container
*/
onOutEvent(): void;
/**
* unselects all items
*/
_removeSelection(): this;
_removeAnchor(): this;
}
interface SelectorConstructor {
/**
* constructor of the Selector
*/
new (node: NodeOrString, params?: ContainerArgs): Selector;
prototype: Selector;
}
/* dojo/dnd/Source */
/**
* a dict of parameters for DnD Source configuration. Note that any
* property on Source elements may be configured, but this is the
* short-list
*/
interface SourceArgs {
[arg: string]: any;
/**
* can be used as a DnD source. Defaults to true.
*/
isSource?: boolean;
/**
* list of accepted types (text strings) for a target; defaults to
* ["text"]
*/
accept?: string[];
/**
* if true refreshes the node list on every operation; false by default
*/
autoSync?: boolean;
/**
* copy items, if true, use a state of Ctrl key otherwisto
* see selfCopy and selfAccept for more details
*/
copyOnly?: boolean;
/**
* the move delay in pixels before detecting a drag; 0 by default
*/
delay?: number;
/**
* a horizontal container, if true, vertical otherwise or when omitted
*/
horizontal?: boolean;
/**
* copy items by default when dropping on itself,
* false by default, works only if copyOnly is true
*/
selfCopy?: boolean;
/**
* accept its own items when copyOnly is true,
* true by default, works only if copyOnly is true
*/
selfAccept?: boolean;
/**
* allows dragging only by handles, false by default
*/
withHandles?: boolean;
/**
* generate text node for drag and drop, true by default
*/
generateText?: boolean;
}
interface Source extends Selector {
/**
* checks if the target can accept nodes from this source
*/
checkAcceptance(source: Container, nodes: HTMLElement[]): boolean;
/**
* Returns true if we need to copy items, false to move.
* It is separated to be overwritten dynamically, if needed.
*/
copyState(keyPressed: boolean, self?: boolean): boolean;
/**
* topic event processor for /dnd/source/over, called when detected a current source
*/
onDndSourceOver(source: Container): void;
/**
* topic event processor for /dnd/start, called to initiate the DnD operation
*/
onDndStart(source: Container, nodes: HTMLElement[], copy?: boolean): void;
/**
* topic event processor for /dnd/drop, called to finish the DnD operation
*/
onDndDrop(source: Container, nodes: HTMLElement[], copy: boolean, target: Container): void;
/**
* topic event processor for /dnd/cancel, called to cancel the DnD operation
*/
onDndCancel(): void;
/**
* called only on the current target, when drop is performed
*/
onDrop(source: Container, nodes: HTMLElement[], copy?: boolean): void;
/**
* called only on the current target, when drop is performed
* from an external source
*/
onDropExternal(source: Container, nodes: HTMLElement[], copy?: boolean): void;
/**
* called only on the current target, when drop is performed
* from the same target/source
*/
onDropInternal(nodes: HTMLElement[], copy?: boolean): void;
/**
* called during the active DnD operation, when items
* are dragged over this target, and it is not disabled
*/
onDraggingOver(): void;
/**
* called during the active DnD operation, when items
* are dragged away from this target, and it is not disabled
*/
onDraggingOut(): void;
/**
* this function is called once, when mouse is over our container
*/
onOverEvent(): void;
/**
* this function is called once, when mouse is out of our container
*/
onOutEvent(): void;
/**
* assigns a class to the current target anchor based on "before" status
*/
_markTargetAnchor(before?: boolean): void;
/**
* removes a class of the current target anchor based on "before" status
*/
_unmarkTargetAnchor(): void;
/**
* changes source's state based on "copy" status
*/
_markDndStatus(copy?: boolean): void;
/**
* checks if user clicked on "approved" items
*/
_legalMouseDown(e?: Event): boolean;
}
interface SourceConstructor {
new (node: NodeOrString, params?: SourceArgs): Source;
prototype: Source;
}
/* dojo/dnd/Target */
interface Target extends Source { }
interface TargetConstructor {
new (node: HTMLElement, params: SourceArgs): Target;
prototype: Target;
}
/* dojo/dnd/TimedMoveable */
interface TimedMoveableArgs extends MoveableArgs {
timeout?: number;
}
interface TimedMoveable extends Moveable {
onMoveStop(mover: Mover): void;
onMove(mover: Mover, leftTop: DndLocation): void;
}
interface TimedMoveableConstructor {
new (node: HTMLElement, params?: TimedMoveableArgs): TimedMoveable;
prototype: TimedMoveable;
}
}
}