source.dussan.org Git - vaadin-framework.git/blob

   1 /*
   2  * Copyright 2000-2018 Vaadin Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
   5  * use this file except in compliance with the License. You may obtain a copy of
   6  * the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  12  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  13  * License for the specific language governing permissions and limitations under
  14  * the License.
  15  */
  16 package com.vaadin.v7.ui.components.calendar;
  17
  18 import java.io.Serializable;
  19 import java.lang.reflect.Method;
  20 import java.util.Date;
  21 import java.util.EventListener;
  22
  23 import com.vaadin.event.SerializableEventListener;
  24 import com.vaadin.util.ReflectTools;
  25 import com.vaadin.v7.shared.ui.calendar.CalendarEventId;
  26 import com.vaadin.v7.ui.Calendar;
  27 import com.vaadin.v7.ui.components.calendar.event.CalendarEvent;
  28
  29 /**
  30  * Interface for all Vaadin Calendar events.
  31  *
  32  * @since 7.1.0
  33  * @author Vaadin Ltd.
  34  *
  35  * @deprecated As of 8.0, no replacement available.
  36  */
  37 @Deprecated
  38 public interface CalendarComponentEvents extends Serializable {
  39
  40     /**
  41      * Notifier interface for notifying listener of calendar events.
  42      */
  43     @Deprecated
  44     public interface CalendarEventNotifier extends Serializable {
  45         /**
  46          * Get the assigned event handler for the given eventId.
  47          *
  48          * @param eventId
  49          * @return the assigned eventHandler, or null if no handler is assigned
  50          */
  51         public EventListener getHandler(String eventId);
  52     }
  53
  54     /**
  55      * Notifier interface for event drag & drops.
  56      */
  57     @Deprecated
  58     public interface EventMoveNotifier extends CalendarEventNotifier {
  59
  60         /**
  61          * Set the EventMoveHandler.
  62          *
  63          * @param listener
  64          *            EventMoveHandler to be added
  65          */
  66         public void setHandler(EventMoveHandler listener);
  67
  68     }
  69
  70     /**
  71      * MoveEvent is sent when existing event is dragged to a new position.
  72      */
  73     @SuppressWarnings("serial")
  74     @Deprecated
  75     public class MoveEvent extends CalendarComponentEvent {
  76
  77         public static final String EVENT_ID = CalendarEventId.EVENTMOVE;
  78
  79         /** Index for the moved Schedule.Event. */
  80         private CalendarEvent calendarEvent;
  81
  82         /** New starting date for the moved Calendar.Event. */
  83         private Date newStart;
  84
  85         /**
  86          * MoveEvent needs the target event and new start date.
  87          *
  88          * @param source
  89          *            Calendar component.
  90          * @param calendarEvent
  91          *            Target event.
  92          * @param newStart
  93          *            Target event's new start date.
  94          */
  95         public MoveEvent(Calendar source, CalendarEvent calendarEvent,
  96                 Date newStart) {
  97             super(source);
  98
  99             this.calendarEvent = calendarEvent;
 100             this.newStart = newStart;
 101         }
 102
 103         /**
 104          * Get target event.
 105          *
 106          * @return Target event.
 107          */
 108         public CalendarEvent getCalendarEvent() {
 109             return calendarEvent;
 110         }
 111
 112         /**
 113          * Get new start date.
 114          *
 115          * @return New start date.
 116          */
 117         public Date getNewStart() {
 118             return newStart;
 119         }
 120     }
 121
 122     /**
 123      * Handler interface for when events are being dragged on the calendar.
 124      *
 125      */
 126     @Deprecated
 127     public interface EventMoveHandler extends SerializableEventListener {
 128
 129         /** Trigger method for the MoveEvent. */
 130         public static final Method eventMoveMethod = ReflectTools.findMethod(
 131                 EventMoveHandler.class, "eventMove", MoveEvent.class);
 132
 133         /**
 134          * This method will be called when event has been moved to a new
 135          * position.
 136          *
 137          * @param event
 138          *            MoveEvent containing specific information of the new
 139          *            position and target event.
 140          */
 141         public void eventMove(MoveEvent event);
 142     }
 143
 144     /**
 145      * Handler interface for day or time cell drag-marking with mouse.
 146      */
 147     @Deprecated
 148     public interface RangeSelectNotifier
 149             extends CalendarEventNotifier {
 150
 151         /**
 152          * Set the RangeSelectHandler that listens for drag-marking.
 153          *
 154          * @param listener
 155          *            RangeSelectHandler to be added.
 156          */
 157         public void setHandler(RangeSelectHandler listener);
 158     }
 159
 160     /**
 161      * RangeSelectEvent is sent when day or time cells are drag-marked with
 162      * mouse.
 163      */
 164     @SuppressWarnings("serial")
 165     @Deprecated
 166     public class RangeSelectEvent extends CalendarComponentEvent {
 167
 168         public static final String EVENT_ID = CalendarEventId.RANGESELECT;
 169
 170         /** Calendar event's start date. */
 171         private Date start;
 172
 173         /** Calendar event's end date. */
 174         private Date end;
 175
 176         /**
 177          * Defines the event's view mode.
 178          */
 179         private boolean monthlyMode;
 180
 181         /**
 182          * RangeSelectEvent needs a start and end date.
 183          *
 184          * @param source
 185          *            Calendar component.
 186          * @param start
 187          *            Start date.
 188          * @param end
 189          *            End date.
 190          * @param monthlyMode
 191          *            Calendar view mode.
 192          */
 193         public RangeSelectEvent(Calendar source, Date start, Date end,
 194                 boolean monthlyMode) {
 195             super(source);
 196             this.start = start;
 197             this.end = end;
 198             this.monthlyMode = monthlyMode;
 199         }
 200
 201         /**
 202          * Get start date.
 203          *
 204          * @return Start date.
 205          */
 206         public Date getStart() {
 207             return start;
 208         }
 209
 210         /**
 211          * Get end date.
 212          *
 213          * @return End date.
 214          */
 215         public Date getEnd() {
 216             return end;
 217         }
 218
 219         /**
 220          * Gets the event's view mode. Calendar can be be either in monthly or
 221          * weekly mode, depending on the active date range.
 222          *
 223          * @deprecated User {@link Calendar#isMonthlyMode()} instead
 224          *
 225          * @return Returns true when monthly view is active.
 226          */
 227         @Deprecated
 228         public boolean isMonthlyMode() {
 229             return monthlyMode;
 230         }
 231     }
 232
 233     /** RangeSelectHandler handles RangeSelectEvent. */
 234     @Deprecated
 235     public interface RangeSelectHandler extends SerializableEventListener {
 236
 237         /** Trigger method for the RangeSelectEvent. */
 238         public static final Method rangeSelectMethod = ReflectTools.findMethod(
 239                 RangeSelectHandler.class, "rangeSelect",
 240                 RangeSelectEvent.class);
 241
 242         /**
 243          * This method will be called when day or time cells are drag-marked
 244          * with mouse.
 245          *
 246          * @param event
 247          *            RangeSelectEvent that contains range start and end date.
 248          */
 249         public void rangeSelect(RangeSelectEvent event);
 250     }
 251
 252     /** Notifier interface for navigation listening. */
 253     @Deprecated
 254     public interface NavigationNotifier extends Serializable {
 255         /**
 256          * Add a forward navigation listener.
 257          *
 258          * @param handler
 259          *            ForwardHandler to be added.
 260          */
 261         public void setHandler(ForwardHandler handler);
 262
 263         /**
 264          * Add a backward navigation listener.
 265          *
 266          * @param handler
 267          *            BackwardHandler to be added.
 268          */
 269         public void setHandler(BackwardHandler handler);
 270
 271         /**
 272          * Add a date click listener.
 273          *
 274          * @param handler
 275          *            DateClickHandler to be added.
 276          */
 277         public void setHandler(DateClickHandler handler);
 278
 279         /**
 280          * Add a event click listener.
 281          *
 282          * @param handler
 283          *            EventClickHandler to be added.
 284          */
 285         public void setHandler(EventClickHandler handler);
 286
 287         /**
 288          * Add a week click listener.
 289          *
 290          * @param handler
 291          *            WeekClickHandler to be added.
 292          */
 293         public void setHandler(WeekClickHandler handler);
 294     }
 295
 296     /**
 297      * ForwardEvent is sent when forward navigation button is clicked.
 298      */
 299     @SuppressWarnings("serial")
 300     @Deprecated
 301     public class ForwardEvent extends CalendarComponentEvent {
 302
 303         public static final String EVENT_ID = CalendarEventId.FORWARD;
 304
 305         /**
 306          * ForwardEvent needs only the source component.
 307          *
 308          * @param source
 309          *            Calendar component.
 310          */
 311         public ForwardEvent(Calendar source) {
 312             super(source);
 313         }
 314     }
 315
 316     /** ForwardHandler handles ForwardEvent. */
 317     @Deprecated
 318     public interface ForwardHandler extends SerializableEventListener {
 319
 320         /** Trigger method for the ForwardEvent. */
 321         public static final Method forwardMethod = ReflectTools.findMethod(
 322                 ForwardHandler.class, "forward", ForwardEvent.class);
 323
 324         /**
 325          * This method will be called when date range is moved forward.
 326          *
 327          * @param event
 328          *            ForwardEvent
 329          */
 330         public void forward(ForwardEvent event);
 331     }
 332
 333     /**
 334      * BackwardEvent is sent when backward navigation button is clicked.
 335      */
 336     @SuppressWarnings("serial")
 337     @Deprecated
 338     public class BackwardEvent extends CalendarComponentEvent {
 339
 340         public static final String EVENT_ID = CalendarEventId.BACKWARD;
 341
 342         /**
 343          * BackwardEvent needs only the source source component.
 344          *
 345          * @param source
 346          *            Calendar component.
 347          */
 348         public BackwardEvent(Calendar source) {
 349             super(source);
 350         }
 351     }
 352
 353     /** BackwardHandler handles BackwardEvent. */
 354     @Deprecated
 355     public interface BackwardHandler extends SerializableEventListener {
 356
 357         /** Trigger method for the BackwardEvent. */
 358         public static final Method backwardMethod = ReflectTools.findMethod(
 359                 BackwardHandler.class, "backward", BackwardEvent.class);
 360
 361         /**
 362          * This method will be called when date range is moved backwards.
 363          *
 364          * @param event
 365          *            BackwardEvent
 366          */
 367         public void backward(BackwardEvent event);
 368     }
 369
 370     /**
 371      * DateClickEvent is sent when a date is clicked.
 372      */
 373     @SuppressWarnings("serial")
 374     @Deprecated
 375     public class DateClickEvent extends CalendarComponentEvent {
 376
 377         public static final String EVENT_ID = CalendarEventId.DATECLICK;
 378
 379         /** Date that was clicked. */
 380         private Date date;
 381
 382         /** DateClickEvent needs the target date that was clicked. */
 383         public DateClickEvent(Calendar source, Date date) {
 384             super(source);
 385             this.date = date;
 386         }
 387
 388         /**
 389          * Get clicked date.
 390          *
 391          * @return Clicked date.
 392          */
 393         public Date getDate() {
 394             return date;
 395         }
 396     }
 397
 398     /** DateClickHandler handles DateClickEvent. */
 399     @Deprecated
 400     public interface DateClickHandler extends SerializableEventListener {
 401
 402         /** Trigger method for the DateClickEvent. */
 403         public static final Method dateClickMethod = ReflectTools.findMethod(
 404                 DateClickHandler.class, "dateClick", DateClickEvent.class);
 405
 406         /**
 407          * This method will be called when a date is clicked.
 408          *
 409          * @param event
 410          *            DateClickEvent containing the target date.
 411          */
 412         public void dateClick(DateClickEvent event);
 413     }
 414
 415     /**
 416      * EventClick is sent when an event is clicked.
 417      */
 418     @SuppressWarnings("serial")
 419     @Deprecated
 420     public class EventClick extends CalendarComponentEvent {
 421
 422         public static final String EVENT_ID = CalendarEventId.EVENTCLICK;
 423
 424         /** Clicked source event. */
 425         private CalendarEvent calendarEvent;
 426
 427         /** Target source event is needed for the EventClick. */
 428         public EventClick(Calendar source, CalendarEvent calendarEvent) {
 429             super(source);
 430             this.calendarEvent = calendarEvent;
 431         }
 432
 433         /**
 434          * Get the clicked event.
 435          *
 436          * @return Clicked event.
 437          */
 438         public CalendarEvent getCalendarEvent() {
 439             return calendarEvent;
 440         }
 441     }
 442
 443     /** EventClickHandler handles EventClick. */
 444     @Deprecated
 445     public interface EventClickHandler extends SerializableEventListener {
 446
 447         /** Trigger method for the EventClick. */
 448         public static final Method eventClickMethod = ReflectTools.findMethod(
 449                 EventClickHandler.class, "eventClick", EventClick.class);
 450
 451         /**
 452          * This method will be called when an event is clicked.
 453          *
 454          * @param event
 455          *            EventClick containing the target event.
 456          */
 457         public void eventClick(EventClick event);
 458     }
 459
 460     /**
 461      * WeekClick is sent when week is clicked.
 462      */
 463     @SuppressWarnings("serial")
 464     @Deprecated
 465     public class WeekClick extends CalendarComponentEvent {
 466
 467         public static final String EVENT_ID = CalendarEventId.WEEKCLICK;
 468
 469         /** Target week. */
 470         private int week;
 471
 472         /** Target year. */
 473         private int year;
 474
 475         /**
 476          * WeekClick needs a target year and week.
 477          *
 478          * @param source
 479          *            Target source.
 480          * @param week
 481          *            Target week.
 482          * @param year
 483          *            Target year.
 484          */
 485         public WeekClick(Calendar source, int week, int year) {
 486             super(source);
 487             this.week = week;
 488             this.year = year;
 489         }
 490
 491         /**
 492          * Get week as a integer. See {@link java.util.Calendar} for the allowed
 493          * values.
 494          *
 495          * @return Week as a integer.
 496          */
 497         public int getWeek() {
 498             return week;
 499         }
 500
 501         /**
 502          * Get year as a integer. See {@link java.util.Calendar} for the allowed
 503          * values.
 504          *
 505          * @return Year as a integer
 506          */
 507         public int getYear() {
 508             return year;
 509         }
 510     }
 511
 512     /** WeekClickHandler handles WeekClicks. */
 513     @Deprecated
 514     public interface WeekClickHandler extends SerializableEventListener {
 515
 516         /** Trigger method for the WeekClick. */
 517         public static final Method weekClickMethod = ReflectTools.findMethod(
 518                 WeekClickHandler.class, "weekClick", WeekClick.class);
 519
 520         /**
 521          * This method will be called when a week is clicked.
 522          *
 523          * @param event
 524          *            WeekClick containing the target week and year.
 525          */
 526         public void weekClick(WeekClick event);
 527     }
 528
 529     /**
 530      * EventResize is sent when an event is resized.
 531      */
 532     @SuppressWarnings("serial")
 533     @Deprecated
 534     public class EventResize extends CalendarComponentEvent {
 535
 536         public static final String EVENT_ID = CalendarEventId.EVENTRESIZE;
 537
 538         private CalendarEvent calendarEvent;
 539
 540         private Date startTime;
 541
 542         private Date endTime;
 543
 544         public EventResize(Calendar source, CalendarEvent calendarEvent,
 545                 Date startTime, Date endTime) {
 546             super(source);
 547             this.calendarEvent = calendarEvent;
 548             this.startTime = startTime;
 549             this.endTime = endTime;
 550         }
 551
 552         /**
 553          * Get target event.
 554          *
 555          * @return Target event.
 556          */
 557         public CalendarEvent getCalendarEvent() {
 558             return calendarEvent;
 559         }
 560
 561         /**
 562          * @deprecated Use {@link #getNewStart()} instead
 563          *
 564          * @return the new start time
 565          */
 566         @Deprecated
 567         public Date getNewStartTime() {
 568             return startTime;
 569         }
 570
 571         /**
 572          * Returns the updated start date/time of the event.
 573          *
 574          * @return The new date for the event
 575          */
 576         public Date getNewStart() {
 577             return startTime;
 578         }
 579
 580         /**
 581          * @deprecated Use {@link #getNewEnd()} instead
 582          *
 583          * @return the new end time
 584          */
 585         @Deprecated
 586         public Date getNewEndTime() {
 587             return endTime;
 588         }
 589
 590         /**
 591          * Returns the updates end date/time of the event.
 592          *
 593          * @return The new date for the event
 594          */
 595         public Date getNewEnd() {
 596             return endTime;
 597         }
 598     }
 599
 600     /**
 601      * Notifier interface for event resizing.
 602      */
 603     @Deprecated
 604     public interface EventResizeNotifier extends Serializable {
 605
 606         /**
 607          * Set a EventResizeHandler.
 608          *
 609          * @param handler
 610          *            EventResizeHandler to be set
 611          */
 612         public void setHandler(EventResizeHandler handler);
 613     }
 614
 615     /**
 616      * Handler for EventResize event.
 617      */
 618     @Deprecated
 619     public interface EventResizeHandler extends SerializableEventListener {
 620
 621         /** Trigger method for the EventResize. */
 622         public static final Method eventResizeMethod = ReflectTools.findMethod(
 623                 EventResizeHandler.class, "eventResize", EventResize.class);
 624
 625         void eventResize(EventResize event);
 626     }
 627
 628 }