plan9-archive/inferno-java

java/pkg/com/sun/java/browser/dom/DOMAccessException.java+89−0

@@ -0,0 +1,89 @@
	1	/*
	2	* Copyright (c) 2000, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.browser.dom;
	27
	28	public class DOMAccessException extends Exception
	29	{
	30	/**
	31	* Constructs a new DOMAccessException with no detail message.
	32	*/
	33	public DOMAccessException()
	34	{
	35	this(null, null);
	36	}
	37
	38
	39	/**
	40	* Constructs a new DOMAccessException with the given detail message.
	41	*
	42	* @param msg Detail message.
	43	*/
	44	public DOMAccessException(String msg)
	45	{
	46	this(null, msg);
	47	}
	48
	49	/**
	50	* Constructs a new DOMAccessException with the given exception as a root clause.
	51	*
	52	* @param e Exception.
	53	*/
	54	public DOMAccessException(Exception e)
	55	{
	56	this(e, null);
	57	}
	58
	59	/**
	60	* Constructs a new DOMAccessException with the given exception as a root clause and the given detail message.
	61	*
	62	* @param e Exception.
	63	* @param msg Detail message.
	64	*/
	65	public DOMAccessException(Exception e, String msg)
	66	{
	67	this.ex = e;
	68	this.msg = msg;
	69	}
	70
	71	/**
	72	* Returns the detail message of the error or null if there is no detail message.
	73	*/
	74	public String getMessage()
	75	{
	76	return msg;
	77	}
	78
	79	/**
	80	* Returns the root cause of the error or null if there is none.
	81	*/
	82	public Throwable getCause()
	83	{
	84	return ex;
	85	}
	86
	87	private Throwable ex;
	88	private String msg;
	89	}

java/pkg/com/sun/java/browser/dom/DOMAccessor.java+40−0

@@ -0,0 +1,40 @@
	1	/*
	2	* Copyright (c) 2000, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.browser.dom;
	27
	28
	29	public interface DOMAccessor
	30	{
	31	/**
	32	* Returns the Document object of the DOM.
	33	*/
	34	public org.w3c.dom.Document getDocument(Object obj) throws org.w3c.dom.DOMException;
	35
	36	/**
	37	* Returns a DOMImplementation object.
	38	*/
	39	public org.w3c.dom.DOMImplementation getDOMImplementation();
	40	}

java/pkg/com/sun/java/browser/dom/DOMAction.java+42−0

@@ -0,0 +1,42 @@
	1	/*
	2	* Copyright (c) 2000, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.browser.dom;
	27
	28
	29	public interface DOMAction
	30	{
	31	/**
	32	* When an object implementing interface DOMAction is passed
	33	* to DOMService.invokeAndWait() or DOMService.invokeLater(),
	34	* run method is called in the DOM access dispatch thread.
	35	*
	36	* accessor is used for the DOMAction to access the entry point of
	37	* the browser's DOM, if necessary.
	38	*
	39	* @param accessor DOMAccessor
	40	*/
	41	public Object run(DOMAccessor accessor);
	42	}

java/pkg/com/sun/java/browser/dom/DOMService.java+103−0

@@ -0,0 +1,103 @@
	1	/*
	2	* Copyright (c) 2000, 2001, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.browser.dom;
	27
	28	public abstract class DOMService
	29	{
	30	/**
	31	* Returns new instance of a DOMService. The implementation
	32	* of the DOMService returns depends on the setting of the
	33	* com.sun.java.browser.dom.DOMServiceProvider property or,
	34	* if the property is not set, a platform specific default.
	35	*
	36	* Throws DOMUnsupportedException if the DOMService is not
	37	* available to the obj.
	38	*
	39	* @param obj Object to leverage the DOMService
	40	*/
	41	public static DOMService getService(Object obj)
	42	throws DOMUnsupportedException
	43	{
	44	try
	45	{
	46	String provider = (String) java.security.AccessController.doPrivileged(
	47	new sun.security.action.GetPropertyAction("com.sun.java.browser.dom.DOMServiceProvider"));
	48
	49	Class clazz = DOMService.class.forName("sun.plugin.dom.DOMService");
	50
	51	return (DOMService) clazz.newInstance();
	52	}
	53	catch (Throwable e)
	54	{
	55	throw new DOMUnsupportedException(e.toString());
	56	}
	57	}
	58
	59	/**
	60	* An empty constructor is provided. Implementations of this
	61	* abstract class must provide a public no-argument constructor
	62	* in order for the static getService() method to work correctly.
	63	* Application programmers should not be able to directly
	64	* construct implementation subclasses of this abstract subclass.
	65	*/
	66	public DOMService()
	67	{
	68	}
	69
	70	/**
	71	* Causes action.run() to be executed synchronously on the
	72	* DOM action dispatching thread. This call will block until all
	73	* pending DOM actions have been processed and (then)
	74	* action.run() returns. This method should be used when an
	75	* application thread needs to access the browser's DOM.
	76	* It should not be called from the DOMActionDispatchThread.
	77	*
	78	* Note that if the DOMAction.run() method throws an uncaught
	79	* exception (on the DOM action dispatching thread), it's caught
	80	* and re-thrown, as an DOMAccessException, on the caller's thread.
	81	*
	82	* If the DOMAction.run() method throws any DOM security related
	83	* exception (on the DOM action dispatching thread), it's caught
	84	* and re-thrown, as an DOMSecurityException, on the caller's thread.
	85	*
	86	* @param action DOMAction.
	87	*/
	88	public abstract Object invokeAndWait(DOMAction action) throws DOMAccessException;
	89
	90	/**
	91	* Causes action.run() to be executed asynchronously on the
	92	* DOM action dispatching thread. This method should be used
	93	* when an application thread needs to access the browser's
	94	* DOM. It should not be called from the DOMActionDispatchThread.
	95	*
	96	* Note that if the DOMAction.run() method throws an uncaught
	97	* exception (on the DOM action dispatching thread), it will not be
	98	* caught and re-thrown on the caller's thread.
	99	*
	100	* @param action DOMAction.
	101	*/
	102	public abstract void invokeLater(DOMAction action);
	103	}

java/pkg/com/sun/java/browser/dom/DOMServiceProvider.java+60−0

@@ -0,0 +1,60 @@
	1	/*
	2	* Copyright (c) 2000, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.browser.dom;
	27
	28	public abstract class DOMServiceProvider
	29	{
	30	/**
	31	* An empty constructor is provided. Implementations should
	32	* provide a public constructor so that the DOMService
	33	* can instantiate instances of the implementation class.
	34	* Application programmers should not be able to directly
	35	* construct implementation subclasses of this abstract subclass.
	36	* The only way an application should be able to obtain a
	37	* reference to a DOMServiceProvider implementation
	38	* instance is by using the appropriate methods of the
	39	* DOMService.
	40	*/
	41	public DOMServiceProvider()
	42	{
	43	}
	44
	45	/**
	46	* Returns true if the DOMService can determine the association
	47	* between the obj and the underlying DOM in the browser.
	48	*/
	49	public abstract boolean canHandle(Object obj);
	50
	51	/**
	52	* Returns the Document object of the DOM.
	53	*/
	54	public abstract org.w3c.dom.Document getDocument(Object obj) throws DOMUnsupportedException;
	55
	56	/**
	57	* Returns the DOMImplemenation object of the DOM.
	58	*/
	59	public abstract org.w3c.dom.DOMImplementation getDOMImplementation();
	60	}

java/pkg/com/sun/java/browser/dom/DOMUnsupportedException.java+89−0

@@ -0,0 +1,89 @@
	1	/*
	2	* Copyright (c) 2000, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.browser.dom;
	27
	28
	29	public class DOMUnsupportedException extends Exception
	30	{
	31	/**
	32	* Constructs a new DOMUnsupportedException with no detail message.
	33	*/
	34	public DOMUnsupportedException()
	35	{
	36	this(null, null);
	37	}
	38
	39	/**
	40	* Constructs a new DOMUnsupportedException with the given detail message.
	41	*
	42	* @param msg Detail message.
	43	*/
	44	public DOMUnsupportedException(String msg)
	45	{
	46	this(null, msg);
	47	}
	48
	49	/**
	50	* Constructs a new DOMUnsupportedException with the given exception as a root clause.
	51	*
	52	* @param e Exception.
	53	*/
	54	public DOMUnsupportedException(Exception e)
	55	{
	56	this(e, null);
	57	}
	58
	59	/**
	60	* Constructs a new DOMUnsupportedException with the given exception as a root clause and the given detail message.
	61	*
	62	* @param e Exception.
	63	* @param msg Detail message.
	64	*/
	65	public DOMUnsupportedException(Exception e, String msg)
	66	{
	67	this.ex = e;
	68	this.msg = msg;
	69	}
	70
	71	/**
	72	* Returns the detail message of the error or null if there is no detail message.
	73	*/
	74	public String getMessage()
	75	{
	76	return msg;
	77	}
	78
	79	/**
	80	* Returns the root cause of the error or null if there is none.
	81	*/
	82	public Throwable getCause()
	83	{
	84	return ex;
	85	}
	86
	87	private Throwable ex;
	88	private String msg;
	89	}

java/pkg/com/sun/java/browser/dom/mkfile+13−0

@@ -0,0 +1,13 @@
	1	<../../../../../../../mkconfig
	2
	3	TARG=\
	4	DOMAccessException.dis\
	5	DOMAccessor.dis\
	6	DOMAction.dis\
	7	DOMService.dis\
	8	DOMServiceProvider.dis\
	9	DOMUnsupportedException.dis\
	10
	11	DISBIN=$ROOT/java/dis/java/java/com/sun/java/browser/dom
	12
	13	<$ROOT/mkfiles/mkjava

java/pkg/com/sun/java/browser/mkfile+7−0

@@ -0,0 +1,7 @@
	1	<../../../../../../mkconfig
	2
	3	DIRS=\
	4	dom\
	5	net\
	6
	7	<$ROOT/mkfiles/mksubdirs

java/pkg/com/sun/java/browser/net/ProxyInfo.java+36−0

@@ -0,0 +1,36 @@
	1	/*
	2	* Copyright (c) 2001, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.browser.net;
	27
	28	/**
	29	*
	30	* @author Zhengyu Gu
	31	*/
	32	public interface ProxyInfo {
	33	public String getHost();
	34	public int getPort();
	35	public boolean isSocks();
	36	}

java/pkg/com/sun/java/browser/net/ProxyService.java+61−0

@@ -0,0 +1,61 @@
	1	/*
	2	* Copyright (c) 2001, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.browser.net;
	27
	28	import java.net.URL;
	29	import java.io.IOException;
	30
	31	/**
	32	*
	33	* @author Zhengyu Gu
	34	*/
	35	public class ProxyService extends Object {
	36	private static ProxyServiceProvider provider = null;
	37
	38
	39	public static void setProvider(ProxyServiceProvider p)
	40	throws IOException {
	41	if(null == provider)
	42	provider = p;
	43	else
	44	throw new IOException("Proxy service provider has already been set.");
	45	}
	46
	47
	48	/**
	49	* <p>The function returns proxy information of the specified URL.</p>
	50	* @param url URL
	51	* @return returns proxy information. If there is not proxy, returns null
	52	* @since 1.4
	53	*/
	54	public static ProxyInfo[] getProxyInfo(URL url)
	55	throws IOException {
	56	if(null == provider)
	57	throw new IOException("Proxy service provider is not yet set");
	58
	59	return provider.getProxyInfo(url);
	60	}
	61	}

java/pkg/com/sun/java/browser/net/ProxyServiceProvider.java+36−0

@@ -0,0 +1,36 @@
	1	/*
	2	* Copyright (c) 2001, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.browser.net;
	27
	28	import java.net.URL;
	29
	30	/**
	31	*
	32	* @author Zhengyu Gu
	33	*/
	34	public interface ProxyServiceProvider {
	35	public ProxyInfo[] getProxyInfo(URL url);
	36	}

java/pkg/com/sun/java/browser/net/mkfile+10−0

@@ -0,0 +1,10 @@
	1	<../../../../../../../mkconfig
	2
	3	TARG=\
	4	ProxyInfo.dis\
	5	ProxyService.dis\
	6	ProxyServiceProvider.dis\
	7
	8	DISBIN=$ROOT/java/dis/java/java/com/sun/java/browser/net
	9
	10	<$ROOT/mkfiles/mkjava

java/pkg/com/sun/java/mkfile+8−0

@@ -0,0 +1,8 @@
	1	<../../../../../mkconfig
	2
	3	DIRS=\
	4	browser\
	5	swing\
	6	util\
	7
	8	<$ROOT/mkfiles/mksubdirs

java/pkg/com/sun/java/swing/Painter.java+33−0

@@ -0,0 +1,33 @@
	1	/*
	2	* Copyright (c) 2005, 2006, 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	package com.sun.java.swing;
	26
	27	/**
	28	* This class is preserved for backward compatibility with JDK 6.
	29	*
	30	* @deprecated Use {@link javax.swing.Painter} instead.
	31	*/
	32	public interface Painter<T> extends javax.swing.Painter {
	33	}

java/pkg/com/sun/java/swing/SwingUtilities3$EventQueueDelegateFromMap.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/SwingUtilities3.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/SwingUtilities3.java+220−0

@@ -0,0 +1,220 @@
	1	/*
	2	* Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.swing;
	27
	28	import sun.awt.EventQueueDelegate;
	29	import sun.awt.AppContext;
	30	import java.util.Collections;
	31	import java.util.Map;
	32	import java.util.WeakHashMap;
	33	import java.util.concurrent.Callable;
	34	import java.applet.Applet;
	35	import java.awt.AWTEvent;
	36	import java.awt.EventQueue;
	37	import java.awt.Component;
	38	import java.awt.Container;
	39	import java.awt.Window;
	40	import javax.swing.JComponent;
	41	import javax.swing.RepaintManager;
	42
	43	/**
	44	* A collection of utility methods for Swing.
	45	* <p>
	46	* <b>WARNING:</b> While this class is public, it should not be treated as
	47	* public API and its API may change in incompatable ways between dot dot
	48	* releases and even patch releases. You should not rely on this class even
	49	* existing.
	50	*
	51	* This is a second part of sun.swing.SwingUtilities2. It is required
	52	* to provide services for JavaFX applets.
	53	*
	54	*/
	55	public class SwingUtilities3 {
	56	/**
	57	* The {@code clientProperty} key for delegate {@code RepaintManager}
	58	*/
	59	private static final Object DELEGATE_REPAINT_MANAGER_KEY =
	60	new StringBuilder("DelegateRepaintManagerKey");
	61
	62	/**
	63	* Registers delegate RepaintManager for {@code JComponent}.
	64	*/
	65	public static void setDelegateRepaintManager(JComponent component,
	66	RepaintManager repaintManager) {
	67	/* setting up flag in AppContext to speed up lookups in case
	68	* there are no delegate RepaintManagers used.
	69	*/
	70	AppContext.getAppContext().put(DELEGATE_REPAINT_MANAGER_KEY,
	71	Boolean.TRUE);
	72
	73	component.putClientProperty(DELEGATE_REPAINT_MANAGER_KEY,
	74	repaintManager);
	75	}
	76
	77	private static final Map<Container, Boolean> vsyncedMap =
	78	Collections.synchronizedMap(new WeakHashMap<Container, Boolean>());
	79
	80	/**
	81	* Sets vsyncRequested state for the {@code rootContainer}. If
	82	* {@code isRequested} is {@code true} then vsynced
	83	* {@code BufferStrategy} is enabled for this {@code rootContainer}.
	84	*
	85	* Note: requesting vsynced painting does not guarantee one. The outcome
	86	* depends on current RepaintManager's RepaintManager.PaintManager
	87	* and on the capabilities of the graphics hardware/software and what not.
	88	*
	89	* @param rootContainer topmost container. Should be either {@code Window}
	90	* or {@code Applet}
	91	* @param isRequested the value to set vsyncRequested state to
	92	*/
	93	public static void setVsyncRequested(Container rootContainer,
	94	boolean isRequested) {
	95	assert (rootContainer instanceof Applet) \|\| (rootContainer instanceof Window);
	96	if (isRequested) {
	97	vsyncedMap.put(rootContainer, Boolean.TRUE);
	98	} else {
	99	vsyncedMap.remove(rootContainer);
	100	}
	101	}
	102
	103	/**
	104	* Checks if vsync painting is requested for {@code rootContainer}
	105	*
	106	* @param rootContainer topmost container. Should be either Window or Applet
	107	* @return {@code true} if vsync painting is requested for {@code rootContainer}
	108	*/
	109	public static boolean isVsyncRequested(Container rootContainer) {
	110	assert (rootContainer instanceof Applet) \|\| (rootContainer instanceof Window);
	111	return Boolean.TRUE == vsyncedMap.get(rootContainer);
	112	}
	113
	114	/**
	115	* Returns delegate {@code RepaintManager} for {@code component} hierarchy.
	116	*/
	117	public static RepaintManager getDelegateRepaintManager(Component
	118	component) {
	119	RepaintManager delegate = null;
	120	if (Boolean.TRUE == AppContext.getAppContext().get(
	121	DELEGATE_REPAINT_MANAGER_KEY)) {
	122	while (delegate == null && component != null) {
	123	while (component != null
	124	&& ! (component instanceof JComponent)) {
	125	component = component.getParent();
	126	}
	127	if (component != null) {
	128	delegate = (RepaintManager)
	129	((JComponent) component)
	130	.getClientProperty(DELEGATE_REPAINT_MANAGER_KEY);
	131	component = component.getParent();
	132	}
	133
	134	}
	135	}
	136	return delegate;
	137	}
	138
	139	/*
	140	* We use maps to avoid reflection. Hopefully it should perform better
	141	* this way.
	142	*/
	143	public static void setEventQueueDelegate(
	144	Map<String, Map<String, Object>> map) {
	145	EventQueueDelegate.setDelegate(new EventQueueDelegateFromMap(map));
	146	}
	147
	148	private static class EventQueueDelegateFromMap
	149	implements EventQueueDelegate.Delegate {
	150	private final AWTEvent[] afterDispatchEventArgument;
	151	private final Object[] afterDispatchHandleArgument;
	152	private final Callable<Void> afterDispatchCallable;
	153
	154	private final AWTEvent[] beforeDispatchEventArgument;
	155	private final Callable<Object> beforeDispatchCallable;
	156
	157	private final EventQueue[] getNextEventEventQueueArgument;
	158	private final Callable<AWTEvent> getNextEventCallable;
	159
	160	@SuppressWarnings("unchecked")
	161	public EventQueueDelegateFromMap(Map<String, Map<String, Object>> objectMap) {
	162	Map<String, Object> methodMap = objectMap.get("afterDispatch");
	163	afterDispatchEventArgument = (AWTEvent[]) methodMap.get("event");
	164	afterDispatchHandleArgument = (Object[]) methodMap.get("handle");
	165	afterDispatchCallable = (Callable<Void>) methodMap.get("method");
	166
	167	methodMap = objectMap.get("beforeDispatch");
	168	beforeDispatchEventArgument = (AWTEvent[]) methodMap.get("event");
	169	beforeDispatchCallable = (Callable<Object>) methodMap.get("method");
	170
	171	methodMap = objectMap.get("getNextEvent");
	172	getNextEventEventQueueArgument =
	173	(EventQueue[]) methodMap.get("eventQueue");
	174	getNextEventCallable = (Callable<AWTEvent>) methodMap.get("method");
	175	}
	176
	177	@Override
	178	public void afterDispatch(AWTEvent event, Object handle) throws InterruptedException {
	179	afterDispatchEventArgument[0] = event;
	180	afterDispatchHandleArgument[0] = handle;
	181	try {
	182	afterDispatchCallable.call();
	183	} catch (InterruptedException e) {
	184	throw e;
	185	} catch (RuntimeException e) {
	186	throw e;
	187	} catch (Exception e) {
	188	throw new RuntimeException(e);
	189	}
	190	}
	191
	192	@Override
	193	public Object beforeDispatch(AWTEvent event) throws InterruptedException {
	194	beforeDispatchEventArgument[0] = event;
	195	try {
	196	return beforeDispatchCallable.call();
	197	} catch (InterruptedException e) {
	198	throw e;
	199	} catch (RuntimeException e) {
	200	throw e;
	201	} catch (Exception e) {
	202	throw new RuntimeException(e);
	203	}
	204	}
	205
	206	@Override
	207	public AWTEvent getNextEvent(EventQueue eventQueue) throws InterruptedException {
	208	getNextEventEventQueueArgument[0] = eventQueue;
	209	try {
	210	return getNextEventCallable.call();
	211	} catch (InterruptedException e) {
	212	throw e;
	213	} catch (RuntimeException e) {
	214	throw e;
	215	} catch (Exception e) {
	216	throw new RuntimeException(e);
	217	}
	218	}
	219	}
	220	}

java/pkg/com/sun/java/swing/mkfile+13−0

@@ -0,0 +1,13 @@
	1	<../../../../../../mkconfig
	2
	3	DIRS=\
	4	plaf\
	5
	6	TARG=\
	7	Painter.dis\
	8	SwingUtilities3.dis\
	9
	10	DISBIN=$ROOT/java/dis/java/java/com/sun/java/swing
	11
	12	<$ROOT/mkfiles/mkjava
	13	<$ROOT/mkfiles/mksubdirs

java/pkg/com/sun/java/swing/plaf/gtk/GTKColorChooserPanel.java+1303−0

@@ -0,0 +1,1303 @@
	1	/*
	2	* Copyright (c) 2002, 2008, 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	package com.sun.java.swing.plaf.gtk;
	26
	27	import java.awt.*;
	28	import java.awt.event.*;
	29	import java.awt.image.*;
	30	import javax.swing.*;
	31	import javax.swing.colorchooser.*;
	32	import javax.swing.event.*;
	33	import javax.swing.plaf.*;
	34
	35	/**
	36	* A color chooser panel mimicking that of GTK's: a color wheel showing
	37	* hue and a triangle that varies saturation and brightness.
	38	*
	39	* @author Scott Violet
	40	*/
	41	class GTKColorChooserPanel extends AbstractColorChooserPanel implements
	42	ChangeListener {
	43	private static final float PI_3 = (float)(Math.PI / 3);
	44
	45	private ColorTriangle triangle;
	46	private JLabel lastLabel;
	47	private JLabel label;
	48
	49	private JSpinner hueSpinner;
	50	private JSpinner saturationSpinner;
	51	private JSpinner valueSpinner;
	52
	53	private JSpinner redSpinner;
	54	private JSpinner greenSpinner;
	55	private JSpinner blueSpinner;
	56
	57	private JTextField colorNameTF;
	58
	59	private boolean settingColor;
	60
	61	// The colors are mirrored to avoid creep in adjusting an individual
	62	// value.
	63	private float hue;
	64	private float saturation;
	65	private float brightness;
	66
	67
	68
	69	/**
	70	* Convenience method to transfer focus to the next child of component.
	71	*/
	72	// PENDING: remove this when a variant of this is added to awt.
	73	static void compositeRequestFocus(Component component, boolean direction) {
	74	if (component instanceof Container) {
	75	Container container = (Container)component;
	76	if (container.isFocusCycleRoot()) {
	77	FocusTraversalPolicy policy = container.
	78	getFocusTraversalPolicy();
	79	Component comp = policy.getDefaultComponent(container);
	80	if (comp!=null) {
	81	comp.requestFocus();
	82	return;
	83	}
	84	}
	85	Container rootAncestor = container.getFocusCycleRootAncestor();
	86	if (rootAncestor!=null) {
	87	FocusTraversalPolicy policy = rootAncestor.
	88	getFocusTraversalPolicy();
	89	Component comp;
	90
	91	if (direction) {
	92	comp = policy.getComponentAfter(rootAncestor, container);
	93	}
	94	else {
	95	comp = policy.getComponentBefore(rootAncestor, container);
	96	}
	97	if (comp != null) {
	98	comp.requestFocus();
	99	return;
	100	}
	101	}
	102	}
	103	component.requestFocus();
	104	}
	105
	106
	107	/**
	108	* Returns a user presentable description of this GTKColorChooserPane.
	109	*/
	110	public String getDisplayName() {
	111	return (String)UIManager.get("GTKColorChooserPanel.nameText");
	112	}
	113
	114	/**
	115	* Returns the mnemonic to use with <code>getDisplayName</code>.
	116	*/
	117	public int getMnemonic() {
	118	String m = (String)UIManager.get("GTKColorChooserPanel.mnemonic");
	119
	120	if (m != null) {
	121	try {
	122	int value = Integer.parseInt(m);
	123
	124	return value;
	125	} catch (NumberFormatException nfe) {}
	126	}
	127	return -1;
	128	}
	129
	130	/**
	131	* Character to underline that represents the mnemonic.
	132	*/
	133	public int getDisplayedMnemonicIndex() {
	134	String m = (String)UIManager.get(
	135	"GTKColorChooserPanel.displayedMnemonicIndex");
	136
	137	if (m != null) {
	138	try {
	139	int value = Integer.parseInt(m);
	140
	141	return value;
	142	} catch (NumberFormatException nfe) {}
	143	}
	144	return -1;
	145	}
	146
	147	public Icon getSmallDisplayIcon() {
	148	return null;
	149	}
	150
	151	public Icon getLargeDisplayIcon() {
	152	return null;
	153	}
	154
	155	public void uninstallChooserPanel(JColorChooser enclosingChooser) {
	156	super.uninstallChooserPanel(enclosingChooser);
	157	removeAll();
	158	}
	159
	160	/**
	161	* Builds and configures the widgets for the GTKColorChooserPanel.
	162	*/
	163	protected void buildChooser() {
	164	triangle = new ColorTriangle();
	165	triangle.setName("GTKColorChooserPanel.triangle");
	166
	167	// PENDING: when we straighten out user setting opacity, this should
	168	// be changed.
	169	label = new OpaqueLabel();
	170	label.setName("GTKColorChooserPanel.colorWell");
	171	label.setOpaque(true);
	172	label.setMinimumSize(new Dimension(67, 32));
	173	label.setPreferredSize(new Dimension(67, 32));
	174	label.setMaximumSize(new Dimension(67, 32));
	175
	176	// PENDING: when we straighten out user setting opacity, this should
	177	// be changed.
	178	lastLabel = new OpaqueLabel();
	179	lastLabel.setName("GTKColorChooserPanel.lastColorWell");
	180	lastLabel.setOpaque(true);
	181	lastLabel.setMinimumSize(new Dimension(67, 32));
	182	lastLabel.setPreferredSize(new Dimension(67, 32));
	183	lastLabel.setMaximumSize(new Dimension(67, 32));
	184
	185	hueSpinner = new JSpinner(new SpinnerNumberModel(0, 0, 360, 1));
	186	configureSpinner(hueSpinner, "GTKColorChooserPanel.hueSpinner");
	187	saturationSpinner = new JSpinner(new SpinnerNumberModel(0, 0, 255, 1));
	188	configureSpinner(saturationSpinner,
	189	"GTKColorChooserPanel.saturationSpinner");
	190	valueSpinner = new JSpinner(new SpinnerNumberModel(0, 0, 255, 1));
	191	configureSpinner(valueSpinner, "GTKColorChooserPanel.valueSpinner");
	192	redSpinner = new JSpinner(new SpinnerNumberModel(0, 0, 255, 1));
	193	configureSpinner(redSpinner, "GTKColorChooserPanel.redSpinner");
	194	greenSpinner = new JSpinner(new SpinnerNumberModel(0, 0, 255, 1));
	195	configureSpinner(greenSpinner, "GTKColorChooserPanel.greenSpinner");
	196	blueSpinner = new JSpinner(new SpinnerNumberModel(0, 0, 255, 1));
	197	configureSpinner(blueSpinner, "GTKColorChooserPanel.blueSpinner");
	198
	199	colorNameTF = new JTextField(8);
	200
	201	setLayout(new GridBagLayout());
	202
	203	add(this, "GTKColorChooserPanel.hue", hueSpinner, -1, -1);
	204	add(this, "GTKColorChooserPanel.red", redSpinner, -1, -1);
	205	add(this, "GTKColorChooserPanel.saturation", saturationSpinner, -1,-1);
	206	add(this, "GTKColorChooserPanel.green", greenSpinner, -1, -1);
	207	add(this, "GTKColorChooserPanel.value", valueSpinner, -1, -1);
	208	add(this, "GTKColorChooserPanel.blue", blueSpinner, -1, -1);
	209
	210	add(new JSeparator(SwingConstants.HORIZONTAL), new
	211	GridBagConstraints(1, 3, 4, 1, 1, 0,
	212	GridBagConstraints.LINE_START, GridBagConstraints.HORIZONTAL,
	213	new Insets(14, 0, 0, 0), 0, 0));
	214
	215	add(this, "GTKColorChooserPanel.colorName", colorNameTF, 0, 4);
	216
	217	add(triangle, new GridBagConstraints(0, 0, 1, 5, 0, 0,
	218	GridBagConstraints.LINE_START, GridBagConstraints.NONE,
	219	new Insets(14, 20, 2, 9), 0, 0));
	220
	221	Box hBox = Box.createHorizontalBox();
	222	hBox.add(lastLabel);
	223	hBox.add(label);
	224	add(hBox, new GridBagConstraints(0, 5, 1, 1, 0, 0,
	225	GridBagConstraints.CENTER, GridBagConstraints.NONE,
	226	new Insets(0, 0, 0, 0), 0, 0));
	227
	228	add(new JSeparator(SwingConstants.HORIZONTAL), new
	229	GridBagConstraints(0, 6, 5, 1, 1, 0,
	230	GridBagConstraints.LINE_START, GridBagConstraints.HORIZONTAL,
	231	new Insets(12, 0, 0, 0), 0, 0));
	232	}
	233
	234	/**
	235	* Configures the spinner.
	236	*/
	237	private void configureSpinner(JSpinner spinner, String name) {
	238	spinner.addChangeListener(this);
	239	spinner.setName(name);
	240	JComponent editor = spinner.getEditor();
	241	if (editor instanceof JSpinner.DefaultEditor) {
	242	JFormattedTextField ftf = ((JSpinner.DefaultEditor)editor).
	243	getTextField();
	244
	245	ftf.setFocusLostBehavior(JFormattedTextField.COMMIT_OR_REVERT);
	246	}
	247	}
	248
	249	/**
	250	* Adds the widget creating a JLabel with the specified name.
	251	*/
	252	private void add(Container parent, String key, JComponent widget,
	253	int x, int y) {
	254	JLabel label = new JLabel(UIManager.getString(key + "Text",
	255	getLocale()));
	256	String mnemonic = (String)UIManager.get(key + "Mnemonic", getLocale());
	257
	258	if (mnemonic != null) {
	259	try {
	260	label.setDisplayedMnemonic(Integer.parseInt(mnemonic));
	261	} catch (NumberFormatException nfe) {
	262	}
	263	String mnemonicIndex = (String)UIManager.get(key + "MnemonicIndex",
	264	getLocale());
	265
	266	if (mnemonicIndex != null) {
	267	try {
	268	label.setDisplayedMnemonicIndex(Integer.parseInt(
	269	mnemonicIndex));
	270	} catch (NumberFormatException nfe) {
	271	}
	272	}
	273	}
	274	label.setLabelFor(widget);
	275	if (x < 0) {
	276	x = parent.getComponentCount() % 4;
	277	}
	278	if (y < 0) {
	279	y = parent.getComponentCount() / 4;
	280	}
	281	GridBagConstraints con = new GridBagConstraints(x + 1, y, 1, 1, 0, 0,
	282	GridBagConstraints.FIRST_LINE_END, GridBagConstraints.NONE,
	283	new Insets(4, 0, 0, 4), 0, 0);
	284	if (y == 0) {
	285	con.insets.top = 14;
	286	}
	287	parent.add(label, con);
	288	con.gridx++;
	289	parent.add(widget, con);
	290	}
	291
	292	/**
	293	* Refreshes the display from the model.
	294	*/
	295	public void updateChooser() {
	296	if (!settingColor) {
	297	lastLabel.setBackground(getColorFromModel());
	298	setColor(getColorFromModel(), true, true, false);
	299	}
	300	}
	301
	302	/**
	303	* Resets the red component of the selected color.
	304	*/
	305	private void setRed(int red) {
	306	setRGB(red << 16 \| getColor().getGreen() << 8 \| getColor().getBlue());
	307	}
	308
	309	/**
	310	* Resets the green component of the selected color.
	311	*/
	312	private void setGreen(int green) {
	313	setRGB(getColor().getRed() << 16 \| green << 8 \| getColor().getBlue());
	314	}
	315
	316	/**
	317	* Resets the blue component of the selected color.
	318	*/
	319	private void setBlue(int blue) {
	320	setRGB(getColor().getRed() << 16 \| getColor().getGreen() << 8 \| blue);
	321	}
	322
	323	/**
	324	* Sets the hue of the selected color and updates the display if
	325	* necessary.
	326	*/
	327	private void setHue(float hue, boolean update) {
	328	setHSB(hue, saturation, brightness);
	329	if (update) {
	330	settingColor = true;
	331	hueSpinner.setValue(Integer.valueOf((int)(hue * 360)));
	332	settingColor = false;
	333	}
	334	}
	335
	336	/**
	337	* Returns the current amount of hue.
	338	*/
	339	private float getHue() {
	340	return hue;
	341	}
	342
	343	/**
	344	* Resets the saturation.
	345	*/
	346	private void setSaturation(float saturation) {
	347	setHSB(hue, saturation, brightness);
	348	}
	349
	350	/**
	351	* Returns the saturation.
	352	*/
	353	private float getSaturation() {
	354	return saturation;
	355	}
	356
	357	/**
	358	* Sets the brightness.
	359	*/
	360	private void setBrightness(float brightness) {
	361	setHSB(hue, saturation, brightness);
	362	}
	363
	364	/**
	365	* Returns the brightness.
	366	*/
	367	private float getBrightness() {
	368	return brightness;
	369	}
	370
	371	/**
	372	* Sets the saturation and brightness and updates the display if
	373	* necessary.
	374	*/
	375	private void setSaturationAndBrightness(float s, float b, boolean update) {
	376	setHSB(hue, s, b);
	377	if (update) {
	378	settingColor = true;
	379	saturationSpinner.setValue(Integer.valueOf((int)(s * 255)));
	380	valueSpinner.setValue(Integer.valueOf((int)(b * 255)));
	381	settingColor = false;
	382	}
	383	}
	384
	385	/**
	386	* Resets the rgb values.
	387	*/
	388	private void setRGB(int rgb) {
	389	Color color = new Color(rgb);
	390
	391	setColor(color, false, true, true);
	392
	393	settingColor = true;
	394	hueSpinner.setValue(Integer.valueOf((int)(hue * 360)));
	395	saturationSpinner.setValue(Integer.valueOf((int)(saturation * 255)));
	396	valueSpinner.setValue(Integer.valueOf((int)(brightness * 255)));
	397	settingColor = false;
	398	}
	399
	400	/**
	401	* Resets the hsb values.
	402	*/
	403	private void setHSB(float h, float s, float b) {
	404	Color color = Color.getHSBColor(h, s, b);
	405
	406	this.hue = h;
	407	this.saturation = s;
	408	this.brightness = b;
	409	setColor(color, false, false, true);
	410
	411	settingColor = true;
	412	redSpinner.setValue(Integer.valueOf(color.getRed()));
	413	greenSpinner.setValue(Integer.valueOf(color.getGreen()));
	414	blueSpinner.setValue(Integer.valueOf(color.getBlue()));
	415	settingColor = false;
	416	}
	417
	418
	419	/**
	420	* Rests the color.
	421	*
	422	* @param color new Color
	423	* @param updateSpinners whether or not to update the spinners.
	424	* @param updateHSB if true, the hsb fields are updated based on the
	425	* new color
	426	* @param updateModel if true, the model is set.
	427	*/
	428	private void setColor(Color color, boolean updateSpinners,
	429	boolean updateHSB, boolean updateModel) {
	430	if (color == null) {
	431	color = Color.BLACK;
	432	}
	433
	434	settingColor = true;
	435
	436	if (updateHSB) {
	437	float[] hsb = Color.RGBtoHSB(color.getRed(), color.getGreen(),
	438	color.getBlue(), null);
	439	hue = hsb[0];
	440	saturation = hsb[1];
	441	brightness = hsb[2];
	442	}
	443
	444	if (updateModel) {
	445	ColorSelectionModel model = getColorSelectionModel();
	446	if (model != null) {
	447	model.setSelectedColor(color);
	448	}
	449	}
	450
	451	triangle.setColor(hue, saturation, brightness);
	452	label.setBackground(color);
	453	// Force Integer to pad the string with 0's by adding 0x1000000 and
	454	// then removing the first character.
	455	String hexString = Integer.toHexString(
	456	(color.getRGB() & 0xFFFFFF) \| 0x1000000);
	457	colorNameTF.setText("#" + hexString.substring(1));
	458
	459	if (updateSpinners) {
	460	redSpinner.setValue(Integer.valueOf(color.getRed()));
	461	greenSpinner.setValue(Integer.valueOf(color.getGreen()));
	462	blueSpinner.setValue(Integer.valueOf(color.getBlue()));
	463
	464	hueSpinner.setValue(Integer.valueOf((int)(hue * 360)));
	465	saturationSpinner.setValue(Integer.valueOf((int)(saturation * 255)));
	466	valueSpinner.setValue(Integer.valueOf((int)(brightness * 255)));
	467	}
	468	settingColor = false;
	469	}
	470
	471	public Color getColor() {
	472	return label.getBackground();
	473	}
	474
	475	/**
	476	* ChangeListener method, updates the necessary display widgets.
	477	*/
	478	public void stateChanged(ChangeEvent e) {
	479	if (settingColor) {
	480	return;
	481	}
	482	Color color = getColor();
	483
	484	if (e.getSource() == hueSpinner) {
	485	setHue(((Number)hueSpinner.getValue()).floatValue() / 360, false);
	486	}
	487	else if (e.getSource() == saturationSpinner) {
	488	setSaturation(((Number)saturationSpinner.getValue()).
	489	floatValue() / 255);
	490	}
	491	else if (e.getSource() == valueSpinner) {
	492	setBrightness(((Number)valueSpinner.getValue()).
	493	floatValue() / 255);
	494	}
	495	else if (e.getSource() == redSpinner) {
	496	setRed(((Number)redSpinner.getValue()).intValue());
	497	}
	498	else if (e.getSource() == greenSpinner) {
	499	setGreen(((Number)greenSpinner.getValue()).intValue());
	500	}
	501	else if (e.getSource() == blueSpinner) {
	502	setBlue(((Number)blueSpinner.getValue()).intValue());
	503	}
	504	}
	505
	506
	507
	508	/**
	509	* Flag indicating the angle, or hue, has changed and the triangle
	510	* needs to be recreated.
	511	*/
	512	private static final int FLAGS_CHANGED_ANGLE = 1 << 0;
	513	/**
	514	* Indicates the wheel is being dragged.
	515	*/
	516	private static final int FLAGS_DRAGGING = 1 << 1;
	517	/**
	518	* Indicates the triangle is being dragged.
	519	*/
	520	private static final int FLAGS_DRAGGING_TRIANGLE = 1 << 2;
	521	/**
	522	* Indicates a color is being set and we should ignore setColor
	523	*/
	524	private static final int FLAGS_SETTING_COLOR = 1 << 3;
	525	/**
	526	* Indicates the wheel has focus.
	527	*/
	528	private static final int FLAGS_FOCUSED_WHEEL = 1 << 4;
	529	/**
	530	* Indicates the triangle has focus.
	531	*/
	532	private static final int FLAGS_FOCUSED_TRIANGLE = 1 << 5;
	533
	534
	535	/**
	536	* Class responsible for rendering a color wheel and color triangle.
	537	*/
	538	private class ColorTriangle extends JPanel {
	539	/**
	540	* Cached image of the wheel.
	541	*/
	542	private Image wheelImage;
	543
	544	/**
	545	* Cached image of the triangle.
	546	*/
	547	private Image triangleImage;
	548
	549	/**
	550	* Angle triangle is rotated by.
	551	*/
	552	private double angle;
	553
	554	/**
	555	* Boolean bitmask.
	556	*/
	557	private int flags;
	558
	559	/**
	560	* X location of selected color indicator.
	561	*/
	562	private int circleX;
	563	/**
	564	* Y location of selected color indicator.
	565	*/
	566	private int circleY;
	567
	568
	569	public ColorTriangle() {
	570	enableEvents(AWTEvent.FOCUS_EVENT_MASK);
	571	enableEvents(AWTEvent.MOUSE_EVENT_MASK);
	572	enableEvents(AWTEvent.MOUSE_MOTION_EVENT_MASK);
	573
	574	setMinimumSize(new Dimension(getWheelRadius() * 2 + 2,
	575	getWheelRadius() * 2 + 2));
	576	setPreferredSize(new Dimension(getWheelRadius() * 2 + 2,
	577	getWheelRadius() * 2 + 2));
	578
	579	// We want to handle tab ourself.
	580	setFocusTraversalKeysEnabled(false);
	581
	582	// PENDING: this should come from the style.
	583	getInputMap().put(KeyStroke.getKeyStroke("UP"), "up");
	584	getInputMap().put(KeyStroke.getKeyStroke("DOWN"), "down");
	585	getInputMap().put(KeyStroke.getKeyStroke("LEFT"), "left");
	586	getInputMap().put(KeyStroke.getKeyStroke("RIGHT"), "right");
	587
	588	getInputMap().put(KeyStroke.getKeyStroke("KP_UP"), "up");
	589	getInputMap().put(KeyStroke.getKeyStroke("KP_DOWN"), "down");
	590	getInputMap().put(KeyStroke.getKeyStroke("KP_LEFT"), "left");
	591	getInputMap().put(KeyStroke.getKeyStroke("KP_RIGHT"), "right");
	592
	593	getInputMap().put(KeyStroke.getKeyStroke("TAB"), "focusNext");
	594	getInputMap().put(KeyStroke.getKeyStroke("shift TAB"),"focusLast");
	595
	596	ActionMap map = (ActionMap)UIManager.get(
	597	"GTKColorChooserPanel.actionMap");
	598
	599	if (map == null) {
	600	map = new ActionMapUIResource();
	601	map.put("left", new ColorAction("left", 2));
	602	map.put("right", new ColorAction("right", 3));
	603	map.put("up", new ColorAction("up", 0));
	604	map.put("down", new ColorAction("down", 1));
	605	map.put("focusNext", new ColorAction("focusNext", 4));
	606	map.put("focusLast", new ColorAction("focusLast", 5));
	607	UIManager.getLookAndFeelDefaults().put(
	608	"GTKColorChooserPanel.actionMap", map);
	609	}
	610	SwingUtilities.replaceUIActionMap(this, map);
	611	}
	612
	613	/**
	614	* Returns the GTKColorChooserPanel.
	615	*/
	616	GTKColorChooserPanel getGTKColorChooserPanel() {
	617	return GTKColorChooserPanel.this;
	618	}
	619
	620	/**
	621	* Gives focus to the wheel.
	622	*/
	623	void focusWheel() {
	624	setFocusType(1);
	625	}
	626
	627	/**
	628	* Gives focus to the triangle.
	629	*/
	630	void focusTriangle() {
	631	setFocusType(2);
	632	}
	633
	634	/**
	635	* Returns true if the wheel currently has focus.
	636	*/
	637	boolean isWheelFocused() {
	638	return isSet(FLAGS_FOCUSED_WHEEL);
	639	}
	640
	641	/**
	642	* Resets the selected color.
	643	*/
	644	public void setColor(float h, float s, float b) {
	645	if (isSet(FLAGS_SETTING_COLOR)) {
	646	return;
	647	}
	648
	649	setAngleFromHue(h);
	650	setSaturationAndBrightness(s, b);
	651	}
	652
	653	/**
	654	* Returns the selected color.
	655	*/
	656	public Color getColor() {
	657	return GTKColorChooserPanel.this.getColor();
	658	}
	659
	660	/**
	661	* Returns the x location of the selected color indicator.
	662	*/
	663	int getColorX() {
	664	return circleX + getIndicatorSize() / 2 - getWheelXOrigin();
	665	}
	666
	667	/**
	668	* Returns the y location of the selected color indicator.
	669	*/
	670	int getColorY() {
	671	return circleY + getIndicatorSize() / 2 - getWheelYOrigin();
	672	}
	673
	674	protected void processEvent(AWTEvent e) {
	675	if (e.getID() == MouseEvent.MOUSE_PRESSED \|\|
	676	((isSet(FLAGS_DRAGGING) \|\|isSet(FLAGS_DRAGGING_TRIANGLE)) &&
	677	e.getID() == MouseEvent.MOUSE_DRAGGED)) {
	678	// Assign focus to either the wheel or triangle and attempt
	679	// to drag either the wheel or triangle.
	680	int size = getWheelRadius();
	681	int x = ((MouseEvent)e).getX() - size;
	682	int y = ((MouseEvent)e).getY() - size;
	683
	684	if (!hasFocus()) {
	685	requestFocus();
	686	}
	687	if (!isSet(FLAGS_DRAGGING_TRIANGLE) &&
	688	adjustHue(x, y, e.getID() == MouseEvent.MOUSE_PRESSED)) {
	689	setFlag(FLAGS_DRAGGING, true);
	690	setFocusType(1);
	691	}
	692	else if (adjustSB(x, y, e.getID() ==
	693	MouseEvent.MOUSE_PRESSED)) {
	694	setFlag(FLAGS_DRAGGING_TRIANGLE, true);
	695	setFocusType(2);
	696	}
	697	else {
	698	setFocusType(2);
	699	}
	700	}
	701	else if (e.getID() == MouseEvent.MOUSE_RELEASED) {
	702	// Stopped dragging
	703	setFlag(FLAGS_DRAGGING_TRIANGLE, false);
	704	setFlag(FLAGS_DRAGGING, false);
	705	}
	706	else if (e.getID() == FocusEvent.FOCUS_LOST) {
	707	// Reset the flags to indicate no one has focus
	708	setFocusType(0);
	709	}
	710	else if (e.getID() == FocusEvent.FOCUS_GAINED) {
	711	// Gained focus, reassign focus to the wheel if no one
	712	// currently has focus.
	713	if (!isSet(FLAGS_FOCUSED_TRIANGLE) &&
	714	!isSet(FLAGS_FOCUSED_WHEEL)) {
	715	setFlag(FLAGS_FOCUSED_WHEEL, true);
	716	setFocusType(1);
	717	}
	718	repaint();
	719	}
	720	super.processEvent(e);
	721	}
	722
	723	public void paintComponent(Graphics g) {
	724	super.paintComponent(g);
	725
	726	// Draw the wheel and triangle
	727	int size = getWheelRadius();
	728	int width = getWheelWidth();
	729	Image image = getImage(size);
	730	g.drawImage(image, getWheelXOrigin() - size,
	731	getWheelYOrigin() - size, null);
	732
	733	// Draw the focus indicator for the wheel
	734	if (hasFocus() && isSet(FLAGS_FOCUSED_WHEEL)) {
	735	g.setColor(Color.BLACK);
	736	g.drawOval(getWheelXOrigin() - size, getWheelYOrigin() - size,
	737	2 * size, 2 * size);
	738	g.drawOval(getWheelXOrigin() - size + width, getWheelYOrigin()-
	739	size + width, 2 * (size - width), 2 *
	740	(size - width));
	741	}
	742
	743	// Draw a line on the wheel indicating the selected hue.
	744	if (Math.toDegrees(Math.PI * 2 - angle) <= 20 \|\|
	745	Math.toDegrees(Math.PI * 2 - angle) >= 201) {
	746	g.setColor(Color.WHITE);
	747	}
	748	else {
	749	g.setColor(Color.BLACK);
	750	}
	751	int lineX0 = (int)(Math.cos(angle) * size);
	752	int lineY0 = (int)(Math.sin(angle) * size);
	753	int lineX1 = (int)(Math.cos(angle) * (size - width));
	754	int lineY1 = (int)(Math.sin(angle) * (size - width));
	755	g.drawLine(lineX0 + size, lineY0 + size, lineX1 + size,
	756	lineY1 + size);
	757
	758	// Draw the focus indicator on the triangle
	759	if (hasFocus() && isSet(FLAGS_FOCUSED_TRIANGLE)) {
	760	Graphics g2 = g.create();
	761	int innerR = getTriangleCircumscribedRadius();
	762	int a = (int)(3 * innerR / Math.sqrt(3));
	763	g2.translate(getWheelXOrigin(), getWheelYOrigin());
	764	((Graphics2D)g2).rotate(angle + Math.PI / 2);
	765	g2.setColor(Color.BLACK);
	766	g2.drawLine(0, -innerR, a / 2, innerR / 2);
	767	g2.drawLine(a / 2, innerR / 2, -a / 2, innerR / 2);
	768	g2.drawLine(-a / 2, innerR / 2, 0, -innerR);
	769	g2.dispose();
	770	}
	771
	772	// Draw the selected color indicator.
	773	g.setColor(Color.BLACK);
	774	g.drawOval(circleX, circleY, getIndicatorSize() - 1,
	775	getIndicatorSize() - 1);
	776	g.setColor(Color.WHITE);
	777	g.drawOval(circleX + 1, circleY + 1, getIndicatorSize() - 3,
	778	getIndicatorSize() - 3);
	779	}
	780
	781	/**
	782	* Returns an image representing the triangle and wheel.
	783	*/
	784	private Image getImage(int size) {
	785	if (!isSet(FLAGS_CHANGED_ANGLE) && wheelImage != null &&
	786	wheelImage.getWidth(null) == size * 2) {
	787	return wheelImage;
	788	}
	789	if (wheelImage == null \|\| wheelImage.getWidth(null) != size) {
	790	wheelImage = getWheelImage(size);
	791	}
	792	int innerR = getTriangleCircumscribedRadius();
	793	int triangleSize = (int)(innerR * 3.0 / 2.0);
	794	int a = (int)(2 * triangleSize / Math.sqrt(3));
	795	if (triangleImage == null \|\| triangleImage.getWidth(null) != a) {
	796	triangleImage = new BufferedImage(a, a,
	797	BufferedImage.TYPE_INT_ARGB);
	798	}
	799	Graphics g = triangleImage.getGraphics();
	800	g.setColor(new Color(0, 0, 0, 0));
	801	g.fillRect(0, 0, a, a);
	802	g.translate(a / 2, 0);
	803	paintTriangle(g, triangleSize, getColor());
	804	g.translate(-a / 2, 0);
	805	g.dispose();
	806
	807	g = wheelImage.getGraphics();
	808	g.setColor(new Color(0, 0, 0, 0));
	809	g.fillOval(getWheelWidth(), getWheelWidth(),
	810	2 * (size - getWheelWidth()),
	811	2 * (size - getWheelWidth()));
	812
	813	double rotate = Math.toRadians(-30.0) + angle;
	814	g.translate(size, size);
	815	((Graphics2D)g).rotate(rotate);
	816	g.drawImage(triangleImage, -a / 2,
	817	getWheelWidth() - size, null);
	818	((Graphics2D)g).rotate(-rotate);
	819	g.translate(a / 2, size - getWheelWidth());
	820
	821	setFlag(FLAGS_CHANGED_ANGLE, false);
	822
	823	return wheelImage;
	824	}
	825
	826	private void paintTriangle(Graphics g, int size, Color color) {
	827	float[] colors = Color.RGBtoHSB(color.getRed(),
	828	color.getGreen(),
	829	color.getBlue(), null);
	830	float hue = colors[0];
	831	double dSize = (double)size;
	832	for (int y = 0; y < size; y++) {
	833	int maxX = (int)(y * Math.tan(Math.toRadians(30.0)));
	834	float factor = maxX * 2;
	835	if (maxX > 0) {
	836	float value = (float)(y / dSize);
	837	for (int x = -maxX; x <= maxX; x++) {
	838	float saturation = (float)x / factor + .5f;
	839	g.setColor(Color.getHSBColor(hue, saturation, value));
	840	g.fillRect(x, y, 1, 1);
	841	}
	842	}
	843	else {
	844	g.setColor(color);
	845	g.fillRect(0, y, 1, 1);
	846	}
	847	}
	848	}
	849
	850	/**
	851	* Returns a color wheel image for the specified size.
	852	*
	853	* @param size Integer giving size of color wheel.
	854	* @return Color wheel image
	855	*/
	856	private Image getWheelImage(int size) {
	857	int minSize = size - getWheelWidth();
	858	int doubleSize = size * 2;
	859	BufferedImage image = new BufferedImage(doubleSize, doubleSize,
	860	BufferedImage.TYPE_INT_ARGB);
	861
	862	for (int y = -size; y < size; y++) {
	863	int ySquared = y * y;
	864	for (int x = -size; x < size; x++) {
	865	double rad = Math.sqrt(ySquared + x * x);
	866
	867	if (rad < size && rad > minSize) {
	868	int rgb = colorWheelLocationToRGB(x, y, rad) \|
	869	0xFF000000;
	870	image.setRGB(x + size, y + size, rgb);
	871	}
	872	}
	873	}
	874	wheelImage = image;
	875	return wheelImage;
	876	}
	877
	878	/**
	879	* Adjusts the saturation and brightness. <code>x</code> and
	880	* <code>y</code> give the location to adjust to and are relative
	881	* to the origin of the wheel/triangle.
	882	*
	883	* @param x X coordinate on the triangle to adjust to
	884	* @param y Y coordinate on the triangle to adjust to
	885	* @param checkLoc if true the location is checked to make sure
	886	* it is contained in the triangle, if false the location is
	887	* constrained to fit in the triangle.
	888	* @return true if the location is valid
	889	*/
	890	boolean adjustSB(int x, int y, boolean checkLoc) {
	891	int innerR = getWheelRadius() - getWheelWidth();
	892	boolean resetXY = false;
	893	// Invert the axis.
	894	y = -y;
	895	if (checkLoc && (x < -innerR \|\| x > innerR \|\| y < -innerR \|\|
	896	y > innerR)) {
	897	return false;
	898	}
	899	// Rotate to origin and and verify x is valid.
	900	int triangleSize = innerR * 3 / 2;
	901	double x1 = Math.cos(angle) * x - Math.sin(angle) * y;
	902	double y1 = Math.sin(angle) * x + Math.cos(angle) * y;
	903	if (x1 < -(innerR / 2)) {
	904	if (checkLoc) {
	905	return false;
	906	}
	907	x1 = -innerR / 2;
	908	resetXY = true;
	909	}
	910	else if ((int)x1 > innerR) {
	911	if (checkLoc) {
	912	return false;
	913	}
	914	x1 = innerR;
	915	resetXY = true;
	916	}
	917	// Verify y location is valid.
	918	int maxY = (int)((triangleSize - x1 - innerR / 2.0) *
	919	Math.tan(Math.toRadians(30.0)));
	920	if (y1 <= -maxY) {
	921	if (checkLoc) {
	922	return false;
	923	}
	924	y1 = -maxY;
	925	resetXY = true;
	926	}
	927	else if (y1 > maxY) {
	928	if (checkLoc) {
	929	return false;
	930	}
	931	y1 = maxY;
	932	resetXY = true;
	933	}
	934	// Rotate again to determine value and scale
	935	double x2 = Math.cos(Math.toRadians(-30.0)) * x1 -
	936	Math.sin(Math.toRadians(-30.0)) * y1;
	937	double y2 = Math.sin(Math.toRadians(-30.0)) * x1 +
	938	Math.cos(Math.toRadians(-30.0)) * y1;
	939	float value = Math.min(1.0f, (float)((innerR - y2) /
	940	(double)triangleSize));
	941	float maxX = (float)(Math.tan(Math.toRadians(30)) * (innerR - y2));
	942	float saturation = Math.min(1.0f, (float)(x2 / maxX / 2 + .5));
	943
	944	setFlag(FLAGS_SETTING_COLOR, true);
	945	if (resetXY) {
	946	setSaturationAndBrightness(saturation, value);
	947	}
	948	else {
	949	setSaturationAndBrightness(saturation, value, x +
	950	getWheelXOrigin(),getWheelYOrigin() - y);
	951	}
	952	GTKColorChooserPanel.this.setSaturationAndBrightness(saturation,
	953	value, true);
	954	setFlag(FLAGS_SETTING_COLOR, false);
	955	return true;
	956	}
	957
	958	/**
	959	* Sets the saturation and brightness.
	960	*/
	961	private void setSaturationAndBrightness(float s, float b) {
	962	int innerR = getTriangleCircumscribedRadius();
	963	int triangleSize = innerR * 3 / 2;
	964	double x = b * triangleSize;
	965	double maxY = x * Math.tan(Math.toRadians(30.0));
	966	double y = 2 * maxY * s - maxY;
	967	x = x - innerR;
	968	double x1 = Math.cos(Math.toRadians(-60.0) - angle) *
	969	x - Math.sin(Math.toRadians(-60.0) - angle) * y;
	970	double y1 = Math.sin(Math.toRadians(-60.0) - angle) * x +
	971	Math.cos(Math.toRadians(-60.0) - angle) * y;
	972	int newCircleX = (int)x1 + getWheelXOrigin();
	973	int newCircleY = getWheelYOrigin() - (int)y1;
	974
	975	setSaturationAndBrightness(s, b, newCircleX, newCircleY);
	976	}
	977
	978
	979	/**
	980	* Sets the saturation and brightness.
	981	*/
	982	private void setSaturationAndBrightness(float s, float b,
	983	int newCircleX, int newCircleY) {
	984	newCircleX -= getIndicatorSize() / 2;
	985	newCircleY -= getIndicatorSize() / 2;
	986
	987	int minX = Math.min(newCircleX, circleX);
	988	int minY = Math.min(newCircleY, circleY);
	989
	990	repaint(minX, minY, Math.max(circleX, newCircleX) - minX +
	991	getIndicatorSize() + 1, Math.max(circleY, newCircleY) -
	992	minY + getIndicatorSize() + 1);
	993	circleX = newCircleX;
	994	circleY = newCircleY;
	995	}
	996
	997	/**
	998	* Adjusts the hue based on the passed in location.
	999	*
	1000	* @param x X location to adjust to, relative to the origin of the
	1001	* wheel
	1002	* @param y Y location to adjust to, relative to the origin of the
	1003	* wheel
	1004	* @param check if true the location is checked to make sure
	1005	* it is contained in the wheel, if false the location is
	1006	* constrained to fit in the wheel
	1007	* @return true if the location is valid.
	1008	*/
	1009	private boolean adjustHue(int x, int y, boolean check) {
	1010	double rad = Math.sqrt(x * x + y * y);
	1011	int size = getWheelRadius();
	1012
	1013	if (!check \|\| (rad >= size - getWheelWidth() && rad < size)) {
	1014	// Map the location to an angle and reset hue
	1015	double angle;
	1016	if (x == 0) {
	1017	if (y > 0) {
	1018	angle = Math.PI / 2.0;
	1019	}
	1020	else {
	1021	angle = Math.PI + Math.PI / 2.0;
	1022	}
	1023	}
	1024	else {
	1025	angle = Math.atan((double)y / (double)x);
	1026	if (x < 0) {
	1027	angle += Math.PI;
	1028	}
	1029	else if (angle < 0) {
	1030	angle += 2 * Math.PI;
	1031	}
	1032	}
	1033	setFlag(FLAGS_SETTING_COLOR, true);
	1034	setHue((float)(1.0 - angle / Math.PI / 2), true);
	1035	setFlag(FLAGS_SETTING_COLOR, false);
	1036	setHueAngle(angle);
	1037	setSaturationAndBrightness(getSaturation(), getBrightness());
	1038	return true;
	1039	}
	1040	return false;
	1041	}
	1042
	1043	/**
	1044	* Rotates the triangle to accomodate the passed in hue.
	1045	*/
	1046	private void setAngleFromHue(float hue) {
	1047	setHueAngle((1.0 - hue) * Math.PI * 2);
	1048	}
	1049
	1050	/**
	1051	* Sets the angle representing the hue.
	1052	*/
	1053	private void setHueAngle(double angle) {
	1054	double oldAngle = this.angle;
	1055
	1056	this.angle = angle;
	1057	if (angle != oldAngle) {
	1058	setFlag(FLAGS_CHANGED_ANGLE, true);
	1059	repaint();
	1060	}
	1061	}
	1062
	1063	/**
	1064	* Returns the size of the color indicator.
	1065	*/
	1066	private int getIndicatorSize() {
	1067	return 8;
	1068	}
	1069
	1070	/**
	1071	* Returns the circumscribed radius of the triangle.
	1072	*/
	1073	private int getTriangleCircumscribedRadius() {
	1074	return 72;
	1075	}
	1076
	1077	/**
	1078	* Returns the x origin of the wheel and triangle.
	1079	*/
	1080	private int getWheelXOrigin() {
	1081	return 85;
	1082	}
	1083
	1084	/**
	1085	* Returns y origin of the wheel and triangle.
	1086	*/
	1087	private int getWheelYOrigin() {
	1088	return 85;
	1089	}
	1090
	1091	/**
	1092	* Returns the width of the wheel.
	1093	*/
	1094	private int getWheelWidth() {
	1095	return 13;
	1096	}
	1097
	1098	/**
	1099	* Sets the focus to one of: 0 no one, 1 the wheel or 2 the triangle.
	1100	*/
	1101	private void setFocusType(int type) {
	1102	if (type == 0) {
	1103	setFlag(FLAGS_FOCUSED_WHEEL, false);
	1104	setFlag(FLAGS_FOCUSED_TRIANGLE, false);
	1105	repaint();
	1106	}
	1107	else {
	1108	int toSet = FLAGS_FOCUSED_WHEEL;
	1109	int toUnset = FLAGS_FOCUSED_TRIANGLE;
	1110
	1111	if (type == 2) {
	1112	toSet = FLAGS_FOCUSED_TRIANGLE;
	1113	toUnset = FLAGS_FOCUSED_WHEEL;
	1114	}
	1115	if (!isSet(toSet)) {
	1116	setFlag(toSet, true);
	1117	repaint();
	1118	setFlag(toUnset, false);
	1119	}
	1120	}
	1121	}
	1122
	1123	/**
	1124	* Returns the radius of the wheel.
	1125	*/
	1126	private int getWheelRadius() {
	1127	// As far as I can tell, GTK doesn't allow stretching this
	1128	// widget
	1129	return 85;
	1130	}
	1131
	1132	/**
	1133	* Updates the flags bitmask.
	1134	*/
	1135	private void setFlag(int flag, boolean value) {
	1136	if (value) {
	1137	flags \|= flag;
	1138	}
	1139	else {
	1140	flags &= ~flag;
	1141	}
	1142	}
	1143
	1144	/**
	1145	* Returns true if a particular flag has been set.
	1146	*/
	1147	private boolean isSet(int flag) {
	1148	return ((flags & flag) == flag);
	1149	}
	1150
	1151	/**
	1152	* Returns the RGB color to use for the specified location. The
	1153	* passed in point must be on the color wheel and be relative to the
	1154	* origin of the color wheel.
	1155	*
	1156	* @param x X location to get color for
	1157	* @param y Y location to get color for
	1158	* @param rad Radius from center of color wheel
	1159	* @return integer with red, green and blue components
	1160	*/
	1161	private int colorWheelLocationToRGB(int x, int y, double rad) {
	1162	double angle = Math.acos((double)x / rad);
	1163	int rgb;
	1164
	1165	if (angle < PI_3) {
	1166	if (y < 0) {
	1167	// FFFF00 - FF0000
	1168	rgb = 0xFF0000 \| Math.min(255,
	1169	(int)(255 * angle / PI_3)) << 8;
	1170	}
	1171	else {
	1172	// FF0000 - FF00FF
	1173	rgb = 0xFF0000 \| Math.min(255,
	1174	(int)(255 * angle / PI_3));
	1175	}
	1176	}
	1177	else if (angle < 2 * PI_3) {
	1178	angle -= PI_3;
	1179	if (y < 0) {
	1180	// 00FF00 - FFFF00
	1181	rgb = 0x00FF00 \| Math.max(0, 255 -
	1182	(int)(255 * angle / PI_3)) << 16;
	1183	}
	1184	else {
	1185	// FF00FF - 0000FF
	1186	rgb = 0x0000FF \| Math.max(0, 255 -
	1187	(int)(255 * angle / PI_3)) << 16;
	1188	}
	1189	}
	1190	else {
	1191	angle -= 2 * PI_3;
	1192	if (y < 0) {
	1193	// 00FFFF - 00FF00
	1194	rgb = 0x00FF00 \| Math.min(255,
	1195	(int)(255 * angle / PI_3));
	1196	}
	1197	else {
	1198	// 0000FF - 00FFFF
	1199	rgb = 0x0000FF \| Math.min(255,
	1200	(int)(255 * angle / PI_3)) << 8;
	1201	}
	1202	}
	1203	return rgb;
	1204	}
	1205
	1206	/**
	1207	* Increments the hue.
	1208	*/
	1209	void incrementHue(boolean positive) {
	1210	float hue = triangle.getGTKColorChooserPanel().getHue();
	1211
	1212	if (positive) {
	1213	hue += 1.0f / 360.0f;
	1214	}
	1215	else {
	1216	hue -= 1.0f / 360.0f;
	1217	}
	1218	if (hue > 1) {
	1219	hue -= 1;
	1220	}
	1221	else if (hue < 0) {
	1222	hue += 1;
	1223	}
	1224	getGTKColorChooserPanel().setHue(hue, true);
	1225	}
	1226	}
	1227
	1228
	1229	/**
	1230	* Action class used for colors.
	1231	*/
	1232	private static class ColorAction extends AbstractAction {
	1233	private int type;
	1234
	1235	ColorAction(String name, int type) {
	1236	super(name);
	1237	this.type = type;
	1238	}
	1239
	1240	public void actionPerformed(ActionEvent e) {
	1241	ColorTriangle triangle = (ColorTriangle)e.getSource();
	1242
	1243	if (triangle.isWheelFocused()) {
	1244	float hue = triangle.getGTKColorChooserPanel().getHue();
	1245
	1246	switch (type) {
	1247	case 0:
	1248	case 2:
	1249	triangle.incrementHue(true);
	1250	break;
	1251	case 1:
	1252	case 3:
	1253	triangle.incrementHue(false);
	1254	break;
	1255	case 4:
	1256	triangle.focusTriangle();
	1257	break;
	1258	case 5:
	1259	compositeRequestFocus(triangle, false);
	1260	break;
	1261	}
	1262	}
	1263	else {
	1264	int xDelta = 0;
	1265	int yDelta = 0;
	1266
	1267	switch (type) {
	1268	case 0:
	1269	// up
	1270	yDelta--;
	1271	break;
	1272	case 1:
	1273	// down
	1274	yDelta++;
	1275	break;
	1276	case 2:
	1277	// left
	1278	xDelta--;
	1279	break;
	1280	case 3:
	1281	// right
	1282	xDelta++;
	1283	break;
	1284	case 4:
	1285	compositeRequestFocus(triangle, true);
	1286	return;
	1287	case 5:
	1288	triangle.focusWheel();
	1289	return;
	1290	}
	1291	triangle.adjustSB(triangle.getColorX() + xDelta,
	1292	triangle.getColorY() + yDelta, true);
	1293	}
	1294	}
	1295	}
	1296
	1297
	1298	private class OpaqueLabel extends JLabel {
	1299	public boolean isOpaque() {
	1300	return true;
	1301	}
	1302	}
	1303	}

java/pkg/com/sun/java/swing/plaf/gtk/GTKColorType.java+167−0

@@ -0,0 +1,167 @@
	1	/*
	2	* Copyright (c) 2002, 2003, 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	package com.sun.java.swing.plaf.gtk;
	26
	27	import javax.swing.plaf.synth.ColorType;
	28	import java.awt.Color;
	29	import javax.swing.plaf.ColorUIResource;
	30
	31	/**
	32	* @author Scott Violet
	33	*/
	34	public class GTKColorType extends ColorType {
	35	// GTK allows you to specify the foreground and background in a
	36	// gtkrc, the rest (dark, mid, light) are calculated from these
	37	// values.
	38	public static final ColorType LIGHT = new GTKColorType("Light");
	39	public static final ColorType DARK = new GTKColorType("Dark");
	40	public static final ColorType MID = new GTKColorType("Mid");
	41	public static final ColorType BLACK = new GTKColorType("Black");
	42	public static final ColorType WHITE = new GTKColorType("White");
	43
	44	public static final int MAX_COUNT;
	45
	46	private static final float[] HLS_COLORS = new float[3];
	47	private static final Object HLS_COLOR_LOCK = new Object();
	48
	49	static {
	50	MAX_COUNT = WHITE.getID() + 1;
	51	}
	52
	53	private static int hlsToRGB(float h, float l, float s) {
	54	float m2 = (l <= .5f) ? (l * (1 + s)) : (l + s - l * s);
	55	float m1 = 2.0f * l - m2;
	56	float r, g, b;
	57
	58	if (s == 0.0) {
	59	if (h == 0.0) {
	60	r = g = b = l;
	61	}
	62	else {
	63	r = g = b = 0;
	64	}
	65	}
	66	else {
	67	r = hlsValue(m1, m2, h + 120);
	68	g = hlsValue(m1, m2, h);
	69	b = hlsValue(m1, m2, h - 120);
	70	}
	71	return (((int)(r * 255)) << 16) \| (((int)(g * 255.0)) << 8) \|
	72	((int)(b * 255));
	73	}
	74
	75	private static float hlsValue(float n1, float n2, float h) {
	76	if (h > 360) {
	77	h -= 360;
	78	}
	79	else if (h < 0) {
	80	h += 360;
	81	}
	82	if (h < 60) {
	83	return n1 + (n2 - n1) * h / 60.0f;
	84	}
	85	else if (h < 180) {
	86	return n2;
	87	}
	88	else if (h < 240) {
	89	return n1 + (n2 - n1) * (240.0f - h) / 60.0f;
	90	}
	91	return n1;
	92	}
	93
	94	/**
	95	* Converts from RGB color space to HLS colorspace.
	96	*/
	97	private static float[] rgbToHLS(int rgb, float[] hls) {
	98	float r = ((rgb & 0xFF0000) >> 16) / 255.0f;
	99	float g = ((rgb & 0xFF00) >> 8) / 255.0f;
	100	float b = (rgb & 0xFF) / 255.0f;
	101
	102	/* calculate lightness */
	103	float max = Math.max(Math.max(r, g), b);
	104	float min = Math.min(Math.min(r, g), b);
	105	float l = (max + min) / 2.0f;
	106	float s = 0;
	107	float h = 0;
	108
	109	if (max != min) {
	110	float delta = max - min;
	111	s = (l <= .5f) ? (delta / (max + min)) : (delta / (2.0f - max -min));
	112	if (r == max) {
	113	h = (g - b) / delta;
	114	}
	115	else if (g == max) {
	116	h = 2.0f + (b - r) / delta;
	117	}
	118	else {
	119	h = 4.0f + (r - g) / delta;
	120	}
	121	h *= 60.0f;
	122	if (h < 0) {
	123	h += 360.0f;
	124	}
	125	}
	126	if (hls == null) {
	127	hls = new float[3];
	128	}
	129	hls[0] = h;
	130	hls[1] = l;
	131	hls[2] = s;
	132	return hls;
	133	}
	134
	135	/**
	136	* Creates and returns a new color derived from the passed in color.
	137	* The transformation is done in the HLS color space using the specified
	138	* arguments to scale.
	139	*
	140	* @param color Color to alter
	141	* @param hFactory Amount to scale the hue
	142	* @param lFactor Amount to scale the lightness
	143	* @param sFactory Amount to sacle saturation
	144	* @return newly created color
	145	*/
	146	static Color adjustColor(Color color, float hFactor, float lFactor,
	147	float sFactor) {
	148	float h;
	149	float l;
	150	float s;
	151
	152	synchronized(HLS_COLOR_LOCK) {
	153	float[] hls = rgbToHLS(color.getRGB(), HLS_COLORS);
	154	h = hls[0];
	155	l = hls[1];
	156	s = hls[2];
	157	}
	158	h = Math.min(360, hFactor * h);
	159	l = Math.min(1, lFactor * l);
	160	s = Math.min(1, sFactor * s);
	161	return new ColorUIResource(hlsToRGB(h, l, s));
	162	}
	163
	164	protected GTKColorType(String name) {
	165	super(name);
	166	}
	167	}

java/pkg/com/sun/java/swing/plaf/gtk/GTKConstants.java+118−0

@@ -0,0 +1,118 @@
	1	/*
	2	* Copyright (c) 2002, 2005, 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	package com.sun.java.swing.plaf.gtk;
	26
	27	/**
	28	* @author Scott Violet
	29	*/
	30	public interface GTKConstants {
	31
	32	/**
	33	* Used to indicate a constant is not defined.
	34	*/
	35	public static final int UNDEFINED = -100;
	36
	37	/**
	38	* Java representation of native GtkIconSize enum
	39	*/
	40	public enum IconSize {
	41	INVALID,
	42	MENU,
	43	SMALL_TOOLBAR,
	44	LARGE_TOOLBAR,
	45	BUTTON,
	46	DND,
	47	DIALOG
	48	}
	49
	50	/**
	51	* Java representation of native GtkTextDirection enum
	52	*/
	53	public enum TextDirection {
	54	NONE,
	55	LTR,
	56	RTL
	57	}
	58
	59	/**
	60	* Java representation of native GtkShadowType enum
	61	*/
	62	public enum ShadowType {
	63	NONE,
	64	IN,
	65	OUT,
	66	ETCHED_IN,
	67	ETCHED_OUT
	68	}
	69
	70	/**
	71	* Java representation of native GtkStateType enum
	72	*/
	73	public enum StateType {
	74	NORMAL,
	75	ACTIVE,
	76	PRELIGHT,
	77	SELECTED,
	78	INSENSITIVE
	79	}
	80
	81	/**
	82	* Java representation of native GtkExpanderStyle enum
	83	*/
	84	public enum ExpanderStyle {
	85	COLLAPSED,
	86	SEMI_COLLAPSED,
	87	SEMI_EXPANDED,
	88	EXPANDED,
	89	}
	90
	91	/**
	92	* Java representation of native GtkPositionType enum
	93	*/
	94	public enum PositionType {
	95	LEFT,
	96	RIGHT,
	97	TOP,
	98	BOTTOM
	99	}
	100
	101	/**
	102	* Java representation of native GtkArrowType enum
	103	*/
	104	public enum ArrowType {
	105	UP,
	106	DOWN,
	107	LEFT,
	108	RIGHT
	109	}
	110
	111	/**
	112	* Java representation of native GtkOrientation enum
	113	*/
	114	public enum Orientation {
	115	HORIZONTAL,
	116	VERTICAL
	117	}
	118	}

java/pkg/com/sun/java/swing/plaf/gtk/GTKEngine.java+635−0

@@ -0,0 +1,635 @@
	1	/*
	2	* Copyright (c) 2005, 2007, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.swing.plaf.gtk;
	27
	28	import java.awt.*;
	29	import java.awt.image.*;
	30	import java.util.HashMap;
	31	import javax.swing.*;
	32	import javax.swing.plaf.synth.*;
	33
	34	import com.sun.java.swing.plaf.gtk.GTKConstants.ArrowType;
	35	import com.sun.java.swing.plaf.gtk.GTKConstants.ExpanderStyle;
	36	import com.sun.java.swing.plaf.gtk.GTKConstants.Orientation;
	37	import com.sun.java.swing.plaf.gtk.GTKConstants.PositionType;
	38	import com.sun.java.swing.plaf.gtk.GTKConstants.ShadowType;
	39	import com.sun.java.swing.plaf.gtk.GTKConstants.TextDirection;
	40
	41	import sun.awt.image.SunWritableRaster;
	42	import sun.swing.ImageCache;
	43
	44	/**
	45	* GTKEngine delegates all painting job to native GTK libraries.
	46	*
	47	* Painting with GTKEngine looks like this:
	48	* First, startPainting() is called. It prepares an offscreen buffer of the
	49	* required size.
	50	* Then, any number of paintXXX() methods can be called. They effectively ignore
	51	* the Graphics parameter and draw to the offscreen buffer.
	52	* Finally, finishPainting() should be called. It fills the data buffer passed
	53	* in with the image data.
	54	*
	55	* @author Josh Outwater
	56	*/
	57	class GTKEngine {
	58
	59	final static GTKEngine INSTANCE = new GTKEngine();
	60
	61	/** Size of the image cache */
	62	private static final int CACHE_SIZE = 50;
	63
	64	/** This enum mirrors that in gtk2_interface.h */
	65	static enum WidgetType {
	66	BUTTON, CHECK_BOX, CHECK_BOX_MENU_ITEM, COLOR_CHOOSER,
	67	COMBO_BOX, COMBO_BOX_ARROW_BUTTON, COMBO_BOX_TEXT_FIELD,
	68	DESKTOP_ICON, DESKTOP_PANE, EDITOR_PANE, FORMATTED_TEXT_FIELD,
	69	HANDLE_BOX, HPROGRESS_BAR,
	70	HSCROLL_BAR, HSCROLL_BAR_BUTTON_LEFT, HSCROLL_BAR_BUTTON_RIGHT,
	71	HSCROLL_BAR_TRACK, HSCROLL_BAR_THUMB,
	72	HSEPARATOR, HSLIDER, HSLIDER_TRACK, HSLIDER_THUMB, HSPLIT_PANE_DIVIDER,
	73	INTERNAL_FRAME, INTERNAL_FRAME_TITLE_PANE, IMAGE, LABEL, LIST, MENU,
	74	MENU_BAR, MENU_ITEM, MENU_ITEM_ACCELERATOR, OPTION_PANE, PANEL,
	75	PASSWORD_FIELD, POPUP_MENU, POPUP_MENU_SEPARATOR,
	76	RADIO_BUTTON, RADIO_BUTTON_MENU_ITEM, ROOT_PANE, SCROLL_PANE,
	77	SPINNER, SPINNER_ARROW_BUTTON, SPINNER_TEXT_FIELD,
	78	SPLIT_PANE, TABBED_PANE, TABBED_PANE_TAB_AREA, TABBED_PANE_CONTENT,
	79	TABBED_PANE_TAB, TABLE, TABLE_HEADER, TEXT_AREA, TEXT_FIELD, TEXT_PANE,
	80	TITLED_BORDER,
	81	TOGGLE_BUTTON, TOOL_BAR, TOOL_BAR_DRAG_WINDOW, TOOL_BAR_SEPARATOR,
	82	TOOL_TIP, TREE, TREE_CELL, VIEWPORT, VPROGRESS_BAR,
	83	VSCROLL_BAR, VSCROLL_BAR_BUTTON_UP, VSCROLL_BAR_BUTTON_DOWN,
	84	VSCROLL_BAR_TRACK, VSCROLL_BAR_THUMB,
	85	VSEPARATOR, VSLIDER, VSLIDER_TRACK, VSLIDER_THUMB,
	86	VSPLIT_PANE_DIVIDER
	87	}
	88
	89	/**
	90	* Representation of GtkSettings properties.
	91	* When we need more settings we can add them here and
	92	* to all implementations of getGTKSetting().
	93	*/
	94	static enum Settings {
	95	GTK_FONT_NAME,
	96	GTK_ICON_SIZES
	97	}
	98
	99	/* Custom regions are needed for representing regions that don't exist
	100	* in the original Region class.
	101	*/
	102	static class CustomRegion extends Region {
	103	/*
	104	* TITLED_BORDER Region is mapped to GtkFrame class which can draw
	105	* titled borders around components.
	106	*/
	107	static Region TITLED_BORDER = new CustomRegion("TitledBorder");
	108
	109	private CustomRegion(String name) {
	110	super(name, null, false);
	111	}
	112	}
	113
	114
	115	private static HashMap<Region, Object> regionToWidgetTypeMap;
	116	private ImageCache cache = new ImageCache(CACHE_SIZE);
	117	private int x0, y0, w0, h0;
	118	private Graphics graphics;
	119	private Object[] cacheArgs;
	120
	121	private native void native_paint_arrow(
	122	int widgetType, int state, int shadowType, String detail,
	123	int x, int y, int width, int height, int arrowType);
	124	private native void native_paint_box(
	125	int widgetType, int state, int shadowType, String detail,
	126	int x, int y, int width, int height, int synthState, int dir);
	127	private native void native_paint_box_gap(
	128	int widgetType, int state, int shadowType, String detail,
	129	int x, int y, int width, int height,
	130	int gapSide, int gapX, int gapWidth);
	131	private native void native_paint_check(
	132	int widgetType, int synthState, String detail,
	133	int x, int y, int width, int height);
	134	private native void native_paint_expander(
	135	int widgetType, int state, String detail,
	136	int x, int y, int width, int height, int expanderStyle);
	137	private native void native_paint_extension(
	138	int widgetType, int state, int shadowType, String detail,
	139	int x, int y, int width, int height, int placement);
	140	private native void native_paint_flat_box(
	141	int widgetType, int state, int shadowType, String detail,
	142	int x, int y, int width, int height, boolean hasFocus);
	143	private native void native_paint_focus(
	144	int widgetType, int state, String detail,
	145	int x, int y, int width, int height);
	146	private native void native_paint_handle(
	147	int widgetType, int state, int shadowType, String detail,
	148	int x, int y, int width, int height, int orientation);
	149	private native void native_paint_hline(
	150	int widgetType, int state, String detail,
	151	int x, int y, int width, int height);
	152	private native void native_paint_option(
	153	int widgetType, int synthState, String detail,
	154	int x, int y, int width, int height);
	155	private native void native_paint_shadow(
	156	int widgetType, int state, int shadowType, String detail,
	157	int x, int y, int width, int height, int synthState, int dir);
	158	private native void native_paint_slider(
	159	int widgetType, int state, int shadowType, String detail,
	160	int x, int y, int width, int height, int orientation);
	161	private native void native_paint_vline(
	162	int widgetType, int state, String detail,
	163	int x, int y, int width, int height);
	164	private native void native_paint_background(
	165	int widgetType, int state, int x, int y, int width, int height);
	166	private native Object native_get_gtk_setting(int property);
	167	private native void nativeSetRangeValue(int widgetType, double value,
	168	double min, double max,
	169	double visible);
	170
	171	private native void nativeStartPainting(int w, int h);
	172	private native int nativeFinishPainting(int[] buffer, int width, int height);
	173	private native void native_switch_theme();
	174
	175	static {
	176	// Make sure the awt toolkit is loaded so we have access to native
	177	// methods.
	178	Toolkit.getDefaultToolkit();
	179
	180	// Initialize regionToWidgetTypeMap
	181	regionToWidgetTypeMap = new HashMap<Region, Object>(50);
	182	regionToWidgetTypeMap.put(Region.ARROW_BUTTON, new WidgetType[] {
	183	WidgetType.SPINNER_ARROW_BUTTON,
	184	WidgetType.COMBO_BOX_ARROW_BUTTON,
	185	WidgetType.HSCROLL_BAR_BUTTON_LEFT,
	186	WidgetType.HSCROLL_BAR_BUTTON_RIGHT,
	187	WidgetType.VSCROLL_BAR_BUTTON_UP,
	188	WidgetType.VSCROLL_BAR_BUTTON_DOWN});
	189	regionToWidgetTypeMap.put(Region.BUTTON, WidgetType.BUTTON);
	190	regionToWidgetTypeMap.put(Region.CHECK_BOX, WidgetType.CHECK_BOX);
	191	regionToWidgetTypeMap.put(Region.CHECK_BOX_MENU_ITEM,
	192	WidgetType.CHECK_BOX_MENU_ITEM);
	193	regionToWidgetTypeMap.put(Region.COLOR_CHOOSER, WidgetType.COLOR_CHOOSER);
	194	regionToWidgetTypeMap.put(Region.FILE_CHOOSER, WidgetType.OPTION_PANE);
	195	regionToWidgetTypeMap.put(Region.COMBO_BOX, WidgetType.COMBO_BOX);
	196	regionToWidgetTypeMap.put(Region.DESKTOP_ICON, WidgetType.DESKTOP_ICON);
	197	regionToWidgetTypeMap.put(Region.DESKTOP_PANE, WidgetType.DESKTOP_PANE);
	198	regionToWidgetTypeMap.put(Region.EDITOR_PANE, WidgetType.EDITOR_PANE);
	199	regionToWidgetTypeMap.put(Region.FORMATTED_TEXT_FIELD, new WidgetType[] {
	200	WidgetType.FORMATTED_TEXT_FIELD, WidgetType.SPINNER_TEXT_FIELD});
	201	regionToWidgetTypeMap.put(GTKRegion.HANDLE_BOX, WidgetType.HANDLE_BOX);
	202	regionToWidgetTypeMap.put(Region.INTERNAL_FRAME,
	203	WidgetType.INTERNAL_FRAME);
	204	regionToWidgetTypeMap.put(Region.INTERNAL_FRAME_TITLE_PANE,
	205	WidgetType.INTERNAL_FRAME_TITLE_PANE);
	206	regionToWidgetTypeMap.put(Region.LABEL, new WidgetType[] {
	207	WidgetType.LABEL, WidgetType.COMBO_BOX_TEXT_FIELD});
	208	regionToWidgetTypeMap.put(Region.LIST, WidgetType.LIST);
	209	regionToWidgetTypeMap.put(Region.MENU, WidgetType.MENU);
	210	regionToWidgetTypeMap.put(Region.MENU_BAR, WidgetType.MENU_BAR);
	211	regionToWidgetTypeMap.put(Region.MENU_ITEM, WidgetType.MENU_ITEM);
	212	regionToWidgetTypeMap.put(Region.MENU_ITEM_ACCELERATOR,
	213	WidgetType.MENU_ITEM_ACCELERATOR);
	214	regionToWidgetTypeMap.put(Region.OPTION_PANE, WidgetType.OPTION_PANE);
	215	regionToWidgetTypeMap.put(Region.PANEL, WidgetType.PANEL);
	216	regionToWidgetTypeMap.put(Region.PASSWORD_FIELD,
	217	WidgetType.PASSWORD_FIELD);
	218	regionToWidgetTypeMap.put(Region.POPUP_MENU, WidgetType.POPUP_MENU);
	219	regionToWidgetTypeMap.put(Region.POPUP_MENU_SEPARATOR,
	220	WidgetType.POPUP_MENU_SEPARATOR);
	221	regionToWidgetTypeMap.put(Region.PROGRESS_BAR, new WidgetType[] {
	222	WidgetType.HPROGRESS_BAR, WidgetType.VPROGRESS_BAR});
	223	regionToWidgetTypeMap.put(Region.RADIO_BUTTON, WidgetType.RADIO_BUTTON);
	224	regionToWidgetTypeMap.put(Region.RADIO_BUTTON_MENU_ITEM,
	225	WidgetType.RADIO_BUTTON_MENU_ITEM);
	226	regionToWidgetTypeMap.put(Region.ROOT_PANE, WidgetType.ROOT_PANE);
	227	regionToWidgetTypeMap.put(Region.SCROLL_BAR, new WidgetType[] {
	228	WidgetType.HSCROLL_BAR, WidgetType.VSCROLL_BAR});
	229	regionToWidgetTypeMap.put(Region.SCROLL_BAR_THUMB, new WidgetType[] {
	230	WidgetType.HSCROLL_BAR_THUMB, WidgetType.VSCROLL_BAR_THUMB});
	231	regionToWidgetTypeMap.put(Region.SCROLL_BAR_TRACK, new WidgetType[] {
	232	WidgetType.HSCROLL_BAR_TRACK, WidgetType.VSCROLL_BAR_TRACK});
	233	regionToWidgetTypeMap.put(Region.SCROLL_PANE, WidgetType.SCROLL_PANE);
	234	regionToWidgetTypeMap.put(Region.SEPARATOR, new WidgetType[] {
	235	WidgetType.HSEPARATOR, WidgetType.VSEPARATOR});
	236	regionToWidgetTypeMap.put(Region.SLIDER, new WidgetType[] {
	237	WidgetType.HSLIDER, WidgetType.VSLIDER});
	238	regionToWidgetTypeMap.put(Region.SLIDER_THUMB, new WidgetType[] {
	239	WidgetType.HSLIDER_THUMB, WidgetType.VSLIDER_THUMB});
	240	regionToWidgetTypeMap.put(Region.SLIDER_TRACK, new WidgetType[] {
	241	WidgetType.HSLIDER_TRACK, WidgetType.VSLIDER_TRACK});
	242	regionToWidgetTypeMap.put(Region.SPINNER, WidgetType.SPINNER);
	243	regionToWidgetTypeMap.put(Region.SPLIT_PANE, WidgetType.SPLIT_PANE);
	244	regionToWidgetTypeMap.put(Region.SPLIT_PANE_DIVIDER, new WidgetType[] {
	245	WidgetType.HSPLIT_PANE_DIVIDER, WidgetType.VSPLIT_PANE_DIVIDER});
	246	regionToWidgetTypeMap.put(Region.TABBED_PANE, WidgetType.TABBED_PANE);
	247	regionToWidgetTypeMap.put(Region.TABBED_PANE_CONTENT,
	248	WidgetType.TABBED_PANE_CONTENT);
	249	regionToWidgetTypeMap.put(Region.TABBED_PANE_TAB,
	250	WidgetType.TABBED_PANE_TAB);
	251	regionToWidgetTypeMap.put(Region.TABBED_PANE_TAB_AREA,
	252	WidgetType.TABBED_PANE_TAB_AREA);
	253	regionToWidgetTypeMap.put(Region.TABLE, WidgetType.TABLE);
	254	regionToWidgetTypeMap.put(Region.TABLE_HEADER, WidgetType.TABLE_HEADER);
	255	regionToWidgetTypeMap.put(Region.TEXT_AREA, WidgetType.TEXT_AREA);
	256	regionToWidgetTypeMap.put(Region.TEXT_FIELD, new WidgetType[] {
	257	WidgetType.TEXT_FIELD, WidgetType.COMBO_BOX_TEXT_FIELD});
	258	regionToWidgetTypeMap.put(Region.TEXT_PANE, WidgetType.TEXT_PANE);
	259	regionToWidgetTypeMap.put(CustomRegion.TITLED_BORDER, WidgetType.TITLED_BORDER);
	260	regionToWidgetTypeMap.put(Region.TOGGLE_BUTTON, WidgetType.TOGGLE_BUTTON);
	261	regionToWidgetTypeMap.put(Region.TOOL_BAR, WidgetType.TOOL_BAR);
	262	regionToWidgetTypeMap.put(Region.TOOL_BAR_CONTENT, WidgetType.TOOL_BAR);
	263	regionToWidgetTypeMap.put(Region.TOOL_BAR_DRAG_WINDOW,
	264	WidgetType.TOOL_BAR_DRAG_WINDOW);
	265	regionToWidgetTypeMap.put(Region.TOOL_BAR_SEPARATOR,
	266	WidgetType.TOOL_BAR_SEPARATOR);
	267	regionToWidgetTypeMap.put(Region.TOOL_TIP, WidgetType.TOOL_TIP);
	268	regionToWidgetTypeMap.put(Region.TREE, WidgetType.TREE);
	269	regionToWidgetTypeMap.put(Region.TREE_CELL, WidgetType.TREE_CELL);
	270	regionToWidgetTypeMap.put(Region.VIEWPORT, WidgetType.VIEWPORT);
	271	}
	272
	273	/** Translate Region and JComponent into WidgetType ordinals */
	274	static WidgetType getWidgetType(JComponent c, Region id) {
	275	Object value = regionToWidgetTypeMap.get(id);
	276
	277	if (value instanceof WidgetType) {
	278	return (WidgetType)value;
	279	}
	280
	281	WidgetType[] widgets = (WidgetType[])value;
	282	if (c == null ) {
	283	return widgets[0];
	284	}
	285
	286	if (c instanceof JScrollBar) {
	287	return (((JScrollBar)c).getOrientation() == JScrollBar.HORIZONTAL) ?
	288	widgets[0] : widgets[1];
	289	} else if (c instanceof JSeparator) {
	290	JSeparator separator = (JSeparator)c;
	291
	292	/* We should return correrct WidgetType if the seperator is inserted
	293	* in Menu/PopupMenu/ToolBar. BugID: 6465603
	294	*/
	295	if (separator.getParent() instanceof JPopupMenu) {
	296	return WidgetType.POPUP_MENU_SEPARATOR;
	297	} else if (separator.getParent() instanceof JToolBar) {
	298	return WidgetType.TOOL_BAR_SEPARATOR;
	299	}
	300
	301	return (separator.getOrientation() == JSeparator.HORIZONTAL) ?
	302	widgets[0] : widgets[1];
	303	} else if (c instanceof JSlider) {
	304	return (((JSlider)c).getOrientation() == JSlider.HORIZONTAL) ?
	305	widgets[0] : widgets[1];
	306	} else if (c instanceof JProgressBar) {
	307	return (((JProgressBar)c).getOrientation() == JProgressBar.HORIZONTAL) ?
	308	widgets[0] : widgets[1];
	309	} else if (c instanceof JSplitPane) {
	310	return (((JSplitPane)c).getOrientation() == JSplitPane.HORIZONTAL_SPLIT) ?
	311	widgets[1] : widgets[0];
	312	} else if (id == Region.LABEL) {
	313	/*
	314	* For all ListCellRenderers we will use COMBO_BOX_TEXT_FIELD widget
	315	* type because we can get correct insets. List items however won't be
	316	* drawn as a text entry (see GTKPainter.paintLabelBackground).
	317	*/
	318	if (c instanceof ListCellRenderer) {
	319	return widgets[1];
	320	} else {
	321	return widgets[0];
	322	}
	323	} else if (id == Region.TEXT_FIELD) {
	324	String name = c.getName();
	325	if (name != null && name.startsWith("ComboBox")) {
	326	return widgets[1];
	327	} else {
	328	return widgets[0];
	329	}
	330	} else if (id == Region.FORMATTED_TEXT_FIELD) {
	331	String name = c.getName();
	332	if (name != null && name.startsWith("Spinner")) {
	333	return widgets[1];
	334	} else {
	335	return widgets[0];
	336	}
	337	} else if (id == Region.ARROW_BUTTON) {
	338	if (c.getParent() instanceof JScrollBar) {
	339	Integer prop = (Integer)
	340	c.getClientProperty("__arrow_direction__");
	341	int dir = (prop != null) ?
	342	prop.intValue() : SwingConstants.WEST;
	343	switch (dir) {
	344	case SwingConstants.WEST:
	345	return WidgetType.HSCROLL_BAR_BUTTON_LEFT;
	346	case SwingConstants.EAST:
	347	return WidgetType.HSCROLL_BAR_BUTTON_RIGHT;
	348	case SwingConstants.NORTH:
	349	return WidgetType.VSCROLL_BAR_BUTTON_UP;
	350	case SwingConstants.SOUTH:
	351	return WidgetType.VSCROLL_BAR_BUTTON_DOWN;
	352	default:
	353	return null;
	354	}
	355	} else if (c.getParent() instanceof JComboBox) {
	356	return WidgetType.COMBO_BOX_ARROW_BUTTON;
	357	} else {
	358	return WidgetType.SPINNER_ARROW_BUTTON;
	359	}
	360	}
	361
	362	return null;
	363	}
	364
	365	private static int getTextDirection(SynthContext context) {
	366	TextDirection dir = TextDirection.NONE;
	367	JComponent comp = context.getComponent();
	368	if (comp != null) {
	369	ComponentOrientation co = comp.getComponentOrientation();
	370	if (co != null) {
	371	dir = co.isLeftToRight() ?
	372	TextDirection.LTR : TextDirection.RTL;
	373	}
	374	}
	375	return dir.ordinal();
	376	}
	377
	378	public void paintArrow(Graphics g, SynthContext context,
	379	Region id, int state, ShadowType shadowType, ArrowType direction,
	380	String detail, int x, int y, int w, int h) {
	381
	382	state = GTKLookAndFeel.synthStateToGTKStateType(state).ordinal();
	383	int widget = getWidgetType(context.getComponent(), id).ordinal();
	384	native_paint_arrow(widget, state, shadowType.ordinal(),
	385	detail, x - x0, y - y0, w, h, direction.ordinal());
	386	}
	387
	388	public void paintBox(Graphics g, SynthContext context,
	389	Region id, int state, ShadowType shadowType,
	390	String detail, int x, int y, int w, int h) {
	391
	392	int gtkState =
	393	GTKLookAndFeel.synthStateToGTKStateType(state).ordinal();
	394	int synthState = context.getComponentState();
	395	int dir = getTextDirection(context);
	396	int widget = getWidgetType(context.getComponent(), id).ordinal();
	397	native_paint_box(widget, gtkState, shadowType.ordinal(),
	398	detail, x - x0, y - y0, w, h, synthState, dir);
	399	}
	400
	401	public void paintBoxGap(Graphics g, SynthContext context,
	402	Region id, int state, ShadowType shadowType,
	403	String detail, int x, int y, int w, int h,
	404	PositionType boxGapType, int tabBegin, int size) {
	405
	406	state = GTKLookAndFeel.synthStateToGTKStateType(state).ordinal();
	407	int widget = getWidgetType(context.getComponent(), id).ordinal();
	408	native_paint_box_gap(widget, state, shadowType.ordinal(), detail,
	409	x - x0, y - y0, w, h, boxGapType.ordinal(), tabBegin, size);
	410	}
	411
	412	public void paintCheck(Graphics g, SynthContext context,
	413	Region id, String detail, int x, int y, int w, int h) {
	414
	415	int synthState = context.getComponentState();
	416	int widget = getWidgetType(context.getComponent(), id).ordinal();
	417	native_paint_check(widget, synthState, detail, x - x0, y - y0, w, h);
	418	}
	419
	420	public void paintExpander(Graphics g, SynthContext context,
	421	Region id, int state, ExpanderStyle expanderStyle, String detail,
	422	int x, int y, int w, int h) {
	423
	424	state = GTKLookAndFeel.synthStateToGTKStateType(state).ordinal();
	425	int widget = getWidgetType(context.getComponent(), id).ordinal();
	426	native_paint_expander(widget, state, detail, x - x0, y - y0, w, h,
	427	expanderStyle.ordinal());
	428	}
	429
	430	public void paintExtension(Graphics g, SynthContext context,
	431	Region id, int state, ShadowType shadowType, String detail,
	432	int x, int y, int w, int h, PositionType placement, int tabIndex) {
	433
	434	state = GTKLookAndFeel.synthStateToGTKStateType(state).ordinal();
	435	int widget = getWidgetType(context.getComponent(), id).ordinal();
	436	native_paint_extension(widget, state, shadowType.ordinal(), detail,
	437	x - x0, y - y0, w, h, placement.ordinal());
	438	}
	439
	440	public void paintFlatBox(Graphics g, SynthContext context,
	441	Region id, int state, ShadowType shadowType, String detail,
	442	int x, int y, int w, int h, ColorType colorType) {
	443
	444	state = GTKLookAndFeel.synthStateToGTKStateType(state).ordinal();
	445	int widget = getWidgetType(context.getComponent(), id).ordinal();
	446	native_paint_flat_box(widget, state, shadowType.ordinal(), detail,
	447	x - x0, y - y0, w, h,
	448	context.getComponent().hasFocus());
	449	}
	450
	451	public void paintFocus(Graphics g, SynthContext context,
	452	Region id, int state, String detail, int x, int y, int w, int h) {
	453
	454	state = GTKLookAndFeel.synthStateToGTKStateType(state).ordinal();
	455	int widget = getWidgetType(context.getComponent(), id).ordinal();
	456	native_paint_focus(widget, state, detail, x - x0, y - y0, w, h);
	457	}
	458
	459	public void paintHandle(Graphics g, SynthContext context,
	460	Region id, int state, ShadowType shadowType, String detail,
	461	int x, int y, int w, int h, Orientation orientation) {
	462
	463	state = GTKLookAndFeel.synthStateToGTKStateType(state).ordinal();
	464	int widget = getWidgetType(context.getComponent(), id).ordinal();
	465	native_paint_handle(widget, state, shadowType.ordinal(), detail,
	466	x - x0, y - y0, w, h, orientation.ordinal());
	467	}
	468
	469	public void paintHline(Graphics g, SynthContext context,
	470	Region id, int state, String detail, int x, int y, int w, int h) {
	471
	472	state = GTKLookAndFeel.synthStateToGTKStateType(state).ordinal();
	473	int widget = getWidgetType(context.getComponent(), id).ordinal();
	474	native_paint_hline(widget, state, detail, x - x0, y - y0, w, h);
	475	}
	476
	477	public void paintOption(Graphics g, SynthContext context,
	478	Region id, String detail, int x, int y, int w, int h) {
	479
	480	int synthState = context.getComponentState();
	481	int widget = getWidgetType(context.getComponent(), id).ordinal();
	482	native_paint_option(widget, synthState, detail, x - x0, y - y0, w, h);
	483	}
	484
	485	public void paintShadow(Graphics g, SynthContext context,
	486	Region id, int state, ShadowType shadowType, String detail,
	487	int x, int y, int w, int h) {
	488
	489	int gtkState =
	490	GTKLookAndFeel.synthStateToGTKStateType(state).ordinal();
	491	int synthState = context.getComponentState();
	492	int dir = getTextDirection(context);
	493	int widget = getWidgetType(context.getComponent(), id).ordinal();
	494	native_paint_shadow(widget, gtkState, shadowType.ordinal(), detail,
	495	x - x0, y - y0, w, h, synthState, dir);
	496	}
	497
	498	public void paintSlider(Graphics g, SynthContext context,
	499	Region id, int state, ShadowType shadowType, String detail,
	500	int x, int y, int w, int h, Orientation orientation) {
	501
	502	state = GTKLookAndFeel.synthStateToGTKStateType(state).ordinal();
	503	int widget = getWidgetType(context.getComponent(), id).ordinal();
	504	native_paint_slider(widget, state, shadowType.ordinal(), detail,
	505	x - x0, y - y0, w, h, orientation.ordinal());
	506	}
	507
	508	public void paintVline(Graphics g, SynthContext context,
	509	Region id, int state, String detail, int x, int y, int w, int h) {
	510
	511	state = GTKLookAndFeel.synthStateToGTKStateType(state).ordinal();
	512	int widget = getWidgetType(context.getComponent(), id).ordinal();
	513	native_paint_vline(widget, state, detail, x - x0, y - y0, w, h);
	514	}
	515
	516	public void paintBackground(Graphics g, SynthContext context,
	517	Region id, int state, Color color, int x, int y, int w, int h) {
	518
	519	state = GTKLookAndFeel.synthStateToGTKStateType(state).ordinal();
	520	int widget = getWidgetType(context.getComponent(), id).ordinal();
	521	native_paint_background(widget, state, x - x0, y - y0, w, h);
	522	}
	523
	524	private final static ColorModel[] COLOR_MODELS = {
	525	// Transparency.OPAQUE
	526	new DirectColorModel(24, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00000000),
	527	// Transparency.BITMASK
	528	new DirectColorModel(25, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x01000000),
	529	// Transparency.TRANSLUCENT
	530	ColorModel.getRGBdefault(),
	531	};
	532
	533	private final static int[][] BAND_OFFSETS = {
	534	{ 0x00ff0000, 0x0000ff00, 0x000000ff }, // OPAQUE
	535	{ 0x00ff0000, 0x0000ff00, 0x000000ff, 0x01000000 }, // BITMASK
	536	{ 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000 } // TRANSLUCENT
	537	};
	538
	539
	540	/**
	541	* Paint a cached image identified by its size and a set of additional
	542	* arguments, if there's one.
	543	*
	544	* @return true if a cached image has been painted, false otherwise
	545	*/
	546	public boolean paintCachedImage(Graphics g,
	547	int x, int y, int w, int h, Object... args) {
	548	if (w <= 0 \|\| h <= 0) {
	549	return true;
	550	}
	551
	552	// look for cached image
	553	Image img = cache.getImage(getClass(), null, w, h, args);
	554	if (img != null) {
	555	g.drawImage(img, x, y, null);
	556	return true;
	557	}
	558	return false;
	559	}
	560
	561	/*
	562	* Allocate a native offscreen buffer of the specified size.
	563	*/
	564	public void startPainting(Graphics g,
	565	int x, int y, int w, int h, Object... args) {
	566	nativeStartPainting(w, h);
	567	x0 = x;
	568	y0 = y;
	569	w0 = w;
	570	h0 = h;
	571	graphics = g;
	572	cacheArgs = args;
	573	}
	574
	575	/**
	576	* Convenience method that delegates to finishPainting() with
	577	* caching enabled.
	578	*/
	579	public void finishPainting() {
	580	finishPainting(true);
	581	}
	582
	583	/**
	584	* Called to indicate that painting is finished. We create a new
	585	* BufferedImage from the offscreen buffer, (optionally) cache it,
	586	* and paint it.
	587	*/
	588	public void finishPainting(boolean useCache) {
	589	DataBufferInt dataBuffer = new DataBufferInt(w0 * h0);
	590	// Note that stealData() requires a markDirty() afterwards
	591	// since we modify the data in it.
	592	int transparency =
	593	nativeFinishPainting(SunWritableRaster.stealData(dataBuffer, 0),
	594	w0, h0);
	595	SunWritableRaster.markDirty(dataBuffer);
	596
	597	int[] bands = BAND_OFFSETS[transparency - 1];
	598	WritableRaster raster = Raster.createPackedRaster(
	599	dataBuffer, w0, h0, w0, bands, null);
	600
	601	ColorModel cm = COLOR_MODELS[transparency - 1];
	602	Image img = new BufferedImage(cm, raster, false, null);
	603	if (useCache) {
	604	cache.setImage(getClass(), null, w0, h0, cacheArgs, img);
	605	}
	606	graphics.drawImage(img, x0, y0, null);
	607	}
	608
	609	/**
	610	* Notify native layer of theme change, and flush cache
	611	*/
	612	public void themeChanged() {
	613	synchronized(sun.awt.UNIXToolkit.GTK_LOCK) {
	614	native_switch_theme();
	615	}
	616	cache.flush();
	617	}
	618
	619	/* GtkSettings enum mirrors that in gtk2_interface.h */
	620	public Object getSetting(Settings property) {
	621	synchronized(sun.awt.UNIXToolkit.GTK_LOCK) {
	622	return native_get_gtk_setting(property.ordinal());
	623	}
	624	}
	625
	626	/**
	627	* Sets up the GtkAdjustment values for the native GtkRange widget
	628	* associated with the given region (e.g. SLIDER, SCROLL_BAR).
	629	*/
	630	void setRangeValue(SynthContext context, Region id,
	631	double value, double min, double max, double visible) {
	632	int widget = getWidgetType(context.getComponent(), id).ordinal();
	633	nativeSetRangeValue(widget, value, min, max, visible);
	634	}
	635	}

java/pkg/com/sun/java/swing/plaf/gtk/GTKFileChooserUI.java+1398−0

@@ -0,0 +1,1398 @@
	1	/*
	2	* Copyright (c) 2002, 2008, 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	package com.sun.java.swing.plaf.gtk;
	26
	27	import java.awt.*;
	28	import java.awt.event.*;
	29	import java.beans.*;
	30	import java.io.File;
	31	import java.io.IOException;
	32	import java.text.MessageFormat;
	33	import java.util.*;
	34
	35	import javax.swing.*;
	36	import javax.swing.border.*;
	37	import javax.swing.filechooser.*;
	38	import javax.swing.event.*;
	39	import javax.swing.plaf.*;
	40	import javax.swing.plaf.basic.BasicDirectoryModel;
	41	import javax.swing.table.*;
	42	import javax.accessibility.*;
	43
	44	import sun.swing.SwingUtilities2;
	45
	46	import sun.swing.plaf.synth.*;
	47	import sun.swing.FilePane;
	48	import sun.awt.shell.ShellFolder;
	49
	50	/**
	51	* GTK FileChooserUI.
	52	*
	53	* @author Leif Samuelsson
	54	* @author Jeff Dinkins
	55	*/
	56	class GTKFileChooserUI extends SynthFileChooserUI {
	57
	58	// The accessoryPanel is a container to place the JFileChooser accessory component
	59	private JPanel accessoryPanel = null;
	60
	61	private String newFolderButtonText = null;
	62	private String newFolderErrorSeparator = null;
	63	private String newFolderErrorText = null;
	64	private String newFolderDialogText = null;
	65	private String newFolderNoDirectoryErrorTitleText = null;
	66	private String newFolderNoDirectoryErrorText = null;
	67
	68	private String deleteFileButtonText = null;
	69	private String renameFileButtonText = null;
	70
	71	private String newFolderButtonToolTipText = null;
	72	private String deleteFileButtonToolTipText = null;
	73	private String renameFileButtonToolTipText = null;
	74
	75	private int newFolderButtonMnemonic = 0;
	76	private int deleteFileButtonMnemonic = 0;
	77	private int renameFileButtonMnemonic = 0;
	78	private int foldersLabelMnemonic = 0;
	79	private int filesLabelMnemonic = 0;
	80
	81	private String renameFileDialogText = null;
	82	private String renameFileErrorTitle = null;
	83	private String renameFileErrorText = null;
	84
	85	private JComboBox filterComboBox;
	86	private FilterComboBoxModel filterComboBoxModel;
	87
	88	// From Motif
	89
	90	private JPanel rightPanel;
	91	private JList directoryList;
	92	private JList fileList;
	93
	94	private JLabel pathField;
	95	private JTextField fileNameTextField;
	96
	97	private static final Dimension hstrut3 = new Dimension(3, 1);
	98	private static final Dimension vstrut10 = new Dimension(1, 10);
	99
	100	private static Dimension prefListSize = new Dimension(75, 150);
	101
	102	private static Dimension PREF_SIZE = new Dimension(435, 360);
	103	private static Dimension MIN_SIZE = new Dimension(200, 300);
	104
	105	private static Dimension ZERO_ACC_SIZE = new Dimension(1, 1);
	106
	107	private static Dimension MAX_SIZE = new Dimension(Short.MAX_VALUE, Short.MAX_VALUE);
	108
	109	private static final Insets buttonMargin = new Insets(3, 3, 3, 3);
	110
	111	private String filesLabelText = null;
	112	private String foldersLabelText = null;
	113	private String pathLabelText = null;
	114	private String filterLabelText = null;
	115
	116	private int pathLabelMnemonic = 0;
	117	private int filterLabelMnemonic = 0;
	118
	119	private JComboBox directoryComboBox;
	120	private DirectoryComboBoxModel directoryComboBoxModel;
	121	private Action directoryComboBoxAction = new DirectoryComboBoxAction();
	122	private JPanel bottomButtonPanel;
	123	private GTKDirectoryModel model = null;
	124	private Action newFolderAction;
	125	private boolean readOnly;
	126	private boolean showDirectoryIcons;
	127	private boolean showFileIcons;
	128	private GTKFileView fileView = new GTKFileView();
	129	private PropertyChangeListener gtkFCPropertyChangeListener;
	130	private Action approveSelectionAction = new GTKApproveSelectionAction();
	131	private GTKDirectoryListModel directoryListModel;
	132
	133	public GTKFileChooserUI(JFileChooser filechooser) {
	134	super(filechooser);
	135	}
	136
	137	protected ActionMap createActionMap() {
	138	ActionMap map = new ActionMapUIResource();
	139	map.put("approveSelection", getApproveSelectionAction());
	140	map.put("cancelSelection", getCancelSelectionAction());
	141	map.put("Go Up", getChangeToParentDirectoryAction());
	142	map.put("fileNameCompletion", getFileNameCompletionAction());
	143	return map;
	144	}
	145
	146	public String getFileName() {
	147	JFileChooser fc = getFileChooser();
	148	String typedInName = fileNameTextField != null ?
	149	fileNameTextField.getText() : null;
	150
	151	if (!fc.isMultiSelectionEnabled()) {
	152	return typedInName;
	153	}
	154
	155	int mode = fc.getFileSelectionMode();
	156	JList list = mode == JFileChooser.DIRECTORIES_ONLY ?
	157	directoryList : fileList;
	158	Object[] files = list.getSelectedValues();
	159	int len = files.length;
	160	Vector<String> result = new Vector<String>(len + 1);
	161
	162	// we return all selected file names
	163	for (int i = 0; i < len; i++) {
	164	File file = (File)files[i];
	165	result.add(file.getName());
	166	}
	167	// plus the file name typed into the text field, if not already there
	168	if (typedInName != null && !result.contains(typedInName)) {
	169	result.add(typedInName);
	170	}
	171
	172	StringBuffer buf = new StringBuffer();
	173	len = result.size();
	174
	175	// construct the resulting string
	176	for (int i=0; i<len; i++) {
	177	if (i > 0) {
	178	buf.append(" ");
	179	}
	180	if (len > 1) {
	181	buf.append("\"");
	182	}
	183	buf.append(result.get(i));
	184	if (len > 1) {
	185	buf.append("\"");
	186	}
	187	}
	188	return buf.toString();
	189	}
	190
	191	public void setFileName(String fileName) {
	192	if (fileNameTextField != null) {
	193	fileNameTextField.setText(fileName);
	194	}
	195	}
	196
	197	// public String getDirectoryName() {
	198	// return pathField.getText();
	199	// }
	200
	201	public void setDirectoryName(String dirname) {
	202	pathField.setText(dirname);
	203	}
	204
	205	public void ensureFileIsVisible(JFileChooser fc, File f) {
	206	// PENDING
	207	}
	208
	209	public void rescanCurrentDirectory(JFileChooser fc) {
	210	getModel().validateFileCache();
	211	}
	212
	213	public JPanel getAccessoryPanel() {
	214	return accessoryPanel;
	215	}
	216
	217	// ***********************
	218	// * FileView operations *
	219	// ***********************
	220
	221	public FileView getFileView(JFileChooser fc) {
	222	return fileView;
	223	}
	224
	225	private class GTKFileView extends BasicFileView {
	226	public GTKFileView() {
	227	iconCache = null;
	228	}
	229
	230	public void clearIconCache() {
	231	}
	232
	233	public Icon getCachedIcon(File f) {
	234	return null;
	235	}
	236
	237	public void cacheIcon(File f, Icon i) {
	238	}
	239
	240	public Icon getIcon(File f) {
	241	return (f != null && f.isDirectory()) ? directoryIcon : fileIcon;
	242	}
	243	}
	244
	245
	246	private void updateDefaultButton() {
	247	JFileChooser filechooser = getFileChooser();
	248	JRootPane root = SwingUtilities.getRootPane(filechooser);
	249	if (root == null) {
	250	return;
	251	}
	252
	253	if (filechooser.getControlButtonsAreShown()) {
	254	if (root.getDefaultButton() == null) {
	255	root.setDefaultButton(getApproveButton(filechooser));
	256	getCancelButton(filechooser).setDefaultCapable(false);
	257	}
	258	} else {
	259	if (root.getDefaultButton() == getApproveButton(filechooser)) {
	260	root.setDefaultButton(null);
	261	}
	262	}
	263	}
	264
	265	protected void doSelectedFileChanged(PropertyChangeEvent e) {
	266	super.doSelectedFileChanged(e);
	267	File f = (File) e.getNewValue();
	268	if (f != null) {
	269	setFileName(getFileChooser().getName(f));
	270	}
	271	}
	272
	273	protected void doDirectoryChanged(PropertyChangeEvent e) {
	274	directoryList.clearSelection();
	275	ListSelectionModel sm = directoryList.getSelectionModel();
	276	if (sm instanceof DefaultListSelectionModel) {
	277	((DefaultListSelectionModel)sm).moveLeadSelectionIndex(0);
	278	sm.setAnchorSelectionIndex(0);
	279	}
	280	fileList.clearSelection();
	281	sm = fileList.getSelectionModel();
	282	if (sm instanceof DefaultListSelectionModel) {
	283	((DefaultListSelectionModel)sm).moveLeadSelectionIndex(0);
	284	sm.setAnchorSelectionIndex(0);
	285	}
	286
	287	File currentDirectory = getFileChooser().getCurrentDirectory();
	288	if (currentDirectory != null) {
	289	try {
	290	setDirectoryName(ShellFolder.getNormalizedFile((File)e.getNewValue()).getPath());
	291	} catch (IOException ioe) {
	292	setDirectoryName(((File)e.getNewValue()).getAbsolutePath());
	293	}
	294	if ((getFileChooser().getFileSelectionMode() == JFileChooser.DIRECTORIES_ONLY) && !getFileChooser().isMultiSelectionEnabled()) {
	295	setFileName(pathField.getText());
	296	}
	297	directoryComboBoxModel.addItem(currentDirectory);
	298	directoryListModel.directoryChanged();
	299	}
	300	super.doDirectoryChanged(e);
	301	}
	302
	303	protected void doAccessoryChanged(PropertyChangeEvent e) {
	304	if (getAccessoryPanel() != null) {
	305	if (e.getOldValue() != null) {
	306	getAccessoryPanel().remove((JComponent)e.getOldValue());
	307	}
	308	JComponent accessory = (JComponent)e.getNewValue();
	309	if (accessory != null) {
	310	getAccessoryPanel().add(accessory, BorderLayout.CENTER);
	311	getAccessoryPanel().setPreferredSize(accessory.getPreferredSize());
	312	getAccessoryPanel().setMaximumSize(MAX_SIZE);
	313	} else {
	314	getAccessoryPanel().setPreferredSize(ZERO_ACC_SIZE);
	315	getAccessoryPanel().setMaximumSize(ZERO_ACC_SIZE);
	316	}
	317	}
	318	}
	319
	320	protected void doFileSelectionModeChanged(PropertyChangeEvent e) {
	321	directoryList.clearSelection();
	322	rightPanel.setVisible(((Integer)e.getNewValue()).intValue() != JFileChooser.DIRECTORIES_ONLY);
	323
	324	super.doFileSelectionModeChanged(e);
	325	}
	326
	327	protected void doMultiSelectionChanged(PropertyChangeEvent e) {
	328	if (getFileChooser().isMultiSelectionEnabled()) {
	329	fileList.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
	330	} else {
	331	fileList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
	332	fileList.clearSelection();
	333	}
	334
	335	super.doMultiSelectionChanged(e);
	336	}
	337
	338	protected void doControlButtonsChanged(PropertyChangeEvent e) {
	339	super.doControlButtonsChanged(e);
	340
	341	JFileChooser filechooser = getFileChooser();
	342	if (filechooser.getControlButtonsAreShown()) {
	343	filechooser.add(bottomButtonPanel, BorderLayout.SOUTH);
	344	} else {
	345	filechooser.remove(bottomButtonPanel);
	346	}
	347	updateDefaultButton();
	348	}
	349
	350	protected void doAncestorChanged(PropertyChangeEvent e) {
	351	if (e.getOldValue() == null && e.getNewValue() != null) {
	352	// Ancestor was added, set initial focus
	353	fileNameTextField.selectAll();
	354	fileNameTextField.requestFocus();
	355	updateDefaultButton();
	356	}
	357
	358	super.doAncestorChanged(e);
	359	}
	360
	361
	362
	363	// ********************************************
	364	// ********** Create Listeners ************
	365	// ********************************************
	366
	367	public ListSelectionListener createListSelectionListener(JFileChooser fc) {
	368	return new SelectionListener();
	369	}
	370
	371	class DoubleClickListener extends MouseAdapter {
	372	JList list;
	373	public DoubleClickListener(JList list) {
	374	this.list = list;
	375	}
	376
	377	public void mouseClicked(MouseEvent e) {
	378	if (SwingUtilities.isLeftMouseButton(e) && e.getClickCount() == 2) {
	379	int index = list.locationToIndex(e.getPoint());
	380	if (index >= 0) {
	381	File f = (File) list.getModel().getElementAt(index);
	382	try {
	383	// Strip trailing ".."
	384	f = ShellFolder.getNormalizedFile(f);
	385	} catch (IOException ex) {
	386	// That's ok, we'll use f as is
	387	}
	388	if (getFileChooser().isTraversable(f)) {
	389	list.clearSelection();
	390	if (getFileChooser().getCurrentDirectory().equals(f)){
	391	rescanCurrentDirectory(getFileChooser());
	392	} else {
	393	getFileChooser().setCurrentDirectory(f);
	394	}
	395	} else {
	396	getFileChooser().approveSelection();
	397	}
	398	}
	399	}
	400	}
	401
	402	public void mouseEntered(MouseEvent evt) {
	403	if (list != null) {
	404	TransferHandler th1 = getFileChooser().getTransferHandler();
	405	TransferHandler th2 = list.getTransferHandler();
	406	if (th1 != th2) {
	407	list.setTransferHandler(th1);
	408	}
	409	if (getFileChooser().getDragEnabled() != list.getDragEnabled()) {
	410	list.setDragEnabled(getFileChooser().getDragEnabled());
	411	}
	412	}
	413	}
	414	}
	415
	416	protected MouseListener createDoubleClickListener(JFileChooser fc, JList list) {
	417	return new DoubleClickListener(list);
	418	}
	419
	420
	421
	422	protected class SelectionListener implements ListSelectionListener {
	423	public void valueChanged(ListSelectionEvent e) {
	424	if (!e.getValueIsAdjusting()) {
	425	JFileChooser chooser = getFileChooser();
	426	JList list = (JList) e.getSource();
	427
	428	if (chooser.isMultiSelectionEnabled()) {
	429	File[] files = null;
	430	Object[] objects = list.getSelectedValues();
	431	if (objects != null) {
	432	if (objects.length == 1
	433	&& ((File)objects[0]).isDirectory()
	434	&& chooser.isTraversable(((File)objects[0]))
	435	&& (chooser.getFileSelectionMode() != chooser.DIRECTORIES_ONLY
	436	\|\| !chooser.getFileSystemView().isFileSystem(((File)objects[0])))) {
	437	setDirectorySelected(true);
	438	setDirectory(((File)objects[0]));
	439	} else {
	440	ArrayList<File> fList = new ArrayList<File>(objects.length);
	441	for (Object object : objects) {
	442	File f = (File) object;
	443	if ((chooser.isFileSelectionEnabled() && f.isFile())
	444	\|\| (chooser.isDirectorySelectionEnabled() && f.isDirectory())) {
	445	fList.add(f);
	446	}
	447	}
	448	if (fList.size() > 0) {
	449	files = fList.toArray(new File[fList.size()]);
	450	}
	451	setDirectorySelected(false);
	452	}
	453	}
	454	chooser.setSelectedFiles(files);
	455	} else {
	456	File file = (File)list.getSelectedValue();
	457	if (file != null
	458	&& file.isDirectory()
	459	&& chooser.isTraversable(file)
	460	&& (chooser.getFileSelectionMode() == chooser.FILES_ONLY
	461	\|\| !chooser.getFileSystemView().isFileSystem(file))) {
	462
	463	setDirectorySelected(true);
	464	setDirectory(file);
	465	} else {
	466	setDirectorySelected(false);
	467	if (file != null) {
	468	chooser.setSelectedFile(file);
	469	}
	470	}
	471	}
	472	}
	473	}
	474	}
	475
	476
	477	//
	478	// ComponentUI Interface Implementation methods
	479	//
	480	public static ComponentUI createUI(JComponent c) {
	481	return new GTKFileChooserUI((JFileChooser)c);
	482	}
	483
	484	public void installUI(JComponent c) {
	485	accessoryPanel = new JPanel(new BorderLayout(10, 10));
	486	accessoryPanel.setName("GTKFileChooser.accessoryPanel");
	487
	488	super.installUI(c);
	489	}
	490
	491	public void uninstallUI(JComponent c) {
	492	c.removePropertyChangeListener(filterComboBoxModel);
	493	super.uninstallUI(c);
	494
	495	if (accessoryPanel != null) {
	496	accessoryPanel.removeAll();
	497	}
	498	accessoryPanel = null;
	499	getFileChooser().removeAll();
	500	}
	501
	502	public void installComponents(JFileChooser fc) {
	503	super.installComponents(fc);
	504
	505	boolean leftToRight = fc.getComponentOrientation().isLeftToRight();
	506
	507	fc.setLayout(new BorderLayout());
	508	fc.setAlignmentX(JComponent.CENTER_ALIGNMENT);
	509
	510	// Top row of buttons
	511	JPanel topButtonPanel = new JPanel(new FlowLayout(FlowLayout.LEADING, 0, 0));
	512	topButtonPanel.setBorder(new EmptyBorder(10, 10, 0, 10));
	513	topButtonPanel.setName("GTKFileChooser.topButtonPanel");
	514
	515	if (!UIManager.getBoolean("FileChooser.readOnly")) {
	516	JButton newFolderButton = new JButton(getNewFolderAction());
	517	newFolderButton.setName("GTKFileChooser.newFolderButton");
	518	newFolderButton.setMnemonic(newFolderButtonMnemonic);
	519	newFolderButton.setToolTipText(newFolderButtonToolTipText);
	520	newFolderButton.setText(newFolderButtonText);
	521	topButtonPanel.add(newFolderButton);
	522	}
	523	JButton deleteFileButton = new JButton(deleteFileButtonText);
	524	deleteFileButton.setName("GTKFileChooser.deleteFileButton");
	525	deleteFileButton.setMnemonic(deleteFileButtonMnemonic);
	526	deleteFileButton.setToolTipText(deleteFileButtonToolTipText);
	527	deleteFileButton.setEnabled(false);
	528	topButtonPanel.add(deleteFileButton);
	529
	530	RenameFileAction rfa = new RenameFileAction();
	531	JButton renameFileButton = new JButton(rfa);
	532	if (readOnly) {
	533	rfa.setEnabled(false);
	534	}
	535	renameFileButton.setText(renameFileButtonText);
	536	renameFileButton.setName("GTKFileChooser.renameFileButton");
	537	renameFileButton.setMnemonic(renameFileButtonMnemonic);
	538	renameFileButton.setToolTipText(renameFileButtonToolTipText);
	539	topButtonPanel.add(renameFileButton);
	540
	541	fc.add(topButtonPanel, BorderLayout.NORTH);
	542
	543
	544	JPanel interior = new JPanel();
	545	interior.setBorder(new EmptyBorder(0, 10, 10, 10));
	546	interior.setName("GTKFileChooser.interiorPanel");
	547	align(interior);
	548	interior.setLayout(new BoxLayout(interior, BoxLayout.PAGE_AXIS));
	549
	550	fc.add(interior, BorderLayout.CENTER);
	551
	552	JPanel comboBoxPanel = new JPanel(new FlowLayout(FlowLayout.CENTER,
	553	0, 0) {
	554	public void layoutContainer(Container target) {
	555	super.layoutContainer(target);
	556	JComboBox comboBox = directoryComboBox;
	557	if (comboBox.getWidth() > target.getWidth()) {
	558	comboBox.setBounds(0, comboBox.getY(), target.getWidth(),
	559	comboBox.getHeight());
	560	}
	561	}
	562	});
	563	comboBoxPanel.setBorder(new EmptyBorder(0, 0, 4, 0));
	564	comboBoxPanel.setName("GTKFileChooser.directoryComboBoxPanel");
	565	// CurrentDir ComboBox
	566	directoryComboBoxModel = createDirectoryComboBoxModel(fc);
	567	directoryComboBox = new JComboBox(directoryComboBoxModel);
	568	directoryComboBox.setName("GTKFileChooser.directoryComboBox");
	569	directoryComboBox.putClientProperty( "JComboBox.lightweightKeyboardNavigation", "Lightweight" );
	570	directoryComboBox.addActionListener(directoryComboBoxAction);
	571	directoryComboBox.setMaximumRowCount(8);
	572	comboBoxPanel.add(directoryComboBox);
	573	interior.add(comboBoxPanel);
	574
	575
	576	// CENTER: left, right, accessory
	577	JPanel centerPanel = new JPanel(new BorderLayout());
	578	centerPanel.setName("GTKFileChooser.centerPanel");
	579
	580	// SPLIT PANEL: left, right
	581	JSplitPane splitPanel = new JSplitPane();
	582	splitPanel.setName("GTKFileChooser.splitPanel");
	583	splitPanel.setDividerLocation((PREF_SIZE.width-8)/2);
	584
	585	// left panel - Filter & directoryList
	586	JPanel leftPanel = new JPanel(new GridBagLayout());
	587	leftPanel.setName("GTKFileChooser.directoryListPanel");
	588
	589	// Add the Directory List
	590	// Create a label that looks like button (should be a table header)
	591	TableCellRenderer headerRenderer = new JTableHeader().getDefaultRenderer();
	592	JLabel directoryListLabel =
	593	(JLabel)headerRenderer.getTableCellRendererComponent(null, foldersLabelText,
	594	false, false, 0, 0);
	595	directoryListLabel.setName("GTKFileChooser.directoryListLabel");
	596	leftPanel.add(directoryListLabel, new GridBagConstraints(
	597	0, 0, 1, 1, 1, 0, GridBagConstraints.WEST,
	598	GridBagConstraints.HORIZONTAL,
	599	new Insets(0, 0, 0, 0), 0, 0));
	600	leftPanel.add(createDirectoryList(), new GridBagConstraints(
	601	0, 1, 1, 1, 1, 1, GridBagConstraints.EAST,
	602	GridBagConstraints.BOTH,
	603	new Insets(0, 0, 0, 0), 0, 0));
	604	directoryListLabel.setDisplayedMnemonic(foldersLabelMnemonic);
	605	directoryListLabel.setLabelFor(directoryList);
	606
	607	// create files list
	608	rightPanel = new JPanel(new GridBagLayout());
	609	rightPanel.setName("GTKFileChooser.fileListPanel");
	610
	611	headerRenderer = new JTableHeader().getDefaultRenderer();
	612	JLabel fileListLabel =
	613	(JLabel)headerRenderer.getTableCellRendererComponent(null, filesLabelText,
	614	false, false, 0, 0);
	615	fileListLabel.setName("GTKFileChooser.fileListLabel");
	616	rightPanel.add(fileListLabel, new GridBagConstraints(
	617	0, 0, 1, 1, 1, 0, GridBagConstraints.WEST,
	618	GridBagConstraints.HORIZONTAL,
	619	new Insets(0, 0, 0, 0), 0, 0));
	620	rightPanel.add(createFilesList(), new GridBagConstraints(
	621	0, 1, 1, 1, 1, 1, GridBagConstraints.EAST,
	622	GridBagConstraints.BOTH,
	623	new Insets(0, 0, 0, 0), 0, 0));
	624	fileListLabel.setDisplayedMnemonic(filesLabelMnemonic);
	625	fileListLabel.setLabelFor(fileList);
	626
	627	splitPanel.add(leftPanel, leftToRight ? JSplitPane.LEFT : JSplitPane.RIGHT);
	628	splitPanel.add(rightPanel, leftToRight ? JSplitPane.RIGHT : JSplitPane.LEFT);
	629	centerPanel.add(splitPanel, BorderLayout.CENTER);
	630
	631	JComponent accessoryPanel = getAccessoryPanel();
	632	JComponent accessory = fc.getAccessory();
	633	if (accessoryPanel != null) {
	634	if (accessory == null) {
	635	accessoryPanel.setPreferredSize(ZERO_ACC_SIZE);
	636	accessoryPanel.setMaximumSize(ZERO_ACC_SIZE);
	637	} else {
	638	getAccessoryPanel().add(accessory, BorderLayout.CENTER);
	639	accessoryPanel.setPreferredSize(accessory.getPreferredSize());
	640	accessoryPanel.setMaximumSize(MAX_SIZE);
	641	}
	642	align(accessoryPanel);
	643	centerPanel.add(accessoryPanel, BorderLayout.AFTER_LINE_ENDS);
	644	}
	645	interior.add(centerPanel);
	646	interior.add(Box.createRigidArea(vstrut10));
	647
	648	JPanel pathFieldPanel = new JPanel(new FlowLayout(FlowLayout.LEADING,
	649	0, 0));
	650	pathFieldPanel.setBorder(new EmptyBorder(0, 0, 4, 0));
	651	JLabel pathFieldLabel = new JLabel(pathLabelText);
	652	pathFieldLabel.setName("GTKFileChooser.pathFieldLabel");
	653	pathFieldLabel.setDisplayedMnemonic(pathLabelMnemonic);
	654	align(pathFieldLabel);
	655	pathFieldPanel.add(pathFieldLabel);
	656	pathFieldPanel.add(Box.createRigidArea(hstrut3));
	657
	658	File currentDirectory = fc.getCurrentDirectory();
	659	String curDirName = null;
	660	if (currentDirectory != null) {
	661	curDirName = currentDirectory.getPath();
	662	}
	663	pathField = new JLabel(curDirName) {
	664	public Dimension getMaximumSize() {
	665	Dimension d = super.getMaximumSize();
	666	d.height = getPreferredSize().height;
	667	return d;
	668	}
	669	};
	670	pathField.setName("GTKFileChooser.pathField");
	671	align(pathField);
	672	pathFieldPanel.add(pathField);
	673	interior.add(pathFieldPanel);
	674
	675	// add the fileName field
	676	fileNameTextField = new JTextField() {
	677	public Dimension getMaximumSize() {
	678	Dimension d = super.getMaximumSize();
	679	d.height = getPreferredSize().height;
	680	return d;
	681	}
	682	};
	683
	684	pathFieldLabel.setLabelFor(fileNameTextField);
	685
	686	Set<AWTKeyStroke> forwardTraversalKeys = fileNameTextField.getFocusTraversalKeys(
	687	KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS);
	688	forwardTraversalKeys = new HashSet<AWTKeyStroke>(forwardTraversalKeys);
	689	forwardTraversalKeys.remove(KeyStroke.getKeyStroke(KeyEvent.VK_TAB, 0));
	690	fileNameTextField.setFocusTraversalKeys(KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, forwardTraversalKeys);
	691
	692	fileNameTextField.setName("GTKFileChooser.fileNameTextField");
	693	fileNameTextField.getActionMap().put("fileNameCompletionAction", getFileNameCompletionAction());
	694	fileNameTextField.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_TAB, 0), "fileNameCompletionAction");
	695	interior.add(fileNameTextField);
	696
	697	// Add the filter combo box
	698	JPanel panel = new JPanel();
	699	panel.setLayout(new FlowLayout(FlowLayout.LEADING, 0, 0));
	700	panel.setBorder(new EmptyBorder(0, 0, 4, 0));
	701	JLabel filterLabel = new JLabel(filterLabelText);
	702	filterLabel.setName("GTKFileChooser.filterLabel");
	703	filterLabel.setDisplayedMnemonic(filterLabelMnemonic);
	704	panel.add(filterLabel);
	705
	706	filterComboBoxModel = createFilterComboBoxModel();
	707	fc.addPropertyChangeListener(filterComboBoxModel);
	708	filterComboBox = new JComboBox(filterComboBoxModel);
	709	filterComboBox.setRenderer(createFilterComboBoxRenderer());
	710	filterLabel.setLabelFor(filterComboBox);
	711
	712	interior.add(Box.createRigidArea(vstrut10));
	713	interior.add(panel);
	714	interior.add(filterComboBox);
	715
	716	// Add buttons
	717	bottomButtonPanel = new JPanel(new FlowLayout(FlowLayout.TRAILING));
	718	bottomButtonPanel.setName("GTKFileChooser.bottomButtonPanel");
	719	align(bottomButtonPanel);
	720
	721	JPanel pnButtons = new JPanel(new GridLayout(1, 2, 5, 0));
	722
	723	JButton cancelButton = getCancelButton(fc);
	724	align(cancelButton);
	725	cancelButton.setMargin(buttonMargin);
	726	pnButtons.add(cancelButton);
	727
	728	JButton approveButton = getApproveButton(fc);
	729	align(approveButton);
	730	approveButton.setMargin(buttonMargin);
	731	pnButtons.add(approveButton);
	732
	733	bottomButtonPanel.add(pnButtons);
	734
	735	if (fc.getControlButtonsAreShown()) {
	736	fc.add(bottomButtonPanel, BorderLayout.SOUTH);
	737	}
	738	}
	739
	740	protected void installListeners(JFileChooser fc) {
	741	super.installListeners(fc);
	742
	743	gtkFCPropertyChangeListener = new GTKFCPropertyChangeListener();
	744	fc.addPropertyChangeListener(gtkFCPropertyChangeListener);
	745	}
	746
	747	private int getMnemonic(String key, Locale l) {
	748	return SwingUtilities2.getUIDefaultsInt(key, l);
	749	}
	750
	751	protected void uninstallListeners(JFileChooser fc) {
	752	super.uninstallListeners(fc);
	753
	754	if (gtkFCPropertyChangeListener != null) {
	755	fc.removePropertyChangeListener(gtkFCPropertyChangeListener);
	756	}
	757	}
	758
	759	private class GTKFCPropertyChangeListener implements PropertyChangeListener {
	760	public void propertyChange(PropertyChangeEvent e) {
	761	String prop = e.getPropertyName();
	762	if (prop.equals("GTKFileChooser.showDirectoryIcons")) {
	763	showDirectoryIcons = Boolean.TRUE.equals(e.getNewValue());
	764	} else if (prop.equals("GTKFileChooser.showFileIcons")) {
	765	showFileIcons = Boolean.TRUE.equals(e.getNewValue());
	766	}
	767	}
	768	}
	769
	770	protected void installDefaults(JFileChooser fc) {
	771	super.installDefaults(fc);
	772	readOnly = UIManager.getBoolean("FileChooser.readOnly");
	773	showDirectoryIcons =
	774	Boolean.TRUE.equals(fc.getClientProperty("GTKFileChooser.showDirectoryIcons"));
	775	showFileIcons =
	776	Boolean.TRUE.equals(fc.getClientProperty("GTKFileChooser.showFileIcons"));
	777	}
	778
	779	protected void installIcons(JFileChooser fc) {
	780	directoryIcon = UIManager.getIcon("FileView.directoryIcon");
	781	fileIcon = UIManager.getIcon("FileView.fileIcon");
	782	}
	783
	784	protected void installStrings(JFileChooser fc) {
	785	super.installStrings(fc);
	786
	787	Locale l = fc.getLocale();
	788
	789	newFolderDialogText = UIManager.getString("FileChooser.newFolderDialogText", l);
	790	newFolderErrorText = UIManager.getString("FileChooser.newFolderErrorText",l);
	791	newFolderErrorSeparator = UIManager.getString("FileChooser.newFolderErrorSeparator",l);
	792	newFolderButtonText = UIManager.getString("FileChooser.newFolderButtonText", l);
	793	newFolderNoDirectoryErrorTitleText = UIManager.getString("FileChooser.newFolderNoDirectoryErrorTitleText", l);
	794	newFolderNoDirectoryErrorText = UIManager.getString("FileChooser.newFolderNoDirectoryErrorText", l);
	795	deleteFileButtonText = UIManager.getString("FileChooser.deleteFileButtonText", l);
	796	renameFileButtonText = UIManager.getString("FileChooser.renameFileButtonText", l);
	797
	798	newFolderButtonMnemonic = getMnemonic("FileChooser.newFolderButtonMnemonic", l);
	799	deleteFileButtonMnemonic = getMnemonic("FileChooser.deleteFileButtonMnemonic", l);
	800	renameFileButtonMnemonic = getMnemonic("FileChooser.renameFileButtonMnemonic", l);
	801
	802	newFolderButtonToolTipText = UIManager.getString("FileChooser.newFolderButtonToolTipText", l);
	803	deleteFileButtonToolTipText = UIManager.getString("FileChooser.deleteFileButtonToolTipText", l);
	804	renameFileButtonToolTipText = UIManager.getString("FileChooser.renameFileButtonToolTipText", l);
	805
	806	renameFileDialogText = UIManager.getString("FileChooser.renameFileDialogText", l);
	807	renameFileErrorTitle = UIManager.getString("FileChooser.renameFileErrorTitle", l);
	808	renameFileErrorText = UIManager.getString("FileChooser.renameFileErrorText", l);
	809
	810	foldersLabelText = UIManager.getString("FileChooser.foldersLabelText",l);
	811	foldersLabelMnemonic = getMnemonic("FileChooser.foldersLabelMnemonic", l);
	812
	813	filesLabelText = UIManager.getString("FileChooser.filesLabelText",l);
	814	filesLabelMnemonic = getMnemonic("FileChooser.filesLabelMnemonic", l);
	815
	816	pathLabelText = UIManager.getString("FileChooser.pathLabelText",l);
	817	pathLabelMnemonic = getMnemonic("FileChooser.pathLabelMnemonic", l);
	818
	819	filterLabelText = UIManager.getString("FileChooser.filterLabelText", l);
	820	filterLabelMnemonic = UIManager.getInt("FileChooser.filterLabelMnemonic");
	821	}
	822
	823	protected void uninstallStrings(JFileChooser fc) {
	824	super.uninstallStrings(fc);
	825
	826	newFolderButtonText = null;
	827	deleteFileButtonText = null;
	828	renameFileButtonText = null;
	829
	830	newFolderButtonToolTipText = null;
	831	deleteFileButtonToolTipText = null;
	832	renameFileButtonToolTipText = null;
	833
	834	renameFileDialogText = null;
	835	renameFileErrorTitle = null;
	836	renameFileErrorText = null;
	837
	838	foldersLabelText = null;
	839	filesLabelText = null;
	840
	841	pathLabelText = null;
	842
	843	newFolderDialogText = null;
	844	newFolderErrorText = null;
	845	newFolderErrorSeparator = null;
	846	}
	847
	848	protected JScrollPane createFilesList() {
	849	fileList = new JList();
	850	fileList.setName("GTKFileChooser.fileList");
	851	fileList.putClientProperty(AccessibleContext.ACCESSIBLE_NAME_PROPERTY, filesLabelText);
	852
	853	if (getFileChooser().isMultiSelectionEnabled()) {
	854	fileList.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
	855	} else {
	856	fileList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
	857	}
	858
	859	fileList.setModel(new GTKFileListModel());
	860	fileList.getSelectionModel().removeSelectionInterval(0, 0);
	861	fileList.setCellRenderer(new FileCellRenderer());
	862	fileList.addListSelectionListener(createListSelectionListener(getFileChooser()));
	863	fileList.addMouseListener(createDoubleClickListener(getFileChooser(), fileList));
	864	align(fileList);
	865	JScrollPane scrollpane = new JScrollPane(fileList);
	866	scrollpane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
	867	scrollpane.setName("GTKFileChooser.fileListScrollPane");
	868	scrollpane.setPreferredSize(prefListSize);
	869	scrollpane.setMaximumSize(MAX_SIZE);
	870	align(scrollpane);
	871	return scrollpane;
	872	}
	873
	874	protected JScrollPane createDirectoryList() {
	875	directoryList = new JList();
	876	directoryList.setName("GTKFileChooser.directoryList");
	877	directoryList.putClientProperty(AccessibleContext.ACCESSIBLE_NAME_PROPERTY, foldersLabelText);
	878	align(directoryList);
	879
	880	directoryList.setCellRenderer(new DirectoryCellRenderer());
	881	directoryListModel = new GTKDirectoryListModel();
	882	directoryList.getSelectionModel().removeSelectionInterval(0, 0);
	883	directoryList.setModel(directoryListModel);
	884	directoryList.addMouseListener(createDoubleClickListener(getFileChooser(), directoryList));
	885	directoryList.addListSelectionListener(createListSelectionListener(getFileChooser()));
	886
	887	JScrollPane scrollpane = new JScrollPane(directoryList);
	888	scrollpane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
	889	scrollpane.setName("GTKFileChooser.directoryListScrollPane");
	890	scrollpane.setMaximumSize(MAX_SIZE);
	891	scrollpane.setPreferredSize(prefListSize);
	892	align(scrollpane);
	893	return scrollpane;
	894	}
	895
	896	protected void createModel() {
	897	model = new GTKDirectoryModel();
	898	}
	899
	900	public BasicDirectoryModel getModel() {
	901	return model;
	902	}
	903
	904	public Action getApproveSelectionAction() {
	905	return approveSelectionAction;
	906	}
	907
	908	private class GTKDirectoryModel extends BasicDirectoryModel {
	909	FileSystemView fsv;
	910	private Comparator<File> fileComparator = new Comparator<File>() {
	911	public int compare(File o, File o1) {
	912	return fsv.getSystemDisplayName(o).compareTo(fsv.getSystemDisplayName(o1));
	913	}
	914	};
	915
	916	public GTKDirectoryModel() {
	917	super(getFileChooser());
	918	}
	919
	920	protected void sort(Vector<? extends File> v) {
	921	fsv = getFileChooser().getFileSystemView();
	922	Collections.sort(v, fileComparator);
	923	}
	924	}
	925
	926	protected class GTKDirectoryListModel extends AbstractListModel implements ListDataListener {
	927	File curDir;
	928	public GTKDirectoryListModel() {
	929	getModel().addListDataListener(this);
	930	directoryChanged();
	931	}
	932
	933	public int getSize() {
	934	return getModel().getDirectories().size() + 1;
	935	}
	936
	937	public Object getElementAt(int index) {
	938	return index > 0 ? getModel().getDirectories().elementAt(index - 1):
	939	curDir;
	940	}
	941
	942	public void intervalAdded(ListDataEvent e) {
	943	fireIntervalAdded(this, e.getIndex0(), e.getIndex1());
	944	}
	945
	946	public void intervalRemoved(ListDataEvent e) {
	947	fireIntervalRemoved(this, e.getIndex0(), e.getIndex1());
	948	}
	949
	950	// PENDING - this is inefficient - should sent out
	951	// incremental adjustment values instead of saying that the
	952	// whole list has changed.
	953	public void fireContentsChanged() {
	954	fireContentsChanged(this, 0, getModel().getDirectories().size()-1);
	955	}
	956
	957	// PENDING - fire the correct interval changed - currently sending
	958	// out that everything has changed
	959	public void contentsChanged(ListDataEvent e) {
	960	fireContentsChanged();
	961	}
	962
	963	private void directoryChanged() {
	964	curDir = getFileChooser().getFileSystemView().createFileObject(
	965	getFileChooser().getCurrentDirectory(), ".");
	966	}
	967	}
	968
	969	protected class GTKFileListModel extends AbstractListModel implements ListDataListener {
	970	public GTKFileListModel() {
	971	getModel().addListDataListener(this);
	972	}
	973
	974	public int getSize() {
	975	return getModel().getFiles().size();
	976	}
	977
	978	public boolean contains(Object o) {
	979	return getModel().getFiles().contains(o);
	980	}
	981
	982	public int indexOf(Object o) {
	983	return getModel().getFiles().indexOf(o);
	984	}
	985
	986	public Object getElementAt(int index) {
	987	return getModel().getFiles().elementAt(index);
	988	}
	989
	990	public void intervalAdded(ListDataEvent e) {
	991	fireIntervalAdded(this, e.getIndex0(), e.getIndex1());
	992	}
	993
	994	public void intervalRemoved(ListDataEvent e) {
	995	fireIntervalRemoved(this, e.getIndex0(), e.getIndex1());
	996	}
	997
	998	// PENDING - this is inefficient - should sent out
	999	// incremental adjustment values instead of saying that the
	1000	// whole list has changed.
	1001	public void fireContentsChanged() {
	1002	fireContentsChanged(this, 0, getModel().getFiles().size()-1);
	1003	}
	1004
	1005	// PENDING - fire the interval changed
	1006	public void contentsChanged(ListDataEvent e) {
	1007	fireContentsChanged();
	1008	}
	1009	}
	1010
	1011
	1012	protected class FileCellRenderer extends DefaultListCellRenderer {
	1013	public Component getListCellRendererComponent(JList list, Object value, int index,
	1014	boolean isSelected, boolean cellHasFocus) {
	1015
	1016	super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
	1017	setText(getFileChooser().getName((File) value));
	1018	if (showFileIcons) {
	1019	setIcon(getFileChooser().getIcon((File)value));
	1020	}
	1021	return this;
	1022	}
	1023	}
	1024
	1025	protected class DirectoryCellRenderer extends DefaultListCellRenderer {
	1026	public Component getListCellRendererComponent(JList list, Object value, int index,
	1027	boolean isSelected, boolean cellHasFocus) {
	1028
	1029	super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
	1030
	1031	if (showDirectoryIcons) {
	1032	setIcon(getFileChooser().getIcon((File)value));
	1033	setText(getFileChooser().getName((File)value));
	1034	} else {
	1035	setText(getFileChooser().getName((File)value) + "/");
	1036	}
	1037	return this;
	1038	}
	1039	}
	1040
	1041	public Dimension getPreferredSize(JComponent c) {
	1042	Dimension prefSize = new Dimension(PREF_SIZE);
	1043	JComponent accessory = getFileChooser().getAccessory();
	1044	if (accessory != null) {
	1045	prefSize.width += accessory.getPreferredSize().width + 20;
	1046	}
	1047	Dimension d = c.getLayout().preferredLayoutSize(c);
	1048	if (d != null) {
	1049	return new Dimension(d.width < prefSize.width ? prefSize.width : d.width,
	1050	d.height < prefSize.height ? prefSize.height : d.height);
	1051	} else {
	1052	return prefSize;
	1053	}
	1054	}
	1055
	1056	public Dimension getMinimumSize(JComponent x) {
	1057	return new Dimension(MIN_SIZE);
	1058	}
	1059
	1060	public Dimension getMaximumSize(JComponent x) {
	1061	return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
	1062	}
	1063
	1064	protected void align(JComponent c) {
	1065	c.setAlignmentX(JComponent.LEFT_ALIGNMENT);
	1066	c.setAlignmentY(JComponent.TOP_ALIGNMENT);
	1067	}
	1068
	1069	public Action getNewFolderAction() {
	1070	if (newFolderAction == null) {
	1071	newFolderAction = new NewFolderAction();
	1072	newFolderAction.setEnabled(!readOnly);
	1073	}
	1074	return newFolderAction;
	1075	}
	1076
	1077	//
	1078	// DataModel for DirectoryComboxbox
	1079	//
	1080	protected DirectoryComboBoxModel createDirectoryComboBoxModel(JFileChooser fc) {
	1081	return new DirectoryComboBoxModel();
	1082	}
	1083
	1084	/**
	1085	* Data model for a type-face selection combo-box.
	1086	*/
	1087	protected class DirectoryComboBoxModel extends AbstractListModel implements ComboBoxModel {
	1088	Vector<File> directories = new Vector<File>();
	1089	File selectedDirectory = null;
	1090	JFileChooser chooser = getFileChooser();
	1091	FileSystemView fsv = chooser.getFileSystemView();
	1092
	1093	public DirectoryComboBoxModel() {
	1094	// Add the current directory to the model, and make it the
	1095	// selectedDirectory
	1096	File dir = getFileChooser().getCurrentDirectory();
	1097	if (dir != null) {
	1098	addItem(dir);
	1099	}
	1100	}
	1101
	1102	/**
	1103	* Adds the directory to the model and sets it to be selected,
	1104	* additionally clears out the previous selected directory and
	1105	* the paths leading up to it, if any.
	1106	*/
	1107	private void addItem(File directory) {
	1108
	1109	if (directory == null) {
	1110	return;
	1111	}
	1112
	1113	int oldSize = directories.size();
	1114	directories.clear();
	1115	if (oldSize > 0) {
	1116	fireIntervalRemoved(this, 0, oldSize);
	1117	}
	1118
	1119	// Get the canonical (full) path. This has the side
	1120	// benefit of removing extraneous chars from the path,
	1121	// for example /foo/bar/ becomes /foo/bar
	1122	File canonical;
	1123	try {
	1124	canonical = fsv.createFileObject(ShellFolder.getNormalizedFile(directory).getPath());
	1125	} catch (IOException e) {
	1126	// Maybe drive is not ready. Can't abort here.
	1127	canonical = directory;
	1128	}
	1129
	1130	// create File instances of each directory leading up to the top
	1131	File f = canonical;
	1132	do {
	1133	directories.add(f);
	1134	} while ((f = f.getParentFile()) != null);
	1135	int newSize = directories.size();
	1136	if (newSize > 0) {
	1137	fireIntervalAdded(this, 0, newSize);
	1138	}
	1139	setSelectedItem(canonical);
	1140	}
	1141
	1142	public void setSelectedItem(Object selectedDirectory) {
	1143	this.selectedDirectory = (File)selectedDirectory;
	1144	fireContentsChanged(this, -1, -1);
	1145	}
	1146
	1147	public Object getSelectedItem() {
	1148	return selectedDirectory;
	1149	}
	1150
	1151	public int getSize() {
	1152	return directories.size();
	1153	}
	1154
	1155	public Object getElementAt(int index) {
	1156	return directories.elementAt(index);
	1157	}
	1158	}
	1159
	1160	/**
	1161	* Acts when DirectoryComboBox has changed the selected item.
	1162	*/
	1163	protected class DirectoryComboBoxAction extends AbstractAction {
	1164	protected DirectoryComboBoxAction() {
	1165	super("DirectoryComboBoxAction");
	1166	}
	1167
	1168	public void actionPerformed(ActionEvent e) {
	1169	File f = (File)directoryComboBox.getSelectedItem();
	1170	getFileChooser().setCurrentDirectory(f);
	1171	}
	1172	}
	1173
	1174	/**
	1175	* Creates a new folder.
	1176	*/
	1177	private class NewFolderAction extends AbstractAction {
	1178	protected NewFolderAction() {
	1179	super(FilePane.ACTION_NEW_FOLDER);
	1180	}
	1181	public void actionPerformed(ActionEvent e) {
	1182	if (readOnly) {
	1183	return;
	1184	}
	1185	JFileChooser fc = getFileChooser();
	1186	File currentDirectory = fc.getCurrentDirectory();
	1187	String dirName = JOptionPane.showInputDialog(fc,
	1188	newFolderDialogText, newFolderButtonText,
	1189	JOptionPane.PLAIN_MESSAGE);
	1190
	1191	if (dirName != null) {
	1192	if (!currentDirectory.exists()) {
	1193	JOptionPane.showMessageDialog(fc,
	1194	MessageFormat.format(newFolderNoDirectoryErrorText, dirName),
	1195	newFolderNoDirectoryErrorTitleText, JOptionPane.ERROR_MESSAGE);
	1196	return;
	1197	}
	1198
	1199	File newDir = fc.getFileSystemView().createFileObject
	1200	(currentDirectory, dirName);
	1201	if (newDir == null \|\| !newDir.mkdir()) {
	1202	JOptionPane.showMessageDialog(fc,
	1203	newFolderErrorText + newFolderErrorSeparator + " \"" +
	1204	dirName + "\"",
	1205	newFolderErrorText, JOptionPane.ERROR_MESSAGE);
	1206	}
	1207	fc.rescanCurrentDirectory();
	1208	}
	1209	}
	1210	}
	1211
	1212	private class GTKApproveSelectionAction extends ApproveSelectionAction {
	1213	public void actionPerformed(ActionEvent e) {
	1214	if (isDirectorySelected()) {
	1215	File dir = getDirectory();
	1216	try {
	1217	// Strip trailing ".."
	1218	if (dir != null) {
	1219	dir = ShellFolder.getNormalizedFile(dir);
	1220	}
	1221	} catch (IOException ex) {
	1222	// Ok, use f as is
	1223	}
	1224	if (getFileChooser().getCurrentDirectory().equals(dir)) {
	1225	directoryList.clearSelection();
	1226	fileList.clearSelection();
	1227	ListSelectionModel sm = fileList.getSelectionModel();
	1228	if (sm instanceof DefaultListSelectionModel) {
	1229	((DefaultListSelectionModel)sm).moveLeadSelectionIndex(0);
	1230	sm.setAnchorSelectionIndex(0);
	1231	}
	1232	rescanCurrentDirectory(getFileChooser());
	1233	return;
	1234	}
	1235	}
	1236	super.actionPerformed(e);
	1237	}
	1238	}
	1239
	1240	/**
	1241	* Renames file
	1242	*/
	1243	private class RenameFileAction extends AbstractAction {
	1244	protected RenameFileAction() {
	1245	super(FilePane.ACTION_EDIT_FILE_NAME);
	1246	}
	1247	public void actionPerformed(ActionEvent e) {
	1248	if (getFileName().equals("")) {
	1249	return;
	1250	}
	1251	JFileChooser fc = getFileChooser();
	1252	File currentDirectory = fc.getCurrentDirectory();
	1253	String newFileName = (String) JOptionPane.showInputDialog
	1254	(fc, new MessageFormat(renameFileDialogText).format
	1255	(new Object[] { getFileName() }),
	1256	renameFileButtonText, JOptionPane.PLAIN_MESSAGE, null, null,
	1257	getFileName());
	1258
	1259	if (newFileName != null) {
	1260	File oldFile = fc.getFileSystemView().createFileObject
	1261	(currentDirectory, getFileName());
	1262	File newFile = fc.getFileSystemView().createFileObject
	1263	(currentDirectory, newFileName);
	1264	if (oldFile == null \|\| newFile == null \|\|
	1265	!getModel().renameFile(oldFile, newFile)) {
	1266	JOptionPane.showMessageDialog(fc,
	1267	new MessageFormat(renameFileErrorText).
	1268	format(new Object[] { getFileName(), newFileName}),
	1269	renameFileErrorTitle, JOptionPane.ERROR_MESSAGE);
	1270	} else {
	1271	setFileName(getFileChooser().getName(newFile));
	1272	fc.rescanCurrentDirectory();
	1273	}
	1274	}
	1275	}
	1276	}
	1277
	1278	//
	1279	// Renderer for Filter ComboBox
	1280	//
	1281	protected FilterComboBoxRenderer createFilterComboBoxRenderer() {
	1282	return new FilterComboBoxRenderer();
	1283	}
	1284
	1285	/**
	1286	* Render different filters
	1287	*/
	1288	public class FilterComboBoxRenderer extends DefaultListCellRenderer implements UIResource {
	1289	public String getName() {
	1290	// As SynthComboBoxRenderer's are asked for a size BEFORE they
	1291	// are parented getName is overriden to force the name to be
	1292	// ComboBox.renderer if it isn't set. If we didn't do this the
	1293	// wrong style could be used for size calculations.
	1294	String name = super.getName();
	1295	if (name == null) {
	1296	return "ComboBox.renderer";
	1297	}
	1298	return name;
	1299	}
	1300
	1301	public Component getListCellRendererComponent(JList list, Object value,
	1302	int index, boolean isSelected,
	1303	boolean cellHasFocus) {
	1304
	1305	super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
	1306
	1307	setName("ComboBox.listRenderer");
	1308
	1309	if (value != null) {
	1310	if (value instanceof FileFilter) {
	1311	setText(((FileFilter) value).getDescription());
	1312	}
	1313	} else {
	1314	setText("");
	1315	}
	1316
	1317	return this;
	1318	}
	1319	}
	1320
	1321	//
	1322	// DataModel for Filter Combobox
	1323	//
	1324	protected FilterComboBoxModel createFilterComboBoxModel() {
	1325	return new FilterComboBoxModel();
	1326	}
	1327
	1328	/**
	1329	* Data model for filter combo-box.
	1330	*/
	1331	protected class FilterComboBoxModel extends AbstractListModel
	1332	implements ComboBoxModel, PropertyChangeListener {
	1333	protected FileFilter[] filters;
	1334
	1335	protected FilterComboBoxModel() {
	1336	super();
	1337	filters = getFileChooser().getChoosableFileFilters();
	1338	}
	1339
	1340	public void propertyChange(PropertyChangeEvent e) {
	1341	String prop = e.getPropertyName();
	1342	if (prop == JFileChooser.CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY) {
	1343	filters = (FileFilter[]) e.getNewValue();
	1344	fireContentsChanged(this, -1, -1);
	1345	} else if (prop == JFileChooser.FILE_FILTER_CHANGED_PROPERTY) {
	1346	fireContentsChanged(this, -1, -1);
	1347	}
	1348	}
	1349
	1350	public void setSelectedItem(Object filter) {
	1351	if (filter != null) {
	1352	getFileChooser().setFileFilter((FileFilter) filter);
	1353	fireContentsChanged(this, -1, -1);
	1354	}
	1355	}
	1356
	1357	public Object getSelectedItem() {
	1358	// Ensure that the current filter is in the list.
	1359	// NOTE: we shouldnt' have to do this, since JFileChooser adds
	1360	// the filter to the choosable filters list when the filter
	1361	// is set. Lets be paranoid just in case someone overrides
	1362	// setFileFilter in JFileChooser.
	1363	FileFilter currentFilter = getFileChooser().getFileFilter();
	1364	boolean found = false;
	1365	if (currentFilter != null) {
	1366	for (FileFilter filter : filters) {
	1367	if (filter == currentFilter) {
	1368	found = true;
	1369	}
	1370	}
	1371	if (found == false) {
	1372	getFileChooser().addChoosableFileFilter(currentFilter);
	1373	}
	1374	}
	1375	return getFileChooser().getFileFilter();
	1376	}
	1377
	1378	public int getSize() {
	1379	if (filters != null) {
	1380	return filters.length;
	1381	} else {
	1382	return 0;
	1383	}
	1384	}
	1385
	1386	public Object getElementAt(int index) {
	1387	if (index > getSize() - 1) {
	1388	// This shouldn't happen. Try to recover gracefully.
	1389	return getFileChooser().getFileFilter();
	1390	}
	1391	if (filters != null) {
	1392	return filters[index];
	1393	} else {
	1394	return null;
	1395	}
	1396	}
	1397	}
	1398	}

java/pkg/com/sun/java/swing/plaf/gtk/GTKGraphicsUtils.java+144−0

@@ -0,0 +1,144 @@
	1	/*
	2	* Copyright (c) 2002, 2006, 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	package com.sun.java.swing.plaf.gtk;
	26
	27	import javax.swing.*;
	28	import javax.swing.plaf.synth.*;
	29	import java.awt.Color;
	30	import java.awt.Graphics;
	31	import java.awt.Rectangle;
	32
	33	/**
	34	* @author Joshua Outwater
	35	*/
	36	class GTKGraphicsUtils extends SynthGraphicsUtils {
	37	public void paintText(SynthContext context, Graphics g, String text,
	38	int x, int y, int mnemonicIndex) {
	39	if (text == null \|\| text.length() <= 0) {
	40	// We don't need to paint empty strings
	41	return;
	42	}
	43
	44	if (context.getRegion() == Region.INTERNAL_FRAME_TITLE_PANE) {
	45	// Metacity handles painting of text on internal frame title,
	46	// ignore this.
	47	return;
	48	}
	49	int componentState = context.getComponentState();
	50	if ((componentState & SynthConstants.DISABLED) ==
	51	SynthConstants.DISABLED){
	52	Color orgColor = g.getColor();
	53	g.setColor(context.getStyle().getColor(context,
	54	GTKColorType.WHITE));
	55	x += 1;
	56	y += 1;
	57	super.paintText(context, g, text, x, y, mnemonicIndex);
	58
	59	g.setColor(orgColor);
	60	x -= 1;
	61	y -= 1;
	62	super.paintText(context, g, text, x, y, mnemonicIndex);
	63	}
	64	else {
	65	String themeName = GTKLookAndFeel.getGtkThemeName();
	66	if (themeName != null && themeName.startsWith("blueprint") &&
	67	shouldShadowText(context.getRegion(), componentState)) {
	68
	69	g.setColor(Color.BLACK);
	70	super.paintText(context, g, text, x+1, y+1, mnemonicIndex);
	71	g.setColor(Color.WHITE);
	72	}
	73
	74	super.paintText(context, g, text, x, y, mnemonicIndex);
	75	}
	76	}
	77
	78	/**
	79	* Paints text at the specified location. This will not attempt to
	80	* render the text as html nor will it offset by the insets of the
	81	* component.
	82	*
	83	* @param ss SynthContext
	84	* @param g Graphics used to render string in.
	85	* @param text Text to render
	86	* @param bounds Bounds of the text to be drawn.
	87	* @param mnemonicIndex Index to draw string at.
	88	*/
	89	public void paintText(SynthContext context, Graphics g, String text,
	90	Rectangle bounds, int mnemonicIndex) {
	91	if (text == null \|\| text.length() <= 0) {
	92	// We don't need to paint empty strings
	93	return;
	94	}
	95
	96	Region id = context.getRegion();
	97	if ((id == Region.RADIO_BUTTON \|\|
	98	id == Region.CHECK_BOX \|\|
	99	id == Region.TABBED_PANE_TAB) &&
	100	(context.getComponentState() & SynthConstants.FOCUSED) != 0)
	101	{
	102	JComponent source = context.getComponent();
	103	if (!(source instanceof AbstractButton) \|\|
	104	((AbstractButton)source).isFocusPainted()) {
	105
	106	// The "bounds" parameter encompasses only the actual text;
	107	// when drawing the focus, we need to expand that bounding
	108	// box by "focus-line-width" plus "focus-padding". Note that
	109	// the layout process for these components will have already
	110	// taken these values into account, so there should always
	111	// be enough space allocated for drawing the focus indicator.
	112	int synthState = context.getComponentState();
	113	GTKStyle style = (GTKStyle)context.getStyle();
	114	int focusSize =
	115	style.getClassSpecificIntValue(context,
	116	"focus-line-width", 1);
	117	int focusPad =
	118	style.getClassSpecificIntValue(context,
	119	"focus-padding", 1);
	120	int totalFocus = focusSize + focusPad;
	121	int x = bounds.x - totalFocus;
	122	int y = bounds.y - totalFocus;
	123	int w = bounds.width + (2 * totalFocus);
	124	int h = bounds.height + (2 * totalFocus);
	125
	126	Color color = g.getColor();
	127	GTKPainter.INSTANCE.paintFocus(context, g, id,
	128	synthState, "checkbutton",
	129	x, y, w, h);
	130	g.setColor(color);
	131	}
	132	}
	133	super.paintText(context, g, text, bounds, mnemonicIndex);
	134	}
	135
	136	private static boolean shouldShadowText(Region id, int state) {
	137	int gtkState = GTKLookAndFeel.synthStateToGTKState(id, state);
	138	return((gtkState == SynthConstants.MOUSE_OVER) &&
	139	(id == Region.MENU \|\|
	140	id == Region.MENU_ITEM \|\|
	141	id == Region.CHECK_BOX_MENU_ITEM \|\|
	142	id == Region.RADIO_BUTTON_MENU_ITEM));
	143	}
	144	}

java/pkg/com/sun/java/swing/plaf/gtk/GTKIconFactory.java+351−0

@@ -0,0 +1,351 @@
	1	/*
	2	* Copyright (c) 2002, 2006, 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	package com.sun.java.swing.plaf.gtk;
	26
	27	import java.util.*;
	28	import javax.swing.plaf.synth.*;
	29	import java.awt.*;
	30	import java.awt.image.BufferedImage;
	31	import java.lang.reflect.*;
	32	import javax.swing.*;
	33	import javax.swing.plaf.*;
	34	import sun.swing.plaf.synth.*;
	35	import com.sun.java.swing.plaf.gtk.GTKConstants.ArrowType;
	36	import com.sun.java.swing.plaf.gtk.GTKConstants.ExpanderStyle;
	37	import com.sun.java.swing.plaf.gtk.GTKConstants.Orientation;
	38	import com.sun.java.swing.plaf.gtk.GTKConstants.ShadowType;
	39
	40	/**
	41	*/
	42	class GTKIconFactory {
	43	static final int CHECK_ICON_EXTRA_INSET = 1;
	44	static final int DEFAULT_ICON_SPACING = 2;
	45	static final int DEFAULT_ICON_SIZE = 13;
	46	static final int DEFAULT_TOGGLE_MENU_ITEM_SIZE = 12; // For pre-gtk2.4
	47
	48	private static final String RADIO_BUTTON_ICON = "paintRadioButtonIcon";
	49	private static final String CHECK_BOX_ICON = "paintCheckBoxIcon";
	50	private static final String MENU_ARROW_ICON = "paintMenuArrowIcon";
	51	private static final String CHECK_BOX_MENU_ITEM_CHECK_ICON =
	52	"paintCheckBoxMenuItemCheckIcon";
	53	private static final String RADIO_BUTTON_MENU_ITEM_CHECK_ICON =
	54	"paintRadioButtonMenuItemCheckIcon";
	55	private static final String TREE_EXPANDED_ICON = "paintTreeExpandedIcon";
	56	private static final String TREE_COLLAPSED_ICON = "paintTreeCollapsedIcon";
	57	private static final String ASCENDING_SORT_ICON = "paintAscendingSortIcon";
	58	private static final String DESCENDING_SORT_ICON = "paintDescendingSortIcon";
	59	private static final String TOOL_BAR_HANDLE_ICON = "paintToolBarHandleIcon";
	60
	61	private static Map<String, DelegatingIcon> iconsPool =
	62	Collections.synchronizedMap(new HashMap<String, DelegatingIcon>());
	63
	64	private static DelegatingIcon getIcon(String methodName) {
	65	DelegatingIcon result = iconsPool.get(methodName);
	66	if (result == null) {
	67	if (methodName == TREE_COLLAPSED_ICON \|\|
	68	methodName == TREE_EXPANDED_ICON)
	69	{
	70	result = new SynthExpanderIcon(methodName);
	71
	72	} else if (methodName == TOOL_BAR_HANDLE_ICON) {
	73	result = new ToolBarHandleIcon();
	74
	75	} else if (methodName == MENU_ARROW_ICON) {
	76	result = new MenuArrowIcon();
	77
	78	} else {
	79	result = new DelegatingIcon(methodName);
	80	}
	81	iconsPool.put(methodName, result);
	82	}
	83	return result;
	84	}
	85
	86	//
	87	// Sort arrow
	88	//
	89	public static Icon getAscendingSortIcon() {
	90	return getIcon(ASCENDING_SORT_ICON);
	91	}
	92
	93	public static Icon getDescendingSortIcon() {
	94	return getIcon(DESCENDING_SORT_ICON);
	95	}
	96
	97	//
	98	// Tree methods
	99	//
	100	public static SynthIcon getTreeExpandedIcon() {
	101	return getIcon(TREE_EXPANDED_ICON);
	102	}
	103
	104	public static SynthIcon getTreeCollapsedIcon() {
	105	return getIcon(TREE_COLLAPSED_ICON);
	106	}
	107
	108	//
	109	// Radio button
	110	//
	111	public static SynthIcon getRadioButtonIcon() {
	112	return getIcon(RADIO_BUTTON_ICON);
	113	}
	114
	115	//
	116	// CheckBox
	117	//
	118	public static SynthIcon getCheckBoxIcon() {
	119	return getIcon(CHECK_BOX_ICON);
	120	}
	121
	122	//
	123	// Menus
	124	//
	125	public static SynthIcon getMenuArrowIcon() {
	126	return getIcon(MENU_ARROW_ICON);
	127	}
	128
	129	public static SynthIcon getCheckBoxMenuItemCheckIcon() {
	130	return getIcon(CHECK_BOX_MENU_ITEM_CHECK_ICON);
	131	}
	132
	133	public static SynthIcon getRadioButtonMenuItemCheckIcon() {
	134	return getIcon(RADIO_BUTTON_MENU_ITEM_CHECK_ICON);
	135	}
	136
	137	//
	138	// ToolBar Handle
	139	//
	140	public static SynthIcon getToolBarHandleIcon() {
	141	return getIcon(TOOL_BAR_HANDLE_ICON);
	142	}
	143
	144	static void resetIcons() {
	145	synchronized (iconsPool) {
	146	for (DelegatingIcon di: iconsPool.values()) {
	147	di.resetIconDimensions();
	148	}
	149	}
	150	}
	151
	152	private static class DelegatingIcon extends SynthIcon implements
	153	UIResource {
	154	private static final Class[] PARAM_TYPES = new Class[] {
	155	SynthContext.class, Graphics.class, int.class,
	156	int.class, int.class, int.class, int.class
	157	};
	158
	159	private Object method;
	160	int iconDimension = -1;
	161
	162	DelegatingIcon(String methodName ){
	163	this.method = methodName;
	164	}
	165
	166	public void paintIcon(SynthContext context, Graphics g,
	167	int x, int y, int w, int h) {
	168	if (context != null) {
	169	GTKPainter.INSTANCE.paintIcon(context, g,
	170	getMethod(), x, y, w, h);
	171	}
	172	}
	173
	174	public int getIconWidth(SynthContext context) {
	175	return getIconDimension(context);
	176	}
	177
	178	public int getIconHeight(SynthContext context) {
	179	return getIconDimension(context);
	180	}
	181
	182	void resetIconDimensions() {
	183	iconDimension = -1;
	184	}
	185
	186	protected Method getMethod() {
	187	if (method instanceof String) {
	188	method = resolveMethod((String)method);
	189	}
	190	return (Method)method;
	191	}
	192
	193	protected Class[] getMethodParamTypes() {
	194	return PARAM_TYPES;
	195	}
	196
	197	private Method resolveMethod(String name) {
	198	try {
	199	return GTKPainter.class.getMethod(name, getMethodParamTypes());
	200	} catch (NoSuchMethodException e) {
	201	assert false;
	202	}
	203	return null;
	204	}
	205
	206	int getIconDimension(SynthContext context) {
	207	if (iconDimension >= 0) {
	208	return iconDimension;
	209	}
	210
	211	if (context == null) {
	212	return DEFAULT_ICON_SIZE;
	213	}
	214
	215	Region region = context.getRegion();
	216	GTKStyle style = (GTKStyle) context.getStyle();
	217	iconDimension = style.getClassSpecificIntValue(context,
	218	"indicator-size",
	219	(region == Region.CHECK_BOX_MENU_ITEM \|\|
	220	region == Region.RADIO_BUTTON_MENU_ITEM) ?
	221	DEFAULT_TOGGLE_MENU_ITEM_SIZE : DEFAULT_ICON_SIZE);
	222
	223	if (region == Region.CHECK_BOX \|\| region == Region.RADIO_BUTTON) {
	224	iconDimension += 2 * style.getClassSpecificIntValue(context,
	225	"indicator-spacing", DEFAULT_ICON_SPACING);
	226	} else if (region == Region.CHECK_BOX_MENU_ITEM \|\|
	227	region == Region.RADIO_BUTTON_MENU_ITEM) {
	228	iconDimension += 2 * CHECK_ICON_EXTRA_INSET;
	229	}
	230	return iconDimension;
	231	}
	232	}
	233
	234	private static class SynthExpanderIcon extends DelegatingIcon {
	235	SynthExpanderIcon(String method) {
	236	super(method);
	237	}
	238
	239	public void paintIcon(SynthContext context, Graphics g, int x, int y,
	240	int w, int h) {
	241	if (context != null) {
	242	super.paintIcon(context, g, x, y, w, h);
	243	updateSizeIfNecessary(context);
	244	}
	245	}
	246
	247	int getIconDimension(SynthContext context) {
	248	updateSizeIfNecessary(context);
	249	return (iconDimension == -1) ? DEFAULT_ICON_SIZE :
	250	iconDimension;
	251	}
	252
	253	private void updateSizeIfNecessary(SynthContext context) {
	254	if (iconDimension == -1 && context != null) {
	255	iconDimension = context.getStyle().getInt(context,
	256	"Tree.expanderSize", 10);
	257	}
	258	}
	259	}
	260
	261	// GTK has a separate widget for the handle box, to mirror this
	262	// we create a unique icon per ToolBar and lookup the style for the
	263	// HandleBox.
	264	private static class ToolBarHandleIcon extends DelegatingIcon {
	265	private static final Class[] PARAM_TYPES = new Class[] {
	266	SynthContext.class, Graphics.class, int.class,
	267	int.class, int.class, int.class, int.class, Orientation.class,
	268	};
	269
	270	private SynthStyle style;
	271
	272	public ToolBarHandleIcon() {
	273	super(TOOL_BAR_HANDLE_ICON);
	274	}
	275
	276	protected Class[] getMethodParamTypes() {
	277	return PARAM_TYPES;
	278	}
	279
	280	public void paintIcon(SynthContext context, Graphics g, int x, int y,
	281	int w, int h) {
	282	if (context != null) {
	283	JToolBar toolbar = (JToolBar)context.getComponent();
	284	Orientation orientation =
	285	(toolbar.getOrientation() == JToolBar.HORIZONTAL ?
	286	Orientation.HORIZONTAL : Orientation.VERTICAL);
	287
	288	if (style == null) {
	289	style = SynthLookAndFeel.getStyleFactory().getStyle(
	290	context.getComponent(), GTKRegion.HANDLE_BOX);
	291	}
	292	context = new SynthContext(toolbar, GTKRegion.HANDLE_BOX,
	293	style, SynthConstants.ENABLED);
	294
	295	GTKPainter.INSTANCE.paintIcon(context, g,
	296	getMethod(), x, y, w, h, orientation);
	297	}
	298	}
	299
	300	public int getIconWidth(SynthContext context) {
	301	if (context == null) {
	302	return 10;
	303	}
	304	if (((JToolBar)context.getComponent()).getOrientation() ==
	305	JToolBar.HORIZONTAL) {
	306	return 10;
	307	} else {
	308	return context.getComponent().getWidth();
	309	}
	310	}
	311
	312	public int getIconHeight(SynthContext context) {
	313	if (context == null) {
	314	return 10;
	315	}
	316	if (((JToolBar)context.getComponent()).getOrientation() ==
	317	JToolBar.HORIZONTAL) {
	318	return context.getComponent().getHeight();
	319	} else {
	320	return 10;
	321	}
	322	}
	323	}
	324
	325	private static class MenuArrowIcon extends DelegatingIcon {
	326	private static final Class[] PARAM_TYPES = new Class[] {
	327	SynthContext.class, Graphics.class, int.class,
	328	int.class, int.class, int.class, int.class, ArrowType.class,
	329	};
	330
	331	public MenuArrowIcon() {
	332	super(MENU_ARROW_ICON);
	333	}
	334
	335	protected Class[] getMethodParamTypes() {
	336	return PARAM_TYPES;
	337	}
	338
	339	public void paintIcon(SynthContext context, Graphics g, int x, int y,
	340	int w, int h) {
	341	if (context != null) {
	342	ArrowType arrowDir = ArrowType.RIGHT;
	343	if (!context.getComponent().getComponentOrientation().isLeftToRight()) {
	344	arrowDir = ArrowType.LEFT;
	345	}
	346	GTKPainter.INSTANCE.paintIcon(context, g,
	347	getMethod(), x, y, w, h, arrowDir);
	348	}
	349	}
	350	}
	351	}

java/pkg/com/sun/java/swing/plaf/gtk/GTKLookAndFeel.java+1739−0

@@ -0,0 +1,1739 @@
	1	/*
	2	* Copyright (c) 2002, 2009, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.swing.plaf.gtk;
	27
	28	import java.awt.*;
	29	import java.awt.event.*;
	30	import java.beans.*;
	31	import java.io.File;
	32	import java.lang.ref.*;
	33	import java.security.AccessController;
	34	import java.security.PrivilegedAction;
	35	import java.util.Locale;
	36	import javax.swing.*;
	37	import javax.swing.colorchooser.*;
	38	import javax.swing.plaf.*;
	39	import javax.swing.plaf.synth.*;
	40	import javax.swing.text.DefaultEditorKit;
	41
	42	import com.sun.java.swing.plaf.gtk.GTKConstants.PositionType;
	43	import com.sun.java.swing.plaf.gtk.GTKConstants.StateType;
	44	import sun.awt.SunToolkit;
	45	import sun.awt.UNIXToolkit;
	46	import sun.awt.OSInfo;
	47	import sun.security.action.GetPropertyAction;
	48	import sun.swing.DefaultLayoutStyle;
	49	import sun.swing.SwingUtilities2;
	50
	51	/**
	52	* @author Scott Violet
	53	*/
	54	public class GTKLookAndFeel extends SynthLookAndFeel {
	55	private static final boolean IS_22;
	56
	57	/**
	58	* Whether or not text is drawn antialiased. This keys off the
	59	* desktop property 'gnome.Xft/Antialias' and 'gnome.Xft/RGBA'
	60	* We should assume ON - or some variation of ON as no GTK desktop
	61	* ships with it OFF.
	62	*/
	63	static Object aaTextInfo;
	64
	65	/**
	66	* Solaris, or Linux with Sun JDS in a CJK Locale.
	67	* Used to determine if Sun's high quality CJK fonts are present.
	68	*/
	69	private static boolean isSunCJK;
	70
	71	/*
	72	* Used to override if system (desktop) text anti-aliasing settings should
	73	* be used. The reasons for this are are is that currently its "off"
	74	* for CJK locales which is not likely to be a good universal answer, and
	75	* also its off for remote display. So this provides an unsupported
	76	* way to explicitly request that it be "on".
	77	*/
	78	private static boolean gtkAAFontSettingsCond;
	79
	80	/**
	81	* Font to use in places where there is no widget.
	82	*/
	83	private Font fallbackFont;
	84
	85	/**
	86	* If true, GTKLookAndFeel is inside the <code>initialize</code>
	87	* method.
	88	*/
	89	private boolean inInitialize;
	90
	91	/**
	92	* If true, PropertyChangeListeners have been installed for the
	93	* Toolkit.
	94	*/
	95	private boolean pclInstalled;
	96
	97	/**
	98	* StyleFactory needs to be created only the first time.
	99	*/
	100	private GTKStyleFactory styleFactory;
	101
	102	/**
	103	* Cached theme name. Used by GTKGraphicsUtils
	104	*/
	105	private static String gtkThemeName = "Default";
	106
	107	static {
	108	// Backup for specifying the version, this isn't currently documented.
	109	// If you pass in anything but 2.2 you got the 2.0 colors/look.
	110	String version = AccessController.doPrivileged(
	111	new GetPropertyAction("swing.gtk.version"));
	112	if (version != null) {
	113	IS_22 = version.equals("2.2");
	114	}
	115	else {
	116	IS_22 = true;
	117	}
	118
	119	String language = Locale.getDefault().getLanguage();
	120	boolean cjkLocale =
	121	(Locale.CHINESE.getLanguage().equals(language) \|\|
	122	Locale.JAPANESE.getLanguage().equals(language) \|\|
	123	Locale.KOREAN.getLanguage().equals(language));
	124
	125	if (cjkLocale) {
	126	boolean isSunDesktop = false;
	127	switch (OSInfo.getOSType()) {
	128	case SOLARIS:
	129	isSunDesktop = true;
	130	break;
	131
	132	case LINUX:
	133	Boolean val = AccessController.doPrivileged(
	134	new PrivilegedAction<Boolean>() {
	135	public Boolean run() {
	136	File f = new File("/etc/sun-release");
	137	return Boolean.valueOf(f.exists());
	138	}
	139	});
	140	isSunDesktop = val.booleanValue();
	141	}
	142	if (isSunDesktop && !sun.java2d.SunGraphicsEnvironment.isOpenSolaris) {
	143	isSunCJK = true;
	144	}
	145	}
	146	}
	147
	148	/**
	149	* Returns true if running on system containing at least 2.2.
	150	*/
	151	static boolean is2_2() {
	152	// NOTE: We're currently hard coding to use 2.2.
	153	// If we want to support both GTK 2.0 and 2.2, we'll
	154	// need to get the major/minor/micro version from the .so.
	155	// Refer to bug 4912613 for details.
	156	return IS_22;
	157	}
	158
	159	/**
	160	* Maps a swing constant to a GTK constant.
	161	*/
	162	static PositionType SwingOrientationConstantToGTK(int side) {
	163	switch (side) {
	164	case SwingConstants.LEFT:
	165	return PositionType.LEFT;
	166	case SwingConstants.RIGHT:
	167	return PositionType.RIGHT;
	168	case SwingConstants.TOP:
	169	return PositionType.TOP;
	170	case SwingConstants.BOTTOM:
	171	return PositionType.BOTTOM;
	172	}
	173	assert false : "Unknown orientation: " + side;
	174	return PositionType.TOP;
	175	}
	176
	177	/**
	178	* Maps from Synth state to native GTK state using typesafe enumeration
	179	* StateType. This is only used by GTKEngine.
	180	*/
	181	static StateType synthStateToGTKStateType(int state) {
	182	StateType result;
	183	switch (state) {
	184	case SynthConstants.PRESSED:
	185	result = StateType.ACTIVE;
	186	break;
	187	case SynthConstants.MOUSE_OVER:
	188	result = StateType.PRELIGHT;
	189	break;
	190	case SynthConstants.SELECTED:
	191	result = StateType.SELECTED;
	192	break;
	193	case SynthConstants.DISABLED:
	194	result = StateType.INSENSITIVE;
	195	break;
	196	case SynthConstants.ENABLED:
	197	default:
	198	result = StateType.NORMAL;
	199	break;
	200	}
	201	return result;
	202	}
	203
	204	/**
	205	* Maps from a Synth state to the corresponding GTK state.
	206	* The GTK states are named differently than Synth's states, the
	207	* following gives the mapping:
	208	* <table><tr><td>Synth<td>GTK
	209	* <tr><td>SynthConstants.PRESSED<td>ACTIVE
	210	* <tr><td>SynthConstants.SELECTED<td>SELECTED
	211	* <tr><td>SynthConstants.MOUSE_OVER<td>PRELIGHT
	212	* <tr><td>SynthConstants.DISABLED<td>INSENSITIVE
	213	* <tr><td>SynthConstants.ENABLED<td>NORMAL
	214	* </table>
	215	* Additionally some widgets are special cased.
	216	*/
	217	static int synthStateToGTKState(Region region, int state) {
	218	if ((state & SynthConstants.PRESSED) != 0) {
	219	if (region == Region.RADIO_BUTTON
	220	\|\| region == Region.CHECK_BOX
	221	\|\| region == Region.MENU
	222	\|\| region == Region.MENU_ITEM
	223	\|\| region == Region.RADIO_BUTTON_MENU_ITEM
	224	\|\| region == Region.CHECK_BOX_MENU_ITEM
	225	\|\| region == Region.SPLIT_PANE) {
	226	state = SynthConstants.MOUSE_OVER;
	227	} else {
	228	state = SynthConstants.PRESSED;
	229	}
	230
	231	} else if (region == Region.TABBED_PANE_TAB) {
	232	if ((state & SynthConstants.DISABLED) != 0) {
	233	state = SynthConstants.DISABLED;
	234	}
	235	else if ((state & SynthConstants.SELECTED) != 0) {
	236	state = SynthConstants.ENABLED;
	237	} else {
	238	state = SynthConstants.PRESSED;
	239	}
	240
	241	} else if ((state & SynthConstants.SELECTED) != 0) {
	242	if (region == Region.MENU) {
	243	state = SynthConstants.MOUSE_OVER;
	244	} else if (region == Region.RADIO_BUTTON \|\|
	245	region == Region.TOGGLE_BUTTON \|\|
	246	region == Region.RADIO_BUTTON_MENU_ITEM \|\|
	247	region == Region.CHECK_BOX_MENU_ITEM \|\|
	248	region == Region.CHECK_BOX \|\|
	249	region == Region.BUTTON) {
	250	if ((state & SynthConstants.DISABLED) != 0) {
	251	state = SynthConstants.DISABLED;
	252	}
	253	// If the button is SELECTED and is PRELIGHT we need to
	254	// make the state MOUSE_OVER otherwise we don't paint the
	255	// PRELIGHT.
	256	else if ((state & SynthConstants.MOUSE_OVER) != 0) {
	257	state = SynthConstants.MOUSE_OVER;
	258	} else {
	259	state = SynthConstants.PRESSED;
	260	}
	261	} else {
	262	state = SynthConstants.SELECTED;
	263	}
	264	}
	265
	266	else if ((state & SynthConstants.MOUSE_OVER) != 0) {
	267	state = SynthConstants.MOUSE_OVER;
	268	}
	269	else if ((state & SynthConstants.DISABLED) != 0) {
	270	state = SynthConstants.DISABLED;
	271	}
	272	else {
	273	if (region == Region.SLIDER_TRACK) {
	274	state = SynthConstants.PRESSED;
	275	} else {
	276	state = SynthConstants.ENABLED;
	277	}
	278	}
	279	return state;
	280	}
	281
	282	static boolean isText(Region region) {
	283	// These Regions treat FOREGROUND as TEXT.
	284	return (region == Region.TEXT_FIELD \|\|
	285	region == Region.FORMATTED_TEXT_FIELD \|\|
	286	region == Region.LIST \|\|
	287	region == Region.PASSWORD_FIELD \|\|
	288	region == Region.SPINNER \|\|
	289	region == Region.TABLE \|\|
	290	region == Region.TEXT_AREA \|\|
	291	region == Region.TEXT_FIELD \|\|
	292	region == Region.TEXT_PANE \|\|
	293	region == Region.TREE);
	294	}
	295
	296	public UIDefaults getDefaults() {
	297	// We need to call super for basic's properties file.
	298	UIDefaults table = super.getDefaults();
	299
	300	// SynthTabbedPaneUI supports rollover on tabs, GTK does not
	301	table.put("TabbedPane.isTabRollover", Boolean.FALSE);
	302
	303	// Prevents Synth from setting text AA by itself
	304	table.put("Synth.doNotSetTextAA", true);
	305
	306	initResourceBundle(table);
	307	// For compatability with apps expecting certain defaults we'll
	308	// populate the table with the values from basic.
	309	initSystemColorDefaults(table);
	310	initComponentDefaults(table);
	311	installPropertyChangeListeners();
	312	return table;
	313	}
	314
	315	private void installPropertyChangeListeners() {
	316	if(!pclInstalled) {
	317	Toolkit kit = Toolkit.getDefaultToolkit();
	318	WeakPCL pcl = new WeakPCL(this, kit, "gnome.Net/ThemeName");
	319	kit.addPropertyChangeListener(pcl.getKey(), pcl);
	320	pcl = new WeakPCL(this, kit, "gnome.Gtk/FontName");
	321	kit.addPropertyChangeListener(pcl.getKey(), pcl);
	322	pcl = new WeakPCL(this, kit, "gnome.Xft/DPI");
	323	kit.addPropertyChangeListener(pcl.getKey(), pcl);
	324
	325	flushUnreferenced();
	326	pclInstalled = true;
	327	}
	328	}
	329
	330	private void initResourceBundle(UIDefaults table) {
	331	table.addResourceBundle("com.sun.java.swing.plaf.gtk.resources.gtk");
	332	}
	333
	334	protected void initComponentDefaults(UIDefaults table) {
	335	// For compatability with apps expecting certain defaults we'll
	336	// populate the table with the values from basic.
	337	super.initComponentDefaults(table);
	338
	339	Integer zero = Integer.valueOf(0);
	340	Object zeroBorder = new sun.swing.SwingLazyValue(
	341	"javax.swing.plaf.BorderUIResource$EmptyBorderUIResource",
	342	new Object[] {zero, zero, zero, zero});
	343	Object focusBorder = new GTKStyle.GTKLazyValue(
	344	"com.sun.java.swing.plaf.gtk.GTKPainter$ListTableFocusBorder",
	345	"getUnselectedCellBorder");
	346	Object focusSelectedBorder = new GTKStyle.GTKLazyValue(
	347	"com.sun.java.swing.plaf.gtk.GTKPainter$ListTableFocusBorder",
	348	"getSelectedCellBorder");
	349	Object noFocusBorder = new GTKStyle.GTKLazyValue(
	350	"com.sun.java.swing.plaf.gtk.GTKPainter$ListTableFocusBorder",
	351	"getNoFocusCellBorder");
	352
	353	GTKStyleFactory factory = (GTKStyleFactory)getStyleFactory();
	354	GTKStyle tableStyle = (GTKStyle)factory.getStyle(null, Region.TREE);
	355	Color tableBg = tableStyle.getGTKColor(SynthConstants.ENABLED,
	356	GTKColorType.TEXT_BACKGROUND);
	357	Color tableFocusCellBg = tableStyle.getGTKColor(SynthConstants.ENABLED,
	358	GTKColorType.BACKGROUND);
	359	Color tableFocusCellFg = tableStyle.getGTKColor(SynthConstants.ENABLED,
	360	GTKColorType.FOREGROUND);
	361
	362	// The following progress bar size calculations come from
	363	// gtkprogressbar.c (version 2.8.20), see MIN_* constants and
	364	// the gtk_progress_bar_size_request() method.
	365	GTKStyle progStyle = (GTKStyle)
	366	factory.getStyle(null, Region.PROGRESS_BAR);
	367	int progXThickness = progStyle.getXThickness();
	368	int progYThickness = progStyle.getYThickness();
	369	int hProgWidth = 150 - (progXThickness * 2);
	370	int hProgHeight = 20 - (progYThickness * 2);
	371	int vProgWidth = 22 - (progXThickness * 2);
	372	int vProgHeight = 80 - (progYThickness * 2);
	373
	374	Integer caretBlinkRate = Integer.valueOf(500);
	375	Insets zeroInsets = new InsetsUIResource(0, 0, 0, 0);
	376
	377	Double defaultCaretAspectRatio = new Double(0.025);
	378	Color caretColor = table.getColor("caretColor");
	379	Color controlText = table.getColor("controlText");
	380
	381	Object fieldInputMap = new UIDefaults.LazyInputMap(new Object[] {
	382	"ctrl C", DefaultEditorKit.copyAction,
	383	"ctrl V", DefaultEditorKit.pasteAction,
	384	"ctrl X", DefaultEditorKit.cutAction,
	385	"COPY", DefaultEditorKit.copyAction,
	386	"PASTE", DefaultEditorKit.pasteAction,
	387	"CUT", DefaultEditorKit.cutAction,
	388	"control INSERT", DefaultEditorKit.copyAction,
	389	"shift INSERT", DefaultEditorKit.pasteAction,
	390	"shift DELETE", DefaultEditorKit.cutAction,
	391	"shift LEFT", DefaultEditorKit.selectionBackwardAction,
	392	"shift KP_LEFT", DefaultEditorKit.selectionBackwardAction,
	393	"shift RIGHT", DefaultEditorKit.selectionForwardAction,
	394	"shift KP_RIGHT", DefaultEditorKit.selectionForwardAction,
	395	"ctrl LEFT", DefaultEditorKit.previousWordAction,
	396	"ctrl KP_LEFT", DefaultEditorKit.previousWordAction,
	397	"ctrl RIGHT", DefaultEditorKit.nextWordAction,
	398	"ctrl KP_RIGHT", DefaultEditorKit.nextWordAction,
	399	"ctrl shift LEFT", DefaultEditorKit.selectionPreviousWordAction,
	400	"ctrl shift KP_LEFT", DefaultEditorKit.selectionPreviousWordAction,
	401	"ctrl shift RIGHT", DefaultEditorKit.selectionNextWordAction,
	402	"ctrl shift KP_RIGHT", DefaultEditorKit.selectionNextWordAction,
	403	"ctrl A", DefaultEditorKit.selectAllAction,
	404	"HOME", DefaultEditorKit.beginLineAction,
	405	"END", DefaultEditorKit.endLineAction,
	406	"shift HOME", DefaultEditorKit.selectionBeginLineAction,
	407	"shift END", DefaultEditorKit.selectionEndLineAction,
	408	"BACK_SPACE", DefaultEditorKit.deletePrevCharAction,
	409	"shift BACK_SPACE", DefaultEditorKit.deletePrevCharAction,
	410	"ctrl H", DefaultEditorKit.deletePrevCharAction,
	411	"DELETE", DefaultEditorKit.deleteNextCharAction,
	412	"ctrl DELETE", DefaultEditorKit.deleteNextWordAction,
	413	"ctrl BACK_SPACE", DefaultEditorKit.deletePrevWordAction,
	414	"RIGHT", DefaultEditorKit.forwardAction,
	415	"LEFT", DefaultEditorKit.backwardAction,
	416	"KP_RIGHT", DefaultEditorKit.forwardAction,
	417	"KP_LEFT", DefaultEditorKit.backwardAction,
	418	"ENTER", JTextField.notifyAction,
	419	"ctrl BACK_SLASH", "unselect"/DefaultEditorKit.unselectAction/,
	420	"control shift O", "toggle-componentOrientation"/DefaultEditorKit.toggleComponentOrientation/
	421	});
	422
	423	Object passwordInputMap = new UIDefaults.LazyInputMap(new Object[] {
	424	"ctrl C", DefaultEditorKit.copyAction,
	425	"ctrl V", DefaultEditorKit.pasteAction,
	426	"ctrl X", DefaultEditorKit.cutAction,
	427	"COPY", DefaultEditorKit.copyAction,
	428	"PASTE", DefaultEditorKit.pasteAction,
	429	"CUT", DefaultEditorKit.cutAction,
	430	"control INSERT", DefaultEditorKit.copyAction,
	431	"shift INSERT", DefaultEditorKit.pasteAction,
	432	"shift DELETE", DefaultEditorKit.cutAction,
	433	"shift LEFT", DefaultEditorKit.selectionBackwardAction,
	434	"shift KP_LEFT", DefaultEditorKit.selectionBackwardAction,
	435	"shift RIGHT", DefaultEditorKit.selectionForwardAction,
	436	"shift KP_RIGHT", DefaultEditorKit.selectionForwardAction,
	437	"ctrl LEFT", DefaultEditorKit.beginLineAction,
	438	"ctrl KP_LEFT", DefaultEditorKit.beginLineAction,
	439	"ctrl RIGHT", DefaultEditorKit.endLineAction,
	440	"ctrl KP_RIGHT", DefaultEditorKit.endLineAction,
	441	"ctrl shift LEFT", DefaultEditorKit.selectionBeginLineAction,
	442	"ctrl shift KP_LEFT", DefaultEditorKit.selectionBeginLineAction,
	443	"ctrl shift RIGHT", DefaultEditorKit.selectionEndLineAction,
	444	"ctrl shift KP_RIGHT", DefaultEditorKit.selectionEndLineAction,
	445	"ctrl A", DefaultEditorKit.selectAllAction,
	446	"HOME", DefaultEditorKit.beginLineAction,
	447	"END", DefaultEditorKit.endLineAction,
	448	"shift HOME", DefaultEditorKit.selectionBeginLineAction,
	449	"shift END", DefaultEditorKit.selectionEndLineAction,
	450	"BACK_SPACE", DefaultEditorKit.deletePrevCharAction,
	451	"shift BACK_SPACE", DefaultEditorKit.deletePrevCharAction,
	452	"ctrl H", DefaultEditorKit.deletePrevCharAction,
	453	"DELETE", DefaultEditorKit.deleteNextCharAction,
	454	"RIGHT", DefaultEditorKit.forwardAction,
	455	"LEFT", DefaultEditorKit.backwardAction,
	456	"KP_RIGHT", DefaultEditorKit.forwardAction,
	457	"KP_LEFT", DefaultEditorKit.backwardAction,
	458	"ENTER", JTextField.notifyAction,
	459	"ctrl BACK_SLASH", "unselect"/DefaultEditorKit.unselectAction/,
	460	"control shift O", "toggle-componentOrientation"/DefaultEditorKit.toggleComponentOrientation/
	461	});
	462
	463	Object editorMargin = new InsetsUIResource(3,3,3,3);
	464
	465	Object multilineInputMap = new UIDefaults.LazyInputMap(new Object[] {
	466	"ctrl C", DefaultEditorKit.copyAction,
	467	"ctrl V", DefaultEditorKit.pasteAction,
	468	"ctrl X", DefaultEditorKit.cutAction,
	469	"COPY", DefaultEditorKit.copyAction,
	470	"PASTE", DefaultEditorKit.pasteAction,
	471	"CUT", DefaultEditorKit.cutAction,
	472	"control INSERT", DefaultEditorKit.copyAction,
	473	"shift INSERT", DefaultEditorKit.pasteAction,
	474	"shift DELETE", DefaultEditorKit.cutAction,
	475	"shift LEFT", DefaultEditorKit.selectionBackwardAction,
	476	"shift KP_LEFT", DefaultEditorKit.selectionBackwardAction,
	477	"shift RIGHT", DefaultEditorKit.selectionForwardAction,
	478	"shift KP_RIGHT", DefaultEditorKit.selectionForwardAction,
	479	"ctrl LEFT", DefaultEditorKit.previousWordAction,
	480	"ctrl KP_LEFT", DefaultEditorKit.previousWordAction,
	481	"ctrl RIGHT", DefaultEditorKit.nextWordAction,
	482	"ctrl KP_RIGHT", DefaultEditorKit.nextWordAction,
	483	"ctrl shift LEFT", DefaultEditorKit.selectionPreviousWordAction,
	484	"ctrl shift KP_LEFT", DefaultEditorKit.selectionPreviousWordAction,
	485	"ctrl shift RIGHT", DefaultEditorKit.selectionNextWordAction,
	486	"ctrl shift KP_RIGHT", DefaultEditorKit.selectionNextWordAction,
	487	"ctrl A", DefaultEditorKit.selectAllAction,
	488	"HOME", DefaultEditorKit.beginLineAction,
	489	"END", DefaultEditorKit.endLineAction,
	490	"shift HOME", DefaultEditorKit.selectionBeginLineAction,
	491	"shift END", DefaultEditorKit.selectionEndLineAction,
	492
	493	"UP", DefaultEditorKit.upAction,
	494	"KP_UP", DefaultEditorKit.upAction,
	495	"DOWN", DefaultEditorKit.downAction,
	496	"KP_DOWN", DefaultEditorKit.downAction,
	497	"PAGE_UP", DefaultEditorKit.pageUpAction,
	498	"PAGE_DOWN", DefaultEditorKit.pageDownAction,
	499	"shift PAGE_UP", "selection-page-up",
	500	"shift PAGE_DOWN", "selection-page-down",
	501	"ctrl shift PAGE_UP", "selection-page-left",
	502	"ctrl shift PAGE_DOWN", "selection-page-right",
	503	"shift UP", DefaultEditorKit.selectionUpAction,
	504	"shift KP_UP", DefaultEditorKit.selectionUpAction,
	505	"shift DOWN", DefaultEditorKit.selectionDownAction,
	506	"shift KP_DOWN", DefaultEditorKit.selectionDownAction,
	507	"ENTER", DefaultEditorKit.insertBreakAction,
	508	"BACK_SPACE", DefaultEditorKit.deletePrevCharAction,
	509	"shift BACK_SPACE", DefaultEditorKit.deletePrevCharAction,
	510	"ctrl H", DefaultEditorKit.deletePrevCharAction,
	511	"DELETE", DefaultEditorKit.deleteNextCharAction,
	512	"ctrl DELETE", DefaultEditorKit.deleteNextWordAction,
	513	"ctrl BACK_SPACE", DefaultEditorKit.deletePrevWordAction,
	514	"RIGHT", DefaultEditorKit.forwardAction,
	515	"LEFT", DefaultEditorKit.backwardAction,
	516	"KP_RIGHT", DefaultEditorKit.forwardAction,
	517	"KP_LEFT", DefaultEditorKit.backwardAction,
	518	"TAB", DefaultEditorKit.insertTabAction,
	519	"ctrl BACK_SLASH", "unselect"/DefaultEditorKit.unselectAction/,
	520	"ctrl HOME", DefaultEditorKit.beginAction,
	521	"ctrl END", DefaultEditorKit.endAction,
	522	"ctrl shift HOME", DefaultEditorKit.selectionBeginAction,
	523	"ctrl shift END", DefaultEditorKit.selectionEndAction,
	524	"ctrl T", "next-link-action",
	525	"ctrl shift T", "previous-link-action",
	526	"ctrl SPACE", "activate-link-action",
	527	"control shift O", "toggle-componentOrientation"/DefaultEditorKit.toggleComponentOrientation/
	528	});
	529
	530	class FontLazyValue implements UIDefaults.LazyValue {
	531	private Region region;
	532	FontLazyValue(Region region) {
	533	this.region = region;
	534	}
	535	public Object createValue(UIDefaults table) {
	536	GTKStyleFactory factory = (GTKStyleFactory)getStyleFactory();
	537	GTKStyle style = (GTKStyle)factory.getStyle(null, region);
	538	return style.getFontForState(null);
	539	}
	540	}
	541
	542	Object[] defaults = new Object[] {
	543	"ArrowButton.size", Integer.valueOf(13),
	544
	545
	546	"Button.defaultButtonFollowsFocus", Boolean.FALSE,
	547	"Button.focusInputMap", new UIDefaults.LazyInputMap(new Object[] {
	548	"SPACE", "pressed",
	549	"released SPACE", "released",
	550	"ENTER", "pressed",
	551	"released ENTER", "released"
	552	}),
	553	"Button.font", new FontLazyValue(Region.BUTTON),
	554	"Button.margin", zeroInsets,
	555
	556
	557	"CheckBox.focusInputMap", new UIDefaults.LazyInputMap(new Object[]{
	558	"SPACE", "pressed",
	559	"released SPACE", "released"
	560	}),
	561	"CheckBox.icon", new GTKStyle.GTKLazyValue(
	562	"com.sun.java.swing.plaf.gtk.GTKIconFactory",
	563	"getCheckBoxIcon"),
	564	"CheckBox.font", new FontLazyValue(Region.CHECK_BOX),
	565	"CheckBox.margin", zeroInsets,
	566
	567
	568	"CheckBoxMenuItem.arrowIcon", null,
	569	"CheckBoxMenuItem.checkIcon", new GTKStyle.GTKLazyValue(
	570	"com.sun.java.swing.plaf.gtk.GTKIconFactory",
	571	"getCheckBoxMenuItemCheckIcon"),
	572	"CheckBoxMenuItem.font",
	573	new FontLazyValue(Region.CHECK_BOX_MENU_ITEM),
	574	"CheckBoxMenuItem.margin", zeroInsets,
	575	"CheckBoxMenuItem.alignAcceleratorText", Boolean.FALSE,
	576
	577
	578	"ColorChooser.showPreviewPanelText", Boolean.FALSE,
	579	"ColorChooser.panels", new UIDefaults.ActiveValue() {
	580	public Object createValue(UIDefaults table) {
	581	return new AbstractColorChooserPanel[] {
	582	new GTKColorChooserPanel() };
	583	}
	584	},
	585	"ColorChooser.font", new FontLazyValue(Region.COLOR_CHOOSER),
	586
	587
	588	"ComboBox.ancestorInputMap",
	589	new UIDefaults.LazyInputMap(new Object[] {
	590	"ESCAPE", "hidePopup",
	591	"PAGE_UP", "pageUpPassThrough",
	592	"PAGE_DOWN", "pageDownPassThrough",
	593	"HOME", "homePassThrough",
	594	"END", "endPassThrough",
	595	"DOWN", "selectNext",
	596	"KP_DOWN", "selectNext",
	597	"alt DOWN", "togglePopup",
	598	"alt KP_DOWN", "togglePopup",
	599	"alt UP", "togglePopup",
	600	"alt KP_UP", "togglePopup",
	601	"SPACE", "spacePopup",
	602	"ENTER", "enterPressed",
	603	"UP", "selectPrevious",
	604	"KP_UP", "selectPrevious"
	605
	606	}),
	607	"ComboBox.font", new FontLazyValue(Region.COMBO_BOX),
	608	"ComboBox.isEnterSelectablePopup", Boolean.TRUE,
	609
	610
	611	"EditorPane.caretForeground", caretColor,
	612	"EditorPane.caretAspectRatio", defaultCaretAspectRatio,
	613	"EditorPane.caretBlinkRate", caretBlinkRate,
	614	"EditorPane.margin", editorMargin,
	615	"EditorPane.focusInputMap", multilineInputMap,
	616	"EditorPane.font", new FontLazyValue(Region.EDITOR_PANE),
	617
	618
	619	"FileChooser.ancestorInputMap",
	620	new UIDefaults.LazyInputMap(new Object[] {
	621	"ESCAPE", "cancelSelection",
	622	"ctrl ENTER", "approveSelection"
	623	}),
	624	"FileChooserUI", "com.sun.java.swing.plaf.gtk.GTKLookAndFeel",
	625
	626
	627	"FormattedTextField.caretForeground", caretColor,
	628	"FormattedTextField.caretAspectRatio", defaultCaretAspectRatio,
	629	"FormattedTextField.caretBlinkRate", caretBlinkRate,
	630	"FormattedTextField.focusInputMap",
	631	new UIDefaults.LazyInputMap(new Object[] {
	632	"ctrl C", DefaultEditorKit.copyAction,
	633	"ctrl V", DefaultEditorKit.pasteAction,
	634	"ctrl X", DefaultEditorKit.cutAction,
	635	"COPY", DefaultEditorKit.copyAction,
	636	"PASTE", DefaultEditorKit.pasteAction,
	637	"CUT", DefaultEditorKit.cutAction,
	638	"control INSERT", DefaultEditorKit.copyAction,
	639	"shift INSERT", DefaultEditorKit.pasteAction,
	640	"shift DELETE", DefaultEditorKit.cutAction,
	641	"shift LEFT", DefaultEditorKit.selectionBackwardAction,
	642	"shift KP_LEFT", DefaultEditorKit.selectionBackwardAction,
	643	"shift RIGHT", DefaultEditorKit.selectionForwardAction,
	644	"shift KP_RIGHT", DefaultEditorKit.selectionForwardAction,
	645	"ctrl LEFT", DefaultEditorKit.previousWordAction,
	646	"ctrl KP_LEFT", DefaultEditorKit.previousWordAction,
	647	"ctrl RIGHT", DefaultEditorKit.nextWordAction,
	648	"ctrl KP_RIGHT", DefaultEditorKit.nextWordAction,
	649	"ctrl shift LEFT", DefaultEditorKit.selectionPreviousWordAction,
	650	"ctrl shift KP_LEFT", DefaultEditorKit.selectionPreviousWordAction,
	651	"ctrl shift RIGHT", DefaultEditorKit.selectionNextWordAction,
	652	"ctrl shift KP_RIGHT", DefaultEditorKit.selectionNextWordAction,
	653	"ctrl A", DefaultEditorKit.selectAllAction,
	654	"HOME", DefaultEditorKit.beginLineAction,
	655	"END", DefaultEditorKit.endLineAction,
	656	"shift HOME", DefaultEditorKit.selectionBeginLineAction,
	657	"shift END", DefaultEditorKit.selectionEndLineAction,
	658	"BACK_SPACE", DefaultEditorKit.deletePrevCharAction,
	659	"shift BACK_SPACE", DefaultEditorKit.deletePrevCharAction,
	660	"ctrl H", DefaultEditorKit.deletePrevCharAction,
	661	"DELETE", DefaultEditorKit.deleteNextCharAction,
	662	"ctrl DELETE", DefaultEditorKit.deleteNextWordAction,
	663	"ctrl BACK_SPACE", DefaultEditorKit.deletePrevWordAction,
	664	"RIGHT", DefaultEditorKit.forwardAction,
	665	"LEFT", DefaultEditorKit.backwardAction,
	666	"KP_RIGHT", DefaultEditorKit.forwardAction,
	667	"KP_LEFT", DefaultEditorKit.backwardAction,
	668	"ENTER", JTextField.notifyAction,
	669	"ctrl BACK_SLASH", "unselect",
	670	"control shift O", "toggle-componentOrientation",
	671	"ESCAPE", "reset-field-edit",
	672	"UP", "increment",
	673	"KP_UP", "increment",
	674	"DOWN", "decrement",
	675	"KP_DOWN", "decrement",
	676	}),
	677	"FormattedTextField.font",
	678	new FontLazyValue(Region.FORMATTED_TEXT_FIELD),
	679
	680
	681	"InternalFrameTitlePane.titlePaneLayout",
	682	new GTKStyle.GTKLazyValue("com.sun.java.swing.plaf.gtk.Metacity",
	683	"getTitlePaneLayout"),
	684	"InternalFrame.windowBindings", new Object[] {
	685	"shift ESCAPE", "showSystemMenu",
	686	"ctrl SPACE", "showSystemMenu",
	687	"ESCAPE", "hideSystemMenu" },
	688	"InternalFrame.layoutTitlePaneAtOrigin", Boolean.TRUE,
	689	"InternalFrame.useTaskBar", Boolean.TRUE,
	690
	691	"InternalFrameTitlePane.iconifyButtonOpacity", null,
	692	"InternalFrameTitlePane.maximizeButtonOpacity", null,
	693	"InternalFrameTitlePane.closeButtonOpacity", null,
	694
	695	"Label.font", new FontLazyValue(Region.LABEL),
	696
	697	"List.background", tableBg,
	698	"List.focusCellHighlightBorder", focusBorder,
	699	"List.focusSelectedCellHighlightBorder", focusSelectedBorder,
	700	"List.noFocusBorder", noFocusBorder,
	701	"List.focusInputMap",
	702	new UIDefaults.LazyInputMap(new Object[] {
	703	"ctrl C", "copy",
	704	"ctrl V", "paste",
	705	"ctrl X", "cut",
	706	"COPY", "copy",
	707	"PASTE", "paste",
	708	"CUT", "cut",
	709	"control INSERT", "copy",
	710	"shift INSERT", "paste",
	711	"shift DELETE", "cut",
	712	"UP", "selectPreviousRow",
	713	"KP_UP", "selectPreviousRow",
	714	"shift UP", "selectPreviousRowExtendSelection",
	715	"shift KP_UP", "selectPreviousRowExtendSelection",
	716	"ctrl shift UP", "selectPreviousRowExtendSelection",
	717	"ctrl shift KP_UP", "selectPreviousRowExtendSelection",
	718	"ctrl UP", "selectPreviousRowChangeLead",
	719	"ctrl KP_UP", "selectPreviousRowChangeLead",
	720	"DOWN", "selectNextRow",
	721	"KP_DOWN", "selectNextRow",
	722	"shift DOWN", "selectNextRowExtendSelection",
	723	"shift KP_DOWN", "selectNextRowExtendSelection",
	724	"ctrl shift DOWN", "selectNextRowExtendSelection",
	725	"ctrl shift KP_DOWN", "selectNextRowExtendSelection",
	726	"ctrl DOWN", "selectNextRowChangeLead",
	727	"ctrl KP_DOWN", "selectNextRowChangeLead",
	728	"LEFT", "selectPreviousColumn",
	729	"KP_LEFT", "selectPreviousColumn",
	730	"shift LEFT", "selectPreviousColumnExtendSelection",
	731	"shift KP_LEFT", "selectPreviousColumnExtendSelection",
	732	"ctrl shift LEFT", "selectPreviousColumnExtendSelection",
	733	"ctrl shift KP_LEFT", "selectPreviousColumnExtendSelection",
	734	"ctrl LEFT", "selectPreviousColumnChangeLead",
	735	"ctrl KP_LEFT", "selectPreviousColumnChangeLead",
	736	"RIGHT", "selectNextColumn",
	737	"KP_RIGHT", "selectNextColumn",
	738	"shift RIGHT", "selectNextColumnExtendSelection",
	739	"shift KP_RIGHT", "selectNextColumnExtendSelection",
	740	"ctrl shift RIGHT", "selectNextColumnExtendSelection",
	741	"ctrl shift KP_RIGHT", "selectNextColumnExtendSelection",
	742	"ctrl RIGHT", "selectNextColumnChangeLead",
	743	"ctrl KP_RIGHT", "selectNextColumnChangeLead",
	744	"HOME", "selectFirstRow",
	745	"shift HOME", "selectFirstRowExtendSelection",
	746	"ctrl shift HOME", "selectFirstRowExtendSelection",
	747	"ctrl HOME", "selectFirstRowChangeLead",
	748	"END", "selectLastRow",
	749	"shift END", "selectLastRowExtendSelection",
	750	"ctrl shift END", "selectLastRowExtendSelection",
	751	"ctrl END", "selectLastRowChangeLead",
	752	"PAGE_UP", "scrollUp",
	753	"shift PAGE_UP", "scrollUpExtendSelection",
	754	"ctrl shift PAGE_UP", "scrollUpExtendSelection",
	755	"ctrl PAGE_UP", "scrollUpChangeLead",
	756	"PAGE_DOWN", "scrollDown",
	757	"shift PAGE_DOWN", "scrollDownExtendSelection",
	758	"ctrl shift PAGE_DOWN", "scrollDownExtendSelection",
	759	"ctrl PAGE_DOWN", "scrollDownChangeLead",
	760	"ctrl A", "selectAll",
	761	"ctrl SLASH", "selectAll",
	762	"ctrl BACK_SLASH", "clearSelection",
	763	"SPACE", "addToSelection",
	764	"ctrl SPACE", "toggleAndAnchor",
	765	"shift SPACE", "extendTo",
	766	"ctrl shift SPACE", "moveSelectionTo"
	767	}),
	768	"List.focusInputMap.RightToLeft",
	769	new UIDefaults.LazyInputMap(new Object[] {
	770	"LEFT", "selectNextColumn",
	771	"KP_LEFT", "selectNextColumn",
	772	"shift LEFT", "selectNextColumnExtendSelection",
	773	"shift KP_LEFT", "selectNextColumnExtendSelection",
	774	"ctrl shift LEFT", "selectNextColumnExtendSelection",
	775	"ctrl shift KP_LEFT", "selectNextColumnExtendSelection",
	776	"ctrl LEFT", "selectNextColumnChangeLead",
	777	"ctrl KP_LEFT", "selectNextColumnChangeLead",
	778	"RIGHT", "selectPreviousColumn",
	779	"KP_RIGHT", "selectPreviousColumn",
	780	"shift RIGHT", "selectPreviousColumnExtendSelection",
	781	"shift KP_RIGHT", "selectPreviousColumnExtendSelection",
	782	"ctrl shift RIGHT", "selectPreviousColumnExtendSelection",
	783	"ctrl shift KP_RIGHT", "selectPreviousColumnExtendSelection",
	784	"ctrl RIGHT", "selectPreviousColumnChangeLead",
	785	"ctrl KP_RIGHT", "selectPreviousColumnChangeLead",
	786	}),
	787	"List.font", new FontLazyValue(Region.LIST),
	788	"List.rendererUseUIBorder", Boolean.FALSE,
	789
	790	"Menu.shortcutKeys", new int[] {KeyEvent.ALT_MASK},
	791	"Menu.arrowIcon", new GTKStyle.GTKLazyValue(
	792	"com.sun.java.swing.plaf.gtk.GTKIconFactory",
	793	"getMenuArrowIcon"),
	794	"Menu.checkIcon", null,
	795	"Menu.font", new FontLazyValue(Region.MENU),
	796	"Menu.margin", zeroInsets,
	797	"Menu.cancelMode", "hideMenuTree",
	798	"Menu.alignAcceleratorText", Boolean.FALSE,
	799
	800
	801	"MenuBar.windowBindings", new Object[] {
	802	"F10", "takeFocus" },
	803	"MenuBar.font", new FontLazyValue(Region.MENU_BAR),
	804
	805
	806	"MenuItem.arrowIcon", null,
	807	"MenuItem.checkIcon", null,
	808	"MenuItem.font", new FontLazyValue(Region.MENU_ITEM),
	809	"MenuItem.margin", zeroInsets,
	810	"MenuItem.alignAcceleratorText", Boolean.FALSE,
	811
	812
	813	"OptionPane.setButtonMargin", Boolean.FALSE,
	814	"OptionPane.sameSizeButtons", Boolean.TRUE,
	815	"OptionPane.buttonOrientation", new Integer(SwingConstants.RIGHT),
	816	"OptionPane.minimumSize", new DimensionUIResource(262, 90),
	817	"OptionPane.buttonPadding", new Integer(10),
	818	"OptionPane.windowBindings", new Object[] {
	819	"ESCAPE", "close" },
	820	"OptionPane.buttonClickThreshhold", new Integer(500),
	821	"OptionPane.isYesLast", Boolean.TRUE,
	822	"OptionPane.font", new FontLazyValue(Region.OPTION_PANE),
	823
	824	"Panel.font", new FontLazyValue(Region.PANEL),
	825
	826	"PasswordField.caretForeground", caretColor,
	827	"PasswordField.caretAspectRatio", defaultCaretAspectRatio,
	828	"PasswordField.caretBlinkRate", caretBlinkRate,
	829	"PasswordField.margin", zeroInsets,
	830	"PasswordField.focusInputMap", passwordInputMap,
	831	"PasswordField.font", new FontLazyValue(Region.PASSWORD_FIELD),
	832
	833
	834	"PopupMenu.consumeEventOnClose", Boolean.TRUE,
	835	"PopupMenu.selectedWindowInputMapBindings", new Object[] {
	836	"ESCAPE", "cancel",
	837	"DOWN", "selectNext",
	838	"KP_DOWN", "selectNext",
	839	"UP", "selectPrevious",
	840	"KP_UP", "selectPrevious",
	841	"LEFT", "selectParent",
	842	"KP_LEFT", "selectParent",
	843	"RIGHT", "selectChild",
	844	"KP_RIGHT", "selectChild",
	845	"ENTER", "return",
	846	"SPACE", "return"
	847	},
	848	"PopupMenu.selectedWindowInputMapBindings.RightToLeft",
	849	new Object[] {
	850	"LEFT", "selectChild",
	851	"KP_LEFT", "selectChild",
	852	"RIGHT", "selectParent",
	853	"KP_RIGHT", "selectParent",
	854	},
	855	"PopupMenu.font", new FontLazyValue(Region.POPUP_MENU),
	856
	857	"ProgressBar.horizontalSize",
	858	new DimensionUIResource(hProgWidth, hProgHeight),
	859	"ProgressBar.verticalSize",
	860	new DimensionUIResource(vProgWidth, vProgHeight),
	861	"ProgressBar.font", new FontLazyValue(Region.PROGRESS_BAR),
	862
	863	"RadioButton.focusInputMap",
	864	new UIDefaults.LazyInputMap(new Object[] {
	865	"SPACE", "pressed",
	866	"released SPACE", "released",
	867	"RETURN", "pressed"
	868	}),
	869	"RadioButton.icon", new GTKStyle.GTKLazyValue(
	870	"com.sun.java.swing.plaf.gtk.GTKIconFactory",
	871	"getRadioButtonIcon"),
	872	"RadioButton.font", new FontLazyValue(Region.RADIO_BUTTON),
	873	"RadioButton.margin", zeroInsets,
	874
	875
	876	"RadioButtonMenuItem.arrowIcon", null,
	877	"RadioButtonMenuItem.checkIcon", new GTKStyle.GTKLazyValue(
	878	"com.sun.java.swing.plaf.gtk.GTKIconFactory",
	879	"getRadioButtonMenuItemCheckIcon"),
	880	"RadioButtonMenuItem.font", new FontLazyValue(Region.RADIO_BUTTON_MENU_ITEM),
	881	"RadioButtonMenuItem.margin", zeroInsets,
	882	"RadioButtonMenuItem.alignAcceleratorText", Boolean.FALSE,
	883
	884
	885	// These bindings are only enabled when there is a default
	886	// button set on the rootpane.
	887	"RootPane.defaultButtonWindowKeyBindings", new Object[] {
	888	"ENTER", "press",
	889	"released ENTER", "release",
	890	"ctrl ENTER", "press",
	891	"ctrl released ENTER", "release"
	892	},
	893
	894
	895	"ScrollBar.squareButtons", Boolean.FALSE,
	896	"ScrollBar.thumbHeight", Integer.valueOf(14),
	897	"ScrollBar.width", Integer.valueOf(16),
	898	"ScrollBar.minimumThumbSize", new Dimension(8, 8),
	899	"ScrollBar.maximumThumbSize", new Dimension(4096, 4096),
	900	"ScrollBar.allowsAbsolutePositioning", Boolean.TRUE,
	901	"ScrollBar.alwaysShowThumb", Boolean.TRUE,
	902	"ScrollBar.ancestorInputMap",
	903	new UIDefaults.LazyInputMap(new Object[] {
	904	"RIGHT", "positiveUnitIncrement",
	905	"KP_RIGHT", "positiveUnitIncrement",
	906	"DOWN", "positiveUnitIncrement",
	907	"KP_DOWN", "positiveUnitIncrement",
	908	"PAGE_DOWN", "positiveBlockIncrement",
	909	"LEFT", "negativeUnitIncrement",
	910	"KP_LEFT", "negativeUnitIncrement",
	911	"UP", "negativeUnitIncrement",
	912	"KP_UP", "negativeUnitIncrement",
	913	"PAGE_UP", "negativeBlockIncrement",
	914	"HOME", "minScroll",
	915	"END", "maxScroll"
	916	}),
	917	"ScrollBar.ancestorInputMap.RightToLeft",
	918	new UIDefaults.LazyInputMap(new Object[] {
	919	"RIGHT", "negativeUnitIncrement",
	920	"KP_RIGHT", "negativeUnitIncrement",
	921	"LEFT", "positiveUnitIncrement",
	922	"KP_LEFT", "positiveUnitIncrement",
	923	}),
	924
	925
	926	"Spinner.disableOnBoundaryValues", Boolean.TRUE,
	927
	928
	929	"ScrollPane.fillUpperCorner", Boolean.TRUE,
	930	"ScrollPane.fillLowerCorner", Boolean.TRUE,
	931	"ScrollPane.ancestorInputMap",
	932	new UIDefaults.LazyInputMap(new Object[] {
	933	"RIGHT", "unitScrollRight",
	934	"KP_RIGHT", "unitScrollRight",
	935	"DOWN", "unitScrollDown",
	936	"KP_DOWN", "unitScrollDown",
	937	"LEFT", "unitScrollLeft",
	938	"KP_LEFT", "unitScrollLeft",
	939	"UP", "unitScrollUp",
	940	"KP_UP", "unitScrollUp",
	941	"PAGE_UP", "scrollUp",
	942	"PAGE_DOWN", "scrollDown",
	943	"ctrl PAGE_UP", "scrollLeft",
	944	"ctrl PAGE_DOWN", "scrollRight",
	945	"ctrl HOME", "scrollHome",
	946	"ctrl END", "scrollEnd"
	947	}),
	948	"ScrollPane.ancestorInputMap.RightToLeft",
	949	new UIDefaults.LazyInputMap(new Object[] {
	950	"ctrl PAGE_UP", "scrollRight",
	951	"ctrl PAGE_DOWN", "scrollLeft",
	952	}),
	953	"ScrollPane.font", new FontLazyValue(Region.SCROLL_PANE),
	954
	955
	956	"Separator.insets", zeroInsets,
	957	"Separator.thickness", Integer.valueOf(2),
	958
	959
	960	"Slider.paintValue", Boolean.TRUE,
	961	"Slider.thumbWidth", Integer.valueOf(30),
	962	"Slider.thumbHeight", Integer.valueOf(14),
	963	"Slider.focusInputMap",
	964	new UIDefaults.LazyInputMap(new Object[] {
	965	"RIGHT", "positiveUnitIncrement",
	966	"KP_RIGHT", "positiveUnitIncrement",
	967	"DOWN", "negativeUnitIncrement",
	968	"KP_DOWN", "negativeUnitIncrement",
	969	"PAGE_DOWN", "negativeBlockIncrement",
	970	"LEFT", "negativeUnitIncrement",
	971	"KP_LEFT", "negativeUnitIncrement",
	972	"UP", "positiveUnitIncrement",
	973	"KP_UP", "positiveUnitIncrement",
	974	"PAGE_UP", "positiveBlockIncrement",
	975	"HOME", "minScroll",
	976	"END", "maxScroll"
	977	}),
	978	"Slider.focusInputMap.RightToLeft",
	979	new UIDefaults.LazyInputMap(new Object[] {
	980	"RIGHT", "negativeUnitIncrement",
	981	"KP_RIGHT", "negativeUnitIncrement",
	982	"LEFT", "positiveUnitIncrement",
	983	"KP_LEFT", "positiveUnitIncrement",
	984	}),
	985	"Slider.onlyLeftMouseButtonDrag", Boolean.FALSE,
	986
	987	"Spinner.ancestorInputMap",
	988	new UIDefaults.LazyInputMap(new Object[] {
	989	"UP", "increment",
	990	"KP_UP", "increment",
	991	"DOWN", "decrement",
	992	"KP_DOWN", "decrement",
	993	}),
	994	"Spinner.font", new FontLazyValue(Region.SPINNER),
	995	"Spinner.editorAlignment", JTextField.LEADING,
	996
	997	"SplitPane.ancestorInputMap",
	998	new UIDefaults.LazyInputMap(new Object[] {
	999	"UP", "negativeIncrement",
	1000	"DOWN", "positiveIncrement",
	1001	"LEFT", "negativeIncrement",
	1002	"RIGHT", "positiveIncrement",
	1003	"KP_UP", "negativeIncrement",
	1004	"KP_DOWN", "positiveIncrement",
	1005	"KP_LEFT", "negativeIncrement",
	1006	"KP_RIGHT", "positiveIncrement",
	1007	"HOME", "selectMin",
	1008	"END", "selectMax",
	1009	"F8", "startResize",
	1010	"F6", "toggleFocus",
	1011	"ctrl TAB", "focusOutForward",
	1012	"ctrl shift TAB", "focusOutBackward"
	1013	}),
	1014
	1015
	1016	"SplitPane.size", Integer.valueOf(7),
	1017	"SplitPane.oneTouchOffset", Integer.valueOf(2),
	1018	"SplitPane.oneTouchButtonSize", Integer.valueOf(5),
	1019	"SplitPane.supportsOneTouchButtons", Boolean.FALSE,
	1020
	1021
	1022	"TabbedPane.focusInputMap",
	1023	new UIDefaults.LazyInputMap(new Object[] {
	1024	"RIGHT", "navigateRight",
	1025	"KP_RIGHT", "navigateRight",
	1026	"LEFT", "navigateLeft",
	1027	"KP_LEFT", "navigateLeft",
	1028	"UP", "navigateUp",
	1029	"KP_UP", "navigateUp",
	1030	"DOWN", "navigateDown",
	1031	"KP_DOWN", "navigateDown",
	1032	"ctrl DOWN", "requestFocusForVisibleComponent",
	1033	"ctrl KP_DOWN", "requestFocusForVisibleComponent",
	1034	"SPACE", "selectTabWithFocus"
	1035	}),
	1036	"TabbedPane.ancestorInputMap",
	1037	new UIDefaults.LazyInputMap(new Object[] {
	1038	"ctrl TAB", "navigateNext",
	1039	"ctrl shift TAB", "navigatePrevious",
	1040	"ctrl PAGE_DOWN", "navigatePageDown",
	1041	"ctrl PAGE_UP", "navigatePageUp",
	1042	"ctrl UP", "requestFocus",
	1043	"ctrl KP_UP", "requestFocus",
	1044	}),
	1045
	1046	"TabbedPane.labelShift", 3,
	1047	"TabbedPane.selectedLabelShift", 3,
	1048	"TabbedPane.font", new FontLazyValue(Region.TABBED_PANE),
	1049	"TabbedPane.selectedTabPadInsets", new InsetsUIResource(2, 2, 0, 1),
	1050
	1051	"Table.scrollPaneBorder", zeroBorder,
	1052	"Table.background", tableBg,
	1053	"Table.focusCellBackground", tableFocusCellBg,
	1054	"Table.focusCellForeground", tableFocusCellFg,
	1055	"Table.focusCellHighlightBorder", focusBorder,
	1056	"Table.focusSelectedCellHighlightBorder", focusSelectedBorder,
	1057	"Table.ancestorInputMap",
	1058	new UIDefaults.LazyInputMap(new Object[] {
	1059	"ctrl C", "copy",
	1060	"ctrl V", "paste",
	1061	"ctrl X", "cut",
	1062	"COPY", "copy",
	1063	"PASTE", "paste",
	1064	"CUT", "cut",
	1065	"control INSERT", "copy",
	1066	"shift INSERT", "paste",
	1067	"shift DELETE", "cut",
	1068	"RIGHT", "selectNextColumn",
	1069	"KP_RIGHT", "selectNextColumn",
	1070	"shift RIGHT", "selectNextColumnExtendSelection",
	1071	"shift KP_RIGHT", "selectNextColumnExtendSelection",
	1072	"ctrl shift RIGHT", "selectNextColumnExtendSelection",
	1073	"ctrl shift KP_RIGHT", "selectNextColumnExtendSelection",
	1074	"ctrl RIGHT", "selectNextColumnChangeLead",
	1075	"ctrl KP_RIGHT", "selectNextColumnChangeLead",
	1076	"LEFT", "selectPreviousColumn",
	1077	"KP_LEFT", "selectPreviousColumn",
	1078	"shift LEFT", "selectPreviousColumnExtendSelection",
	1079	"shift KP_LEFT", "selectPreviousColumnExtendSelection",
	1080	"ctrl shift LEFT", "selectPreviousColumnExtendSelection",
	1081	"ctrl shift KP_LEFT", "selectPreviousColumnExtendSelection",
	1082	"ctrl LEFT", "selectPreviousColumnChangeLead",
	1083	"ctrl KP_LEFT", "selectPreviousColumnChangeLead",
	1084	"DOWN", "selectNextRow",
	1085	"KP_DOWN", "selectNextRow",
	1086	"shift DOWN", "selectNextRowExtendSelection",
	1087	"shift KP_DOWN", "selectNextRowExtendSelection",
	1088	"ctrl shift DOWN", "selectNextRowExtendSelection",
	1089	"ctrl shift KP_DOWN", "selectNextRowExtendSelection",
	1090	"ctrl DOWN", "selectNextRowChangeLead",
	1091	"ctrl KP_DOWN", "selectNextRowChangeLead",
	1092	"UP", "selectPreviousRow",
	1093	"KP_UP", "selectPreviousRow",
	1094	"shift UP", "selectPreviousRowExtendSelection",
	1095	"shift KP_UP", "selectPreviousRowExtendSelection",
	1096	"ctrl shift UP", "selectPreviousRowExtendSelection",
	1097	"ctrl shift KP_UP", "selectPreviousRowExtendSelection",
	1098	"ctrl UP", "selectPreviousRowChangeLead",
	1099	"ctrl KP_UP", "selectPreviousRowChangeLead",
	1100	"HOME", "selectFirstColumn",
	1101	"shift HOME", "selectFirstColumnExtendSelection",
	1102	"ctrl shift HOME", "selectFirstRowExtendSelection",
	1103	"ctrl HOME", "selectFirstRow",
	1104	"END", "selectLastColumn",
	1105	"shift END", "selectLastColumnExtendSelection",
	1106	"ctrl shift END", "selectLastRowExtendSelection",
	1107	"ctrl END", "selectLastRow",
	1108	"PAGE_UP", "scrollUpChangeSelection",
	1109	"shift PAGE_UP", "scrollUpExtendSelection",
	1110	"ctrl shift PAGE_UP", "scrollLeftExtendSelection",
	1111	"ctrl PAGE_UP", "scrollLeftChangeSelection",
	1112	"PAGE_DOWN", "scrollDownChangeSelection",
	1113	"shift PAGE_DOWN", "scrollDownExtendSelection",
	1114	"ctrl shift PAGE_DOWN", "scrollRightExtendSelection",
	1115	"ctrl PAGE_DOWN", "scrollRightChangeSelection",
	1116	"TAB", "selectNextColumnCell",
	1117	"shift TAB", "selectPreviousColumnCell",
	1118	"ENTER", "selectNextRowCell",
	1119	"shift ENTER", "selectPreviousRowCell",
	1120	"ctrl A", "selectAll",
	1121	"ctrl SLASH", "selectAll",
	1122	"ctrl BACK_SLASH", "clearSelection",
	1123	"ESCAPE", "cancel",
	1124	"F2", "startEditing",
	1125	"SPACE", "addToSelection",
	1126	"ctrl SPACE", "toggleAndAnchor",
	1127	"shift SPACE", "extendTo",
	1128	"ctrl shift SPACE", "moveSelectionTo",
	1129	"F8", "focusHeader"
	1130	}),
	1131	"Table.ancestorInputMap.RightToLeft",
	1132	new UIDefaults.LazyInputMap(new Object[] {
	1133	"RIGHT", "selectPreviousColumn",
	1134	"KP_RIGHT", "selectPreviousColumn",
	1135	"shift RIGHT", "selectPreviousColumnExtendSelection",
	1136	"shift KP_RIGHT", "selectPreviousColumnExtendSelection",
	1137	"ctrl shift RIGHT", "selectPreviousColumnExtendSelection",
	1138	"ctrl shift KP_RIGHT", "selectPreviousColumnExtendSelection",
	1139	"shift RIGHT", "selectPreviousColumnChangeLead",
	1140	"shift KP_RIGHT", "selectPreviousColumnChangeLead",
	1141	"LEFT", "selectNextColumn",
	1142	"KP_LEFT", "selectNextColumn",
	1143	"shift LEFT", "selectNextColumnExtendSelection",
	1144	"shift KP_LEFT", "selectNextColumnExtendSelection",
	1145	"ctrl shift LEFT", "selectNextColumnExtendSelection",
	1146	"ctrl shift KP_LEFT", "selectNextColumnExtendSelection",
	1147	"ctrl LEFT", "selectNextColumnChangeLead",
	1148	"ctrl KP_LEFT", "selectNextColumnChangeLead",
	1149	"ctrl PAGE_UP", "scrollRightChangeSelection",
	1150	"ctrl PAGE_DOWN", "scrollLeftChangeSelection",
	1151	"ctrl shift PAGE_UP", "scrollRightExtendSelection",
	1152	"ctrl shift PAGE_DOWN", "scrollLeftExtendSelection",
	1153	}),
	1154	"Table.font", new FontLazyValue(Region.TABLE),
	1155	"Table.ascendingSortIcon", new GTKStyle.GTKLazyValue(
	1156	"com.sun.java.swing.plaf.gtk.GTKIconFactory",
	1157	"getAscendingSortIcon"),
	1158	"Table.descendingSortIcon", new GTKStyle.GTKLazyValue(
	1159	"com.sun.java.swing.plaf.gtk.GTKIconFactory",
	1160	"getDescendingSortIcon"),
	1161
	1162	"TableHeader.font", new FontLazyValue(Region.TABLE_HEADER),
	1163	"TableHeader.alignSorterArrow", Boolean.TRUE,
	1164
	1165	"TextArea.caretForeground", caretColor,
	1166	"TextArea.caretAspectRatio", defaultCaretAspectRatio,
	1167	"TextArea.caretBlinkRate", caretBlinkRate,
	1168	"TextArea.margin", zeroInsets,
	1169	"TextArea.focusInputMap", multilineInputMap,
	1170	"TextArea.font", new FontLazyValue(Region.TEXT_AREA),
	1171
	1172
	1173	"TextField.caretForeground", caretColor,
	1174	"TextField.caretAspectRatio", defaultCaretAspectRatio,
	1175	"TextField.caretBlinkRate", caretBlinkRate,
	1176	"TextField.margin", zeroInsets,
	1177	"TextField.focusInputMap", fieldInputMap,
	1178	"TextField.font", new FontLazyValue(Region.TEXT_FIELD),
	1179
	1180
	1181	"TextPane.caretForeground", caretColor,
	1182	"TextPane.caretAspectRatio", defaultCaretAspectRatio,
	1183	"TextPane.caretBlinkRate", caretBlinkRate,
	1184	"TextPane.margin", editorMargin,
	1185	"TextPane.focusInputMap", multilineInputMap,
	1186	"TextPane.font", new FontLazyValue(Region.TEXT_PANE),
	1187
	1188
	1189	"TitledBorder.titleColor", controlText,
	1190	"TitledBorder.border", new UIDefaults.LazyValue() {
	1191	public Object createValue(UIDefaults table) {
	1192	return new GTKPainter.TitledBorder();
	1193	}
	1194	},
	1195
	1196	"ToggleButton.focusInputMap",
	1197	new UIDefaults.LazyInputMap(new Object[] {
	1198	"SPACE", "pressed",
	1199	"released SPACE", "released"
	1200	}),
	1201	"ToggleButton.font", new FontLazyValue(Region.TOGGLE_BUTTON),
	1202	"ToggleButton.margin", zeroInsets,
	1203
	1204
	1205	"ToolBar.separatorSize", new DimensionUIResource(10, 10),
	1206	"ToolBar.handleIcon", new UIDefaults.ActiveValue() {
	1207	public Object createValue(UIDefaults table) {
	1208	return GTKIconFactory.getToolBarHandleIcon();
	1209	}
	1210	},
	1211	"ToolBar.ancestorInputMap",
	1212	new UIDefaults.LazyInputMap(new Object[] {
	1213	"UP", "navigateUp",
	1214	"KP_UP", "navigateUp",
	1215	"DOWN", "navigateDown",
	1216	"KP_DOWN", "navigateDown",
	1217	"LEFT", "navigateLeft",
	1218	"KP_LEFT", "navigateLeft",
	1219	"RIGHT", "navigateRight",
	1220	"KP_RIGHT", "navigateRight"
	1221	}),
	1222	"ToolBar.font", new FontLazyValue(Region.TOOL_BAR),
	1223
	1224	"ToolTip.font", new FontLazyValue(Region.TOOL_TIP),
	1225
	1226	"Tree.padding", Integer.valueOf(4),
	1227	"Tree.background", tableBg,
	1228	"Tree.drawHorizontalLines", Boolean.FALSE,
	1229	"Tree.drawVerticalLines", Boolean.FALSE,
	1230	"Tree.rowHeight", Integer.valueOf(-1),
	1231	"Tree.scrollsOnExpand", Boolean.FALSE,
	1232	"Tree.expanderSize", Integer.valueOf(10),
	1233	"Tree.repaintWholeRow", Boolean.TRUE,
	1234	"Tree.closedIcon", null,
	1235	"Tree.leafIcon", null,
	1236	"Tree.openIcon", null,
	1237	"Tree.expandedIcon", new GTKStyle.GTKLazyValue(
	1238	"com.sun.java.swing.plaf.gtk.GTKIconFactory",
	1239	"getTreeExpandedIcon"),
	1240	"Tree.collapsedIcon", new GTKStyle.GTKLazyValue(
	1241	"com.sun.java.swing.plaf.gtk.GTKIconFactory",
	1242	"getTreeCollapsedIcon"),
	1243	"Tree.leftChildIndent", Integer.valueOf(2),
	1244	"Tree.rightChildIndent", Integer.valueOf(12),
	1245	"Tree.scrollsHorizontallyAndVertically", Boolean.FALSE,
	1246	"Tree.drawsFocusBorder", Boolean.TRUE,
	1247	"Tree.focusInputMap",
	1248	new UIDefaults.LazyInputMap(new Object[] {
	1249	"ctrl C", "copy",
	1250	"ctrl V", "paste",
	1251	"ctrl X", "cut",
	1252	"COPY", "copy",
	1253	"PASTE", "paste",
	1254	"CUT", "cut",
	1255	"control INSERT", "copy",
	1256	"shift INSERT", "paste",
	1257	"shift DELETE", "cut",
	1258	"UP", "selectPrevious",
	1259	"KP_UP", "selectPrevious",
	1260	"shift UP", "selectPreviousExtendSelection",
	1261	"shift KP_UP", "selectPreviousExtendSelection",
	1262	"ctrl shift UP", "selectPreviousExtendSelection",
	1263	"ctrl shift KP_UP", "selectPreviousExtendSelection",
	1264	"ctrl UP", "selectPreviousChangeLead",
	1265	"ctrl KP_UP", "selectPreviousChangeLead",
	1266	"DOWN", "selectNext",
	1267	"KP_DOWN", "selectNext",
	1268	"shift DOWN", "selectNextExtendSelection",
	1269	"shift KP_DOWN", "selectNextExtendSelection",
	1270	"ctrl shift DOWN", "selectNextExtendSelection",
	1271	"ctrl shift KP_DOWN", "selectNextExtendSelection",
	1272	"ctrl DOWN", "selectNextChangeLead",
	1273	"ctrl KP_DOWN", "selectNextChangeLead",
	1274	"RIGHT", "selectChild",
	1275	"KP_RIGHT", "selectChild",
	1276	"LEFT", "selectParent",
	1277	"KP_LEFT", "selectParent",
	1278	"typed +", "expand",
	1279	"typed -", "collapse",
	1280	"BACK_SPACE", "moveSelectionToParent",
	1281	"PAGE_UP", "scrollUpChangeSelection",
	1282	"shift PAGE_UP", "scrollUpExtendSelection",
	1283	"ctrl shift PAGE_UP", "scrollUpExtendSelection",
	1284	"ctrl PAGE_UP", "scrollUpChangeLead",
	1285	"PAGE_DOWN", "scrollDownChangeSelection",
	1286	"shift PAGE_DOWN", "scrollDownExtendSelection",
	1287	"ctrl shift PAGE_DOWN", "scrollDownExtendSelection",
	1288	"ctrl PAGE_DOWN", "scrollDownChangeLead",
	1289	"HOME", "selectFirst",
	1290	"shift HOME", "selectFirstExtendSelection",
	1291	"ctrl shift HOME", "selectFirstExtendSelection",
	1292	"ctrl HOME", "selectFirstChangeLead",
	1293	"END", "selectLast",
	1294	"shift END", "selectLastExtendSelection",
	1295	"ctrl shift END", "selectLastExtendSelection",
	1296	"ctrl END", "selectLastChangeLead",
	1297	"F2", "startEditing",
	1298	"ctrl A", "selectAll",
	1299	"ctrl SLASH", "selectAll",
	1300	"ctrl BACK_SLASH", "clearSelection",
	1301	"ctrl LEFT", "scrollLeft",
	1302	"ctrl KP_LEFT", "scrollLeft",
	1303	"ctrl RIGHT", "scrollRight",
	1304	"ctrl KP_RIGHT", "scrollRight",
	1305	"SPACE", "addToSelection",
	1306	"ctrl SPACE", "toggleAndAnchor",
	1307	"shift SPACE", "extendTo",
	1308	"ctrl shift SPACE", "moveSelectionTo"
	1309	}),
	1310	"Tree.focusInputMap.RightToLeft",
	1311	new UIDefaults.LazyInputMap(new Object[] {
	1312	"RIGHT", "selectParent",
	1313	"KP_RIGHT", "selectParent",
	1314	"LEFT", "selectChild",
	1315	"KP_LEFT", "selectChild",
	1316	}),
	1317	"Tree.ancestorInputMap",
	1318	new UIDefaults.LazyInputMap(new Object[] {
	1319	"ESCAPE", "cancel"
	1320	}),
	1321	"Tree.font", new FontLazyValue(Region.TREE),
	1322
	1323	"Viewport.font", new FontLazyValue(Region.VIEWPORT)
	1324	};
	1325	table.putDefaults(defaults);
	1326
	1327	if (fallbackFont != null) {
	1328	table.put("TitledBorder.font", fallbackFont);
	1329	}
	1330	table.put(SwingUtilities2.AA_TEXT_PROPERTY_KEY, aaTextInfo);
	1331	}
	1332
	1333	protected void initSystemColorDefaults(UIDefaults table) {
	1334	GTKStyleFactory factory = (GTKStyleFactory)getStyleFactory();
	1335	GTKStyle windowStyle =
	1336	(GTKStyle)factory.getStyle(null, Region.INTERNAL_FRAME);
	1337	table.put("window", windowStyle.getGTKColor(SynthConstants.ENABLED,
	1338	GTKColorType.BACKGROUND));
	1339	table.put("windowText", windowStyle.getGTKColor(SynthConstants.ENABLED,
	1340	GTKColorType.TEXT_FOREGROUND));
	1341
	1342	GTKStyle entryStyle = (GTKStyle)factory.getStyle(null, Region.TEXT_FIELD);
	1343	table.put("text", entryStyle.getGTKColor(SynthConstants.ENABLED,
	1344	GTKColorType.TEXT_BACKGROUND));
	1345	table.put("textText", entryStyle.getGTKColor(SynthConstants.ENABLED,
	1346	GTKColorType.TEXT_FOREGROUND));
	1347	table.put("textHighlight",
	1348	entryStyle.getGTKColor(SynthConstants.SELECTED,
	1349	GTKColorType.TEXT_BACKGROUND));
	1350	table.put("textHighlightText",
	1351	entryStyle.getGTKColor(SynthConstants.SELECTED,
	1352	GTKColorType.TEXT_FOREGROUND));
	1353	table.put("textInactiveText",
	1354	entryStyle.getGTKColor(SynthConstants.DISABLED,
	1355	GTKColorType.TEXT_FOREGROUND));
	1356	Object caretColor =
	1357	entryStyle.getClassSpecificValue("cursor-color");
	1358	if (caretColor == null) {
	1359	caretColor = GTKStyle.BLACK_COLOR;
	1360	}
	1361	table.put("caretColor", caretColor);
	1362
	1363	GTKStyle menuStyle = (GTKStyle)factory.getStyle(null, Region.MENU_ITEM);
	1364	table.put("menu", menuStyle.getGTKColor(SynthConstants.ENABLED,
	1365	GTKColorType.BACKGROUND));
	1366	table.put("menuText", menuStyle.getGTKColor(SynthConstants.ENABLED,
	1367	GTKColorType.TEXT_FOREGROUND));
	1368
	1369	GTKStyle scrollbarStyle = (GTKStyle)factory.getStyle(null, Region.SCROLL_BAR);
	1370	table.put("scrollbar", scrollbarStyle.getGTKColor(SynthConstants.ENABLED,
	1371	GTKColorType.BACKGROUND));
	1372
	1373	GTKStyle infoStyle = (GTKStyle)factory.getStyle(null, Region.OPTION_PANE);
	1374	table.put("info", infoStyle.getGTKColor(SynthConstants.ENABLED,
	1375	GTKColorType.BACKGROUND));
	1376	table.put("infoText", infoStyle.getGTKColor(SynthConstants.ENABLED,
	1377	GTKColorType.TEXT_FOREGROUND));
	1378
	1379	GTKStyle desktopStyle = (GTKStyle)factory.getStyle(null, Region.DESKTOP_PANE);
	1380	table.put("desktop", desktopStyle.getGTKColor(SynthConstants.ENABLED,
	1381	GTKColorType.BACKGROUND));
	1382
	1383	// colors specific only for GTK
	1384	// It is impossible to create a simple GtkWidget without specifying the
	1385	// type. So for GtkWidget we can use any appropriate concrete type of
	1386	// wigdet. LABEL in this case.
	1387	GTKStyle widgetStyle = (GTKStyle)factory.getStyle(null, Region.LABEL);
	1388	Color bg = widgetStyle.getGTKColor(SynthConstants.ENABLED,
	1389	GTKColorType.BACKGROUND);
	1390	table.put("control", bg);
	1391	table.put("controlHighlight", bg);
	1392	table.put("controlText", widgetStyle.getGTKColor(SynthConstants.ENABLED,
	1393	GTKColorType.TEXT_FOREGROUND));
	1394	table.put("controlLtHighlight", widgetStyle.getGTKColor(
	1395	SynthConstants.ENABLED, GTKColorType.LIGHT));
	1396	table.put("controlShadow", widgetStyle.getGTKColor(
	1397	SynthConstants.ENABLED, GTKColorType.DARK));
	1398	table.put("controlDkShadow", widgetStyle.getGTKColor(
	1399	SynthConstants.ENABLED, GTKColorType.BLACK));
	1400	table.put("light", widgetStyle.getGTKColor(
	1401	SynthConstants.ENABLED, GTKColorType.LIGHT));
	1402	table.put("mid", widgetStyle.getGTKColor(
	1403	SynthConstants.ENABLED, GTKColorType.MID));
	1404	table.put("dark", widgetStyle.getGTKColor(
	1405	SynthConstants.ENABLED, GTKColorType.DARK));
	1406	table.put("black", widgetStyle.getGTKColor(
	1407	SynthConstants.ENABLED, GTKColorType.BLACK));
	1408	table.put("white", widgetStyle.getGTKColor(
	1409	SynthConstants.ENABLED, GTKColorType.WHITE));
	1410	}
	1411
	1412	/**
	1413	* Creates the GTK look and feel class for the passed in Component.
	1414	*/
	1415	public static ComponentUI createUI(JComponent c) {
	1416	String key = c.getUIClassID().intern();
	1417
	1418	if (key == "FileChooserUI") {
	1419	return GTKFileChooserUI.createUI(c);
	1420	}
	1421	return SynthLookAndFeel.createUI(c);
	1422	}
	1423
	1424	/**
	1425	* Returns the cached gtkThemeName
	1426	*/
	1427	static String getGtkThemeName() {
	1428	return gtkThemeName;
	1429	}
	1430
	1431	static boolean isLeftToRight(Component c) {
	1432	return c.getComponentOrientation().isLeftToRight();
	1433	}
	1434
	1435	public void initialize() {
	1436	/*
	1437	* We need to call loadGTK() to ensure that the native GTK
	1438	* libraries are loaded. It is very unlikely that this call will
	1439	* fail (since we've already verified native GTK support in
	1440	* isSupportedLookAndFeel()), but we can throw an error in the
	1441	* failure situation just in case.
	1442	*/
	1443	Toolkit toolkit = Toolkit.getDefaultToolkit();
	1444	if (toolkit instanceof UNIXToolkit &&
	1445	!((UNIXToolkit)toolkit).loadGTK())
	1446	{
	1447	throw new InternalError("Unable to load native GTK libraries");
	1448	}
	1449
	1450	super.initialize();
	1451	inInitialize = true;
	1452	loadStyles();
	1453	inInitialize = false;
	1454
	1455	/*
	1456	* Check if system AA font settings should be used.
	1457	* Sun's JDS (for Linux and Solaris) ships with high quality CJK
	1458	* fonts and specifies via fontconfig that these be rendered in
	1459	* B&W to take advantage of the embedded bitmaps.
	1460	* If is a Sun CJK locale or remote display, indicate by the condition
	1461	* variable that in this case the L&F recommends ignoring desktop
	1462	* settings. On other Unixes (eg Linux) this doesn't apply.
	1463	* REMIND 1: The isSunCJK test is really just a place holder
	1464	* until we can properly query fontconfig and use the properties
	1465	* set for specific fonts.
	1466	* REMIND 2: See comment on isLocalDisplay() definition regarding
	1467	* XRender.
	1468	*/
	1469	gtkAAFontSettingsCond = !isSunCJK && SwingUtilities2.isLocalDisplay();
	1470	aaTextInfo = SwingUtilities2.AATextInfo.getAATextInfo(gtkAAFontSettingsCond);
	1471	}
	1472
	1473	static ReferenceQueue<GTKLookAndFeel> queue = new ReferenceQueue<GTKLookAndFeel>();
	1474
	1475	private static void flushUnreferenced() {
	1476	WeakPCL pcl;
	1477
	1478	while ((pcl = (WeakPCL)queue.poll()) != null) {
	1479	pcl.dispose();
	1480	}
	1481	}
	1482
	1483	static class WeakPCL extends WeakReference<GTKLookAndFeel> implements
	1484	PropertyChangeListener {
	1485	private Toolkit kit;
	1486	private String key;
	1487
	1488	WeakPCL(GTKLookAndFeel target, Toolkit kit, String key) {
	1489	super(target, queue);
	1490	this.kit = kit;
	1491	this.key = key;
	1492	}
	1493
	1494	public String getKey() { return key; }
	1495
	1496	public void propertyChange(final PropertyChangeEvent pce) {
	1497	final GTKLookAndFeel lnf = get();
	1498
	1499	if (lnf == null \|\| UIManager.getLookAndFeel() != lnf) {
	1500	// The property was GC'ed, we're no longer interested in
	1501	// PropertyChanges, remove the listener.
	1502	dispose();
	1503	}
	1504	else {
	1505	// We are using invokeLater here because we are getting called
	1506	// on the AWT-Motif thread which can cause a deadlock.
	1507	SwingUtilities.invokeLater(new Runnable() {
	1508	public void run() {
	1509	String name = pce.getPropertyName();
	1510	/* We are listening for GTK desktop text AA settings:
	1511	* "gnome.Xft/Antialias" and "gnome.Xft/RGBA".
	1512	* However we don't need to read these here as
	1513	* the UIDefaults reads them and this event causes
	1514	* those to be reinitialised.
	1515	*/
	1516	if ("gnome.Net/ThemeName".equals(name)) {
	1517	GTKEngine.INSTANCE.themeChanged();
	1518	GTKIconFactory.resetIcons();
	1519	}
	1520	lnf.loadStyles();
	1521	Window appWindows[] = Window.getWindows();
	1522	for (int i = 0; i < appWindows.length; i++) {
	1523	SynthLookAndFeel.updateStyles(appWindows[i]);
	1524	}
	1525	}
	1526	});
	1527	}
	1528	}
	1529
	1530	void dispose() {
	1531	kit.removePropertyChangeListener(key, this);
	1532	}
	1533	}
	1534
	1535	public boolean isSupportedLookAndFeel() {
	1536	Toolkit toolkit = Toolkit.getDefaultToolkit();
	1537	return (toolkit instanceof SunToolkit &&
	1538	((SunToolkit)toolkit).isNativeGTKAvailable());
	1539	}
	1540
	1541	public boolean isNativeLookAndFeel() {
	1542	return true;
	1543	}
	1544
	1545	public String getDescription() {
	1546	return "GTK look and feel";
	1547	}
	1548
	1549	public String getName() {
	1550	return "GTK look and feel";
	1551	}
	1552
	1553	public String getID() {
	1554	return "GTK";
	1555	}
	1556
	1557	// Subclassed to pass in false to the superclass, we don't want to try
	1558	// and load the system colors.
	1559	protected void loadSystemColors(UIDefaults table, String[] systemColors, boolean useNative) {
	1560	super.loadSystemColors(table, systemColors, false);
	1561	}
	1562
	1563	private void loadStyles() {
	1564	gtkThemeName = (String)Toolkit.getDefaultToolkit().
	1565	getDesktopProperty("gnome.Net/ThemeName");
	1566
	1567	setStyleFactory(getGTKStyleFactory());
	1568
	1569	// If we are in initialize initializations will be
	1570	// called later, don't do it now.
	1571	if (!inInitialize) {
	1572	UIDefaults table = UIManager.getLookAndFeelDefaults();
	1573	initSystemColorDefaults(table);
	1574	initComponentDefaults(table);
	1575	}
	1576	}
	1577
	1578	private GTKStyleFactory getGTKStyleFactory() {
	1579
	1580	GTKEngine engine = GTKEngine.INSTANCE;
	1581	Object iconSizes = engine.getSetting(GTKEngine.Settings.GTK_ICON_SIZES);
	1582	if (iconSizes instanceof String) {
	1583	if (!configIconSizes((String)iconSizes)) {
	1584	System.err.println("Error parsing gtk-icon-sizes string: '" + iconSizes + "'");
	1585	}
	1586	}
	1587
	1588	// Desktop property appears to have preference over rc font.
	1589	Object fontName = Toolkit.getDefaultToolkit().getDesktopProperty(
	1590	"gnome.Gtk/FontName");
	1591
	1592	if (!(fontName instanceof String)) {
	1593	fontName = engine.getSetting(GTKEngine.Settings.GTK_FONT_NAME);
	1594	if (!(fontName instanceof String)) {
	1595	fontName = "sans 10";
	1596	}
	1597	}
	1598
	1599	if (styleFactory == null) {
	1600	styleFactory = new GTKStyleFactory();
	1601	}
	1602
	1603	Font defaultFont = PangoFonts.lookupFont((String)fontName);
	1604	fallbackFont = defaultFont;
	1605	styleFactory.initStyles(defaultFont);
	1606
	1607	return styleFactory;
	1608	}
	1609
	1610	private boolean configIconSizes(String sizeString) {
	1611	String[] sizes = sizeString.split(":");
	1612	for (int i = 0; i < sizes.length; i++) {
	1613	String[] splits = sizes[i].split("=");
	1614
	1615	if (splits.length != 2) {
	1616	return false;
	1617	}
	1618
	1619	String size = splits[0].trim().intern();
	1620	if (size.length() < 1) {
	1621	return false;
	1622	}
	1623
	1624	splits = splits[1].split(",");
	1625
	1626	if (splits.length != 2) {
	1627	return false;
	1628	}
	1629
	1630	String width = splits[0].trim();
	1631	String height = splits[1].trim();
	1632
	1633	if (width.length() < 1 \|\| height.length() < 1) {
	1634	return false;
	1635	}
	1636
	1637	int w;
	1638	int h;
	1639
	1640	try {
	1641	w = Integer.parseInt(width);
	1642	h = Integer.parseInt(height);
	1643	} catch (NumberFormatException nfe) {
	1644	return false;
	1645	}
	1646
	1647	if (w > 0 && h > 0) {
	1648	int type = GTKStyle.GTKStockIconInfo.getIconType(size);
	1649	GTKStyle.GTKStockIconInfo.setIconSize(type, w, h);
	1650	} else {
	1651	System.err.println("Invalid size in gtk-icon-sizes: " + w + "," + h);
	1652	}
	1653	}
	1654
	1655	return true;
	1656	}
	1657
	1658	/**
	1659	* Returns whether or not the UIs should update their
	1660	* <code>SynthStyles</code> from the <code>SynthStyleFactory</code>
	1661	* when the ancestor of the Component changes.
	1662	*
	1663	* @return whether or not the UIs should update their
	1664	* <code>SynthStyles</code> from the <code>SynthStyleFactory</code>
	1665	* when the ancestor changed.
	1666	*/
	1667	public boolean shouldUpdateStyleOnAncestorChanged() {
	1668	return true;
	1669	}
	1670
	1671	/**
	1672	* {@inheritDoc}
	1673	*/
	1674	public LayoutStyle getLayoutStyle() {
	1675	return GnomeLayoutStyle.INSTANCE;
	1676	}
	1677
	1678
	1679	/**
	1680	* Gnome layout style. From:
	1681	* http://developer.gnome.org/projects/gup/hig/2.0/design-window.html#window-layout-spacing
	1682	* You'll notice this doesn't do the radiobutton/checkbox border
	1683	* adjustments that windows/metal do. This is because gtk doesn't
	1684	* provide margins/insets for checkbox/radiobuttons.
	1685	*/
	1686	private static class GnomeLayoutStyle extends DefaultLayoutStyle {
	1687	private static GnomeLayoutStyle INSTANCE = new GnomeLayoutStyle();
	1688
	1689	@Override
	1690	public int getPreferredGap(JComponent component1,
	1691	JComponent component2, ComponentPlacement type, int position,
	1692	Container parent) {
	1693	// Checks args
	1694	super.getPreferredGap(component1, component2, type, position,
	1695	parent);
	1696
	1697	switch(type) {
	1698	case INDENT:
	1699	if (position == SwingConstants.EAST \|\|
	1700	position == SwingConstants.WEST) {
	1701	// Indent group members 12 pixels to denote hierarchy and
	1702	// association.
	1703	return 12;
	1704	}
	1705	// Fall through to related
	1706	// As a basic rule of thumb, leave space between user
	1707	// interface components in increments of 6 pixels, going up as
	1708	// the relationship between related elements becomes more
	1709	// distant. For example, between icon labels and associated
	1710	// graphics within an icon, 6 pixels are adequate. Between
	1711	// labels and associated components, leave 12 horizontal
	1712	// pixels. For vertical spacing between groups of components,
	1713	// 18 pixels is adequate.
	1714	//
	1715	// The first part of this is handled automatically by Icon (which
	1716	// won't give you 6 pixels).
	1717	case RELATED:
	1718	if (isLabelAndNonlabel(component1, component2, position)) {
	1719	return 12;
	1720	}
	1721	return 6;
	1722	case UNRELATED:
	1723	return 12;
	1724	}
	1725	return 0;
	1726	}
	1727
	1728	@Override
	1729	public int getContainerGap(JComponent component, int position,
	1730	Container parent) {
	1731	// Checks args
	1732	super.getContainerGap(component, position, parent);
	1733	// A general padding of 12 pixels is
	1734	// recommended between the contents of a dialog window and the
	1735	// window borders.
	1736	return 12;
	1737	}
	1738	}
	1739	}

java/pkg/com/sun/java/swing/plaf/gtk/GTKPainter.java+1497−0

@@ -0,0 +1,1497 @@
	1	/*
	2	* Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25	package com.sun.java.swing.plaf.gtk;
	26
	27	import sun.awt.UNIXToolkit;
	28
	29	import javax.swing.plaf.synth.*;
	30	import java.awt.*;
	31	import javax.swing.*;
	32	import javax.swing.border.*;
	33	import javax.swing.plaf.*;
	34	import com.sun.java.swing.plaf.gtk.GTKConstants.ArrowType;
	35	import com.sun.java.swing.plaf.gtk.GTKConstants.ExpanderStyle;
	36	import com.sun.java.swing.plaf.gtk.GTKConstants.Orientation;
	37	import com.sun.java.swing.plaf.gtk.GTKConstants.PositionType;
	38	import com.sun.java.swing.plaf.gtk.GTKConstants.ShadowType;
	39	import java.lang.reflect.InvocationTargetException;
	40	import java.lang.reflect.Method;
	41
	42	/**
	43	* @author Joshua Outwater
	44	* @author Scott Violet
	45	*/
	46	// Need to support:
	47	// default_outside_border: Insets when default.
	48	// interior_focus: Indicates if focus should appear inside border, or
	49	// outside border.
	50	// focus-line-width: Integer giving size of focus border
	51	// focus-padding: Integer giving padding between border and focus
	52	// indicator.
	53	// focus-line-pattern:
	54	//
	55	class GTKPainter extends SynthPainter {
	56	private static final PositionType[] POSITIONS = {
	57	PositionType.BOTTOM, PositionType.RIGHT,
	58	PositionType.TOP, PositionType.LEFT
	59	};
	60
	61	private static final ShadowType SHADOWS[] = {
	62	ShadowType.NONE, ShadowType.IN, ShadowType.OUT,
	63	ShadowType.ETCHED_IN, ShadowType.OUT
	64	};
	65
	66	private final static GTKEngine ENGINE = GTKEngine.INSTANCE;
	67	final static GTKPainter INSTANCE = new GTKPainter();
	68
	69	private GTKPainter() {
	70	}
	71
	72	private String getName(SynthContext context) {
	73	return (context.getRegion().isSubregion()) ? null :
	74	context.getComponent().getName();
	75	}
	76
	77	public void paintCheckBoxBackground(SynthContext context,
	78	Graphics g, int x, int y, int w, int h) {
	79	paintRadioButtonBackground(context, g, x, y, w, h);
	80	}
	81
	82	public void paintCheckBoxMenuItemBackground(SynthContext context,
	83	Graphics g, int x, int y, int w, int h) {
	84	paintRadioButtonMenuItemBackground(context, g, x, y, w, h);
	85	}
	86
	87	// FORMATTED_TEXT_FIELD
	88	public void paintFormattedTextFieldBackground(SynthContext context,
	89	Graphics g, int x, int y,
	90	int w, int h) {
	91	paintTextBackground(context, g, x, y, w, h);
	92	}
	93
	94	//
	95	// TOOL_BAR_DRAG_WINDOW
	96	//
	97	public void paintToolBarDragWindowBackground(SynthContext context,
	98	Graphics g, int x, int y,
	99	int w, int h) {
	100	paintToolBarBackground(context, g, x, y, w, h);
	101	}
	102
	103
	104	//
	105	// TOOL_BAR
	106	//
	107	public void paintToolBarBackground(SynthContext context,
	108	Graphics g, int x, int y,
	109	int w, int h) {
	110	Region id = context.getRegion();
	111	int state = context.getComponentState();
	112	int gtkState = GTKLookAndFeel.synthStateToGTKState(id, state);
	113	int orientation = ((JToolBar)context.getComponent()).getOrientation();
	114	synchronized (UNIXToolkit.GTK_LOCK) {
	115	if (! ENGINE.paintCachedImage(g, x, y, w, h, id,
	116	state, orientation))
	117	{
	118	ENGINE.startPainting(g, x, y, w, h, id, state, orientation);
	119	ENGINE.paintBox(g, context, id, gtkState, ShadowType.OUT,
	120	"handlebox_bin", x, y, w, h);
	121	ENGINE.finishPainting();
	122	}
	123	}
	124	}
	125
	126	public void paintToolBarContentBackground(SynthContext context,
	127	Graphics g,
	128	int x, int y, int w, int h) {
	129	Region id = context.getRegion();
	130	int orientation = ((JToolBar)context.getComponent()).getOrientation();
	131	synchronized (UNIXToolkit.GTK_LOCK) {
	132	if (! ENGINE.paintCachedImage(g, x, y, w, h, id, orientation)) {
	133	ENGINE.startPainting(g, x, y, w, h, id, orientation);
	134	ENGINE.paintBox(g, context, id, SynthConstants.ENABLED,
	135	ShadowType.OUT, "toolbar", x, y, w, h);
	136	ENGINE.finishPainting();
	137	}
	138	}
	139	}
	140
	141	//
	142	// PASSWORD_FIELD
	143	//
	144	public void paintPasswordFieldBackground(SynthContext context,
	145	Graphics g, int x, int y,
	146	int w, int h) {
	147	paintTextBackground(context, g, x, y, w, h);
	148	}
	149
	150	//
	151	// TEXT_FIELD
	152	//
	153	public void paintTextFieldBackground(SynthContext context, Graphics g,
	154	int x, int y, int w, int h) {
	155	if (getName(context) == "Tree.cellEditor") {
	156	paintTreeCellEditorBackground(context, g, x, y, w, h);
	157	} else {
	158	paintTextBackground(context, g, x, y, w, h);
	159	}
	160	}
	161
	162	//
	163	// RADIO_BUTTON
	164	//
	165	// NOTE: this is called for JCheckBox too
	166	public void paintRadioButtonBackground(SynthContext context,
	167	Graphics g, int x, int y,
	168	int w, int h) {
	169	Region id = context.getRegion();
	170	int gtkState = GTKLookAndFeel.synthStateToGTKState(
	171	id, context.getComponentState());
	172	if (gtkState == SynthConstants.MOUSE_OVER) {
	173	synchronized (UNIXToolkit.GTK_LOCK) {
	174	if (! ENGINE.paintCachedImage(g, x, y, w, h, id)) {
	175	ENGINE.startPainting(g, x, y, w, h, id);
	176	ENGINE.paintFlatBox(g, context, id,
	177	SynthConstants.MOUSE_OVER, ShadowType.ETCHED_OUT,
	178	"checkbutton", x, y, w, h, ColorType.BACKGROUND);
	179	ENGINE.finishPainting();
	180	}
	181	}
	182	}
	183	}
	184
	185	//
	186	// RADIO_BUTTON_MENU_ITEM
	187	//
	188	// NOTE: this is called for JCheckBoxMenuItem too
	189	public void paintRadioButtonMenuItemBackground(SynthContext context,
	190	Graphics g, int x, int y,
	191	int w, int h) {
	192	Region id = context.getRegion();
	193	int gtkState = GTKLookAndFeel.synthStateToGTKState(
	194	id, context.getComponentState());
	195	if (gtkState == SynthConstants.MOUSE_OVER) {
	196	synchronized (UNIXToolkit.GTK_LOCK) {
	197	if (! ENGINE.paintCachedImage(g, x, y, w, h, id)) {
	198	ShadowType shadow = (GTKLookAndFeel.is2_2() ?
	199	ShadowType.NONE : ShadowType.OUT);
	200	ENGINE.startPainting(g, x, y, w, h, id);
	201	ENGINE.paintBox(g, context, id, gtkState,
	202	shadow, "menuitem", x, y, w, h);
	203	ENGINE.finishPainting();
	204	}
	205	}
	206	}
	207	}
	208
	209	//
	210	// LABEL
	211	//
	212	public void paintLabelBackground(SynthContext context,
	213	Graphics g, int x, int y,
	214	int w, int h) {
	215	String name = getName(context);
	216	JComponent c = context.getComponent();
	217	Container container = c.getParent();
	218
	219	if (name == "TableHeader.renderer" \|\|
	220	name == "GTKFileChooser.directoryListLabel" \|\|
	221	name == "GTKFileChooser.fileListLabel") {
	222
	223	paintButtonBackgroundImpl(context, g, Region.BUTTON, "button",
	224	x, y, w, h, true, false, false, false);
	225	}
	226	/*
	227	* If the label is a ListCellRenderer and it's in a container
	228	* (CellRendererPane) which is in a JComboBox then we paint the label
	229	* as a TextField like a gtk_entry for a combobox.
	230	*/
	231	else if (c instanceof ListCellRenderer &&
	232	container != null &&
	233	container.getParent() instanceof JComboBox ) {
	234	paintTextBackground(context, g, x, y, w, h);
	235	}
	236	}
	237
	238	//
	239	// INTERNAL_FRAME
	240	//
	241	public void paintInternalFrameBorder(SynthContext context,
	242	Graphics g, int x, int y,
	243	int w, int h) {
	244	Metacity.INSTANCE.paintFrameBorder(context, g, x, y, w, h);
	245	}
	246
	247	//
	248	// DESKTOP_PANE
	249	//
	250	public void paintDesktopPaneBackground(SynthContext context,
	251	Graphics g, int x, int y,
	252	int w, int h) {
	253	// Does not call into ENGINE for better performance
	254	fillArea(context, g, x, y, w, h, ColorType.BACKGROUND);
	255	}
	256
	257	//
	258	// DESKTOP_ICON
	259	//
	260	public void paintDesktopIconBorder(SynthContext context,
	261	Graphics g, int x, int y,
	262	int w, int h) {
	263	Metacity.INSTANCE.paintFrameBorder(context, g, x, y, w, h);
	264	}
	265
	266	public void paintButtonBackground(SynthContext context, Graphics g,
	267	int x, int y, int w, int h) {
	268	String name = getName(context);
	269	if (name != null && name.startsWith("InternalFrameTitlePane.")) {
	270	Metacity.INSTANCE.paintButtonBackground(context, g, x, y, w, h);
	271
	272	} else {
	273	AbstractButton button = (AbstractButton)context.getComponent();
	274	boolean paintBG = button.isContentAreaFilled() &&
	275	button.isBorderPainted();
	276	boolean paintFocus = button.isFocusPainted();
	277	boolean defaultCapable = (button instanceof JButton) &&
	278	((JButton)button).isDefaultCapable();
	279	boolean toolButton = (button.getParent() instanceof JToolBar);
	280	paintButtonBackgroundImpl(context, g, Region.BUTTON, "button",
	281	x, y, w, h, paintBG, paintFocus, defaultCapable, toolButton);
	282	}
	283	}
	284
	285	private void paintButtonBackgroundImpl(SynthContext context, Graphics g,
	286	Region id, String detail, int x, int y, int w, int h,
	287	boolean paintBackground, boolean paintFocus,
	288	boolean defaultCapable, boolean toolButton) {
	289	int state = context.getComponentState();
	290	synchronized (UNIXToolkit.GTK_LOCK) {
	291	if (ENGINE.paintCachedImage(g, x, y, w, h, id, state, detail,
	292	paintBackground, paintFocus, defaultCapable, toolButton)) {
	293	return;
	294	}
	295	ENGINE.startPainting(g, x, y, w, h, id, state, detail,
	296	paintBackground, paintFocus, defaultCapable, toolButton);
	297
	298	// Paint the default indicator
	299	GTKStyle style = (GTKStyle)context.getStyle();
	300	if (defaultCapable && !toolButton) {
	301	Insets defaultInsets = style.getClassSpecificInsetsValue(
	302	context, "default-border",
	303	GTKStyle.BUTTON_DEFAULT_BORDER_INSETS);
	304
	305	if (paintBackground && (state & SynthConstants.DEFAULT) != 0) {
	306	ENGINE.paintBox(g, context, id, SynthConstants.ENABLED,
	307	ShadowType.IN, "buttondefault", x, y, w, h);
	308	}
	309	x += defaultInsets.left;
	310	y += defaultInsets.top;
	311	w -= (defaultInsets.left + defaultInsets.right);
	312	h -= (defaultInsets.top + defaultInsets.bottom);
	313	}
	314
	315	boolean interiorFocus = style.getClassSpecificBoolValue(
	316	context, "interior-focus", true);
	317	int focusSize = style.getClassSpecificIntValue(
	318	context, "focus-line-width",1);
	319	int focusPad = style.getClassSpecificIntValue(
	320	context, "focus-padding", 1);
	321
	322	int totalFocusSize = focusSize + focusPad;
	323	int xThickness = style.getXThickness();
	324	int yThickness = style.getYThickness();
	325
	326	// Render the box.
	327	if (!interiorFocus &&
	328	(state & SynthConstants.FOCUSED) == SynthConstants.FOCUSED) {
	329	x += totalFocusSize;
	330	y += totalFocusSize;
	331	w -= 2 * totalFocusSize;
	332	h -= 2 * totalFocusSize;
	333	}
	334
	335	int gtkState = GTKLookAndFeel.synthStateToGTKState(id, state);
	336	boolean paintBg;
	337	if (toolButton) {
	338	// Toolbar buttons should only have their background painted
	339	// in the PRESSED, SELECTED, or MOUSE_OVER states.
	340	paintBg =
	341	(gtkState != SynthConstants.ENABLED) &&
	342	(gtkState != SynthConstants.DISABLED);
	343	} else {
	344	// Otherwise, always paint the button's background, unless
	345	// the user has overridden it and we're in the ENABLED state.
	346	paintBg =
	347	paintBackground \|\|
	348	(gtkState != SynthConstants.ENABLED);
	349	}
	350	if (paintBg) {
	351	ShadowType shadowType = ShadowType.OUT;
	352	if ((state & (SynthConstants.PRESSED \|
	353	SynthConstants.SELECTED)) != 0) {
	354	shadowType = ShadowType.IN;
	355	}
	356	ENGINE.paintBox(g, context, id, gtkState,
	357	shadowType, detail, x, y, w, h);
	358	}
	359
	360	// focus
	361	if (paintFocus && (state & SynthConstants.FOCUSED) != 0) {
	362	if (interiorFocus) {
	363	x += xThickness + focusPad;
	364	y += yThickness + focusPad;
	365	w -= 2 * (xThickness + focusPad);
	366	h -= 2 * (yThickness + focusPad);
	367	} else {
	368	x -= totalFocusSize;
	369	y -= totalFocusSize;
	370	w += 2 * totalFocusSize;
	371	h += 2 * totalFocusSize;
	372	}
	373	ENGINE.paintFocus(g, context, id, gtkState, detail, x, y, w, h);
	374	}
	375	ENGINE.finishPainting();
	376	}
	377	}
	378
	379	//
	380	// ARROW_BUTTON
	381	//
	382	public void paintArrowButtonForeground(SynthContext context, Graphics g,
	383	int x, int y, int w, int h,
	384	int direction) {
	385	Region id = context.getRegion();
	386	Component c = context.getComponent();
	387	String name = c.getName();
	388
	389	ArrowType arrowType = null;
	390	switch (direction) {
	391	case SwingConstants.NORTH:
	392	arrowType = ArrowType.UP; break;
	393	case SwingConstants.SOUTH:
	394	arrowType = ArrowType.DOWN; break;
	395	case SwingConstants.EAST:
	396	arrowType = ArrowType.RIGHT; break;
	397	case SwingConstants.WEST:
	398	arrowType = ArrowType.LEFT; break;
	399	}
	400
	401	String detail = "arrow";
	402	if ((name == "ScrollBar.button") \|\| (name == "TabbedPane.button")) {
	403	if (arrowType == ArrowType.UP \|\| arrowType == ArrowType.DOWN) {
	404	detail = "vscrollbar";
	405	} else {
	406	detail = "hscrollbar";
	407	}
	408	} else if (name == "Spinner.nextButton" \|\|
	409	name == "Spinner.previousButton") {
	410	detail = "spinbutton";
	411	} else if (name != "ComboBox.arrowButton") {
	412	assert false : "unexpected name: " + name;
	413	}
	414
	415	int gtkState = GTKLookAndFeel.synthStateToGTKState(
	416	id, context.getComponentState());
	417	ShadowType shadowType = (gtkState == SynthConstants.PRESSED ?
	418	ShadowType.IN : ShadowType.OUT);
	419	synchronized (UNIXToolkit.GTK_LOCK) {
	420	if (ENGINE.paintCachedImage(g, x, y, w, h,
	421	gtkState, name, direction)) {
	422	return;
	423	}
	424	ENGINE.startPainting(g, x, y, w, h, gtkState, name, direction);
	425	ENGINE.paintArrow(g, context, id, gtkState,
	426	shadowType, arrowType, detail, x, y, w, h);
	427	ENGINE.finishPainting();
	428	}
	429	}
	430
	431	public void paintArrowButtonBackground(SynthContext context,
	432	Graphics g, int x, int y, int w, int h) {
	433	Region id = context.getRegion();
	434	AbstractButton button = (AbstractButton)context.getComponent();
	435
	436	String name = button.getName();
	437	String detail = "button";
	438	int direction = SwingConstants.CENTER;
	439	if ((name == "ScrollBar.button") \|\| (name == "TabbedPane.button")) {
	440	Integer prop = (Integer)
	441	button.getClientProperty("__arrow_direction__");
	442	direction = (prop != null) ?
	443	prop.intValue() : SwingConstants.WEST;
	444	switch (direction) {
	445	default:
	446	case SwingConstants.EAST:
	447	case SwingConstants.WEST:
	448	detail = "hscrollbar";
	449	break;
	450	case SwingConstants.NORTH:
	451	case SwingConstants.SOUTH:
	452	detail = "vscrollbar";
	453	break;
	454	}
	455	} else if (name == "Spinner.previousButton") {
	456	detail = "spinbutton_down";
	457	} else if (name == "Spinner.nextButton") {
	458	detail = "spinbutton_up";
	459	} else if (name != "ComboBox.arrowButton") {
	460	assert false : "unexpected name: " + name;
	461	}
	462
	463	int state = context.getComponentState();
	464	synchronized (UNIXToolkit.GTK_LOCK) {
	465	if (ENGINE.paintCachedImage(g, x, y, w, h, id,
	466	state, detail, direction))
	467	{
	468	return;
	469	}
	470	ENGINE.startPainting(g, x, y, w, h, id,
	471	state, detail, direction);
	472
	473	if (detail.startsWith("spin")) {
	474	/*
	475	* The ubuntulooks engine (and presumably others) expect us to
	476	* first draw the full "spinbutton" background, and then draw
	477	* the individual "spinbutton_up/down" buttons on top of that.
	478	* Note that it is the state of the JSpinner (not its arrow
	479	* button) that determines how we draw this background.
	480	*/
	481	int spinState = button.getParent().isEnabled() ?
	482	SynthConstants.ENABLED : SynthConstants.DISABLED;
	483	int mody = (detail == "spinbutton_up") ? y : y-h;
	484	int modh = h*2;
	485	ENGINE.paintBox(g, context, id, spinState,
	486	ShadowType.IN, "spinbutton",
	487	x, mody, w, modh);
	488	}
	489
	490	int gtkState = GTKLookAndFeel.synthStateToGTKState(id, state);
	491	ShadowType shadowType = ShadowType.OUT;
	492	if ((gtkState & (SynthConstants.PRESSED \|
	493	SynthConstants.SELECTED)) != 0)
	494	{
	495	shadowType = ShadowType.IN;
	496	}
	497	ENGINE.paintBox(g, context, id, gtkState,
	498	shadowType, detail,
	499	x, y, w, h);
	500
	501	ENGINE.finishPainting();
	502	}
	503	}
	504
	505
	506	//
	507	// LIST
	508	//
	509	public void paintListBackground(SynthContext context, Graphics g,
	510	int x, int y, int w, int h) {
	511	// Does not call into ENGINE for better performance
	512	fillArea(context, g, x, y, w, h, GTKColorType.TEXT_BACKGROUND);
	513	}
	514
	515	public void paintMenuBarBackground(SynthContext context, Graphics g,
	516	int x, int y, int w, int h) {
	517	Region id = context.getRegion();
	518	synchronized (UNIXToolkit.GTK_LOCK) {
	519	if (ENGINE.paintCachedImage(g, x, y, w, h, id)) {
	520	return;
	521	}
	522	GTKStyle style = (GTKStyle)context.getStyle();
	523	int shadow = style.getClassSpecificIntValue(
	524	context, "shadow-type", 2);
	525	ShadowType shadowType = SHADOWS[shadow];
	526	int gtkState = GTKLookAndFeel.synthStateToGTKState(
	527	id, context.getComponentState());
	528	ENGINE.startPainting(g, x, y, w, h, id);
	529	ENGINE.paintBox(g, context, id, gtkState,
	530	shadowType, "menubar", x, y, w, h);
	531	ENGINE.finishPainting();
	532	}
	533	}
	534
	535	//
	536	// MENU
	537	//
	538	public void paintMenuBackground(SynthContext context,
	539	Graphics g,
	540	int x, int y, int w, int h) {
	541	paintMenuItemBackground(context, g, x, y, w, h);
	542	}
	543
	544	// This is called for both MENU and MENU_ITEM
	545	public void paintMenuItemBackground(SynthContext context,
	546	Graphics g,
	547	int x, int y, int w, int h) {
	548	int gtkState = GTKLookAndFeel.synthStateToGTKState(
	549	context.getRegion(), context.getComponentState());
	550	if (gtkState == SynthConstants.MOUSE_OVER) {
	551	Region id = Region.MENU_ITEM;
	552	synchronized (UNIXToolkit.GTK_LOCK) {
	553	if (! ENGINE.paintCachedImage(g, x, y, w, h, id)) {
	554	ShadowType shadow = (GTKLookAndFeel.is2_2() ?
	555	ShadowType.NONE : ShadowType.OUT);
	556	ENGINE.startPainting(g, x, y, w, h, id);
	557	ENGINE.paintBox(g, context, id, gtkState, shadow,
	558	"menuitem", x, y, w, h);
	559	ENGINE.finishPainting();
	560	}
	561	}
	562	}
	563	}
	564
	565	public void paintPopupMenuBackground(SynthContext context, Graphics g,
	566	int x, int y, int w, int h) {
	567	Region id = context.getRegion();
	568	int gtkState = GTKLookAndFeel.synthStateToGTKState(
	569	id, context.getComponentState());
	570	synchronized (UNIXToolkit.GTK_LOCK) {
	571	if (ENGINE.paintCachedImage(g, x, y, w, h, id, gtkState)) {
	572	return;
	573	}
	574	ENGINE.startPainting(g, x, y, w, h, id, gtkState);
	575	ENGINE.paintBox(g, context, id, gtkState,
	576	ShadowType.OUT, "menu", x, y, w, h);
	577
	578	GTKStyle style = (GTKStyle)context.getStyle();
	579	int xThickness = style.getXThickness();
	580	int yThickness = style.getYThickness();
	581	ENGINE.paintBackground(g, context, id, gtkState,
	582	style.getGTKColor(context, gtkState, GTKColorType.BACKGROUND),
	583	x + xThickness, y + yThickness,
	584	w - xThickness - xThickness, h - yThickness - yThickness);
	585	ENGINE.finishPainting();
	586	}
	587	}
	588
	589	public void paintProgressBarBackground(SynthContext context,
	590	Graphics g,
	591	int x, int y, int w, int h) {
	592	Region id = context.getRegion();
	593	synchronized (UNIXToolkit.GTK_LOCK) {
	594	if (! ENGINE.paintCachedImage(g, x, y, w, h, id)) {
	595	ENGINE.startPainting(g, x, y, w, h, id);
	596	ENGINE.paintBox(g, context, id, SynthConstants.ENABLED,
	597	ShadowType.IN, "trough", x, y, w, h);
	598	ENGINE.finishPainting();
	599	}
	600	}
	601	}
	602
	603	public void paintProgressBarForeground(SynthContext context, Graphics g,
	604	int x, int y, int w, int h,
	605	int orientation) {
	606	Region id = context.getRegion();
	607	synchronized (UNIXToolkit.GTK_LOCK) {
	608	// Note that we don't call paintCachedImage() here. Since the
	609	// progress bar foreground is painted differently for each value
	610	// it would be wasteful to try to cache an image for each state,
	611	// so instead we simply avoid caching in this case.
	612	if (w <= 0 \|\| h <= 0) {
	613	return;
	614	}
	615	ENGINE.startPainting(g, x, y, w, h, id, "fg");
	616	ENGINE.paintBox(g, context, id, SynthConstants.MOUSE_OVER,
	617	ShadowType.OUT, "bar", x, y, w, h);
	618	ENGINE.finishPainting(false); // don't bother caching the image
	619	}
	620	}
	621
	622	public void paintViewportBorder(SynthContext context, Graphics g,
	623	int x, int y, int w, int h) {
	624	Region id = context.getRegion();
	625	synchronized (UNIXToolkit.GTK_LOCK) {
	626	if (! ENGINE.paintCachedImage(g, x, y, w, h, id)) {
	627	ENGINE.startPainting(g, x, y, w, h, id);
	628	ENGINE.paintShadow(g, context, id, SynthConstants.ENABLED,
	629	ShadowType.IN, "scrolled_window", x, y, w, h);
	630	ENGINE.finishPainting();
	631	}
	632	}
	633	}
	634
	635	public void paintSeparatorBackground(SynthContext context,
	636	Graphics g,
	637	int x, int y, int w, int h,
	638	int orientation) {
	639	Region id = context.getRegion();
	640	int state = context.getComponentState();
	641	JComponent c = context.getComponent();
	642
	643	/*
	644	* Note: In theory, the style's x/y thickness values would determine
	645	* the width of the separator content. In practice, however, some
	646	* engines will render a line that is wider than the corresponding
	647	* thickness value. For example, ubuntulooks reports x/y thickness
	648	* values of 1 for separators, but always renders a 2-pixel wide line.
	649	* As a result of all this, we need to be careful not to restrict
	650	* the w/h values below too much, so that the full thickness of the
	651	* rendered line will be captured by our image caching code.
	652	*/
	653	String detail;
	654	if (c instanceof JToolBar.Separator) {
	655	/*
	656	* GTK renders toolbar separators differently in that an
	657	* artificial padding is added to each end of the separator.
	658	* The value of 0.2f below is derived from the source code of
	659	* gtktoolbar.c in the current version of GTK+ (2.8.20 at the
	660	* time of this writing). Specifically, the relevant values are:
	661	* SPACE_LINE_DIVISION 10.0
	662	* SPACE_LINE_START 2.0
	663	* SPACE_LINE_END 8.0
	664	* These are used to determine the distance from the top (or left)
	665	* edge of the toolbar to the other edge. So for example, the
	666	* starting/top point of a vertical separator is 2/10 of the
	667	* height of a horizontal toolbar away from the top edge, which
	668	* is how we arrive at 0.2f below. Likewise, the ending/bottom
	669	* point is 8/10 of the height away from the top edge, or in other
	670	* words, it is 2/10 away from the bottom edge, which is again
	671	* how we arrive at the 0.2f value below.
	672	*
	673	* The separator is also centered horizontally or vertically,
	674	* depending on its orientation. This was determined empirically
	675	* and by examining the code referenced above.
	676	*/
	677	detail = "toolbar";
	678	float pct = 0.2f;
	679	JToolBar.Separator sep = (JToolBar.Separator)c;
	680	Dimension size = sep.getSeparatorSize();
	681	GTKStyle style = (GTKStyle)context.getStyle();
	682	if (orientation == JSeparator.HORIZONTAL) {
	683	x += (int)(w * pct);
	684	w -= (int)(w * pct * 2);
	685	y += (size.height - style.getYThickness()) / 2;
	686	} else {
	687	y += (int)(h * pct);
	688	h -= (int)(h * pct * 2);
	689	x += (size.width - style.getXThickness()) / 2;
	690	}
	691	} else {
	692	// For regular/menu separators, we simply subtract out the insets.
	693	detail = "separator";
	694	Insets insets = c.getInsets();
	695	x += insets.left;
	696	y += insets.top;
	697	if (orientation == JSeparator.HORIZONTAL) {
	698	w -= (insets.left + insets.right);
	699	} else {
	700	h -= (insets.top + insets.bottom);
	701	}
	702	}
	703
	704	synchronized (UNIXToolkit.GTK_LOCK) {
	705	if (! ENGINE.paintCachedImage(g, x, y, w, h, id,
	706	state, detail, orientation)) {
	707	ENGINE.startPainting(g, x, y, w, h, id,
	708	state, detail, orientation);
	709	if (orientation == JSeparator.HORIZONTAL) {
	710	ENGINE.paintHline(g, context, id, state,
	711	detail, x, y, w, h);
	712	} else {
	713	ENGINE.paintVline(g, context, id, state,
	714	detail, x, y, w, h);
	715	}
	716	ENGINE.finishPainting();
	717	}
	718	}
	719	}
	720
	721	public void paintSliderTrackBackground(SynthContext context,
	722	Graphics g,
	723	int x, int y, int w,int h) {
	724	Region id = context.getRegion();
	725	int state = context.getComponentState();
	726
	727	// For focused sliders, we paint focus rect outside the bounds passed.
	728	// Need to adjust for that.
	729	boolean focused = ((state & SynthConstants.FOCUSED) != 0);
	730	int focusSize = 0;
	731	if (focused) {
	732	GTKStyle style = (GTKStyle)context.getStyle();
	733	focusSize = style.getClassSpecificIntValue(
	734	context, "focus-line-width", 1) +
	735	style.getClassSpecificIntValue(
	736	context, "focus-padding", 1);
	737	x -= focusSize;
	738	y -= focusSize;
	739	w += focusSize * 2;
	740	h += focusSize * 2;
	741	}
	742
	743	// The ubuntulooks engine paints slider troughs differently depending
	744	// on the current slider value and its component orientation.
	745	JSlider slider = (JSlider)context.getComponent();
	746	double value = slider.getValue();
	747	double min = slider.getMinimum();
	748	double max = slider.getMaximum();
	749	double visible = 20; // not used for sliders; any value will work
	750
	751	synchronized (UNIXToolkit.GTK_LOCK) {
	752	// Note that we don't call paintCachedImage() here. Since some
	753	// engines (e.g. ubuntulooks) paint the slider background
	754	// differently for any given slider value, it would be wasteful
	755	// to try to cache an image for each state, so instead we simply
	756	// avoid caching in this case.
	757	if (w <= 0 \|\| h <= 0) {
	758	return;
	759	}
	760	ENGINE.startPainting(g, x, y, w, h, id, state, value);
	761	int gtkState = GTKLookAndFeel.synthStateToGTKState(id, state);
	762	ENGINE.setRangeValue(context, id, value, min, max, visible);
	763	ENGINE.paintBox(g, context, id, gtkState, ShadowType.IN,
	764	"trough", x + focusSize, y + focusSize,
	765	w - 2 * focusSize, h - 2 * focusSize);
	766	if (focused) {
	767	ENGINE.paintFocus(g, context, id, SynthConstants.ENABLED,
	768	"trough", x, y, w, h);
	769	}
	770	ENGINE.finishPainting(false); // don't bother caching the image
	771	}
	772	}
	773
	774	public void paintSliderThumbBackground(SynthContext context,
	775	Graphics g, int x, int y, int w, int h, int dir) {
	776	Region id = context.getRegion();
	777	int gtkState = GTKLookAndFeel.synthStateToGTKState(
	778	id, context.getComponentState());
	779	synchronized (UNIXToolkit.GTK_LOCK) {
	780	if (! ENGINE.paintCachedImage(g, x, y, w, h, id, gtkState, dir)) {
	781	Orientation orientation = (dir == JSlider.HORIZONTAL ?
	782	Orientation.HORIZONTAL : Orientation.VERTICAL);
	783	String detail = (dir == JSlider.HORIZONTAL ?
	784	"hscale" : "vscale");
	785	ENGINE.startPainting(g, x, y, w, h, id, gtkState, dir);
	786	ENGINE.paintSlider(g, context, id, gtkState,
	787	ShadowType.OUT, detail, x, y, w, h, orientation);
	788	ENGINE.finishPainting();
	789	}
	790	}
	791	}
	792
	793	//
	794	// SPINNER
	795	//
	796	public void paintSpinnerBackground(SynthContext context,
	797	Graphics g,
	798	int x, int y, int w, int h) {
	799	// This is handled in paintTextFieldBackground
	800	}
	801
	802	//
	803	// SPLIT_PANE_DIVIDER
	804	//
	805	public void paintSplitPaneDividerBackground(SynthContext context,
	806	Graphics g,
	807	int x, int y, int w, int h) {
	808	Region id = context.getRegion();
	809	int gtkState = GTKLookAndFeel.synthStateToGTKState(
	810	id, context.getComponentState());
	811	JSplitPane splitPane = (JSplitPane)context.getComponent();
	812	Orientation orientation =
	813	(splitPane.getOrientation() == JSplitPane.HORIZONTAL_SPLIT ?
	814	Orientation.VERTICAL : Orientation.HORIZONTAL);
	815	synchronized (UNIXToolkit.GTK_LOCK) {
	816	if (! ENGINE.paintCachedImage(g, x, y, w, h,
	817	id, gtkState, orientation)) {
	818	ENGINE.startPainting(g, x, y, w, h, id, gtkState, orientation);
	819	ENGINE.paintHandle(g, context, id, gtkState,
	820	ShadowType.OUT, "paned", x, y, w, h, orientation);
	821	ENGINE.finishPainting();
	822	}
	823	}
	824	}
	825
	826	public void paintSplitPaneDragDivider(SynthContext context,
	827	Graphics g,int x, int y, int w, int h,
	828	int orientation) {
	829	paintSplitPaneDividerForeground(context, g, x, y, w, h, orientation);
	830	}
	831
	832	public void paintTabbedPaneContentBackground(SynthContext context,
	833	Graphics g, int x, int y, int w, int h) {
	834	JTabbedPane pane = (JTabbedPane)context.getComponent();
	835	int selectedIndex = pane.getSelectedIndex();
	836	PositionType placement = GTKLookAndFeel.SwingOrientationConstantToGTK(
	837	pane.getTabPlacement());
	838
	839	int gapStart = 0;
	840	int gapSize = 0;
	841	if (selectedIndex != -1) {
	842	Rectangle tabBounds = pane.getBoundsAt(selectedIndex);
	843
	844	if (placement == PositionType.TOP \|\|
	845	placement == PositionType.BOTTOM) {
	846
	847	gapStart = tabBounds.x - x;
	848	gapSize = tabBounds.width;
	849	}
	850	else {
	851	gapStart = tabBounds.y - y;
	852	gapSize = tabBounds.height;
	853	}
	854	}
	855
	856	Region id = context.getRegion();
	857	int gtkState = GTKLookAndFeel.synthStateToGTKState(
	858	id, context.getComponentState());
	859	synchronized (UNIXToolkit.GTK_LOCK) {
	860	if (! ENGINE.paintCachedImage(g, x, y, w, h,
	861	id, gtkState, placement, gapStart, gapSize)) {
	862	ENGINE.startPainting(g, x, y, w, h,
	863	id, gtkState, placement, gapStart, gapSize);
	864	ENGINE.paintBoxGap(g, context, id, gtkState, ShadowType.OUT,
	865	"notebook", x, y, w, h, placement, gapStart, gapSize);
	866	ENGINE.finishPainting();
	867	}
	868	}
	869	}
	870
	871	public void paintTabbedPaneTabBackground(SynthContext context,
	872	Graphics g,
	873	int x, int y, int w, int h,
	874	int tabIndex) {
	875	Region id = context.getRegion();
	876	int state = context.getComponentState();
	877	int gtkState = ((state & SynthConstants.SELECTED) != 0 ?
	878	SynthConstants.ENABLED : SynthConstants.PRESSED);
	879	JTabbedPane pane = (JTabbedPane)context.getComponent();
	880	int placement = pane.getTabPlacement();
	881
	882	synchronized (UNIXToolkit.GTK_LOCK) {
	883	if (! ENGINE.paintCachedImage(g, x, y, w, h,
	884	id, gtkState, placement, tabIndex)) {
	885	PositionType side = POSITIONS[placement - 1];
	886	ENGINE.startPainting(g, x, y, w, h,
	887	id, gtkState, placement, tabIndex);
	888	ENGINE.paintExtension(g, context, id, gtkState,
	889	ShadowType.OUT, "tab", x, y, w, h, side, tabIndex);
	890	ENGINE.finishPainting();
	891	}
	892	}
	893	}
	894
	895	//
	896	// TEXT_PANE
	897	//
	898	public void paintTextPaneBackground(SynthContext context, Graphics g,
	899	int x, int y, int w, int h) {
	900	paintTextAreaBackground(context, g, x, y, w, h);
	901	}
	902
	903	//
	904	// EDITOR_PANE
	905	//
	906	public void paintEditorPaneBackground(SynthContext context, Graphics g,
	907	int x, int y, int w, int h) {
	908	paintTextAreaBackground(context, g, x, y, w, h);
	909	}
	910
	911	//
	912	// TEXT_AREA
	913	//
	914	public void paintTextAreaBackground(SynthContext context, Graphics g,
	915	int x, int y, int w, int h) {
	916	// Does not call into ENGINE for better performance
	917	fillArea(context, g, x, y, w, h, GTKColorType.TEXT_BACKGROUND);
	918	}
	919
	920	//
	921	// TEXT_FIELD
	922	//
	923	// NOTE: Combobox and Label, Password and FormattedTextField calls this
	924	// too.
	925	private void paintTextBackground(SynthContext context, Graphics g,
	926	int x, int y, int w, int h) {
	927	// Text is odd in that it uses the TEXT_BACKGROUND vs BACKGROUND.
	928	JComponent c = context.getComponent();
	929	GTKStyle style = (GTKStyle)context.getStyle();
	930	Region id = context.getRegion();
	931	int state = context.getComponentState();
	932	synchronized (UNIXToolkit.GTK_LOCK) {
	933	if (ENGINE.paintCachedImage(g, x, y, w, h, id, state)) {
	934	return;
	935	}
	936
	937	int gtkState = GTKLookAndFeel.synthStateToGTKState(id, state);
	938	int focusSize = 0;
	939	boolean interiorFocus = style.getClassSpecificBoolValue(
	940	context, "interior-focus", true);
	941	if (!interiorFocus && (state & SynthConstants.FOCUSED) != 0) {
	942	focusSize = style.getClassSpecificIntValue(context,
	943	"focus-line-width",1);
	944	x += focusSize;
	945	y += focusSize;
	946	w -= 2 * focusSize;
	947	h -= 2 * focusSize;
	948	}
	949
	950	int xThickness = style.getXThickness();
	951	int yThickness = style.getYThickness();
	952
	953	ENGINE.startPainting(g, x, y, w, h, id, state);
	954	ENGINE.paintShadow(g, context, id, gtkState,
	955	ShadowType.IN, "entry", x, y, w, h);
	956	ENGINE.paintFlatBox(g, context, id,
	957	gtkState, ShadowType.NONE, "entry_bg",
	958	x + xThickness,
	959	y + yThickness,
	960	w - (2 * xThickness),
	961	h - (2 * yThickness),
	962	ColorType.TEXT_BACKGROUND);
	963
	964	if (focusSize > 0) {
	965	x -= focusSize;
	966	y -= focusSize;
	967	w += 2 * focusSize;
	968	h += 2 * focusSize;
	969	ENGINE.paintFocus(g, context, id, gtkState,
	970	"entry", x, y, w, h);
	971	}
	972	ENGINE.finishPainting();
	973	}
	974	}
	975
	976	private void paintTreeCellEditorBackground(SynthContext context, Graphics g,
	977	int x, int y, int w, int h) {
	978	Region id = context.getRegion();
	979	int gtkState = GTKLookAndFeel.synthStateToGTKState(
	980	id, context.getComponentState());
	981	synchronized (UNIXToolkit.GTK_LOCK) {
	982	if (! ENGINE.paintCachedImage(g, x, y, w, h, id, gtkState)) {
	983	ENGINE.startPainting(g, x, y, w, h, id, gtkState);
	984	ENGINE.paintFlatBox(g, context, id, gtkState, ShadowType.NONE,
	985	"entry_bg", x, y, w, h, ColorType.TEXT_BACKGROUND);
	986	ENGINE.finishPainting();
	987	}
	988	}
	989	}
	990
	991
	992	//
	993	// ROOT_PANE
	994	//
	995	public void paintRootPaneBackground(SynthContext context, Graphics g,
	996	int x, int y, int w, int h) {
	997	// Does not call into ENGINE for better performance
	998	fillArea(context, g, x, y, w, h, GTKColorType.BACKGROUND);
	999	}
	1000
	1001	//
	1002	// TOGGLE_BUTTON
	1003	//
	1004	public void paintToggleButtonBackground(SynthContext context,
	1005	Graphics g,
	1006	int x, int y, int w, int h) {
	1007	Region id = context.getRegion();
	1008	JToggleButton toggleButton = (JToggleButton)context.getComponent();
	1009	boolean paintBG = toggleButton.isContentAreaFilled() &&
	1010	toggleButton.isBorderPainted();
	1011	boolean paintFocus = toggleButton.isFocusPainted();
	1012	boolean toolButton = (toggleButton.getParent() instanceof JToolBar);
	1013	paintButtonBackgroundImpl(context, g, id, "button",
	1014	x, y, w, h,
	1015	paintBG, paintFocus, false, toolButton);
	1016	}
	1017
	1018
	1019	//
	1020	// SCROLL_BAR
	1021	//
	1022	public void paintScrollBarBackground(SynthContext context,
	1023	Graphics g,
	1024	int x, int y, int w,int h) {
	1025	Region id = context.getRegion();
	1026	boolean focused =
	1027	(context.getComponentState() & SynthConstants.FOCUSED) != 0;
	1028	synchronized (UNIXToolkit.GTK_LOCK) {
	1029	if (ENGINE.paintCachedImage(g, x, y, w, h, id, focused)) {
	1030	return;
	1031	}
	1032	ENGINE.startPainting(g, x, y, w, h, id, focused);
	1033
	1034	// Note: the scrollbar insets already include the "trough-border",
	1035	// which is needed to position the scrollbar buttons properly.
	1036	// But when we render, we need to take the trough border out
	1037	// of the equation so that we paint the entire area covered by
	1038	// the trough border and the scrollbar content itself.
	1039	Insets insets = context.getComponent().getInsets();
	1040	GTKStyle style = (GTKStyle)context.getStyle();
	1041	int troughBorder =
	1042	style.getClassSpecificIntValue(context, "trough-border", 1);
	1043	insets.left -= troughBorder;
	1044	insets.right -= troughBorder;
	1045	insets.top -= troughBorder;
	1046	insets.bottom -= troughBorder;
	1047
	1048	ENGINE.paintBox(g, context, id, SynthConstants.PRESSED,
	1049	ShadowType.IN, "trough",
	1050	x + insets.left,
	1051	y + insets.top,
	1052	w - insets.left - insets.right,
	1053	h - insets.top - insets.bottom);
	1054
	1055	if (focused) {
	1056	ENGINE.paintFocus(g, context, id,
	1057	SynthConstants.ENABLED, "trough", x, y, w, h);
	1058	}
	1059	ENGINE.finishPainting();
	1060	}
	1061	}
	1062
	1063
	1064	//
	1065	// SCROLL_BAR_THUMB
	1066	//
	1067	public void paintScrollBarThumbBackground(SynthContext context,
	1068	Graphics g, int x, int y, int w, int h, int dir) {
	1069	Region id = context.getRegion();
	1070	int gtkState = GTKLookAndFeel.synthStateToGTKState(
	1071	id, context.getComponentState());
	1072
	1073	// The clearlooks engine paints scrollbar thumbs differently
	1074	// depending on the current scroll value (specifically, it will avoid
	1075	// rendering a certain line when the thumb is at the starting or
	1076	// ending position). Therefore, we normalize the current value to
	1077	// the range [0,100] here and then pass it down to setRangeValue()
	1078	// so that the native widget is configured appropriately. Note that
	1079	// there are really only four values that matter (min, middle, max,
	1080	// or fill) so we restrict to one of those four values to avoid
	1081	// blowing out the image cache.
	1082	JScrollBar sb = (JScrollBar)context.getComponent();
	1083	boolean rtl =
	1084	sb.getOrientation() == JScrollBar.HORIZONTAL &&
	1085	!sb.getComponentOrientation().isLeftToRight();
	1086	double min = 0;
	1087	double max = 100;
	1088	double visible = 20;
	1089	double value;
	1090	if (sb.getMaximum() - sb.getMinimum() == sb.getVisibleAmount()) {
	1091	// In this case, the thumb fills the entire track, so it is
	1092	// touching both ends at the same time
	1093	value = 0;
	1094	visible = 100;
	1095	} else if (sb.getValue() == sb.getMinimum()) {
	1096	// At minimum
	1097	value = rtl ? 100 : 0;
	1098	} else if (sb.getValue() >= sb.getMaximum() - sb.getVisibleAmount()) {
	1099	// At maximum
	1100	value = rtl ? 0 : 100;
	1101	} else {
	1102	// Somewhere in between
	1103	value = 50;
	1104	}
	1105
	1106	synchronized (UNIXToolkit.GTK_LOCK) {
	1107	if (! ENGINE.paintCachedImage(g, x, y, w, h, id, gtkState,
	1108	dir, value, visible, rtl))
	1109	{
	1110	ENGINE.startPainting(g, x, y, w, h, id, gtkState,
	1111	dir, value, visible, rtl);
	1112	Orientation orientation = (dir == JScrollBar.HORIZONTAL ?
	1113	Orientation.HORIZONTAL : Orientation.VERTICAL);
	1114	ENGINE.setRangeValue(context, id, value, min, max, visible);
	1115	ENGINE.paintSlider(g, context, id, gtkState,
	1116	ShadowType.OUT, "slider", x, y, w, h, orientation);
	1117	ENGINE.finishPainting();
	1118	}
	1119	}
	1120	}
	1121
	1122	//
	1123	// TOOL_TIP
	1124	//
	1125	public void paintToolTipBackground(SynthContext context, Graphics g,
	1126	int x, int y, int w,int h) {
	1127	Region id = context.getRegion();
	1128	synchronized (UNIXToolkit.GTK_LOCK) {
	1129	if (! ENGINE.paintCachedImage(g, x, y, w, h, id)) {
	1130	ENGINE.startPainting(g, x, y, w, h, id);
	1131	ENGINE.paintFlatBox(g, context, id, SynthConstants.ENABLED,
	1132	ShadowType.OUT, "tooltip", x, y, w, h,
	1133	ColorType.BACKGROUND);
	1134	ENGINE.finishPainting();
	1135	}
	1136	}
	1137	}
	1138
	1139
	1140	//
	1141	// TREE_CELL
	1142	//
	1143	public void paintTreeCellBackground(SynthContext context, Graphics g,
	1144	int x, int y, int w, int h) {
	1145	Region id = context.getRegion();
	1146	int state = context.getComponentState();
	1147	int gtkState = GTKLookAndFeel.synthStateToGTKState(id, state);
	1148	synchronized (UNIXToolkit.GTK_LOCK) {
	1149	if (! ENGINE.paintCachedImage(g, x, y, w, h, id, state)) {
	1150	ENGINE.startPainting(g, x, y, w, h, id, state);
	1151	// the string arg should alternate based on row being painted,
	1152	// but we currently don't pass that in.
	1153	ENGINE.paintFlatBox(g, context, id, gtkState, ShadowType.NONE,
	1154	"cell_odd", x, y, w, h, ColorType.TEXT_BACKGROUND);
	1155	ENGINE.finishPainting();
	1156	}
	1157	}
	1158	}
	1159
	1160	public void paintTreeCellFocus(SynthContext context, Graphics g,
	1161	int x, int y, int w, int h) {
	1162	Region id = Region.TREE_CELL;
	1163	int state = context.getComponentState();
	1164	paintFocus(context, g, id, state, "treeview", x, y, w, h);
	1165	}
	1166
	1167
	1168	//
	1169	// TREE
	1170	//
	1171	public void paintTreeBackground(SynthContext context, Graphics g,
	1172	int x, int y, int w, int h) {
	1173	// As far as I can tell, these don't call into the ENGINE.
	1174	fillArea(context, g, x, y, w, h, GTKColorType.TEXT_BACKGROUND);
	1175	}
	1176
	1177
	1178	//
	1179	// VIEWPORT
	1180	//
	1181	public void paintViewportBackground(SynthContext context, Graphics g,
	1182	int x, int y, int w, int h) {
	1183	// As far as I can tell, these don't call into the ENGINE.
	1184	// Also note that you don't want this to call into the ENGINE
	1185	// as if it where to paint a background JViewport wouldn't scroll
	1186	// correctly.
	1187	fillArea(context, g, x, y, w, h, GTKColorType.TEXT_BACKGROUND);
	1188	}
	1189
	1190	void paintFocus(SynthContext context, Graphics g, Region id,
	1191	int state, String detail, int x, int y, int w, int h) {
	1192	int gtkState = GTKLookAndFeel.synthStateToGTKState(id, state);
	1193	synchronized (UNIXToolkit.GTK_LOCK) {
	1194	if (! ENGINE.paintCachedImage(g, x, y, w, h, id, gtkState, "focus")) {
	1195	ENGINE.startPainting(g, x, y, w, h, id, gtkState, "focus");
	1196	ENGINE.paintFocus(g, context, id, gtkState, detail, x, y, w, h);
	1197	ENGINE.finishPainting();
	1198	}
	1199	}
	1200	}
	1201
	1202	void paintMetacityElement(SynthContext context, Graphics g,
	1203	int gtkState, String detail, int x, int y, int w, int h,
	1204	ShadowType shadow, ArrowType direction) {
	1205	synchronized (UNIXToolkit.GTK_LOCK) {
	1206	if (! ENGINE.paintCachedImage(
	1207	g, x, y, w, h, gtkState, detail, shadow, direction)) {
	1208	ENGINE.startPainting(
	1209	g, x, y, w, h, gtkState, detail, shadow, direction);
	1210	if (detail == "metacity-arrow") {
	1211	ENGINE.paintArrow(g, context, Region.INTERNAL_FRAME_TITLE_PANE,
	1212	gtkState, shadow, direction, "", x, y, w, h);
	1213
	1214	} else if (detail == "metacity-box") {
	1215	ENGINE.paintBox(g, context, Region.INTERNAL_FRAME_TITLE_PANE,
	1216	gtkState, shadow, "", x, y, w, h);
	1217
	1218	} else if (detail == "metacity-vline") {
	1219	ENGINE.paintVline(g, context, Region.INTERNAL_FRAME_TITLE_PANE,
	1220	gtkState, "", x, y, w, h);
	1221	}
	1222	ENGINE.finishPainting();
	1223	}
	1224	}
	1225	}
	1226
	1227	void paintIcon(SynthContext context, Graphics g,
	1228	Method paintMethod, int x, int y, int w, int h) {
	1229	int state = context.getComponentState();
	1230	synchronized (UNIXToolkit.GTK_LOCK) {
	1231	if (! ENGINE.paintCachedImage(g, x, y, w, h, state, paintMethod)) {
	1232	ENGINE.startPainting(g, x, y, w, h, state, paintMethod);
	1233	try {
	1234	paintMethod.invoke(this, context, g, state, x, y, w, h);
	1235	} catch (IllegalAccessException iae) {
	1236	assert false;
	1237	} catch (InvocationTargetException ite) {
	1238	assert false;
	1239	}
	1240	ENGINE.finishPainting();
	1241	}
	1242	}
	1243	}
	1244
	1245	void paintIcon(SynthContext context, Graphics g,
	1246	Method paintMethod, int x, int y, int w, int h, Object direction) {
	1247	int state = context.getComponentState();
	1248	synchronized (UNIXToolkit.GTK_LOCK) {
	1249	if (! ENGINE.paintCachedImage(g,
	1250	x, y, w, h, state, paintMethod, direction)) {
	1251	ENGINE.startPainting(g,
	1252	x, y, w, h, state, paintMethod, direction);
	1253	try {
	1254	paintMethod.invoke(this, context,
	1255	g, state, x, y, w, h, direction);
	1256	} catch (IllegalAccessException iae) {
	1257	assert false;
	1258	} catch (InvocationTargetException ite) {
	1259	assert false;
	1260	}
	1261	ENGINE.finishPainting();
	1262	}
	1263	}
	1264	}
	1265
	1266	// All icon painting methods are called from under GTK_LOCK
	1267
	1268	public void paintTreeExpandedIcon(SynthContext context,
	1269	Graphics g, int state, int x, int y, int w, int h) {
	1270	ENGINE.paintExpander(g, context, Region.TREE,
	1271	GTKLookAndFeel.synthStateToGTKState(context.getRegion(), state),
	1272	ExpanderStyle.EXPANDED, "treeview", x, y, w, h);
	1273	}
	1274
	1275	public void paintTreeCollapsedIcon(SynthContext context,
	1276	Graphics g, int state, int x, int y, int w, int h) {
	1277	ENGINE.paintExpander(g, context, Region.TREE,
	1278	GTKLookAndFeel.synthStateToGTKState(context.getRegion(), state),
	1279	ExpanderStyle.COLLAPSED, "treeview", x, y, w, h);
	1280	}
	1281
	1282	public void paintCheckBoxIcon(SynthContext context,
	1283	Graphics g, int state, int x, int y, int w, int h) {
	1284	GTKStyle style = (GTKStyle)context.getStyle();
	1285	int size = style.getClassSpecificIntValue(context,
	1286	"indicator-size", GTKIconFactory.DEFAULT_ICON_SIZE);
	1287	int offset = style.getClassSpecificIntValue(context,
	1288	"indicator-spacing", GTKIconFactory.DEFAULT_ICON_SPACING);
	1289
	1290	ENGINE.paintCheck(g, context, Region.CHECK_BOX, "checkbutton",
	1291	x+offset, y+offset, size, size);
	1292	}
	1293
	1294	public void paintRadioButtonIcon(SynthContext context,
	1295	Graphics g, int state, int x, int y, int w, int h) {
	1296	GTKStyle style = (GTKStyle)context.getStyle();
	1297	int size = style.getClassSpecificIntValue(context,
	1298	"indicator-size", GTKIconFactory.DEFAULT_ICON_SIZE);
	1299	int offset = style.getClassSpecificIntValue(context,
	1300	"indicator-spacing", GTKIconFactory.DEFAULT_ICON_SPACING);
	1301
	1302	ENGINE.paintOption(g, context, Region.RADIO_BUTTON, "radiobutton",
	1303	x+offset, y+offset, size, size);
	1304	}
	1305
	1306	public void paintMenuArrowIcon(SynthContext context, Graphics g,
	1307	int state, int x, int y, int w, int h, ArrowType dir) {
	1308	int gtkState = GTKLookAndFeel.synthStateToGTKState(
	1309	context.getRegion(), state);
	1310	ShadowType shadow = ShadowType.OUT;
	1311	if (gtkState == SynthConstants.MOUSE_OVER) {
	1312	shadow = ShadowType.IN;
	1313	}
	1314	ENGINE.paintArrow(g, context, Region.MENU_ITEM, gtkState, shadow,
	1315	dir, "menuitem", x + 3, y + 3, 7, 7);
	1316	}
	1317
	1318	public void paintCheckBoxMenuItemCheckIcon(SynthContext context,
	1319	Graphics g, int state, int x, int y, int w, int h) {
	1320
	1321	GTKStyle style = (GTKStyle)context.getStyle();
	1322	int size = style.getClassSpecificIntValue(context,"indicator-size",
	1323	GTKIconFactory.DEFAULT_TOGGLE_MENU_ITEM_SIZE);
	1324
	1325	ENGINE.paintCheck(g, context, Region.CHECK_BOX_MENU_ITEM, "check",
	1326	x + GTKIconFactory.CHECK_ICON_EXTRA_INSET,
	1327	y + GTKIconFactory.CHECK_ICON_EXTRA_INSET,
	1328	size, size);
	1329	}
	1330
	1331	public void paintRadioButtonMenuItemCheckIcon(SynthContext context,
	1332	Graphics g, int state, int x, int y, int w, int h) {
	1333
	1334	GTKStyle style = (GTKStyle)context.getStyle();
	1335	int size = style.getClassSpecificIntValue(context,"indicator-size",
	1336	GTKIconFactory.DEFAULT_TOGGLE_MENU_ITEM_SIZE);
	1337
	1338	ENGINE.paintOption(g, context, Region.RADIO_BUTTON_MENU_ITEM, "option",
	1339	x + GTKIconFactory.CHECK_ICON_EXTRA_INSET,
	1340	y + GTKIconFactory.CHECK_ICON_EXTRA_INSET,
	1341	size, size);
	1342	}
	1343
	1344	public void paintToolBarHandleIcon(SynthContext context, Graphics g,
	1345	int state, int x, int y, int w, int h, Orientation orientation) {
	1346	int gtkState = GTKLookAndFeel.synthStateToGTKState(
	1347	context.getRegion(), state);
	1348
	1349	// The orientation parameter passed down by Synth refers to the
	1350	// orientation of the toolbar, but the one we pass to GTK refers
	1351	// to the orientation of the handle. Therefore, we need to swap
	1352	// the value here: horizontal toolbars have vertical handles, and
	1353	// vice versa.
	1354	orientation = (orientation == Orientation.HORIZONTAL) ?
	1355	Orientation.VERTICAL : Orientation.HORIZONTAL;
	1356
	1357	ENGINE.paintHandle(g, context, Region.TOOL_BAR, gtkState,
	1358	ShadowType.OUT, "handlebox", x, y, w, h, orientation);
	1359	}
	1360
	1361	public void paintAscendingSortIcon(SynthContext context,
	1362	Graphics g, int state, int x, int y, int w, int h) {
	1363	ENGINE.paintArrow(g, context, Region.TABLE, SynthConstants.ENABLED,
	1364	ShadowType.IN, ArrowType.UP, "arrow", x, y, w, h);
	1365	}
	1366
	1367	public void paintDescendingSortIcon(SynthContext context,
	1368	Graphics g, int state, int x, int y, int w, int h) {
	1369	ENGINE.paintArrow(g, context, Region.TABLE, SynthConstants.ENABLED,
	1370	ShadowType.IN, ArrowType.DOWN, "arrow", x, y, w, h);
	1371	}
	1372
	1373	/*
	1374	* Fill an area with color determined from this context's Style using the
	1375	* specified GTKColorType
	1376	*/
	1377	private void fillArea(SynthContext context, Graphics g,
	1378	int x, int y, int w, int h, ColorType colorType) {
	1379	if (context.getComponent().isOpaque()) {
	1380	Region id = context.getRegion();
	1381	int gtkState = GTKLookAndFeel.synthStateToGTKState(id,
	1382	context.getComponentState());
	1383	GTKStyle style = (GTKStyle)context.getStyle();
	1384
	1385	g.setColor(style.getGTKColor(context, gtkState, colorType));
	1386	g.fillRect(x, y, w, h);
	1387	}
	1388	}
	1389
	1390	// Refer to GTKLookAndFeel for details on this.
	1391	static class ListTableFocusBorder extends AbstractBorder implements
	1392	UIResource {
	1393
	1394	private boolean selectedCell;
	1395	private boolean focusedCell;
	1396
	1397	public static ListTableFocusBorder getSelectedCellBorder() {
	1398	return new ListTableFocusBorder(true, true);
	1399	}
	1400
	1401	public static ListTableFocusBorder getUnselectedCellBorder() {
	1402	return new ListTableFocusBorder(false, true);
	1403	}
	1404
	1405	public static ListTableFocusBorder getNoFocusCellBorder() {
	1406	return new ListTableFocusBorder(false, false);
	1407	}
	1408
	1409	public ListTableFocusBorder(boolean selectedCell, boolean focusedCell) {
	1410	this.selectedCell = selectedCell;
	1411	this.focusedCell = focusedCell;
	1412	}
	1413
	1414	private SynthContext getContext(Component c) {
	1415	SynthContext context = null;
	1416
	1417	ComponentUI ui = null;
	1418	if (c instanceof JLabel) {
	1419	ui = ((JLabel)c).getUI();
	1420	}
	1421
	1422	if (ui instanceof SynthUI) {
	1423	context = ((SynthUI)ui).getContext((JComponent)c);
	1424	}
	1425
	1426	return context;
	1427	}
	1428
	1429	public void paintBorder(Component c, Graphics g, int x, int y,
	1430	int w, int h) {
	1431	if (focusedCell) {
	1432	SynthContext context = getContext(c);
	1433	int state = (selectedCell? SynthConstants.SELECTED:
	1434	SynthConstants.FOCUSED \| SynthConstants.ENABLED);
	1435
	1436	if (context != null) {
	1437	GTKPainter.INSTANCE.paintFocus(context, g,
	1438	Region.TABLE, state, "", x, y, w, h);
	1439	}
	1440	}
	1441	}
	1442
	1443	public Insets getBorderInsets(Component c, Insets i) {
	1444	SynthContext context = getContext(c);
	1445
	1446	if (context != null) {
	1447	i = context.getStyle().getInsets(context, i);
	1448	}
	1449
	1450	return i;
	1451	}
	1452
	1453	public boolean isBorderOpaque() {
	1454	return true;
	1455	}
	1456	}
	1457
	1458	// TitledBorder implementation for GTK L&F
	1459	static class TitledBorder extends AbstractBorder implements UIResource {
	1460
	1461	public void paintBorder(Component c, Graphics g, int x, int y,
	1462	int w, int h) {
	1463	SynthContext context = getContext((JComponent)c);
	1464	Region id = context.getRegion();
	1465	int state = context.getComponentState();
	1466	int gtkState = GTKLookAndFeel.synthStateToGTKState(id, state);
	1467
	1468	synchronized (UNIXToolkit.GTK_LOCK) {
	1469	if (! ENGINE.paintCachedImage(g, x, y, w, h, id)) {
	1470	ENGINE.startPainting(g, x, y, w, h, id);
	1471	ENGINE.paintShadow(g, context, id, gtkState, ShadowType.ETCHED_IN,
	1472	"frame", x, y, w, h);
	1473	ENGINE.finishPainting();
	1474	}
	1475	}
	1476	}
	1477
	1478	public Insets getBorderInsets(Component c, Insets i) {
	1479	SynthContext context = getContext((JComponent)c);
	1480	return context.getStyle().getInsets(context, i);
	1481	}
	1482
	1483	public boolean isBorderOpaque() {
	1484	return true;
	1485	}
	1486
	1487	private SynthStyle getStyle(JComponent c) {
	1488	return SynthLookAndFeel.getStyle(c, GTKEngine.CustomRegion.TITLED_BORDER);
	1489	}
	1490
	1491	private SynthContext getContext(JComponent c) {
	1492	int state = SynthConstants.DEFAULT;
	1493	return new SynthContext(c, GTKEngine.CustomRegion.TITLED_BORDER,
	1494	getStyle(c), state);
	1495	}
	1496	}
	1497	}

java/pkg/com/sun/java/swing/plaf/gtk/GTKRegion.java+42−0

@@ -0,0 +1,42 @@
	1	/*
	2	* Copyright (c) 2003, 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	package com.sun.java.swing.plaf.gtk;
	26
	27	import javax.swing.plaf.synth.Region;
	28
	29	/**
	30	* A typesafe enumeration of the distinct rendering portions specific
	31	* to GTK.
	32	*
	33	* @author Scott Violet
	34	*/
	35	class GTKRegion extends Region {
	36	public static final Region HANDLE_BOX = new GTKRegion("HandleBox", null,
	37	true);
	38
	39	protected GTKRegion(String name, String ui, boolean subregion) {
	40	super(name, ui, subregion);
	41	}
	42	}

java/pkg/com/sun/java/swing/plaf/gtk/GTKStyle.java+1141−0

@@ -0,0 +1,1141 @@
	1	/*
	2	* Copyright (c) 2002, 2008, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.swing.plaf.gtk;
	27
	28	import java.awt.*;
	29	import java.lang.reflect.*;
	30	import java.security.*;
	31	import java.util.*;
	32	import javax.swing.*;
	33	import javax.swing.plaf.*;
	34	import javax.swing.plaf.synth.*;
	35
	36	import sun.awt.AppContext;
	37	import sun.awt.UNIXToolkit;
	38	import sun.swing.SwingUtilities2;
	39	import sun.swing.plaf.synth.SynthIcon;
	40
	41	import com.sun.java.swing.plaf.gtk.GTKEngine.WidgetType;
	42
	43	/**
	44	*
	45	* @author Scott Violet
	46	*/
	47	class GTKStyle extends SynthStyle implements GTKConstants {
	48
	49	private static native int nativeGetXThickness(int widgetType);
	50	private static native int nativeGetYThickness(int widgetType);
	51	private static native int nativeGetColorForState(int widgetType,
	52	int state, int typeID);
	53	private static native Object nativeGetClassValue(int widgetType,
	54	String key);
	55	private static native String nativeGetPangoFontName(int widgetType);
	56
	57	private static final String ICON_PROPERTY_PREFIX = "gtk.icon.";
	58
	59	static final Color BLACK_COLOR = new ColorUIResource(Color.BLACK);
	60	static final Color WHITE_COLOR = new ColorUIResource(Color.WHITE);
	61
	62	static final Font DEFAULT_FONT = new FontUIResource("sansserif",
	63	Font.PLAIN, 10 );
	64	static final Insets BUTTON_DEFAULT_BORDER_INSETS = new Insets(1, 1, 1, 1);
	65
	66	private static final GTKGraphicsUtils GTK_GRAPHICS = new GTKGraphicsUtils();
	67
	68	/**
	69	* Maps from a key that is passed to Style.get to the equivalent class
	70	* specific key.
	71	*/
	72	private static final Map<String,String> CLASS_SPECIFIC_MAP;
	73
	74	/**
	75	* Backing style properties that are used if the style does not
	76	* defined the property.
	77	*/
	78	private static final Map<String,GTKStockIcon> ICONS_MAP;
	79
	80	/**
	81	* The font used for this particular style, as determined at
	82	* construction time.
	83	*/
	84	private final Font font;
	85
	86	/** Widget type used when looking up class specific values. */
	87	private final int widgetType;
	88
	89	/** The x/y thickness values for this particular style. */
	90	private final int xThickness, yThickness;
	91
	92	GTKStyle(Font userFont, WidgetType widgetType) {
	93	this.widgetType = widgetType.ordinal();
	94
	95	String pangoFontName;
	96	synchronized (sun.awt.UNIXToolkit.GTK_LOCK) {
	97	xThickness = nativeGetXThickness(this.widgetType);
	98	yThickness = nativeGetYThickness(this.widgetType);
	99	pangoFontName = nativeGetPangoFontName(this.widgetType);
	100	}
	101
	102	Font pangoFont = null;
	103	if (pangoFontName != null) {
	104	pangoFont = PangoFonts.lookupFont(pangoFontName);
	105	}
	106	if (pangoFont != null) {
	107	this.font = pangoFont;
	108	} else if (userFont != null) {
	109	this.font = userFont;
	110	} else {
	111	this.font = DEFAULT_FONT;
	112	}
	113	}
	114
	115	@Override
	116	public void installDefaults(SynthContext context) {
	117	super.installDefaults(context);
	118	if (!context.getRegion().isSubregion()) {
	119	context.getComponent().putClientProperty(
	120	SwingUtilities2.AA_TEXT_PROPERTY_KEY,
	121	GTKLookAndFeel.aaTextInfo);
	122	}
	123	}
	124
	125	@Override
	126	public SynthGraphicsUtils getGraphicsUtils(SynthContext context) {
	127	return GTK_GRAPHICS;
	128	}
	129
	130	/**
	131	* Returns a <code>SynthPainter</code> that will route the appropriate
	132	* calls to a <code>GTKEngine</code>.
	133	*
	134	* @param state SynthContext indentifying requestor
	135	* @return SynthPainter
	136	*/
	137	@Override
	138	public SynthPainter getPainter(SynthContext state) {
	139	return GTKPainter.INSTANCE;
	140	}
	141
	142	protected Color getColorForState(SynthContext context, ColorType type) {
	143	if (type == ColorType.FOCUS \|\| type == GTKColorType.BLACK) {
	144	return BLACK_COLOR;
	145	}
	146	else if (type == GTKColorType.WHITE) {
	147	return WHITE_COLOR;
	148	}
	149
	150	Region id = context.getRegion();
	151	int state = context.getComponentState();
	152	state = GTKLookAndFeel.synthStateToGTKState(id, state);
	153
	154	if (type == ColorType.TEXT_FOREGROUND &&
	155	(id == Region.BUTTON \|\|
	156	id == Region.CHECK_BOX \|\|
	157	id == Region.CHECK_BOX_MENU_ITEM \|\|
	158	id == Region.MENU \|\|
	159	id == Region.MENU_ITEM \|\|
	160	id == Region.RADIO_BUTTON \|\|
	161	id == Region.RADIO_BUTTON_MENU_ITEM \|\|
	162	id == Region.TABBED_PANE_TAB \|\|
	163	id == Region.TOGGLE_BUTTON \|\|
	164	id == Region.TOOL_TIP \|\|
	165	id == Region.MENU_ITEM_ACCELERATOR \|\|
	166	id == Region.TABBED_PANE_TAB)) {
	167	type = ColorType.FOREGROUND;
	168	} else if (id == Region.TABLE \|\|
	169	id == Region.LIST \|\|
	170	id == Region.TREE \|\|
	171	id == Region.TREE_CELL) {
	172	if (type == ColorType.FOREGROUND) {
	173	type = ColorType.TEXT_FOREGROUND;
	174	if (state == SynthConstants.PRESSED) {
	175	state = SynthConstants.SELECTED;
	176	}
	177	} else if (type == ColorType.BACKGROUND) {
	178	type = ColorType.TEXT_BACKGROUND;
	179	}
	180	}
	181
	182	return getStyleSpecificColor(context, state, type);
	183	}
	184
	185	/**
	186	* Returns color specific to the current style. This method is
	187	* invoked when other variants don't fit.
	188	*/
	189	private Color getStyleSpecificColor(SynthContext context, int state,
	190	ColorType type)
	191	{
	192	state = GTKLookAndFeel.synthStateToGTKStateType(state).ordinal();
	193	synchronized (sun.awt.UNIXToolkit.GTK_LOCK) {
	194	int rgb = nativeGetColorForState(widgetType, state,
	195	type.getID());
	196	return new ColorUIResource(rgb);
	197	}
	198	}
	199
	200	Color getGTKColor(int state, ColorType type) {
	201	return getGTKColor(null, state, type);
	202	}
	203
	204	/**
	205	* Returns the color for the specified state.
	206	*
	207	* @param context SynthContext identifying requester
	208	* @param state to get the color for
	209	* @param type of the color
	210	* @return Color to render with
	211	*/
	212	Color getGTKColor(SynthContext context, int state, ColorType type) {
	213	if (context != null) {
	214	JComponent c = context.getComponent();
	215	Region id = context.getRegion();
	216
	217	state = GTKLookAndFeel.synthStateToGTKState(id, state);
	218	if (!id.isSubregion() &&
	219	(state & SynthConstants.ENABLED) != 0) {
	220	if (type == ColorType.BACKGROUND \|\|
	221	type == ColorType.TEXT_BACKGROUND) {
	222	Color bg = c.getBackground();
	223	if (!(bg instanceof UIResource)) {
	224	return bg;
	225	}
	226	}
	227	else if (type == ColorType.FOREGROUND \|\|
	228	type == ColorType.TEXT_FOREGROUND) {
	229	Color fg = c.getForeground();
	230	if (!(fg instanceof UIResource)) {
	231	return fg;
	232	}
	233	}
	234	}
	235	}
	236
	237	return getStyleSpecificColor(context, state, type);
	238	}
	239
	240	@Override
	241	public Color getColor(SynthContext context, ColorType type) {
	242	JComponent c = context.getComponent();
	243	Region id = context.getRegion();
	244	int state = context.getComponentState();
	245
	246	if (c.getName() == "Table.cellRenderer") {
	247	if (type == ColorType.BACKGROUND) {
	248	return c.getBackground();
	249	}
	250	if (type == ColorType.FOREGROUND) {
	251	return c.getForeground();
	252	}
	253	}
	254
	255	if (id == Region.LABEL && type == ColorType.TEXT_FOREGROUND) {
	256	type = ColorType.FOREGROUND;
	257	}
	258
	259	// For the enabled state, prefer the widget's colors
	260	if (!id.isSubregion() && (state & SynthConstants.ENABLED) != 0) {
	261	if (type == ColorType.BACKGROUND) {
	262	return c.getBackground();
	263	}
	264	else if (type == ColorType.FOREGROUND) {
	265	return c.getForeground();
	266	}
	267	else if (type == ColorType.TEXT_FOREGROUND) {
	268	// If getForeground returns a non-UIResource it means the
	269	// developer has explicitly set the foreground, use it over
	270	// that of TEXT_FOREGROUND as that is typically the expected
	271	// behavior.
	272	Color color = c.getForeground();
	273	if (color != null && !(color instanceof UIResource)) {
	274	return color;
	275	}
	276	}
	277	}
	278	return getColorForState(context, type);
	279	}
	280
	281	protected Font getFontForState(SynthContext context) {
	282	return font;
	283	}
	284
	285	/**
	286	* Returns the X thickness to use for this GTKStyle.
	287	*
	288	* @return x thickness.
	289	*/
	290	int getXThickness() {
	291	return xThickness;
	292	}
	293
	294	/**
	295	* Returns the Y thickness to use for this GTKStyle.
	296	*
	297	* @return y thickness.
	298	*/
	299	int getYThickness() {
	300	return yThickness;
	301	}
	302
	303	/**
	304	* Returns the Insets. If <code>insets</code> is non-null the resulting
	305	* insets will be placed in it, otherwise a new Insets object will be
	306	* created and returned.
	307	*
	308	* @param context SynthContext indentifying requestor
	309	* @param insets Where to place Insets
	310	* @return Insets.
	311	*/
	312	@Override
	313	public Insets getInsets(SynthContext state, Insets insets) {
	314	Region id = state.getRegion();
	315	JComponent component = state.getComponent();
	316	String name = (id.isSubregion()) ? null : component.getName();
	317
	318	if (insets == null) {
	319	insets = new Insets(0, 0, 0, 0);
	320	} else {
	321	insets.top = insets.bottom = insets.left = insets.right = 0;
	322	}
	323
	324	if (id == Region.ARROW_BUTTON \|\| id == Region.BUTTON \|\|
	325	id == Region.TOGGLE_BUTTON) {
	326	if ("Spinner.previousButton" == name \|\|
	327	"Spinner.nextButton" == name) {
	328	return getSimpleInsets(state, insets, 1);
	329	} else {
	330	return getButtonInsets(state, insets);
	331	}
	332	}
	333	else if (id == Region.CHECK_BOX \|\| id == Region.RADIO_BUTTON) {
	334	return getRadioInsets(state, insets);
	335	}
	336	else if (id == Region.MENU_BAR) {
	337	return getMenuBarInsets(state, insets);
	338	}
	339	else if (id == Region.MENU \|\|
	340	id == Region.MENU_ITEM \|\|
	341	id == Region.CHECK_BOX_MENU_ITEM \|\|
	342	id == Region.RADIO_BUTTON_MENU_ITEM) {
	343	return getMenuItemInsets(state, insets);
	344	}
	345	else if (id == Region.FORMATTED_TEXT_FIELD) {
	346	return getTextFieldInsets(state, insets);
	347	}
	348	else if (id == Region.INTERNAL_FRAME) {
	349	insets = Metacity.INSTANCE.getBorderInsets(state, insets);
	350	}
	351	else if (id == Region.LABEL) {
	352	if ("TableHeader.renderer" == name) {
	353	return getButtonInsets(state, insets);
	354	}
	355	else if (component instanceof ListCellRenderer) {
	356	return getTextFieldInsets(state, insets);
	357	}
	358	else if ("Tree.cellRenderer" == name) {
	359	return getSimpleInsets(state, insets, 1);
	360	}
	361	}
	362	else if (id == Region.OPTION_PANE) {
	363	return getSimpleInsets(state, insets, 6);
	364	}
	365	else if (id == Region.POPUP_MENU) {
	366	return getSimpleInsets(state, insets, 2);
	367	}
	368	else if (id == Region.PROGRESS_BAR \|\| id == Region.SLIDER \|\|
	369	id == Region.TABBED_PANE \|\| id == Region.TABBED_PANE_CONTENT \|\|
	370	id == Region.TOOL_BAR \|\|
	371	id == Region.TOOL_BAR_DRAG_WINDOW \|\|
	372	id == Region.TOOL_TIP) {
	373	return getThicknessInsets(state, insets);
	374	}
	375	else if (id == Region.SCROLL_BAR) {
	376	return getScrollBarInsets(state, insets);
	377	}
	378	else if (id == Region.SLIDER_TRACK) {
	379	return getSliderTrackInsets(state, insets);
	380	}
	381	else if (id == Region.TABBED_PANE_TAB) {
	382	return getTabbedPaneTabInsets(state, insets);
	383	}
	384	else if (id == Region.TEXT_FIELD \|\| id == Region.PASSWORD_FIELD) {
	385	if (name == "Tree.cellEditor") {
	386	return getSimpleInsets(state, insets, 1);
	387	}
	388	return getTextFieldInsets(state, insets);
	389	} else if (id == Region.SEPARATOR \|\|
	390	id == Region.POPUP_MENU_SEPARATOR \|\|
	391	id == Region.TOOL_BAR_SEPARATOR) {
	392	return getSeparatorInsets(state, insets);
	393	} else if (id == GTKEngine.CustomRegion.TITLED_BORDER) {
	394	return getThicknessInsets(state, insets);
	395	}
	396	return insets;
	397	}
	398
	399	private Insets getButtonInsets(SynthContext context, Insets insets) {
	400	// The following calculations are derived from gtkbutton.c
	401	// (GTK+ version 2.8.20), gtk_button_size_allocate() method.
	402	int CHILD_SPACING = 1;
	403	int focusSize = getClassSpecificIntValue(context, "focus-line-width",1);
	404	int focusPad = getClassSpecificIntValue(context, "focus-padding", 1);
	405	int xThickness = getXThickness();
	406	int yThickness = getYThickness();
	407	int w = focusSize + focusPad + xThickness + CHILD_SPACING;
	408	int h = focusSize + focusPad + yThickness + CHILD_SPACING;
	409	insets.left = insets.right = w;
	410	insets.top = insets.bottom = h;
	411
	412	Component component = context.getComponent();
	413	if ((component instanceof JButton) &&
	414	!(component.getParent() instanceof JToolBar) &&
	415	((JButton)component).isDefaultCapable())
	416	{
	417	// Include the default border insets, but only for JButtons
	418	// that are default capable. Note that
	419	// JButton.getDefaultCapable() returns true by default, but
	420	// GtkToolButtons are never default capable, so we skip this
	421	// step if the button is contained in a toolbar.
	422	Insets defaultInsets = getClassSpecificInsetsValue(context,
	423	"default-border", BUTTON_DEFAULT_BORDER_INSETS);
	424	insets.left += defaultInsets.left;
	425	insets.right += defaultInsets.right;
	426	insets.top += defaultInsets.top;
	427	insets.bottom += defaultInsets.bottom;
	428	}
	429
	430	return insets;
	431	}
	432
	433	/*
	434	* This is used for both RADIO_BUTTON and CHECK_BOX.
	435	*/
	436	private Insets getRadioInsets(SynthContext context, Insets insets) {
	437	// The following calculations are derived from gtkcheckbutton.c
	438	// (GTK+ version 2.8.20), gtk_check_button_size_allocate() method.
	439	int focusSize =
	440	getClassSpecificIntValue(context, "focus-line-width", 1);
	441	int focusPad =
	442	getClassSpecificIntValue(context, "focus-padding", 1);
	443	int totalFocus = focusSize + focusPad;
	444
	445	// Note: GTKIconFactory.DelegateIcon will have already included the
	446	// "indicator-spacing" value in the size of the indicator icon,
	447	// which explains why we use zero as the left inset (or right inset
	448	// in the RTL case); see 6489585 for more details.
	449	insets.top = totalFocus;
	450	insets.bottom = totalFocus;
	451	if (context.getComponent().getComponentOrientation().isLeftToRight()) {
	452	insets.left = 0;
	453	insets.right = totalFocus;
	454	} else {
	455	insets.left = totalFocus;
	456	insets.right = 0;
	457	}
	458
	459	return insets;
	460	}
	461
	462	private Insets getMenuBarInsets(SynthContext context, Insets insets) {
	463	// The following calculations are derived from gtkmenubar.c
	464	// (GTK+ version 2.8.20), gtk_menu_bar_size_allocate() method.
	465	int internalPadding = getClassSpecificIntValue(context,
	466	"internal-padding", 1);
	467	int xThickness = getXThickness();
	468	int yThickness = getYThickness();
	469	insets.left = insets.right = xThickness + internalPadding;
	470	insets.top = insets.bottom = yThickness + internalPadding;
	471	return insets;
	472	}
	473
	474	private Insets getMenuItemInsets(SynthContext context, Insets insets) {
	475	// The following calculations are derived from gtkmenuitem.c
	476	// (GTK+ version 2.8.20), gtk_menu_item_size_allocate() method.
	477	int horizPadding = getClassSpecificIntValue(context,
	478	"horizontal-padding", 3);
	479	int xThickness = getXThickness();
	480	int yThickness = getYThickness();
	481	insets.left = insets.right = xThickness + horizPadding;
	482	insets.top = insets.bottom = yThickness;
	483	return insets;
	484	}
	485
	486	private Insets getThicknessInsets(SynthContext context, Insets insets) {
	487	insets.left = insets.right = getXThickness();
	488	insets.top = insets.bottom = getYThickness();
	489	return insets;
	490	}
	491
	492	private Insets getSeparatorInsets(SynthContext context, Insets insets) {
	493	int horizPadding = 0;
	494	if (context.getRegion() == Region.POPUP_MENU_SEPARATOR) {
	495	horizPadding =
	496	getClassSpecificIntValue(context, "horizontal-padding", 3);
	497	}
	498	insets.right = insets.left = getXThickness() + horizPadding;
	499	insets.top = insets.bottom = getYThickness();
	500	return insets;
	501	}
	502
	503	private Insets getSliderTrackInsets(SynthContext context, Insets insets) {
	504	int focusSize = getClassSpecificIntValue(context, "focus-line-width", 1);
	505	int focusPad = getClassSpecificIntValue(context, "focus-padding", 1);
	506	insets.top = insets.bottom =
	507	insets.left = insets.right = focusSize + focusPad;
	508	return insets;
	509	}
	510
	511	private Insets getSimpleInsets(SynthContext context, Insets insets, int n) {
	512	insets.top = insets.bottom = insets.right = insets.left = n;
	513	return insets;
	514	}
	515
	516	private Insets getTabbedPaneTabInsets(SynthContext context, Insets insets) {
	517	int xThickness = getXThickness();
	518	int yThickness = getYThickness();
	519	int focusSize = getClassSpecificIntValue(context, "focus-line-width",1);
	520	int pad = 2;
	521
	522	insets.left = insets.right = focusSize + pad + xThickness;
	523	insets.top = insets.bottom = focusSize + pad + yThickness;
	524	return insets;
	525	}
	526
	527	// NOTE: this is called for ComboBox, and FormattedTextField also
	528	private Insets getTextFieldInsets(SynthContext context, Insets insets) {
	529	insets = getClassSpecificInsetsValue(context, "inner-border",
	530	getSimpleInsets(context, insets, 2));
	531
	532	int xThickness = getXThickness();
	533	int yThickness = getYThickness();
	534	boolean interiorFocus =
	535	getClassSpecificBoolValue(context, "interior-focus", true);
	536	int focusSize = 0;
	537
	538	if (!interiorFocus) {
	539	focusSize = getClassSpecificIntValue(context, "focus-line-width",1);
	540	}
	541
	542	insets.left += focusSize + xThickness;
	543	insets.right += focusSize + xThickness;
	544	insets.top += focusSize + yThickness;
	545	insets.bottom += focusSize + yThickness;
	546	return insets;
	547	}
	548
	549	private Insets getScrollBarInsets(SynthContext context, Insets insets) {
	550	int troughBorder =
	551	getClassSpecificIntValue(context, "trough-border", 1);
	552	insets.left = insets.right = insets.top = insets.bottom = troughBorder;
	553
	554	JComponent c = context.getComponent();
	555	if (c.getParent() instanceof JScrollPane) {
	556	// This scrollbar is part of a scrollpane; use only the
	557	// "scrollbar-spacing" style property to determine the padding
	558	// between the scrollbar and its parent scrollpane.
	559	int spacing =
	560	getClassSpecificIntValue(WidgetType.SCROLL_PANE,
	561	"scrollbar-spacing", 3);
	562	if (((JScrollBar)c).getOrientation() == JScrollBar.HORIZONTAL) {
	563	insets.top += spacing;
	564	} else {
	565	if (c.getComponentOrientation().isLeftToRight()) {
	566	insets.left += spacing;
	567	} else {
	568	insets.right += spacing;
	569	}
	570	}
	571	} else {
	572	// This is a standalone scrollbar; leave enough room for the
	573	// focus line in addition to the trough border.
	574	if (c.isFocusable()) {
	575	int focusSize =
	576	getClassSpecificIntValue(context, "focus-line-width", 1);
	577	int focusPad =
	578	getClassSpecificIntValue(context, "focus-padding", 1);
	579	int totalFocus = focusSize + focusPad;
	580	insets.left += totalFocus;
	581	insets.right += totalFocus;
	582	insets.top += totalFocus;
	583	insets.bottom += totalFocus;
	584	}
	585	}
	586	return insets;
	587	}
	588
	589	/**
	590	* Returns the value for a class specific property for a particular
	591	* WidgetType. This method is useful in those cases where we need to
	592	* fetch a value for a Region that is not associated with the component
	593	* currently in use (e.g. we need to figure out the insets for a
	594	* SCROLL_BAR, but certain values can only be extracted from a
	595	* SCROLL_PANE region).
	596	*
	597	* @param wt WidgetType for which to fetch the value
	598	* @param key Key identifying class specific value
	599	* @return Value, or null if one has not been defined
	600	*/
	601	private static Object getClassSpecificValue(WidgetType wt, String key) {
	602	synchronized (UNIXToolkit.GTK_LOCK) {
	603	return nativeGetClassValue(wt.ordinal(), key);
	604	}
	605	}
	606
	607	/**
	608	* Convenience method to get a class specific integer value for
	609	* a particular WidgetType.
	610	*
	611	* @param wt WidgetType for which to fetch the value
	612	* @param key Key identifying class specific value
	613	* @param defaultValue Returned if there is no value for the specified
	614	* type
	615	* @return Value, or defaultValue if <code>key</code> is not defined
	616	*/
	617	private static int getClassSpecificIntValue(WidgetType wt, String key,
	618	int defaultValue)
	619	{
	620	Object value = getClassSpecificValue(wt, key);
	621	if (value instanceof Number) {
	622	return ((Number)value).intValue();
	623	}
	624	return defaultValue;
	625	}
	626
	627	/**
	628	* Returns the value for a class specific property. A class specific value
	629	* is a value that will be picked up based on class hierarchy.
	630	*
	631	* @param key Key identifying class specific value
	632	* @return Value, or null if one has not been defined.
	633	*/
	634	Object getClassSpecificValue(String key) {
	635	synchronized (sun.awt.UNIXToolkit.GTK_LOCK) {
	636	return nativeGetClassValue(widgetType, key);
	637	}
	638	}
	639
	640	/**
	641	* Convenience method to get a class specific integer value.
	642	*
	643	* @param context SynthContext indentifying requestor
	644	* @param key Key identifying class specific value
	645	* @param defaultValue Returned if there is no value for the specified
	646	* type
	647	* @return Value, or defaultValue if <code>key</code> is not defined
	648	*/
	649	int getClassSpecificIntValue(SynthContext context, String key,
	650	int defaultValue)
	651	{
	652	Object value = getClassSpecificValue(key);
	653
	654	if (value instanceof Number) {
	655	return ((Number)value).intValue();
	656	}
	657	return defaultValue;
	658	}
	659
	660	/**
	661	* Convenience method to get a class specific Insets value.
	662	*
	663	* @param context SynthContext indentifying requestor
	664	* @param key Key identifying class specific value
	665	* @param defaultValue Returned if there is no value for the specified
	666	* type
	667	* @return Value, or defaultValue if <code>key</code> is not defined
	668	*/
	669	Insets getClassSpecificInsetsValue(SynthContext context, String key,
	670	Insets defaultValue)
	671	{
	672	Object value = getClassSpecificValue(key);
	673
	674	if (value instanceof Insets) {
	675	return (Insets)value;
	676	}
	677	return defaultValue;
	678	}
	679
	680	/**
	681	* Convenience method to get a class specific Boolean value.
	682	*
	683	* @param context SynthContext indentifying requestor
	684	* @param key Key identifying class specific value
	685	* @param defaultValue Returned if there is no value for the specified
	686	* type
	687	* @return Value, or defaultValue if <code>key</code> is not defined
	688	*/
	689	boolean getClassSpecificBoolValue(SynthContext context, String key,
	690	boolean defaultValue)
	691	{
	692	Object value = getClassSpecificValue(key);
	693
	694	if (value instanceof Boolean) {
	695	return ((Boolean)value).booleanValue();
	696	}
	697	return defaultValue;
	698	}
	699
	700	/**
	701	* Returns the value to initialize the opacity property of the Component
	702	* to. A Style should NOT assume the opacity will remain this value, the
	703	* developer may reset it or override it.
	704	*
	705	* @param context SynthContext indentifying requestor
	706	* @return opaque Whether or not the JComponent is opaque.
	707	*/
	708	@Override
	709	public boolean isOpaque(SynthContext context) {
	710	Region region = context.getRegion();
	711	if (region == Region.COMBO_BOX \|\|
	712	region == Region.DESKTOP_PANE \|\|
	713	region == Region.DESKTOP_ICON \|\|
	714	region == Region.EDITOR_PANE \|\|
	715	region == Region.FORMATTED_TEXT_FIELD \|\|
	716	region == Region.INTERNAL_FRAME \|\|
	717	region == Region.LIST \|\|
	718	region == Region.MENU_BAR \|\|
	719	region == Region.PANEL \|\|
	720	region == Region.PASSWORD_FIELD \|\|
	721	region == Region.POPUP_MENU \|\|
	722	region == Region.PROGRESS_BAR \|\|
	723	region == Region.ROOT_PANE \|\|
	724	region == Region.SCROLL_PANE \|\|
	725	region == Region.SPINNER \|\|
	726	region == Region.SPLIT_PANE_DIVIDER \|\|
	727	region == Region.TABLE \|\|
	728	region == Region.TEXT_AREA \|\|
	729	region == Region.TEXT_FIELD \|\|
	730	region == Region.TEXT_PANE \|\|
	731	region == Region.TOOL_BAR_DRAG_WINDOW \|\|
	732	region == Region.TOOL_TIP \|\|
	733	region == Region.TREE \|\|
	734	region == Region.VIEWPORT) {
	735	return true;
	736	}
	737	Component c = context.getComponent();
	738	String name = c.getName();
	739	if (name == "ComboBox.renderer" \|\| name == "ComboBox.listRenderer") {
	740	return true;
	741	}
	742	return false;
	743	}
	744
	745	@Override
	746	public Object get(SynthContext context, Object key) {
	747	// See if this is a class specific value.
	748	String classKey = CLASS_SPECIFIC_MAP.get(key);
	749	if (classKey != null) {
	750	Object value = getClassSpecificValue(classKey);
	751	if (value != null) {
	752	return value;
	753	}
	754	}
	755
	756	// Is it a specific value ?
	757	if (key == "ScrollPane.viewportBorderInsets") {
	758	return getThicknessInsets(context, new Insets(0, 0, 0, 0));
	759	}
	760	else if (key == "Slider.tickColor") {
	761	return getColorForState(context, ColorType.FOREGROUND);
	762	}
	763	else if (key == "ScrollBar.minimumThumbSize") {
	764	int len =
	765	getClassSpecificIntValue(context, "min-slider-length", 21);
	766	JScrollBar sb = (JScrollBar)context.getComponent();
	767	if (sb.getOrientation() == JScrollBar.HORIZONTAL) {
	768	return new DimensionUIResource(len, 0);
	769	} else {
	770	return new DimensionUIResource(0, len);
	771	}
	772	}
	773	else if (key == "Separator.thickness") {
	774	JSeparator sep = (JSeparator)context.getComponent();
	775	if (sep.getOrientation() == JSeparator.HORIZONTAL) {
	776	return getYThickness();
	777	} else {
	778	return getXThickness();
	779	}
	780	}
	781	else if (key == "ToolBar.separatorSize") {
	782	int size = getClassSpecificIntValue(WidgetType.TOOL_BAR,
	783	"space-size", 12);
	784	return new DimensionUIResource(size, size);
	785	}
	786	else if (key == "ScrollBar.buttonSize") {
	787	JScrollBar sb = (JScrollBar)context.getComponent().getParent();
	788	boolean horiz = (sb.getOrientation() == JScrollBar.HORIZONTAL);
	789	WidgetType wt = horiz ?
	790	WidgetType.HSCROLL_BAR : WidgetType.VSCROLL_BAR;
	791	int sliderWidth = getClassSpecificIntValue(wt, "slider-width", 14);
	792	int stepperSize = getClassSpecificIntValue(wt, "stepper-size", 14);
	793	return horiz ?
	794	new DimensionUIResource(stepperSize, sliderWidth) :
	795	new DimensionUIResource(sliderWidth, stepperSize);
	796	}
	797	else if (key == "ArrowButton.size") {
	798	String name = context.getComponent().getName();
	799	if (name != null && name.startsWith("Spinner")) {
	800	// Believe it or not, the size of a spinner arrow button is
	801	// dependent upon the size of the spinner's font. These
	802	// calculations come from gtkspinbutton.c (version 2.8.20),
	803	// spin_button_get_arrow_size() method.
	804	String pangoFontName;
	805	synchronized (sun.awt.UNIXToolkit.GTK_LOCK) {
	806	pangoFontName =
	807	nativeGetPangoFontName(WidgetType.SPINNER.ordinal());
	808	}
	809	int arrowSize = (pangoFontName != null) ?
	810	PangoFonts.getFontSize(pangoFontName) : 10;
	811	return (arrowSize + (getXThickness() * 2));
	812	}
	813	// For all other kinds of arrow buttons (e.g. combobox arrow
	814	// buttons), we will simply fall back on the value of
	815	// ArrowButton.size as defined in the UIDefaults for
	816	// GTKLookAndFeel when we call UIManager.get() below...
	817	}
	818	else if ("CheckBox.iconTextGap".equals(key) \|\|
	819	"RadioButton.iconTextGap".equals(key))
	820	{
	821	// The iconTextGap value needs to include "indicator-spacing"
	822	// and it also needs to leave enough space for the focus line,
	823	// which falls between the indicator icon and the text.
	824	// See getRadioInsets() and 6489585 for more details.
	825	int indicatorSpacing =
	826	getClassSpecificIntValue(context, "indicator-spacing", 2);
	827	int focusSize =
	828	getClassSpecificIntValue(context, "focus-line-width", 1);
	829	int focusPad =
	830	getClassSpecificIntValue(context, "focus-padding", 1);
	831	return indicatorSpacing + focusSize + focusPad;
	832	}
	833
	834	// Is it a stock icon ?
	835	GTKStockIcon stockIcon = null;
	836	synchronized (ICONS_MAP) {
	837	stockIcon = ICONS_MAP.get(key);
	838	}
	839
	840	if (stockIcon != null) {
	841	return stockIcon;
	842	}
	843
	844	// Is it another kind of value ?
	845	if (key != "engine") {
	846	// For backward compatability we'll fallback to the UIManager.
	847	// We don't go to the UIManager for engine as the engine is GTK
	848	// specific.
	849	Object value = UIManager.get(key);
	850	if (key == "Table.rowHeight") {
	851	int focusLineWidth = getClassSpecificIntValue(context,
	852	"focus-line-width", 0);
	853	if (value == null && focusLineWidth > 0) {
	854	value = Integer.valueOf(16 + 2 * focusLineWidth);
	855	}
	856	}
	857	return value;
	858	}
	859
	860	// Don't call super, we don't want to pick up defaults from
	861	// SynthStyle.
	862	return null;
	863	}
	864
	865	private Icon getStockIcon(SynthContext context, String key, int type) {
	866	TextDirection direction = TextDirection.LTR;
	867
	868	if (context != null) {
	869	ComponentOrientation co = context.getComponent().
	870	getComponentOrientation();
	871
	872	if (co != null && !co.isLeftToRight()) {
	873	direction = TextDirection.RTL;
	874	}
	875	}
	876
	877	// First try loading a theme-specific icon using the native
	878	// GTK libraries (native GTK handles the resizing for us).
	879	Icon icon = getStyleSpecificIcon(key, direction, type);
	880	if (icon != null) {
	881	return icon;
	882	}
	883
	884	// In a failure case where native GTK (unexpectedly) returns a
	885	// null icon, we can try loading a default icon as a fallback.
	886	String propName = ICON_PROPERTY_PREFIX + key + '.' + type + '.' +
	887	(direction == TextDirection.RTL ? "rtl" : "ltr");
	888	Image img = (Image)
	889	Toolkit.getDefaultToolkit().getDesktopProperty(propName);
	890	if (img != null) {
	891	return new ImageIcon(img);
	892	}
	893
	894	// In an extreme failure situation, just return null (callers are
	895	// already prepared to handle a null icon, so the worst that can
	896	// happen is that an icon won't be included in the button/dialog).
	897	return null;
	898	}
	899
	900	private Icon getStyleSpecificIcon(String key,
	901	TextDirection direction, int type)
	902	{
	903	UNIXToolkit tk = (UNIXToolkit)Toolkit.getDefaultToolkit();
	904	Image img =
	905	tk.getStockIcon(widgetType, key, type, direction.ordinal(), null);
	906	return (img != null) ? new ImageIcon(img) : null;
	907	}
	908
	909	static class GTKStockIconInfo {
	910	private static Map<String,Integer> ICON_TYPE_MAP;
	911	private static final Object ICON_SIZE_KEY = new StringBuffer("IconSize");
	912
	913	private static Dimension[] getIconSizesMap() {
	914	AppContext appContext = AppContext.getAppContext();
	915	Dimension[] iconSizes = (Dimension[])appContext.get(ICON_SIZE_KEY);
	916
	917	if (iconSizes == null) {
	918	iconSizes = new Dimension[7];
	919	iconSizes[0] = null; // GTK_ICON_SIZE_INVALID
	920	iconSizes[1] = new Dimension(16, 16); // GTK_ICON_SIZE_MENU
	921	iconSizes[2] = new Dimension(18, 18); // GTK_ICON_SIZE_SMALL_TOOLBAR
	922	iconSizes[3] = new Dimension(24, 24); // GTK_ICON_SIZE_LARGE_TOOLBAR
	923	iconSizes[4] = new Dimension(20, 20); // GTK_ICON_SIZE_BUTTON
	924	iconSizes[5] = new Dimension(32, 32); // GTK_ICON_SIZE_DND
	925	iconSizes[6] = new Dimension(48, 48); // GTK_ICON_SIZE_DIALOG
	926	appContext.put(ICON_SIZE_KEY, iconSizes);
	927	}
	928	return iconSizes;
	929	}
	930
	931	/**
	932	* Return the size of a particular icon type (logical size)
	933	*
	934	* @param type icon type (GtkIconSize value)
	935	* @return a Dimension object, or null if lsize is invalid
	936	*/
	937	public static Dimension getIconSize(int type) {
	938	Dimension[] iconSizes = getIconSizesMap();
	939	return type >= 0 && type < iconSizes.length ?
	940	iconSizes[type] : null;
	941	}
	942
	943	/**
	944	* Change icon size in a type to size mapping. This is called by code
	945	* that parses the gtk-icon-sizes setting
	946	*
	947	* @param type icon type (GtkIconSize value)
	948	* @param w the new icon width
	949	* @param h the new icon height
	950	*/
	951	public static void setIconSize(int type, int w, int h) {
	952	Dimension[] iconSizes = getIconSizesMap();
	953	if (type >= 0 && type < iconSizes.length) {
	954	iconSizes[type] = new Dimension(w, h);
	955	}
	956	}
	957
	958	/**
	959	* Return icon type (GtkIconSize value) given a symbolic name which can
	960	* occur in a theme file.
	961	*
	962	* @param size symbolic name, e.g. gtk-button
	963	* @return icon type. Valid types are 1 to 6
	964	*/
	965	public static int getIconType(String size) {
	966	if (size == null) {
	967	return UNDEFINED;
	968	}
	969	if (ICON_TYPE_MAP == null) {
	970	initIconTypeMap();
	971	}
	972	Integer n = ICON_TYPE_MAP.get(size);
	973	return n != null ? n.intValue() : UNDEFINED;
	974	}
	975
	976	private static void initIconTypeMap() {
	977	ICON_TYPE_MAP = new HashMap<String,Integer>();
	978	ICON_TYPE_MAP.put("gtk-menu", Integer.valueOf(1));
	979	ICON_TYPE_MAP.put("gtk-small-toolbar", Integer.valueOf(2));
	980	ICON_TYPE_MAP.put("gtk-large-toolbar", Integer.valueOf(3));
	981	ICON_TYPE_MAP.put("gtk-button", Integer.valueOf(4));
	982	ICON_TYPE_MAP.put("gtk-dnd", Integer.valueOf(5));
	983	ICON_TYPE_MAP.put("gtk-dialog", Integer.valueOf(6));
	984	}
	985
	986	}
	987
	988	/**
	989	* An Icon that is fetched using getStockIcon.
	990	*/
	991	private static class GTKStockIcon extends SynthIcon {
	992	private String key;
	993	private int size;
	994	private boolean loadedLTR;
	995	private boolean loadedRTL;
	996	private Icon ltrIcon;
	997	private Icon rtlIcon;
	998	private SynthStyle style;
	999
	1000	GTKStockIcon(String key, int size) {
	1001	this.key = key;
	1002	this.size = size;
	1003	}
	1004
	1005	public void paintIcon(SynthContext context, Graphics g, int x,
	1006	int y, int w, int h) {
	1007	Icon icon = getIcon(context);
	1008
	1009	if (icon != null) {
	1010	if (context == null) {
	1011	icon.paintIcon(null, g, x, y);
	1012	}
	1013	else {
	1014	icon.paintIcon(context.getComponent(), g, x, y);
	1015	}
	1016	}
	1017	}
	1018
	1019	public int getIconWidth(SynthContext context) {
	1020	Icon icon = getIcon(context);
	1021
	1022	if (icon != null) {
	1023	return icon.getIconWidth();
	1024	}
	1025	return 0;
	1026	}
	1027
	1028	public int getIconHeight(SynthContext context) {
	1029	Icon icon = getIcon(context);
	1030
	1031	if (icon != null) {
	1032	return icon.getIconHeight();
	1033	}
	1034	return 0;
	1035	}
	1036
	1037	private Icon getIcon(SynthContext context) {
	1038	if (context != null) {
	1039	ComponentOrientation co = context.getComponent().
	1040	getComponentOrientation();
	1041	SynthStyle style = context.getStyle();
	1042
	1043	if (style != this.style) {
	1044	this.style = style;
	1045	loadedLTR = loadedRTL = false;
	1046	}
	1047	if (co == null \|\| co.isLeftToRight()) {
	1048	if (!loadedLTR) {
	1049	loadedLTR = true;
	1050	ltrIcon = ((GTKStyle)context.getStyle()).
	1051	getStockIcon(context, key, size);
	1052	}
	1053	return ltrIcon;
	1054	}
	1055	else if (!loadedRTL) {
	1056	loadedRTL = true;
	1057	rtlIcon = ((GTKStyle)context.getStyle()).
	1058	getStockIcon(context, key,size);
	1059	}
	1060	return rtlIcon;
	1061	}
	1062	return ltrIcon;
	1063	}
	1064	}
	1065
	1066	/**
	1067	* GTKLazyValue is a slimmed down version of <code>ProxyLaxyValue</code>.
	1068	* The code is duplicate so that it can get at the package private
	1069	* classes in gtk.
	1070	*/
	1071	static class GTKLazyValue implements UIDefaults.LazyValue {
	1072	/**
	1073	* Name of the class to create.
	1074	*/
	1075	private String className;
	1076	private String methodName;
	1077
	1078	GTKLazyValue(String name) {
	1079	this(name, null);
	1080	}
	1081
	1082	GTKLazyValue(String name, String methodName) {
	1083	this.className = name;
	1084	this.methodName = methodName;
	1085	}
	1086
	1087	public Object createValue(UIDefaults table) {
	1088	try {
	1089	Class c = Class.forName(className, true,Thread.currentThread().
	1090	getContextClassLoader());
	1091
	1092	if (methodName == null) {
	1093	return c.newInstance();
	1094	}
	1095	Method m = c.getMethod(methodName, (Class[])null);
	1096
	1097	return m.invoke(c, (Object[])null);
	1098	} catch (ClassNotFoundException cnfe) {
	1099	} catch (IllegalAccessException iae) {
	1100	} catch (InvocationTargetException ite) {
	1101	} catch (NoSuchMethodException nsme) {
	1102	} catch (InstantiationException ie) {
	1103	}
	1104	return null;
	1105	}
	1106	}
	1107
	1108	static {
	1109	CLASS_SPECIFIC_MAP = new HashMap<String,String>();
	1110	CLASS_SPECIFIC_MAP.put("Slider.thumbHeight", "slider-width");
	1111	CLASS_SPECIFIC_MAP.put("Slider.trackBorder", "trough-border");
	1112	CLASS_SPECIFIC_MAP.put("SplitPane.size", "handle-size");
	1113	CLASS_SPECIFIC_MAP.put("Tree.expanderSize", "expander-size");
	1114	CLASS_SPECIFIC_MAP.put("ScrollBar.thumbHeight", "slider-width");
	1115	CLASS_SPECIFIC_MAP.put("ScrollBar.width", "slider-width");
	1116	CLASS_SPECIFIC_MAP.put("TextArea.caretForeground", "cursor-color");
	1117	CLASS_SPECIFIC_MAP.put("TextArea.caretAspectRatio", "cursor-aspect-ratio");
	1118	CLASS_SPECIFIC_MAP.put("TextField.caretForeground", "cursor-color");
	1119	CLASS_SPECIFIC_MAP.put("TextField.caretAspectRatio", "cursor-aspect-ratio");
	1120	CLASS_SPECIFIC_MAP.put("PasswordField.caretForeground", "cursor-color");
	1121	CLASS_SPECIFIC_MAP.put("PasswordField.caretAspectRatio", "cursor-aspect-ratio");
	1122	CLASS_SPECIFIC_MAP.put("FormattedTextField.caretForeground", "cursor-color");
	1123	CLASS_SPECIFIC_MAP.put("FormattedTextField.caretAspectRatio", "cursor-aspect-");
	1124	CLASS_SPECIFIC_MAP.put("TextPane.caretForeground", "cursor-color");
	1125	CLASS_SPECIFIC_MAP.put("TextPane.caretAspectRatio", "cursor-aspect-ratio");
	1126	CLASS_SPECIFIC_MAP.put("EditorPane.caretForeground", "cursor-color");
	1127	CLASS_SPECIFIC_MAP.put("EditorPane.caretAspectRatio", "cursor-aspect-ratio");
	1128
	1129	ICONS_MAP = new HashMap<String, GTKStockIcon>();
	1130	ICONS_MAP.put("FileChooser.cancelIcon", new GTKStockIcon("gtk-cancel", 4));
	1131	ICONS_MAP.put("FileChooser.okIcon", new GTKStockIcon("gtk-ok", 4));
	1132	ICONS_MAP.put("OptionPane.errorIcon", new GTKStockIcon("gtk-dialog-error", 6));
	1133	ICONS_MAP.put("OptionPane.informationIcon", new GTKStockIcon("gtk-dialog-info", 6));
	1134	ICONS_MAP.put("OptionPane.warningIcon", new GTKStockIcon("gtk-dialog-warning", 6));
	1135	ICONS_MAP.put("OptionPane.questionIcon", new GTKStockIcon("gtk-dialog-question", 6));
	1136	ICONS_MAP.put("OptionPane.yesIcon", new GTKStockIcon("gtk-yes", 4));
	1137	ICONS_MAP.put("OptionPane.noIcon", new GTKStockIcon("gtk-no", 4));
	1138	ICONS_MAP.put("OptionPane.cancelIcon", new GTKStockIcon("gtk-cancel", 4));
	1139	ICONS_MAP.put("OptionPane.okIcon", new GTKStockIcon("gtk-ok", 4));
	1140	}
	1141	}

java/pkg/com/sun/java/swing/plaf/gtk/GTKStyleFactory.java+182−0

@@ -0,0 +1,182 @@
	1	/*
	2	* Copyright (c) 2002, 2006, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.swing.plaf.gtk;
	27
	28	import java.awt.Font;
	29	import java.util.*;
	30	import javax.swing.*;
	31	import javax.swing.plaf.synth.*;
	32	import com.sun.java.swing.plaf.gtk.GTKEngine.WidgetType;
	33
	34	/**
	35	*
	36	* @author Scott Violet
	37	*/
	38	class GTKStyleFactory extends SynthStyleFactory {
	39
	40	/**
	41	* Saves all styles that have been accessed. In most common cases,
	42	* the hash key is simply the WidgetType, but in more complex cases
	43	* it will be a ComplexKey object that contains arguments to help
	44	* differentiate similar styles.
	45	*/
	46	private final Map<Object, GTKStyle> stylesCache;
	47
	48	private Font defaultFont;
	49
	50	GTKStyleFactory() {
	51	stylesCache = new HashMap<Object, GTKStyle>();
	52	}
	53
	54	/**
	55	* Returns the <code>GTKStyle</code> to use based on the
	56	* <code>Region</code> id
	57	*
	58	* @param c this parameter isn't used, may be null.
	59	* @param id of the region to get the style.
	60	*/
	61	public synchronized SynthStyle getStyle(JComponent c, Region id) {
	62	WidgetType wt = GTKEngine.getWidgetType(c, id);
	63
	64	Object key = null;
	65	if (id == Region.SCROLL_BAR) {
	66	// The style/insets of a scrollbar can depend on a number of
	67	// factors (see GTKStyle.getScrollBarInsets()) so use a
	68	// complex key here.
	69	if (c != null) {
	70	JScrollBar sb = (JScrollBar)c;
	71	boolean sp = (sb.getParent() instanceof JScrollPane);
	72	boolean horiz = (sb.getOrientation() == JScrollBar.HORIZONTAL);
	73	boolean ltr = sb.getComponentOrientation().isLeftToRight();
	74	boolean focusable = sb.isFocusable();
	75	key = new ComplexKey(wt, sp, horiz, ltr, focusable);
	76	}
	77	}
	78	else if (id == Region.CHECK_BOX \|\| id == Region.RADIO_BUTTON) {
	79	// The style/insets of a checkbox or radiobutton can depend
	80	// on the component orientation, so use a complex key here.
	81	if (c != null) {
	82	boolean ltr = c.getComponentOrientation().isLeftToRight();
	83	key = new ComplexKey(wt, ltr);
	84	}
	85	}
	86	else if (id == Region.BUTTON) {
	87	// The style/insets of a button can depend on whether it is
	88	// default capable or in a toolbar, so use a complex key here.
	89	if (c != null) {
	90	JButton btn = (JButton)c;
	91	boolean toolButton = (btn.getParent() instanceof JToolBar);
	92	boolean defaultCapable = btn.isDefaultCapable();
	93	key = new ComplexKey(wt, toolButton, defaultCapable);
	94	}
	95	}
	96	if (key == null) {
	97	// Otherwise, just use the WidgetType as the key.
	98	key = wt;
	99	}
	100
	101	GTKStyle result = stylesCache.get(key);
	102	if (result == null) {
	103	result = new GTKStyle(defaultFont, wt);
	104	stylesCache.put(key, result);
	105	}
	106
	107	return result;
	108	}
	109
	110	void initStyles(Font defaultFont) {
	111	this.defaultFont = defaultFont;
	112	stylesCache.clear();
	113	}
	114
	115	/**
	116	* Represents a hash key used for fetching GTKStyle objects from the
	117	* cache. In most cases only the WidgetType is used for lookup, but
	118	* in some complex cases, other Object arguments can be specified
	119	* via a ComplexKey to differentiate the various styles.
	120	*/
	121	private static class ComplexKey {
	122	private final WidgetType wt;
	123	private final Object[] args;
	124
	125	ComplexKey(WidgetType wt, Object... args) {
	126	this.wt = wt;
	127	this.args = args;
	128	}
	129
	130	@Override
	131	public int hashCode() {
	132	int hash = wt.hashCode();
	133	if (args != null) {
	134	for (Object arg : args) {
	135	hash = hash*29 + (arg == null ? 0 : arg.hashCode());
	136	}
	137	}
	138	return hash;
	139	}
	140
	141	@Override
	142	public boolean equals(Object o) {
	143	if (!(o instanceof ComplexKey)) {
	144	return false;
	145	}
	146	ComplexKey that = (ComplexKey)o;
	147	if (this.wt == that.wt) {
	148	if (this.args == null && that.args == null) {
	149	return true;
	150	}
	151	if (this.args != null && that.args != null &&
	152	this.args.length == that.args.length)
	153	{
	154	for (int i = 0; i < this.args.length; i++) {
	155	Object a1 = this.args[i];
	156	Object a2 = that.args[i];
	157	if (!(a1==null ? a2==null : a1.equals(a2))) {
	158	return false;
	159	}
	160	}
	161	return true;
	162	}
	163	}
	164	return false;
	165	}
	166
	167	@Override
	168	public String toString() {
	169	String str = "ComplexKey[wt=" + wt;
	170	if (args != null) {
	171	str += ",args=[";
	172	for (int i = 0; i < args.length; i++) {
	173	str += args[i];
	174	if (i < args.length-1) str += ",";
	175	}
	176	str += "]";
	177	}
	178	str += "]";
	179	return str;
	180	}
	181	}
	182	}

java/pkg/com/sun/java/swing/plaf/gtk/Metacity.java+2155−0

@@ -0,0 +1,2155 @@
	1	/*
	2	* Copyright (c) 2002, 2008, 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	package com.sun.java.swing.plaf.gtk;
	26
	27	import sun.swing.SwingUtilities2;
	28	import com.sun.java.swing.plaf.gtk.GTKConstants.ArrowType;
	29	import com.sun.java.swing.plaf.gtk.GTKConstants.ShadowType;
	30
	31	import javax.swing.plaf.ColorUIResource;
	32	import javax.swing.plaf.synth.*;
	33
	34	import java.awt.*;
	35	import java.awt.geom.*;
	36	import java.awt.image.*;
	37	import java.io.*;
	38	import java.net.*;
	39	import java.security.*;
	40	import java.util.*;
	41
	42	import javax.swing.*;
	43	import javax.swing.border.*;
	44
	45	import javax.xml.parsers.*;
	46	import org.xml.sax.SAXException;
	47	import org.w3c.dom.*;
	48
	49	/**
	50	*/
	51	class Metacity implements SynthConstants {
	52	// Tutorial:
	53	// http://developer.gnome.org/doc/tutorials/metacity/metacity-themes.html
	54
	55	// Themes:
	56	// http://art.gnome.org/theme_list.php?category=metacity
	57
	58	static Metacity INSTANCE;
	59
	60	private static final String[] themeNames = {
	61	getUserTheme(),
	62	"blueprint",
	63	"Bluecurve",
	64	"Crux",
	65	"SwingFallbackTheme"
	66	};
	67
	68	static {
	69	for (String themeName : themeNames) {
	70	if (themeName != null) {
	71	try {
	72	INSTANCE = new Metacity(themeName);
	73	} catch (FileNotFoundException ex) {
	74	} catch (IOException ex) {
	75	logError(themeName, ex);
	76	} catch (ParserConfigurationException ex) {
	77	logError(themeName, ex);
	78	} catch (SAXException ex) {
	79	logError(themeName, ex);
	80	}
	81	}
	82	if (INSTANCE != null) {
	83	break;
	84	}
	85	}
	86	if (INSTANCE == null) {
	87	throw new Error("Could not find any installed metacity theme, and fallback failed");
	88	}
	89	}
	90
	91	private static boolean errorLogged = false;
	92	private static DocumentBuilder documentBuilder;
	93	private static Document xmlDoc;
	94	private static String userHome;
	95
	96	private Node frame_style_set;
	97	private Map<String, Object> frameGeometry;
	98	private Map<String, Map<String, Object>> frameGeometries;
	99
	100	private LayoutManager titlePaneLayout = new TitlePaneLayout();
	101
	102	private ColorizeImageFilter imageFilter = new ColorizeImageFilter();
	103	private URL themeDir = null;
	104	private SynthContext context;
	105	private String themeName;
	106
	107	private ArithmeticExpressionEvaluator aee = new ArithmeticExpressionEvaluator();
	108	private Map<String, Integer> variables;
	109
	110	// Reusable clip shape object
	111	private RoundRectClipShape roundedClipShape;
	112
	113	protected Metacity(String themeName) throws IOException, ParserConfigurationException, SAXException {
	114	this.themeName = themeName;
	115	themeDir = getThemeDir(themeName);
	116	if (themeDir != null) {
	117	URL themeURL = new URL(themeDir, "metacity-theme-1.xml");
	118	xmlDoc = getXMLDoc(themeURL);
	119	if (xmlDoc == null) {
	120	throw new IOException(themeURL.toString());
	121	}
	122	} else {
	123	throw new FileNotFoundException(themeName);
	124	}
	125
	126	// Initialize constants
	127	variables = new HashMap<String, Integer>();
	128	NodeList nodes = xmlDoc.getElementsByTagName("constant");
	129	int n = nodes.getLength();
	130	for (int i = 0; i < n; i++) {
	131	Node node = nodes.item(i);
	132	String name = getStringAttr(node, "name");
	133	if (name != null) {
	134	String value = getStringAttr(node, "value");
	135	if (value != null) {
	136	try {
	137	variables.put(name, Integer.parseInt(value));
	138	} catch (NumberFormatException ex) {
	139	logError(themeName, ex);
	140	// Ignore bad value
	141	}
	142	}
	143	}
	144	}
	145
	146	// Cache frame geometries
	147	frameGeometries = new HashMap<String, Map<String, Object>>();
	148	nodes = xmlDoc.getElementsByTagName("frame_geometry");
	149	n = nodes.getLength();
	150	for (int i = 0; i < n; i++) {
	151	Node node = nodes.item(i);
	152	String name = getStringAttr(node, "name");
	153	if (name != null) {
	154	HashMap<String, Object> gm = new HashMap<String, Object>();
	155	frameGeometries.put(name, gm);
	156
	157	String parentGM = getStringAttr(node, "parent");
	158	if (parentGM != null) {
	159	gm.putAll(frameGeometries.get(parentGM));
	160	}
	161
	162	gm.put("has_title",
	163	Boolean.valueOf(getBooleanAttr(node, "has_title", true)));
	164	gm.put("rounded_top_left",
	165	Boolean.valueOf(getBooleanAttr(node, "rounded_top_left", false)));
	166	gm.put("rounded_top_right",
	167	Boolean.valueOf(getBooleanAttr(node, "rounded_top_right", false)));
	168	gm.put("rounded_bottom_left",
	169	Boolean.valueOf(getBooleanAttr(node, "rounded_bottom_left", false)));
	170	gm.put("rounded_bottom_right",
	171	Boolean.valueOf(getBooleanAttr(node, "rounded_bottom_right", false)));
	172
	173	NodeList childNodes = node.getChildNodes();
	174	int nc = childNodes.getLength();
	175	for (int j = 0; j < nc; j++) {
	176	Node child = childNodes.item(j);
	177	if (child.getNodeType() == Node.ELEMENT_NODE) {
	178	name = child.getNodeName();
	179	Object value = null;
	180	if ("distance".equals(name)) {
	181	value = Integer.valueOf(getIntAttr(child, "value", 0));
	182	} else if ("border".equals(name)) {
	183	value = new Insets(getIntAttr(child, "top", 0),
	184	getIntAttr(child, "left", 0),
	185	getIntAttr(child, "bottom", 0),
	186	getIntAttr(child, "right", 0));
	187	} else if ("aspect_ratio".equals(name)) {
	188	value = new Float(getFloatAttr(child, "value", 1.0F));
	189	} else {
	190	logError(themeName, "Unknown Metacity frame geometry value type: "+name);
	191	}
	192	String childName = getStringAttr(child, "name");
	193	if (childName != null && value != null) {
	194	gm.put(childName, value);
	195	}
	196	}
	197	}
	198	}
	199	}
	200	frameGeometry = frameGeometries.get("normal");
	201	}
	202
	203
	204	public static LayoutManager getTitlePaneLayout() {
	205	return INSTANCE.titlePaneLayout;
	206	}
	207
	208	private Shape getRoundedClipShape(int x, int y, int w, int h,
	209	int arcw, int arch, int corners) {
	210	if (roundedClipShape == null) {
	211	roundedClipShape = new RoundRectClipShape();
	212	}
	213	roundedClipShape.setRoundedRect(x, y, w, h, arcw, arch, corners);
	214
	215	return roundedClipShape;
	216	}
	217
	218	void paintButtonBackground(SynthContext context, Graphics g, int x, int y, int w, int h) {
	219	updateFrameGeometry(context);
	220
	221	this.context = context;
	222	JButton button = (JButton)context.getComponent();
	223	String buttonName = button.getName();
	224	int buttonState = context.getComponentState();
	225
	226	JComponent titlePane = (JComponent)button.getParent();
	227	Container titlePaneParent = titlePane.getParent();
	228
	229	JInternalFrame jif;
	230	if (titlePaneParent instanceof JInternalFrame) {
	231	jif = (JInternalFrame)titlePaneParent;
	232	} else if (titlePaneParent instanceof JInternalFrame.JDesktopIcon) {
	233	jif = ((JInternalFrame.JDesktopIcon)titlePaneParent).getInternalFrame();
	234	} else {
	235	return;
	236	}
	237
	238	boolean active = jif.isSelected();
	239	button.setOpaque(false);
	240
	241	String state = "normal";
	242	if ((buttonState & PRESSED) != 0) {
	243	state = "pressed";
	244	} else if ((buttonState & MOUSE_OVER) != 0) {
	245	state = "prelight";
	246	}
	247
	248	String function = null;
	249	String location = null;
	250	boolean left_corner = false;
	251	boolean right_corner = false;
	252
	253
	254	if (buttonName == "InternalFrameTitlePane.menuButton") {
	255	function = "menu";
	256	location = "left_left";
	257	left_corner = true;
	258	} else if (buttonName == "InternalFrameTitlePane.iconifyButton") {
	259	function = "minimize";
	260	int nButtons = ((jif.isIconifiable() ? 1 : 0) +
	261	(jif.isMaximizable() ? 1 : 0) +
	262	(jif.isClosable() ? 1 : 0));
	263	right_corner = (nButtons == 1);
	264	switch (nButtons) {
	265	case 1: location = "right_right"; break;
	266	case 2: location = "right_middle"; break;
	267	case 3: location = "right_left"; break;
	268	}
	269	} else if (buttonName == "InternalFrameTitlePane.maximizeButton") {
	270	function = "maximize";
	271	right_corner = !jif.isClosable();
	272	location = jif.isClosable() ? "right_middle" : "right_right";
	273	} else if (buttonName == "InternalFrameTitlePane.closeButton") {
	274	function = "close";
	275	right_corner = true;
	276	location = "right_right";
	277	}
	278
	279	Node frame = getNode(frame_style_set, "frame", new String[] {
	280	"focus", (active ? "yes" : "no"),
	281	"state", (jif.isMaximum() ? "maximized" : "normal")
	282	});
	283
	284	if (function != null && frame != null) {
	285	Node frame_style = getNode("frame_style", new String[] {
	286	"name", getStringAttr(frame, "style")
	287	});
	288	if (frame_style != null) {
	289	Shape oldClip = g.getClip();
	290	if ((right_corner && getBoolean("rounded_top_right", false)) \|\|
	291	(left_corner && getBoolean("rounded_top_left", false))) {
	292
	293	Point buttonLoc = button.getLocation();
	294	if (right_corner) {
	295	g.setClip(getRoundedClipShape(0, 0, w, h,
	296	12, 12, RoundRectClipShape.TOP_RIGHT));
	297	} else {
	298	g.setClip(getRoundedClipShape(0, 0, w, h,
	299	11, 11, RoundRectClipShape.TOP_LEFT));
	300	}
	301
	302	Rectangle clipBounds = oldClip.getBounds();
	303	g.clipRect(clipBounds.x, clipBounds.y,
	304	clipBounds.width, clipBounds.height);
	305	}
	306	drawButton(frame_style, location+"_background", state, g, w, h, jif);
	307	drawButton(frame_style, function, state, g, w, h, jif);
	308	g.setClip(oldClip);
	309	}
	310	}
	311	}
	312
	313	protected void drawButton(Node frame_style, String function, String state,
	314	Graphics g, int w, int h, JInternalFrame jif) {
	315	Node buttonNode = getNode(frame_style, "button",
	316	new String[] { "function", function, "state", state });
	317	if (buttonNode == null && !state.equals("normal")) {
	318	buttonNode = getNode(frame_style, "button",
	319	new String[] { "function", function, "state", "normal" });
	320	}
	321	if (buttonNode != null) {
	322	Node draw_ops;
	323	String draw_ops_name = getStringAttr(buttonNode, "draw_ops");
	324	if (draw_ops_name != null) {
	325	draw_ops = getNode("draw_ops", new String[] { "name", draw_ops_name });
	326	} else {
	327	draw_ops = getNode(buttonNode, "draw_ops", null);
	328	}
	329	variables.put("width", w);
	330	variables.put("height", h);
	331	draw(draw_ops, g, jif);
	332	}
	333	}
	334
	335	void paintFrameBorder(SynthContext context, Graphics g, int x0, int y0, int width, int height) {
	336	updateFrameGeometry(context);
	337
	338	this.context = context;
	339	JComponent comp = context.getComponent();
	340	JComponent titlePane = findChild(comp, "InternalFrame.northPane");
	341
	342	if (titlePane == null) {
	343	return;
	344	}
	345
	346	JInternalFrame jif = null;
	347	if (comp instanceof JInternalFrame) {
	348	jif = (JInternalFrame)comp;
	349	} else if (comp instanceof JInternalFrame.JDesktopIcon) {
	350	jif = ((JInternalFrame.JDesktopIcon)comp).getInternalFrame();
	351	} else {
	352	assert false : "component is not JInternalFrame or JInternalFrame.JDesktopIcon";
	353	return;
	354	}
	355
	356	boolean active = jif.isSelected();
	357	Font oldFont = g.getFont();
	358	g.setFont(titlePane.getFont());
	359	g.translate(x0, y0);
	360
	361	Rectangle titleRect = calculateTitleArea(jif);
	362	JComponent menuButton = findChild(titlePane, "InternalFrameTitlePane.menuButton");
	363
	364	Icon frameIcon = jif.getFrameIcon();
	365	variables.put("mini_icon_width",
	366	(frameIcon != null) ? frameIcon.getIconWidth() : 0);
	367	variables.put("mini_icon_height",
	368	(frameIcon != null) ? frameIcon.getIconHeight() : 0);
	369	variables.put("title_width", calculateTitleTextWidth(g, jif));
	370	FontMetrics fm = SwingUtilities2.getFontMetrics(jif, g);
	371	variables.put("title_height", fm.getAscent() + fm.getDescent());
	372
	373	// These don't seem to apply here, but the Galaxy theme uses them. Not sure why.
	374	variables.put("icon_width", 32);
	375	variables.put("icon_height", 32);
	376
	377	if (frame_style_set != null) {
	378	Node frame = getNode(frame_style_set, "frame", new String[] {
	379	"focus", (active ? "yes" : "no"),
	380	"state", (jif.isMaximum() ? "maximized" : "normal")
	381	});
	382
	383	if (frame != null) {
	384	Node frame_style = getNode("frame_style", new String[] {
	385	"name", getStringAttr(frame, "style")
	386	});
	387	if (frame_style != null) {
	388	Shape oldClip = g.getClip();
	389	boolean roundTopLeft = getBoolean("rounded_top_left", false);
	390	boolean roundTopRight = getBoolean("rounded_top_right", false);
	391	boolean roundBottomLeft = getBoolean("rounded_bottom_left", false);
	392	boolean roundBottomRight = getBoolean("rounded_bottom_right", false);
	393
	394	if (roundTopLeft \|\| roundTopRight \|\| roundBottomLeft \|\| roundBottomRight) {
	395	jif.setOpaque(false);
	396
	397	g.setClip(getRoundedClipShape(0, 0, width, height, 12, 12,
	398	(roundTopLeft ? RoundRectClipShape.TOP_LEFT : 0) \|
	399	(roundTopRight ? RoundRectClipShape.TOP_RIGHT : 0) \|
	400	(roundBottomLeft ? RoundRectClipShape.BOTTOM_LEFT : 0) \|
	401	(roundBottomRight ? RoundRectClipShape.BOTTOM_RIGHT : 0)));
	402	}
	403
	404	Rectangle clipBounds = oldClip.getBounds();
	405	g.clipRect(clipBounds.x, clipBounds.y,
	406	clipBounds.width, clipBounds.height);
	407
	408	int titleHeight = titlePane.getHeight();
	409
	410	boolean minimized = jif.isIcon();
	411	Insets insets = getBorderInsets(context, null);
	412
	413	int leftTitlebarEdge = getInt("left_titlebar_edge");
	414	int rightTitlebarEdge = getInt("right_titlebar_edge");
	415	int topTitlebarEdge = getInt("top_titlebar_edge");
	416	int bottomTitlebarEdge = getInt("bottom_titlebar_edge");
	417
	418	if (!minimized) {
	419	drawPiece(frame_style, g, "entire_background",
	420	0, 0, width, height, jif);
	421	}
	422	drawPiece(frame_style, g, "titlebar",
	423	0, 0, width, titleHeight, jif);
	424	drawPiece(frame_style, g, "titlebar_middle",
	425	leftTitlebarEdge, topTitlebarEdge,
	426	width - leftTitlebarEdge - rightTitlebarEdge,
	427	titleHeight - topTitlebarEdge - bottomTitlebarEdge,
	428	jif);
	429	drawPiece(frame_style, g, "left_titlebar_edge",
	430	0, 0, leftTitlebarEdge, titleHeight, jif);
	431	drawPiece(frame_style, g, "right_titlebar_edge",
	432	width - rightTitlebarEdge, 0,
	433	rightTitlebarEdge, titleHeight, jif);
	434	drawPiece(frame_style, g, "top_titlebar_edge",
	435	0, 0, width, topTitlebarEdge, jif);
	436	drawPiece(frame_style, g, "bottom_titlebar_edge",
	437	0, titleHeight - bottomTitlebarEdge,
	438	width, bottomTitlebarEdge, jif);
	439	drawPiece(frame_style, g, "title",
	440	titleRect.x, titleRect.y, titleRect.width, titleRect.height, jif);
	441	if (!minimized) {
	442	drawPiece(frame_style, g, "left_edge",
	443	0, titleHeight, insets.left, height-titleHeight, jif);
	444	drawPiece(frame_style, g, "right_edge",
	445	width-insets.right, titleHeight, insets.right, height-titleHeight, jif);
	446	drawPiece(frame_style, g, "bottom_edge",
	447	0, height - insets.bottom, width, insets.bottom, jif);
	448	drawPiece(frame_style, g, "overlay",
	449	0, 0, width, height, jif);
	450	}
	451	g.setClip(oldClip);
	452	}
	453	}
	454	}
	455	g.translate(-x0, -y0);
	456	g.setFont(oldFont);
	457	}
	458
	459
	460
	461	private static class Privileged implements PrivilegedAction<Object> {
	462	private static int GET_THEME_DIR = 0;
	463	private static int GET_USER_THEME = 1;
	464	private static int GET_IMAGE = 2;
	465	private int type;
	466	private Object arg;
	467
	468	public Object doPrivileged(int type, Object arg) {
	469	this.type = type;
	470	this.arg = arg;
	471	return AccessController.doPrivileged(this);
	472	}
	473
	474	public Object run() {
	475	if (type == GET_THEME_DIR) {
	476	String sep = File.separator;
	477	String[] dirs = new String[] {
	478	userHome + sep + ".themes",
	479	System.getProperty("swing.metacitythemedir"),
	480	"/usr/share/themes",
	481	"/usr/gnome/share/themes", // Debian/Redhat/Solaris
	482	"/opt/gnome2/share/themes" // SuSE
	483	};
	484
	485	URL themeDir = null;
	486	for (int i = 0; i < dirs.length; i++) {
	487	// System property may not be set so skip null directories.
	488	if (dirs[i] == null) {
	489	continue;
	490	}
	491	File dir =
	492	new File(dirs[i] + sep + arg + sep + "metacity-1");
	493	if (new File(dir, "metacity-theme-1.xml").canRead()) {
	494	try {
	495	themeDir = dir.toURI().toURL();
	496	} catch (MalformedURLException ex) {
	497	themeDir = null;
	498	}
	499	break;
	500	}
	501	}
	502	if (themeDir == null) {
	503	String filename = "resources/metacity/" + arg +
	504	"/metacity-1/metacity-theme-1.xml";
	505	URL url = getClass().getResource(filename);
	506	if (url != null) {
	507	String str = url.toString();
	508	try {
	509	themeDir = new URL(str.substring(0, str.lastIndexOf('/'))+"/");
	510	} catch (MalformedURLException ex) {
	511	themeDir = null;
	512	}
	513	}
	514	}
	515	return themeDir;
	516	} else if (type == GET_USER_THEME) {
	517	try {
	518	// Set userHome here because we need the privilege
	519	userHome = System.getProperty("user.home");
	520
	521	String theme = System.getProperty("swing.metacitythemename");
	522	if (theme != null) {
	523	return theme;
	524	}
	525	// Note: this is a small file (< 1024 bytes) so it's not worth
	526	// starting an XML parser or even to use a buffered reader.
	527	URL url = new URL(new File(userHome).toURI().toURL(),
	528	".gconf/apps/metacity/general/%25gconf.xml");
	529	// Pending: verify character encoding spec for gconf
	530	Reader reader = new InputStreamReader(url.openStream(), "ISO-8859-1");
	531	char[] buf = new char[1024];
	532	StringBuffer strBuf = new StringBuffer();
	533	int n;
	534	while ((n = reader.read(buf)) >= 0) {
	535	strBuf.append(buf, 0, n);
	536	}
	537	reader.close();
	538	String str = strBuf.toString();
	539	if (str != null) {
	540	String strLowerCase = str.toLowerCase();
	541	int i = strLowerCase.indexOf("<entry name=\"theme\"");
	542	if (i >= 0) {
	543	i = strLowerCase.indexOf("<stringvalue>", i);
	544	if (i > 0) {
	545	i += "<stringvalue>".length();
	546	int i2 = str.indexOf("<", i);
	547	return str.substring(i, i2);
	548	}
	549	}
	550	}
	551	} catch (MalformedURLException ex) {
	552	// OK to just ignore. We'll use a fallback theme.
	553	} catch (IOException ex) {
	554	// OK to just ignore. We'll use a fallback theme.
	555	}
	556	return null;
	557	} else if (type == GET_IMAGE) {
	558	return new ImageIcon((URL)arg).getImage();
	559	} else {
	560	return null;
	561	}
	562	}
	563	}
	564
	565	private static URL getThemeDir(String themeName) {
	566	return (URL)new Privileged().doPrivileged(Privileged.GET_THEME_DIR, themeName);
	567	}
	568
	569	private static String getUserTheme() {
	570	return (String)new Privileged().doPrivileged(Privileged.GET_USER_THEME, null);
	571	}
	572
	573	protected void tileImage(Graphics g, Image image, int x0, int y0, int w, int h, float[] alphas) {
	574	Graphics2D g2 = (Graphics2D)g;
	575	Composite oldComp = g2.getComposite();
	576
	577	int sw = image.getWidth(null);
	578	int sh = image.getHeight(null);
	579	int y = y0;
	580	while (y < y0 + h) {
	581	sh = Math.min(sh, y0 + h - y);
	582	int x = x0;
	583	while (x < x0 + w) {
	584	float f = (alphas.length - 1.0F) * x / (x0 + w);
	585	int i = (int)f;
	586	f -= (int)f;
	587	float alpha = (1-f) * alphas[i];
	588	if (i+1 < alphas.length) {
	589	alpha += f * alphas[i+1];
	590	}
	591	g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha));
	592	int swm = Math.min(sw, x0 + w - x);
	593	g.drawImage(image, x, y, x+swm, y+sh, 0, 0, swm, sh, null);
	594	x += swm;
	595	}
	596	y += sh;
	597	}
	598	g2.setComposite(oldComp);
	599	}
	600
	601	private HashMap<String, Image> images = new HashMap<String, Image>();
	602
	603	protected Image getImage(String key, Color c) {
	604	Image image = images.get(key+"-"+c.getRGB());
	605	if (image == null) {
	606	image = imageFilter.colorize(getImage(key), c);
	607	if (image != null) {
	608	images.put(key+"-"+c.getRGB(), image);
	609	}
	610	}
	611	return image;
	612	}
	613
	614	protected Image getImage(String key) {
	615	Image image = images.get(key);
	616	if (image == null) {
	617	if (themeDir != null) {
	618	try {
	619	URL url = new URL(themeDir, key);
	620	image = (Image)new Privileged().doPrivileged(Privileged.GET_IMAGE, url);
	621	} catch (MalformedURLException ex) {
	622	//log("Bad image url: "+ themeDir + "/" + key);
	623	}
	624	}
	625	if (image != null) {
	626	images.put(key, image);
	627	}
	628	}
	629	return image;
	630	}
	631
	632	private class ColorizeImageFilter extends RGBImageFilter {
	633	double cr, cg, cb;
	634
	635	public ColorizeImageFilter() {
	636	canFilterIndexColorModel = true;
	637	}
	638
	639	public void setColor(Color color) {
	640	cr = color.getRed() / 255.0;
	641	cg = color.getGreen() / 255.0;
	642	cb = color.getBlue() / 255.0;
	643	}
	644
	645	public Image colorize(Image fromImage, Color c) {
	646	setColor(c);
	647	ImageProducer producer = new FilteredImageSource(fromImage.getSource(), this);
	648	return new ImageIcon(context.getComponent().createImage(producer)).getImage();
	649	}
	650
	651	public int filterRGB(int x, int y, int rgb) {
	652	// Assume all rgb values are shades of gray
	653	double grayLevel = 2 * (rgb & 0xff) / 255.0;
	654	double r, g, b;
	655
	656	if (grayLevel <= 1.0) {
	657	r = cr * grayLevel;
	658	g = cg * grayLevel;
	659	b = cb * grayLevel;
	660	} else {
	661	grayLevel -= 1.0;
	662	r = cr + (1.0 - cr) * grayLevel;
	663	g = cg + (1.0 - cg) * grayLevel;
	664	b = cb + (1.0 - cb) * grayLevel;
	665	}
	666
	667	return ((rgb & 0xff000000) +
	668	(((int)(r * 255)) << 16) +
	669	(((int)(g * 255)) << 8) +
	670	(int)(b * 255));
	671	}
	672	}
	673
	674	protected static JComponent findChild(JComponent parent, String name) {
	675	int n = parent.getComponentCount();
	676	for (int i = 0; i < n; i++) {
	677	JComponent c = (JComponent)parent.getComponent(i);
	678	if (name.equals(c.getName())) {
	679	return c;
	680	}
	681	}
	682	return null;
	683	}
	684
	685
	686	protected class TitlePaneLayout implements LayoutManager {
	687	public void addLayoutComponent(String name, Component c) {}
	688	public void removeLayoutComponent(Component c) {}
	689	public Dimension preferredLayoutSize(Container c) {
	690	return minimumLayoutSize(c);
	691	}
	692
	693	public Dimension minimumLayoutSize(Container c) {
	694	JComponent titlePane = (JComponent)c;
	695	Container titlePaneParent = titlePane.getParent();
	696	JInternalFrame frame;
	697	if (titlePaneParent instanceof JInternalFrame) {
	698	frame = (JInternalFrame)titlePaneParent;
	699	} else if (titlePaneParent instanceof JInternalFrame.JDesktopIcon) {
	700	frame = ((JInternalFrame.JDesktopIcon)titlePaneParent).getInternalFrame();
	701	} else {
	702	return null;
	703	}
	704
	705	Dimension buttonDim = calculateButtonSize(titlePane);
	706	Insets title_border = (Insets)getFrameGeometry().get("title_border");
	707	Insets button_border = (Insets)getFrameGeometry().get("button_border");
	708
	709	// Calculate width.
	710	int width = getInt("left_titlebar_edge") + buttonDim.width + getInt("right_titlebar_edge");
	711	if (title_border != null) {
	712	width += title_border.left + title_border.right;
	713	}
	714	if (frame.isClosable()) {
	715	width += buttonDim.width;
	716	}
	717	if (frame.isMaximizable()) {
	718	width += buttonDim.width;
	719	}
	720	if (frame.isIconifiable()) {
	721	width += buttonDim.width;
	722	}
	723	FontMetrics fm = frame.getFontMetrics(titlePane.getFont());
	724	String frameTitle = frame.getTitle();
	725	int title_w = frameTitle != null ? SwingUtilities2.stringWidth(
	726	frame, fm, frameTitle) : 0;
	727	int title_length = frameTitle != null ? frameTitle.length() : 0;
	728
	729	// Leave room for three characters in the title.
	730	if (title_length > 3) {
	731	int subtitle_w = SwingUtilities2.stringWidth(
	732	frame, fm, frameTitle.substring(0, 3) + "...");
	733	width += (title_w < subtitle_w) ? title_w : subtitle_w;
	734	} else {
	735	width += title_w;
	736	}
	737
	738	// Calculate height.
	739	int titleHeight = fm.getHeight() + getInt("title_vertical_pad");
	740	if (title_border != null) {
	741	titleHeight += title_border.top + title_border.bottom;
	742	}
	743	int buttonHeight = buttonDim.height;
	744	if (button_border != null) {
	745	buttonHeight += button_border.top + button_border.bottom;
	746	}
	747	int height = Math.max(buttonHeight, titleHeight);
	748
	749	return new Dimension(width, height);
	750	}
	751
	752	public void layoutContainer(Container c) {
	753	JComponent titlePane = (JComponent)c;
	754	Container titlePaneParent = titlePane.getParent();
	755	JInternalFrame frame;
	756	if (titlePaneParent instanceof JInternalFrame) {
	757	frame = (JInternalFrame)titlePaneParent;
	758	} else if (titlePaneParent instanceof JInternalFrame.JDesktopIcon) {
	759	frame = ((JInternalFrame.JDesktopIcon)titlePaneParent).getInternalFrame();
	760	} else {
	761	return;
	762	}
	763	Map gm = getFrameGeometry();
	764
	765	int w = titlePane.getWidth();
	766	int h = titlePane.getHeight();
	767
	768	JComponent menuButton = findChild(titlePane, "InternalFrameTitlePane.menuButton");
	769	JComponent minimizeButton = findChild(titlePane, "InternalFrameTitlePane.iconifyButton");
	770	JComponent maximizeButton = findChild(titlePane, "InternalFrameTitlePane.maximizeButton");
	771	JComponent closeButton = findChild(titlePane, "InternalFrameTitlePane.closeButton");
	772
	773	Insets button_border = (Insets)gm.get("button_border");
	774	Dimension buttonDim = calculateButtonSize(titlePane);
	775
	776	int y = (button_border != null) ? button_border.top : 0;
	777	if (titlePaneParent.getComponentOrientation().isLeftToRight()) {
	778	int x = getInt("left_titlebar_edge");
	779
	780	menuButton.setBounds(x, y, buttonDim.width, buttonDim.height);
	781
	782	x = w - buttonDim.width - getInt("right_titlebar_edge");
	783	if (button_border != null) {
	784	x -= button_border.right;
	785	}
	786
	787	if (frame.isClosable()) {
	788	closeButton.setBounds(x, y, buttonDim.width, buttonDim.height);
	789	x -= buttonDim.width;
	790	}
	791
	792	if (frame.isMaximizable()) {
	793	maximizeButton.setBounds(x, y, buttonDim.width, buttonDim.height);
	794	x -= buttonDim.width;
	795	}
	796
	797	if (frame.isIconifiable()) {
	798	minimizeButton.setBounds(x, y, buttonDim.width, buttonDim.height);
	799	}
	800	} else {
	801	int x = w - buttonDim.width - getInt("right_titlebar_edge");
	802
	803	menuButton.setBounds(x, y, buttonDim.width, buttonDim.height);
	804
	805	x = getInt("left_titlebar_edge");
	806	if (button_border != null) {
	807	x += button_border.left;
	808	}
	809
	810	if (frame.isClosable()) {
	811	closeButton.setBounds(x, y, buttonDim.width, buttonDim.height);
	812	x += buttonDim.width;
	813	}
	814
	815	if (frame.isMaximizable()) {
	816	maximizeButton.setBounds(x, y, buttonDim.width, buttonDim.height);
	817	x += buttonDim.width;
	818	}
	819
	820	if (frame.isIconifiable()) {
	821	minimizeButton.setBounds(x, y, buttonDim.width, buttonDim.height);
	822	}
	823	}
	824	}
	825	} // end TitlePaneLayout
	826
	827	protected Map getFrameGeometry() {
	828	return frameGeometry;
	829	}
	830
	831	protected void setFrameGeometry(JComponent titlePane, Map gm) {
	832	this.frameGeometry = gm;
	833	if (getInt("top_height") == 0 && titlePane != null) {
	834	gm.put("top_height", Integer.valueOf(titlePane.getHeight()));
	835	}
	836	}
	837
	838	protected int getInt(String key) {
	839	Integer i = (Integer)frameGeometry.get(key);
	840	if (i == null) {
	841	i = variables.get(key);
	842	}
	843	return (i != null) ? i.intValue() : 0;
	844	}
	845
	846	protected boolean getBoolean(String key, boolean fallback) {
	847	Boolean b = (Boolean)frameGeometry.get(key);
	848	return (b != null) ? b.booleanValue() : fallback;
	849	}
	850
	851
	852	protected void drawArc(Node node, Graphics g) {
	853	NamedNodeMap attrs = node.getAttributes();
	854	Color color = parseColor(getStringAttr(attrs, "color"));
	855	int x = aee.evaluate(getStringAttr(attrs, "x"));
	856	int y = aee.evaluate(getStringAttr(attrs, "y"));
	857	int w = aee.evaluate(getStringAttr(attrs, "width"));
	858	int h = aee.evaluate(getStringAttr(attrs, "height"));
	859	int start_angle = aee.evaluate(getStringAttr(attrs, "start_angle"));
	860	int extent_angle = aee.evaluate(getStringAttr(attrs, "extent_angle"));
	861	boolean filled = getBooleanAttr(node, "filled", false);
	862	if (getInt("width") == -1) {
	863	x -= w;
	864	}
	865	if (getInt("height") == -1) {
	866	y -= h;
	867	}
	868	g.setColor(color);
	869	if (filled) {
	870	g.fillArc(x, y, w, h, start_angle, extent_angle);
	871	} else {
	872	g.drawArc(x, y, w, h, start_angle, extent_angle);
	873	}
	874	}
	875
	876	protected void drawLine(Node node, Graphics g) {
	877	NamedNodeMap attrs = node.getAttributes();
	878	Color color = parseColor(getStringAttr(attrs, "color"));
	879	int x1 = aee.evaluate(getStringAttr(attrs, "x1"));
	880	int y1 = aee.evaluate(getStringAttr(attrs, "y1"));
	881	int x2 = aee.evaluate(getStringAttr(attrs, "x2"));
	882	int y2 = aee.evaluate(getStringAttr(attrs, "y2"));
	883	int lineWidth = aee.evaluate(getStringAttr(attrs, "width"), 1);
	884	g.setColor(color);
	885	if (lineWidth != 1) {
	886	Graphics2D g2d = (Graphics2D)g;
	887	Stroke stroke = g2d.getStroke();
	888	g2d.setStroke(new BasicStroke((float)lineWidth));
	889	g2d.drawLine(x1, y1, x2, y2);
	890	g2d.setStroke(stroke);
	891	} else {
	892	g.drawLine(x1, y1, x2, y2);
	893	}
	894	}
	895
	896	protected void drawRectangle(Node node, Graphics g) {
	897	NamedNodeMap attrs = node.getAttributes();
	898	Color color = parseColor(getStringAttr(attrs, "color"));
	899	boolean filled = getBooleanAttr(node, "filled", false);
	900	int x = aee.evaluate(getStringAttr(attrs, "x"));
	901	int y = aee.evaluate(getStringAttr(attrs, "y"));
	902	int w = aee.evaluate(getStringAttr(attrs, "width"));
	903	int h = aee.evaluate(getStringAttr(attrs, "height"));
	904	g.setColor(color);
	905	if (getInt("width") == -1) {
	906	x -= w;
	907	}
	908	if (getInt("height") == -1) {
	909	y -= h;
	910	}
	911	if (filled) {
	912	g.fillRect(x, y, w, h);
	913	} else {
	914	g.drawRect(x, y, w, h);
	915	}
	916	}
	917
	918	protected void drawTile(Node node, Graphics g, JInternalFrame jif) {
	919	NamedNodeMap attrs = node.getAttributes();
	920	int x0 = aee.evaluate(getStringAttr(attrs, "x"));
	921	int y0 = aee.evaluate(getStringAttr(attrs, "y"));
	922	int w = aee.evaluate(getStringAttr(attrs, "width"));
	923	int h = aee.evaluate(getStringAttr(attrs, "height"));
	924	int tw = aee.evaluate(getStringAttr(attrs, "tile_width"));
	925	int th = aee.evaluate(getStringAttr(attrs, "tile_height"));
	926	int width = getInt("width");
	927	int height = getInt("height");
	928	if (width == -1) {
	929	x0 -= w;
	930	}
	931	if (height == -1) {
	932	y0 -= h;
	933	}
	934	Shape oldClip = g.getClip();
	935	if (g instanceof Graphics2D) {
	936	((Graphics2D)g).clip(new Rectangle(x0, y0, w, h));
	937	}
	938	variables.put("width", tw);
	939	variables.put("height", th);
	940
	941	Node draw_ops = getNode("draw_ops", new String[] { "name", getStringAttr(node, "name") });
	942
	943	int y = y0;
	944	while (y < y0 + h) {
	945	int x = x0;
	946	while (x < x0 + w) {
	947	g.translate(x, y);
	948	draw(draw_ops, g, jif);
	949	g.translate(-x, -y);
	950	x += tw;
	951	}
	952	y += th;
	953	}
	954
	955	variables.put("width", width);
	956	variables.put("height", height);
	957	g.setClip(oldClip);
	958	}
	959
	960	protected void drawTint(Node node, Graphics g) {
	961	NamedNodeMap attrs = node.getAttributes();
	962	Color color = parseColor(getStringAttr(attrs, "color"));
	963	float alpha = Float.parseFloat(getStringAttr(attrs, "alpha"));
	964	int x = aee.evaluate(getStringAttr(attrs, "x"));
	965	int y = aee.evaluate(getStringAttr(attrs, "y"));
	966	int w = aee.evaluate(getStringAttr(attrs, "width"));
	967	int h = aee.evaluate(getStringAttr(attrs, "height"));
	968	if (getInt("width") == -1) {
	969	x -= w;
	970	}
	971	if (getInt("height") == -1) {
	972	y -= h;
	973	}
	974	if (g instanceof Graphics2D) {
	975	Graphics2D g2 = (Graphics2D)g;
	976	Composite oldComp = g2.getComposite();
	977	AlphaComposite ac = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha);
	978	g2.setComposite(ac);
	979	g2.setColor(color);
	980	g2.fillRect(x, y, w, h);
	981	g2.setComposite(oldComp);
	982	}
	983	}
	984
	985	protected void drawTitle(Node node, Graphics g, JInternalFrame jif) {
	986	NamedNodeMap attrs = node.getAttributes();
	987	String colorStr = getStringAttr(attrs, "color");
	988	int i = colorStr.indexOf("gtk:fg[");
	989	if (i > 0) {
	990	colorStr = colorStr.substring(0, i) + "gtk:text[" + colorStr.substring(i+7);
	991	}
	992	Color color = parseColor(colorStr);
	993	int x = aee.evaluate(getStringAttr(attrs, "x"));
	994	int y = aee.evaluate(getStringAttr(attrs, "y"));
	995
	996	String title = jif.getTitle();
	997	if (title != null) {
	998	FontMetrics fm = SwingUtilities2.getFontMetrics(jif, g);
	999	title = SwingUtilities2.clipStringIfNecessary(jif, fm, title,
	1000	calculateTitleArea(jif).width);
	1001	g.setColor(color);
	1002	SwingUtilities2.drawString(jif, g, title, x, y + fm.getAscent());
	1003	}
	1004	}
	1005
	1006	protected Dimension calculateButtonSize(JComponent titlePane) {
	1007	int buttonHeight = getInt("button_height");
	1008	if (buttonHeight == 0) {
	1009	buttonHeight = titlePane.getHeight();
	1010	if (buttonHeight == 0) {
	1011	buttonHeight = 13;
	1012	} else {
	1013	Insets button_border = (Insets)frameGeometry.get("button_border");
	1014	if (button_border != null) {
	1015	buttonHeight -= (button_border.top + button_border.bottom);
	1016	}
	1017	}
	1018	}
	1019	int buttonWidth = getInt("button_width");
	1020	if (buttonWidth == 0) {
	1021	buttonWidth = buttonHeight;
	1022	Float aspect_ratio = (Float)frameGeometry.get("aspect_ratio");
	1023	if (aspect_ratio != null) {
	1024	buttonWidth = (int)(buttonHeight / aspect_ratio.floatValue());
	1025	}
	1026	}
	1027	return new Dimension(buttonWidth, buttonHeight);
	1028	}
	1029
	1030	protected Rectangle calculateTitleArea(JInternalFrame jif) {
	1031	JComponent titlePane = findChild(jif, "InternalFrame.northPane");
	1032	Dimension buttonDim = calculateButtonSize(titlePane);
	1033	Insets title_border = (Insets)frameGeometry.get("title_border");
	1034	Insets button_border = (Insets)getFrameGeometry().get("button_border");
	1035
	1036	Rectangle r = new Rectangle();
	1037	r.x = getInt("left_titlebar_edge");
	1038	r.y = 0;
	1039	r.height = titlePane.getHeight();
	1040	if (title_border != null) {
	1041	r.x += title_border.left;
	1042	r.y += title_border.top;
	1043	r.height -= (title_border.top + title_border.bottom);
	1044	}
	1045
	1046	if (titlePane.getParent().getComponentOrientation().isLeftToRight()) {
	1047	r.x += buttonDim.width;
	1048	if (button_border != null) {
	1049	r.x += button_border.left;
	1050	}
	1051	r.width = titlePane.getWidth() - r.x - getInt("right_titlebar_edge");
	1052	if (jif.isClosable()) {
	1053	r.width -= buttonDim.width;
	1054	}
	1055	if (jif.isMaximizable()) {
	1056	r.width -= buttonDim.width;
	1057	}
	1058	if (jif.isIconifiable()) {
	1059	r.width -= buttonDim.width;
	1060	}
	1061	} else {
	1062	if (jif.isClosable()) {
	1063	r.x += buttonDim.width;
	1064	}
	1065	if (jif.isMaximizable()) {
	1066	r.x += buttonDim.width;
	1067	}
	1068	if (jif.isIconifiable()) {
	1069	r.x += buttonDim.width;
	1070	}
	1071	r.width = titlePane.getWidth() - r.x - getInt("right_titlebar_edge")
	1072	- buttonDim.width;
	1073	if (button_border != null) {
	1074	r.x -= button_border.right;
	1075	}
	1076	}
	1077	if (title_border != null) {
	1078	r.width -= title_border.right;
	1079	}
	1080	return r;
	1081	}
	1082
	1083
	1084	protected int calculateTitleTextWidth(Graphics g, JInternalFrame jif) {
	1085	String title = jif.getTitle();
	1086	if (title != null) {
	1087	Rectangle r = calculateTitleArea(jif);
	1088	return Math.min(SwingUtilities2.stringWidth(jif,
	1089	SwingUtilities2.getFontMetrics(jif, g), title), r.width);
	1090	}
	1091	return 0;
	1092	}
	1093
	1094	protected void setClip(Node node, Graphics g) {
	1095	NamedNodeMap attrs = node.getAttributes();
	1096	int x = aee.evaluate(getStringAttr(attrs, "x"));
	1097	int y = aee.evaluate(getStringAttr(attrs, "y"));
	1098	int w = aee.evaluate(getStringAttr(attrs, "width"));
	1099	int h = aee.evaluate(getStringAttr(attrs, "height"));
	1100	if (getInt("width") == -1) {
	1101	x -= w;
	1102	}
	1103	if (getInt("height") == -1) {
	1104	y -= h;
	1105	}
	1106	if (g instanceof Graphics2D) {
	1107	((Graphics2D)g).clip(new Rectangle(x, y, w, h));
	1108	}
	1109	}
	1110
	1111	protected void drawGTKArrow(Node node, Graphics g) {
	1112	NamedNodeMap attrs = node.getAttributes();
	1113	String arrow = getStringAttr(attrs, "arrow");
	1114	String shadow = getStringAttr(attrs, "shadow");
	1115	String stateStr = getStringAttr(attrs, "state").toUpperCase();
	1116	int x = aee.evaluate(getStringAttr(attrs, "x"));
	1117	int y = aee.evaluate(getStringAttr(attrs, "y"));
	1118	int w = aee.evaluate(getStringAttr(attrs, "width"));
	1119	int h = aee.evaluate(getStringAttr(attrs, "height"));
	1120
	1121	int state = -1;
	1122	if ("NORMAL".equals(stateStr)) {
	1123	state = ENABLED;
	1124	} else if ("SELECTED".equals(stateStr)) {
	1125	state = SELECTED;
	1126	} else if ("INSENSITIVE".equals(stateStr)) {
	1127	state = DISABLED;
	1128	} else if ("PRELIGHT".equals(stateStr)) {
	1129	state = MOUSE_OVER;
	1130	}
	1131
	1132	ShadowType shadowType = null;
	1133	if ("in".equals(shadow)) {
	1134	shadowType = ShadowType.IN;
	1135	} else if ("out".equals(shadow)) {
	1136	shadowType = ShadowType.OUT;
	1137	} else if ("etched_in".equals(shadow)) {
	1138	shadowType = ShadowType.ETCHED_IN;
	1139	} else if ("etched_out".equals(shadow)) {
	1140	shadowType = ShadowType.ETCHED_OUT;
	1141	} else if ("none".equals(shadow)) {
	1142	shadowType = ShadowType.NONE;
	1143	}
	1144
	1145	ArrowType direction = null;
	1146	if ("up".equals(arrow)) {
	1147	direction = ArrowType.UP;
	1148	} else if ("down".equals(arrow)) {
	1149	direction = ArrowType.DOWN;
	1150	} else if ("left".equals(arrow)) {
	1151	direction = ArrowType.LEFT;
	1152	} else if ("right".equals(arrow)) {
	1153	direction = ArrowType.RIGHT;
	1154	}
	1155
	1156	GTKPainter.INSTANCE.paintMetacityElement(context, g, state,
	1157	"metacity-arrow", x, y, w, h, shadowType, direction);
	1158	}
	1159
	1160	protected void drawGTKBox(Node node, Graphics g) {
	1161	NamedNodeMap attrs = node.getAttributes();
	1162	String shadow = getStringAttr(attrs, "shadow");
	1163	String stateStr = getStringAttr(attrs, "state").toUpperCase();
	1164	int x = aee.evaluate(getStringAttr(attrs, "x"));
	1165	int y = aee.evaluate(getStringAttr(attrs, "y"));
	1166	int w = aee.evaluate(getStringAttr(attrs, "width"));
	1167	int h = aee.evaluate(getStringAttr(attrs, "height"));
	1168
	1169	int state = -1;
	1170	if ("NORMAL".equals(stateStr)) {
	1171	state = ENABLED;
	1172	} else if ("SELECTED".equals(stateStr)) {
	1173	state = SELECTED;
	1174	} else if ("INSENSITIVE".equals(stateStr)) {
	1175	state = DISABLED;
	1176	} else if ("PRELIGHT".equals(stateStr)) {
	1177	state = MOUSE_OVER;
	1178	}
	1179
	1180	ShadowType shadowType = null;
	1181	if ("in".equals(shadow)) {
	1182	shadowType = ShadowType.IN;
	1183	} else if ("out".equals(shadow)) {
	1184	shadowType = ShadowType.OUT;
	1185	} else if ("etched_in".equals(shadow)) {
	1186	shadowType = ShadowType.ETCHED_IN;
	1187	} else if ("etched_out".equals(shadow)) {
	1188	shadowType = ShadowType.ETCHED_OUT;
	1189	} else if ("none".equals(shadow)) {
	1190	shadowType = ShadowType.NONE;
	1191	}
	1192	GTKPainter.INSTANCE.paintMetacityElement(context, g, state,
	1193	"metacity-box", x, y, w, h, shadowType, null);
	1194	}
	1195
	1196	protected void drawGTKVLine(Node node, Graphics g) {
	1197	NamedNodeMap attrs = node.getAttributes();
	1198	String stateStr = getStringAttr(attrs, "state").toUpperCase();
	1199
	1200	int x = aee.evaluate(getStringAttr(attrs, "x"));
	1201	int y1 = aee.evaluate(getStringAttr(attrs, "y1"));
	1202	int y2 = aee.evaluate(getStringAttr(attrs, "y2"));
	1203
	1204	int state = -1;
	1205	if ("NORMAL".equals(stateStr)) {
	1206	state = ENABLED;
	1207	} else if ("SELECTED".equals(stateStr)) {
	1208	state = SELECTED;
	1209	} else if ("INSENSITIVE".equals(stateStr)) {
	1210	state = DISABLED;
	1211	} else if ("PRELIGHT".equals(stateStr)) {
	1212	state = MOUSE_OVER;
	1213	}
	1214
	1215	GTKPainter.INSTANCE.paintMetacityElement(context, g, state,
	1216	"metacity-vline", x, y1, 1, y2 - y1, null, null);
	1217	}
	1218
	1219	protected void drawGradient(Node node, Graphics g) {
	1220	NamedNodeMap attrs = node.getAttributes();
	1221	String type = getStringAttr(attrs, "type");
	1222	float alpha = getFloatAttr(node, "alpha", -1F);
	1223	int x = aee.evaluate(getStringAttr(attrs, "x"));
	1224	int y = aee.evaluate(getStringAttr(attrs, "y"));
	1225	int w = aee.evaluate(getStringAttr(attrs, "width"));
	1226	int h = aee.evaluate(getStringAttr(attrs, "height"));
	1227	if (getInt("width") == -1) {
	1228	x -= w;
	1229	}
	1230	if (getInt("height") == -1) {
	1231	y -= h;
	1232	}
	1233
	1234	// Get colors from child nodes
	1235	Node[] colorNodes = getNodesByName(node, "color");
	1236	Color[] colors = new Color[colorNodes.length];
	1237	for (int i = 0; i < colorNodes.length; i++) {
	1238	colors[i] = parseColor(getStringAttr(colorNodes[i], "value"));
	1239	}
	1240
	1241	boolean horizontal = ("diagonal".equals(type) \|\| "horizontal".equals(type));
	1242	boolean vertical = ("diagonal".equals(type) \|\| "vertical".equals(type));
	1243
	1244	if (g instanceof Graphics2D) {
	1245	Graphics2D g2 = (Graphics2D)g;
	1246	Composite oldComp = g2.getComposite();
	1247	if (alpha >= 0F) {
	1248	g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha));
	1249	}
	1250	int n = colors.length - 1;
	1251	for (int i = 0; i < n; i++) {
	1252	g2.setPaint(new GradientPaint(x + (horizontal ? (i*w/n) : 0),
	1253	y + (vertical ? (i*h/n) : 0),
	1254	colors[i],
	1255	x + (horizontal ? ((i+1)*w/n) : 0),
	1256	y + (vertical ? ((i+1)*h/n) : 0),
	1257	colors[i+1]));
	1258	g2.fillRect(x + (horizontal ? (i*w/n) : 0),
	1259	y + (vertical ? (i*h/n) : 0),
	1260	(horizontal ? (w/n) : w),
	1261	(vertical ? (h/n) : h));
	1262	}
	1263	g2.setComposite(oldComp);
	1264	}
	1265	}
	1266
	1267	protected void drawImage(Node node, Graphics g) {
	1268	NamedNodeMap attrs = node.getAttributes();
	1269	String filename = getStringAttr(attrs, "filename");
	1270	String colorizeStr = getStringAttr(attrs, "colorize");
	1271	Color colorize = (colorizeStr != null) ? parseColor(colorizeStr) : null;
	1272	String alpha = getStringAttr(attrs, "alpha");
	1273	Image object = (colorize != null) ? getImage(filename, colorize) : getImage(filename);
	1274	variables.put("object_width", object.getWidth(null));
	1275	variables.put("object_height", object.getHeight(null));
	1276	String fill_type = getStringAttr(attrs, "fill_type");
	1277	int x = aee.evaluate(getStringAttr(attrs, "x"));
	1278	int y = aee.evaluate(getStringAttr(attrs, "y"));
	1279	int w = aee.evaluate(getStringAttr(attrs, "width"));
	1280	int h = aee.evaluate(getStringAttr(attrs, "height"));
	1281	if (getInt("width") == -1) {
	1282	x -= w;
	1283	}
	1284	if (getInt("height") == -1) {
	1285	y -= h;
	1286	}
	1287
	1288	if (alpha != null) {
	1289	if ("tile".equals(fill_type)) {
	1290	StringTokenizer tokenizer = new StringTokenizer(alpha, ":");
	1291	float[] alphas = new float[tokenizer.countTokens()];
	1292	for (int i = 0; i < alphas.length; i++) {
	1293	alphas[i] = Float.parseFloat(tokenizer.nextToken());
	1294	}
	1295	tileImage(g, object, x, y, w, h, alphas);
	1296	} else {
	1297	float a = Float.parseFloat(alpha);
	1298	if (g instanceof Graphics2D) {
	1299	Graphics2D g2 = (Graphics2D)g;
	1300	Composite oldComp = g2.getComposite();
	1301	g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, a));
	1302	g2.drawImage(object, x, y, w, h, null);
	1303	g2.setComposite(oldComp);
	1304	}
	1305	}
	1306	} else {
	1307	g.drawImage(object, x, y, w, h, null);
	1308	}
	1309	}
	1310
	1311	protected void drawIcon(Node node, Graphics g, JInternalFrame jif) {
	1312	Icon icon = jif.getFrameIcon();
	1313	if (icon == null) {
	1314	return;
	1315	}
	1316
	1317	NamedNodeMap attrs = node.getAttributes();
	1318	String alpha = getStringAttr(attrs, "alpha");
	1319	int x = aee.evaluate(getStringAttr(attrs, "x"));
	1320	int y = aee.evaluate(getStringAttr(attrs, "y"));
	1321	int w = aee.evaluate(getStringAttr(attrs, "width"));
	1322	int h = aee.evaluate(getStringAttr(attrs, "height"));
	1323	if (getInt("width") == -1) {
	1324	x -= w;
	1325	}
	1326	if (getInt("height") == -1) {
	1327	y -= h;
	1328	}
	1329
	1330	if (alpha != null) {
	1331	float a = Float.parseFloat(alpha);
	1332	if (g instanceof Graphics2D) {
	1333	Graphics2D g2 = (Graphics2D)g;
	1334	Composite oldComp = g2.getComposite();
	1335	g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, a));
	1336	icon.paintIcon(jif, g, x, y);
	1337	g2.setComposite(oldComp);
	1338	}
	1339	} else {
	1340	icon.paintIcon(jif, g, x, y);
	1341	}
	1342	}
	1343
	1344	protected void drawInclude(Node node, Graphics g, JInternalFrame jif) {
	1345	int oldWidth = getInt("width");
	1346	int oldHeight = getInt("height");
	1347
	1348	NamedNodeMap attrs = node.getAttributes();
	1349	int x = aee.evaluate(getStringAttr(attrs, "x"), 0);
	1350	int y = aee.evaluate(getStringAttr(attrs, "y"), 0);
	1351	int w = aee.evaluate(getStringAttr(attrs, "width"), -1);
	1352	int h = aee.evaluate(getStringAttr(attrs, "height"), -1);
	1353
	1354	if (w != -1) {
	1355	variables.put("width", w);
	1356	}
	1357	if (h != -1) {
	1358	variables.put("height", h);
	1359	}
	1360
	1361	Node draw_ops = getNode("draw_ops", new String[] {
	1362	"name", getStringAttr(node, "name")
	1363	});
	1364	g.translate(x, y);
	1365	draw(draw_ops, g, jif);
	1366	g.translate(-x, -y);
	1367
	1368	if (w != -1) {
	1369	variables.put("width", oldWidth);
	1370	}
	1371	if (h != -1) {
	1372	variables.put("height", oldHeight);
	1373	}
	1374	}
	1375
	1376	protected void draw(Node draw_ops, Graphics g, JInternalFrame jif) {
	1377	if (draw_ops != null) {
	1378	NodeList nodes = draw_ops.getChildNodes();
	1379	if (nodes != null) {
	1380	Shape oldClip = g.getClip();
	1381	for (int i = 0; i < nodes.getLength(); i++) {
	1382	Node child = nodes.item(i);
	1383	if (child.getNodeType() == Node.ELEMENT_NODE) {
	1384	try {
	1385	String name = child.getNodeName();
	1386	if ("include".equals(name)) {
	1387	drawInclude(child, g, jif);
	1388	} else if ("arc".equals(name)) {
	1389	drawArc(child, g);
	1390	} else if ("clip".equals(name)) {
	1391	setClip(child, g);
	1392	} else if ("gradient".equals(name)) {
	1393	drawGradient(child, g);
	1394	} else if ("gtk_arrow".equals(name)) {
	1395	drawGTKArrow(child, g);
	1396	} else if ("gtk_box".equals(name)) {
	1397	drawGTKBox(child, g);
	1398	} else if ("gtk_vline".equals(name)) {
	1399	drawGTKVLine(child, g);
	1400	} else if ("image".equals(name)) {
	1401	drawImage(child, g);
	1402	} else if ("icon".equals(name)) {
	1403	drawIcon(child, g, jif);
	1404	} else if ("line".equals(name)) {
	1405	drawLine(child, g);
	1406	} else if ("rectangle".equals(name)) {
	1407	drawRectangle(child, g);
	1408	} else if ("tint".equals(name)) {
	1409	drawTint(child, g);
	1410	} else if ("tile".equals(name)) {
	1411	drawTile(child, g, jif);
	1412	} else if ("title".equals(name)) {
	1413	drawTitle(child, g, jif);
	1414	} else {
	1415	System.err.println("Unknown Metacity drawing op: "+child);
	1416	}
	1417	} catch (NumberFormatException ex) {
	1418	logError(themeName, ex);
	1419	}
	1420	}
	1421	}
	1422	g.setClip(oldClip);
	1423	}
	1424	}
	1425	}
	1426
	1427	protected void drawPiece(Node frame_style, Graphics g, String position, int x, int y,
	1428	int width, int height, JInternalFrame jif) {
	1429	Node piece = getNode(frame_style, "piece", new String[] { "position", position });
	1430	if (piece != null) {
	1431	Node draw_ops;
	1432	String draw_ops_name = getStringAttr(piece, "draw_ops");
	1433	if (draw_ops_name != null) {
	1434	draw_ops = getNode("draw_ops", new String[] { "name", draw_ops_name });
	1435	} else {
	1436	draw_ops = getNode(piece, "draw_ops", null);
	1437	}
	1438	variables.put("width", width);
	1439	variables.put("height", height);
	1440	g.translate(x, y);
	1441	draw(draw_ops, g, jif);
	1442	g.translate(-x, -y);
	1443	}
	1444	}
	1445
	1446
	1447	Insets getBorderInsets(SynthContext context, Insets insets) {
	1448	updateFrameGeometry(context);
	1449
	1450	if (insets == null) {
	1451	insets = new Insets(0, 0, 0, 0);
	1452	}
	1453	insets.top = ((Insets)frameGeometry.get("title_border")).top;
	1454	insets.bottom = getInt("bottom_height");
	1455	insets.left = getInt("left_width");
	1456	insets.right = getInt("right_width");
	1457	return insets;
	1458	}
	1459
	1460
	1461	private void updateFrameGeometry(SynthContext context) {
	1462	this.context = context;
	1463	JComponent comp = context.getComponent();
	1464	JComponent titlePane = findChild(comp, "InternalFrame.northPane");
	1465
	1466	JInternalFrame jif = null;
	1467	if (comp instanceof JInternalFrame) {
	1468	jif = (JInternalFrame)comp;
	1469	} else if (comp instanceof JInternalFrame.JDesktopIcon) {
	1470	jif = ((JInternalFrame.JDesktopIcon)comp).getInternalFrame();
	1471	} else {
	1472	assert false : "component is not JInternalFrame or JInternalFrame.JDesktopIcon";
	1473	return;
	1474	}
	1475
	1476	if (frame_style_set == null) {
	1477	Node window = getNode("window", new String[]{"type", "normal"});
	1478
	1479	if (window != null) {
	1480	frame_style_set = getNode("frame_style_set",
	1481	new String[] {"name", getStringAttr(window, "style_set")});
	1482	}
	1483
	1484	if (frame_style_set == null) {
	1485	frame_style_set = getNode("frame_style_set", new String[] {"name", "normal"});
	1486	}
	1487	}
	1488
	1489	if (frame_style_set != null) {
	1490	Node frame = getNode(frame_style_set, "frame", new String[] {
	1491	"focus", (jif.isSelected() ? "yes" : "no"),
	1492	"state", (jif.isMaximum() ? "maximized" : "normal")
	1493	});
	1494
	1495	if (frame != null) {
	1496	Node frame_style = getNode("frame_style", new String[] {
	1497	"name", getStringAttr(frame, "style")
	1498	});
	1499	if (frame_style != null) {
	1500	Map gm = frameGeometries.get(getStringAttr(frame_style, "geometry"));
	1501
	1502	setFrameGeometry(titlePane, gm);
	1503	}
	1504	}
	1505	}
	1506	}
	1507
	1508
	1509	protected static void logError(String themeName, Exception ex) {
	1510	logError(themeName, ex.toString());
	1511	}
	1512
	1513	protected static void logError(String themeName, String msg) {
	1514	if (!errorLogged) {
	1515	System.err.println("Exception in Metacity for theme \""+themeName+"\": "+msg);
	1516	errorLogged = true;
	1517	}
	1518	}
	1519
	1520
	1521	// XML Parsing
	1522
	1523
	1524	protected static Document getXMLDoc(final URL xmlFile)
	1525	throws IOException,
	1526	ParserConfigurationException,
	1527	SAXException {
	1528	if (documentBuilder == null) {
	1529	documentBuilder =
	1530	DocumentBuilderFactory.newInstance().newDocumentBuilder();
	1531	}
	1532	InputStream inputStream =
	1533	AccessController.doPrivileged(new PrivilegedAction<InputStream>() {
	1534	public InputStream run() {
	1535	try {
	1536	return new BufferedInputStream(xmlFile.openStream());
	1537	} catch (IOException ex) {
	1538	return null;
	1539	}
	1540	}
	1541	});
	1542
	1543	Document doc = null;
	1544	if (inputStream != null) {
	1545	doc = documentBuilder.parse(inputStream);
	1546	}
	1547	return doc;
	1548	}
	1549
	1550
	1551	protected Node[] getNodesByName(Node parent, String name) {
	1552	NodeList nodes = parent.getChildNodes(); // ElementNode
	1553	int n = nodes.getLength();
	1554	ArrayList<Node> list = new ArrayList<Node>();
	1555	for (int i=0; i < n; i++) {
	1556	Node node = nodes.item(i);
	1557	if (name.equals(node.getNodeName())) {
	1558	list.add(node);
	1559	}
	1560	}
	1561	return list.toArray(new Node[list.size()]);
	1562	}
	1563
	1564
	1565
	1566	protected Node getNode(String tagName, String[] attrs) {
	1567	NodeList nodes = xmlDoc.getElementsByTagName(tagName);
	1568	return (nodes != null) ? getNode(nodes, tagName, attrs) : null;
	1569	}
	1570
	1571	protected Node getNode(Node parent, String name, String[] attrs) {
	1572	Node node = null;
	1573	NodeList nodes = parent.getChildNodes();
	1574	if (nodes != null) {
	1575	node = getNode(nodes, name, attrs);
	1576	}
	1577	if (node == null) {
	1578	String inheritFrom = getStringAttr(parent, "parent");
	1579	if (inheritFrom != null) {
	1580	Node inheritFromNode = getNode(parent.getParentNode(),
	1581	parent.getNodeName(),
	1582	new String[] { "name", inheritFrom });
	1583	if (inheritFromNode != null) {
	1584	node = getNode(inheritFromNode, name, attrs);
	1585	}
	1586	}
	1587	}
	1588	return node;
	1589	}
	1590
	1591	protected Node getNode(NodeList nodes, String name, String[] attrs) {
	1592	int n = nodes.getLength();
	1593	for (int i=0; i < n; i++) {
	1594	Node node = nodes.item(i);
	1595	if (name.equals(node.getNodeName())) {
	1596	if (attrs != null) {
	1597	NamedNodeMap nodeAttrs = node.getAttributes();
	1598	if (nodeAttrs != null) {
	1599	boolean matches = true;
	1600	int nAttrs = attrs.length / 2;
	1601	for (int a = 0; a < nAttrs; a++) {
	1602	String aName = attrs[a * 2];
	1603	String aValue = attrs[a * 2 + 1];
	1604	Node attr = nodeAttrs.getNamedItem(aName);
	1605	if (attr == null \|\|
	1606	aValue != null && !aValue.equals(attr.getNodeValue())) {
	1607	matches = false;
	1608	break;
	1609	}
	1610	}
	1611	if (matches) {
	1612	return node;
	1613	}
	1614	}
	1615	} else {
	1616	return node;
	1617	}
	1618	}
	1619	}
	1620	return null;
	1621	}
	1622
	1623	protected String getStringAttr(Node node, String name) {
	1624	String value = null;
	1625	NamedNodeMap attrs = node.getAttributes();
	1626	if (attrs != null) {
	1627	value = getStringAttr(attrs, name);
	1628	if (value == null) {
	1629	String inheritFrom = getStringAttr(attrs, "parent");
	1630	if (inheritFrom != null) {
	1631	Node inheritFromNode = getNode(node.getParentNode(),
	1632	node.getNodeName(),
	1633	new String[] { "name", inheritFrom });
	1634	if (inheritFromNode != null) {
	1635	value = getStringAttr(inheritFromNode, name);
	1636	}
	1637	}
	1638	}
	1639	}
	1640	return value;
	1641	}
	1642
	1643	protected String getStringAttr(NamedNodeMap attrs, String name) {
	1644	Node item = attrs.getNamedItem(name);
	1645	return (item != null) ? item.getNodeValue() : null;
	1646	}
	1647
	1648	protected boolean getBooleanAttr(Node node, String name, boolean fallback) {
	1649	String str = getStringAttr(node, name);
	1650	if (str != null) {
	1651	return Boolean.valueOf(str).booleanValue();
	1652	}
	1653	return fallback;
	1654	}
	1655
	1656	protected int getIntAttr(Node node, String name, int fallback) {
	1657	String str = getStringAttr(node, name);
	1658	int value = fallback;
	1659	if (str != null) {
	1660	try {
	1661	value = Integer.parseInt(str);
	1662	} catch (NumberFormatException ex) {
	1663	logError(themeName, ex);
	1664	}
	1665	}
	1666	return value;
	1667	}
	1668
	1669	protected float getFloatAttr(Node node, String name, float fallback) {
	1670	String str = getStringAttr(node, name);
	1671	float value = fallback;
	1672	if (str != null) {
	1673	try {
	1674	value = Float.parseFloat(str);
	1675	} catch (NumberFormatException ex) {
	1676	logError(themeName, ex);
	1677	}
	1678	}
	1679	return value;
	1680	}
	1681
	1682
	1683
	1684	protected Color parseColor(String str) {
	1685	StringTokenizer tokenizer = new StringTokenizer(str, "/");
	1686	int n = tokenizer.countTokens();
	1687	if (n > 1) {
	1688	String function = tokenizer.nextToken();
	1689	if ("shade".equals(function)) {
	1690	assert (n == 3);
	1691	Color c = parseColor2(tokenizer.nextToken());
	1692	float alpha = Float.parseFloat(tokenizer.nextToken());
	1693	return GTKColorType.adjustColor(c, 1.0F, alpha, alpha);
	1694	} else if ("blend".equals(function)) {
	1695	assert (n == 4);
	1696	Color bg = parseColor2(tokenizer.nextToken());
	1697	Color fg = parseColor2(tokenizer.nextToken());
	1698	float alpha = Float.parseFloat(tokenizer.nextToken());
	1699	if (alpha > 1.0f) {
	1700	alpha = 1.0f / alpha;
	1701	}
	1702
	1703	return new Color((int)(bg.getRed() + ((fg.getRed() - bg.getRed()) * alpha)),
	1704	(int)(bg.getRed() + ((fg.getRed() - bg.getRed()) * alpha)),
	1705	(int)(bg.getRed() + ((fg.getRed() - bg.getRed()) * alpha)));
	1706	} else {
	1707	System.err.println("Unknown Metacity color function="+str);
	1708	return null;
	1709	}
	1710	} else {
	1711	return parseColor2(str);
	1712	}
	1713	}
	1714
	1715	protected Color parseColor2(String str) {
	1716	Color c = null;
	1717	if (str.startsWith("gtk:")) {
	1718	int i1 = str.indexOf('[');
	1719	if (i1 > 3) {
	1720	String typeStr = str.substring(4, i1).toLowerCase();
	1721	int i2 = str.indexOf(']');
	1722	if (i2 > i1+1) {
	1723	String stateStr = str.substring(i1+1, i2).toUpperCase();
	1724	int state = -1;
	1725	if ("ACTIVE".equals(stateStr)) {
	1726	state = PRESSED;
	1727	} else if ("INSENSITIVE".equals(stateStr)) {
	1728	state = DISABLED;
	1729	} else if ("NORMAL".equals(stateStr)) {
	1730	state = ENABLED;
	1731	} else if ("PRELIGHT".equals(stateStr)) {
	1732	state = MOUSE_OVER;
	1733	} else if ("SELECTED".equals(stateStr)) {
	1734	state = SELECTED;
	1735	}
	1736	ColorType type = null;
	1737	if ("fg".equals(typeStr)) {
	1738	type = GTKColorType.FOREGROUND;
	1739	} else if ("bg".equals(typeStr)) {
	1740	type = GTKColorType.BACKGROUND;
	1741	} else if ("base".equals(typeStr)) {
	1742	type = GTKColorType.TEXT_BACKGROUND;
	1743	} else if ("text".equals(typeStr)) {
	1744	type = GTKColorType.TEXT_FOREGROUND;
	1745	} else if ("dark".equals(typeStr)) {
	1746	type = GTKColorType.DARK;
	1747	} else if ("light".equals(typeStr)) {
	1748	type = GTKColorType.LIGHT;
	1749	}
	1750	if (state >= 0 && type != null) {
	1751	c = ((GTKStyle)context.getStyle()).getGTKColor(context, state, type);
	1752	}
	1753	}
	1754	}
	1755	}
	1756	if (c == null) {
	1757	c = parseColorString(str);
	1758	}
	1759	return c;
	1760	}
	1761
	1762	private static Color parseColorString(String str) {
	1763	if (str.charAt(0) == '#') {
	1764	str = str.substring(1);
	1765
	1766	int i = str.length();
	1767
	1768	if (i < 3 \|\| i > 12 \|\| (i % 3) != 0) {
	1769	return null;
	1770	}
	1771
	1772	i /= 3;
	1773
	1774	int r;
	1775	int g;
	1776	int b;
	1777
	1778	try {
	1779	r = Integer.parseInt(str.substring(0, i), 16);
	1780	g = Integer.parseInt(str.substring(i, i * 2), 16);
	1781	b = Integer.parseInt(str.substring(i * 2, i * 3), 16);
	1782	} catch (NumberFormatException nfe) {
	1783	return null;
	1784	}
	1785
	1786	if (i == 4) {
	1787	return new ColorUIResource(r / 65535.0f, g / 65535.0f, b / 65535.0f);
	1788	} else if (i == 1) {
	1789	return new ColorUIResource(r / 15.0f, g / 15.0f, b / 15.0f);
	1790	} else if (i == 2) {
	1791	return new ColorUIResource(r, g, b);
	1792	} else {
	1793	return new ColorUIResource(r / 4095.0f, g / 4095.0f, b / 4095.0f);
	1794	}
	1795	} else {
	1796	return XColors.lookupColor(str);
	1797	}
	1798	}
	1799
	1800	class ArithmeticExpressionEvaluator {
	1801	private PeekableStringTokenizer tokenizer;
	1802
	1803	int evaluate(String expr) {
	1804	tokenizer = new PeekableStringTokenizer(expr, " \t+-*/%()", true);
	1805	return Math.round(expression());
	1806	}
	1807
	1808	int evaluate(String expr, int fallback) {
	1809	return (expr != null) ? evaluate(expr) : fallback;
	1810	}
	1811
	1812	public float expression() {
	1813	float value = getTermValue();
	1814	boolean done = false;
	1815	while (!done && tokenizer.hasMoreTokens()) {
	1816	String next = tokenizer.peek();
	1817	if ("+".equals(next) \|\|
	1818	"-".equals(next) \|\|
	1819	"`max`".equals(next) \|\|
	1820	"`min`".equals(next)) {
	1821	tokenizer.nextToken();
	1822	float value2 = getTermValue();
	1823	if ("+".equals(next)) {
	1824	value += value2;
	1825	} else if ("-".equals(next)) {
	1826	value -= value2;
	1827	} else if ("`max`".equals(next)) {
	1828	value = Math.max(value, value2);
	1829	} else if ("`min`".equals(next)) {
	1830	value = Math.min(value, value2);
	1831	}
	1832	} else {
	1833	done = true;
	1834	}
	1835	}
	1836	return value;
	1837	}
	1838
	1839	public float getTermValue() {
	1840	float value = getFactorValue();
	1841	boolean done = false;
	1842	while (!done && tokenizer.hasMoreTokens()) {
	1843	String next = tokenizer.peek();
	1844	if ("*".equals(next) \|\| "/".equals(next) \|\| "%".equals(next)) {
	1845	tokenizer.nextToken();
	1846	float value2 = getFactorValue();
	1847	if ("*".equals(next)) {
	1848	value *= value2;
	1849	} else if ("/".equals(next)) {
	1850	value /= value2;
	1851	} else {
	1852	value %= value2;
	1853	}
	1854	} else {
	1855	done = true;
	1856	}
	1857	}
	1858	return value;
	1859	}
	1860
	1861	public float getFactorValue() {
	1862	float value;
	1863	if ("(".equals(tokenizer.peek())) {
	1864	tokenizer.nextToken();
	1865	value = expression();
	1866	tokenizer.nextToken(); // skip right paren
	1867	} else {
	1868	String token = tokenizer.nextToken();
	1869	if (Character.isDigit(token.charAt(0))) {
	1870	value = Float.parseFloat(token);
	1871	} else {
	1872	Integer i = variables.get(token);
	1873	if (i == null) {
	1874	i = (Integer)getFrameGeometry().get(token);
	1875	}
	1876	if (i == null) {
	1877	logError(themeName, "Variable \"" + token + "\" not defined");
	1878	return 0;
	1879	}
	1880	value = (i != null) ? i.intValue() : 0F;
	1881	}
	1882	}
	1883	return value;
	1884	}
	1885
	1886
	1887	}
	1888
	1889	static class PeekableStringTokenizer extends StringTokenizer {
	1890	String token = null;
	1891
	1892	public PeekableStringTokenizer(String str, String delim,
	1893	boolean returnDelims) {
	1894	super(str, delim, returnDelims);
	1895	peek();
	1896	}
	1897
	1898	public String peek() {
	1899	if (token == null) {
	1900	token = nextToken();
	1901	}
	1902	return token;
	1903	}
	1904
	1905	public boolean hasMoreTokens() {
	1906	return (token != null \|\| super.hasMoreTokens());
	1907	}
	1908
	1909	public String nextToken() {
	1910	if (token != null) {
	1911	String t = token;
	1912	token = null;
	1913	if (hasMoreTokens()) {
	1914	peek();
	1915	}
	1916	return t;
	1917	} else {
	1918	String token = super.nextToken();
	1919	while ((token.equals(" ") \|\| token.equals("\t"))
	1920	&& hasMoreTokens()) {
	1921	token = super.nextToken();
	1922	}
	1923	return token;
	1924	}
	1925	}
	1926	}
	1927
	1928
	1929	static class RoundRectClipShape extends RectangularShape {
	1930	static final int TOP_LEFT = 1;
	1931	static final int TOP_RIGHT = 2;
	1932	static final int BOTTOM_LEFT = 4;
	1933	static final int BOTTOM_RIGHT = 8;
	1934
	1935	int x;
	1936	int y;
	1937	int width;
	1938	int height;
	1939	int arcwidth;
	1940	int archeight;
	1941	int corners;
	1942
	1943	public RoundRectClipShape() {
	1944	}
	1945
	1946	public RoundRectClipShape(int x, int y, int w, int h,
	1947	int arcw, int arch, int corners) {
	1948	setRoundedRect(x, y, w, h, arcw, arch, corners);
	1949	}
	1950
	1951	public void setRoundedRect(int x, int y, int w, int h,
	1952	int arcw, int arch, int corners) {
	1953	this.corners = corners;
	1954	this.x = x;
	1955	this.y = y;
	1956	this.width = w;
	1957	this.height = h;
	1958	this.arcwidth = arcw;
	1959	this.archeight = arch;
	1960	}
	1961
	1962	public double getX() {
	1963	return (double)x;
	1964	}
	1965
	1966	public double getY() {
	1967	return (double)y;
	1968	}
	1969
	1970	public double getWidth() {
	1971	return (double)width;
	1972	}
	1973
	1974	public double getHeight() {
	1975	return (double)height;
	1976	}
	1977
	1978	public double getArcWidth() {
	1979	return (double)arcwidth;
	1980	}
	1981
	1982	public double getArcHeight() {
	1983	return (double)archeight;
	1984	}
	1985
	1986	public boolean isEmpty() {
	1987	return false; // Not called
	1988	}
	1989
	1990	public Rectangle2D getBounds2D() {
	1991	return null; // Not called
	1992	}
	1993
	1994	public int getCornerFlags() {
	1995	return corners;
	1996	}
	1997
	1998	public void setFrame(double x, double y, double w, double h) {
	1999	// Not called
	2000	}
	2001
	2002	public boolean contains(double x, double y) {
	2003	return false; // Not called
	2004	}
	2005
	2006	private int classify(double coord, double left, double right, double arcsize) {
	2007	return 0; // Not called
	2008	}
	2009
	2010	public boolean intersects(double x, double y, double w, double h) {
	2011	return false; // Not called
	2012	}
	2013
	2014	public boolean contains(double x, double y, double w, double h) {
	2015	return false; // Not called
	2016	}
	2017
	2018	public PathIterator getPathIterator(AffineTransform at) {
	2019	return new RoundishRectIterator(this, at);
	2020	}
	2021
	2022
	2023	static class RoundishRectIterator implements PathIterator {
	2024	double x, y, w, h, aw, ah;
	2025	AffineTransform affine;
	2026	int index;
	2027
	2028	double ctrlpts[][];
	2029	int types[];
	2030
	2031	private static final double angle = Math.PI / 4.0;
	2032	private static final double a = 1.0 - Math.cos(angle);
	2033	private static final double b = Math.tan(angle);
	2034	private static final double c = Math.sqrt(1.0 + b * b) - 1 + a;
	2035	private static final double cv = 4.0 / 3.0 * a * b / c;
	2036	private static final double acv = (1.0 - cv) / 2.0;
	2037
	2038	// For each array:
	2039	// 4 values for each point {v0, v1, v2, v3}:
	2040	// point = (x + v0 * w + v1 * arcWidth,
	2041	// y + v2 * h + v3 * arcHeight);
	2042	private static final double CtrlPtTemplate[][] = {
	2043	{ 0.0, 0.0, 1.0, 0.0 }, /* BOTTOM LEFT corner */
	2044	{ 0.0, 0.0, 1.0, -0.5 }, /* BOTTOM LEFT arc start */
	2045	{ 0.0, 0.0, 1.0, -acv, /* BOTTOM LEFT arc curve */
	2046	0.0, acv, 1.0, 0.0,
	2047	0.0, 0.5, 1.0, 0.0 },
	2048	{ 1.0, 0.0, 1.0, 0.0 }, /* BOTTOM RIGHT corner */
	2049	{ 1.0, -0.5, 1.0, 0.0 }, /* BOTTOM RIGHT arc start */
	2050	{ 1.0, -acv, 1.0, 0.0, /* BOTTOM RIGHT arc curve */
	2051	1.0, 0.0, 1.0, -acv,
	2052	1.0, 0.0, 1.0, -0.5 },
	2053	{ 1.0, 0.0, 0.0, 0.0 }, /* TOP RIGHT corner */
	2054	{ 1.0, 0.0, 0.0, 0.5 }, /* TOP RIGHT arc start */
	2055	{ 1.0, 0.0, 0.0, acv, /* TOP RIGHT arc curve */
	2056	1.0, -acv, 0.0, 0.0,
	2057	1.0, -0.5, 0.0, 0.0 },
	2058	{ 0.0, 0.0, 0.0, 0.0 }, /* TOP LEFT corner */
	2059	{ 0.0, 0.5, 0.0, 0.0 }, /* TOP LEFT arc start */
	2060	{ 0.0, acv, 0.0, 0.0, /* TOP LEFT arc curve */
	2061	0.0, 0.0, 0.0, acv,
	2062	0.0, 0.0, 0.0, 0.5 },
	2063	{}, /* Closing path element */
	2064	};
	2065	private static final int CornerFlags[] = {
	2066	RoundRectClipShape.BOTTOM_LEFT,
	2067	RoundRectClipShape.BOTTOM_RIGHT,
	2068	RoundRectClipShape.TOP_RIGHT,
	2069	RoundRectClipShape.TOP_LEFT,
	2070	};
	2071
	2072	RoundishRectIterator(RoundRectClipShape rr, AffineTransform at) {
	2073	this.x = rr.getX();
	2074	this.y = rr.getY();
	2075	this.w = rr.getWidth();
	2076	this.h = rr.getHeight();
	2077	this.aw = Math.min(w, Math.abs(rr.getArcWidth()));
	2078	this.ah = Math.min(h, Math.abs(rr.getArcHeight()));
	2079	this.affine = at;
	2080	if (w < 0 \|\| h < 0) {
	2081	// Don't draw anything...
	2082	ctrlpts = new double[0][];
	2083	types = new int[0];
	2084	} else {
	2085	int corners = rr.getCornerFlags();
	2086	int numedges = 5; // 4xCORNER_POINT, CLOSE
	2087	for (int i = 1; i < 0x10; i <<= 1) {
	2088	// Add one for each corner that has a curve
	2089	if ((corners & i) != 0) numedges++;
	2090	}
	2091	ctrlpts = new double[numedges][];
	2092	types = new int[numedges];
	2093	int j = 0;
	2094	for (int i = 0; i < 4; i++) {
	2095	types[j] = SEG_LINETO;
	2096	if ((corners & CornerFlags[i]) == 0) {
	2097	ctrlpts[j++] = CtrlPtTemplate[i*3+0];
	2098	} else {
	2099	ctrlpts[j++] = CtrlPtTemplate[i*3+1];
	2100	types[j] = SEG_CUBICTO;
	2101	ctrlpts[j++] = CtrlPtTemplate[i*3+2];
	2102	}
	2103	}
	2104	types[j] = SEG_CLOSE;
	2105	ctrlpts[j++] = CtrlPtTemplate[12];
	2106	types[0] = SEG_MOVETO;
	2107	}
	2108	}
	2109
	2110	public int getWindingRule() {
	2111	return WIND_NON_ZERO;
	2112	}
	2113
	2114	public boolean isDone() {
	2115	return index >= ctrlpts.length;
	2116	}
	2117
	2118	public void next() {
	2119	index++;
	2120	}
	2121
	2122	public int currentSegment(float[] coords) {
	2123	if (isDone()) {
	2124	throw new NoSuchElementException("roundrect iterator out of bounds");
	2125	}
	2126	double ctrls[] = ctrlpts[index];
	2127	int nc = 0;
	2128	for (int i = 0; i < ctrls.length; i += 4) {
	2129	coords[nc++] = (float) (x + ctrls[i + 0] * w + ctrls[i + 1] * aw);
	2130	coords[nc++] = (float) (y + ctrls[i + 2] * h + ctrls[i + 3] * ah);
	2131	}
	2132	if (affine != null) {
	2133	affine.transform(coords, 0, coords, 0, nc / 2);
	2134	}
	2135	return types[index];
	2136	}
	2137
	2138	public int currentSegment(double[] coords) {
	2139	if (isDone()) {
	2140	throw new NoSuchElementException("roundrect iterator out of bounds");
	2141	}
	2142	double ctrls[] = ctrlpts[index];
	2143	int nc = 0;
	2144	for (int i = 0; i < ctrls.length; i += 4) {
	2145	coords[nc++] = x + ctrls[i + 0] * w + ctrls[i + 1] * aw;
	2146	coords[nc++] = y + ctrls[i + 2] * h + ctrls[i + 3] * ah;
	2147	}
	2148	if (affine != null) {
	2149	affine.transform(coords, 0, coords, 0, nc / 2);
	2150	}
	2151	return types[index];
	2152	}
	2153	}
	2154	}
	2155	}

java/pkg/com/sun/java/swing/plaf/gtk/PangoFonts.java+233−0

@@ -0,0 +1,233 @@
	1	/*
	2	* Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.swing.plaf.gtk;
	27
	28	import java.awt.*;
	29	import java.awt.geom.AffineTransform;
	30	import javax.swing.plaf.FontUIResource;
	31	import java.util.StringTokenizer;
	32
	33	import sun.font.FontConfigManager;
	34	import sun.font.FontUtilities;
	35
	36	/**
	37	* @author Shannon Hickey
	38	* @author Leif Samuelsson
	39	*/
	40	class PangoFonts {
	41
	42	public static final String CHARS_DIGITS = "0123456789";
	43
	44	/**
	45	* Calculate a default scale factor for fonts in this L&F to match
	46	* the reported resolution of the screen.
	47	* Java 2D specified a default user-space scale of 72dpi.
	48	* This is unlikely to correspond to that of the real screen.
	49	* The Xserver reports a value which may be used to adjust for this.
	50	* and Java 2D exposes it via a normalizing transform.
	51	* However many Xservers report a hard-coded 90dpi whilst others report a
	52	* calculated value based on possibly incorrect data.
	53	* That is something that must be solved at the X11 level
	54	* Note that in an X11 multi-screen environment, the default screen
	55	* is the one used by the JRE so it is safe to use it here.
	56	*/
	57	private static double fontScale;
	58
	59	static {
	60	fontScale = 1.0d;
	61	GraphicsEnvironment ge =
	62	GraphicsEnvironment.getLocalGraphicsEnvironment();
	63
	64	if (!ge.isHeadless()) {
	65	GraphicsConfiguration gc =
	66	ge.getDefaultScreenDevice().getDefaultConfiguration();
	67	AffineTransform at = gc.getNormalizingTransform();
	68	fontScale = at.getScaleY();
	69	}
	70	}
	71
	72
	73	/**
	74	* Parses a String containing a pango font description and returns
	75	* a Font object.
	76	*
	77	* @param pangoName a String describing a pango font
	78	* e.g. "Sans Italic 10"
	79	* @return a Font object as a FontUIResource
	80	* or null if no suitable font could be created.
	81	*/
	82	static Font lookupFont(String pangoName) {
	83	String family = "";
	84	int style = Font.PLAIN;
	85	int size = 10;
	86
	87	StringTokenizer tok = new StringTokenizer(pangoName);
	88
	89	while (tok.hasMoreTokens()) {
	90	String word = tok.nextToken();
	91
	92	if (word.equalsIgnoreCase("italic")) {
	93	style \|= Font.ITALIC;
	94	} else if (word.equalsIgnoreCase("bold")) {
	95	style \|= Font.BOLD;
	96	} else if (CHARS_DIGITS.indexOf(word.charAt(0)) != -1) {
	97	try {
	98	size = Integer.parseInt(word);
	99	} catch (NumberFormatException ex) {
	100	}
	101	} else {
	102	if (family.length() > 0) {
	103	family += " ";
	104	}
	105
	106	family += word;
	107	}
	108	}
	109
	110	/*
	111	* Java 2D font point sizes are in a user-space scale of 72dpi.
	112	* GTK allows a user to configure a "dpi" property used to scale
	113	* the fonts used to match a user's preference.
	114	* To match the font size of GTK apps we need to obtain this DPI and
	115	* adjust as follows:
	116	* Some versions of GTK use XSETTINGS if available to dynamically
	117	* monitor user-initiated changes in the DPI to be used by GTK
	118	* apps. This value is also made available as the Xft.dpi X resource.
	119	* This is presumably a function of the font preferences API and/or
	120	* the manner in which it requests the toolkit to update the default
	121	* for the desktop. This dual approach is probably necessary since
	122	* other versions of GTK - or perhaps some apps - determine the size
	123	* to use only at start-up from that X resource.
	124	* If that resource is not set then GTK scales for the DPI resolution
	125	* reported by the Xserver using the formula
	126	* DisplayHeight(dpy, screen) / DisplayHeightMM(dpy, screen) * 25.4
	127	* (25.4mm == 1 inch).
	128	* JDK tracks the Xft.dpi XSETTINGS property directly so it can
	129	* dynamically change font size by tracking just that value.
	130	* If that resource is not available use the same fall back formula
	131	* as GTK (see calculation for fontScale).
	132	*
	133	* GTK's default setting for Xft.dpi is 96 dpi (and it seems -1
	134	* apparently also can mean that "default"). However this default
	135	* isn't used if there's no property set. The real default in the
	136	* absence of a resource is the Xserver reported dpi.
	137	* Finally this DPI is used to calculate the nearest Java 2D font
	138	* 72 dpi font size.
	139	* There are cases in which JDK behaviour may not exactly mimic
	140	* GTK native app behaviour :
	141	* 1) When a GTK app is not able to dynamically track the changes
	142	* (does not use XSETTINGS), JDK will resize but other apps will
	143	* not. This is OK as JDK is exhibiting preferred behaviour and
	144	* this is probably how all later GTK apps will behave
	145	* 2) When a GTK app does not use XSETTINGS and for some reason
	146	* the XRDB property is not present. JDK will pick up XSETTINGS
	147	* and the GTK app will use the Xserver default. Since its
	148	* impossible for JDK to know that some other GTK app is not
	149	* using XSETTINGS its impossible to account for this and in any
	150	* case for it to be a problem the values would have to be different.
	151	* It also seems unlikely to arise except when a user explicitly
	152	* deletes the X resource database entry.
	153	* There also some other issues to be aware of for the future:
	154	* GTK specifies the Xft.dpi value as server-wide which when used
	155	* on systems with 2 distinct X screens with different physical DPI
	156	* the font sizes will inevitably appear different. It would have
	157	* been a more user-friendly design to further adjust that one
	158	* setting depending on the screen resolution to achieve perceived
	159	* equivalent sizes. If such a change were ever to be made in GTK
	160	* we would need to update for that.
	161	*/
	162	double dsize = size;
	163	int dpi = 96;
	164	Object value =
	165	Toolkit.getDefaultToolkit().getDesktopProperty("gnome.Xft/DPI");
	166	if (value instanceof Integer) {
	167	dpi = ((Integer)value).intValue() / 1024;
	168	if (dpi == -1) {
	169	dpi = 96;
	170	}
	171	if (dpi < 50) { /* 50 dpi is the minimum value gnome allows */
	172	dpi = 50;
	173	}
	174	/* The Java rasteriser assumes pts are in a user space of
	175	* 72 dpi, so we need to adjust for that.
	176	*/
	177	dsize = ((double)(dpi * size)/ 72.0);
	178	} else {
	179	/* If there's no property, GTK scales for the resolution
	180	* reported by the Xserver using the formula listed above.
	181	* fontScale already accounts for the 72 dpi Java 2D space.
	182	*/
	183	dsize = size * fontScale;
	184	}
	185
	186	/* Round size to nearest integer pt size */
	187	size = (int)(dsize + 0.5);
	188	if (size < 1) {
	189	size = 1;
	190	}
	191
	192	String fcFamilyLC = family.toLowerCase();
	193	if (FontUtilities.mapFcName(fcFamilyLC) != null) {
	194	/* family is a Fc/Pango logical font which we need to expand. */
	195	Font font = FontUtilities.getFontConfigFUIR(fcFamilyLC, style, size);
	196	font = font.deriveFont(style, (float)dsize);
	197	return new FontUIResource(font);
	198	} else {
	199	/* It's a physical font which we will create with a fallback */
	200	Font font = new Font(family, style, size);
	201	/* a roundabout way to set the font size in floating points */
	202	font = font.deriveFont(style, (float)dsize);
	203	FontUIResource fuir = new FontUIResource(font);
	204	return FontUtilities.getCompositeFontUIResource(fuir);
	205	}
	206	}
	207
	208	/**
	209	* Parses a String containing a pango font description and returns
	210	* the (unscaled) font size as an integer.
	211	*
	212	* @param pangoName a String describing a pango font
	213	* @return the size of the font described by pangoName (e.g. if
	214	* pangoName is "Sans Italic 10", then this method returns 10)
	215	*/
	216	static int getFontSize(String pangoName) {
	217	int size = 10;
	218
	219	StringTokenizer tok = new StringTokenizer(pangoName);
	220	while (tok.hasMoreTokens()) {
	221	String word = tok.nextToken();
	222
	223	if (CHARS_DIGITS.indexOf(word.charAt(0)) != -1) {
	224	try {
	225	size = Integer.parseInt(word);
	226	} catch (NumberFormatException ex) {
	227	}
	228	}
	229	}
	230
	231	return size;
	232	}
	233	}

java/pkg/com/sun/java/swing/plaf/gtk/XColors.java+831−0

@@ -0,0 +1,831 @@
	1	/*
	2	* Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.swing.plaf.gtk;
	27
	28	import java.awt.Color;
	29	import java.util.Arrays;
	30	import javax.swing.plaf.ColorUIResource;
	31
	32	/**
	33	* @author Shannon Hickey
	34	*/
	35	class XColors {
	36
	37	private static class XColor implements Comparable {
	38	String name;
	39
	40	int red;
	41	int green;
	42	int blue;
	43
	44	XColor(String name, int red, int green, int blue) {
	45	this.name = name;
	46	this.red = red;
	47	this.green = green;
	48	this.blue = blue;
	49	}
	50
	51	Color toColor() {
	52	return new ColorUIResource(red, green, blue);
	53	}
	54
	55	public int compareTo(Object o) {
	56	XColor other = (XColor)o;
	57
	58	return name.compareTo(other.name);
	59	}
	60	}
	61
	62	private static XColor key = new XColor("", -1, -1, -1);
	63
	64	static Color lookupColor(String name) {
	65	key.name = name.toLowerCase();
	66
	67	int pos = Arrays.binarySearch(colors, key);
	68
	69	if (pos < 0) {
	70	return null;
	71	}
	72
	73	return colors[pos].toColor();
	74	}
	75
	76	private static final XColor[] colors = {
	77	new XColor("alice blue", 240, 248, 255),
	78	new XColor("aliceblue", 240, 248, 255),
	79	new XColor("antique white", 250, 235, 215),
	80	new XColor("antiquewhite", 250, 235, 215),
	81	new XColor("antiquewhite1", 255, 239, 219),
	82	new XColor("antiquewhite2", 238, 223, 204),
	83	new XColor("antiquewhite3", 205, 192, 176),
	84	new XColor("antiquewhite4", 139, 131, 120),
	85	new XColor("aquamarine", 127, 255, 212),
	86	new XColor("aquamarine1", 127, 255, 212),
	87	new XColor("aquamarine2", 118, 238, 198),
	88	new XColor("aquamarine3", 102, 205, 170),
	89	new XColor("aquamarine4", 69, 139, 116),
	90	new XColor("azure", 240, 255, 255),
	91	new XColor("azure1", 240, 255, 255),
	92	new XColor("azure2", 224, 238, 238),
	93	new XColor("azure3", 193, 205, 205),
	94	new XColor("azure4", 131, 139, 139),
	95	new XColor("beige", 245, 245, 220),
	96	new XColor("bisque", 255, 228, 196),
	97	new XColor("bisque1", 255, 228, 196),
	98	new XColor("bisque2", 238, 213, 183),
	99	new XColor("bisque3", 205, 183, 158),
	100	new XColor("bisque4", 139, 125, 107),
	101	new XColor("black", 0, 0, 0),
	102	new XColor("blanched almond", 255, 235, 205),
	103	new XColor("blanchedalmond", 255, 235, 205),
	104	new XColor("blue", 0, 0, 255),
	105	new XColor("blue violet", 138, 43, 226),
	106	new XColor("blue1", 0, 0, 255),
	107	new XColor("blue2", 0, 0, 238),
	108	new XColor("blue3", 0, 0, 205),
	109	new XColor("blue4", 0, 0, 139),
	110	new XColor("blueviolet", 138, 43, 226),
	111	new XColor("brown", 165, 42, 42),
	112	new XColor("brown1", 255, 64, 64),
	113	new XColor("brown2", 238, 59, 59),
	114	new XColor("brown3", 205, 51, 51),
	115	new XColor("brown4", 139, 35, 35),
	116	new XColor("burlywood", 222, 184, 135),
	117	new XColor("burlywood1", 255, 211, 155),
	118	new XColor("burlywood2", 238, 197, 145),
	119	new XColor("burlywood3", 205, 170, 125),
	120	new XColor("burlywood4", 139, 115, 85),
	121	new XColor("cadet blue", 95, 158, 160),
	122	new XColor("cadetblue", 95, 158, 160),
	123	new XColor("cadetblue1", 152, 245, 255),
	124	new XColor("cadetblue2", 142, 229, 238),
	125	new XColor("cadetblue3", 122, 197, 205),
	126	new XColor("cadetblue4", 83, 134, 139),
	127	new XColor("chartreuse", 127, 255, 0),
	128	new XColor("chartreuse1", 127, 255, 0),
	129	new XColor("chartreuse2", 118, 238, 0),
	130	new XColor("chartreuse3", 102, 205, 0),
	131	new XColor("chartreuse4", 69, 139, 0),
	132	new XColor("chocolate", 210, 105, 30),
	133	new XColor("chocolate1", 255, 127, 36),
	134	new XColor("chocolate2", 238, 118, 33),
	135	new XColor("chocolate3", 205, 102, 29),
	136	new XColor("chocolate4", 139, 69, 19),
	137	new XColor("coral", 255, 127, 80),
	138	new XColor("coral1", 255, 114, 86),
	139	new XColor("coral2", 238, 106, 80),
	140	new XColor("coral3", 205, 91, 69),
	141	new XColor("coral4", 139, 62, 47),
	142	new XColor("cornflower blue", 100, 149, 237),
	143	new XColor("cornflowerblue", 100, 149, 237),
	144	new XColor("cornsilk", 255, 248, 220),
	145	new XColor("cornsilk1", 255, 248, 220),
	146	new XColor("cornsilk2", 238, 232, 205),
	147	new XColor("cornsilk3", 205, 200, 177),
	148	new XColor("cornsilk4", 139, 136, 120),
	149	new XColor("cyan", 0, 255, 255),
	150	new XColor("cyan1", 0, 255, 255),
	151	new XColor("cyan2", 0, 238, 238),
	152	new XColor("cyan3", 0, 205, 205),
	153	new XColor("cyan4", 0, 139, 139),
	154	new XColor("dark blue", 0, 0, 139),
	155	new XColor("dark cyan", 0, 139, 139),
	156	new XColor("dark goldenrod", 184, 134, 11),
	157	new XColor("dark gray", 169, 169, 169),
	158	new XColor("dark green", 0, 100, 0),
	159	new XColor("dark grey", 169, 169, 169),
	160	new XColor("dark khaki", 189, 183, 107),
	161	new XColor("dark magenta", 139, 0, 139),
	162	new XColor("dark olive green", 85, 107, 47),
	163	new XColor("dark orange", 255, 140, 0),
	164	new XColor("dark orchid", 153, 50, 204),
	165	new XColor("dark red", 139, 0, 0),
	166	new XColor("dark salmon", 233, 150, 122),
	167	new XColor("dark sea green", 143, 188, 143),
	168	new XColor("dark slate blue", 72, 61, 139),
	169	new XColor("dark slate gray", 47, 79, 79),
	170	new XColor("dark slate grey", 47, 79, 79),
	171	new XColor("dark turquoise", 0, 206, 209),
	172	new XColor("dark violet", 148, 0, 211),
	173	new XColor("darkblue", 0, 0, 139),
	174	new XColor("darkcyan", 0, 139, 139),
	175	new XColor("darkgoldenrod", 184, 134, 11),
	176	new XColor("darkgoldenrod1", 255, 185, 15),
	177	new XColor("darkgoldenrod2", 238, 173, 14),
	178	new XColor("darkgoldenrod3", 205, 149, 12),
	179	new XColor("darkgoldenrod4", 139, 101, 8),
	180	new XColor("darkgray", 169, 169, 169),
	181	new XColor("darkgreen", 0, 100, 0),
	182	new XColor("darkgrey", 169, 169, 169),
	183	new XColor("darkkhaki", 189, 183, 107),
	184	new XColor("darkmagenta", 139, 0, 139),
	185	new XColor("darkolivegreen", 85, 107, 47),
	186	new XColor("darkolivegreen1", 202, 255, 112),
	187	new XColor("darkolivegreen2", 188, 238, 104),
	188	new XColor("darkolivegreen3", 162, 205, 90),
	189	new XColor("darkolivegreen4", 110, 139, 61),
	190	new XColor("darkorange", 255, 140, 0),
	191	new XColor("darkorange1", 255, 127, 0),
	192	new XColor("darkorange2", 238, 118, 0),
	193	new XColor("darkorange3", 205, 102, 0),
	194	new XColor("darkorange4", 139, 69, 0),
	195	new XColor("darkorchid", 153, 50, 204),
	196	new XColor("darkorchid1", 191, 62, 255),
	197	new XColor("darkorchid2", 178, 58, 238),
	198	new XColor("darkorchid3", 154, 50, 205),
	199	new XColor("darkorchid4", 104, 34, 139),
	200	new XColor("darkred", 139, 0, 0),
	201	new XColor("darksalmon", 233, 150, 122),
	202	new XColor("darkseagreen", 143, 188, 143),
	203	new XColor("darkseagreen1", 193, 255, 193),
	204	new XColor("darkseagreen2", 180, 238, 180),
	205	new XColor("darkseagreen3", 155, 205, 155),
	206	new XColor("darkseagreen4", 105, 139, 105),
	207	new XColor("darkslateblue", 72, 61, 139),
	208	new XColor("darkslategray", 47, 79, 79),
	209	new XColor("darkslategray1", 151, 255, 255),
	210	new XColor("darkslategray2", 141, 238, 238),
	211	new XColor("darkslategray3", 121, 205, 205),
	212	new XColor("darkslategray4", 82, 139, 139),
	213	new XColor("darkslategrey", 47, 79, 79),
	214	new XColor("darkturquoise", 0, 206, 209),
	215	new XColor("darkviolet", 148, 0, 211),
	216	new XColor("deep pink", 255, 20, 147),
	217	new XColor("deep sky blue", 0, 191, 255),
	218	new XColor("deeppink", 255, 20, 147),
	219	new XColor("deeppink1", 255, 20, 147),
	220	new XColor("deeppink2", 238, 18, 137),
	221	new XColor("deeppink3", 205, 16, 118),
	222	new XColor("deeppink4", 139, 10, 80),
	223	new XColor("deepskyblue", 0, 191, 255),
	224	new XColor("deepskyblue1", 0, 191, 255),
	225	new XColor("deepskyblue2", 0, 178, 238),
	226	new XColor("deepskyblue3", 0, 154, 205),
	227	new XColor("deepskyblue4", 0, 104, 139),
	228	new XColor("dim gray", 105, 105, 105),
	229	new XColor("dim grey", 105, 105, 105),
	230	new XColor("dimgray", 105, 105, 105),
	231	new XColor("dimgrey", 105, 105, 105),
	232	new XColor("dodger blue", 30, 144, 255),
	233	new XColor("dodgerblue", 30, 144, 255),
	234	new XColor("dodgerblue1", 30, 144, 255),
	235	new XColor("dodgerblue2", 28, 134, 238),
	236	new XColor("dodgerblue3", 24, 116, 205),
	237	new XColor("dodgerblue4", 16, 78, 139),
	238	new XColor("firebrick", 178, 34, 34),
	239	new XColor("firebrick1", 255, 48, 48),
	240	new XColor("firebrick2", 238, 44, 44),
	241	new XColor("firebrick3", 205, 38, 38),
	242	new XColor("firebrick4", 139, 26, 26),
	243	new XColor("floral white", 255, 250, 240),
	244	new XColor("floralwhite", 255, 250, 240),
	245	new XColor("forest green", 34, 139, 34),
	246	new XColor("forestgreen", 34, 139, 34),
	247	new XColor("gainsboro", 220, 220, 220),
	248	new XColor("ghost white", 248, 248, 255),
	249	new XColor("ghostwhite", 248, 248, 255),
	250	new XColor("gold", 255, 215, 0),
	251	new XColor("gold1", 255, 215, 0),
	252	new XColor("gold2", 238, 201, 0),
	253	new XColor("gold3", 205, 173, 0),
	254	new XColor("gold4", 139, 117, 0),
	255	new XColor("goldenrod", 218, 165, 32),
	256	new XColor("goldenrod1", 255, 193, 37),
	257	new XColor("goldenrod2", 238, 180, 34),
	258	new XColor("goldenrod3", 205, 155, 29),
	259	new XColor("goldenrod4", 139, 105, 20),
	260	new XColor("gray", 190, 190, 190),
	261	new XColor("gray0", 0, 0, 0),
	262	new XColor("gray1", 3, 3, 3),
	263	new XColor("gray10", 26, 26, 26),
	264	new XColor("gray100", 255, 255, 255),
	265	new XColor("gray11", 28, 28, 28),
	266	new XColor("gray12", 31, 31, 31),
	267	new XColor("gray13", 33, 33, 33),
	268	new XColor("gray14", 36, 36, 36),
	269	new XColor("gray15", 38, 38, 38),
	270	new XColor("gray16", 41, 41, 41),
	271	new XColor("gray17", 43, 43, 43),
	272	new XColor("gray18", 46, 46, 46),
	273	new XColor("gray19", 48, 48, 48),
	274	new XColor("gray2", 5, 5, 5),
	275	new XColor("gray20", 51, 51, 51),
	276	new XColor("gray21", 54, 54, 54),
	277	new XColor("gray22", 56, 56, 56),
	278	new XColor("gray23", 59, 59, 59),
	279	new XColor("gray24", 61, 61, 61),
	280	new XColor("gray25", 64, 64, 64),
	281	new XColor("gray26", 66, 66, 66),
	282	new XColor("gray27", 69, 69, 69),
	283	new XColor("gray28", 71, 71, 71),
	284	new XColor("gray29", 74, 74, 74),
	285	new XColor("gray3", 8, 8, 8),
	286	new XColor("gray30", 77, 77, 77),
	287	new XColor("gray31", 79, 79, 79),
	288	new XColor("gray32", 82, 82, 82),
	289	new XColor("gray33", 84, 84, 84),
	290	new XColor("gray34", 87, 87, 87),
	291	new XColor("gray35", 89, 89, 89),
	292	new XColor("gray36", 92, 92, 92),
	293	new XColor("gray37", 94, 94, 94),
	294	new XColor("gray38", 97, 97, 97),
	295	new XColor("gray39", 99, 99, 99),
	296	new XColor("gray4", 10, 10, 10),
	297	new XColor("gray40", 102, 102, 102),
	298	new XColor("gray41", 105, 105, 105),
	299	new XColor("gray42", 107, 107, 107),
	300	new XColor("gray43", 110, 110, 110),
	301	new XColor("gray44", 112, 112, 112),
	302	new XColor("gray45", 115, 115, 115),
	303	new XColor("gray46", 117, 117, 117),
	304	new XColor("gray47", 120, 120, 120),
	305	new XColor("gray48", 122, 122, 122),
	306	new XColor("gray49", 125, 125, 125),
	307	new XColor("gray5", 13, 13, 13),
	308	new XColor("gray50", 127, 127, 127),
	309	new XColor("gray51", 130, 130, 130),
	310	new XColor("gray52", 133, 133, 133),
	311	new XColor("gray53", 135, 135, 135),
	312	new XColor("gray54", 138, 138, 138),
	313	new XColor("gray55", 140, 140, 140),
	314	new XColor("gray56", 143, 143, 143),
	315	new XColor("gray57", 145, 145, 145),
	316	new XColor("gray58", 148, 148, 148),
	317	new XColor("gray59", 150, 150, 150),
	318	new XColor("gray6", 15, 15, 15),
	319	new XColor("gray60", 153, 153, 153),
	320	new XColor("gray61", 156, 156, 156),
	321	new XColor("gray62", 158, 158, 158),
	322	new XColor("gray63", 161, 161, 161),
	323	new XColor("gray64", 163, 163, 163),
	324	new XColor("gray65", 166, 166, 166),
	325	new XColor("gray66", 168, 168, 168),
	326	new XColor("gray67", 171, 171, 171),
	327	new XColor("gray68", 173, 173, 173),
	328	new XColor("gray69", 176, 176, 176),
	329	new XColor("gray7", 18, 18, 18),
	330	new XColor("gray70", 179, 179, 179),
	331	new XColor("gray71", 181, 181, 181),
	332	new XColor("gray72", 184, 184, 184),
	333	new XColor("gray73", 186, 186, 186),
	334	new XColor("gray74", 189, 189, 189),
	335	new XColor("gray75", 191, 191, 191),
	336	new XColor("gray76", 194, 194, 194),
	337	new XColor("gray77", 196, 196, 196),
	338	new XColor("gray78", 199, 199, 199),
	339	new XColor("gray79", 201, 201, 201),
	340	new XColor("gray8", 20, 20, 20),
	341	new XColor("gray80", 204, 204, 204),
	342	new XColor("gray81", 207, 207, 207),
	343	new XColor("gray82", 209, 209, 209),
	344	new XColor("gray83", 212, 212, 212),
	345	new XColor("gray84", 214, 214, 214),
	346	new XColor("gray85", 217, 217, 217),
	347	new XColor("gray86", 219, 219, 219),
	348	new XColor("gray87", 222, 222, 222),
	349	new XColor("gray88", 224, 224, 224),
	350	new XColor("gray89", 227, 227, 227),
	351	new XColor("gray9", 23, 23, 23),
	352	new XColor("gray90", 229, 229, 229),
	353	new XColor("gray91", 232, 232, 232),
	354	new XColor("gray92", 235, 235, 235),
	355	new XColor("gray93", 237, 237, 237),
	356	new XColor("gray94", 240, 240, 240),
	357	new XColor("gray95", 242, 242, 242),
	358	new XColor("gray96", 245, 245, 245),
	359	new XColor("gray97", 247, 247, 247),
	360	new XColor("gray98", 250, 250, 250),
	361	new XColor("gray99", 252, 252, 252),
	362	new XColor("green", 0, 255, 0),
	363	new XColor("green yellow", 173, 255, 47),
	364	new XColor("green1", 0, 255, 0),
	365	new XColor("green2", 0, 238, 0),
	366	new XColor("green3", 0, 205, 0),
	367	new XColor("green4", 0, 139, 0),
	368	new XColor("greenyellow", 173, 255, 47),
	369	new XColor("grey", 190, 190, 190),
	370	new XColor("grey0", 0, 0, 0),
	371	new XColor("grey1", 3, 3, 3),
	372	new XColor("grey10", 26, 26, 26),
	373	new XColor("grey100", 255, 255, 255),
	374	new XColor("grey11", 28, 28, 28),
	375	new XColor("grey12", 31, 31, 31),
	376	new XColor("grey13", 33, 33, 33),
	377	new XColor("grey14", 36, 36, 36),
	378	new XColor("grey15", 38, 38, 38),
	379	new XColor("grey16", 41, 41, 41),
	380	new XColor("grey17", 43, 43, 43),
	381	new XColor("grey18", 46, 46, 46),
	382	new XColor("grey19", 48, 48, 48),
	383	new XColor("grey2", 5, 5, 5),
	384	new XColor("grey20", 51, 51, 51),
	385	new XColor("grey21", 54, 54, 54),
	386	new XColor("grey22", 56, 56, 56),
	387	new XColor("grey23", 59, 59, 59),
	388	new XColor("grey24", 61, 61, 61),
	389	new XColor("grey25", 64, 64, 64),
	390	new XColor("grey26", 66, 66, 66),
	391	new XColor("grey27", 69, 69, 69),
	392	new XColor("grey28", 71, 71, 71),
	393	new XColor("grey29", 74, 74, 74),
	394	new XColor("grey3", 8, 8, 8),
	395	new XColor("grey30", 77, 77, 77),
	396	new XColor("grey31", 79, 79, 79),
	397	new XColor("grey32", 82, 82, 82),
	398	new XColor("grey33", 84, 84, 84),
	399	new XColor("grey34", 87, 87, 87),
	400	new XColor("grey35", 89, 89, 89),
	401	new XColor("grey36", 92, 92, 92),
	402	new XColor("grey37", 94, 94, 94),
	403	new XColor("grey38", 97, 97, 97),
	404	new XColor("grey39", 99, 99, 99),
	405	new XColor("grey4", 10, 10, 10),
	406	new XColor("grey40", 102, 102, 102),
	407	new XColor("grey41", 105, 105, 105),
	408	new XColor("grey42", 107, 107, 107),
	409	new XColor("grey43", 110, 110, 110),
	410	new XColor("grey44", 112, 112, 112),
	411	new XColor("grey45", 115, 115, 115),
	412	new XColor("grey46", 117, 117, 117),
	413	new XColor("grey47", 120, 120, 120),
	414	new XColor("grey48", 122, 122, 122),
	415	new XColor("grey49", 125, 125, 125),
	416	new XColor("grey5", 13, 13, 13),
	417	new XColor("grey50", 127, 127, 127),
	418	new XColor("grey51", 130, 130, 130),
	419	new XColor("grey52", 133, 133, 133),
	420	new XColor("grey53", 135, 135, 135),
	421	new XColor("grey54", 138, 138, 138),
	422	new XColor("grey55", 140, 140, 140),
	423	new XColor("grey56", 143, 143, 143),
	424	new XColor("grey57", 145, 145, 145),
	425	new XColor("grey58", 148, 148, 148),
	426	new XColor("grey59", 150, 150, 150),
	427	new XColor("grey6", 15, 15, 15),
	428	new XColor("grey60", 153, 153, 153),
	429	new XColor("grey61", 156, 156, 156),
	430	new XColor("grey62", 158, 158, 158),
	431	new XColor("grey63", 161, 161, 161),
	432	new XColor("grey64", 163, 163, 163),
	433	new XColor("grey65", 166, 166, 166),
	434	new XColor("grey66", 168, 168, 168),
	435	new XColor("grey67", 171, 171, 171),
	436	new XColor("grey68", 173, 173, 173),
	437	new XColor("grey69", 176, 176, 176),
	438	new XColor("grey7", 18, 18, 18),
	439	new XColor("grey70", 179, 179, 179),
	440	new XColor("grey71", 181, 181, 181),
	441	new XColor("grey72", 184, 184, 184),
	442	new XColor("grey73", 186, 186, 186),
	443	new XColor("grey74", 189, 189, 189),
	444	new XColor("grey75", 191, 191, 191),
	445	new XColor("grey76", 194, 194, 194),
	446	new XColor("grey77", 196, 196, 196),
	447	new XColor("grey78", 199, 199, 199),
	448	new XColor("grey79", 201, 201, 201),
	449	new XColor("grey8", 20, 20, 20),
	450	new XColor("grey80", 204, 204, 204),
	451	new XColor("grey81", 207, 207, 207),
	452	new XColor("grey82", 209, 209, 209),
	453	new XColor("grey83", 212, 212, 212),
	454	new XColor("grey84", 214, 214, 214),
	455	new XColor("grey85", 217, 217, 217),
	456	new XColor("grey86", 219, 219, 219),
	457	new XColor("grey87", 222, 222, 222),
	458	new XColor("grey88", 224, 224, 224),
	459	new XColor("grey89", 227, 227, 227),
	460	new XColor("grey9", 23, 23, 23),
	461	new XColor("grey90", 229, 229, 229),
	462	new XColor("grey91", 232, 232, 232),
	463	new XColor("grey92", 235, 235, 235),
	464	new XColor("grey93", 237, 237, 237),
	465	new XColor("grey94", 240, 240, 240),
	466	new XColor("grey95", 242, 242, 242),
	467	new XColor("grey96", 245, 245, 245),
	468	new XColor("grey97", 247, 247, 247),
	469	new XColor("grey98", 250, 250, 250),
	470	new XColor("grey99", 252, 252, 252),
	471	new XColor("honeydew", 240, 255, 240),
	472	new XColor("honeydew1", 240, 255, 240),
	473	new XColor("honeydew2", 224, 238, 224),
	474	new XColor("honeydew3", 193, 205, 193),
	475	new XColor("honeydew4", 131, 139, 131),
	476	new XColor("hot pink", 255, 105, 180),
	477	new XColor("hotpink", 255, 105, 180),
	478	new XColor("hotpink1", 255, 110, 180),
	479	new XColor("hotpink2", 238, 106, 167),
	480	new XColor("hotpink3", 205, 96, 144),
	481	new XColor("hotpink4", 139, 58, 98),
	482	new XColor("indian red", 205, 92, 92),
	483	new XColor("indianred", 205, 92, 92),
	484	new XColor("indianred1", 255, 106, 106),
	485	new XColor("indianred2", 238, 99, 99),
	486	new XColor("indianred3", 205, 85, 85),
	487	new XColor("indianred4", 139, 58, 58),
	488	new XColor("ivory", 255, 255, 240),
	489	new XColor("ivory1", 255, 255, 240),
	490	new XColor("ivory2", 238, 238, 224),
	491	new XColor("ivory3", 205, 205, 193),
	492	new XColor("ivory4", 139, 139, 131),
	493	new XColor("khaki", 240, 230, 140),
	494	new XColor("khaki1", 255, 246, 143),
	495	new XColor("khaki2", 238, 230, 133),
	496	new XColor("khaki3", 205, 198, 115),
	497	new XColor("khaki4", 139, 134, 78),
	498	new XColor("lavender", 230, 230, 250),
	499	new XColor("lavender blush", 255, 240, 245),
	500	new XColor("lavenderblush", 255, 240, 245),
	501	new XColor("lavenderblush1", 255, 240, 245),
	502	new XColor("lavenderblush2", 238, 224, 229),
	503	new XColor("lavenderblush3", 205, 193, 197),
	504	new XColor("lavenderblush4", 139, 131, 134),
	505	new XColor("lawn green", 124, 252, 0),
	506	new XColor("lawngreen", 124, 252, 0),
	507	new XColor("lemon chiffon", 255, 250, 205),
	508	new XColor("lemonchiffon", 255, 250, 205),
	509	new XColor("lemonchiffon1", 255, 250, 205),
	510	new XColor("lemonchiffon2", 238, 233, 191),
	511	new XColor("lemonchiffon3", 205, 201, 165),
	512	new XColor("lemonchiffon4", 139, 137, 112),
	513	new XColor("light blue", 173, 216, 230),
	514	new XColor("light coral", 240, 128, 128),
	515	new XColor("light cyan", 224, 255, 255),
	516	new XColor("light goldenrod", 238, 221, 130),
	517	new XColor("light goldenrod yellow", 250, 250, 210),
	518	new XColor("light gray", 211, 211, 211),
	519	new XColor("light green", 144, 238, 144),
	520	new XColor("light grey", 211, 211, 211),
	521	new XColor("light pink", 255, 182, 193),
	522	new XColor("light salmon", 255, 160, 122),
	523	new XColor("light sea green", 32, 178, 170),
	524	new XColor("light sky blue", 135, 206, 250),
	525	new XColor("light slate blue", 132, 112, 255),
	526	new XColor("light slate gray", 119, 136, 153),
	527	new XColor("light slate grey", 119, 136, 153),
	528	new XColor("light steel blue", 176, 196, 222),
	529	new XColor("light yellow", 255, 255, 224),
	530	new XColor("lightblue", 173, 216, 230),
	531	new XColor("lightblue1", 191, 239, 255),
	532	new XColor("lightblue2", 178, 223, 238),
	533	new XColor("lightblue3", 154, 192, 205),
	534	new XColor("lightblue4", 104, 131, 139),
	535	new XColor("lightcoral", 240, 128, 128),
	536	new XColor("lightcyan", 224, 255, 255),
	537	new XColor("lightcyan1", 224, 255, 255),
	538	new XColor("lightcyan2", 209, 238, 238),
	539	new XColor("lightcyan3", 180, 205, 205),
	540	new XColor("lightcyan4", 122, 139, 139),
	541	new XColor("lightgoldenrod", 238, 221, 130),
	542	new XColor("lightgoldenrod1", 255, 236, 139),
	543	new XColor("lightgoldenrod2", 238, 220, 130),
	544	new XColor("lightgoldenrod3", 205, 190, 112),
	545	new XColor("lightgoldenrod4", 139, 129, 76),
	546	new XColor("lightgoldenrodyellow", 250, 250, 210),
	547	new XColor("lightgray", 211, 211, 211),
	548	new XColor("lightgreen", 144, 238, 144),
	549	new XColor("lightgrey", 211, 211, 211),
	550	new XColor("lightpink", 255, 182, 193),
	551	new XColor("lightpink1", 255, 174, 185),
	552	new XColor("lightpink2", 238, 162, 173),
	553	new XColor("lightpink3", 205, 140, 149),
	554	new XColor("lightpink4", 139, 95, 101),
	555	new XColor("lightsalmon", 255, 160, 122),
	556	new XColor("lightsalmon1", 255, 160, 122),
	557	new XColor("lightsalmon2", 238, 149, 114),
	558	new XColor("lightsalmon3", 205, 129, 98),
	559	new XColor("lightsalmon4", 139, 87, 66),
	560	new XColor("lightseagreen", 32, 178, 170),
	561	new XColor("lightskyblue", 135, 206, 250),
	562	new XColor("lightskyblue1", 176, 226, 255),
	563	new XColor("lightskyblue2", 164, 211, 238),
	564	new XColor("lightskyblue3", 141, 182, 205),
	565	new XColor("lightskyblue4", 96, 123, 139),
	566	new XColor("lightslateblue", 132, 112, 255),
	567	new XColor("lightslategray", 119, 136, 153),
	568	new XColor("lightslategrey", 119, 136, 153),
	569	new XColor("lightsteelblue", 176, 196, 222),
	570	new XColor("lightsteelblue1", 202, 225, 255),
	571	new XColor("lightsteelblue2", 188, 210, 238),
	572	new XColor("lightsteelblue3", 162, 181, 205),
	573	new XColor("lightsteelblue4", 110, 123, 139),
	574	new XColor("lightyellow", 255, 255, 224),
	575	new XColor("lightyellow1", 255, 255, 224),
	576	new XColor("lightyellow2", 238, 238, 209),
	577	new XColor("lightyellow3", 205, 205, 180),
	578	new XColor("lightyellow4", 139, 139, 122),
	579	new XColor("lime green", 50, 205, 50),
	580	new XColor("limegreen", 50, 205, 50),
	581	new XColor("linen", 250, 240, 230),
	582	new XColor("magenta", 255, 0, 255),
	583	new XColor("magenta1", 255, 0, 255),
	584	new XColor("magenta2", 238, 0, 238),
	585	new XColor("magenta3", 205, 0, 205),
	586	new XColor("magenta4", 139, 0, 139),
	587	new XColor("maroon", 176, 48, 96),
	588	new XColor("maroon1", 255, 52, 179),
	589	new XColor("maroon2", 238, 48, 167),
	590	new XColor("maroon3", 205, 41, 144),
	591	new XColor("maroon4", 139, 28, 98),
	592	new XColor("medium aquamarine", 102, 205, 170),
	593	new XColor("medium blue", 0, 0, 205),
	594	new XColor("medium orchid", 186, 85, 211),
	595	new XColor("medium purple", 147, 112, 219),
	596	new XColor("medium sea green", 60, 179, 113),
	597	new XColor("medium slate blue", 123, 104, 238),
	598	new XColor("medium spring green", 0, 250, 154),
	599	new XColor("medium turquoise", 72, 209, 204),
	600	new XColor("medium violet red", 199, 21, 133),
	601	new XColor("mediumaquamarine", 102, 205, 170),
	602	new XColor("mediumblue", 0, 0, 205),
	603	new XColor("mediumorchid", 186, 85, 211),
	604	new XColor("mediumorchid1", 224, 102, 255),
	605	new XColor("mediumorchid2", 209, 95, 238),
	606	new XColor("mediumorchid3", 180, 82, 205),
	607	new XColor("mediumorchid4", 122, 55, 139),
	608	new XColor("mediumpurple", 147, 112, 219),
	609	new XColor("mediumpurple1", 171, 130, 255),
	610	new XColor("mediumpurple2", 159, 121, 238),
	611	new XColor("mediumpurple3", 137, 104, 205),
	612	new XColor("mediumpurple4", 93, 71, 139),
	613	new XColor("mediumseagreen", 60, 179, 113),
	614	new XColor("mediumslateblue", 123, 104, 238),
	615	new XColor("mediumspringgreen", 0, 250, 154),
	616	new XColor("mediumturquoise", 72, 209, 204),
	617	new XColor("mediumvioletred", 199, 21, 133),
	618	new XColor("midnight blue", 25, 25, 112),
	619	new XColor("midnightblue", 25, 25, 112),
	620	new XColor("mint cream", 245, 255, 250),
	621	new XColor("mintcream", 245, 255, 250),
	622	new XColor("misty rose", 255, 228, 225),
	623	new XColor("mistyrose", 255, 228, 225),
	624	new XColor("mistyrose1", 255, 228, 225),
	625	new XColor("mistyrose2", 238, 213, 210),
	626	new XColor("mistyrose3", 205, 183, 181),
	627	new XColor("mistyrose4", 139, 125, 123),
	628	new XColor("moccasin", 255, 228, 181),
	629	new XColor("navajo white", 255, 222, 173),
	630	new XColor("navajowhite", 255, 222, 173),
	631	new XColor("navajowhite1", 255, 222, 173),
	632	new XColor("navajowhite2", 238, 207, 161),
	633	new XColor("navajowhite3", 205, 179, 139),
	634	new XColor("navajowhite4", 139, 121, 94),
	635	new XColor("navy", 0, 0, 128),
	636	new XColor("navy blue", 0, 0, 128),
	637	new XColor("navyblue", 0, 0, 128),
	638	new XColor("old lace", 253, 245, 230),
	639	new XColor("oldlace", 253, 245, 230),
	640	new XColor("olive drab", 107, 142, 35),
	641	new XColor("olivedrab", 107, 142, 35),
	642	new XColor("olivedrab1", 192, 255, 62),
	643	new XColor("olivedrab2", 179, 238, 58),
	644	new XColor("olivedrab3", 154, 205, 50),
	645	new XColor("olivedrab4", 105, 139, 34),
	646	new XColor("orange", 255, 165, 0),
	647	new XColor("orange red", 255, 69, 0),
	648	new XColor("orange1", 255, 165, 0),
	649	new XColor("orange2", 238, 154, 0),
	650	new XColor("orange3", 205, 133, 0),
	651	new XColor("orange4", 139, 90, 0),
	652	new XColor("orangered", 255, 69, 0),
	653	new XColor("orangered1", 255, 69, 0),
	654	new XColor("orangered2", 238, 64, 0),
	655	new XColor("orangered3", 205, 55, 0),
	656	new XColor("orangered4", 139, 37, 0),
	657	new XColor("orchid", 218, 112, 214),
	658	new XColor("orchid1", 255, 131, 250),
	659	new XColor("orchid2", 238, 122, 233),
	660	new XColor("orchid3", 205, 105, 201),
	661	new XColor("orchid4", 139, 71, 137),
	662	new XColor("pale goldenrod", 238, 232, 170),
	663	new XColor("pale green", 152, 251, 152),
	664	new XColor("pale turquoise", 175, 238, 238),
	665	new XColor("pale violet red", 219, 112, 147),
	666	new XColor("palegoldenrod", 238, 232, 170),
	667	new XColor("palegreen", 152, 251, 152),
	668	new XColor("palegreen1", 154, 255, 154),
	669	new XColor("palegreen2", 144, 238, 144),
	670	new XColor("palegreen3", 124, 205, 124),
	671	new XColor("palegreen4", 84, 139, 84),
	672	new XColor("paleturquoise", 175, 238, 238),
	673	new XColor("paleturquoise1", 187, 255, 255),
	674	new XColor("paleturquoise2", 174, 238, 238),
	675	new XColor("paleturquoise3", 150, 205, 205),
	676	new XColor("paleturquoise4", 102, 139, 139),
	677	new XColor("palevioletred", 219, 112, 147),
	678	new XColor("palevioletred1", 255, 130, 171),
	679	new XColor("palevioletred2", 238, 121, 159),
	680	new XColor("palevioletred3", 205, 104, 137),
	681	new XColor("palevioletred4", 139, 71, 93),
	682	new XColor("papaya whip", 255, 239, 213),
	683	new XColor("papayawhip", 255, 239, 213),
	684	new XColor("peach puff", 255, 218, 185),
	685	new XColor("peachpuff", 255, 218, 185),
	686	new XColor("peachpuff1", 255, 218, 185),
	687	new XColor("peachpuff2", 238, 203, 173),
	688	new XColor("peachpuff3", 205, 175, 149),
	689	new XColor("peachpuff4", 139, 119, 101),
	690	new XColor("peru", 205, 133, 63),
	691	new XColor("pink", 255, 192, 203),
	692	new XColor("pink1", 255, 181, 197),
	693	new XColor("pink2", 238, 169, 184),
	694	new XColor("pink3", 205, 145, 158),
	695	new XColor("pink4", 139, 99, 108),
	696	new XColor("plum", 221, 160, 221),
	697	new XColor("plum1", 255, 187, 255),
	698	new XColor("plum2", 238, 174, 238),
	699	new XColor("plum3", 205, 150, 205),
	700	new XColor("plum4", 139, 102, 139),
	701	new XColor("powder blue", 176, 224, 230),
	702	new XColor("powderblue", 176, 224, 230),
	703	new XColor("purple", 160, 32, 240),
	704	new XColor("purple1", 155, 48, 255),
	705	new XColor("purple2", 145, 44, 238),
	706	new XColor("purple3", 125, 38, 205),
	707	new XColor("purple4", 85, 26, 139),
	708	new XColor("red", 255, 0, 0),
	709	new XColor("red1", 255, 0, 0),
	710	new XColor("red2", 238, 0, 0),
	711	new XColor("red3", 205, 0, 0),
	712	new XColor("red4", 139, 0, 0),
	713	new XColor("rosy brown", 188, 143, 143),
	714	new XColor("rosybrown", 188, 143, 143),
	715	new XColor("rosybrown1", 255, 193, 193),
	716	new XColor("rosybrown2", 238, 180, 180),
	717	new XColor("rosybrown3", 205, 155, 155),
	718	new XColor("rosybrown4", 139, 105, 105),
	719	new XColor("royal blue", 65, 105, 225),
	720	new XColor("royalblue", 65, 105, 225),
	721	new XColor("royalblue1", 72, 118, 255),
	722	new XColor("royalblue2", 67, 110, 238),
	723	new XColor("royalblue3", 58, 95, 205),
	724	new XColor("royalblue4", 39, 64, 139),
	725	new XColor("saddle brown", 139, 69, 19),
	726	new XColor("saddlebrown", 139, 69, 19),
	727	new XColor("salmon", 250, 128, 114),
	728	new XColor("salmon1", 255, 140, 105),
	729	new XColor("salmon2", 238, 130, 98),
	730	new XColor("salmon3", 205, 112, 84),
	731	new XColor("salmon4", 139, 76, 57),
	732	new XColor("sandy brown", 244, 164, 96),
	733	new XColor("sandybrown", 244, 164, 96),
	734	new XColor("sea green", 46, 139, 87),
	735	new XColor("seagreen", 46, 139, 87),
	736	new XColor("seagreen1", 84, 255, 159),
	737	new XColor("seagreen2", 78, 238, 148),
	738	new XColor("seagreen3", 67, 205, 128),
	739	new XColor("seagreen4", 46, 139, 87),
	740	new XColor("seashell", 255, 245, 238),
	741	new XColor("seashell1", 255, 245, 238),
	742	new XColor("seashell2", 238, 229, 222),
	743	new XColor("seashell3", 205, 197, 191),
	744	new XColor("seashell4", 139, 134, 130),
	745	new XColor("sienna", 160, 82, 45),
	746	new XColor("sienna1", 255, 130, 71),
	747	new XColor("sienna2", 238, 121, 66),
	748	new XColor("sienna3", 205, 104, 57),
	749	new XColor("sienna4", 139, 71, 38),
	750	new XColor("sky blue", 135, 206, 235),
	751	new XColor("skyblue", 135, 206, 235),
	752	new XColor("skyblue1", 135, 206, 255),
	753	new XColor("skyblue2", 126, 192, 238),
	754	new XColor("skyblue3", 108, 166, 205),
	755	new XColor("skyblue4", 74, 112, 139),
	756	new XColor("slate blue", 106, 90, 205),
	757	new XColor("slate gray", 112, 128, 144),
	758	new XColor("slate grey", 112, 128, 144),
	759	new XColor("slateblue", 106, 90, 205),
	760	new XColor("slateblue1", 131, 111, 255),
	761	new XColor("slateblue2", 122, 103, 238),
	762	new XColor("slateblue3", 105, 89, 205),
	763	new XColor("slateblue4", 71, 60, 139),
	764	new XColor("slategray", 112, 128, 144),
	765	new XColor("slategray1", 198, 226, 255),
	766	new XColor("slategray2", 185, 211, 238),
	767	new XColor("slategray3", 159, 182, 205),
	768	new XColor("slategray4", 108, 123, 139),
	769	new XColor("slategrey", 112, 128, 144),
	770	new XColor("snow", 255, 250, 250),
	771	new XColor("snow1", 255, 250, 250),
	772	new XColor("snow2", 238, 233, 233),
	773	new XColor("snow3", 205, 201, 201),
	774	new XColor("snow4", 139, 137, 137),
	775	new XColor("spring green", 0, 255, 127),
	776	new XColor("springgreen", 0, 255, 127),
	777	new XColor("springgreen1", 0, 255, 127),
	778	new XColor("springgreen2", 0, 238, 118),
	779	new XColor("springgreen3", 0, 205, 102),
	780	new XColor("springgreen4", 0, 139, 69),
	781	new XColor("steel blue", 70, 130, 180),
	782	new XColor("steelblue", 70, 130, 180),
	783	new XColor("steelblue1", 99, 184, 255),
	784	new XColor("steelblue2", 92, 172, 238),
	785	new XColor("steelblue3", 79, 148, 205),
	786	new XColor("steelblue4", 54, 100, 139),
	787	new XColor("tan", 210, 180, 140),
	788	new XColor("tan1", 255, 165, 79),
	789	new XColor("tan2", 238, 154, 73),
	790	new XColor("tan3", 205, 133, 63),
	791	new XColor("tan4", 139, 90, 43),
	792	new XColor("thistle", 216, 191, 216),
	793	new XColor("thistle1", 255, 225, 255),
	794	new XColor("thistle2", 238, 210, 238),
	795	new XColor("thistle3", 205, 181, 205),
	796	new XColor("thistle4", 139, 123, 139),
	797	new XColor("tomato", 255, 99, 71),
	798	new XColor("tomato1", 255, 99, 71),
	799	new XColor("tomato2", 238, 92, 66),
	800	new XColor("tomato3", 205, 79, 57),
	801	new XColor("tomato4", 139, 54, 38),
	802	new XColor("turquoise", 64, 224, 208),
	803	new XColor("turquoise1", 0, 245, 255),
	804	new XColor("turquoise2", 0, 229, 238),
	805	new XColor("turquoise3", 0, 197, 205),
	806	new XColor("turquoise4", 0, 134, 139),
	807	new XColor("violet", 238, 130, 238),
	808	new XColor("violet red", 208, 32, 144),
	809	new XColor("violetred", 208, 32, 144),
	810	new XColor("violetred1", 255, 62, 150),
	811	new XColor("violetred2", 238, 58, 140),
	812	new XColor("violetred3", 205, 50, 120),
	813	new XColor("violetred4", 139, 34, 82),
	814	new XColor("wheat", 245, 222, 179),
	815	new XColor("wheat1", 255, 231, 186),
	816	new XColor("wheat2", 238, 216, 174),
	817	new XColor("wheat3", 205, 186, 150),
	818	new XColor("wheat4", 139, 126, 102),
	819	new XColor("white", 255, 255, 255),
	820	new XColor("white smoke", 245, 245, 245),
	821	new XColor("whitesmoke", 245, 245, 245),
	822	new XColor("yellow", 255, 255, 0),
	823	new XColor("yellow green", 154, 205, 50),
	824	new XColor("yellow1", 255, 255, 0),
	825	new XColor("yellow2", 238, 238, 0),
	826	new XColor("yellow3", 205, 205, 0),
	827	new XColor("yellow4", 139, 139, 0),
	828	new XColor("yellowgreen", 154, 205, 5)
	829	};
	830
	831	}

java/pkg/com/sun/java/swing/plaf/gtk/icons/Directory.gif+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/gtk/icons/File.gif+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/gtk/icons/image-delayed.png+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/gtk/icons/image-failed.png+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/gtk/icons/mkfile+2−0

@@ -0,0 +1,2 @@
	1	<../../../../../../../../../mkconfig
	2

java/pkg/com/sun/java/swing/plaf/gtk/mkfile+27−0

@@ -0,0 +1,27 @@
	1	<../../../../../../../../mkconfig
	2
	3	DIRS=\
	4	icons\
	5	resources\
	6
	7	TARG=\
	8	GTKColorChooserPanel.dis\
	9	GTKColorType.dis\
	10	GTKConstants.dis\
	11	GTKEngine.dis\
	12	GTKFileChooserUI.dis\
	13	GTKGraphicsUtils.dis\
	14	GTKIconFactory.dis\
	15	GTKLookAndFeel.dis\
	16	GTKPainter.dis\
	17	GTKRegion.dis\
	18	GTKStyle.dis\
	19	GTKStyleFactory.dis\
	20	Metacity.dis\
	21	PangoFonts.dis\
	22	XColors.dis\
	23
	24	DISBIN=$ROOT/java/dis/java/java/com/sun/java/swing/plaf/gtk
	25
	26	<$ROOT/mkfiles/mkjava
	27	<$ROOT/mkfiles/mksubdirs

java/pkg/com/sun/java/swing/plaf/gtk/resources/gtk.properties+83−0

@@ -0,0 +1,83 @@
	1	# Refer to the note in basic.properties for a description as to what
	2	# the mnemonics correspond to and how to calculate them.
	3
	4
	5
	6	# GTK specific properties
	7
	8	# GTK color chooser properties:
	9	GTKColorChooserPanel.nameText=GTK Color Chooser
	10	# mnemonic as a VK_ constant
	11	GTKColorChooserPanel.mnemonic=71
	12	# Can also define GTKColorChooserPanel.dispalyedMnemonicIndex if you
	13	# want an index other than would normally be underlined by
	14	# GTKColorChooserPanel.mnemonic to be underlined. This is only useful
	15	# if GTKColorChooserPanel.nameText defines the mnemonic character more
	16	# than once and you want a character other than the first underlined.
	17
	18	# Text and mnemonics for the spinner. You can also defined a different
	19	# index for the mnemonic via xxxMnemonicIndex, for example
	20	# GTKColorChooserPanel.hueMnemonicIndex=1 would indicate the second
	21	# character of GTKColorChooserPanel.hueText should be underlined to
	22	# represent the mnemonic.
	23	GTKColorChooserPanel.hueText=Hue:
	24	GTKColorChooserPanel.hueMnemonic=72
	25
	26	GTKColorChooserPanel.redText=Red:
	27	GTKColorChooserPanel.redMnemonic=69
	28
	29	GTKColorChooserPanel.saturationText=Saturation:
	30	GTKColorChooserPanel.saturationMnemonic=83
	31
	32	GTKColorChooserPanel.greenText=Green:
	33	GTKColorChooserPanel.greenMnemonic=71
	34
	35	GTKColorChooserPanel.valueText=Value:
	36	GTKColorChooserPanel.valueMnemonic=86
	37
	38	GTKColorChooserPanel.blueText=Blue:
	39	GTKColorChooserPanel.blueMnemonic=66
	40
	41	GTKColorChooserPanel.colorNameText=Color Name:
	42	GTKColorChooserPanel.colorNameMnemonic=78
	43
	44
	45
	46	############ FILE CHOOSER STRINGS #############
	47
	48	FileChooser.acceptAllFileFilterText=All Files
	49	FileChooser.newFolderButtonText=New Folder
	50	FileChooser.newFolderButtonMnemonic=78
	51	FileChooser.newFolderDialogText=Folder name:
	52	FileChooser.newFolderNoDirectoryErrorTitleText=Error
	53	FileChooser.newFolderNoDirectoryErrorText=Error creating directory "{0}": No such file or directory
	54	FileChooser.deleteFileButtonText=Delete File
	55	FileChooser.deleteFileButtonMnemonic=76
	56	FileChooser.renameFileButtonText=Rename File
	57	FileChooser.renameFileButtonMnemonic=82
	58	FileChooser.cancelButtonText=Cancel
	59	FileChooser.cancelButtonMnemonic=67
	60	FileChooser.saveButtonText=OK
	61	FileChooser.saveButtonMnemonic=79
	62	FileChooser.openButtonText=OK
	63	FileChooser.openButtonMnemonic=79
	64	FileChooser.saveDialogTitleText=Save
	65	FileChooser.openDialogTitleText=Open
	66	FileChooser.pathLabelText=Selection:
	67	FileChooser.filterLabelText=Filter:
	68	FileChooser.pathLabelMnemonic=83
	69	FileChooser.foldersLabelText=Folders
	70	FileChooser.foldersLabelMnemonic=68
	71	FileChooser.filesLabelText=Files
	72	FileChooser.filesLabelMnemonic=70
	73
	74	FileChooser.cancelButtonToolTipText=Abort file chooser dialog.
	75	FileChooser.saveButtonToolTipText=Save selected file.
	76	FileChooser.openButtonToolTipText=Open selected file.
	77
	78	FileChooser.renameFileDialogText=Rename file "{0}" to
	79	FileChooser.renameFileErrorTitle=Error
	80	FileChooser.renameFileErrorText=Error renaming file "{0}" to "{1}"
	81
	82	OptionPane.okButtonMnemonic=79
	83	OptionPane.cancelButtonMnemonic=67

java/pkg/com/sun/java/swing/plaf/gtk/resources/gtk_de.properties+88−0

@@ -0,0 +1,88 @@
	1	# Refer to the note in basic.properties for a description as to what
	2	# the mnemonics correspond to and how to calculate them.
	3
	4
	5
	6	# GTK specific properties
	7
	8	# GTK color chooser properties:
	9	GTKColorChooserPanel.nameText=GTK-Farbauswahl
	10	# mnemonic as a VK_ constant
	11	GTKColorChooserPanel.mnemonic=71
	12	# Can also define GTKColorChooserPanel.dispalyedMnemonicIndex if you
	13	# want an index other than would normally be underlined by
	14	# GTKColorChooserPanel.mnemonic to be underlined. This is only useful
	15	# if GTKColorChooserPanel.nameText defines the mnemonic character more
	16	# than once and you want a character other than the first underlined.
	17
	18	# Text and mnemonics for the spinner. You can also defined a different
	19	# index for the mnemonic via xxxMnemonicIndex, for example
	20	# GTKColorChooserPanel.hueMnemonicIndex=1 would indicate the second
	21	# character of GTKColorChooserPanel.hueText should be underlined to
	22	# represent the mnemonic.
	23	GTKColorChooserPanel.hueText=Farbton:
	24	GTKColorChooserPanel.hueMnemonic=70
	25
	26	GTKColorChooserPanel.redText=Rot:
	27	GTKColorChooserPanel.redMnemonic=82
	28
	29	GTKColorChooserPanel.saturationText=S\u00E4ttigung:
	30	GTKColorChooserPanel.saturationMnemonic=83
	31
	32	GTKColorChooserPanel.greenText=Gr\u00FCn:
	33	GTKColorChooserPanel.greenMnemonic=71
	34
	35	GTKColorChooserPanel.valueText=Wert:
	36	GTKColorChooserPanel.valueMnemonic=87
	37
	38	GTKColorChooserPanel.blueText=Blau:
	39	GTKColorChooserPanel.blueMnemonic=66
	40
	41	GTKColorChooserPanel.colorNameText=Farbname:
	42	GTKColorChooserPanel.colorNameMnemonic=78
	43
	44
	45
	46	############ FILE CHOOSER STRINGS #############
	47
	48	FileChooser.acceptAllFileFilterText=Alle Dateien
	49	FileChooser.newFolderButtonText=Neuer Ordner
	50	FileChooser.newFolderButtonMnemonic=78
	51	FileChooser.newFolderDialogText=Ordnername:
	52	FileChooser.newFolderNoDirectoryErrorTitleText=Fehler
	53	FileChooser.newFolderNoDirectoryErrorText=Fehler beim Erstellen von Verzeichnis "{0}": Datei oder Verzeichnis nicht vorhanden
	54	FileChooser.deleteFileButtonText=Datei l\u00F6schen
	55	FileChooser.deleteFileButtonMnemonic=76
	56	FileChooser.renameFileButtonText=Datei umbenennen
	57	FileChooser.renameFileButtonMnemonic=85
	58	FileChooser.cancelButtonText=Abbrechen
	59	FileChooser.cancelButtonMnemonic=65
	60	FileChooser.saveButtonText=OK
	61	FileChooser.saveButtonMnemonic=79
	62	FileChooser.openButtonText=OK
	63	FileChooser.openButtonMnemonic=79
	64	FileChooser.saveDialogTitleText=Speichern
	65	FileChooser.openDialogTitleText=\u00D6ffnen
	66	FileChooser.pathLabelText=Auswahl:
	67	FileChooser.filterLabelText=Filter:
	68	FileChooser.pathLabelMnemonic=87
	69	FileChooser.foldersLabelText=Ordner
	70	FileChooser.foldersLabelMnemonic=79
	71	FileChooser.filesLabelText=Dateien
	72	FileChooser.filesLabelMnemonic=68
	73
	74	FileChooser.cancelButtonToolTipText=Dialogfeld f\u00FCr Dateiauswahl schlie\u00DFen.
	75	FileChooser.saveButtonToolTipText=Ausgew\u00E4hlte Datei speichern.
	76	FileChooser.openButtonToolTipText=Ausgew\u00E4hlte Datei \u00F6ffnen.
	77
	78	FileChooser.renameFileDialogText=Datei "{0}" umbenennen in
	79	FileChooser.renameFileErrorTitle=Fehler
	80	FileChooser.renameFileErrorText=Fehler beim Umbenennen der Datei "{0}" in "{1}"
	81
	82	# dummy resource added for translation automation
	83	OptionPane.okButtonText=OK
	84	OptionPane.okButtonMnemonic=79
	85	# dummy resource added for translation automation
	86	OptionPane.cancelButtonText=Abbrechen
	87	OptionPane.cancelButtonMnemonic=65
	88

java/pkg/com/sun/java/swing/plaf/gtk/resources/gtk_es.properties+88−0

@@ -0,0 +1,88 @@
	1	# Refer to the note in basic.properties for a description as to what
	2	# the mnemonics correspond to and how to calculate them.
	3
	4
	5
	6	# GTK specific properties
	7
	8	# GTK color chooser properties:
	9	GTKColorChooserPanel.nameText=Selector de Color para GTK
	10	# mnemonic as a VK_ constant
	11	GTKColorChooserPanel.mnemonic=71
	12	# Can also define GTKColorChooserPanel.dispalyedMnemonicIndex if you
	13	# want an index other than would normally be underlined by
	14	# GTKColorChooserPanel.mnemonic to be underlined. This is only useful
	15	# if GTKColorChooserPanel.nameText defines the mnemonic character more
	16	# than once and you want a character other than the first underlined.
	17
	18	# Text and mnemonics for the spinner. You can also defined a different
	19	# index for the mnemonic via xxxMnemonicIndex, for example
	20	# GTKColorChooserPanel.hueMnemonicIndex=1 would indicate the second
	21	# character of GTKColorChooserPanel.hueText should be underlined to
	22	# represent the mnemonic.
	23	GTKColorChooserPanel.hueText=Mat:
	24	GTKColorChooserPanel.hueMnemonic=77
	25
	26	GTKColorChooserPanel.redText=Rojo:
	27	GTKColorChooserPanel.redMnemonic=74
	28
	29	GTKColorChooserPanel.saturationText=Saturaci\u00F3n:
	30	GTKColorChooserPanel.saturationMnemonic=83
	31
	32	GTKColorChooserPanel.greenText=Verde:
	33	GTKColorChooserPanel.greenMnemonic=69
	34
	35	GTKColorChooserPanel.valueText=Valor:
	36	GTKColorChooserPanel.valueMnemonic=86
	37
	38	GTKColorChooserPanel.blueText=Azul:
	39	GTKColorChooserPanel.blueMnemonic=65
	40
	41	GTKColorChooserPanel.colorNameText=Nombre del Color:
	42	GTKColorChooserPanel.colorNameMnemonic=78
	43
	44
	45
	46	############ FILE CHOOSER STRINGS #############
	47
	48	FileChooser.acceptAllFileFilterText=Todos los Archivos
	49	FileChooser.newFolderButtonText=Nueva Carpeta
	50	FileChooser.newFolderButtonMnemonic=78
	51	FileChooser.newFolderDialogText=Nombre de la Carpeta:
	52	FileChooser.newFolderNoDirectoryErrorTitleText=Error
	53	FileChooser.newFolderNoDirectoryErrorText=Error al crear el directorio "{0}": no existe dicho archivo o directorio
	54	FileChooser.deleteFileButtonText=Suprimir Archivo
	55	FileChooser.deleteFileButtonMnemonic=80
	56	FileChooser.renameFileButtonText=Cambiar Nombre de Archivo
	57	FileChooser.renameFileButtonMnemonic=82
	58	FileChooser.cancelButtonText=Cancelar
	59	FileChooser.cancelButtonMnemonic=67
	60	FileChooser.saveButtonText=Aceptar
	61	FileChooser.saveButtonMnemonic=65
	62	FileChooser.openButtonText=Aceptar
	63	FileChooser.openButtonMnemonic=65
	64	FileChooser.saveDialogTitleText=Guardar
	65	FileChooser.openDialogTitleText=Abrir
	66	FileChooser.pathLabelText=Selecci\u00F3n:
	67	FileChooser.filterLabelText=Filtro:
	68	FileChooser.pathLabelMnemonic=83
	69	FileChooser.foldersLabelText=Carpetas
	70	FileChooser.foldersLabelMnemonic=84
	71	FileChooser.filesLabelText=Archivos
	72	FileChooser.filesLabelMnemonic=65
	73
	74	FileChooser.cancelButtonToolTipText=Abortar cuadro de di\u00E1logo del selector de archivos.
	75	FileChooser.saveButtonToolTipText=Guardar el archivo seleccionado.
	76	FileChooser.openButtonToolTipText=Abrir el archivo seleccionado.
	77
	78	FileChooser.renameFileDialogText=Cambiar el nombre del archivo "{0}" por
	79	FileChooser.renameFileErrorTitle=Error
	80	FileChooser.renameFileErrorText=Error al cambiar el nombre del archivo "{0}" a "{1}"
	81
	82	# dummy resource added for translation automation
	83	OptionPane.okButtonText=Aceptar
	84	OptionPane.okButtonMnemonic=65
	85	# dummy resource added for translation automation
	86	OptionPane.cancelButtonText=Cancelar
	87	OptionPane.cancelButtonMnemonic=67
	88

java/pkg/com/sun/java/swing/plaf/gtk/resources/gtk_fr.properties+88−0

@@ -0,0 +1,88 @@
	1	# Refer to the note in basic.properties for a description as to what
	2	# the mnemonics correspond to and how to calculate them.
	3
	4
	5
	6	# GTK specific properties
	7
	8	# GTK color chooser properties:
	9	GTKColorChooserPanel.nameText=S\u00E9lecteur de couleurs GTK
	10	# mnemonic as a VK_ constant
	11	GTKColorChooserPanel.mnemonic=71
	12	# Can also define GTKColorChooserPanel.dispalyedMnemonicIndex if you
	13	# want an index other than would normally be underlined by
	14	# GTKColorChooserPanel.mnemonic to be underlined. This is only useful
	15	# if GTKColorChooserPanel.nameText defines the mnemonic character more
	16	# than once and you want a character other than the first underlined.
	17
	18	# Text and mnemonics for the spinner. You can also defined a different
	19	# index for the mnemonic via xxxMnemonicIndex, for example
	20	# GTKColorChooserPanel.hueMnemonicIndex=1 would indicate the second
	21	# character of GTKColorChooserPanel.hueText should be underlined to
	22	# represent the mnemonic.
	23	GTKColorChooserPanel.hueText=Teinte :
	24	GTKColorChooserPanel.hueMnemonic=84
	25
	26	GTKColorChooserPanel.redText=Rouge\u00A0:
	27	GTKColorChooserPanel.redMnemonic=69
	28
	29	GTKColorChooserPanel.saturationText=Saturation :
	30	GTKColorChooserPanel.saturationMnemonic=83
	31
	32	GTKColorChooserPanel.greenText=Vert :
	33	GTKColorChooserPanel.greenMnemonic=69
	34
	35	GTKColorChooserPanel.valueText=Valeur :
	36	GTKColorChooserPanel.valueMnemonic=86
	37
	38	GTKColorChooserPanel.blueText=Bleu :
	39	GTKColorChooserPanel.blueMnemonic=66
	40
	41	GTKColorChooserPanel.colorNameText=Nom de couleur :
	42	GTKColorChooserPanel.colorNameMnemonic=78
	43
	44
	45
	46	############ FILE CHOOSER STRINGS #############
	47
	48	FileChooser.acceptAllFileFilterText=Tous les fichiers
	49	FileChooser.newFolderButtonText=Nouveau dossier
	50	FileChooser.newFolderButtonMnemonic=78
	51	FileChooser.newFolderDialogText=Nom du dossier :
	52	FileChooser.newFolderNoDirectoryErrorTitleText=Erreur
	53	FileChooser.newFolderNoDirectoryErrorText=Erreur lors de la cr\u00E9ation du r\u00E9pertoire "{0}" : ce fichier ou r\u00E9pertoire n''existe pas
	54	FileChooser.deleteFileButtonText=Supprimer le fichier
	55	FileChooser.deleteFileButtonMnemonic=76
	56	FileChooser.renameFileButtonText=Renommer le fichier
	57	FileChooser.renameFileButtonMnemonic=82
	58	FileChooser.cancelButtonText=Annuler
	59	FileChooser.cancelButtonMnemonic=65
	60	FileChooser.saveButtonText=OK
	61	FileChooser.saveButtonMnemonic=79
	62	FileChooser.openButtonText=OK
	63	FileChooser.openButtonMnemonic=79
	64	FileChooser.saveDialogTitleText=Enregistrer
	65	FileChooser.openDialogTitleText=Ouvrir
	66	FileChooser.pathLabelText=S\u00E9lection :
	67	FileChooser.filterLabelText=Filtre :
	68	FileChooser.pathLabelMnemonic=83
	69	FileChooser.foldersLabelText=Dossiers
	70	FileChooser.foldersLabelMnemonic=68
	71	FileChooser.filesLabelText=Fichiers
	72	FileChooser.filesLabelMnemonic=70
	73
	74	FileChooser.cancelButtonToolTipText=Ferme la bo\u00EEte de dialogue du s\u00E9lecteur de fichiers.
	75	FileChooser.saveButtonToolTipText=Enregistre le fichier s\u00E9lectionn\u00E9.
	76	FileChooser.openButtonToolTipText=Ouvre le fichier s\u00E9lectionn\u00E9.
	77
	78	FileChooser.renameFileDialogText=Renomme le fichier "{0}" en
	79	FileChooser.renameFileErrorTitle=Erreur
	80	FileChooser.renameFileErrorText=Erreur lors du changement de nom du fichier "{0}" en "{1}"
	81
	82	# dummy resource added for translation automation
	83	OptionPane.okButtonText=OK
	84	OptionPane.okButtonMnemonic=79
	85	# dummy resource added for translation automation
	86	OptionPane.cancelButtonText=Annuler
	87	OptionPane.cancelButtonMnemonic=65
	88

java/pkg/com/sun/java/swing/plaf/gtk/resources/gtk_it.properties+88−0

@@ -0,0 +1,88 @@
	1	# Refer to the note in basic.properties for a description as to what
	2	# the mnemonics correspond to and how to calculate them.
	3
	4
	5
	6	# GTK specific properties
	7
	8	# GTK color chooser properties:
	9	GTKColorChooserPanel.nameText=Selezione colore GTK
	10	# mnemonic as a VK_ constant
	11	GTKColorChooserPanel.mnemonic=71
	12	# Can also define GTKColorChooserPanel.dispalyedMnemonicIndex if you
	13	# want an index other than would normally be underlined by
	14	# GTKColorChooserPanel.mnemonic to be underlined. This is only useful
	15	# if GTKColorChooserPanel.nameText defines the mnemonic character more
	16	# than once and you want a character other than the first underlined.
	17
	18	# Text and mnemonics for the spinner. You can also defined a different
	19	# index for the mnemonic via xxxMnemonicIndex, for example
	20	# GTKColorChooserPanel.hueMnemonicIndex=1 would indicate the second
	21	# character of GTKColorChooserPanel.hueText should be underlined to
	22	# represent the mnemonic.
	23	GTKColorChooserPanel.hueText=Ton.:
	24	GTKColorChooserPanel.hueMnemonic=84
	25
	26	GTKColorChooserPanel.redText=Rosso:
	27	GTKColorChooserPanel.redMnemonic=79
	28
	29	GTKColorChooserPanel.saturationText=Saturazione:
	30	GTKColorChooserPanel.saturationMnemonic=83
	31
	32	GTKColorChooserPanel.greenText=Verde:
	33	GTKColorChooserPanel.greenMnemonic=69
	34
	35	GTKColorChooserPanel.valueText=Valore:
	36	GTKColorChooserPanel.valueMnemonic=86
	37
	38	GTKColorChooserPanel.blueText=Blu:
	39	GTKColorChooserPanel.blueMnemonic=66
	40
	41	GTKColorChooserPanel.colorNameText=Nome colore:
	42	GTKColorChooserPanel.colorNameMnemonic=78
	43
	44
	45
	46	############ FILE CHOOSER STRINGS #############
	47
	48	FileChooser.acceptAllFileFilterText=Tutti i file
	49	FileChooser.newFolderButtonText=Nuova cartella
	50	FileChooser.newFolderButtonMnemonic=78
	51	FileChooser.newFolderDialogText=Nome della cartella:
	52	FileChooser.newFolderNoDirectoryErrorTitleText=Errore
	53	FileChooser.newFolderNoDirectoryErrorText=Errore durante la creazione della directory "{0}": file o directory inesistente
	54	FileChooser.deleteFileButtonText=Elimina file
	55	FileChooser.deleteFileButtonMnemonic=76
	56	FileChooser.renameFileButtonText=Rinomina file
	57	FileChooser.renameFileButtonMnemonic=82
	58	FileChooser.cancelButtonText=Annulla
	59	FileChooser.cancelButtonMnemonic=65
	60	FileChooser.saveButtonText=OK
	61	FileChooser.saveButtonMnemonic=79
	62	FileChooser.openButtonText=OK
	63	FileChooser.openButtonMnemonic=79
	64	FileChooser.saveDialogTitleText=Salva
	65	FileChooser.openDialogTitleText=Apri
	66	FileChooser.pathLabelText=Selezione:
	67	FileChooser.filterLabelText=Filtro:
	68	FileChooser.pathLabelMnemonic=83
	69	FileChooser.foldersLabelText=Cartelle
	70	FileChooser.foldersLabelMnemonic=84
	71	FileChooser.filesLabelText=File
	72	FileChooser.filesLabelMnemonic=70
	73
	74	FileChooser.cancelButtonToolTipText=Chiude la finestra di dialogo di selezione file.
	75	FileChooser.saveButtonToolTipText=Salva il file selezionato.
	76	FileChooser.openButtonToolTipText=Apre il file selezionato.
	77
	78	FileChooser.renameFileDialogText=Rinomina file "{0}" in
	79	FileChooser.renameFileErrorTitle=Errore
	80	FileChooser.renameFileErrorText=Errore durante la ridenominazione del file "{0}" in "{1}"
	81
	82	# dummy resource added for translation automation
	83	OptionPane.okButtonText=OK
	84	OptionPane.okButtonMnemonic=79
	85	# dummy resource added for translation automation
	86	OptionPane.cancelButtonText=Annulla
	87	OptionPane.cancelButtonMnemonic=65
	88

java/pkg/com/sun/java/swing/plaf/gtk/resources/gtk_ja.properties+84−0

@@ -0,0 +1,84 @@
	1	# Refer to the note in basic.properties for a description as to what
	2	# the mnemonics correspond to and how to calculate them.
	3
	4
	5
	6	# GTK specific properties
	7
	8	# GTK color chooser properties:
	9	GTKColorChooserPanel.nameText=GTK\u30AB\u30E9\u30FC\u30FB\u30C1\u30E5\u30FC\u30B6(G)
	10	# mnemonic as a VK_ constant
	11	GTKColorChooserPanel.mnemonic=71
	12	# Can also define GTKColorChooserPanel.dispalyedMnemonicIndex if you
	13	# want an index other than would normally be underlined by
	14	# GTKColorChooserPanel.mnemonic to be underlined. This is only useful
	15	# if GTKColorChooserPanel.nameText defines the mnemonic character more
	16	# than once and you want a character other than the first underlined.
	17
	18	# Text and mnemonics for the spinner. You can also defined a different
	19	# index for the mnemonic via xxxMnemonicIndex, for example
	20	# GTKColorChooserPanel.hueMnemonicIndex=1 would indicate the second
	21	# character of GTKColorChooserPanel.hueText should be underlined to
	22	# represent the mnemonic.
	23	GTKColorChooserPanel.hueText=\u8272\u76F8(H):
	24	GTKColorChooserPanel.hueMnemonic=72
	25
	26	GTKColorChooserPanel.redText=\u8D64(E):
	27	GTKColorChooserPanel.redMnemonic=69
	28
	29	GTKColorChooserPanel.saturationText=\u5F69\u5EA6(S):
	30	GTKColorChooserPanel.saturationMnemonic=83
	31
	32	GTKColorChooserPanel.greenText=\u7DD1(G):
	33	GTKColorChooserPanel.greenMnemonic=71
	34
	35	GTKColorChooserPanel.valueText=\u5024(V):
	36	GTKColorChooserPanel.valueMnemonic=86
	37
	38	GTKColorChooserPanel.blueText=\u9752(B):
	39	GTKColorChooserPanel.blueMnemonic=66
	40
	41	GTKColorChooserPanel.colorNameText=\u8272\u540D(N):
	42	GTKColorChooserPanel.colorNameMnemonic=78
	43
	44
	45
	46	############ FILE CHOOSER STRINGS #############
	47
	48	FileChooser.acceptAllFileFilterText=\u3059\u3079\u3066\u306E\u30D5\u30A1\u30A4\u30EB
	49	FileChooser.newFolderButtonText=\u65B0\u898F\u30D5\u30A9\u30EB\u30C0(N)
	50	FileChooser.newFolderButtonMnemonic=78
	51	FileChooser.newFolderDialogText=\u30D5\u30A9\u30EB\u30C0\u540D:
	52	FileChooser.newFolderNoDirectoryErrorTitleText=\u30A8\u30E9\u30FC
	53	FileChooser.newFolderNoDirectoryErrorText=\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA"{0}"\u306E\u4F5C\u6210\u4E2D\u306B\u30A8\u30E9\u30FC\u304C\u767A\u751F\u3057\u307E\u3057\u305F: \u3053\u306E\u30D5\u30A1\u30A4\u30EB\u307E\u305F\u306F\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u306F\u5B58\u5728\u3057\u307E\u305B\u3093
	54	FileChooser.deleteFileButtonText=\u30D5\u30A1\u30A4\u30EB\u306E\u524A\u9664(L)
	55	FileChooser.deleteFileButtonMnemonic=76
	56	FileChooser.renameFileButtonText=\u30D5\u30A1\u30A4\u30EB\u306E\u540D\u524D\u5909\u66F4(R)
	57	FileChooser.renameFileButtonMnemonic=82
	58	FileChooser.cancelButtonText=\u53D6\u6D88
	59	FileChooser.cancelButtonMnemonic=67
	60	FileChooser.saveButtonText=OK
	61	FileChooser.saveButtonMnemonic=79
	62	FileChooser.openButtonText=OK
	63	FileChooser.openButtonMnemonic=79
	64	FileChooser.saveDialogTitleText=\u4FDD\u5B58
	65	FileChooser.openDialogTitleText=\u958B\u304F
	66	FileChooser.pathLabelText=\u9078\u629E(S):
	67	FileChooser.filterLabelText=\u30D5\u30A3\u30EB\u30BF:
	68	FileChooser.pathLabelMnemonic=83
	69	FileChooser.foldersLabelText=\u30D5\u30A9\u30EB\u30C0(D)
	70	FileChooser.foldersLabelMnemonic=68
	71	FileChooser.filesLabelText=\u30D5\u30A1\u30A4\u30EB(F)
	72	FileChooser.filesLabelMnemonic=70
	73
	74	FileChooser.cancelButtonToolTipText=\u30D5\u30A1\u30A4\u30EB\u30FB\u30C1\u30E5\u30FC\u30B6\u30FB\u30C0\u30A4\u30A2\u30ED\u30B0\u3092\u7D42\u4E86\u3057\u307E\u3059\u3002
	75	FileChooser.saveButtonToolTipText=\u9078\u629E\u3057\u305F\u30D5\u30A1\u30A4\u30EB\u3092\u4FDD\u5B58\u3057\u307E\u3059\u3002
	76	FileChooser.openButtonToolTipText=\u9078\u629E\u3057\u305F\u30D5\u30A1\u30A4\u30EB\u3092\u958B\u304D\u307E\u3059\u3002
	77
	78	FileChooser.renameFileDialogText=\u30D5\u30A1\u30A4\u30EB"{0}"\u3092\u6B21\u306E\u540D\u524D\u306B\u5909\u66F4:
	79	FileChooser.renameFileErrorTitle=\u30A8\u30E9\u30FC
	80	FileChooser.renameFileErrorText=\u30D5\u30A1\u30A4\u30EB"{0}"\u306E"{1}"\u3078\u306E\u5909\u66F4\u4E2D\u306B\u30A8\u30E9\u30FC\u304C\u767A\u751F\u3057\u307E\u3057\u305F
	81
	82	#OptionPane.okButtonMnemonic=79
	83	#OptionPane.cancelButtonMnemonic=67
	84

java/pkg/com/sun/java/swing/plaf/gtk/resources/gtk_ko.properties+84−0

@@ -0,0 +1,84 @@
	1	# Refer to the note in basic.properties for a description as to what
	2	# the mnemonics correspond to and how to calculate them.
	3
	4
	5
	6	# GTK specific properties
	7
	8	# GTK color chooser properties:
	9	GTKColorChooserPanel.nameText=GTK \uC0C9\uC0C1 \uC120\uD0DD\uAE30(G)
	10	# mnemonic as a VK_ constant
	11	GTKColorChooserPanel.mnemonic=71
	12	# Can also define GTKColorChooserPanel.dispalyedMnemonicIndex if you
	13	# want an index other than would normally be underlined by
	14	# GTKColorChooserPanel.mnemonic to be underlined. This is only useful
	15	# if GTKColorChooserPanel.nameText defines the mnemonic character more
	16	# than once and you want a character other than the first underlined.
	17
	18	# Text and mnemonics for the spinner. You can also defined a different
	19	# index for the mnemonic via xxxMnemonicIndex, for example
	20	# GTKColorChooserPanel.hueMnemonicIndex=1 would indicate the second
	21	# character of GTKColorChooserPanel.hueText should be underlined to
	22	# represent the mnemonic.
	23	GTKColorChooserPanel.hueText=\uC0C9\uC870(H):
	24	GTKColorChooserPanel.hueMnemonic=72
	25
	26	GTKColorChooserPanel.redText=\uBE68\uAC04\uC0C9(E):
	27	GTKColorChooserPanel.redMnemonic=69
	28
	29	GTKColorChooserPanel.saturationText=\uCC44\uB3C4(S):
	30	GTKColorChooserPanel.saturationMnemonic=83
	31
	32	GTKColorChooserPanel.greenText=\uB179\uC0C9(G):
	33	GTKColorChooserPanel.greenMnemonic=71
	34
	35	GTKColorChooserPanel.valueText=\uAC12(V):
	36	GTKColorChooserPanel.valueMnemonic=86
	37
	38	GTKColorChooserPanel.blueText=\uD30C\uB780\uC0C9(B):
	39	GTKColorChooserPanel.blueMnemonic=66
	40
	41	GTKColorChooserPanel.colorNameText=\uC0C9\uC0C1 \uC774\uB984(N):
	42	GTKColorChooserPanel.colorNameMnemonic=78
	43
	44
	45
	46	############ FILE CHOOSER STRINGS #############
	47
	48	FileChooser.acceptAllFileFilterText=\uBAA8\uB4E0 \uD30C\uC77C
	49	FileChooser.newFolderButtonText=\uC0C8 \uD3F4\uB354(N)
	50	FileChooser.newFolderButtonMnemonic=78
	51	FileChooser.newFolderDialogText=\uD3F4\uB354 \uC774\uB984:
	52	FileChooser.newFolderNoDirectoryErrorTitleText=\uC624\uB958
	53	FileChooser.newFolderNoDirectoryErrorText="{0}" \uB514\uB809\uD1A0\uB9AC\uB97C \uC0DD\uC131\uD558\uB294 \uC911 \uC624\uB958 \uBC1C\uC0DD: \uD574\uB2F9 \uD30C\uC77C \uB610\uB294 \uB514\uB809\uD1A0\uB9AC\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.
	54	FileChooser.deleteFileButtonText=\uD30C\uC77C \uC0AD\uC81C(L)
	55	FileChooser.deleteFileButtonMnemonic=76
	56	FileChooser.renameFileButtonText=\uD30C\uC77C \uC774\uB984 \uBC14\uAFB8\uAE30(R)
	57	FileChooser.renameFileButtonMnemonic=82
	58	FileChooser.cancelButtonText=\uCDE8\uC18C
	59	FileChooser.cancelButtonMnemonic=67
	60	FileChooser.saveButtonText=\uD655\uC778
	61	FileChooser.saveButtonMnemonic=79
	62	FileChooser.openButtonText=\uD655\uC778
	63	FileChooser.openButtonMnemonic=79
	64	FileChooser.saveDialogTitleText=\uC800\uC7A5
	65	FileChooser.openDialogTitleText=\uC5F4\uAE30
	66	FileChooser.pathLabelText=\uC120\uD0DD \uC0AC\uD56D(S):
	67	FileChooser.filterLabelText=\uD544\uD130:
	68	FileChooser.pathLabelMnemonic=83
	69	FileChooser.foldersLabelText=\uD3F4\uB354(D)
	70	FileChooser.foldersLabelMnemonic=68
	71	FileChooser.filesLabelText=\uD30C\uC77C(F)
	72	FileChooser.filesLabelMnemonic=70
	73
	74	FileChooser.cancelButtonToolTipText=\uD30C\uC77C \uC120\uD0DD\uAE30 \uB300\uD654\uC0C1\uC790\uB97C \uC911\uB2E8\uD569\uB2C8\uB2E4.
	75	FileChooser.saveButtonToolTipText=\uC120\uD0DD\uB41C \uD30C\uC77C\uC744 \uC800\uC7A5\uD569\uB2C8\uB2E4.
	76	FileChooser.openButtonToolTipText=\uC120\uD0DD\uB41C \uD30C\uC77C\uC744 \uC5FD\uB2C8\uB2E4.
	77
	78	FileChooser.renameFileDialogText="{0}" \uD30C\uC77C\uC758 \uC774\uB984 \uBC14\uAFB8\uAE30
	79	FileChooser.renameFileErrorTitle=\uC624\uB958
	80	FileChooser.renameFileErrorText="{0}" \uD30C\uC77C\uC758 \uC774\uB984\uC744 "{1}"(\uC73C)\uB85C \uBC14\uAFB8\uB294 \uC911 \uC624\uB958\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4.
	81
	82	#OptionPane.okButtonMnemonic=79
	83	#OptionPane.cancelButtonMnemonic=67
	84

java/pkg/com/sun/java/swing/plaf/gtk/resources/gtk_pt_BR.properties+88−0

@@ -0,0 +1,88 @@
	1	# Refer to the note in basic.properties for a description as to what
	2	# the mnemonics correspond to and how to calculate them.
	3
	4
	5
	6	# GTK specific properties
	7
	8	# GTK color chooser properties:
	9	GTKColorChooserPanel.nameText=Seletor de Cores do GTK
	10	# mnemonic as a VK_ constant
	11	GTKColorChooserPanel.mnemonic=71
	12	# Can also define GTKColorChooserPanel.dispalyedMnemonicIndex if you
	13	# want an index other than would normally be underlined by
	14	# GTKColorChooserPanel.mnemonic to be underlined. This is only useful
	15	# if GTKColorChooserPanel.nameText defines the mnemonic character more
	16	# than once and you want a character other than the first underlined.
	17
	18	# Text and mnemonics for the spinner. You can also defined a different
	19	# index for the mnemonic via xxxMnemonicIndex, for example
	20	# GTKColorChooserPanel.hueMnemonicIndex=1 would indicate the second
	21	# character of GTKColorChooserPanel.hueText should be underlined to
	22	# represent the mnemonic.
	23	GTKColorChooserPanel.hueText=Matiz:
	24	GTKColorChooserPanel.hueMnemonic=77
	25
	26	GTKColorChooserPanel.redText=Vermelho:
	27	GTKColorChooserPanel.redMnemonic=69
	28
	29	GTKColorChooserPanel.saturationText=Satura\u00E7\u00E3o:
	30	GTKColorChooserPanel.saturationMnemonic=83
	31
	32	GTKColorChooserPanel.greenText=Verde:
	33	GTKColorChooserPanel.greenMnemonic=68
	34
	35	GTKColorChooserPanel.valueText=Valor:
	36	GTKColorChooserPanel.valueMnemonic=86
	37
	38	GTKColorChooserPanel.blueText=Azul:
	39	GTKColorChooserPanel.blueMnemonic=65
	40
	41	GTKColorChooserPanel.colorNameText=Nome da Cor:
	42	GTKColorChooserPanel.colorNameMnemonic=78
	43
	44
	45
	46	############ FILE CHOOSER STRINGS #############
	47
	48	FileChooser.acceptAllFileFilterText=Todos os Arquivos
	49	FileChooser.newFolderButtonText=Nova Pasta
	50	FileChooser.newFolderButtonMnemonic=78
	51	FileChooser.newFolderDialogText=Nome da pasta:
	52	FileChooser.newFolderNoDirectoryErrorTitleText=Erro
	53	FileChooser.newFolderNoDirectoryErrorText=Erro ao criar o diret\u00F3rio "{0}": N\u00E3o h\u00E1 arquivo ou diret\u00F3rio
	54	FileChooser.deleteFileButtonText=Deletar Arquivo
	55	FileChooser.deleteFileButtonMnemonic=76
	56	FileChooser.renameFileButtonText=Renomear Arquivo
	57	FileChooser.renameFileButtonMnemonic=82
	58	FileChooser.cancelButtonText=Cancelar
	59	FileChooser.cancelButtonMnemonic=67
	60	FileChooser.saveButtonText=OK
	61	FileChooser.saveButtonMnemonic=79
	62	FileChooser.openButtonText=OK
	63	FileChooser.openButtonMnemonic=79
	64	FileChooser.saveDialogTitleText=Salvar
	65	FileChooser.openDialogTitleText=Abrir
	66	FileChooser.pathLabelText=Sele\u00E7\u00E3o:
	67	FileChooser.filterLabelText=Filtro:
	68	FileChooser.pathLabelMnemonic=83
	69	FileChooser.foldersLabelText=Pastas
	70	FileChooser.foldersLabelMnemonic=80
	71	FileChooser.filesLabelText=Arquivos
	72	FileChooser.filesLabelMnemonic=65
	73
	74	FileChooser.cancelButtonToolTipText=Abortar caixa de di\u00E1logo do seletor de arquivos.
	75	FileChooser.saveButtonToolTipText=Salvar arquivo selecionado.
	76	FileChooser.openButtonToolTipText=Abrir arquivo selecionado.
	77
	78	FileChooser.renameFileDialogText=Renomear arquivo "{0}" por
	79	FileChooser.renameFileErrorTitle=Erro
	80	FileChooser.renameFileErrorText=Erro ao renomear o arquivo "{0}" por "{1}"
	81
	82	# dummy resource added for translation automation
	83	OptionPane.okButtonText=OK
	84	OptionPane.okButtonMnemonic=79
	85	# dummy resource added for translation automation
	86	OptionPane.cancelButtonText=Cancelar
	87	OptionPane.cancelButtonMnemonic=67
	88

java/pkg/com/sun/java/swing/plaf/gtk/resources/gtk_sv.properties+88−0

@@ -0,0 +1,88 @@
	1	# Refer to the note in basic.properties for a description as to what
	2	# the mnemonics correspond to and how to calculate them.
	3
	4
	5
	6	# GTK specific properties
	7
	8	# GTK color chooser properties:
	9	GTKColorChooserPanel.nameText=GTK-f\u00E4rgv\u00E4ljaren
	10	# mnemonic as a VK_ constant
	11	GTKColorChooserPanel.mnemonic=71
	12	# Can also define GTKColorChooserPanel.dispalyedMnemonicIndex if you
	13	# want an index other than would normally be underlined by
	14	# GTKColorChooserPanel.mnemonic to be underlined. This is only useful
	15	# if GTKColorChooserPanel.nameText defines the mnemonic character more
	16	# than once and you want a character other than the first underlined.
	17
	18	# Text and mnemonics for the spinner. You can also defined a different
	19	# index for the mnemonic via xxxMnemonicIndex, for example
	20	# GTKColorChooserPanel.hueMnemonicIndex=1 would indicate the second
	21	# character of GTKColorChooserPanel.hueText should be underlined to
	22	# represent the mnemonic.
	23	GTKColorChooserPanel.hueText=Nyans:
	24	GTKColorChooserPanel.hueMnemonic=78
	25
	26	GTKColorChooserPanel.redText=R\u00F6d:
	27	GTKColorChooserPanel.redMnemonic=82
	28
	29	GTKColorChooserPanel.saturationText=M\u00E4ttnad:
	30	GTKColorChooserPanel.saturationMnemonic=77
	31
	32	GTKColorChooserPanel.greenText=Gr\u00F6n:
	33	GTKColorChooserPanel.greenMnemonic=71
	34
	35	GTKColorChooserPanel.valueText=V\u00E4rde:
	36	GTKColorChooserPanel.valueMnemonic=86
	37
	38	GTKColorChooserPanel.blueText=Bl\u00E5:
	39	GTKColorChooserPanel.blueMnemonic=66
	40
	41	GTKColorChooserPanel.colorNameText=F\u00E4rgnamn:
	42	GTKColorChooserPanel.colorNameMnemonic=70
	43
	44
	45
	46	############ FILE CHOOSER STRINGS #############
	47
	48	FileChooser.acceptAllFileFilterText=Alla filer
	49	FileChooser.newFolderButtonText=Ny mapp
	50	FileChooser.newFolderButtonMnemonic=78
	51	FileChooser.newFolderDialogText=Mapp:
	52	FileChooser.newFolderNoDirectoryErrorTitleText=Fel
	53	FileChooser.newFolderNoDirectoryErrorText=Ett fel intr\u00E4ffade vid f\u00F6rs\u00F6k att skapa katalogen "{0}": Filen eller katalogen finns inte
	54	FileChooser.deleteFileButtonText=Ta bort fil
	55	FileChooser.deleteFileButtonMnemonic=66
	56	FileChooser.renameFileButtonText=\u00C4ndra namn p\u00E5 filen
	57	FileChooser.renameFileButtonMnemonic=82
	58	FileChooser.cancelButtonText=Avbryt
	59	FileChooser.cancelButtonMnemonic=65
	60	FileChooser.saveButtonText=OK
	61	FileChooser.saveButtonMnemonic=79
	62	FileChooser.openButtonText=OK
	63	FileChooser.openButtonMnemonic=79
	64	FileChooser.saveDialogTitleText=Spara
	65	FileChooser.openDialogTitleText=\u00D6ppna
	66	FileChooser.pathLabelText=Urval:
	67	FileChooser.filterLabelText=Filter:
	68	FileChooser.pathLabelMnemonic=85
	69	FileChooser.foldersLabelText=Mappar
	70	FileChooser.foldersLabelMnemonic=80
	71	FileChooser.filesLabelText=Filer
	72	FileChooser.filesLabelMnemonic=70
	73
	74	FileChooser.cancelButtonToolTipText=Avbryt dialogrutan Filv\u00E4ljare.
	75	FileChooser.saveButtonToolTipText=Spara vald fil.
	76	FileChooser.openButtonToolTipText=\u00D6ppna vald fil.
	77
	78	FileChooser.renameFileDialogText=Namn\u00E4ndra fil "{0}" till
	79	FileChooser.renameFileErrorTitle=Fel
	80	FileChooser.renameFileErrorText=Fel vid namn\u00E4ndring av fil "{0}" till "{1}"
	81
	82	# dummy resource added for translation automation
	83	OptionPane.okButtonText=OK
	84	OptionPane.okButtonMnemonic=79
	85	# dummy resource added for translation automation
	86	OptionPane.cancelButtonText=Avbryt
	87	OptionPane.cancelButtonMnemonic=65
	88

java/pkg/com/sun/java/swing/plaf/gtk/resources/gtk_zh_CN.properties+84−0

@@ -0,0 +1,84 @@
	1	# Refer to the note in basic.properties for a description as to what
	2	# the mnemonics correspond to and how to calculate them.
	3
	4
	5
	6	# GTK specific properties
	7
	8	# GTK color chooser properties:
	9	GTKColorChooserPanel.nameText=GTK \u989C\u8272\u9009\u62E9\u5668(G)
	10	# mnemonic as a VK_ constant
	11	GTKColorChooserPanel.mnemonic=71
	12	# Can also define GTKColorChooserPanel.dispalyedMnemonicIndex if you
	13	# want an index other than would normally be underlined by
	14	# GTKColorChooserPanel.mnemonic to be underlined. This is only useful
	15	# if GTKColorChooserPanel.nameText defines the mnemonic character more
	16	# than once and you want a character other than the first underlined.
	17
	18	# Text and mnemonics for the spinner. You can also defined a different
	19	# index for the mnemonic via xxxMnemonicIndex, for example
	20	# GTKColorChooserPanel.hueMnemonicIndex=1 would indicate the second
	21	# character of GTKColorChooserPanel.hueText should be underlined to
	22	# represent the mnemonic.
	23	GTKColorChooserPanel.hueText=\u8272\u8C03(H):
	24	GTKColorChooserPanel.hueMnemonic=72
	25
	26	GTKColorChooserPanel.redText=\u7EA2\u8272(E):
	27	GTKColorChooserPanel.redMnemonic=69
	28
	29	GTKColorChooserPanel.saturationText=\u9971\u548C\u5EA6(S):
	30	GTKColorChooserPanel.saturationMnemonic=83
	31
	32	GTKColorChooserPanel.greenText=\u7EFF\u8272(G):
	33	GTKColorChooserPanel.greenMnemonic=71
	34
	35	GTKColorChooserPanel.valueText=\u503C(V):
	36	GTKColorChooserPanel.valueMnemonic=86
	37
	38	GTKColorChooserPanel.blueText=\u84DD\u8272(B):
	39	GTKColorChooserPanel.blueMnemonic=66
	40
	41	GTKColorChooserPanel.colorNameText=\u989C\u8272\u540D(N):
	42	GTKColorChooserPanel.colorNameMnemonic=78
	43
	44
	45
	46	############ FILE CHOOSER STRINGS #############
	47
	48	FileChooser.acceptAllFileFilterText=\u6240\u6709\u6587\u4EF6
	49	FileChooser.newFolderButtonText=\u65B0\u6587\u4EF6\u5939(N)
	50	FileChooser.newFolderButtonMnemonic=78
	51	FileChooser.newFolderDialogText=\u6587\u4EF6\u5939\u540D:
	52	FileChooser.newFolderNoDirectoryErrorTitleText=\u9519\u8BEF
	53	FileChooser.newFolderNoDirectoryErrorText=\u521B\u5EFA\u76EE\u5F55 "{0}" \u65F6\u51FA\u9519: \u6CA1\u6709\u6B64\u7C7B\u6587\u4EF6\u6216\u76EE\u5F55
	54	FileChooser.deleteFileButtonText=\u5220\u9664\u6587\u4EF6(L)
	55	FileChooser.deleteFileButtonMnemonic=76
	56	FileChooser.renameFileButtonText=\u91CD\u547D\u540D\u6587\u4EF6(R)
	57	FileChooser.renameFileButtonMnemonic=82
	58	FileChooser.cancelButtonText=\u53D6\u6D88
	59	FileChooser.cancelButtonMnemonic=67
	60	FileChooser.saveButtonText=\u786E\u5B9A
	61	FileChooser.saveButtonMnemonic=79
	62	FileChooser.openButtonText=\u786E\u5B9A
	63	FileChooser.openButtonMnemonic=79
	64	FileChooser.saveDialogTitleText=\u4FDD\u5B58
	65	FileChooser.openDialogTitleText=\u6253\u5F00
	66	FileChooser.pathLabelText=\u9009\u5B9A\u5185\u5BB9(S):
	67	FileChooser.filterLabelText=\u7B5B\u9009\u5668:
	68	FileChooser.pathLabelMnemonic=83
	69	FileChooser.foldersLabelText=\u6587\u4EF6\u5939(D)
	70	FileChooser.foldersLabelMnemonic=68
	71	FileChooser.filesLabelText=\u6587\u4EF6(F)
	72	FileChooser.filesLabelMnemonic=70
	73
	74	FileChooser.cancelButtonToolTipText=\u4E2D\u6B62\u6587\u4EF6\u9009\u62E9\u5668\u5BF9\u8BDD\u6846\u3002
	75	FileChooser.saveButtonToolTipText=\u4FDD\u5B58\u6240\u9009\u6587\u4EF6\u3002
	76	FileChooser.openButtonToolTipText=\u6253\u5F00\u6240\u9009\u6587\u4EF6\u3002
	77
	78	FileChooser.renameFileDialogText=\u5C06\u6587\u4EF6 "{0}" \u91CD\u547D\u540D\u4E3A
	79	FileChooser.renameFileErrorTitle=\u9519\u8BEF
	80	FileChooser.renameFileErrorText=\u5C06\u6587\u4EF6 "{0}" \u91CD\u547D\u540D\u4E3A "{1}" \u65F6\u51FA\u9519
	81
	82	#OptionPane.okButtonMnemonic=79
	83	#OptionPane.cancelButtonMnemonic=67
	84

java/pkg/com/sun/java/swing/plaf/gtk/resources/gtk_zh_TW.properties+84−0

@@ -0,0 +1,84 @@
	1	# Refer to the note in basic.properties for a description as to what
	2	# the mnemonics correspond to and how to calculate them.
	3
	4
	5
	6	# GTK specific properties
	7
	8	# GTK color chooser properties:
	9	GTKColorChooserPanel.nameText=GTK \u8272\u5F69\u9078\u64C7\u5668(G)
	10	# mnemonic as a VK_ constant
	11	GTKColorChooserPanel.mnemonic=71
	12	# Can also define GTKColorChooserPanel.dispalyedMnemonicIndex if you
	13	# want an index other than would normally be underlined by
	14	# GTKColorChooserPanel.mnemonic to be underlined. This is only useful
	15	# if GTKColorChooserPanel.nameText defines the mnemonic character more
	16	# than once and you want a character other than the first underlined.
	17
	18	# Text and mnemonics for the spinner. You can also defined a different
	19	# index for the mnemonic via xxxMnemonicIndex, for example
	20	# GTKColorChooserPanel.hueMnemonicIndex=1 would indicate the second
	21	# character of GTKColorChooserPanel.hueText should be underlined to
	22	# represent the mnemonic.
	23	GTKColorChooserPanel.hueText=\u8272\u8ABF(H)\uFF1A
	24	GTKColorChooserPanel.hueMnemonic=72
	25
	26	GTKColorChooserPanel.redText=\u7D05(E):
	27	GTKColorChooserPanel.redMnemonic=69
	28
	29	GTKColorChooserPanel.saturationText=\u5F69\u5EA6(S):
	30	GTKColorChooserPanel.saturationMnemonic=83
	31
	32	GTKColorChooserPanel.greenText=\u7DA0(G):
	33	GTKColorChooserPanel.greenMnemonic=71
	34
	35	GTKColorChooserPanel.valueText=\u503C(V):
	36	GTKColorChooserPanel.valueMnemonic=86
	37
	38	GTKColorChooserPanel.blueText=\u85CD(B):
	39	GTKColorChooserPanel.blueMnemonic=66
	40
	41	GTKColorChooserPanel.colorNameText=\u984F\u8272\u540D\u7A31(N):
	42	GTKColorChooserPanel.colorNameMnemonic=78
	43
	44
	45
	46	############ FILE CHOOSER STRINGS #############
	47
	48	FileChooser.acceptAllFileFilterText=\u6240\u6709\u6A94\u6848
	49	FileChooser.newFolderButtonText=\u65B0\u5EFA\u8CC7\u6599\u593E(N)
	50	FileChooser.newFolderButtonMnemonic=78
	51	FileChooser.newFolderDialogText=\u8CC7\u6599\u593E\u540D\u7A31:
	52	FileChooser.newFolderNoDirectoryErrorTitleText=\u932F\u8AA4
	53	FileChooser.newFolderNoDirectoryErrorText=\u5EFA\u7ACB\u76EE\u9304 "{0}" \u6642\u767C\u751F\u932F\u8AA4: \u6C92\u6709\u6B64\u6A94\u6848\u6216\u76EE\u9304
	54	FileChooser.deleteFileButtonText=\u522A\u9664\u6A94\u6848(L)
	55	FileChooser.deleteFileButtonMnemonic=76
	56	FileChooser.renameFileButtonText=\u91CD\u65B0\u547D\u540D\u6A94\u6848(R)
	57	FileChooser.renameFileButtonMnemonic=82
	58	FileChooser.cancelButtonText=\u53D6\u6D88
	59	FileChooser.cancelButtonMnemonic=67
	60	FileChooser.saveButtonText=\u78BA\u5B9A
	61	FileChooser.saveButtonMnemonic=79
	62	FileChooser.openButtonText=\u78BA\u5B9A
	63	FileChooser.openButtonMnemonic=79
	64	FileChooser.saveDialogTitleText=\u5132\u5B58
	65	FileChooser.openDialogTitleText=\u958B\u555F
	66	FileChooser.pathLabelText=\u9078\u53D6(S):
	67	FileChooser.filterLabelText=\u7BE9\u9078:
	68	FileChooser.pathLabelMnemonic=83
	69	FileChooser.foldersLabelText=\u8CC7\u6599\u593E(D)
	70	FileChooser.foldersLabelMnemonic=68
	71	FileChooser.filesLabelText=\u6A94\u6848(F)
	72	FileChooser.filesLabelMnemonic=70
	73
	74	FileChooser.cancelButtonToolTipText=\u4E2D\u6B62\u6A94\u6848\u9078\u64C7\u5668\u5C0D\u8A71\u65B9\u584A\u3002
	75	FileChooser.saveButtonToolTipText=\u5132\u5B58\u9078\u53D6\u7684\u6A94\u6848\u3002
	76	FileChooser.openButtonToolTipText=\u958B\u555F\u9078\u53D6\u7684\u6A94\u6848\u3002
	77
	78	FileChooser.renameFileDialogText=\u5C07\u6A94\u6848 "{0}" \u91CD\u65B0\u547D\u540D\u70BA
	79	FileChooser.renameFileErrorTitle=\u932F\u8AA4
	80	FileChooser.renameFileErrorText=\u5C07\u6A94\u6848 "{0}" \u91CD\u65B0\u547D\u540D\u70BA "{1}" \u6642\u51FA\u73FE\u932F\u8AA4
	81
	82	#OptionPane.okButtonMnemonic=79
	83	#OptionPane.cancelButtonMnemonic=67
	84

java/pkg/com/sun/java/swing/plaf/gtk/resources/metacity/SwingFallbackTheme/metacity-1/metacity-theme-1.xml+178−0

@@ -0,0 +1,178 @@
	1	<?xml version="1.0"?>
	2
	3	<!--
	4	Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved.
	5	DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	6
	7	This code is free software; you can redistribute it and/or modify it
	8	under the terms of the GNU General Public License version 2 only, as
	9	published by the Free Software Foundation. Oracle designates this
	10	particular file as subject to the "Classpath" exception as provided
	11	by Oracle in the LICENSE file that accompanied this code.
	12
	13	This code is distributed in the hope that it will be useful, but WITHOUT
	14	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	15	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	16	version 2 for more details (a copy is included in the LICENSE file that
	17	accompanied this code).
	18
	19	You should have received a copy of the GNU General Public License version
	20	2 along with this work; if not, write to the Free Software Foundation,
	21	Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	22
	23	Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	24	or visit www.oracle.com if you need additional information or have any
	25	questions.
	26	-->
	27
	28	<metacity_theme>
	29	<info>
	30	<name>SwingFallbackTheme</name>
	31	<author>Leif Samuelsson</author>
	32	<copyright>Â Sun Microsystems, Inc, 2003</copyright>
	33	<description>
	34	A fallback theme for Swing's GTK Look and Feel, in case no other metacity
	35	theme can be found. Note: This theme is not intended to work with the
	36	Metacity window manager, nor to be used for any purpose other than stated
	37	here.
	38	</description>
	39	</info>
	40
	41	<frame_geometry name="normal">
	42	<distance name="left_width" value="5"/>
	43	<distance name="right_width" value="6"/>
	44	<distance name="bottom_height" value="6"/>
	45	<distance name="left_titlebar_edge" value="5"/>
	46	<distance name="right_titlebar_edge" value="6"/>
	47	<aspect_ratio name="button" value="1.0"/>
	48	<distance name="title_vertical_pad" value="0"/>
	49	<border name="title_border" left="0" right="0" top="3" bottom="3"/>
	50	<border name="button_border" left="0" right="0" top="3" bottom="3"/>
	51	</frame_geometry>
	52
	53	<draw_ops name="button">
	54	<rectangle color="black" x="0" y="0" width="width-2" height="height-2"/>
	55	</draw_ops>
	56
	57	<draw_ops name="button_pressed">
	58	<rectangle color="black" x="1" y="1" width="width-2" height="height-2"/>
	59	</draw_ops>
	60
	61	<frame_style name="normal" geometry="normal">
	62
	63	<piece position="entire_background">
	64	<draw_ops>
	65	<rectangle color="black" x="0" y="0" width="width-1" height="height-1"/>
	66	<rectangle color="black" x="left_width-1" y="1" width="width-left_width-right_width+1" height="height-bottom_height-1"/>
	67	</draw_ops>
	68	</piece>
	69
	70	<piece position="title">
	71	<draw_ops>
	72	<title color="black" x="2" y="0"/>
	73	</draw_ops>
	74	</piece>
	75
	76	<piece position="titlebar">
	77	<draw_ops>
	78	<gradient type="diagonal" x="1" y="1" width="width-2" height="height-2">
	79	<color value="shade/gtk:bg[NORMAL]/1.0"/>
	80	<color value="shade/gtk:bg[NORMAL]/0.9"/>
	81	</gradient>
	82	<line color="black" x1="left_width" y1="height-1" x2="width-right_width" y2="height-1"/>
	83	</draw_ops>
	84	</piece>
	85
	86	<button function="close" state="normal">
	87	<draw_ops>
	88	<include name="button"/>
	89	<line color="black" x1="3" y1="3" x2="width-5" y2="height-5"/>
	90	<line color="black" x1="width-5" y1="3" x2="3" y2="height-5"/>
	91	</draw_ops>
	92	</button>
	93
	94	<button function="close" state="pressed">
	95	<draw_ops>
	96	<include name="button_pressed"/>
	97	<line color="black" x1="4" y1="4" x2="width-4" y2="height-4"/>
	98	<line color="black" x1="width-4" y1="4" x2="4" y2="height-4"/>
	99	</draw_ops>
	100	</button>
	101
	102	<button function="minimize" state="normal">
	103	<draw_ops>
	104	<include name="button"/>
	105	<line color="black" x1="4" y1="height-4" x2="width-5" y2="height-4"/>
	106	</draw_ops>
	107	</button>
	108
	109	<button function="minimize" state="pressed">
	110	<draw_ops>
	111	<include name="button_pressed"/>
	112	<line color="black" x1="5" y1="height-3" x2="width-4" y2="height-3"/>
	113	</draw_ops>
	114	</button>
	115
	116	<button function="maximize" state="normal">
	117	<draw_ops>
	118	<include name="button"/>
	119	<rectangle color="black" x="3" y="3" width="width-3-5" height="height-3-5"/>
	120	</draw_ops>
	121	</button>
	122
	123	<button function="maximize" state="pressed">
	124	<draw_ops>
	125	<include name="button_pressed"/>
	126	<rectangle color="black" x="4" y="4" width="width-3-5" height="height-3-5"/>
	127	</draw_ops>
	128	</button>
	129
	130	<button function="menu" state="normal">
	131	<draw_ops>
	132	<include name="button"/>
	133	</draw_ops>
	134	</button>
	135
	136	<button function="menu" state="pressed">
	137	<draw_ops>
	138	<include name="button_pressed"/>
	139	</draw_ops>
	140	</button>
	141	</frame_style>
	142
	143
	144	<frame_style name="focused" geometry="normal" parent="normal">
	145
	146	<piece position="entire_background">
	147	<draw_ops>
	148	<rectangle color="black" x="0" y="0" width="width-1" height="height-1"/>
	149	<rectangle color="black" x="left_width-1" y="1" width="width-left_width-right_width+1" height="height-bottom_height-1"/>
	150	</draw_ops>
	151	</piece>
	152
	153	<piece position="title">
	154	<draw_ops>
	155	<title color="black" x="2" y="((height - title_height) / 2) `max` 0"/>
	156	</draw_ops>
	157	</piece>
	158
	159	<piece position="titlebar">
	160	<draw_ops>
	161	<gradient type="diagonal" x="1" y="1" width="width-2" height="height-2">
	162	<color value="#f0f0f0"/>
	163	<color value="shade/gtk:bg[NORMAL]/1.0"/>
	164	</gradient>
	165	<line color="black" x1="left_width" y1="height-1" x2="width-right_width" y2="height-1"/>
	166	</draw_ops>
	167	</piece>
	168
	169	</frame_style>
	170
	171	<frame_style_set name="normal">
	172	<frame focus="yes" state="normal" resize="both" style="focused"/>
	173	<frame focus="yes" state="maximized" style="focused"/>
	174	<frame focus="no" state="normal" resize="both" style="normal"/>
	175	<frame focus="no" state="maximized" style="normal"/>
	176	</frame_style_set>
	177
	178	</metacity_theme>

java/pkg/com/sun/java/swing/plaf/gtk/resources/metacity/SwingFallbackTheme/metacity-1/mkfile+2−0

@@ -0,0 +1,2 @@
	1	<../../../../../../../../../../../../mkconfig
	2

java/pkg/com/sun/java/swing/plaf/gtk/resources/metacity/SwingFallbackTheme/mkfile+6−0

@@ -0,0 +1,6 @@
	1	<../../../../../../../../../../../mkconfig
	2
	3	DIRS=\
	4	metacity-1\
	5
	6	<$ROOT/mkfiles/mksubdirs

java/pkg/com/sun/java/swing/plaf/gtk/resources/metacity/mkfile+6−0

@@ -0,0 +1,6 @@
	1	<../../../../../../../../../../mkconfig
	2
	3	DIRS=\
	4	SwingFallbackTheme\
	5
	6	<$ROOT/mkfiles/mksubdirs

java/pkg/com/sun/java/swing/plaf/gtk/resources/mkfile+6−0

@@ -0,0 +1,6 @@
	1	<../../../../../../../../../mkconfig
	2
	3	DIRS=\
	4	metacity\
	5
	6	<$ROOT/mkfiles/mksubdirs

java/pkg/com/sun/java/swing/plaf/mkfile+9−0

@@ -0,0 +1,9 @@
	1	<../../../../../../../mkconfig
	2
	3	DIRS=\
	4	gtk\
	5	motif\
	6	nimbus\
	7	windows\
	8
	9	<$ROOT/mkfiles/mksubdirs

java/pkg/com/sun/java/swing/plaf/motif/MotifBorders.java+734−0

@@ -0,0 +1,734 @@
	1	/*
	2	* Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.swing.plaf.motif;
	27
	28	import sun.swing.SwingUtilities2;
	29	import javax.swing.*;
	30	import javax.swing.border.*;
	31	import javax.swing.plaf.*;
	32
	33	import java.awt.Color;
	34	import java.awt.Component;
	35	import java.awt.Dimension;
	36	import java.awt.Font;
	37	import java.awt.FontMetrics;
	38	import java.awt.Graphics;
	39	import java.awt.Insets;
	40	import java.awt.Point;
	41	import java.awt.Rectangle;
	42
	43	/**
	44	* Factory object that can vend Icons appropriate for the basic L & F.
	45	* <p>
	46	* <strong>Warning:</strong>
	47	* Serialized objects of this class will not be compatible with
	48	* future Swing releases. The current serialization support is appropriate
	49	* for short term storage or RMI between applications running the same
	50	* version of Swing. A future release of Swing will provide support for
	51	* long term persistence.
	52	*
	53	* @author Amy Fowler
	54	*/
	55	public class MotifBorders {
	56
	57	public static class BevelBorder extends AbstractBorder implements UIResource {
	58	private Color darkShadow = UIManager.getColor("controlShadow");
	59	private Color lightShadow = UIManager.getColor("controlLtHighlight");
	60	private boolean isRaised;
	61
	62	public BevelBorder(boolean isRaised, Color darkShadow, Color lightShadow) {
	63	this.isRaised = isRaised;
	64	this.darkShadow = darkShadow;
	65	this.lightShadow = lightShadow;
	66	}
	67
	68	public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
	69	g.setColor((isRaised) ? lightShadow : darkShadow);
	70	g.drawLine(x, y, x+w-1, y); // top
	71	g.drawLine(x, y+h-1, x, y+1); // left
	72
	73	g.setColor((isRaised) ? darkShadow : lightShadow);
	74	g.drawLine(x+1, y+h-1, x+w-1, y+h-1); // bottom
	75	g.drawLine(x+w-1, y+h-1, x+w-1, y+1); // right
	76	}
	77
	78	public Insets getBorderInsets(Component c, Insets insets) {
	79	insets.set(1, 1, 1, 1);
	80	return insets;
	81	}
	82
	83	public boolean isOpaque(Component c) {
	84	return true;
	85	}
	86
	87	}
	88
	89
	90	public static class FocusBorder extends AbstractBorder implements UIResource {
	91	private Color focus;
	92	private Color control;
	93
	94	public FocusBorder(Color control, Color focus) {
	95	this.control = control;
	96	this.focus = focus;
	97	}
	98
	99	public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
	100	if (c.hasFocus()) {
	101	g.setColor(focus);
	102	g.drawRect(x, y, w-1, h-1);
	103	} else {
	104	g.setColor(control);
	105	g.drawRect(x, y, w-1, h-1);
	106	}
	107	}
	108
	109	public Insets getBorderInsets(Component c, Insets insets) {
	110	insets.set(1, 1, 1, 1);
	111	return insets;
	112	}
	113	}
	114
	115
	116	public static class ButtonBorder extends AbstractBorder implements UIResource {
	117	protected Color focus = UIManager.getColor("activeCaptionBorder");
	118	protected Color shadow = UIManager.getColor("Button.shadow");
	119	protected Color highlight = UIManager.getColor("Button.light");
	120	protected Color darkShadow;
	121
	122	public ButtonBorder(Color shadow, Color highlight, Color darkShadow, Color focus) {
	123	this.shadow = shadow;
	124	this.highlight = highlight;
	125	this.darkShadow = darkShadow;
	126	this.focus = focus;
	127	}
	128
	129	public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
	130	boolean isPressed = false;
	131	boolean hasFocus = false;
	132	boolean canBeDefault = false;
	133	boolean isDefault = false;
	134
	135	if (c instanceof AbstractButton) {
	136	AbstractButton b = (AbstractButton)c;
	137	ButtonModel model = b.getModel();
	138
	139	isPressed = (model.isArmed() && model.isPressed());
	140	hasFocus = (model.isArmed() && isPressed) \|\|
	141	(b.isFocusPainted() && b.hasFocus());
	142	if (b instanceof JButton) {
	143	canBeDefault = ((JButton)b).isDefaultCapable();
	144	isDefault = ((JButton)b).isDefaultButton();
	145	}
	146	}
	147	int bx1 = x+1;
	148	int by1 = y+1;
	149	int bx2 = x+w-2;
	150	int by2 = y+h-2;
	151
	152	if (canBeDefault) {
	153	if (isDefault) {
	154	g.setColor(shadow);
	155	g.drawLine(x+3, y+3, x+3, y+h-4);
	156	g.drawLine(x+3, y+3, x+w-4, y+3);
	157
	158	g.setColor(highlight);
	159	g.drawLine(x+4, y+h-4, x+w-4, y+h-4);
	160	g.drawLine(x+w-4, y+3, x+w-4, y+h-4);
	161	}
	162	bx1 +=6;
	163	by1 += 6;
	164	bx2 -= 6;
	165	by2 -= 6;
	166	}
	167
	168	if (hasFocus) {
	169	g.setColor(focus);
	170	if (isDefault) {
	171	g.drawRect(x, y, w-1, h-1);
	172	} else {
	173	g.drawRect(bx1-1, by1-1, bx2-bx1+2, by2-by1+2);
	174	}
	175	}
	176
	177	g.setColor(isPressed? shadow : highlight);
	178	g.drawLine(bx1, by1, bx2, by1);
	179	g.drawLine(bx1, by1, bx1, by2);
	180
	181	g.setColor(isPressed? highlight : shadow);
	182	g.drawLine(bx2, by1+1, bx2, by2);
	183	g.drawLine(bx1+1, by2, bx2, by2);
	184	}
	185
	186	public Insets getBorderInsets(Component c, Insets insets) {
	187	int thickness = (c instanceof JButton && ((JButton)c).isDefaultCapable())? 8 : 2;
	188	insets.set(thickness, thickness, thickness, thickness);
	189	return insets;
	190	}
	191
	192	}
	193
	194	public static class ToggleButtonBorder extends ButtonBorder {
	195
	196	public ToggleButtonBorder(Color shadow, Color highlight, Color darkShadow, Color focus) {
	197	super(shadow, highlight, darkShadow, focus);
	198	}
	199
	200	public void paintBorder(Component c, Graphics g, int x, int y,
	201	int width, int height) {
	202	if (c instanceof AbstractButton) {
	203	AbstractButton b = (AbstractButton)c;
	204	ButtonModel model = b.getModel();
	205
	206	if (model.isArmed() && model.isPressed() \|\| model.isSelected()) {
	207	drawBezel(g, x, y, width, height,
	208	(model.isPressed() \|\| model.isSelected()),
	209	b.isFocusPainted() && b.hasFocus(), shadow, highlight, darkShadow, focus);
	210	} else {
	211	drawBezel(g, x, y, width, height,
	212	false, b.isFocusPainted() && b.hasFocus(),
	213	shadow, highlight, darkShadow, focus);
	214	}
	215	} else {
	216	drawBezel(g, x, y, width, height, false, false,
	217	shadow, highlight, darkShadow, focus);
	218	}
	219	}
	220
	221	public Insets getBorderInsets(Component c, Insets insets) {
	222	insets.set(2, 2, 3, 3);
	223	return insets;
	224	}
	225	}
	226
	227	public static class MenuBarBorder extends ButtonBorder {
	228
	229	public MenuBarBorder(Color shadow, Color highlight, Color darkShadow, Color focus) {
	230	super(shadow, highlight, darkShadow, focus);
	231	}
	232
	233	public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
	234	if (!(c instanceof JMenuBar)) {
	235	return;
	236	}
	237	JMenuBar menuBar = (JMenuBar)c;
	238	if (menuBar.isBorderPainted() == true) {
	239	// this draws the MenuBar border
	240	Dimension size = menuBar.getSize();
	241	drawBezel(g,x,y,size.width,size.height,false,false,
	242	shadow, highlight, darkShadow, focus);
	243	}
	244	}
	245
	246	public Insets getBorderInsets(Component c, Insets insets) {
	247	insets.set(6, 6, 6, 6);
	248	return insets;
	249	}
	250	}
	251
	252	public static class FrameBorder extends AbstractBorder implements UIResource {
	253
	254	JComponent jcomp;
	255	Color frameHighlight;
	256	Color frameColor;
	257	Color frameShadow;
	258
	259	// The width of the border
	260	public final static int BORDER_SIZE = 5;
	261
	262	/** Constructs an FrameBorder for the JComponent <b>comp</b>.
	263	*/
	264	public FrameBorder(JComponent comp) {
	265	jcomp = comp;
	266	}
	267
	268	/** Sets the FrameBorder's JComponent.
	269	*/
	270	public void setComponent(JComponent comp) {
	271	jcomp = comp;
	272	}
	273
	274	/** Returns the FrameBorder's JComponent.
	275	* @see #setComponent
	276	*/
	277	public JComponent component() {
	278	return jcomp;
	279	}
	280
	281	protected Color getFrameHighlight() {
	282	return frameHighlight;
	283	}
	284
	285	protected Color getFrameColor() {
	286	return frameColor;
	287	}
	288
	289	protected Color getFrameShadow() {
	290	return frameShadow;
	291	}
	292
	293	public Insets getBorderInsets(Component c, Insets newInsets) {
	294	newInsets.set(BORDER_SIZE, BORDER_SIZE, BORDER_SIZE, BORDER_SIZE);
	295	return newInsets;
	296	}
	297
	298	/** Draws the FrameBorder's top border.
	299	*/
	300	protected boolean drawTopBorder(Component c, Graphics g,
	301	int x, int y, int width, int height) {
	302	Rectangle titleBarRect = new Rectangle(x, y, width, BORDER_SIZE);
	303	if (!g.getClipBounds().intersects(titleBarRect)) {
	304	return false;
	305	}
	306
	307	int maxX = width - 1;
	308	int maxY = BORDER_SIZE - 1;
	309
	310	// Draw frame
	311	g.setColor(frameColor);
	312	g.drawLine(x, y + 2, maxX - 2, y + 2);
	313	g.drawLine(x, y + 3, maxX - 2, y + 3);
	314	g.drawLine(x, y + 4, maxX - 2, y + 4);
	315
	316	// Draw highlights
	317	g.setColor(frameHighlight);
	318	g.drawLine(x, y, maxX, y);
	319	g.drawLine(x, y + 1, maxX, y + 1);
	320	g.drawLine(x, y + 2, x, y + 4);
	321	g.drawLine(x + 1, y + 2, x + 1, y + 4);
	322
	323	// Draw shadows
	324	g.setColor(frameShadow);
	325	g.drawLine(x + 4, y + 4, maxX - 4, y + 4);
	326	g.drawLine(maxX, y + 1, maxX, maxY);
	327	g.drawLine(maxX - 1, y + 2, maxX - 1, maxY);
	328
	329	return true;
	330	}
	331
	332	/** Draws the FrameBorder's left border.
	333	*/
	334	protected boolean drawLeftBorder(Component c, Graphics g, int x, int y,
	335	int width, int height) {
	336	Rectangle borderRect =
	337	new Rectangle(0, 0, getBorderInsets(c).left, height);
	338	if (!g.getClipBounds().intersects(borderRect)) {
	339	return false;
	340	}
	341
	342	int startY = BORDER_SIZE;
	343
	344	g.setColor(frameHighlight);
	345	g.drawLine(x, startY, x, height - 1);
	346	g.drawLine(x + 1, startY, x + 1, height - 2);
	347
	348	g.setColor(frameColor);
	349	g.fillRect(x + 2, startY, x + 2, height - 3);
	350
	351	g.setColor(frameShadow);
	352	g.drawLine(x + 4, startY, x + 4, height - 5);
	353
	354	return true;
	355	}
	356
	357	/** Draws the FrameBorder's right border.
	358	*/
	359	protected boolean drawRightBorder(Component c, Graphics g, int x, int y,
	360	int width, int height) {
	361	Rectangle borderRect = new Rectangle(
	362	width - getBorderInsets(c).right, 0,
	363	getBorderInsets(c).right, height);
	364	if (!g.getClipBounds().intersects(borderRect)) {
	365	return false;
	366	}
	367
	368	int startX = width - getBorderInsets(c).right;
	369	int startY = BORDER_SIZE;
	370
	371	g.setColor(frameColor);
	372	g.fillRect(startX + 1, startY, 2, height - 1);
	373
	374	g.setColor(frameShadow);
	375	g.fillRect(startX + 3, startY, 2, height - 1);
	376
	377	g.setColor(frameHighlight);
	378	g.drawLine(startX, startY, startX, height - 1);
	379
	380	return true;
	381	}
	382
	383	/** Draws the FrameBorder's bottom border.
	384	*/
	385	protected boolean drawBottomBorder(Component c, Graphics g, int x, int y,
	386	int width, int height) {
	387	Rectangle borderRect;
	388	int marginHeight, startY;
	389
	390	borderRect = new Rectangle(0, height - getBorderInsets(c).bottom,
	391	width, getBorderInsets(c).bottom);
	392	if (!g.getClipBounds().intersects(borderRect)) {
	393	return false;
	394	}
	395
	396	startY = height - getBorderInsets(c).bottom;
	397
	398	g.setColor(frameShadow);
	399	g.drawLine(x + 1, height - 1, width - 1, height - 1);
	400	g.drawLine(x + 2, height - 2, width - 2, height - 2);
	401
	402	g.setColor(frameColor);
	403	g.fillRect(x + 2, startY + 1, width - 4, 2);
	404
	405	g.setColor(frameHighlight);
	406	g.drawLine(x + 5, startY, width - 5, startY);
	407
	408	return true;
	409	}
	410
	411	// Returns true if the associated component has focus.
	412	protected boolean isActiveFrame() {
	413	return jcomp.hasFocus();
	414	}
	415
	416	/** Draws the FrameBorder in the given Rect. Calls
	417	* <b>drawTitleBar</b>, <b>drawLeftBorder</b>, <b>drawRightBorder</b> and
	418	* <b>drawBottomBorder</b>.
	419	*/
	420	public void paintBorder(Component c, Graphics g,
	421	int x, int y, int width, int height) {
	422	if (isActiveFrame()) {
	423	frameColor = UIManager.getColor("activeCaptionBorder");
	424	} else {
	425	frameColor = UIManager.getColor("inactiveCaptionBorder");
	426	}
	427	frameHighlight = frameColor.brighter();
	428	frameShadow = frameColor.darker().darker();
	429
	430	drawTopBorder(c, g, x, y, width, height);
	431	drawLeftBorder(c, g, x, y, width, height);
	432	drawRightBorder(c, g, x, y, width, height);
	433	drawBottomBorder(c, g, x, y, width, height);
	434	}
	435	}
	436
	437	public static class InternalFrameBorder extends FrameBorder {
	438
	439	JInternalFrame frame;
	440
	441	// The size of the bounding box for Motif frame corners.
	442	public final static int CORNER_SIZE = 24;
	443
	444	/** Constructs an InternalFrameBorder for the InternalFrame
	445	* <b>aFrame</b>.
	446	*/
	447	public InternalFrameBorder(JInternalFrame aFrame) {
	448	super(aFrame);
	449	frame = aFrame;
	450	}
	451
	452	/** Sets the InternalFrameBorder's InternalFrame.
	453	*/
	454	public void setFrame(JInternalFrame aFrame) {
	455	frame = aFrame;
	456	}
	457
	458	/** Returns the InternalFrameBorder's InternalFrame.
	459	* @see #setFrame
	460	*/
	461	public JInternalFrame frame() {
	462	return frame;
	463	}
	464
	465	/** Returns the width of the InternalFrameBorder's resize controls,
	466	* appearing along the InternalFrameBorder's bottom border. Clicking
	467	* and dragging within these controls lets the user change both the
	468	* InternalFrame's width and height, while dragging between the controls
	469	* constrains resizing to just the vertical dimension. Override this
	470	* method if you implement your own bottom border painting and use a
	471	* resize control with a different size.
	472	*/
	473	public int resizePartWidth() {
	474	if (!frame.isResizable()) {
	475	return 0;
	476	}
	477	return FrameBorder.BORDER_SIZE;
	478	}
	479
	480	/** Draws the InternalFrameBorder's top border.
	481	*/
	482	protected boolean drawTopBorder(Component c, Graphics g,
	483	int x, int y, int width, int height) {
	484	if (super.drawTopBorder(c, g, x, y, width, height) &&
	485	frame.isResizable()) {
	486	g.setColor(getFrameShadow());
	487	g.drawLine(CORNER_SIZE - 1, y + 1, CORNER_SIZE - 1, y + 4);
	488	g.drawLine(width - CORNER_SIZE - 1, y + 1,
	489	width - CORNER_SIZE - 1, y + 4);
	490
	491	g.setColor(getFrameHighlight());
	492	g.drawLine(CORNER_SIZE, y, CORNER_SIZE, y + 4);
	493	g.drawLine(width - CORNER_SIZE, y, width - CORNER_SIZE, y + 4);
	494	return true;
	495	}
	496	return false;
	497	}
	498
	499	/** Draws the InternalFrameBorder's left border.
	500	*/
	501	protected boolean drawLeftBorder(Component c, Graphics g, int x, int y,
	502	int width, int height) {
	503	if (super.drawLeftBorder(c, g, x, y, width, height) &&
	504	frame.isResizable()) {
	505	g.setColor(getFrameHighlight());
	506	int topY = y + CORNER_SIZE;
	507	g.drawLine(x, topY, x + 4, topY);
	508	int bottomY = height - CORNER_SIZE;
	509	g.drawLine(x + 1, bottomY, x + 5, bottomY);
	510	g.setColor(getFrameShadow());
	511	g.drawLine(x + 1, topY - 1, x + 5, topY - 1);
	512	g.drawLine(x + 1, bottomY - 1, x + 5, bottomY - 1);
	513	return true;
	514	}
	515	return false;
	516	}
	517
	518	/** Draws the InternalFrameBorder's right border.
	519	*/
	520	protected boolean drawRightBorder(Component c, Graphics g, int x, int y,
	521	int width, int height) {
	522	if (super.drawRightBorder(c, g, x, y, width, height) &&
	523	frame.isResizable()) {
	524	int startX = width - getBorderInsets(c).right;
	525	g.setColor(getFrameHighlight());
	526	int topY = y + CORNER_SIZE;
	527	g.drawLine(startX, topY, width - 2, topY);
	528	int bottomY = height - CORNER_SIZE;
	529	g.drawLine(startX + 1, bottomY, startX + 3, bottomY);
	530	g.setColor(getFrameShadow());
	531	g.drawLine(startX + 1, topY - 1, width - 2, topY - 1);
	532	g.drawLine(startX + 1, bottomY - 1, startX + 3, bottomY - 1);
	533	return true;
	534	}
	535	return false;
	536	}
	537
	538	/** Draws the InternalFrameBorder's bottom border.
	539	*/
	540	protected boolean drawBottomBorder(Component c, Graphics g, int x, int y,
	541	int width, int height) {
	542	if (super.drawBottomBorder(c, g, x, y, width, height) &&
	543	frame.isResizable()) {
	544	int startY = height - getBorderInsets(c).bottom;
	545
	546	g.setColor(getFrameShadow());
	547	g.drawLine(CORNER_SIZE - 1, startY + 1,
	548	CORNER_SIZE - 1, height - 1);
	549	g.drawLine(width - CORNER_SIZE, startY + 1,
	550	width - CORNER_SIZE, height - 1);
	551
	552	g.setColor(getFrameHighlight());
	553	g.drawLine(CORNER_SIZE, startY, CORNER_SIZE, height - 2);
	554	g.drawLine(width - CORNER_SIZE + 1, startY,
	555	width - CORNER_SIZE + 1, height - 2);
	556	return true;
	557	}
	558	return false;
	559	}
	560
	561	// Returns true if the associated internal frame has focus.
	562	protected boolean isActiveFrame() {
	563	return frame.isSelected();
	564	}
	565	}
	566
	567	public static void drawBezel(Graphics g, int x, int y, int w, int h,
	568	boolean isPressed, boolean hasFocus,
	569	Color shadow, Color highlight,
	570	Color darkShadow, Color focus) {
	571
	572	Color oldColor = g.getColor();
	573	g.translate(x, y);
	574
	575	if (isPressed) {
	576	if (hasFocus){
	577	g.setColor(focus);
	578	g.drawRect(0, 0, w-1, h-1);
	579	}
	580	g.setColor(shadow); // inner border
	581	g.drawRect(1, 1, w-3, h-3);
	582
	583	g.setColor(highlight); // inner 3D border
	584	g.drawLine(2, h-3, w-3, h-3);
	585	g.drawLine(w-3, 2, w-3, h-4);
	586
	587	} else {
	588	if (hasFocus) {
	589	g.setColor(focus);
	590	g.drawRect(0, 0, w-1, h-1);
	591
	592	g.setColor(highlight); // inner 3D border
	593	g.drawLine(1, 1, 1, h-3);
	594	g.drawLine(2, 1, w-4, 1);
	595
	596	g.setColor(shadow);
	597	g.drawLine(2, h-3, w-3, h-3);
	598	g.drawLine(w-3, 1, w-3, h-4);
	599
	600	g.setColor(darkShadow); // black drop shadow __\|
	601	g.drawLine(1, h-2, w-2, h-2);
	602	g.drawLine(w-2, h-2, w-2, 1);
	603	} else {
	604	g.setColor(highlight); // inner 3D border
	605	g.drawLine(1,1,1,h-3);
	606	g.drawLine(2,1,w-4,1);
	607	g.setColor(shadow);
	608	g.drawLine(2,h-3,w-3,h-3);
	609	g.drawLine(w-3,1,w-3,h-4);
	610
	611	g.setColor(darkShadow); // black drop shadow __\|
	612	g.drawLine(1,h-2,w-2,h-2);
	613	g.drawLine(w-2,h-2,w-2,0);
	614
	615	}
	616	g.translate(-x, -y);
	617	}
	618	g.setColor(oldColor);
	619	}
	620
	621	public static class MotifPopupMenuBorder extends AbstractBorder implements UIResource {
	622	protected Font font;
	623	protected Color background;
	624	protected Color foreground;
	625	protected Color shadowColor;
	626	protected Color highlightColor;
	627
	628	// Space between the border and text
	629	static protected final int TEXT_SPACING = 2;
	630
	631	// Space for the separator under the title
	632	static protected final int GROOVE_HEIGHT = 2;
	633
	634	/**
	635	* Creates a MotifPopupMenuBorder instance
	636	*
	637	*/
	638	public MotifPopupMenuBorder(
	639	Font titleFont,
	640	Color bgColor,
	641	Color fgColor,
	642	Color shadow,
	643	Color highlight) {
	644	this.font = titleFont;
	645	this.background = bgColor;
	646	this.foreground = fgColor;
	647	this.shadowColor = shadow;
	648	this.highlightColor = highlight;
	649	}
	650
	651	/**
	652	* Paints the border for the specified component with the
	653	* specified position and size.
	654	* @param c the component for which this border is being painted
	655	* @param g the paint graphics
	656	* @param x the x position of the painted border
	657	* @param y the y position of the painted border
	658	* @param width the width of the painted border
	659	* @param height the height of the painted border
	660	*/
	661	public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
	662	if (!(c instanceof JPopupMenu)) {
	663	return;
	664	}
	665
	666	Font origFont = g.getFont();
	667	Color origColor = g.getColor();
	668	JPopupMenu popup = (JPopupMenu)c;
	669
	670	String title = popup.getLabel();
	671	if (title == null) {
	672	return;
	673	}
	674
	675	g.setFont(font);
	676
	677	FontMetrics fm = SwingUtilities2.getFontMetrics(popup, g, font);
	678	int fontHeight = fm.getHeight();
	679	int descent = fm.getDescent();
	680	int ascent = fm.getAscent();
	681	Point textLoc = new Point();
	682	int stringWidth = SwingUtilities2.stringWidth(popup, fm,
	683	title);
	684
	685	textLoc.y = y + ascent + TEXT_SPACING;
	686	textLoc.x = x + ((width - stringWidth) / 2);
	687
	688	g.setColor(background);
	689	g.fillRect(textLoc.x - TEXT_SPACING, textLoc.y - (fontHeight-descent),
	690	stringWidth + (2 * TEXT_SPACING), fontHeight - descent);
	691	g.setColor(foreground);
	692	SwingUtilities2.drawString(popup, g, title, textLoc.x, textLoc.y);
	693
	694	MotifGraphicsUtils.drawGroove(g, x, textLoc.y + TEXT_SPACING,
	695	width, GROOVE_HEIGHT,
	696	shadowColor, highlightColor);
	697
	698	g.setFont(origFont);
	699	g.setColor(origColor);
	700	}
	701
	702	/**
	703	* Reinitialize the insets parameter with this Border's current Insets.
	704	* @param c the component for which this border insets value applies
	705	* @param insets the object to be reinitialized
	706	*/
	707	public Insets getBorderInsets(Component c, Insets insets) {
	708	if (!(c instanceof JPopupMenu)) {
	709	return insets;
	710	}
	711	FontMetrics fm;
	712	int descent = 0;
	713	int ascent = 16;
	714
	715	String title = ((JPopupMenu)c).getLabel();
	716	if (title == null) {
	717	insets.left = insets.top = insets.right = insets.bottom = 0;
	718	return insets;
	719	}
	720
	721	fm = c.getFontMetrics(font);
	722
	723	if(fm != null) {
	724	descent = fm.getDescent();
	725	ascent = fm.getAscent();
	726	}
	727
	728	insets.top += ascent + descent + TEXT_SPACING + GROOVE_HEIGHT;
	729	return insets;
	730	}
	731
	732	}
	733
	734	}

java/pkg/com/sun/java/swing/plaf/motif/MotifButtonListener.java+49−0

@@ -0,0 +1,49 @@
	1	/*
	2	* Copyright (c) 1997, 2001, 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
	27	package com.sun.java.swing.plaf.motif;
	28
	29	import java.awt.*;
	30	import java.awt.event.*;
	31	import javax.swing.*;
	32	import javax.swing.plaf.basic.*;
	33	import javax.swing.event.*;
	34
	35	/**
	36	* Button Listener
	37	* <p>
	38	*
	39	* @author Rich Schiavi
	40	*/
	41	public class MotifButtonListener extends BasicButtonListener {
	42	public MotifButtonListener(AbstractButton b ) {
	43	super(b);
	44	}
	45
	46	protected void checkOpacity(AbstractButton b) {
	47	b.setOpaque( false );
	48	}
	49	}

java/pkg/com/sun/java/swing/plaf/motif/MotifButtonUI.java+150−0

@@ -0,0 +1,150 @@
	1	/*
	2	* Copyright (c) 1997, 2003, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.swing.plaf.motif;
	27
	28	import sun.awt.AppContext;
	29
	30	import javax.swing.*;
	31	import javax.swing.border.*;
	32	import javax.swing.plaf.basic.*;
	33	import java.awt.*;
	34	import java.awt.event.*;
	35	import javax.swing.plaf.*;
	36
	37	/**
	38	* MotifButton implementation
	39	* <p>
	40	* <strong>Warning:</strong>
	41	* Serialized objects of this class will not be compatible with
	42	* future Swing releases. The current serialization support is appropriate
	43	* for short term storage or RMI between applications running the same
	44	* version of Swing. A future release of Swing will provide support for
	45	* long term persistence.
	46	*
	47	* @author Rich Schiavi
	48	*/
	49	public class MotifButtonUI extends BasicButtonUI {
	50
	51	protected Color selectColor;
	52
	53	private boolean defaults_initialized = false;
	54
	55	private static final Object MOTIF_BUTTON_UI_KEY = new Object();
	56
	57	// ********************************
	58	// Create PLAF
	59	// ********************************
	60	public static ComponentUI createUI(JComponent c) {
	61	AppContext appContext = AppContext.getAppContext();
	62	MotifButtonUI motifButtonUI =
	63	(MotifButtonUI) appContext.get(MOTIF_BUTTON_UI_KEY);
	64	if (motifButtonUI == null) {
	65	motifButtonUI = new MotifButtonUI();
	66	appContext.put(MOTIF_BUTTON_UI_KEY, motifButtonUI);
	67	}
	68	return motifButtonUI;
	69	}
	70
	71	// ********************************
	72	// Create Listeners
	73	// ********************************
	74	protected BasicButtonListener createButtonListener(AbstractButton b){
	75	return new MotifButtonListener(b);
	76	}
	77
	78	// ********************************
	79	// Install Defaults
	80	// ********************************
	81	public void installDefaults(AbstractButton b) {
	82	super.installDefaults(b);
	83	if(!defaults_initialized) {
	84	selectColor = UIManager.getColor(getPropertyPrefix() + "select");
	85	defaults_initialized = true;
	86	}
	87	LookAndFeel.installProperty(b, "opaque", Boolean.FALSE);
	88	}
	89
	90	protected void uninstallDefaults(AbstractButton b) {
	91	super.uninstallDefaults(b);
	92	defaults_initialized = false;
	93	}
	94
	95	// ********************************
	96	// Default Accessors
	97	// ********************************
	98
	99	protected Color getSelectColor() {
	100	return selectColor;
	101	}
	102
	103	// ********************************
	104	// Paint Methods
	105	// ********************************
	106	public void paint(Graphics g, JComponent c) {
	107	fillContentArea( g, (AbstractButton)c , c.getBackground() );
	108	super.paint(g,c);
	109	}
	110
	111	// Overridden to ensure we don't paint icon over button borders.
	112	protected void paintIcon(Graphics g, JComponent c, Rectangle iconRect) {
	113	Shape oldClip = g.getClip();
	114	Rectangle newClip =
	115	AbstractBorder.getInteriorRectangle(c, c.getBorder(), 0, 0,
	116	c.getWidth(), c.getHeight());
	117
	118	Rectangle r = oldClip.getBounds();
	119	newClip =
	120	SwingUtilities.computeIntersection(r.x, r.y, r.width, r.height,
	121	newClip);
	122	g.setClip(newClip);
	123	super.paintIcon(g, c, iconRect);
	124	g.setClip(oldClip);
	125	}
	126
	127	protected void paintFocus(Graphics g, AbstractButton b, Rectangle viewRect, Rectangle textRect, Rectangle iconRect){
	128	// focus painting is handled by the border
	129	}
	130
	131	protected void paintButtonPressed(Graphics g, AbstractButton b) {
	132
	133	fillContentArea( g, b , selectColor );
	134
	135	}
	136
	137	protected void fillContentArea( Graphics g, AbstractButton b, Color fillColor) {
	138
	139	if (b.isContentAreaFilled()) {
	140	Insets margin = b.getMargin();
	141	Insets insets = b.getInsets();
	142	Dimension size = b.getSize();
	143	g.setColor(fillColor);
	144	g.fillRect(insets.left - margin.left,
	145	insets.top - margin.top,
	146	size.width - (insets.left-margin.left) - (insets.right - margin.right),
	147	size.height - (insets.top-margin.top) - (insets.bottom - margin.bottom));
	148	}
	149	}
	150	}

java/pkg/com/sun/java/swing/plaf/motif/MotifCheckBoxMenuItemUI.java+107−0

@@ -0,0 +1,107 @@
	1	/*
	2	* Copyright (c) 1997, 2006, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.swing.plaf.motif;
	27
	28	import javax.swing.*;
	29	import javax.swing.event.*;
	30	import javax.swing.plaf.*;
	31	import javax.swing.plaf.basic.BasicButtonListener;
	32	import javax.swing.plaf.basic.BasicCheckBoxMenuItemUI;
	33
	34	import java.awt.*;
	35	import java.awt.event.*;
	36
	37
	38	/**
	39	* MotifCheckboxMenuItem implementation
	40	* <p>
	41	*
	42	* @author Georges Saab
	43	* @author Rich Schiavi
	44	*/
	45	public class MotifCheckBoxMenuItemUI extends BasicCheckBoxMenuItemUI
	46	{
	47	protected ChangeListener changeListener;
	48
	49	public static ComponentUI createUI(JComponent b) {
	50	return new MotifCheckBoxMenuItemUI();
	51	}
	52
	53	protected void installListeners() {
	54	super.installListeners();
	55	changeListener = createChangeListener(menuItem);
	56	menuItem.addChangeListener(changeListener);
	57	}
	58
	59	protected void uninstallListeners() {
	60	super.uninstallListeners();
	61	menuItem.removeChangeListener(changeListener);
	62	}
	63
	64	protected ChangeListener createChangeListener(JComponent c) {
	65	return new ChangeHandler();
	66	}
	67
	68	protected class ChangeHandler implements ChangeListener {
	69	public void stateChanged(ChangeEvent e) {
	70	JMenuItem c = (JMenuItem)e.getSource();
	71	LookAndFeel.installProperty(c, "borderPainted", c.isArmed());
	72	}
	73	}
	74
	75	protected MouseInputListener createMouseInputListener(JComponent c) {
	76	return new MouseInputHandler();
	77	}
	78
	79
	80	protected class MouseInputHandler implements MouseInputListener {
	81	public void mouseClicked(MouseEvent e) {}
	82	public void mousePressed(MouseEvent e) {
	83	MenuSelectionManager manager = MenuSelectionManager.defaultManager();
	84	manager.setSelectedPath(getPath());
	85	}
	86	public void mouseReleased(MouseEvent e) {
	87	MenuSelectionManager manager =
	88	MenuSelectionManager.defaultManager();
	89	JMenuItem menuItem = (JMenuItem)e.getComponent();
	90	Point p = e.getPoint();
	91	if(p.x >= 0 && p.x < menuItem.getWidth() &&
	92	p.y >= 0 && p.y < menuItem.getHeight()) {
	93	manager.clearSelectedPath();
	94	menuItem.doClick(0);
	95	} else {
	96	manager.processMouseEvent(e);
	97	}
	98	}
	99	public void mouseEntered(MouseEvent e) {}
	100	public void mouseExited(MouseEvent e) {}
	101	public void mouseDragged(MouseEvent e) {
	102	MenuSelectionManager.defaultManager().processMouseEvent(e);
	103	}
	104	public void mouseMoved(MouseEvent e) { }
	105	}
	106
	107	}

java/pkg/com/sun/java/swing/plaf/motif/MotifCheckBoxUI.java+90−0

@@ -0,0 +1,90 @@
	1	/*
	2	* Copyright (c) 1997, 1998, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.swing.plaf.motif;
	27
	28	import sun.awt.AppContext;
	29
	30	import javax.swing.*;
	31
	32	import javax.swing.plaf.*;
	33
	34	import java.awt.*;
	35
	36	/**
	37	* MotifCheckBox implementation
	38	* <p>
	39	* <strong>Warning:</strong>
	40	* Serialized objects of this class will not be compatible with
	41	* future Swing releases. The current serialization support is appropriate
	42	* for short term storage or RMI between applications running the same
	43	* version of Swing. A future release of Swing will provide support for
	44	* long term persistence.
	45	*
	46	* @author Rich Schiavi
	47	*/
	48	public class MotifCheckBoxUI extends MotifRadioButtonUI {
	49
	50	private static final Object MOTIF_CHECK_BOX_UI_KEY = new Object();
	51
	52	private final static String propertyPrefix = "CheckBox" + ".";
	53
	54	private boolean defaults_initialized = false;
	55
	56
	57	// ********************************
	58	// Create PLAF
	59	// ********************************
	60	public static ComponentUI createUI(JComponent c) {
	61	AppContext appContext = AppContext.getAppContext();
	62	MotifCheckBoxUI motifCheckBoxUI =
	63	(MotifCheckBoxUI) appContext.get(MOTIF_CHECK_BOX_UI_KEY);
	64	if (motifCheckBoxUI == null) {
	65	motifCheckBoxUI = new MotifCheckBoxUI();
	66	appContext.put(MOTIF_CHECK_BOX_UI_KEY, motifCheckBoxUI);
	67	}
	68	return motifCheckBoxUI;
	69	}
	70
	71	public String getPropertyPrefix() {
	72	return propertyPrefix;
	73	}
	74
	75	// ********************************
	76	// Defaults
	77	// ********************************
	78	public void installDefaults(AbstractButton b) {
	79	super.installDefaults(b);
	80	if(!defaults_initialized) {
	81	icon = UIManager.getIcon(getPropertyPrefix() + "icon");
	82	defaults_initialized = true;
	83	}
	84	}
	85
	86	protected void uninstallDefaults(AbstractButton b) {
	87	super.uninstallDefaults(b);
	88	defaults_initialized = false;
	89	}
	90	}

java/pkg/com/sun/java/swing/plaf/motif/MotifComboBoxUI.java+361−0

@@ -0,0 +1,361 @@
	1	/*
	2	* Copyright (c) 1997, 2006, 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	package com.sun.java.swing.plaf.motif;
	26
	27	import java.awt.*;
	28	import javax.swing.*;
	29	import javax.swing.plaf.*;
	30	import javax.swing.border.*;
	31	import javax.swing.plaf.basic.*;
	32	import java.io.Serializable;
	33	import java.awt.event.*;
	34	import java.beans.*;
	35
	36	/**
	37	* ComboBox motif look and feel
	38	* <p> * <strong>Warning:</strong>
	39	* Serialized objects of this class will not be compatible with
	40	* future Swing releases. The current serialization support is appropriate
	41	* for short term storage or RMI between applications running the same
	42	* version of Swing. A future release of Swing will provide support for
	43	* long term persistence.
	44	*
	45	* @author Arnaud Weber
	46	*/
	47	public class MotifComboBoxUI extends BasicComboBoxUI implements Serializable {
	48	Icon arrowIcon;
	49	static final int HORIZ_MARGIN = 3;
	50
	51	public static ComponentUI createUI(JComponent c) {
	52	return new MotifComboBoxUI();
	53	}
	54
	55	public void installUI(JComponent c) {
	56	super.installUI(c);
	57	arrowIcon = new MotifComboBoxArrowIcon(UIManager.getColor("controlHighlight"),
	58	UIManager.getColor("controlShadow"),
	59	UIManager.getColor("control"));
	60
	61	Runnable initCode = new Runnable() {
	62	public void run(){
	63	if ( motifGetEditor() != null ) {
	64	motifGetEditor().setBackground( UIManager.getColor( "text" ) );
	65	}
	66	}
	67	};
	68
	69	SwingUtilities.invokeLater( initCode );
	70	}
	71
	72	public Dimension getMinimumSize( JComponent c ) {
	73	if ( !isMinimumSizeDirty ) {
	74	return new Dimension( cachedMinimumSize );
	75	}
	76	Dimension size;
	77	Insets insets = getInsets();
	78	size = getDisplaySize();
	79	size.height += insets.top + insets.bottom;
	80	int buttonSize = iconAreaWidth();
	81	size.width += insets.left + insets.right + buttonSize;
	82
	83	cachedMinimumSize.setSize( size.width, size.height );
	84	isMinimumSizeDirty = false;
	85
	86	return size;
	87	}
	88
	89	protected ComboPopup createPopup() {
	90	return new MotifComboPopup( comboBox );
	91	}
	92
	93	/**
	94	* Overriden to empty the MouseMotionListener.
	95	*/
	96	protected class MotifComboPopup extends BasicComboPopup {
	97
	98	public MotifComboPopup( JComboBox comboBox ) {
	99	super( comboBox );
	100	}
	101
	102	/**
	103	* Motif combo popup should not track the mouse in the list.
	104	*/
	105	public MouseMotionListener createListMouseMotionListener() {
	106	return new MouseMotionAdapter() {};
	107	}
	108
	109	public KeyListener createKeyListener() {
	110	return super.createKeyListener();
	111	}
	112
	113	protected class InvocationKeyHandler extends BasicComboPopup.InvocationKeyHandler {
	114	protected InvocationKeyHandler() {
	115	MotifComboPopup.this.super();
	116	}
	117	}
	118	}
	119
	120	protected void installComponents() {
	121	if ( comboBox.isEditable() ) {
	122	addEditor();
	123	}
	124
	125	comboBox.add( currentValuePane );
	126	}
	127
	128	protected void uninstallComponents() {
	129	removeEditor();
	130	comboBox.removeAll();
	131	}
	132
	133	public void paint(Graphics g, JComponent c) {
	134	boolean hasFocus = comboBox.hasFocus();
	135	Rectangle r;
	136
	137	if (comboBox.isEnabled()) {
	138	g.setColor(comboBox.getBackground());
	139	} else {
	140	g.setColor(UIManager.getColor("ComboBox.disabledBackground"));
	141	}
	142	g.fillRect(0,0,c.getWidth(),c.getHeight());
	143
	144	if ( !comboBox.isEditable() ) {
	145	r = rectangleForCurrentValue();
	146	paintCurrentValue(g,r,hasFocus);
	147	}
	148	r = rectangleForArrowIcon();
	149	arrowIcon.paintIcon(c,g,r.x,r.y);
	150	if ( !comboBox.isEditable() ) {
	151	Border border = comboBox.getBorder();
	152	Insets in;
	153	if ( border != null ) {
	154	in = border.getBorderInsets(comboBox);
	155	}
	156	else {
	157	in = new Insets( 0, 0, 0, 0 );
	158	}
	159	// Draw the separation
	160	if(MotifGraphicsUtils.isLeftToRight(comboBox)) {
	161	r.x -= (HORIZ_MARGIN + 2);
	162	}
	163	else {
	164	r.x += r.width + HORIZ_MARGIN + 1;
	165	}
	166	r.y = in.top;
	167	r.width = 1;
	168	r.height = comboBox.getBounds().height - in.bottom - in.top;
	169	g.setColor(UIManager.getColor("controlShadow"));
	170	g.fillRect(r.x,r.y,r.width,r.height);
	171	r.x++;
	172	g.setColor(UIManager.getColor("controlHighlight"));
	173	g.fillRect(r.x,r.y,r.width,r.height);
	174	}
	175	}
	176
	177	public void paintCurrentValue(Graphics g,Rectangle bounds,boolean hasFocus) {
	178	ListCellRenderer renderer = comboBox.getRenderer();
	179	Component c;
	180	Dimension d;
	181	c = renderer.getListCellRendererComponent(listBox, comboBox.getSelectedItem(), -1, false, false);
	182	c.setFont(comboBox.getFont());
	183	if ( comboBox.isEnabled() ) {
	184	c.setForeground(comboBox.getForeground());
	185	c.setBackground(comboBox.getBackground());
	186	}
	187	else {
	188	c.setForeground(UIManager.getColor("ComboBox.disabledForeground"));
	189	c.setBackground(UIManager.getColor("ComboBox.disabledBackground"));
	190	}
	191	d = c.getPreferredSize();
	192	currentValuePane.paintComponent(g,c,comboBox,bounds.x,bounds.y,
	193	bounds.width,d.height);
	194	}
	195
	196	protected Rectangle rectangleForArrowIcon() {
	197	Rectangle b = comboBox.getBounds();
	198	Border border = comboBox.getBorder();
	199	Insets in;
	200	if ( border != null ) {
	201	in = border.getBorderInsets(comboBox);
	202	}
	203	else {
	204	in = new Insets( 0, 0, 0, 0 );
	205	}
	206	b.x = in.left;
	207	b.y = in.top;
	208	b.width -= (in.left + in.right);
	209	b.height -= (in.top + in.bottom);
	210
	211	if(MotifGraphicsUtils.isLeftToRight(comboBox)) {
	212	b.x = b.x + b.width - HORIZ_MARGIN - arrowIcon.getIconWidth();
	213	}
	214	else {
	215	b.x += HORIZ_MARGIN;
	216	}
	217	b.y = b.y + (b.height - arrowIcon.getIconHeight()) / 2;
	218	b.width = arrowIcon.getIconWidth();
	219	b.height = arrowIcon.getIconHeight();
	220	return b;
	221	}
	222
	223	protected Rectangle rectangleForCurrentValue() {
	224	int width = comboBox.getWidth();
	225	int height = comboBox.getHeight();
	226	Insets insets = getInsets();
	227	if(MotifGraphicsUtils.isLeftToRight(comboBox)) {
	228	return new Rectangle(insets.left, insets.top,
	229	(width - (insets.left + insets.right)) -
	230	iconAreaWidth(),
	231	height - (insets.top + insets.bottom));
	232	}
	233	else {
	234	return new Rectangle(insets.left + iconAreaWidth(), insets.top,
	235	(width - (insets.left + insets.right)) -
	236	iconAreaWidth(),
	237	height - (insets.top + insets.bottom));
	238	}
	239	}
	240
	241	public int iconAreaWidth() {
	242	if ( comboBox.isEditable() )
	243	return arrowIcon.getIconWidth() + (2 * HORIZ_MARGIN);
	244	else
	245	return arrowIcon.getIconWidth() + (3 * HORIZ_MARGIN) + 2;
	246	}
	247
	248	public void configureEditor() {
	249	super.configureEditor();
	250	editor.setBackground( UIManager.getColor( "text" ) );
	251	}
	252
	253	protected LayoutManager createLayoutManager() {
	254	return new ComboBoxLayoutManager();
	255	}
	256
	257	private Component motifGetEditor() {
	258	return editor;
	259	}
	260
	261	/**
	262	* This inner class is marked "public" due to a compiler bug.
	263	* This class should be treated as a "protected" inner class.
	264	* Instantiate it only within subclasses of <FooUI>.
	265	*/
	266	public class ComboBoxLayoutManager extends BasicComboBoxUI.ComboBoxLayoutManager {
	267	public ComboBoxLayoutManager() {
	268	MotifComboBoxUI.this.super();
	269	}
	270	public void layoutContainer(Container parent) {
	271	if ( motifGetEditor() != null ) {
	272	Rectangle cvb = rectangleForCurrentValue();
	273	cvb.x += 1;
	274	cvb.y += 1;
	275	cvb.width -= 1;
	276	cvb.height -= 2;
	277	motifGetEditor().setBounds(cvb);
	278	}
	279	}
	280	}
	281
	282	static class MotifComboBoxArrowIcon implements Icon, Serializable {
	283	private Color lightShadow;
	284	private Color darkShadow;
	285	private Color fill;
	286
	287	public MotifComboBoxArrowIcon(Color lightShadow, Color darkShadow, Color fill) {
	288	this.lightShadow = lightShadow;
	289	this.darkShadow = darkShadow;
	290	this.fill = fill;
	291	}
	292
	293
	294	public void paintIcon(Component c, Graphics g, int xo, int yo) {
	295	int w = getIconWidth();
	296	int h = getIconHeight();
	297
	298	g.setColor(lightShadow);
	299	g.drawLine(xo, yo, xo+w-1, yo);
	300	g.drawLine(xo, yo+1, xo+w-3, yo+1);
	301	g.setColor(darkShadow);
	302	g.drawLine(xo+w-2, yo+1, xo+w-1, yo+1);
	303
	304	for ( int x = xo+1, y = yo+2, dx = w-6; y+1 < yo+h; y += 2 ) {
	305	g.setColor(lightShadow);
	306	g.drawLine(x, y, x+1, y);
	307	g.drawLine(x, y+1, x+1, y+1);
	308	if ( dx > 0 ) {
	309	g.setColor(fill);
	310	g.drawLine(x+2, y, x+1+dx, y);
	311	g.drawLine(x+2, y+1, x+1+dx, y+1);
	312	}
	313	g.setColor(darkShadow);
	314	g.drawLine(x+dx+2, y, x+dx+3, y);
	315	g.drawLine(x+dx+2, y+1, x+dx+3, y+1);
	316	x += 1;
	317	dx -= 2;
	318	}
	319
	320	g.setColor(darkShadow);
	321	g.drawLine(xo+(w/2), yo+h-1, xo+(w/2), yo+h-1);
	322
	323	}
	324
	325	public int getIconWidth() {
	326	return 11;
	327	}
	328
	329	public int getIconHeight() {
	330	return 11;
	331	}
	332	}
	333
	334	/**
	335	*{@inheritDoc}
	336	*
	337	* @since 1.6
	338	*/
	339	protected PropertyChangeListener createPropertyChangeListener() {
	340	return new MotifPropertyChangeListener();
	341	}
	342
	343	/**
	344	* This class should be made "protected" in future releases.
	345	*/
	346	private class MotifPropertyChangeListener
	347	extends BasicComboBoxUI.PropertyChangeHandler {
	348	public void propertyChange(PropertyChangeEvent e) {
	349	super.propertyChange(e);
	350	String propertyName = e.getPropertyName();
	351	if (propertyName == "enabled") {
	352	if (comboBox.isEnabled()) {
	353	Component editor = motifGetEditor();
	354	if (editor != null) {
	355	editor.setBackground(UIManager.getColor("text"));
	356	}
	357	}
	358	}
	359	}
	360	}
	361	}

java/pkg/com/sun/java/swing/plaf/motif/MotifDesktopIconUI.java+365−0

@@ -0,0 +1,365 @@
	1	/*
	2	* Copyright (c) 1997, 2005, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.swing.plaf.motif;
	27
	28	import sun.swing.SwingUtilities2;
	29	import java.awt.*;
	30	import java.awt.event.*;
	31	import javax.swing.*;
	32	import javax.swing.border.*;
	33	import javax.swing.plaf.*;
	34	import javax.swing.plaf.basic.*;
	35	import java.beans.*;
	36	import java.util.EventListener;
	37	import java.io.Serializable;
	38
	39
	40	/**
	41	* Motif rendition of the component.
	42	*
	43	* @author Thomas Ball
	44	* @author Rich Schiavi
	45	*/
	46	public class MotifDesktopIconUI extends BasicDesktopIconUI
	47	{
	48	protected DesktopIconActionListener desktopIconActionListener;
	49	protected DesktopIconMouseListener desktopIconMouseListener;
	50
	51	protected Icon defaultIcon;
	52	protected IconButton iconButton;
	53	protected IconLabel iconLabel;
	54
	55	// This is only used for its system menu, but we need a reference to it so
	56	// we can remove its listeners.
	57	private MotifInternalFrameTitlePane sysMenuTitlePane;
	58
	59	JPopupMenu systemMenu;
	60	EventListener mml;
	61
	62	final static int LABEL_HEIGHT = 18;
	63	final static int LABEL_DIVIDER = 4; // padding between icon and label
	64
	65	final static Font defaultTitleFont =
	66	new Font(Font.SANS_SERIF, Font.PLAIN, 12);
	67
	68	public static ComponentUI createUI(JComponent c) {
	69	return new MotifDesktopIconUI();
	70	}
	71
	72	public MotifDesktopIconUI() {
	73	}
	74
	75	protected void installDefaults(){
	76	super.installDefaults();
	77	setDefaultIcon(UIManager.getIcon("DesktopIcon.icon"));
	78	iconButton = createIconButton(defaultIcon);
	79	// An underhanded way of creating a system popup menu.
	80	sysMenuTitlePane = new MotifInternalFrameTitlePane(frame);
	81	systemMenu = sysMenuTitlePane.getSystemMenu();
	82
	83	MotifBorders.FrameBorder border = new MotifBorders.FrameBorder(desktopIcon);
	84	desktopIcon.setLayout(new BorderLayout());
	85	iconButton.setBorder(border);
	86	desktopIcon.add(iconButton, BorderLayout.CENTER);
	87	iconLabel = createIconLabel(frame);
	88	iconLabel.setBorder(border);
	89	desktopIcon.add(iconLabel, BorderLayout.SOUTH);
	90	desktopIcon.setSize(desktopIcon.getPreferredSize());
	91	desktopIcon.validate();
	92	JLayeredPane.putLayer(desktopIcon, JLayeredPane.getLayer(frame));
	93	}
	94
	95	protected void installComponents(){
	96	}
	97
	98	protected void uninstallComponents(){
	99	}
	100
	101	protected void installListeners(){
	102	super.installListeners();
	103	desktopIconActionListener = createDesktopIconActionListener();
	104	desktopIconMouseListener = createDesktopIconMouseListener();
	105	iconButton.addActionListener(desktopIconActionListener);
	106	iconButton.addMouseListener(desktopIconMouseListener);
	107	iconLabel.addMouseListener(desktopIconMouseListener);
	108	}
	109
	110	JInternalFrame.JDesktopIcon getDesktopIcon(){
	111	return desktopIcon;
	112	}
	113
	114	void setDesktopIcon(JInternalFrame.JDesktopIcon d){
	115	desktopIcon = d;
	116	}
	117
	118	JInternalFrame getFrame(){
	119	return frame;
	120	}
	121
	122	void setFrame(JInternalFrame f){
	123	frame = f ;
	124	}
	125
	126	protected void showSystemMenu(){
	127	systemMenu.show(iconButton, 0, getDesktopIcon().getHeight());
	128	}
	129
	130	protected void hideSystemMenu(){
	131	systemMenu.setVisible(false);
	132	}
	133
	134	protected IconLabel createIconLabel(JInternalFrame frame){
	135	return new IconLabel(frame);
	136	}
	137
	138	protected IconButton createIconButton(Icon i){
	139	return new IconButton(i);
	140	}
	141
	142	protected DesktopIconActionListener createDesktopIconActionListener(){
	143	return new DesktopIconActionListener();
	144	}
	145
	146	protected DesktopIconMouseListener createDesktopIconMouseListener(){
	147	return new DesktopIconMouseListener();
	148	}
	149
	150	protected void uninstallDefaults(){
	151	super.uninstallDefaults();
	152	desktopIcon.setLayout(null);
	153	desktopIcon.remove(iconButton);
	154	desktopIcon.remove(iconLabel);
	155	}
	156
	157	protected void uninstallListeners(){
	158	super.uninstallListeners();
	159	iconButton.removeActionListener(desktopIconActionListener);
	160	iconButton.removeMouseListener(desktopIconMouseListener);
	161	sysMenuTitlePane.uninstallListeners();
	162	}
	163
	164	public Dimension getMinimumSize(JComponent c) {
	165	JInternalFrame iframe = desktopIcon.getInternalFrame();
	166
	167	int w = defaultIcon.getIconWidth();
	168	int h = defaultIcon.getIconHeight() + LABEL_HEIGHT + LABEL_DIVIDER;
	169
	170	Border border = iframe.getBorder();
	171	if(border != null) {
	172	w += border.getBorderInsets(iframe).left +
	173	border.getBorderInsets(iframe).right;
	174	h += border.getBorderInsets(iframe).bottom +
	175	border.getBorderInsets(iframe).top;
	176	}
	177
	178	return new Dimension(w, h);
	179	}
	180
	181	public Dimension getPreferredSize(JComponent c) {
	182	return getMinimumSize(c);
	183	}
	184
	185	public Dimension getMaximumSize(JComponent c){
	186	return getMinimumSize(c);
	187	}
	188
	189	/**
	190	* Returns the default desktop icon.
	191	*/
	192	public Icon getDefaultIcon() {
	193	return defaultIcon;
	194	}
	195
	196	/**
	197	* Sets the icon used as the default desktop icon.
	198	*/
	199	public void setDefaultIcon(Icon newIcon) {
	200	defaultIcon = newIcon;
	201	}
	202
	203	protected class IconLabel extends JPanel {
	204	JInternalFrame frame;
	205
	206	IconLabel(JInternalFrame f) {
	207	super();
	208	this.frame = f;
	209	setFont(defaultTitleFont);
	210
	211	// Forward mouse events to titlebar for moves.
	212	addMouseMotionListener(new MouseMotionListener() {
	213	public void mouseDragged(MouseEvent e) {
	214	forwardEventToParent(e);
	215	}
	216	public void mouseMoved(MouseEvent e) {
	217	forwardEventToParent(e);
	218	}
	219	});
	220	addMouseListener(new MouseListener() {
	221	public void mouseClicked(MouseEvent e) {
	222	forwardEventToParent(e);
	223	}
	224	public void mousePressed(MouseEvent e) {
	225	forwardEventToParent(e);
	226	}
	227	public void mouseReleased(MouseEvent e) {
	228	forwardEventToParent(e);
	229	}
	230	public void mouseEntered(MouseEvent e) {
	231	forwardEventToParent(e);
	232	}
	233	public void mouseExited(MouseEvent e) {
	234	forwardEventToParent(e);
	235	}
	236	});
	237	}
	238
	239	void forwardEventToParent(MouseEvent e) {
	240	getParent().dispatchEvent(new MouseEvent(
	241	getParent(), e.getID(), e.getWhen(), e.getModifiers(),
	242	e.getX(), e.getY(), e.getXOnScreen(),
	243	e.getYOnScreen(), e.getClickCount(),
	244	e.isPopupTrigger(), MouseEvent.NOBUTTON));
	245	}
	246
	247	public boolean isFocusTraversable() {
	248	return false;
	249	}
	250
	251	public Dimension getMinimumSize() {
	252	return new Dimension(defaultIcon.getIconWidth() + 1,
	253	LABEL_HEIGHT + LABEL_DIVIDER);
	254	}
	255
	256	public Dimension getPreferredSize() {
	257	String title = frame.getTitle();
	258	FontMetrics fm = frame.getFontMetrics(defaultTitleFont);
	259	int w = 4;
	260	if (title != null) {
	261	w += SwingUtilities2.stringWidth(frame, fm, title);
	262	}
	263	return new Dimension(w, LABEL_HEIGHT + LABEL_DIVIDER);
	264	}
	265
	266	public void paint(Graphics g) {
	267	super.paint(g);
	268
	269	// touch-up frame
	270	int maxX = getWidth() - 1;
	271	Color shadow =
	272	UIManager.getColor("inactiveCaptionBorder").darker().darker();
	273	g.setColor(shadow);
	274	g.setClip(0, 0, getWidth(), getHeight());
	275	g.drawLine(maxX - 1, 1, maxX - 1, 1);
	276	g.drawLine(maxX, 0, maxX, 0);
	277
	278	// fill background
	279	g.setColor(UIManager.getColor("inactiveCaption"));
	280	g.fillRect(2, 1, maxX - 3, LABEL_HEIGHT + 1);
	281
	282	// draw text -- clipping to truncate text like CDE/Motif
	283	g.setClip(2, 1, maxX - 4, LABEL_HEIGHT);
	284	int y = LABEL_HEIGHT - SwingUtilities2.getFontMetrics(frame, g).
	285	getDescent();
	286	g.setColor(UIManager.getColor("inactiveCaptionText"));
	287	String title = frame.getTitle();
	288	if (title != null) {
	289	SwingUtilities2.drawString(frame, g, title, 4, y);
	290	}
	291	}
	292	}
	293
	294	protected class IconButton extends JButton {
	295	Icon icon;
	296
	297	IconButton(Icon icon) {
	298	super(icon);
	299	this.icon = icon;
	300	// Forward mouse events to titlebar for moves.
	301	addMouseMotionListener(new MouseMotionListener() {
	302	public void mouseDragged(MouseEvent e) {
	303	forwardEventToParent(e);
	304	}
	305	public void mouseMoved(MouseEvent e) {
	306	forwardEventToParent(e);
	307	}
	308	});
	309	addMouseListener(new MouseListener() {
	310	public void mouseClicked(MouseEvent e) {
	311	forwardEventToParent(e);
	312	}
	313	public void mousePressed(MouseEvent e) {
	314	forwardEventToParent(e);
	315	}
	316	public void mouseReleased(MouseEvent e) {
	317	if (!systemMenu.isShowing()) {
	318	forwardEventToParent(e);
	319	}
	320	}
	321	public void mouseEntered(MouseEvent e) {
	322	forwardEventToParent(e);
	323	}
	324	public void mouseExited(MouseEvent e) {
	325	forwardEventToParent(e);
	326	}
	327	});
	328	}
	329
	330	void forwardEventToParent(MouseEvent e) {
	331	getParent().dispatchEvent(new MouseEvent(
	332	getParent(), e.getID(), e.getWhen(), e.getModifiers(),
	333	e.getX(), e.getY(), e.getXOnScreen(), e.getYOnScreen(),
	334	e.getClickCount(), e.isPopupTrigger(), MouseEvent.NOBUTTON ));
	335	}
	336
	337	public boolean isFocusTraversable() {
	338	return false;
	339	}
	340	}
	341
	342
	343	protected class DesktopIconActionListener implements ActionListener {
	344	public void actionPerformed(ActionEvent e){
	345	systemMenu.show(iconButton, 0, getDesktopIcon().getHeight());
	346	}
	347	}
	348
	349	protected class DesktopIconMouseListener extends MouseAdapter {
	350	// if we drag or move we should deengage the popup
	351	public void mousePressed(MouseEvent e){
	352	if (e.getClickCount() > 1) {
	353	try {
	354	getFrame().setIcon(false);
	355	} catch (PropertyVetoException e2){ }
	356	systemMenu.setVisible(false);
	357	/* the mouse release will not get reported correctly,
	358	because the icon will no longer be in the hierarchy;
	359	maybe that should be fixed, but until it is, we need
	360	to do the required cleanup here. */
	361	getFrame().getDesktopPane().getDesktopManager().endDraggingFrame((JComponent)e.getSource());
	362	}
	363	}
	364	}
	365	}

java/pkg/com/sun/java/swing/plaf/motif/MotifDesktopPaneUI.java+267−0

@@ -0,0 +1,267 @@
	1	/*
	2	* Copyright (c) 1997, 2003, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.swing.plaf.motif;
	27
	28	import javax.swing.*;
	29	import java.awt.Rectangle;
	30	import java.awt.Dimension;
	31	import java.awt.Insets;
	32	import java.awt.Color;
	33	import java.awt.Graphics;
	34	import java.awt.Component;
	35	import java.awt.Point;
	36	import javax.swing.plaf.*;
	37	import java.io.Serializable;
	38
	39	/**
	40	* <p>
	41	* <strong>Warning:</strong>
	42	* Serialized objects of this class will not be compatible with
	43	* future Swing releases. The current serialization support is appropriate
	44	* for short term storage or RMI between applications running the same
	45	* version of Swing. A future release of Swing will provide support for
	46	* long term persistence.
	47	*
	48	* @author David Kloba
	49	*/
	50	public class MotifDesktopPaneUI extends javax.swing.plaf.basic.BasicDesktopPaneUI
	51	{
	52
	53	/// DesktopPaneUI methods
	54	public static ComponentUI createUI(JComponent d) {
	55	return new MotifDesktopPaneUI();
	56	}
	57
	58	public MotifDesktopPaneUI() {
	59	}
	60
	61	protected void installDesktopManager() {
	62	desktopManager = desktop.getDesktopManager();
	63	if(desktopManager == null) {
	64	desktopManager = new MotifDesktopManager();
	65	desktop.setDesktopManager(desktopManager);
	66	((MotifDesktopManager)desktopManager).adjustIcons(desktop);
	67	}
	68	}
	69
	70	public Insets getInsets(JComponent c) {return new Insets(0,0,0,0);}
	71
	72	////////////////////////////////////////////////////////////////////////////////////
	73	/// DragPane class
	74	////////////////////////////////////////////////////////////////////////////////////
	75	private class DragPane extends JComponent {
	76	public void paint(Graphics g) {
	77	g.setColor(Color.darkGray);
	78	g.drawRect(0, 0, getWidth()-1, getHeight()-1);
	79	}
	80	};
	81
	82	////////////////////////////////////////////////////////////////////////////////////
	83	/// MotifDesktopManager class
	84	////////////////////////////////////////////////////////////////////////////////////
	85	private class MotifDesktopManager extends DefaultDesktopManager implements Serializable, UIResource {
	86	JComponent dragPane;
	87	boolean usingDragPane = false;
	88	private transient JLayeredPane layeredPaneForDragPane;
	89	int iconWidth, iconHeight;
	90
	91	// PENDING(klobad) this should be optimized
	92	public void setBoundsForFrame(JComponent f, int newX, int newY,
	93	int newWidth, int newHeight) {
	94	if(!usingDragPane) {
	95	boolean didResize;
	96	didResize = (f.getWidth() != newWidth \|\| f.getHeight() != newHeight);
	97	Rectangle r = f.getBounds();
	98	f.setBounds(newX, newY, newWidth, newHeight);
	99	SwingUtilities.computeUnion(newX, newY, newWidth, newHeight, r);
	100	f.getParent().repaint(r.x, r.y, r.width, r.height);
	101	if(didResize) {
	102	f.validate();
	103	}
	104	} else {
	105	Rectangle r = dragPane.getBounds();
	106	dragPane.setBounds(newX, newY, newWidth, newHeight);
	107	SwingUtilities.computeUnion(newX, newY, newWidth, newHeight, r);
	108	dragPane.getParent().repaint(r.x, r.y, r.width, r.height);
	109	}
	110	}
	111
	112	public void beginDraggingFrame(JComponent f) {
	113	usingDragPane = false;
	114	if(f.getParent() instanceof JLayeredPane) {
	115	if(dragPane == null)
	116	dragPane = new DragPane();
	117	layeredPaneForDragPane = (JLayeredPane)f.getParent();
	118	layeredPaneForDragPane.setLayer(dragPane, Integer.MAX_VALUE);
	119	dragPane.setBounds(f.getX(), f.getY(), f.getWidth(), f.getHeight());
	120	layeredPaneForDragPane.add(dragPane);
	121	usingDragPane = true;
	122	}
	123	}
	124
	125	public void dragFrame(JComponent f, int newX, int newY) {
	126	setBoundsForFrame(f, newX, newY, f.getWidth(), f.getHeight());
	127	}
	128
	129	public void endDraggingFrame(JComponent f) {
	130	if(usingDragPane) {
	131	layeredPaneForDragPane.remove(dragPane);
	132	usingDragPane = false;
	133	if (f instanceof JInternalFrame) {
	134	setBoundsForFrame(f, dragPane.getX(), dragPane.getY(),
	135	dragPane.getWidth(), dragPane.getHeight());
	136	} else if (f instanceof JInternalFrame.JDesktopIcon) {
	137	adjustBoundsForIcon((JInternalFrame.JDesktopIcon)f,
	138	dragPane.getX(), dragPane.getY());
	139	}
	140	}
	141	}
	142
	143	public void beginResizingFrame(JComponent f, int direction) {
	144	usingDragPane = false;
	145	if(f.getParent() instanceof JLayeredPane) {
	146	if(dragPane == null)
	147	dragPane = new DragPane();
	148	JLayeredPane p = (JLayeredPane)f.getParent();
	149	p.setLayer(dragPane, Integer.MAX_VALUE);
	150	dragPane.setBounds(f.getX(), f.getY(),
	151	f.getWidth(), f.getHeight());
	152	p.add(dragPane);
	153	usingDragPane = true;
	154	}
	155	}
	156
	157	public void resizeFrame(JComponent f, int newX, int newY,
	158	int newWidth, int newHeight) {
	159	setBoundsForFrame(f, newX, newY, newWidth, newHeight);
	160	}
	161
	162	public void endResizingFrame(JComponent f) {
	163	if(usingDragPane) {
	164	JLayeredPane p = (JLayeredPane)f.getParent();
	165	p.remove(dragPane);
	166	usingDragPane = false;
	167	setBoundsForFrame(f, dragPane.getX(), dragPane.getY(),
	168	dragPane.getWidth(), dragPane.getHeight());
	169	}
	170	}
	171
	172	public void iconifyFrame(JInternalFrame f) {
	173	JInternalFrame.JDesktopIcon icon = f.getDesktopIcon();
	174	Point p = icon.getLocation();
	175	adjustBoundsForIcon(icon, p.x, p.y);
	176	super.iconifyFrame(f);
	177	}
	178
	179	/**
	180	* Change positions of icons in the desktop pane so that
	181	* they do not overlap
	182	*/
	183	protected void adjustIcons(JDesktopPane desktop) {
	184	// We need to know Motif icon size
	185	JInternalFrame.JDesktopIcon icon = new JInternalFrame.JDesktopIcon(
	186	new JInternalFrame());
	187	Dimension iconSize = icon.getPreferredSize();
	188	iconWidth = iconSize.width;
	189	iconHeight = iconSize.height;
	190
	191	JInternalFrame[] frames = desktop.getAllFrames();
	192	for (int i=0; i<frames.length; i++) {
	193	icon = frames[i].getDesktopIcon();
	194	Point ip = icon.getLocation();
	195	adjustBoundsForIcon(icon, ip.x, ip.y);
	196	}
	197	}
	198
	199	/**
	200	* Change positions of icon so that it doesn't overlap
	201	* other icons.
	202	*/
	203	protected void adjustBoundsForIcon(JInternalFrame.JDesktopIcon icon,
	204	int x, int y) {
	205	JDesktopPane c = icon.getDesktopPane();
	206
	207	int maxy = c.getHeight();
	208	int w = iconWidth;
	209	int h = iconHeight;
	210	c.repaint(x, y, w, h);
	211	x = x < 0 ? 0 : x;
	212	y = y < 0 ? 0 : y;
	213
	214	/* Fix for disappearing icons. If the y value is maxy then this
	215	* algorithm would place the icon in a non-displayed cell. Never
	216	* to be ssen again.*/
	217	y = y >= maxy ? (maxy - 1) : y;
	218
	219	/* Compute the offset for the cell we are trying to go in. */
	220	int lx = (x / w) * w;
	221	int ygap = maxy % h;
	222	int ly = ((y-ygap) / h) * h + ygap;
	223
	224	/* How far are we into the cell we dropped the icon in. */
	225	int dx = x - lx;
	226	int dy = y - ly;
	227
	228	/* Set coordinates for the icon. */
	229	x = dx < w/2 ? lx: lx + w;
	230	y = dy < h/2 ? ly: ((ly + h) < maxy ? ly + h: ly);
	231
	232	while (getIconAt(c, icon, x, y) != null) {
	233	x += w;
	234	}
	235
	236	/* Cancel the move if the x value was moved off screen. */
	237	if (x > c.getWidth()) {
	238	return;
	239	}
	240	if (icon.getParent() != null) {
	241	setBoundsForFrame(icon, x, y, w, h);
	242	} else {
	243	icon.setLocation(x, y);
	244	}
	245	}
	246
	247	protected JInternalFrame.JDesktopIcon getIconAt(JDesktopPane desktop,
	248	JInternalFrame.JDesktopIcon icon, int x, int y) {
	249
	250	JInternalFrame.JDesktopIcon currentIcon = null;
	251	Component[] components = desktop.getComponents();
	252
	253	for (int i=0; i<components.length; i++) {
	254	Component comp = components[i];
	255	if (comp instanceof JInternalFrame.JDesktopIcon &&
	256	comp != icon) {
	257
	258	Point p = comp.getLocation();
	259	if (p.x == x && p.y == y) {
	260	return (JInternalFrame.JDesktopIcon)comp;
	261	}
	262	}
	263	}
	264	return null;
	265	}
	266	}; /// END of MotifDesktopManager
	267	}

java/pkg/com/sun/java/swing/plaf/motif/MotifEditorPaneUI.java+68−0

@@ -0,0 +1,68 @@
	1	/*
	2	* Copyright (c) 1997, 1998, 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	package com.sun.java.swing.plaf.motif;
	26
	27	import javax.swing.*;
	28	import javax.swing.text.*;
	29	import javax.swing.plaf.*;
	30	import javax.swing.plaf.basic.BasicEditorPaneUI;
	31
	32	/**
	33	* Provides the look and feel for an pluggable content-type text editor.
	34	* <p>
	35	* <strong>Warning:</strong>
	36	* Serialized objects of this class will not be compatible with
	37	* future Swing releases. The current serialization support is appropriate
	38	* for short term storage or RMI between applications running the same
	39	* version of Swing. A future release of Swing will provide support for
	40	* long term persistence.
	41	*
	42	* @author Timothy Prinzing
	43	*/
	44	public class MotifEditorPaneUI extends BasicEditorPaneUI {
	45
	46	/**
	47	* Creates a UI for the JTextPane.
	48	*
	49	* @param c the JTextPane component
	50	* @return the UI
	51	*/
	52	public static ComponentUI createUI(JComponent c) {
	53	return new MotifEditorPaneUI();
	54	}
	55
	56	/**
	57	* Creates the object to use for a caret. By default an
	58	* instance of MotifTextUI.MotifCaret is created. This method
	59	* can be redefined to provide something else that implements
	60	* the Caret interface.
	61	*
	62	* @return the caret object
	63	*/
	64	protected Caret createCaret() {
	65	return MotifTextUI.createCaret();
	66	}
	67
	68	}

java/pkg/com/sun/java/swing/plaf/motif/MotifFileChooserUI.java+846−0

@@ -0,0 +1,846 @@
	1	/*
	2	* Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.swing.plaf.motif;
	27
	28	import javax.swing.*;
	29	import javax.swing.filechooser.*;
	30	import javax.swing.event.*;
	31	import javax.swing.plaf.*;
	32	import javax.swing.plaf.basic.*;
	33	import java.awt.*;
	34	import java.awt.event.MouseAdapter;
	35	import java.awt.event.MouseEvent;
	36	import java.beans.*;
	37	import java.io.File;
	38	import java.io.IOException;
	39	import java.util.*;
	40	import sun.awt.shell.ShellFolder;
	41	import sun.swing.SwingUtilities2;
	42
	43	/**
	44	* Motif FileChooserUI.
	45	*
	46	* @author Jeff Dinkins
	47	*/
	48	public class MotifFileChooserUI extends BasicFileChooserUI {
	49
	50	private FilterComboBoxModel filterComboBoxModel;
	51
	52	protected JList directoryList = null;
	53	protected JList fileList = null;
	54
	55	protected JTextField pathField = null;
	56	protected JComboBox filterComboBox = null;
	57	protected JTextField filenameTextField = null;
	58
	59	private static final Dimension hstrut10 = new Dimension(10, 1);
	60	private static final Dimension vstrut10 = new Dimension(1, 10);
	61
	62	private static final Insets insets = new Insets(10, 10, 10, 10);
	63
	64	private static Dimension prefListSize = new Dimension(75, 150);
	65
	66	private static Dimension WITH_ACCELERATOR_PREF_SIZE = new Dimension(650, 450);
	67	private static Dimension PREF_SIZE = new Dimension(350, 450);
	68	private static Dimension MIN_SIZE = new Dimension(200, 300);
	69
	70	private static Dimension PREF_ACC_SIZE = new Dimension(10, 10);
	71	private static Dimension ZERO_ACC_SIZE = new Dimension(1, 1);
	72
	73	private static Dimension MAX_SIZE = new Dimension(Short.MAX_VALUE, Short.MAX_VALUE);
	74
	75	private static final Insets buttonMargin = new Insets(3, 3, 3, 3);
	76
	77	private JPanel bottomPanel;
	78
	79	protected JButton approveButton;
	80
	81	private String enterFolderNameLabelText = null;
	82	private int enterFolderNameLabelMnemonic = 0;
	83	private String enterFileNameLabelText = null;
	84	private int enterFileNameLabelMnemonic = 0;
	85
	86	private String filesLabelText = null;
	87	private int filesLabelMnemonic = 0;
	88
	89	private String foldersLabelText = null;
	90	private int foldersLabelMnemonic = 0;
	91
	92	private String pathLabelText = null;
	93	private int pathLabelMnemonic = 0;
	94
	95	private String filterLabelText = null;
	96	private int filterLabelMnemonic = 0;
	97
	98	private JLabel fileNameLabel;
	99
	100	private void populateFileNameLabel() {
	101	if (getFileChooser().getFileSelectionMode() == JFileChooser.DIRECTORIES_ONLY) {
	102	fileNameLabel.setText(enterFolderNameLabelText);
	103	fileNameLabel.setDisplayedMnemonic(enterFolderNameLabelMnemonic);
	104	} else {
	105	fileNameLabel.setText(enterFileNameLabelText);
	106	fileNameLabel.setDisplayedMnemonic(enterFileNameLabelMnemonic);
	107	}
	108	}
	109
	110	private String fileNameString(File file) {
	111	if (file == null) {
	112	return null;
	113	} else {
	114	JFileChooser fc = getFileChooser();
	115	if (fc.isDirectorySelectionEnabled() && !fc.isFileSelectionEnabled()) {
	116	return file.getPath();
	117	} else {
	118	return file.getName();
	119	}
	120	}
	121	}
	122
	123	private String fileNameString(File[] files) {
	124	StringBuffer buf = new StringBuffer();
	125	for (int i = 0; files != null && i < files.length; i++) {
	126	if (i > 0) {
	127	buf.append(" ");
	128	}
	129	if (files.length > 1) {
	130	buf.append("\"");
	131	}
	132	buf.append(fileNameString(files[i]));
	133	if (files.length > 1) {
	134	buf.append("\"");
	135	}
	136	}
	137	return buf.toString();
	138	}
	139
	140	public MotifFileChooserUI(JFileChooser filechooser) {
	141	super(filechooser);
	142	}
	143
	144	public String getFileName() {
	145	if(filenameTextField != null) {
	146	return filenameTextField.getText();
	147	} else {
	148	return null;
	149	}
	150	}
	151
	152	public void setFileName(String filename) {
	153	if(filenameTextField != null) {
	154	filenameTextField.setText(filename);
	155	}
	156	}
	157
	158	public String getDirectoryName() {
	159	return pathField.getText();
	160	}
	161
	162	public void setDirectoryName(String dirname) {
	163	pathField.setText(dirname);
	164	}
	165
	166	public void ensureFileIsVisible(JFileChooser fc, File f) {
	167	// PENDING(jeff)
	168	}
	169
	170	public void rescanCurrentDirectory(JFileChooser fc) {
	171	getModel().validateFileCache();
	172	}
	173
	174	public PropertyChangeListener createPropertyChangeListener(JFileChooser fc) {
	175	return new PropertyChangeListener() {
	176	public void propertyChange(PropertyChangeEvent e) {
	177	String prop = e.getPropertyName();
	178	if(prop.equals(JFileChooser.SELECTED_FILE_CHANGED_PROPERTY)) {
	179	File f = (File) e.getNewValue();
	180	if(f != null) {
	181	setFileName(getFileChooser().getName(f));
	182	}
	183	} else if (prop.equals(JFileChooser.SELECTED_FILES_CHANGED_PROPERTY)) {
	184	File[] files = (File[]) e.getNewValue();
	185	JFileChooser fc = getFileChooser();
	186	if (files != null && files.length > 0 && (files.length > 1 \|\| fc.isDirectorySelectionEnabled()
	187	\|\| !files[0].isDirectory())) {
	188	setFileName(fileNameString(files));
	189	}
	190	} else if (prop.equals(JFileChooser.FILE_FILTER_CHANGED_PROPERTY)) {
	191	fileList.clearSelection();
	192	} else if(prop.equals(JFileChooser.DIRECTORY_CHANGED_PROPERTY)) {
	193	directoryList.clearSelection();
	194	ListSelectionModel sm = directoryList.getSelectionModel();
	195	if (sm instanceof DefaultListSelectionModel) {
	196	((DefaultListSelectionModel)sm).moveLeadSelectionIndex(0);
	197	sm.setAnchorSelectionIndex(0);
	198	}
	199	fileList.clearSelection();
	200	sm = fileList.getSelectionModel();
	201	if (sm instanceof DefaultListSelectionModel) {
	202	((DefaultListSelectionModel)sm).moveLeadSelectionIndex(0);
	203	sm.setAnchorSelectionIndex(0);
	204	}
	205	File currentDirectory = getFileChooser().getCurrentDirectory();
	206	if(currentDirectory != null) {
	207	try {
	208	setDirectoryName(ShellFolder.getNormalizedFile((File)e.getNewValue()).getPath());
	209	} catch (IOException ioe) {
	210	setDirectoryName(((File)e.getNewValue()).getAbsolutePath());
	211	}
	212	if ((getFileChooser().getFileSelectionMode() == JFileChooser.DIRECTORIES_ONLY) && !getFileChooser().isMultiSelectionEnabled()) {
	213	setFileName(getDirectoryName());
	214	}
	215	}
	216	} else if(prop.equals(JFileChooser.FILE_SELECTION_MODE_CHANGED_PROPERTY)) {
	217	if (fileNameLabel != null) {
	218	populateFileNameLabel();
	219	}
	220	directoryList.clearSelection();
	221	} else if (prop.equals(JFileChooser.MULTI_SELECTION_ENABLED_CHANGED_PROPERTY)) {
	222	if(getFileChooser().isMultiSelectionEnabled()) {
	223	fileList.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
	224	} else {
	225	fileList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
	226	fileList.clearSelection();
	227	getFileChooser().setSelectedFiles(null);
	228	}
	229	} else if (prop.equals(JFileChooser.ACCESSORY_CHANGED_PROPERTY)) {
	230	if(getAccessoryPanel() != null) {
	231	if(e.getOldValue() != null) {
	232	getAccessoryPanel().remove((JComponent) e.getOldValue());
	233	}
	234	JComponent accessory = (JComponent) e.getNewValue();
	235	if(accessory != null) {
	236	getAccessoryPanel().add(accessory, BorderLayout.CENTER);
	237	getAccessoryPanel().setPreferredSize(PREF_ACC_SIZE);
	238	getAccessoryPanel().setMaximumSize(MAX_SIZE);
	239	} else {
	240	getAccessoryPanel().setPreferredSize(ZERO_ACC_SIZE);
	241	getAccessoryPanel().setMaximumSize(ZERO_ACC_SIZE);
	242	}
	243	}
	244	} else if (prop.equals(JFileChooser.APPROVE_BUTTON_TEXT_CHANGED_PROPERTY) \|\|
	245	prop.equals(JFileChooser.APPROVE_BUTTON_TOOL_TIP_TEXT_CHANGED_PROPERTY) \|\|
	246	prop.equals(JFileChooser.DIALOG_TYPE_CHANGED_PROPERTY)) {
	247	approveButton.setText(getApproveButtonText(getFileChooser()));
	248	approveButton.setToolTipText(getApproveButtonToolTipText(getFileChooser()));
	249	} else if (prop.equals(JFileChooser.CONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY)) {
	250	doControlButtonsChanged(e);
	251	} else if (prop.equals("componentOrientation")) {
	252	ComponentOrientation o = (ComponentOrientation)e.getNewValue();
	253	JFileChooser cc = (JFileChooser)e.getSource();
	254	if (o != (ComponentOrientation)e.getOldValue()) {
	255	cc.applyComponentOrientation(o);
	256	}
	257	}
	258	}
	259	};
	260	}
	261
	262	//
	263	// ComponentUI Interface Implementation methods
	264	//
	265	public static ComponentUI createUI(JComponent c) {
	266	return new MotifFileChooserUI((JFileChooser)c);
	267	}
	268
	269	public void installUI(JComponent c) {
	270	super.installUI(c);
	271	}
	272
	273	public void uninstallUI(JComponent c) {
	274	c.removePropertyChangeListener(filterComboBoxModel);
	275	approveButton.removeActionListener(getApproveSelectionAction());
	276	filenameTextField.removeActionListener(getApproveSelectionAction());
	277	super.uninstallUI(c);
	278	}
	279
	280	public void installComponents(JFileChooser fc) {
	281	fc.setLayout(new BorderLayout(10, 10));
	282	fc.setAlignmentX(JComponent.CENTER_ALIGNMENT);
	283
	284	JPanel interior = new JPanel() {
	285	public Insets getInsets() {
	286	return insets;
	287	}
	288	};
	289	interior.setInheritsPopupMenu(true);
	290	align(interior);
	291	interior.setLayout(new BoxLayout(interior, BoxLayout.PAGE_AXIS));
	292
	293	fc.add(interior, BorderLayout.CENTER);
	294
	295	// PENDING(jeff) - I18N
	296	JLabel l = new JLabel(pathLabelText);
	297	l.setDisplayedMnemonic(pathLabelMnemonic);
	298	align(l);
	299	interior.add(l);
	300
	301	File currentDirectory = fc.getCurrentDirectory();
	302	String curDirName = null;
	303	if(currentDirectory != null) {
	304	curDirName = currentDirectory.getPath();
	305	}
	306	pathField = new JTextField(curDirName) {
	307	public Dimension getMaximumSize() {
	308	Dimension d = super.getMaximumSize();
	309	d.height = getPreferredSize().height;
	310	return d;
	311	}
	312	};
	313	pathField.setInheritsPopupMenu(true);
	314	l.setLabelFor(pathField);
	315	align(pathField);
	316
	317	// Change to folder on return
	318	pathField.addActionListener(getUpdateAction());
	319	interior.add(pathField);
	320
	321	interior.add(Box.createRigidArea(vstrut10));
	322
	323
	324	// CENTER: left, right accessory
	325	JPanel centerPanel = new JPanel();
	326	centerPanel.setLayout(new BoxLayout(centerPanel, BoxLayout.LINE_AXIS));
	327	align(centerPanel);
	328
	329	// left panel - Filter & folderList
	330	JPanel leftPanel = new JPanel();
	331	leftPanel.setLayout(new BoxLayout(leftPanel, BoxLayout.PAGE_AXIS));
	332	align(leftPanel);
	333
	334	// add the filter PENDING(jeff) - I18N
	335	l = new JLabel(filterLabelText);
	336	l.setDisplayedMnemonic(filterLabelMnemonic);
	337	align(l);
	338	leftPanel.add(l);
	339
	340	filterComboBox = new JComboBox() {
	341	public Dimension getMaximumSize() {
	342	Dimension d = super.getMaximumSize();
	343	d.height = getPreferredSize().height;
	344	return d;
	345	}
	346	};
	347	filterComboBox.setInheritsPopupMenu(true);
	348	l.setLabelFor(filterComboBox);
	349	filterComboBoxModel = createFilterComboBoxModel();
	350	filterComboBox.setModel(filterComboBoxModel);
	351	filterComboBox.setRenderer(createFilterComboBoxRenderer());
	352	fc.addPropertyChangeListener(filterComboBoxModel);
	353	align(filterComboBox);
	354	leftPanel.add(filterComboBox);
	355
	356	// leftPanel.add(Box.createRigidArea(vstrut10));
	357
	358	// Add the Folder List PENDING(jeff) - I18N
	359	l = new JLabel(foldersLabelText);
	360	l.setDisplayedMnemonic(foldersLabelMnemonic);
	361	align(l);
	362	leftPanel.add(l);
	363	JScrollPane sp = createDirectoryList();
	364	sp.getVerticalScrollBar().setFocusable(false);
	365	sp.getHorizontalScrollBar().setFocusable(false);
	366	sp.setInheritsPopupMenu(true);
	367	l.setLabelFor(sp.getViewport().getView());
	368	leftPanel.add(sp);
	369	leftPanel.setInheritsPopupMenu(true);
	370
	371
	372	// create files list
	373	JPanel rightPanel = new JPanel();
	374	align(rightPanel);
	375	rightPanel.setLayout(new BoxLayout(rightPanel, BoxLayout.PAGE_AXIS));
	376	rightPanel.setInheritsPopupMenu(true);
	377
	378	l = new JLabel(filesLabelText);
	379	l.setDisplayedMnemonic(filesLabelMnemonic);
	380	align(l);
	381	rightPanel.add(l);
	382	sp = createFilesList();
	383	l.setLabelFor(sp.getViewport().getView());
	384	rightPanel.add(sp);
	385	sp.setInheritsPopupMenu(true);
	386
	387	centerPanel.add(leftPanel);
	388	centerPanel.add(Box.createRigidArea(hstrut10));
	389	centerPanel.add(rightPanel);
	390	centerPanel.setInheritsPopupMenu(true);
	391
	392	JComponent accessoryPanel = getAccessoryPanel();
	393	JComponent accessory = fc.getAccessory();
	394	if(accessoryPanel != null) {
	395	if(accessory == null) {
	396	accessoryPanel.setPreferredSize(ZERO_ACC_SIZE);
	397	accessoryPanel.setMaximumSize(ZERO_ACC_SIZE);
	398	} else {
	399	getAccessoryPanel().add(accessory, BorderLayout.CENTER);
	400	accessoryPanel.setPreferredSize(PREF_ACC_SIZE);
	401	accessoryPanel.setMaximumSize(MAX_SIZE);
	402	}
	403	align(accessoryPanel);
	404	centerPanel.add(accessoryPanel);
	405	accessoryPanel.setInheritsPopupMenu(true);
	406	}
	407	interior.add(centerPanel);
	408	interior.add(Box.createRigidArea(vstrut10));
	409
	410	// add the filename field PENDING(jeff) - I18N
	411	fileNameLabel = new JLabel();
	412	populateFileNameLabel();
	413	align(fileNameLabel);
	414	interior.add(fileNameLabel);
	415
	416	filenameTextField = new JTextField() {
	417	public Dimension getMaximumSize() {
	418	Dimension d = super.getMaximumSize();
	419	d.height = getPreferredSize().height;
	420	return d;
	421	}
	422	};
	423	filenameTextField.setInheritsPopupMenu(true);
	424	fileNameLabel.setLabelFor(filenameTextField);
	425	filenameTextField.addActionListener(getApproveSelectionAction());
	426	align(filenameTextField);
	427	filenameTextField.setAlignmentX(JComponent.LEFT_ALIGNMENT);
	428	interior.add(filenameTextField);
	429
	430	bottomPanel = getBottomPanel();
	431	bottomPanel.add(new JSeparator(), BorderLayout.NORTH);
	432
	433	// Add buttons
	434	JPanel buttonPanel = new JPanel();
	435	align(buttonPanel);
	436	buttonPanel.setLayout(new BoxLayout(buttonPanel, BoxLayout.LINE_AXIS));
	437	buttonPanel.add(Box.createGlue());
	438
	439	approveButton = new JButton(getApproveButtonText(fc)) {
	440	public Dimension getMaximumSize() {
	441	return new Dimension(MAX_SIZE.width, this.getPreferredSize().height);
	442	}
	443	};
	444	approveButton.setMnemonic(getApproveButtonMnemonic(fc));
	445	approveButton.setToolTipText(getApproveButtonToolTipText(fc));
	446	approveButton.setInheritsPopupMenu(true);
	447	align(approveButton);
	448	approveButton.setMargin(buttonMargin);
	449	approveButton.addActionListener(getApproveSelectionAction());
	450	buttonPanel.add(approveButton);
	451	buttonPanel.add(Box.createGlue());
	452
	453	JButton updateButton = new JButton(updateButtonText) {
	454	public Dimension getMaximumSize() {
	455	return new Dimension(MAX_SIZE.width, this.getPreferredSize().height);
	456	}
	457	};
	458	updateButton.setMnemonic(updateButtonMnemonic);
	459	updateButton.setToolTipText(updateButtonToolTipText);
	460	updateButton.setInheritsPopupMenu(true);
	461	align(updateButton);
	462	updateButton.setMargin(buttonMargin);
	463	updateButton.addActionListener(getUpdateAction());
	464	buttonPanel.add(updateButton);
	465	buttonPanel.add(Box.createGlue());
	466
	467	JButton cancelButton = new JButton(cancelButtonText) {
	468	public Dimension getMaximumSize() {
	469	return new Dimension(MAX_SIZE.width, this.getPreferredSize().height);
	470	}
	471	};
	472	cancelButton.setMnemonic(cancelButtonMnemonic);
	473	cancelButton.setToolTipText(cancelButtonToolTipText);
	474	cancelButton.setInheritsPopupMenu(true);
	475	align(cancelButton);
	476	cancelButton.setMargin(buttonMargin);
	477	cancelButton.addActionListener(getCancelSelectionAction());
	478	buttonPanel.add(cancelButton);
	479	buttonPanel.add(Box.createGlue());
	480
	481	JButton helpButton = new JButton(helpButtonText) {
	482	public Dimension getMaximumSize() {
	483	return new Dimension(MAX_SIZE.width, this.getPreferredSize().height);
	484	}
	485	};
	486	helpButton.setMnemonic(helpButtonMnemonic);
	487	helpButton.setToolTipText(helpButtonToolTipText);
	488	align(helpButton);
	489	helpButton.setMargin(buttonMargin);
	490	helpButton.setEnabled(false);
	491	helpButton.setInheritsPopupMenu(true);
	492	buttonPanel.add(helpButton);
	493	buttonPanel.add(Box.createGlue());
	494	buttonPanel.setInheritsPopupMenu(true);
	495
	496	bottomPanel.add(buttonPanel, BorderLayout.SOUTH);
	497	bottomPanel.setInheritsPopupMenu(true);
	498	if (fc.getControlButtonsAreShown()) {
	499	fc.add(bottomPanel, BorderLayout.SOUTH);
	500	}
	501	}
	502
	503	protected JPanel getBottomPanel() {
	504	if (bottomPanel == null) {
	505	bottomPanel = new JPanel(new BorderLayout(0, 4));
	506	}
	507	return bottomPanel;
	508	}
	509
	510	private void doControlButtonsChanged(PropertyChangeEvent e) {
	511	if (getFileChooser().getControlButtonsAreShown()) {
	512	getFileChooser().add(bottomPanel,BorderLayout.SOUTH);
	513	} else {
	514	getFileChooser().remove(getBottomPanel());
	515	}
	516	}
	517
	518	public void uninstallComponents(JFileChooser fc) {
	519	fc.removeAll();
	520	bottomPanel = null;
	521	if (filterComboBoxModel != null) {
	522	fc.removePropertyChangeListener(filterComboBoxModel);
	523	}
	524	}
	525
	526	protected void installStrings(JFileChooser fc) {
	527	super.installStrings(fc);
	528
	529	Locale l = fc.getLocale();
	530
	531	enterFolderNameLabelText = UIManager.getString("FileChooser.enterFolderNameLabelText",l);
	532	enterFolderNameLabelMnemonic = UIManager.getInt("FileChooser.enterFolderNameLabelMnemonic");
	533	enterFileNameLabelText = UIManager.getString("FileChooser.enterFileNameLabelText",l);
	534	enterFileNameLabelMnemonic = UIManager.getInt("FileChooser.enterFileNameLabelMnemonic");
	535
	536	filesLabelText = UIManager.getString("FileChooser.filesLabelText",l);
	537	filesLabelMnemonic = UIManager.getInt("FileChooser.filesLabelMnemonic");
	538
	539	foldersLabelText = UIManager.getString("FileChooser.foldersLabelText",l);
	540	foldersLabelMnemonic = UIManager.getInt("FileChooser.foldersLabelMnemonic");
	541
	542	pathLabelText = UIManager.getString("FileChooser.pathLabelText",l);
	543	pathLabelMnemonic = UIManager.getInt("FileChooser.pathLabelMnemonic");
	544
	545	filterLabelText = UIManager.getString("FileChooser.filterLabelText",l);
	546	filterLabelMnemonic = UIManager.getInt("FileChooser.filterLabelMnemonic");
	547	}
	548
	549	protected void installIcons(JFileChooser fc) {
	550	// Since motif doesn't have button icons, leave this empty
	551	// which overrides the supertype icon loading
	552	}
	553
	554	protected void uninstallIcons(JFileChooser fc) {
	555	// Since motif doesn't have button icons, leave this empty
	556	// which overrides the supertype icon loading
	557	}
	558
	559	protected JScrollPane createFilesList() {
	560	fileList = new JList();
	561
	562	if(getFileChooser().isMultiSelectionEnabled()) {
	563	fileList.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
	564	} else {
	565	fileList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
	566	}
	567
	568	fileList.setModel(new MotifFileListModel());
	569	fileList.getSelectionModel().removeSelectionInterval(0, 0);
	570	fileList.setCellRenderer(new FileCellRenderer());
	571	fileList.addListSelectionListener(createListSelectionListener(getFileChooser()));
	572	fileList.addMouseListener(createDoubleClickListener(getFileChooser(), fileList));
	573	fileList.addMouseListener(new MouseAdapter() {
	574	public void mouseClicked(MouseEvent e) {
	575	JFileChooser chooser = getFileChooser();
	576	if (SwingUtilities.isLeftMouseButton(e) && !chooser.isMultiSelectionEnabled()) {
	577	int index = SwingUtilities2.loc2IndexFileList(fileList, e.getPoint());
	578	if (index >= 0) {
	579	File file = (File) fileList.getModel().getElementAt(index);
	580	setFileName(chooser.getName(file));
	581	}
	582	}
	583	}
	584	});
	585	align(fileList);
	586	JScrollPane scrollpane = new JScrollPane(fileList);
	587	scrollpane.setPreferredSize(prefListSize);
	588	scrollpane.setMaximumSize(MAX_SIZE);
	589	align(scrollpane);
	590	fileList.setInheritsPopupMenu(true);
	591	scrollpane.setInheritsPopupMenu(true);
	592	return scrollpane;
	593	}
	594
	595	protected JScrollPane createDirectoryList() {
	596	directoryList = new JList();
	597	align(directoryList);
	598
	599	directoryList.setCellRenderer(new DirectoryCellRenderer());
	600	directoryList.setModel(new MotifDirectoryListModel());
	601	directoryList.getSelectionModel().removeSelectionInterval(0, 0);
	602	directoryList.addMouseListener(createDoubleClickListener(getFileChooser(), directoryList));
	603	directoryList.addListSelectionListener(createListSelectionListener(getFileChooser()));
	604	directoryList.setInheritsPopupMenu(true);
	605
	606	JScrollPane scrollpane = new JScrollPane(directoryList);
	607	scrollpane.setMaximumSize(MAX_SIZE);
	608	scrollpane.setPreferredSize(prefListSize);
	609	scrollpane.setInheritsPopupMenu(true);
	610	align(scrollpane);
	611	return scrollpane;
	612	}
	613
	614	public Dimension getPreferredSize(JComponent c) {
	615	Dimension prefSize =
	616	(getFileChooser().getAccessory() != null) ? WITH_ACCELERATOR_PREF_SIZE : PREF_SIZE;
	617	Dimension d = c.getLayout().preferredLayoutSize(c);
	618	if (d != null) {
	619	return new Dimension(d.width < prefSize.width ? prefSize.width : d.width,
	620	d.height < prefSize.height ? prefSize.height : d.height);
	621	} else {
	622	return prefSize;
	623	}
	624	}
	625
	626	public Dimension getMinimumSize(JComponent x) {
	627	return MIN_SIZE;
	628	}
	629
	630	public Dimension getMaximumSize(JComponent x) {
	631	return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
	632	}
	633
	634	protected void align(JComponent c) {
	635	c.setAlignmentX(JComponent.LEFT_ALIGNMENT);
	636	c.setAlignmentY(JComponent.TOP_ALIGNMENT);
	637	}
	638
	639	protected class FileCellRenderer extends DefaultListCellRenderer {
	640	public Component getListCellRendererComponent(JList list, Object value, int index,
	641	boolean isSelected, boolean cellHasFocus) {
	642
	643	super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
	644	setText(getFileChooser().getName((File) value));
	645	setInheritsPopupMenu(true);
	646	return this;
	647	}
	648	}
	649
	650	protected class DirectoryCellRenderer extends DefaultListCellRenderer {
	651	public Component getListCellRendererComponent(JList list, Object value, int index,
	652	boolean isSelected, boolean cellHasFocus) {
	653
	654	super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
	655	setText(getFileChooser().getName((File) value));
	656	setInheritsPopupMenu(true);
	657	return this;
	658	}
	659	}
	660
	661	protected class MotifDirectoryListModel extends AbstractListModel implements ListDataListener {
	662	public MotifDirectoryListModel() {
	663	getModel().addListDataListener(this);
	664	}
	665
	666	public int getSize() {
	667	return getModel().getDirectories().size();
	668	}
	669
	670	public Object getElementAt(int index) {
	671	return getModel().getDirectories().elementAt(index);
	672	}
	673
	674	public void intervalAdded(ListDataEvent e) {
	675	fireIntervalAdded(this, e.getIndex0(), e.getIndex1());
	676	}
	677
	678	public void intervalRemoved(ListDataEvent e) {
	679	fireIntervalRemoved(this, e.getIndex0(), e.getIndex1());
	680	}
	681
	682	// PENDING(jeff) - this is inefficient - should sent out
	683	// incremental adjustment values instead of saying that the
	684	// whole list has changed.
	685	public void fireContentsChanged() {
	686	fireContentsChanged(this, 0, getModel().getDirectories().size()-1);
	687	}
	688
	689	// PENDING(jeff) - fire the correct interval changed - currently sending
	690	// out that everything has changed
	691	public void contentsChanged(ListDataEvent e) {
	692	fireContentsChanged();
	693	}
	694
	695	}
	696
	697	protected class MotifFileListModel extends AbstractListModel implements ListDataListener {
	698	public MotifFileListModel() {
	699	getModel().addListDataListener(this);
	700	}
	701
	702	public int getSize() {
	703	return getModel().getFiles().size();
	704	}
	705
	706	public boolean contains(Object o) {
	707	return getModel().getFiles().contains(o);
	708	}
	709
	710	public int indexOf(Object o) {
	711	return getModel().getFiles().indexOf(o);
	712	}
	713
	714	public Object getElementAt(int index) {
	715	return getModel().getFiles().elementAt(index);
	716	}
	717
	718	public void intervalAdded(ListDataEvent e) {
	719	fireIntervalAdded(this, e.getIndex0(), e.getIndex1());
	720	}
	721
	722	public void intervalRemoved(ListDataEvent e) {
	723	fireIntervalRemoved(this, e.getIndex0(), e.getIndex1());
	724	}
	725
	726	// PENDING(jeff) - this is inefficient - should sent out
	727	// incremental adjustment values instead of saying that the
	728	// whole list has changed.
	729	public void fireContentsChanged() {
	730	fireContentsChanged(this, 0, getModel().getFiles().size()-1);
	731	}
	732
	733	// PENDING(jeff) - fire the interval changed
	734	public void contentsChanged(ListDataEvent e) {
	735	fireContentsChanged();
	736	}
	737
	738	}
	739
	740	//
	741	// DataModel for Types Comboxbox
	742	//
	743	protected FilterComboBoxModel createFilterComboBoxModel() {
	744	return new FilterComboBoxModel();
	745	}
	746
	747	//
	748	// Renderer for Types ComboBox
	749	//
	750	protected FilterComboBoxRenderer createFilterComboBoxRenderer() {
	751	return new FilterComboBoxRenderer();
	752	}
	753
	754
	755	/**
	756	* Render different type sizes and styles.
	757	*/
	758	public class FilterComboBoxRenderer extends DefaultListCellRenderer {
	759	public Component getListCellRendererComponent(JList list,
	760	Object value, int index, boolean isSelected,
	761	boolean cellHasFocus) {
	762
	763	super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
	764
	765	if (value != null && value instanceof FileFilter) {
	766	setText(((FileFilter)value).getDescription());
	767	}
	768
	769	return this;
	770	}
	771	}
	772
	773	/**
	774	* Data model for a type-face selection combo-box.
	775	*/
	776	protected class FilterComboBoxModel extends AbstractListModel implements ComboBoxModel, PropertyChangeListener {
	777	protected FileFilter[] filters;
	778	protected FilterComboBoxModel() {
	779	super();
	780	filters = getFileChooser().getChoosableFileFilters();
	781	}
	782
	783	public void propertyChange(PropertyChangeEvent e) {
	784	String prop = e.getPropertyName();
	785	if(prop.equals(JFileChooser.CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY)) {
	786	filters = (FileFilter[]) e.getNewValue();
	787	fireContentsChanged(this, -1, -1);
	788	} else if (prop.equals(JFileChooser.FILE_FILTER_CHANGED_PROPERTY)) {
	789	fireContentsChanged(this, -1, -1);
	790	}
	791	}
	792
	793	public void setSelectedItem(Object filter) {
	794	if(filter != null) {
	795	getFileChooser().setFileFilter((FileFilter) filter);
	796	fireContentsChanged(this, -1, -1);
	797	}
	798	}
	799
	800	public Object getSelectedItem() {
	801	// Ensure that the current filter is in the list.
	802	// NOTE: we shouldnt' have to do this, since JFileChooser adds
	803	// the filter to the choosable filters list when the filter
	804	// is set. Lets be paranoid just in case someone overrides
	805	// setFileFilter in JFileChooser.
	806	FileFilter currentFilter = getFileChooser().getFileFilter();
	807	boolean found = false;
	808	if(currentFilter != null) {
	809	for (FileFilter filter : filters) {
	810	if (filter == currentFilter) {
	811	found = true;
	812	}
	813	}
	814	if (!found) {
	815	getFileChooser().addChoosableFileFilter(currentFilter);
	816	}
	817	}
	818	return getFileChooser().getFileFilter();
	819	}
	820
	821	public int getSize() {
	822	if(filters != null) {
	823	return filters.length;
	824	} else {
	825	return 0;
	826	}
	827	}
	828
	829	public Object getElementAt(int index) {
	830	if(index > getSize() - 1) {
	831	// This shouldn't happen. Try to recover gracefully.
	832	return getFileChooser().getFileFilter();
	833	}
	834	if(filters != null) {
	835	return filters[index];
	836	} else {
	837	return null;
	838	}
	839	}
	840	}
	841
	842	protected JButton getApproveButton(JFileChooser fc) {
	843	return approveButton;
	844	}
	845
	846	}

java/pkg/com/sun/java/swing/plaf/motif/MotifGraphicsUtils.java+476−0

@@ -0,0 +1,476 @@
	1	/*
	2	* Copyright (c) 1997, 2008, 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	package com.sun.java.swing.plaf.motif;
	26
	27	import sun.swing.SwingUtilities2;
	28
	29	import javax.swing.*;
	30	import java.awt.Color;
	31	import java.awt.Dimension;
	32	import java.awt.Graphics;
	33	import java.awt.Font;
	34	import java.awt.FontMetrics;
	35	import java.awt.Rectangle;
	36	import java.awt.Component;
	37	import java.awt.Insets;
	38	import java.awt.event.KeyEvent;
	39	import java.awt.Container;
	40
	41	import javax.swing.plaf.basic.*;
	42	import javax.swing.text.View;
	43
	44	/*
	45	* @author Jeff Dinkins
	46	* @author Dave Kloba
	47	*/
	48
	49	public class MotifGraphicsUtils implements SwingConstants
	50	{
	51	/* Client Property keys for text and accelerator text widths */
	52	private static final String MAX_ACC_WIDTH = "maxAccWidth";
	53
	54	/**
	55	* Draws the point (<b>x</b>, <b>y</b>) in the current color.
	56	*/
	57	static void drawPoint(Graphics g, int x, int y) {
	58	g.drawLine(x, y, x, y);
	59	}
	60
	61	/*
	62	* Convenience method for drawing a grooved line
	63	*
	64	*/
	65	public static void drawGroove(Graphics g, int x, int y, int w, int h,
	66	Color shadow, Color highlight)
	67	{
	68	Color oldColor = g.getColor(); // Make no net change to g
	69	g.translate(x, y);
	70
	71	g.setColor(shadow);
	72	g.drawRect(0, 0, w-2, h-2);
	73
	74	g.setColor(highlight);
	75	g.drawLine(1, h-3, 1, 1);
	76	g.drawLine(1, 1, w-3, 1);
	77
	78	g.drawLine(0, h-1, w-1, h-1);
	79	g.drawLine(w-1, h-1, w-1, 0);
	80
	81	g.translate(-x, -y);
	82	g.setColor(oldColor);
	83	}
	84
	85	/** Draws <b>aString</b> in the rectangle defined by
	86	* (<b>x</b>, <b>y</b>, <b>width</b>, <b>height</b>).
	87	* <b>justification</b> specifies the text's justification, one of
	88	* LEFT, CENTER, or RIGHT.
	89	* <b>drawStringInRect()</b> does not clip to the rectangle, but instead
	90	* uses this rectangle and the desired justification to compute the point
	91	* at which to begin drawing the text.
	92	* @see #drawString
	93	*/
	94	public static void drawStringInRect(Graphics g, String aString, int x, int y,
	95	int width, int height, int justification) {
	96	drawStringInRect(null, g, aString, x, y, width, height, justification);
	97	}
	98
	99	static void drawStringInRect(JComponent c, Graphics g, String aString,
	100	int x, int y, int width, int height,
	101	int justification) {
	102	FontMetrics fontMetrics;
	103	int drawWidth, startX, startY, delta;
	104
	105	if (g.getFont() == null) {
	106	// throw new InconsistencyException("No font set");
	107	return;
	108	}
	109	fontMetrics = SwingUtilities2.getFontMetrics(c, g);
	110	if (fontMetrics == null) {
	111	// throw new InconsistencyException("No metrics for Font " + font());
	112	return;
	113	}
	114
	115	if (justification == CENTER) {
	116	drawWidth = SwingUtilities2.stringWidth(c, fontMetrics, aString);
	117	if (drawWidth > width) {
	118	drawWidth = width;
	119	}
	120	startX = x + (width - drawWidth) / 2;
	121	} else if (justification == RIGHT) {
	122	drawWidth = SwingUtilities2.stringWidth(c, fontMetrics, aString);
	123	if (drawWidth > width) {
	124	drawWidth = width;
	125	}
	126	startX = x + width - drawWidth;
	127	} else {
	128	startX = x;
	129	}
	130
	131	delta = (height - fontMetrics.getAscent() - fontMetrics.getDescent()) / 2;
	132	if (delta < 0) {
	133	delta = 0;
	134	}
	135
	136	startY = y + height - delta - fontMetrics.getDescent();
	137
	138	SwingUtilities2.drawString(c, g, aString, startX, startY);
	139	}
	140
	141	/**
	142	* This method is not being used to paint menu item since
	143	* 6.0 This code left for compatibility only. Do not use or
	144	* override it, this will not cause any visible effect.
	145	*/
	146	public static void paintMenuItem(Graphics g, JComponent c,
	147	Icon checkIcon, Icon arrowIcon,
	148	Color background, Color foreground,
	149	int defaultTextIconGap)
	150	{
	151
	152	JMenuItem b = (JMenuItem) c;
	153	ButtonModel model = b.getModel();
	154
	155	Dimension size = b.getSize();
	156	Insets i = c.getInsets();
	157
	158	Rectangle viewRect = new Rectangle(size);
	159
	160	viewRect.x += i.left;
	161	viewRect.y += i.top;
	162	viewRect.width -= (i.right + viewRect.x);
	163	viewRect.height -= (i.bottom + viewRect.y);
	164
	165	Rectangle iconRect = new Rectangle();
	166	Rectangle textRect = new Rectangle();
	167	Rectangle acceleratorRect = new Rectangle();
	168	Rectangle checkRect = new Rectangle();
	169	Rectangle arrowRect = new Rectangle();
	170
	171	Font holdf = g.getFont();
	172	Font f = c.getFont();
	173	g.setFont(f);
	174	FontMetrics fm = SwingUtilities2.getFontMetrics(c, g, f);
	175	FontMetrics fmAccel = SwingUtilities2.getFontMetrics(
	176	c, g, UIManager.getFont("MenuItem.acceleratorFont"));
	177
	178	if (c.isOpaque()) {
	179	if (model.isArmed()\|\| (c instanceof JMenu && model.isSelected())) {
	180	g.setColor(background);
	181	} else {
	182	g.setColor(c.getBackground());
	183	}
	184	g.fillRect(0,0, size.width, size.height);
	185	}
	186
	187	// get Accelerator text
	188	KeyStroke accelerator = b.getAccelerator();
	189	String acceleratorText = "";
	190	if (accelerator != null) {
	191	int modifiers = accelerator.getModifiers();
	192	if (modifiers > 0) {
	193	acceleratorText = KeyEvent.getKeyModifiersText(modifiers);
	194	acceleratorText += "+";
	195	}
	196	acceleratorText += KeyEvent.getKeyText(accelerator.getKeyCode());
	197	}
	198
	199	// layout the text and icon
	200	String text = layoutMenuItem(c, fm, b.getText(), fmAccel,
	201	acceleratorText, b.getIcon(),
	202	checkIcon, arrowIcon,
	203	b.getVerticalAlignment(),
	204	b.getHorizontalAlignment(),
	205	b.getVerticalTextPosition(),
	206	b.getHorizontalTextPosition(),
	207	viewRect, iconRect,
	208	textRect, acceleratorRect,
	209	checkRect, arrowRect,
	210	b.getText() == null
	211	? 0 : defaultTextIconGap,
	212	defaultTextIconGap
	213	);
	214
	215	// Paint the Check
	216	Color holdc = g.getColor();
	217	if (checkIcon != null) {
	218	if(model.isArmed() \|\| (c instanceof JMenu && model.isSelected()))
	219	g.setColor(foreground);
	220	checkIcon.paintIcon(c, g, checkRect.x, checkRect.y);
	221	g.setColor(holdc);
	222	}
	223
	224	// Paint the Icon
	225	if(b.getIcon() != null) {
	226	Icon icon;
	227	if(!model.isEnabled()) {
	228	icon = b.getDisabledIcon();
	229	} else if(model.isPressed() && model.isArmed()) {
	230	icon = b.getPressedIcon();
	231	if(icon == null) {
	232	// Use default icon
	233	icon = b.getIcon();
	234	}
	235	} else {
	236	icon = b.getIcon();
	237	}
	238
	239	if (icon!=null) {
	240	icon.paintIcon(c, g, iconRect.x, iconRect.y);
	241	}
	242	}
	243
	244	// Draw the Text
	245	if(text != null && !text.equals("")) {
	246	// Once BasicHTML becomes public, use BasicHTML.propertyKey
	247	// instead of the hardcoded string below!
	248	View v = (View) c.getClientProperty("html");
	249	if (v != null) {
	250	v.paint(g, textRect);
	251	} else {
	252	int mnemIndex = b.getDisplayedMnemonicIndex();
	253
	254	if(!model.isEnabled()) {
	255	// *** paint the text disabled
	256	g.setColor(b.getBackground().brighter());
	257	SwingUtilities2.drawStringUnderlineCharAt(b, g,text,
	258	mnemIndex,
	259	textRect.x, textRect.y + fmAccel.getAscent());
	260	g.setColor(b.getBackground().darker());
	261	SwingUtilities2.drawStringUnderlineCharAt(b, g,text,
	262	mnemIndex,
	263	textRect.x - 1, textRect.y + fmAccel.getAscent() - 1);
	264
	265	} else {
	266	// *** paint the text normally
	267	if (model.isArmed()\|\| (c instanceof JMenu && model.isSelected())) {
	268	g.setColor(foreground);
	269	} else {
	270	g.setColor(b.getForeground());
	271	}
	272	SwingUtilities2.drawStringUnderlineCharAt(b, g,text,
	273	mnemIndex,
	274	textRect.x,
	275	textRect.y + fm.getAscent());
	276	}
	277	}
	278	}
	279
	280	// Draw the Accelerator Text
	281	if(acceleratorText != null && !acceleratorText.equals("")) {
	282
	283	//Get the maxAccWidth from the parent to calculate the offset.
	284	int accOffset = 0;
	285	Container parent = b.getParent();
	286	if (parent != null && parent instanceof JComponent) {
	287	JComponent p = (JComponent) parent;
	288	Integer maxValueInt = (Integer) p.getClientProperty(MotifGraphicsUtils.MAX_ACC_WIDTH);
	289	int maxValue = maxValueInt != null ?
	290	maxValueInt.intValue() : acceleratorRect.width;
	291
	292	//Calculate the offset, with which the accelerator texts will be drawn with.
	293	accOffset = maxValue - acceleratorRect.width;
	294	}
	295
	296	g.setFont( UIManager.getFont("MenuItem.acceleratorFont") );
	297	if(!model.isEnabled()) {
	298	// *** paint the acceleratorText disabled
	299	g.setColor(b.getBackground().brighter());
	300	SwingUtilities2.drawString(c, g,acceleratorText,
	301	acceleratorRect.x - accOffset, acceleratorRect.y + fm.getAscent());
	302	g.setColor(b.getBackground().darker());
	303	SwingUtilities2.drawString(c, g,acceleratorText,
	304	acceleratorRect.x - accOffset - 1, acceleratorRect.y + fm.getAscent() - 1);
	305	} else {
	306	// *** paint the acceleratorText normally
	307	if (model.isArmed()\|\| (c instanceof JMenu && model.isSelected()))
	308	{
	309	g.setColor(foreground);
	310	} else {
	311	g.setColor(b.getForeground());
	312	}
	313	SwingUtilities2.drawString(c, g,acceleratorText,
	314	acceleratorRect.x - accOffset,
	315	acceleratorRect.y + fmAccel.getAscent());
	316	}
	317	}
	318
	319	// Paint the Arrow
	320	if (arrowIcon != null) {
	321	if(model.isArmed() \|\| (c instanceof JMenu && model.isSelected()))
	322	g.setColor(foreground);
	323	if( !(b.getParent() instanceof JMenuBar) )
	324	arrowIcon.paintIcon(c, g, arrowRect.x, arrowRect.y);
	325	}
	326
	327	g.setColor(holdc);
	328	g.setFont(holdf);
	329	}
	330
	331
	332	/**
	333	* Compute and return the location of the icons origin, the
	334	* location of origin of the text baseline, and a possibly clipped
	335	* version of the compound labels string. Locations are computed
	336	* relative to the viewR rectangle.
	337	*/
	338
	339	private static String layoutMenuItem(
	340	JComponent c,
	341	FontMetrics fm,
	342	String text,
	343	FontMetrics fmAccel,
	344	String acceleratorText,
	345	Icon icon,
	346	Icon checkIcon,
	347	Icon arrowIcon,
	348	int verticalAlignment,
	349	int horizontalAlignment,
	350	int verticalTextPosition,
	351	int horizontalTextPosition,
	352	Rectangle viewR,
	353	Rectangle iconR,
	354	Rectangle textR,
	355	Rectangle acceleratorR,
	356	Rectangle checkIconR,
	357	Rectangle arrowIconR,
	358	int textIconGap,
	359	int menuItemGap
	360	)
	361	{
	362
	363	SwingUtilities.layoutCompoundLabel(c,
	364	fm,
	365	text,
	366	icon,
	367	verticalAlignment,
	368	horizontalAlignment,
	369	verticalTextPosition,
	370	horizontalTextPosition,
	371	viewR,
	372	iconR,
	373	textR,
	374	textIconGap);
	375
	376	/* Initialize the acceelratorText bounds rectangle textR. If a null
	377	* or and empty String was specified we substitute "" here
	378	* and use 0,0,0,0 for acceleratorTextR.
	379	*/
	380	if( (acceleratorText == null) \|\| acceleratorText.equals("") ) {
	381	acceleratorR.width = acceleratorR.height = 0;
	382	acceleratorText = "";
	383	}
	384	else {
	385	acceleratorR.width
	386	= SwingUtilities2.stringWidth(c, fmAccel, acceleratorText);
	387	acceleratorR.height = fmAccel.getHeight();
	388	}
	389
	390	/* Initialize the checkIcon bounds rectangle checkIconR.
	391	*/
	392
	393	if (checkIcon != null) {
	394	checkIconR.width = checkIcon.getIconWidth();
	395	checkIconR.height = checkIcon.getIconHeight();
	396	}
	397	else {
	398	checkIconR.width = checkIconR.height = 0;
	399	}
	400
	401	/* Initialize the arrowIcon bounds rectangle arrowIconR.
	402	*/
	403
	404	if (arrowIcon != null) {
	405	arrowIconR.width = arrowIcon.getIconWidth();
	406	arrowIconR.height = arrowIcon.getIconHeight();
	407	}
	408	else {
	409	arrowIconR.width = arrowIconR.height = 0;
	410	}
	411
	412
	413	Rectangle labelR = iconR.union(textR);
	414	if( MotifGraphicsUtils.isLeftToRight(c) ) {
	415	textR.x += checkIconR.width + menuItemGap;
	416	iconR.x += checkIconR.width + menuItemGap;
	417
	418	// Position the Accelerator text rect
	419	acceleratorR.x = viewR.x + viewR.width - arrowIconR.width
	420	- menuItemGap - acceleratorR.width;
	421
	422	// Position the Check and Arrow Icons
	423	checkIconR.x = viewR.x;
	424	arrowIconR.x = viewR.x + viewR.width - menuItemGap
	425	- arrowIconR.width;
	426	} else {
	427	textR.x -= (checkIconR.width + menuItemGap);
	428	iconR.x -= (checkIconR.width + menuItemGap);
	429
	430	// Position the Accelerator text rect
	431	acceleratorR.x = viewR.x + arrowIconR.width + menuItemGap;
	432
	433	// Position the Check and Arrow Icons
	434	checkIconR.x = viewR.x + viewR.width - checkIconR.width;
	435	arrowIconR.x = viewR.x + menuItemGap;
	436	}
	437
	438	// Align the accelertor text and the check and arrow icons vertically
	439	// with the center of the label rect.
	440	acceleratorR.y = labelR.y + (labelR.height/2) - (acceleratorR.height/2);
	441	arrowIconR.y = labelR.y + (labelR.height/2) - (arrowIconR.height/2);
	442	checkIconR.y = labelR.y + (labelR.height/2) - (checkIconR.height/2);
	443
	444	/*
	445	System.out.println("Layout: v=" +viewR+" c="+checkIconR+" i="+
	446	iconR+" t="+textR+" acc="+acceleratorR+" a="+arrowIconR);
	447	*/
	448	return text;
	449	}
	450
	451	private static void drawMenuBezel(Graphics g, Color background,
	452	int x, int y,
	453	int width, int height)
	454	{
	455	// shadowed button region
	456	g.setColor(background);
	457	g.fillRect(x,y,width,height);
	458
	459	g.setColor(background.brighter().brighter());
	460	g.drawLine(x+1, y+height-1, x+width-1, y+height-1);
	461	g.drawLine(x+width-1, y+height-2, x+width-1, y+1);
	462
	463	g.setColor(background.darker().darker());
	464	g.drawLine(x, y, x+width-2, y);
	465	g.drawLine(x, y+1, x, y+height-2);
	466
	467	}
	468
	469	/*
	470	* Convenience function for determining ComponentOrientation. Helps us
	471	* avoid having Munge directives throughout the code.
	472	*/
	473	static boolean isLeftToRight( Component c ) {
	474	return c.getComponentOrientation().isLeftToRight();
	475	}
	476	}

java/pkg/com/sun/java/swing/plaf/motif/MotifIconFactory.java+460−0

@@ -0,0 +1,460 @@
	1	/*
	2	* Copyright (c) 1997, 2004, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.swing.plaf.motif;
	27
	28	import javax.swing.*;
	29
	30	import javax.swing.plaf.UIResource;
	31
	32	import java.awt.Color;
	33	import java.awt.Component;
	34	import java.awt.Dimension;
	35	import java.awt.Graphics;
	36	import java.awt.Polygon;
	37
	38	import java.io.Serializable;
	39
	40	/**
	41	* Icon factory for the CDE/Motif Look and Feel
	42	* <p>
	43	* <strong>Warning:</strong>
	44	* Serialized objects of this class will not be compatible with
	45	* future Swing releases. The current serialization support is appropriate
	46	* for short term storage or RMI between applications running the same
	47	* version of Swing. A future release of Swing will provide support for
	48	* long term persistence.
	49	*
	50	* 1.20 04/27/99
	51	* @author Georges Saab
	52	*/
	53	public class MotifIconFactory implements Serializable
	54	{
	55	private static Icon checkBoxIcon;
	56	private static Icon radioButtonIcon;
	57	private static Icon menuItemCheckIcon;
	58	private static Icon menuItemArrowIcon;
	59	private static Icon menuArrowIcon;
	60
	61	public static Icon getMenuItemCheckIcon() {
	62	return null;
	63	}
	64
	65	public static Icon getMenuItemArrowIcon() {
	66	if (menuItemArrowIcon == null) {
	67	menuItemArrowIcon = new MenuItemArrowIcon();
	68	}
	69	return menuItemArrowIcon;
	70	}
	71
	72	public static Icon getMenuArrowIcon() {
	73	if (menuArrowIcon == null) {
	74	menuArrowIcon = new MenuArrowIcon();
	75	}
	76	return menuArrowIcon;
	77	}
	78
	79	public static Icon getCheckBoxIcon() {
	80	if (checkBoxIcon == null) {
	81	checkBoxIcon = new CheckBoxIcon();
	82	}
	83	return checkBoxIcon;
	84	}
	85
	86	public static Icon getRadioButtonIcon() {
	87	if (radioButtonIcon == null) {
	88	radioButtonIcon = new RadioButtonIcon();
	89	}
	90	return radioButtonIcon;
	91	}
	92
	93	private static class CheckBoxIcon implements Icon, UIResource, Serializable {
	94	final static int csize = 13;
	95
	96	private Color control = UIManager.getColor("control");
	97	private Color foreground = UIManager.getColor("CheckBox.foreground");
	98	private Color shadow = UIManager.getColor("controlShadow");
	99	private Color highlight = UIManager.getColor("controlHighlight");
	100	private Color lightShadow = UIManager.getColor("controlLightShadow");
	101
	102	public void paintIcon(Component c, Graphics g, int x, int y) {
	103	AbstractButton b = (AbstractButton) c;
	104	ButtonModel model = b.getModel();
	105
	106	boolean flat = false;
	107
	108	if(b instanceof JCheckBox) {
	109	flat = ((JCheckBox)b).isBorderPaintedFlat();
	110	}
	111
	112	boolean isPressed = model.isPressed();
	113	boolean isArmed = model.isArmed();
	114	boolean isEnabled = model.isEnabled();
	115	boolean isSelected = model.isSelected();
	116
	117	// There are 4 "looks" to the Motif CheckBox:
	118	// drawCheckBezelOut - default unchecked state
	119	// drawBezel - when we uncheck in toggled state
	120	// drawCheckBezel - when we check in toggle state
	121	// drawCheckBezelIn - selected, mouseReleased
	122	boolean checkToggleIn = ((isPressed &&
	123	!isArmed &&
	124	isSelected) \|\|
	125	(isPressed &&
	126	isArmed &&
	127	!isSelected));
	128	boolean uncheckToggleOut = ((isPressed &&
	129	!isArmed &&
	130	!isSelected) \|\|
	131	(isPressed &&
	132	isArmed &&
	133	isSelected));
	134
	135	boolean checkIn = (!isPressed &&
	136	isArmed &&
	137	isSelected \|\|
	138	(!isPressed &&
	139	!isArmed &&
	140	isSelected));
	141
	142
	143	if(flat) {
	144	g.setColor(shadow);
	145	g.drawRect(x+2,y,csize-1,csize-1);
	146	if(uncheckToggleOut \|\| checkToggleIn) {
	147	g.setColor(control);
	148	g.fillRect(x+3,y+1,csize-2,csize-2);
	149	}
	150	}
	151
	152	if (checkToggleIn) {
	153	// toggled from unchecked to checked
	154	drawCheckBezel(g,x,y,csize,true,false,false,flat);
	155	} else if (uncheckToggleOut) {
	156	// MotifBorderFactory.drawBezel(g,x,y,csize,csize,false,false);
	157	drawCheckBezel(g,x,y,csize,true,true,false,flat);
	158	} else if (checkIn) {
	159	// show checked, unpressed state
	160	drawCheckBezel(g,x,y,csize,false,false,true,flat);
	161	} else if(!flat) {
	162	// show unchecked state
	163	drawCheckBezelOut(g,x,y,csize);
	164	}
	165	}
	166
	167	public int getIconWidth() {
	168	return csize;
	169	}
	170
	171	public int getIconHeight() {
	172	return csize;
	173	}
	174
	175	public void drawCheckBezelOut(Graphics g, int x, int y, int csize){
	176	Color controlShadow = UIManager.getColor("controlShadow");
	177
	178	int w = csize;
	179	int h = csize;
	180	Color oldColor = g.getColor();
	181
	182	g.translate(x,y);
	183	g.setColor(highlight); // inner 3D border
	184	g.drawLine(0, 0, 0, h-1);
	185	g.drawLine(1, 0, w-1, 0);
	186
	187	g.setColor(shadow); // black drop shadow __\|
	188	g.drawLine(1, h-1, w-1, h-1);
	189	g.drawLine(w-1, h-1, w-1, 1);
	190	g.translate(-x,-y);
	191	g.setColor(oldColor);
	192	}
	193
	194	public void drawCheckBezel(Graphics g, int x, int y, int csize,
	195	boolean shade, boolean out, boolean check, boolean flat)
	196	{
	197
	198
	199	Color oldColor = g.getColor();
	200	g.translate(x, y);
	201
	202
	203	//bottom
	204	if(!flat) {
	205	if (out) {
	206	g.setColor(control);
	207	g.fillRect(1,1,csize-2,csize-2);
	208	g.setColor(shadow);
	209	} else {
	210	g.setColor(lightShadow);
	211	g.fillRect(0,0,csize,csize);
	212	g.setColor(highlight);
	213	}
	214
	215	g.drawLine(1,csize-1,csize-2,csize-1);
	216	if (shade) {
	217	g.drawLine(2,csize-2,csize-3,csize-2);
	218	g.drawLine(csize-2,2,csize-2 ,csize-1);
	219	if (out) {
	220	g.setColor(highlight);
	221	} else {
	222	g.setColor(shadow);
	223	}
	224	g.drawLine(1,2,1,csize-2);
	225	g.drawLine(1,1,csize-3,1);
	226	if (out) {
	227	g.setColor(shadow);
	228	} else {
	229	g.setColor(highlight);
	230	}
	231	}
	232	//right
	233	g.drawLine(csize-1,1,csize-1,csize-1);
	234
	235	//left
	236	if (out) {
	237	g.setColor(highlight);
	238	} else {
	239	g.setColor(shadow);
	240	}
	241	g.drawLine(0,1,0,csize-1);
	242
	243	//top
	244	g.drawLine(0,0,csize-1,0);
	245	}
	246
	247	if (check) {
	248	// draw check
	249	g.setColor(foreground);
	250	g.drawLine(csize-2,1,csize-2,2);
	251	g.drawLine(csize-3,2,csize-3,3);
	252	g.drawLine(csize-4,3,csize-4,4);
	253	g.drawLine(csize-5,4,csize-5,6);
	254	g.drawLine(csize-6,5,csize-6,8);
	255	g.drawLine(csize-7,6,csize-7,10);
	256	g.drawLine(csize-8,7,csize-8,10);
	257	g.drawLine(csize-9,6,csize-9,9);
	258	g.drawLine(csize-10,5,csize-10,8);
	259	g.drawLine(csize-11,5,csize-11,7);
	260	g.drawLine(csize-12,6,csize-12,6);
	261	}
	262	g.translate(-x, -y);
	263	g.setColor(oldColor);
	264	}
	265	} // end class CheckBoxIcon
	266
	267	private static class RadioButtonIcon implements Icon, UIResource, Serializable {
	268	private Color dot = UIManager.getColor("activeCaptionBorder");
	269	private Color highlight = UIManager.getColor("controlHighlight");
	270	private Color shadow = UIManager.getColor("controlShadow");
	271
	272	public void paintIcon(Component c, Graphics g, int x, int y) {
	273	// fill interior
	274	AbstractButton b = (AbstractButton) c;
	275	ButtonModel model = b.getModel();
	276
	277	int w = getIconWidth();
	278	int h = getIconHeight();
	279
	280	boolean isPressed = model.isPressed();
	281	boolean isArmed = model.isArmed();
	282	boolean isEnabled = model.isEnabled();
	283	boolean isSelected = model.isSelected();
	284
	285	boolean checkIn = ((isPressed &&
	286	!isArmed &&
	287	isSelected) \|\|
	288	(isPressed &&
	289	isArmed &&
	290	!isSelected)
	291	\|\|
	292	(!isPressed &&
	293	isArmed &&
	294	isSelected \|\|
	295	(!isPressed &&
	296	!isArmed &&
	297	isSelected)));
	298
	299	if (checkIn){
	300	g.setColor(shadow);
	301	g.drawLine(x+5,y+0,x+8,y+0);
	302	g.drawLine(x+3,y+1,x+4,y+1);
	303	g.drawLine(x+9,y+1,x+9,y+1);
	304	g.drawLine(x+2,y+2,x+2,y+2);
	305	g.drawLine(x+1,y+3,x+1,y+3);
	306	g.drawLine(x,y+4,x,y+9);
	307	g.drawLine(x+1,y+10,x+1,y+10);
	308	g.drawLine(x+2,y+11,x+2,y+11);
	309	g.setColor(highlight);
	310	g.drawLine(x+3,y+12,x+4,y+12);
	311	g.drawLine(x+5,y+13,x+8,y+13);
	312	g.drawLine(x+9,y+12,x+10,y+12);
	313	g.drawLine(x+11,y+11,x+11,y+11);
	314	g.drawLine(x+12,y+10,x+12,y+10);
	315	g.drawLine(x+13,y+9,x+13,y+4);
	316	g.drawLine(x+12,y+3,x+12,y+3);
	317	g.drawLine(x+11,y+2,x+11,y+2);
	318	g.drawLine(x+10,y+1,x+10,y+1);
	319	g.setColor(dot);
	320	g.fillRect(x+4,y+5,6,4);
	321	g.drawLine(x+5,y+4,x+8,y+4);
	322	g.drawLine(x+5,y+9,x+8,y+9);
	323	}
	324	else {
	325	g.setColor(highlight);
	326	g.drawLine(x+5,y+0,x+8,y+0);
	327	g.drawLine(x+3,y+1,x+4,y+1);
	328	g.drawLine(x+9,y+1,x+9,y+1);
	329	g.drawLine(x+2,y+2,x+2,y+2);
	330	g.drawLine(x+1,y+3,x+1,y+3);
	331	g.drawLine(x,y+4,x,y+9);
	332	g.drawLine(x+1,y+10,x+1,y+10);
	333	g.drawLine(x+2,y+11,x+2,y+11);
	334
	335	g.setColor(shadow);
	336	g.drawLine(x+3,y+12,x+4,y+12);
	337	g.drawLine(x+5,y+13,x+8,y+13);
	338	g.drawLine(x+9,y+12,x+10,y+12);
	339	g.drawLine(x+11,y+11,x+11,y+11);
	340	g.drawLine(x+12,y+10,x+12,y+10);
	341	g.drawLine(x+13,y+9,x+13,y+4);
	342	g.drawLine(x+12,y+3,x+12,y+3);
	343	g.drawLine(x+11,y+2,x+11,y+2);
	344	g.drawLine(x+10,y+1,x+10,y+1);
	345
	346	}
	347	}
	348
	349	public int getIconWidth() {
	350	return 14;
	351	}
	352
	353	public int getIconHeight() {
	354	return 14;
	355	}
	356	} // end class RadioButtonIcon
	357
	358	private static class MenuItemCheckIcon implements Icon, UIResource, Serializable
	359	{
	360	public void paintIcon(Component c,Graphics g, int x, int y)
	361	{
	362	}
	363	public int getIconWidth() { return 0; }
	364	public int getIconHeight() { return 0; }
	365	} // end class MenuItemCheckIcon
	366
	367
	368	private static class MenuItemArrowIcon implements Icon, UIResource, Serializable
	369	{
	370	public void paintIcon(Component c,Graphics g, int x, int y)
	371	{
	372	}
	373	public int getIconWidth() { return 0; }
	374	public int getIconHeight() { return 0; }
	375	} // end class MenuItemArrowIcon
	376
	377	private static class MenuArrowIcon implements Icon, UIResource, Serializable
	378	{
	379	private Color focus = UIManager.getColor("windowBorder");
	380	private Color shadow = UIManager.getColor("controlShadow");
	381	private Color highlight = UIManager.getColor("controlHighlight");
	382
	383	public void paintIcon(Component c, Graphics g, int x, int y) {
	384	AbstractButton b = (AbstractButton) c;
	385	ButtonModel model = b.getModel();
	386
	387	// These variables are kind of pointless as the following code
	388	// assumes the icon will be 10 x 10 regardless of their value.
	389	int w = getIconWidth();
	390	int h = getIconHeight();
	391
	392	Color oldColor = g.getColor();
	393
	394	if (model.isSelected()){
	395	if( MotifGraphicsUtils.isLeftToRight(c) ){
	396	g.setColor(shadow);
	397	g.fillRect(x+1,y+1,2,h);
	398	g.drawLine(x+4,y+2,x+4,y+2);
	399	g.drawLine(x+6,y+3,x+6,y+3);
	400	g.drawLine(x+8,y+4,x+8,y+5);
	401	g.setColor(focus);
	402	g.fillRect(x+2,y+2,2,h-2);
	403	g.fillRect(x+4,y+3,2,h-4);
	404	g.fillRect(x+6,y+4,2,h-6);
	405	g.setColor(highlight);
	406	g.drawLine(x+2,y+h,x+2,y+h);
	407	g.drawLine(x+4,y+h-1,x+4,y+h-1);
	408	g.drawLine(x+6,y+h-2,x+6,y+h-2);
	409	g.drawLine(x+8,y+h-4,x+8,y+h-3);
	410	} else {
	411	g.setColor(highlight);
	412	g.fillRect(x+7,y+1,2,10);
	413	g.drawLine(x+5,y+9,x+5,y+9);
	414	g.drawLine(x+3,y+8,x+3,y+8);
	415	g.drawLine(x+1,y+6,x+1,y+7);
	416	g.setColor(focus);
	417	g.fillRect(x+6,y+2,2,8);
	418	g.fillRect(x+4,y+3,2,6);
	419	g.fillRect(x+2,y+4,2,4);
	420	g.setColor(shadow);
	421	g.drawLine(x+1,y+4,x+1,y+5);
	422	g.drawLine(x+3,y+3,x+3,y+3);
	423	g.drawLine(x+5,y+2,x+5,y+2);
	424	g.drawLine(x+7,y+1,x+7,y+1);
	425	}
	426	} else {
	427	if( MotifGraphicsUtils.isLeftToRight(c) ){
	428	g.setColor(highlight);
	429	g.drawLine(x+1,y+1,x+1,y+h);
	430	g.drawLine(x+2,y+1,x+2,y+h-2);
	431	g.fillRect(x+3,y+2,2,2);
	432	g.fillRect(x+5,y+3,2,2);
	433	g.fillRect(x+7,y+4,2,2);
	434	g.setColor(shadow);
	435	g.drawLine(x+2,y+h-1,x+2,y+h);
	436	g.fillRect(x+3,y+h-2,2,2);
	437	g.fillRect(x+5,y+h-3,2,2);
	438	g.fillRect(x+7,y+h-4,2,2);
	439	g.setColor(oldColor);
	440	} else {
	441	g.setColor(highlight);
	442	g.fillRect(x+1,y+4,2,2);
	443	g.fillRect(x+3,y+3,2,2);
	444	g.fillRect(x+5,y+2,2,2);
	445	g.drawLine(x+7,y+1,x+7,y+2);
	446	g.setColor(shadow);
	447	g.fillRect(x+1,y+h-4,2,2);
	448	g.fillRect(x+3,y+h-3,2,2);
	449	g.fillRect(x+5,y+h-2,2,2);
	450	g.drawLine(x+7,y+3,x+7,y+h);
	451	g.drawLine(x+8,y+1,x+8,y+h);
	452	g.setColor(oldColor);
	453	}
	454	}
	455
	456	}
	457	public int getIconWidth() { return 10; }
	458	public int getIconHeight() { return 10; }
	459	} // End class MenuArrowIcon
	460	}

java/pkg/com/sun/java/swing/plaf/motif/MotifInternalFrameTitlePane.java+374−0

@@ -0,0 +1,374 @@
	1	/*
	2	* Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.swing.plaf.motif;
	27
	28	import java.awt.*;
	29	import java.awt.event.*;
	30	import javax.swing.*;
	31	import javax.swing.border.*;
	32	import javax.swing.event.InternalFrameEvent;
	33	import javax.swing.plaf.basic.*;
	34	import java.util.EventListener;
	35	import java.beans.PropertyChangeListener;
	36	import java.beans.PropertyChangeEvent;
	37	import java.beans.VetoableChangeListener;
	38	import java.beans.PropertyVetoException;
	39
	40	/**
	41	* Class that manages a Motif title bar
	42	*
	43	* @since 1.3
	44	*/
	45	public class MotifInternalFrameTitlePane
	46	extends BasicInternalFrameTitlePane implements LayoutManager, ActionListener, PropertyChangeListener
	47	{
	48	SystemButton systemButton;
	49	MinimizeButton minimizeButton;
	50	MaximizeButton maximizeButton;
	51	JPopupMenu systemMenu;
	52	Title title;
	53	Color color;
	54	Color highlight;
	55	Color shadow;
	56
	57	// The width and height of a title pane button
	58	public final static int BUTTON_SIZE = 19; // 17 + 1 pixel border
	59
	60
	61	public MotifInternalFrameTitlePane(JInternalFrame frame) {
	62	super(frame);
	63	}
	64
	65	protected void installDefaults() {
	66	setFont(UIManager.getFont("InternalFrame.titleFont"));
	67	setPreferredSize(new Dimension(100, BUTTON_SIZE));
	68	}
	69
	70	protected void uninstallListeners() {
	71	// Get around protected method in superclass
	72	super.uninstallListeners();
	73	}
	74
	75	protected PropertyChangeListener createPropertyChangeListener() {
	76	return this;
	77	}
	78
	79	protected LayoutManager createLayout() {
	80	return this;
	81	}
	82
	83	JPopupMenu getSystemMenu() {
	84	return systemMenu;
	85	}
	86
	87	protected void assembleSystemMenu() {
	88	systemMenu = new JPopupMenu();
	89	JMenuItem mi = systemMenu.add(new JMenuItem(restoreAction));
	90	mi.setMnemonic('R');
	91	mi = systemMenu.add(new JMenuItem(moveAction));
	92	mi.setMnemonic('M');
	93	mi = systemMenu.add(new JMenuItem(sizeAction));
	94	mi.setMnemonic('S');
	95	mi = systemMenu.add(new JMenuItem(iconifyAction));
	96	mi.setMnemonic('n');
	97	mi = systemMenu.add(new JMenuItem(maximizeAction));
	98	mi.setMnemonic('x');
	99	systemMenu.add(new JSeparator());
	100	mi = systemMenu.add(new JMenuItem(closeAction));
	101	mi.setMnemonic('C');
	102
	103	systemButton = new SystemButton();
	104	systemButton.addActionListener(new ActionListener() {
	105	public void actionPerformed(ActionEvent e) {
	106	systemMenu.show(systemButton, 0, BUTTON_SIZE);
	107	}
	108	});
	109
	110	systemButton.addMouseListener(new MouseAdapter() {
	111	public void mousePressed(MouseEvent evt) {
	112	try {
	113	frame.setSelected(true);
	114	} catch (PropertyVetoException pve) {
	115	}
	116	if ((evt.getClickCount() == 2)) {
	117	closeAction.actionPerformed(new
	118	ActionEvent(evt.getSource(),
	119	ActionEvent.ACTION_PERFORMED,
	120	null, evt.getWhen(), 0));
	121	systemMenu.setVisible(false);
	122	}
	123	}
	124	});
	125	}
	126
	127
	128	protected void createButtons() {
	129	minimizeButton = new MinimizeButton();
	130	minimizeButton.addActionListener(iconifyAction);
	131
	132	maximizeButton = new MaximizeButton();
	133	maximizeButton.addActionListener(maximizeAction);
	134	}
	135
	136
	137	protected void addSubComponents() {
	138	title = new Title(frame.getTitle());
	139	title.setFont(getFont());
	140
	141	add(systemButton);
	142	add(title);
	143	add(minimizeButton);
	144	add(maximizeButton);
	145	}
	146
	147	public void paintComponent(Graphics g) {
	148	}
	149
	150	void setColors(Color c, Color h, Color s) {
	151	color = c;
	152	highlight = h;
	153	shadow = s;
	154	}
	155
	156	public void actionPerformed(ActionEvent e) {
	157	}
	158
	159	public void propertyChange(PropertyChangeEvent evt) {
	160	String prop = evt.getPropertyName();
	161	JInternalFrame f = (JInternalFrame)evt.getSource();
	162	boolean value = false;
	163	if (JInternalFrame.IS_SELECTED_PROPERTY.equals(prop)) {
	164	repaint();
	165	} else if (prop.equals("maximizable")) {
	166	if ((Boolean)evt.getNewValue() == Boolean.TRUE)
	167	add(maximizeButton);
	168	else
	169	remove(maximizeButton);
	170	revalidate();
	171	repaint();
	172	} else if (prop.equals("iconable")) {
	173	if ((Boolean)evt.getNewValue() == Boolean.TRUE)
	174	add(minimizeButton);
	175	else
	176	remove(minimizeButton);
	177	revalidate();
	178	repaint();
	179	} else if (prop.equals(JInternalFrame.TITLE_PROPERTY)) {
	180	repaint();
	181	}
	182	enableActions();
	183	}
	184
	185	public void addLayoutComponent(String name, Component c) {}
	186	public void removeLayoutComponent(Component c) {}
	187	public Dimension preferredLayoutSize(Container c) {
	188	return minimumLayoutSize(c);
	189	}
	190
	191	public Dimension minimumLayoutSize(Container c) {
	192	return new Dimension(100, BUTTON_SIZE);
	193	}
	194
	195	public void layoutContainer(Container c) {
	196	int w = getWidth();
	197	systemButton.setBounds(0, 0, BUTTON_SIZE, BUTTON_SIZE);
	198	int x = w - BUTTON_SIZE;
	199
	200	if(frame.isMaximizable()) {
	201	maximizeButton.setBounds(x, 0, BUTTON_SIZE, BUTTON_SIZE);
	202	x -= BUTTON_SIZE;
	203	} else if(maximizeButton.getParent() != null) {
	204	maximizeButton.getParent().remove(maximizeButton);
	205	}
	206
	207	if(frame.isIconifiable()) {
	208	minimizeButton.setBounds(x, 0, BUTTON_SIZE, BUTTON_SIZE);
	209	x -= BUTTON_SIZE;
	210	} else if(minimizeButton.getParent() != null) {
	211	minimizeButton.getParent().remove(minimizeButton);
	212	}
	213
	214	title.setBounds(BUTTON_SIZE, 0, x, BUTTON_SIZE);
	215	}
	216
	217	protected void showSystemMenu(){
	218	systemMenu.show(systemButton, 0, BUTTON_SIZE);
	219	}
	220
	221	protected void hideSystemMenu(){
	222	systemMenu.setVisible(false);
	223	}
	224
	225	static Dimension buttonDimension = new Dimension(BUTTON_SIZE, BUTTON_SIZE);
	226
	227	private abstract class FrameButton extends JButton {
	228
	229	FrameButton() {
	230	super();
	231	setFocusPainted(false);
	232	setBorderPainted(false);
	233	}
	234
	235	public boolean isFocusTraversable() {
	236	return false;
	237	}
	238
	239	public void requestFocus() {
	240	// ignore request.
	241	}
	242
	243	public Dimension getMinimumSize() {
	244	return buttonDimension;
	245	}
	246
	247	public Dimension getPreferredSize() {
	248	return buttonDimension;
	249	}
	250
	251	public void paintComponent(Graphics g) {
	252	Dimension d = getSize();
	253	int maxX = d.width - 1;
	254	int maxY = d.height - 1;
	255
	256	// draw background
	257	g.setColor(color);
	258	g.fillRect(1, 1, d.width, d.height);
	259
	260	// draw border
	261	boolean pressed = getModel().isPressed();
	262	g.setColor(pressed ? shadow : highlight);
	263	g.drawLine(0, 0, maxX, 0);
	264	g.drawLine(0, 0, 0, maxY);
	265	g.setColor(pressed ? highlight : shadow);
	266	g.drawLine(1, maxY, maxX, maxY);
	267	g.drawLine(maxX, 1, maxX, maxY);
	268	}
	269	}
	270
	271	private class MinimizeButton extends FrameButton {
	272	public void paintComponent(Graphics g) {
	273	super.paintComponent(g);
	274	g.setColor(highlight);
	275	g.drawLine(7, 8, 7, 11);
	276	g.drawLine(7, 8, 10, 8);
	277	g.setColor(shadow);
	278	g.drawLine(8, 11, 10, 11);
	279	g.drawLine(11, 9, 11, 11);
	280	}
	281	}
	282
	283	private class MaximizeButton extends FrameButton {
	284	public void paintComponent(Graphics g) {
	285	super.paintComponent(g);
	286	int max = BUTTON_SIZE - 5;
	287	boolean isMaxed = frame.isMaximum();
	288	g.setColor(isMaxed ? shadow : highlight);
	289	g.drawLine(4, 4, 4, max);
	290	g.drawLine(4, 4, max, 4);
	291	g.setColor(isMaxed ? highlight : shadow);
	292	g.drawLine(5, max, max, max);
	293	g.drawLine(max, 5, max, max);
	294	}
	295	}
	296
	297	private class SystemButton extends FrameButton {
	298	public boolean isFocusTraversable() { return false; }
	299	public void requestFocus() {}
	300
	301	public void paintComponent(Graphics g) {
	302	super.paintComponent(g);
	303	g.setColor(highlight);
	304	g.drawLine(4, 8, 4, 11);
	305	g.drawLine(4, 8, BUTTON_SIZE - 5, 8);
	306	g.setColor(shadow);
	307	g.drawLine(5, 11, BUTTON_SIZE - 5, 11);
	308	g.drawLine(BUTTON_SIZE - 5, 9, BUTTON_SIZE - 5, 11);
	309	}
	310	}
	311
	312	private class Title extends FrameButton {
	313	Title(String title) {
	314	super();
	315	setText(title);
	316	setHorizontalAlignment(SwingConstants.CENTER);
	317	setBorder(BorderFactory.createBevelBorder(
	318	BevelBorder.RAISED,
	319	UIManager.getColor("activeCaptionBorder"),
	320	UIManager.getColor("inactiveCaptionBorder")));
	321
	322	// Forward mouse events to titlebar for moves.
	323	addMouseMotionListener(new MouseMotionListener() {
	324	public void mouseDragged(MouseEvent e) {
	325	forwardEventToParent(e);
	326	}
	327	public void mouseMoved(MouseEvent e) {
	328	forwardEventToParent(e);
	329	}
	330	});
	331	addMouseListener(new MouseListener() {
	332	public void mouseClicked(MouseEvent e) {
	333	forwardEventToParent(e);
	334	}
	335	public void mousePressed(MouseEvent e) {
	336	forwardEventToParent(e);
	337	}
	338	public void mouseReleased(MouseEvent e) {
	339	forwardEventToParent(e);
	340	}
	341	public void mouseEntered(MouseEvent e) {
	342	forwardEventToParent(e);
	343	}
	344	public void mouseExited(MouseEvent e) {
	345	forwardEventToParent(e);
	346	}
	347	});
	348	}
	349
	350	void forwardEventToParent(MouseEvent e) {
	351	getParent().dispatchEvent(new MouseEvent(
	352	getParent(), e.getID(), e.getWhen(), e.getModifiers(),
	353	e.getX(), e.getY(), e.getXOnScreen(),
	354	e.getYOnScreen(), e.getClickCount(),
	355	e.isPopupTrigger(), MouseEvent.NOBUTTON));
	356	}
	357
	358	public void paintComponent(Graphics g) {
	359	super.paintComponent(g);
	360	if (frame.isSelected()) {
	361	g.setColor(UIManager.getColor("activeCaptionText"));
	362	} else {
	363	g.setColor(UIManager.getColor("inactiveCaptionText"));
	364	}
	365	Dimension d = getSize();
	366	String frameTitle = frame.getTitle();
	367	if (frameTitle != null) {
	368	MotifGraphicsUtils.drawStringInRect(frame, g, frameTitle,
	369	0, 0, d.width, d.height,
	370	SwingConstants.CENTER);
	371	}
	372	}
	373	}
	374	}

java/pkg/com/sun/java/swing/plaf/motif/MotifInternalFrameUI.java+223−0

@@ -0,0 +1,223 @@
	1	/*
	2	* Copyright (c) 1997, 2004, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.swing.plaf.motif;
	27
	28	import java.awt.*;
	29	import java.awt.event.*;
	30	import javax.swing.*;
	31	import javax.swing.event.*;
	32
	33	import java.util.EventListener;
	34
	35	import javax.swing.plaf.basic.*;
	36	import javax.swing.border.*;
	37	import javax.swing.plaf.*;
	38
	39
	40	/**
	41	* A Motif L&F implementation of InternalFrame.
	42	* <p>
	43	* <strong>Warning:</strong>
	44	* Serialized objects of this class will not be compatible with
	45	* future Swing releases. The current serialization support is appropriate
	46	* for short term storage or RMI between applications running the same
	47	* version of Swing. A future release of Swing will provide support for
	48	* long term persistence.
	49	*
	50	* @author Tom Ball
	51	*/
	52	public class MotifInternalFrameUI extends BasicInternalFrameUI {
	53
	54	Color color;
	55	Color highlight;
	56	Color shadow;
	57	MotifInternalFrameTitlePane titlePane;
	58
	59	/**
	60	* As of Java 2 platform v1.3 this previously undocumented field is no
	61	* longer used.
	62	* Key bindings are now defined by the LookAndFeel, please refer to
	63	* the key bindings specification for further details.
	64	*
	65	* @deprecated As of Java 2 platform v1.3.
	66	*/
	67	@Deprecated
	68	protected KeyStroke closeMenuKey;
	69
	70
	71	/////////////////////////////////////////////////////////////////////////////
	72	// ComponentUI Interface Implementation methods
	73	/////////////////////////////////////////////////////////////////////////////
	74	public static ComponentUI createUI(JComponent w) {
	75	return new MotifInternalFrameUI((JInternalFrame)w);
	76	}
	77
	78	public MotifInternalFrameUI(JInternalFrame w) {
	79	super(w);
	80	}
	81
	82	public void installUI(JComponent c) {
	83	super.installUI(c);
	84	setColors((JInternalFrame)c);
	85	}
	86
	87	protected void installDefaults() {
	88	Border frameBorder = frame.getBorder();
	89	frame.setLayout(internalFrameLayout = createLayoutManager());
	90	if (frameBorder == null \|\| frameBorder instanceof UIResource) {
	91	frame.setBorder(new MotifBorders.InternalFrameBorder(frame));
	92	}
	93	}
	94
	95
	96	protected void installKeyboardActions(){
	97	super.installKeyboardActions();
	98	// We replace the
	99	// we use JPopup in our TitlePane so need escape support
	100	closeMenuKey = KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0);
	101	}
	102
	103
	104	protected void uninstallDefaults() {
	105	LookAndFeel.uninstallBorder(frame);
	106	frame.setLayout(null);
	107	internalFrameLayout = null;
	108	}
	109
	110	private JInternalFrame getFrame(){
	111	return frame;
	112	}
	113
	114	public JComponent createNorthPane(JInternalFrame w) {
	115	titlePane = new MotifInternalFrameTitlePane(w);
	116	return titlePane;
	117	}
	118
	119	public Dimension getMaximumSize(JComponent x) {
	120	return Toolkit.getDefaultToolkit().getScreenSize();
	121	}
	122
	123	protected void uninstallKeyboardActions(){
	124	super.uninstallKeyboardActions();
	125	if (isKeyBindingRegistered()){
	126	JInternalFrame.JDesktopIcon di = frame.getDesktopIcon();
	127	SwingUtilities.replaceUIActionMap(di, null);
	128	SwingUtilities.replaceUIInputMap(di, JComponent.WHEN_IN_FOCUSED_WINDOW,
	129	null);
	130	}
	131	}
	132
	133	protected void setupMenuOpenKey(){
	134	super.setupMenuOpenKey();
	135	ActionMap map = SwingUtilities.getUIActionMap(frame);
	136	if (map != null) {
	137	// BasicInternalFrameUI creates an action with the same name, we override
	138	// it as MotifInternalFrameTitlePane has a titlePane ivar that shadows the
	139	// titlePane ivar in BasicInternalFrameUI, making supers action throw
	140	// an NPE for us.
	141	map.put("showSystemMenu", new AbstractAction(){
	142	public void actionPerformed(ActionEvent e){
	143	titlePane.showSystemMenu();
	144	}
	145	public boolean isEnabled(){
	146	return isKeyBindingActive();
	147	}
	148	});
	149	}
	150	}
	151
	152	protected void setupMenuCloseKey(){
	153	ActionMap map = SwingUtilities.getUIActionMap(frame);
	154	if (map != null) {
	155	map.put("hideSystemMenu", new AbstractAction(){
	156	public void actionPerformed(ActionEvent e){
	157	titlePane.hideSystemMenu();
	158	}
	159	public boolean isEnabled(){
	160	return isKeyBindingActive();
	161	}
	162	});
	163	}
	164
	165	// Set up the bindings for the DesktopIcon, it is odd that
	166	// we install them, and not the desktop icon.
	167	JInternalFrame.JDesktopIcon di = frame.getDesktopIcon();
	168	InputMap diInputMap = SwingUtilities.getUIInputMap
	169	(di, JComponent.WHEN_IN_FOCUSED_WINDOW);
	170	if (diInputMap == null) {
	171	Object[] bindings = (Object[])UIManager.get
	172	("DesktopIcon.windowBindings");
	173	if (bindings != null) {
	174	diInputMap = LookAndFeel.makeComponentInputMap(di, bindings);
	175
	176	SwingUtilities.replaceUIInputMap(di, JComponent.
	177	WHEN_IN_FOCUSED_WINDOW,
	178	diInputMap);
	179	}
	180	}
	181	ActionMap diActionMap = SwingUtilities.getUIActionMap(di);
	182	if (diActionMap == null) {
	183	diActionMap = new ActionMapUIResource();
	184	diActionMap.put("hideSystemMenu", new AbstractAction(){
	185	public void actionPerformed(ActionEvent e){
	186	JInternalFrame.JDesktopIcon icon = getFrame().
	187	getDesktopIcon();
	188	MotifDesktopIconUI micon = (MotifDesktopIconUI)icon.
	189	getUI();
	190	micon.hideSystemMenu();
	191	}
	192	public boolean isEnabled(){
	193	return isKeyBindingActive();
	194	}
	195	});
	196	SwingUtilities.replaceUIActionMap(di, diActionMap);
	197	}
	198	}
	199
	200	/** This method is called when the frame becomes selected.
	201	*/
	202	protected void activateFrame(JInternalFrame f) {
	203	super.activateFrame(f);
	204	setColors(f);
	205	}
	206	/** This method is called when the frame is no longer selected.
	207	*/
	208	protected void deactivateFrame(JInternalFrame f) {
	209	setColors(f);
	210	super.deactivateFrame(f);
	211	}
	212
	213	void setColors(JInternalFrame frame) {
	214	if (frame.isSelected()) {
	215	color = UIManager.getColor("InternalFrame.activeTitleBackground");
	216	} else {
	217	color = UIManager.getColor("InternalFrame.inactiveTitleBackground");
	218	}
	219	highlight = color.brighter();
	220	shadow = color.darker().darker();
	221	titlePane.setColors(color, highlight, shadow);
	222	}
	223	}

java/pkg/com/sun/java/swing/plaf/motif/MotifLabelUI.java+61−0

@@ -0,0 +1,61 @@
	1	/*
	2	* Copyright (c) 1997, 1998, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.swing.plaf.motif;
	27
	28	import sun.awt.AppContext;
	29
	30	import javax.swing.*;
	31	import javax.swing.plaf.basic.BasicLabelUI;
	32	import javax.swing.plaf.ComponentUI;
	33
	34	/**
	35	* A Motif L&F implementation of LabelUI.
	36	* This merely sets up new default values in MotifLookAndFeel.
	37	* <p>
	38	* <strong>Warning:</strong>
	39	* Serialized objects of this class will not be compatible with
	40	* future Swing releases. The current serialization support is appropriate
	41	* for short term storage or RMI between applications running the same
	42	* version of Swing. A future release of Swing will provide support for
	43	* long term persistence.
	44	*
	45	* @author Amy Fowler
	46	*/
	47	public class MotifLabelUI extends BasicLabelUI
	48	{
	49	private static final Object MOTIF_LABEL_UI_KEY = new Object();
	50
	51	public static ComponentUI createUI(JComponent c) {
	52	AppContext appContext = AppContext.getAppContext();
	53	MotifLabelUI motifLabelUI =
	54	(MotifLabelUI) appContext.get(MOTIF_LABEL_UI_KEY);
	55	if (motifLabelUI == null) {
	56	motifLabelUI = new MotifLabelUI();
	57	appContext.put(MOTIF_LABEL_UI_KEY, motifLabelUI);
	58	}
	59	return motifLabelUI;
	60	}
	61	}

java/pkg/com/sun/java/swing/plaf/motif/MotifLookAndFeel.java+1283−0

@@ -0,0 +1,1283 @@
	1	/*
	2	* Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.swing.plaf.motif;
	27
	28	import java.awt.Color;
	29	import java.awt.Font;
	30	import java.awt.Insets;
	31	import java.awt.event.KeyEvent;
	32	import java.awt.event.InputEvent;
	33	import java.util.*;
	34
	35	import javax.swing.*;
	36	import javax.swing.plaf.*;
	37	import javax.swing.border.*;
	38	import javax.swing.text.JTextComponent;
	39	import javax.swing.text.DefaultEditorKit;
	40
	41	import javax.swing.plaf.basic.BasicLookAndFeel;
	42	import javax.swing.plaf.basic.BasicBorders;
	43	import javax.swing.plaf.basic.BasicComboBoxRenderer;
	44	import javax.swing.plaf.basic.BasicComboBoxEditor;
	45
	46	import sun.swing.SwingUtilities2;
	47	import sun.awt.OSInfo;
	48
	49	/**
	50	* Implements the Motif Look and Feel.
	51	* UI classes not implemented specifically for Motif will
	52	* default to those implemented in Basic.
	53	* <p>
	54	* <strong>Warning:</strong>
	55	* Serialized objects of this class will not be compatible with
	56	* future Swing releases. The current serialization support is appropriate
	57	* for short term storage or RMI between applications running the same
	58	* version of Swing. A future release of Swing will provide support for
	59	* long term persistence.
	60	*
	61	* @author unattributed
	62	*/
	63	public class MotifLookAndFeel extends BasicLookAndFeel
	64	{
	65	public String getName() {
	66	return "CDE/Motif";
	67	}
	68
	69	public String getID() {
	70	return "Motif";
	71	}
	72
	73	public String getDescription() {
	74	return "The CDE/Motif Look and Feel";
	75	}
	76
	77
	78	public boolean isNativeLookAndFeel() {
	79	return OSInfo.getOSType() == OSInfo.OSType.SOLARIS;
	80	}
	81
	82
	83	public boolean isSupportedLookAndFeel() {
	84	return true;
	85	}
	86
	87
	88	/**
	89	* Load the SystemColors into the defaults table. The keys
	90	* for SystemColor defaults are the same as the names of
	91	* the public fields in SystemColor. If the table is being
	92	* created on a native Motif platform we use the SystemColor
	93	* values, otherwise we create color objects whose values match
	94	* the default CDE/Motif colors.
	95	*/
	96	protected void initSystemColorDefaults(UIDefaults table)
	97	{
	98	String[] defaultSystemColors = {
	99	"desktop", "#005C5C", /* Color of the desktop background */
	100	"activeCaption", "#000080", /* Color for captions (title bars) when they are active. */
	101	"activeCaptionText", "#FFFFFF", /* Text color for text in captions (title bars). */
	102	"activeCaptionBorder", "#B24D7A", /* Border color for caption (title bar) window borders. */
	103	"inactiveCaption", "#AEB2C3", /* Color for captions (title bars) when not active. */
	104	"inactiveCaptionText", "#000000", /* Text color for text in inactive captions (title bars). */
	105	"inactiveCaptionBorder", "#AEB2C3", /* Border color for inactive caption (title bar) window borders. */
	106	"window", "#AEB2C3", /* Default color for the interior of windows */
	107	"windowBorder", "#AEB2C3", /* ??? */
	108	"windowText", "#000000", /* ??? */
	109	"menu", "#AEB2C3", /* ??? */
	110	"menuText", "#000000", /* ??? */
	111	"text", "#FFF7E9", /* Text background color */
	112	"textText", "#000000", /* Text foreground color */
	113	"textHighlight", "#000000", /* Text background color when selected */
	114	"textHighlightText", "#FFF7E9", /* Text color when selected */
	115	"textInactiveText", "#808080", /* Text color when disabled */
	116	"control", "#AEB2C3", /* Default color for controls (buttons, sliders, etc) */
	117	"controlText", "#000000", /* Default color for text in controls */
	118	"controlHighlight", "#DCDEE5", /* Highlight color for controls */
	119	"controlLtHighlight", "#DCDEE5", /* Light highlight color for controls */
	120	"controlShadow", "#63656F", /* Shadow color for controls */
	121	"controlLightShadow", "#9397A5", /* Shadow color for controls */
	122	"controlDkShadow", "#000000", /* Dark shadow color for controls */
	123	"scrollbar", "#AEB2C3", /* Scrollbar ??? color. PENDING(jeff) foreground? background? ?*/
	124	"info", "#FFF7E9", /* ??? */
	125	"infoText", "#000000" /* ??? */
	126	};
	127
	128	loadSystemColors(table, defaultSystemColors, false);
	129	}
	130
	131
	132	protected void initClassDefaults(UIDefaults table)
	133	{
	134	super.initClassDefaults(table);
	135	String motifPackageName = "com.sun.java.swing.plaf.motif.";
	136
	137	Object[] uiDefaults = {
	138	"ButtonUI", motifPackageName + "MotifButtonUI",
	139	"CheckBoxUI", motifPackageName + "MotifCheckBoxUI",
	140	"DirectoryPaneUI", motifPackageName + "MotifDirectoryPaneUI",
	141	"FileChooserUI", motifPackageName + "MotifFileChooserUI",
	142	"LabelUI", motifPackageName + "MotifLabelUI",
	143	"MenuBarUI", motifPackageName + "MotifMenuBarUI",
	144	"MenuUI", motifPackageName + "MotifMenuUI",
	145	"MenuItemUI", motifPackageName + "MotifMenuItemUI",
	146	"CheckBoxMenuItemUI", motifPackageName + "MotifCheckBoxMenuItemUI",
	147	"RadioButtonMenuItemUI", motifPackageName + "MotifRadioButtonMenuItemUI",
	148	"RadioButtonUI", motifPackageName + "MotifRadioButtonUI",
	149	"ToggleButtonUI", motifPackageName + "MotifToggleButtonUI",
	150	"PopupMenuUI", motifPackageName + "MotifPopupMenuUI",
	151	"ProgressBarUI", motifPackageName + "MotifProgressBarUI",
	152	"ScrollBarUI", motifPackageName + "MotifScrollBarUI",
	153	"ScrollPaneUI", motifPackageName + "MotifScrollPaneUI",
	154	"SliderUI", motifPackageName + "MotifSliderUI",
	155	"SplitPaneUI", motifPackageName + "MotifSplitPaneUI",
	156	"TabbedPaneUI", motifPackageName + "MotifTabbedPaneUI",
	157	"TextAreaUI", motifPackageName + "MotifTextAreaUI",
	158	"TextFieldUI", motifPackageName + "MotifTextFieldUI",
	159	"PasswordFieldUI", motifPackageName + "MotifPasswordFieldUI",
	160	"TextPaneUI", motifPackageName + "MotifTextPaneUI",
	161	"EditorPaneUI", motifPackageName + "MotifEditorPaneUI",
	162	"TreeUI", motifPackageName + "MotifTreeUI",
	163	"InternalFrameUI", motifPackageName + "MotifInternalFrameUI",
	164	"DesktopPaneUI", motifPackageName + "MotifDesktopPaneUI",
	165	"SeparatorUI", motifPackageName + "MotifSeparatorUI",
	166	"PopupMenuSeparatorUI", motifPackageName + "MotifPopupMenuSeparatorUI",
	167	"OptionPaneUI", motifPackageName + "MotifOptionPaneUI",
	168	"ComboBoxUI", motifPackageName + "MotifComboBoxUI",
	169	"DesktopIconUI", motifPackageName + "MotifDesktopIconUI"
	170	};
	171
	172	table.putDefaults(uiDefaults);
	173	}
	174
	175
	176	/**
	177	* Initialize the defaults table with the name of the ResourceBundle
	178	* used for getting localized defaults.
	179	*/
	180	private void initResourceBundle(UIDefaults table) {
	181	table.addResourceBundle( "com.sun.java.swing.plaf.motif.resources.motif" );
	182	}
	183
	184
	185	protected void initComponentDefaults(UIDefaults table)
	186	{
	187	super.initComponentDefaults(table);
	188
	189	initResourceBundle(table);
	190
	191	FontUIResource dialogPlain12 = new FontUIResource(Font.DIALOG,
	192	Font.PLAIN, 12);
	193	FontUIResource serifPlain12 = new FontUIResource(Font.SERIF,
	194	Font.PLAIN, 12);
	195	FontUIResource sansSerifPlain12 = new FontUIResource(Font.SANS_SERIF,
	196	Font.PLAIN, 12);
	197	FontUIResource monospacedPlain12 = new FontUIResource(Font.MONOSPACED,
	198	Font.PLAIN, 12);
	199	ColorUIResource red = new ColorUIResource(Color.red);
	200	ColorUIResource black = new ColorUIResource(Color.black);
	201	ColorUIResource white = new ColorUIResource(Color.white);
	202	ColorUIResource lightGray = new ColorUIResource(Color.lightGray);
	203	ColorUIResource controlDarker = new ColorUIResource(147, 151, 165); // slate blue
	204	ColorUIResource scrollBarTrack = controlDarker;
	205	ColorUIResource menuItemPressedBackground = new ColorUIResource(165,165,165);
	206	ColorUIResource menuItemPressedForeground = new ColorUIResource(0,0,0);
	207
	208
	209	Border loweredBevelBorder = new MotifBorders.BevelBorder(false,
	210	table.getColor("controlShadow"),
	211	table.getColor("controlLtHighlight"));
	212
	213	Border raisedBevelBorder = new MotifBorders.BevelBorder(true, table.getColor("controlShadow"),
	214	table.getColor("controlLtHighlight"));
	215
	216	Border marginBorder = new BasicBorders.MarginBorder();
	217
	218	Border focusBorder = new MotifBorders.FocusBorder(
	219	table.getColor("control"),
	220	table.getColor("activeCaptionBorder"));
	221
	222
	223	Border focusBevelBorder = new BorderUIResource.CompoundBorderUIResource(
	224	focusBorder,
	225	loweredBevelBorder);
	226
	227	Border comboBoxBorder = new BorderUIResource.CompoundBorderUIResource(
	228	focusBorder,
	229	raisedBevelBorder);
	230
	231
	232	Border buttonBorder = new BorderUIResource.CompoundBorderUIResource(
	233	new MotifBorders.ButtonBorder(
	234	table.getColor("Button.shadow"),
	235	table.getColor("Button.highlight"),
	236	table.getColor("Button.darkShadow"),
	237	table.getColor("activeCaptionBorder")),
	238	marginBorder);
	239
	240	Border toggleButtonBorder = new BorderUIResource.CompoundBorderUIResource(
	241	new MotifBorders.ToggleButtonBorder(
	242	table.getColor("ToggleButton.shadow"),
	243	table.getColor("ToggleButton.highlight"),
	244	table.getColor("ToggleButton.darkShadow"),
	245	table.getColor("activeCaptionBorder")), marginBorder);
	246
	247	Border textFieldBorder = new BorderUIResource.CompoundBorderUIResource(
	248	focusBevelBorder,
	249	marginBorder);
	250
	251	Border popupMenuBorder = new BorderUIResource.CompoundBorderUIResource(
	252	raisedBevelBorder,
	253	new MotifBorders.MotifPopupMenuBorder(
	254	table.getFont("PopupMenu.font"),
	255	table.getColor("PopupMenu.background"),
	256	table.getColor("PopupMenu.foreground"),
	257	table.getColor("controlShadow"),
	258	table.getColor("controlLtHighlight")
	259	));
	260
	261	Object menuItemCheckIcon = new UIDefaults.LazyValue() {
	262	public Object createValue(UIDefaults table) {
	263	return MotifIconFactory.getMenuItemCheckIcon();
	264	}
	265	};
	266
	267	Object menuItemArrowIcon = new UIDefaults.LazyValue() {
	268	public Object createValue(UIDefaults table) {
	269	return MotifIconFactory.getMenuItemArrowIcon();
	270	}
	271	};
	272
	273	Object menuArrowIcon = new UIDefaults.LazyValue() {
	274	public Object createValue(UIDefaults table) {
	275	return MotifIconFactory.getMenuArrowIcon();
	276	}
	277	};
	278
	279	Object checkBoxIcon = new UIDefaults.LazyValue() {
	280	public Object createValue(UIDefaults table) {
	281	return MotifIconFactory.getCheckBoxIcon();
	282	}
	283	};
	284
	285	Object radioButtonIcon = new UIDefaults.LazyValue() {
	286	public Object createValue(UIDefaults table) {
	287	return MotifIconFactory.getRadioButtonIcon();
	288	}
	289	};
	290
	291	Object unselectedTabBackground = new UIDefaults.LazyValue() {
	292	public Object createValue(UIDefaults table) {
	293	Color c = table.getColor("control");
	294	return new ColorUIResource(Math.max((int)(c.getRed()*.85),0),
	295	Math.max((int)(c.getGreen()*.85),0),
	296	Math.max((int)(c.getBlue()*.85),0));
	297	}
	298	};
	299
	300	Object unselectedTabForeground = new UIDefaults.LazyValue() {
	301	public Object createValue(UIDefaults table) {
	302	Color c = table.getColor("controlText");
	303	return new ColorUIResource(Math.max((int)(c.getRed()*.85),0),
	304	Math.max((int)(c.getGreen()*.85),0),
	305	Math.max((int)(c.getBlue()*.85),0));
	306	}
	307	};
	308
	309	Object unselectedTabShadow = new UIDefaults.LazyValue() {
	310	public Object createValue(UIDefaults table) {
	311	Color c = table.getColor("control");
	312	Color base = new Color(Math.max((int)(c.getRed()*.85),0),
	313	Math.max((int)(c.getGreen()*.85),0),
	314	Math.max((int)(c.getBlue()*.85),0));
	315	return new ColorUIResource(base.darker());
	316	}
	317	};
	318
	319	Object unselectedTabHighlight = new UIDefaults.LazyValue() {
	320	public Object createValue(UIDefaults table) {
	321	Color c = table.getColor("control");
	322	Color base = new Color(Math.max((int)(c.getRed()*.85),0),
	323	Math.max((int)(c.getGreen()*.85),0),
	324	Math.max((int)(c.getBlue()*.85),0));
	325	return new ColorUIResource(base.brighter());
	326	}
	327	};
	328
	329	// *** Text
	330
	331	Object fieldInputMap = new UIDefaults.LazyInputMap(new Object[] {
	332	"COPY", DefaultEditorKit.copyAction,
	333	"PASTE", DefaultEditorKit.pasteAction,
	334	"CUT", DefaultEditorKit.cutAction,
	335	"control INSERT", DefaultEditorKit.copyAction,
	336	"shift INSERT", DefaultEditorKit.pasteAction,
	337	"shift DELETE", DefaultEditorKit.cutAction,
	338	"control F", DefaultEditorKit.forwardAction,
	339	"control B", DefaultEditorKit.backwardAction,
	340	"control D", DefaultEditorKit.deleteNextCharAction,
	341	"BACK_SPACE", DefaultEditorKit.deletePrevCharAction,
	342	"shift BACK_SPACE", DefaultEditorKit.deletePrevCharAction,
	343	"ctrl H", DefaultEditorKit.deletePrevCharAction,
	344	"DELETE", DefaultEditorKit.deleteNextCharAction,
	345	"ctrl DELETE", DefaultEditorKit.deleteNextWordAction,
	346	"ctrl BACK_SPACE", DefaultEditorKit.deletePrevWordAction,
	347	"RIGHT", DefaultEditorKit.forwardAction,
	348	"LEFT", DefaultEditorKit.backwardAction,
	349	"KP_RIGHT", DefaultEditorKit.forwardAction,
	350	"KP_LEFT", DefaultEditorKit.backwardAction,
	351	"shift LEFT", DefaultEditorKit.selectionBackwardAction,
	352	"shift RIGHT", DefaultEditorKit.selectionForwardAction,
	353	"control LEFT", DefaultEditorKit.previousWordAction,
	354	"control RIGHT", DefaultEditorKit.nextWordAction,
	355	"control shift LEFT", DefaultEditorKit.selectionPreviousWordAction,
	356	"control shift RIGHT", DefaultEditorKit.selectionNextWordAction,
	357	"control SLASH", DefaultEditorKit.selectAllAction,
	358	"HOME", DefaultEditorKit.beginLineAction,
	359	"END", DefaultEditorKit.endLineAction,
	360	"shift HOME", DefaultEditorKit.selectionBeginLineAction,
	361	"shift END", DefaultEditorKit.selectionEndLineAction,
	362	"control BACK_SLASH", "unselect"/DefaultEditorKit.unselectAction/,
	363	"ENTER", JTextField.notifyAction,
	364	"control shift O", "toggle-componentOrientation"/DefaultEditorKit.toggleComponentOrientation/
	365	});
	366
	367	Object passwordInputMap = new UIDefaults.LazyInputMap(new Object[] {
	368	"COPY", DefaultEditorKit.copyAction,
	369	"PASTE", DefaultEditorKit.pasteAction,
	370	"CUT", DefaultEditorKit.cutAction,
	371	"control INSERT", DefaultEditorKit.copyAction,
	372	"shift INSERT", DefaultEditorKit.pasteAction,
	373	"shift DELETE", DefaultEditorKit.cutAction,
	374	"control F", DefaultEditorKit.forwardAction,
	375	"control B", DefaultEditorKit.backwardAction,
	376	"control D", DefaultEditorKit.deleteNextCharAction,
	377	"BACK_SPACE", DefaultEditorKit.deletePrevCharAction,
	378	"shift BACK_SPACE", DefaultEditorKit.deletePrevCharAction,
	379	"ctrl H", DefaultEditorKit.deletePrevCharAction,
	380	"DELETE", DefaultEditorKit.deleteNextCharAction,
	381	"RIGHT", DefaultEditorKit.forwardAction,
	382	"LEFT", DefaultEditorKit.backwardAction,
	383	"KP_RIGHT", DefaultEditorKit.forwardAction,
	384	"KP_LEFT", DefaultEditorKit.backwardAction,
	385	"shift LEFT", DefaultEditorKit.selectionBackwardAction,
	386	"shift RIGHT", DefaultEditorKit.selectionForwardAction,
	387	"control LEFT", DefaultEditorKit.beginLineAction,
	388	"control RIGHT", DefaultEditorKit.endLineAction,
	389	"control shift LEFT", DefaultEditorKit.selectionBeginLineAction,
	390	"control shift RIGHT", DefaultEditorKit.selectionEndLineAction,
	391	"control SLASH", DefaultEditorKit.selectAllAction,
	392	"HOME", DefaultEditorKit.beginLineAction,
	393	"END", DefaultEditorKit.endLineAction,
	394	"shift HOME", DefaultEditorKit.selectionBeginLineAction,
	395	"shift END", DefaultEditorKit.selectionEndLineAction,
	396	"control BACK_SLASH", "unselect"/DefaultEditorKit.unselectAction/,
	397	"ENTER", JTextField.notifyAction,
	398	"control shift O", "toggle-componentOrientation"/DefaultEditorKit.toggleComponentOrientation/
	399	});
	400
	401	Object multilineInputMap = new UIDefaults.LazyInputMap(new Object[] {
	402	"COPY", DefaultEditorKit.copyAction,
	403	"PASTE", DefaultEditorKit.pasteAction,
	404	"CUT", DefaultEditorKit.cutAction,
	405	"control INSERT", DefaultEditorKit.copyAction,
	406	"shift INSERT", DefaultEditorKit.pasteAction,
	407	"shift DELETE", DefaultEditorKit.cutAction,
	408	"control F", DefaultEditorKit.forwardAction,
	409	"control B", DefaultEditorKit.backwardAction,
	410	"control D", DefaultEditorKit.deleteNextCharAction,
	411	"BACK_SPACE", DefaultEditorKit.deletePrevCharAction,
	412	"shift BACK_SPACE", DefaultEditorKit.deletePrevCharAction,
	413	"ctrl H", DefaultEditorKit.deletePrevCharAction,
	414	"DELETE", DefaultEditorKit.deleteNextCharAction,
	415	"ctrl DELETE", DefaultEditorKit.deleteNextWordAction,
	416	"ctrl BACK_SPACE", DefaultEditorKit.deletePrevWordAction,
	417	"RIGHT", DefaultEditorKit.forwardAction,
	418	"LEFT", DefaultEditorKit.backwardAction,
	419	"KP_RIGHT", DefaultEditorKit.forwardAction,
	420	"KP_LEFT", DefaultEditorKit.backwardAction,
	421	"shift LEFT", DefaultEditorKit.selectionBackwardAction,
	422	"shift RIGHT", DefaultEditorKit.selectionForwardAction,
	423	"control LEFT", DefaultEditorKit.previousWordAction,
	424	"control RIGHT", DefaultEditorKit.nextWordAction,
	425	"control shift LEFT", DefaultEditorKit.selectionPreviousWordAction,
	426	"control shift RIGHT", DefaultEditorKit.selectionNextWordAction,
	427	"control SLASH", DefaultEditorKit.selectAllAction,
	428	"HOME", DefaultEditorKit.beginLineAction,
	429	"END", DefaultEditorKit.endLineAction,
	430	"shift HOME", DefaultEditorKit.selectionBeginLineAction,
	431	"shift END", DefaultEditorKit.selectionEndLineAction,
	432
	433	"control N", DefaultEditorKit.downAction,
	434	"control P", DefaultEditorKit.upAction,
	435	"UP", DefaultEditorKit.upAction,
	436	"DOWN", DefaultEditorKit.downAction,
	437	"PAGE_UP", DefaultEditorKit.pageUpAction,
	438	"PAGE_DOWN", DefaultEditorKit.pageDownAction,
	439	"shift PAGE_UP", "selection-page-up",
	440	"shift PAGE_DOWN", "selection-page-down",
	441	"ctrl shift PAGE_UP", "selection-page-left",
	442	"ctrl shift PAGE_DOWN", "selection-page-right",
	443	"shift UP", DefaultEditorKit.selectionUpAction,
	444	"shift DOWN", DefaultEditorKit.selectionDownAction,
	445	"ENTER", DefaultEditorKit.insertBreakAction,
	446	"TAB", DefaultEditorKit.insertTabAction,
	447	"control BACK_SLASH", "unselect"/DefaultEditorKit.unselectAction/,
	448	"control HOME", DefaultEditorKit.beginAction,
	449	"control END", DefaultEditorKit.endAction,
	450	"control shift HOME", DefaultEditorKit.selectionBeginAction,
	451	"control shift END", DefaultEditorKit.selectionEndAction,
	452	"control T", "next-link-action",
	453	"control shift T", "previous-link-action",
	454	"control SPACE", "activate-link-action",
	455	"control shift O", "toggle-componentOrientation"/DefaultEditorKit.toggleComponentOrientation/
	456	});
	457
	458	// *** Tree
	459
	460	Object treeOpenIcon = SwingUtilities2.makeIcon(getClass(),
	461	MotifLookAndFeel.class,
	462	"icons/TreeOpen.gif");
	463
	464	Object treeClosedIcon = SwingUtilities2.makeIcon(getClass(),
	465	MotifLookAndFeel.class,
	466	"icons/TreeClosed.gif");
	467
	468	Object treeLeafIcon = new UIDefaults.LazyValue() {
	469	public Object createValue(UIDefaults table) {
	470	return MotifTreeCellRenderer.loadLeafIcon();
	471	}
	472	};
	473
	474	Object treeExpandedIcon = new UIDefaults.LazyValue() {
	475	public Object createValue(UIDefaults table) {
	476	return MotifTreeUI.MotifExpandedIcon.createExpandedIcon();
	477	}
	478	};
	479
	480	Object treeCollapsedIcon = new UIDefaults.LazyValue() {
	481	public Object createValue(UIDefaults table) {
	482	return MotifTreeUI.MotifCollapsedIcon.createCollapsedIcon();
	483	}
	484	};
	485
	486	Border menuBarBorder = new MotifBorders.MenuBarBorder(
	487	table.getColor("MenuBar.shadow"),
	488	table.getColor("MenuBar.highlight"),
	489	table.getColor("MenuBar.darkShadow"),
	490	table.getColor("activeCaptionBorder"));
	491
	492
	493	Border menuMarginBorder = new BorderUIResource.CompoundBorderUIResource(
	494	loweredBevelBorder,
	495	marginBorder);
	496
	497
	498	Border focusCellHighlightBorder = new BorderUIResource.LineBorderUIResource(
	499	table.getColor("activeCaptionBorder"));
	500
	501	Object sliderFocusInsets = new InsetsUIResource( 0, 0, 0, 0 );
	502
	503	// ** for tabbedpane
	504
	505	Object tabbedPaneTabInsets = new InsetsUIResource(3, 4, 3, 4);
	506
	507	Object tabbedPaneTabPadInsets = new InsetsUIResource(3, 0, 1, 0);
	508
	509	Object tabbedPaneTabAreaInsets = new InsetsUIResource(4, 2, 0, 8);
	510
	511	Object tabbedPaneContentBorderInsets = new InsetsUIResource(2, 2, 2, 2);
	512
	513
	514	// ** for optionpane
	515
	516	Object optionPaneBorder = new BorderUIResource.EmptyBorderUIResource(10,0,0,0);
	517
	518	Object optionPaneButtonAreaBorder = new BorderUIResource.EmptyBorderUIResource(10,10,10,10);
	519
	520	Object optionPaneMessageAreaBorder = new BorderUIResource.EmptyBorderUIResource(10,10,12,10);
	521
	522
	523	Object[] defaults = {
	524
	525	"Desktop.background", table.get("desktop"),
	526	"Desktop.ancestorInputMap",
	527	new UIDefaults.LazyInputMap(new Object[] {
	528	"ctrl F5", "restore",
	529	"ctrl F4", "close",
	530	"ctrl F7", "move",
	531	"ctrl F8", "resize",
	532	"RIGHT", "right",
	533	"KP_RIGHT", "right",
	534	"shift RIGHT", "shrinkRight",
	535	"shift KP_RIGHT", "shrinkRight",
	536	"LEFT", "left",
	537	"KP_LEFT", "left",
	538	"shift LEFT", "shrinkLeft",
	539	"shift KP_LEFT", "shrinkLeft",
	540	"UP", "up",
	541	"KP_UP", "up",
	542	"shift UP", "shrinkUp",
	543	"shift KP_UP", "shrinkUp",
	544	"DOWN", "down",
	545	"KP_DOWN", "down",
	546	"shift DOWN", "shrinkDown",
	547	"shift KP_DOWN", "shrinkDown",
	548	"ESCAPE", "escape",
	549	"ctrl F9", "minimize",
	550	"ctrl F10", "maximize",
	551	"ctrl F6", "selectNextFrame",
	552	"ctrl TAB", "selectNextFrame",
	553	"ctrl alt F6", "selectNextFrame",
	554	"shift ctrl alt F6", "selectPreviousFrame",
	555	"ctrl F12", "navigateNext",
	556	"shift ctrl F12", "navigatePrevious"
	557	}),
	558
	559	"Panel.background", table.get("control"),
	560	"Panel.foreground", table.get("textText"),
	561	"Panel.font", dialogPlain12,
	562
	563	"ProgressBar.font", dialogPlain12,
	564	"ProgressBar.foreground", controlDarker,
	565	"ProgressBar.background", table.get("control"),
	566	"ProgressBar.selectionForeground", table.get("control"),
	567	"ProgressBar.selectionBackground", table.get("controlText"),
	568	"ProgressBar.border", loweredBevelBorder,
	569	"ProgressBar.cellLength", new Integer(6),
	570	"ProgressBar.cellSpacing", Integer.valueOf(0),
	571
	572	// Buttons
	573	"Button.margin", new InsetsUIResource(2, 4, 2, 4),
	574	"Button.border", buttonBorder,
	575	"Button.background", table.get("control"),
	576	"Button.foreground", table.get("controlText"),
	577	"Button.select", table.get("controlLightShadow"),
	578	"Button.font", dialogPlain12,
	579	"Button.focusInputMap", new UIDefaults.LazyInputMap(new Object[] {
	580	"SPACE", "pressed",
	581	"released SPACE", "released"
	582	}),
	583
	584	"CheckBox.textIconGap", new Integer(8),
	585	"CheckBox.margin", new InsetsUIResource(4, 2, 4, 2),
	586	"CheckBox.icon", checkBoxIcon,
	587	"CheckBox.focus", table.get("activeCaptionBorder"),
	588	"CheckBox.focusInputMap",
	589	new UIDefaults.LazyInputMap(new Object[] {
	590	"SPACE", "pressed",
	591	"released SPACE", "released"
	592	}),
	593
	594	"RadioButton.margin", new InsetsUIResource(4, 2, 4, 2),
	595	"RadioButton.textIconGap", new Integer(8),
	596	"RadioButton.background", table.get("control"),
	597	"RadioButton.foreground", table.get("controlText"),
	598	"RadioButton.icon", radioButtonIcon,
	599	"RadioButton.focus", table.get("activeCaptionBorder"),
	600	"RadioButton.icon", radioButtonIcon,
	601	"RadioButton.focusInputMap",
	602	new UIDefaults.LazyInputMap(new Object[] {
	603	"SPACE", "pressed",
	604	"released SPACE", "released"
	605	}),
	606
	607	"ToggleButton.border", toggleButtonBorder,
	608	"ToggleButton.background", table.get("control"),
	609	"ToggleButton.foreground", table.get("controlText"),
	610	"ToggleButton.focus", table.get("controlText"),
	611	"ToggleButton.select", table.get("controlLightShadow"),
	612	"ToggleButton.focusInputMap",
	613	new UIDefaults.LazyInputMap(new Object[] {
	614	"SPACE", "pressed",
	615	"released SPACE", "released"
	616	}),
	617
	618	// Menus
	619	"Menu.border", menuMarginBorder,
	620	"Menu.font", dialogPlain12,
	621	"Menu.acceleratorFont", dialogPlain12,
	622	"Menu.acceleratorSelectionForeground", menuItemPressedForeground,
	623	"Menu.foreground", table.get("menuText"),
	624	"Menu.background", table.get("menu"),
	625	"Menu.selectionForeground", menuItemPressedForeground,
	626	"Menu.selectionBackground", menuItemPressedBackground,
	627	"Menu.checkIcon", menuItemCheckIcon,
	628	"Menu.arrowIcon", menuArrowIcon,
	629	"Menu.menuPopupOffsetX", new Integer(0),
	630	"Menu.menuPopupOffsetY", new Integer(0),
	631	"Menu.submenuPopupOffsetX", new Integer(-2),
	632	"Menu.submenuPopupOffsetY", new Integer(3),
	633	"Menu.shortcutKeys", new int[] {KeyEvent.ALT_MASK,
	634	KeyEvent.META_MASK},
	635	"Menu.cancelMode", "hideMenuTree",
	636
	637	"MenuBar.border", menuBarBorder,
	638	"MenuBar.background", table.get("menu"),
	639	"MenuBar.foreground", table.get("menuText"),
	640	"MenuBar.font", dialogPlain12,
	641	"MenuBar.windowBindings", new Object[] {
	642	"F10", "takeFocus" },
	643
	644	"MenuItem.border", menuMarginBorder,
	645	"MenuItem.font", dialogPlain12,
	646	"MenuItem.acceleratorFont", dialogPlain12,
	647	"MenuItem.acceleratorSelectionForeground", menuItemPressedForeground,
	648	"MenuItem.foreground", table.get("menuText"),
	649	"MenuItem.background", table.get("menu"),
	650	"MenuItem.selectionForeground", menuItemPressedForeground,
	651	"MenuItem.selectionBackground", menuItemPressedBackground,
	652	"MenuItem.checkIcon", menuItemCheckIcon,
	653	"MenuItem.arrowIcon", menuItemArrowIcon,
	654
	655	"RadioButtonMenuItem.border", menuMarginBorder,
	656	"RadioButtonMenuItem.font", dialogPlain12,
	657	"RadioButtonMenuItem.acceleratorFont", dialogPlain12,
	658	"RadioButtonMenuItem.acceleratorSelectionForeground", menuItemPressedForeground,
	659	"RadioButtonMenuItem.foreground", table.get("menuText"),
	660	"RadioButtonMenuItem.background", table.get("menu"),
	661	"RadioButtonMenuItem.selectionForeground", menuItemPressedForeground,
	662	"RadioButtonMenuItem.selectionBackground", menuItemPressedBackground,
	663	"RadioButtonMenuItem.checkIcon", radioButtonIcon,
	664	"RadioButtonMenuItem.arrowIcon", menuItemArrowIcon,
	665
	666	"CheckBoxMenuItem.border", menuMarginBorder,
	667	"CheckBoxMenuItem.font", dialogPlain12,
	668	"CheckBoxMenuItem.acceleratorFont", dialogPlain12,
	669	"CheckBoxMenuItem.acceleratorSelectionForeground", menuItemPressedForeground,
	670	"CheckBoxMenuItem.foreground", table.get("menuText"),
	671	"CheckBoxMenuItem.background", table.get("menu"),
	672	"CheckBoxMenuItem.selectionForeground", menuItemPressedForeground,
	673	"CheckBoxMenuItem.selectionBackground", menuItemPressedBackground,
	674	"CheckBoxMenuItem.checkIcon", checkBoxIcon,
	675	"CheckBoxMenuItem.arrowIcon", menuItemArrowIcon,
	676
	677	"PopupMenu.background", table.get("menu"),
	678	"PopupMenu.border", popupMenuBorder,
	679	"PopupMenu.foreground", table.get("menuText"),
	680	"PopupMenu.font", dialogPlain12,
	681	"PopupMenu.consumeEventOnClose", Boolean.TRUE,
	682
	683	"Label.font", dialogPlain12,
	684	"Label.background", table.get("control"),
	685	"Label.foreground", table.get("controlText"),
	686
	687	"Separator.shadow", table.get("controlShadow"), // DEPRECATED - DO NOT USE!
	688	"Separator.highlight", table.get("controlLtHighlight"), // DEPRECATED - DO NOT USE!
	689
	690	"Separator.background", table.get("controlLtHighlight"),
	691	"Separator.foreground", table.get("controlShadow"),
	692
	693	"List.focusCellHighlightBorder", focusCellHighlightBorder,
	694	"List.focusInputMap",
	695	new UIDefaults.LazyInputMap(new Object[] {
	696	"COPY", "copy",
	697	"PASTE", "paste",
	698	"CUT", "cut",
	699	"control INSERT", "copy",
	700	"shift INSERT", "paste",
	701	"shift DELETE", "cut",
	702	"UP", "selectPreviousRow",
	703	"KP_UP", "selectPreviousRow",
	704	"shift UP", "selectPreviousRowExtendSelection",
	705	"shift KP_UP", "selectPreviousRowExtendSelection",
	706	"ctrl shift UP", "selectPreviousRowExtendSelection",
	707	"ctrl shift KP_UP", "selectPreviousRowExtendSelection",
	708	"ctrl UP", "selectPreviousRowChangeLead",
	709	"ctrl KP_UP", "selectPreviousRowChangeLead",
	710	"DOWN", "selectNextRow",
	711	"KP_DOWN", "selectNextRow",
	712	"shift DOWN", "selectNextRowExtendSelection",
	713	"shift KP_DOWN", "selectNextRowExtendSelection",
	714	"ctrl shift DOWN", "selectNextRowExtendSelection",
	715	"ctrl shift KP_DOWN", "selectNextRowExtendSelection",
	716	"ctrl DOWN", "selectNextRowChangeLead",
	717	"ctrl KP_DOWN", "selectNextRowChangeLead",
	718	"LEFT", "selectPreviousColumn",
	719	"KP_LEFT", "selectPreviousColumn",
	720	"shift LEFT", "selectPreviousColumnExtendSelection",
	721	"shift KP_LEFT", "selectPreviousColumnExtendSelection",
	722	"ctrl shift LEFT", "selectPreviousColumnExtendSelection",
	723	"ctrl shift KP_LEFT", "selectPreviousColumnExtendSelection",
	724	"ctrl LEFT", "selectPreviousColumnChangeLead",
	725	"ctrl KP_LEFT", "selectPreviousColumnChangeLead",
	726	"RIGHT", "selectNextColumn",
	727	"KP_RIGHT", "selectNextColumn",
	728	"shift RIGHT", "selectNextColumnExtendSelection",
	729	"shift KP_RIGHT", "selectNextColumnExtendSelection",
	730	"ctrl shift RIGHT", "selectNextColumnExtendSelection",
	731	"ctrl shift KP_RIGHT", "selectNextColumnExtendSelection",
	732	"ctrl RIGHT", "selectNextColumnChangeLead",
	733	"ctrl KP_RIGHT", "selectNextColumnChangeLead",
	734	"HOME", "selectFirstRow",
	735	"shift HOME", "selectFirstRowExtendSelection",
	736	"ctrl shift HOME", "selectFirstRowExtendSelection",
	737	"ctrl HOME", "selectFirstRowChangeLead",
	738	"END", "selectLastRow",
	739	"shift END", "selectLastRowExtendSelection",
	740	"ctrl shift END", "selectLastRowExtendSelection",
	741	"ctrl END", "selectLastRowChangeLead",
	742	"PAGE_UP", "scrollUp",
	743	"shift PAGE_UP", "scrollUpExtendSelection",
	744	"ctrl shift PAGE_UP", "scrollUpExtendSelection",
	745	"ctrl PAGE_UP", "scrollUpChangeLead",
	746	"PAGE_DOWN", "scrollDown",
	747	"shift PAGE_DOWN", "scrollDownExtendSelection",
	748	"ctrl shift PAGE_DOWN", "scrollDownExtendSelection",
	749	"ctrl PAGE_DOWN", "scrollDownChangeLead",
	750	"ctrl A", "selectAll",
	751	"ctrl SLASH", "selectAll",
	752	"ctrl BACK_SLASH", "clearSelection",
	753	"SPACE", "addToSelection",
	754	"ctrl SPACE", "toggleAndAnchor",
	755	"shift SPACE", "extendTo",
	756	"ctrl shift SPACE", "moveSelectionTo"
	757	}),
	758
	759	"DesktopIcon.icon", SwingUtilities2.makeIcon(getClass(),
	760	MotifLookAndFeel.class,
	761	"icons/DesktopIcon.gif"),
	762	"DesktopIcon.border", null,
	763	// These are a little odd, MotifInternalFrameUI isntalls em!
	764	"DesktopIcon.windowBindings", new Object[]
	765	{ "ESCAPE", "hideSystemMenu" },
	766
	767	"InternalFrame.activeTitleBackground", table.get("activeCaptionBorder"),
	768	"InternalFrame.inactiveTitleBackground", table.get("inactiveCaptionBorder"),
	769	"InternalFrame.windowBindings", new Object[] {
	770	"shift ESCAPE", "showSystemMenu",
	771	"ctrl SPACE", "showSystemMenu",
	772	"ESCAPE", "hideSystemMenu"
	773	},
	774
	775	"ScrollBar.background", scrollBarTrack,
	776	"ScrollBar.foreground", table.get("control"),
	777	"ScrollBar.track", scrollBarTrack,
	778	"ScrollBar.trackHighlight", table.get("controlDkShadow"),
	779	"ScrollBar.thumb", table.get("control"),
	780	"ScrollBar.thumbHighlight", table.get("controlHighlight"),
	781	"ScrollBar.thumbDarkShadow", table.get("controlDkShadow"),
	782	"ScrollBar.thumbShadow", table.get("controlShadow"),
	783	"ScrollBar.border", loweredBevelBorder,
	784	"ScrollBar.allowsAbsolutePositioning", Boolean.TRUE,
	785	"ScrollBar.ancestorInputMap",
	786	new UIDefaults.LazyInputMap(new Object[] {
	787	"RIGHT", "positiveUnitIncrement",
	788	"KP_RIGHT", "positiveUnitIncrement",
	789	"DOWN", "positiveUnitIncrement",
	790	"KP_DOWN", "positiveUnitIncrement",
	791	"PAGE_DOWN", "positiveBlockIncrement",
	792	"ctrl PAGE_DOWN", "positiveBlockIncrement",
	793	"LEFT", "negativeUnitIncrement",
	794	"KP_LEFT", "negativeUnitIncrement",
	795	"UP", "negativeUnitIncrement",
	796	"KP_UP", "negativeUnitIncrement",
	797	"PAGE_UP", "negativeBlockIncrement",
	798	"ctrl PAGE_UP", "negativeBlockIncrement",
	799	"HOME", "minScroll",
	800	"END", "maxScroll"
	801	}),
	802
	803	"ScrollPane.font", dialogPlain12,
	804	"ScrollPane.background", table.get("control"),
	805	"ScrollPane.foreground", table.get("controlText"),
	806	"ScrollPane.border", null,
	807	"ScrollPane.viewportBorder", loweredBevelBorder,
	808	"ScrollPane.ancestorInputMap",
	809	new UIDefaults.LazyInputMap(new Object[] {
	810	"RIGHT", "unitScrollRight",
	811	"KP_RIGHT", "unitScrollRight",
	812	"DOWN", "unitScrollDown",
	813	"KP_DOWN", "unitScrollDown",
	814	"LEFT", "unitScrollLeft",
	815	"KP_LEFT", "unitScrollLeft",
	816	"UP", "unitScrollUp",
	817	"KP_UP", "unitScrollUp",
	818	"PAGE_UP", "scrollUp",
	819	"PAGE_DOWN", "scrollDown",
	820	"ctrl PAGE_UP", "scrollLeft",
	821	"ctrl PAGE_DOWN", "scrollRight",
	822	"ctrl HOME", "scrollHome",
	823	"ctrl END", "scrollEnd"
	824	}),
	825
	826	"Slider.font", dialogPlain12,
	827	"Slider.border", focusBevelBorder,
	828	"Slider.foreground", table.get("control"),
	829	"Slider.background", controlDarker,
	830	"Slider.highlight", table.get("controlHighlight"),
	831	"Slider.shadow", table.get("controlShadow"),
	832	"Slider.focus", table.get("controlDkShadow"),
	833	"Slider.focusInsets", sliderFocusInsets,
	834	"Slider.focusInputMap", new UIDefaults.LazyInputMap(new Object[] {
	835	"RIGHT", "positiveUnitIncrement",
	836	"KP_RIGHT", "positiveUnitIncrement",
	837	"DOWN", "negativeUnitIncrement",
	838	"KP_DOWN", "negativeUnitIncrement",
	839	"ctrl PAGE_DOWN", "negativeBlockIncrement",
	840	"LEFT", "negativeUnitIncrement",
	841	"KP_LEFT", "negativeUnitIncrement",
	842	"UP", "positiveUnitIncrement",
	843	"KP_UP", "positiveUnitIncrement",
	844	"ctrl PAGE_UP", "positiveBlockIncrement",
	845	"HOME", "minScroll",
	846	"END", "maxScroll"
	847	}),
	848
	849	// Spinner
	850	"Spinner.ancestorInputMap",
	851	new UIDefaults.LazyInputMap(new Object[] {
	852	"UP", "increment",
	853	"KP_UP", "increment",
	854	"DOWN", "decrement",
	855	"KP_DOWN", "decrement",
	856	}),
	857	"Spinner.border", textFieldBorder,
	858
	859	"SplitPane.background", table.get("control"),
	860	"SplitPane.highlight", table.get("controlHighlight"),
	861	"SplitPane.shadow", table.get("controlShadow"),
	862	"SplitPane.dividerSize", Integer.valueOf(20),
	863	"SplitPane.activeThumb", table.get("activeCaptionBorder"),
	864	"SplitPane.ancestorInputMap",
	865	new UIDefaults.LazyInputMap(new Object[] {
	866	"UP", "negativeIncrement",
	867	"DOWN", "positiveIncrement",
	868	"LEFT", "negativeIncrement",
	869	"RIGHT", "positiveIncrement",
	870	"KP_UP", "negativeIncrement",
	871	"KP_DOWN", "positiveIncrement",
	872	"KP_LEFT", "negativeIncrement",
	873	"KP_RIGHT", "positiveIncrement",
	874	"HOME", "selectMin",
	875	"END", "selectMax",
	876	"F8", "startResize",
	877	"F6", "toggleFocus",
	878	"ctrl TAB", "focusOutForward",
	879	"ctrl shift TAB", "focusOutBackward"
	880	}),
	881
	882	"TabbedPane.font", dialogPlain12,
	883	"TabbedPane.background", table.get("control"),
	884	"TabbedPane.foreground", table.get("controlText"),
	885	"TabbedPane.light", table.get("controlHighlight"),
	886	"TabbedPane.highlight", table.get("controlLtHighlight"),
	887	"TabbedPane.shadow", table.get("controlShadow"),
	888	"TabbedPane.darkShadow", table.get("controlShadow"),
	889	"TabbedPane.unselectedTabBackground", unselectedTabBackground,
	890	"TabbedPane.unselectedTabForeground", unselectedTabForeground,
	891	"TabbedPane.unselectedTabHighlight", unselectedTabHighlight,
	892	"TabbedPane.unselectedTabShadow", unselectedTabShadow,
	893	"TabbedPane.focus", table.get("activeCaptionBorder"),
	894	"TabbedPane.tabInsets", tabbedPaneTabInsets,
	895	"TabbedPane.selectedTabPadInsets", tabbedPaneTabPadInsets,
	896	"TabbedPane.tabAreaInsets", tabbedPaneTabAreaInsets,
	897	"TabbedPane.contentBorderInsets", tabbedPaneContentBorderInsets,
	898	"TabbedPane.focusInputMap",
	899	new UIDefaults.LazyInputMap(new Object[] {
	900	"RIGHT", "navigateRight",
	901	"KP_RIGHT", "navigateRight",
	902	"LEFT", "navigateLeft",
	903	"KP_LEFT", "navigateLeft",
	904	"UP", "navigateUp",
	905	"KP_UP", "navigateUp",
	906	"DOWN", "navigateDown",
	907	"KP_DOWN", "navigateDown",
	908	"ctrl DOWN", "requestFocusForVisibleComponent",
	909	"ctrl KP_DOWN", "requestFocusForVisibleComponent",
	910	}),
	911	"TabbedPane.ancestorInputMap",
	912	new UIDefaults.LazyInputMap(new Object[] {
	913	"ctrl PAGE_DOWN", "navigatePageDown",
	914	"ctrl PAGE_UP", "navigatePageUp",
	915	"ctrl UP", "requestFocus",
	916	"ctrl KP_UP", "requestFocus",
	917	}),
	918
	919
	920	"Tree.background", controlDarker, // default: dark slate blue
	921	"Tree.hash", table.get("controlDkShadow"), // default: black
	922	"Tree.iconShadow", table.get("controlShadow"),
	923	"Tree.iconHighlight", table.get("controlHighlight"),
	924	"Tree.iconBackground", table.get("control"),
	925	"Tree.iconForeground", table.get("controlShadow"), // default: black
	926	"Tree.textBackground", controlDarker, // default: dark slate blue
	927	"Tree.textForeground", table.get("textText"), // default: black
	928	"Tree.selectionBackground", table.get("text"), // default: white
	929	"Tree.selectionForeground", table.get("textText"), // default: black
	930	"Tree.selectionBorderColor", table.get("activeCaptionBorder"), // default: maroon
	931	"Tree.openIcon", treeOpenIcon,
	932	"Tree.closedIcon", treeClosedIcon,
	933	"Tree.leafIcon", treeLeafIcon,
	934	"Tree.expandedIcon", treeExpandedIcon,
	935	"Tree.collapsedIcon", treeCollapsedIcon,
	936	"Tree.editorBorder", focusBorder,
	937	"Tree.editorBorderSelectionColor", table.get("activeCaptionBorder"),
	938	"Tree.rowHeight", new Integer(18),
	939	"Tree.drawsFocusBorderAroundIcon", Boolean.TRUE,
	940	"Tree.focusInputMap", new UIDefaults.LazyInputMap(new Object[] {
	941	"COPY", "copy",
	942	"PASTE", "paste",
	943	"CUT", "cut",
	944	"control INSERT", "copy",
	945	"shift INSERT", "paste",
	946	"shift DELETE", "cut",
	947	"UP", "selectPrevious",
	948	"KP_UP", "selectPrevious",
	949	"shift UP", "selectPreviousExtendSelection",
	950	"shift KP_UP", "selectPreviousExtendSelection",
	951	"ctrl shift UP", "selectPreviousExtendSelection",
	952	"ctrl shift KP_UP", "selectPreviousExtendSelection",
	953	"ctrl UP", "selectPreviousChangeLead",
	954	"ctrl KP_UP", "selectPreviousChangeLead",
	955	"DOWN", "selectNext",
	956	"KP_DOWN", "selectNext",
	957	"shift DOWN", "selectNextExtendSelection",
	958	"shift KP_DOWN", "selectNextExtendSelection",
	959	"ctrl shift DOWN", "selectNextExtendSelection",
	960	"ctrl shift KP_DOWN", "selectNextExtendSelection",
	961	"ctrl DOWN", "selectNextChangeLead",
	962	"ctrl KP_DOWN", "selectNextChangeLead",
	963	"RIGHT", "selectChild",
	964	"KP_RIGHT", "selectChild",
	965	"LEFT", "selectParent",
	966	"KP_LEFT", "selectParent",
	967	"PAGE_UP", "scrollUpChangeSelection",
	968	"shift PAGE_UP", "scrollUpExtendSelection",
	969	"ctrl shift PAGE_UP", "scrollUpExtendSelection",
	970	"ctrl PAGE_UP", "scrollUpChangeLead",
	971	"PAGE_DOWN", "scrollDownChangeSelection",
	972	"shift PAGE_DOWN", "scrollDownExtendSelection",
	973	"ctrl shift PAGE_DOWN", "scrollDownExtendSelection",
	974	"ctrl PAGE_DOWN", "scrollDownChangeLead",
	975	"HOME", "selectFirst",
	976	"shift HOME", "selectFirstExtendSelection",
	977	"ctrl shift HOME", "selectFirstExtendSelection",
	978	"ctrl HOME", "selectFirstChangeLead",
	979	"END", "selectLast",
	980	"shift END", "selectLastExtendSelection",
	981	"ctrl shift END", "selectLastExtendSelection",
	982	"ctrl END", "selectLastChangeLead",
	983	"F2", "startEditing",
	984	"ctrl A", "selectAll",
	985	"ctrl SLASH", "selectAll",
	986	"ctrl BACK_SLASH", "clearSelection",
	987	"ctrl LEFT", "scrollLeft",
	988	"ctrl KP_LEFT", "scrollLeft",
	989	"ctrl RIGHT", "scrollRight",
	990	"ctrl KP_RIGHT", "scrollRight",
	991	"SPACE", "addToSelection",
	992	"ctrl SPACE", "toggleAndAnchor",
	993	"shift SPACE", "extendTo",
	994	"ctrl shift SPACE", "moveSelectionTo"
	995	}),
	996	"Tree.ancestorInputMap", new UIDefaults.LazyInputMap(new Object[] {
	997	"ESCAPE", "cancel" }),
	998
	999	"Table.focusCellHighlightBorder", focusCellHighlightBorder,
	1000	"Table.scrollPaneBorder", null,
	1001	"Table.dropLineShortColor", table.get("activeCaptionBorder"),
	1002
	1003	// "Table.background", white, // cell background color
	1004	"Table.ancestorInputMap",
	1005	new UIDefaults.LazyInputMap(new Object[] {
	1006	"COPY", "copy",
	1007	"PASTE", "paste",
	1008	"CUT", "cut",
	1009	"control INSERT", "copy",
	1010	"shift INSERT", "paste",
	1011	"shift DELETE", "cut",
	1012	"RIGHT", "selectNextColumn",
	1013	"KP_RIGHT", "selectNextColumn",
	1014	"shift RIGHT", "selectNextColumnExtendSelection",
	1015	"shift KP_RIGHT", "selectNextColumnExtendSelection",
	1016	"ctrl shift RIGHT", "selectNextColumnExtendSelection",
	1017	"ctrl shift KP_RIGHT", "selectNextColumnExtendSelection",
	1018	"ctrl RIGHT", "selectNextColumnChangeLead",
	1019	"ctrl KP_RIGHT", "selectNextColumnChangeLead",
	1020	"LEFT", "selectPreviousColumn",
	1021	"KP_LEFT", "selectPreviousColumn",
	1022	"shift LEFT", "selectPreviousColumnExtendSelection",
	1023	"shift KP_LEFT", "selectPreviousColumnExtendSelection",
	1024	"ctrl shift LEFT", "selectPreviousColumnExtendSelection",
	1025	"ctrl shift KP_LEFT", "selectPreviousColumnExtendSelection",
	1026	"ctrl LEFT", "selectPreviousColumnChangeLead",
	1027	"ctrl KP_LEFT", "selectPreviousColumnChangeLead",
	1028	"DOWN", "selectNextRow",
	1029	"KP_DOWN", "selectNextRow",
	1030	"shift DOWN", "selectNextRowExtendSelection",
	1031	"shift KP_DOWN", "selectNextRowExtendSelection",
	1032	"ctrl shift DOWN", "selectNextRowExtendSelection",
	1033	"ctrl shift KP_DOWN", "selectNextRowExtendSelection",
	1034	"ctrl DOWN", "selectNextRowChangeLead",
	1035	"ctrl KP_DOWN", "selectNextRowChangeLead",
	1036	"UP", "selectPreviousRow",
	1037	"KP_UP", "selectPreviousRow",
	1038	"shift UP", "selectPreviousRowExtendSelection",
	1039	"shift KP_UP", "selectPreviousRowExtendSelection",
	1040	"ctrl shift UP", "selectPreviousRowExtendSelection",
	1041	"ctrl shift KP_UP", "selectPreviousRowExtendSelection",
	1042	"ctrl UP", "selectPreviousRowChangeLead",
	1043	"ctrl KP_UP", "selectPreviousRowChangeLead",
	1044	"HOME", "selectFirstColumn",
	1045	"shift HOME", "selectFirstColumnExtendSelection",
	1046	"ctrl shift HOME", "selectFirstRowExtendSelection",
	1047	"ctrl HOME", "selectFirstRow",
	1048	"END", "selectLastColumn",
	1049	"shift END", "selectLastColumnExtendSelection",
	1050	"ctrl shift END", "selectLastRowExtendSelection",
	1051	"ctrl END", "selectLastRow",
	1052	"PAGE_UP", "scrollUpChangeSelection",
	1053	"shift PAGE_UP", "scrollUpExtendSelection",
	1054	"ctrl shift PAGE_UP", "scrollLeftExtendSelection",
	1055	"ctrl PAGE_UP", "scrollLeftChangeSelection",
	1056	"PAGE_DOWN", "scrollDownChangeSelection",
	1057	"shift PAGE_DOWN", "scrollDownExtendSelection",
	1058	"ctrl shift PAGE_DOWN", "scrollRightExtendSelection",
	1059	"ctrl PAGE_DOWN", "scrollRightChangeSelection",
	1060	"TAB", "selectNextColumnCell",
	1061	"shift TAB", "selectPreviousColumnCell",
	1062	"ENTER", "selectNextRowCell",
	1063	"shift ENTER", "selectPreviousRowCell",
	1064	"ctrl A", "selectAll",
	1065	"ctrl SLASH", "selectAll",
	1066	"ctrl BACK_SLASH", "clearSelection",
	1067	"ESCAPE", "cancel",
	1068	"F2", "startEditing",
	1069	"SPACE", "addToSelection",
	1070	"ctrl SPACE", "toggleAndAnchor",
	1071	"shift SPACE", "extendTo",
	1072	"ctrl shift SPACE", "moveSelectionTo",
	1073	"F8", "focusHeader"
	1074	}),
	1075
	1076
	1077	"FormattedTextField.focusInputMap",
	1078	new UIDefaults.LazyInputMap(new Object[] {
	1079	"ctrl C", DefaultEditorKit.copyAction,
	1080	"ctrl V", DefaultEditorKit.pasteAction,
	1081	"ctrl X", DefaultEditorKit.cutAction,
	1082	"COPY", DefaultEditorKit.copyAction,
	1083	"PASTE", DefaultEditorKit.pasteAction,
	1084	"CUT", DefaultEditorKit.cutAction,
	1085	"shift LEFT", DefaultEditorKit.selectionBackwardAction,
	1086	"shift KP_LEFT", DefaultEditorKit.selectionBackwardAction,
	1087	"shift RIGHT", DefaultEditorKit.selectionForwardAction,
	1088	"shift KP_RIGHT", DefaultEditorKit.selectionForwardAction,
	1089	"ctrl LEFT", DefaultEditorKit.previousWordAction,
	1090	"ctrl KP_LEFT", DefaultEditorKit.previousWordAction,
	1091	"ctrl RIGHT", DefaultEditorKit.nextWordAction,
	1092	"ctrl KP_RIGHT", DefaultEditorKit.nextWordAction,
	1093	"ctrl shift LEFT", DefaultEditorKit.selectionPreviousWordAction,
	1094	"ctrl shift KP_LEFT", DefaultEditorKit.selectionPreviousWordAction,
	1095	"ctrl shift RIGHT", DefaultEditorKit.selectionNextWordAction,
	1096	"ctrl shift KP_RIGHT", DefaultEditorKit.selectionNextWordAction,
	1097	"ctrl A", DefaultEditorKit.selectAllAction,
	1098	"HOME", DefaultEditorKit.beginLineAction,
	1099	"END", DefaultEditorKit.endLineAction,
	1100	"shift HOME", DefaultEditorKit.selectionBeginLineAction,
	1101	"shift END", DefaultEditorKit.selectionEndLineAction,
	1102	"BACK_SPACE", DefaultEditorKit.deletePrevCharAction,
	1103	"shift BACK_SPACE", DefaultEditorKit.deletePrevCharAction,
	1104	"ctrl H", DefaultEditorKit.deletePrevCharAction,
	1105	"DELETE", DefaultEditorKit.deleteNextCharAction,
	1106	"ctrl DELETE", DefaultEditorKit.deleteNextWordAction,
	1107	"ctrl BACK_SPACE", DefaultEditorKit.deletePrevWordAction,
	1108	"RIGHT", DefaultEditorKit.forwardAction,
	1109	"LEFT", DefaultEditorKit.backwardAction,
	1110	"KP_RIGHT", DefaultEditorKit.forwardAction,
	1111	"KP_LEFT", DefaultEditorKit.backwardAction,
	1112	"ENTER", JTextField.notifyAction,
	1113	"ctrl BACK_SLASH", "unselect",
	1114	"control shift O", "toggle-componentOrientation",
	1115	"ESCAPE", "reset-field-edit",
	1116	"UP", "increment",
	1117	"KP_UP", "increment",
	1118	"DOWN", "decrement",
	1119	"KP_DOWN", "decrement",
	1120	}),
	1121
	1122	// ToolBar.
	1123	"ToolBar.ancestorInputMap",
	1124	new UIDefaults.LazyInputMap(new Object[] {
	1125	"UP", "navigateUp",
	1126	"KP_UP", "navigateUp",
	1127	"DOWN", "navigateDown",
	1128	"KP_DOWN", "navigateDown",
	1129	"LEFT", "navigateLeft",
	1130	"KP_LEFT", "navigateLeft",
	1131	"RIGHT", "navigateRight",
	1132	"KP_RIGHT", "navigateRight"
	1133	}),
	1134
	1135
	1136
	1137	"ComboBox.control", table.get("control"),
	1138	"ComboBox.controlForeground", black,
	1139	"ComboBox.background", table.get("window"),
	1140	"ComboBox.foreground", black,
	1141	"ComboBox.border", comboBoxBorder,
	1142	"ComboBox.selectionBackground", black,
	1143	"ComboBox.selectionForeground", table.get("text"),
	1144	"ComboBox.disabledBackground", table.get("control"),
	1145	"ComboBox.disabledForeground", table.get("textInactiveText"),
	1146	"ComboBox.font", dialogPlain12,
	1147	"ComboBox.ancestorInputMap", new UIDefaults.LazyInputMap(new Object[] {
	1148	"ESCAPE", "hidePopup",
	1149	"PAGE_UP", "pageUpPassThrough",
	1150	"PAGE_DOWN", "pageDownPassThrough",
	1151	"HOME", "homePassThrough",
	1152	"END", "endPassThrough",
	1153	"DOWN", "selectNext",
	1154	"KP_DOWN", "selectNext",
	1155	"UP", "selectPrevious",
	1156	"KP_UP", "selectPrevious",
	1157	"SPACE", "spacePopup",
	1158	"ENTER", "enterPressed"
	1159
	1160	}),
	1161
	1162	"TextField.caretForeground", black,
	1163	"TextField.caretBlinkRate", Integer.valueOf(500),
	1164	"TextField.inactiveForeground", table.get("textInactiveText"),
	1165	"TextField.selectionBackground", table.get("textHighlight"),
	1166	"TextField.selectionForeground", table.get("textHighlightText"),
	1167	"TextField.background", table.get("window"),
	1168	"TextField.foreground", table.get("textText"),
	1169	"TextField.font", sansSerifPlain12,
	1170	"TextField.border", textFieldBorder,
	1171	"TextField.focusInputMap", fieldInputMap,
	1172
	1173	"PasswordField.caretForeground", black,
	1174	"PasswordField.caretBlinkRate", Integer.valueOf(500),
	1175	"PasswordField.inactiveForeground", table.get("textInactiveText"),
	1176	"PasswordField.selectionBackground", table.get("textHighlight"),
	1177	"PasswordField.selectionForeground", table.get("textHighlightText"),
	1178	"PasswordField.background", table.get("window"),
	1179	"PasswordField.foreground", table.get("textText"),
	1180	"PasswordField.font", monospacedPlain12,
	1181	"PasswordField.border", textFieldBorder,
	1182	"PasswordField.focusInputMap", passwordInputMap,
	1183
	1184	"TextArea.caretForeground", black,
	1185	"TextArea.caretBlinkRate", Integer.valueOf(500),
	1186	"TextArea.inactiveForeground", table.get("textInactiveText"),
	1187	"TextArea.selectionBackground", table.get("textHighlight"),
	1188	"TextArea.selectionForeground", table.get("textHighlightText"),
	1189	"TextArea.background", table.get("window"),
	1190	"TextArea.foreground", table.get("textText"),
	1191	"TextArea.font", monospacedPlain12,
	1192	"TextArea.border", marginBorder,
	1193	"TextArea.focusInputMap", multilineInputMap,
	1194
	1195	"TextPane.caretForeground", black,
	1196	"TextPane.caretBlinkRate", Integer.valueOf(500),
	1197	"TextPane.inactiveForeground", table.get("textInactiveText"),
	1198	"TextPane.selectionBackground", lightGray,
	1199	"TextPane.selectionForeground", table.get("textHighlightText"),
	1200	"TextPane.background", white,
	1201	"TextPane.foreground", table.get("textText"),
	1202	"TextPane.font", serifPlain12,
	1203	"TextPane.border", marginBorder,
	1204	"TextPane.focusInputMap", multilineInputMap,
	1205
	1206	"EditorPane.caretForeground", red,
	1207	"EditorPane.caretBlinkRate", Integer.valueOf(500),
	1208	"EditorPane.inactiveForeground", table.get("textInactiveText"),
	1209	"EditorPane.selectionBackground", lightGray,
	1210	"EditorPane.selectionForeground", table.get("textHighlightText"),
	1211	"EditorPane.background", white,
	1212	"EditorPane.foreground", table.get("textText"),
	1213	"EditorPane.font", serifPlain12,
	1214	"EditorPane.border", marginBorder,
	1215	"EditorPane.focusInputMap", multilineInputMap,
	1216
	1217
	1218	"FileChooser.pathLabelMnemonic", new Integer(KeyEvent.VK_P), // 'p'
	1219	"FileChooser.filterLabelMnemonic", new Integer (KeyEvent.VK_R), // 'r'
	1220	"FileChooser.foldersLabelMnemonic", new Integer (KeyEvent.VK_L), // 'l'
	1221	"FileChooser.filesLabelMnemonic", new Integer (KeyEvent.VK_I), // 'i'
	1222	"FileChooser.enterFileNameLabelMnemonic", new Integer (KeyEvent.VK_N), // 'n'
	1223	"FileChooser.ancestorInputMap",
	1224	new UIDefaults.LazyInputMap(new Object[] {
	1225	"ESCAPE", "cancelSelection"
	1226	}),
	1227
	1228
	1229	"ToolTip.border", raisedBevelBorder,
	1230	"ToolTip.background", table.get("info"),
	1231	"ToolTip.foreground", table.get("infoText"),
	1232
	1233	// These window InputMap bindings are used when the Menu is
	1234	// selected.
	1235	"PopupMenu.selectedWindowInputMapBindings", new Object[] {
	1236	"ESCAPE", "cancel",
	1237	"TAB", "cancel",
	1238	"shift TAB", "cancel",
	1239	"DOWN", "selectNext",
	1240	"KP_DOWN", "selectNext",
	1241	"UP", "selectPrevious",
	1242	"KP_UP", "selectPrevious",
	1243	"LEFT", "selectParent",
	1244	"KP_LEFT", "selectParent",
	1245	"RIGHT", "selectChild",
	1246	"KP_RIGHT", "selectChild",
	1247	"ENTER", "return",
	1248	"SPACE", "return"
	1249	},
	1250
	1251
	1252	"OptionPane.border", optionPaneBorder,
	1253	"OptionPane.messageAreaBorder", optionPaneMessageAreaBorder,
	1254	"OptionPane.buttonAreaBorder", optionPaneButtonAreaBorder,
	1255	"OptionPane.errorIcon", SwingUtilities2.makeIcon(getClass(),
	1256	MotifLookAndFeel.class,
	1257	"icons/Error.gif"),
	1258	"OptionPane.informationIcon", SwingUtilities2.makeIcon(getClass(),
	1259	MotifLookAndFeel.class,
	1260	"icons/Inform.gif"),
	1261	"OptionPane.warningIcon", SwingUtilities2.makeIcon(getClass(),
	1262	MotifLookAndFeel.class,
	1263	"icons/Warn.gif"),
	1264	"OptionPane.questionIcon", SwingUtilities2.makeIcon(getClass(),
	1265	MotifLookAndFeel.class,
	1266	"icons/Question.gif"),
	1267	"OptionPane.windowBindings", new Object[] {
	1268	"ESCAPE", "close" },
	1269
	1270	// These bindings are only enabled when there is a default
	1271	// button set on the rootpane.
	1272	"RootPane.defaultButtonWindowKeyBindings", new Object[] {
	1273	"ENTER", "press",
	1274	"released ENTER", "release",
	1275	"ctrl ENTER", "press",
	1276	"ctrl released ENTER", "release"
	1277	},
	1278	};
	1279
	1280	table.putDefaults(defaults);
	1281	}
	1282
	1283	}

java/pkg/com/sun/java/swing/plaf/motif/MotifMenuBarUI.java+69−0

@@ -0,0 +1,69 @@
	1	/*
	2	* Copyright (c) 1997, 1998, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package com.sun.java.swing.plaf.motif;
	27
	28	import java.awt.Component;
	29	import java.awt.Container;
	30	import java.awt.Dimension;
	31	import java.awt.Graphics;
	32	import java.awt.Color;
	33	import java.awt.Insets;
	34	import java.awt.Point;
	35	import java.awt.Rectangle;
	36	import java.awt.event.*;
	37	import java.io.Serializable;
	38
	39	import javax.swing.*;
	40	import javax.swing.event.*;

29 more lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/MotifMenuItemUI.java+109−0

This diff is large: its 110 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/MotifMenuMouseListener.java+48−0

This diff is large: its 49 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/MotifMenuMouseMotionListener.java+43−0

This diff is large: its 44 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/MotifMenuUI.java+151−0

This diff is large: its 152 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/MotifOptionPaneUI.java+114−0

This diff is large: its 115 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/MotifPasswordFieldUI.java+68−0

This diff is large: its 69 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/MotifPopupMenuSeparatorUI.java+66−0

This diff is large: its 67 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/MotifPopupMenuUI.java+114−0

This diff is large: its 115 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/MotifProgressBarUI.java+58−0

This diff is large: its 59 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/MotifRadioButtonMenuItemUI.java+113−0

This diff is large: its 114 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/MotifRadioButtonUI.java+104−0

This diff is large: its 105 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/MotifScrollBarButton.java+211−0

This diff is large: its 212 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/MotifScrollBarUI.java+108−0

This diff is large: its 109 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/MotifScrollPaneUI.java+143−0

This diff is large: its 144 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/MotifSeparatorUI.java+59−0

This diff is large: its 60 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/MotifSliderUI.java+159−0

This diff is large: its 160 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/MotifSplitPaneDivider.java+295−0

This diff is large: its 296 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/MotifSplitPaneUI.java+66−0

This diff is large: its 67 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/MotifTabbedPaneUI.java+306−0

This diff is large: its 307 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/MotifTextAreaUI.java+70−0

This diff is large: its 71 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/MotifTextFieldUI.java+68−0

This diff is large: its 69 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/MotifTextPaneUI.java+68−0

This diff is large: its 69 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/MotifTextUI.java+175−0

This diff is large: its 176 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/MotifToggleButtonUI.java+125−0

This diff is large: its 126 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/MotifTreeCellRenderer.java+113−0

This diff is large: its 114 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/MotifTreeUI.java+166−0

This diff is large: its 167 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/icons/DesktopIcon.gif+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/motif/icons/Error.gif+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/motif/icons/Inform.gif+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/motif/icons/Question.gif+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/motif/icons/TreeClosed.gif+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/motif/icons/TreeOpen.gif+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/motif/icons/Warn.gif+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/motif/icons/image-delayed.png+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/motif/icons/image-failed.png+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/motif/icons/mkfile+2−0

This diff is large: its 3 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/mkfile+55−0

This diff is large: its 56 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/resources/mkfile+2−0

This diff is large: its 3 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/resources/motif.properties+40−0

This diff is large: its 41 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/resources/motif_de.properties+40−0

This diff is large: its 41 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/resources/motif_es.properties+40−0

This diff is large: its 41 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/resources/motif_fr.properties+40−0

This diff is large: its 41 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/resources/motif_it.properties+40−0

This diff is large: its 41 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/resources/motif_ja.properties+40−0

This diff is large: its 41 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/resources/motif_ko.properties+40−0

This diff is large: its 41 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/resources/motif_pt_BR.properties+40−0

This diff is large: its 41 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/resources/motif_sv.properties+40−0

This diff is large: its 41 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/resources/motif_zh_CN.properties+40−0

This diff is large: its 41 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/motif/resources/motif_zh_TW.properties+40−0

This diff is large: its 41 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/nimbus/AbstractRegionPainter.java+33−0

This diff is large: its 34 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/nimbus/NimbusLookAndFeel.java+33−0

This diff is large: its 34 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/nimbus/mkfile+9−0

This diff is large: its 10 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/AnimationController$1.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/AnimationController$AnimationState.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/AnimationController$PartUIClientPropertyKey.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/AnimationController.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/AnimationController.java+428−0

This diff is large: its 429 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/DesktopProperty$1.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/DesktopProperty$WeakPCL.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/DesktopProperty.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/DesktopProperty.java+285−0

This diff is large: its 286 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/TMSchema$Control.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/TMSchema$Part.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/TMSchema$Prop.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/TMSchema$State.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/TMSchema$TypeEnum.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/TMSchema.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/TMSchema.java+565−0

This diff is large: its 566 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsBorders$ComplementDashedBorder.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsBorders$DashedBorder.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsBorders$InternalFrameLineBorder.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsBorders$ProgressBarBorder.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsBorders$ToolBarBorder.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsBorders.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsBorders.java+336−0

This diff is large: its 337 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsButtonListener.java+54−0

This diff is large: its 55 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsButtonUI$1.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsButtonUI.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsButtonUI.java+320−0

This diff is large: its 321 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsCheckBoxMenuItemUI$1.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsCheckBoxMenuItemUI.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsCheckBoxMenuItemUI.java+104−0

This diff is large: its 105 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsCheckBoxUI.java+95−0

This diff is large: its 96 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsClassicLookAndFeel.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsClassicLookAndFeel.java+44−0

This diff is large: its 45 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsComboBoxUI$1.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsComboBoxUI$2.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsComboBoxUI$3.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsComboBoxUI$WindowsComboBoxEditor.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsComboBoxUI$WindowsComboBoxRenderer.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsComboBoxUI$WindowsComboPopup$InvocationKeyHandler.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsComboBoxUI$WindowsComboPopup.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsComboBoxUI$XPComboBoxButton.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsComboBoxUI.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsComboBoxUI.java+565−0

This diff is large: its 566 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsDesktopIconUI.java+98−0

This diff is large: its 99 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsDesktopManager.java+103−0

This diff is large: its 104 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsDesktopPaneUI.java+71−0

This diff is large: its 72 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsEditorPaneUI.java+68−0

This diff is large: its 69 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsFileChooserUI.java+1309−0

This diff is large: its 1310 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsGraphicsUtils.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsGraphicsUtils.java+211−0

This diff is large: its 212 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsIconFactory$1.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsIconFactory$CheckBoxIcon.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsIconFactory$CheckBoxMenuItemIcon.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsIconFactory$FrameButtonIcon.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsIconFactory$MenuArrowIcon.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsIconFactory$MenuItemArrowIcon.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsIconFactory$MenuItemCheckIcon.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsIconFactory$RadioButtonIcon.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsIconFactory$RadioButtonMenuItemIcon.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsIconFactory$ResizeIcon.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsIconFactory$VistaMenuItemCheckIconFactory$VistaMenuItemCheckIcon.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsIconFactory$VistaMenuItemCheckIconFactory.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsIconFactory.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsIconFactory.java+903−0

This diff is large: its 904 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsInternalFrameTitlePane.java+559−0

This diff is large: its 560 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsInternalFrameUI.java+134−0

This diff is large: its 135 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsLabelUI.java+112−0

This diff is large: its 113 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsLookAndFeel$1.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsLookAndFeel$2.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsLookAndFeel$ActiveWindowsIcon$1.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsLookAndFeel$ActiveWindowsIcon.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsLookAndFeel$AudioAction.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsLookAndFeel$FontDesktopProperty.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsLookAndFeel$LazyWindowsIcon.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsLookAndFeel$RGBGrayFilter.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsLookAndFeel$SkinIcon.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsLookAndFeel$TriggerDesktopProperty.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsLookAndFeel$WindowsFontProperty.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsLookAndFeel$WindowsFontSizeProperty.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsLookAndFeel$WindowsLayoutStyle.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsLookAndFeel$XPBorderValue.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsLookAndFeel$XPColorValue$XPColorValueKey.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsLookAndFeel$XPColorValue.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsLookAndFeel$XPDLUValue.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsLookAndFeel$XPValue.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsLookAndFeel.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsLookAndFeel.java+2620−0

This diff is large: its 2621 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsMenuBarUI$1.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsMenuBarUI$2.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsMenuBarUI$TakeFocus.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsMenuBarUI.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsMenuBarUI.java+186−0

This diff is large: its 187 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsMenuItemUI$1.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsMenuItemUI.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsMenuItemUI.java+177−0

This diff is large: its 178 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsMenuItemUIAccessor.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsMenuItemUIAccessor.java+46−0

This diff is large: its 47 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsMenuUI$1.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsMenuUI$WindowsMouseInputHandler.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsMenuUI.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsMenuUI.java+295−0

This diff is large: its 296 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsOptionPaneUI.java+47−0

This diff is large: its 48 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsPasswordFieldUI.java+69−0

This diff is large: its 70 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsPopupMenuSeparatorUI.java+94−0

This diff is large: its 95 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsPopupMenuUI$MnemonicListener.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsPopupMenuUI.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsPopupMenuUI.java+224−0

This diff is large: its 225 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsPopupWindow.java+95−0

This diff is large: its 96 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsProgressBarUI.java+400−0

This diff is large: its 401 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsRadioButtonMenuItemUI$1.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsRadioButtonMenuItemUI.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsRadioButtonMenuItemUI.java+103−0

This diff is large: its 104 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsRadioButtonUI.java+130−0

This diff is large: its 131 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsRootPaneUI$AltProcessor.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsRootPaneUI.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsRootPaneUI.java+184−0

This diff is large: its 185 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsScrollBarUI.java+479−0

This diff is large: its 480 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsScrollPaneUI.java+44−0

This diff is large: its 45 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsSeparatorUI.java+35−0

This diff is large: its 36 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsSliderUI.java+234−0

This diff is large: its 235 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsSpinnerUI.java+103−0

This diff is large: its 104 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsSplitPaneDivider.java+72−0

This diff is large: its 73 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsSplitPaneUI.java+67−0

This diff is large: its 68 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsTabbedPaneUI.java+227−0

This diff is large: its 228 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsTableHeaderUI.java+245−0

This diff is large: its 246 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsTextAreaUI.java+68−0

This diff is large: its 69 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsTextFieldUI.java+175−0

This diff is large: its 176 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsTextPaneUI.java+67−0

This diff is large: its 68 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsTextUI.java+236−0

This diff is large: its 237 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsToggleButtonUI.java+181−0

This diff is large: its 182 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsToolBarSeparatorUI.java+124−0

This diff is large: its 125 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsToolBarUI.java+99−0

This diff is large: its 100 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/WindowsTreeUI$CollapsedIcon.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsTreeUI$ExpandedIcon.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsTreeUI$WindowsTreeCellRenderer.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsTreeUI.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/WindowsTreeUI.java+234−0

This diff is large: its 235 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/XPStyle$GlyphButton.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/XPStyle$Skin.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/XPStyle$SkinPainter.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/XPStyle$XPEmptyBorder.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/XPStyle$XPFillBorder.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/XPStyle$XPImageBorder.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/XPStyle$XPStatefulFillBorder.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/XPStyle.class+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/XPStyle.java+751−0

This diff is large: its 752 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/icons/Computer.gif+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/icons/DetailsView.gif+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/icons/Directory.gif+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/icons/Error.gif+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/icons/File.gif+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/icons/FloppyDrive.gif+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/icons/HardDrive.gif+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/icons/HomeFolder.gif+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/icons/Inform.gif+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/icons/JavaCup32.png+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/icons/ListView.gif+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/icons/NewFolder.gif+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/icons/Question.gif+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/icons/TreeClosed.gif+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/icons/TreeLeaf.gif+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/icons/TreeOpen.gif+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/icons/UpFolder.gif+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/icons/Warn.gif+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/icons/image-delayed.png+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/icons/image-failed.png+0−0

Binary file not shown.

java/pkg/com/sun/java/swing/plaf/windows/icons/mkfile+2−0

This diff is large: its 3 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/mkfile+64−0

This diff is large: its 65 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/resources/mkfile+2−0

This diff is large: its 3 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/resources/windows.properties+47−0

This diff is large: its 48 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/resources/windows_de.properties+47−0

This diff is large: its 48 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/resources/windows_es.properties+47−0

This diff is large: its 48 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/resources/windows_fr.properties+47−0

This diff is large: its 48 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/resources/windows_it.properties+47−0

This diff is large: its 48 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/resources/windows_ja.properties+47−0

This diff is large: its 48 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/resources/windows_ko.properties+47−0

This diff is large: its 48 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/resources/windows_pt_BR.properties+47−0

This diff is large: its 48 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/resources/windows_sv.properties+47−0

This diff is large: its 48 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/resources/windows_zh_CN.properties+47−0

This diff is large: its 48 lines aren’t shown here.

java/pkg/com/sun/java/swing/plaf/windows/resources/windows_zh_TW.properties+47−0

This diff is large: its 48 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/mkfile+6−0

This diff is large: its 7 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/AdaptiveCoding.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/AdaptiveCoding.java+298−0

This diff is large: its 299 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/Attribute$1.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Attribute$FormatException.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Attribute$Holder.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Attribute$Layout$Element.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Attribute$Layout.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Attribute$ValueStream.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Attribute.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Attribute.java+1622−0

This diff is large: its 1623 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/BandStructure$Band.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/BandStructure$ByteBand$1.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/BandStructure$ByteBand.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/BandStructure$ByteCounter.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/BandStructure$CPRefBand.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/BandStructure$IntBand.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/BandStructure$MultiBand.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/BandStructure$ValueBand.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/BandStructure.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/BandStructure.java+2682−0

This diff is large: its 2683 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/ClassReader$1.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/ClassReader$ClassFormatException.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/ClassReader.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/ClassReader.java+494−0

This diff is large: its 495 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/ClassWriter.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/ClassWriter.java+257−0

This diff is large: its 258 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/Code.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Code.java+399−0

This diff is large: its 400 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/Coding.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Coding.java+907−0

This diff is large: its 908 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/CodingChooser$Choice.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/CodingChooser$Sizer.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/CodingChooser.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/CodingChooser.java+1489−0

This diff is large: its 1490 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/CodingMethod.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/CodingMethod.java+43−0

This diff is large: its 44 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/ConstantPool$ClassEntry.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/ConstantPool$DescriptorEntry.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/ConstantPool$Entry.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/ConstantPool$Index.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/ConstantPool$IndexGroup.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/ConstantPool$LiteralEntry.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/ConstantPool$MemberEntry.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/ConstantPool$NumberEntry.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/ConstantPool$SignatureEntry.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/ConstantPool$StringEntry.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/ConstantPool$Utf8Entry.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/ConstantPool.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/ConstantPool.java+1218−0

This diff is large: its 1219 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/Constants.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Constants.java+436−0

This diff is large: its 437 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/Driver.java+725−0

This diff is large: its 726 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/DriverResource.java+131−0

This diff is large: its 132 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/FixedList.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/FixedList.java+174−0

This diff is large: its 175 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/Fixups$1.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Fixups$Fixup.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Fixups$Itr.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Fixups.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Fixups.java+546−0

This diff is large: its 547 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/Histogram$1.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Histogram$BitMetric.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Histogram.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Histogram.java+818−0

This diff is large: its 819 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/Instruction$FormatException.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Instruction$LookupSwitch.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Instruction$Switch.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Instruction$TableSwitch.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Instruction.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Instruction.java+664−0

This diff is large: its 665 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/NativeUnpack.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/NativeUnpack.java+322−0

This diff is large: its 323 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/Package$1.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Package$Class$Field.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Package$Class$Member.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Package$Class$Method.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Package$Class.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Package$File.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Package$InnerClass.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Package.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Package.java+1322−0

This diff is large: its 1323 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/PackageReader$1.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/PackageReader$2.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/PackageReader$LimitedBuffer$1.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/PackageReader$LimitedBuffer.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/PackageReader.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/PackageReader.java+2204−0

This diff is large: its 2205 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/PackageWriter$1.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/PackageWriter$2.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/PackageWriter$3.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/PackageWriter.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/PackageWriter.java+1619−0

This diff is large: its 1620 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/PackerImpl$1.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/PackerImpl$DoPack$InFile.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/PackerImpl$DoPack.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/PackerImpl.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/PackerImpl.java+642−0

This diff is large: its 643 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/PopulationCoding.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/PopulationCoding.java+500−0

This diff is large: its 501 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/PropMap.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/PropMap.java+338−0

This diff is large: its 339 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/TLGlobals.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/TLGlobals.java+97−0

This diff is large: its 98 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/UnpackerImpl$1.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/UnpackerImpl$DoUnpack.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/UnpackerImpl.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/UnpackerImpl.java+281−0

This diff is large: its 282 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/Utils$NonCloser.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Utils$Pack200Logger.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Utils.class+0−0

Binary file not shown.

java/pkg/com/sun/java/util/jar/pack/Utils.java+344−0

This diff is large: its 345 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/intrinsic.properties+46−0

This diff is large: its 47 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/mkfile+34−0

This diff is large: its 35 lines aren’t shown here.

java/pkg/com/sun/java/util/jar/pack/package.html+104−0

This diff is large: its 105 lines aren’t shown here.

java/pkg/com/sun/java/util/mkfile+6−0

This diff is large: its 7 lines aren’t shown here.