1. /*

  2.  * @(#)BasicDesktopPaneUI.java	1.45 03/01/23

  3.  *

  4.  * Copyright 2003 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. 

  8. package javax.swing.plaf.basic;

  9. 

  10. import javax.swing.*;

  11. import javax.swing.plaf.*;

  12. 

  13. import java.beans.*;

  14. 

  15. import java.awt.event.*;

  16. import java.awt.Dimension;

  17. import java.awt.Insets;

  18. import java.awt.Graphics;

  19. import java.awt.KeyboardFocusManager;

  20. import java.awt.*;

  21. import java.util.Vector;

  22. 

  23. /**

  24.  * Basic L&F for a desktop.

  25.  *

  26.  * @version 1.45 01/23/03

  27.  * @author Steve Wilson

  28.  */

  29. public class BasicDesktopPaneUI extends DesktopPaneUI

  30. {

  31.     private static Dimension minSize = new Dimension(0,0);

  32.     private static Dimension maxSize = new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);

  33. 

  34.     protected JDesktopPane desktop;

  35.     protected DesktopManager desktopManager;

  36. 

  37.     /**

  38.      * As of Java 2 platform v1.3 this previously undocumented field is no

  39.      * longer used.

  40.      * Key bindings are now defined by the LookAndFeel, please refer to

  41.      * the key bindings specification for further details.

  42.      *

  43.      * @deprecated As of 1.3.

  44.      */

  45.     protected KeyStroke minimizeKey;

  46.     /**

  47.      * As of Java 2 platform v1.3 this previously undocumented field is no

  48.      * longer used.

  49.      * Key bindings are now defined by the LookAndFeel, please refer to

  50.      * the key bindings specification for further details.

  51.      *

  52.      * @deprecated As of 1.3.

  53.      */

  54.     protected KeyStroke maximizeKey;

  55.     /**

  56.      * As of Java 2 platform v1.3 this previously undocumented field is no

  57.      * longer used.

  58.      * Key bindings are now defined by the LookAndFeel, please refer to

  59.      * the key bindings specification for further details.

  60.      *

  61.      * @deprecated As of 1.3.

  62.      */

  63.     protected KeyStroke closeKey;

  64.     /**

  65.      * As of Java 2 platform v1.3 this previously undocumented field is no

  66.      * longer used.

  67.      * Key bindings are now defined by the LookAndFeel, please refer to

  68.      * the key bindings specification for further details.

  69.      *

  70.      * @deprecated As of 1.3.

  71.      */

  72.     protected KeyStroke navigateKey;

  73.     /**

  74.      * As of Java 2 platform v1.3 this previously undocumented field is no

  75.      * longer used.

  76.      * Key bindings are now defined by the LookAndFeel, please refer to

  77.      * the key bindings specification for further details.

  78.      *

  79.      * @deprecated As of 1.3.

  80.      */

  81.     protected KeyStroke navigateKey2;

  82. 

  83.     public static ComponentUI createUI(JComponent c) {

  84.         return new BasicDesktopPaneUI();

  85.     }

  86. 

  87.     public BasicDesktopPaneUI() {

  88.     }

  89. 

  90.     public void installUI(JComponent c)   {

  91. 	desktop = (JDesktopPane)c;

  92. 	installDefaults();

  93. 	installDesktopManager();

  94. 	installKeyboardActions();

  95.     }

  96. 

  97.     public void uninstallUI(JComponent c) {

  98. 	uninstallKeyboardActions();

  99. 	uninstallDesktopManager();

  100.         uninstallDefaults();

  101. 	desktop = null;

  102.     }

  103. 

  104.     protected void installDefaults() {

  105. 	if (desktop.getBackground() == null || 

  106. 	    desktop.getBackground() instanceof UIResource) {

  107. 	    desktop.setBackground(UIManager.getColor("Desktop.background"));

  108. 	}        

  109.     }

  110. 

  111.     protected void uninstallDefaults() { }

  112. 

  113.     protected void installDesktopManager() {

  114. 	if(desktop.getDesktopManager() == null) {

  115. 	    desktopManager = new DefaultDesktopManager();

  116. 	    desktop.setDesktopManager(desktopManager);

  117. 	}

  118.     }

  119. 

  120.     protected void uninstallDesktopManager() {

  121. 	if(desktop.getDesktopManager() == desktopManager) {

  122. 	    desktop.setDesktopManager(null);

  123. 	}

  124. 	desktopManager = null;

  125.     }

  126. 

  127.     protected void installKeyboardActions(){

  128. 	InputMap inputMap = getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);

  129. 	if (inputMap != null) {

  130. 	    SwingUtilities.replaceUIInputMap(desktop,

  131. 			JComponent.WHEN_IN_FOCUSED_WINDOW, inputMap);

  132. 	}

  133. 	inputMap = getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);

  134. 	if (inputMap != null) {

  135. 	    SwingUtilities.replaceUIInputMap(desktop,

  136. 			JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,

  137. 			inputMap);

  138. 	}

  139. 	ActionMap actionMap = getActionMap();

  140. 	SwingUtilities.replaceUIActionMap(desktop, actionMap);

  141. 	registerKeyboardActions();

  142.     }

  143. 

  144.     protected void registerKeyboardActions(){

  145.     }

  146.  

  147.     protected void unregisterKeyboardActions(){

  148.     }

  149. 

  150.     InputMap getInputMap(int condition) {

  151. 	if (condition == JComponent.WHEN_IN_FOCUSED_WINDOW) {

  152. 	    return createInputMap(condition);

  153. 	}

  154. 	else if (condition == JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT) {

  155. 	    return (InputMap)UIManager.get("Desktop.ancestorInputMap");

  156. 	}

  157. 	return null;

  158.     }

  159. 

  160.     InputMap createInputMap(int condition) {

  161. 	if (condition == JComponent.WHEN_IN_FOCUSED_WINDOW) {

  162. 	    Object[] bindings = (Object[])UIManager.get

  163. 		                          ("Desktop.windowBindings");

  164. 

  165. 	    if (bindings != null) {

  166. 		return LookAndFeel.makeComponentInputMap(desktop, bindings);

  167. 	    }

  168. 	}

  169. 	return null;

  170.     }

  171. 

  172.     ActionMap getActionMap() {

  173. 	return createActionMap();

  174.     }

  175. 

  176.     ActionMap createActionMap() {

  177. 	ActionMap map = new ActionMapUIResource();

  178. 

  179. 	map.put("restore", new OpenAction());

  180. 	map.put("close", new CloseAction());

  181. 	map.put("move", new MoveResizeAction("move"));

  182. 	map.put("resize", new MoveResizeAction("resize"));

  183. 	map.put("left", new MoveResizeAction("left"));

  184. 	map.put("shrinkLeft", new MoveResizeAction("shrinkLeft"));

  185. 	map.put("right", new MoveResizeAction("right"));

  186. 	map.put("shrinkRight", new MoveResizeAction("shrinkRight"));

  187. 	map.put("up", new MoveResizeAction("up"));

  188. 	map.put("shrinkUp", new MoveResizeAction("shrinkUp"));

  189. 	map.put("down", new MoveResizeAction("down"));

  190. 	map.put("shrinkDown", new MoveResizeAction("shrinkDown"));

  191. 	map.put("escape", new MoveResizeAction("escape"));

  192. 	map.put("minimize", new MinimizeAction());

  193. 	map.put("maximize", new MaximizeAction());

  194. 	map.put("selectNextFrame", nextAction = new NavigateAction());

  195. 	map.put("selectPreviousFrame", new PreviousAction());

  196.         map.put("navigateNext", new NavigateOutAction(true));

  197.         map.put("navigatePrevious", new NavigateOutAction(false));

  198. 	return map;

  199.     }

  200. 

  201.     protected void uninstallKeyboardActions(){ 

  202.       unregisterKeyboardActions();

  203.       SwingUtilities.replaceUIInputMap(desktop, JComponent.

  204. 				     WHEN_IN_FOCUSED_WINDOW, null);

  205.       SwingUtilities.replaceUIInputMap(desktop, JComponent.

  206. 				     WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, null);

  207.       SwingUtilities.replaceUIActionMap(desktop, null);

  208.     }

  209. 

  210.     public void paint(Graphics g, JComponent c) {}

  211. 

  212.     public Dimension getPreferredSize(JComponent c) {return null;}

  213. 

  214.     public Dimension getMinimumSize(JComponent c) {

  215. 	return minSize;

  216. 	}

  217.     public Dimension getMaximumSize(JComponent c){

  218. 	return maxSize;

  219.     }

  220. 

  221.     /*

  222.      * Key binding for accessibility -----------------

  223.      */

  224.     private static Vector framesCache;

  225.     private NavigateAction nextAction;

  226.     private boolean moving = false;

  227.     private boolean resizing = false;

  228.     private final int MOVE_RESIZE_INCREMENT = 10;

  229. 

  230.     /*

  231.      * Handles restoring a minimized or maximized internal frame.

  232.      */

  233.     protected class OpenAction extends AbstractAction {

  234. 	public void actionPerformed(ActionEvent e) {

  235. 	    // restore the selected minimized or maximized frame

  236. 	    JInternalFrame f = desktop.getSelectedFrame();

  237. 	    if (f == null) return;

  238. 	    try {

  239. 	      if (f.isIcon()) {

  240. 		f.setIcon(false);

  241. 	      } else if (f.isMaximum()) {

  242. 		f.setMaximum(false);

  243. 	      }

  244. 	      f.setSelected(true);

  245. 	    } catch (PropertyVetoException pve) {

  246. 	    }

  247. 	}

  248. 	public boolean isEnabled() { 

  249. 	    return true;

  250. 	}

  251.     }

  252. 

  253.     /*

  254.      * Handles closing an internal frame

  255.      */

  256.     protected class CloseAction extends AbstractAction {

  257. 	public void actionPerformed(ActionEvent e) {

  258. 	    JInternalFrame f = desktop.getSelectedFrame();

  259. 	    if (f == null) return;

  260. 	    if (f.isClosable()) {

  261. 	      try {

  262. 		f.setClosed(true);

  263. 	      } catch (PropertyVetoException pve) {

  264. 	      }

  265. 	    }

  266. 	}

  267. 	public boolean isEnabled() { 

  268. 	    return true;

  269. 	}

  270.     }

  271. 

  272.     /*

  273.      * Handles moving and resizing an internal frame

  274.      */

  275.     private class MoveResizeAction extends AbstractAction {

  276. 	private String command;

  277. 	

  278. 	public MoveResizeAction(String command) {

  279. 	    this.command = command;

  280. 	}

  281. 

  282. 	public void actionPerformed(ActionEvent e) {

  283. 	    JInternalFrame c = desktop.getSelectedFrame(); 

  284. 	    if (c == null) {

  285. 		return;

  286. 	    }

  287. 	    if ("move".equals(command)) {

  288. 		moving = true;

  289. 		resizing = false;

  290. 		return;

  291. 	    } else if ("resize".equals(command)) {

  292. 		moving = false;

  293. 		resizing = true;

  294. 		return;

  295. 	    } else if ("escape".equals(command)) {

  296. 		moving = resizing = false;

  297. 		return;

  298. 	    }

  299. 	    if (!moving && !resizing) {

  300. 		return;

  301. 	    }

  302. 

  303. 	    Dimension size = c.getSize();

  304.             Dimension minSize = c.getMinimumSize();

  305. 	    Point loc = c.getLocation();

  306. 

  307. 	    if ("left".equals(command)) {

  308. 		if (moving) {

  309. 		    c.setLocation(loc.x - MOVE_RESIZE_INCREMENT, loc.y);

  310. 		} else if (resizing) {

  311. 		    c.setLocation(loc.x - MOVE_RESIZE_INCREMENT, loc.y);

  312. 		    c.setSize(size.width + MOVE_RESIZE_INCREMENT, size.height);

  313. 		}

  314. 	    } else if ("right".equals(command)) {

  315. 		if (moving) {

  316. 		    c.setLocation(loc.x + MOVE_RESIZE_INCREMENT, loc.y);

  317. 		} else if (resizing) {

  318. 		    c.setLocation(loc.x, loc.y);

  319. 		    c.setSize(size.width + MOVE_RESIZE_INCREMENT, size.height);

  320. 		}

  321. 	    } else if ("up".equals(command)) {

  322. 		if (moving) {

  323. 		    c.setLocation(loc.x, loc.y - MOVE_RESIZE_INCREMENT);

  324. 		} else if (resizing) {

  325. 		    c.setLocation(loc.x, loc.y - MOVE_RESIZE_INCREMENT);

  326. 		    c.setSize(size.width, size.height + MOVE_RESIZE_INCREMENT);

  327. 		}

  328. 	    } else if ("down".equals(command)) {

  329. 		if (moving) {

  330. 		    c.setLocation(loc.x, loc.y + MOVE_RESIZE_INCREMENT);

  331. 		} else if (resizing) {

  332. 		    c.setLocation(loc.x, loc.y);

  333. 		    c.setSize(size.width, size.height + MOVE_RESIZE_INCREMENT);

  334. 		}

  335. 	    } else if ("shrinkLeft".equals(command) && resizing) {

  336.                 if (minSize.width < (size.width - MOVE_RESIZE_INCREMENT)) {

  337.                     c.setLocation(loc.x, loc.y);

  338.                     c.setSize(size.width - MOVE_RESIZE_INCREMENT, size.height);

  339.                 } else {

  340.                     c.setSize(minSize.width, size.height);

  341.                 }

  342. 	    } else if ("shrinkRight".equals(command) && resizing) {

  343.                 if (minSize.width < (size.width - MOVE_RESIZE_INCREMENT)) {

  344.                     c.setLocation(loc.x + MOVE_RESIZE_INCREMENT, loc.y);

  345.                     c.setSize(size.width - MOVE_RESIZE_INCREMENT, size.height);

  346.                 } else {

  347.                     c.setLocation(loc.x - minSize.width + size.width , loc.y);

  348.                     c.setSize(minSize.width, size.height);

  349.                 }

  350. 	    } else if ("shrinkUp".equals(command) && resizing) {

  351.                 if (minSize.height < (size.height - MOVE_RESIZE_INCREMENT)) {

  352.                     c.setLocation(loc.x, loc.y);

  353.                     c.setSize(size.width, size.height - MOVE_RESIZE_INCREMENT);

  354.                 } else {

  355.                     c.setSize(size.width, minSize.height);

  356.                 }

  357. 	    } else if ("shrinkDown".equals(command) && resizing) {

  358.                 if (minSize.height < (size.height - MOVE_RESIZE_INCREMENT)) {

  359.                     c.setLocation(loc.x, loc.y + MOVE_RESIZE_INCREMENT);

  360.                     c.setSize(size.width, size.height - MOVE_RESIZE_INCREMENT);

  361.                 } else {

  362.                     c.setLocation(loc.x, loc.y - minSize.height + size.height);

  363.                     c.setSize(size.width, minSize.height);

  364.                 }

  365.             }

  366. 	}

  367. 	public boolean isEnabled() { 

  368. 	    return true;

  369. 	}

  370.     }

  371. 

  372.     /*

  373.      * Handles minimizing an internal frame

  374.      */

  375.     protected class MinimizeAction extends AbstractAction {

  376. 	public void actionPerformed(ActionEvent e) {

  377. 	    // minimize the selected frame

  378. 	    JInternalFrame f = desktop.getSelectedFrame();

  379. 	    if (f == null) return;

  380. 	    if (f.isIconifiable() && ! f.isIcon()) {

  381. 	      try {

  382. 		f.setIcon(true);

  383. 	      } catch (PropertyVetoException pve) {

  384. 	      }

  385. 	    }

  386. 	}

  387. 	public boolean isEnabled() { 

  388. 	    return true;

  389. 	}

  390.     }

  391. 

  392.     /*

  393.      * Handles maximizing an internal frame

  394.      */

  395.     protected class MaximizeAction extends AbstractAction {

  396. 	public void actionPerformed(ActionEvent e) {

  397. 	    // maximize the selected frame

  398. 	    JInternalFrame f = desktop.getSelectedFrame();

  399. 	    if (f == null) return;

  400. 	    if (f.isMaximizable() && !f.isMaximum()) {

  401. 	      if (f.isIcon()) {

  402. 		try {

  403. 		  f.setIcon(false);

  404. 		  f.setMaximum(true);

  405. 		} catch (PropertyVetoException pve) {}

  406. 	      } else

  407. 		try {

  408. 		  f.setMaximum(true);

  409. 		} catch (PropertyVetoException pve) {

  410. 		}

  411. 	    }

  412. 	}

  413. 

  414. 	public boolean isEnabled() { 

  415. 	    return true;

  416.       }

  417.     }

  418. 

  419.     /*

  420.      * Handles navigating to the next internal frame. 

  421.      */

  422.     protected class NavigateAction extends AbstractAction {

  423. 	public void actionPerformed(ActionEvent e) {

  424. 	    // navigate to the next frame

  425. 	    int i = 0;

  426. 	    verifyFramesCache();

  427. 	    if (framesCache.size() == 0) return;

  428. 	    JInternalFrame f = desktop.getSelectedFrame();

  429. 	    if (f != null) i = framesCache.indexOf(f);

  430. 	    if (i == -1) {

  431. 	      /* if the frame is not there, its icon may be */

  432. 	      i = framesCache.indexOf(f.getDesktopIcon());

  433. 	      if (i == -1) {

  434. 		/* error */ return;

  435. 	      }

  436. 	    }

  437. 	    if (++i == framesCache.size()) /* wrap */ i = 0;

  438. 	    JComponent c = (JComponent) framesCache.elementAt(i);

  439. 	    if (c instanceof JInternalFrame) {

  440. 	      try {

  441. 		((JInternalFrame) c).setSelected(true);

  442. 		desktopManager.activateFrame((JInternalFrame) c);

  443. 	      }

  444. 	      catch (PropertyVetoException pve) {}

  445. 	    } else {

  446. 	      /* it had better be an icon! */

  447. 	      if (!(c instanceof JInternalFrame.JDesktopIcon)){

  448. 		/* error */

  449. 		return;

  450. 	      }

  451. 	      try {

  452. 		((JInternalFrame)((JInternalFrame.JDesktopIcon) c).getInternalFrame()).setSelected(true);

  453. 		desktopManager.activateFrame(((JInternalFrame.JDesktopIcon) c).getInternalFrame());

  454. 	      }

  455. 	      catch (PropertyVetoException pve) {}

  456. 	    }

  457. 	}

  458. 	public boolean isEnabled() { 

  459. 	    return true;

  460. 	}

  461.     }

  462. 

  463.     /*

  464.      * Handles navigating to the previous internal frame. 

  465.      */

  466.     private class PreviousAction extends AbstractAction {

  467. 	public void actionPerformed(ActionEvent e) {

  468. 	    // navigate to the previous internal frame

  469.             int i = 0;

  470. 	    verifyFramesCache();

  471. 	    if (framesCache.size() == 0) return;

  472. 	    JInternalFrame f = desktop.getSelectedFrame();

  473. 	    if (f != null) i = framesCache.indexOf(f);

  474. 	    if (i == -1) {

  475. 	      /* if the frame is not there, its icon may be */

  476. 	      i = framesCache.indexOf(f.getDesktopIcon());

  477. 	      if (i == -1) {

  478. 		/* error */ return;

  479. 	      }

  480. 	    }

  481. 	    if (--i == -1) /* wrap */ i = framesCache.size() - 1;

  482. 	    JComponent c = (JComponent) framesCache.elementAt(i);

  483. 	    if (c instanceof JInternalFrame) {

  484. 	      try {

  485. 		((JInternalFrame) c).setSelected(true);

  486. 	      }

  487. 	      catch (PropertyVetoException pve) {}

  488. 	    } else {

  489. 	      /* it had better be an icon! */

  490. 	      if (!(c instanceof JInternalFrame.JDesktopIcon)){

  491. 		/* error */

  492. 		return;

  493. 	      }

  494. 	      try {

  495. 		((JInternalFrame)((JInternalFrame.JDesktopIcon) c).getInternalFrame()).setSelected(true);

  496. 	      }

  497. 	      catch (PropertyVetoException pve) {}

  498. 	    }

  499. 	}

  500. 	public boolean isEnabled() { 

  501. 	    return true;

  502. 	}

  503.     }

  504. 

  505.     /**

  506.      * Handles navigating to the component before or after the desktop.

  507.      */

  508.     private class NavigateOutAction extends AbstractAction {

  509.         private boolean moveForward;

  510. 

  511.         public NavigateOutAction(boolean moveForward) {

  512.             this.moveForward = moveForward;

  513.         }

  514. 

  515.         public void actionPerformed(ActionEvent e) {

  516.             Container cycleRoot = desktop.getFocusCycleRootAncestor();

  517. 

  518.             if (cycleRoot != null) {

  519.                 FocusTraversalPolicy policy =

  520.                         cycleRoot.getFocusTraversalPolicy();

  521.                 if (policy != null && policy instanceof

  522.                         SortingFocusTraversalPolicy) {

  523.                     SortingFocusTraversalPolicy sPolicy =

  524.                             (SortingFocusTraversalPolicy)policy;

  525.                     boolean idc = sPolicy.getImplicitDownCycleTraversal();

  526.                     try {

  527.                         sPolicy.setImplicitDownCycleTraversal(false);

  528.                         if (moveForward) {

  529.                             KeyboardFocusManager.

  530.                                 getCurrentKeyboardFocusManager().

  531.                                 focusNextComponent(desktop);

  532.                         } else {

  533.                             KeyboardFocusManager.

  534.                                 getCurrentKeyboardFocusManager().

  535.                                 focusPreviousComponent(desktop);

  536.                         }

  537.                     } finally {

  538.                         sPolicy.setImplicitDownCycleTraversal(idc);

  539.                     }

  540.                 }

  541.             }

  542.         }

  543. 

  544.         public boolean isEnabled() {

  545.             return true;

  546.         }

  547.     }

  548. 

  549.     /*

  550.      * Verifies the internal frames cache is up to date.

  551.      */

  552.     private void verifyFramesCache() {

  553. 

  554. 	// Need to initialize?

  555. 	if (framesCache == null) {

  556. 	    framesCache = new Vector();

  557. 	}

  558. 

  559. 	// Check whether any internal frames have closed in

  560. 	// which case we have to refresh the frames cache.

  561.        	boolean framesHaveClosed = false;

  562. 	int len = framesCache.size();

  563. 	for (int i = 0; i < len; i++) {

  564. 	    JComponent c = 

  565. 		(JComponent)framesCache.elementAt(i);

  566. 	    if (c instanceof JInternalFrame) {

  567. 		JInternalFrame f = (JInternalFrame)c;

  568. 		if (f.isClosed()) {

  569. 		    framesHaveClosed = true;

  570. 		    break;

  571. 		}

  572. 	    }

  573. 	    else if (c instanceof JInternalFrame.JDesktopIcon) {

  574. 		JInternalFrame.JDesktopIcon icon = 

  575. 		    (JInternalFrame.JDesktopIcon)c;

  576. 		JInternalFrame f = (JInternalFrame)icon.getInternalFrame();

  577. 		if (f.isClosed()) {

  578. 		    framesHaveClosed = true;

  579. 		    break;

  580. 		}

  581. 	    }

  582. 	} 

  583.        	JInternalFrame [] allFrames = desktop.getAllFrames();

  584.        	if (framesHaveClosed || allFrames.length != framesCache.size()) {

  585. 	    // Cache frames starting at the lowest layer.

  586. 	    framesCache.clear();

  587. 	    int low = desktop.lowestLayer();

  588. 	    int high = desktop.highestLayer();

  589. 	    for (int i = high; i >= low; i--) {

  590. 		Component [] comp = desktop.getComponentsInLayer(i);

  591. 		if (comp.length > 0) {

  592. 		    for (int j = 0; j < comp.length; j++) {

  593. 			framesCache.addElement(comp[j]);

  594. 		    }

  595. 		}

  596. 	    }

  597.        	}

  598.     }

  599.     // End of accessibility keybindings

  600. }

  601.