Файл: book-of-vaadin.pdf

Vaadin Calendar

createEvent(details, transferable); removeTableRow(transferable);

}

public AcceptCriterion getAcceptCriterion() { return AcceptAll.get();

}

});

return calendar;

}

protected void createEvent(CalendarTargetDetails details, TableTransferable transferable) {

Date dropTime = details.getDropTime();

java.util.Calendar timeCalendar = details.getTargetCalendar()

.getInternalCalendar();

timeCalendar.setTime(dropTime); timeCalendar.add(java.util.Calendar.MINUTE, 120); Date endTime = timeCalendar.getTime();

Item draggedItem = transferable.getSourceComponent(). getItem(transferable.getItemId());

String eventType = (String)draggedItem. getItemProperty("type").getValue();

String eventDescription = "Attending: " + getParticipantString(

(String[]) draggedItem. getItemProperty("participants").getValue());

BasicEvent newEvent = new BasicEvent(); newEvent.setAllDay(!details.hasDropTime()); newEvent.setCaption(eventType); newEvent.setDescription(eventDescription); newEvent.setStart(dropTime); newEvent.setEnd(endTime);

BasicEventProvider ep = (BasicEventProvider) details

.getTargetCalendar().getEventProvider(); ep.addEvent(newEvent);

}

18.7. Using the Context Menu

Vaadin Calendar allows the use of context menu (mouse right-click) to manage events. As in other context menus in Vaadin, the menu items are handled in Vaadin as actions by an action handler. To enable a context menu, you have to implement a Vaadin Action.Handler and add it to the calendar with addActionHandler().

An action handler must implement two methods: getActions() and handleAction(). The getActions() is called for each day displayed in the calendar view. It should return a list of allowed actions for that day, that is, the items of the context menu. The target parameter is the context of the click - a CalendarDateRange that spans over the day.The sender is the Calendar object.

The handleActions() receives the target context in the target. If the context menu was opened on an event, the target is the Event object, otherwise it is a CalendarDateRange.

Vaadin Calendar

18.8. Localization and Formatting

18.8.1. Setting the Locale and Time Zone

Month and weekday names are shown in the language of the locale setting of the Calendar. The translations are acquired from the standard Java locale data. By default, Calendar uses the system default locale for its internal calendar, but you can change it with setLocale(Locale locale). Setting the locale will update also other location specific date and time settings, such as the first day of the week, time zone, and time format. However, time zone and time format can be overridden by settings in the Calendar.

For example, the following would set the language to US English:

cal.setLocale(Locale.US);

The locale defines the default time zone. You can change it with the setTimeZone() method, which takes a java.util.TimeZone object as its parameter. Setting timezone to null will reset timezone to the locale default.

For example, the following would set the Finnish time zone, which is EET

cal.setTimeZone(TimeZone.getTimeZone("Europe/Helsinki"));

18.8.2. Time and Date Caption Format

The time may be shown either in 24 or 12 hour format.The default format is defined by the locale, but you can change it with the setTimeFormat() method. Giving a null setting will reset the time format to the locale default.

cal.setTimeFormat(TimeFormat.Format12H);

You can change the format of the date captions in the week view with the setWeeklyCaptionFormat(String dateFormatPattern) method.The date format pattern should follow the format of the standard Java java.text.SimpleDateFormat class.

For example:

cal.setWeeklyCaptionFormat("dd-MM-yyyy");

18.9. Customizing the Calendar

In this section, we give a tutorial for how to make various basic customizations of the Vaadin Calendar. The event provider and styling was described earlier, so now we concentrate on other features of the Calendar API.

We use example code to demonstrate the customizations. You can find the source code of the example application on-line with the name CustomizedCalendarDemo at http://dev.vaadin.com/svn/addons/Calendar. Some of the less important code for this document has been left out to make the code more readable and shorter.

18.9.1. Overview of Handlers

Most of the handlers related to calendar events have sensible default handlers. These are found in the com.vaadin.ui.handler package.The default handlers and their functionalities are described below.

Vaadin Calendar

•BasicBackwardHandler. Handles clicking the back-button of the weekly view so that the viewed month is changed to the previous one.

•BasicForwardHandler. Handles clicking the forward-button of the weekly view so that the viewed month is changed to the next one.

•BasicWeekClickHandler. Handles clicking the week numbers int the monthly view so that the viewable date range is changed to the clicked week.

•BasicDateClickHandler. Handles clicking the dates on both the monthly view and the weekly view. Changes the viewable date range so that only the clicked day is visible.

•BasicEventMoveHandler. Handles moving the events in both monthly view and the weekly view. Events can be moved and their start and end dates are changed correctly, but only if the event implements CalendarEventEditor (implemented by BasicEvent).

•BasicEventResizeHandler. Handles resizing the events in the weekly view. Events can be resized and their start and end dates are changed correctly, but only if the event implements CalendarEventEditor (implemented by the BasicEvent).

All of these handlers are automatically set when creating a new Calendar. If you wish to disable some of the default functionality, you can simply set the corresponding handler to null. This will prevent the functionality from ever appearing on the user interface. For example, if you set the EventMoveHandler to null, the user will be unable to move events in the browser.

18.9.2. Creating a Calendar

Let us first create a new Calendar instance. Here we use our own event provider, the MyEventProvider described in Section 18.4.2, “Implementing the Event Provider”.

Calendar cal = new Calendar(new MyEventProvider());

This initializes the Calendar. To customize the viewable date range, we must set a start and end date to it.

There is only one visible event in the timeline, starting from the current time. That is what our event provider passes to the client.

It would be nice to also be able to control the navigation forward and backward. The default navigation is provided by the default handlers, but perhaps we want to restrict the users so they can only navigate dates in the current year. Maybe we also want to pose some other restrictions to the clicking week numbers and dates.

These restrictions and other custom logic can be defined with custom handlers.You can find the handlers in the com.vaadin.addon.calendar.ui.handler package and they can be easily extended. Note that if you don not want to extend the default handlers, you are free to implement your own. The interfaces are described in CalendarComponentEvents.

18.9.3. Backward and Forward Navigation

Vaadin Calendar has only limited built-in navigation support. The weekly view has navigation buttons in the top left and top right corners.

You can handle backward and forward navigation with a BackwardListener and

ForwardListener.

Vaadin Calendar

cal.setHandler(new BasicBackwardHandler() { protected void setDates(BackwardEvent event,

Date start, Date end) {

java.util.Calendar calendar = event.getComponent()

.getInternalCalendar();

if (isThisYear(calendar, end)

&& isThisYear(calendar, start)) { super.setDates(event, start, end);

}

}});

The forward navigation handler can be implemented in the same way. The example handler restricts the dates to the current year.

18.9.4. Date Click Handling

By default, clicking a date either in month or week view switches single-day view. The date click event is handled by a DateClickHandler.

The following example handles click events so that when the user clicks the date header in the weekly view, it will switch to single-day view, and in the single-day view switch back to the weekly view.

cal.setHandler(new BasicDateClickHandler() { public void dateClick(DateClickEvent event) {

Calendar cal = event.getComponent();

long currentCalDateRange = cal.getEndDate().getTime()

- cal.getStartDate().getTime();

if (currentCalDateRange < VCalendar.DAYINMILLIS) {

//Change the date range to the current week cal.setStartDate(cal.getFirstDateForWeek(event.getDate())); cal.setEndDate(cal.getLastDateForWeek(event.getDate()));

}else {

//Default behaviour, change date range to one day super.dateClick(event);

}

}

});

18.9.5. Handling Week Clicks

The monthly view displays week numbers for each week row on the left side of the date grid. The week number are clickable and you can handle the click events by setting a WeekClickHandler for the Calendar object. The default handler changes the date range to be the clicked week.

In the following example, we add a week click handler that changes the date range of the calendar to one week only if the start and end dates of the week are in the current month.

cal.setHandler(new BasicWeekClickHandler() { protected void setDates(WeekClick event,

Date start, Date end) { java.util.Calendar calendar = event.getComponent()

.getInternalCalendar(); if (isThisMonth(calendar, start)

&& isThisMonth(calendar, end)) { super.setDates(event, start, end);

}

}

});

Vaadin Calendar

18.9.6. Handling Event Clicks

The calendar events in all views are are clickable. There is no default handler. Just like the date and week click handlers, event click handling is enabled by setting an EventClickHandler for the Calendar object.

You can get hold of the clicked event by the getCalendarEvent() method in the EventClick object passed to the handler, as shown in the following example.

cal.addListener(new EventClickListener() { public void eventClick(EventClick event) {

BasicEvent e = (BasicEvent) event.getCalendarEvent();

// Do something with it

new Notification("Event clicked: " + e.getCaption(), e.getDescription()).show(Page.getCurrent());

}

});

18.9.7. Event Dragging

The user can drag an event to change its position in time. The default handler sets the start and end time of the event accordingly. You can do many things with a custom move handler, such as restrict moving events.

In the following example, we add a EventMoveHandler to a Calendar. The event handler updates the new position to the datasource, but only if the new dates are in the current month. This requires making some changes to the event provider class.

cal.setHandler(new BasicEventMoveHandler() { private java.util.Calendar javaCalendar;

public void eventMove(MoveEvent event) {

javaCalendar = event.getComponent().getInternalCalendar(); super.eventMove(event);

}

protected void setDates(CalendarEventEditor event, Date start, Date end) {

if (isThisMonth(javaCalendar, start)

&& isThisMonth(javaCalendar, end)) { super.setDates(event, start, end);

}

}

});

For the above example to work, the example event provider presented earlier needs to be changed slightly so that it doesn't always create a new event when getEvents() is called.

public static class MyEventProvider

implements CalendarEventProvider { private List<CalendarEvent> events =

new ArrayList<CalendarEvent>();

public MyEventProvider() {

events = new ArrayList<CalendarEvent>(); GregorianCalendar cal = new GregorianCalendar(); cal.setTime(new Date());

Date start = cal.getTime(); cal.add(GregorianCalendar.HOUR, 5); Date end = cal.getTime();