1 /*
   2  * Copyright (c) 2000, 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 sun.print;
  27 
  28 import java.awt.BorderLayout;
  29 import java.awt.Color;
  30 import java.awt.Component;
  31 import java.awt.Container;
  32 import java.awt.Dialog;
  33 import java.awt.FlowLayout;
  34 import java.awt.Frame;
  35 import java.awt.GraphicsConfiguration;
  36 import java.awt.GridBagLayout;
  37 import java.awt.GridBagConstraints;
  38 import java.awt.GridLayout;
  39 import java.awt.Insets;
  40 import java.awt.Toolkit;
  41 import java.awt.event.ActionEvent;
  42 import java.awt.event.ActionListener;
  43 import java.awt.event.FocusEvent;
  44 import java.awt.event.FocusListener;
  45 import java.awt.event.ItemEvent;
  46 import java.awt.event.ItemListener;
  47 import java.awt.event.WindowEvent;
  48 import java.awt.event.WindowAdapter;
  49 import java.awt.print.PrinterJob;
  50 import java.io.File;
  51 import java.io.FilePermission;
  52 import java.io.IOException;
  53 import java.net.URI;
  54 import java.net.URL;
  55 import java.text.DecimalFormat;
  56 import java.util.Locale;
  57 import java.util.ResourceBundle;
  58 import java.util.Vector;
  59 import javax.print.*;
  60 import javax.print.attribute.*;
  61 import javax.print.attribute.standard.*;
  62 import javax.swing.*;
  63 import javax.swing.border.Border;
  64 import javax.swing.border.EmptyBorder;
  65 import javax.swing.border.TitledBorder;
  66 import javax.swing.event.ChangeEvent;
  67 import javax.swing.event.ChangeListener;
  68 import javax.swing.event.DocumentEvent;
  69 import javax.swing.event.DocumentListener;
  70 import javax.swing.event.PopupMenuEvent;
  71 import javax.swing.event.PopupMenuListener;
  72 import javax.swing.text.NumberFormatter;
  73 import sun.print.SunPageSelection;
  74 import java.awt.event.KeyEvent;
  75 import java.net.URISyntaxException;
  76 import java.lang.reflect.Field;
  77 
  78 
  79 /**
  80  * A class which implements a cross-platform print dialog.
  81  *
  82  * @author  Chris Campbell
  83  */
  84 @SuppressWarnings("serial") // Superclass is not serializable across versions
  85 public class ServiceDialog extends JDialog implements ActionListener {
  86 
  87     /**
  88      * Waiting print status (user response pending).
  89      */
  90     public static final int WAITING = 0;
  91 
  92     /**
  93      * Approve print status (user activated "Print" or "OK").
  94      */
  95     public static final int APPROVE = 1;
  96 
  97     /**
  98      * Cancel print status (user activated "Cancel");
  99      */
 100     public static final int CANCEL = 2;
 101 
 102     private static final String strBundle = "sun.print.resources.serviceui";
 103     private static final Insets panelInsets = new Insets(6, 6, 6, 6);
 104     private static final Insets compInsets = new Insets(3, 6, 3, 6);
 105 
 106     private static ResourceBundle messageRB;
 107     private JTabbedPane tpTabs;
 108     private JButton btnCancel, btnApprove;
 109     private PrintService[] services;
 110     private int defaultServiceIndex;
 111     private PrintRequestAttributeSet asOriginal;
 112     private HashPrintRequestAttributeSet asCurrent;
 113     private PrintService psCurrent;
 114     private DocFlavor docFlavor;
 115     private int status;
 116 
 117     private ValidatingFileChooser jfc;
 118 
 119     private GeneralPanel pnlGeneral;
 120     private PageSetupPanel pnlPageSetup;
 121     private AppearancePanel pnlAppearance;
 122 
 123     private boolean isAWT = false;
 124     static {
 125         initResource();
 126     }
 127 
 128 
 129     /**
 130      * Constructor for the "standard" print dialog (containing all relevant
 131      * tabs)
 132      */
 133     public ServiceDialog(GraphicsConfiguration gc,
 134                          int x, int y,
 135                          PrintService[] services,
 136                          int defaultServiceIndex,
 137                          DocFlavor flavor,
 138                          PrintRequestAttributeSet attributes,
 139                          Dialog dialog)
 140     {
 141         super(dialog, getMsg("dialog.printtitle"), true, gc);
 142         initPrintDialog(x, y, services, defaultServiceIndex,
 143                         flavor, attributes);
 144     }
 145 
 146 
 147 
 148     /**
 149      * Constructor for the "standard" print dialog (containing all relevant
 150      * tabs)
 151      */
 152     public ServiceDialog(GraphicsConfiguration gc,
 153                          int x, int y,
 154                          PrintService[] services,
 155                          int defaultServiceIndex,
 156                          DocFlavor flavor,
 157                          PrintRequestAttributeSet attributes,
 158                          Frame frame)
 159     {
 160         super(frame, getMsg("dialog.printtitle"), true, gc);
 161         initPrintDialog(x, y, services, defaultServiceIndex,
 162                         flavor, attributes);
 163     }
 164 
 165 
 166     /**
 167      * Initialize print dialog.
 168      */
 169     void initPrintDialog(int x, int y,
 170                          PrintService[] services,
 171                          int defaultServiceIndex,
 172                          DocFlavor flavor,
 173                          PrintRequestAttributeSet attributes)
 174     {
 175         this.services = services;
 176         this.defaultServiceIndex = defaultServiceIndex;
 177         this.asOriginal = attributes;
 178         this.asCurrent = new HashPrintRequestAttributeSet(attributes);
 179         this.psCurrent = services[defaultServiceIndex];
 180         this.docFlavor = flavor;
 181         SunPageSelection pages =
 182             (SunPageSelection)attributes.get(SunPageSelection.class);
 183         if (pages != null) {
 184             isAWT = true;
 185         }
 186 
 187         Container c = getContentPane();
 188         c.setLayout(new BorderLayout());
 189 
 190         tpTabs = new JTabbedPane();
 191         tpTabs.setBorder(new EmptyBorder(5, 5, 5, 5));
 192 
 193         String gkey = getMsg("tab.general");
 194         int gmnemonic = getVKMnemonic("tab.general");
 195         pnlGeneral = new GeneralPanel();
 196         tpTabs.add(gkey, pnlGeneral);
 197         tpTabs.setMnemonicAt(0, gmnemonic);
 198 
 199         String pkey = getMsg("tab.pagesetup");
 200         int pmnemonic = getVKMnemonic("tab.pagesetup");
 201         pnlPageSetup = new PageSetupPanel();
 202         tpTabs.add(pkey, pnlPageSetup);
 203         tpTabs.setMnemonicAt(1, pmnemonic);
 204 
 205         String akey = getMsg("tab.appearance");
 206         int amnemonic = getVKMnemonic("tab.appearance");
 207         pnlAppearance = new AppearancePanel();
 208         tpTabs.add(akey, pnlAppearance);
 209         tpTabs.setMnemonicAt(2, amnemonic);
 210 
 211         c.add(tpTabs, BorderLayout.CENTER);
 212 
 213         updatePanels();
 214 
 215         JPanel pnlSouth = new JPanel(new FlowLayout(FlowLayout.TRAILING));
 216         btnApprove = createExitButton("button.print", this);
 217         pnlSouth.add(btnApprove);
 218         getRootPane().setDefaultButton(btnApprove);
 219         btnCancel = createExitButton("button.cancel", this);
 220         handleEscKey(btnCancel);
 221         pnlSouth.add(btnCancel);
 222         c.add(pnlSouth, BorderLayout.SOUTH);
 223 
 224         addWindowListener(new WindowAdapter() {
 225             public void windowClosing(WindowEvent event) {
 226                 dispose(CANCEL);
 227             }
 228         });
 229 
 230         getAccessibleContext().setAccessibleDescription(getMsg("dialog.printtitle"));
 231         setResizable(false);
 232         setLocation(x, y);
 233         pack();
 234     }
 235 
 236    /**
 237      * Constructor for the solitary "page setup" dialog
 238      */
 239     public ServiceDialog(GraphicsConfiguration gc,
 240                          int x, int y,
 241                          PrintService ps,
 242                          DocFlavor flavor,
 243                          PrintRequestAttributeSet attributes,
 244                          Dialog dialog)
 245     {
 246         super(dialog, getMsg("dialog.pstitle"), true, gc);
 247         initPageDialog(x, y, ps, flavor, attributes);
 248     }
 249 
 250     /**
 251      * Constructor for the solitary "page setup" dialog
 252      */
 253     public ServiceDialog(GraphicsConfiguration gc,
 254                          int x, int y,
 255                          PrintService ps,
 256                          DocFlavor flavor,
 257                          PrintRequestAttributeSet attributes,
 258                          Frame frame)
 259     {
 260         super(frame, getMsg("dialog.pstitle"), true, gc);
 261         initPageDialog(x, y, ps, flavor, attributes);
 262     }
 263 
 264 
 265     /**
 266      * Initialize "page setup" dialog
 267      */
 268     void initPageDialog(int x, int y,
 269                          PrintService ps,
 270                          DocFlavor flavor,
 271                          PrintRequestAttributeSet attributes)
 272     {
 273         this.psCurrent = ps;
 274         this.docFlavor = flavor;
 275         this.asOriginal = attributes;
 276         this.asCurrent = new HashPrintRequestAttributeSet(attributes);
 277 
 278         Container c = getContentPane();
 279         c.setLayout(new BorderLayout());
 280 
 281         pnlPageSetup = new PageSetupPanel();
 282         c.add(pnlPageSetup, BorderLayout.CENTER);
 283 
 284         pnlPageSetup.updateInfo();
 285 
 286         JPanel pnlSouth = new JPanel(new FlowLayout(FlowLayout.TRAILING));
 287         btnApprove = createExitButton("button.ok", this);
 288         pnlSouth.add(btnApprove);
 289         getRootPane().setDefaultButton(btnApprove);
 290         btnCancel = createExitButton("button.cancel", this);
 291         handleEscKey(btnCancel);
 292         pnlSouth.add(btnCancel);
 293         c.add(pnlSouth, BorderLayout.SOUTH);
 294 
 295         addWindowListener(new WindowAdapter() {
 296             public void windowClosing(WindowEvent event) {
 297                 dispose(CANCEL);
 298             }
 299         });
 300 
 301         getAccessibleContext().setAccessibleDescription(getMsg("dialog.pstitle"));
 302         setResizable(false);
 303         setLocation(x, y);
 304         pack();
 305     }
 306 
 307     /**
 308      * Performs Cancel when Esc key is pressed.
 309      */
 310     private void handleEscKey(JButton btnCancel) {
 311         @SuppressWarnings("serial") // anonymous class
 312         Action cancelKeyAction = new AbstractAction() {
 313             public void actionPerformed(ActionEvent e) {
 314                 dispose(CANCEL);
 315             }
 316         };
 317         KeyStroke cancelKeyStroke =
 318             KeyStroke.getKeyStroke((char)KeyEvent.VK_ESCAPE, 0);
 319         InputMap inputMap =
 320             btnCancel.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
 321         ActionMap actionMap = btnCancel.getActionMap();
 322 
 323         if (inputMap != null && actionMap != null) {
 324             inputMap.put(cancelKeyStroke, "cancel");
 325             actionMap.put("cancel", cancelKeyAction);
 326         }
 327     }
 328 
 329 
 330     /**
 331      * Returns the current status of the dialog (whether the user has selected
 332      * the "Print" or "Cancel" button)
 333      */
 334     public int getStatus() {
 335         return status;
 336     }
 337 
 338     /**
 339      * Returns an AttributeSet based on whether or not the user cancelled the
 340      * dialog.  If the user selected "Print" we return their new selections,
 341      * otherwise we return the attributes that were passed in initially.
 342      */
 343     public PrintRequestAttributeSet getAttributes() {
 344         if (status == APPROVE) {
 345             return asCurrent;
 346         } else {
 347             return asOriginal;
 348         }
 349     }
 350 
 351     /**
 352      * Returns a PrintService based on whether or not the user cancelled the
 353      * dialog.  If the user selected "Print" we return the user's selection
 354      * for the PrintService, otherwise we return null.
 355      */
 356     public PrintService getPrintService() {
 357         if (status == APPROVE) {
 358             return psCurrent;
 359         } else {
 360             return null;
 361         }
 362     }
 363 
 364     /**
 365      * Sets the current status flag for the dialog and disposes it (thus
 366      * returning control of the parent frame back to the user)
 367      */
 368     public void dispose(int status) {
 369         this.status = status;
 370 
 371         super.dispose();
 372     }
 373 
 374     public void actionPerformed(ActionEvent e) {
 375         Object source = e.getSource();
 376         boolean approved = false;
 377 
 378         if (source == btnApprove) {
 379             approved = true;
 380 
 381             if (pnlGeneral != null) {
 382                 if (pnlGeneral.isPrintToFileRequested()) {
 383                     approved = showFileChooser();
 384                 } else {
 385                     asCurrent.remove(Destination.class);
 386                 }
 387             }
 388         }
 389 
 390         dispose(approved ? APPROVE : CANCEL);
 391     }
 392 
 393     /**
 394      * Displays a JFileChooser that allows the user to select the destination
 395      * for "Print To File"
 396      */
 397     private boolean showFileChooser() {
 398         Class<Destination> dstCategory = Destination.class;
 399 
 400         Destination dst = (Destination)asCurrent.get(dstCategory);
 401         if (dst == null) {
 402             dst = (Destination)asOriginal.get(dstCategory);
 403             if (dst == null) {
 404                 dst = (Destination)psCurrent.getDefaultAttributeValue(dstCategory);
 405                 // "dst" should not be null. The following code
 406                 // is only added to safeguard against a possible
 407                 // buggy implementation of a PrintService having a
 408                 // null default Destination.
 409                 if (dst == null) {
 410                     try {
 411                         dst = new Destination(new URI("file:out.prn"));
 412                     } catch (URISyntaxException e) {
 413                     }
 414                 }
 415             }
 416         }
 417 
 418         File fileDest;
 419         if (dst != null) {
 420             try {
 421                 fileDest = new File(dst.getURI());
 422             } catch (Exception e) {
 423                 // all manner of runtime exceptions possible
 424                 fileDest = new File("out.prn");
 425             }
 426         } else {
 427             fileDest = new File("out.prn");
 428         }
 429 
 430         ValidatingFileChooser jfc = new ValidatingFileChooser();
 431         jfc.setApproveButtonText(getMsg("button.ok"));
 432         jfc.setDialogTitle(getMsg("dialog.printtofile"));
 433         jfc.setDialogType(JFileChooser.SAVE_DIALOG);
 434         jfc.setSelectedFile(fileDest);
 435 
 436         int returnVal = jfc.showDialog(this, null);
 437         if (returnVal == JFileChooser.APPROVE_OPTION) {
 438             fileDest = jfc.getSelectedFile();
 439 
 440             try {
 441                 asCurrent.add(new Destination(fileDest.toURI()));
 442             } catch (Exception e) {
 443                 asCurrent.remove(dstCategory);
 444             }
 445         } else {
 446             asCurrent.remove(dstCategory);
 447         }
 448 
 449         return (returnVal == JFileChooser.APPROVE_OPTION);
 450     }
 451 
 452     /**
 453      * Updates each of the top level panels
 454      */
 455     private void updatePanels() {
 456         pnlGeneral.updateInfo();
 457         pnlPageSetup.updateInfo();
 458         pnlAppearance.updateInfo();
 459     }
 460 
 461     /**
 462      * Initialize ResourceBundle
 463      */
 464     public static void initResource() {
 465         java.security.AccessController.doPrivileged(
 466             new java.security.PrivilegedAction<Object>() {
 467                 public Object run() {
 468                     try {
 469                         messageRB = ResourceBundle.getBundle(strBundle);
 470                         return null;
 471                     } catch (java.util.MissingResourceException e) {
 472                         throw new Error("Fatal: Resource for ServiceUI " +
 473                                         "is missing");
 474                     }
 475                 }
 476             }
 477         );
 478     }
 479 
 480     /**
 481      * Returns message string from resource
 482      */
 483     public static String getMsg(String key) {
 484         try {
 485             return removeMnemonics(messageRB.getString(key));
 486         } catch (java.util.MissingResourceException e) {
 487             throw new Error("Fatal: Resource for ServiceUI is broken; " +
 488                             "there is no " + key + " key in resource");
 489         }
 490     }
 491 
 492     private static String removeMnemonics(String s) {
 493         int i = s.indexOf('&');
 494         int len = s.length();
 495         if (i < 0 || i == (len - 1)) {
 496             return s;
 497         }
 498         int j = s.indexOf('&', i+1);
 499         if (j == i+1) {
 500             if (j+1 == len) {
 501                 return s.substring(0, i+1);  // string ends with &&
 502             } else {
 503                 return s.substring(0, i+1) + removeMnemonics(s.substring(j+1));
 504             }
 505         }
 506         // ok first & not double &&
 507         if (i == 0) {
 508             return removeMnemonics(s.substring(1));
 509         } else {
 510             return (s.substring(0, i) + removeMnemonics(s.substring(i+1)));
 511         }
 512     }
 513 
 514 
 515     /**
 516      * Returns mnemonic character from resource
 517      */
 518     private static char getMnemonic(String key) {
 519         String str = messageRB.getString(key).replace("&&", "");
 520         int index = str.indexOf('&');
 521         if (0 <= index && index < str.length() - 1) {
 522             char c = str.charAt(index + 1);
 523             return Character.toUpperCase(c);
 524         } else {
 525             return (char)0;
 526         }
 527     }
 528 
 529     /**
 530      * Returns the mnemonic as a KeyEvent.VK constant from the resource.
 531      */
 532     static Class<?> _keyEventClazz = null;
 533     private static int getVKMnemonic(String key) {
 534         String s = String.valueOf(getMnemonic(key));
 535         if ( s == null || s.length() != 1) {
 536             return 0;
 537         }
 538         String vkString = "VK_" + s.toUpperCase();
 539 
 540         try {
 541             if (_keyEventClazz == null) {
 542                 _keyEventClazz= Class.forName("java.awt.event.KeyEvent",
 543                                  true, (ServiceDialog.class).getClassLoader());
 544             }
 545             Field field = _keyEventClazz.getDeclaredField(vkString);
 546             int value = field.getInt(null);
 547             return value;
 548         } catch (Exception e) {
 549         }
 550         return 0;
 551     }
 552 
 553     /**
 554      * Returns URL for image resource
 555      */
 556     private static URL getImageResource(final String key) {
 557         URL url = java.security.AccessController.doPrivileged(
 558                        new java.security.PrivilegedAction<URL>() {
 559                 public URL run() {
 560                     URL url = ServiceDialog.class.getResource(
 561                                                   "resources/" + key);
 562                     return url;
 563                 }
 564         });
 565 
 566         if (url == null) {
 567             throw new Error("Fatal: Resource for ServiceUI is broken; " +
 568                             "there is no " + key + " key in resource");
 569         }
 570 
 571         return url;
 572     }
 573 
 574     /**
 575      * Creates a new JButton and sets its text, mnemonic, and ActionListener
 576      */
 577     private static JButton createButton(String key, ActionListener al) {
 578         JButton btn = new JButton(getMsg(key));
 579         btn.setMnemonic(getMnemonic(key));
 580         btn.addActionListener(al);
 581 
 582         return btn;
 583     }
 584 
 585     /**
 586      * Creates a new JButton and sets its text, and ActionListener
 587      */
 588     private static JButton createExitButton(String key, ActionListener al) {
 589         String str = getMsg(key);
 590         JButton btn = new JButton(str);
 591         btn.addActionListener(al);
 592         btn.getAccessibleContext().setAccessibleDescription(str);
 593         return btn;
 594     }
 595 
 596     /**
 597      * Creates a new JCheckBox and sets its text, mnemonic, and ActionListener
 598      */
 599     private static JCheckBox createCheckBox(String key, ActionListener al) {
 600         JCheckBox cb = new JCheckBox(getMsg(key));
 601         cb.setMnemonic(getMnemonic(key));
 602         cb.addActionListener(al);
 603 
 604         return cb;
 605     }
 606 
 607     /**
 608      * Creates a new JRadioButton and sets its text, mnemonic,
 609      * and ActionListener
 610      */
 611     private static JRadioButton createRadioButton(String key,
 612                                                   ActionListener al)
 613     {
 614         JRadioButton rb = new JRadioButton(getMsg(key));
 615         rb.setMnemonic(getMnemonic(key));
 616         rb.addActionListener(al);
 617 
 618         return rb;
 619     }
 620 
 621   /**
 622    * Creates a  pop-up dialog for "no print service"
 623    */
 624     public static void showNoPrintService(GraphicsConfiguration gc)
 625     {
 626         Frame dlgFrame = new Frame(gc);
 627         JOptionPane.showMessageDialog(dlgFrame,
 628                                       getMsg("dialog.noprintermsg"));
 629         dlgFrame.dispose();
 630     }
 631 
 632     /**
 633      * Sets the constraints for the GridBagLayout and adds the Component
 634      * to the given Container
 635      */
 636     private static void addToGB(Component comp, Container cont,
 637                                 GridBagLayout gridbag,
 638                                 GridBagConstraints constraints)
 639     {
 640         gridbag.setConstraints(comp, constraints);
 641         cont.add(comp);
 642     }
 643 
 644     /**
 645      * Adds the AbstractButton to both the given ButtonGroup and Container
 646      */
 647     private static void addToBG(AbstractButton button, Container cont,
 648                                 ButtonGroup bg)
 649     {
 650         bg.add(button);
 651         cont.add(button);
 652     }
 653 
 654 
 655 
 656 
 657     /**
 658      * The "General" tab.  Includes the controls for PrintService,
 659      * PageRange, and Copies/Collate.
 660      */
 661     @SuppressWarnings("serial") // Superclass is not serializable across versions
 662     private class GeneralPanel extends JPanel {
 663 
 664         private PrintServicePanel pnlPrintService;
 665         private PrintRangePanel pnlPrintRange;
 666         private CopiesPanel pnlCopies;
 667 
 668         public GeneralPanel() {
 669             super();
 670 
 671             GridBagLayout gridbag = new GridBagLayout();
 672             GridBagConstraints c = new GridBagConstraints();
 673 
 674             setLayout(gridbag);
 675 
 676             c.fill = GridBagConstraints.BOTH;
 677             c.insets = panelInsets;
 678             c.weightx = 1.0;
 679             c.weighty = 1.0;
 680 
 681             c.gridwidth = GridBagConstraints.REMAINDER;
 682             pnlPrintService = new PrintServicePanel();
 683             addToGB(pnlPrintService, this, gridbag, c);
 684 
 685             c.gridwidth = GridBagConstraints.RELATIVE;
 686             pnlPrintRange = new PrintRangePanel();
 687             addToGB(pnlPrintRange, this, gridbag, c);
 688 
 689             c.gridwidth = GridBagConstraints.REMAINDER;
 690             pnlCopies = new CopiesPanel();
 691             addToGB(pnlCopies, this, gridbag, c);
 692         }
 693 
 694         public boolean isPrintToFileRequested() {
 695             return (pnlPrintService.isPrintToFileSelected());
 696         }
 697 
 698         public void updateInfo() {
 699             pnlPrintService.updateInfo();
 700             pnlPrintRange.updateInfo();
 701             pnlCopies.updateInfo();
 702         }
 703     }
 704 
 705     @SuppressWarnings("serial") // Superclass is not serializable across versions
 706     private class PrintServicePanel extends JPanel
 707         implements ActionListener, ItemListener, PopupMenuListener
 708     {
 709         private final String strTitle = getMsg("border.printservice");
 710         private FilePermission printToFilePermission;
 711         private JButton btnProperties;
 712         private JCheckBox cbPrintToFile;
 713         private JComboBox<String> cbName;
 714         private JLabel lblType, lblStatus, lblInfo;
 715         private ServiceUIFactory uiFactory;
 716         private boolean changedService = false;
 717         private boolean filePermission;
 718 
 719         public PrintServicePanel() {
 720             super();
 721 
 722             uiFactory = psCurrent.getServiceUIFactory();
 723 
 724             GridBagLayout gridbag = new GridBagLayout();
 725             GridBagConstraints c = new GridBagConstraints();
 726 
 727             setLayout(gridbag);
 728             setBorder(BorderFactory.createTitledBorder(strTitle));
 729 
 730             String[] psnames = new String[services.length];
 731             for (int i = 0; i < psnames.length; i++) {
 732                 psnames[i] = services[i].getName();
 733             }
 734             cbName = new JComboBox<>(psnames);
 735             cbName.setSelectedIndex(defaultServiceIndex);
 736             cbName.addItemListener(this);
 737             cbName.addPopupMenuListener(this);
 738 
 739             c.fill = GridBagConstraints.BOTH;
 740             c.insets = compInsets;
 741 
 742             c.weightx = 0.0;
 743             JLabel lblName = new JLabel(getMsg("label.psname"), JLabel.TRAILING);
 744             lblName.setDisplayedMnemonic(getMnemonic("label.psname"));
 745             lblName.setLabelFor(cbName);
 746             addToGB(lblName, this, gridbag, c);
 747             c.weightx = 1.0;
 748             c.gridwidth = GridBagConstraints.RELATIVE;
 749             addToGB(cbName, this, gridbag, c);
 750             c.weightx = 0.0;
 751             c.gridwidth = GridBagConstraints.REMAINDER;
 752             btnProperties = createButton("button.properties", this);
 753             addToGB(btnProperties, this, gridbag, c);
 754 
 755             c.weighty = 1.0;
 756             lblStatus = addLabel(getMsg("label.status"), gridbag, c);
 757             lblStatus.setLabelFor(null);
 758 
 759             lblType = addLabel(getMsg("label.pstype"), gridbag, c);
 760             lblType.setLabelFor(null);
 761 
 762             c.gridwidth = 1;
 763             addToGB(new JLabel(getMsg("label.info"), JLabel.TRAILING),
 764                     this, gridbag, c);
 765             c.gridwidth = GridBagConstraints.RELATIVE;
 766             lblInfo = new JLabel();
 767             lblInfo.setLabelFor(null);
 768 
 769             addToGB(lblInfo, this, gridbag, c);
 770 
 771             c.gridwidth = GridBagConstraints.REMAINDER;
 772             cbPrintToFile = createCheckBox("checkbox.printtofile", this);
 773             addToGB(cbPrintToFile, this, gridbag, c);
 774 
 775             filePermission = allowedToPrintToFile();
 776         }
 777 
 778         public boolean isPrintToFileSelected() {
 779             return cbPrintToFile.isSelected();
 780         }
 781 
 782         private JLabel addLabel(String text,
 783                                 GridBagLayout gridbag, GridBagConstraints c)
 784         {
 785             c.gridwidth = 1;
 786             addToGB(new JLabel(text, JLabel.TRAILING), this, gridbag, c);
 787 
 788             c.gridwidth = GridBagConstraints.REMAINDER;
 789             JLabel label = new JLabel();
 790             addToGB(label, this, gridbag, c);
 791 
 792             return label;
 793         }
 794 
 795         @SuppressWarnings("deprecation")
 796         public void actionPerformed(ActionEvent e) {
 797             Object source = e.getSource();
 798 
 799             if (source == btnProperties) {
 800                 if (uiFactory != null) {
 801                     JDialog dialog = (JDialog)uiFactory.getUI(
 802                                                ServiceUIFactory.MAIN_UIROLE,
 803                                                ServiceUIFactory.JDIALOG_UI);
 804 
 805                     if (dialog != null) {
 806                         dialog.show();
 807                     } else {
 808                         DocumentPropertiesUI docPropertiesUI = null;
 809                         try {
 810                             docPropertiesUI =
 811                                 (DocumentPropertiesUI)uiFactory.getUI
 812                                 (DocumentPropertiesUI.DOCUMENTPROPERTIES_ROLE,
 813                                  DocumentPropertiesUI.DOCPROPERTIESCLASSNAME);
 814                         } catch (Exception ex) {
 815                         }
 816                         if (docPropertiesUI != null) {
 817                             PrinterJobWrapper wrapper = (PrinterJobWrapper)
 818                                 asCurrent.get(PrinterJobWrapper.class);
 819                             if (wrapper == null) {
 820                                 return; // should not happen, defensive only.
 821                             }
 822                             PrinterJob job = wrapper.getPrinterJob();
 823                             if (job == null) {
 824                                 return;  // should not happen, defensive only.
 825                             }
 826                             PrintRequestAttributeSet newAttrs =
 827                                docPropertiesUI.showDocumentProperties
 828                                (job, ServiceDialog.this, psCurrent, asCurrent);
 829                             if (newAttrs != null) {
 830                                 asCurrent.addAll(newAttrs);
 831                                 updatePanels();
 832                             }
 833                         }
 834                     }
 835                 }
 836             }
 837         }
 838 
 839         public void itemStateChanged(ItemEvent e) {
 840             if (e.getStateChange() == ItemEvent.SELECTED) {
 841                 int index = cbName.getSelectedIndex();
 842 
 843                 if ((index >= 0) && (index < services.length)) {
 844                     if (!services[index].equals(psCurrent)) {
 845                         psCurrent = services[index];
 846                         uiFactory = psCurrent.getServiceUIFactory();
 847                         changedService = true;
 848 
 849                         Destination dest =
 850                             (Destination)asOriginal.get(Destination.class);
 851                         // to preserve the state of Print To File
 852                         if ((dest != null || isPrintToFileSelected())
 853                             && psCurrent.isAttributeCategorySupported(
 854                                                         Destination.class)) {
 855 
 856                             if (dest != null) {
 857                                 asCurrent.add(dest);
 858                             } else {
 859                                 dest = (Destination)psCurrent.
 860                                     getDefaultAttributeValue(Destination.class);
 861                                 // "dest" should not be null. The following code
 862                                 // is only added to safeguard against a possible
 863                                 // buggy implementation of a PrintService having a
 864                                 // null default Destination.
 865                                 if (dest == null) {
 866                                     try {
 867                                         dest =
 868                                             new Destination(new URI("file:out.prn"));
 869                                     } catch (URISyntaxException ue) {
 870                                     }
 871                                 }
 872 
 873                                 if (dest != null) {
 874                                     asCurrent.add(dest);
 875                                 }
 876                             }
 877                         } else {
 878                             asCurrent.remove(Destination.class);
 879                         }
 880                     }
 881                 }
 882             }
 883         }
 884 
 885         public void popupMenuWillBecomeVisible(PopupMenuEvent e) {
 886             changedService = false;
 887         }
 888 
 889         public void popupMenuWillBecomeInvisible(PopupMenuEvent e) {
 890             if (changedService) {
 891                 changedService = false;
 892                 updatePanels();
 893             }
 894         }
 895 
 896         public void popupMenuCanceled(PopupMenuEvent e) {
 897         }
 898 
 899         /**
 900          * We disable the "Print To File" checkbox if this returns false
 901          */
 902         private boolean allowedToPrintToFile() {
 903             try {
 904                 throwPrintToFile();
 905                 return true;
 906             } catch (SecurityException e) {
 907                 return false;
 908             }
 909         }
 910 
 911         /**
 912          * Break this out as it may be useful when we allow API to
 913          * specify printing to a file. In that case its probably right
 914          * to throw a SecurityException if the permission is not granted.
 915          */
 916         private void throwPrintToFile() {
 917             SecurityManager security = System.getSecurityManager();
 918             if (security != null) {
 919                 if (printToFilePermission == null) {
 920                     printToFilePermission =
 921                         new FilePermission("<<ALL FILES>>", "read,write");
 922                 }
 923                 security.checkPermission(printToFilePermission);
 924             }
 925         }
 926 
 927         public void updateInfo() {
 928             Class<Destination> dstCategory = Destination.class;
 929             boolean dstSupported = false;
 930             boolean dstSelected = false;
 931             boolean dstAllowed = filePermission ?
 932                 allowedToPrintToFile() : false;
 933 
 934             // setup Destination (print-to-file) widgets
 935             if (psCurrent.isAttributeCategorySupported(dstCategory)) {
 936                 dstSupported = true;
 937             }
 938             Destination dst = (Destination)asCurrent.get(dstCategory);
 939             if (dst != null) {
 940                 dstSelected = true;
 941             }
 942             cbPrintToFile.setEnabled(dstSupported && dstAllowed);
 943             cbPrintToFile.setSelected(dstSelected && dstAllowed
 944                                       && dstSupported);
 945 
 946             // setup PrintService information widgets
 947             Attribute type = psCurrent.getAttribute(PrinterMakeAndModel.class);
 948             if (type != null) {
 949                 lblType.setText(type.toString());
 950             }
 951             Attribute status =
 952                 psCurrent.getAttribute(PrinterIsAcceptingJobs.class);
 953             if (status != null) {
 954                 lblStatus.setText(getMsg(status.toString()));
 955             }
 956             Attribute info = psCurrent.getAttribute(PrinterInfo.class);
 957             if (info != null) {
 958                 lblInfo.setText(info.toString());
 959             }
 960             btnProperties.setEnabled(uiFactory != null);
 961         }
 962     }
 963 
 964     @SuppressWarnings("serial") // Superclass is not serializable across versions
 965     private class PrintRangePanel extends JPanel
 966         implements ActionListener, FocusListener
 967     {
 968         private final String strTitle = getMsg("border.printrange");
 969         private final PageRanges prAll = new PageRanges(1, Integer.MAX_VALUE);
 970         private JRadioButton rbAll, rbPages, rbSelect;
 971         private JFormattedTextField tfRangeFrom, tfRangeTo;
 972         private JLabel lblRangeTo;
 973         private boolean prSupported;
 974 
 975         public PrintRangePanel() {
 976             super();
 977 
 978             GridBagLayout gridbag = new GridBagLayout();
 979             GridBagConstraints c = new GridBagConstraints();
 980 
 981             setLayout(gridbag);
 982             setBorder(BorderFactory.createTitledBorder(strTitle));
 983 
 984             c.fill = GridBagConstraints.BOTH;
 985             c.insets = compInsets;
 986             c.gridwidth = GridBagConstraints.REMAINDER;
 987 
 988             ButtonGroup bg = new ButtonGroup();
 989             JPanel pnlTop = new JPanel(new FlowLayout(FlowLayout.LEADING));
 990             rbAll = createRadioButton("radiobutton.rangeall", this);
 991             rbAll.setSelected(true);
 992             bg.add(rbAll);
 993             pnlTop.add(rbAll);
 994             addToGB(pnlTop, this, gridbag, c);
 995 
 996             // Selection never seemed to work so I'm commenting this part.
 997             /*
 998             if (isAWT) {
 999                 JPanel pnlMiddle  =
1000                     new JPanel(new FlowLayout(FlowLayout.LEADING));
1001                 rbSelect =
1002                     createRadioButton("radiobutton.selection", this);
1003                 bg.add(rbSelect);
1004                 pnlMiddle.add(rbSelect);
1005                 addToGB(pnlMiddle, this, gridbag, c);
1006             }
1007             */
1008 
1009             JPanel pnlBottom = new JPanel(new FlowLayout(FlowLayout.LEADING));
1010             rbPages = createRadioButton("radiobutton.rangepages", this);
1011             bg.add(rbPages);
1012             pnlBottom.add(rbPages);
1013             DecimalFormat format = new DecimalFormat("####0");
1014             format.setMinimumFractionDigits(0);
1015             format.setMaximumFractionDigits(0);
1016             format.setMinimumIntegerDigits(0);
1017             format.setMaximumIntegerDigits(5);
1018             format.setParseIntegerOnly(true);
1019             format.setDecimalSeparatorAlwaysShown(false);
1020             NumberFormatter nf = new NumberFormatter(format);
1021             nf.setMinimum(1);
1022             nf.setMaximum(Integer.MAX_VALUE);
1023             nf.setAllowsInvalid(true);
1024             nf.setCommitsOnValidEdit(true);
1025             tfRangeFrom = new JFormattedTextField(nf);
1026             tfRangeFrom.setColumns(4);
1027             tfRangeFrom.setEnabled(false);
1028             tfRangeFrom.addActionListener(this);
1029             tfRangeFrom.addFocusListener(this);
1030             tfRangeFrom.setFocusLostBehavior(
1031                 JFormattedTextField.PERSIST);
1032             tfRangeFrom.getAccessibleContext().setAccessibleName(
1033                                           getMsg("radiobutton.rangepages"));
1034             pnlBottom.add(tfRangeFrom);
1035             lblRangeTo = new JLabel(getMsg("label.rangeto"));
1036             lblRangeTo.setEnabled(false);
1037             pnlBottom.add(lblRangeTo);
1038             NumberFormatter nfto;
1039             try {
1040                 nfto = (NumberFormatter)nf.clone();
1041             } catch (CloneNotSupportedException e) {
1042                 nfto = new NumberFormatter();
1043             }
1044             tfRangeTo = new JFormattedTextField(nfto);
1045             tfRangeTo.setColumns(4);
1046             tfRangeTo.setEnabled(false);
1047             tfRangeTo.addFocusListener(this);
1048             tfRangeTo.getAccessibleContext().setAccessibleName(
1049                                           getMsg("label.rangeto"));
1050             pnlBottom.add(tfRangeTo);
1051             addToGB(pnlBottom, this, gridbag, c);
1052         }
1053 
1054         public void actionPerformed(ActionEvent e) {
1055             Object source = e.getSource();
1056             SunPageSelection select = SunPageSelection.ALL;
1057 
1058             setupRangeWidgets();
1059 
1060             if (source == rbAll) {
1061                 asCurrent.add(prAll);
1062             } else if (source == rbSelect) {
1063                 select = SunPageSelection.SELECTION;
1064             } else if (source == rbPages ||
1065                        source == tfRangeFrom ||
1066                        source == tfRangeTo) {
1067                 updateRangeAttribute();
1068                 select = SunPageSelection.RANGE;
1069             }
1070 
1071             if (isAWT) {
1072                 asCurrent.add(select);
1073             }
1074         }
1075 
1076         public void focusLost(FocusEvent e) {
1077             Object source = e.getSource();
1078 
1079             if ((source == tfRangeFrom) || (source == tfRangeTo)) {
1080                 updateRangeAttribute();
1081             }
1082         }
1083 
1084         public void focusGained(FocusEvent e) {}
1085 
1086         private void setupRangeWidgets() {
1087             boolean rangeEnabled = (rbPages.isSelected() && prSupported);
1088             tfRangeFrom.setEnabled(rangeEnabled);
1089             tfRangeTo.setEnabled(rangeEnabled);
1090             lblRangeTo.setEnabled(rangeEnabled);
1091         }
1092 
1093         private void updateRangeAttribute() {
1094             String strFrom = tfRangeFrom.getText();
1095             String strTo = tfRangeTo.getText();
1096 
1097             int min;
1098             int max;
1099 
1100             try {
1101                 min = Integer.parseInt(strFrom);
1102             } catch (NumberFormatException e) {
1103                 min = 1;
1104             }
1105 
1106             try {
1107                 max = Integer.parseInt(strTo);
1108             } catch (NumberFormatException e) {
1109                 max = min;
1110             }
1111 
1112             if (min < 1) {
1113                 min = 1;
1114                 tfRangeFrom.setValue(1);
1115             }
1116 
1117             if (max < min) {
1118                 max = min;
1119                 tfRangeTo.setValue(min);
1120             }
1121 
1122             PageRanges pr = new PageRanges(min, max);
1123             asCurrent.add(pr);
1124         }
1125 
1126         public void updateInfo() {
1127             Class<PageRanges> prCategory = PageRanges.class;
1128             prSupported = false;
1129 
1130             if (psCurrent.isAttributeCategorySupported(prCategory) ||
1131                    isAWT) {
1132                 prSupported = true;
1133             }
1134 
1135             SunPageSelection select = SunPageSelection.ALL;
1136             int min = 1;
1137             int max = 1;
1138 
1139             PageRanges pr = (PageRanges)asCurrent.get(prCategory);
1140             if (pr != null) {
1141                 if (!pr.equals(prAll)) {
1142                     select = SunPageSelection.RANGE;
1143 
1144                     int[][] members = pr.getMembers();
1145                     if ((members.length > 0) &&
1146                         (members[0].length > 1)) {
1147                         min = members[0][0];
1148                         max = members[0][1];
1149                     }
1150                 }
1151             }
1152 
1153             if (isAWT) {
1154                 select = (SunPageSelection)asCurrent.get(
1155                                                 SunPageSelection.class);
1156             }
1157 
1158             if (select == SunPageSelection.ALL) {
1159                 rbAll.setSelected(true);
1160             } else if (select == SunPageSelection.SELECTION) {
1161                 // Comment this for now -  rbSelect is not initialized
1162                 // because Selection button is not added.
1163                 // See PrintRangePanel above.
1164 
1165                 //rbSelect.setSelected(true);
1166             } else { // RANGE
1167                 rbPages.setSelected(true);
1168             }
1169             tfRangeFrom.setValue(min);
1170             tfRangeTo.setValue(max);
1171             rbAll.setEnabled(prSupported);
1172             rbPages.setEnabled(prSupported);
1173             setupRangeWidgets();
1174         }
1175     }
1176 
1177     @SuppressWarnings("serial") // Superclass is not serializable across versions
1178     private class CopiesPanel extends JPanel
1179         implements ActionListener, ChangeListener
1180     {
1181         private final String strTitle = getMsg("border.copies");
1182         private SpinnerNumberModel snModel;
1183         private JSpinner spinCopies;
1184         private JLabel lblCopies;
1185         private JCheckBox cbCollate;
1186         private boolean scSupported;
1187 
1188         public CopiesPanel() {
1189             super();
1190 
1191             GridBagLayout gridbag = new GridBagLayout();
1192             GridBagConstraints c = new GridBagConstraints();
1193 
1194             setLayout(gridbag);
1195             setBorder(BorderFactory.createTitledBorder(strTitle));
1196 
1197             c.fill = GridBagConstraints.HORIZONTAL;
1198             c.insets = compInsets;
1199 
1200             lblCopies = new JLabel(getMsg("label.numcopies"), JLabel.TRAILING);
1201             lblCopies.setDisplayedMnemonic(getMnemonic("label.numcopies"));
1202             lblCopies.getAccessibleContext().setAccessibleName(
1203                                              getMsg("label.numcopies"));
1204             addToGB(lblCopies, this, gridbag, c);
1205 
1206             snModel = new SpinnerNumberModel(1, 1, 999, 1);
1207             spinCopies = new JSpinner(snModel);
1208             lblCopies.setLabelFor(spinCopies);
1209             // REMIND
1210             ((JSpinner.NumberEditor)spinCopies.getEditor()).getTextField().setColumns(3);
1211             spinCopies.addChangeListener(this);
1212             c.gridwidth = GridBagConstraints.REMAINDER;
1213             addToGB(spinCopies, this, gridbag, c);
1214 
1215             cbCollate = createCheckBox("checkbox.collate", this);
1216             cbCollate.setEnabled(false);
1217             addToGB(cbCollate, this, gridbag, c);
1218         }
1219 
1220         public void actionPerformed(ActionEvent e) {
1221             if (cbCollate.isSelected()) {
1222                 asCurrent.add(SheetCollate.COLLATED);
1223             } else {
1224                 asCurrent.add(SheetCollate.UNCOLLATED);
1225             }
1226         }
1227 
1228         public void stateChanged(ChangeEvent e) {
1229             updateCollateCB();
1230 
1231             asCurrent.add(new Copies(snModel.getNumber().intValue()));
1232         }
1233 
1234         private void updateCollateCB() {
1235             int num = snModel.getNumber().intValue();
1236             if (isAWT) {
1237                 cbCollate.setEnabled(true);
1238             } else {
1239                 cbCollate.setEnabled((num > 1) && scSupported);
1240             }
1241         }
1242 
1243         public void updateInfo() {
1244             Class<Copies> cpCategory = Copies.class;
1245             Class<SheetCollate> scCategory = SheetCollate.class;
1246             boolean cpSupported = false;
1247             scSupported = false;
1248 
1249             // setup Copies spinner
1250             if (psCurrent.isAttributeCategorySupported(cpCategory)) {
1251                 cpSupported = true;
1252             }
1253             CopiesSupported cs =
1254                 (CopiesSupported)psCurrent.getSupportedAttributeValues(
1255                                                        cpCategory, null, null);
1256             if (cs == null) {
1257                 cs = new CopiesSupported(1, 999);
1258             }
1259             Copies cp = (Copies)asCurrent.get(cpCategory);
1260             if (cp == null) {
1261                 cp = (Copies)psCurrent.getDefaultAttributeValue(cpCategory);
1262                 if (cp == null) {
1263                     cp = new Copies(1);
1264                 }
1265             }
1266             spinCopies.setEnabled(cpSupported);
1267             lblCopies.setEnabled(cpSupported);
1268 
1269             int[][] members = cs.getMembers();
1270             int min, max;
1271             if ((members.length > 0) && (members[0].length > 0)) {
1272                 min = members[0][0];
1273                 max = members[0][1];
1274             } else {
1275                 min = 1;
1276                 max = Integer.MAX_VALUE;
1277             }
1278             snModel.setMinimum(min);
1279             snModel.setMaximum(max);
1280 
1281             int value = cp.getValue();
1282             if ((value < min) || (value > max)) {
1283                 value = min;
1284             }
1285             snModel.setValue(value);
1286 
1287             // setup Collate checkbox
1288             if (psCurrent.isAttributeCategorySupported(scCategory)) {
1289                 scSupported = true;
1290             }
1291             SheetCollate sc = (SheetCollate)asCurrent.get(scCategory);
1292             if (sc == null) {
1293                 sc = (SheetCollate)psCurrent.getDefaultAttributeValue(scCategory);
1294                 if (sc == null) {
1295                     sc = SheetCollate.UNCOLLATED;
1296                 }
1297             }
1298             cbCollate.setSelected(sc == SheetCollate.COLLATED);
1299             updateCollateCB();
1300         }
1301     }
1302 
1303 
1304 
1305 
1306     /**
1307      * The "Page Setup" tab.  Includes the controls for MediaSource/MediaTray,
1308      * OrientationRequested, and Sides.
1309      */
1310     @SuppressWarnings("serial") // Superclass is not serializable across versions
1311     private class PageSetupPanel extends JPanel {
1312 
1313         private MediaPanel pnlMedia;
1314         private OrientationPanel pnlOrientation;
1315         private MarginsPanel pnlMargins;
1316 
1317         public PageSetupPanel() {
1318             super();
1319 
1320             GridBagLayout gridbag = new GridBagLayout();
1321             GridBagConstraints c = new GridBagConstraints();
1322 
1323             setLayout(gridbag);
1324 
1325             c.fill = GridBagConstraints.BOTH;
1326             c.insets = panelInsets;
1327             c.weightx = 1.0;
1328             c.weighty = 1.0;
1329 
1330             c.gridwidth = GridBagConstraints.REMAINDER;
1331             pnlMedia = new MediaPanel();
1332             addToGB(pnlMedia, this, gridbag, c);
1333 
1334             pnlOrientation = new OrientationPanel();
1335             c.gridwidth = GridBagConstraints.RELATIVE;
1336             addToGB(pnlOrientation, this, gridbag, c);
1337 
1338             pnlMargins = new MarginsPanel();
1339             pnlOrientation.addOrientationListener(pnlMargins);
1340             pnlMedia.addMediaListener(pnlMargins);
1341             c.gridwidth = GridBagConstraints.REMAINDER;
1342             addToGB(pnlMargins, this, gridbag, c);
1343         }
1344 
1345         public void updateInfo() {
1346             pnlMedia.updateInfo();
1347             pnlOrientation.updateInfo();
1348             pnlMargins.updateInfo();
1349         }
1350     }
1351 
1352     @SuppressWarnings("serial") // Superclass is not serializable across versions
1353     private class MarginsPanel extends JPanel
1354                                implements ActionListener, FocusListener {
1355 
1356         private final String strTitle = getMsg("border.margins");
1357         private JFormattedTextField leftMargin, rightMargin,
1358                                     topMargin, bottomMargin;
1359         private JLabel lblLeft, lblRight, lblTop, lblBottom;
1360         private int units = MediaPrintableArea.MM;
1361         // storage for the last margin values calculated, -ve is uninitialised
1362         private float lmVal = -1f,rmVal = -1f, tmVal = -1f, bmVal = -1f;
1363         // storage for margins as objects mapped into orientation for display
1364         private Float lmObj,rmObj,tmObj,bmObj;
1365 
1366         public MarginsPanel() {
1367             super();
1368 
1369             GridBagLayout gridbag = new GridBagLayout();
1370             GridBagConstraints c = new GridBagConstraints();
1371             c.fill = GridBagConstraints.HORIZONTAL;
1372             c.weightx = 1.0;
1373             c.weighty = 0.0;
1374             c.insets = compInsets;
1375 
1376             setLayout(gridbag);
1377             setBorder(BorderFactory.createTitledBorder(strTitle));
1378 
1379             String unitsKey = "label.millimetres";
1380             String defaultCountry = Locale.getDefault().getCountry();
1381             if (defaultCountry != null &&
1382                 (defaultCountry.equals("") ||
1383                  defaultCountry.equals(Locale.US.getCountry()) ||
1384                  defaultCountry.equals(Locale.CANADA.getCountry()))) {
1385                 unitsKey = "label.inches";
1386                 units = MediaPrintableArea.INCH;
1387             }
1388             String unitsMsg = getMsg(unitsKey);
1389 
1390             DecimalFormat format;
1391             if (units == MediaPrintableArea.MM) {
1392                 format = new DecimalFormat("###.##");
1393                 format.setMaximumIntegerDigits(3);
1394             } else {
1395                 format = new DecimalFormat("##.##");
1396                 format.setMaximumIntegerDigits(2);
1397             }
1398 
1399             format.setMinimumFractionDigits(1);
1400             format.setMaximumFractionDigits(2);
1401             format.setMinimumIntegerDigits(1);
1402             format.setParseIntegerOnly(false);
1403             format.setDecimalSeparatorAlwaysShown(true);
1404             NumberFormatter nf = new NumberFormatter(format);
1405             nf.setMinimum(Float.valueOf(0.0f));
1406             nf.setMaximum(Float.valueOf(999.0f));
1407             nf.setAllowsInvalid(true);
1408             nf.setCommitsOnValidEdit(true);
1409 
1410             leftMargin = new JFormattedTextField(nf);
1411             leftMargin.addFocusListener(this);
1412             leftMargin.addActionListener(this);
1413             leftMargin.getAccessibleContext().setAccessibleName(
1414                                               getMsg("label.leftmargin"));
1415             rightMargin = new JFormattedTextField(nf);
1416             rightMargin.addFocusListener(this);
1417             rightMargin.addActionListener(this);
1418             rightMargin.getAccessibleContext().setAccessibleName(
1419                                               getMsg("label.rightmargin"));
1420             topMargin = new JFormattedTextField(nf);
1421             topMargin.addFocusListener(this);
1422             topMargin.addActionListener(this);
1423             topMargin.getAccessibleContext().setAccessibleName(
1424                                               getMsg("label.topmargin"));
1425 
1426             bottomMargin = new JFormattedTextField(nf);
1427             bottomMargin.addFocusListener(this);
1428             bottomMargin.addActionListener(this);
1429             bottomMargin.getAccessibleContext().setAccessibleName(
1430                                               getMsg("label.bottommargin"));
1431 
1432             c.gridwidth = GridBagConstraints.RELATIVE;
1433             lblLeft = new JLabel(getMsg("label.leftmargin") + " " + unitsMsg,
1434                                  JLabel.LEADING);
1435             lblLeft.setDisplayedMnemonic(getMnemonic("label.leftmargin"));
1436             lblLeft.setLabelFor(leftMargin);
1437             addToGB(lblLeft, this, gridbag, c);
1438 
1439             c.gridwidth = GridBagConstraints.REMAINDER;
1440             lblRight = new JLabel(getMsg("label.rightmargin") + " " + unitsMsg,
1441                                   JLabel.LEADING);
1442             lblRight.setDisplayedMnemonic(getMnemonic("label.rightmargin"));
1443             lblRight.setLabelFor(rightMargin);
1444             addToGB(lblRight, this, gridbag, c);
1445 
1446             c.gridwidth = GridBagConstraints.RELATIVE;
1447             addToGB(leftMargin, this, gridbag, c);
1448 
1449             c.gridwidth = GridBagConstraints.REMAINDER;
1450             addToGB(rightMargin, this, gridbag, c);
1451 
1452             // add an invisible spacing component.
1453             addToGB(new JPanel(), this, gridbag, c);
1454 
1455             c.gridwidth = GridBagConstraints.RELATIVE;
1456             lblTop = new JLabel(getMsg("label.topmargin") + " " + unitsMsg,
1457                                 JLabel.LEADING);
1458             lblTop.setDisplayedMnemonic(getMnemonic("label.topmargin"));
1459             lblTop.setLabelFor(topMargin);
1460             addToGB(lblTop, this, gridbag, c);
1461 
1462             c.gridwidth = GridBagConstraints.REMAINDER;
1463             lblBottom = new JLabel(getMsg("label.bottommargin") +
1464                                    " " + unitsMsg, JLabel.LEADING);
1465             lblBottom.setDisplayedMnemonic(getMnemonic("label.bottommargin"));
1466             lblBottom.setLabelFor(bottomMargin);
1467             addToGB(lblBottom, this, gridbag, c);
1468 
1469             c.gridwidth = GridBagConstraints.RELATIVE;
1470             addToGB(topMargin, this, gridbag, c);
1471 
1472             c.gridwidth = GridBagConstraints.REMAINDER;
1473             addToGB(bottomMargin, this, gridbag, c);
1474 
1475         }
1476 
1477         public void actionPerformed(ActionEvent e) {
1478             Object source = e.getSource();
1479             updateMargins(source);
1480         }
1481 
1482         public void focusLost(FocusEvent e) {
1483             Object source = e.getSource();
1484             updateMargins(source);
1485         }
1486 
1487         public void focusGained(FocusEvent e) {}
1488 
1489         /* Get the numbers, use to create a MPA.
1490          * If its valid, accept it and update the attribute set.
1491          * If its not valid, then reject it and call updateInfo()
1492          * to re-establish the previous entries.
1493          */
1494         public void updateMargins(Object source) {
1495             if (!(source instanceof JFormattedTextField)) {
1496                 return;
1497             } else {
1498                 JFormattedTextField tf = (JFormattedTextField)source;
1499                 Float val = (Float)tf.getValue();
1500                 if (val == null) {
1501                     return;
1502                 }
1503                 if (tf == leftMargin && val.equals(lmObj)) {
1504                     return;
1505                 }
1506                 if (tf == rightMargin && val.equals(rmObj)) {
1507                     return;
1508                 }
1509                 if (tf == topMargin && val.equals(tmObj)) {
1510                     return;
1511                 }
1512                 if (tf == bottomMargin && val.equals(bmObj)) {
1513                     return;
1514                 }
1515             }
1516 
1517             Float lmTmpObj = (Float)leftMargin.getValue();
1518             Float rmTmpObj = (Float)rightMargin.getValue();
1519             Float tmTmpObj = (Float)topMargin.getValue();
1520             Float bmTmpObj = (Float)bottomMargin.getValue();
1521 
1522             float lm = lmTmpObj.floatValue();
1523             float rm = rmTmpObj.floatValue();
1524             float tm = tmTmpObj.floatValue();
1525             float bm = bmTmpObj.floatValue();
1526 
1527             /* adjust for orientation */
1528             Class<OrientationRequested> orCategory = OrientationRequested.class;
1529             OrientationRequested or =
1530                 (OrientationRequested)asCurrent.get(orCategory);
1531 
1532             if (or == null) {
1533                 or = (OrientationRequested)
1534                      psCurrent.getDefaultAttributeValue(orCategory);
1535             }
1536 
1537             float tmp;
1538             if (or == OrientationRequested.REVERSE_PORTRAIT) {
1539                 tmp = lm; lm = rm; rm = tmp;
1540                 tmp = tm; tm = bm; bm = tmp;
1541             } else if (or == OrientationRequested.LANDSCAPE) {
1542                 tmp = lm;
1543                 lm = tm;
1544                 tm = rm;
1545                 rm = bm;
1546                 bm = tmp;
1547             } else if (or == OrientationRequested.REVERSE_LANDSCAPE) {
1548                 tmp = lm;
1549                 lm = bm;
1550                 bm = rm;
1551                 rm = tm;
1552                 tm = tmp;
1553             }
1554             MediaPrintableArea mpa;
1555             if ((mpa = validateMargins(lm, rm, tm, bm)) != null) {
1556                 asCurrent.add(mpa);
1557                 lmVal = lm;
1558                 rmVal = rm;
1559                 tmVal = tm;
1560                 bmVal = bm;
1561                 lmObj = lmTmpObj;
1562                 rmObj = rmTmpObj;
1563                 tmObj = tmTmpObj;
1564                 bmObj = bmTmpObj;
1565             } else {
1566                 if (lmObj == null || rmObj == null ||
1567                     tmObj == null || bmObj == null) {
1568                     return;
1569                 } else {
1570                     leftMargin.setValue(lmObj);
1571                     rightMargin.setValue(rmObj);
1572                     topMargin.setValue(tmObj);
1573                     bottomMargin.setValue(bmObj);
1574 
1575                 }
1576             }
1577         }
1578 
1579         /*
1580          * This method either accepts the values and creates a new
1581          * MediaPrintableArea, or does nothing.
1582          * It should not attempt to create a printable area from anything
1583          * other than the exact values passed in.
1584          * But REMIND/TBD: it would be user friendly to replace margins the
1585          * user entered but are out of bounds with the minimum.
1586          * At that point this method will need to take responsibility for
1587          * updating the "stored" values and the UI.
1588          */
1589         private MediaPrintableArea validateMargins(float lm, float rm,
1590                                                    float tm, float bm) {
1591 
1592             Class<MediaPrintableArea> mpaCategory = MediaPrintableArea.class;
1593             MediaPrintableArea mpa;
1594             MediaPrintableArea mpaMax = null;
1595             MediaSize mediaSize = null;
1596 
1597             Media media = (Media)asCurrent.get(Media.class);
1598             if (media == null || !(media instanceof MediaSizeName)) {
1599                 media = (Media)psCurrent.getDefaultAttributeValue(Media.class);
1600             }
1601             if (media != null && (media instanceof MediaSizeName)) {
1602                 MediaSizeName msn = (MediaSizeName)media;
1603                 mediaSize = MediaSize.getMediaSizeForName(msn);
1604             }
1605             if (mediaSize == null) {
1606                 mediaSize = new MediaSize(8.5f, 11f, Size2DSyntax.INCH);
1607             }
1608 
1609             if (media != null) {
1610                 PrintRequestAttributeSet tmpASet =
1611                     new HashPrintRequestAttributeSet(asCurrent);
1612                 tmpASet.add(media);
1613 
1614                 Object values =
1615                     psCurrent.getSupportedAttributeValues(mpaCategory,
1616                                                           docFlavor,
1617                                                           tmpASet);
1618                 if (values instanceof MediaPrintableArea[] &&
1619                     ((MediaPrintableArea[])values).length > 0) {
1620                     mpaMax = ((MediaPrintableArea[])values)[0];
1621 
1622                 }
1623             }
1624             if (mpaMax == null) {
1625                 mpaMax = new MediaPrintableArea(0f, 0f,
1626                                                 mediaSize.getX(units),
1627                                                 mediaSize.getY(units),
1628                                                 units);
1629             }
1630 
1631             float wid = mediaSize.getX(units);
1632             float hgt = mediaSize.getY(units);
1633             float pax = lm;
1634             float pay = tm;
1635             float par = rm;
1636             float pab = bm;
1637             float paw = wid - lm - rm;
1638             float pah = hgt - tm - bm;
1639 
1640             if (paw <= 0f || pah <= 0f || pax < 0f || pay < 0f ||
1641                 par <= 0f || pab <= 0f || 
1642                 pax < mpaMax.getX(units) || paw > mpaMax.getWidth(units) ||
1643                 pay < mpaMax.getY(units) || pah > mpaMax.getHeight(units)) {
1644                 return null;
1645             } else {
1646                 return new MediaPrintableArea(lm, tm, paw, pah, units);
1647             }
1648         }
1649 
1650         /* This is complex as a MediaPrintableArea is valid only within
1651          * a particular context of media size.
1652          * So we need a MediaSize as well as a MediaPrintableArea.
1653          * MediaSize can be obtained from MediaSizeName.
1654          * If the application specifies a MediaPrintableArea, we accept it
1655          * to the extent its valid for the Media they specify. If they
1656          * don't specify a Media, then the default is assumed.
1657          *
1658          * If an application doesn't define a MediaPrintableArea, we need to
1659          * create a suitable one, this is created using the specified (or
1660          * default) Media and default 1 inch margins. This is validated
1661          * against the paper in case this is too large for tiny media.
1662          */
1663         public void updateInfo() {
1664 
1665             if (isAWT) {
1666                 leftMargin.setEnabled(false);
1667                 rightMargin.setEnabled(false);
1668                 topMargin.setEnabled(false);
1669                 bottomMargin.setEnabled(false);
1670                 lblLeft.setEnabled(false);
1671                 lblRight.setEnabled(false);
1672                 lblTop.setEnabled(false);
1673                 lblBottom.setEnabled(false);
1674                 return;
1675             }
1676 
1677             Class<MediaPrintableArea> mpaCategory = MediaPrintableArea.class;
1678             MediaPrintableArea mpa =
1679                  (MediaPrintableArea)asCurrent.get(mpaCategory);
1680             MediaPrintableArea mpaMax = null;
1681             MediaSize mediaSize = null;
1682 
1683             Media media = (Media)asCurrent.get(Media.class);
1684             if (media == null || !(media instanceof MediaSizeName)) {
1685                 media = (Media)psCurrent.getDefaultAttributeValue(Media.class);
1686             }
1687             if (media != null && (media instanceof MediaSizeName)) {
1688                 MediaSizeName msn = (MediaSizeName)media;
1689                 mediaSize = MediaSize.getMediaSizeForName(msn);
1690             }
1691             if (mediaSize == null) {
1692                 mediaSize = new MediaSize(8.5f, 11f, Size2DSyntax.INCH);
1693             }
1694 
1695             if (media != null) {
1696                 PrintRequestAttributeSet tmpASet =
1697                     new HashPrintRequestAttributeSet(asCurrent);
1698                 tmpASet.add(media);
1699 
1700                 Object values =
1701                     psCurrent.getSupportedAttributeValues(mpaCategory,
1702                                                           docFlavor,
1703                                                           tmpASet);
1704                 if (values instanceof MediaPrintableArea[] &&
1705                     ((MediaPrintableArea[])values).length > 0) {
1706                     mpaMax = ((MediaPrintableArea[])values)[0];
1707 
1708                 } else if (values instanceof MediaPrintableArea) {
1709                     mpaMax = (MediaPrintableArea)values;
1710                 }
1711             }
1712             if (mpaMax == null) {
1713                 mpaMax = new MediaPrintableArea(0f, 0f,
1714                                                 mediaSize.getX(units),
1715                                                 mediaSize.getY(units),
1716                                                 units);
1717             }
1718 
1719             /*
1720              * At this point we now know as best we can :-
1721              * - the media size
1722              * - the maximum corresponding printable area
1723              * - the media printable area specified by the client, if any.
1724              * The next step is to create a default MPA if none was specified.
1725              * 1" margins are used unless they are disproportionately
1726              * large compared to the size of the media.
1727              */
1728 
1729             float wid = mediaSize.getX(MediaPrintableArea.INCH);
1730             float hgt = mediaSize.getY(MediaPrintableArea.INCH);
1731             float maxMarginRatio = 5f;
1732             float xMgn, yMgn;
1733             if (wid > maxMarginRatio) {
1734                 xMgn = 1f;
1735             } else {
1736                 xMgn = wid / maxMarginRatio;
1737             }
1738             if (hgt > maxMarginRatio) {
1739                 yMgn = 1f;
1740             } else {
1741                 yMgn = hgt / maxMarginRatio;
1742             }
1743 
1744             if (mpa == null) {
1745                 mpa = new MediaPrintableArea(xMgn, yMgn,
1746                                              wid-(2*xMgn), hgt-(2*yMgn),
1747                                              MediaPrintableArea.INCH);
1748                 asCurrent.add(mpa);
1749             }
1750             float pax = mpa.getX(units);
1751             float pay = mpa.getY(units);
1752             float paw = mpa.getWidth(units);
1753             float pah = mpa.getHeight(units);
1754             float paxMax = mpaMax.getX(units);
1755             float payMax = mpaMax.getY(units);
1756             float pawMax = mpaMax.getWidth(units);
1757             float pahMax = mpaMax.getHeight(units);
1758 
1759 
1760             boolean invalid = false;
1761 
1762             // If the paper is set to something which is too small to
1763             // accommodate a specified printable area, perhaps carried
1764             // over from a larger paper, the adjustment that needs to be
1765             // performed should seem the most natural from a user's viewpoint.
1766             // Since the user is specifying margins, then we are biased
1767             // towards keeping the margins as close to what is specified as
1768             // possible, shrinking or growing the printable area.
1769             // But the API uses printable area, so you need to know the
1770             // media size in which the margins were previously interpreted,
1771             // or at least have a record of the margins.
1772             // In the case that this is the creation of this UI we do not
1773             // have this record, so we are somewhat reliant on the client
1774             // to supply a reasonable default
1775             wid = mediaSize.getX(units);
1776             hgt = mediaSize.getY(units);
1777             if (lmVal >= 0f) {
1778                 invalid = true;
1779 
1780                 if (lmVal + rmVal > wid) {
1781                     // margins impossible, but maintain P.A if can
1782                     if (paw > pawMax) {
1783                         paw = pawMax;
1784                     }
1785                     // try to centre the printable area.
1786                     pax = (wid - paw)/2f;
1787                 } else {
1788                     pax = (lmVal >= paxMax) ? lmVal : paxMax;
1789                     paw = wid - pax - rmVal;
1790                 }
1791                 if (tmVal + bmVal > hgt) {
1792                     if (pah > pahMax) {
1793                         pah = pahMax;
1794                     }
1795                     pay = (hgt - pah)/2f;
1796                 } else {
1797                     pay = (tmVal >= payMax) ? tmVal : payMax;
1798                     pah = hgt - pay - bmVal;
1799                 }
1800             }
1801             if (pax < paxMax) {
1802                 invalid = true;
1803                 pax = paxMax;
1804             }
1805             if (pay < payMax) {
1806                 invalid = true;
1807                 pay = payMax;
1808             }
1809             if (paw > pawMax) {
1810                 invalid = true;
1811                 paw = pawMax;
1812             }
1813             if (pah > pahMax) {
1814                 invalid = true;
1815                 pah = pahMax;
1816             }
1817 
1818             if ((pax + paw > paxMax + pawMax) || (paw <= 0f)) {
1819                 invalid = true;
1820                 pax = paxMax;
1821                 paw = pawMax;
1822             }
1823             if ((pay + pah > payMax + pahMax) || (pah <= 0f)) {
1824                 invalid = true;
1825                 pay = payMax;
1826                 pah = pahMax;
1827             }
1828 
1829             if (invalid) {
1830                 mpa = new MediaPrintableArea(pax, pay, paw, pah, units);
1831                 asCurrent.add(mpa);
1832             }
1833 
1834             /* We now have a valid printable area.
1835              * Turn it into margins, using the mediaSize
1836              */
1837             lmVal = pax;
1838             tmVal = pay;
1839             rmVal = mediaSize.getX(units) - pax - paw;
1840             bmVal = mediaSize.getY(units) - pay - pah;
1841 
1842             lmObj = lmVal;
1843             rmObj = rmVal;
1844             tmObj = tmVal;
1845             bmObj = bmVal;
1846 
1847             /* Now we know the values to use, we need to assign them
1848              * to the fields appropriate for the orientation.
1849              * Note: if orientation changes this method must be called.
1850              */
1851             Class<OrientationRequested> orCategory = OrientationRequested.class;
1852             OrientationRequested or =
1853                 (OrientationRequested)asCurrent.get(orCategory);
1854 
1855             if (or == null) {
1856                 or = (OrientationRequested)
1857                      psCurrent.getDefaultAttributeValue(orCategory);
1858             }
1859 
1860             Float tmp;
1861 
1862             if (or == OrientationRequested.REVERSE_PORTRAIT) {
1863                 tmp = lmObj; lmObj = rmObj; rmObj = tmp;
1864                 tmp = tmObj; tmObj = bmObj; bmObj = tmp;
1865             }  else if (or == OrientationRequested.LANDSCAPE) {
1866                 tmp = lmObj;
1867                 lmObj = bmObj;
1868                 bmObj = rmObj;
1869                 rmObj = tmObj;
1870                 tmObj = tmp;
1871             }  else if (or == OrientationRequested.REVERSE_LANDSCAPE) {
1872                 tmp = lmObj;
1873                 lmObj = tmObj;
1874                 tmObj = rmObj;
1875                 rmObj = bmObj;
1876                 bmObj = tmp;
1877             }
1878 
1879             leftMargin.setValue(lmObj);
1880             rightMargin.setValue(rmObj);
1881             topMargin.setValue(tmObj);
1882             bottomMargin.setValue(bmObj);
1883         }
1884     }
1885 
1886     @SuppressWarnings("serial") // Superclass is not serializable across versions
1887     private class MediaPanel extends JPanel implements ItemListener {
1888 
1889         private final String strTitle = getMsg("border.media");
1890         private JLabel lblSize, lblSource;
1891         private JComboBox<Object> cbSize, cbSource;
1892         private Vector<MediaSizeName> sizes = new Vector<>();
1893         private Vector<MediaTray> sources = new Vector<>();
1894         private MarginsPanel pnlMargins = null;
1895 
1896         public MediaPanel() {
1897             super();
1898 
1899             GridBagLayout gridbag = new GridBagLayout();
1900             GridBagConstraints c = new GridBagConstraints();
1901 
1902             setLayout(gridbag);
1903             setBorder(BorderFactory.createTitledBorder(strTitle));
1904 
1905             cbSize = new JComboBox<>();
1906             cbSource = new JComboBox<>();
1907 
1908             c.fill = GridBagConstraints.BOTH;
1909             c.insets = compInsets;
1910             c.weighty = 1.0;
1911 
1912             c.weightx = 0.0;
1913             lblSize = new JLabel(getMsg("label.size"), JLabel.TRAILING);
1914             lblSize.setDisplayedMnemonic(getMnemonic("label.size"));
1915             lblSize.setLabelFor(cbSize);
1916             addToGB(lblSize, this, gridbag, c);
1917             c.weightx = 1.0;
1918             c.gridwidth = GridBagConstraints.REMAINDER;
1919             addToGB(cbSize, this, gridbag, c);
1920 
1921             c.weightx = 0.0;
1922             c.gridwidth = 1;
1923             lblSource = new JLabel(getMsg("label.source"), JLabel.TRAILING);
1924             lblSource.setDisplayedMnemonic(getMnemonic("label.source"));
1925             lblSource.setLabelFor(cbSource);
1926             addToGB(lblSource, this, gridbag, c);
1927             c.gridwidth = GridBagConstraints.REMAINDER;
1928             addToGB(cbSource, this, gridbag, c);
1929         }
1930 
1931         private String getMediaName(String key) {
1932             try {
1933                 // replace characters that would be invalid in
1934                 // a resource key with valid characters
1935                 String newkey = key.replace(' ', '-');
1936                 newkey = newkey.replace('#', 'n');
1937 
1938                 return messageRB.getString(newkey);
1939             } catch (java.util.MissingResourceException e) {
1940                 return key;
1941             }
1942         }
1943 
1944         public void itemStateChanged(ItemEvent e) {
1945             Object source = e.getSource();
1946 
1947             if (e.getStateChange() == ItemEvent.SELECTED) {
1948                 if (source == cbSize) {
1949                     int index = cbSize.getSelectedIndex();
1950 
1951                     if ((index >= 0) && (index < sizes.size())) {
1952                         if ((cbSource.getItemCount() > 1) &&
1953                             (cbSource.getSelectedIndex() >= 1))
1954                         {
1955                             int src = cbSource.getSelectedIndex() - 1;
1956                             MediaTray mt = sources.get(src);
1957                             asCurrent.add(new SunAlternateMedia(mt));
1958                         }
1959                         asCurrent.add(sizes.get(index));
1960                     }
1961                 } else if (source == cbSource) {
1962                     int index = cbSource.getSelectedIndex();
1963 
1964                     if ((index >= 1) && (index < (sources.size() + 1))) {
1965                        asCurrent.remove(SunAlternateMedia.class);
1966                        MediaTray newTray = sources.get(index - 1);
1967                        Media m = (Media)asCurrent.get(Media.class);
1968                        if (m == null || m instanceof MediaTray) {
1969                            asCurrent.add(newTray);
1970                        } else if (m instanceof MediaSizeName) {
1971                            MediaSizeName msn = (MediaSizeName)m;
1972                            Media def = (Media)psCurrent.getDefaultAttributeValue(Media.class);
1973                            if (def instanceof MediaSizeName && def.equals(msn)) {
1974                                asCurrent.add(newTray);
1975                            } else {
1976                                /* Non-default paper size, so need to store tray
1977                                 * as SunAlternateMedia
1978                                 */
1979                                asCurrent.add(new SunAlternateMedia(newTray));
1980                            }
1981                        }
1982                     } else if (index == 0) {
1983                         asCurrent.remove(SunAlternateMedia.class);
1984                         if (cbSize.getItemCount() > 0) {
1985                             int size = cbSize.getSelectedIndex();
1986                             asCurrent.add(sizes.get(size));
1987                         }
1988                     }
1989                 }
1990             // orientation affects display of margins.
1991                 if (pnlMargins != null) {
1992                     pnlMargins.updateInfo();
1993                 }
1994             }
1995         }
1996 
1997 
1998         /* this is ad hoc to keep things simple */
1999         public void addMediaListener(MarginsPanel pnl) {
2000             pnlMargins = pnl;
2001         }
2002         public void updateInfo() {
2003             Class<Media> mdCategory = Media.class;
2004             Class<SunAlternateMedia> amCategory = SunAlternateMedia.class;
2005             boolean mediaSupported = false;
2006 
2007             cbSize.removeItemListener(this);
2008             cbSize.removeAllItems();
2009             cbSource.removeItemListener(this);
2010             cbSource.removeAllItems();
2011             cbSource.addItem(getMediaName("auto-select"));
2012 
2013             sizes.clear();
2014             sources.clear();
2015 
2016             if (psCurrent.isAttributeCategorySupported(mdCategory)) {
2017                 mediaSupported = true;
2018 
2019                 Object values =
2020                     psCurrent.getSupportedAttributeValues(mdCategory,
2021                                                           docFlavor,
2022                                                           asCurrent);
2023 
2024                 if (values instanceof Media[]) {
2025                     Media[] media = (Media[])values;
2026 
2027                     for (int i = 0; i < media.length; i++) {
2028                         Media medium = media[i];
2029 
2030                         if (medium instanceof MediaSizeName) {
2031                             sizes.add((MediaSizeName)medium);
2032                             cbSize.addItem(getMediaName(medium.toString()));
2033                         } else if (medium instanceof MediaTray) {
2034                             sources.add((MediaTray)medium);
2035                             cbSource.addItem(getMediaName(medium.toString()));
2036                         }
2037                     }
2038                 }
2039             }
2040 
2041             boolean msSupported = (mediaSupported && (sizes.size() > 0));
2042             lblSize.setEnabled(msSupported);
2043             cbSize.setEnabled(msSupported);
2044 
2045             if (isAWT) {
2046                 cbSource.setEnabled(false);
2047                 lblSource.setEnabled(false);
2048             } else {
2049                 cbSource.setEnabled(mediaSupported);
2050             }
2051 
2052             if (mediaSupported) {
2053 
2054                 Media medium = (Media)asCurrent.get(mdCategory);
2055 
2056                // initialize size selection to default
2057                 Media defMedia = (Media)psCurrent.getDefaultAttributeValue(mdCategory);
2058                 if (defMedia instanceof MediaSizeName) {
2059                     cbSize.setSelectedIndex(sizes.size() > 0 ? sizes.indexOf(defMedia) : -1);
2060                 }
2061 
2062                 if (medium == null ||
2063                     !psCurrent.isAttributeValueSupported(medium,
2064                                                          docFlavor, asCurrent)) {
2065 
2066                     medium = defMedia;
2067 
2068                     if (medium == null) {
2069                         if (sizes.size() > 0) {
2070                             medium = (Media)sizes.get(0);
2071                         }
2072                     }
2073                     if (medium != null) {
2074                         asCurrent.add(medium);
2075                     }
2076                 }
2077                 if (medium != null) {
2078                     if (medium instanceof MediaSizeName) {
2079                         MediaSizeName ms = (MediaSizeName)medium;
2080                         cbSize.setSelectedIndex(sizes.indexOf(ms));
2081                     } else if (medium instanceof MediaTray) {
2082                         MediaTray mt = (MediaTray)medium;
2083                         cbSource.setSelectedIndex(sources.indexOf(mt) + 1);
2084                     }
2085                 } else {
2086                     cbSize.setSelectedIndex(sizes.size() > 0 ? 0 : -1);
2087                     cbSource.setSelectedIndex(0);
2088                 }
2089 
2090                 SunAlternateMedia alt = (SunAlternateMedia)asCurrent.get(amCategory);
2091                 if (alt != null) {
2092                     Media md = alt.getMedia();
2093                     if (md instanceof MediaTray) {
2094                         MediaTray mt = (MediaTray)md;
2095                         cbSource.setSelectedIndex(sources.indexOf(mt) + 1);
2096                     }
2097                 }
2098 
2099                 int selIndex = cbSize.getSelectedIndex();
2100                 if ((selIndex >= 0) && (selIndex < sizes.size())) {
2101                   asCurrent.add(sizes.get(selIndex));
2102                 }
2103 
2104                 selIndex = cbSource.getSelectedIndex();
2105                 if ((selIndex >= 1) && (selIndex < (sources.size()+1))) {
2106                     MediaTray mt = sources.get(selIndex-1);
2107                     if (medium instanceof MediaTray) {
2108                         asCurrent.add(mt);
2109                     } else {
2110                         asCurrent.add(new SunAlternateMedia(mt));
2111                     }
2112                 }
2113 
2114 
2115             }
2116             cbSize.addItemListener(this);
2117             cbSource.addItemListener(this);
2118         }
2119     }
2120 
2121     @SuppressWarnings("serial") // Superclass is not serializable across versions
2122     private class OrientationPanel extends JPanel
2123         implements ActionListener
2124     {
2125         private final String strTitle = getMsg("border.orientation");
2126         private IconRadioButton rbPortrait, rbLandscape,
2127                                 rbRevPortrait, rbRevLandscape;
2128         private MarginsPanel pnlMargins = null;
2129 
2130         public OrientationPanel() {
2131             super();
2132 
2133             GridBagLayout gridbag = new GridBagLayout();
2134             GridBagConstraints c = new GridBagConstraints();
2135 
2136             setLayout(gridbag);
2137             setBorder(BorderFactory.createTitledBorder(strTitle));
2138 
2139             c.fill = GridBagConstraints.BOTH;
2140             c.insets = compInsets;
2141             c.weighty = 1.0;
2142             c.gridwidth = GridBagConstraints.REMAINDER;
2143 
2144             ButtonGroup bg = new ButtonGroup();
2145             rbPortrait = new IconRadioButton("radiobutton.portrait",
2146                                              "orientPortrait.png", true,
2147                                              bg, this);
2148             rbPortrait.addActionListener(this);
2149             addToGB(rbPortrait, this, gridbag, c);
2150             rbLandscape = new IconRadioButton("radiobutton.landscape",
2151                                               "orientLandscape.png", false,
2152                                               bg, this);
2153             rbLandscape.addActionListener(this);
2154             addToGB(rbLandscape, this, gridbag, c);
2155             rbRevPortrait = new IconRadioButton("radiobutton.revportrait",
2156                                                 "orientRevPortrait.png", false,
2157                                                 bg, this);
2158             rbRevPortrait.addActionListener(this);
2159             addToGB(rbRevPortrait, this, gridbag, c);
2160             rbRevLandscape = new IconRadioButton("radiobutton.revlandscape",
2161                                                  "orientRevLandscape.png", false,
2162                                                  bg, this);
2163             rbRevLandscape.addActionListener(this);
2164             addToGB(rbRevLandscape, this, gridbag, c);
2165         }
2166 
2167         public void actionPerformed(ActionEvent e) {
2168             Object source = e.getSource();
2169 
2170             if (rbPortrait.isSameAs(source)) {
2171                 asCurrent.add(OrientationRequested.PORTRAIT);
2172             } else if (rbLandscape.isSameAs(source)) {
2173                 asCurrent.add(OrientationRequested.LANDSCAPE);
2174             } else if (rbRevPortrait.isSameAs(source)) {
2175                 asCurrent.add(OrientationRequested.REVERSE_PORTRAIT);
2176             } else if (rbRevLandscape.isSameAs(source)) {
2177                 asCurrent.add(OrientationRequested.REVERSE_LANDSCAPE);
2178             }
2179             // orientation affects display of margins.
2180             if (pnlMargins != null) {
2181                 pnlMargins.updateInfo();
2182             }
2183         }
2184 
2185         /* This is ad hoc to keep things simple */
2186         void addOrientationListener(MarginsPanel pnl) {
2187             pnlMargins = pnl;
2188         }
2189 
2190         public void updateInfo() {
2191             Class<OrientationRequested> orCategory = OrientationRequested.class;
2192             boolean pSupported = false;
2193             boolean lSupported = false;
2194             boolean rpSupported = false;
2195             boolean rlSupported = false;
2196 
2197             if (isAWT) {
2198                 pSupported = true;
2199                 lSupported = true;
2200             } else
2201             if (psCurrent.isAttributeCategorySupported(orCategory)) {
2202                 Object values =
2203                     psCurrent.getSupportedAttributeValues(orCategory,
2204                                                           docFlavor,
2205                                                           asCurrent);
2206 
2207                 if (values instanceof OrientationRequested[]) {
2208                     OrientationRequested[] ovalues =
2209                         (OrientationRequested[])values;
2210 
2211                     for (int i = 0; i < ovalues.length; i++) {
2212                         OrientationRequested value = ovalues[i];
2213 
2214                         if (value == OrientationRequested.PORTRAIT) {
2215                             pSupported = true;
2216                         } else if (value == OrientationRequested.LANDSCAPE) {
2217                             lSupported = true;
2218                         } else if (value == OrientationRequested.REVERSE_PORTRAIT) {
2219                             rpSupported = true;
2220                         } else if (value == OrientationRequested.REVERSE_LANDSCAPE) {
2221                             rlSupported = true;
2222                         }
2223                     }
2224                 }
2225             }
2226 
2227 
2228             rbPortrait.setEnabled(pSupported);
2229             rbLandscape.setEnabled(lSupported);
2230             rbRevPortrait.setEnabled(rpSupported);
2231             rbRevLandscape.setEnabled(rlSupported);
2232 
2233             OrientationRequested or = (OrientationRequested)asCurrent.get(orCategory);
2234             if (or == null ||
2235                 !psCurrent.isAttributeValueSupported(or, docFlavor, asCurrent)) {
2236 
2237                 or = (OrientationRequested)psCurrent.getDefaultAttributeValue(orCategory);
2238                 // need to validate if default is not supported
2239                 if ((or != null) &&
2240                    !psCurrent.isAttributeValueSupported(or, docFlavor, asCurrent)) {
2241                     or = null;
2242                     Object values =
2243                         psCurrent.getSupportedAttributeValues(orCategory,
2244                                                               docFlavor,
2245                                                               asCurrent);
2246                     if (values instanceof OrientationRequested[]) {
2247                         OrientationRequested[] orValues =
2248                                             (OrientationRequested[])values;
2249                         if (orValues.length > 1) {
2250                             // get the first in the list
2251                             or = orValues[0];
2252                         }
2253                     }
2254                 }
2255 
2256                 if (or == null) {
2257                     or = OrientationRequested.PORTRAIT;
2258                 }
2259                 asCurrent.add(or);
2260             }
2261 
2262             if (or == OrientationRequested.PORTRAIT) {
2263                 rbPortrait.setSelected(true);
2264             } else if (or == OrientationRequested.LANDSCAPE) {
2265                 rbLandscape.setSelected(true);
2266             } else if (or == OrientationRequested.REVERSE_PORTRAIT) {
2267                 rbRevPortrait.setSelected(true);
2268             } else { // if (or == OrientationRequested.REVERSE_LANDSCAPE)
2269                 rbRevLandscape.setSelected(true);
2270             }
2271         }
2272     }
2273 
2274 
2275 
2276     /**
2277      * The "Appearance" tab.  Includes the controls for Chromaticity,
2278      * PrintQuality, JobPriority, JobName, and other related job attributes.
2279      */
2280     @SuppressWarnings("serial") // Superclass is not serializable across versions
2281     private class AppearancePanel extends JPanel {
2282 
2283         private ChromaticityPanel pnlChromaticity;
2284         private QualityPanel pnlQuality;
2285         private JobAttributesPanel pnlJobAttributes;
2286         private SidesPanel pnlSides;
2287 
2288         public AppearancePanel() {
2289             super();
2290 
2291             GridBagLayout gridbag = new GridBagLayout();
2292             GridBagConstraints c = new GridBagConstraints();
2293 
2294             setLayout(gridbag);
2295 
2296             c.fill = GridBagConstraints.BOTH;
2297             c.insets = panelInsets;
2298             c.weightx = 1.0;
2299             c.weighty = 1.0;
2300 
2301             c.gridwidth = GridBagConstraints.RELATIVE;
2302             pnlChromaticity = new ChromaticityPanel();
2303             addToGB(pnlChromaticity, this, gridbag, c);
2304 
2305             c.gridwidth = GridBagConstraints.REMAINDER;
2306             pnlQuality = new QualityPanel();
2307             addToGB(pnlQuality, this, gridbag, c);
2308 
2309             c.gridwidth = 1;
2310             pnlSides = new SidesPanel();
2311             addToGB(pnlSides, this, gridbag, c);
2312 
2313             c.gridwidth = GridBagConstraints.REMAINDER;
2314             pnlJobAttributes = new JobAttributesPanel();
2315             addToGB(pnlJobAttributes, this, gridbag, c);
2316 
2317         }
2318 
2319         public void updateInfo() {
2320             pnlChromaticity.updateInfo();
2321             pnlQuality.updateInfo();
2322             pnlSides.updateInfo();
2323             pnlJobAttributes.updateInfo();
2324         }
2325     }
2326 
2327     @SuppressWarnings("serial") // Superclass is not serializable across versions
2328     private class ChromaticityPanel extends JPanel
2329         implements ActionListener
2330     {
2331         private final String strTitle = getMsg("border.chromaticity");
2332         private JRadioButton rbMonochrome, rbColor;
2333 
2334         public ChromaticityPanel() {
2335             super();
2336 
2337             GridBagLayout gridbag = new GridBagLayout();
2338             GridBagConstraints c = new GridBagConstraints();
2339 
2340             setLayout(gridbag);
2341             setBorder(BorderFactory.createTitledBorder(strTitle));
2342 
2343             c.fill = GridBagConstraints.BOTH;
2344             c.gridwidth = GridBagConstraints.REMAINDER;
2345             c.weighty = 1.0;
2346 
2347             ButtonGroup bg = new ButtonGroup();
2348             rbMonochrome = createRadioButton("radiobutton.monochrome", this);
2349             rbMonochrome.setSelected(true);
2350             bg.add(rbMonochrome);
2351             addToGB(rbMonochrome, this, gridbag, c);
2352             rbColor = createRadioButton("radiobutton.color", this);
2353             bg.add(rbColor);
2354             addToGB(rbColor, this, gridbag, c);
2355         }
2356 
2357         public void actionPerformed(ActionEvent e) {
2358             Object source = e.getSource();
2359 
2360             // REMIND: use isSameAs if we move to a IconRB in the future
2361             if (source == rbMonochrome) {
2362                 asCurrent.add(Chromaticity.MONOCHROME);
2363             } else if (source == rbColor) {
2364                 asCurrent.add(Chromaticity.COLOR);
2365             }
2366         }
2367 
2368         public void updateInfo() {
2369             Class<Chromaticity> chCategory = Chromaticity.class;
2370             boolean monoSupported = false;
2371             boolean colorSupported = false;
2372 
2373             if (isAWT) {
2374                 monoSupported = true;
2375                 colorSupported = true;
2376             } else
2377             if (psCurrent.isAttributeCategorySupported(chCategory)) {
2378                 Object values =
2379                     psCurrent.getSupportedAttributeValues(chCategory,
2380                                                           docFlavor,
2381                                                           asCurrent);
2382 
2383                 if (values instanceof Chromaticity[]) {
2384                     Chromaticity[] cvalues = (Chromaticity[])values;
2385 
2386                     for (int i = 0; i < cvalues.length; i++) {
2387                         Chromaticity value = cvalues[i];
2388 
2389                         if (value == Chromaticity.MONOCHROME) {
2390                             monoSupported = true;
2391                         } else if (value == Chromaticity.COLOR) {
2392                             colorSupported = true;
2393                         }
2394                     }
2395                 }
2396             }
2397 
2398 
2399             rbMonochrome.setEnabled(monoSupported);
2400             rbColor.setEnabled(colorSupported);
2401 
2402             Chromaticity ch = (Chromaticity)asCurrent.get(chCategory);
2403             if (ch == null) {
2404                 ch = (Chromaticity)psCurrent.getDefaultAttributeValue(chCategory);
2405                 if (ch == null) {
2406                     ch = Chromaticity.MONOCHROME;
2407                 }
2408             }
2409 
2410             if (ch == Chromaticity.MONOCHROME) {
2411                 rbMonochrome.setSelected(true);
2412             } else { // if (ch == Chromaticity.COLOR)
2413                 rbColor.setSelected(true);
2414             }
2415         }
2416     }
2417 
2418     @SuppressWarnings("serial") // Superclass is not serializable across versions
2419     private class QualityPanel extends JPanel
2420         implements ActionListener
2421     {
2422         private final String strTitle = getMsg("border.quality");
2423         private JRadioButton rbDraft, rbNormal, rbHigh;
2424 
2425         public QualityPanel() {
2426             super();
2427 
2428             GridBagLayout gridbag = new GridBagLayout();
2429             GridBagConstraints c = new GridBagConstraints();
2430 
2431             setLayout(gridbag);
2432             setBorder(BorderFactory.createTitledBorder(strTitle));
2433 
2434             c.fill = GridBagConstraints.BOTH;
2435             c.gridwidth = GridBagConstraints.REMAINDER;
2436             c.weighty = 1.0;
2437 
2438             ButtonGroup bg = new ButtonGroup();
2439             rbDraft = createRadioButton("radiobutton.draftq", this);
2440             bg.add(rbDraft);
2441             addToGB(rbDraft, this, gridbag, c);
2442             rbNormal = createRadioButton("radiobutton.normalq", this);
2443             rbNormal.setSelected(true);
2444             bg.add(rbNormal);
2445             addToGB(rbNormal, this, gridbag, c);
2446             rbHigh = createRadioButton("radiobutton.highq", this);
2447             bg.add(rbHigh);
2448             addToGB(rbHigh, this, gridbag, c);
2449         }
2450 
2451         public void actionPerformed(ActionEvent e) {
2452             Object source = e.getSource();
2453 
2454             if (source == rbDraft) {
2455                 asCurrent.add(PrintQuality.DRAFT);
2456             } else if (source == rbNormal) {
2457                 asCurrent.add(PrintQuality.NORMAL);
2458             } else if (source == rbHigh) {
2459                 asCurrent.add(PrintQuality.HIGH);
2460             }
2461         }
2462 
2463         public void updateInfo() {
2464             Class<PrintQuality> pqCategory = PrintQuality.class;
2465             boolean draftSupported = false;
2466             boolean normalSupported = false;
2467             boolean highSupported = false;
2468 
2469             if (isAWT) {
2470                 draftSupported = true;
2471                 normalSupported = true;
2472                 highSupported = true;
2473             } else
2474             if (psCurrent.isAttributeCategorySupported(pqCategory)) {
2475                 Object values =
2476                     psCurrent.getSupportedAttributeValues(pqCategory,
2477                                                           docFlavor,
2478                                                           asCurrent);
2479 
2480                 if (values instanceof PrintQuality[]) {
2481                     PrintQuality[] qvalues = (PrintQuality[])values;
2482 
2483                     for (int i = 0; i < qvalues.length; i++) {
2484                         PrintQuality value = qvalues[i];
2485 
2486                         if (value == PrintQuality.DRAFT) {
2487                             draftSupported = true;
2488                         } else if (value == PrintQuality.NORMAL) {
2489                             normalSupported = true;
2490                         } else if (value == PrintQuality.HIGH) {
2491                             highSupported = true;
2492                         }
2493                     }
2494                 }
2495             }
2496 
2497             rbDraft.setEnabled(draftSupported);
2498             rbNormal.setEnabled(normalSupported);
2499             rbHigh.setEnabled(highSupported);
2500 
2501             PrintQuality pq = (PrintQuality)asCurrent.get(pqCategory);
2502             if (pq == null) {
2503                 pq = (PrintQuality)psCurrent.getDefaultAttributeValue(pqCategory);
2504                 if (pq == null) {
2505                     pq = PrintQuality.NORMAL;
2506                 }
2507             }
2508 
2509             if (pq == PrintQuality.DRAFT) {
2510                 rbDraft.setSelected(true);
2511             } else if (pq == PrintQuality.NORMAL) {
2512                 rbNormal.setSelected(true);
2513             } else { // if (pq == PrintQuality.HIGH)
2514                 rbHigh.setSelected(true);
2515             }
2516         }
2517 
2518 
2519     }
2520 
2521     @SuppressWarnings("serial") // Superclass is not serializable across versions
2522     private class SidesPanel extends JPanel
2523         implements ActionListener
2524     {
2525         private final String strTitle = getMsg("border.sides");
2526         private IconRadioButton rbOneSide, rbTumble, rbDuplex;
2527 
2528         public SidesPanel() {
2529             super();
2530 
2531             GridBagLayout gridbag = new GridBagLayout();
2532             GridBagConstraints c = new GridBagConstraints();
2533 
2534             setLayout(gridbag);
2535             setBorder(BorderFactory.createTitledBorder(strTitle));
2536 
2537             c.fill = GridBagConstraints.BOTH;
2538             c.insets = compInsets;
2539             c.weighty = 1.0;
2540             c.gridwidth = GridBagConstraints.REMAINDER;
2541 
2542             ButtonGroup bg = new ButtonGroup();
2543             rbOneSide = new IconRadioButton("radiobutton.oneside",
2544                                             "oneside.png", true,
2545                                             bg, this);
2546             rbOneSide.addActionListener(this);
2547             addToGB(rbOneSide, this, gridbag, c);
2548             rbTumble = new IconRadioButton("radiobutton.tumble",
2549                                            "tumble.png", false,
2550                                            bg, this);
2551             rbTumble.addActionListener(this);
2552             addToGB(rbTumble, this, gridbag, c);
2553             rbDuplex = new IconRadioButton("radiobutton.duplex",
2554                                            "duplex.png", false,
2555                                            bg, this);
2556             rbDuplex.addActionListener(this);
2557             c.gridwidth = GridBagConstraints.REMAINDER;
2558             addToGB(rbDuplex, this, gridbag, c);
2559         }
2560 
2561         public void actionPerformed(ActionEvent e) {
2562             Object source = e.getSource();
2563 
2564             if (rbOneSide.isSameAs(source)) {
2565                 asCurrent.add(Sides.ONE_SIDED);
2566             } else if (rbTumble.isSameAs(source)) {
2567                 asCurrent.add(Sides.TUMBLE);
2568             } else if (rbDuplex.isSameAs(source)) {
2569                 asCurrent.add(Sides.DUPLEX);
2570             }
2571         }
2572 
2573         public void updateInfo() {
2574             Class<Sides> sdCategory = Sides.class;
2575             boolean osSupported = false;
2576             boolean tSupported = false;
2577             boolean dSupported = false;
2578 
2579             if (psCurrent.isAttributeCategorySupported(sdCategory)) {
2580                 Object values =
2581                     psCurrent.getSupportedAttributeValues(sdCategory,
2582                                                           docFlavor,
2583                                                           asCurrent);
2584 
2585                 if (values instanceof Sides[]) {
2586                     Sides[] svalues = (Sides[])values;
2587 
2588                     for (int i = 0; i < svalues.length; i++) {
2589                         Sides value = svalues[i];
2590 
2591                         if (value == Sides.ONE_SIDED) {
2592                             osSupported = true;
2593                         } else if (value == Sides.TUMBLE) {
2594                             tSupported = true;
2595                         } else if (value == Sides.DUPLEX) {
2596                             dSupported = true;
2597                         }
2598                     }
2599                 }
2600             }
2601             rbOneSide.setEnabled(osSupported);
2602             rbTumble.setEnabled(tSupported);
2603             rbDuplex.setEnabled(dSupported);
2604 
2605             Sides sd = (Sides)asCurrent.get(sdCategory);
2606             if (sd == null) {
2607                 sd = (Sides)psCurrent.getDefaultAttributeValue(sdCategory);
2608                 if (sd == null) {
2609                     sd = Sides.ONE_SIDED;
2610                 }
2611             }
2612 
2613             if (sd == Sides.ONE_SIDED) {
2614                 rbOneSide.setSelected(true);
2615             } else if (sd == Sides.TUMBLE) {
2616                 rbTumble.setSelected(true);
2617             } else { // if (sd == Sides.DUPLEX)
2618                 rbDuplex.setSelected(true);
2619             }
2620         }
2621     }
2622 
2623 
2624     @SuppressWarnings("serial") // Superclass is not serializable across versions
2625     private class JobAttributesPanel extends JPanel
2626         implements ActionListener, ChangeListener, FocusListener
2627     {
2628         private final String strTitle = getMsg("border.jobattributes");
2629         private JLabel lblPriority, lblJobName, lblUserName;
2630         private JSpinner spinPriority;
2631         private SpinnerNumberModel snModel;
2632         private JCheckBox cbJobSheets;
2633         private JTextField tfJobName, tfUserName;
2634 
2635         public JobAttributesPanel() {
2636             super();
2637 
2638             GridBagLayout gridbag = new GridBagLayout();
2639             GridBagConstraints c = new GridBagConstraints();
2640 
2641             setLayout(gridbag);
2642             setBorder(BorderFactory.createTitledBorder(strTitle));
2643 
2644             c.fill = GridBagConstraints.NONE;
2645             c.insets = compInsets;
2646             c.weighty = 1.0;
2647 
2648             cbJobSheets = createCheckBox("checkbox.jobsheets", this);
2649             c.anchor = GridBagConstraints.LINE_START;
2650             addToGB(cbJobSheets, this, gridbag, c);
2651 
2652             JPanel pnlTop = new JPanel();
2653             lblPriority = new JLabel(getMsg("label.priority"), JLabel.TRAILING);
2654             lblPriority.setDisplayedMnemonic(getMnemonic("label.priority"));
2655 
2656             pnlTop.add(lblPriority);
2657             snModel = new SpinnerNumberModel(1, 1, 100, 1);
2658             spinPriority = new JSpinner(snModel);
2659             lblPriority.setLabelFor(spinPriority);
2660             // REMIND
2661             ((JSpinner.NumberEditor)spinPriority.getEditor()).getTextField().setColumns(3);
2662             spinPriority.addChangeListener(this);
2663             pnlTop.add(spinPriority);
2664             c.anchor = GridBagConstraints.LINE_END;
2665             c.gridwidth = GridBagConstraints.REMAINDER;
2666             pnlTop.getAccessibleContext().setAccessibleName(
2667                                        getMsg("label.priority"));
2668             addToGB(pnlTop, this, gridbag, c);
2669 
2670             c.fill = GridBagConstraints.HORIZONTAL;
2671             c.anchor = GridBagConstraints.CENTER;
2672             c.weightx = 0.0;
2673             c.gridwidth = 1;
2674             char jmnemonic = getMnemonic("label.jobname");
2675             lblJobName = new JLabel(getMsg("label.jobname"), JLabel.TRAILING);
2676             lblJobName.setDisplayedMnemonic(jmnemonic);
2677             addToGB(lblJobName, this, gridbag, c);
2678             c.weightx = 1.0;
2679             c.gridwidth = GridBagConstraints.REMAINDER;
2680             tfJobName = new JTextField();
2681             lblJobName.setLabelFor(tfJobName);
2682             tfJobName.addFocusListener(this);
2683             tfJobName.setFocusAccelerator(jmnemonic);
2684             tfJobName.getAccessibleContext().setAccessibleName(
2685                                              getMsg("label.jobname"));
2686             addToGB(tfJobName, this, gridbag, c);
2687 
2688             c.weightx = 0.0;
2689             c.gridwidth = 1;
2690             char umnemonic = getMnemonic("label.username");
2691             lblUserName = new JLabel(getMsg("label.username"), JLabel.TRAILING);
2692             lblUserName.setDisplayedMnemonic(umnemonic);
2693             addToGB(lblUserName, this, gridbag, c);
2694             c.gridwidth = GridBagConstraints.REMAINDER;
2695             tfUserName = new JTextField();
2696             lblUserName.setLabelFor(tfUserName);
2697             tfUserName.addFocusListener(this);
2698             tfUserName.setFocusAccelerator(umnemonic);
2699             tfUserName.getAccessibleContext().setAccessibleName(
2700                                              getMsg("label.username"));
2701             addToGB(tfUserName, this, gridbag, c);
2702         }
2703 
2704         public void actionPerformed(ActionEvent e) {
2705             if (cbJobSheets.isSelected()) {
2706                 asCurrent.add(JobSheets.STANDARD);
2707             } else {
2708                 asCurrent.add(JobSheets.NONE);
2709             }
2710         }
2711 
2712         public void stateChanged(ChangeEvent e) {
2713             asCurrent.add(new JobPriority(snModel.getNumber().intValue()));
2714         }
2715 
2716         public void focusLost(FocusEvent e) {
2717             Object source = e.getSource();
2718 
2719             if (source == tfJobName) {
2720                 asCurrent.add(new JobName(tfJobName.getText(),
2721                                           Locale.getDefault()));
2722             } else if (source == tfUserName) {
2723                 asCurrent.add(new RequestingUserName(tfUserName.getText(),
2724                                                      Locale.getDefault()));
2725             }
2726         }
2727 
2728         public void focusGained(FocusEvent e) {}
2729 
2730         public void updateInfo() {
2731             Class<JobSheets>          jsCategory = JobSheets.class;
2732             Class<JobPriority>        jpCategory = JobPriority.class;
2733             Class<JobName>            jnCategory = JobName.class;
2734             Class<RequestingUserName> unCategory = RequestingUserName.class;
2735             boolean jsSupported = false;
2736             boolean jpSupported = false;
2737             boolean jnSupported = false;
2738             boolean unSupported = false;
2739 
2740             // setup JobSheets checkbox
2741             if (psCurrent.isAttributeCategorySupported(jsCategory)) {
2742                 jsSupported = true;
2743             }
2744             JobSheets js = (JobSheets)asCurrent.get(jsCategory);
2745             if (js == null) {
2746                 js = (JobSheets)psCurrent.getDefaultAttributeValue(jsCategory);
2747                 if (js == null) {
2748                     js = JobSheets.NONE;
2749                 }
2750             }
2751             cbJobSheets.setSelected(js != JobSheets.NONE);
2752             cbJobSheets.setEnabled(jsSupported);
2753 
2754             // setup JobPriority spinner
2755             if (!isAWT && psCurrent.isAttributeCategorySupported(jpCategory)) {
2756                 jpSupported = true;
2757             }
2758             JobPriority jp = (JobPriority)asCurrent.get(jpCategory);
2759             if (jp == null) {
2760                 jp = (JobPriority)psCurrent.getDefaultAttributeValue(jpCategory);
2761                 if (jp == null) {
2762                     jp = new JobPriority(1);
2763                 }
2764             }
2765             int value = jp.getValue();
2766             if ((value < 1) || (value > 100)) {
2767                 value = 1;
2768             }
2769             snModel.setValue(value);
2770             lblPriority.setEnabled(jpSupported);
2771             spinPriority.setEnabled(jpSupported);
2772 
2773             // setup JobName text field
2774             if (psCurrent.isAttributeCategorySupported(jnCategory)) {
2775                 jnSupported = true;
2776             }
2777             JobName jn = (JobName)asCurrent.get(jnCategory);
2778             if (jn == null) {
2779                 jn = (JobName)psCurrent.getDefaultAttributeValue(jnCategory);
2780                 if (jn == null) {
2781                     jn = new JobName("", Locale.getDefault());
2782                 }
2783             }
2784             tfJobName.setText(jn.getValue());
2785             tfJobName.setEnabled(jnSupported);
2786             lblJobName.setEnabled(jnSupported);
2787 
2788             // setup RequestingUserName text field
2789             if (!isAWT && psCurrent.isAttributeCategorySupported(unCategory)) {
2790                 unSupported = true;
2791             }
2792             RequestingUserName un = (RequestingUserName)asCurrent.get(unCategory);
2793             if (un == null) {
2794                 un = (RequestingUserName)psCurrent.getDefaultAttributeValue(unCategory);
2795                 if (un == null) {
2796                     un = new RequestingUserName("", Locale.getDefault());
2797                 }
2798             }
2799             tfUserName.setText(un.getValue());
2800             tfUserName.setEnabled(unSupported);
2801             lblUserName.setEnabled(unSupported);
2802         }
2803     }
2804 
2805 
2806 
2807 
2808     /**
2809      * A special widget that groups a JRadioButton with an associated icon,
2810      * placed to the left of the radio button.
2811      */
2812     @SuppressWarnings("serial") // Superclass is not serializable across versions
2813     private class IconRadioButton extends JPanel {
2814 
2815         private JRadioButton rb;
2816         private JLabel lbl;
2817 
2818         public IconRadioButton(String key, String img, boolean selected,
2819                                ButtonGroup bg, ActionListener al)
2820         {
2821             super(new FlowLayout(FlowLayout.LEADING));
2822             final URL imgURL = getImageResource(img);
2823             Icon icon = java.security.AccessController.doPrivileged(
2824                                  new java.security.PrivilegedAction<Icon>() {
2825                 public Icon run() {
2826                     Icon icon = new ImageIcon(imgURL);
2827                     return icon;
2828                 }
2829             });
2830             lbl = new JLabel(icon);
2831             add(lbl);
2832 
2833             rb = createRadioButton(key, al);
2834             rb.setSelected(selected);
2835             addToBG(rb, this, bg);
2836         }
2837 
2838         public void addActionListener(ActionListener al) {
2839             rb.addActionListener(al);
2840         }
2841 
2842         public boolean isSameAs(Object source) {
2843             return (rb == source);
2844         }
2845 
2846         public void setEnabled(boolean enabled) {
2847             rb.setEnabled(enabled);
2848             lbl.setEnabled(enabled);
2849         }
2850 
2851         public boolean isSelected() {
2852             return rb.isSelected();
2853         }
2854 
2855         public void setSelected(boolean selected) {
2856             rb.setSelected(selected);
2857         }
2858     }
2859 
2860     /**
2861      * Similar in functionality to the default JFileChooser, except this
2862      * chooser will pop up a "Do you want to overwrite..." dialog if the
2863      * user selects a file that already exists.
2864      */
2865     @SuppressWarnings("serial") // JDK implementation class
2866     private class ValidatingFileChooser extends JFileChooser {
2867         public void approveSelection() {
2868             File selected = getSelectedFile();
2869             boolean exists;
2870 
2871             try {
2872                 exists = selected.exists();
2873             } catch (SecurityException e) {
2874                 exists = false;
2875             }
2876 
2877             if (exists) {
2878                 int val;
2879                 val = JOptionPane.showConfirmDialog(this,
2880                                                     getMsg("dialog.overwrite"),
2881                                                     getMsg("dialog.owtitle"),
2882                                                     JOptionPane.YES_NO_OPTION);
2883                 if (val != JOptionPane.YES_OPTION) {
2884                     return;
2885                 }
2886             }
2887 
2888             try {
2889                 if (selected.createNewFile()) {
2890                     selected.delete();
2891                 }
2892             }  catch (IOException ioe) {
2893                 JOptionPane.showMessageDialog(this,
2894                                    getMsg("dialog.writeerror")+" "+selected,
2895                                    getMsg("dialog.owtitle"),
2896                                    JOptionPane.WARNING_MESSAGE);
2897                 return;
2898             } catch (SecurityException se) {
2899                 //There is already file read/write access so at this point
2900                 // only delete access is denied.  Just ignore it because in
2901                 // most cases the file created in createNewFile gets
2902                 // overwritten anyway.
2903             }
2904             File pFile = selected.getParentFile();
2905             if ((selected.exists() &&
2906                       (!selected.isFile() || !selected.canWrite())) ||
2907                      ((pFile != null) &&
2908                       (!pFile.exists() || (pFile.exists() && !pFile.canWrite())))) {
2909                 JOptionPane.showMessageDialog(this,
2910                                    getMsg("dialog.writeerror")+" "+selected,
2911                                    getMsg("dialog.owtitle"),
2912                                    JOptionPane.WARNING_MESSAGE);
2913                 return;
2914             }
2915 
2916             super.approveSelection();
2917         }
2918     }
2919 }