DayTable |
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Developer’s Guide Home
Installation and Configuration Common Concepts Components Index Border Layout Panel Calendar Chart Command Button Command Link Composite Filter Confirmation Data Table Date Chooser Day Table Drop Down Field Dynamic Image Folding Panel For Each Graphic Text Hint Label Input Text Input Textarea Layered Pane Level Indicator Popup Layer Popup Menu Select Boolean Checkbox Select Many Checkbox Select One Radio Spinner Suggestion Field Tabbed Pane Tab Set Tree Table Two List Selection Window Focus Load Bundle Scroll Position Ajax Framework Validation Framework Tag Reference API Reference |
Key Features
Basic ConfigurationConfiguring Displayed EventsThe DayTable component can be added to a page using the <o:dayTable> tag. In order to get the simplest DayTable working you just need to specify the events attribute. This attribute should be specified as a value binding expression that refers a collection or array of TimetableEvent instances (or ReservedTimeEvent instances as described in the Specifying "Reserved Time" Events section below). The TimetableEvent class specifies the parameters for a single event in a timetable:
Although DayTable component displays events for one day at a time, it allows changing the current day thus making it possible to edit timetable for an arbitrary number of days. For this reason you should just provide events for all days through the events attribute, and the component will automatically separate these events onto days. It is also possible to avoid loading the whole data in case of dealing with large amounts of data, see the Handling Large Datasets section for details. Here's the simplest DayTable declaration that displays the specified events: <o:dayTable events="#{MyBean.timetableEvents}"/>
The backing bean class for MyBean should have the following method: public List getTimetableEvents() { List events = retrieveEvents(); // this should return a list of TimetableEvent instances return events; } This code displays a read-only timetable. In order to make it editable, you should specify the means by which the changes can be saved as described in the Adding Editing Capability section below. Specifying "Reserved Time" EventsBesides the usual events that commonly specify various activities, such as meetings, work periods, etc., there's also a special type of events called reserved time events that doesn't have name, description and color fields and which cannot be edited or removed. These events can be represented with instances of class ReservedTimetableEvent and they have the following fields: id, resourceId, start, end, customProperties. These events can be included in the displayed event list along with the usual events, and they are meant to be used for displaying the time intervals that shouldn't normally be occupied by normal events, e.g. launch breaks, etc. Adding Day SwitcherYou can add the interface that allows the user to view and switch the currently displayed day by placing the <o:daySwitcher> component into the "header" facet of <o:dayTable> tag. Here's a simple example: <o:dayTable events="#{TimeTableBean.events}"> <f:facet name="header"> <o:daySwitcher/> </f:facet> </o:dayTable> Please see the details in the Header and Footer and Navigation Between Days sections below. Adding Editing CapabilityThe editing capability can be added by specifying the timetableChangeListener attribute of <o:dayTable> tag. This attribute should be declared as a value binding expression that refers to a method with one parameter of TimetableChangeEvent type. This method will be invoked to save changes made by the user. The TimetableChangeEvent class has the following methods that can be used to identify the changes that need to be saved:
Changing Editing OptionsIt is possible to customize various parameters of event editing behavior by adding a <o:timetableEditingOptions> tag inside of the <o:dayTable> tag. By default the DayTable component automatically saves each change on the fly with Ajax. Though this functionality can be changed by specifying the autoSaveChanges attribute to false. Turning auto saving changes off will make the DayTable handle changes like any other editable component – the changes will be saved along with the nearest form submission. Regardless of whether auto saving functionality is used or not, the same mechanism for saving the changes is used as described in the previous section. The default duration for new events is 30 minutes. This default value can be changed by specifying the defaultEventDuration attribute. This attribute specifies the number of minutes as an integer number. It is possible to disable changing event duration by assigning "false" to the eventDurationEditable attribute. In addition, you can disable moving events from one resource to another by assigning "false" to the eventResourceEditable attribute. By default the user can create any configuration of events even if time spans of events overlap. Though it is possible to disable an ability to create overlapped events by assigning false to the overlappedEventsAllowed attribute. Note that will only prevent creating overlapped events by using the DayTable's editing capabilities, but it won't prevent displaying overlapped events if such events are provided through the component's data model. Handling Large DatasetsIf a component should deal with large sets of data, you can minimize the data loaded by the DayTable using the preloadedEvents attribute. It can take on of the two values:
Since the second mode loads data in portions, some additional logic should be implemented in the data retrieval method – the method that is bound to the events attribute of <o:dayTable> tag. When a DayTable with preloadedEvents of "none" invokes the data retrieval method, it assigns the two request-scope variables named startTime and endTime of type java.util.Date, which specify the time range for which events should be returned. All events which at least partially intersect the time period specified with these variables should be returned. Here's a simple example of defining the DayTable that loads events on demand as the user switches the days: <o:dayTable events="#{MyBean.timetableEvents}" preloadedNodes="none" /> ... public List getTimetableEvents() { Date startTime = Faces.var("startTime", Date.class); Date endTime = Faces.var("endTime", Date.class); List events = retrieveEventsInRange(startTime, endTime); return events; } Showing a Multi-Resource TimetableIt is possible to configure a DayTable component to display a timetable for multiple resources. In this case the DayTable is displayed in multiple columns, one column per resource. Each resource has an independent schedule, and this mode can be thought of as multiple schedules for the same day displayed on the same timetable for convenience. As an added benefit it's possible to move events between the resources. The multi-resource mode can be turned on by declaring the resources attribute of the dayTable tag. This attribute should be declared as a value binding expression that refers to a collection or array of TimetableResource instances. The TimetableResource class defines parameters for a single resource displayed in a timetable:
It is possible to specify the custom resource header components by specifying the "resourceHeader" facet for the dayTable tag. The component specified in this facet will be rendered in the resource column header cells. The declaration of the "resourceHeader" component can use the "resource" request-scope variable that refers to an instance of TimetableResource that corresponds to the currently rendered resource header. Here's an example of defining the multi-resource DayTable with custom resource headers displayed with a GraphicText component. <o:dayTable events="#{MyBean.timetableEvents}"> <f:facet name="resourceHeader"> <o:graphicText direction="15" value="#{resource.name}" style="font-family: Arial; font-size: 14pt;"/> </f:facet> </o:dayTable/> Header and FooterThe DayTable component has the header and footer areas that are displayed as the top and the bottom of the day table. The content of these areas can be specified with the "header" and "footer" facets of the <o:dayTable> tag. The styles for these areas can also be customized using corresponding headerStyle/headerClass and footerStyle/footerClass attributes. As described in the Showing a Multi-Resource Timetable section, the DayTable can also contain an additional header row that displays resource names. The style for this row can be customized with the resourceHeadersRowStyle/resourceHeadersRowClass attributes, and the style of the line that separates resource header row from events area can be specified with the resourceHeadersRowSeparator attribute, which is specified as the CSS border property but without the "border:" prefix, for example "1px solid gray". Navigation Between DaysThe DayTable component provides interface for switching the selected day. The navigation can be implemented using the exposed client side API that contains functions to swicth DayTable to next/previous day, for today or on any particular date (please refer to Client-Side API section for more information). The DaySwitcher ComponentThe DaySwitcher component is denoted by the <o:daySwitcher> tag. It can be placed within the DayTable component, inside its "header" and "footer" facets or somewhere else on the page. <o:dayTable id="conferenceSchedule" events="#{TimeTableBean.events}"> <f:facet name="header"> <o:daySwitcher/> </f:facet> </o:dayTable> The code above will produce the following output in the browser: In case when <o:daySwitcher> specified outside of day table the for attribute should point to id of the corresponding <o:dayTable>. <o:daySwitcher for="conferenceSchedule"/> Specifying Date Format for DaySwitcherThe DaySwitcher component provides ability to specify date format to display selected date. Here's examples of defining date format for DaySwitcher. <o:daySwitcher for="dayTable" pattern="MMMM, dd" upperPattern="yyyy"/> <o:daySwitcher for="dayTable" dateFormat="medium" upperPattern=""/> Customizing Appearance of DaySwitcherBesides the standard style and styleClass attributes DaySwitcher provides ability to set rolloverStyle and rolloverClass attributes. It is also possible to customize appearance of buttons and text using the following attributes:
InternationalizationThe DayTable allows specifying the locale used for displaying time strings using the locale attribute of <o:dayTable> tag. If not specified, the application's default locale is used, that is the locale returned by UIViewRoot's getLocale() method. All Date instances that a DayTable is working on, e.g. event start and end dates are interpreted in a time zone specified with the timeZone attribute of <o:dayTable> tag. If not specified explicitly, the server's default time zone as defined by the TimeZone.getDefault() method is used. It is also possible to customize all of the auxiliary texts and displayed by the component and its parts (day switcher, event editor, etc.), and patterns for formatting dates and times displayed in the component. Please refer to the Appearance Customization, Event Editor Dialog, and The DaySwitcher Component sections for details. Appearance CustomizationLike any other component, the style for the entire DayTable component can be customized with its style/styleClass attributes. Note that if the height CSS attribute is specified using these attributes then the DayTable component's scrollable mode is turned on automatically, which allows scrolling through the "invisible" part of the timeline using the vertical scrollbar. Customizing Time ScaleIt is possible to restrict the range of the displayed time range using the startTime and endTime attributes of the <o:dayTable> tag. Thes attributes should be specified in the "HH:mm" format, for example "16:00". Each of these attributes is optional, and if both of them are omitted then the whole time range from 00:00 to 24:00 is displayed. There's also the scrollTime attribute, works only for the scrollable DayTable (when it's height is specified), and it specifies the scroll position as the time in format "HH:mm" at the top component's border. For example, if "10:00" is specified, then the DayTable will be loaded to visually start from 10:00am though the user will be able to scroll the view to reveal the events before that time. The scrollTime attribute supports a two-side binding, which means that you can bind it to your backing bean to save the scroll position that might have been changted by the user. Note The time scale represented by the DayTable compnent has a two-fold subdivision: there are major time intervals, and each major time interval is separated onto minor time intervals. These time intervals are displayed as the table rows on top of which the events are displayed. By default, the major time interval corresponds to one hour, and a minor one corresponds to half an hour, which results in two minor intervals per one major one by default. The size of these intervals can be customized using the majorTimeInterval and minorTimeInterval attributes of the <o:dayTable> tag respectively. These attributes should be specified as an integer number specifying the interval's duration in minutes, and the default values are 60 and 30 respectively. Note that the value of majorTimeInterval should be a multiple of minorTimeInterval value. The separators displayed at major and minor intervals have different styles and they can be customized with the primaryRowSeparator and secondaryRowSeparator attributes, whose values are specified as the CSS border attribute value, but without the "border:" prefix, for example, "1px solid gray". The height and background CSS attributes of the time slot rows can be customized with the rowStyle/rowClass attributes of the <o:dayTable> tag. Time Column CustomizationThe style for the time column can be specified using the timeColumnStyle/timeColumnClass attributes. The style of the line that separates time column from the events are can be customized using the timeColumnSeparator attribute, which is specified in the same format as the primaryRowSeparator and secondaryRowSeparator attributes described above (for example "1px solid gray"). By default, the time strings in the time column are displayed in the H mm pattern, with the minute part being displayed as a superscript. Technically, the time string consists of two parts, displayed beside each other, where each part has its own time pattern and a style, which allows to display the minutes as superscript in the default display. The patterns for the first and the second part are specified with the timePattern and timeSuffixPattern attributes, which have the default values of "H" and "mm" respectively. The main part of time text, specified by the timePattern is displayed with the style inherited from the column class, as defined by the columnStyle/columnClass attributes. The style for the "time suffix" part of time string can be customized using the timeSuffixStyle/timeSuffixClass attributes. The horizontal time slot separators within the time column can be customized using the timeColumnPrimaryRowSeparator and timeColumnSecondaryRowSeparator attributes, which specify the style of grid lines for the primary time intervals and secondary time intervals respectively. As was mentioned in the Customizing Time Scale seciton, there are horizontal and minor time intervals. By default, the time column displays time only for the major intervals. You can turn on displaying time for the minor intervals by specifying the showTimeForMinorIntervals attribute with a value of true. The styles for major and minor time texts can be customized individually with the majorTimeStyle/majorTimeClass and minorTimeStyle/minorTimeClass attributes respectively. By default, the time text is displayed under the grid-line that marks the appropriate time. It is change the time text position so that it be displayed right against the appropriate grid-line. This can be done by specifying the timeTextPosition attribute with a value of "againstMark" (the default value is "underMark". Customizing Event AppearanceAs it was mentioned in the Configuring Displayed Events section, each event can be displayed with its individual color according to the color field of the event object. Though the value of the color field is optional and if it is not specified (has a value of null) then the appropriate event is displayed with the default event color. This color can be customized using the defaultEventColor attribute of <o:dayTable> tag. There's a range of settings that define various aspects of how events are displayed and behaving in the <o:timetableEvent> tag, which should be placed inside of <o:dayTable> tag. Event's border and background color is calculated automatically based on the event's color field. The CSS style for the events can be customized with the style and styleClass attributes of the <o:timetableEvent> tag. The border is displayed in the unchanged event's color, and the background color is displayed in the same color but of less intensity. The level of color intensity for event's background can be customized with the backgroundIntensity, which is specified as a double number in range 0..1. 0 corresponds to the least-intense color – white, and 1 corresponds to a fully intense color – a color specified for this event (the same color as used for displaying event's borders). The default value is 0.25 to ensure good reading contrast while still displaying the event color. Note that the behavior of automatic border and background calculation can be overridden by explicit specification of border and/or background CSS attributes in the style and styleClass attributes. The event's background also has a certain degree of transparency, which can be customized with the backgroundTransparency attribute, which is also specified as a double value in range 0..1 where 0 corresponds to fully opaque background and 1 means fully transparent one (the default value is 0.2). The style for the rollover event (the event located under the mouse pointer) can be customized using the rolloverStyle/rolloverClass attributes of the <o:timetableEvent> tag. By default, any HTML formatting characters contained in the event's name and description strings are escaped to show the pure textual representation as defined by the strings, which makes it impossible to use HTML constructs for example to highlight certain portions of name or description. The escaping behavior can be turned off by assigning false to the escapeName and/or escapeDescription attribute of the <o:timetableEvent> tag. The <o:timetableEvent> tag also has a set of attributes allowing to specify client-side event handlers for the HTML element that displays the timetable event: onclick, ondblclick, onmousedown, onmousemove, onmouseout, onmouseover, onmouseup. There's also an additional timetable-event-specific oncreate event, which is when a client-side representation element is created for each individual event. Each of these events receive the usual event variable, though this event variable has an additional field named timetableEvent, which refers to the client-side timetable event object for which the event is triggered. See the Client Side API section for details on this object. This allows adding custom interactions for the event's HTML representation elements. "Reserved Time" Events AppearanceAs it was mentioned in the Configuring Displayed Events section, there's a special type of events called "reserved events" and specified with ReservedTimeEvent instances in the event list. These events are displayed in a special way: they don't have a name and description and have a separate set of attributes that customize their appearance:
Customizing Event Action BarThe event action bar is an area that appears on the event's bottom side when hovering a mouse over the event element. It contains an auxiliary text that notifies of the "click on edit" behavior, and contains the event deletion button by default. The contents of the event action bar can be customized using the <o:eventActionBar> tag, which should be placed into the <o:dayTable> tag. Like background color of the event element, background color of the event action bar and its buttons is calculated using the event's color. The intensity of the action bar's background color can be customized using the backgroundIntensity attribute, and intensity for the various states of action bar's buttons is specified with the actionRolloverBackgroundIntensity/actionPressedBackgroundIntensity attributes. As usual, the style of the event action bar itself can be customized with the style/styleClass attributes. The text displayed in the action bar can be changed using the noteText attribute. And the main feature of the action bar is an ability to specify event-specific actions. By default, it just contains the "delete event" action, but you can add more events and/or remove the default one by placing one of the following tags inside of the <o:eventActionBar>:
When at least one action tag is added inside of <o:eventActionBar>, the default set of buttons (or just the "delete" button actually) is removed and replaced with the explicitly specified set of actions. In order to remove the default "delete" button you should place the deleteEventAction tag and specify its rendered attribute with a value of false. Each of the action tags has a set of attributes that specify its appearance: style/styleClass, roilloverStyle/rolloverClass, pressedStyle/pressedClass – for customizing the styles, and imageUrl/rolloverImageUrl/pressedImageUrl for customizing action button's images in various state. There's also the hint attribute, which specifies the tool tip text for the action button. The <o:deleteEventAction> tag has the showConfirmation attribute, which as the name says defines whether the event deletion confirmation will be shown when pressing the action button. The <o:eventAction> tag has the usual attributes that are normally available for all button tags: acitonListener and onclick for implementing server-side and client-side event handlers appropriately. Customizing Event Deletion ConfirmationThe appearance of the event deletion confirmation (if not turned off as described in the Customizing Event Action Bar section above) can be customized by adding the <o:confirmation> tag to the "deleteEventConfirmation" facet of the <o:dayTable} tag and customizing its attributes appropriately. Here's an example: <o:dayTable ...> <f:facet name="deleteEventConfirmation"> <o:confirmation message="Removing event" details="Proceed with removing?" okButtonText="YES" cancelButtonText="NO"/> </f:facet/> ... </o:dayTable> Attaching Additional Event AreasIf the standard output displayed in the event elements (name, description, action bar, etc.) is not enough, it is possible to attach custom output areas to event elements. This can be done by placing one or more <o:eventArea> tags inside of <o:dayTable> tag. Each <o:eventArea> defines an area that should be attached to each event element. Here's a simple example: <o:dayTable id="dayTable" eventVar="event" ...> <o:eventArea verticalAlignment="above"> <o:commandLink render="dayTable" actionListener="#{MyBean.postpone}" value="Postpone #{event.name}"/> </o:eventArea> ... </o:dayTable> ... public void postpone(ActionEvent actionEvent) { TimetableEvent event = Faces.var("event", TimetableEvent.class); ... } As you can see in the example, you can place any components into the <o:eventArea> tag and those components can use the request-scope variable whose name is specified in the eventVar attribute of the <o:dayTable> tag. This variable refers to the to the TimetableEvent whose event area is currently being rendered. Similarly, you can use the same variable in the event handler code to discover the TimetableEvent on which for which server-side event has been triggered. The <o:eventArea> tag has the following two attributes that define where the area is to be positioned relative to the event's rectangle: horizontalAlignment and verticalAlignment. The horizontalAlignment attribute can take one of the following values:
And the verticalAlignment attribute can take the following values:
The event area doesn't have any style of its own by default, though you can specify one using the style and styleClass attributes. As usual, there's also the client-side event handler attributes: onclick, ondblclick, onmousedown, onmousemove, onmouseout, onmouseover, onmouseup. It is possible to attach several event areas by specifying several <o:eventArea> tags. Displaying Event PreviewIn certain application scenarios, event description can be quite a long one and since event height is identified by event's duration it might not be possible to read the full description in some cases. This can be solved by displaying the "event preview" area when the mouse hovers over an event for some time. This functionality can be turned on by placing the <o:eventPreview> tag to the <o:dayTable> tag. Adding this tag will make the event preview rectangle to be displayed above the element automatically when the mouse hovers over the event for a while. The event preview area will show the full event name and description. The delay after which the preview is shown can be customized by specifying the appropriate number of milliseconds in the showingDelay tag of the <o:eventPreview> tag. The position relative to the event rectangle is customized with the horizontalAlignment and verticalAlignment attributes, which have the same values as the analogous attributes of the eventArea tag described in the Attaching Additional Event Areas section above. In addition to the alignment attributes, it's also possible to specify the distance between the event rectangle and the event preview rectangle using the horizontalDistance and verticalDistance attributes. The event preview is automatically hidden when the user moves the mouse pointer out of the event rectangle. The style for the event preview itself can be customized with the style/styleClass attributes, and the style for event name and description with the eventNameStyle/eventNameClass and eventDescriptionStyle/eventDescriptionClass respectively. Customizing EffectsThe DayTable component smoothens transition between time-slots when using event drag&drop. That is, when a user drags an event to another time slot, the event doesn't "jump" to the new position instantaneously but is gradually moved to the new position. The speed of this transition can be customized with the dragAndDropTransitionPeriod attribute which accepts the transition duration as a number in milliseconds. The default value is 70. You can turn off smooth transition by specifying 0 as the value for this attribute. When time-overlapping events are disabled with the overlappedEventsAllowed attribute of the <o:timetableEditingOptions> tag, and the user is trying to drag an event over another event or resize it so that it becomes overlapped with some other event, the DayTable returns the event to its original position as it was before moving/resizing. This is also done by gradual transition of event's rectangle instead of just "jumping" to the original place, and the duration for this transition is customizible with the dragAndDropCancelingPeriod. In addition, while a user is dragging an event and it is an "undroppable" position (that is over another event), the DayTable makes the dragged event semitransparent to let the user know of this situation. The transparency level for the "undroppable" state can be customized with the undroppableEventTransparency attribute (as a double number in range 0..1), and the gradual transition period to and from "undroppable" state is customizible with the undroppableStateTransitionPeriod attribute. Customizing Event EditorWhen a user clicks an event of an editable DayTable or clicks an empty area to create a new event, the event editor is shown. The default behavior is showing a dialog for event editing, though the kind of event editor and its appearance can be customized using the "eventEditor" facet of <o:dayTable> tag. There are two kinds of event editors that can be specified in this facet:
Event Editor DialogYou can customize the default event editor dialog by placing the <o:eventEditorDialog> tag into the "eventEditor" facet of <o:dayTable> tag. Event editor dialog is displayed as a modal window, so most of the customization settings available for the Window component are available for the EventEditorDialog component as well. That is you can customize window options with the following attributes:
The window's caption can be customized with the createEventCaption and editEventCaption attributes which specify a caption text to be shown in an editor window in case of creating a new event and editing an existing event respectively. The texts for field labels and buttons in the editor dialog can be customized with the following attributes: nameLabel, resourceLabel, startLabel, endLabel, descriptionLabel, okButtonText, cancelButtonText, and deleteButtonText. Style for the labels can be customized using the labelStyle/labelClass attributes. Button styles are customizeable using the following attributes: okButtonStyle/okButtonClass, cancelButtonStyle/cancelButtonClass, deleteButtonStyle/deleteButtonClass. You can customize the style and appearance of all editing fields by placing the properly customized components into the appropriate facets as shown below. Note that no data-specific configuration should be performed when declaring the components because the data is managed by the dialog automatically. Instead, you can specify the style and appearance-related attributes to make these components look in an application-specific manner.
Here's an example that demonstrates customizing editor dialog's caption, labels and some of the editor fields: <o:dayTable ...> <f:facet name="eventEditor"> <o:eventEditorDialog labelStyle="font: normal 10pt Tahoma, Arial; color: darkgrey" captionStyle="font: normal 12pt Tahoma, Arial; color: darkgrey" deleteButtonStyle="color: red;"> <f:facet name="nameField"> <h:inputText style="color: blue"/> </f:facet> <f:facet name="startDateField"> <o:dateChooser fieldStyle="color: blue" calendarStyle="border: 1px solid blue"/> </f:facet> <f:facet name="descriptionArea"> <o:inputTextarea promptText="Enter event description here"/> </f:facet> </o:eventEditorDialog> </f:facet> ... </o:dayTable> Like the ordinary Window component, the event editor dialog has all of the standard events (onclick, ondblclick, onmousedown, onmouseover, onmousemove, onmouseout, onmouseup, onkeydown, onkeyup, onhkeypress), and two custom events onshow and onhide that are fired when the window is shown and hidden respectively. Event Editor PageYou can replace the standard event editor dialog with a custom page for editing an event by placing the <o:eventEditorPage> tag into the "eventEditor" facet of <o:dayTable> tag. You can specify the actual event editor page in two ways:
All of the parameters of the edited (or created) event are passed in the following request parameters:
(*) You can simplify retrieving the request parameters by using the org.openfaces.util.Faces.var(String varName) function. Note that these are passed as request parameters to the first request of the specified page and are not resubmitted automatically upon with a next request, so you'll need to save them in a "session" or another appropriate scope to save these parameters between requests. Your custom editor page should process these parameters and configure the editing components appropriately. You can use the provided eventId for retrieval of all data data for the edited event. Upon pressing on the "Save" button (or any analog on your page) you should manually update the underlying data storage for the DayTable component (or add a new event in case of event creation) and navigate back to the DayTable page. Custom Event EditorYou can create a custom event editor by placing the <o:customEventEditor> tag into the "eventEditor" facet of <o:dayTable> tag. This tag has the following two attributes:
In both cases the code specified in these attributes has access to following variables
The custom event editor should update the passed timetableEvent instance and invoke the following client-side methods of DayTable component depending on situation:
See the Client-Side API section for the description of all DayTable's client-side methods and event object fields. Client-Side APIAll client-side API methods for the DayTable component are listed in the following table:
The client-side timetable event objects manipulated by the methods mentioned above are direct counterparts of server-side TimetableEvent instances. The timetable event objects have the following structure:
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
© 2010 TeamDev Ltd. | ![]() |