Save This Page
Home » openjdk-7 » javax » swing » plaf » synth » [javadoc | source]
    1   /*
    2    * Copyright (c) 2002, 2010, 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 javax.swing.plaf.synth;
   27   
   28   import java.awt;
   29   import java.beans;
   30   import javax.swing;
   31   import javax.swing.border;
   32   import javax.swing.plaf;
   33   import javax.swing.plaf.basic;
   34   import javax.swing.table;
   35   import sun.swing.table;
   36   
   37   /**
   38    * Provides the Synth L&F UI delegate for
   39    * {@link javax.swing.table.JTableHeader}.
   40    *
   41    * @author Alan Chung
   42    * @author Philip Milne
   43    * @since 1.7
   44    */
   45   public class SynthTableHeaderUI extends BasicTableHeaderUI
   46                                   implements PropertyChangeListener, SynthUI {
   47   
   48   //
   49   // Instance Variables
   50   //
   51   
   52       private TableCellRenderer prevRenderer = null;
   53   
   54       private SynthStyle style;
   55   
   56       /**
   57        * Creates a new UI object for the given component.
   58        *
   59        * @param h component to create UI object for
   60        * @return the UI object
   61        */
   62       public static ComponentUI createUI(JComponent h) {
   63           return new SynthTableHeaderUI();
   64       }
   65   
   66       /**
   67        * @inheritDoc
   68        */
   69       @Override
   70       protected void installDefaults() {
   71           prevRenderer = header.getDefaultRenderer();
   72           if (prevRenderer instanceof UIResource) {
   73               header.setDefaultRenderer(new HeaderRenderer());
   74           }
   75           updateStyle(header);
   76       }
   77   
   78       private void updateStyle(JTableHeader c) {
   79           SynthContext context = getContext(c, ENABLED);
   80           SynthStyle oldStyle = style;
   81           style = SynthLookAndFeel.updateStyle(context, this);
   82           if (style != oldStyle) {
   83               if (oldStyle != null) {
   84                   uninstallKeyboardActions();
   85                   installKeyboardActions();
   86               }
   87           }
   88           context.dispose();
   89       }
   90   
   91       /**
   92        * @inheritDoc
   93        */
   94       @Override
   95       protected void installListeners() {
   96           super.installListeners();
   97           header.addPropertyChangeListener(this);
   98       }
   99   
  100       /**
  101        * @inheritDoc
  102        */
  103       @Override
  104       protected void uninstallDefaults() {
  105           if (header.getDefaultRenderer() instanceof HeaderRenderer) {
  106               header.setDefaultRenderer(prevRenderer);
  107           }
  108   
  109           SynthContext context = getContext(header, ENABLED);
  110   
  111           style.uninstallDefaults(context);
  112           context.dispose();
  113           style = null;
  114       }
  115   
  116       /**
  117        * @inheritDoc
  118        */
  119       @Override
  120       protected void uninstallListeners() {
  121           header.removePropertyChangeListener(this);
  122           super.uninstallListeners();
  123       }
  124   
  125       /**
  126        * Notifies this UI delegate to repaint the specified component.
  127        * This method paints the component background, then calls
  128        * the {@link #paint(SynthContext,Graphics)} method.
  129        *
  130        * <p>In general, this method does not need to be overridden by subclasses.
  131        * All Look and Feel rendering code should reside in the {@code paint} method.
  132        *
  133        * @param g the {@code Graphics} object used for painting
  134        * @param c the component being painted
  135        * @see #paint(SynthContext,Graphics)
  136        */
  137       @Override
  138       public void update(Graphics g, JComponent c) {
  139           SynthContext context = getContext(c);
  140   
  141           SynthLookAndFeel.update(context, g);
  142           context.getPainter().paintTableHeaderBackground(context,
  143                             g, 0, 0, c.getWidth(), c.getHeight());
  144           paint(context, g);
  145           context.dispose();
  146       }
  147   
  148       /**
  149        * Paints the specified component according to the Look and Feel.
  150        * <p>This method is not used by Synth Look and Feel.
  151        * Painting is handled by the {@link #paint(SynthContext,Graphics)} method.
  152        *
  153        * @param g the {@code Graphics} object used for painting
  154        * @param c the component being painted
  155        * @see #paint(SynthContext,Graphics)
  156        */
  157       @Override
  158       public void paint(Graphics g, JComponent c) {
  159           SynthContext context = getContext(c);
  160   
  161           paint(context, g);
  162           context.dispose();
  163       }
  164   
  165       /**
  166        * Paints the specified component.
  167        *
  168        * @param context context for the component being painted
  169        * @param g the {@code Graphics} object used for painting
  170        * @see #update(Graphics,JComponent)
  171        */
  172       protected void paint(SynthContext context, Graphics g) {
  173           super.paint(g, context.getComponent());
  174       }
  175   
  176       /**
  177        * @inheritDoc
  178        */
  179       @Override
  180       public void paintBorder(SynthContext context, Graphics g, int x,
  181                               int y, int w, int h) {
  182           context.getPainter().paintTableHeaderBorder(context, g, x, y, w, h);
  183       }
  184   //
  185   // SynthUI
  186   //
  187       /**
  188        * @inheritDoc
  189        */
  190       @Override
  191       public SynthContext getContext(JComponent c) {
  192           return getContext(c, SynthLookAndFeel.getComponentState(c));
  193       }
  194   
  195       private SynthContext getContext(JComponent c, int state) {
  196           return SynthContext.getContext(SynthContext.class, c,
  197                       SynthLookAndFeel.getRegion(c), style, state);
  198       }
  199   
  200       /**
  201        * @inheritDoc
  202        */
  203       @Override
  204       protected void rolloverColumnUpdated(int oldColumn, int newColumn) {
  205           header.repaint(header.getHeaderRect(oldColumn));
  206           header.repaint(header.getHeaderRect(newColumn));
  207       }
  208   
  209       /**
  210        * @inheritDoc
  211        */
  212       @Override
  213       public void propertyChange(PropertyChangeEvent evt) {
  214           if (SynthLookAndFeel.shouldUpdateStyle(evt)) {
  215               updateStyle((JTableHeader)evt.getSource());
  216           }
  217       }
  218   
  219       private class HeaderRenderer extends DefaultTableCellHeaderRenderer {
  220           HeaderRenderer() {
  221               setHorizontalAlignment(JLabel.LEADING);
  222               setName("TableHeader.renderer");
  223           }
  224   
  225           @Override
  226           public Component getTableCellRendererComponent(JTable table, Object value,
  227                                                          boolean isSelected,
  228                                                          boolean hasFocus,
  229                                                          int row, int column) {
  230   
  231               boolean hasRollover = (column == getRolloverColumn());
  232               if (isSelected || hasRollover || hasFocus) {
  233                   SynthLookAndFeel.setSelectedUI((SynthLabelUI)SynthLookAndFeel.
  234                                getUIOfType(getUI(), SynthLabelUI.class),
  235                                isSelected, hasFocus, table.isEnabled(),
  236                                hasRollover);
  237               } else {
  238                   SynthLookAndFeel.resetSelectedUI();
  239               }
  240   
  241               //stuff a variable into the client property of this renderer indicating the sort order,
  242               //so that different rendering can be done for the header based on sorted state.
  243               RowSorter rs = table == null ? null : table.getRowSorter();
  244               java.util.List<? extends RowSorter.SortKey> sortKeys = rs == null ? null : rs.getSortKeys();
  245               if (sortKeys != null && sortKeys.size() > 0 && sortKeys.get(0).getColumn() ==
  246                       table.convertColumnIndexToModel(column)) {
  247                   switch(sortKeys.get(0).getSortOrder()) {
  248                       case ASCENDING:
  249                           putClientProperty("Table.sortOrder", "ASCENDING");
  250                           break;
  251                       case DESCENDING:
  252                           putClientProperty("Table.sortOrder", "DESCENDING");
  253                           break;
  254                       case UNSORTED:
  255                           putClientProperty("Table.sortOrder", "UNSORTED");
  256                           break;
  257                       default:
  258                           throw new AssertionError("Cannot happen");
  259                   }
  260               } else {
  261                   putClientProperty("Table.sortOrder", "UNSORTED");
  262               }
  263   
  264               super.getTableCellRendererComponent(table, value, isSelected,
  265                                                   hasFocus, row, column);
  266   
  267               return this;
  268           }
  269   
  270           @Override
  271           public void setBorder(Border border) {
  272               if (border instanceof SynthBorder) {
  273                   super.setBorder(border);
  274               }
  275           }
  276       }
  277   }

Save This Page
Home » openjdk-7 » javax » swing » plaf » synth » [javadoc | source]