elements).
///
},
occurrenceByUid: function(uid) {
///
///
/// Gets the event occurrence with the specified uid.
///
/// The uid of the occurrence to look for.
/// the occurrence instance. Returns undefined if an occurrence with the specified uid is not found.
///
},
occurrencesInRange: function(start,end) {
///
///
/// Gets a list of event occurrences in specified time range.
///
/// The start date of the period.
/// The end date of the period.
/// a list of scheduler events filtered by the specified start/end period.
///
},
refresh: function() {
///
///
/// Refreshes the Scheduler rendering using the current data items.
///
///
},
removeEvent: function(event) {
///
///
/// Removes the specified scheduler event.
///
/// The event which should be removed. Also accepts a string which is the uid of the event which should be removed.
///
},
resourcesBySlot: function(slot) {
///
///
/// Get the relevant resources for a given slot.
///
///
/// The relevant resources.
///
},
saveAsPDF: function() {
///
///
/// Initiates the PDF export and returns a promise. Also triggers the pdfExport event.
///
/// A promise that will be resolved when the export completes. The same promise is available in the pdfExport event arguments.
///
},
saveEvent: function() {
///
///
/// Saves the scheduler event which is open in the edit form and closes it.
///
///
},
select: function(events,options) {
///
///
/// Gets or sets the events (or slots) which are selected.
///
/// The Uids of events which should be selected. List of the available events can be get using the data method.
///
///
},
setDataSource: function(dataSource) {
///
///
/// Sets the data source of the widget.
///
/// The data source to which the widget should be bound.
///
},
slotByPosition: function(xPosition,yPosition) {
///
///
/// Get the time slot from given horizontal (x) and vertical (y) position.
///
/// The horizontal position.
/// The vertical position.
/// The time slot.
///
},
slotByElement: function(element) {
///
///
/// Get the time slot from given element.
///
///
/// The time slot.
///
},
view: function(type) {
///
///
/// Sets the current Scheduler view.To get the current Scheduler view name, use the viewName method.
///
/// The view type to select.
///
},
viewName: function() {
///
///
/// The name of the current view. Can be used for refreshing the current view data.
///
/// the name of the current scheduler view.
///
},
bind: function(event, callback) {
///
///
/// Binds to a widget event.
///
/// The event name
/// The callback to be executed when the event is triggered.
///
},
unbind: function(event, callback) {
///
///
/// Unbinds a callback from a widget event.
///
/// The event name
/// The callback to be removed.
///
}
});
return instance;
};
intellisense.redirectDefinition(wrapper, original);
return wrapper;
})();
jQuery.fn.kendoScheduler = function() {
this.data("kendoScheduler", new kendo.ui.Scheduler());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoScheduler: function() {
///
///
/// Returns a reference to the kendo.ui.Scheduler widget, instantiated on the selector.
///
/// The kendo.ui.Scheduler instance (if present).
///
},
kendoScheduler: function(options) {
///
///
/// Instantiates a kendo.ui.Scheduler widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
allDayEventTemplate - String|Function
///
The template used to render the "all day" scheduler events.The fields which can be used in the template are:
///
///
allDaySlot - Boolean (default: true)
///
If set to true the scheduler will display a slot for "all day" events.
///
///
autoBind - Boolean (default: true)
///
If set to false the widget will not bind to the data source during initialization. In this case data binding will occur when the change event of the
///
data source is fired. By default the widget will bind to the data source specified in the configuration.
///
///
currentTimeMarker - Boolean
///
If set to false the "current time" marker of the scheduler would not be displayed.
///
///
currentTimeMarker - Object
///
If set to false the "current time" marker of the scheduler would not be displayed.
///
///
dataSource - Object|Array|kendo.data.SchedulerDataSource
///
The data source of the widget which contains the scheduler events. Can be a JavaScript object which represents a valid data source configuration, a JavaScript array or an existing kendo.data.SchedulerDataSource
///
instance.If the dataSource option is set to a JavaScript object or array the widget will initialize a new kendo.data.SchedulerDataSource instance using that value as data source configuration.If the dataSource option is an existing kendo.data.SchedulerDataSource instance the widget will use that instance and will not initialize a new one.
///
///
date - Date
///
The current date of the scheduler. Used to determine the period which is displayed by the widget.
///
///
dateHeaderTemplate - String|Function
///
The template used to render the date header cells.By default the scheduler renders the date using a custom date format - "ddd M/dd".
///
The "ddd" specifier represents the abbreviated name of the week day and will be localized using the current Kendo UI culture.
///
If the developer wants to control the day and month order, then one needs to define a custom template.The fields which can be used in the template are:
///
///
editable - Boolean (default: true)
///
If set to true the user would be able to create new scheduler events and modify or delete existing ones.
///
///
editable - Object (default: true)
///
If set to true the user would be able to create new scheduler events and modify or delete existing ones.
///
///
endTime - Date
///
The end time of the week and day views. The scheduler will display events ending before the endTime.
///
///
eventTemplate - String|Function
///
The template used to render the scheduler events.The fields which can be used in the template are:
///
///
footer - Boolean
///
If set to false the footer of the scheduler would not be displayed.
///
///
footer - Object
///
If set to false the footer of the scheduler would not be displayed.
///
///
group - Object
///
The configuration of the scheduler resource(s) grouping.
///
///
groupHeaderTemplate - String|Function
///
The template used to render the group headers of scheduler day, week, workWeek and timeline views.The fields which can be used in the template are:
///
///
height - Number|String
///
The height of the widget. Numeric values are treated as pixels.
///
///
majorTick - Number (default: 60)
///
The number of minutes represented by a major tick.
///
///
majorTimeHeaderTemplate - String|Function
///
The template used to render the major ticks.By default the scheduler renders the time using the current culture time format.The fields which can be used in the template are:
///
///
max - Date (default: 31/12/2099)
///
Constraints the maximum date which can be selected via the scheduler navigation.
///
///
messages - Object
///
The configuration of the scheduler messages. Use this option to customize or localize the scheduler messages.
///
///
min - Date (default: 1/1/1900)
///
Constraints the minimum date which can be selected via the scheduler navigation.
///
///
minorTickCount - Number (default: 2)
///
The number of time slots to display per major tick.
///
///
minorTimeHeaderTemplate - String|Function
///
The template used to render the minor ticks.By default the scheduler renders a " ".The fields which can be used in the template are:
///
///
mobile - Boolean|String (default: false)
///
If set to true and the scheduler is viewed on mobile browser it will use adaptive rendering.Can be set to a string phone or tablet which will force the widget to use adaptive rendering regardless of browser type.
///
///
pdf - Object
///
Configures the Kendo UI Scheduler PDF export settings.
///
///
resources - Array
///
The configuration of the scheduler resource(s). A scheduler resource is optional metadata that can be associated
///
with a scheduler event.
///
///
selectable - Boolean (default: false)
///
If set to true the user would be able to select scheduler cells and events. By default selection is disabled.
///
///
showWorkHours - Boolean (default: false)
///
If set to true the view will be initially shown in business hours mode. By default view is displayed in full day mode.
///
///
snap - Boolean (default: true)
///
If set to true the scheduler will snap events to the nearest slot during dragging (resizing or moving). Set it to false to allow free moving and resizing of events.
///
///
startTime - Date
///
The start time of the week and day views. The scheduler will display events starting after the startTime.
///
///
timezone - String
///
The timezone which the scheduler will use to display the scheduler appointment dates. By default the current system timezone is used. This is an acceptable default when the
///
scheduler widget is bound to local array of events. It is advisable to specify a timezone if the scheduler is bound to a remote service.
///
That way all users would see the same dates and times no matter their configured system timezone.The complete list of the supported timezones is available in the List of IANA time zones Wikipedia page.
///
///
toolbar - Array
///
List of commands that the scheduler will display in its toolbar as buttons. Currently supports only the "pdf" command.The "pdf" command exports the scheduler in PDF format.
///
///
views - Array
///
The views displayed by the scheduler and their configuration. The array items can be either objects specifying the view configuration or strings representing the view types (assuming default configuration).
///
By default the Kendo UI Scheduler widget displays "day" and "week" view.
///
///
width - Number|String
///
The width of the widget. Numeric values are treated as pixels.
///
///
workDayStart - Date
///
Sets the start of the work day when the "Show business hours" button is clicked.
///
///
workDayEnd - Date
///
Sets the end of the work day when the "Show business hours" button is clicked.
///
///
workWeekStart - Number (default: 1)
///
The start of working week (index based).
///
///
workWeekEnd - Number (default: 5)
///
The end of working week (index based).
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.ui, {
Slider: function() {
///
/// Constructor of kendo.ui.Slider
///
}
});
kendo.ui.Slider = (function() {
var original = kendo.ui.Slider;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
destroy: function() {
///
///
/// Prepares the Slider for safe removal from the DOM.Detaches event handlers and removes data entries in order to avoid memory leaks.
///
///
},
enable: function(enable) {
///
///
/// Enable/Disable the Slider widget.
///
/// The argument, which defines whether to enable/disable the Slider.
///
},
value: function(value) {
///
///
/// Gets or sets the value of a Slider. It accepts a string or number as parameters and returns
/// a number representing the underlying value.
///
/// _optional, default: _The value to be set for a Slider.
/// The value of the Slider.
///
},
resize: function() {
///
///
/// Adjusts the Slider layout to match the size of the container.
///
///
},
bind: function(event, callback) {
///
///
/// Binds to a widget event.
///
/// The event name
/// The callback to be executed when the event is triggered.
///
},
unbind: function(event, callback) {
///
///
/// Unbinds a callback from a widget event.
///
/// The event name
/// The callback to be removed.
///
}
});
return instance;
};
intellisense.redirectDefinition(wrapper, original);
return wrapper;
})();
jQuery.fn.kendoSlider = function() {
this.data("kendoSlider", new kendo.ui.Slider());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoSlider: function() {
///
///
/// Returns a reference to the kendo.ui.Slider widget, instantiated on the selector.
///
/// The kendo.ui.Slider instance (if present).
///
},
kendoSlider: function(options) {
///
///
/// Instantiates a kendo.ui.Slider widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
decreaseButtonTitle - String (default: "Decrease")
///
The title of the decrease button of the Slider.
///
///
dragHandleTitle - String (default: "drag")
///
The title of the drag handle of the Slider.
///
///
increaseButtonTitle - String (default: "Increase")
///
The title of the increase button of the Slider.
///
///
largeStep - Number (default: 5)
///
The delta with which the value will change when the user presses the Page Up or Page Down key (the drag
///
handle must be focused). Note: largeStep will also set a large tick for every large step.Must be a positive number, larger than smallStep.
///
///
max - Number (default: 10)
///
The maximum value of the Slider.
///
///
min - Number (default: 0)
///
The minimum value of the Slider.
///
///
orientation - String (default: "horizontal")
///
The orientation of a Slider: "horizontal" or "vertical".
///
///
showButtons - Boolean (default: true)
///
Can be used to show (true) or hide (false) the
///
increase and decrease buttons of a Slider.
///
///
smallStep - Number (default: 1)
///
The small step value of the Slider. Must be a positive number, otherwise an Javascript exception will be thrown.The small step value determines the amount of Slider value change when the end user
///
///
tickPlacement - String (default: "both")
///
Denotes the location of the tick marks in the Slider. The available options are:
///
///
tooltip - Object
///
Configuration of the Slider tooltip.
///
///
value - Number
///
The underlying value of the Slider.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.ui, {
Sortable: function() {
///
/// Constructor of kendo.ui.Sortable
///
}
});
kendo.ui.Sortable = (function() {
var original = kendo.ui.Sortable;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
indexOf: function(element) {
///
///
/// Returns the index of specified item. Filtered items are excluded from the collection.
///
/// jQuery object which represents the sortable element.
/// the index of specified item.
///
},
items: function() {
///
///
/// Returns the sortable elements. Filtered items and the placeholder are excluded from the collection.
///
/// the sortable items
///
},
bind: function(event, callback) {
///
///
/// Binds to a widget event.
///
/// The event name
/// The callback to be executed when the event is triggered.
///
},
unbind: function(event, callback) {
///
///
/// Unbinds a callback from a widget event.
///
/// The event name
/// The callback to be removed.
///
}
});
return instance;
};
intellisense.redirectDefinition(wrapper, original);
return wrapper;
})();
jQuery.fn.kendoSortable = function() {
this.data("kendoSortable", new kendo.ui.Sortable());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoSortable: function() {
///
///
/// Returns a reference to the kendo.ui.Sortable widget, instantiated on the selector.
///
/// The kendo.ui.Sortable instance (if present).
///
},
kendoSortable: function(options) {
///
///
/// Instantiates a kendo.ui.Sortable widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
axis - String (default: null)
///
Constrains the hint movement to either the horizontal (x) or vertical (y) axis. Can be set to either "x" or "y".
///
///
autoScroll - Boolean (default: false)
///
If set to true the widget will auto-scroll the container when the mouse/finger is close to the top/bottom of it.
///
///
container - String|jQuery (default: null)
///
Selector that determines the container to which boundaries the hint movement will be constrained.
///
///
connectWith - String (default: null)
///
Selector which determines if items from the current Sortable widget can be accepted from another Sortable container(s). The connectWith option describes one way relationship, if the developer wants a two way connection then the connectWith option should be set on both widgets.
///
///
cursor - String (default: "auto")
///
The cursor that will be shown while user drags sortable item.
///
///
cursorOffset - Object (default: null)
///
If set, specifies the offset of the hint relative to the mouse cursor/finger.
///
By default, the hint is initially positioned on top of the draggable source offset. The option accepts an object with two keys: top and left.
///
///
disabled - String (default: null)
///
Selector that determines which items are disabled. Disabled items cannot be dragged but are valid sort targets.
///
///
filter - String (default: null)
///
Selector that determines which items are sortable. Filtered items cannot be dragged and are not valid sort targets.
///
///
handler - String (default: null)
///
Selector that determines which element will be used as a draggable handler. If a handler is defined, the user will be able to move the Sortable items only if the cursor/finger is positioned onto the handler element.
///
///
hint - Function|String|jQuery
///
Provides a way for customization of the sortable item hint. If a function is supplied, it receives one argument - the draggable element's jQuery object.
///
If hint function is not provided the widget will clone dragged item and use it as a hint.
///
///
holdToDrag - Boolean (default: false)
///
Suitable for touch oriented user interface, in order to avoid collision with the touch scrolling gesture. When set to true, the item will be activated after the user taps and holds the finger on the element for a short amount of time.
///
The item will also be activated by pressing, holding and lifting the finger without any movement. Dragging it afterwards will initiate the drag immediately.
///
///
ignore - String (default: null)
///
Selector that determines which elements inside the sorted item's container will be ignored. Useful if the sortable item contains input elements.
///
///
placeholder - Function|String|jQuery
///
Provides a way for customization of the sortable item placeholder. If a function is supplied, it receives one argument - the draggable element's jQuery object.
///
If placeholder function is not provided the widget will clone dragged item, remove its ID attribute, set its visibility to hidden and use it as a placeholder.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.ui, {
Splitter: function() {
///
/// Constructor of kendo.ui.Splitter
///
}
});
kendo.ui.Splitter = (function() {
var original = kendo.ui.Splitter;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
ajaxRequest: function(pane,url,data) {
///
///
/// Loads the content of a pane from a local or remote URL.
///
/// The targeted pane whose content is to be loaded via a URL.
/// A local or remote URL from which the content of the pane is to be loaded.
/// Any data that is necessary to be sent to the server.
///
},
append: function(config) {
///
///
/// Appends a new pane. The method returns the pane element, so it can be populated with arbitrary content, if contentUrl is not set.
/// Invoking this method will force the widget to redraw and it will trigger the resize event.
///
/// The new pane configuration
/// the pane element.
///
},
collapse: function(pane) {
///
///
/// Collapses a specified pane. Invoking this method will force the widget to redraw and it will trigger the resize event.
/// Note: Invoking the method will not trigger a collapse event.
///
/// The pane to be collapsed.
///
},
destroy: function() {
///
///
/// Prepares the widget for safe removal from DOM. Detaches all event handlers and removes jQuery.data attributes to avoid memory leaks. Calls destroy method of any child Kendo widgets.
///
///
},
expand: function(pane) {
///
///
/// Expands a specified pane. Invoking this method will force the widget to redraw and it will trigger the resize event.
/// Note: Invoking the method will not trigger an expand event.
///
/// The pane to be expanded.
///
},
insertAfter: function(config,referencePane) {
///
///
/// Inserts a new pane after the specified one. The method returns the pane element, so it can be populated with arbitrary content, if contentUrl is not set.
/// Invoking this method will force the widget to redraw and it will trigger the resize event.
///
/// The new pane configuration.
/// The existing pane after which the new one will be inserted.
/// the pane element.
///
},
insertBefore: function(config,referencePane) {
///
///
/// Inserts a new pane before the specified one. The method returns the pane element, so it can be populated with arbitrary content, if contentUrl is not set.
/// Invoking this method will force the widget to redraw and it will trigger the resize event.
///
/// The new pane configuration.
/// The existing pane before which the new one will be inserted.
/// the pane element.
///
},
max: function(pane,value) {
///
///
/// Sets the maximum size of a pane. Setting this value will not cause the widget to redraw, nor will it trigger any events.
///
/// The pane being targeted for a new minimum size configuration value.
/// The maximum size value of the pane defined as pixels (i.e. "200px") or as a percentage (i.e. "50%").
///
},
min: function(pane,value) {
///
///
/// Sets the minimum size of a pane. Setting this value will not cause the widget to redraw, nor will it trigger any events.
///
/// The pane being targeted for a new minimum size configuration value.
/// The minimum size value of the pane defined as pixels (i.e. "200px") or as a percentage (i.e. "50%").
///
},
remove: function(pane) {
///
///
/// Removes one or more panes. The method returns the Splitter instance.
/// Invoking this method will force the widget to redraw and it will trigger the resize event.
///
/// The pane(s) to be removed.
///
},
size: function(pane,value) {
///
///
/// Get or set the size of the pane. Setting this value will cause the widget to redraw and it will trigger the resize event.
///
/// The pane to be resized.
/// The new size of the pane defined as pixels (i.e. "200px") or as a percentage (i.e. "50%"). Note: This value must not exceed panes.max or be less then panes.min.
/// the pane size.
///
},
toggle: function(pane,expand) {
///
///
/// Toggles the state of a specified pane (i.e. collapsed or expanded).
/// Invoking this method will force the widget to redraw and it will trigger the resize event.
/// Note: Invoking the method will not trigger collapse or expand events.
///
/// The pane to be collapsed.
/// Represents the desired state of the specified pane; to be expanded (true) or collapsed (false). If undefined, toggle() will collapse the pane if it is expanded or will expand the pane if it is collapsed.
///
},
bind: function(event, callback) {
///
///
/// Binds to a widget event.
///
/// The event name
/// The callback to be executed when the event is triggered.
///
},
unbind: function(event, callback) {
///
///
/// Unbinds a callback from a widget event.
///
/// The event name
/// The callback to be removed.
///
}
});
return instance;
};
intellisense.redirectDefinition(wrapper, original);
return wrapper;
})();
jQuery.fn.kendoSplitter = function() {
this.data("kendoSplitter", new kendo.ui.Splitter());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoSplitter: function() {
///
///
/// Returns a reference to the kendo.ui.Splitter widget, instantiated on the selector.
///
/// The kendo.ui.Splitter instance (if present).
///
},
kendoSplitter: function(options) {
///
///
/// Instantiates a kendo.ui.Splitter widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
orientation - String (default: "horizontal")
///
Specifies the orientation of the widget. Supported values are "horizontal" and "vertical".
///
///
panes - Array
///
An array of pane definitions.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.ui, {
Spreadsheet: function() {
///
/// Constructor of kendo.ui.Spreadsheet
///
}
});
kendo.ui.Spreadsheet = (function() {
var original = kendo.ui.Spreadsheet;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
activeSheet: function(sheet) {
///
///
/// Gets or sets the active sheet.
///
/// The sheet to set as active.
/// the active sheet.
///
},
sheets: function() {
///
///
/// Returns an array with the sheets in the workbook.
///
/// the available sheets.
///
},
fromFile: function(blob) {
///
///
/// Clears the spreadsheets and populates it with data from the specified Excel (.xlsx) file.
///
/// The file or blob, usually obtained through a file input.
/// a promise that will be resolved when the import operation completes.
///
},
saveAsExcel: function() {
///
///
/// Initiates the Excel export. Also fires the excelExport event.
///
///
},
saveAsPDF: function() {
///
///
/// Initiates the PDF export. Also fires the pdfExport event.
///
/// A promise that will be resolved when the export completes. The same promise is available in the pdfExport event arguments.
///
},
sheetByName: function(name) {
///
///
/// Returns a sheet matching the specified name, if any.
///
/// The name of the sheet to locate.
/// the sheet that match the name.
///
},
sheetIndex: function(sheet) {
///
///
/// Returns the index of the specified sheet.
///
/// The sheet to determine the index of.
/// the sheet index.
///
},
sheetByIndex: function(index) {
///
///
/// Locates a sheet by its index in the workbook.
///
/// The index of the sheet to locate.
/// the sheet that match the index.
///
},
insertSheet: function(options) {
///
///
/// Inserts a sheet with the specified options.
///
/// The configuration options for the sheet.
/// the inserted sheet.
///
},
moveSheetToIndex: function(sheet,index) {
///
///
/// Moves the sheet to the specified index.
///
/// The sheet instance to move.
/// The new zero-based index of the sheet.
///
},
removeSheet: function(sheet) {
///
///
/// Removes the specified sheet.
///
/// The sheet instance to remove.
///
},
renameSheet: function(sheet,newSheetName) {
///
///
/// Renames the specified sheet.
///
/// The sheet instance to rename.
/// The new name of the sheet.
/// the renamed sheet.
///
},
toJSON: function() {
///
///
/// Serializes the workbook in the format defined in the configuration.
///
/// the serialized workbook.
///
},
fromJSON: function(data) {
///
///
/// Loads the workbook data from an object with the format defined in the configuration.
///
/// The object to load data from. This should be the deserialized object, not the JSON string.
///
},
defineName: function(name,value,hidden) {
///
///
/// Define a custom name to be available and used in formulas. If the function is not able to parse the name of the value, it will throw an error.
///
/// A new name to be defined. The names are case-insensitive.It is possible to provide a name that already exists. In such cases, the value is silently updated.To make the name available only in one sheet, qualify it in the way demonstrated in the next example.
/// The value has to be a valid formula in the form of a string, that is, without a leading = sign.Generally, a name points to a reference. For maximum compatibility, it is recommended for you to use references here that are fully qualified (include the name of the sheet they refer to) and absolute (prefix both row and column with the $ sign).
/// To hide this name from the custom names dropdown in the toolbar, pass true. Even if hidden is set to false, only reference names will be displayed in the dropdown.
///
},
undefineName: function(name) {
///
///
/// Delete a name.
///
/// To delete a fully qualified name, prefix the name of the sheet - for example, spreadsheet.undefineName("Sheet1!Foo").
///
},
bind: function(event, callback) {
///
///
/// Binds to a widget event.
///
/// The event name
/// The callback to be executed when the event is triggered.
///
},
unbind: function(event, callback) {
///
///
/// Unbinds a callback from a widget event.
///
/// The event name
/// The callback to be removed.
///
}
});
return instance;
};
intellisense.redirectDefinition(wrapper, original);
return wrapper;
})();
jQuery.fn.kendoSpreadsheet = function() {
this.data("kendoSpreadsheet", new kendo.ui.Spreadsheet());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoSpreadsheet: function() {
///
///
/// Returns a reference to the kendo.ui.Spreadsheet widget, instantiated on the selector.
///
/// The kendo.ui.Spreadsheet instance (if present).
///
},
kendoSpreadsheet: function(options) {
///
///
/// Instantiates a kendo.ui.Spreadsheet widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
activeSheet - String
///
The name of the currently active sheet.Must match one of the (sheet names)[#configuration-sheets.name] exactly.
///
///
columnWidth - Number (default: 64)
///
The default column width in pixels.
///
///
columns - Number (default: 50)
///
The number of columns in the document.
///
///
headerHeight - Number (default: 20)
///
The height of the header row in pixels.
///
///
headerWidth - Number (default: 32)
///
The width of the header column in pixels.
///
///
excel - Object
///
Configures the Kendo UI Spreadsheet Excel export settings.
///
///
pdf - Object
///
Configures the Kendo UI Spreadsheet PDF export settings.
///
///
rowHeight - Number (default: 20)
///
The default row height in pixels.
///
///
rows - Number (default: 200)
///
The number of rows in the document.
///
///
sheets - Array
///
An array defining the document sheets and their content.
///
///
sheetsbar - Boolean (default: true)
///
A boolean value indicating if the sheetsbar should be displayed.
///
///
toolbar - Boolean (default: true)
///
A boolean value indicating if the toolbar should be displayed.
///
///
toolbar - Object (default: true)
///
A boolean value indicating if the toolbar should be displayed.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.ui, {
TabStrip: function() {
///
/// Constructor of kendo.ui.TabStrip
///
}
});
kendo.ui.TabStrip = (function() {
var original = kendo.ui.TabStrip;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
activateTab: function(item) {
///
///
/// Activates a tab specified as a selector. Note: Invoking this method will not trigger any events.
///
/// The target tab, specified as a selector, to be activated.
///
},
append: function(tab) {
///
///
/// Appends a tab to the collection of tabs in a TabStrip.
///
/// Target tab, specified as a JSON object. You can pass tab text, content or contentUrl here. Can handle an HTML string or array of such strings or JSON.
/// Returns the TabStrip object to support chaining.
///
},
contentElement: function(itemIndex) {
///
///
/// Obtains the DOM element that encloses tab content by its tab index in the TabStrip.
///
/// The index of the tab in the TabStrip.
/// The DOM element enclosing tab content by its tab index in the TabStrip.
///
},
contentHolder: function(itemIndex) {
///
///
/// Obtains the DOM element that holds tab content by its tab index in the TabStrip.
/// The difference between contentElement and contentHolder is that contentHolder returns the DOM element that really holds the content, which on mobile is the scroll container.
///
/// The index of the tab in the TabStrip.
/// The DOM element holding tab content by its tab index in the TabStrip.
///
},
deactivateTab: function(item) {
///
///
/// Deactivates a tab specified as a selector. Note: Invoking this method will not trigger any events.
///
/// The target tab, specified as a selector, to be deactivated.
///
},
destroy: function() {
///
///
/// Prepares the TabStrip for safe removal from DOM. Detaches all event handlers and removes jQuery.data attributes to avoid memory leaks. Calls destroy method of any child Kendo widgets.
///
///
},
disable: function(element) {
///
///
/// Disables a tab(s) of a TabStrip.
///
/// The target tab(s), specified as a selector, to be disabled.
/// Returns the TabStrip object to support chaining.
///
},
enable: function(element,enable) {
///
///
/// Disables (false) or enables (true) a tab(s) of a TabStrip.
///
/// The target tab(s), specified as a selector, to be enabled (true) or disabled (false).
/// Desired state of the tab(s) specified by the selector; enabled (true) or disabled (false).
/// Returns the TabStrip object to support chaining.
///
},
insertAfter: function(item,referenceTab) {
///
///
/// Inserts a newly-created tab after a specified tab.
///
/// Target tab(s), specified as a JSON object or array of objects. You can pass tab text, content or contentUrl here. Accepts also existing tab(s) specified as a string selector or jQuery object or DOM elements.
/// A reference tab to insert the new item after.
/// Returns the TabStrip object to support chaining.
///
},
insertBefore: function(item,referenceTab) {
///
///
/// Inserts a newly-created tab before a specified tab.
///
/// Target tab(s), specified as a JSON object or array of objects. You can pass tab text, content or contentUrl here. Accepts also existing tab(s) specified as a string selector or jQuery object or DOM elements.
/// A reference tab to insert the new item before
/// Returns the TabStrip object to support chaining.
///
},
items: function() {
///
///
/// Gets the list of DOM elements that represent the tabs.
///
/// the tabs as an HTML collection of elements.
///
},
reload: function(element) {
///
///
/// Reloads TabStrip tab(s) via AJAX.
///
/// The target tab(s), specified as a selector or jQuery object, to be reloaded via AJAX.
/// Returns the TabStrip object to support chaining.
///
},
remove: function(element) {
///
///
/// Removes a specified tab from a TabStrip.
///
/// The target tab(s) to be removed, specified as a string selector, a jQuery object, or a zero-based item index.
/// Returns the TabStrip object to support chaining.
///
},
select: function(element) {
///
///
/// Get/set the selected tab. If called without arguments, it returns the
/// currently selected tab.
///
/// The target tab(s), specified as a selector, jQuery object or index in the tab group.
/// the selected tab if called without arguments. kendo.ui.TabStrip if called with arguments.
///
},
setDataSource: function(dataSource) {
///
///
/// Sets the dataSource of an existing tabstrip and rebinds it.
///
///
///
},
bind: function(event, callback) {
///
///
/// Binds to a widget event.
///
/// The event name
/// The callback to be executed when the event is triggered.
///
},
unbind: function(event, callback) {
///
///
/// Unbinds a callback from a widget event.
///
/// The event name
/// The callback to be removed.
///
}
});
return instance;
};
intellisense.redirectDefinition(wrapper, original);
return wrapper;
})();
jQuery.fn.kendoTabStrip = function() {
this.data("kendoTabStrip", new kendo.ui.TabStrip());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoTabStrip: function() {
///
///
/// Returns a reference to the kendo.ui.TabStrip widget, instantiated on the selector.
///
/// The kendo.ui.TabStrip instance (if present).
///
},
kendoTabStrip: function(options) {
///
///
/// Instantiates a kendo.ui.TabStrip widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
animation - Boolean
///
A collection of visual animations used when TabStrip tab are selected through user interactions. Setting this option to false will disable all animations. is not a valid configuration.
///
///
animation - Object
///
A collection of visual animations used when TabStrip tab are selected through user interactions. Setting this option to false will disable all animations. is not a valid configuration.
///
///
collapsible - Boolean (default: false)
///
Specifies whether the TabStrip should be able to collapse completely when clicking an expanded tab.
///
///
contentUrls - Array
///
Sets an array with the URLs from which the tabs content to be loaded from. If only specific tabs should be loaded via Ajax, then you should set the URLs to the corresponding positions in the array and set the other elements to null.
///
///
dataContentField - String (default: "")
///
Sets the field of the data item that provides the text content of the tab content element.
///
///
dataContentUrlField - String (default: "")
///
Sets the field of the data item that provides the URL for the Ajax loaded tab content.
///
///
dataImageUrlField - String (default: "")
///
Sets the field of the data item that provides the image URL of the tab.
///
///
dataSource - Object|Array|kendo.data.DataSource
///
The data source of the widget which is used to display the items. Can be a JavaScript object which represents a valid data source configuration, a JavaScript array or an existing kendo.data.DataSource
///
instance.If the dataSource option is set to a JavaScript object or array the widget will initialize a new kendo.data.DataSource instance using that value as data source configuration.If the dataSource option is an existing kendo.data.DataSource instance the widget will use that instance and will not initialize a new one.
///
///
dataSpriteCssClass - String (default: "")
///
Sets the field of the data item that provides the CSS class of the tab.
///
///
dataTextField - String (default: "")
///
Sets the field of the data item that provides the text name of the tab.
///
///
dataUrlField - String (default: "")
///
Sets the field of the data item that provides the link URL for the tab.
///
///
navigatable - Boolean (default: true)
///
Specifies whether the TabStrip should be keyboard navigatable.
///
///
scrollable - Boolean
///
If enabled, the TabStrip will display buttons that will scroll the tabs horizontally, when they cannot fit the TabStrip width. By default scrolling is enabled.The feature requires "top" or "bottom" tabPosition.Unless disabled, scrollable must be set to a JavaScript object, which represents the scrolling configuration.See Scrollable Tabs for more information.
///
///
scrollable - Object
///
If enabled, the TabStrip will display buttons that will scroll the tabs horizontally, when they cannot fit the TabStrip width. By default scrolling is enabled.The feature requires "top" or "bottom" tabPosition.Unless disabled, scrollable must be set to a JavaScript object, which represents the scrolling configuration.See Scrollable Tabs for more information.
///
///
tabPosition - String (default: "top")
///
Specifies the position of the widget tabs. Valid values are "top" (default), "left", "right" and "bottom".
///
A fade animation is highly recommended with any of the non-default tab position settings.
///
///
value - String (default: null)
///
Specifies the selected tab. Should be corresponding to the dataTextField configuration and used when bound to a DataSource component.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.ui, {
TimePicker: function() {
///
/// Constructor of kendo.ui.TimePicker
///
}
});
kendo.ui.TimePicker = (function() {
var original = kendo.ui.TimePicker;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
close: function() {
///
///
/// Closes the drop-down list of a TimePicker.
///
///
},
destroy: function() {
///
///
/// Prepares the TimePicker for safe removal from DOM. Detaches all event handlers and removes jQuery.data attributes to avoid memory leaks. Calls destroy method of any child Kendo widgets.
///
///
},
enable: function(enable) {
///
///
/// Enables or disables a TimePicker.
///
/// Enables (true or undefined) or disables (false) a TimePicker.
///
},
readonly: function(readonly) {
///
///
/// Toggles the readonly state of the widget. When the widget is readonly it doesn't allow user input.
///
/// The argument, which defines whether the TimePicker should be readonly or editable.
///
},
max: function(value) {
///
///
/// Gets or sets the maximum value of the TimePicker.
///
/// The maximum time value to set for a TimePicker, expressed as a Date object or as a string.
/// The maximum time value of a TimePicker.
///
},
min: function(value) {
///
///
/// Gets or sets the minimum value of the TimePicker.
///
/// The minimum time value to set for a TimePicker, expressed as a Date object or as a string.
/// The minimum time value of a TimePicker.
///
},
open: function() {
///
///
/// Opens the drop-down list of a TimePicker.
///
///
},
setOptions: function(options) {
///
///
/// Changes the initial TimePicker configuration. Will be included in Q3 2013 SP1. Currently available in Q3 2013 internal builds only.
///
/// The new configuration options.
///
},
value: function(value) {
///
///
/// Gets or sets the value of the TimePicker.
///
/// The time value to set for a TimePicker, expressed as a Date object or as a string.
/// The time value of a TimePicker.
///
},
bind: function(event, callback) {
///
///
/// Binds to a widget event.
///
/// The event name
/// The callback to be executed when the event is triggered.
///
},
unbind: function(event, callback) {
///
///
/// Unbinds a callback from a widget event.
///
/// The event name
/// The callback to be removed.
///
}
});
return instance;
};
intellisense.redirectDefinition(wrapper, original);
return wrapper;
})();
jQuery.fn.kendoTimePicker = function() {
this.data("kendoTimePicker", new kendo.ui.TimePicker());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoTimePicker: function() {
///
///
/// Returns a reference to the kendo.ui.TimePicker widget, instantiated on the selector.
///
/// The kendo.ui.TimePicker instance (if present).
///
},
kendoTimePicker: function(options) {
///
///
/// Instantiates a kendo.ui.TimePicker widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
animation - Boolean
///
Configures the opening and closing animations of the popup. Setting the animation option to false will disable the opening and closing animations. As a result the popup will open and close instantly. is not a valid configuration.
///
///
animation - Object
///
Configures the opening and closing animations of the popup. Setting the animation option to false will disable the opening and closing animations. As a result the popup will open and close instantly. is not a valid configuration.
///
///
culture - String (default: "en-US")
///
Specifies the culture info used by the widget.
///
///
dates - Array
///
Specifies a list of dates, which are shown in the time drop-down list. If not set, the TimePicker will auto-generate the available times.
///
///
format - String (default: "h:mm tt")
///
Specifies the format, which is used to format the value of the TimePicker displayed in the input. The format also will be used to parse the input.
///
///
interval - Number (default: "30")
///
Specifies the interval, between values in the popup list, in minutes.
///
///
max - Date (default: "00:00")
///
Specifies the end value in the popup list.
///
///
min - Date (default: "00:00")
///
Specifies the start value in the popup list.
///
///
parseFormats - Array
///
Specifies the formats, which are used to parse the value set with the value method or by direct input. If not set the value of the options.format will be used. Note that value of the format option is always used.
///
///
value - Date (default: null)
///
Specifies the selected time.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.ui, {
ToolBar: function() {
///
/// Constructor of kendo.ui.ToolBar
///
}
});
kendo.ui.ToolBar = (function() {
var original = kendo.ui.ToolBar;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
add: function(command) {
///
///
/// Adds new command to the ToolBar widget. Accepts object with valid command configuration options.
///
/// An object with valid command configuration options.
///
},
destroy: function() {
///
///
/// Prepares the widget for safe removal from DOM. Detaches all event handlers and removes jQuery.data attributes to avoid memory leaks. Calls destroy method of any child Kendo widgets.
///
///
},
enable: function(command,enable) {
///
///
/// Enables or disables the specified command. If the second parameter is omitted it will be treated as true and the command will be enabled.
///
/// A string, DOM element or jQuery object which represents the command to be enabled or disabled. A string is treated as jQuery selector.
/// A boolean flag that determines whether the command should be enabled (true) or disabled (false). If omitted the command will be enabled.
///
},
getSelectedFromGroup: function(groupName) {
///
///
/// Returns the selected toggle button from the specified group.
///
/// The name of the group.
///
},
hide: function(command) {
///
///
/// Hides a command from the ToolBar widget. The command is hidden from the ToolBar container and overflow popup (if resizable is enabled).
///
/// A string, DOM element or jQuery object which represents the command to be hidden. A string is treated as jQuery selector.
///
},
remove: function(command) {
///
///
/// Removes a command from the ToolBar widget. The command is removed from the ToolBar container and overflow popup (if resizable is enabled).
///
/// A string, DOM element or jQuery object which represents the command to be removed. A string is treated as jQuery selector.
///
},
show: function(command) {
///
///
/// Shows a hidden command in the ToolBar widget. The command is shown in the ToolBar container and overflow popup (if resizable is enabled).
///
/// A string, DOM element or jQuery object which represents the command to be shown. A string is treated as jQuery selector.
///
},
toggle: function(command,state) {
///
///
/// Change the state of a togglable button.
///
/// A string, DOM element or jQuery object which represents the togglable button which state will be changed. A string is treated as jQuery selector.
/// A boolean flag that determines whether the button will be toggled or not.
///
},
bind: function(event, callback) {
///
///
/// Binds to a widget event.
///
/// The event name
/// The callback to be executed when the event is triggered.
///
},
unbind: function(event, callback) {
///
///
/// Unbinds a callback from a widget event.
///
/// The event name
/// The callback to be removed.
///
}
});
return instance;
};
intellisense.redirectDefinition(wrapper, original);
return wrapper;
})();
jQuery.fn.kendoToolBar = function() {
this.data("kendoToolBar", new kendo.ui.ToolBar());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoToolBar: function() {
///
///
/// Returns a reference to the kendo.ui.ToolBar widget, instantiated on the selector.
///
/// The kendo.ui.ToolBar instance (if present).
///
},
kendoToolBar: function(options) {
///
///
/// Instantiates a kendo.ui.ToolBar widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
resizable - Boolean (default: true)
///
If resizable is set to true the widget will detect changes in the viewport width and hides the overflowing controls in the command overflow popup.
///
///
items - Array
///
A JavaScript array that contains the ToolBar's commands configuration.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.ui, {
Tooltip: function() {
///
/// Constructor of kendo.ui.Tooltip
///
}
});
kendo.ui.Tooltip = (function() {
var original = kendo.ui.Tooltip;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
show: function(element) {
///
///
/// Shows the Tooltip for given target.
///
/// The target element for which the Tooltip should be shown.
///
},
hide: function() {
///
///
/// Hides the Tooltip.
///
///
},
refresh: function() {
///
///
/// Refresh the Tooltip content.
///
///
},
target: function() {
///
///
/// Gets the Tooltip current target.
///
/// The target element or null.
///
},
bind: function(event, callback) {
///
///
/// Binds to a widget event.
///
/// The event name
/// The callback to be executed when the event is triggered.
///
},
unbind: function(event, callback) {
///
///
/// Unbinds a callback from a widget event.
///
/// The event name
/// The callback to be removed.
///
}
});
return instance;
};
intellisense.redirectDefinition(wrapper, original);
return wrapper;
})();
jQuery.fn.kendoTooltip = function() {
this.data("kendoTooltip", new kendo.ui.Tooltip());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoTooltip: function() {
///
///
/// Returns a reference to the kendo.ui.Tooltip widget, instantiated on the selector.
///
/// The kendo.ui.Tooltip instance (if present).
///
},
kendoTooltip: function(options) {
///
///
/// Instantiates a kendo.ui.Tooltip widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
autoHide - Boolean (default: true)
///
Specifies if the Tooltip will be hidden when mouse leaves the target element. If set to false a close button will be shown within Tooltip. If set to false, showAfter is specified and the showOn is set to "mouseenter" the Tooltip will be displayed after the given timeout even if the element is no longer hovered.
///
///
animation - Boolean
///
A collection of {Animation} objects, used to change default animations. A value of false will disable all animations in the widget. is not a valid configuration.
///
///
animation - Object
///
A collection of {Animation} objects, used to change default animations. A value of false will disable all animations in the widget. is not a valid configuration.
///
///
content - String|Function
///
The text or a function which result will be shown within the Tooltip.
///
By default the Tooltip will display the target element title attribute content.
///
///
content - Object
///
The text or a function which result will be shown within the Tooltip.
///
By default the Tooltip will display the target element title attribute content.
///
///
callout - Boolean (default: true)
///
Specifies if the Tooltip callout will be displayed.
///
///
filter - String
///
Specifies a selector for elements, within the container, for which the Tooltip will be displayed.
///
///
iframe - Boolean
///
Explicitly states whether content iframe should be created.
///
///
height - Number (default: Infinity)
///
The height (in pixels) of the Tooltip.
///
///
width - Number (default: Infinity)
///
The width (in pixels) of the Tooltip.
///
///
position - String (default: "bottom")
///
The position relative to the target element, at which the Tooltip will be shown. Predefined values are "bottom", "top", "left", "right", "center".
///
///
showAfter - Number (default: 100)
///
Specify the delay in milliseconds before the Tooltip is shown. This option is ignored if showOn is set to "click" or "focus".
///
///
showOn - String (default: "mouseenter")
///
The event on which the Tooltip will be shown. Predefined values are "mouseenter", "click" and "focus".
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.ui, {
TreeList: function() {
///
/// Constructor of kendo.ui.TreeList
///
}
});
kendo.ui.TreeList = (function() {
var original = kendo.ui.TreeList;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
addRow: function(parentRow) {
///
///
/// Adds an empty data item to the treelist. In "inline" editing mode a table row will be appended. A popup window will be displayed in "popup" editing mode.Fires the edit event.
///
/// A string, DOM element or jQuery object which represents the parent table row. A string is treated as a jQuery selector.
///
},
autoFitColumn: function(column) {
///
///
/// Applies the minimum possible width for the specified column, so that all text fits without wrapping.
///
/// The index of the column, or the field to which the columns is bound, or the column object obtained from the columns collection.
///
},
cancelRow: function() {
///
///
/// Cancels editing for the table row which is in edit mode. Reverts any changes made.
///
///
},
clearSelection: function() {
///
///
/// Clears the currently selected table rows or cells (depending on the current selection mode).
///
///
},
collapse: function() {
///
///
/// This method collapse the row.
///
///
},
dataItem: function(row) {
///
///
/// Returns the data item to which the specified table row is bound.
///
/// A string, DOM element or jQuery object which represents the table row. A string is treated as a jQuery selector.
/// the data item to which the specified table row is bound.
///
},
destroy: function() {
///
///
/// Prepares the widget for safe removal from DOM. Detaches all event handlers and removes jQuery.data attributes to avoid memory leaks. Calls the destroy method of any child Kendo widgets.
///
///
},
editRow: function(row) {
///
///
/// Switches the specified table row to edit mode.Fires the edit event.
///
/// The jQuery object which represents the table row.
///
},
expand: function(row) {
///
///
/// This method expands the row.
///
/// A string, DOM element or jQuery object which represents the table row. A string is treated as a jQuery selector.
///
///
},
itemFor: function(model) {
///
///
/// Returns the rendered HTML element for a given model.
///
/// A model from the DataSource, or the id of a model in the DataSource.
/// the row that corresponds to the model
///
},
items: function() {
///
///
/// Obtains an Array of the DOM elements, which correspond to the data items from the Kendo UI DataSource view.
///
/// The currently rendered data table rows ( elements).
///
},
refresh: function() {
///
///
/// Renders all table rows using the current data items.
///
///
},
removeRow: function(row) {
///
///
/// Removes the specified table row from the treelist. Also removes the corresponding data item from the data source.Fires the remove event.
///
/// A string, DOM element or jQuery object which represents the table row. A string is treated as a jQuery selector.
///
},
saveAsExcel: function() {
///
///
/// Initiates the Excel export. Also fires the excelExport event.
///
///
},
saveAsPDF: function() {
///
///
/// Initiates the PDF export and returns a promise. Also triggers the pdfExport event.
///
/// A promise that will be resolved when the export completes. The same promise is available in the pdfExport event arguments.
///
},
saveRow: function() {
///
///
/// Switches the table row which is in edit mode and saves any changes made by the user.Fires the edit event.
///
///
},
select: function(rows) {
///
///
/// Gets or sets the table rows (or cells) which are selected.
///
/// A string, DOM element or jQuery object which represents the table row(s) or cell(s). A string is treated as a jQuery selector.
/// the selected table rows or cells.
///
},
setDataSource: function(dataSource) {
///
///
/// Sets the data source of the widget.
///
/// The data source to which the widget should be bound.
///
},
showColumn: function(column) {
///
///
/// Shows the specified column.
///
/// The index of the column, or the field to which the columns is bound.
///
},
hideColumn: function(column) {
///
///
/// Hides the specified column.
///
/// The index of the column, or the field to which the columns is bound.
///
},
lockColumn: function(column) {
///
///
/// Locks (freezes) a column, allowing users to see it at all times when scrolling.
///
/// The index of the column or the field to which the columns is bound.
///
},
unlockColumn: function(column) {
///
///
/// Unlocks (unfreezes) a column.
///
/// The index of the column or the field to which the columns is bound.
///
},
reorderColumn: function(destIndex,column) {
///
///
/// Changes the position of the specified column.
///
/// The new position of the column. The destination index should be calculated with regard to all columns, including the hidden ones.
/// The column whose position should be changed.
///
},
bind: function(event, callback) {
///
///
/// Binds to a widget event.
///
/// The event name
/// The callback to be executed when the event is triggered.
///
},
unbind: function(event, callback) {
///
///
/// Unbinds a callback from a widget event.
///
/// The event name
/// The callback to be removed.
///
}
});
return instance;
};
intellisense.redirectDefinition(wrapper, original);
return wrapper;
})();
jQuery.fn.kendoTreeList = function() {
this.data("kendoTreeList", new kendo.ui.TreeList());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoTreeList: function() {
///
///
/// Returns a reference to the kendo.ui.TreeList widget, instantiated on the selector.
///
/// The kendo.ui.TreeList instance (if present).
///
},
kendoTreeList: function(options) {
///
///
/// Instantiates a kendo.ui.TreeList widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
autoBind - Boolean (default: true)
///
If set to false the widget will not bind to the data source during initialization. In this case data binding will occur when the change event of the
///
data source is fired. By default the widget will bind to the data source specified in the configuration.
///
///
columns - Array
///
The configuration of the treelist columns. An array of JavaScript objects or strings. JavaScript objects are interpreted as column configurations. Strings are interpreted as the
///
field to which the column is bound. The treelist will create a column for every item of the array.
///
///
resizable - Boolean (default: false)
///
If set to true allows users to resize columns by dragging their header borders. By default resizing is disabled.
///
///
reorderable - Boolean (default: false)
///
If set to true the user could reorder the columns by dragging their header cells. By default reordering is disabled.
///
///
columnMenu - Boolean (default: false)
///
If set to true the treelist will display the column menu when the user clicks the chevron icon in the column headers. The column menu allows the user to show and hide columns, filter and sort (if filtering and sorting are enabled).
///
By default the column menu is not enabled.Can be set to a JavaScript object which represents the column menu configuration.
///
///
columnMenu - Object (default: false)
///
If set to true the treelist will display the column menu when the user clicks the chevron icon in the column headers. The column menu allows the user to show and hide columns, filter and sort (if filtering and sorting are enabled).
///
By default the column menu is not enabled.Can be set to a JavaScript object which represents the column menu configuration.
///
///
dataSource - Object|Array|kendo.data.TreeListDataSource
///
The data source of the widget which is used to render table rows. Can be a JavaScript object which represents a valid data source configuration, a JavaScript array or an existing kendo.data.DataSource
///
instance.If the dataSource option is set to a JavaScript object or array the widget will initialize a new kendo.data.DataSource instance using that value as data source configuration.If the dataSource option is an existing kendo.data.DataSource instance, the widget will use that instance and will not initialize a new one.
///
///
editable - Boolean (default: false)
///
If set to true the user would be able to edit the data to which the treelist is bound. By default editing is disabled.Can be set to a string ("inline" or "popup") to specify the editing mode. The default editing mode is "inline".Can be set to a JavaScript object which represents the editing configuration.
///
///
editable - Object (default: false)
///
If set to true the user would be able to edit the data to which the treelist is bound. By default editing is disabled.Can be set to a string ("inline" or "popup") to specify the editing mode. The default editing mode is "inline".Can be set to a JavaScript object which represents the editing configuration.
///
///
excel - Object
///
Configures the Kendo UI TreeList Excel export settings.
///
///
filterable - Boolean (default: false)
///
If set to true the user can filter the data source using the treelist filter menu. Filtering is disabled by default.Can be set to a JavaScript object which represents the filter menu configuration.
///
///
filterable - Object (default: false)
///
If set to true the user can filter the data source using the treelist filter menu. Filtering is disabled by default.Can be set to a JavaScript object which represents the filter menu configuration.
///
///
height - Number|String
///
The height of the treelist. Numeric values are treated as pixels.
///
///
messages - Object
///
Defines the text of the command buttons that are shown within the TreeList. Used primarily for localization.
///
///
pdf - Object
///
Configures the Kendo UI TreeList PDF export settings.
///
///
scrollable - Boolean|Object (default: true)
///
If set to true the TreeList will display a scrollbar when the total row height (or width) exceeds the TreeList height (or width). By default scrolling is enabled.Scrolling renders separate tables for the header and data area. For accessibility-conscious applications, disable scrolling.
///
///
selectable - Boolean|String (default: false)
///
If set to true the user would be able to select treelist rows. By default selection is disabled.Can also be set to the following string values:
///
///
sortable - Boolean (default: false)
///
If set to true the user could sort the treelist by clicking the column header cells. By default sorting is disabled.Can be set to a JavaScript object which represents the sorting configuration.
///
///
sortable - Object (default: false)
///
If set to true the user could sort the treelist by clicking the column header cells. By default sorting is disabled.Can be set to a JavaScript object which represents the sorting configuration.
///
///
toolbar - String|Function
///
If a String value is assigned to the toolbar configuration option, it will be treated as a single string template for the whole treelist Toolbar,
///
and the string value will be passed as an argument to a kendo.template() function.If a Function value is assigned (it may be a kendo.template() function call or a generic function reference), then the return value of the function will be used to render the treelist Toolbar contents.If an Array value is assigned, it will be treated as the list of commands displayed in the treelist Toolbar. Commands can be custom or built-in ("create", "excel", "pdf").
///
///
toolbar - Array
///
If a String value is assigned to the toolbar configuration option, it will be treated as a single string template for the whole treelist Toolbar,
///
and the string value will be passed as an argument to a kendo.template() function.If a Function value is assigned (it may be a kendo.template() function call or a generic function reference), then the return value of the function will be used to render the treelist Toolbar contents.If an Array value is assigned, it will be treated as the list of commands displayed in the treelist Toolbar. Commands can be custom or built-in ("create", "excel", "pdf").
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.ui, {
TreeView: function() {
///
/// Constructor of kendo.ui.TreeView
///
}
});
kendo.ui.TreeView = (function() {
var original = kendo.ui.TreeView;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
append: function(nodeData,parentNode,success) {
///
///
/// Appends a node to any level of the TreeView . This method may also be used to reorder nodes.
///
/// A JSON-formatted string or selector that specifies the node to be appended. If the argument is a plain JavaScript object, a new item will be created. If the argument is a jQuery element that holds a node, the TreeView node will be moved. If the argument is an array of objects, each item of the array will be appended.
/// The node that will contain the newly appended node. If not specified, the new node will be appended to the root group of the TreeView.
/// A success callback that will be called once the new node has been appended. Useful in the case of remote binding where an item is appended to an unfetched node. The callback is called once the siblings have been fetched.
/// The inserted element, wrapped in a jQuery object,or null if the new model has not been inserted immediately.
///
},
collapse: function(nodes) {
///
///
/// Collapses nodes.
///
/// The nodes that will be collapsed.
///
},
dataItem: function(node) {
///
///
/// Returns the data item to which the specified node is bound.
///
/// A string, DOM element or jQuery object which represents the node. A string is treated as a jQuery selector.
/// The model of the item that was passed as a parameter.
///
},
destroy: function() {
///
///
/// Prepares the widget for safe removal from DOM. Detaches all event handlers and removes jQuery.data attributes to avoid memory leaks. Calls destroy method of any child Kendo widgets.
///
///
},
detach: function(node) {
///
///
/// Removes a node from a TreeView, but keeps its jQuery.data() objects.
///
/// The node that is to be detached.
/// The node that has been detached.
///
},
enable: function(nodes,enable) {
///
///
/// Enables or disables nodes.
///
/// The nodes that are to be enabled/disabled.
/// Whether the nodes should be enabled or disabled.
///
},
expand: function(nodes) {
///
///
/// Expands collapsed nodes.
///
/// The nodes that are to be expanded.
///
},
expandPath: function(path,complete) {
///
///
/// Expands all nodes to a given element. Nodes may be loaded from a remote end-point.
///
/// The IDs of the nodes that need to be expanded.
/// Callback function that will be called once the path has been expanded.
///
},
expandTo: function(targetNode) {
///
///
/// Expands all nodes up to a given element. The element needs to be already loaded.
///
/// The dataItem of the node up to which to expand. Can also be the node ID
///
},
findByText: function(text) {
///
///
/// Searches for a node that has specific text.
///
/// The text that is being searched for.
/// All nodes that have the text.
///
},
findByUid: function(text) {
///
///
/// Searches for a node with the given unique identifier.
/// Applicable when the widget is bound to a HierarchicalDataSource.
/// If you want to find a node by its id, use the dataSource.get() method and supply its uid to the findByUid method.
///
/// The text that is being searched for.
/// All nodes that have the text.
///
},
insertAfter: function(nodeData,referenceNode) {
///
///
/// Inserts a node after a specified node.
/// This method may also be used to reorder nodes.
///
/// A JSON-formatted string or selector that specifies the node to be inserted.
/// The node that will precede the newly-appended node.
///
},
insertBefore: function(nodeData,referenceNode) {
///
///
/// Inserts a node before another node. This method may also be used to reorder nodes.
///
/// A JSON-formatted string or selector that specifies the node to be inserted.
/// The node that follows the inserted node.
///
},
items: function() {
///
///
/// Obtains an Array of the DOM elements, which correspond to the data items from the Kendo UI DataSource view.
///
/// The currently rendered tree items ( elements, that are children of the
elements).
///
},
parent: function(node) {
///
///
/// Gets the parent node of the item
///
/// The child node whose parent will be returned.
/// The parent node of the given parameter node.
///
},
remove: function(node) {
///
///
/// Removes a node from the widget.
///
/// The node that is to be removed.
///
},
select: function(node) {
///
///
/// Gets or sets the selected node.
///
/// If provided, the node that should be selected.
/// The currently selected node.
///
},
setDataSource: function(dataSource) {
///
///
/// Sets and binds a dataSource to the widget.
///
/// The new dataSource that the widget will bind to
///
},
text: function(node,newText) {
///
///
/// Gets or sets the text of a node in a TreeView.
///
/// The node of which the text is being retrieved or set.
/// Optional. When passed, sets the node text to the specified string
/// The text of a node.
///
},
toggle: function(node) {
///
///
/// Toggles the node of a TreeView between its expanded and collapsed states.
///
/// The node that should be toggled.
///
},
updateIndeterminate: function(node) {
///
///
/// Updates the indeterminate state of the TreeView checkboxes.
/// Call it after using the insert / remove API on TreeViews with checkChildren: true.
/// Use to improve performance when checking multiple checkboxes through code.
///
/// Optional. The root of the hierarchy that will be looped through. Allows only a subtree to be processed. The default value is the TreeView root.
///
},
bind: function(event, callback) {
///
///
/// Binds to a widget event.
///
/// The event name
/// The callback to be executed when the event is triggered.
///
},
unbind: function(event, callback) {
///
///
/// Unbinds a callback from a widget event.
///
/// The event name
/// The callback to be removed.
///
}
});
return instance;
};
intellisense.redirectDefinition(wrapper, original);
return wrapper;
})();
jQuery.fn.kendoTreeView = function() {
this.data("kendoTreeView", new kendo.ui.TreeView());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoTreeView: function() {
///
///
/// Returns a reference to the kendo.ui.TreeView widget, instantiated on the selector.
///
/// The kendo.ui.TreeView instance (if present).
///
},
kendoTreeView: function(options) {
///
///
/// Instantiates a kendo.ui.TreeView widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
animation - Boolean
///
A collection of visual animations used when items are expanded or collapsed through user interaction.
///
Setting this option to false will disable all animations. is not a valid configuration.
///
///
animation - Object
///
A collection of visual animations used when items are expanded or collapsed through user interaction.
///
Setting this option to false will disable all animations. is not a valid configuration.
///
///
autoBind - Boolean (default: true)
///
If set to false the widget will not bind to the data source during initialization. In this case data binding will occur when the change event of the
///
data source is fired. By default the widget will bind to the data source specified in the configuration.
///
///
autoScroll - Boolean (default: false)
///
If set to true the widget will auto-scroll the containing element when the mouse/finger is close to the top/bottom of it.
///
///
checkboxes - Boolean
///
If true or an object, renders checkboxes beside each node.
///
///
checkboxes - Object
///
If true or an object, renders checkboxes beside each node.
///
///
dataImageUrlField - String (default: null)
///
Sets the field of the data item that provides the image URL of the TreeView nodes.
///
///
dataSource - Object|Array|kendo.data.HierarchicalDataSource
///
The data source of the widget which is used render nodes. Can be a JavaScript object which represents a valid data source configuration, a JavaScript array or an existing kendo.data.HierarchicalDataSource instance.If the dataSource option is set to a JavaScript object or array the widget will initialize a new kendo.data.HierarchicalDataSource instance using that value as data source configuration.If the dataSource option is an existing kendo.data.HierarchicalDataSource instance the widget will use that instance and will not initialize a new one.
///
///
dataSpriteCssClassField - String (default: null)
///
Sets the field of the data item that provides the sprite CSS class of the nodes.
///
If an array, each level uses the field that is at the same index in the array, or the last item in the array.
///
///
dataTextField - String|Array (default: null)
///
Sets the field of the data item that provides the text content of the nodes.
///
If an array, each level uses the field that is at the same index in the array, or the last item in the array.
///
///
dataUrlField - String (default: null)
///
Sets the field of the data item that provides the link URL of the nodes.
///
///
dragAndDrop - Boolean (default: false)
///
Disables (false) or enables (true) drag-and-drop of the nodes.
///
///
loadOnDemand - Boolean (default: true)
///
Indicates whether the child DataSources should be fetched lazily when parent groups get expanded.
///
Setting this to false causes all child DataSources to be loaded at initialization time.
///
///
messages - Object
///
The text messages displayed in the widget. Use it to customize or localize the messages.
///
///
template - String|Function
///
Template for rendering each node.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.ui, {
Upload: function() {
///
/// Constructor of kendo.ui.Upload
///
}
});
kendo.ui.Upload = (function() {
var original = kendo.ui.Upload;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
clearAllFiles: function() {
///
///
/// Removes all files (only visually from the UI) without issuing requests to the remove handler.
///
///
},
clearFile: function() {
///
///
/// Removes all files for which the callback function returns true (only visually from the UI) without issuing requests to the remove handler.
///
///
},
clearFileByUid: function() {
///
///
/// Removes a file by ID (only visually from the UI) without issuing requests to the remove handler.
///
///
},
destroy: function() {
///
///
/// Prepares the Upload for safe removal from DOM. Detaches all event handlers and removes jQuery.data attributes to avoid memory leaks. Calls destroy method of any child Kendo widgets.
///
///
},
disable: function() {
///
///
/// Disables the upload.
///
///
},
enable: function(enable) {
///
///
/// Enables the upload.
///
/// The argument, which defines whether to enable/disable the upload.
///
},
focus: function() {
///
///
/// Focuses the upload's input element.
///
///
},
getFiles: function() {
///
///
/// Retrieves the files that are currently selected.
///
/// a collection of all currently selected files.
///
},
removeAllFiles: function() {
///
///
/// Removes all files by sending a standard remove request to the handler.
///
///
},
removeFile: function() {
///
///
/// Removes all files for which the callback function returns true by sending a standard remove request to the handler.
///
///
},
removeFileByUid: function() {
///
///
/// Removes a file by ID by sending a standard remove request to the handler.
///
///
},
toggle: function(enable) {
///
///
/// Toggles the upload enabled state.
///
/// (Optional) The new enabled state.
///
},
upload: function() {
///
///
/// Manually triggers the upload process.
///
///
},
bind: function(event, callback) {
///
///
/// Binds to a widget event.
///
/// The event name
/// The callback to be executed when the event is triggered.
///
},
unbind: function(event, callback) {
///
///
/// Unbinds a callback from a widget event.
///
/// The event name
/// The callback to be removed.
///
}
});
return instance;
};
intellisense.redirectDefinition(wrapper, original);
return wrapper;
})();
jQuery.fn.kendoUpload = function() {
this.data("kendoUpload", new kendo.ui.Upload());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoUpload: function() {
///
///
/// Returns a reference to the kendo.ui.Upload widget, instantiated on the selector.
///
/// The kendo.ui.Upload instance (if present).
///
},
kendoUpload: function(options) {
///
///
/// Instantiates a kendo.ui.Upload widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
async - Object
///
Configures the ability to upload a file(s) in an asynchronous manner. Please refer to the
///
async mode help topic
///
for more details.
///
///
dropZone - String
///
Initializes a dropzone element(s) based on a given selector that provides drag and drop file upload.
///
///
enabled - Boolean (default: true)
///
Enables (true) or disables (false) an Upload. A disabled
///
Upload may be re-enabled via enable().
///
///
files - Array
///
List of files to be initially rendered in the Upload widget files list.
///
///
localization - Object
///
Sets the strings rendered by the Upload.
///
///
multiple - Boolean (default: true)
///
Enables (true) or disables (false) the ability to select multiple files.
///
If false, users will be able to select only one file at a time. Note: This option does not
///
limit the total number of uploaded files in an asynchronous configuration.
///
///
showFileList - Boolean (default: true)
///
Enables (true) or disables (false) the ability to display a file listing
///
for uploading a file(s). Disabling a file listing may be useful you wish to customize the UI; use the
///
client-side events to build your own UI.
///
///
template - String|Function
///
The template used to render the files in the list
///
///
validation - Object
///
Configures the validation options for uploaded files.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.ui, {
Validator: function() {
///
/// Constructor of kendo.ui.Validator
///
}
});
kendo.ui.Validator = (function() {
var original = kendo.ui.Validator;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
errors: function() {
///
///
/// Get the error messages if any.
///
/// Messages for the failed validation rules.
///
},
hideMessages: function() {
///
///
/// Hides the validation messages.
///
///
},
validate: function() {
///
///
/// Validates the input element(s) against the declared validation rules.
///
/// true if all validation rules passed successfully.Note that if a HTML form element is set as validation container, the form submits will be automatically prevented if validation fails.
///
},
validateInput: function(input) {
///
///
/// Validates the input element against the declared validation rules.
///
/// Input element to be validated.
/// true if all validation rules passed successfully.
///
},
bind: function(event, callback) {
///
///
/// Binds to a widget event.
///
/// The event name
/// The callback to be executed when the event is triggered.
///
},
unbind: function(event, callback) {
///
///
/// Unbinds a callback from a widget event.
///
/// The event name
/// The callback to be removed.
///
}
});
return instance;
};
intellisense.redirectDefinition(wrapper, original);
return wrapper;
})();
jQuery.fn.kendoValidator = function() {
this.data("kendoValidator", new kendo.ui.Validator());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoValidator: function() {
///
///
/// Returns a reference to the kendo.ui.Validator widget, instantiated on the selector.
///
/// The kendo.ui.Validator instance (if present).
///
},
kendoValidator: function(options) {
///
///
/// Instantiates a kendo.ui.Validator widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
errorTemplate - String
///
The template which renders the validation message.
///
///
messages - Object
///
Set of messages (either strings or functions) which will be shown when given validation rule fails.
///
By setting already existing key the appropriate built-in message will be overridden.
///
///
rules - Object
///
Set of custom validation rules. Those rules will extend the built-in ones.
///
///
validateOnBlur - Boolean
///
Determines if validation will be triggered when element loses focus. Default value is true.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.ui, {
Widget: function() {
///
/// Constructor of kendo.ui.Widget
///
}
});
kendo.ui.Widget = (function() {
var original = kendo.ui.Widget;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
bind: function() {
///
///
/// Attaches a handler to an event. Examples and more info can be found in the bind section of the kendo.Observable API reference.
///
///
},
destroy: function() {
///
///
/// Prepares the widget for safe removal from the DOM. Detaches all event handlers and removes jQuery.data attributes to avoid memory leaks. Calls destroy method of any child Kendo widgets.
///
///
},
one: function() {
///
///
/// Attaches a handler to an event. The handler is executed only once. Examples and more info can be found in the one section of the
/// kendo.Observable API reference.
///
///
},
resize: function() {
///
///
/// Readjusts the layout of the widget. For more information, refer to the article on responsive web design.
///
///
},
setOptions: function(newOptions) {
///
///
/// Allows changing the widget configuration after initialization. Depending on the widget, some properties may not be changed, and the method's implementation varies for each widget.
///
/// The options to be changed or added.
///
},
trigger: function() {
///
///
/// Executes all handlers attached to the given event. More info can be found in the trigger section of the
/// kendo.Observable API reference.
///
///
},
unbind: function() {
///
///
/// Remove a previously attached event handler. More info can be found in the unbind section of the
/// kendo.Observable API reference.
///
///
}
});
return instance;
};
intellisense.redirectDefinition(wrapper, original);
return wrapper;
})();
jQuery.fn.kendoWidget = function() {
this.data("kendoWidget", new kendo.ui.Widget());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoWidget: function() {
///
///
/// Returns a reference to the kendo.ui.Widget widget, instantiated on the selector.
///
/// The kendo.ui.Widget instance (if present).
///
},
kendoWidget: function(options) {
///
///
/// Instantiates a kendo.ui.Widget widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.ui, {
Window: function() {
///
/// Constructor of kendo.ui.Window
///
}
});
kendo.ui.Window = (function() {
var original = kendo.ui.Window;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
center: function() {
///
///
/// Centers the window within the viewport.If the Window has no set dimensions and is centered before its content is loaded with Ajax, it is probably going to resize after the content is loaded. This naturally changes the position of the widget on the screen and it is no longer centered. If this is a requirement, then either center the Window in its refresh event, or set some explicit dimensions.
///
/// Returns the window object to support chaining, for example center and open the Window with a single expression.
///
},
close: function() {
///
///
/// Closes a Window.
///
/// Returns the window object to support chaining.
///
},
content: function(content) {
///
///
/// Gets or set the content of a window. Supports chaining when used as a setter.
///
/// The content of the Window. Can be an HTML string or jQuery object.
/// The current window content, if used as a getter. If used as a setter, the method will return the window object to support chaining.
///
},
destroy: function() {
///
///
/// Destroys the window and its modal overlay, if necessary. Removes the widget HTML elements from the DOM.
///
///
},
isMaximized: function() {
///
///
/// Indicates whether the window is maximized.
///
///
///
},
isMinimized: function() {
///
///
/// Indicates whether the window is minimized.
///
///
///
},
maximize: function() {
///
///
/// Maximizes a Window to the entire viewing area of the user agent. Triggers the resize event.
///
/// Returns the window object to support chaining.
///
},
minimize: function() {
///
///
/// Maximizes a Window to its title bar.
///
/// Returns the window object to support chaining.
///
},
open: function() {
///
///
/// Opens a Window and brings it on top of any other open Window instances by calling toFront internally.
///
/// Returns the window object to support chaining.
///
},
pin: function() {
///
///
/// Pins the Window at its current position with a position:fixed style, i.e. the widget stops moving together with the other page content when the page is scrolled.
/// The user will still be able to move the Window with the mouse or keyboard.
///
///
},
refresh: function(options) {
///
///
/// Refreshes the content of a Window from a remote URL or the initially defined content template.
/// Note that passing data and non-GET requests cannot be sent to an iframe, as they require a form with a target attribute.
///
/// Options for requesting data from the server. If omitted, the window uses the content property that was supplied when the window was created. Any options specified here are passed to jQuery.ajax().
/// Returns the window object to support chaining.
///
},
restore: function() {
///
///
/// Restores a maximized or minimized Window to its previous state. Triggers the resize event.
///
/// Returns the window object to support chaining.
///
},
setOptions: function(options) {
///
///
/// Allows the Window to be configured with new options.If you change the content url, call refresh afterwards. Another option is to execute the refresh method with the new URL directly.Changing the size or position of the Window requires the widget to not be in maximized or minimized state.
///
/// The configuration options to be set.
///
},
title: function(text) {
///
///
/// Gets or sets the title of a Window. Supports chaining when used as a setter.
///
/// The title of the Window.
/// The current window title, if used as a getter. If used as a setter, the method will return the window object to support chaining.
///
},
toFront: function() {
///
///
/// Increases the z-index style of a Window wrapper to bring the instance on top of other open Windows. This method is executed automatically when the open method is used.
///
/// Returns the window object to support chaining.
///
},
toggleMaximization: function() {
///
///
/// Toggles a Window between a maximized and restored state. Triggers the resize event.
///
/// Returns the window object to support chaining.
///
},
unpin: function() {
///
///
/// Disables the Window's pinned state, so that the widget will move together with the other page content when the page is scrolled.
///
///
},
bind: function(event, callback) {
///
///
/// Binds to a widget event.
///
/// The event name
/// The callback to be executed when the event is triggered.
///
},
unbind: function(event, callback) {
///
///
/// Unbinds a callback from a widget event.
///
/// The event name
/// The callback to be removed.
///
}
});
return instance;
};
intellisense.redirectDefinition(wrapper, original);
return wrapper;
})();
jQuery.fn.kendoWindow = function() {
this.data("kendoWindow", new kendo.ui.Window());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoWindow: function() {
///
///
/// Returns a reference to the kendo.ui.Window widget, instantiated on the selector.
///
/// The kendo.ui.Window instance (if present).
///
},
kendoWindow: function(options) {
///
///
/// Instantiates a kendo.ui.Window widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
actions - Array (default: ["Close"])
///
The buttons for interacting with the window. Predefined array values are "Close", "Refresh", "Minimize",
///
and "Maximize".
///
///
animation - Boolean
///
A collection of {Animation} objects, used to change default animations. A value of false will disable all animations in the widget. is not a valid configuration.
///
///
animation - Object
///
A collection of {Animation} objects, used to change default animations. A value of false will disable all animations in the widget. is not a valid configuration.
///
///
appendTo - Object|String (default: document.body)
///
The element that the Window will be appended to. Beneficial if the Window is used together with a form.
///
Note that this does not constrain the window dragging within the given element.
///
///
autoFocus - Boolean (default: true)
///
Determines whether the Window will be focused automatically when opened. The property also influences the focus behavior when the Window is clicked when already opened.
///
///
content - String
///
Specifies a URL or request options that the window should load its content from.Note: For URLs starting with a protocol (e.g. http://),
///
a container iframe element is automatically created. This behavior may change in future
///
versions, so it is advisable to always use the iframe configuration option.
///
///
content - Object
///
Specifies a URL or request options that the window should load its content from.Note: For URLs starting with a protocol (e.g. http://),
///
a container iframe element is automatically created. This behavior may change in future
///
versions, so it is advisable to always use the iframe configuration option.
///
///
draggable - Boolean (default: true)
///
Enables (true) or disables (false) the ability for users to move/drag the widget.
///
///
iframe - Boolean
///
Explicitly states whether a content iframe should be created. For more information, please read Using iframes.
///
///
height - Number|String
///
Specifies height of the window.
///
///
maxHeight - Number (default: Infinity)
///
The maximum height (in pixels) that may be achieved by resizing the window.
///
///
maxWidth - Number (default: Infinity)
///
The maximum width (in pixels) that may be achieved by resizing the window.
///
///
minHeight - Number (default: 50)
///
The minimum height (in pixels) that may be achieved by resizing the window.
///
///
minWidth - Number (default: 50)
///
The minimum width (in pixels) that may be achieved by resizing the window.
///
///
modal - Boolean (default: false)
///
Specifies whether the window should show a modal overlay over the page.
///
///
pinned - Boolean (default: false)
///
Specifies whether the window should be pinned, i.e. it will not move together with the page content during scrolling.
///
///
position - Object
///
A collection of one or two members, which define the initial Window's top and/or left position on the page.
///
///
resizable - Boolean (default: true)
///
Enables (true) or disables (false) the ability for users to resize a Window.
///
///
scrollable - Boolean (default: true)
///
Enables (true) or disables (false) the ability for users to scroll the window contents.
///
///
title - String|Boolean (default: "")
///
The text in the window title bar. If false, the window will be displayed without a title bar. Note that this will prevent the window from being dragged, and the window titlebar buttons will not be shown.
///
///
visible - Boolean (default: true)
///
Specifies whether the window will be initially visible.
///
///
width - Number|String
///
Specifies width of the window.
///
///
///
/// The widget configuration options
///
///
}
});