Appointment,
+ * coordinates of the drop, etc.
+ */
+ @Override
+ public void onDrop(final DragContext context) {
+ super.onDrop(context);
+
+ for (Element elem : highlightedCells) {
+ if (elem != null) {
+ DOM.setStyleAttribute(elem, BACKGROUND, "#FFFFFF");
+ }
+ }
+ highlightedCells = null;
+
+ Draggable draggable = draggableList.get(0);
+
+ Appointment appointment =
+ ((AppointmentWidget) context.draggable).getAppointment();
+
+ long originalStartToEndTimeDistance =
+ appointment.getEnd().getTime() - appointment.getStart().getTime();
+
+ //get the column and row for the draggable widget
+ int row = getRow(context, draggable) - 1;
+ int col = getColumn(context, draggable);
+ int cell = row * daysPerWeek + col;
+
+ //calculate the new start & end dates
+ Date newStart = DateUtils.shiftDate(firstDateDisplayed, cell);
+ DateUtils.copyTime(appointment.getStart(), newStart);
+
+ Date newEnd = new Date(newStart.getTime() + originalStartToEndTimeDistance);
+
+ //Set the appointment's new start & end dates
+ appointment.setStart(newStart);
+ appointment.setEnd(newEnd);
+ }
+
+ /**
+ * Gets all the cells (as DOM Elements) that an appointment spans. Note: It
+ * only includes cells in the table. If an appointment ends in the following
+ * month the last cell in the list will be the last cell in the table.
+ *
+ * @param row Appointment's starting row
+ * @param col Appointment's starting column
+ * @param days Number of days an appointment spans
+ * @return Cell elements that an appointment spans
+ */
+ protected Element[] getCells(int row, int col, int days) {
+
+ Element[] elems = new Element[days];
+
+ for (int i = 0; i < days; i++) {
+ if (col > daysPerWeek - 1) {
+ col = 0;
+ row++;
+ }
+
+ /*
+ * Cheap code here. If the row / cell throw an out of index exception
+ * we just break. This kind of sucks because we have to
+ * now account for null items in the Element[] array.
+ */
+ try {
+ elems[i] = monthGrid.getFlexCellFormatter().getElement(row, col);
+ } catch (Exception ex) {
+ break;
+ }
+
+ col++;
+ }
+
+ return elems;
+ }
+
+ public int getRow(final DragContext context, final Draggable draggable) {
+ int y =
+ context.desiredDraggableY - dropTargetOffsetY + draggable.relativeY;
+ return (int)
+ Math.floor(y / (monthGrid.getOffsetHeight() / weeksPerMonth)) + 1;
+ }
+
+ public int getColumn(final DragContext context, final Draggable draggable) {
+ int x =
+ context.desiredDraggableX - dropTargetOffsetX + draggable.relativeX;
+ return (int)
+ Math.floor(x / (monthGrid.getOffsetWidth() / daysPerWeek));
+ }
+}
diff --git a/src/com/allen_sauer/gwt/dnd/client/drop/MonthViewPickupDragController.java b/src/com/allen_sauer/gwt/dnd/client/drop/MonthViewPickupDragController.java
new file mode 100644
index 0000000..0776089
--- /dev/null
+++ b/src/com/allen_sauer/gwt/dnd/client/drop/MonthViewPickupDragController.java
@@ -0,0 +1,19 @@
+package com.allen_sauer.gwt.dnd.client.drop;
+
+import com.allen_sauer.gwt.dnd.client.PickupDragController;
+import com.google.gwt.user.client.ui.AbsolutePanel;
+
+public class MonthViewPickupDragController extends PickupDragController {
+
+ public MonthViewPickupDragController(AbsolutePanel boundaryPanel,
+ boolean allowDroppingOnBoundaryPanel) {
+ super(boundaryPanel, allowDroppingOnBoundaryPanel);
+ }
+
+ @Override
+ public void dragMove() {
+ try {
+ super.dragMove();
+ } catch(NullPointerException ex) { }
+ }
+}
diff --git a/src/com/biomed/Biomed.gwt.xml b/src/com/biomed/Biomed.gwt.xml
index b7ebf1a..d4bf386 100644
--- a/src/com/biomed/Biomed.gwt.xml
+++ b/src/com/biomed/Biomed.gwt.xml
@@ -43,4 +43,7 @@
Appointment class provides a set of text-based properties to
+ * describe it, including a title, description, location, createdBy,
+ * etc. Additional to these, there is a set of properties that exist to provide
+ * the gwt-cal components with information useful during the
+ * Appointment rendering in the widget views (allDay,
+ * recurring, etc.)
+ *
+ *
+ * All Appointment properties are ultimately used by the gwt-cal
+ * views and it is up to these components to decide how to render (if at all)
+ * them as well as to provide appropriate runtime features to modify them.
+ *
+ * Creates an Appointment with the following attributes set to
+ * null
+ *
+ *
titledescriptionstartendlocationcreatedByattendees collection empty the allDay and
+ * the readOnly property false.
+ *
+ *
+ */
+ public Appointment() {
+
+ }
+
+ /**
+ * Returns the unique identifier for this Appointment. The
+ * field is optional (and not used by gwt-cal) and therefore may be null.
+ *
+ * @return A unique identifier for this Appointment (optional).
+ */
+ public String getId() {
+ return id;
+ }
+
+ /**
+ * Sets the unique identifier of this Appointment. This
+ * identifier is optional.
+ *
+ * @param id Arbitrary string to uniquely identify the appointment.
+ */
+ public void setId(final String id) {
+ this.id = id;
+ }
+
+ /**
+ * Returns the configured start time-stamp of this Appointment.
+ *
+ * @return A date object with the date and time this appointment starts on
+ */
+ public Date getStart() {
+ return start;
+ }
+
+ /**
+ * Sets the start time-stamp of this Appointment.
+ *
+ * @param start
+ * A date object with the date and time this appointment starts
+ */
+ public void setStart(final Date start) {
+ this.start = start;
+ }
+
+ /**
+ * Returns the configured end time-stamp of this Appointment.
+ *
+ * @return A date object with the date and time this appointment ends on
+ */
+ public Date getEnd() {
+ return end;
+ }
+
+ /**
+ * Sets the end time-stamp of this Appointment.
+ *
+ * @param end
+ * A date object with the date and time this appointment ends on
+ */
+ public void setEnd(final Date end) {
+ this.end = end;
+ }
+
+ /**
+ * Returns the identifying title of this Appointment.
+ *
+ * @return The title's short text
+ */
+ public String getTitle() {
+ return title;
+ }
+
+ /**
+ * Sets the identifying title of this Appointment.
+ *
+ * @param title
+ * The title's short text
+ */
+ public void setTitle(final String title) {
+ this.title = title;
+ }
+
+ /**
+ * Returns a description for this Appointment.
+ *
+ * @return The appointment's description
+ */
+ public String getDescription() {
+ return description;
+ }
+
+ /**
+ * Sets the description of this Appointment.
+ *
+ * @param description
+ * The title's short text
+ */
+ public void setDescription(final String description) {
+ this.description = description;
+ }
+
+ /**
+ * Returns a location of this Appointment.
+ *
+ * @return The appointment location.
+ */
+ public String getLocation() {
+ return location;
+ }
+
+ /**
+ * Sets the location of this Appointment.
+ *
+ * @param location
+ * The appointment location
+ */
+ public void setLocation(final String location) {
+ this.location = location;
+ }
+
+ /**
+ * Returns a creator of this Appointment.
+ *
+ * @return The appointment creator description.
+ */
+ public String getCreatedBy() {
+ return createdBy;
+ }
+
+ /**
+ * Sets the creator of this Appointment.
+ *
+ * @param createdBy
+ * The appointment creator description.
+ */
+ public void setCreatedBy(final String createdBy) {
+ this.createdBy = createdBy;
+ }
+
+ /**
+ * Returns the collection of associated attendees.
+ *
+ * @return The currently configured list of attendees
+ */
+ public ListAppointment.
+ *
+ * @param attendees
+ * The entities associated (attending) this
+ * Appointment
+ */
+ public void setAttendees(final ListAppointment with the specified
+ * appointment based first on the start dates of
+ * each appointment and then (if they happen to be the same), on the
+ * end dates.
+ *
+ * @param appointment
+ * The appointment to compare this one to
+ * @return a negative integer if this appointment
+ * is before appointment, zero if
+ * both appointments have the same start/
+ * end dates, and a positive integer if
+ * this appointment is after
+ * appointment.
+ */
+ public int compareTo(final Appointment appointment) {
+ int compare = this.getStart().compareTo(appointment.getStart());
+
+ if (compare == 0) {
+ compare = appointment.getEnd().compareTo(this.getEnd());
+ }
+
+ return compare;
+ }
+
+ /**
+ * Tells whether this Appointment spans more than a single day,
+ * based on its start and end properties.
+ *
+ * @return true if the start and end
+ * dates fall on different dates, false otherwise.
+ */
+ public boolean isMultiDay() {
+ if (getEnd() != null && getStart() != null) {
+ return !DateUtils.areOnTheSameDay(getEnd(), getStart());
+ }
+ throw new IllegalStateException(
+ "Calculating isMultiDay with no start/end dates set");
+ }
+
+ /**
+ * Returns the configured value of the allDay property, which
+ * indicates if this Appointment should be considered as
+ * spanning all day. It is left to the view rendering this
+ * Appointment to decide how to render an appointment based on
+ * this property value. For instance, the month view, will display the
+ * Appointment at the top of the days in a week.
+ *
+ * @return The current value of the allDay property
+ */
+ public boolean isAllDay() {
+ return allDay;
+ }
+
+ /**
+ * Configures the the allDay property, which indicates if this
+ * Appointment should be considered as spanning all day. It is
+ * left to the view rendering this Appointment to decide how to
+ * render an appointment based on this property value. For instance, the
+ * month view, will display the Appointment at the top of the
+ * days in a week.
+ *
+ * @param allDay
+ * The current value of the allDay property
+ */
+ public void setAllDay(final boolean allDay) {
+ this.allDay = allDay;
+ }
+
+ public AppointmentStyle getStyle() {
+ return style;
+ }
+
+ public void setStyle(final AppointmentStyle style) {
+ this.style = style;
+ }
+
+ public String getCustomStyle() {
+ return customStyle;
+ }
+
+ public void setCustomStyle(final String customStyle) {
+ this.customStyle = customStyle;
+ }
+
+ public boolean isReadOnly() {
+ return readOnly;
+ }
+
+ public void setReadOnly(final boolean readOnly) {
+ this.readOnly = readOnly;
+ }
+
+ public Appointment clone() {
+ Appointment clone = new Appointment();
+ clone.setId(this.id);
+ clone.setAllDay(this.allDay);
+ clone.setAttendees(new ArrayListAppointmentManager are: null when no currently selected appointment has been set.
+ */
+ private Appointment selectedAppointment = null;
+
+ /**
+ * A reference to the most recent appointment to receive
+ * a mouse over event.
+ */
+ private Appointment hoveredAppointment = null;
+
+ /**
+ * A copy of the last appointment that was updated,
+ * prior to the update taking place.
+ */
+ private Appointment rollbackAppointment = null;
+
+ /**
+ * A reference to the last appointment that was updated.
+ */
+ private Appointment committedAppointment = null;
+
+ /**
+ * The collection of appointments to be maintained by this
+ * AppointmentManager.
+ */
+ private ArrayListAppointmentManager
+ * maintains. Warning: this method returns a modifiable
+ * reference to the internally managed list of appointments; client code
+ * might break the invariants that this AppointmentManager
+ * enforces if it performs any operations that modify the returned
+ * collection.
+ *
+ * @return The appointments managed by this AppointmentManager.
+ */
+ public ListApplicationManager.
+ *
+ * @param appt The appointment to be made part of this manager's managed
+ * collection
+ */
+ public void addAppointment(Appointment appt) {
+ if (appt != null) {
+ appointments.add(appt);
+ sortPending = true;
+ }
+ }
+
+ /**
+ * Adds multiple appointments to the collection maintained by this
+ * ApplicationManager.
+ *
+ * @param appointments The appointments that will be made part of this
+ * manager's managed collection
+ */
+ public void addAppointments(Listappointment from this manager's managed
+ * collection.
+ *
+ * @param appointment The appointment to remove
+ */
+ public void removeAppointment(Appointment appointment) {
+ if (appointment != null) {
+ boolean wasRemoved = appointments.remove(appointment);
+ if (wasRemoved) {
+ sortPending = true;
+ }
+ //I'd rather have the client keep the reference to the selected one if they need it than having here
+ //a reference to a thing I no longer should know about...
+ if (hasAppointmentSelected() &&
+ getSelectedAppointment().equals(appointment)) {
+ selectedAppointment = null;
+ }
+ }
+ }
+
+ /**
+ * Removes the "currently selected" appointment from this
+ * manager's collection.
+ */
+ public void removeCurrentlySelectedAppointment() {
+ if (hasAppointmentSelected()) {
+ removeAppointment(getSelectedAppointment());
+ selectedAppointment = null;
+ }
+ }
+
+ /**
+ * Empties the collection of managed appointments.
+ */
+ public void clearAppointments() {
+ appointments.clear();
+ }
+
+ /**
+ * Sets the appointment that should be considered the "currently
+ * selected" appointment.
+ *
+ * @param selectedAppointment The appointment to consider "currently
+ * selected"
+ */
+ public void setSelectedAppointment(Appointment selectedAppointment) {
+ if (selectedAppointment != null &&
+ appointments.contains(selectedAppointment)) {
+ this.selectedAppointment = selectedAppointment;
+ }
+ }
+
+ /**
+ * Indicates whether there is a "currently selected" appointment
+ * at the moment.
+ *
+ * @return true if there is a currently selected appointment
+ * for the collection managed by this component, false
+ * otherwise
+ */
+ public boolean hasAppointmentSelected() {
+ return selectedAppointment != null;
+ }
+
+ /**
+ * Returns the appointment in this manager's collection that is
+ * "currently selected".
+ *
+ * @return The currently selected appointment
+ */
+ public Appointment getSelectedAppointment() {
+ return selectedAppointment;
+ }
+
+ /**
+ * Sorts the collection of appointments by their natural order.
+ */
+ public void sortAppointments() {
+ if (sortPending) {
+ Collections.sort(appointments);
+ sortPending = false;
+ }
+ }
+
+ /**
+ * Moves the "currently selected" to the previous appointment in
+ * the managed collection of this AppointmentManager. true if selecting the previous appointment was
+ * successful, false no currently selected appointment
+ * is set or the currently selected appointment is the first in the
+ * collection.
+ */
+ public boolean selectPreviousAppointment() {
+ boolean moveSucceeded = false;
+ if (getSelectedAppointment() != null) {
+ int selectedApptIndex =
+ getAppointments().indexOf(getSelectedAppointment());
+ Appointment prevAppt;
+ if (selectedApptIndex > 0 && (prevAppt =
+ getAppointments().get(selectedApptIndex - 1)) != null) {
+ selectedAppointment = prevAppt;
+ moveSucceeded = true;
+ }
+ }
+ return moveSucceeded;
+ }
+
+ /**
+ * Moves the "currently selected" to the next appointment in the
+ * managed collection of this AppointmentManager. true if selecting the previous appointment was
+ * successful, false no currently selected appointment
+ * is set or the currently selected appointment is the last in the
+ * collection.
+ */
+ public boolean selectNextAppointment() {
+ boolean moveSucceeded = false;
+
+ if (getSelectedAppointment() != null) {
+ int selectedApptIndex =
+ getAppointments().indexOf(getSelectedAppointment());
+ int lastIndex = getAppointments().size() - 1;
+
+ Appointment nextAppt;
+ if (selectedApptIndex < lastIndex
+ && (nextAppt = getAppointments().get(selectedApptIndex + 1)) != null) {
+ selectedAppointment = nextAppt;
+ moveSucceeded = true;
+ }
+ }
+
+ return moveSucceeded;
+ }
+
+ /**
+ * Resets the "currently selected" appointment of this manager.
+ * If this manager has a currently selected appointment, the
+ * appointment selected property will be set to
+ * false and this manager's selectedAppointment
+ * property will be set to null.
+ */
+ public void resetSelectedAppointment() {
+ if (hasAppointmentSelected()) {
+ //selectedAppointment.setSelected(false);
+ selectedAppointment = null;
+ }
+ }
+
+ /**
+ * Tells whether the passed appointment is the same one as the
+ * one that is currently selected in this manager.
+ *
+ * @param appointment The appointment to test to be the same as the
+ * currently selected
+ * @return true if there is a currently selected appointment
+ * and it is equal to the passed appointment
+ */
+ public boolean isTheSelectedAppointment(Appointment appointment) {
+ return hasAppointmentSelected() && selectedAppointment.equals(
+ appointment);
+ }
+
+ public void commit() {
+ rollbackAppointment = null;
+ committedAppointment = null;
+ }
+
+ public void rollback() {
+
+ //if the snapshot block is empty, we can do nothing
+ if(rollbackAppointment==null && committedAppointment==null)
+ return;
+
+ //if there is no committed appointment, we assume
+ // this was a delete operation. We re-add the appointment
+ if (committedAppointment == null) {
+ addAppointment(rollbackAppointment);
+
+ //if there is no rollback appointment, we assume
+ // this was an add or update operation. We remove the appointment
+ } else if (rollbackAppointment == null) {
+ removeAppointment(committedAppointment);
+
+ //else, we assume this is an update
+ } else {
+
+ removeAppointment(committedAppointment);
+ addAppointment(rollbackAppointment);
+ }
+
+ commit();
+ }
+
+ public void setRollbackAppointment(Appointment appt) {
+ sortPending = true;
+ commit();
+ rollbackAppointment = appt;
+ }
+
+ public void setCommittedAppointment(Appointment appt) {
+ sortPending = true;
+ committedAppointment = appt;
+ }
+
+ public void resetHoveredAppointment() {
+ this.hoveredAppointment = null;
+ }
+
+ public void setHoveredAppointment(Appointment hoveredAppointment) {
+ this.hoveredAppointment = hoveredAppointment;
+ }
+
+ public Appointment getHoveredAppointment() {
+ return hoveredAppointment;
+ }
+}
\ No newline at end of file
diff --git a/src/com/bradrydzewski/gwt/calendar/client/AppointmentStyle.java b/src/com/bradrydzewski/gwt/calendar/client/AppointmentStyle.java
new file mode 100644
index 0000000..dd6ff08
--- /dev/null
+++ b/src/com/bradrydzewski/gwt/calendar/client/AppointmentStyle.java
@@ -0,0 +1,12 @@
+package com.bradrydzewski.gwt.calendar.client;
+
+import java.io.Serializable;
+
+import com.google.gwt.user.client.rpc.IsSerializable;
+
+public enum AppointmentStyle implements Serializable, IsSerializable {
+ BLUE, RED, PINK, PURPLE, DARK_PURPLE, STEELE_BLUE, LIGHT_BLUE,
+ TEAL, LIGHT_TEAL, GREEN, LIGHT_GREEN, YELLOW_GREEN, YELLOW,
+ ORANGE, RED_ORANGE, LIGHT_BROWN, LIGHT_PURPLE, GREY, BLUE_GREY,
+ YELLOW_GREY, BROWN, DEFAULT, CUSTOM
+}
diff --git a/src/com/bradrydzewski/gwt/calendar/client/Attendee.java b/src/com/bradrydzewski/gwt/calendar/client/Attendee.java
new file mode 100644
index 0000000..7cd0ddb
--- /dev/null
+++ b/src/com/bradrydzewski/gwt/calendar/client/Attendee.java
@@ -0,0 +1,150 @@
+/*
+ * This file is part of gwt-cal
+ * Copyright (C) 2010 Scottsdale Software LLC
+ *
+ * gwt-cal is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see Attendee name (if a person) or description
+ * (when a resource).
+ */
+ private String name;
+
+ /**
+ * This Attendee email address.
+ */
+ private String email;
+
+ /**
+ * The status of attendance of this attendee to an Appointment.
+ */
+ private Attending attending = Attending.Maybe;
+
+ /**
+ * A URL to an image to depict this Attendee.
+ */
+ private String imageUrl;
+
+ /**
+ * Returns the name (if a person) or description (when a resource)
+ * of this Attendee.
+ *
+ * @return The currently configured name of this attendee
+ */
+ public String getName() {
+ return name;
+ }
+
+ /**
+ * Sets the name (if a person) or description (when a resource)
+ * of this Attendee.
+ *
+ * @param name The name of this attendee
+ */
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ /**
+ * Returns this Attendee email address.
+ *
+ * @return The email address
+ */
+ public String getEmail() {
+ return email;
+ }
+
+ /**
+ * Sets this Attendee email address.
+ * @param email The email address
+ */
+ public void setEmail(String email) {
+ this.email = email;
+ }
+
+ /**
+ * Returns the attendance status of this attendant
+ * to the Appointment referencing it.
+ * @return The attendance status of this Attendee
+ */
+ public Attending getAttending() {
+ return attending;
+ }
+
+ /**
+ * Sets the attendance status of this attendant
+ * to the Appointment referencing it.
+ *
+ * @param attending The attendance status
+ */
+ public void setAttending(Attending attending) {
+ this.attending = attending;
+ }
+
+ /**
+ * Returns the URL to an image to (optionally) depict this Attendee
+ * in the views.
+ * @return A URL (relative or absolute) meaningful within the
+ * deployed application context
+ */
+ public String getImageUrl() {
+ return imageUrl;
+ }
+
+ /**
+ * Sets the URL to an image to (optionally) depict this Attendee
+ * in the views.
+ * @param imageUrl A URL (relative or absolute) meaningful within the
+ */
+ public void setImageUrl(String imageUrl) {
+ this.imageUrl = imageUrl;
+ }
+
+ /**
+ * Returns the attendance ID.
+ * @return The attendance ID
+ * @since 0.9.4
+ */
+ public String getId() {
+ return id;
+ }
+
+ /**
+ * Sets the attendance the ID.
+ * @param id The ID
+ * @since 0.9.4
+ */
+ public void setId(String id) {
+ this.id = id;
+ }
+}
diff --git a/src/com/bradrydzewski/gwt/calendar/client/Attending.java b/src/com/bradrydzewski/gwt/calendar/client/Attending.java
new file mode 100644
index 0000000..0d3f5b4
--- /dev/null
+++ b/src/com/bradrydzewski/gwt/calendar/client/Attending.java
@@ -0,0 +1,46 @@
+/*
+ * This file is part of gwt-cal
+ * Copyright (C) 2009 Scottsdale Software LLC
+ *
+ * gwt-cal is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see Calendar with the given CalendarView displayed by
+ * default.
+ */
+ public Calendar(CalendarViews view, CalendarSettings settings) {
+ super();
+ this.setSettings(settings);
+ setView(view);
+ }
+
+ /**
+ * Constructs a Calendar with the a user-defined CalendarView
+ * displayed by default.
+ */
+ public Calendar(CalendarView view) {
+ super();
+ setView(view);
+ }
+
+ /**
+ * Sets the CalendarView that should be used by the Calendar to display the
+ * list of appointments.
+ *
+ * @param view
+ */
+ final public void setView(CalendarViews view) {
+ setView(view, getDays());
+ }
+
+ /**
+ * Sets the current view of this calendar.
+ *
+ * @param view
+ * The ID of a view used to visualize the appointments managed by the
+ * calendar
+ * @param days
+ * The number of days to display in the view, which can be ignored by
+ * some views.
+ */
+ public void setView(CalendarViews view, int days) {
+ switch (view) {
+ case DAY: {
+ if (dayView == null) {
+ dayView = new DayView();
+ }
+ dayView.setDisplayedDays(days);
+ setView(dayView);
+ break;
+ }
+ case AGENDA: {
+ // TODO: need to cache agendaView, but there is a layout bug after a
+ // calendar item is deleted.
+ // agendaView = new AgendaView();
+ // setView(agendaView);
+ // break;
+ throw new RuntimeException("Agenda View is not yet supported");
+ }
+ case MONTH: {
+ if (monthView == null) {
+ monthView = new MonthView();
+ }
+ setView(monthView);
+ break;
+ }
+ case TECH: {
+ if (techView == null) {
+ techView = new TechView();
+ }
+ setView(techView);
+ break;
+ }
+ }
+ selectedView = view;
+ }
+
+ /**
+ * Gets the current view of this calendar.
+ *
+ * @return Current view
+ */
+ public CalendarViews getCalendarView() {
+ return selectedView;
+ }
+
+ public void onResize() {
+ resizeTimer.schedule(500);
+ }
+
+ private Timer resizeTimer = new Timer() {
+ /**
+ * Snapshot of the Calendar's height at the last time it was resized.
+ */
+ private int height;
+
+ @Override
+ public void run() {
+
+ int newHeight = getOffsetHeight();
+ if (newHeight != height) {
+ height = newHeight;
+ doSizing();
+ if (getView() instanceof MonthView)
+ doLayout();
+ }
+ }
+ };
+}
diff --git a/src/com/bradrydzewski/gwt/calendar/client/CalendarFormat.java b/src/com/bradrydzewski/gwt/calendar/client/CalendarFormat.java
new file mode 100644
index 0000000..0054afa
--- /dev/null
+++ b/src/com/bradrydzewski/gwt/calendar/client/CalendarFormat.java
@@ -0,0 +1,312 @@
+/*
+ * This file is part of gwt-cal
+ * Copyright (C) 2009-2011 Scottsdale Software LLC
+ *
+ * gwt-cal is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see DateTimeFormat.
+ *
+ * @param formatPattern The pattern to format day names
+ * @see com.google.gwt.i18n.client.DateTimeFormat#getFormat(String)
+ */
+ public void setDayOfWeekAbbreviatedFormat(String formatPattern) {
+ dayOfWeekAbbreviatedFormat = DateTimeFormat.getFormat(formatPattern);
+ refreshWeekDayNames();
+ }
+
+ public String[] getDayOfWeekAbbreviatedNames() {
+ return dayOfWeekAbbreviatedNames;
+ }
+
+ private void refreshWeekDayNames() {
+ Date date = new Date();
+ for (int i = 1; i <= 7; i++) {
+ date.setDate(i);
+ int dayOfWeek = date.getDay();
+ weekDayNames[dayOfWeek] = dayOfWeekFormat.format(date);
+ dayOfWeekAbbreviatedNames[dayOfWeek] =
+ dayOfWeekAbbreviatedFormat.format(date);
+ }
+ }
+
+ /**
+ * Configures the formatting pattern to render the days of the month using
+ * DateTimeFormat. Most likely, formatPattern will
+ * contain at the minimum, the format to render the number of the
+ * corresponding day.
+ *
+ * @param formatPattern The pattern to format days in the month view
+ * @see com.google.gwt.i18n.client.DateTimeFormat#getFormat(String)
+ */
+ public void setDayOfMonthFormat(String formatPattern) {
+ dayOfMonthFormat = DateTimeFormat.getFormat(formatPattern);
+ refreshMonthDayNames();
+ }
+
+ private void refreshMonthDayNames() {
+ Date date = new Date();
+ date.setMonth(0);
+ for (int i = 1; i < 32; ++i) {
+ date.setDate(i);
+ dayOfMonthNames[i] = dayOfMonthFormat.format(date);
+ }
+ }
+
+ public void setDateFormat(String formatPattern) {
+ dateFormat = DateTimeFormat.getFormat(formatPattern);
+ }
+
+ public DateTimeFormat getDateFormat() {
+ return dateFormat;
+ }
+
+ /**
+ * Sets the pattern used to format the displayed hours and re-generates
+ * all hour labels.
+ *
+ * @param formatPattern A legal format following the patterns
+ * in {@link com.google.gwt.i18n.client.DateTimeFormat}
+ */
+ public void setTimeFormat(String formatPattern) {
+ timeFormat = DateTimeFormat.getFormat(formatPattern);
+ generateHourLabels();
+ }
+
+ public DateTimeFormat getTimeFormat() {
+ return timeFormat;
+ }
+
+ /**
+ * Allows programmatic configuration of the 24 hour labels in the calendar.
+ *
+ * @param hourLabels The labels to be used as labels for the hours of the
+ * day.
+ * @throws IllegalArgumentException If the hourLabels array is
+ * null, does not have 24
+ * elements, or any of the elements is
+ * null
+ */
+ public void setHourLabels(String[] hourLabels) {
+ if (hourLabels == null || hourLabels.length != HOURS_IN_DAY) {
+ throw new IllegalArgumentException(
+ "24 Hour labels expected. Please provide an array with 24 non-null values");
+ }
+ for (int i = 0; i < HOURS_IN_DAY; i++) {
+ if (hourLabels[i] == null) {
+ throw new IllegalArgumentException(
+ "Hour @ position " + i + " is null.");
+ }
+ hours[i] = hourLabels[i];
+ }
+ }
+
+ /**
+ * Default logic to generate the labels for the hours.
+ */
+ private void generateHourLabels() {
+ Date date = new Date();
+ date.setHours(0);
+ date.setMinutes(0);
+ String hour;
+
+ for (int i = 0; i < HOURS_IN_DAY; i++) {
+ date.setHours(i);
+ hour = timeFormat.format(date);
+ //shortTimeFormat.format(date);
+ hours[i] = hour;
+ }
+ }
+
+ /**
+ * Returns the currently configured day to start weeks in the
+ * MonthView. The default value is read from the
+ * CalendarConstants i18n configuration file, but it can be
+ * changed through the setFirstDayOfWeek method of this class.
+ *
+ * @return The currently configured day to start weeks, 0 for
+ * Sunday, 1 for Monday, and so on.
+ */
+ public int getFirstDayOfWeek() {
+ return firstDayOfWeek;
+ }
+
+ /**
+ * Configures the first day in the week when rendering the month view.
+ *
+ * @param firstDayOfWeek The first day of the week, where Sunday is
+ * represented by 0, Monday by
+ * 1, and so on.
+ */
+ public void setFirstDayOfWeek(int firstDayOfWeek) {
+ this.firstDayOfWeek = Math.abs(firstDayOfWeek % 7);
+ }
+
+ public String getAm() {
+ return am;
+ }
+
+ public void setAm(String am) {
+ this.am = am;
+ }
+
+ public String getPm() {
+ return pm;
+ }
+
+ public void setPm(String pm) {
+ this.pm = pm;
+ }
+
+ /**
+ * Returns the currently configured label for the noon (12 p.m.).
+ *
+ * @return The configured label for the 12 p.m. time either through the
+ * CalendarConstants or the setNoon method
+ * of this class.
+ */
+ public String getNoon() {
+ return noon;
+ }
+
+ /**
+ * Configures the label to show for the 12 p.m.
+ *
+ * @param noon A label to show instead of 12 p.m.
+ */
+ public void setNoon(String noon) {
+ this.noon = noon;
+ }
+
+ /**
+ * Returns the configured labels for the 24 hours of the day. Some labels
+ * will vary, depending con configuration, for example "Noon"
+ * instead of "12".
+ *
+ * @return An array of Strings with the corresponding labels for the hours in
+ * a day
+ */
+ public String[] getHourLabels() {
+ return hours;
+ }
+
+ /**
+ * Indicates if we want to use the NoonLabel or the 12 p.m.
+ * @param use true if we want to use the NoonLabel, false otherwise
+ * @since 0.9.4
+ */
+ public void setUseNoonLabel(boolean use) {
+ this.useNoonLabel = use;
+ }
+
+ /**
+ * Indicates if we are using the NoonLabel for the 12 p.m.
+ * @since 0.9.4
+ */
+ public boolean isUseNoonLabel() {
+ return useNoonLabel;
+ }
+}
\ No newline at end of file
diff --git a/src/com/bradrydzewski/gwt/calendar/client/CalendarSettings.java b/src/com/bradrydzewski/gwt/calendar/client/CalendarSettings.java
new file mode 100644
index 0000000..f7626d4
--- /dev/null
+++ b/src/com/bradrydzewski/gwt/calendar/client/CalendarSettings.java
@@ -0,0 +1,182 @@
+/*
+ * This file is part of gwt-cal
+ * Copyright (C) 2009 Brad Rydzewski
+ *
+ * gwt-cal is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see holidays = new ArrayList();
+ private int dayStartsAt = 0;
+
+ /*
+ * Clicks required to fire TimeBlockClickEvent.
+ */
+ private Click timeBlockClickNumber = Click.Single;
+
+ public CalendarSettings() {
+ }
+
+ public int getPixelsPerInterval() {
+ return pixelsPerInterval;
+ }
+
+ public void setPixelsPerInterval(final int px) {
+ pixelsPerInterval = px;
+ }
+
+ public int getIntervalsPerHour() {
+ return intervalsPerHour;
+ }
+
+ public void setIntervalsPerHour(final int intervals) {
+ intervalsPerHour = intervals;
+ }
+
+ public int getWorkingHourStart() {
+ return workingHourStart;
+ }
+
+ public void setWorkingHourStart(final int start) {
+ workingHourStart = start;
+ }
+
+ public int getWorkingHourEnd() {
+ return workingHourEnd;
+ }
+
+ public void setWorkingHourEnd(final int end) {
+ workingHourEnd = end;
+ }
+
+ public int getScrollToHour() {
+ return scrollToHour;
+ }
+
+ public void setScrollToHour(final int hour) {
+ scrollToHour = hour;
+ }
+
+ public boolean isEnableDragDrop() {
+ return enableDragDrop;
+ }
+
+ public void setEnableDragDrop(final boolean enableDragDrop) {
+ this.enableDragDrop = enableDragDrop;
+ }
+
+ public boolean isOffsetHourLabels() {
+ return offsetHourLabels;
+ }
+
+ public void setOffsetHourLabels(final boolean offsetHourLabels) {
+ this.offsetHourLabels = offsetHourLabels;
+ }
+
+ public Click getTimeBlockClickNumber() {
+ return timeBlockClickNumber;
+ }
+
+ public void setTimeBlockClickNumber(final Click timeBlockClickNumber) {
+ this.timeBlockClickNumber = timeBlockClickNumber;
+ }
+
+ /**
+ * @deprecated As of release 0.9.4 removed since is not really needed
+ */
+ @Deprecated
+ public void setEnableDragDropCreation(final boolean dragDropCreation) {
+
+ }
+
+ /**
+ * @deprecated As of release 0.9.4 removed since is not really needed
+ */
+ @Deprecated
+ public boolean getEnableDragDropCreation() {
+ return false;
+ }
+
+ public void setDayStartsAt(int dayStartsAt) {
+ this.dayStartsAt = dayStartsAt;
+ DateUtils.setDayStartsAt(dayStartsAt);
+ }
+
+ public int getDayStartsAt() {
+ return dayStartsAt;
+ }
+
+ /**
+ *
+ * @param showWeekNumbers
+ * @since 0.9.4
+ */
+ public void setShowWeekNumbers(final boolean showWeekNumbers) {
+ this.showWeekNumbers = showWeekNumbers;
+ }
+
+ /**
+ *
+ * @since 0.9.4
+ */
+ public boolean isShowingWeekNumbers() {
+ return showWeekNumbers;
+ }
+
+ public void setHolidays(List holidays) {
+ this.holidays = holidays;
+ }
+
+ public List getHolidays() {
+ return holidays;
+ }
+
+ /**
+ *
+ * @since 0.9.4
+ */
+ public void setShowMultiday(final boolean visible) {
+ this.showMultiDay = visible;
+ }
+
+ /**
+ *
+ * @since 0.9.4
+ */
+ public boolean isMultidayVisible() {
+ return showMultiDay;
+ }
+
+ public enum Click {
+ Double, Single, Drag
+ }
+}
diff --git a/src/com/bradrydzewski/gwt/calendar/client/CalendarView.java b/src/com/bradrydzewski/gwt/calendar/client/CalendarView.java
new file mode 100644
index 0000000..c94e6c9
--- /dev/null
+++ b/src/com/bradrydzewski/gwt/calendar/client/CalendarView.java
@@ -0,0 +1,285 @@
+/*
+ * This file is part of gwt-cal
+ * Copyright (C) 2009 Scottsdale Software LLC
+ *
+ * gwt-cal is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see , HasDaySelectionHandlers {
+
+ /**
+ * Calendar widget bound to the view.
+ *
+ * @see CalendarWidget
+ */
+ protected CalendarWidget calendarWidget = null;
+
+ /**
+ * Number of days the calendar should display at a given time, 3 by
+ * default.
+ */
+ private int displayedDays = 3;
+
+ /**
+ * Attaches this view to the provided {@link CalendarWidget}.
+ *
+ * @param calendarWidget The interactive widget containing the calendar
+ */
+ public void attach(CalendarWidget calendarWidget) {
+ this.calendarWidget = calendarWidget;
+ }
+
+ /**
+ * Detaches this view from the currently associated {@link CalendarWidget}.
+ * TODO: The CalendarWidget might still have a reference to this
+ * CalendarView, is that correct??
+ */
+ public void detatch() {
+ calendarWidget = null;
+ }
+
+ /**
+ * Returns the CSS style name of this calendar view.
+ *
+ * @return The CSS style that should be used when rendering this calendar
+ * view
+ */
+ public abstract String getStyleName();
+
+ public void doSizing() {
+ }
+
+ public abstract void doLayout();
+
+ /**
+ * Configures this view component's currently selected
+ * appointment. Notification to the calendar widget associated
+ * is optional and controlled with the fireEvent flag.
+ *
+ * @param appointment The appointment in the calendar in-memory model to be
+ * configured as the currently selected
+ * @param fireEvent Indicates whether a selection event should be
+ * triggered by the parent widget so that it informs its
+ * set of registered listeners about the change
+ */
+// public void setSelectedAppointment(Appointment appointment,
+// boolean fireEvent) {
+// calendarWidget.setSelectedAppointment(appointment);
+// if (fireEvent) {
+// calendarWidget.fireSelectionEvent(appointment);
+// }
+// }
+
+ /**
+ * Configures this view component's currently selected
+ * appointment and notifies widget about the change in the
+ * model state.
+ *
+ * @param appointment The appointment in the calendar in-memory model to be
+ * configured as the currently selected
+ */
+// public void setSelectedAppointment(Appointment appointment) {
+// setSelectedAppointment(appointment, true);
+// }
+
+ /**
+ * Returns the configured number of days the calendar should display at a
+ * given time.
+ *
+ * @return The number of days this calendar view should display at a given
+ * time
+ */
+ public int getDisplayedDays() {
+ return displayedDays;
+ }
+
+ /**
+ * Sets the configured number of days the calendar should display at a given
+ * time.
+ *
+ * @param displayedDays The number of days this calendar view should display
+ * at a given time
+ */
+ public void setDisplayedDays(int displayedDays) {
+ this.displayedDays = displayedDays;
+ }
+
+ /* on clicks */
+ public abstract void onDoubleClick(Element element, Event event);
+
+ public abstract void onSingleClick(Element element, Event event);
+
+ public abstract void onMouseOver(Element element, Event event);
+
+ /**
+ * Processes user {@link com.google.gwt.event.dom.client.KeyCodes#KEY_DELETE}
+ * and {@link com.google.gwt.event.dom.client.KeyCodes.KEY_BACKSPACE}
+ * keystrokes. The CalendarView implementation is empty so that
+ * subclasses are not forced to implement it if no specific logic is needed
+ * for {@link com.google.gwt.event.dom.client.KeyCodes#KEY_DELETE} or
+ * {@link com.google.gwt.event.dom.client.KeyCodes#KEY_BACKSPACE} keystrokes.
+ */
+ public void onDeleteKeyPressed() {
+ }
+
+ /**
+ * Processes user {@link com.google.gwt.event.dom.client.KeyCodes#KEY_UP}
+ * keystrokes. The CalendarView implementation is empty so that
+ * subclasses are not forced to implement it if no specific logic is needed
+ * for {@link com.google.gwt.event.dom.client.KeyCodes#KEY_UP} keystrokes.
+ */
+ public void onUpArrowKeyPressed() {
+ }
+
+ /**
+ * Processes user {@link com.google.gwt.event.dom.client.KeyCodes#KEY_DOWN}
+ * keystrokes. The CalendarView implementation is empty so that
+ * subclasses are not forced to implement it if no specific logic is needed
+ * for {@link com.google.gwt.event.dom.client.KeyCodes#KEY_DOWN}
+ * keystrokes.
+ */
+ public void onDownArrowKeyPressed() {
+ }
+
+ /**
+ * Processes user {@link com.google.gwt.event.dom.client.KeyCodes#KEY_LEFT}
+ * keystrokes. The CalendarView implementation is empty so that
+ * subclasses are not forced to implement it if no specific logic is needed
+ * for {@link com.google.gwt.event.dom.client.KeyCodes#KEY_LEFT}
+ * keystrokes.
+ */
+ public void onLeftArrowKeyPressed() {
+ }
+
+ /**
+ * Processes user {@link com.google.gwt.event.dom.client.KeyCodes#KEY_RIGHT}
+ * keystrokes. The CalendarView implementation is empty so that
+ * subclasses are not forced to implement it if no specific logic is needed
+ * for {@link com.google.gwt.event.dom.client.KeyCodes#KEY_RIGHT}
+ * keystrokes.
+ */
+ public void onRightArrowKeyPressed() {
+ }
+
+ public abstract void onAppointmentSelected(Appointment appt);
+
+ public final void selectAppointment(Appointment appt) {
+ calendarWidget.setSelectedAppointment(appt, true);
+ }
+
+ public final void selectNextAppointment() {
+ calendarWidget.selectNextAppointment();
+ }
+
+ public final void selectPreviousAppointment() {
+ calendarWidget.selectPreviousAppointment();
+ }
+
+ public final void updateAppointment(Appointment toAppt) {
+ calendarWidget.fireUpdateEvent(toAppt);
+ }
+
+ public final void deleteAppointment(Appointment appt) {
+ calendarWidget.fireDeleteEvent(appt);
+ }
+
+ public final void openAppointment(Appointment appt) {
+ calendarWidget.fireOpenEvent(appt);
+ }
+
+ public final void createAppointment(Appointment appt) {
+ createAppointment(appt.getStart(), appt.getEnd());
+ }
+
+ public final void createAppointment(Date start, Date end) {
+ calendarWidget.fireTimeBlockClickEvent(start);
+ }
+
+ public void scrollToHour(int hour) {
+
+ }
+
+ public CalendarSettings getSettings() {
+ return calendarWidget.getSettings();
+ }
+
+ public void setSettings(CalendarSettings settings) {
+ calendarWidget.setSettings(settings);
+ }
+
+ protected void addDayClickHandler(final Label dayLabel, final Date day) {
+ dayLabel.addClickHandler(new ClickHandler() {
+ public void onClick(ClickEvent event) {
+ fireSelectedDay(day);
+ }
+ });
+ }
+
+ protected void addWeekClickHandler(final Label weekLabel, final Date day) {
+ weekLabel.addClickHandler(new ClickHandler() {
+ public void onClick(ClickEvent event) {
+ fireSelectedWeek(day);
+ }
+ });
+ }
+
+ protected void fireSelectedDay(final Date day) {
+ DaySelectionEvent.fire(this, day);
+ }
+
+ protected void fireSelectedWeek(final Date day) {
+ WeekSelectionEvent.fire(this, day);
+ }
+
+ public HandlerRegistration addWeekSelectionHandler(
+ WeekSelectionHandler handler) {
+ return calendarWidget.addHandler(handler, WeekSelectionEvent.getType());
+ }
+
+ public HandlerRegistration addDaySelectionHandler(
+ DaySelectionHandler handler) {
+ return calendarWidget.addHandler(handler, DaySelectionEvent.getType());
+ }
+
+ public void fireEvent(GwtEvent event) {
+ calendarWidget.fireEvent(event);
+ }
+}
\ No newline at end of file
diff --git a/src/com/bradrydzewski/gwt/calendar/client/CalendarViews.java b/src/com/bradrydzewski/gwt/calendar/client/CalendarViews.java
new file mode 100644
index 0000000..72bf540
--- /dev/null
+++ b/src/com/bradrydzewski/gwt/calendar/client/CalendarViews.java
@@ -0,0 +1,48 @@
+/*
+ * This file is part of gwt-cal
+ * Copyright (C) 2009 Scottsdale Software LLC
+ *
+ * gwt-cal is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see CalendarWidget is an {@link com.bradrydzewski.gwt.calendar.client.InteractiveWidget}
+ * that maintains a calendar model (a set of {@link Appointment} objects)
+ * managed through an {@link AppointmentManager}.
+ *
+ * TODO: Need Calendar "View" - CHECK
+ * TODO: Need CalendarSettings
+ * TODO: Need LayoutStrategy - CHECK
+ * TODO: Need DragDropStrategy
+ * TODO: Need ResizeStrategy ??? or is this same as DragDrop
+ * TODO: Add AppointmentBuilder ??? downside is that if the Appointment object is updated, need to refersh widget
+ *
+ * @author Brad Rydzewski
+ * @see com.bradrydzewski.gwt.calendar.client.InteractiveWidget
+ */
+public class CalendarWidget extends InteractiveWidget implements
+ HasSelectionHandlers, HasDeleteHandlers,
+ HasOpenHandlers, HasTimeBlockClickHandlers,
+ HasUpdateHandlers, HasDateRequestHandlers,
+ HasMouseOverHandlers,
+ HasLayout, HasAppointments {
+
+ /**
+ * Set to true if the calendar layout is suspended and cannot
+ * be triggered.
+ */
+ private boolean layoutSuspended = false;
+
+ /**
+ * Set to true if the calendar is pending the layout of its
+ * appointments.
+ */
+ private boolean layoutPending = false;
+
+ /**
+ * The date currently displayed by the calendar. Set to current system date
+ * by default.
+ */
+ private Date date;
+
+ /**
+ * Calendar settings, set to default.
+ */
+ private CalendarSettings settings = CalendarSettings.DEFAULT_SETTINGS;
+
+ /**
+ * The component to manage the set of appointments displayed by this
+ * CalendarWidget.
+ */
+ private AppointmentManager appointmentManager = null;
+
+ private CalendarView view = null;
+
+ /**
+ * Creates a CalendarWidget with an empty set of appointments
+ * and the current system date as the date currently displayed by the
+ * calendar.
+ */
+ public CalendarWidget() {
+ this(new Date());
+ }
+
+ public CalendarWidget(Date date) {
+ super();
+ appointmentManager = new AppointmentManager();
+ this.date = date;
+ DateUtils.resetTime(this.date);
+ }
+
+ /**
+ * Changes the current view of this calendar widget to the specified
+ * view. By setting this widget's current view the whole widget
+ * panel is cleared.
+ *
+ * @param view The {@link CalendarView} implementation to render this
+ * widget's underlying calendar
+ */
+ public final void setView(CalendarView view) {
+ this.getRootPanel().clear();
+ this.view = view;
+ this.view.attach(this);
+ this.setStyleName(this.view.getStyleName());
+ this.refresh();
+ }
+
+ public final CalendarView getView() {
+ return view;
+ }
+
+ public Date getDate() {
+ return (Date) date.clone();
+ }
+
+ public void setDate(Date date, int days) {
+ Date dateCopy = (Date)date.clone();
+ DateUtils.resetTime(dateCopy);
+ this.date = dateCopy;
+ view.setDisplayedDays(days);
+ refresh();
+ }
+
+ public void setDate(Date date) {
+ setDate(date, getDays());
+ }
+
+ /**
+ * Moves this calendar widget current date as many days as
+ * specified by the numOfDays parameter.
+ *
+ * @param numOfDays The number of days to change the calendar date forward
+ * (positive number) or backwards.
+ */
+ @SuppressWarnings("deprecation")
+ public void addDaysToDate(int numOfDays) {
+ this.date.setDate(this.date.getDate() + numOfDays);
+ }
+
+ public int getDays() {
+ return view == null ? 3 : view.getDisplayedDays();
+ }
+
+ public void setDays(int days) {
+ view.setDisplayedDays(days);
+ refresh();
+ }
+
+ /**
+ * Returns the collection of appointments in the underlying in-memory model
+ * of this calendar widget. Warning: the returned
+ * collection of apointments can be modified by client code, possibly
+ * breaking the system model invariants.
+ *
+ * @return The set of appointments to be displayed by this calendar widget
+ * @see AppointmentManager#getAppointments()
+ */
+ public List getAppointments() {
+ return appointmentManager.getAppointments();
+ }
+
+ /**
+ * Removes an appointment from the calendar.
+ *
+ * @param appointment the item to be removed.
+ */
+ public void removeAppointment(Appointment appointment) {
+ removeAppointment(appointment, false);
+ }
+
+ /**
+ * Removes the currently selected appointment from the model, if such
+ * appointment is set.
+ */
+ public void removeCurrentlySelectedAppointment() {
+ appointmentManager.removeCurrentlySelectedAppointment();
+ }
+
+ /**
+ * Removes an appointment from the calendar.
+ *
+ * @param appointment the item to be removed.
+ * @param fireEvents true to allow deletion events to be
+ * fired
+ */
+ public void removeAppointment(Appointment appointment, boolean fireEvents) {
+ boolean commitChange = true;
+
+ if (fireEvents) {
+ commitChange = DeleteEvent.fire(this, getSelectedAppointment());
+ }
+
+ if (commitChange) {
+ appointmentManager.removeAppointment(appointment);
+ refresh();
+ }
+ }
+
+ /**
+ * Resets the "currently selected" appointment of this calendar.
+ *
+ * @see com.bradrydzewski.gwt.calendar.client.AppointmentManager
+ */
+ public void resetSelectedAppointment() {
+ appointmentManager.resetSelectedAppointment();
+ }
+
+ /**
+ * Adds an appointment to the calendar.
+ *
+ * @param appointment item to be added
+ */
+ public void addAppointment(Appointment appointment) {
+ if (appointment == null) {
+ throw new NullPointerException("Added appointment cannot be null.");
+ }
+ appointmentManager.addAppointment(appointment);
+ refresh();
+ }
+
+ /**
+ * Adds each appointment in the list to the calendar.
+ *
+ * @param appointments items to be added.
+ */
+ public void addAppointments(List appointments) {
+ appointmentManager.addAppointments(appointments);
+ refresh();
+ }
+
+ /**
+ * Clears all appointment items.
+ */
+ public void clearAppointments() {
+ appointmentManager.clearAppointments();
+ refresh();
+ }
+
+ /**
+ * Sets the currently selected item.
+ *
+ * @param appointment the item to be selected, or null to
+ * de-select all items.
+ */
+ public void setSelectedAppointment(Appointment appointment) {
+ setSelectedAppointment(appointment, true);
+ }
+
+ public void setSelectedAppointment(Appointment appointment,
+ boolean fireEvents) {
+ appointmentManager.setSelectedAppointment(appointment);
+ if (fireEvents) {
+ fireSelectionEvent(appointment);
+ }
+ }
+
+ /**
+ * Indicates whether there is a "currently selected" appointment
+ * at the moment.
+ *
+ * @return true if there is an appointment currently selected,
+ * false if it is null.
+ * @see com.bradrydzewski.gwt.calendar.client.AppointmentManager#hasAppointmentSelected()
+ */
+ public boolean hasAppointmentSelected() {
+ return appointmentManager.hasAppointmentSelected();
+ }
+
+ /**
+ * Gets the currently selected item.
+ *
+ * @return the selected item.
+ */
+ public Appointment getSelectedAppointment() {
+ return appointmentManager.getSelectedAppointment();
+ }
+
+ /**
+ * Tells whether the passed appointment is the currently
+ * selected appointment.
+ *
+ * @param appointment The appointment to test to be the currently selected
+ * @return true if there is a currently selected appointment
+ * and happens to be equal to the passed appointment
+ * @see com.bradrydzewski.gwt.calendar.client.AppointmentManager#isTheSelectedAppointment(Appointment)
+ */
+ public boolean isTheSelectedAppointment(Appointment appointment) {
+ return appointmentManager.isTheSelectedAppointment(appointment);
+ }
+
+ /**
+ * Performs all layout calculations for the list of appointments and resizes
+ * the Calendar View appropriately.
+ */
+ protected void refresh() {
+ if (layoutSuspended) {
+ layoutPending = true;
+ return;
+ }
+
+ appointmentManager.resetHoveredAppointment();
+ appointmentManager.sortAppointments();
+
+ doLayout();
+ doSizing();
+ }
+
+ public void doLayout() {
+ view.doLayout();
+ }
+
+ public void doSizing() {
+ view.doSizing();
+ }
+
+ public void onLoad() {
+ Scheduler.get().scheduleDeferred(new ScheduledCommand() {
+ public void execute() {
+ refresh();
+ }
+ });
+ }
+
+ /**
+ * Suspends the calendar from performing a layout. This can be useful when
+ * adding a large number of appointments at a time, since a layout is
+ * performed each time an appointment is added.
+ */
+ public void suspendLayout() {
+ layoutSuspended = true;
+ }
+
+ /**
+ * Allows the calendar to perform a layout, sizing the component and placing
+ * all appointments. If a layout is pending it will get executed when this
+ * method is called.
+ */
+ public void resumeLayout() {
+ layoutSuspended = false;
+
+ if (layoutPending) {
+ refresh();
+ }
+ }
+
+ public CalendarSettings getSettings() {
+ return this.settings;
+ }
+
+ public void setSettings(CalendarSettings settings) {
+ this.settings = settings;
+ }
+
+ public void scrollToHour(int hour) {
+ view.scrollToHour(hour);
+ }
+
+ public boolean selectPreviousAppointment() {
+
+ boolean selected = appointmentManager.selectPreviousAppointment();
+ if (selected) {
+ fireSelectionEvent(getSelectedAppointment());
+ }
+
+ return selected;
+ }
+
+ public boolean selectNextAppointment() {
+ boolean selected = appointmentManager.selectNextAppointment();
+ if (selected) {
+ fireSelectionEvent(getSelectedAppointment());
+ }
+ return selected;
+ }
+
+ @Override
+ public void onDeleteKeyPressed() {
+ view.onDeleteKeyPressed();
+ }
+
+ @Override
+ public void onDoubleClick(Element element, Event event) {
+ view.onDoubleClick(element, event);
+ }
+
+ @Override
+ public void onDownArrowKeyPressed() {
+ view.onDownArrowKeyPressed();
+ }
+
+ @Override
+ public void onLeftArrowKeyPressed() {
+ view.onLeftArrowKeyPressed();
+ }
+
+ @Override
+ public void onMouseDown(Element element, Event event) {
+ view.onSingleClick(element, event);
+ }
+
+ public void onMouseOver(Element element, Event event) {
+ view.onMouseOver(element, event);
+ }
+
+ @Override
+ public void onRightArrowKeyPressed() {
+ view.onRightArrowKeyPressed();
+ }
+
+ @Override
+ public void onUpArrowKeyPressed() {
+ view.onUpArrowKeyPressed();
+ }
+
+ public void fireOpenEvent(Appointment appointment) {
+ OpenEvent.fire(this, appointment);
+ }
+
+ public void fireDeleteEvent(Appointment appointment) {
+
+ //fire the event to notify the client
+ boolean allow = DeleteEvent.fire(this, appointment);
+
+ if (allow) {
+ appointmentManager.removeAppointment(appointment);
+ refresh();
+ }
+ }
+
+ public void fireSelectionEvent(Appointment appointment) {
+ view.onAppointmentSelected(appointment);
+ SelectionEvent.fire(this, appointment);
+ }
+
+ public void fireMouseOverEvent(
+ Appointment appointment, Element element) {
+ //we need to make sure we aren't re-firing the event
+ // for the same appointment. This is a bit problematic,
+ // because the mouse over event will fire for an appointment's
+ // child elements (title label, footer, body, for example)
+ // and will cause this method to be called with a null
+ // appointment. this is a temp workaround, but basically
+ // an appointment cannot be hovered twice in a row
+ if (appointment != null
+ && !appointment.equals(appointmentManager
+ .getHoveredAppointment())) {
+ appointmentManager.setHoveredAppointment(appointment);
+ MouseOverEvent.fire(this, appointment, element);
+ }
+ }
+
+ public void fireTimeBlockClickEvent(Date date) {
+ TimeBlockClickEvent.fire(this, date);
+ }
+
+ public void fireCreateEvent(Appointment appointment) {
+ boolean allow = CreateEvent.fire(this, appointment);
+ if (!allow) {
+ appointmentManager.rollback();
+ refresh();
+ }
+ }
+
+ public void fireDateRequestEvent(Date date) {
+ DateRequestEvent.fire(this, date);
+ }
+
+ public void fireDateRequestEvent(Date date, Element clicked) {
+ DateRequestEvent.fire(this, date, clicked);
+ }
+
+ public void fireUpdateEvent(Appointment appointment) {
+ //refresh the appointment
+ refresh();
+ //fire the event to notify the client
+ boolean allow = UpdateEvent.fire(this, appointment);
+
+ if (!allow) {
+ appointmentManager.rollback();
+ refresh();
+ }
+ }
+
+ public HandlerRegistration addSelectionHandler(
+ SelectionHandler handler) {
+ return addHandler(handler, SelectionEvent.getType());
+ }
+
+ public HandlerRegistration addDeleteHandler(
+ DeleteHandler handler) {
+ return addHandler(handler, DeleteEvent.getType());
+ }
+
+ public HandlerRegistration addMouseOverHandler(
+ MouseOverHandler handler) {
+ return addHandler(handler, MouseOverEvent.getType());
+ }
+
+ public HandlerRegistration addTimeBlockClickHandler(
+ TimeBlockClickHandler handler) {
+ return addHandler(handler, TimeBlockClickEvent.getType());
+ }
+
+ public HandlerRegistration addUpdateHandler(UpdateHandler handler) {
+ return addHandler(handler, UpdateEvent.getType());
+ }
+
+ public HandlerRegistration addCreateHandler(
+ CreateHandler handler) {
+ return addHandler(handler, CreateEvent.getType());
+ }
+
+ public HandlerRegistration addOpenHandler(
+ OpenHandler handler) {
+ return addHandler(handler, OpenEvent.getType());
+ }
+
+ public HandlerRegistration addDateRequestHandler(
+ DateRequestHandler handler) {
+ return addHandler(handler, DateRequestEvent.getType());
+ }
+
+ public void addToRootPanel(Widget widget) {
+ getRootPanel().add(widget);
+ }
+
+ public void setRollbackAppointment(Appointment appt) {
+ appointmentManager.setRollbackAppointment(appt);
+ }
+
+ public void setCommittedAppointment(Appointment appt) {
+ appointmentManager.setCommittedAppointment(appt);
+ }
+}
\ No newline at end of file
diff --git a/src/com/bradrydzewski/gwt/calendar/client/DateUtils.java b/src/com/bradrydzewski/gwt/calendar/client/DateUtils.java
new file mode 100644
index 0000000..795a78f
--- /dev/null
+++ b/src/com/bradrydzewski/gwt/calendar/client/DateUtils.java
@@ -0,0 +1,405 @@
+/*
+ * This file is part of gwt-cal
+ * Copyright (C) 2009-2011 Scottsdale Software LLC
+ *
+ * gwt-cal is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see null -safe way to return the number of milliseconds
+ * on a date.
+ *
+ * @param date The date whose value in milliseconds will be returned
+ * @return The number of milliseconds in date, 0
+ * (zero) if date is null.
+ */
+ private static long safeInMillis(Date date) {
+ return date != null ? date.getTime() : 0;
+ }
+
+ /**
+ * Returns the number of days between the passed dates.
+ *
+ * @param endDate The upper limit of the date range
+ * @param startDate The lower limit of the date range
+ * @return The number of days between endDate and
+ * starDate (inclusive)
+ */
+ @SuppressWarnings(value = "deprecation")
+ public static int differenceInDays(Date endDate, Date startDate) {
+ int difference = 0;
+ if (!areOnTheSameDay(endDate, startDate)) {
+ int endDateOffset = -(endDate.getTimezoneOffset() * 60 * 1000);
+ long endDateInstant = endDate.getTime() + endDateOffset;
+ int startDateOffset = -(startDate.getTimezoneOffset() * 60 * 1000);
+ long startDateInstant = startDate.getTime() + startDateOffset;
+ double differenceDouble =
+ (double) Math.abs(endDateInstant - startDateInstant) /
+ (double) MILLIS_IN_A_DAY;
+ differenceDouble = Math.max(1.0D, differenceDouble);
+ difference = (int) differenceDouble;
+ }
+ return difference;
+ }
+
+ /**
+ * Returns the full year (4-digits) of the passed date.
+ * @param date The date whose year will be returned
+ * @return The full year of the passed date.
+ */
+ @SuppressWarnings("deprecation")
+ public static int year(Date date) {
+ return 1900 + date.getYear();
+ }
+
+ /**
+ * Moves a date shift days. A clone of date to
+ * prevent undesired object modifications.
+ *
+ * @param date The date to shift
+ * @param shift The number of days to push the original date
+ * forward
+ * @return A new date pushed shift days forward
+ */
+ @SuppressWarnings("deprecation")
+ public static Date shiftDate(Date date, int shift) {
+ Date result = (Date) date.clone();
+ result.setDate(date.getDate() + shift);
+ return result;
+ }
+
+ /**
+ * Resets the date to have no time modifiers (hours, minutes, seconds.)
+ *
+ * @param date The date to reset
+ */
+ @SuppressWarnings("deprecation")
+ public static void resetTime(Date date) {
+ long milliseconds = safeInMillis(date);
+ milliseconds = (milliseconds / 1000) * 1000;
+ date.setTime(milliseconds);
+ date.setHours(DateUtils.getDayStartsAt());
+ date.setMinutes(0);
+ date.setSeconds(0);
+ }
+
+ /**
+ * Indicates whether two dates are on the same date by comparing their day,
+ * month and year values. Time values such as hours and minutes are not
+ * considered in this comparison.
+ *
+ * @param dateOne The first date to test
+ * @param dateTwo The second date to test
+ * @return true if both dates have their date,
+ * month and year properties with the
+ * exact same values (whatever they are)
+ */
+ @SuppressWarnings("deprecation")
+ public static boolean areOnTheSameDay(Date dateOne, Date dateTwo) {
+ Date end;
+ Date start;
+
+ if (dateTwo.getTime() > dateOne.getTime()) {
+ end = (Date) dateTwo.clone();
+ start = (Date) dateOne.clone();
+ } else {
+ start = (Date) dateTwo.clone();
+ end = (Date) dateOne.clone();
+ }
+
+ if (DateUtils.dayStartsAt != 0) {
+ long time = start.getTime()
+ - (1000 * 60 * 60 * DateUtils.dayStartsAt);
+ start = new Date(time);
+
+ time = end.getTime()
+ - (1000 * 60 * 60 * DateUtils.dayStartsAt);
+ end = new Date(time);
+ }
+
+ return start.getDate() == end.getDate()
+ && start.getMonth() == end.getMonth()
+ && start.getYear() == end.getYear();
+ }
+
+ /**
+ * Indicates whether two dates are on the same month of the same year.
+ *
+ * @param dateOne The first date of the comparison
+ * @param dateTwo The second date of the comparison
+ * @return true if both dates have the same year and month,
+ * false otherwise
+ */
+ @SuppressWarnings("deprecation")
+ public static boolean areOnTheSameMonth(Date dateOne, Date dateTwo) {
+ Date end = (Date)dateTwo.clone();
+
+ if (DateUtils.dayStartsAt != 0) {
+ long time = end.getTime() - (1000 * 60 * 60 * DateUtils.dayStartsAt);
+ end = new Date(time);
+ }
+
+ return dateOne.getYear() == end.getYear() &&
+ dateOne.getMonth() == end.getMonth();
+ }
+
+ /**
+ * Returns a clone of the anyDayInMonth date set to the
+ * first day of whatever its month is.
+ *
+ * @param anyDayInMonth Any date on a month+year
+ * @return A clone of the anyDayInMonth date, representing the
+ * first day of that same month and year
+ */
+ @SuppressWarnings("deprecation")
+ public static Date firstOfTheMonth(Date anyDayInMonth) {
+ Date first = (Date) anyDayInMonth.clone();
+ first.setDate(1);
+ return first;
+ }
+
+ /**
+ * Moves the date of the passed object to be one day after whatever date it
+ * has.
+ *
+ * @param date An object representing a date
+ * @return The day
+ */
+ @SuppressWarnings("deprecation")
+ public static Date moveOneDayForward(Date date) {
+ date.setDate(date.getDate() + 1);
+ return date;
+ }
+
+ /**
+ * Returns the date corresponding to the first day of the next month relative
+ * to the passed date.
+ *
+ * @param date The reference date
+ * @return The first day of the next month, if the month of the passed date
+ * corresponds to december (11) one will be
+ * added to the year of the returned date.
+ */
+ @SuppressWarnings("deprecation")
+ public static Date firstOfNextMonth(Date date) {
+ Date firstOfNextMonth = null;
+ if (date != null) {
+ int year = date.getMonth() == 11 ? date.getYear() + 1 : date.getYear();
+ firstOfNextMonth = new Date(year, date.getMonth() + 1 % 11, 1);
+ }
+ return firstOfNextMonth;
+ }
+
+ /**
+ * Returns a day exactly 24 hours before the instant passed as
+ * date. // TODO: This logic should address the time zone
+ * offset
+ *
+ * @param date A point in time from which the moment 24 hours before will be
+ * calculated
+ * @return A new object 24 hours prior to the passed
+ * date
+ */
+ public static Date previousDay(Date date) {
+ return new Date(date.getTime() - MILLIS_IN_A_DAY);
+ }
+
+
+ /**
+ * Copies the hours, minutes and seconds in the source date into
+ * the target date object.
+ *
+ * @param source The date with the hour, minutes and seconds to be copied
+ * @param target The date whose time fields will be set
+ */
+ @SuppressWarnings("deprecation")
+ public static void copyTime(Date source, Date target) {
+ target.setHours(source.getHours());
+ target.setMinutes(source.getMinutes());
+ target.setSeconds(source.getSeconds());
+ }
+
+ /**
+ * Returns the amount of minutes elapsed since the beginning of the passed
+ * day.
+ *
+ * @param day The day to calculate the elapsed minutes
+ * @return The number of minutes since day started
+ */
+ @SuppressWarnings("deprecation")
+ public static int minutesSinceDayStarted(Date day) {
+ int minutes = (day.getHours() - dayStartsAt) * 60 + day.getMinutes();
+ if (day.getHours() < dayStartsAt) {
+ minutes = ((24 - dayStartsAt) + day.getHours()) * 60 + day.getMinutes();
+ }
+ return minutes;
+ }
+
+ /**
+ * Creates a new date with whatever date/time the passed date
+ * object represents.
+ *
+ * @param date The source date
+ * @return A new date object representing the same date and time as the passed
+ * object
+ */
+ public static Date newDate(Date date) {
+ Date result = null;
+ if (date != null) {
+ result = new Date(date.getTime());
+ }
+ return result;
+ }
+
+ @SuppressWarnings("deprecation")
+ public static boolean isWeekend(final Date day) {
+ return day.getDay()==0 || day.getDay()==6;
+ }
+
+ @SuppressWarnings("deprecation")
+ public static Integer weekday(final Date date) {
+ int firstDayOfWeek = Integer.valueOf(CalendarFormat.INSTANCE.getFirstDayOfWeek());
+
+ int weekday = date.getDay();
+ if ((firstDayOfWeek == 1) && (weekday == 0)) {
+ weekday = 7;
+ }
+ return weekday;
+ }
+
+ @SuppressWarnings("deprecation")
+ public static int calendarWeekIso(final Date inputDate) {
+ final int daysWeek = 7;
+ int firstDayOfWeek = Integer.valueOf(CalendarFormat.INSTANCE.getFirstDayOfWeek());
+
+ int thursdayDay = 4 + firstDayOfWeek;
+
+ Date thisThursday = new Date(inputDate.getYear(), inputDate.getMonth(),
+ inputDate.getDate() - weekday(inputDate) + thursdayDay);
+
+ Date firstThursdayOfYear = new Date(thisThursday.getYear(), 0, 1);
+
+ while (weekday(firstThursdayOfYear) != thursdayDay) {
+ firstThursdayOfYear.setDate(firstThursdayOfYear.getDate() + 1);
+ }
+
+ Date firstMondayOfYear = new Date(firstThursdayOfYear.getYear(), 0,
+ firstThursdayOfYear.getDate() - 3);
+
+ Long cw = (thisThursday.getTime() - firstMondayOfYear.getTime())
+ / MILLIS_IN_A_DAY / daysWeek + 1;
+
+ return cw.intValue();
+ }
+
+ /**
+ * Adds or subtracts the specified amount of days for the given Date.
+ *
+ * @param date
+ * A point in time
+ * @param days
+ * Number of days to add or substract
+ * @return A new object days after to the passed date
+ */
+ public static Date addDays(final Date date, final int days) {
+ return new Date(date.getTime() + (days * MILLIS_IN_A_DAY));
+ }
+
+ /**
+ * Adds or subtracts the specified amount of weeks for the given Date.
+ *
+ * @param date
+ * A point in time
+ * @param weeks
+ * Number of weeks to add or substract
+ * @return A new object weeks after to the passed date
+ */
+ public static Date addWeeks(final Date date, final int weeks) {
+ return new Date(date.getTime() + (weeks * (MILLIS_IN_A_DAY * DAYS_IN_A_WEEK)));
+ }
+
+ /**
+ * Adds or subtracts the specified amount of months for the given Date.
+ *
+ * @param date
+ * A point in time
+ * @param months
+ * Number of months to add or substract
+ * @return A new object weeks after to the passed date
+ */
+ public static Date addMonths(final Date date, final int months) {
+ return new Date(date.getTime() + (months * (MILLIS_IN_A_DAY * DAYS_IN_A_WEEK)));
+ }
+
+ /**
+ * Returns the total number of days between start and
+ * end. The calculation is rounded to take in account
+ * the saving day calculation.
+ *
+ * @param start
+ * The first day in the period
+ * @param end
+ * The last day in the period
+ * @return The number of days between start and
+ * end, the minimum difference being one (
+ * 1)
+ */
+ public static int daysInPeriod(final Date start, final Date end) {
+ long diff = end.getTime() - start.getTime();
+ double days = ((double)diff / MILLIS_IN_A_DAY) + 1;
+
+ Long result = Math.round(days);
+ return result.intValue();
+ }
+
+ /**
+ * Calculates the amount of days in the month the
+ * @param day
+ * @return
+ */
+ public static int daysInMonth(final Date date) {
+ return 32 - new Date(date.getYear(), date.getMonth(), 32).getDate();
+ }
+}
diff --git a/src/com/bradrydzewski/gwt/calendar/client/HasAppointments.java b/src/com/bradrydzewski/gwt/calendar/client/HasAppointments.java
new file mode 100644
index 0000000..fc5dc19
--- /dev/null
+++ b/src/com/bradrydzewski/gwt/calendar/client/HasAppointments.java
@@ -0,0 +1,17 @@
+package com.bradrydzewski.gwt.calendar.client;
+
+import java.util.List;
+
+public interface HasAppointments {
+
+ void removeAppointment(Appointment appointment);
+ void removeAppointment(Appointment appointment, boolean fireEvents);
+ void addAppointment(Appointment appointment);
+ void addAppointments(ListonMouseDown and onDoubleClick methods to provide
+ * the custom event processing logic.
+ *
+ * @author Brad Rydzewski
+ */
+public abstract class InteractiveWidget extends Composite {
+
+ /**
+ * Focus widget used to add keyboard and mouse focus to a calendar.
+ */
+ private FocusPanel focusPanel = new FocusPanel();
+
+ /**
+ * Main panel hold all other components.
+ */
+ protected FlowPanel rootPanel = new FlowPanel();
+
+ /**
+ * Used by focus widget to make sure a key stroke is only handled once by
+ * the calendar.
+ */
+ private boolean lastWasKeyDown = false;
+
+ public InteractiveWidget() {
+
+ initWidget(rootPanel);
+
+ //Sink events, mouse and keyboard for now
+ sinkEvents(Event.ONMOUSEDOWN | Event.ONDBLCLICK | Event.KEYEVENTS | Event.ONMOUSEOVER);
+
+ hideFocusPanel();
+
+ //Add key handler events to the focus panel
+ focusPanel.addKeyPressHandler(new KeyPressHandler() {
+ public void onKeyPress(KeyPressEvent event) {
+ if (!lastWasKeyDown) {
+ keyboardNavigation(event.getNativeEvent().getKeyCode());
+ }
+ lastWasKeyDown = false;
+ }
+ });
+
+ focusPanel.addKeyUpHandler(new KeyUpHandler() {
+ public void onKeyUp(KeyUpEvent event) {
+ lastWasKeyDown = false;
+ }
+ });
+ focusPanel.addKeyDownHandler(new KeyDownHandler() {
+ public void onKeyDown(KeyDownEvent event) {
+ keyboardNavigation(event.getNativeEvent().getKeyCode());
+ lastWasKeyDown = true;
+ }
+ });
+ }
+
+ /**
+ * Makes the widget's focus panel invisible.
+ */
+ private void hideFocusPanel() {
+/*
+ focusPanel.setVisible(false);
+ RootPanel.get().add(focusPanel);
+ DOM.setStyleAttribute(focusPanel.getElement(), "position", "absolute");
+ DOM.setStyleAttribute(focusPanel.getElement(), "top", "0");
+ DOM.setStyleAttribute(focusPanel.getElement(), "left", "0");
+ DOM.setStyleAttribute(focusPanel.getElement(), "height", "100%");
+ DOM.setStyleAttribute(focusPanel.getElement(), "width", "100%");
+*/
+ RootPanel.get().add(focusPanel);
+ DOM.setStyleAttribute(focusPanel.getElement(), "position", "absolute");
+ DOM.setStyleAttribute(focusPanel.getElement(), "top", "-10");
+ DOM.setStyleAttribute(focusPanel.getElement(), "left", "-10");
+ DOM.setStyleAttribute(focusPanel.getElement(), "height", "0px");
+ DOM.setStyleAttribute(focusPanel.getElement(), "width", "0px");
+ }
+
+ public ComplexPanel getRootPanel() {
+ return rootPanel;
+ }
+
+ /**
+ * Processes mouse double-click events. Concrete interactive widgets should
+ * provide the component's specific logic.
+ *
+ * @param element The HTML DOM element that originated the event
+ */
+ public abstract void onDoubleClick(Element element, Event event);
+
+ /**
+ * Processes mouse over events. Concrete interactive widgets
+ * should provide the component's specific logic.
+ *
+ * @param element The HTML DOM element that originated the event
+ * @param event The HTML DOM event that was triggered
+ */
+ public abstract void onMouseOver(Element element, Event event);
+
+ /**
+ * Processes mouse button pressing events. Concrete interactive widgets
+ * should provide the component's specific logic.
+ *
+ * @param element The HTML DOM element that originated the event
+ */
+ public abstract void onMouseDown(Element element, Event event);
+
+ /**
+ * Processes {@link com.google.gwt.event.dom.client.KeyCodes.KEY_DELETE}
+ * and {@link com.google.gwt.event.dom.client.KeyCodes.KEY_BACKSPACE}
+ * keystrokes. Concrete interactive widgets should provide the component's
+ * specific logic.
+ */
+ public abstract void onDeleteKeyPressed();
+
+ /**
+ * Processes {@link com.google.gwt.event.dom.client.KeyCodes.KEY_UP}
+ * keystrokes. Concrete interactive widgets should provide the component's
+ * specific logic.
+ */
+ public abstract void onUpArrowKeyPressed();
+
+ /**
+ * Processes {@link com.google.gwt.event.dom.client.KeyCodes.KEY_DOWN}
+ * keystrokes. Concrete interactive widgets should provide the component's
+ * specific logic.
+ */
+ public abstract void onDownArrowKeyPressed();
+
+ /**
+ * Processes {@link com.google.gwt.event.dom.client.KeyCodes.KEY_LEFT}
+ * keystrokes. Concrete interactive widgets should provide the component's
+ * specific logic.
+ */
+ public abstract void onLeftArrowKeyPressed();
+
+ /**
+ * Processes {@link com.google.gwt.event.dom.client.KeyCodes.KEY_RIGHT}
+ * keystrokes. Concrete interactive widgets should provide the component's
+ * specific logic.
+ */
+ public abstract void onRightArrowKeyPressed();
+
+ @Override
+ public void onBrowserEvent(Event event) {
+ int eventType = DOM.eventGetType(event);
+ Element element = DOM.eventGetTarget(event);
+
+ switch (eventType) {
+ case Event.ONDBLCLICK: {
+ onDoubleClick(element, event);
+ focusPanel.setFocus(true);
+ break;
+ }
+ case Event.ONMOUSEDOWN: {
+ if (DOM.eventGetCurrentTarget(event) == getElement()) {
+
+ onMouseDown(element, event);
+ focusPanel.setFocus(true);
+ //Cancel events so Firefox / Chrome don't
+ //give child widgets with scrollbars focus.
+ //TODO: Should not cancel onMouseDown events in the event an appointment would have a child widget with a scrollbar (if this would ever even happen).
+ DOM.eventCancelBubble(event, true);
+ DOM.eventPreventDefault(event);
+ return;
+ }
+ }
+ case Event.ONMOUSEOVER:{
+ if (DOM.eventGetCurrentTarget(event) == getElement()){
+ onMouseOver(element, event);
+ DOM.eventCancelBubble(event, true);
+ DOM.eventPreventDefault(event);
+ return;
+ }
+ }
+ }
+
+ super.onBrowserEvent(event);
+ }
+
+ /**
+ * Dispatches the processing of a key being pressed to the this widget
+ * onXXXXKeyPressed methods.
+ *
+ * @param key Pressed key code
+ */
+ protected void keyboardNavigation(int key) {
+ switch (key) {
+ case KeyCodes.KEY_BACKSPACE: {
+ onDeleteKeyPressed();
+ break;
+ }
+ case KeyCodes.KEY_DELETE: {
+ onDeleteKeyPressed();
+ break;
+ }
+ case KeyCodes.KEY_LEFT: {
+ onLeftArrowKeyPressed();
+ break;
+ }
+ case KeyCodes.KEY_UP: {
+ onUpArrowKeyPressed();
+ break;
+ }
+ case KeyCodes.KEY_RIGHT: {
+ onRightArrowKeyPressed();
+ break;
+ }
+ case KeyCodes.KEY_DOWN: {
+ onDownArrowKeyPressed();
+ break;
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/com/bradrydzewski/gwt/calendar/client/ThemeAppointmentStyle.java b/src/com/bradrydzewski/gwt/calendar/client/ThemeAppointmentStyle.java
new file mode 100644
index 0000000..21a6827
--- /dev/null
+++ b/src/com/bradrydzewski/gwt/calendar/client/ThemeAppointmentStyle.java
@@ -0,0 +1,46 @@
+/*
+ * This file is part of gwt-cal
+ * Copyright (C) 2011 Scottsdale Software LLC
+ *
+ * gwt-cal is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see true if is adding the appointments to the multiview section, false otherwise
+ */
+ private void addAppointmentsToGrid(final Listelement. Each Appointment drawn on the CalendarView maps to
+ * a Widget and therefore an Element. This method attempts to find an
+ * Appointment based on the provided Element. If no match is found a null
+ * value is returned.
+ *
+ * @param element
+ * Element to look up.
+ * @return Appointment matching the element.
+ */
+ private Appointment findAppointmentByElement(Element element) {
+ Appointment appointmentAtElement = null;
+ for (AppointmentWidget widget : appointmentWidgets) {
+ if (DOM.isOrHasChild(widget.getElement(), element)) {
+ appointmentAtElement = widget.getAppointment();
+ break;
+ }
+ }
+ return appointmentAtElement;
+ }
+
+ /**
+ * Finds any related adapters that match the given Appointment.
+ *
+ * @param appt
+ * Appointment to match.
+ * @return List of related AppointmentWidget objects.
+ */
+ private List
+ * Note how overlapping appointments are displayed in the provided image
+ *
+ * @author Brad Rydzewski
+ * @version 1.0 6/07/09
+ * @since 1.0
+ */
+public class DayViewLayoutStrategy {
+
+ private static final int MINUTES_PER_HOUR = 60;
+ private static final int HOURS_PER_DAY = 24;
+ private final HasSettings settings;
+
+ public DayViewLayoutStrategy(final HasSettings settings) {
+ this.settings = settings;
+ }
+
+ public List
+ *
MonthView in which there are more
+ * appointments to display than fit in the day cell.
+ *
+ * @param appointments The number of additional appointments in the day
+ * @return The localized string
+ */
+ public String more(int appointments);
+
+ /**
+ * The localized text label for 12 p.m.
+ *
+ * @return The label for the noon
+ */
+ public String noon();
+
+ /**
+ * String representing AM. For certain locales this
+ * will be null.
+ *
+ * @return AM string
+ */
+ public String am();
+
+ /**
+ * String representing AM. For certain locales this
+ * will be null.
+ *
+ * @return PM string
+ */
+ public String pm();
+
+
+ /**
+ * String used to format time in the DayView
+ * components timeline. Example: time is formatted in the US as h AM,
+ * and is formatted in French HH:00.
+ *
+ * @return The localized time format for the DayView
+ */
+ public String timeFormat();
+
+ /**
+ * Each column in the DayView represents a date in time, and
+ * displays the date in its header (i.e. Wed, Jan 15). This property
+ * provides the pattern to format the date.
+ *
+ * @return The localized time format for the DayView
+ */
+ public String dateFormat();
+
+ /**
+ * Each column in the MonthView represents a day of the week,
+ * and displays the day of the week in its header (i.e. Mon, Tue, Wed). This
+ * property provides the pattern to format the day of the week.
+ *
+ * @return The pattern to format the names of the days in the month view
+ */
+ public String weekdayFormat();
+
+ /**
+ * Returns the pattern to format the days in a month.
+ *
+ * @return The pattern to format the names/numbers of days in a month
+ */
+ public String dayOfMonthFormat();
+
+ /**
+ * Returns what the first day of the week is; e.g., SUNDAY in the U.S.,
+ * MONDAY in France.
+ *
+ * @return The text representing the first day of the week, zero-based
+ * (Sunday is 0, Monday is 1, Tuesday is 2, etc.)
+ */
+ public String firstDayOfWeek();
+}
diff --git a/src/com/bradrydzewski/gwt/calendar/client/i18n/CalendarConstants.properties b/src/com/bradrydzewski/gwt/calendar/client/i18n/CalendarConstants.properties
new file mode 100644
index 0000000..dae9dba
--- /dev/null
+++ b/src/com/bradrydzewski/gwt/calendar/client/i18n/CalendarConstants.properties
@@ -0,0 +1,9 @@
+noon=Noon
+more=+{0} more
+dayOfMonthFormat=d
+timeFormat=h
+dateFormat=EEE, MMM d
+weekdayFormat=EEE
+am=AM
+pm=PM
+firstDayOfWeek=0
\ No newline at end of file
diff --git a/src/com/bradrydzewski/gwt/calendar/client/monthview/AppointmentLayoutDescription.java b/src/com/bradrydzewski/gwt/calendar/client/monthview/AppointmentLayoutDescription.java
new file mode 100644
index 0000000..2638383
--- /dev/null
+++ b/src/com/bradrydzewski/gwt/calendar/client/monthview/AppointmentLayoutDescription.java
@@ -0,0 +1,105 @@
+package com.bradrydzewski.gwt.calendar.client.monthview;
+
+import com.bradrydzewski.gwt.calendar.client.Appointment;
+
+/**
+ * Contains common properties and behavior for layout descriptions that can be
+ * "stacked" on top of each month view's week.
+ *
+ * @author Carlos D. Morales
+ */
+public class AppointmentLayoutDescription {
+ /**
+ * The layer order (in a stack-like arrangement)assigned to this description
+ * by the AppointmentStackingManager when arranging the
+ * descriptions on the top of a week.
+ */
+ private int stackOrder = 0;
+
+ /**
+ * The start day of the described Appointment when laid on the
+ * top of one of the weeks while visualizing a month through the
+ * MonthView.
+ */
+ private int fromWeekDay = 0;
+
+ /**
+ * The end day of the described Appointment when laid on the top
+ * of one of the weeks while visualizing a month through the
+ * MonthView.
+ */
+ private int toWeekDay = 0;
+
+ /**
+ * The underlying Appointment whose details will be displayed
+ * through the MonthView.
+ */
+ private Appointment appointment = null;
+
+
+ public AppointmentLayoutDescription(int fromWeekDay, int toWeekDay,
+ Appointment appointment) {
+ this.toWeekDay = toWeekDay;
+ this.fromWeekDay = fromWeekDay;
+ this.appointment = appointment;
+ }
+
+ public AppointmentLayoutDescription(int weekDay,
+ Appointment appointment) {
+ this(weekDay, weekDay, appointment);
+ }
+
+ public boolean overlapsWithRange(int from, int to) {
+ return fromWeekDay >= from && fromWeekDay <= to ||
+ fromWeekDay <= from && toWeekDay >= from;
+ }
+
+ public void setStackOrder(int stackOrder) {
+ this.stackOrder = stackOrder;
+ }
+
+ public int getStackOrder() {
+ return stackOrder;
+ }
+
+ public int getWeekStartDay() {
+ return fromWeekDay;
+ }
+
+ public int getWeekEndDay() {
+ return toWeekDay;
+ }
+
+ public boolean spansMoreThanADay() {
+ return fromWeekDay != toWeekDay;
+ }
+
+ public AppointmentLayoutDescription split() {
+ AppointmentLayoutDescription secondPart = null;
+ if (spansMoreThanADay()) {
+ secondPart =
+ new AppointmentLayoutDescription(fromWeekDay + 1, toWeekDay,
+ appointment);
+ this.toWeekDay = this.fromWeekDay;
+ } else {
+ secondPart = this;
+ }
+ return secondPart;
+ }
+
+
+ public Appointment getAppointment() {
+ return appointment;
+ }
+
+ public void setAppointment(Appointment appointment) {
+ this.appointment = appointment;
+ }
+
+ @Override public String toString() {
+ return "AppointmentLayoutDescription{" + "stackOrder=" + stackOrder
+ + ", fromWeekDay=" + fromWeekDay + ", toWeekDay=" + toWeekDay
+ + ", appointment=[" + appointment.getTitle() + "]@"
+ + appointment.hashCode() + '}';
+ }
+}
diff --git a/src/com/bradrydzewski/gwt/calendar/client/monthview/AppointmentStackingManager.java b/src/com/bradrydzewski/gwt/calendar/client/monthview/AppointmentStackingManager.java
new file mode 100644
index 0000000..0f262cc
--- /dev/null
+++ b/src/com/bradrydzewski/gwt/calendar/client/monthview/AppointmentStackingManager.java
@@ -0,0 +1,258 @@
+package com.bradrydzewski.gwt.calendar.client.monthview;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+/**
+ * Manages the AppointmentLayoutDescription in a stack-like
+ * structure arranged in layers. Layers are 0-based (1nd. layer has
+ * an index of 0, 2nd. has an index of 1).
+ *
+ * @author Carlos D. Morales
+ */
+public class AppointmentStackingManager {
+
+ /**
+ * The highest layer index that has been allocated by this manager.
+ */
+ private int highestLayer = 0;
+
+ /**
+ * The collection of AppointmentLayoutDescriptions grouped by by
+ * layer (map key).
+ */
+ private HashMapdescription to the first available
+ * layer in the collection administered by this manager. This manager will
+ * look up in the stack of layers (from lowest index to highest index) until
+ * a layer that does not have any AppointmentLayoutDescriptions
+ * that overlap with the days that the description's appointment spans.
+ *
+ * @param description An appointment description object that can be laid on a
+ * layer
+ */
+ public void assignLayer(AppointmentLayoutDescription description) {
+ boolean layerAssigned;
+ int currentlyInspectedLayer = 0;
+ do {
+ initLayer(currentlyInspectedLayer);
+ layerAssigned = assignLayer(currentlyInspectedLayer, description);
+ currentlyInspectedLayer++;
+ } while (!layerAssigned);
+ }
+
+ /**
+ * Returns the lowest layer index that is available on the specified
+ * day.
+ *
+ * @param day The day index for which the lowest layer index will be
+ * attempted to identify
+ * @return An integer representing the index of the layer (zero-based) for
+ * which an single day Appointment can be displayed on.
+ */
+ public int lowestLayerIndex(int day) {
+ return (nextLowestLayerIndex(day, 0));
+ }
+
+ /**
+ * Returns the lowest layer index higher than fromLayer
+ * that is available on the specified day.
+ *
+ * @param day The day index for which the lowest layer index will be
+ * attempted to identify found
+ * @param fromLayer The layer index after which the search for next
+ * available layer should be started from
+ * @return An integer representing the index of the layer (zero-based) for
+ * which an single day Appointment can be displayed on.
+ */
+ public int nextLowestLayerIndex(int day, int fromLayer) {
+ boolean layerFound = false;
+ int currentlyInspectedLayer = fromLayer;
+ do {
+ if (isLayerAllocated(currentlyInspectedLayer)) {
+ if (overlapsWithDescriptionInLayer(
+ layeredDescriptions.get(currentlyInspectedLayer), day,
+ day)) {
+ currentlyInspectedLayer++;
+ } else {
+ layerFound = true;
+ }
+ } else {
+ layerFound = true;
+ }
+
+ } while (!layerFound);
+ return currentlyInspectedLayer;
+ }
+
+ /**
+ * Returns all the AppointmentLayoutDescriptions in the
+ * specified layer.
+ *
+ * @param layerIndex The index of a layer for which descriptions will be
+ * returned
+ * @return The collection of appointment descriptions in the layer,
+ * null if no appointment has been allocated for the
+ * layer at all
+ */
+ public ArrayListstart-end
+ * overlaps with any of the appointment descriptions in
+ * layerDescriptions.
+ *
+ * @param layerDescriptions All the AppointmentLayoutDescription
+ * in a single layer.
+ * @param start The first day of the week in the range to test
+ * @param end The last day of the week in the range to test
+ * @return true if any appointment description in
+ * layerDescriptions overlaps with the specified range,
+ * false otherwise.
+ */
+ private boolean overlapsWithDescriptionInLayer(
+ ArrayListlayerIndex
+ * has been allocated in the layeredDescriptions map.
+ *
+ * @param layerIndex The index of a layer to verify
+ * @return true if the layeredDescriptions map has
+ * an entry (List<AppointmentLayoutDescription>)
+ * for the layerIndex.
+ */
+ private boolean isLayerAllocated(int layerIndex) {
+ return layeredDescriptions.get(layerIndex) != null;
+ }
+
+ /**
+ * Initializes the collection of descriptions for the layer with the
+ * specified layerIndex.
+ *
+ * @param layerIndex The index of a layer to initialize
+ */
+ private void initLayer(int layerIndex) {
+ if (!isLayerAllocated(layerIndex)) {
+ layeredDescriptions.put(layerIndex,
+ new ArrayListlayerOverflowLimit value when they were
+ * stacked.
+ *
+ * @param day The day to perform the count
+ * @return The number of days that got a layer higher than the configured
+ * layerOverflowLimit layer, if there were any
+ */
+ public int multidayAppointmentsOverLimitOn(int day) {
+ int count = 0;
+ for (int layer = 0; layer <= highestLayer; layer++) {
+ ArrayListday.
+ *
+ * @param day The day to test for appointments
+ * @return true if there are any descriptions in any layer for
+ * the specified day.
+ */
+ public boolean areThereAppointmentsOn(int day) {
+ boolean thereAre = false;
+ for (int layersIndex = 0; layersIndex <= highestLayer; layersIndex++) {
+ ArrayListMonthView. Through an association to a domain-model
+ * Appointment, AppointmentWidgets allow displaying
+ * the appointment details and to capture mouse and keyboard events.
+ *
Appointment represented by this panel.
+ */
+ private Appointment appointment;
+
+ /**
+ * Creates an AppointmentWidget with a reference to the provided
+ * appointment.
+ *
+ * @param appointment The appointment to be displayed through this panel
+ * widget
+ */
+ public AppointmentWidget(Appointment appointment) {
+ this.appointment = appointment;
+ Label titleLabel = new Label();
+ titleLabel.getElement().setInnerHTML(this.appointment.getTitle());
+ this.add(titleLabel);
+ }
+
+ /**
+ * Returns the Appointment this panel represents/is associated
+ * to.
+ *
+ * @return The domain model appointment rendered through this panel
+ */
+ public Appointment getAppointment() {
+ return appointment;
+ }
+}
diff --git a/src/com/bradrydzewski/gwt/calendar/client/monthview/AppointmentWidgetParts.java b/src/com/bradrydzewski/gwt/calendar/client/monthview/AppointmentWidgetParts.java
new file mode 100644
index 0000000..6adfb1a
--- /dev/null
+++ b/src/com/bradrydzewski/gwt/calendar/client/monthview/AppointmentWidgetParts.java
@@ -0,0 +1,12 @@
+package com.bradrydzewski.gwt.calendar.client.monthview;
+
+/**
+ * Indicates whether the presence of an Appointment that spans
+ * multiple weeks in a month view is the first, second or before the
+ * last, or the last.
+ *
+ * @author Carlos D. Morales
+ */
+public enum AppointmentWidgetParts {
+ FIRST_WEEK, IN_BETWEEN, LAST_WEEK
+}
diff --git a/src/com/bradrydzewski/gwt/calendar/client/monthview/DayLayoutDescription.java b/src/com/bradrydzewski/gwt/calendar/client/monthview/DayLayoutDescription.java
new file mode 100644
index 0000000..9169d5e
--- /dev/null
+++ b/src/com/bradrydzewski/gwt/calendar/client/monthview/DayLayoutDescription.java
@@ -0,0 +1,53 @@
+package com.bradrydzewski.gwt.calendar.client.monthview;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.bradrydzewski.gwt.calendar.client.Appointment;
+
+/**
+ * Contains the calculated layout description of all Appointments
+ * in single day part of a week row in a MonthView.
+ * Note: A DayLayoutDescription is not
+ * aware of multi-day Appointments that might span the day
+ * represented by this description.
+ *
+ * @author Carlos D. Morales
+ */
+public class DayLayoutDescription {
+ /**
+ * The list of simple appointments (not multiday, not all-day) in
+ * this single day.
+ */
+ private ListMonthView. This class is responsible for the distribution of the
+ * appointments over the multiple weeks they possibly span.
+ *
+ * @author Carlos D. Morales
+ */
+public class MonthLayoutDescription {
+
+ private Date calendarFirstDay = null;
+
+ private Date calendarLastDay = null;
+
+ private WeekLayoutDescription[] weeks = new WeekLayoutDescription[6];
+
+ public MonthLayoutDescription(Date calendarFirstDay,
+ int monthViewRequiredRows,
+ List