1 /*
   2  * Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package com.sun.javafx.scene.control.skin;
  27 
  28 import java.util.*;
  29 
  30 import javafx.beans.InvalidationListener;
  31 import javafx.beans.WeakInvalidationListener;
  32 import javafx.beans.property.BooleanProperty;
  33 import javafx.beans.property.SimpleBooleanProperty;
  34 import javafx.beans.property.StringProperty;
  35 import javafx.collections.ListChangeListener;
  36 import javafx.collections.WeakListChangeListener;
  37 import javafx.geometry.HPos;
  38 import javafx.geometry.Insets;
  39 import javafx.geometry.Side;
  40 import javafx.geometry.VPos;
  41 import javafx.scene.control.CheckMenuItem;
  42 import javafx.scene.control.ContextMenu;
  43 import javafx.scene.control.Control;
  44 import javafx.scene.control.Label;
  45 import javafx.scene.control.TableColumn;
  46 import javafx.scene.control.TableColumnBase;
  47 import javafx.scene.layout.Pane;
  48 import javafx.scene.layout.Region;
  49 import javafx.scene.layout.StackPane;
  50 import javafx.scene.shape.Rectangle;
  51 
  52 import com.sun.javafx.scene.control.skin.resources.ControlResources;
  53 
  54 /**
  55  * Region responsible for painting the entire row of column headers.
  56  */
  57 public class TableHeaderRow extends StackPane {
  58 
  59     /***************************************************************************
  60      *                                                                         *
  61      * Static Fields                                                           *
  62      *                                                                         *
  63      **************************************************************************/
  64 
  65     private static final String MENU_SEPARATOR = 
  66             ControlResources.getString("TableView.nestedColumnControlMenuSeparator");
  67 
  68 
  69 
  70     /***************************************************************************
  71      *                                                                         *
  72      * Private Fields                                                          *
  73      *                                                                         *
  74      **************************************************************************/
  75 
  76     private final VirtualFlow flow;
  77 
  78     private final TableViewSkinBase tableSkin;
  79 
  80     private Map<TableColumnBase, CheckMenuItem> columnMenuItems = new HashMap<TableColumnBase, CheckMenuItem>();
  81 
  82     // Vertical line that is shown when columns are being reordered
  83 //    private Region columnReorderLine;
  84 
  85     private double scrollX;
  86 
  87     private double tableWidth;
  88 
  89     private Rectangle clip;
  90 
  91     private TableColumnHeader reorderingRegion;
  92 
  93     /**
  94      * This is the ghosted region representing the table column that is being
  95      * dragged. It moves along the x-axis but is fixed in the y-axis.
  96      */
  97     private StackPane dragHeader;
  98     private final Label dragHeaderLabel = new Label();
  99 
 100     /*
 101      * The header row is actually just one NestedTableColumnHeader that spans
 102      * the entire width. Nested within this is the TableColumnHeader's and
 103      * NestedTableColumnHeader's, as necessary. This makes it nice and clean
 104      * to handle column reordering - we basically enforce the rule that column
 105      * reordering only occurs within a single NestedTableColumnHeader, and only
 106      * at that level.
 107      */
 108     private final NestedTableColumnHeader header;
 109 
 110     private Region filler;
 111 
 112     /**
 113      * This is the region where the user can interact with to show/hide columns.
 114      * It is positioned in the top-right hand corner of the TableHeaderRow, and
 115      * when clicked shows a PopupMenu consisting of all leaf columns.
 116      */
 117     private Pane cornerRegion;
 118 
 119     /**
 120      * PopupMenu shown to users to allow for them to hide/show columns in the
 121      * table.
 122      */
 123     private ContextMenu columnPopupMenu;
 124 
 125     private BooleanProperty reordering = new SimpleBooleanProperty(this, "reordering", false) {
 126         @Override protected void invalidated() {
 127             TableColumnHeader r = getReorderingRegion();
 128             if (r != null) {
 129                 double dragHeaderHeight = r.getNestedColumnHeader() != null ?
 130                         r.getNestedColumnHeader().getHeight() :
 131                         getReorderingRegion().getHeight();
 132 
 133                 dragHeader.resize(dragHeader.getWidth(), dragHeaderHeight);
 134                 dragHeader.setTranslateY(getHeight() - dragHeaderHeight);
 135             }
 136             dragHeader.setVisible(isReordering());
 137         }
 138     };
 139 
 140 
 141 
 142     /***************************************************************************
 143      *                                                                         *
 144      * Constructor                                                             *
 145      *                                                                         *
 146      **************************************************************************/
 147     
 148     public TableHeaderRow(final TableViewSkinBase skin) {
 149         this.tableSkin = skin;
 150         this.flow = skin.flow;
 151 
 152         getStyleClass().setAll("column-header-background");
 153 
 154         // clip the header so it doesn't show outside of the table bounds
 155         clip = new Rectangle();
 156         clip.setSmooth(false);
 157         clip.heightProperty().bind(heightProperty());
 158         setClip(clip);
 159 
 160         // listen to table width to keep header in sync
 161         updateTableWidth();
 162         tableSkin.getSkinnable().widthProperty().addListener(weakTableWidthListener);
 163         tableSkin.getSkinnable().paddingProperty().addListener(weakTablePaddingListener);
 164         skin.getVisibleLeafColumns().addListener(weakVisibleLeafColumnsListener);
 165 
 166         // popup menu for hiding/showing columns
 167         columnPopupMenu = new ContextMenu();
 168         updateTableColumnListeners(tableSkin.getColumns(), Collections.<TableColumnBase<?,?>>emptyList());
 169         tableSkin.getVisibleLeafColumns().addListener(weakTableColumnsListener);
 170 
 171         // drag header region. Used to indicate the current column being reordered
 172         dragHeader = new StackPane();
 173         dragHeader.setVisible(false);
 174         dragHeader.getStyleClass().setAll("column-drag-header");
 175         dragHeader.setManaged(false);
 176         dragHeader.getChildren().add(dragHeaderLabel);
 177 
 178         // the header lives inside a NestedTableColumnHeader
 179         header = createRootHeader();
 180         header.setFocusTraversable(false);
 181         header.setTableHeaderRow(this);
 182 
 183         // The 'filler' area that extends from the right-most column to the edge
 184         // of the tableview, or up to the 'column control' button
 185         filler = new Region();
 186         filler.getStyleClass().setAll("filler");
 187 
 188         // Give focus to the table when an empty area of the header row is clicked.
 189         // This ensures the user knows that the table has focus.
 190         setOnMousePressed(e -> {
 191             skin.getSkinnable().requestFocus();
 192         });
 193 
 194         // build the corner region button for showing the popup menu
 195         final StackPane image = new StackPane();
 196         image.setSnapToPixel(false);
 197         image.getStyleClass().setAll("show-hide-column-image");
 198         cornerRegion = new StackPane() {
 199             @Override protected void layoutChildren() {
 200                 double imageWidth = image.snappedLeftInset() + image.snappedRightInset();
 201                 double imageHeight = image.snappedTopInset() + image.snappedBottomInset();
 202                 
 203                 image.resize(imageWidth, imageHeight);
 204                 positionInArea(image, 0, 0, getWidth(), getHeight() - 3, 
 205                         0, HPos.CENTER, VPos.CENTER);
 206             }
 207         };
 208         cornerRegion.getStyleClass().setAll("show-hide-columns-button");
 209         cornerRegion.getChildren().addAll(image);
 210         cornerRegion.setVisible(tableSkin.tableMenuButtonVisibleProperty().get());
 211         tableSkin.tableMenuButtonVisibleProperty().addListener(valueModel -> {
 212             cornerRegion.setVisible(tableSkin.tableMenuButtonVisibleProperty().get());
 213             requestLayout();
 214         });
 215         cornerRegion.setOnMousePressed(me -> {
 216             // show a popupMenu which lists all columns
 217             columnPopupMenu.show(cornerRegion, Side.BOTTOM, 0, 0);
 218             me.consume();
 219         });
 220 
 221         // the actual header
 222         // the region that is anchored above the vertical scrollbar
 223         // a 'ghost' of the header being dragged by the user to force column
 224         // reordering
 225         getChildren().addAll(filler, header, cornerRegion, dragHeader);
 226     }
 227     
 228 
 229 
 230     /***************************************************************************
 231      *                                                                         *
 232      * Listeners                                                               *
 233      *                                                                         *
 234      **************************************************************************/    
 235     
 236     private InvalidationListener tableWidthListener = valueModel -> {
 237         updateTableWidth();
 238     };
 239 
 240     private InvalidationListener tablePaddingListener = valueModel -> {
 241         updateTableWidth();
 242     };
 243     
 244     private ListChangeListener visibleLeafColumnsListener = new ListChangeListener<TableColumn<?,?>>() {
 245         @Override public void onChanged(ListChangeListener.Change<? extends TableColumn<?,?>> c) {
 246             // This is necessary for RT-20300 (but was updated for RT-20840)
 247             header.setHeadersNeedUpdate();
 248         }
 249     };
 250     
 251     private final ListChangeListener tableColumnsListener = c -> {
 252         while (c.next()) {
 253             updateTableColumnListeners(c.getAddedSubList(), c.getRemoved());
 254         }
 255     };
 256     
 257     private final InvalidationListener columnTextListener = observable -> {
 258         TableColumnBase<?,?> column = (TableColumnBase<?,?>) ((StringProperty)observable).getBean();
 259         CheckMenuItem menuItem = columnMenuItems.get(column);
 260         if (menuItem != null) {
 261             menuItem.setText(getText(column.getText(), column));
 262         }
 263     };
 264     
 265     private final WeakInvalidationListener weakTableWidthListener = 
 266             new WeakInvalidationListener(tableWidthListener);
 267 
 268     private final WeakInvalidationListener weakTablePaddingListener =
 269             new WeakInvalidationListener(tablePaddingListener);
 270 
 271     private final WeakListChangeListener weakVisibleLeafColumnsListener =
 272             new WeakListChangeListener(visibleLeafColumnsListener);
 273     
 274     private final WeakListChangeListener weakTableColumnsListener =
 275             new WeakListChangeListener(tableColumnsListener);
 276     
 277     private final WeakInvalidationListener weakColumnTextListener = 
 278             new WeakInvalidationListener(columnTextListener);
 279 
 280 
 281 
 282     /***************************************************************************
 283      *                                                                         *
 284      * Public Methods                                                          *
 285      *                                                                         *
 286      **************************************************************************/
 287 
 288     /** {@inheritDoc} */
 289     @Override protected void layoutChildren() {
 290         double x = scrollX;
 291         double headerWidth = snapSize(header.prefWidth(-1));
 292         double prefHeight = getHeight() - snappedTopInset() - snappedBottomInset();
 293         double cornerWidth = snapSize(flow.getVbar().prefWidth(-1));
 294 
 295         // position the main nested header
 296         header.resizeRelocate(x, snappedTopInset(), headerWidth, prefHeight);
 297         
 298         // position the filler region
 299         final Control control = tableSkin.getSkinnable();
 300         if (control == null) {
 301             return;
 302         }
 303 
 304         final double controlInsets = control.snappedLeftInset() + control.snappedRightInset();
 305         double fillerWidth = tableWidth - headerWidth + filler.getInsets().getLeft() - controlInsets;
 306         fillerWidth -= tableSkin.tableMenuButtonVisibleProperty().get() ? cornerWidth : 0;
 307         filler.setVisible(fillerWidth > 0);
 308         if (fillerWidth > 0) {
 309             filler.resizeRelocate(x + headerWidth, snappedTopInset(), fillerWidth, prefHeight);
 310         }
 311 
 312         // position the top-right rectangle (which sits above the scrollbar)
 313         cornerRegion.resizeRelocate(tableWidth - cornerWidth, snappedTopInset(), cornerWidth, prefHeight);
 314     }
 315 
 316     /** {@inheritDoc} */
 317     @Override protected double computePrefWidth(double height) {
 318         return header.prefWidth(height);
 319     }
 320 
 321     /** {@inheritDoc} */
 322     @Override protected double computeMinHeight(double width) {
 323         return computePrefHeight(width);
 324     }
 325 
 326     /** {@inheritDoc} */
 327     @Override protected double computePrefHeight(double width) {
 328         // we use cornerRegion.getHeight() here to avoid RT-37616, where the
 329         // entire header row would disappear when all columns were hidden. We know
 330         // that the cornerRegion height has previously been calculated and set,
 331         // so we can baseline on this size to prevent the header row disappearing.
 332         return snappedTopInset() + Math.max(header.prefHeight(width), cornerRegion.getHeight()) + snappedBottomInset();
 333     }
 334 
 335     // protected to allow subclasses to provide a custom root header
 336     protected NestedTableColumnHeader createRootHeader() {
 337         return new NestedTableColumnHeader(tableSkin, null);
 338     }
 339 
 340     // protected to allow subclasses access to the TableViewSkinBase instance
 341     protected TableViewSkinBase<?,?,?,?,?,?> getTableSkin() {
 342         return this.tableSkin;
 343     }
 344 
 345     // protected to allow subclasses to modify the horizontal scrolling
 346     protected void updateScrollX() {
 347         scrollX = flow.getHbar().isVisible() ? -flow.getHbar().getValue() : 0.0F;
 348         requestLayout();
 349 
 350         // Fix for RT-36392: without this call even though we call requestLayout()
 351         // we don't seem to ever see the layoutChildren() method above called,
 352         // which means the layout is not always updated to use the latest scrollX.
 353         layout();
 354     }
 355 
 356     public final void setReordering(boolean value) {
 357         this.reordering.set(value);
 358     }
 359 
 360     public final boolean isReordering() {
 361         return reordering.get();
 362     }
 363 
 364     public final BooleanProperty reorderingProperty() {
 365         return reordering;
 366     }
 367 
 368     public TableColumnHeader getReorderingRegion() {
 369         return reorderingRegion;
 370     }
 371 
 372     public void setReorderingColumn(TableColumnBase rc) {
 373         dragHeaderLabel.setText(rc == null ? "" : rc.getText());
 374     }
 375 
 376     public void setReorderingRegion(TableColumnHeader reorderingRegion) {
 377         this.reorderingRegion = reorderingRegion;
 378 
 379         if (reorderingRegion != null) {
 380             dragHeader.resize(reorderingRegion.getWidth(), dragHeader.getHeight());
 381         }
 382     }
 383 
 384     public void setDragHeaderX(double dragHeaderX) {
 385         dragHeader.setTranslateX(dragHeaderX);
 386     }
 387 
 388     public NestedTableColumnHeader getRootHeader() {
 389         return header;
 390     }
 391 
 392     // protected to allow subclass to customise the width, to allow for features
 393     // such as row headers
 394     protected void updateTableWidth() {
 395         // snapping added for RT-19428
 396         final Control c = tableSkin.getSkinnable();
 397         if (c == null) {
 398             this.tableWidth = 0;
 399         } else {
 400             Insets insets = c.getInsets() == null ? Insets.EMPTY : c.getInsets();
 401             double padding = snapSize(insets.getLeft()) + snapSize(insets.getRight());
 402             this.tableWidth = snapSize(c.getWidth()) - padding;
 403         }
 404 
 405         clip.setWidth(tableWidth);
 406     }
 407 
 408     public TableColumnHeader getColumnHeaderFor(final TableColumnBase<?,?> col) {
 409         if (col == null) return null;
 410         List<TableColumnBase<?,?>> columnChain = new ArrayList<>();
 411         columnChain.add(col);
 412 
 413         TableColumnBase<?,?> parent = col.getParentColumn();
 414         while (parent != null) {
 415             columnChain.add(0, parent);
 416             parent = parent.getParentColumn();
 417         }
 418 
 419         // we now have a list from top to bottom of a nested column hierarchy,
 420         // and we can now navigate down to retrieve the header with ease
 421         TableColumnHeader currentHeader = getRootHeader();
 422         for (int depth = 0; depth < columnChain.size(); depth++) {
 423             // this is the column we are looking for at this depth
 424             TableColumnBase<?,?> column = columnChain.get(depth);
 425 
 426             // and now we iterate through the nested table column header at this
 427             // level to get the header
 428             currentHeader = getColumnHeaderFor(column, currentHeader);
 429         }
 430         return currentHeader;
 431     }
 432 
 433     public TableColumnHeader getColumnHeaderFor(final TableColumnBase<?,?> col, TableColumnHeader currentHeader) {
 434         if (currentHeader instanceof NestedTableColumnHeader) {
 435             List<TableColumnHeader> headers = ((NestedTableColumnHeader)currentHeader).getColumnHeaders();
 436 
 437             for (int i = 0; i < headers.size(); i++) {
 438                 TableColumnHeader header = headers.get(i);
 439                 if (header.getTableColumn() == col) {
 440                     return header;
 441                 }
 442             }
 443         }
 444 
 445         return null;
 446     }
 447 
 448 
 449     /***************************************************************************
 450      *                                                                         *
 451      * Private Implementation                                                  *
 452      *                                                                         *
 453      **************************************************************************/
 454 
 455     private void updateTableColumnListeners(List<? extends TableColumnBase<?,?>> added, List<? extends TableColumnBase<?,?>> removed) {
 456         // remove binding from all removed items
 457         for (TableColumnBase tc : removed) {
 458             remove(tc);
 459         }
 460 
 461         rebuildColumnMenu();
 462     }
 463 
 464     private void remove(TableColumnBase<?,?> col) {
 465         if (col == null) return;
 466 
 467         CheckMenuItem item = columnMenuItems.remove(col);
 468         if (item != null) {
 469             col.textProperty().removeListener(weakColumnTextListener);
 470             item.selectedProperty().unbindBidirectional(col.visibleProperty());
 471 
 472             columnPopupMenu.getItems().remove(item);
 473         }
 474 
 475         if (! col.getColumns().isEmpty()) {
 476             for (TableColumnBase tc : col.getColumns()) {
 477                 remove(tc);
 478             }
 479         }
 480     }
 481 
 482     private void rebuildColumnMenu() {
 483         columnPopupMenu.getItems().clear();
 484 
 485         for (TableColumnBase<?,?> col : getTableSkin().getVisibleLeafColumns()) {
 486             CheckMenuItem item = columnMenuItems.get(col);
 487             if (item == null) {
 488                 item = new CheckMenuItem();
 489                 columnMenuItems.put(col, item);
 490             }
 491 
 492             // bind column text and isVisible so that the menu item is always correct
 493             item.setText(getText(col.getText(), col));
 494             col.textProperty().addListener(weakColumnTextListener);
 495             item.selectedProperty().bindBidirectional(col.visibleProperty());
 496 
 497             columnPopupMenu.getItems().add(item);
 498         }
 499     }
 500 
 501     /*
 502      * Function used for building the strings in the popup menu
 503      */
 504     private String getText(String text, TableColumnBase col) {
 505         String s = text;
 506         TableColumnBase parentCol = col.getParentColumn();
 507         while (parentCol != null) {
 508             if (isColumnVisibleInHeader(parentCol, tableSkin.getColumns())) {
 509                 s = parentCol.getText() + MENU_SEPARATOR + s;
 510             }
 511             parentCol = parentCol.getParentColumn();
 512         }
 513         return s;
 514     }
 515     
 516     // We need to show strings properly. If a column has a parent column which is
 517     // not inserted into the TableView columns list, it effectively doesn't have
 518     // a parent column from the users perspective. As such, we shouldn't include
 519     // the parent column text in the menu. Fixes RT-14482.
 520     private boolean isColumnVisibleInHeader(TableColumnBase col, List columns) {
 521         if (col == null) return false;
 522         
 523         for (int i = 0; i < columns.size(); i++) {
 524             TableColumnBase column = (TableColumnBase) columns.get(i);
 525             if (col.equals(column)) return true;
 526             
 527             if (! column.getColumns().isEmpty()) {
 528                 boolean isVisible = isColumnVisibleInHeader(col, column.getColumns());
 529                 if (isVisible) return true;
 530             }
 531         }
 532         
 533         return false;
 534     }
 535 }