modules/javafx.controls/src/main/java/javafx/scene/control/ListView.java

@@ -238,10 +238,12 @@
 
     /**
      * An EventType that indicates some edit event has occurred. It is the parent
      * type of all other edit events: {@link #EDIT_START_EVENT},
      *  {@link #EDIT_COMMIT_EVENT} and {@link #EDIT_CANCEL_EVENT}.
+     * @param <T> the type of the objects stored in this ListView
+     * @return the event type
      */
     @SuppressWarnings("unchecked")
     public static <T> EventType<ListView.EditEvent<T>> editAnyEvent() {
         return (EventType<ListView.EditEvent<T>>) EDIT_ANY_EVENT;
     }

@@ -249,10 +251,12 @@
             new EventType<>(Event.ANY, "LIST_VIEW_EDIT");
 
     /**
      * An EventType used to indicate that an edit event has started within the
      * ListView upon which the event was fired.
+     * @param <T> the type of the objects stored in this ListView
+     * @return the event type
      */
     @SuppressWarnings("unchecked")
     public static <T> EventType<ListView.EditEvent<T>> editStartEvent() {
         return (EventType<ListView.EditEvent<T>>) EDIT_START_EVENT;
     }

@@ -260,10 +264,12 @@
             new EventType<>(editAnyEvent(), "EDIT_START");
 
     /**
      * An EventType used to indicate that an edit event has just been canceled
      * within the ListView upon which the event was fired.
+     * @param <T> the type of the objects stored in this ListView
+     * @return the event type
      */
     @SuppressWarnings("unchecked")
     public static <T> EventType<ListView.EditEvent<T>> editCancelEvent() {
         return (EventType<ListView.EditEvent<T>>) EDIT_CANCEL_EVENT;
     }

@@ -271,10 +277,12 @@
             new EventType<>(editAnyEvent(), "EDIT_CANCEL");
 
     /**
      * An EventType used to indicate that an edit event has been committed
      * within the ListView upon which the event was fired.
+     * @param <T> the type of the objects stored in this ListView
+     * @return the event type
      */
     @SuppressWarnings("unchecked")
     public static <T> EventType<ListView.EditEvent<T>> editCommitEvent() {
         return (EventType<ListView.EditEvent<T>>) EDIT_COMMIT_EVENT;
     }

@@ -324,10 +332,11 @@
      * <p>Attempts to add a listener to the {@link ObservableList}, such that all
      * subsequent changes inside the list will be shown to the user.
      *
      * <p>Refer to the {@link ListView} class documentation for details on the
      * default state of other properties.
+     * @param items the list of items
      */
     public ListView(ObservableList<T> items) {
         getStyleClass().setAll(DEFAULT_STYLE_CLASS);
         setAccessibleRole(AccessibleRole.LIST_VIEW);
 

@@ -383,10 +392,11 @@
     private ObjectProperty<ObservableList<T>> items;
 
     /**
      * Sets the underlying data model for the ListView. Note that it has a generic
      * type that must match the type of the ListView itself.
+     * @param value the list of items for this ListView
      */
     public final void setItems(ObservableList<T> value) {
         itemsProperty().set(value);
     }
 

@@ -404,10 +414,11 @@
     }
 
     /**
      * The underlying data model for the ListView. Note that it has a generic
      * type that must match the type of the ListView itself.
+     * @return the items property for this ListView
      */
     public final ObjectProperty<ObservableList<T>> itemsProperty() {
         if (items == null) {
             items = new SimpleObjectProperty<>(this, "items");
         }

@@ -420,10 +431,11 @@
     /**
      * This Node is shown to the user when the listview has no content to show.
      * This may be the case because the table model has no data in the first
      * place or that a filter has been applied to the list model, resulting
      * in there being nothing to show the user..
+     * @return the placeholder property for this ListView
      * @since JavaFX 8.0
      */
     public final ObjectProperty<Node> placeholderProperty() {
         if (placeholder == null) {
             placeholder = new SimpleObjectProperty<Node>(this, "placeholder");

@@ -445,27 +457,30 @@
      * Sets the {@link MultipleSelectionModel} to be used in the ListView.
      * Despite a ListView requiring a <b>Multiple</b>SelectionModel, it is possible
      * to configure it to only allow single selection (see
      * {@link MultipleSelectionModel#setSelectionMode(javafx.scene.control.SelectionMode)}
      * for more information).
+     * @param value the MultipleSelectionModel to be used in this ListView
      */
     public final void setSelectionModel(MultipleSelectionModel<T> value) {
         selectionModelProperty().set(value);
     }
 
     /**
      * Returns the currently installed selection model.
+     * @return the currently installed selection model
      */
     public final MultipleSelectionModel<T> getSelectionModel() {
         return selectionModel == null ? null : selectionModel.get();
     }
 
     /**
      * The SelectionModel provides the API through which it is possible
      * to select single or multiple items within a ListView, as  well as inspect
      * which items have been selected by the user. Note that it has a generic
      * type that must match the type of the ListView itself.
+     * @return the selectionModel property
      */
     public final ObjectProperty<MultipleSelectionModel<T>> selectionModelProperty() {
         return selectionModel;
     }
 

@@ -473,26 +488,29 @@
     // --- Focus Model
     private ObjectProperty<FocusModel<T>> focusModel;
 
     /**
      * Sets the {@link FocusModel} to be used in the ListView.
+     * @param value the FocusModel to be used in the ListView
      */
     public final void setFocusModel(FocusModel<T> value) {
         focusModelProperty().set(value);
     }
 
     /**
      * Returns the currently installed {@link FocusModel}.
+     * @return the currently installed FocusModel
      */
     public final FocusModel<T> getFocusModel() {
         return focusModel == null ? null : focusModel.get();
     }
 
     /**
      * The FocusModel provides the API through which it is possible
      * to both get and set the focus on a single item within a ListView. Note
      * that it has a generic type that must match the type of the ListView itself.
+     * @return the FocusModel property
      */
     public final ObjectProperty<FocusModel<T>> focusModelProperty() {
         if (focusModel == null) {
             focusModel = new SimpleObjectProperty<FocusModel<T>>(this, "focusModel");
         }

@@ -504,26 +522,29 @@
     private ObjectProperty<Orientation> orientation;
 
     /**
      * Sets the orientation of the ListView, which dictates whether
      * it scrolls vertically or horizontally.
+     * @param value the orientation of the ListView
      */
     public final void setOrientation(Orientation value) {
         orientationProperty().set(value);
     };
 
     /**
      * Returns the current orientation of the ListView, which dictates whether
      * it scrolls vertically or horizontally.
+     * @return the current orientation of the ListView
      */
     public final Orientation getOrientation() {
         return orientation == null ? Orientation.VERTICAL : orientation.get();
     }
 
     /**
      * The orientation of the {@code ListView} - this can either be horizontal
      * or vertical.
+     * @return the orientation property of this ListView
      */
     public final ObjectProperty<Orientation> orientationProperty() {
         if (orientation == null) {
             orientation = new StyleableObjectProperty<Orientation>(Orientation.VERTICAL) {
                 @Override public void invalidated() {

@@ -559,17 +580,19 @@
 
     /**
      * Sets a new cell factory to use in the ListView. This forces all old
      * {@link ListCell}'s to be thrown away, and new ListCell's created with
      * the new cell factory.
+     * @param value ell factory to use in this ListView
      */
     public final void setCellFactory(Callback<ListView<T>, ListCell<T>> value) {
         cellFactoryProperty().set(value);
     }
 
     /**
      * Returns the current cell factory.
+     * @return the current cell factory
      */
     public final Callback<ListView<T>, ListCell<T>> getCellFactory() {
         return cellFactory == null ? null : cellFactory.get();
     }
 

@@ -579,10 +602,11 @@
      * ListView is responsible for reusing ListCells - all that is necessary
      * is for the custom cell factory to return from this function a ListCell
      * which might be usable for representing any item in the ListView.
      *
      * <p>Refer to the {@link Cell} class documentation for more detail.
+     * @return the cell factory property
      */
     public final ObjectProperty<Callback<ListView<T>, ListCell<T>>> cellFactoryProperty() {
         if (cellFactory == null) {
             cellFactory = new SimpleObjectProperty<Callback<ListView<T>, ListCell<T>>>(this, "cellFactory");
         }

@@ -636,10 +660,11 @@
      * only size (thus allowing for variable cell sizes, and preventing the
      * performance gains from being possible). Therefore, when performance matters
      * use -fx-fixed-cell-size, instead of -fx-cell-size. If both properties are
      * specified in CSS, -fx-fixed-cell-size takes precedence.</p>
      *
+     * @return the fixed cell size property
      * @since JavaFX 8.0
      */
     public final DoubleProperty fixedCellSizeProperty() {
         if (fixedCellSize == null) {
             fixedCellSize = new StyleableDoubleProperty(Region.USE_COMPUTED_SIZE) {

@@ -670,10 +695,11 @@
     }
     /**
      * Specifies whether this ListView is editable - only if the ListView and
      * the ListCells within it are both editable will a ListCell be able to go
      * into their editing state.
+     * @return the editable property
      */
     public final BooleanProperty editableProperty() {
         if (editable == null) {
             editable = new SimpleBooleanProperty(this, "editable", false);
         }

@@ -689,10 +715,11 @@
     }
 
     /**
      * Returns the index of the item currently being edited in the ListView,
      * or -1 if no item is being edited.
+     * @return the index of the item currently being edited
      */
     public final int getEditingIndex() {
         return editingIndex == null ? -1 : editingIndex.get();
     }
 

@@ -700,10 +727,11 @@
      * <p>A property used to represent the index of the item currently being edited
      * in the ListView, if editing is taking place, or -1 if no item is being edited.
      *
      * <p>It is not possible to set the editing index, instead it is required that
      * you call {@link #edit(int)}.
+     * @return the editing index property
      */
     public final ReadOnlyIntegerProperty editingIndexProperty() {
         return editingIndexPropertyImpl().getReadOnlyProperty();
     }
 

@@ -723,26 +751,30 @@
      * an edit.
      *
      * <p>This is a convenience method - the same result can be
      * achieved by calling
      * <code>addEventHandler(ListView.EDIT_START_EVENT, eventHandler)</code>.
+     * @param value the EventHandler that will be called when the user begins
+     * an edit
      */
     public final void setOnEditStart(EventHandler<ListView.EditEvent<T>> value) {
         onEditStartProperty().set(value);
     }
 
     /**
      * Returns the {@link EventHandler} that will be called when the user begins
      * an edit.
+     * @return the EventHandler that will be called when the user begins an edit
      */
     public final EventHandler<ListView.EditEvent<T>> getOnEditStart() {
         return onEditStart == null ? null : onEditStart.get();
     }
 
     /**
      * This event handler will be fired when the user successfully initiates
      * editing.
+     * @return the onEditStart event handler property
      */
     public final ObjectProperty<EventHandler<ListView.EditEvent<T>>> onEditStartProperty() {
         if (onEditStart == null) {
             onEditStart = new ObjectPropertyBase<EventHandler<ListView.EditEvent<T>>>() {
                 @Override protected void invalidated() {

@@ -773,18 +805,21 @@
      * {@link ListCell#commitEdit(java.lang.Object)} method.
      *
      * <p>This is a convenience method - the same result can be
      * achieved by calling
      * <code>addEventHandler(ListView.EDIT_START_EVENT, eventHandler)</code>.
+     * @param value the EventHandler that will be called when the user has
+     * completed their editing
      */
     public final void setOnEditCommit(EventHandler<ListView.EditEvent<T>> value) {
         onEditCommitProperty().set(value);
     }
 
     /**
      * Returns the {@link EventHandler} that will be called when the user commits
      * an edit.
+     * @return the EventHandler that will be called when the user commits an edit
      */
     public final EventHandler<ListView.EditEvent<T>> getOnEditCommit() {
         return onEditCommit == null ? null : onEditCommit.get();
     }
 

@@ -794,10 +829,11 @@
      *
      * <p>The EventHandler in this property should not be called directly -
      * instead call {@link ListCell#commitEdit(java.lang.Object)} from within
      * your custom ListCell. This will handle firing this event, updating the
      * view, and switching out of the editing state.</p>
+     * @return the onEditCommit event handler property
      */
     public final ObjectProperty<EventHandler<ListView.EditEvent<T>>> onEditCommitProperty() {
         if (onEditCommit == null) {
             onEditCommit = new ObjectPropertyBase<EventHandler<ListView.EditEvent<T>>>() {
                 @Override protected void invalidated() {

@@ -823,25 +859,29 @@
     private ObjectProperty<EventHandler<ListView.EditEvent<T>>> onEditCancel;
 
     /**
      * Sets the {@link EventHandler} that will be called when the user cancels
      * an edit.
+     * @param value the EventHandler that will be called when the user cancels
+     * an edit
      */
     public final void setOnEditCancel(EventHandler<ListView.EditEvent<T>> value) {
         onEditCancelProperty().set(value);
     }
 
     /**
      * Returns the {@link EventHandler} that will be called when the user cancels
      * an edit.
+     * @return the EventHandler that will be called when the user cancels an edit
      */
     public final EventHandler<ListView.EditEvent<T>> getOnEditCancel() {
         return onEditCancel == null ? null : onEditCancel.get();
     }
 
     /**
      * This event handler will be fired when the user cancels editing a cell.
+     * @return the onEditCancel event handler property
      */
     public final ObjectProperty<EventHandler<ListView.EditEvent<T>>> onEditCancelProperty() {
         if (onEditCancel == null) {
             onEditCancel = new ObjectPropertyBase<EventHandler<ListView.EditEvent<T>>>() {
                 @Override protected void invalidated() {

@@ -1119,10 +1159,14 @@
 
         /**
          * Creates a new EditEvent instance to represent an edit event. This
          * event is used for {@link #EDIT_START_EVENT},
          * {@link #EDIT_COMMIT_EVENT} and {@link #EDIT_CANCEL_EVENT} types.
+         * @param source the source
+         * @param eventType the event type
+         * @param newValue the new value
+         * @param editIndex the edit index
          */
         public EditEvent(ListView<T> source,
                          EventType<? extends ListView.EditEvent<T>> eventType,
                          T newValue,
                          int editIndex) {

@@ -1139,17 +1183,19 @@
             return source;
         }
 
         /**
          * Returns the index in which the edit took place.
+         * @return the index in which the edit took place
          */
         public int getIndex() {
             return editIndex;
         }
 
         /**
          * Returns the value of the new input provided by the end user.
+         * @return the value of the new input provided by the end user
          */
         public T getNewValue() {
             return newValue;
         }