1. /*

  2.  * @(#)BasicDesktopPaneUI.java	1.36 00/02/02

  3.  *

  4.  * Copyright 1997-2000 Sun Microsystems, Inc. All Rights Reserved.

  5.  * 

  6.  * This software is the proprietary information of Sun Microsystems, Inc.  

  7.  * Use is subject to license terms.

  8.  * 

  9.  */

  10. 

  11. package javax.swing.plaf.basic;

  12. 

  13. import javax.swing.*;

  14. import javax.swing.plaf.*;

  15. 

  16. import java.beans.*;

  17. 

  18. import java.awt.event.*;

  19. import java.awt.Dimension;

  20. import java.awt.Insets;

  21. import java.awt.Graphics;

  22. import java.awt.*;

  23. import java.util.Vector;

  24. 

  25. /**

  26.  * Basic L&F for a desktop.

  27.  *

  28.  * @version 1.36 02/02/00

  29.  * @author Steve Wilson

  30.  */

  31. public class BasicDesktopPaneUI extends DesktopPaneUI

  32. {

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

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

  35. 

  36.     protected JDesktopPane desktop;

  37.     protected DesktopManager desktopManager;

  38. 

  39.     /**

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

  41.      * longer used.

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

  43.      * the key bindings specification for further details.

  44.      *

  45.      * @deprecated As of JDK version 1.3.

  46.      */

  47.     protected KeyStroke minimizeKey;

  48.     /**

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

  50.      * longer used.

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

  52.      * the key bindings specification for further details.

  53.      *

  54.      * @deprecated As of JDK version 1.3.

  55.      */

  56.     protected KeyStroke maximizeKey;

  57.     /**

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

  59.      * longer used.

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

  61.      * the key bindings specification for further details.

  62.      *

  63.      * @deprecated As of JDK version 1.3.

  64.      */

  65.     protected KeyStroke closeKey;

  66.     /**

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

  68.      * longer used.

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

  70.      * the key bindings specification for further details.

  71.      *

  72.      * @deprecated As of JDK version 1.3.

  73.      */

  74.     protected KeyStroke navigateKey;

  75.     /**

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

  77.      * longer used.

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

  79.      * the key bindings specification for further details.

  80.      *

  81.      * @deprecated As of JDK version 1.3.

  82.      */

  83.     protected KeyStroke navigateKey2;

  84. 

  85.     public static ComponentUI createUI(JComponent c) {

  86.         return new BasicDesktopPaneUI();

  87.     }

  88. 

  89.     public BasicDesktopPaneUI() {

  90.     }

  91. 

  92.     public void installUI(JComponent c)   {

  93. 	desktop = (JDesktopPane)c;

  94. 	installDefaults();

  95. 	installDesktopManager();

  96. 	installKeyboardActions();

  97. 	

  98.     }

  99. 

  100.     public void uninstallUI(JComponent c) {

  101. 	uninstallKeyboardActions();

  102. 	uninstallDesktopManager();

  103.         uninstallDefaults();

  104. 	desktop = null;

  105.     }

  106. 

  107.     protected void installDefaults() {

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

  109. 	    desktop.getBackground() instanceof UIResource) {

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

  111. 	}        

  112.     }

  113. 

  114.     protected void uninstallDefaults() { }

  115. 

  116.     protected void installDesktopManager() {

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

  118. 	    desktopManager = new DefaultDesktopManager();

  119. 	    desktop.setDesktopManager(desktopManager);

  120. 	}

  121.     }

  122. 

  123.     protected void uninstallDesktopManager() {

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

  125. 	    desktop.setDesktopManager(null);

  126. 	}

  127. 	desktopManager = null;

  128.     }

  129. 

  130.     protected void installKeyboardActions(){

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

  132. 	if (inputMap != null) {

  133. 	    SwingUtilities.replaceUIInputMap(desktop,

  134. 			JComponent.WHEN_IN_FOCUSED_WINDOW, inputMap);

  135. 	}

  136. 	inputMap = getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);

  137. 	if (inputMap != null) {

  138. 	    SwingUtilities.replaceUIInputMap(desktop,

  139. 			JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,

  140. 			inputMap);

  141. 	}

  142. 	ActionMap actionMap = getActionMap();

  143. 	SwingUtilities.replaceUIActionMap(desktop, actionMap);

  144. 	registerKeyboardActions();

  145.     }

  146. 

  147.     protected void registerKeyboardActions(){

  148.     }

  149.  

  150.     protected void unregisterKeyboardActions(){

  151.     }

  152. 

  153.     InputMap getInputMap(int condition) {

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

  155. 	    return createInputMap(condition);

  156. 	}

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

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

  159. 	}

  160. 	return null;

  161.     }

  162. 

  163.     InputMap createInputMap(int condition) {

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

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

  166. 		                          ("Desktop.windowBindings");

  167. 

  168. 	    if (bindings != null) {

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

  170. 	    }

  171. 	}

  172. 	return null;

  173.     }

  174. 

  175.     ActionMap getActionMap() {

  176. 	return createActionMap();

  177.     }

  178. 

  179.     ActionMap createActionMap() {

  180. 	ActionMap map = new ActionMapUIResource();

  181. 

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

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

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

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

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

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

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

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

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

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

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

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

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

  195. 	return map;

  196.     }

  197. 

  198.     protected void uninstallKeyboardActions(){ 

  199.       unregisterKeyboardActions();

  200.       SwingUtilities.replaceUIInputMap(desktop, JComponent.

  201. 				     WHEN_IN_FOCUSED_WINDOW, null);

  202.       SwingUtilities.replaceUIInputMap(desktop, JComponent.

  203. 				     WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, null);

  204.       SwingUtilities.replaceUIActionMap(desktop, null);

  205.     }

  206. 

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

  208. 

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

  210. 

  211.     public Dimension getMinimumSize(JComponent c) {

  212. 	return minSize;

  213. 	}

  214.     public Dimension getMaximumSize(JComponent c){

  215. 	return maxSize;

  216.     }

  217. 

  218.     /*

  219.      * Key binding for accessibility -----------------

  220.      */

  221.     private static Vector framesCache;

  222.     private static int selectedIndex;

  223.     private NavigateAction nextAction;

  224.     private boolean moving = false;

  225.     private boolean resizing = false;

  226.     private final int MOVE_RESIZE_INCREMENT = 10;

  227. 

  228.     /*

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

  230.      */

  231.     protected class OpenAction extends AbstractAction {

  232. 	public void actionPerformed(ActionEvent e) {

  233. 	    // restore the selected minimized or maximized frame

  234. 	    verifyFramesCache();

  235. 	    JComponent c = 

  236. 		(JComponent)framesCache.elementAt(selectedIndex);

  237. 	    if (c instanceof JInternalFrame) {

  238. 		JInternalFrame f = (JInternalFrame)c;

  239. 		try {

  240. 		    if (f.isIcon()) {

  241. 			f.setIcon(false);

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

  243. 			f.setMaximum(false);

  244. 		    }

  245. 		    f.setSelected(true);

  246. 		    desktopManager.activateFrame(f);

  247. 		} catch (PropertyVetoException pve) {

  248. 		}

  249. 	    } else if (c instanceof JInternalFrame.JDesktopIcon) {

  250. 		JInternalFrame.JDesktopIcon icon = 

  251. 		    (JInternalFrame.JDesktopIcon)c;

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

  253. 		try {

  254. 		    f.setIcon(false);

  255. 		    f.setSelected(true);

  256. 		    desktopManager.activateFrame(f);

  257. 		} catch (PropertyVetoException pve) {

  258. 		}

  259. 	    }

  260. 	}

  261. 	public boolean isEnabled() { 

  262. 	    return true;

  263. 	}

  264.     }

  265. 

  266.     /*

  267.      * Handles closing an internal frame

  268.      */

  269.     protected class CloseAction extends AbstractAction {

  270. 	public void actionPerformed(ActionEvent e) {

  271. 	    verifyFramesCache();

  272. 	    JComponent c = 

  273. 		(JComponent)framesCache.elementAt(selectedIndex);

  274. 	    if (c instanceof JInternalFrame) {

  275. 		JInternalFrame f = (JInternalFrame)c;

  276. 		if (f.isClosable()) {

  277. 		    try {

  278. 			f.setClosed(true);

  279. 			nextAction.actionPerformed(e);

  280. 		    } catch (PropertyVetoException pve) {

  281. 		    }

  282. 		}

  283. 	    }

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

  285. 		JInternalFrame.JDesktopIcon icon = 

  286. 		    (JInternalFrame.JDesktopIcon)c;

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

  288. 		if (f.isClosable()) {

  289. 		    try {

  290. 			f.setClosed(true);

  291. 			nextAction.actionPerformed(e);

  292. 		    } catch (PropertyVetoException pve) {

  293. 		    }

  294. 		}

  295. 	    }

  296. 	}

  297. 	public boolean isEnabled() { 

  298. 	    return true;

  299. 	}

  300.     }

  301. 

  302.     /*

  303.      * Handles moving and resizing an internal frame

  304.      */

  305.     private class MoveResizeAction extends AbstractAction {

  306. 	private String command;

  307. 	

  308. 	public MoveResizeAction(String command) {

  309. 	    this.command = command;

  310. 	}

  311. 

  312. 	public void actionPerformed(ActionEvent e) {

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

  314. 		moving = true;

  315. 		resizing = false;

  316. 		return;

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

  318. 		moving = false;

  319. 		resizing = true;

  320. 		return;

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

  322. 		moving = resizing = false;

  323. 		return;

  324. 	    }

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

  326. 		return;

  327. 	    }

  328. 

  329. 	    JComponent c = desktop.getSelectedFrame(); 

  330. 	    if ((c == null) || (!(c instanceof JInternalFrame))) {

  331. 		return;

  332. 	    }

  333. 	    Dimension size = c.getSize();

  334. 	    Point loc = c.getLocation();

  335. 

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

  337. 		if (moving) {

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

  339. 		} else if (resizing) {

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

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

  342. 		}

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

  344. 		if (moving) {

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

  346. 		} else if (resizing) {

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

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

  349. 		}

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

  351. 		if (moving) {

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

  353. 		} else if (resizing) {

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

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

  356. 		}

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

  358. 		if (moving) {

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

  360. 		} else if (resizing) {

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

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

  363. 		}

  364. 	    }

  365. 	}

  366. 	public boolean isEnabled() { 

  367. 	    return true;

  368. 	}

  369.     }

  370. 

  371.     /*

  372.      * Handles minimizing an internal frame

  373.      */

  374.     protected class MinimizeAction extends AbstractAction {

  375. 	public void actionPerformed(ActionEvent e) {

  376. 	    // minimize the selected frame

  377. 	    verifyFramesCache();

  378. 	    JComponent c = 

  379. 		(JComponent)framesCache.elementAt(selectedIndex);

  380. 	    if (c instanceof JInternalFrame) {

  381. 		JInternalFrame f = (JInternalFrame)c;

  382. 		if (f.isIconifiable()) {

  383. 		    try {

  384. 			f.setIcon(true);

  385. 			nextAction.actionPerformed(e);

  386. 		    } catch (PropertyVetoException pve) {

  387. 		    }

  388. 		}

  389. 	    }

  390. 	}

  391. 	public boolean isEnabled() { 

  392. 	    return true;

  393. 	}

  394.     }

  395. 

  396.     /*

  397.      * Handles maximizing an internal frame

  398.      */

  399.     protected class MaximizeAction extends AbstractAction {

  400. 	public void actionPerformed(ActionEvent e) {

  401. 	    // maximize the selected frame

  402. 	    verifyFramesCache();

  403. 	    JComponent c = 

  404. 		(JComponent)framesCache.elementAt(selectedIndex);

  405. 	    if (c instanceof JInternalFrame) {

  406. 		JInternalFrame f = (JInternalFrame)c;

  407. 		if (f.isMaximizable()) {

  408. 		    try {

  409. 			f.setMaximum(true);

  410. 		    } catch (PropertyVetoException pve) {

  411. 		    }

  412. 		}

  413. 	    }

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

  415. 		JInternalFrame.JDesktopIcon icon = 

  416. 		    (JInternalFrame.JDesktopIcon)c;

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

  418. 		if (f.isMaximizable()) {

  419. 		    try {

  420. 			f.setIcon(false);

  421. 			f.setMaximum(true);

  422. 		    } catch (PropertyVetoException pve) {

  423. 		    }

  424. 		}

  425. 	    }

  426. 	}

  427. 

  428. 	public boolean isEnabled() { 

  429. 	    return true;

  430.       }

  431.     }

  432. 

  433.     /*

  434.      * Handles navigating to the next internal frame. 

  435.      */

  436.     protected class NavigateAction extends AbstractAction {

  437. 	public void actionPerformed(ActionEvent e) {

  438. 	    // navigate to the next frame

  439. 	    verifyFramesCache();

  440. 	    selectedIndex++;

  441. 	    if (selectedIndex >= framesCache.size()) {

  442. 		selectedIndex = 0;

  443. 	    }

  444. 	    JComponent c = 

  445. 		(JComponent)framesCache.elementAt(selectedIndex);

  446. 	    if (c instanceof JInternalFrame) {

  447. 		JInternalFrame f = (JInternalFrame)c;

  448. 		try {

  449. 		    f.setSelected(true);

  450. 		    desktopManager.activateFrame(f);

  451. 		} catch (PropertyVetoException pve) {

  452. 		}

  453. 	    }

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

  455. 		JInternalFrame.JDesktopIcon icon = 

  456. 		    (JInternalFrame.JDesktopIcon)c;

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

  458. 		try {

  459. 		    f.setSelected(true);

  460. 		    desktopManager.activateFrame(f);

  461. 		} catch (PropertyVetoException pve) {

  462. 		}

  463. 	    }

  464. 	}

  465. 	public boolean isEnabled() { 

  466. 	    return true;

  467. 	}

  468.     }

  469. 

  470.     /*

  471.      * Handles navigating to the previous internal frame. 

  472.      */

  473.     private class PreviousAction extends AbstractAction {

  474. 	public void actionPerformed(ActionEvent e) {

  475. 	    // navigate to the previous internal frame

  476. 	    verifyFramesCache();

  477. 	    selectedIndex--;

  478. 	    if (selectedIndex < 0) {

  479. 		selectedIndex = framesCache.size() - 1;

  480. 	    }

  481. 	    JComponent c = 

  482. 		(JComponent)framesCache.elementAt(selectedIndex);

  483. 	    if (c instanceof JInternalFrame) {

  484. 		JInternalFrame f = (JInternalFrame)c;

  485. 		try {

  486. 		    f.setSelected(true);

  487. 		    desktopManager.activateFrame(f);

  488. 		} catch (PropertyVetoException pve) {

  489. 		}

  490. 	    }

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

  492. 		JInternalFrame.JDesktopIcon icon = 

  493. 		    (JInternalFrame.JDesktopIcon)c;

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

  495. 		try {

  496. 		    f.setSelected(true);

  497. 		    desktopManager.activateFrame(f);

  498. 		} catch (PropertyVetoException pve) {

  499. 		}

  500. 	    }

  501. 	}

  502. 	public boolean isEnabled() { 

  503. 	    return true;

  504. 	}

  505.     }

  506. 

  507.     /*

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

  509.      */

  510.     private void verifyFramesCache() {

  511. 

  512. 	// Need to initialize?

  513. 	boolean shouldSetSelection = false;

  514. 	if (framesCache == null) {

  515. 	    framesCache = new Vector();

  516. 	    shouldSetSelection = true;

  517. 	}

  518. 

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

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

  521. 	boolean framesHaveClosed = false;

  522. 	int len = framesCache.size();

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

  524. 	    JComponent c = 

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

  526. 	    if (c instanceof JInternalFrame) {

  527. 		JInternalFrame f = (JInternalFrame)c;

  528. 		if (f.isClosed()) {

  529. 		    framesHaveClosed = true;

  530. 		    break;

  531. 		}

  532. 	    }

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

  534. 		JInternalFrame.JDesktopIcon icon = 

  535. 		    (JInternalFrame.JDesktopIcon)c;

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

  537. 		if (f.isClosed()) {

  538. 		    framesHaveClosed = true;

  539. 		    break;

  540. 		}

  541. 	    }

  542. 	}

  543. 

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

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

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

  547. 	    framesCache.clear();

  548. 	    int low = desktop.lowestLayer();

  549. 	    int high = desktop.highestLayer();

  550. 	    int index = 0;

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

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

  553. 		if (comp.length > 0) {

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

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

  556. 			if (shouldSetSelection && 

  557. 			    comp[j] instanceof JInternalFrame) {

  558. 			    if (((JInternalFrame)comp[j]).isSelected()) {

  559. 				selectedIndex = index;

  560. 			    }

  561. 			}

  562. 			index++;

  563. 		    }

  564. 		}

  565. 	    }

  566. 	}

  567.     }

  568.     // End of accessibility keybindings

  569. }

  570.