• Home
• com.calendarfx
• view
• 8.5.0
• source code
• DateControl.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.calendarfx.view.DateControl Maven / Gradle / Ivy

/*
 *  Copyright (C) 2017 Dirk Lemmermann Software & Consulting (dlsc.com)
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *          http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package com.calendarfx.view;

import com.calendarfx.model.Calendar;
import com.calendarfx.model.CalendarSource;
import com.calendarfx.model.Entry;
import com.calendarfx.model.Interval;
import com.calendarfx.util.LoggingDomain;
import com.calendarfx.view.page.DayPage;
import com.calendarfx.view.popover.DatePopOver;
import com.calendarfx.view.popover.EntryPopOverContentPane;
import impl.com.calendarfx.view.ViewHelper;
import javafx.application.Platform;
import javafx.beans.InvalidationListener;
import javafx.beans.Observable;
import javafx.beans.WeakInvalidationListener;
import javafx.beans.binding.Bindings;
import javafx.beans.property.BooleanProperty;
import javafx.beans.property.ObjectProperty;
import javafx.beans.property.ReadOnlyListProperty;
import javafx.beans.property.ReadOnlyListWrapper;
import javafx.beans.property.SimpleBooleanProperty;
import javafx.beans.property.SimpleObjectProperty;
import javafx.beans.value.ObservableValue;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.collections.ObservableMap;
import javafx.collections.ObservableSet;
import javafx.geometry.Point2D;
import javafx.scene.Node;
import javafx.scene.Parent;
import javafx.scene.control.Alert;
import javafx.scene.control.Alert.AlertType;
import javafx.scene.control.ContextMenu;
import javafx.scene.control.Label;
import javafx.scene.control.Menu;
import javafx.scene.control.MenuItem;
import javafx.scene.control.RadioMenuItem;
import javafx.scene.control.SelectionMode;
import javafx.scene.effect.Light.Point;
import javafx.scene.input.ContextMenuEvent;
import javafx.scene.input.InputEvent;
import javafx.scene.input.MouseEvent;
import javafx.scene.layout.StackPane;
import javafx.scene.shape.Rectangle;
import javafx.util.Callback;
import org.controlsfx.control.PopOver;
import org.controlsfx.control.PopOver.ArrowLocation;
import org.controlsfx.control.PropertySheet.Item;

import java.text.MessageFormat;
import java.time.DayOfWeek;
import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.temporal.ChronoUnit;
import java.time.temporal.WeekFields;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.Objects;
import java.util.Optional;

import static java.time.DayOfWeek.SATURDAY;
import static java.time.DayOfWeek.SUNDAY;
import static java.util.Objects.requireNonNull;
import static javafx.scene.control.SelectionMode.MULTIPLE;
import static javafx.scene.input.ContextMenuEvent.CONTEXT_MENU_REQUESTED;
import static javafx.scene.input.MouseButton.PRIMARY;

/**
 * The superclass for all controls that are showing calendar information. This
 * class is responsible for:
 * 

 * 

 * 
Binding to other date controls
 * 
Providing the current date, "today", first day of week
 * 
Creating sources, calendars, entries
 * 
Context menu
 * 
Showing details for a given date or entry
 * 
Providing a virtual grid for editing
 * 
Selection handling
 * 
Printing
 * 
 * 
Binding
 Date controls are bound to each other to create complex date
 * controls like the {@link CalendarView}. When date controls are bound to each
 * other via the {@link #bind(DateControl, boolean)} method then most of their
 * properties will be bound to each other. This not only includes date and time
 * zone properties but also all the factory and detail callbacks. This allows an
 * application to create a complex calendar control and to configure only that
 * control without worrying about the date controls that are nested inside of
 * it. The children will all "inherit" their settings from the parent control.
 * 

 * 
Current Date, Today, First Day of Week
 The {@link #dateProperty()}
 * is used to store the date that the control has to display. For the
 * {@link DayView} this would mean that it has to show exactly that date. The
 * {@link DetailedWeekView} would only have to guarantee that it shows the week that
 * contains this date. For this the {@link DetailedWeekView} uses the
 * {@link #getFirstDayOfWeek()} method that looks up its value from the week
 * fields stored in the {@link #weekFieldsProperty()}. The
 * {@link #todayProperty()} is mainly used for highlighting today's date in the
 * view (e.g. a red background).
 * 

 * 
Creating Sources, Calendars, Entries
 The date control uses various
 * factories to create new sources, calendars, and entries. Each factory has to
 * implement the {@link Callback} interface. The factories will be invoked when
 * the application calls {@link #createCalendarSource()} or
 * {@link #createEntryAt(ZonedDateTime)}.
 * 

 * 
Context Menu
 Date controls can either set a context menu explicitly
 * via {@link #setContextMenu(ContextMenu)} or by providing a callback that gets
 * invoked every time the context menu event is received (see
 * {@link #setContextMenuCallback(Callback)}). If a context menu has been set
 * explicitly then the callback will never be called again.
 * 

 * 
Details for Entries and Dates
 When clicking on an entry or a date
 * the user wants to see details regarding the entry or the date. Callbacks for
 * this can be registered via {@link #setEntryDetailsCallback(Callback)} and
 * {@link #setDateDetailsCallback(Callback)}. The callbacks can decide which
 * kind of user interface they want to show to the user. The default
 * implementation for both callbacks is a {@link PopOver} control from the
 * ControlsFX project.
 * 

 * 
Selection Handling
 Date controls use a very simple selection
 * concept. All selected entries are stored inside an observable list (see
 * {@link #getSelections()}). The controls support single and multiple
 * selections (see {@link #setSelectionMode(SelectionMode)}). Due to the binding
 * approach it does not matter in which child date control an entry gets
 * selected. All controls will always know which entries are selected.
 * 

 * 
Virtual Grid
 A virtual grid is used for editing. It allows the start
 * and end times of entries to snap to "virtual" grid lines. The grid can be
 * used to make the times always snap to 5, 10, 15, 30 minutes for example. This
 * makes it easier to align entries to each other and covers the most common use
 * cases. More precise times can always be set in the details.
 */
public abstract class DateControl extends CalendarFXControl {

    private int entryCounter = 1;

    private Boolean usesOwnContextMenu;

    private final InvalidationListener updateCalendarListListener = (Observable it) -> updateCalendarList();

    private final WeakInvalidationListener weakUpdateCalendarListListener = new WeakInvalidationListener(updateCalendarListListener);

    /**
     * Constructs a new date control and initializes all factories and callbacks
     * with default implementations.
     */
    protected DateControl() {
        setFocusTraversable(false);

        setUsagePolicy(count -> {
            if (count < 0) {
                throw new IllegalArgumentException("usage count can not be smaller than zero, but was " + count);
            }

            switch (count) {
                case 0:
                    return Usage.NONE;
                case 1:
                    return Usage.VERY_LOW;
                case 2:
                    return Usage.LOW;
                case 3:
                    return Usage.MEDIUM;
                case 4:
                    return Usage.HIGH;
                case 5:
                default:
                    return Usage.VERY_HIGH;
            }
        });

        getWeekendDays().add(SATURDAY);
        getWeekendDays().add(SUNDAY);

        /*
         * Every date control is initially populated with a default source and
         * calendar.
         */
        CalendarSource defaultCalendarSource = new CalendarSource(Messages.getString("DateControl.DEFAULT_CALENDAR_SOURCE_NAME")); //$NON-NLS-1$
        Calendar defaultCalendar = new Calendar(Messages.getString("DateControl.DEFAULT_CALENDAR_NAME")); //$NON-NLS-1$
        defaultCalendarSource.getCalendars().add(defaultCalendar);
        getCalendarSources().add(defaultCalendarSource);

        InvalidationListener hidePopOverListener = it -> maybeHidePopOvers();
        sceneProperty().addListener(hidePopOverListener);
        visibleProperty().addListener(hidePopOverListener);

        getCalendarSources().addListener(weakUpdateCalendarListListener);

        /*
         * The popover content callback creates a content node that will make
         * out the content of the popover used to display entry details.
         */
        setEntryDetailsPopOverContentCallback(param -> new EntryPopOverContentPane(param.getPopOver(), param.getDateControl(), param.getEntry()));

        /*
         * The default calendar provider returns the first calendar from the
         * first source.
         */
        setDefaultCalendarProvider(control -> {
            List sources = getCalendarSources();
            if (sources != null && !sources.isEmpty()) {
                CalendarSource s = sources.get(0);
                List calendars = s.getCalendars();
                if (calendars != null && !calendars.isEmpty()) {
                    for (Calendar c : calendars) {
                        if (!c.isReadOnly() && isCalendarVisible(c)) {
                            return c;
                        }
                    }

                    Alert alert = new Alert(AlertType.WARNING);
                    alert.setTitle(Messages.getString("DateControl.TITLE_CALENDAR_PROBLEM")); //$NON-NLS-1$
                    alert.setHeaderText(Messages.getString("DateControl.HEADER_TEXT_UNABLE_TO_CREATE_NEW_ENTRY")); //$NON-NLS-1$
                    String newLine = System.getProperty("line.separator"); //$NON-NLS-1$
                    alert.setContentText(MessageFormat.format(Messages.getString("DateControl.CONTENT_TEXT_UNABLE_TO_CREATE_NEW_ENTRY"), //$NON-NLS-1$
                            newLine));
                    alert.show();
                } else {
                    Alert alert = new Alert(AlertType.WARNING);
                    alert.setTitle(Messages.getString("DateControl.TITLE_CALENDAR_PROBLEM")); //$NON-NLS-1$
                    alert.setHeaderText(Messages.getString("DateControl.HEADER_TEXT_NO_CALENDARS_DEFINED")); //$NON-NLS-1$
                    alert.setContentText(Messages.getString("DateControl.CONTENT_TEXT_NO_CALENDARS_DEFINED")); //$NON-NLS-1$
                    alert.show();
                }
            }

            return null;
        });

        setEntryFactory(param -> {
            DateControl control = param.getDateControl();

            VirtualGrid grid = control.getVirtualGrid();
            ZonedDateTime time = param.getZonedDateTime();
            DayOfWeek firstDayOfWeek = getFirstDayOfWeek();
            ZonedDateTime lowerTime = grid.adjustTime(time, false, firstDayOfWeek);
            ZonedDateTime upperTime = grid.adjustTime(time, true, firstDayOfWeek);

            if (Duration.between(time, lowerTime).abs().minus(Duration.between(time, upperTime).abs()).isNegative()) {
                time = lowerTime;
            } else {
                time = upperTime;
            }

            Entry