intellisense.annotate(kendo, {
Class: function() {
///
/// Constructor of kendo.Class
///
}
});
kendo.Class = (function() {
var original = kendo.Class;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
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;
})();
intellisense.annotate(kendo, {
Color: function() {
///
/// Constructor of kendo.Color
///
}
});
kendo.Color = (function() {
var original = kendo.Color;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
diff: function() {
///
///
/// Computes the relative luminance between two colors.
///
/// The relative luminance.
///
},
equals: function() {
///
///
/// Compares two color objects for equality.
///
/// returns true if the two colors are the same. Otherwise, false
///
},
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;
})();
intellisense.annotate(kendo, {
Layout: function() {
///
/// Constructor of kendo.Layout
///
}
});
kendo.Layout = (function() {
var original = kendo.Layout;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
showIn: function(container,view) {
///
///
/// Renders the View element in the element specified by the selector
///
/// The selector of the container in which the view element will be appended.
/// The view instance that will be rendered.
///
},
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;
})();
intellisense.annotate(kendo, {
Observable: function() {
///
/// Constructor of kendo.Observable
///
}
});
kendo.Observable = (function() {
var original = kendo.Observable;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
bind: function(eventName,handler) {
///
///
/// Attaches a handler to an event.
///
/// The name of the event.
/// A function to execute each time the event is triggered. That function should have a single parameter which will contain any event specific data.
///
},
one: function(eventName,handler) {
///
///
/// Attaches a handler to an event. The handler is executed only once.
///
/// The name of the event.
/// A function to execute each time the event is triggered. That function should have a single parameter which will contain any event specific data.
///
},
trigger: function(eventName,eventData) {
///
///
/// Executes all handlers attached to the given event.
///
/// The name of the event to trigger.
/// Optional event data which will be passed as an argument to the event handlers.
///
},
unbind: function(eventName,handler) {
///
///
/// Remove a previously attached event handler.
///
/// The name of the event. If not specified all handlers of all events will be removed.
/// The handler which should no longer be executed. If not specified all handlers listening to that event will be removed.
///
}
});
return instance;
};
intellisense.redirectDefinition(wrapper, original);
return wrapper;
})();
intellisense.annotate(kendo, {
Router: function() {
///
/// Constructor of kendo.Router
///
}
});
kendo.Router = (function() {
var original = kendo.Router;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
start: function() {
///
///
/// Activates the router binding to the URL fragment part changes.
///
///
},
route: function(route,callback) {
///
///
/// Specifies a callback for the given route. The route definition can contain bound parameters, optional segments, and route globbing.
/// The parsed parts of the URL are passed as parameters to the route callback. Query string parameters are parsed and passed as last argument of the callback function.
///
/// The route definition.
/// The callback to be executed when the route is matched.
///
},
navigate: function(route,silent) {
///
///
/// Navigates to the given route.
///
/// The route to navigate to.
/// If set to true, the router callbacks will not be called.
///
},
destroy: function() {
///
///
/// Unbinds the router instance listeners from the URL fragment part changes.
///
///
},
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;
})();
intellisense.annotate(kendo, {
View: function() {
///
/// Constructor of kendo.View
///
}
});
kendo.View = (function() {
var original = kendo.View;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
destroy: function() {
///
///
/// Removes the View element from the DOM. Detaches all event handlers and removes jQuery.data attributes to avoid memory leaks. Calls destroy method of any child Kendo widgets.
///
///
},
render: function(container) {
///
///
/// Renders the view contents. Accepts a jQuery selector (or jQuery object) to which the contents will be appended.
/// Alternatively, the render method can be called without parameters in order to retrieve the View element for manual insertion/further manipulation.
///
/// (optional) the element in which the view element will be appended.
/// the view element.
///
},
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;
})();
intellisense.annotate(kendo.data, {
Binder: function() {
///
/// Constructor of kendo.data.Binder
///
}
});
kendo.data.Binder = (function() {
var original = kendo.data.Binder;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
refresh: function() {
///
///
/// Invoked by the Kendo UI MVVM framework when the bound view model value is changed. The binder should update the UI (HTML element or Kendo UI widget) to reflect the view model change.
///
///
},
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;
})();
intellisense.annotate(kendo.data, {
DataSource: function() {
///
/// Constructor of kendo.data.DataSource
///
}
});
kendo.data.DataSource = (function() {
var original = kendo.data.DataSource;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
add: function(model) {
///
///
/// Appends a data item to the data source.
///
/// Either a kendo.data.Model instance or JavaScript object containing the data item field values.
/// the data item which is inserted.
///
},
aggregate: function(value) {
///
///
/// Gets or sets the aggregate configuration.
///
/// The aggregate configuration. Accepts the same values as the aggregate option.
/// the current aggregate configuration.
///
},
aggregates: function() {
///
///
/// Returns the aggregate results.
///
/// the aggregate results. There is a key for every aggregated field.
///
},
at: function(index) {
///
///
/// Returns the data item at the specified index. The index is zero-based.
///
/// The zero-based index of the data item.
/// the data item at the specified index. Returns undefined if a data item is not found at the specified index.Returns a kendo.data.Model instance if the schema.model option is set.
///
},
cancelChanges: function(model) {
///
///
/// Cancels any pending changes in the data source. Deleted data items are restored, new data items are removed and updated data items are restored to their initial state.
///
/// The optional data item (model). If specified only the changes of this data item will be discarded. If omitted all changes will be discarded.
///
},
data: function(value) {
///
///
/// Gets or sets the data items of the data source.If the data source is bound to a remote service (via the transport option) the data method will return the service response.
/// Every item from the response is wrapped in a kendo.data.ObservableObject or kendo.data.Model (if the schema.model option is set).If the data source is bound to a JavaScript array (via the data option) the data method will return the items of that array.
/// Every item from the array is wrapped in a kendo.data.ObservableObject or kendo.data.Model (if the schema.model option is set).If the data source is grouped (via the group option or the group method) and the serverGrouping is set to true
/// the data method will return the group items.
///
/// The data items which will replace the current ones in the data source. If omitted the current data items will be returned.
/// the data items of the data source. Returns empty array if the data source hasn't been populated with data items via the read, fetch or query methods.
///
},
fetch: function(callback) {
///
///
/// Reads the data items from a remote service (if the transport option is set) or from a JavaScript array (if the data option is set).
///
/// The optional function which is executed when the remote request is finished. The function context (available via the this keyword) will be set to the data source instance.
///
},
filter: function(value) {
///
///
/// Gets or sets the filter configuration.
///
/// The filter configuration. Accepts the same values as the filter option.
/// the current filter configuration.
///
},
get: function(id) {
///
///
/// Gets the data item (model) with the specified id.
///
/// The id of the model to look for.
/// the model instance. Returns undefined if a model with the specified id is not found.
///
},
getByUid: function(uid) {
///
///
/// Gets the data item (model) with the specified uid.
///
/// The uid of the model to look for.
/// the model instance. Returns undefined if a model with the specified uid is not found.
///
},
group: function(value) {
///
///
/// Gets or sets the grouping configuration.
///
/// The grouping configuration. Accepts the same values as the group option.
/// the current grouping configuration.
///
},
hasChanges: function() {
///
///
/// Cheks if the data itams have changed.
///
/// returns true if the data items have changed. Otherwise, false.
///
},
indexOf: function(dataItem) {
///
///
/// Gets the index of the specified data item.
///
/// The target data item.
/// the index of the specified data item. Returns -1 if the data item is not found.
///
},
insert: function(index,model) {
///
///
/// Inserts a data item in the data source at the specified index.
///
/// The zero-based index at which the data item will be inserted.
/// Either a kendo.data.Model instance or JavaScript object containing the field values.
/// the data item which is inserted.
///
},
page: function(page) {
///
///
/// Gets or sets the current page.
///
/// The new page.
/// the current page.
///
},
pageSize: function(size) {
///
///
/// Gets or sets the current page size.
///
/// The new page size.
/// the current page size.
///
},
query: function(options) {
///
///
/// Executes the specified query over the data items. Makes a HTTP request if bound to a remote service.
///
/// The query options which should be applied.
///
},
read: function(data) {
///
///
/// Reads data items from a remote service (if the transport option is set) or from a JavaScript array (if the data option is set).
///
/// Optional data to pass to the remote service.
///
},
remove: function(model) {
///
///
/// Removes the specified data item from the data source.
///
/// The data item which should be removed.
///
},
sort: function(value) {
///
///
/// Gets or sets the sort order which will be applied over the data items.
///
/// The sort configuration. Accepts the same values as the sort option.
/// the current sort configuration.
///
},
sync: function() {
///
///
/// Saves any data item changes.The sync method will request the remote service if:
///
///
},
total: function() {
///
///
/// Gets the total number of data items. Uses schema.total if the transport.read option is set.
///
/// the total number of data items. Returns the length of the array returned by the data method if schema.total or transport.read are not set.Returns 0 if the data source hasn't been populated with data items via the read, fetch or query methods.
///
},
totalPages: function() {
///
///
/// Gets the number of available pages.
///
/// the available pages.
///
},
view: function() {
///
///
/// Returns the data items which correspond to the current page, filter, sort and group configuration.To ensure that data is available this method should be used within the change event handler or the fetch method.
///
/// the data items. Returns groups if the data items are grouped (via the group option or the group method).
///
},
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;
})();
intellisense.annotate(kendo.data, {
HierarchicalDataSource: function() {
///
/// Constructor of kendo.data.HierarchicalDataSource
///
}
});
kendo.data.HierarchicalDataSource = (function() {
var original = kendo.data.HierarchicalDataSource;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
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;
})();
intellisense.annotate(kendo.data, {
Model: function() {
///
/// Constructor of kendo.data.Model
///
}
});
kendo.data.Model = (function() {
var original = kendo.data.Model;
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.
///
///
},
editable: function(field) {
///
///
/// Determines if the specified field is editable or not.
///
/// The field to check.
/// true if the field is editable; false otherwise.
///
},
get: function() {
///
///
/// Gets the value of the specified field. Inherited from kendo.data.ObservableObject. Examples and more info can be found in the get section of the
/// ObservableObject API reference.
///
///
},
isNew: function() {
///
///
/// Checks if the Model is new or not. The id field is used to determine if a model instance is new or existing one.
/// If the value of the field specified is equal to the default value (specified through the fields configuration) the model is considered as new.
///
/// true if the model is new; false otherwise.
///
},
set: function() {
///
///
/// Sets the value of the specified field. Inherited from kendo.data.ObservableObject. Examples and more info can be found in the set section of the
/// ObservableObject API reference.
///
///
},
toJSON: function() {
///
///
/// Creates a plain JavaScript object which contains all fields of the Model. Inherited from kendo.data.ObservableObject. Examples and more info can be found in the toJSON section of the
/// ObservableObject API reference.
///
///
},
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;
})();
intellisense.annotate(kendo.data, {
Node: function() {
///
/// Constructor of kendo.data.Node
///
}
});
kendo.data.Node = (function() {
var original = kendo.data.Node;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
append: function(model) {
///
///
/// Appends a new item to the children data source, and initializes it if necessary.
///
/// The data for the new item
///
},
level: function() {
///
///
/// Gets the current nesting level of the node within the data source.
///
/// the zero based level of the node.
///
},
load: function() {
///
///
/// Loads the child nodes in the child data source, supplying the id of the Node to the request.
///
///
},
loaded: function() {
///
///
/// Gets or sets the loaded flag of the Node. Setting the loaded flag to false allows reloading of child items.
///
///
},
parentNode: function() {
///
///
/// Gets the parent node.
///
/// the parent of the node; null if the node is a root node or doesn't have a parent.
///
},
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;
})();
intellisense.annotate(kendo.data, {
ObservableArray: function() {
///
/// Constructor of kendo.data.ObservableArray
///
}
});
kendo.data.ObservableArray = (function() {
var original = kendo.data.ObservableArray;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
bind: function(eventName,handler) {
///
///
/// Attaches an event handler for the specified event.
///
/// The name of the event.
/// The function which will be invoked when the event is raised.
///
},
join: function(separator) {
///
///
/// Joins all items of an ObservableArray into a string. Equivalent of
/// Array.prototype.join.
///
/// Specifies the string to separate each item of the array. If omitted the array items are separated with a comma (,)
///
},
parent: function() {
///
///
/// Gets the parent of the array if such parent exists.
///
/// the parent of the array; undefined if the array is not nested and doesn't have a parent.
///
},
pop: function() {
///
///
/// Removes the last item from an array and returns that item. Equivalent of Array.prototype.pop.
///
/// the item which was removed.
///
},
push: function() {
///
///
/// Appends the given items to the array and returns the new length of the array. Equivalent of Array.prototype.push.
/// The new items are wrapped as ObservableObject if they are complex objects.
///
/// the new length of the array.
///
},
slice: function(begin,end) {
///
///
/// Returns a one-level deep copy of a portion of an array. Equivalent of
/// Array.prototype.slice.
/// The result of the slice method is not an instance of ObvservableArray. It is a regular JavaScript Array object.
///
/// Zero-based index at which to begin extraction.
/// Zero-based index at which to end extraction. If end is omitted, slice extracts to the end of the sequence.
///
},
splice: function(index,howMany) {
///
///
/// Changes an ObservableArray, by adding new items while removing old items. Equivalent of
/// Array.prototype.splice
///
/// Index at which to start changing the array. If negative, will begin that many elements from the end.
/// An integer indicating the number of items to remove. If set to 0, no items are removed. In this case, you should specify at least one new item.
/// containing the removed items. The result of the splice method is not an instance of ObvservableArray.
///
},
shift: function() {
///
///
/// Removes the first item from an ObvservableArray and returns that item. Equivalent of Array.prototype.shift.
///
/// the item which was removed.
///
},
toJSON: function() {
///
///
/// Returns a JavaScript Array which represents the contents of the ObservableArray.
///
///
},
unshift: function() {
///
///
/// Adds one or more items to the beginning of an ObservableArray and returns the new length. Equivalent of Array.prototype.unshift.
///
/// the new length of the array.
///
},
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;
})();
intellisense.annotate(kendo.data, {
ObservableObject: function() {
///
/// Constructor of kendo.data.ObservableObject
///
}
});
kendo.data.ObservableObject = (function() {
var original = kendo.data.ObservableObject;
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.
///
///
},
get: function(name) {
///
///
/// Gets the value of the specified field.
///
/// The name of the field whose value is going to be returned.
/// the value of the specified field.
///
},
parent: function() {
///
///
/// Gets the parent of the object if such parent exists.
///
/// the parent of the object; undefined if the object is not nested and doesn't have a parent.
///
},
set: function(name,value) {
///
///
/// Sets the value of the specified field.
///
/// The name of the field whose value is going to be returned.
/// The new value of the field.
///
},
toJSON: function() {
///
///
/// Creates a plain JavaScript object which contains all fields of the ObservableObject.
///
/// which contains only the fields of the ObservableObject.
///
},
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;
})();
intellisense.annotate(kendo.data, {
SchedulerDataSource: function() {
///
/// Constructor of kendo.data.SchedulerDataSource
///
}
});
kendo.data.SchedulerDataSource = (function() {
var original = kendo.data.SchedulerDataSource;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
expand: function(start,end) {
///
///
/// Expands all recurring events in the data and returns a list of events for a specific period.
///
/// The start date of the period.
/// The end date of the period.
/// the expanded list of scheduler events filtered by the specified start/end period.
///
},
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;
})();
intellisense.annotate(kendo.data, {
SchedulerEvent: function() {
///
/// Constructor of kendo.data.SchedulerEvent
///
}
});
kendo.data.SchedulerEvent = (function() {
var original = kendo.data.SchedulerEvent;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
clone: function(options) {
///
///
/// Clones the scheduler event.
///
/// Additional options passed to the SchedulerEvent constructor.
/// the cloned scheduler event.
///
},
duration: function() {
///
///
/// Returns the scheduler event length in milliseconds.
///
/// the length of the event.
///
},
expand: function(start,end,timeZoneId) {
///
///
/// Expands the event for a specific period based on the recurrenceRule option.
///
/// The start date of the occurrence period.
/// The end date of the occurrence period.
/// The time zone ID used to convert the recurrence rule dates.
/// the list of the occurrences.
///
},
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;
})();
intellisense.annotate(kendo.dataviz.ui, {
Barcode: function() {
///
/// Constructor of kendo.dataviz.ui.Barcode
///
}
});
kendo.dataviz.ui.Barcode = (function() {
var original = kendo.dataviz.ui.Barcode;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
imageDataURL: function() {
///
///
/// Returns a PNG image of the barcode encoded as a Data URL.
///
/// A data URL with image/png MIME type. Will be null if the browser does not support the canvas element.
///
},
redraw: function() {
///
///
/// Redraws the barcode.
///
///
},
svg: function() {
///
///
/// Returns the SVG representation of the barcode. The returned string is a self-contained SVG document that can be used as is or converted to other formats using tools like Inkscape and
/// ImageMagick. Both programs provide command-line interface suitable for server-side processing.
///
/// the SVG representation of the barcode.
///
},
value: function(value) {
///
///
/// Gets/Sets the value of the barcode.
///
/// The value to set.
/// The value of the barcode.
///
},
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.kendoBarcode = function() {
this.data("kendoBarcode", new kendo.dataviz.ui.Barcode());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoBarcode: function() {
///
///
/// Returns a reference to the kendo.dataviz.ui.Barcode widget, instantiated on the selector.
///
/// The kendo.dataviz.ui.Barcode instance (if present).
///
},
kendoBarcode: function(options) {
///
///
/// Instantiates a kendo.dataviz.ui.Barcode widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
renderAs — String (default: "canvas")
///
Sets the preferred rendering engine.
///
If it is not supported by the browser, the Barcode will switch to the first available mode.The supported values are:
///
///
background — String (default: "white")
///
The background of the barcode area.
///
Any valid CSS color string will work here, including hex and rgb.
///
///
border — Object
///
The border of the barcode area.
///
///
checksum — Boolean (default: false)
///
If set to true the barcode will not display the checksum digit next to the value in the text area.
///
///
color — String (default: "black")
///
The color of the bar elements.
///
Any valid CSS color string will work here, including hex and rgb.
///
///
height — Number (default: 100)
///
The height of the barcode in pixels. By default the height is 100.
///
///
padding — Object
///
The padding of the barcode.
///
///
text — Object
///
Can be set to a JavaScript object which represents the text configuration.
///
///
type — String (default: "code39")
///
The symbology (encoding) the barcode will use.The supported values are:
///
///
value — String
///
The initial value of the Barcode
///
///
width — Number (default: 300)
///
The width of the barcode in pixels. By default the width is 300.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.dataviz.ui, {
Chart: function() {
///
/// Constructor of kendo.dataviz.ui.Chart
///
}
});
kendo.dataviz.ui.Chart = (function() {
var original = kendo.dataviz.ui.Chart;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
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.
///
///
},
redraw: function() {
///
///
/// Repaints the chart using the currently loaded data.
///
///
},
refresh: function() {
///
///
/// Reloads the data and renders the chart.
///
///
},
setDataSource: function(dataSource) {
///
///
/// Sets the data source of the widget.
///
/// The data source to which the widget should be bound.
///
},
setOptions: function(options) {
///
///
/// Sets the widget options. Changes are cumulative.
///
/// The chart settings to update.
///
},
svg: function() {
///
///
/// Returns the SVG representation of the chart.
/// The returned string is a self-contained SVG document that can be used as is or
/// converted to other formats using tools like Inkscape and
/// ImageMagick.
/// Both programs provide command-line interface suitable for server-side processing.
///
/// the SVG representation of the chart.
///
},
imageDataURL: function() {
///
///
/// Returns a PNG image of the chart encoded as a Data URL.
///
/// A data URL with image/png MIME type. Will be null if the browser does not support the canvas element.
///
},
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.kendoChart = function() {
this.data("kendoChart", new kendo.dataviz.ui.Chart());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoChart: function() {
///
///
/// Returns a reference to the kendo.dataviz.ui.Chart widget, instantiated on the selector.
///
/// The kendo.dataviz.ui.Chart instance (if present).
///
},
kendoChart: function(options) {
///
///
/// Instantiates a kendo.dataviz.ui.Chart 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.
///
///
axisDefaults — Object
///
The default options for all chart axes. Accepts the options supported by categoryAxis, valueAxis, xAxis and yAxis.
///
///
categoryAxis — Array|Object
///
The category axis configuration options.
///
///
chartArea — Object
///
The chart area configuration options. Represents the entire visible area of the chart.
///
///
dataSource — Object|Array
///
The data source of the chart which is used to display the series. 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.
///
///
legend — Object
///
The chart legend configuration options.
///
///
panes — Array
///
The chart panes configuration.Panes are used to split the chart in two or more parts. The panes are ordered from top to bottom.Each axis can be associated with a pane by setting its pane option to the name of the desired pane.
///
Axis that don't have specified pane are placed in the top (default) pane.Series are moved to the desired pane by associating them with an axis.
///
///
plotArea — Object
///
The plot area configuration options. The plot area is the area which displays the series.
///
///
renderAs — String
///
Sets the preferred rendering engine.
///
If it is not supported by the browser, the Chart will switch to the first available mode.The supported values are:
///
///
series — Array
///
The configuration of the chart series.The series type is determined by the value of the type field.
///
If a type value is missing, the type is assumed to be the one specified in seriesDefaults.
///
///
seriesColors — Array
///
The default colors for the chart's series. When all colors are used, new colors are pulled from the start again.
///
///
seriesDefaults — Object
///
The default options for all series.
///
///
theme — String
///
The chart theme.The supported values are:
///
///
title — String
///
The chart title configuration options or text.
///
///
title — Object
///
The chart title configuration options or text.
///
///
tooltip — Object
///
The chart series tooltip configuration options.
///
///
transitions — Boolean (default: true)
///
If set to true the chart will play animations when displaying the series. By default animations are enabled.
///
///
valueAxis — Array
///
The value axis configuration options.
///
///
xAxis — Array
///
The X-axis configuration options of the scatter chart X-axis. Supports all valueAxis options.
///
///
yAxis — Array
///
The y axis configuration options of the scatter chart. Supports all valueAxis options.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.dataviz.ui, {
LinearGauge: function() {
///
/// Constructor of kendo.dataviz.ui.LinearGauge
///
}
});
kendo.dataviz.ui.LinearGauge = (function() {
var original = kendo.dataviz.ui.LinearGauge;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
destroy: function() {
///
///
/// Prepares the Gauge for safe removal from the DOM.Detaches event handlers and removes data entries in order to avoid memory leaks.
///
///
},
redraw: function() {
///
///
/// Redraws the gauge.
///
///
},
svg: function() {
///
///
/// Returns the SVG representation of the gauge.
/// The returned string is a self-contained SVG document that can be used as is or
/// converted to other formats using tools like Inkscape and
/// ImageMagick.
/// Both programs provide command-line interface suitable for server-side processing.
///
///
},
imageDataURL: function() {
///
///
/// Returns a PNG image of the gauge encoded as a Data URL.
///
/// A data URL with image/png MIME type. Will be null if the browser does not support the canvas element.
///
},
value: function() {
///
///
/// Change the value of the gauge.
///
///
},
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.kendoLinearGauge = function() {
this.data("kendoLinearGauge", new kendo.dataviz.ui.LinearGauge());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoLinearGauge: function() {
///
///
/// Returns a reference to the kendo.dataviz.ui.LinearGauge widget, instantiated on the selector.
///
/// The kendo.dataviz.ui.LinearGauge instance (if present).
///
},
kendoLinearGauge: function(options) {
///
///
/// Instantiates a kendo.dataviz.ui.LinearGauge widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
gaugeArea — Object
///
The gauge area configuration options.
///
This is the entire visible area of the gauge.
///
///
pointer — Object
///
The pointer configuration options.
///
///
renderAs — String
///
Sets the preferred rendering engine.
///
If it is not supported by the browser, the Gauge will switch to the first available mode.The supported values are:
///
///
scale — Object
///
Configures the scale.
///
///
transitions — Boolean (default: true)
///
A value indicating if transition animations should be played.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.dataviz.ui, {
Map: function() {
///
/// Constructor of kendo.dataviz.ui.Map
///
}
});
kendo.dataviz.ui.Map = (function() {
var original = kendo.dataviz.ui.Map;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
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.
///
///
},
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.kendoMap = function() {
this.data("kendoMap", new kendo.dataviz.ui.Map());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoMap: function() {
///
///
/// Returns a reference to the kendo.dataviz.ui.Map widget, instantiated on the selector.
///
/// The kendo.dataviz.ui.Map instance (if present).
///
},
kendoMap: function(options) {
///
///
/// Instantiates a kendo.dataviz.ui.Map widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
center — Array
///
The map center. Coordinates are listed as [Latitude, Longitude].
///
///
controls — Object
///
The configuration of built-in map controls.
///
///
layerDefaults — Object
///
The default configuration for map layers by type.
///
///
layers — Array
///
The configuration of the map layers.
///
The layer type is determined by the value of the type field.
///
///
markerDefaults — Object
///
The default options for all markers.
///
///
markers — Array
///
Static markers to display on the map.
///
///
minZoom — Number (default: 2)
///
The minimum zoom level.
///
///
maxZoom — Number (default: 19)
///
The maximum zoom level.
///
///
minSize — Number (default: 256)
///
The size of the map in pixels at zoom level 0.
///
///
wraparound — Boolean (default: true)
///
Specifies whether the map should wrap around the east-west edges.
///
///
zoom — Number (default: 3)
///
The initial zoom level.Typical web maps use zoom levels from 0 (whole world) to 19 (sub-meter features).The map size is derived from the zoom level and minScale options: size = (2 ^ zoom) * minSize
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.dataviz.ui, {
QRCode: function() {
///
/// Constructor of kendo.dataviz.ui.QRCode
///
}
});
kendo.dataviz.ui.QRCode = (function() {
var original = kendo.dataviz.ui.QRCode;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
destroy: function() {
///
///
/// Prepares the QRCode for safe removal from the DOM.Removes data entries in order to avoid memory leaks.
///
///
},
imageDataURL: function() {
///
///
/// Returns a PNG image of the qrcode encoded as a Data URL.
///
/// A data URL with image/png MIME type. Will be null if the browser does not support the canvas element.
///
},
redraw: function() {
///
///
/// Redraws the QR code using the current value and options.
///
///
},
setOptions: function(options) {
///
///
/// Sets new options to the QRCode and redraws it.
///
/// An object with the new options. All configuration options can be set.
///
},
svg: function() {
///
///
/// Returns the SVG representation of the qrcode. The returned string is a self-contained SVG document that can be used as is or converted to other formats using tools like Inkscape and
/// ImageMagick. Both programs provide command-line interface suitable for server-side processing.
///
/// the SVG representation of the qrcode.
///
},
value: function(options) {
///
///
/// Change the value of the QR code.
///
/// The new value to be set.
///
},
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.kendoQRCode = function() {
this.data("kendoQRCode", new kendo.dataviz.ui.QRCode());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoQRCode: function() {
///
///
/// Returns a reference to the kendo.dataviz.ui.QRCode widget, instantiated on the selector.
///
/// The kendo.dataviz.ui.QRCode instance (if present).
///
},
kendoQRCode: function(options) {
///
///
/// Instantiates a kendo.dataviz.ui.QRCode widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
background — String (default: "#fff")
///
The background color of the QR code. Accepts a valid CSS color string, including hex and rgb.
///
///
border — Object
///
The border of the QR code.
///
///
color — String (default: "#000")
///
The color of the QR code. Accepts a valid CSS color string, including hex and rgb.
///
///
encoding — String (default: "ISO_8859_1")
///
The encoding mode used to encode the value.The possible values are:
///
///
errorCorrection — String (default: "L")
///
The error correction level used to encode the value.The possible values are:
///
///
renderAs — String (default: "canvas")
///
Sets the preferred rendering engine.
///
If it is not supported by the browser, the QRCode will switch to the first available mode.The supported values are:
///
///
size — Number|String
///
Specifies the size of a QR code in pixels (i.e. "200px"). Numeric values are treated as pixels. If no size is specified, it will be determined from the element width and height. In case the element does not have width or height bigger than zero, a default value of 200 pixels will be used.
///
///
value — Number|String
///
The value of the QRCode.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.dataviz.ui, {
RadialGauge: function() {
///
/// Constructor of kendo.dataviz.ui.RadialGauge
///
}
});
kendo.dataviz.ui.RadialGauge = (function() {
var original = kendo.dataviz.ui.RadialGauge;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
destroy: function() {
///
///
/// Prepares the Gauge for safe removal from the DOM.Detaches event handlers and removes data entries in order to avoid memory leaks.
///
///
},
redraw: function() {
///
///
/// Redraws the gauge.
///
///
},
svg: function() {
///
///
/// Returns the SVG representation of the gauge.
/// The returned string is a self-contained SVG document that can be used as is or
/// converted to other formats using tools like Inkscape and
/// ImageMagick.
/// Both programs provide command-line interface suitable for server-side processing.
///
///
},
imageDataURL: function() {
///
///
/// Returns a PNG image of the gauge encoded as a Data URL.
///
/// A data URL with image/png MIME type. Will be null if the browser does not support the canvas element.
///
},
value: function() {
///
///
/// Change the value of the gauge.
///
///
},
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.kendoRadialGauge = function() {
this.data("kendoRadialGauge", new kendo.dataviz.ui.RadialGauge());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoRadialGauge: function() {
///
///
/// Returns a reference to the kendo.dataviz.ui.RadialGauge widget, instantiated on the selector.
///
/// The kendo.dataviz.ui.RadialGauge instance (if present).
///
},
kendoRadialGauge: function(options) {
///
///
/// Instantiates a kendo.dataviz.ui.RadialGauge widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
gaugeArea — Object
///
The gauge area configuration options.
///
This is the entire visible area of the gauge.
///
///
pointer — Object
///
The pointer configuration options.
///
///
renderAs — String
///
Sets the preferred rendering engine.
///
If it is not supported by the browser, the Gauge will switch to the first available mode.The supported values are:
///
///
scale — Object
///
Configures the scale.
///
///
transitions — Boolean (default: true)
///
A value indicating if transition animations should be played.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.dataviz.ui, {
Sparkline: function() {
///
/// Constructor of kendo.dataviz.ui.Sparkline
///
}
});
kendo.dataviz.ui.Sparkline = (function() {
var original = kendo.dataviz.ui.Sparkline;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
destroy: function() {
///
///
/// Prepares the Sparkline for safe removal from the DOM.Detaches event handlers and removes data entries in order to avoid memory leaks.
///
///
},
refresh: function() {
///
///
/// Reloads the data and repaints the chart.
///
///
},
setDataSource: function(dataSource) {
///
///
/// Sets the dataSource of an existing Chart and rebinds it.
///
///
///
},
setOptions: function(options) {
///
///
/// Sets the widget options. Changes are cumulative.
///
/// The chart settings to update.
///
},
svg: function() {
///
///
/// Returns the SVG representation of the chart.
/// The returned string is a self-contained SVG document that can be used as is or
/// converted to other formats using tools like Inkscape and
/// ImageMagick.
/// Both programs provide command-line interface suitable for server-side processing.
///
/// the SVG representation of the sparkline.
///
},
imageDataURL: function() {
///
///
/// Returns a PNG image of the sparkline encoded as a Data URL.
///
/// A data URL with image/png MIME type. Will be null if the browser does not support the canvas element.
///
},
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.kendoSparkline = function() {
this.data("kendoSparkline", new kendo.dataviz.ui.Sparkline());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoSparkline: function() {
///
///
/// Returns a reference to the kendo.dataviz.ui.Sparkline widget, instantiated on the selector.
///
/// The kendo.dataviz.ui.Sparkline instance (if present).
///
},
kendoSparkline: function(options) {
///
///
/// Instantiates a kendo.dataviz.ui.Sparkline widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
axisDefaults — Object
///
Default options for all chart axes.
///
///
categoryAxis — Array
///
The category axis configuration options.
///
///
chartArea — Object
///
The chart area configuration options.
///
This is the entire visible area of the chart.
///
///
data — Array
///
The data for the default sparkline series.Will be discareded if series are supplied.
///
///
dataSource — Object
///
DataSource configuration or instance.
///
///
autoBind — Boolean (default: true)
///
Indicates whether the chart will call read on the data source initially.
///
///
plotArea — Object
///
The plot area configuration options. This is the area containing the plotted series.
///
///
pointWidth — Number (default: 5)
///
The width to allocate for each data point.
///
///
renderAs — String
///
Sets the preferred rendering engine.
///
If it is not supported by the browser, the Sparkline will switch to the first available mode.The supported values are:
///
///
series — Array
///
Array of series definitions.The series type is determined by the value of the type field.
///
If a type value is missing, the type is assumed to be the one specified in seriesDefaults.Each series type has a different set of options.
///
///
seriesColors — Array
///
The default colors for the chart's series. When all colors are used, new colors are pulled from the start again.
///
///
seriesDefaults — Object
///
Default values for each series.
///
///
theme — String
///
Sets Chart theme. Available themes: default, blueOpal, black.
///
///
tooltip — Object
///
The data point tooltip configuration options.
///
///
transitions — Boolean (default: false)
///
A value indicating if transition animations should be played.
///
///
type — String (default: "line")
///
The default series type.
///
///
valueAxis — Array
///
The value axis configuration options.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.dataviz.ui, {
StockChart: function() {
///
/// Constructor of kendo.dataviz.ui.StockChart
///
}
});
kendo.dataviz.ui.StockChart = (function() {
var original = kendo.dataviz.ui.StockChart;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
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.
///
///
},
redraw: function() {
///
///
/// Repaints the chart using the currently loaded data.
///
///
},
refresh: function() {
///
///
/// Reloads the data and renders the chart.
///
///
},
setDataSource: function(dataSource) {
///
///
/// Sets the data source of the widget.
///
/// The data source to which the widget should be bound.
///
},
svg: function() {
///
///
/// Returns the SVG representation of the chart.
/// The returned string is a self-contained SVG document that can be used as is or
/// converted to other formats using tools like Inkscape and
/// ImageMagick.
/// Both programs provide command-line interface suitable for server-side processing.
///
/// the SVG representation of the chart.
///
},
imageDataURL: function() {
///
///
/// Returns a PNG image of the chart encoded as a Data URL.
///
/// A data URL with image/png MIME type. Will be null if the browser does not support the canvas element.
///
},
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.kendoStockChart = function() {
this.data("kendoStockChart", new kendo.dataviz.ui.StockChart());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoStockChart: function() {
///
///
/// Returns a reference to the kendo.dataviz.ui.StockChart widget, instantiated on the selector.
///
/// The kendo.dataviz.ui.StockChart instance (if present).
///
},
kendoStockChart: function(options) {
///
///
/// Instantiates a kendo.dataviz.ui.StockChart widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
dateField — String (default: "date")
///
The field containing the point date.
///
It is used as a default categoryField for all series.The data item field value must be either:
///
///
navigator — Object
///
The data navigator configuration options.
///
///
axisDefaults — Object
///
Default options for all chart axes.
///
///
categoryAxis — Array
///
The category axis configuration options.
///
///
chartArea — Object
///
The chart area configuration options.
///
This is the entire visible area of the chart.
///
///
dataSource — Object
///
DataSource configuration or instance.
///
///
autoBind — Boolean (default: true)
///
Indicates whether the chart will call read on the data source initially.
///
///
legend — Object
///
The chart legend configuration options.
///
///
panes — Array
///
The chart panes configuration.Panes are used to split the chart in two or more parts. The panes are ordered from top to bottom.Each axis can be associated with a pane by setting its pane option to the name of the desired pane.
///
Axis that don't have specified pane are placed in the top (default) pane.Series are moved to the desired pane by associating them with an axis.
///
///
plotArea — Object
///
The plot area configuration options. This is the area containing the plotted series.
///
///
renderAs — String
///
Sets the preferred rendering engine.
///
If it is not supported by the browser, the Chart will switch to the first available mode.The supported values are:
///
///
series — Array
///
Array of series definitions.The series type is determined by the value of the type field.
///
If a type value is missing, the type is assumed to be the one specified in seriesDefaults.Each series type has a different set of options.
///
///
seriesColors — Array
///
The default colors for the chart's series. When all colors are used, new colors are pulled from the start again.
///
///
seriesDefaults — Object
///
Default values for each series.
///
///
theme — String
///
Sets Chart theme. Available themes: default, blueOpal, black.
///
///
title — Object
///
The chart title configuration options or text.
///
///
tooltip — Object
///
The data point tooltip configuration options.
///
///
transitions — Boolean (default: true)
///
A value indicating if transition animations should be played.
///
///
valueAxis — Array
///
The value axis configuration options.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.mobile, {
Application: function() {
///
/// Constructor of kendo.mobile.Application
///
}
});
kendo.mobile.Application = (function() {
var original = kendo.mobile.Application;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
changeLoadingMessage: function(text) {
///
///
/// Changes the loading message.
///
/// New text of the loading animation.
///
},
hideLoading: function() {
///
///
/// Hide the loading animation.
///
///
},
navigate: function(url,transition) {
///
///
/// Navigate to local or to remote view.
///
/// The id or url of the view.
/// Optional. The transition to apply when navigating. See View Transitions section for more information.
///
},
scroller: function() {
///
///
/// Get a reference to the current view's scroller widget instance.
///
/// the scroller widget instance.
///
},
showLoading: function() {
///
///
/// Show the loading animation.
///
///
},
skin: function(skin) {
///
///
/// Change the current skin of the mobile application. When used without parameters, returns the currently used skin. Available as of Q2 2013.
///
/// The skin name to switch to or empty string ("") to return to native.
/// Current skin in effect.
///
},
view: function() {
///
///
/// Get a reference to the current view.
///
/// the view instance.
///
},
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;
})();
intellisense.annotate(kendo.mobile.ui, {
ActionSheet: function() {
///
/// Constructor of kendo.mobile.ui.ActionSheet
///
}
});
kendo.mobile.ui.ActionSheet = (function() {
var original = kendo.mobile.ui.ActionSheet;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
close: function() {
///
///
/// Close the ActionSheet.
///
///
},
destroy: function() {
///
///
/// Prepares the ActionSheet 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.
///
///
},
open: function(target,context) {
///
///
/// Open the ActionSheet.
///
/// (optional) The target element of the ActionSheet, available in the callback methods.Notice The target element is mandatory on tablets, as the ActionSheet widget positions itself relative to opening element when a tablet is detected.
/// (optional) The context of the ActionSheet, available in the callback methods.
///
},
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.kendoActionSheet = function() {
this.data("kendoActionSheet", new kendo.mobile.ui.ActionSheet());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoActionSheet: function() {
///
///
/// Returns a reference to the kendo.mobile.ui.ActionSheet widget, instantiated on the selector.
///
/// The kendo.mobile.ui.ActionSheet instance (if present).
///
},
kendoActionSheet: function(options) {
///
///
/// Instantiates a kendo.mobile.ui.ActionSheet widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
cancel — String (default: "Cancel")
///
The text of the cancel button.
///
///
popup — Object
///
The popup configuration options (tablet only).
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.mobile.ui, {
BackButton: function() {
///
/// Constructor of kendo.mobile.ui.BackButton
///
}
});
kendo.mobile.ui.BackButton = (function() {
var original = kendo.mobile.ui.BackButton;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
destroy: function() {
///
///
/// Prepares the BackButton 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.
///
///
},
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.kendoBackButton = function() {
this.data("kendoBackButton", new kendo.mobile.ui.BackButton());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoBackButton: function() {
///
///
/// Returns a reference to the kendo.mobile.ui.BackButton widget, instantiated on the selector.
///
/// The kendo.mobile.ui.BackButton instance (if present).
///
},
kendoBackButton: function(options) {
///
///
/// Instantiates a kendo.mobile.ui.BackButton widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.mobile.ui, {
Button: function() {
///
/// Constructor of kendo.mobile.ui.Button
///
}
});
kendo.mobile.ui.Button = (function() {
var original = kendo.mobile.ui.Button;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
badge: function(value) {
///
///
/// Introduced in Q1 2013 SP Sets a badge on the Button with the specified value. If invoked without parameters, returns the current badge value. Set the value to false to remove the badge.
///
/// The target value to be set or false to be removed.
/// the badge value if invoked without parameters, otherwise the Button object.
///
},
destroy: function() {
///
///
/// Prepares the Button 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) {
///
///
/// Changes the enabled state of the widget.
///
/// Whether to enable or disable the widget.
///
},
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.kendoButton = function() {
this.data("kendoButton", new kendo.mobile.ui.Button());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoButton: function() {
///
///
/// Returns a reference to the kendo.mobile.ui.Button widget, instantiated on the selector.
///
/// The kendo.mobile.ui.Button instance (if present).
///
},
kendoButton: function(options) {
///
///
/// Instantiates a kendo.mobile.ui.Button widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
badge — String
///
The badge of the button.
///
///
enable — Boolean (default: true)
///
If set to false the widget will be disabled and will not allow the user to click it. The widget is enabled by default.
///
///
icon — String
///
The icon of the button. It can be either one of the built-in icons, or a custom one.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.mobile.ui, {
ButtonGroup: function() {
///
/// Constructor of kendo.mobile.ui.ButtonGroup
///
}
});
kendo.mobile.ui.ButtonGroup = (function() {
var original = kendo.mobile.ui.ButtonGroup;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
badge: function(button,value) {
///
///
/// Introduced in Q1 2013 SP Sets a badge on one of the ButtonGroup buttons with the specified value. If invoked without parameters, returns the button's current badge value. Set the value to false to remove the badge.
///
/// The target button specified either as a jQuery selector/object or as an button index.
/// The target value to be set or false to be removed.
/// the badge value if invoked without parameters, otherwise the ButtonGroup object.
///
},
current: function() {
///
///
/// Get the currently selected Button.
///
/// the jQuery object representing the currently selected button.
///
},
destroy: function() {
///
///
/// Prepares the ButtonGroup 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.
///
///
},
select: function(li) {
///
///
/// Select a Button.
///
/// LI element or index of the Button.
///
},
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.kendoButtonGroup = function() {
this.data("kendoButtonGroup", new kendo.mobile.ui.ButtonGroup());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoButtonGroup: function() {
///
///
/// Returns a reference to the kendo.mobile.ui.ButtonGroup widget, instantiated on the selector.
///
/// The kendo.mobile.ui.ButtonGroup instance (if present).
///
},
kendoButtonGroup: function(options) {
///
///
/// Instantiates a kendo.mobile.ui.ButtonGroup widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
index — Number
///
Defines the initially selected Button (zero based index).
///
///
selectOn — String (default: default "down")
///
Sets the DOM event used to select the button. Accepts "up" as an alias for touchend, mouseup and MSPointerUp vendor specific events.By default, buttons are selected immediately after the user presses the button (on touchstart or mousedown or MSPointerDown, depending on the mobile device).
///
However, if the widget is placed in a scrollable view, the user may accidentally press the button when scrolling. In such cases, it is recommended to set this option to "up".
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.mobile.ui, {
DetailButton: function() {
///
/// Constructor of kendo.mobile.ui.DetailButton
///
}
});
kendo.mobile.ui.DetailButton = (function() {
var original = kendo.mobile.ui.DetailButton;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
destroy: function() {
///
///
/// Prepares the DetailButton 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.
///
///
},
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.kendoDetailButton = function() {
this.data("kendoDetailButton", new kendo.mobile.ui.DetailButton());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoDetailButton: function() {
///
///
/// Returns a reference to the kendo.mobile.ui.DetailButton widget, instantiated on the selector.
///
/// The kendo.mobile.ui.DetailButton instance (if present).
///
},
kendoDetailButton: function(options) {
///
///
/// Instantiates a kendo.mobile.ui.DetailButton widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.mobile.ui, {
Drawer: function() {
///
/// Constructor of kendo.mobile.ui.Drawer
///
}
});
kendo.mobile.ui.Drawer = (function() {
var original = kendo.mobile.ui.Drawer;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
destroy: function() {
///
///
/// Prepares the Drawer 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.
///
///
},
hide: function() {
///
///
/// Hide the Drawer
///
///
},
show: function() {
///
///
/// Show the Drawer
///
///
},
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.kendoDrawer = function() {
this.data("kendoDrawer", new kendo.mobile.ui.Drawer());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoDrawer: function() {
///
///
/// Returns a reference to the kendo.mobile.ui.Drawer widget, instantiated on the selector.
///
/// The kendo.mobile.ui.Drawer instance (if present).
///
},
kendoDrawer: function(options) {
///
///
/// Instantiates a kendo.mobile.ui.Drawer widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
position — String (default: 'left')
///
The position of the drawer. Can be left (default) or right.
///
///
swipeToOpen — Boolean (default: true)
///
If set to false, swiping the view will not activate the drawer. In this case, the drawer will only be open by a designated button
///
///
title — String
///
The text to display in the Navbar title (if present).
///
///
views — Array
///
A list of the view ids on which the drawer will appear. If omitted, the drawer will work on any view in the application.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.mobile.ui, {
Layout: function() {
///
/// Constructor of kendo.mobile.ui.Layout
///
}
});
kendo.mobile.ui.Layout = (function() {
var original = kendo.mobile.ui.Layout;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
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.kendoLayout = function() {
this.data("kendoLayout", new kendo.mobile.ui.Layout());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoLayout: function() {
///
///
/// Returns a reference to the kendo.mobile.ui.Layout widget, instantiated on the selector.
///
/// The kendo.mobile.ui.Layout instance (if present).
///
},
kendoLayout: function(options) {
///
///
/// Instantiates a kendo.mobile.ui.Layout widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
id — String (default: null)
///
The id of the layout. Required
///
///
platform — String
///
The specific platform this layout targets. By default, layouts are displayed
///
on all platforms.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.mobile.ui, {
ListView: function() {
///
/// Constructor of kendo.mobile.ui.ListView
///
}
});
kendo.mobile.ui.ListView = (function() {
var original = kendo.mobile.ui.ListView;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
append: function(dataItems) {
///
///
/// Appends new items generated by rendering the given data items with the listview template to the bottom of the listview.
///
///
///
},
prepend: function(dataItems) {
///
///
/// Prepends new items generated by rendering the given data items with the listview template to the top of the listview.
///
///
///
},
replace: function(dataItems) {
///
///
/// Replaces the contents of the listview with the passed rendered data items.
///
///
///
},
remove: function(dataItems) {
///
///
/// Removes the listview items which are rendered with the passed data items.
///
///
///
},
setDataItem: function(item,dataItem) {
///
///
/// Re-renders the given listview item with the new dataItem provided. In order for the method to work as expected, the data items should be of type kendo.data.Model.
///
/// The listview item to update
/// The new dataItem
///
},
destroy: function() {
///
///
/// Prepares the ListView 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.
///
///
},
items: function() {
///
///
/// Get the listview DOM element items
///
/// The listview DOM element items
///
},
refresh: function() {
///
///
/// Repaints the listview (works only in databound mode).
///
///
},
setDataSource: function(dataSource) {
///
///
/// Sets the DataSource of an existing ListView 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.kendoListView = function() {
this.data("kendoListView", new kendo.mobile.ui.ListView());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoListView: function() {
///
///
/// Returns a reference to the kendo.mobile.ui.ListView widget, instantiated on the selector.
///
/// The kendo.mobile.ui.ListView instance (if present).
///
},
kendoListView: function(options) {
///
///
/// Instantiates a kendo.mobile.ui.ListView widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
appendOnRefresh — Boolean (default: false)
///
Used in combination with pullToRefresh. If set to true, newly loaded data will be appended on top when refreshing. Notice: not applicable if ListView is in a virtual mode.
///
///
autoBind — Boolean (default: true)
///
Indicates whether the listview will call read on the DataSource initially. If set to false, the listview will be bound after the DataSource instance fetch method is called.
///
///
dataSource — Object
///
Instance of DataSource or the data that the mobile ListView will be bound to.
///
///
endlessScroll — Boolean (default: false)
///
If set to true, the listview gets the next page of data when the user scrolls near the bottom of the view.
///
///
fixedHeaders — Boolean (default: false)
///
If set to true, the group headers will persist their position when the user scrolls through the listview.
///
Applicable only when the type is set to group, or when binding to grouped DataSource.Notice: fixed headers are not supported in virtual mode.
///
///
headerTemplate — String|Function (default: "#:value#")
///
The header item template (applicable when the type is set to group).
///
///
loadMore — Boolean (default: false)
///
If set to true, a button is rendered at the bottom of the listview. Tapping it fetches and displays the items from the next page of the DataSource.
///
///
loadMoreText — String (default: "Press to load more")
///
The text of the rendered load-more button (applies only if loadMore is set to true).
///
///
pullToRefresh — Boolean (default: false)
///
If set to true, the listview will reload its data when the user pulls the view over the top limit.
///
///
pullParameters — Function
///
A callback function used when the 'pullToRefresh' option is enabled. The result of the function will be send as additional parameters to the DataSource's next method.Notice: When the listview is in a virtual mode, the pull to refresh action removes the previously loaded items in the listview (instead of appending new records at the top).
///
Previously loaded pages in the DataSource are also discarded.
///
///
style — String (default: "")
///
The style of the widget. Can be either empty string(""), or inset.
///
///
template — String|Function (default: "#:data#")
///
The item template.
///
///
type — String (default: "flat")
///
The type of the control. Can be either flat (default) or group. Determined automatically in databound mode.
///
///
filterable — Boolean (default: false)
///
Indicates whether the filter input must be visible or not.
///
///
filterable — Object
///
Indicates whether the filter input must be visible or not.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.mobile.ui, {
Loader: function() {
///
/// Constructor of kendo.mobile.ui.Loader
///
}
});
kendo.mobile.ui.Loader = (function() {
var original = kendo.mobile.ui.Loader;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
hide: function() {
///
///
/// Hide the loading animation.
///
///
},
show: function() {
///
///
/// Show the loading animation.
///
///
},
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.kendoLoader = function() {
this.data("kendoLoader", new kendo.mobile.ui.Loader());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoLoader: function() {
///
///
/// Returns a reference to the kendo.mobile.ui.Loader widget, instantiated on the selector.
///
/// The kendo.mobile.ui.Loader instance (if present).
///
},
kendoLoader: function(options) {
///
///
/// Instantiates a kendo.mobile.ui.Loader widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.mobile.ui, {
ModalView: function() {
///
/// Constructor of kendo.mobile.ui.ModalView
///
}
});
kendo.mobile.ui.ModalView = (function() {
var original = kendo.mobile.ui.ModalView;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
close: function() {
///
///
/// Close the ModalView
///
///
},
destroy: function() {
///
///
/// Prepares the ModalView 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.
///
///
},
open: function(target) {
///
///
/// Open the ModalView
///
/// (optional) The target of the ModalView
///
},
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.kendoModalView = function() {
this.data("kendoModalView", new kendo.mobile.ui.ModalView());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoModalView: function() {
///
///
/// Returns a reference to the kendo.mobile.ui.ModalView widget, instantiated on the selector.
///
/// The kendo.mobile.ui.ModalView instance (if present).
///
},
kendoModalView: function(options) {
///
///
/// Instantiates a kendo.mobile.ui.ModalView widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
height — Number
///
The height of the ModalView container in pixels. If not set, the element style is used.
///
///
modal — Boolean (default: true)
///
When set to false, the ModalView will close when the user taps outside of its element.
///
///
width — Number
///
The width of the ModalView container in pixels. If not set, the element style is used.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.mobile.ui, {
NavBar: function() {
///
/// Constructor of kendo.mobile.ui.NavBar
///
}
});
kendo.mobile.ui.NavBar = (function() {
var original = kendo.mobile.ui.NavBar;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
destroy: function() {
///
///
/// Prepares the NavBar 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.
///
///
},
title: function(value) {
///
///
/// Update the title element text. The title element is specified by setting the role data attribute to view-title.
///
/// The text of title
///
},
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.kendoNavBar = function() {
this.data("kendoNavBar", new kendo.mobile.ui.NavBar());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoNavBar: function() {
///
///
/// Returns a reference to the kendo.mobile.ui.NavBar widget, instantiated on the selector.
///
/// The kendo.mobile.ui.NavBar instance (if present).
///
},
kendoNavBar: function(options) {
///
///
/// Instantiates a kendo.mobile.ui.NavBar widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.mobile.ui, {
Pane: function() {
///
/// Constructor of kendo.mobile.ui.Pane
///
}
});
kendo.mobile.ui.Pane = (function() {
var original = kendo.mobile.ui.Pane;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
destroy: function() {
///
///
/// Prepares the Pane 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.
///
///
},
hideLoading: function() {
///
///
/// Hide the loading animation.
///
///
},
navigate: function(url,transition) {
///
///
/// Navigate the local or remote view.
///
/// The id or URL of the view.
/// The transition to apply when navigating. See View Transitions for more information.
///
},
showLoading: function() {
///
///
/// Show the loading animation.
///
///
},
view: function() {
///
///
/// Get a reference to the current view.
///
/// the view instance.
///
},
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.kendoPane = function() {
this.data("kendoPane", new kendo.mobile.ui.Pane());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoPane: function() {
///
///
/// Returns a reference to the kendo.mobile.ui.Pane widget, instantiated on the selector.
///
/// The kendo.mobile.ui.Pane instance (if present).
///
},
kendoPane: function(options) {
///
///
/// Instantiates a kendo.mobile.ui.Pane widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
collapsible — Boolean (default: false)
///
Applicable when the pane is inside a SplitView. If set to true, the pane will be hidden when the device is in portrait position. The expandPanes SplitView method displays the hidden panes.The id of the initial mobile View to display.
///
///
initial — String
///
The id of the initial mobile View to display.
///
///
layout — String
///
The id of the default Pane Layout.
///
///
loading — String (default: "Loading...")
///
The text displayed in the loading popup. Setting this value to false will disable the loading popup.
///
///
portraitWidth — Number
///
Sets the pane width in pixels when the device is in portrait position.
///
///
transition — String
///
The default View transition.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.mobile.ui, {
PopOver: function() {
///
/// Constructor of kendo.mobile.ui.PopOver
///
}
});
kendo.mobile.ui.PopOver = (function() {
var original = kendo.mobile.ui.PopOver;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
close: function() {
///
///
/// Close the popover.
///
///
},
destroy: function() {
///
///
/// Prepares the PopOver 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.
///
///
},
open: function(target) {
///
///
/// Open the PopOver.
///
/// The target of the Popover, to which the visual arrow will point to. This parameter is required for a tablet OS.
///
},
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.kendoPopOver = function() {
this.data("kendoPopOver", new kendo.mobile.ui.PopOver());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoPopOver: function() {
///
///
/// Returns a reference to the kendo.mobile.ui.PopOver widget, instantiated on the selector.
///
/// The kendo.mobile.ui.PopOver instance (if present).
///
},
kendoPopOver: function(options) {
///
///
/// Instantiates a kendo.mobile.ui.PopOver widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
pane — Object
///
The pane configuration options.
///
///
popup — Object
///
The popup configuration options.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.mobile.ui, {
ScrollView: function() {
///
/// Constructor of kendo.mobile.ui.ScrollView
///
}
});
kendo.mobile.ui.ScrollView = (function() {
var original = kendo.mobile.ui.ScrollView;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
content: function(content) {
///
///
/// Update the ScrollView HTML content.
///
/// The new ScrollView content.
///
},
destroy: function() {
///
///
/// Prepares the ScrollView 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.
///
///
},
refresh: function() {
///
///
/// Redraw the mobile ScrollView pager. Called automatically on device orientation change event.
///
///
},
scrollTo: function(page,instant) {
///
///
/// Scroll to the given page. Pages are zero-based indexed.
///
/// The page to scroll to.
/// If set to true, the ScrollView will jump instantly to the given page without any animation effects.
///
},
setDataSource: function(dataSource) {
///
///
/// Sets the DataSource of an existing ScrollView 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.kendoScrollView = function() {
this.data("kendoScrollView", new kendo.mobile.ui.ScrollView());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoScrollView: function() {
///
///
/// Returns a reference to the kendo.mobile.ui.ScrollView widget, instantiated on the selector.
///
/// The kendo.mobile.ui.ScrollView instance (if present).
///
},
kendoScrollView: function(options) {
///
///
/// Instantiates a kendo.mobile.ui.ScrollView 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 DataSource 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 DataSource specified in the configuration.Applicable only in data bound mode.
///
///
bounceVelocityThreshold — Number (default: 1.6)
///
The velocity threshold after which a swipe will result in a bounce effect.
///
///
contentHeight — Number|String (default: "auto")
///
The height of the ScrollView content. Supports 100% if the ScrollView is embedded in a stretched view and the ScrollView element is an immediate child of the view element.
///
///
dataSource — Object
///
Instance of DataSource that the mobile ScrollView will be bound to. If DataSource is set, the widget will operate in data bound mode.
///
///
duration — Number (default: 400)
///
The milliseconds that take the ScrollView to snap to the current page after released.
///
///
emptyTemplate — String (default: "")
///
The template which is used to render the pages without content. By default the ScrollView renders a blank page.Applicable only in data bound mode.
///
///
enablePager — Boolean (default: true)
///
If set to true the ScrollView will display a pager. By default pager is enabled.
///
///
itemsPerPage — Number (default: 1)
///
Determines how many data items will be passed to the page template.Applicable only in data bound mode.
///
///
page — Number (default: 0)
///
The initial page to display.
///
///
pageSize — Number (default: 1)
///
Multiplier applied to the snap amount of the ScrollView. By default, the widget scrolls to the next screen when swipe. If the pageSize property is set to 0.5, the ScrollView will scroll by half of the widget width.Not applicable in data bound mode.
///
///
template — String (default: "#:data#")
///
The template which is used to render the content of pages. By default the ScrollView renders a div element for every page.Applicable only in data bound mode.
///
///
velocityThreshold — Number (default: 0.8)
///
The velocity threshold after which a swipe will navigate to the next page (as opposed to snapping back to the current page).
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.mobile.ui, {
Scroller: function() {
///
/// Constructor of kendo.mobile.ui.Scroller
///
}
});
kendo.mobile.ui.Scroller = (function() {
var original = kendo.mobile.ui.Scroller;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
animatedScrollTo: function(x,y) {
///
///
/// Scrolls the scroll container to the specified location with animation. The arguments should be negative numbers.
///
/// The horizontal offset in pixels to scroll to.
/// The vertical offset in pixels to scroll to.
///
},
destroy: function() {
///
///
/// Prepares the Scroller 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 scrolling of the element.
///
///
},
enable: function() {
///
///
/// Enables the scrolling of the element after it has been disabled by calling disable.
///
///
},
height: function() {
///
///
/// Returns the viewport height of the scrollable element.
///
/// the viewport height in pixels.
///
},
pullHandled: function() {
///
///
/// Indicate that the pull event is handled (i.e. data from the server has been retrieved).
///
///
},
reset: function() {
///
///
/// Scrolls the container to the top.
///
///
},
scrollHeight: function() {
///
///
/// Returns the height in pixels of the scroller content.
///
///
},
scrollTo: function(x,y) {
///
///
/// Scrolls the container to the specified location. The arguments should be negative numbers.
///
/// The horizontal offset in pixels to scroll to.
/// The vertical offset in pixels to scroll to.
///
},
scrollWidth: function() {
///
///
/// Returns the width in pixels of the scroller content.
///
///
},
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.kendoScroller = function() {
this.data("kendoScroller", new kendo.mobile.ui.Scroller());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoScroller: function() {
///
///
/// Returns a reference to the kendo.mobile.ui.Scroller widget, instantiated on the selector.
///
/// The kendo.mobile.ui.Scroller instance (if present).
///
},
kendoScroller: function(options) {
///
///
/// Instantiates a kendo.mobile.ui.Scroller widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
zoom — Boolean (default: false)
///
If set to true, the user can zoom in/out the contents of the widget using the pinch/zoom gesture.
///
///
elastic — Boolean (default: true)
///
Weather or not to allow out of bounds dragging and easing.
///
///
pullOffset — Number (default: 140)
///
The threshold below which a releasing the scroller will trigger the pull event.
///
Has effect only when the pullToRefresh option is set to true.
///
///
pullTemplate — String (default: "Pull to refresh")
///
The message template displayed when the user pulls the scroller.
///
Has effect only when the pullToRefresh option is set to true.
///
///
pullToRefresh — Boolean (default: false)
///
If set to true, the scroller will display a hint when the user pulls the container beyond its top limit.
///
If a pull beyond the specified pullOffset occurs, a pull event will be triggered.
///
///
refreshTemplate — String (default: "Refreshing")
///
The message template displayed during the refresh.
///
Has effect only when the pullToRefresh option is set to true.
///
///
releaseTemplate — String (default: "Release to refresh")
///
The message template displayed when the user pulls the scroller below the pullOffset, indicating that pullToRefresh will occur.
///
Has effect only when the pullToRefresh option is set to true.
///
///
useNative — Boolean (default: false)
///
If set to true, the scroller will use the native scrolling available in the current platform. This should help with form issues on some platforms (namely Android and WP8).
///
Native scrolling is only enabled on platforms that support it: iOS > 4, Android > 2, WP8. BlackBerry devices do support it, but the native scroller is flaky.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.mobile.ui, {
SplitView: function() {
///
/// Constructor of kendo.mobile.ui.SplitView
///
}
});
kendo.mobile.ui.SplitView = (function() {
var original = kendo.mobile.ui.SplitView;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
destroy: function() {
///
///
/// Prepares the SplitView 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.
///
///
},
expandPanes: function() {
///
///
/// Displays the collapsible panes; has effect only when the device is in portrait orientation.
///
///
},
collapsePanes: function() {
///
///
/// Collapses back the collapsible panes (displayed previously with expandPanes); has effect only when the device is in portrait orientation.
///
///
},
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.kendoSplitView = function() {
this.data("kendoSplitView", new kendo.mobile.ui.SplitView());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoSplitView: function() {
///
///
/// Returns a reference to the kendo.mobile.ui.SplitView widget, instantiated on the selector.
///
/// The kendo.mobile.ui.SplitView instance (if present).
///
},
kendoSplitView: function(options) {
///
///
/// Instantiates a kendo.mobile.ui.SplitView widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
style — String (default: "horizontal")
///
Defines the SplitView style - horizontal or vertical.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.mobile.ui, {
Switch: function() {
///
/// Constructor of kendo.mobile.ui.Switch
///
}
});
kendo.mobile.ui.Switch = (function() {
var original = kendo.mobile.ui.Switch;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
check: function(check) {
///
///
/// Get/Set the checked state of the widget.
///
/// Whether to turn the widget on or off.
/// The checked state of the widget.
///
},
destroy: function() {
///
///
/// Prepares the Switch 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) {
///
///
/// Changes the enabled state of the widget.
///
/// Whether to enable or disable the widget.
///
},
toggle: function() {
///
///
/// Toggle the checked state of the widget.
///
///
},
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.kendoSwitch = function() {
this.data("kendoSwitch", new kendo.mobile.ui.Switch());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoSwitch: function() {
///
///
/// Returns a reference to the kendo.mobile.ui.Switch widget, instantiated on the selector.
///
/// The kendo.mobile.ui.Switch instance (if present).
///
},
kendoSwitch: function(options) {
///
///
/// Instantiates a kendo.mobile.ui.Switch widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
checked — Boolean (default: false)
///
The checked state of the widget.
///
///
enable — Boolean (default: true)
///
If set to false the widget will be disabled and will not allow the user to change its checked state. The widget is enabled by default.
///
///
offLabel — String (default: "OFF")
///
The OFF label.
///
///
onLabel — String (default: "ON")
///
The ON label.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.mobile.ui, {
TabStrip: function() {
///
/// Constructor of kendo.mobile.ui.TabStrip
///
}
});
kendo.mobile.ui.TabStrip = (function() {
var original = kendo.mobile.ui.TabStrip;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
badge: function(tab,value) {
///
///
/// Introduced in Q1 2013 SP Sets a badge on one of the tabs with the specified value. If invoked without second parameter, returns the tab's current badge value. Set the value to false to remove the badge.
///
/// The target tab specified either as a jQuery selector/object or as an item index.
/// The target value to be set or false to be removed.
/// Returns the badge value if invoked without parameters, otherwise returns the TabStrip object.
///
},
currentItem: function() {
///
///
/// Get the currently selected tab DOM element.
///
/// the currently selected tab DOM element.
///
},
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.
///
///
},
switchTo: function(url) {
///
///
/// Set the mobile TabStrip active tab to the tab with the specified URL. This method doesn't change the current View. To change the View, use Application's navigate method instead.
///
/// The URL or zero based index of the tab.
///
},
switchByFullUrl: function(url) {
///
///
/// Set the mobile TabStrip active tab to the tab with the specified full URL. This method doesn't change the current View. To change the View, use Application's navigate method instead.
///
/// The URL of the tab.
///
},
clear: function() {
///
///
/// Clear the currently selected tab.
///
///
},
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.mobile.ui.TabStrip());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoTabStrip: function() {
///
///
/// Returns a reference to the kendo.mobile.ui.TabStrip widget, instantiated on the selector.
///
/// The kendo.mobile.ui.TabStrip instance (if present).
///
},
kendoTabStrip: function(options) {
///
///
/// Instantiates a kendo.mobile.ui.TabStrip widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
selectedIndex — Number (default: 0)
///
The index of the initially selected tab.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.mobile.ui, {
View: function() {
///
/// Constructor of kendo.mobile.ui.View
///
}
});
kendo.mobile.ui.View = (function() {
var original = kendo.mobile.ui.View;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
contentElement: function() {
///
///
/// Retrieves the current content holder of the View - this is the content element if the View is stretched or the scroll container otherwise.
///
///
},
destroy: function() {
///
///
/// Prepares the View 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 the user interaction with the view and its contents.
///
/// Omitting the parameter or passing true enables the view. Passing false disables the 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.kendoView = function() {
this.data("kendoView", new kendo.mobile.ui.View());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoView: function() {
///
///
/// Returns a reference to the kendo.mobile.ui.View widget, instantiated on the selector.
///
/// The kendo.mobile.ui.View instance (if present).
///
},
kendoView: function(options) {
///
///
/// Instantiates a kendo.mobile.ui.View widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
model — String (default: null)
///
The MVVM model to bind to. If a string is passed, The view will try to resolve a reference to the view model variable in the global scope.
///
///
reload — Boolean (default: false)
///
Applicable to remote views only. If set to true, the remote view contents will be reloaded from the server (using Ajax) each time the view is navigated to.
///
///
stretch — Boolean (default: false)
///
If set to true, the view will stretch its child contents to occupy the entire view, while disabling kinetic scrolling.
///
Useful if the view contains an image or a map.
///
///
title — String
///
The text to display in the NavBar title (if present) and the browser title.
///
///
useNativeScrolling — Boolean (default: false)
///
If set to true, the view will use the native scrolling available in the current platform. This should help with form issues on some platforms (namely Android and WP8).
///
Native scrolling is only enabled on platforms that support it: iOS > 5+, Android > 3+, WP8. BlackBerry devices do support it, but the native scroller is flaky.
///
///
zoom — Boolean (default: false)
///
If set to true, the user can zoom in/out the contents of the view using the pinch/zoom gesture.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.mobile.ui, {
Widget: function() {
///
/// Constructor of kendo.mobile.ui.Widget
///
}
});
kendo.mobile.ui.Widget = (function() {
var original = kendo.mobile.ui.Widget;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
view: function() {
///
///
/// Returns the kendo.mobile.ui.View which contains the widget. If the widget is contained in a splitview, modalview, or drawer, the respective widget instance is returned.
///
///
},
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.kendoWidget = function() {
this.data("kendoWidget", new kendo.mobile.ui.Widget());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoWidget: function() {
///
///
/// Returns a reference to the kendo.mobile.ui.Widget widget, instantiated on the selector.
///
/// The kendo.mobile.ui.Widget instance (if present).
///
},
kendoWidget: function(options) {
///
///
/// Instantiates a kendo.mobile.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, {
AutoComplete: function() {
///
/// Constructor of kendo.ui.AutoComplete
///
}
});
kendo.ui.AutoComplete = (function() {
var original = kendo.ui.AutoComplete;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
close: function() {
///
///
/// Closes the widget suggestion popup.
///
///
},
dataItem: function(index) {
///
///
/// Returns the data item at the specified index.
///
/// The zero-based index of of the data item.
/// the data item at the specified index. Returns undefined if the index is not within bounds.
///
},
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(enable) {
///
///
/// Enables or disables the widget.
///
/// If set to true the widget will be enabled. If set to false the widget will be disabled.
///
},
focus: function() {
///
///
/// Focuses the widget.
///
///
},
readonly: function(readonly) {
///
///
/// Toggles the readonly state of the widget. When the widget is readonly it doesn't allow user input.
///
/// If set to true the widget will not allow user input. If set to false the widget will allow user input.
///
},
refresh: function() {
///
///
/// Refresh the suggestion popup by rendering all items again.
///
///
},
search: function(word) {
///
///
/// Searches the data source for the provided value and displays any matches as suggestions.
///
/// The value to search for. All matches are displayed in the suggestion popup.
///
},
select: function(item) {
///
///
/// Selects the item provided as an argument and updates the value of the widget.
///
/// A string, DOM element or jQuery object which represents the item to be selected. A string is treated as a jQuery selector.
///
},
setDataSource: function(dataSource) {
///
///
/// Sets the data source of the widget.
///
/// The data source to which the widget should be bound.
///
},
suggest: function(value) {
///
///
/// Sets the value of the widget to the specified argument and visually selects the text.
///
/// The value to set.
///
},
value: function(value) {
///
///
/// Gets or sets the value of the widget.
///
/// The value to set.
/// the value of the widget.
///
},
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.kendoAutoComplete = function() {
this.data("kendoAutoComplete", new kendo.ui.AutoComplete());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoAutoComplete: function() {
///
///
/// Returns a reference to the kendo.ui.AutoComplete widget, instantiated on the selector.
///
/// The kendo.ui.AutoComplete instance (if present).
///
},
kendoAutoComplete: function(options) {
///
///
/// Instantiates a kendo.ui.AutoComplete widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
animation — Object
///
Configures the opening and closing animations of the suggestion popup. Setting the animation option to false will disable the opening and closing animations. As a result the suggestion popup will open and close instantly.
///
///
dataSource — Object|Array
///
The data source of the widget which is used to display suggestions for the current value. 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.
///
///
dataTextField — String (default: null)
///
The field of the data item used when searching for suggestions. This is the text that will be displayed in the list of matched results.
///
///
delay — Number (default: 200)
///
The delay in milliseconds between a keystroke and when the widget displays the suggestion popup.
///
///
enable — Boolean (default: true)
///
If set to false the widget will be disabled and will not allow user input. The widget is enabled by default and allows user input.
///
///
filter — String (default: "startswith")
///
The filtering method used to determine the suggestions for the current value. The default filter is "startswith" -
///
all data items which begin with the current widget value are displayed in the suggestion popup. The supported filter values are startswith, endswith and contains.
///
///
height — Number (default: 200)
///
The height of the suggestion popup in pixels. The default value is 200 pixels.
///
///
highlightFirst — Boolean (default: true)
///
If set to true the first suggestion will be automatically highlighted.
///
///
ignoreCase — Boolean (default: true)
///
If set to false case-sensitive search will be performed to find suggestions. The widget performs case-insensitive searching by default.
///
///
minLength — Number (default: 1)
///
The minimum number of characters the user must type before a search is performed. Set to higher value than 1 if the search could match a lot of items.
///
///
placeholder — String (default: "")
///
The hint displayed by the widget when it is empty. Not set by default.
///
///
separator — String (default: "")
///
The character used to separate multiple values. Empty by default.
///
///
suggest — Boolean (default: false)
///
If set to true the widget will automatically use the first suggestion as its value.
///
///
headerTemplate — String|Function
///
Specifies a static HTML content, which will be rendered as a header of the popup element.
///
///
template — String|Function
///
The template used to render the suggestions. By default the widget displays only the text of the suggestion (configured via dataTextField).
///
///
valuePrimitive — Boolean (default: false)
///
Spcifies the value binding behavior for the widget when the initial model value is null. If set to true, the View-Model field will be updated with the selected item text field. If set to false, the View-Model field will be updated with the selected item.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.ui, {
Button: function() {
///
/// Constructor of kendo.ui.Button
///
}
});
kendo.ui.Button = (function() {
var original = kendo.ui.Button;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
enable: function(toggle) {
///
///
/// Enables or disables the Button.
///
/// Indicates whether the Button should be enabled or disabled. Truthy and falsy arguments are accepted. If no argument is supplied, the Button will assume true and will be enabled.
///
},
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.kendoButton = function() {
this.data("kendoButton", new kendo.ui.Button());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoButton: function() {
///
///
/// Returns a reference to the kendo.ui.Button widget, instantiated on the selector.
///
/// The kendo.ui.Button instance (if present).
///
},
kendoButton: function(options) {
///
///
/// Instantiates a kendo.ui.Button widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
enable — Boolean (default: true)
///
Indicates whether the Button should be enabled or disabled. By default, it is enabled, unless a disabled="disabled" attribute is detected.
///
///
icon — String
///
Defines a name of an existing icon in the Kendo UI theme sprite. The icon will be applied as background image of a span element inside the Button.
///
The span element can be added automatically by the widget, or an existing element can be used, if it has a k-icon CSS class applied.
///
For a list of available icon names, please refer to the Icons demo.
///
///
imageUrl — String
///
Defines a URL, which will be used for an img element inside the Button. The URL can be relative or absolute. In case it is relative, it will be evaluated with relation to the web page URL.The img element can be added automatically by the widget, or an existing element can be used, if it has a k-image CSS class applied.
///
///
spriteCssClass — String
///
Defines a CSS class (or multiple classes separated by spaces), which will be used for applying a background image to a span element inside the Button.
///
In case you want to use an icon from the Kendo UI theme sprite background image, it is easier to use the icon property.The span element can be added automatically by the widget, or an existing element can be used, if it has a k-sprite CSS class applied.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.ui, {
Calendar: function() {
///
/// Constructor of kendo.ui.Calendar
///
}
});
kendo.ui.Calendar = (function() {
var original = kendo.ui.Calendar;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
current: function() {
///
///
/// Gets currently focused date.
///
/// The current focused date shown in the calendar.
///
},
destroy: function() {
///
///
/// Prepares the Calendar 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.
///
///
},
max: function(value) {
///
///
/// Gets/Sets the max value of the calendar.
///
/// The max date to set.
/// The max value of the calendar.
///
},
min: function(value) {
///
///
/// Gets/Sets the min value of the calendar.
///
/// The min date to set.
/// The min value of the calendar.
///
},
navigate: function(value,view) {
///
///
/// Navigates to view.
///
/// Desired date.
/// Desired view.
///
},
navigateDown: function(value) {
///
///
/// Navigates to the lower view.
///
/// Desired date.
///
},
navigateToFuture: function() {
///
///
/// Navigates to the future.
///
///
},
navigateToPast: function() {
///
///
/// Navigates to the past.
///
///
},
navigateUp: function() {
///
///
/// Navigates to the upper view.
///
///
},
value: function(value) {
///
///
/// Gets/Sets the value of the calendar.
///
/// The date to set.
/// The value of the calendar.
///
},
view: function() {
///
///
/// Gets an instance of the current view used by the calendar.
///
/// The instance of the current view used by the calendar.
///
},
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.kendoCalendar = function() {
this.data("kendoCalendar", new kendo.ui.Calendar());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoCalendar: function() {
///
///
/// Returns a reference to the kendo.ui.Calendar widget, instantiated on the selector.
///
/// The kendo.ui.Calendar instance (if present).
///
},
kendoCalendar: function(options) {
///
///
/// Instantiates a kendo.ui.Calendar widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
culture — String (default: "en-US")
///
Specifies the culture info used by the widget.
///
///
dates — Array
///
Specifies a list of dates, which will be passed to the month template.
///
///
depth — String
///
Specifies the navigation depth. The following
///
settings are available for the depth value:
///
///
footer — String|Function
///
The template which renders the footer. If false, the footer will not be rendered.
///
///
format — String (default: "MM/dd/yyyy")
///
Specifies the format, which is used to parse value set with value() method.
///
///
max — Date (default: Date(2099, 11, 31))
///
Specifies the maximum date, which the calendar can show.
///
///
min — Date (default: Date(1900, 0, 1))
///
Specifies the minimum date, which the calendar can show.
///
///
month — Object
///
Templates for the cells rendered in "month" view.
///
///
start — String (default: "month")
///
Specifies the start view.
///
The following settings are available for the start value:
///
///
value — Date (default: null)
///
Specifies the selected date.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.ui, {
ColorPalette: function() {
///
/// Constructor of kendo.ui.ColorPalette
///
}
});
kendo.ui.ColorPalette = (function() {
var original = kendo.ui.ColorPalette;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
value: function(color) {
///
///
/// Get or set the selected color. If no argument is given, this returns the currently selected color as a string in format #FFFFFF.If one argument is given, it selects the new color and updates the UI. The argument can be a string in hex, rgb or rgba format, or a kendo.Color object object.
///
///
/// the string representation of the current color.
///
},
color: function(color) {
///
///
/// Get or set the selected color. If no argument is given, this returns the currently selected color as a kendo.Color object.
///
/// The color that should be set as the current value
/// the current value
///
},
enable: function(enable) {
///
///
/// Enables or disables the widget.
///
/// Whether the widget should be enabled (true) or disabled (false). If not specified, the method will enable the widget.
///
},
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.kendoColorPalette = function() {
this.data("kendoColorPalette", new kendo.ui.ColorPalette());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoColorPalette: function() {
///
///
/// Returns a reference to the kendo.ui.ColorPalette widget, instantiated on the selector.
///
/// The kendo.ui.ColorPalette instance (if present).
///
},
kendoColorPalette: function(options) {
///
///
/// Instantiates a kendo.ui.ColorPalette widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
palette — String|Array (default: "basic")
///
Specifies the color palette to display.
///
It can be a string with comma-separated colors in hex representation, an array of kendo.Color object objects or of strings that parseColor understands. As a shortcut, you can pass "basic" to get the simple palette (this is the default) or "websafe" to get the Web-safe palette.
///
///
columns — Number (default: 10)
///
The number of columns to display. When you use the "websafe" palette, this will automatically default to 18.
///
///
tileSize — Number (default: 14)
///
The size of a color cell.
///
///
tileSize — Object
///
The size of a color cell.
///
///
value — String (default: null)
///
Specifies the initially selected color.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.ui, {
ColorPicker: function() {
///
/// Constructor of kendo.ui.ColorPicker
///
}
});
kendo.ui.ColorPicker = (function() {
var original = kendo.ui.ColorPicker;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
close: function() {
///
///
/// Closes the popup.
///
///
},
open: function() {
///
///
/// Opens the popup element with the color selector.
///
///
},
toggle: function() {
///
///
/// Toggles the popup.
///
///
},
value: function(color) {
///
///
/// Get or set the selected color. If no argument is given, this returns the
/// currently selected color as a string in format #FFFFFF when the opacity
/// option is off, or rgba(255, 255, 255, 1) when opacity is requested.If one argument is given, it selects the new color and updates the UI. The
/// argument can be a string in hex, rgb or rgba format, or a Color object.
/// This does not trigger the "change" event.
///
///
/// the string representation of the current color.
///
},
color: function(color) {
///
///
/// Get or set the selected color. If no argument is given, this returns the currently selected color as a kendo.Color object.
///
/// The color that should be set as the current value
/// the current value
///
},
enable: function(enable) {
///
///
/// Enables or disables the widget.
///
/// Whether the widget should be enabled (true) or disabled (false). If not specified, the method will enable the widget.
///
},
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.kendoColorPicker = function() {
this.data("kendoColorPicker", new kendo.ui.ColorPicker());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoColorPicker: function() {
///
///
/// Returns a reference to the kendo.ui.ColorPicker widget, instantiated on the selector.
///
/// The kendo.ui.ColorPicker instance (if present).
///
},
kendoColorPicker: function(options) {
///
///
/// Instantiates a kendo.ui.ColorPicker widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
buttons — Boolean (default: true)
///
Specifies whether the widget should display the Apply / Cancel buttons.Applicable only for the HSV selector, when a pallete is not specified.
///
///
columns — Number
///
The number of columns to show in the color dropdown when a pallete is specified.
///
This is automatically initialized for the "basic" and "websafe" palettes.
///
If you use a custom palette then you can set this to some value that makes sense for your colors.
///
///
tileSize — Number (default: 14)
///
The size of a color cell.
///
///
tileSize — Object
///
The size of a color cell.
///
///
messages — Object
///
Allows customization of "Apply" / "Cancel" labels.
///
///
palette — String|Array (default: null)
///
When a non-null palette argument is supplied, the drop-down will be
///
a simple color picker that lists the colors. The following are supported:If palette is missing or null, the widget will display the HSV
///
selector.
///
///
opacity — Boolean (default: false)
///
Only for the HSV selector. If true, the widget will display the opacity slider.
///
Note that currently in HTML5 the does not support opacity.
///
///
preview — Boolean (default: true)
///
Only applicable for the HSV selector.Displays the color preview element, along with an input field where the end user can paste a color in a CSS-supported notation.
///
///
toolIcon — String (default: null)
///
A CSS class name to display an icon in the color picker button. If
///
specified, the HTML for the element will look like this:
///
///
value — String (default: null)
///
The initially selected color.
///
Note that when initializing the widget from an element, the initial color will be decided by the field instead.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.ui, {
ComboBox: function() {
///
/// Constructor of kendo.ui.ComboBox
///
}
});
kendo.ui.ComboBox = (function() {
var original = kendo.ui.ComboBox;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
close: function() {
///
///
/// Closes the widget popup.
///
///
},
dataItem: function(index) {
///
///
/// Returns the data item at the specified index. If the index is not specified, the selected index will be used.
///
/// The zero-based index of the data record.
/// The raw data record. Returns undefined if no data.
///
},
destroy: function() {
///
///
/// Prepares the ComboBox 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 the widget.
///
/// If set to true the widget will be enabled. If set to false the widget will be disabled.
///
},
readonly: function(readonly) {
///
///
/// Toggles the readonly state of the widget. When the widget is readonly it doesn't allow user input.
///
/// If set to true the widget will not allow user input. If set to false the widget will allow user input.
///
},
focus: function() {
///
///
/// Focuses the widget.
///
///
},
open: function() {
///
///
/// Opens the popup.
///
///
},
refresh: function() {
///
///
/// Refresh the popup by rendering all items again.
///
///
},
search: function(word) {
///
///
/// Searches the data source for the provided value and displays any matches as suggestions.
///
/// The filter value.
///
},
select: function(li) {
///
///
/// Selects the item provided as an argument and updates the value and text of the widget.
///
/// A string, DOM element or jQuery object which represents the item to be selected. A string is treated as a jQuery selector. A number representing the index of the item or function predicate which returns the correct data item.
/// The index of the selected item, if called with no parameters. If a custom value is entered, the returned selected index is -1. If called with a parameter as a setter.
///
},
setDataSource: function(dataSource) {
///
///
/// Sets the dataSource of an existing ComboBox and rebinds it.
///
///
///
},
suggest: function(value) {
///
///
/// Sets the value of the widget to the specified argument and visually selects the text.
///
/// Characters to force a suggestion.
///
},
text: function(text) {
///
///
/// Gets or sets the text of the ComboBox. Widget will select the item with same text. If
/// there are no matches then the text will be considered as a custom value of the widget.
///
/// The text to set.
/// The text of the combobox.
///
},
toggle: function(toggle) {
///
///
/// Opens or closes the widget popup.
///
/// Defines the whether to open/close the drop-down list.
///
},
value: function(value) {
///
///
/// Gets or sets the value of the combobox.
///
/// The value to set.
/// The value of the combobox.
///
},
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.kendoComboBox = function() {
this.data("kendoComboBox", new kendo.ui.ComboBox());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoComboBox: function() {
///
///
/// Returns a reference to the kendo.ui.ComboBox widget, instantiated on the selector.
///
/// The kendo.ui.ComboBox instance (if present).
///
},
kendoComboBox: function(options) {
///
///
/// Instantiates a kendo.ui.ComboBox widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
animation — Object
///
Configures the opening and closing animations of the suggestion popup. Setting the animation option to false will disable the opening and closing animations. As a result the suggestion popup will open and close instantly.
///
///
autoBind — Boolean (default: true)
///
Controls whether to bind the widget to the data source on initialization.
///
///
cascadeFrom — String
///
Use it to set the Id of the parent ComboBox widget.
///
Help topic showing how cascading functionality works
///
///
cascadeFromField — String
///
Defines the field to be used to filter the data source. If not defiend the parent's dataValueField option will be used.
///
Help topic showing how cascading functionality works
///
///
dataSource — Object|Array
///
The data source of the widget which is used to display a list of values. 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.
///
///
dataTextField — String (default: "")
///
The field of the data item that provides the text content of the list items. The widget will filter the data source based on this field.
///
///
dataValueField — String (default: "")
///
The field of the data item that provides the value of the widget.
///
///
delay — Number (default: 200)
///
The delay in milliseconds between a keystroke and when the widget displays the popup.
///
///
enable — Boolean (default: true)
///
If set to false the widget will be disabled and will not allow user input. The widget is enabled by default and allows user input.
///
///
filter — String (default: "none")
///
The filtering method used to determine the suggestions for the current value. Filtration is turned of by default.
///
The supported filter values are startswith, endswith and contains.
///
///
height — Number (default: 200)
///
The height of the suggestion popup in pixels. The default value is 200 pixels.
///
///
highlightFirst — Boolean (default: true)
///
If set to true the first suggestion will be automatically highlighted.
///
///
ignoreCase — String (default: true)
///
If set to false case-sensitive search will be performed to find suggestions. The widget performs case-insensitive searching by default.
///
///
index — Number (default: -1)
///
The index of the initially selected item. The index is 0 based.
///
///
minLength — Number (default: 1)
///
The minimum number of characters the user must type before a search is performed. Set to higher value than 1 if the search could match a lot of items.
///
///
placeholder — String (default: "")
///
The hint displayed by the widget when it is empty. Not set by default.
///
///
suggest — Boolean (default: false)
///
If set to true the widget will automatically use the first suggestion as its value.
///
///
headerTemplate — String|Function
///
Specifies a static HTML content, which will be rendered as a header of the popup element.
///
///
template — String|Function
///
The template used to render the items. By default the widget displays only the text of the data item (configured via dataTextField).
///
///
text — String (default: "")
///
The text of the widget used when the autoBind is set to false.
///
///
value — String (default: "")
///
The value of the widget.
///
///
valuePrimitive — Boolean (default: false)
///
Specifies the value binding behavior for the widget when the initial model value is null. If set to true, the View-Model field will be updated with the selected item value field. If set to false, the View-Model field will be updated with the selected item.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.ui, {
DatePicker: function() {
///
/// Constructor of kendo.ui.DatePicker
///
}
});
kendo.ui.DatePicker = (function() {
var original = kendo.ui.DatePicker;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
close: function() {
///
///
/// Closes the calendar.
///
///
},
destroy: function() {
///
///
/// Prepares the DatePicker 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) {
///
///
/// Enable/Disable the DatePicker widget.
///
/// The argument, which defines whether to enable/disable the DatePicker.
///
},
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 datepicker should be readonly or editable.
///
},
max: function(value) {
///
///
/// Gets/Sets the max value of the DatePicker.
///
/// The max date to set.
/// The max value of the DatePicker.
///
},
min: function(value) {
///
///
/// Gets/Sets the min value of the DatePicker.
///
/// The min date to set.
/// The min value of the DatePicker.
///
},
open: function() {
///
///
/// Opens the calendar.
///
///
},
value: function(value) {
///
///
/// Gets/Sets the value of the DatePicker.
///
/// The value to set.
/// The value of the DatePicker.
///
},
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.kendoDatePicker = function() {
this.data("kendoDatePicker", new kendo.ui.DatePicker());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoDatePicker: function() {
///
///
/// Returns a reference to the kendo.ui.DatePicker widget, instantiated on the selector.
///
/// The kendo.ui.DatePicker instance (if present).
///
},
kendoDatePicker: function(options) {
///
///
/// Instantiates a kendo.ui.DatePicker widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
animation — Object
///
Configures the opening and closing animations of the calendar popup. Setting the animation option to false will disable the opening and closing animations. As a result the calendar popup will open and close instantly.
///
///
ARIATemplate — String (default: "Current focused date is #=kendo.toString(data.current, 'D'#"))
///
Specifies a template used to populate value of the aria-label attribute.
///
///
culture — String (default: "en-US")
///
Specifies the culture info used by the widget.
///
///
dates — Array
///
Specifies a list of dates, which will be passed to the month template.
///
///
depth — String
///
Specifies the navigation depth. The following
///
settings are available for the depth value:
///
///
footer — String|Function
///
The template which renders the footer of the calendar. If false, the footer will not be rendered.
///
///
format — String (default: "MM/dd/yyyy")
///
Specifies the format, which is used to format the value of the DatePicker displayed in the input. The format also will be used to parse the input.
///
///
max — Date (default: Date(2099, 11, 31))
///
Specifies the maximum date, which the calendar can show.
///
///
min — Date (default: Date(1900, 0, 1))
///
Specifies the minimum date that the calendar can show.
///
///
month — Object
///
Templates for the cells rendered in the calendar "month" view.
///
///
parseFormats — Array
///
Specifies a lis of date formats used to parse the value set with value() method or by direct user input. If not set the value of the format will be used.
///
Note that format option is always used parsing process.
///
///
start — String (default: "month")
///
Specifies the start view.
///
The following settings are available for the start value:
///
///
value — Date (default: null)
///
Specifies the selected date.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.ui, {
DateTimePicker: function() {
///
/// Constructor of kendo.ui.DateTimePicker
///
}
});
kendo.ui.DateTimePicker = (function() {
var original = kendo.ui.DateTimePicker;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
close: function(view) {
///
///
/// Closes the calendar or the time drop-down list.
///
/// The view of the DateTimePicker, expressed as a string. Available views are "time" and "date".
///
},
destroy: function() {
///
///
/// Prepares the DateTimePicker 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 DateTimePicker.
///
/// Enables (true or undefined) or disables (false) a DateTimePicker.
///
},
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 datetimepicker should be readonly or editable.
///
},
max: function(value) {
///
///
/// Gets or sets the maximum value of the DateTimePicker.
///
/// The maximum time value to set for a DateTimePicker, expressed as a Date object or as a string.
/// The maximum time value of a DateTimePicker.
///
},
min: function(value) {
///
///
/// Gets or sets the minimum value of the DateTimePicker.
///
/// The minimum time value to set for a DateTimePicker, expressed as a Date object or as a string.
/// The minimum time value of a DateTimePicker.
///
},
open: function(view) {
///
///
/// Opens the calendar or the time drop-down list.
///
/// The view of the DateTimePicker, expressed as a string. Available views are "time" and "date".
///
},
toggle: function(view) {
///
///
/// Toggles the calendar or the time drop-down list.
///
/// The view of the DateTimePicker, expressed as a string. Available views are "time" and "date".
///
},
value: function(value) {
///
///
/// Gets or sets the value of the DateTimePicker.
///
/// The time value to set for a DateTimePicker, expressed as a Date object or as a string.
/// The time value of a DateTimePicker.
///
},
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.kendoDateTimePicker = function() {
this.data("kendoDateTimePicker", new kendo.ui.DateTimePicker());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoDateTimePicker: function() {
///
///
/// Returns a reference to the kendo.ui.DateTimePicker widget, instantiated on the selector.
///
/// The kendo.ui.DateTimePicker instance (if present).
///
},
kendoDateTimePicker: function(options) {
///
///
/// Instantiates a kendo.ui.DateTimePicker widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
animation — Object
///
Configures the opening and closing animations of the popups. Setting the animation option to false will disable the opening and closing animations. As a result the popup will open and close instantly.
///
///
ARIATemplate — String (default: "Current focused date is #=kendo.toString(data.current, 'G'#"))
///
Specifies a template used to populate value of the aria-label attribute.
///
///
culture — String (default: "en-US")
///
Specifies the culture info used by the widget.
///
///
dates — Array
///
Specifies a list of dates, which will be passed to the month template of the DateView. All dates, which match the date portion of the selected date will be used to re-bind the TimeView.
///
///
depth — String
///
Specifies the navigation depth of the calendar. The following
///
settings are available for the depth value:
///
///
footer — String
///
The template which renders the footer of the calendar. If false, the footer will not be rendered.
///
///
format — String (default: "MM/dd/yyyy h:mm tt")
///
Specifies the format, which is used to format the value of the DateTimePicker 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: Date(2099, 11, 31))
///
Specifies the maximum date, which the calendar can show.
///
///
min — Date (default: Date(1900, 0, 1))
///
Specifies the minimum date that the calendar can show.
///
///
month — Object
///
Templates for the cells rendered in the calendar "month" view.
///
///
parseFormats — Array
///
Specifies the formats, which are used to parse the value set with value() method or by direct input. If not set the value of the options.format and options.timeFormat will be used. Note that value of the format option is always used.
///
///
start — String (default: "month")
///
Specifies the start view of the calendar.
///
The following settings are available for the start value:
///
///
timeFormat — String (default: "h:mm tt")
///
Specifies the format, which is used to format the values in the time drop-down list.
///
///
value — Date (default: null)
///
Specifies the selected value.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.ui, {
Draggable: function() {
///
/// Constructor of kendo.ui.Draggable
///
}
});
kendo.ui.Draggable = (function() {
var original = kendo.ui.Draggable;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
cancelHold: function() {
///
///
/// Has effect only when holdToDrag is set to true. Cancels the activated state of the widget, caused by pressing and holding.
///
///
},
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.kendoDraggable = function() {
this.data("kendoDraggable", new kendo.ui.Draggable());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoDraggable: function() {
///
///
/// Returns a reference to the kendo.ui.Draggable widget, instantiated on the selector.
///
/// The kendo.ui.Draggable instance (if present).
///
},
kendoDraggable: function(options) {
///
///
/// Instantiates a kendo.ui.Draggable 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".
///
///
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.
///
///
distance — Number (default: 5)
///
The required distance that the mouse should travel in order to initiate a drag.
///
///
group — String (default: "default")
///
Used to group sets of draggable and drop targets. A draggable with the same group value as a drop target will be accepted by the drop target.
///
///
hint — Function
///
Provides a way for customization of the drag indicator. If a function is supplied, it receives one argument - the draggable element's jQuery object.
///
///
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 widget will be activated after the user taps and holds the finger on the element for a short amount of time.The draggable will also be activated by pressing, holding and lifting the finger without any movement. Dragging it afterwards will initiate the drag immediately. The activated mode can be canceled by calling cancelHold.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.ui, {
DropDownList: function() {
///
/// Constructor of kendo.ui.DropDownList
///
}
});
kendo.ui.DropDownList = (function() {
var original = kendo.ui.DropDownList;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
close: function() {
///
///
/// Closes the widget popup.
///
///
},
dataItem: function(index) {
///
///
/// Returns the data item at the specified index. If the index is not specified, the selected index will be used.
///
/// The zero-based index of the data record.
/// The raw data record. Returns undefined if no data.
///
},
destroy: function() {
///
///
/// Prepares the DropDownList 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.
///
///
},
focus: function() {
///
///
/// Focuses the widget.
///
///
},
open: function() {
///
///
/// Opens the popup.
///
///
},
enable: function(enable) {
///
///
/// Enables or disables the widget.
///
/// If set to true the widget will be enabled. If set to false the widget will be disabled.
///
},
readonly: function(readonly) {
///
///
/// Controls whether the widget is editable or readonly.
///
/// The argument, which defines whether the datepicker should be readonly or editable.
///
},
refresh: function() {
///
///
/// Refresh the popup by rendering all items again.
///
///
},
search: function(word) {
///
///
/// Selects an item, which starts with the provided value.
///
/// The search value.
///
},
select: function(li) {
///
///
/// Gets or sets the selected item. Selects the item provided as an argument and updates the value and text of the widget.
///
/// A string, DOM element or jQuery object which represents the item to be selected. A string is treated as a jQuery selector. A number representing the index of the item or function predicate which returns the correct data item.
/// The index of the selected item, if called with no parameters. If a custom value is entered, the returned selected index is -1. If called with a parameter as a setter.
///
},
setDataSource: function(dataSource) {
///
///
/// Sets the dataSource of an existing DropDownList and rebinds it.
///
///
///
},
text: function(text) {
///
///
/// Gets or sets the text of the dropdownlist.
///
/// The text to set.
/// The text of the dropdownlist.
///
},
toggle: function(toggle) {
///
///
/// Opens or closes the widget popup.
///
/// Defines the whether to open/close the drop-down list.
///
},
value: function(value) {
///
///
/// Gets or sets the value of the dropdownlist. The value will not be set if there is no item with such value. If value is undefined, text of the data item is used.
///
/// The value to set.
/// The value of the dropdownlist.
///
},
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.kendoDropDownList = function() {
this.data("kendoDropDownList", new kendo.ui.DropDownList());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoDropDownList: function() {
///
///
/// Returns a reference to the kendo.ui.DropDownList widget, instantiated on the selector.
///
/// The kendo.ui.DropDownList instance (if present).
///
},
kendoDropDownList: function(options) {
///
///
/// Instantiates a kendo.ui.DropDownList widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
animation — Object
///
Configures the opening and closing animations of the suggestion popup. Setting the animation option to false will disable the opening and closing animations. As a result the suggestion popup will open and close instantly.
///
///
autoBind — Boolean (default: true)
///
Controls whether to bind the widget to the data source on initialization.
///
///
cascadeFrom — String
///
Use it to set the Id of the parent dropdownlist widget.
///
Help topic showing how cascading functionality works
///
///
cascadeFromField — String
///
Defines the field to be used to filter the data source. If not defiend the parent's dataValueField option will be used.
///
Help topic showing how cascading functionality works
///
///
dataSource — Object|Array
///
The data source of the widget which is used to display a list of values. 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.
///
///
dataTextField — String (default: "")
///
The field of the data item that provides the text content of the list items. The widget will filter the data source based on this field.
///
///
dataValueField — String (default: "")
///
The field of the data item that provides the value of the widget.
///
///
delay — Number (default: 500)
///
Specifies the delay in milliseconds before the search-text typed by the end user is cleared.
///
///
enable — Boolean (default: true)
///
If set to false the widget will be disabled and will not allow user input. The widget is enabled by default and allows user input.
///
///
height — Number (default: 200)
///
The height of the suggestion popup in pixels. The default value is 200 pixels.
///
///
ignoreCase — String (default: true)
///
If set to false case-sensitive search will be performed to find suggestions. The widget performs case-insensitive searching by default.
///
///
index — Number (default: 0)
///
The index of the initially selected item. The index is 0 based.
///
///
optionLabel — String|Object (default: "")
///
Define the text of the default empty item. If the value is an object, then the widget will use it a valid data item.
///
Note that the optionLabel will not be available if the widget is empty.
///
///
headerTemplate — String|Function
///
Specifies a static HTML content, which will be rendered as a header of the popup element.
///
///
template — String|Function
///
The template used to render the items. By default the widget displays only the text of the data item (configured via dataTextField).
///
///
valueTemplate — String|Function
///
The valueTemplate used to render the selected value. By default the widget displays only the text of the data item (configured via dataTextField).
///
///
text — String (default: "")
///
The text of the widget used when the autoBind is set to false.
///
///
value — String (default: "")
///
The value of the widget.
///
///
valuePrimitive — Boolean (default: false)
///
Spcifies the value binding behavior for the widget when the initial model value is null. If set to true, the View-Model field will be updated with the selected item value field. If set to false, the View-Model field will be updated with the selected item.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.ui, {
DropTarget: function() {
///
/// Constructor of kendo.ui.DropTarget
///
}
});
kendo.ui.DropTarget = (function() {
var original = kendo.ui.DropTarget;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
destroyGroup: function() {
///
///
/// Destroys all DropTarget instances from the group with the given name.
///
///
},
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.kendoDropTarget = function() {
this.data("kendoDropTarget", new kendo.ui.DropTarget());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoDropTarget: function() {
///
///
/// Returns a reference to the kendo.ui.DropTarget widget, instantiated on the selector.
///
/// The kendo.ui.DropTarget instance (if present).
///
},
kendoDropTarget: function(options) {
///
///
/// Instantiates a kendo.ui.DropTarget widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
group — String (default: "default")
///
Used to group sets of draggable and drop targets. A draggable with the same group value as a drop target will be accepted by the drop target.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.ui, {
DropTargetArea: function() {
///
/// Constructor of kendo.ui.DropTargetArea
///
}
});
kendo.ui.DropTargetArea = (function() {
var original = kendo.ui.DropTargetArea;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
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.kendoDropTargetArea = function() {
this.data("kendoDropTargetArea", new kendo.ui.DropTargetArea());
return this;
};
intellisense.annotate(jQuery.fn, {
getKendoDropTargetArea: function() {
///
///
/// Returns a reference to the kendo.ui.DropTargetArea widget, instantiated on the selector.
///
/// The kendo.ui.DropTargetArea instance (if present).
///
},
kendoDropTargetArea: function(options) {
///
///
/// Instantiates a kendo.ui.DropTargetArea widget based the DOM elements that match the selector.
///
Accepts an object with the following configuration options:
///
///
group — String (default: "default")
///
Used to group sets of draggable and drop targets. A draggable with the same group value as a drop target will be accepted by the drop target.
///
///
filter — String (default: null)
///
Selector to filter the drop targets in the area. Every matched element acts as a drop target and fires events on the DropTargetArea. Specifying the filter is mandatory.
///
///
///
/// The widget configuration options
///
///
}
});
intellisense.annotate(kendo.ui, {
Editor: function() {
///
/// Constructor of kendo.ui.Editor
///
}
});
kendo.ui.Editor = (function() {
var original = kendo.ui.Editor;
var wrapper = function() {
var instance = new original();
intellisense.annotate(instance, {
createRange: function(document) {
///
///
/// Creates a W3C-compatible Range object.
///
/// The document that the range is associated with. If omitted, the document of the editor editing area will be used.
/// The created Range object.
///
},
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.
///
///
},
encodedValue: function() {
///
///
/// Gets the HTML encoded value of the editor.
///
///
},
exec: function(name,params) {
///
///
/// Executes an editor command on the currently selected text.
///
/// The name of the command to be executed.
/// The parameters for the executed command.
///
},
focus: function() {
///
///
/// Focuses the editable area.
///
///
},
getRange: function() {
///
///
/// Gets a Range object form the editable area.
///
/// A W3C-compatible Range object that represents the currently selected text in the editor area.
///
},
getSelection: function() {
///
///
/// Gets a W3C-compatible Selection object form the editable area.
///
/// a W3C-compatible Selection object form the editable area.
///
},
paste: function(html) {
///
///
/// Pastes HTML into the editable area. Cleans up MS Word formatting.
///
/// The HTML to be pasted.
///
},
selectedHtml: function() {
///
///
/// Serializes the currently selected text to a XHTML string.
///
/// The selectied text as valid XHTML.
///
},
refresh: function() {
///
///
/// Reinitializes the editing area iframe. Should be used after moving the editor in the DOM.
///
///
},
selectRange: function(range) {
///
///
/// Focuses the editable area and selects the range described by the range parameter.
///
/// The Range object that describes the new selection.
///
},
update: function() {
///
///
/// Serializes the current state of the editable area to the