code stringlengths 1 2.01M | repo_name stringlengths 3 62 | path stringlengths 1 267 | language stringclasses 231
values | license stringclasses 13
values | size int64 1 2.01M |
|---|---|---|---|---|---|
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.components.xmlbundle;
import java.util.Locale;
import java.util.MissingResourceException;
import javax.swing.ImageIcon;
/**The interface provides access to a resourcebundle that
can be defined in XML or as an java-object.
Example Usage:
<pre>
I18nBundle i18n = serviceManager.lookup(I18nBundle.class);
i18n.getString("yes"); // will get the translation for yes.
</pre>
*/
public interface I18nBundle {
/** same as </code>format(key,new Object[] {obj1});</code>
@see #format(String,Object[])
*/
String format(String key,Object obj1) throws MissingResourceException;
/** same as </code>format(key,new Object[] {obj1, obj2});</code>
@see #format(String,Object[])
*/
String format(String key,Object obj1,Object obj2) throws MissingResourceException;
/** same as
<code>
(new MessageFormat(getString(key))).format(obj);
</code>
@see java.text.MessageFormat
*/
String format(String key,Object... obj) throws MissingResourceException;
/** returns the specified icon from the image-resource-file.
@throws MissingResourceException if not found or can't be loaded.
*/
ImageIcon getIcon(String key) throws MissingResourceException;
/** returns the specified string from the selected resource-file.
* Same as getString(key,getLocale())
* @throws MissingResourceException if not found or can't be loaded.
*/
String getString(String key) throws MissingResourceException;
/** returns the specified string from the selected resource-file for the specified locale
@throws MissingResourceException if not found or can't be loaded.
*/
String getString( String key, Locale locale);
/** @return the selected language. */
String getLang();
/** @return the selected Locale. */
Locale getLocale();
}
| 04900db4-clienttest | src/org/rapla/components/xmlbundle/I18nBundle.java | Java | gpl3 | 2,815 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.components.xmlbundle.impl;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.net.URL;
import java.text.MessageFormat;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Locale;
import java.util.Map;
import java.util.MissingResourceException;
import java.util.ResourceBundle;
import java.util.TreeMap;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import org.rapla.components.util.IOUtil;
import org.rapla.components.xmlbundle.I18nBundle;
import org.rapla.components.xmlbundle.LocaleChangeEvent;
import org.rapla.components.xmlbundle.LocaleChangeListener;
import org.rapla.components.xmlbundle.LocaleSelector;
import org.rapla.framework.Configuration;
import org.rapla.framework.DefaultConfiguration;
import org.rapla.framework.Disposable;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.framework.logger.Logger;
/** The default implementation of the xmlbundle component allows reading from
a compiled ResourceBundle as well as directly from the source-xml-file.
<p>
Sample Configuration 1: (Resources are loaded from the compiled ResourceBundles)
<pre>
<resource-bundle id="org.rapla.RaplaResources"/>
</pre>
</p>
<p>
Sample Configuration 2: (Resources will be loaded directly from the resource-file)
<pre>
<resource-bundle id="org.rapla.plugin.periodwizard.WizardResources">
<file>/home/christopher/Rapla/src/org/rapla/periodwizard/WizardResources.xml</file>
</resource-bundle>
</pre>
</p>
<p>
This class looks for a LocaleSelector on the context and registers itself as
a LocaleChangeListener and switches to the new Locale on a LocaleChangeEvent.
</p>
@see TranslationParser
@see LocaleSelector
*/
public class I18nBundleImpl implements I18nBundle, LocaleChangeListener, Disposable
{
String className;
Locale locale;
Logger logger = null;
LocaleSelectorImpl m_localeSelector;
final String dictionaryFile;
final RaplaDictionary dict;
LinkedHashMap<Locale,LanguagePack> packMap = new LinkedHashMap<Locale,LanguagePack>();
String parentId = null;
class LanguagePack
{
Locale locale;
Map<String,Icon> iconCache = Collections.synchronizedMap( new TreeMap<String,Icon>() );
ResourceBundle resourceBundle;
public String getString( String key ) throws MissingResourceException
{
String lang = locale.getLanguage();
if ( dictionaryFile != null )
{
String lookup = dict.lookup(key, lang);
if ( lookup == null)
{
throw new MissingResourceException("Entry not found for "+ key, dictionaryFile, key);
}
return lookup;
}
DictionaryEntry entry = dict.getEntry(key);
String string;
if ( entry != null)
{
string = entry.get( lang );
if ( string == null )
{
string = resourceBundle.getString( key );
entry.add(lang, key);
}
}
else
{
string = resourceBundle.getString( key );
entry = new DictionaryEntry( key);
entry.add(lang, string);
try {
dict.addEntry( entry);
} catch (UniqueKeyException e) {
// we can ignore it here
}
}
return string;
}
public ImageIcon getIcon( String key ) throws MissingResourceException
{
String iconfile;
try
{
iconfile = getString( key );
}
catch ( MissingResourceException ex )
{
getLogger().debug( ex.getMessage() ); //BJO
throw ex;
}
try
{
ImageIcon icon = (ImageIcon) iconCache.get( iconfile );
if ( icon == null )
{
icon = new ImageIcon( loadResource( iconfile ), key );
iconCache.put( iconfile, icon );
} // end of if ()
return icon;
}
catch ( Exception ex )
{
String message = "Icon " + iconfile + " can't be created: " + ex.getMessage();
getLogger().error( message );
throw new MissingResourceException( message, className, key );
}
}
private final byte[] loadResource( String fileName ) throws IOException
{
return IOUtil.readBytes( getResourceFromFile( fileName ) );
}
private URL getResourceFromFile( String fileName ) throws IOException
{
URL resource = null;
String base;
if ( dictionaryFile == null )
{
if ( resourceBundle == null)
{
throw new IOException("Resource Bundle for locale " + locale + " is missing while looking up " + fileName);
}
if ( resourceBundle instanceof PropertyResourceBundleWrapper)
{
base = ((PropertyResourceBundleWrapper) resourceBundle).getName();
}
else
{
base = resourceBundle.getClass().getName();
}
base = base.substring(0,base.lastIndexOf("."));
base = base.replaceAll("\\.", "/");
String file = "/" + base + "/" + fileName;
resource = I18nBundleImpl.class.getResource( file );
}
else
{
if ( getLogger().isDebugEnabled() )
getLogger().debug( "Looking for resourcefile " + fileName + " in classpath ");
URL resourceBundleURL = getClass().getClassLoader().getResource(dictionaryFile);
if (resourceBundleURL != null)
{
resource = new URL( resourceBundleURL, fileName);
base = resource.getPath();
}
else
{
base = ( new File( dictionaryFile ) ).getParent();
if ( base != null)
{
if ( getLogger().isDebugEnabled() )
getLogger().debug( "Looking for resourcefile " + fileName + " in directory " + base );
File resourceFile = new File( base, fileName );
if ( resourceFile.exists() )
resource = resourceFile.toURI().toURL();
}
}
}
if ( resource == null )
throw new IOException( "File '"
+ fileName
+ "' not found. "
+ " in bundle "
+ className
+ " It must be in the same location as '"
+ base
+ "'" );
return resource;
}
}
/**
* @throws RaplaException when the resource-file is missing or can't be accessed
or can't be parsed
*/
public I18nBundleImpl( RaplaContext context, Configuration config, Logger logger ) throws RaplaException
{
enableLogging( logger );
Locale locale;
m_localeSelector = (LocaleSelectorImpl) context.lookup( LocaleSelector.class ) ;
if ( m_localeSelector != null )
{
m_localeSelector.addLocaleChangeListenerFirst( this );
locale = m_localeSelector.getLocale();
}
else
{
locale = Locale.getDefault();
}
String filePath = config.getChild( "file" ).getValue( null );
try
{
InputStream resource;
if ( filePath == null )
{
className = config.getChild( "classname" ).getValue( null );
if ( className == null )
{
className = config.getAttribute( "id" );
}
else
{
className = className.trim();
}
String resourceFile = "" + className.replaceAll("\\.", "/") + ".xml";
resource = getClass().getClassLoader().getResourceAsStream(resourceFile);
dictionaryFile = resource != null ? resourceFile : null;
}
else
{
File file = new File( filePath);
getLogger().info( "getting lanaguageResources from " + file.getCanonicalPath() );
resource = new FileInputStream( file );
dictionaryFile = filePath;
}
if ( resource != null)
{
dict = new TranslationParser().parse( resource );
resource.close();
}
else
{
dict = new RaplaDictionary(locale.getLanguage());
}
}
catch ( Exception ex )
{
throw new RaplaException( ex );
}
setLocale( locale );
try
{
parentId = getPack(locale).getString( TranslationParser.PARENT_BUNDLE_IDENTIFIER );
}
catch ( MissingResourceException ex )
{
}
}
public String getParentId()
{
return parentId;
}
public static Configuration createConfig( String resourceFile )
{
DefaultConfiguration config = new DefaultConfiguration( "component");
config.setAttribute( "id", resourceFile.toString() );
return config;
}
public void dispose()
{
if ( m_localeSelector != null )
m_localeSelector.removeLocaleChangeListener( this );
}
public void localeChanged( LocaleChangeEvent evt )
{
try
{
setLocale( evt.getLocale() );
}
catch ( Exception ex )
{
getLogger().error( "Can't set new locale " + evt.getLocale(), ex );
}
}
public void enableLogging( Logger logger )
{
this.logger = logger;
}
protected Logger getLogger()
{
return logger;
}
public String format( String key, Object obj1 )
{
Object[] array1 = new Object[1];
array1[0] = obj1;
return format( key, array1 );
}
public String format( String key, Object obj1, Object obj2 )
{
Object[] array2 = new Object[2];
array2[0] = obj1;
array2[1] = obj2;
return format( key, array2 );
}
public String format( String key, Object... obj )
{
MessageFormat msg = new MessageFormat( getString( key ) );
return msg.format( obj );
}
public ImageIcon getIcon( String key ) throws MissingResourceException
{
ImageIcon icon = getPack(getLocale()).getIcon( key);
return icon;
}
public Locale getLocale()
{
if ( locale == null )
throw new IllegalStateException( "Call setLocale first!" );
return locale;
}
public String getLang()
{
if ( locale == null )
throw new IllegalStateException( "Call setLocale first!" );
return locale.getLanguage();
}
public String getString( String key ) throws MissingResourceException
{
if ( locale == null )
throw new IllegalStateException( "Call setLocale first!" );
return getString(key, locale);
}
public String getString( String key, Locale locale) throws MissingResourceException
{
LanguagePack pack = getPack(locale);
return pack.getString(key);
}
// /* replaces XHTML with HTML because swing can't display proper XHTML*/
// String filterXHTML( String text )
// {
// if ( text.indexOf( "<br/>" ) >= 0 )
// {
// return applyXHTMLFilter( text );
// }
// else
// {
// return text;
// } // end of else
// }
// public static String replaceAll( String text, String token, String with )
// {
// StringBuffer buf = new StringBuffer();
// int i = 0;
// int lastpos = 0;
// while ( ( i = text.indexOf( token, lastpos ) ) >= 0 )
// {
// if ( i > 0 )
// buf.append( text.substring( lastpos, i ) );
// buf.append( with );
// i = ( lastpos = i + token.length() );
// } // end of if ()
// buf.append( text.substring( lastpos, text.length() ) );
// return buf.toString();
// }
//
// private String applyXHTMLFilter( String text )
// {
// return replaceAll( text, "<br/>", "<br></br>" );
// }
public void setLocale( Locale locale )
{
this.locale = locale;
getLogger().debug( "Locale changed to " + locale );
try
{
getPack(locale);
}
catch (MissingResourceException ex)
{
getLogger().error(ex.getMessage(), ex);
}
}
private LanguagePack getPack(Locale locale) throws MissingResourceException {
LanguagePack pack = packMap.get(locale);
if (pack != null)
{
return pack;
}
synchronized ( packMap )
{
// again, now with synchronization
pack = packMap.get(locale);
if (pack != null)
{
return pack;
}
pack = new LanguagePack();
pack.locale = locale;
if ( dictionaryFile == null )
{
pack.resourceBundle = new ResourceBundleLoader().loadResourceBundle( className, locale );
}
packMap.put( locale, pack);
return pack;
}
}
}
class ResourceBundleLoader
{
/** this method imitates the orginal
* <code>ResourceBundle.getBundle(String className,Locale
* locale)</code> which causes problems when the locale is changed
* to the base locale (english). For a full description see
* ResourceBundle.getBundle(String className) in the java-api.*/
public ResourceBundle loadResourceBundle( String className, Locale locale ) throws MissingResourceException
{
String tries[] = new String[7];
StringBuffer buf = new StringBuffer();
tries[6] = className;
buf.append( className );
if ( locale.getLanguage().length() > 0 )
{
buf.append( '_' );
buf.append( locale.getLanguage() );
tries[2] = buf.toString();
}
if ( locale.getCountry().length() > 0 )
{
buf.append( '_' );
buf.append( locale.getCountry() );
tries[1] = buf.toString();
}
if ( locale.getVariant().length() > 0 )
{
buf.append( '_' );
buf.append( locale.getVariant() );
tries[0] = buf.toString();
}
buf.delete( className.length(), buf.length() - 1 );
Locale defaultLocale = Locale.getDefault();
if ( defaultLocale.getLanguage().length() > 0 )
{
buf.append( defaultLocale.getLanguage() );
tries[5] = buf.toString();
}
if ( defaultLocale.getCountry().length() > 0 )
{
buf.append( '_' );
buf.append( defaultLocale.getCountry() );
tries[4] = buf.toString();
}
if ( defaultLocale.getVariant().length() > 0 )
{
buf.append( '_' );
buf.append( defaultLocale.getVariant() );
tries[3] = buf.toString();
}
ResourceBundle bundle = null;
for ( int i = 0; i < tries.length; i++ )
{
if ( tries[i] == null )
continue;
bundle = loadBundle( tries[i] );
if ( bundle != null )
{
loadParent( tries, i, bundle );
return bundle;
}
}
throw new MissingResourceException( "'" + className + "' not found. The resource-file is missing.", className,
"" );
}
private ResourceBundle loadBundle( String name )
{
InputStream io = null;
try
{
String pathName = getPropertyFileNameFromClassName( name );
io = this.getClass().getResourceAsStream( pathName );
if ( io != null )
{
return new PropertyResourceBundleWrapper(io , name);
}
ResourceBundle bundle = (ResourceBundle) this.getClass().getClassLoader().loadClass( name ).newInstance();
return bundle;
}
catch ( Exception ex )
{
return null;
}
catch ( ClassFormatError ex )
{
return null;
}
finally
{
if ( io != null)
{
try {
io.close();
} catch (IOException e) {
return null;
}
}
}
}
private void loadParent( String[] tries, int i, ResourceBundle bundle )
{
ResourceBundle parent = null;
if ( i == 0 || i == 3 )
{
parent = loadBundle( tries[i++] );
if ( parent != null )
setParent( bundle, parent );
bundle = parent;
}
if ( i == 1 || i == 4 )
{
parent = loadBundle( tries[i++] );
if ( parent != null )
setParent( bundle, parent );
bundle = parent;
}
if ( i == 2 || i == 5 )
{
parent = loadBundle( tries[6] );
if ( parent != null )
setParent( bundle, parent );
}
}
private void setParent( ResourceBundle bundle, ResourceBundle parent )
{
try
{
Method method = bundle.getClass().getMethod( "setParent", new Class[]
{ ResourceBundle.class } );
method.invoke( bundle, new Object[]
{ parent } );
}
catch ( Exception ex )
{
}
}
private String getPropertyFileNameFromClassName( String classname )
{
StringBuffer result = new StringBuffer( classname );
for ( int i = 0; i < result.length(); i++ )
{
if ( result.charAt( i ) == '.' )
result.setCharAt( i, '/' );
}
result.insert( 0, '/' );
result.append( ".properties" );
return result.toString();
}
}
| 04900db4-clienttest | src/org/rapla/components/xmlbundle/impl/I18nBundleImpl.java | Java | gpl3 | 19,002 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.components.xmlbundle.impl;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import org.rapla.components.util.Assert;
import org.rapla.components.util.IOUtil;
import org.rapla.components.util.xml.XMLReaderAdapter;
import org.rapla.framework.ConfigurationException;
import org.xml.sax.Attributes;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.DefaultHandler;
/** This class reads *Resources.xml files and generates
the appropriate ResourceBundle java-files.
<pre>
Usage :
org.rapla.components.xmlbundle.TranslationParser PATH_TO_SOURCES [DESTINATION_PATH]
Note: a xml-parser must be on your classpath.
Example usage under windows:
java -classpath lib\saxon.jar;lib\fortress.jar;build\classes org.rapla.components.xmlbundle.TranslationParser src
</pre>
*/
public class TranslationParser extends DefaultHandler
{
RaplaDictionary dict;
DictionaryEntry currentEntry = null;
String currentLang = null;
String defaultLang = null;
String currentIconSrc = null;
int level = 0;
// used to store the nested content in the translation element
StringBuffer charBuffer;
XMLReader xmlReader;
/** The translation parser will add an extra identifer {$i18nbundle_parent$} to
the translation table if a parentbundle is specified.
*/
public final static String PARENT_BUNDLE_IDENTIFIER = "{$i18nbundle_parent$}";
DefaultHandler handler = new DefaultHandler()
{
public InputSource resolveEntity( String publicId, String systemId ) throws SAXException
{
if ( systemId.endsWith( "resources.dtd" ) )
{
try
{
URL resource = getClass().getResource( "/org/rapla/components/xmlbundle/resources.dtd" );
Assert.notNull( resource, "resources.dtd not found on classpath" );
return new InputSource( IOUtil.getInputStream( resource ) );
}
catch ( IOException ex )
{
throw new SAXException( ex );
}
}
else
{
// use the default behaviour
try
{
return super.resolveEntity( publicId, systemId );
}
catch ( SAXException ex )
{
throw ex;
}
catch ( Exception ex )
{
throw new SAXException( ex );
}
}
}
public void startElement( String uri, String name, String qName, Attributes atts ) throws SAXException
{
// if ( log.isDebugEnabled() )
// log.debug( indent() + "Start element: " + qName + "(" + name + ")" );
level:
{
if ( name.equals( "resources" ) )
{
String defaultLang = atts.getValue( "", "default" );
String parentDict = atts.getValue( "", "parent" );
dict = new RaplaDictionary( defaultLang );
if ( parentDict != null && parentDict.trim().length() > 0 )
{
DictionaryEntry entry = new DictionaryEntry( PARENT_BUNDLE_IDENTIFIER );
entry.add( "en", parentDict.trim() );
try
{
dict.addEntry( entry );
}
catch ( UniqueKeyException ex )
{
//first entry must be unique
}
}
break level;
}
if ( name.equals( "entry" ) )
{
String key = atts.getValue( "", "key" );
currentEntry = new DictionaryEntry( key );
break level;
}
if ( name.equals( "text" ) )
{
currentLang = atts.getValue( "", "lang" );
if ( currentLang == null )
currentLang = dict.getDefaultLang();
charBuffer = new StringBuffer();
break level;
}
if ( name.equals( "icon" ) )
{
currentLang = atts.getValue( "", "lang" );
if ( currentLang == null )
currentLang = dict.getDefaultLang();
currentIconSrc = atts.getValue( "", "src" );
charBuffer = new StringBuffer();
break level;
}
// copy startag
if ( charBuffer != null )
{
copyStartTag( name, atts );
}
}
level++;
}
public void endElement( String uri, String name, String qName ) throws SAXException
{
level--;
// if ( log.isDebugEnabled() )
// log.debug( indent() + "End element: " + qName + "(" + name + ")" );
level:
{
if ( name.equals( "icon" ) )
{
if ( currentIconSrc != null )
currentEntry.add( currentLang, currentIconSrc );
break level;
}
if ( name.equals( "text" ) )
{
removeWhiteSpaces( charBuffer );
currentEntry.add( currentLang, charBuffer.toString() );
break level;
}
if ( name.equals( "entry" ) )
{
try
{
dict.addEntry( currentEntry );
}
catch ( UniqueKeyException e )
{
throw new SAXException( e.getMessage() );
} // end of try-catch
currentEntry = null;
break level;
}
// copy endtag
if ( charBuffer != null )
{
copyEndTag( name );
} // end of if ()
}
}
public void characters( char ch[], int start, int length )
{
// copy nested content
if ( charBuffer != null )
{
charBuffer.append( ch, start, length );
} // end of if ()
}
};
TranslationParser() throws ConfigurationException
{
super();
try
{
xmlReader = XMLReaderAdapter.createXMLReader( false );
xmlReader.setContentHandler( handler );
xmlReader.setErrorHandler( handler );
xmlReader.setDTDHandler( handler );
xmlReader.setEntityResolver( handler );
}
catch ( SAXException ex )
{
if ( ex.getException() != null )
{
throw new ConfigurationException( "", ex.getException() );
}
else
{
throw new ConfigurationException( "", ex );
} // end of else
}
}
RaplaDictionary parse( InputStream in ) throws IOException, SAXException
{
dict = null;
xmlReader.parse( new InputSource( in ) );
checkDict();
return dict;
}
RaplaDictionary parse( String systemID ) throws IOException, SAXException
{
dict = null;
xmlReader.parse( systemID );
checkDict();
return dict;
}
private void checkDict() throws IOException
{
if ( dict == null )
{
throw new IOException( "Dictionary file empty " );
}
}
private void copyStartTag( String name, Attributes atts )
{
charBuffer.append( '<' );
charBuffer.append( name );
for ( int i = 0; i < atts.getLength(); i++ )
{
charBuffer.append( ' ' );
charBuffer.append( atts.getLocalName( i ) );
charBuffer.append( '=' );
charBuffer.append( '\"' );
charBuffer.append( atts.getValue( i ) );
charBuffer.append( '\"' );
}
charBuffer.append( '>' );
}
private void copyEndTag( String name )
{
if ( ( charBuffer != null )
&& ( charBuffer.length() > 0 )
&& ( charBuffer.charAt( charBuffer.length() - 1 ) == '>' ) )
{
// <some-tag></some-tag> --> <some-tag/>
charBuffer.insert( charBuffer.length() - 1, "/" );
}
else
{
// </some-tag>
charBuffer.append( "</" + name + ">" );
} // end of else
}
private void removeWhiteSpaces( StringBuffer buf )
{
for ( int i = 1; i < buf.length(); i++ )
{
if ( ( buf.charAt( i ) == ' ' ) && ( buf.charAt( i - 1 ) == ' ' ) )
buf.deleteCharAt( --i );
} // end of for ()
}
/** @deprecated moved to {@link ResourceFileGenerator}*/
@Deprecated
public static void main( String[] args )
{
ResourceFileGenerator.main(args);
}
}
| 04900db4-clienttest | src/org/rapla/components/xmlbundle/impl/TranslationParser.java | Java | gpl3 | 10,387 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.components.xmlbundle.impl;
/** thrown by the RaplaDictionary when a duplicated entry is found */
class UniqueKeyException extends Exception {
private static final long serialVersionUID = 1L;
public UniqueKeyException(String text) {
super(text);
}
}
| 04900db4-clienttest | src/org/rapla/components/xmlbundle/impl/UniqueKeyException.java | Java | gpl3 | 1,233 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.components.xmlbundle.impl;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Properties;
import java.util.Set;
import java.util.Stack;
import java.util.Vector;
import org.rapla.framework.ConfigurationException;
import org.rapla.framework.logger.ConsoleLogger;
import org.rapla.framework.logger.Logger;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
class ResourceFileGenerator {
public static final String encoding = "UTF-8";
static Logger log = new ConsoleLogger( ConsoleLogger.LEVEL_INFO );
boolean writeProperties = true;
public void transform(RaplaDictionary dict
,String packageName
,String classPrefix
,File destDir
)
throws IOException
{
String[] languages = dict.getAvailableLanguages();
for (String lang:languages) {
String className = classPrefix;
if (!lang.equals(dict.getDefaultLang()))
{
className += "_" + lang;
}
String ending = writeProperties ? ".properties" : ".java";
File file = new File(destDir, className + ending);
PrintWriter w = new PrintWriter(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file),encoding)));
if ( writeProperties)
{
Properties properties = new Properties();
Iterator<DictionaryEntry> it = dict.getEntries().iterator();
while ( it.hasNext()) {
DictionaryEntry entry = it.next();
String key = entry.getKey();
String value = entry.get(lang);
if ( value != null)
{
properties.put(key, value);
}
}
@SuppressWarnings("serial")
Properties temp = new Properties()
{
@SuppressWarnings({ "rawtypes", "unchecked" })
public synchronized Enumeration keys() {
Enumeration<Object> keysEnum = super.keys();
Vector keyList = new Vector<Object>();
while(keysEnum.hasMoreElements()){
keyList.add(keysEnum.nextElement());
}
Collections.sort(keyList);
return keyList.elements();
}
};
temp.putAll( properties);
String comment = packageName + "." + className + "_" + lang;
temp.store(w, comment);
}
else
{
generateJavaHeader(w,packageName);
generateJavaContent(w,dict, className, lang);
}
w.flush();
w.close();
}
}
// public void transformSingleLanguage(RaplaDictionary dict
// ,String packageName
// ,String classPrefix
// ,String lang
// ) {
// String className = classPrefix + "_" + lang;
// w = new PrintWriter(System.out);
// generateHeader(packageName);
// generateContent(dict,className, lang);
// w.flush();
// }
public static String toPackageName(String pathName) {
StringBuffer buf = new StringBuffer();
char[] c =pathName.toCharArray();
for (int i=0;i<c.length;i++) {
if (c[i] == File.separatorChar ) {
if (i>0 && i<c.length-1)
buf.append('.');
} else {
buf.append(c[i]);
}
}
return buf.toString();
}
private void generateJavaHeader(PrintWriter w, String packageName) {
w.println("/*******************************************");
w.println(" * Autogenerated file. Please do not edit. *");
w.println(" * Edit the *Resources.xml file. *");
w.println(" *******************************************/");
w.println();
w.println("package " + packageName + ";");
}
private void generateJavaContent(PrintWriter w, RaplaDictionary dict
,String className
,String lang
)
{
w.println("import java.util.ListResourceBundle;");
w.println("import java.util.ResourceBundle;");
w.println();
w.println("public class " + className + " extends ListResourceBundle {");
w.println(" public Object[][] getContents() { return contents; }");
// We make the setParent method public, so that we can use it in I18nImpl
w.println(" public void setParent(ResourceBundle parent) { super.setParent(parent); }");
w.println(" static final Object[][] contents = { {\"\",\"\"} ");
Iterator<DictionaryEntry> it = dict.getEntries().iterator();
while ( it.hasNext()) {
DictionaryEntry entry = it.next();
String value = entry.get(lang);
if (value != null) {
String content = convertToJava(value);
w.println(" , { \"" + entry.getKey() + "\",\"" + content + "\"}");
}
}
w.println(" };");
w.println("}");
}
static public String byteToHex(byte b) {
// Returns hex String representation of byte b
char hexDigit[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
char[] array = { hexDigit[(b >> 4) & 0x0f], hexDigit[b & 0x0f] };
return new String(array);
}
static public String charToHex(char c) {
// Returns hex String representation of char c
byte hi = (byte) (c >>> 8);
byte lo = (byte) (c & 0xff);
return byteToHex(hi) + byteToHex(lo);
}
private String convertToJava(String text) {
StringBuffer result = new StringBuffer();
for ( int i = 0;i< text.length();i++) {
char c = text.charAt(i);
switch ( c) {
case '\n': // LineBreaks
result.append("\" \n + \"");
break;
case '\\': // \
result.append("\\\\");
break;
case '\"': // "
result.append("\\\"");
break;
default:
if ( c > 127) {
result.append("\\u" + charToHex(c));
} else {
result.append(c);
} // end of else
break;
} // end of switch ()
} // end of for ()
return result.toString();
}
public static final String USAGE = new String( "Usage : \n"
+ "PATH_TO_SOURCES [DESTINATION_PATH]\n"
+ "Example usage under windows:\n"
+ "java -classpath build\\classes "
+ "org.rapla.components.xmlbundle.ResourceFileGenerator "
+ "src \n" );
public static void processDir( String srcDir, String destDir ) throws IOException, SAXException,
ConfigurationException
{
TranslationParser parser = new TranslationParser();
ResourceFileGenerator generator = new ResourceFileGenerator();
Set<String> languages = new HashSet<String>();
Stack<File> stack = new Stack<File>();
File topDir = new File( srcDir );
stack.push( topDir );
while ( !stack.empty() )
{
File file = stack.pop();
if ( file.isDirectory() )
{
// System.out.println("Checking Dir: " + file.getName());
File[] files = file.listFiles();
for ( int i = 0; i < files.length; i++ )
stack.push( files[i] );
}
else
{
// System.out.println("Checking File: " + file.getName());
if ( file.getName().endsWith( "Resources.xml" ) )
{
String absolut = file.getAbsolutePath();
System.out.println( "Transforming source:" + file );
String relativePath = absolut.substring( topDir.getAbsolutePath().length() );
String prefix = file.getName().substring( 0, file.getName().length() - "Resources.xml".length() );
String pathName = relativePath.substring( 0, relativePath.indexOf( file.getName() ) );
RaplaDictionary dict = parser.parse( file.toURI().toURL().toExternalForm() );
File dir = new File( destDir, pathName );
System.out.println( "destination:" + dir );
dir.mkdirs();
String packageName = ResourceFileGenerator.toPackageName( pathName );
generator.transform( dict, packageName, prefix + "Resources", dir );
String[] langs = dict.getAvailableLanguages();
for ( int i = 0; i < langs.length; i++ )
languages.add( langs[i] );
}
}
}
}
public static void main( String[] args )
{
try
{
if ( args.length < 1 )
{
System.out.println( USAGE );
return;
} // end of if ()
String sourceDir = args[0];
String destDir = ( args.length > 1 ) ? args[1] : sourceDir;
processDir( sourceDir, destDir );
}
catch ( SAXParseException ex )
{
log.error( "Line:" + ex.getLineNumber() + " Column:" + ex.getColumnNumber() + " " + ex.getMessage(), ex );
System.exit( 1 );
}
catch ( Throwable e )
{
log.error( e.getMessage(), e );
System.exit( 1 );
}
} // end of main ()
}
| 04900db4-clienttest | src/org/rapla/components/xmlbundle/impl/ResourceFileGenerator.java | Java | gpl3 | 11,079 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.components.xmlbundle.impl;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Map;
import java.util.TreeMap;
class RaplaDictionary {
Map<String,DictionaryEntry> entries = new TreeMap<String,DictionaryEntry>();
Collection<String> availableLang = new ArrayList<String>();
String defaultLang;
public RaplaDictionary(String defaultLang) {
this.defaultLang = defaultLang;
}
public void addEntry(DictionaryEntry entry) throws UniqueKeyException {
if ( entries.get(entry.getKey()) != null) {
throw new UniqueKeyException("Key '" + entry.getKey() + "' already in map.");
} // end of if ()
String[] lang = entry.availableLanguages();
for ( int i = 0; i<lang.length;i++)
if (!availableLang.contains(lang[i]))
availableLang.add(lang[i]);
entries.put(entry.getKey(),entry);
}
public Collection<DictionaryEntry> getEntries() {
return entries.values();
}
public String getDefaultLang() {
return defaultLang;
}
public String[] getAvailableLanguages() {
return availableLang.toArray(new String[0]);
}
public String lookup(String key,String lang) {
DictionaryEntry entry = getEntry(key);
if ( entry != null) {
return entry.get(lang,defaultLang);
} else {
return null;
} // end of else
}
public DictionaryEntry getEntry(String key) {
return entries.get(key);
}
}
| 04900db4-clienttest | src/org/rapla/components/xmlbundle/impl/RaplaDictionary.java | Java | gpl3 | 2,486 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.components.xmlbundle.impl;
import java.util.Locale;
import java.util.Vector;
import org.rapla.components.xmlbundle.LocaleChangeEvent;
import org.rapla.components.xmlbundle.LocaleChangeListener;
import org.rapla.components.xmlbundle.LocaleSelector;
/** If you want to change the locales during runtime put a LocaleSelector
in the base-context. Instances of {@link I18nBundleImpl} will then register them-self
as {@link LocaleChangeListener LocaleChangeListeners}. Change the locale
with {@link #setLocale} and all bundles will try to load the appropriate resources.
*/
public class LocaleSelectorImpl implements LocaleSelector {
Locale locale;
Vector<LocaleChangeListener> localeChangeListeners = new Vector<LocaleChangeListener>();
public LocaleSelectorImpl() {
locale = Locale.getDefault();
}
public void addLocaleChangeListener(LocaleChangeListener listener) {
localeChangeListeners.add(listener);
}
public void removeLocaleChangeListener(LocaleChangeListener listener) {
localeChangeListeners.remove(listener);
}
public void setLocale(Locale locale) {
this.locale = locale;
fireLocaleChanged();
}
public Locale getLocale() {
return this.locale;
}
public LocaleChangeListener[] getLocaleChangeListeners() {
return localeChangeListeners.toArray(new LocaleChangeListener[]{});
}
public void setLanguage(String language) {
setLocale(new Locale(language,locale.getCountry()));
}
public void setCountry(String country) {
setLocale(new Locale(locale.getLanguage(),country));
}
public String getLanguage() {
return locale.getLanguage();
}
protected void fireLocaleChanged() {
if (localeChangeListeners.size() == 0)
return;
LocaleChangeListener[] listeners = getLocaleChangeListeners();
LocaleChangeEvent evt = new LocaleChangeEvent(this,getLocale());
for (int i=0;i<listeners.length;i++)
listeners[i].localeChanged(evt);
}
/** This Listeners is for the bundles only, it will ensure the bundles are always
notified first.
*/
void addLocaleChangeListenerFirst(LocaleChangeListener listener) {
localeChangeListeners.add(0,listener);
}
}
| 04900db4-clienttest | src/org/rapla/components/xmlbundle/impl/LocaleSelectorImpl.java | Java | gpl3 | 3,269 |
package org.rapla.components.xmlbundle.impl;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.Charset;
import java.util.Enumeration;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Properties;
import java.util.ResourceBundle;
import java.util.Set;
import java.util.Vector;
public class PropertyResourceBundleWrapper extends ResourceBundle {
private Map<String,Object> lookup;
String name;
static Charset charset = Charset.forName("UTF-8");
@SuppressWarnings({ "unchecked", "rawtypes" })
public PropertyResourceBundleWrapper(InputStream stream,String name) throws IOException {
Properties properties = new Properties();
properties.load(new InputStreamReader(stream, charset));
lookup = new LinkedHashMap(properties);
this.name = name;
}
public String getName()
{
return name;
}
// We make the setParent method public, so that we can use it in I18nImpl
public void setParent(ResourceBundle parent) {
super.setParent(parent);
}
// Implements java.util.ResourceBundle.handleGetObject; inherits javadoc specification.
public Object handleGetObject(String key) {
if (key == null) {
throw new NullPointerException();
}
return lookup.get(key);
}
/**
* Returns an <code>Enumeration</code> of the keys contained in
* this <code>ResourceBundle</code> and its parent bundles.
*
* @return an <code>Enumeration</code> of the keys contained in
* this <code>ResourceBundle</code> and its parent bundles.
* @see #keySet()
*/
public Enumeration<String> getKeys() {
ResourceBundle parent = this.parent;
Set<String> set = new LinkedHashSet<String>(lookup.keySet());
if ( parent != null)
{
set.addAll( parent.keySet());
}
Vector<String> vector = new Vector<String>(set);
Enumeration<String> enum1 = vector.elements();
return enum1;
}
/**
* Returns a <code>Set</code> of the keys contained
* <em>only</em> in this <code>ResourceBundle</code>.
*
* @return a <code>Set</code> of the keys contained only in this
* <code>ResourceBundle</code>
* @since 1.6
* @see #keySet()
*/
protected Set<String> handleKeySet() {
return lookup.keySet();
}
// ==================privates====================
}
| 04900db4-clienttest | src/org/rapla/components/xmlbundle/impl/PropertyResourceBundleWrapper.java | Java | gpl3 | 2,578 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.components.xmlbundle.impl;
import java.util.Collections;
import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;
class DictionaryEntry {
String key;
Map<String,String> translations = Collections.synchronizedMap(new TreeMap<String,String>());
public DictionaryEntry(String key) {
this.key = key;
}
public void add(String lang,String value) {
translations.put(lang,value);
}
public String getKey() {
return key;
}
public String get(String lang) {
return translations.get(lang);
}
public String get(String lang,String defaultLang) {
String content = translations.get(lang);
if ( content == null) {
content = translations.get(defaultLang);
} // end of if ()
if ( content == null) {
Iterator<String> it = translations.values().iterator();
content = it.next();
}
return content;
}
public String[] availableLanguages() {
String[] result = new String[translations.keySet().size()];
Iterator<String> it = translations.keySet().iterator();
int i = 0;
while ( it.hasNext()) {
result[i++] = it.next();
}
return result;
}
}
| 04900db4-clienttest | src/org/rapla/components/xmlbundle/impl/DictionaryEntry.java | Java | gpl3 | 2,234 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.components.xmlbundle;
import java.util.EventObject;
import java.util.Locale;
public class LocaleChangeEvent extends EventObject{
private static final long serialVersionUID = 1L;
Locale locale;
public LocaleChangeEvent(Object source,Locale locale) {
super(source);
this.locale = locale;
}
public Locale getLocale() {
return locale;
}
}
| 04900db4-clienttest | src/org/rapla/components/xmlbundle/LocaleChangeEvent.java | Java | gpl3 | 1,343 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.components.xmlbundle;
import java.util.Locale;
/** If you want to change the locales during runtime put a LocaleSelector
in the base-context. Instances of I18nBundle will then register them-self
as {@link LocaleChangeListener LocaleChangeListeners}. Change the locale
with {@link #setLocale} and all bundles will try to load the appropriate resources.
*/
public interface LocaleSelector {
void addLocaleChangeListener(LocaleChangeListener listener);
void removeLocaleChangeListener(LocaleChangeListener listener);
void setLocale(Locale locale);
Locale getLocale();
void setLanguage(String language);
void setCountry(String country);
String getLanguage();
}
| 04900db4-clienttest | src/org/rapla/components/xmlbundle/LocaleSelector.java | Java | gpl3 | 1,664 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla;
import java.net.MalformedURLException;
import java.net.URL;
import org.rapla.components.util.IOUtil;
import org.rapla.components.util.JNLPUtil;
import org.rapla.framework.Configuration;
import org.rapla.framework.RaplaException;
import org.rapla.framework.StartupEnvironment;
import org.rapla.framework.internal.ConfigTools;
import org.rapla.framework.logger.ConsoleLogger;
import org.rapla.framework.logger.Logger;
final public class RaplaStartupEnvironment implements StartupEnvironment
{
private int startupMode = CONSOLE;
//private LoadingProgress progressbar;
private Logger bootstrapLogger = new ConsoleLogger( ConsoleLogger.LEVEL_WARN );
private URL configURL;
private URL contextRootURL;
private URL downloadURL;
public Configuration getStartupConfiguration() throws RaplaException
{
return ConfigTools.createConfig( getConfigURL().toExternalForm() );
}
public URL getConfigURL() throws RaplaException
{
if ( configURL != null )
{
return configURL;
}
else
{
return ConfigTools.configFileToURL( null, "rapla.xconf" );
}
}
public Logger getBootstrapLogger()
{
return bootstrapLogger;
}
public void setStartupMode( int startupMode )
{
this.startupMode = startupMode;
}
/* (non-Javadoc)
* @see org.rapla.framework.IStartupEnvironment#getStartupMode()
*/
public int getStartupMode()
{
return startupMode;
}
public void setBootstrapLogger( Logger logger )
{
bootstrapLogger = logger;
}
public void setConfigURL( URL configURL )
{
this.configURL = configURL;
}
public URL getContextRootURL() throws RaplaException
{
if ( contextRootURL != null )
return contextRootURL;
return IOUtil.getBase( getConfigURL() );
}
public void setContextRootURL(URL contextRootURL)
{
this.contextRootURL = contextRootURL;
}
public URL getDownloadURL() throws RaplaException
{
if ( downloadURL != null )
{
return downloadURL;
}
if ( startupMode == WEBSTART )
{
try
{
return JNLPUtil.getCodeBase();
}
catch ( Exception e )
{
throw new RaplaException( e );
}
}
else
{
URL base = IOUtil.getBase( getConfigURL() );
if ( base != null)
{
return base;
}
try
{
return new URL( "http://localhost:8051" );
}
catch ( MalformedURLException e )
{
throw new RaplaException( "Invalid URL" );
}
}
}
public void setDownloadURL( URL downloadURL )
{
this.downloadURL = downloadURL;
}
}
| 04900db4-clienttest | src/org/rapla/RaplaStartupEnvironment.java | Java | gpl3 | 3,889 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui;
import org.rapla.entities.Named;
import org.rapla.entities.configuration.Preferences;
import org.rapla.framework.RaplaException;
import org.rapla.gui.toolkit.RaplaWidget;
public interface OptionPanel extends RaplaWidget, Named {
void setPreferences(Preferences preferences);
/** commits the changes in the option Dialog.*/
void commit() throws RaplaException;
/** called when the option Panel is selected for displaying.*/
void show() throws RaplaException;
}
| 04900db4-clienttest | src/org/rapla/gui/OptionPanel.java | Java | gpl3 | 1,451 |
package org.rapla.gui;
import java.awt.Component;
import java.awt.Point;
import javax.swing.JComponent;
import org.rapla.framework.RaplaException;
import org.rapla.gui.toolkit.DialogUI;
public interface InfoFactory
{
<T> JComponent createInfoComponent( T object ) throws RaplaException;
/** same as getToolTip(obj, true) */
<T> String getToolTip( T obj );
/** @param wrapHtml wraps an html Page arround the tooltip */
<T> String getToolTip( T obj, boolean wrapHtml );
<T> void showInfoDialog( T object, Component owner ) throws RaplaException;
<T> void showInfoDialog( T object, Component owner, Point point ) throws RaplaException;
DialogUI createDeleteDialog( Object[] deletables, Component owner ) throws RaplaException;
} | 04900db4-clienttest | src/org/rapla/gui/InfoFactory.java | Java | gpl3 | 767 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.toolkit;
import javax.swing.JComponent;
/** Should be implemented by all rapla-gui-components that have a view.*/
public interface RaplaWidget {
public JComponent getComponent();
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/RaplaWidget.java | Java | gpl3 | 1,145 |
package org.rapla.gui.toolkit;
import javax.swing.MenuElement;
/** Adds an id to the standard Swing Menu Component as JSeperator, JMenuItem and JMenu*/
public interface IdentifiableMenuEntry
{
String getId();
MenuElement getMenuElement();
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/IdentifiableMenuEntry.java | Java | gpl3 | 252 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.toolkit;
import java.net.URL;
import javax.swing.JTextPane;
final public class HTMLView extends JTextPane {
private static final long serialVersionUID = 1L;
public HTMLView() {
setOpaque(false);
setEditable(false);
setContentType("text/html");
setDefaultDocBase();
}
public static String DEFAULT_STYLE =
"body {font-family:SansSerif;font-size:12;}\n"
+ ".infotable{padding:0px;margin:0px;}\n"
+ ".label {vertical-align:top;}\n"
+ ".value {vertical-align:top;}\n"
;
private static URL base;
private static Exception error = null;
/** will only work for resources inside the same jar as org/rapla/gui/images/repeating.png */
private void setDefaultDocBase() {
if (base == null && error == null) {
try {
String marker = "org/rapla/gui/images/repeating.png";
URL url= HTMLView.class.getClassLoader().getResource(marker);
if (url == null) {
System.err.println("Marker not found " + marker);
return;
}
//System.out.println("resource:" + url);
String urlPath = url.toString();
base = new URL(urlPath.substring(0,urlPath.lastIndexOf(marker)));
//System.out.println("document-base:" + base);
} catch (Exception ex) {
error = ex;
System.err.println("Can't get document-base: " + ex + " in class: " + HTMLView.class.getName());
}
}
if (error == null)
((javax.swing.text.html.HTMLDocument)getDocument()).setBase(base);
}
/** calls setText(createHTMLPage(body)) */
public void setBody(String body) {
try {
setText(createHTMLPage(body));
} catch (Exception ex) {
setText(body);
}
}
static public String createHTMLPage(String body,String styles) {
StringBuffer buf = new StringBuffer();
buf.append("<html>");
buf.append("<head>");
buf.append("<style type=\"text/css\">");
buf.append(styles);
buf.append("</style>");
buf.append("</head>");
buf.append("<body>");
buf.append(body);
buf.append("</body>");
buf.append("</html>");
return buf.toString();
}
static public String createHTMLPage(String body) {
return createHTMLPage(body,DEFAULT_STYLE);
}
public void setText( String message, boolean packText )
{
if (packText) {
JEditorPaneWorkaround.packText(this, message ,600);
} else {
setText( message);
}
}
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/HTMLView.java | Java | gpl3 | 3,686 |
package org.rapla.gui.toolkit;
import java.awt.Component;
import javax.swing.JComponent;
import javax.swing.JMenuItem;
/** JPopupMenu and JMenu don't have a common interface, so this is a common interface
* for RaplaMenu and RaplaPopupMenu
*/
public interface MenuInterface {
JMenuItem add(JMenuItem item);
void remove(JMenuItem item);
void addSeparator();
void removeAll();
void removeAllBetween(String startId, String endId);
void insertAfterId(Component component,String id);
void insertBeforeId(JComponent component,String id);
} | 04900db4-clienttest | src/org/rapla/gui/toolkit/MenuInterface.java | Java | gpl3 | 567 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.toolkit;
import java.awt.Component;
import javax.swing.JComponent;
import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
public class RaplaPopupMenu extends JPopupMenu implements MenuInterface {
private static final long serialVersionUID = 1L;
public RaplaPopupMenu() {
super();
}
private int getIndexOfEntryWithId(String id) {
int size = getComponentCount();
for ( int i=0;i< size;i++)
{
Component component = getComponent( i );
if ( component instanceof IdentifiableMenuEntry) {
IdentifiableMenuEntry comp = (IdentifiableMenuEntry) component;
if ( id != null && id.equals( comp.getId() ) )
{
return i;
}
}
}
return -1;
}
public void removeAllBetween(String startId, String endId) {
int startIndex = getIndexOfEntryWithId( startId );
int endIndex = getIndexOfEntryWithId( endId);
if ( startIndex < 0 || endIndex < 0 )
return;
for ( int i= startIndex + 1; i< endIndex ;i++)
{
remove( startIndex );
}
}
public void insertAfterId(Component component,String id) {
if ( id == null) {
add ( component );
} else {
int index = getIndexOfEntryWithId( id ) ;
insert( component, index +1);
}
}
public void insertBeforeId(JComponent component,String id) {
int index = getIndexOfEntryWithId( id );
insert( component, index);
}
public void remove( JMenuItem item )
{
super.remove( item );
}
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/RaplaPopupMenu.java | Java | gpl3 | 2,642 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas, Bettina Lademann |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.toolkit;
import java.util.Locale;
import javax.swing.DefaultComboBoxModel;
import javax.swing.JComboBox;
import org.rapla.components.calendarview.WeekdayMapper;
/** ComboBox that displays the weekdays in long format
@see WeekdayMapper
*/
public final class WeekdayChooser extends JComboBox {
private static final long serialVersionUID = 1L;
WeekdayMapper mapper;
public WeekdayChooser() {
this( Locale.getDefault() );
}
public WeekdayChooser(Locale locale) {
setLocale(locale);
}
@SuppressWarnings("unchecked")
public void setLocale(Locale locale) {
super.setLocale(locale);
if (locale == null)
return;
mapper = new WeekdayMapper(locale);
DefaultComboBoxModel aModel = new DefaultComboBoxModel(mapper.getNames());
setModel(aModel);
}
public void selectWeekday(int weekday) {
setSelectedIndex(mapper.indexForDay(weekday));
}
/** returns the selected day or -1 if no day is selected.
@see java.util.Calendar
*/
public int getSelectedWeekday() {
if (getSelectedIndex() == -1)
return -1;
else
return mapper.dayForIndex(getSelectedIndex());
}
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/WeekdayChooser.java | Java | gpl3 | 2,188 |
/**
*
*/
package org.rapla.gui.toolkit;
import java.awt.Color;
import java.awt.Component;
import java.awt.Graphics;
import java.awt.Insets;
import javax.swing.border.Border;
public class EmptyLineBorder implements Border {
Insets insets = new Insets(0,0,0,0);
Color COLOR = Color.LIGHT_GRAY;
public void paintBorder( Component c, Graphics g, int x, int y, int width, int height )
{
g.setColor( COLOR );
g.drawLine(30,8, c.getWidth(), 8);
}
public Insets getBorderInsets( Component c )
{
return insets;
}
public boolean isBorderOpaque()
{
return true;
}
} | 04900db4-clienttest | src/org/rapla/gui/toolkit/EmptyLineBorder.java | Java | gpl3 | 639 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.toolkit;
import java.awt.AWTEvent;
import java.awt.event.WindowEvent;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyVetoException;
import java.beans.VetoableChangeListener;
import java.util.ArrayList;
import javax.swing.JFrame;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
public class RaplaFrame extends JFrame
implements
FrameController
{
private static final long serialVersionUID = 1L;
FrameControllerList frameList = null;
ArrayList<VetoableChangeListener> listenerList = new ArrayList<VetoableChangeListener>();
/**
This frame registers itself on the FrameControllerList on <code>contextualzize</code>
and unregisters upon <code>dispose()</code>.
Use addVetoableChangeListener() to get notified on a window-close event (and throw
a veto if necessary.
* @throws RaplaException
*/
public RaplaFrame(RaplaContext sm) throws RaplaException {
enableEvents(AWTEvent.WINDOW_EVENT_MASK);
/*
AWTAdapterFactory fact =
AWTAdapterFactory.getFactory();
if (fact != null) {
fact.createFocusAdapter( this ).ignoreFocusComponents(new FocusTester() {
public boolean accept(Component component) {
return !(component instanceof HTMLView) ;
}
});
}*/
frameList = sm.lookup(FrameControllerList.class);
frameList.add(this);
}
protected void processWindowEvent(WindowEvent e) {
if (e.getID() == WindowEvent.WINDOW_CLOSING) {
try {
fireFrameClosing();
close();
} catch (PropertyVetoException ex) {
return;
}
}
super.processWindowEvent(e);
}
public void addVetoableChangeListener(VetoableChangeListener listener) {
listenerList.add(listener);
}
public void removeVetoableChangeListener(VetoableChangeListener listener) {
listenerList.remove(listener);
}
public VetoableChangeListener[] getVetoableChangeListeners() {
return listenerList.toArray(new VetoableChangeListener[]{});
}
protected void fireFrameClosing() throws PropertyVetoException {
if (listenerList.size() == 0)
return;
// The propterychange event indicates that the window
// is closing.
PropertyChangeEvent evt = new PropertyChangeEvent(
this
,"visible"
,new Boolean(true)
,new Boolean(false)
)
;
VetoableChangeListener[] listeners = getVetoableChangeListeners();
for (int i = 0;i<listeners.length; i++) {
listeners[i].vetoableChange(evt);
}
}
final public void place(boolean placeRelativeToMain,boolean packFrame) {
//Validate frames that have preset sizes
//Pack frames that have useful preferred size info, e.g. from their layout
if (packFrame) {
this.pack();
} else {
this.validate();
}
if (placeRelativeToMain)
frameList.placeRelativeToMain(this);
}
public void dispose() {
super.dispose();
frameList.remove(this);
}
public void close() {
dispose();
}
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/RaplaFrame.java | Java | gpl3 | 4,562 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.toolkit;
/** This exception is thrown by the ErrorDialog and
is used to test error-messages.
@see ErrorDialog */
final public class ErrorDialogException extends RuntimeException {
private static final long serialVersionUID = 1L;
int type;
/** @param type The type of the Error-Message.
@see ErrorDialog */
public ErrorDialogException(Throwable throwable,int type) {
super(String.valueOf(type),throwable);
this.type = type;
}
/** returns the type of the Error-Message.
@see ErrorDialog */
public int getType() {
return type;
}
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/ErrorDialogException.java | Java | gpl3 | 1,578 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.toolkit;
import java.awt.Dimension;
import java.awt.FontMetrics;
import javax.swing.JEditorPane;
/** #BUGFIX
* This is a workaround for a bug in the Sun JDK
* that don't calculate the correct size of an JEditorPane.
* The first version of this workaround caused a NullPointerException
* on JDK 1.2.2 sometimes, so this is a workaround for a workaround:
* A zero-sized component is added to the StartFrame- Window
* This component will be used to calculate the size of
* the JEditorPane Components.
*/
final class JEditorPaneWorkaround {
static public void packText(JEditorPane jText,String text,int width) {
int height;
if (width <=0 )
return;
try {
jText.setSize(new Dimension(width,100));
jText.setText(text);
height = jText.getPreferredScrollableViewportSize().height;
} catch ( NullPointerException e) {
jText.setSize(new Dimension(width,100));
jText.setText(text);
FontMetrics fm = jText.getFontMetrics(jText.getFont());
height = fm.stringWidth(text)/width * fm.getHeight() + 50;
} // end of try-catch
jText.setSize(new Dimension(width,height));
jText.setPreferredSize(new Dimension(width,height));
}
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/JEditorPaneWorkaround.java | Java | gpl3 | 2,220 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.toolkit;
import java.awt.AWTEvent;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dialog;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.GridLayout;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.KeyEvent;
import java.awt.event.WindowEvent;
import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.BorderFactory;
import javax.swing.BoxLayout;
import javax.swing.Icon;
import javax.swing.JComponent;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.KeyStroke;
import javax.swing.LayoutFocusTraversalPolicy;
import org.rapla.components.xmlbundle.I18nBundle;
import org.rapla.components.xmlbundle.LocaleChangeEvent;
import org.rapla.components.xmlbundle.LocaleChangeListener;
import org.rapla.components.xmlbundle.LocaleSelector;
import org.rapla.facade.RaplaComponent;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
public class DialogUI extends JDialog
implements
FrameController
,LocaleChangeListener
{
private static final long serialVersionUID = 1L;
protected RaplaButton[] buttons;
protected JComponent content;
private JPanel jPanelButtonFrame = new JPanel();
private JLabel label = null;
private boolean useDefaultOptions = false;
private boolean bClosed = false;
private Component parent;
private int selectedIndex = -1;
private FrameControllerList frameList = null;
protected boolean packFrame = true;
private LocaleSelector localeSelector;
private I18nBundle i18n;
private RaplaContext context = null;
private ButtonListener buttonListener = new ButtonListener();
private boolean m_modal;
private Action abortAction = new AbstractAction() {
private static final long serialVersionUID = 1L;
public void actionPerformed(ActionEvent evt) {
close();
}
};
public static Component getOwnerWindow(Component component) {
if (component == null)
return getInvisibleSharedFrame();
if (component instanceof Dialog)
return component;
if (component instanceof Frame)
return component;
Container owner = component.getParent();
return getOwnerWindow(owner);
}
private static String[] getDefaultOptions() {
return new String[] {"OK"};
}
public DialogUI(RaplaContext sm, Dialog parent) throws RaplaException {
super( parent );
service( sm );
}
public DialogUI(RaplaContext sm, Frame parent) throws RaplaException {
super( parent );
service( sm );
}
/** @see #getInvisibleSharedFrame */
private static JFrame invisibleSharedFrame;
/** @see #getInvisibleSharedFrame */
private static int referenceCounter = 0;
/** If a dialogs owner is null this frame will be used as owner.
A call to this method will increase the referenceCounter.
A new shared frame is created when the referenceCounter is 1.
The frame gets disposed if the refernceCounter is 0.
The referenceCounter is decreased in the dispose method.
*/
private static Frame getInvisibleSharedFrame() {
referenceCounter ++;
if (referenceCounter == 1)
{
invisibleSharedFrame = new JFrame();
invisibleSharedFrame.setSize(400,400);
FrameControllerList.centerWindowOnScreen(invisibleSharedFrame);
}
return invisibleSharedFrame;
}
public static DialogUI create(RaplaContext context,Component owner,boolean modal,JComponent content,String[] options) throws RaplaException {
DialogUI dlg;
Component topLevel = getOwnerWindow(owner);
if ( topLevel instanceof Dialog)
dlg = new DialogUI(context,(Dialog)topLevel);
else
dlg = new DialogUI(context,(Frame)topLevel);
dlg.parent = owner;
dlg.init(modal,content,options);
return dlg;
}
public static DialogUI create(RaplaContext context,Component owner,boolean modal,String title,String text,String[] options) throws RaplaException {
DialogUI dlg= create(context,owner,modal,new JPanel(),options);
dlg.createMessagePanel(text);
dlg.setTitle(title);
return dlg;
}
public static DialogUI create(RaplaContext context,Component owner,boolean modal,String title,String text) throws RaplaException {
DialogUI dlg = create(context,owner,modal,title,text,getDefaultOptions());
dlg.useDefaultOptions = true;
return dlg;
}
public RaplaButton getButton(int index) {
return buttons[index];
}
protected void init(boolean modal,JComponent content,String[] options) {
super.setModal(modal);
m_modal = modal;
this.setFocusTraversalPolicy( new LayoutFocusTraversalPolicy()
{
private static final long serialVersionUID = 1L;
protected boolean accept(Component component) {
return !(component instanceof HTMLView) ;
}
} );
this.content = content;
this.enableEvents(AWTEvent.WINDOW_EVENT_MASK);
JPanel contentPane = (JPanel) this.getContentPane();
contentPane.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
contentPane.setLayout(new BorderLayout());
contentPane.add(content, BorderLayout.CENTER);
contentPane.add(jPanelButtonFrame,BorderLayout.SOUTH);
jPanelButtonFrame.setLayout(new FlowLayout(FlowLayout.CENTER));
setButtons(options);
contentPane.setVisible(true);
/*
We enable the escape-key for executing the abortCmd. Many thanks to John Zukowski.
<a href="http://www.javaworld.com/javaworld/javatips/jw-javatip72.html">Java-Tip 72</a>
*/
KeyStroke stroke = KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0);
contentPane.getActionMap().put("abort",buttonListener);
contentPane.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(stroke,"abort");
}
protected void setButtons(String[] options) {
buttons = new RaplaButton[options.length];
for (int i=0;i<options.length;i++) {
buttons[i] = new RaplaButton(options[i],RaplaButton.DEFAULT);
buttons[i].addActionListener(buttonListener);
buttons[i].setAction(abortAction);
buttons[i].setDefaultCapable(true);
}
jPanelButtonFrame.removeAll();
jPanelButtonFrame.add(createButtonPanel());
if (options.length>0)
setDefault(0);
jPanelButtonFrame.invalidate();
}
protected JComponent createButtonPanel() {
GridLayout gridLayout = new GridLayout();
JPanel jPanelButtons = new JPanel();
jPanelButtons.setLayout(gridLayout);
gridLayout.setRows(1);
gridLayout.setHgap(10);
gridLayout.setVgap(5);
gridLayout.setColumns(buttons.length);
for (int i=0;i<buttons.length;i++) {
jPanelButtons.add(buttons[i]);
}
return jPanelButtons;
}
class ButtonListener extends AbstractAction {
private static final long serialVersionUID = 1L;
public void actionPerformed(ActionEvent evt) {
for (int i=0;i<buttons.length;i++) {
if (evt.getSource() == buttons[i]) {
selectedIndex = i;
return;
}
}
selectedIndex = -1;
abortAction.actionPerformed(new ActionEvent(DialogUI.this, ActionEvent.ACTION_PERFORMED,""));
}
}
public int getSelectedIndex() {
return selectedIndex;
}
public void setAbortAction(Action action) {
abortAction = action;
}
private void service(RaplaContext context) throws RaplaException {
this.context = context;
i18n = context.lookup(RaplaComponent.RAPLA_RESOURCES);
if (useDefaultOptions) {
if (buttons.length > 1) {
getButton(0).setText(i18n.getString("ok"));
getButton(1).setIcon(i18n.getIcon("icon.abort"));
getButton(1).setText(i18n.getString("abort"));
} else {
getButton(0).setText(i18n.getString("ok"));
}
}
localeSelector = context.lookup( LocaleSelector.class);
localeSelector.addLocaleChangeListener(this);
frameList = context.lookup(FrameControllerList.class);
frameList.add(this);
}
protected I18nBundle getI18n() {
return i18n;
}
protected RaplaContext getContext() {
return context;
}
/** the default implementation does nothing. Override this method
if you want to react on a locale change.*/
public void localeChanged(LocaleChangeEvent evt) {
}
public void setIcon(Icon icon) {
try {
if (label != null)
label.setIcon(icon);
} catch (Exception ex) {
}
}
FrameControllerList getFrameList() {
return frameList;
}
/** close and set the selectedIndex to the index Value. Usefull for modal dialogs*/
public void close(int index) {
selectedIndex = index;
close();
}
// The implementation of the FrameController Interface
public void close() {
if (bClosed)
return;
dispose();
}
public void dispose() {
bClosed = true;
try {
if (getOwner() == invisibleSharedFrame)
referenceCounter --;
super.dispose();
if (referenceCounter == 0 && invisibleSharedFrame!= null)
invisibleSharedFrame.dispose();
if (frameList != null)
frameList.remove(this);
if ( localeSelector != null )
localeSelector.removeLocaleChangeListener(this);
} catch (Exception ex) {
ex.printStackTrace();
}
}
// The implementation of the DialogController Interface
public void setDefault(int index) {
this.getRootPane().setDefaultButton(getButton(index));
}
public void setTitle(String title) {
super.setTitle(title);
}
public boolean isClosed() {
return bClosed;
}
public void start(Point p) {
//Validate frames that have preset sizes
//Pack frames that have useful preferred size info, e.g. from their layout
if (packFrame) {
this.pack();
} else {
this.validate();
}
if (parent != null) {
FrameControllerList.placeRelativeToComponent(this,parent,p);
} else {
getFrameList().placeRelativeToMain(this);
}
if ( initFocusComponent != null)
{
initFocusComponent.requestFocus();
}
// okButton.requestFocus();
bClosed = false;
super.setVisible( true );
if (m_modal) {
dispose();
}
}
Component initFocusComponent;
public void setInitFocus(Component component)
{
initFocusComponent = component;
}
public void start() {
start(null);
}
public void startNoPack() {
packFrame = false;
start(null);
}
protected void processWindowEvent(WindowEvent e) {
if (e.getID() == WindowEvent.WINDOW_CLOSING) {
abortAction.actionPerformed(new ActionEvent(this,ActionEvent.ACTION_PERFORMED,""));
} else if (e.getID() == WindowEvent.WINDOW_CLOSED) {
close();
}
}
private void createMessagePanel(String text) {
JPanel panel = (JPanel) content;
panel.setLayout(new BoxLayout(panel,BoxLayout.X_AXIS));
label = new JLabel();
HTMLView textView = new HTMLView();
JEditorPaneWorkaround.packText(textView, HTMLView.createHTMLPage(text) ,450);
JPanel jContainer = new JPanel();
jContainer.setLayout(new BorderLayout());
panel.add(jContainer);
jContainer.add(label,BorderLayout.NORTH);
panel.add(textView);
}
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/DialogUI.java | Java | gpl3 | 13,222 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.toolkit;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Dialog;
import java.awt.Dimension;
import java.awt.Frame;
import javax.swing.ActionMap;
import javax.swing.BorderFactory;
import javax.swing.JComponent;
import javax.swing.JPanel;
import org.rapla.components.layout.TableLayout;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
/** displays a wizard dialog with four buttons and a HTML help.
*/
public class WizardDialog extends DialogUI {
private static final long serialVersionUID = 1L;
protected WizardPanel wizardPanel;
protected HTMLView helpView;
static public String[] options = new String[] {
WizardPanel.ABORT
,WizardPanel.PREV
,WizardPanel.NEXT
,WizardPanel.FINISH
};
public static WizardDialog createWizard(RaplaContext sm,Component owner,boolean modal) throws RaplaException {
WizardDialog dlg;
Component topLevel = getOwnerWindow(owner);
if (topLevel instanceof Dialog)
dlg = new WizardDialog(sm,(Dialog)topLevel);
else
dlg = new WizardDialog(sm,(Frame)topLevel);
dlg.init(modal);
return dlg;
}
protected WizardDialog(RaplaContext sm,Dialog owner) throws RaplaException {
super(sm,owner);
}
protected WizardDialog(RaplaContext sm,Frame owner) throws RaplaException {
super(sm,owner);
}
private void init(boolean modal) {
super.init(modal, new JPanel(), options);
content.setLayout(new BorderLayout());
helpView = new HTMLView();
helpView.setBorder(
BorderFactory.createCompoundBorder(
BorderFactory.createEmptyBorder(0,0,3,0)
, BorderFactory.createCompoundBorder(
BorderFactory.createEtchedBorder()
,BorderFactory.createEmptyBorder(4,4,4,4)
)
)
);
helpView.setOpaque(true);
content.add(helpView,BorderLayout.WEST);
helpView.setPreferredSize(new Dimension(220,300));
packFrame=false;
}
protected JComponent createButtonPanel() {
TableLayout tableLayout = new TableLayout(new double[][] {
{10,0.2,10,0.2,5,0.4,10,0.2,10}
,{5,TableLayout.PREFERRED,5}
});
JPanel jPanelButtons = new JPanel();
jPanelButtons.setLayout(tableLayout);
jPanelButtons.add(buttons[0],"1,1,l,c");
jPanelButtons.add(buttons[1],"3,1,r,c");
jPanelButtons.add(buttons[2],"5,1,l,c");
jPanelButtons.add(buttons[3],"7,1");
return jPanelButtons;
}
public WizardPanel getActivePanel() {
return wizardPanel;
}
public void start(WizardPanel newPanel) {
if (!isVisible())
start();
if (wizardPanel != null)
content.remove(wizardPanel.getComponent());
wizardPanel = newPanel;
if (wizardPanel == null)
close();
content.add(wizardPanel.getComponent(),BorderLayout.CENTER);
wizardPanel.getComponent().setBorder(BorderFactory.createEmptyBorder(0,4,0,4));
if (wizardPanel.getHelp() != null)
helpView.setBody(wizardPanel.getHelp());
String defaultAction = wizardPanel.getDefaultAction();
content.revalidate();
content.repaint();
// set actions
ActionMap actionMap = wizardPanel.getActionMap();
getButton(0).setAction(actionMap.get(WizardPanel.ABORT));
getButton(0).setActionCommand(WizardPanel.ABORT);
if (defaultAction.equals(WizardPanel.ABORT))
setDefault(0);
getButton(1).setAction(actionMap.get(WizardPanel.PREV));
getButton(1).setActionCommand(WizardPanel.PREV);
if (defaultAction.equals(WizardPanel.PREV))
setDefault(1);
getButton(2).setAction(actionMap.get(WizardPanel.NEXT));
getButton(2).setActionCommand(WizardPanel.NEXT);
if (defaultAction.equals(WizardPanel.NEXT))
setDefault(2);
getButton(3).setAction(actionMap.get(WizardPanel.FINISH));
getButton(3).setActionCommand(WizardPanel.FINISH);
if (defaultAction.equals(WizardPanel.FINISH))
setDefault(3);
}
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/WizardDialog.java | Java | gpl3 | 5,416 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.toolkit;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.lang.reflect.Method;
import javax.swing.DefaultListModel;
import javax.swing.JCheckBox;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import org.rapla.facade.RaplaComponent;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
final public class ErrorDialog extends RaplaComponent {
/**
* @param context
* @throws RaplaException
*/
public ErrorDialog(RaplaContext context) throws RaplaException {
super(context);
}
public static final int WARNING_MESSAGE = 1;
public static final int ERROR_MESSAGE = 2;
public static final int EXCEPTION_MESSAGE = 3;
/** This is for the test-cases only. If this flag is set
the ErrorDialog throws an ErrorDialogException instead of
displaying the dialog. This is useful for testing. */
public static boolean THROW_ERROR_DIALOG_EXCEPTION = false;
private void test(String message,int type) {
if (THROW_ERROR_DIALOG_EXCEPTION) {
throw new ErrorDialogException(new RaplaException(message),type);
}
}
private void test(Throwable ex,int type) {
if (THROW_ERROR_DIALOG_EXCEPTION) {
throw new ErrorDialogException(ex,type);
}
}
private String createTitle(String key) {
return getI18n().format("exclamation.format",getI18n().getString(key));
}
public void show(String message) {
test(message,ERROR_MESSAGE);
try {
showDialog(createTitle("error"),message,null);
} catch (Exception ex) {
getLogger().error(message);
}
}
public void showWarningDialog(String message,Component owner) {
test(message,WARNING_MESSAGE);
try {
showWarningDialog(createTitle("warning"),message,owner);
} catch (Exception ex) {
getLogger().error(message);
}
}
static private String getCause(Throwable e) {
String message = e.getMessage();
if (message != null && message.length() > 0) {
return message;
}
Throwable cause = e.getCause();
if (cause != null)
message = getCause( cause );
return message;
}
static public String getMessage(Throwable e) {
String message = getCause(e);
if (message == null || message.length() == 0)
message = e.toString();
return message;
}
public void showExceptionDialog(Throwable e,Component owner) {
test(e,EXCEPTION_MESSAGE);
try {
String message = getMessage(e);
if ( getLogger() != null )
getLogger().error(message, e);
JPanel component = new JPanel();
component.setLayout( new BorderLayout());
HTMLView textView = new HTMLView();
JEditorPaneWorkaround.packText(textView, HTMLView.createHTMLPage(message) ,450);
component.add( textView,BorderLayout.NORTH);
boolean showStacktrace = true;
Throwable nestedException = e;
do
{
if ( nestedException instanceof RaplaException)
{
showStacktrace = false;
nestedException = ((RaplaException) nestedException).getCause();
}
else
{
showStacktrace = true;
}
}
while ( nestedException != null && !showStacktrace);
if ( showStacktrace)
{
try {
Method getStackTrace =Exception.class.getMethod("getStackTrace",new Class[] {});
final Object[] stackTrace = (Object[])getStackTrace.invoke( e, new Object[] {} );
final JList lister = new JList( );
final JScrollPane list = new JScrollPane(lister, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
list.setBorder( null);
JPanel stackTracePanel = new JPanel();
final JCheckBox stackTraceChooser = new JCheckBox("show stacktrace");
stackTracePanel.setLayout( new BorderLayout());
stackTracePanel.add( stackTraceChooser, BorderLayout.NORTH);
stackTracePanel.add( list, BorderLayout.CENTER);
stackTracePanel.setPreferredSize( new Dimension(300,200));
stackTracePanel.setMinimumSize( new Dimension(300,200));
component.add( stackTracePanel,BorderLayout.CENTER);
lister.setVisible( false );
stackTraceChooser.addActionListener( new ActionListener() {
@SuppressWarnings("unchecked")
public void actionPerformed(ActionEvent e) {
DefaultListModel model =new DefaultListModel();
if (stackTraceChooser.isSelected() ) {
for ( int i=0;i< stackTrace.length;i++) {
model.addElement( stackTrace[i]);
}
}
lister.setModel( model );
lister.setVisible( stackTraceChooser.isSelected());
}
});
} catch (Exception ex) {
}
}
DialogUI dlg = DialogUI.create(getContext(),owner,true,component, new String[] {getI18n().getString("ok")});
dlg.setTitle(createTitle("error"));
dlg.setIcon(getI18n().getIcon("icon.error"));
dlg.start();
} catch (Exception ex) {
getLogger().error( e.getMessage(), e);
getLogger().error("Can't show errorDialog " + ex);
}
}
private void showDialog(String title, String message,Component owner) {
try {
DialogUI dlg = DialogUI.create(getContext(),owner,true,title,message);
dlg.setIcon(getI18n().getIcon("icon.error"));
dlg.start();
} catch (Exception ex2) {
getLogger().error(ex2.getMessage());
}
}
public void showWarningDialog(String title, String message,Component owner) {
try {
DialogUI dlg = DialogUI.create(getContext(),owner,true,title,message);
dlg.setIcon(getI18n().getIcon("icon.warning"));
dlg.start();
} catch (Exception ex2) {
getLogger().error(ex2.getMessage());
}
}
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/ErrorDialog.java | Java | gpl3 | 7,820 |
package org.rapla.gui.toolkit;
import javax.swing.JComboBox;
import org.rapla.entities.Named;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaContextException;
import org.rapla.framework.RaplaLocale;
import org.rapla.gui.internal.common.NamedListCellRenderer;
public final class RaplaListComboBox extends JComboBox {
private static final long serialVersionUID = 1L;
// copied the coe from tree table
String cachedSearchKey = "";
RaplaContext context;
public RaplaListComboBox(RaplaContext context) {
init(context);
}
@SuppressWarnings("unchecked")
public RaplaListComboBox(RaplaContext context,Object[] named) {
super(named);
init(context);
}
@SuppressWarnings("unchecked")
public void init(RaplaContext context) {
this.context = context;
try {
setRenderer(new NamedListCellRenderer(context.lookup(RaplaLocale.class).getLocale()));
} catch (RaplaContextException e) {
throw new IllegalStateException(e);
}
}
protected boolean processKeyBinding(javax.swing.KeyStroke ks, java.awt.event.KeyEvent e, int condition, boolean pressed) {
// live search in current parent node
if ((Character.isLetterOrDigit(e.getKeyChar())) && ks.isOnKeyRelease()) {
char keyChar = e.getKeyChar();
// search term
String search = ("" + keyChar).toLowerCase();
// try to find node with matching searchterm plus the search before
int nextIndexMatching = getNextIndexMatching(cachedSearchKey + search);
// if we did not find anything, try to find search term only: restart!
if (nextIndexMatching <0 ) {
nextIndexMatching = getNextIndexMatching(search);
cachedSearchKey = "";
}
// if we found a node, select it, make it visible and return true
if (nextIndexMatching >=0 ) {
// store found treepath
cachedSearchKey = cachedSearchKey + search;
setSelectedIndex(nextIndexMatching);
return true;
}
cachedSearchKey = "";
return true;
}
return super.processKeyBinding(ks,e,condition,pressed);
}
private int getNextIndexMatching(String string)
{
int i = 0;
while ( i< getItemCount())
{
Object item = getItemAt( i );
String toString;
if ( item instanceof Named)
{
toString = ((Named) item).getName( getLocale());
}
else if ( item != null)
{
toString = item.toString();
}
else
{
toString = null;
}
if ( toString != null && toString.toLowerCase().startsWith( string.toLowerCase()))
{
return i;
}
i++;
}
return -1;
}
} | 04900db4-clienttest | src/org/rapla/gui/toolkit/RaplaListComboBox.java | Java | gpl3 | 3,054 |
package org.rapla.gui.toolkit;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import org.rapla.framework.Disposable;
/** Disposes an object on window close. Must be added as a WindowListener
to the target window*/
final public class DisposingTool extends WindowAdapter {
Disposable m_objectToDispose;
public DisposingTool(Disposable objectToDispose) {
m_objectToDispose = objectToDispose;
}
public void windowClosed(WindowEvent e) {
m_objectToDispose.dispose();
}
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/DisposingTool.java | Java | gpl3 | 531 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.toolkit;
import javax.swing.JTree;
public interface TreeToolTipRenderer {
public String getToolTipText(JTree table, int row);
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/TreeToolTipRenderer.java | Java | gpl3 | 1,091 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.toolkit;
import java.awt.Point;
import java.util.EventObject;
public class PopupEvent extends EventObject {
private static final long serialVersionUID = 1L;
Point m_point;
Object m_selectedObject;
public PopupEvent(Object source, Object selectedObject, Point p) {
super(source);
m_selectedObject = selectedObject;
m_point = p;
}
public Object getSelectedObject() {
return m_selectedObject;
}
public Point getPoint() {
return m_point;
}
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/PopupEvent.java | Java | gpl3 | 1,482 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.toolkit;
import java.awt.Color;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;
import javax.swing.BorderFactory;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;
import org.rapla.components.util.Tools;
/** Encapsulates the complex tree class and provides some basic functionality like
* life model exchanging while keeping the Tree state or the integration of the popup listener.
*/
final public class RaplaTree extends JScrollPane {
private static final long serialVersionUID = 1L;
ArrayList<PopupListener> m_popupListeners = new ArrayList<PopupListener>();
ArrayList<ActionListener> m_doubleclickListeners = new ArrayList<ActionListener>();
ArrayList<ChangeListener> m_changeListeners = new ArrayList<ChangeListener>();
JTree jTree = new JTree() {
private static final long serialVersionUID = 1L;
public String getToolTipText(MouseEvent evt) {
if (toolTipRenderer == null)
{
return super.getToolTipText(evt);
}
int row = getRowForLocation(evt.getX(),evt.getY());
if (row >=0)
{
return toolTipRenderer.getToolTipText(this,row);
}
return super.getToolTipText(evt);
}
public Point getToolTipLocation(MouseEvent evt) {
return new Point(getWidth(), 0);
}
/**
* Overwrite the standard method for performance reasons.
*
* @see javax.swing.JTree#getExpandedDescendants(javax.swing.tree.TreePath)
*/
// @Override
// public Enumeration getExpandedDescendants(final TreePath parent) {
// return null;
// }
};
Listener listener = new Listener();
private boolean treeSelectionListenerBlocked = false;
private boolean bMultiSelect = false;
TreePath selectedPath = null;
TreeToolTipRenderer toolTipRenderer;
public RaplaTree() {
jTree.setBorder( BorderFactory.createEtchedBorder(Color.white,new Color(178, 178, 178)));
jTree.setRootVisible(false);
jTree.setShowsRootHandles(true);
//jTree.putClientProperty("JTree.lineStyle", "None");
getViewport().add(jTree, null);
jTree.addTreeSelectionListener( listener );
jTree.addMouseListener( listener );
setMultiSelect(bMultiSelect);
}
public void setToolTipRenderer(TreeToolTipRenderer renderer) {
toolTipRenderer = renderer;
}
public void addChangeListener(ChangeListener listener) {
m_changeListeners.add(listener);
}
public void removeChangeListener(ChangeListener listener) {
m_changeListeners.remove(listener);
}
/** An ChangeEvent will be fired to every registered ChangeListener
* when the selection has changed.
*/
protected void fireValueChanged() {
if (m_changeListeners.size() == 0)
return;
ChangeListener[] listeners = getChangeListeners();
ChangeEvent evt = new ChangeEvent(this);
for (int i = 0;i<listeners.length;i++) {
listeners[i].stateChanged(evt);
}
}
public ChangeListener[] getChangeListeners() {
return m_changeListeners.toArray(new ChangeListener[]{});
}
public TreeToolTipRenderer getToolTipRenderer() {
return toolTipRenderer;
}
public void addDoubleclickListeners(ActionListener listener) {
m_doubleclickListeners.add(listener);
}
public void removeDoubleclickListeners(ActionListener listener) {
m_doubleclickListeners.remove(listener);
}
public ActionListener[] getDoubleclickListeners() {
return m_doubleclickListeners.toArray(new ActionListener[]{});
}
public void addPopupListener(PopupListener listener) {
m_popupListeners.add(listener);
}
public void removePopupListener(PopupListener listener) {
m_popupListeners.remove(listener);
}
public PopupListener[] getPopupListeners() {
return m_popupListeners.toArray(new PopupListener[]{});
}
/** An PopupEvent will be fired to every registered PopupListener
* when the popup is selected
*/
protected void firePopup(MouseEvent me) {
Point p = new Point(me.getX(), me.getY());
if (m_popupListeners.size() == 0)
return;
PopupListener[] listeners = getPopupListeners();
Object selectedObject = null;
TreePath path = getTree().getPathForLocation(p.x,p.y);
if (path != null) {
Object node = path.getLastPathComponent();
if (node != null) {
if (node instanceof DefaultMutableTreeNode)
selectedObject = ((DefaultMutableTreeNode)node).getUserObject();
}
}
Point upperLeft = getViewport().getViewPosition();
Point newPoint = new Point(p.x - upperLeft.x + 10
,p.y-upperLeft.y);
PopupEvent evt = new PopupEvent(this, selectedObject, newPoint);
for (int i = 0;i<listeners.length;i++) {
listeners[i].showPopup(evt);
}
}
protected void fireEdit(MouseEvent me) {
Point p = new Point(me.getX(), me.getY());
if (m_doubleclickListeners.size() == 0)
return;
ActionListener[] listeners = getDoubleclickListeners();
Object selectedObject = null;
TreePath path = getTree().getPathForLocation(p.x,p.y);
if (path != null) {
Object node = path.getLastPathComponent();
if (node != null) {
if (node instanceof DefaultMutableTreeNode)
{
selectedObject = ((DefaultMutableTreeNode)node).getUserObject();
}
}
}
if (selectedObject != null) {
ActionEvent evt = new ActionEvent( selectedObject, ActionEvent.ACTION_PERFORMED, "");
for (int i = 0;i<listeners.length;i++) {
listeners[i].actionPerformed(evt);
}
}
}
public JTree getTree() {
return jTree;
}
class Listener implements MouseListener,TreeSelectionListener {
public void valueChanged(TreeSelectionEvent event) {
if ( event.getSource() == jTree && ! treeSelectionListenerBlocked) {
selectedPath = event.getNewLeadSelectionPath();
fireValueChanged();
}
}
public void mouseEntered(MouseEvent me) {
}
public void mouseExited(MouseEvent me) {
}
public void mousePressed(MouseEvent me) {
if (me.isPopupTrigger())
firePopup(me);
}
public void mouseReleased(MouseEvent me) {
if (me.isPopupTrigger())
firePopup(me);
}
public void mouseClicked(MouseEvent me) {
TreePath selectionPath = jTree.getSelectionPath();
if (me.getClickCount() == 2 && selectionPath != null )
{
final Object lastPathComponent = selectionPath.getLastPathComponent();
if ( lastPathComponent instanceof TreeNode)
{
if (( (TreeNode) lastPathComponent).isLeaf())
{
fireEdit(me);
}
}
// System.out.println("mouse Clicked > 1");
// System.out.println("Button= " + me.getButton() + "Cliks= " + me.getClickCount() + " " + me.getComponent().getClass().getName());
}
}
}
public void setEnabled(boolean enabled) {
jTree.setEnabled(enabled);
}
private Object getFromNode(TreeNode node) {
if (node == null) return null;
return getObject(node);
}
private Object getLastSelectedElement() {
if (selectedPath != null) {
TreeNode node = (TreeNode)
selectedPath.getLastPathComponent();
return getFromNode(node);
} else {
return null;
}
}
private static Object getObject(Object treeNode) {
try {
if (treeNode == null)
return null;
if (treeNode instanceof DefaultMutableTreeNode)
return ((DefaultMutableTreeNode) treeNode).getUserObject();
return treeNode.getClass().getMethod("getUserObject",Tools.EMPTY_CLASS_ARRAY).invoke(treeNode, Tools.EMPTY_ARRAY);
} catch (Exception ex) {
return null;
}
}
public void exchangeTreeModel(TreeModel model) {
boolean notifySelection;
try {
treeSelectionListenerBlocked = true;
notifySelection = exchangeTreeModel( model, jTree ) ;
} finally {
treeSelectionListenerBlocked = false;
}
if ( notifySelection ) {
this.fireValueChanged();
}
}
public void exchangeTreeModel2(TreeModel model) {
try {
treeSelectionListenerBlocked = true;
jTree.setModel(model);
} finally {
treeSelectionListenerBlocked = false;
}
}
/** Exchanges the tree-model while trying to preserve the selection an expansion state.
* Returns if the selection has been affected by the excahnge.*/
public static boolean exchangeTreeModel(TreeModel model,JTree tree) {
Collection<Object> expanded = new LinkedHashSet<Object>();
Collection<Object> selected = new LinkedHashSet<Object>();
int rowCount = tree.getRowCount();
for (int i=0;i<rowCount;i++) {
if (tree.isExpanded(i)) {
Object obj = getObject( tree.getPathForRow(i).getLastPathComponent() );
if (obj != null )
expanded.add( obj );
}
if (tree.isRowSelected(i)) {
Object obj = getObject( tree.getPathForRow(i).getLastPathComponent() );
if (obj != null )
selected.add( obj );
}
}
tree.setModel(model);
if ( model instanceof DefaultTreeModel ) {
((DefaultTreeModel)model).reload();
}
if (expanded.size() ==0 && selected.size() == 0)
{
TreeNode root = (TreeNode)model.getRoot();
if (root.getChildCount()<2)
{
tree.expandRow(0);
}
}
ArrayList<TreePath> selectedList = new ArrayList<TreePath>();
for (int i=0;i<rowCount;i++) {
TreePath treePath = tree.getPathForRow(i);
if (treePath != null)
{
Object obj = getObject( treePath.getLastPathComponent() );
if (obj == null)
continue;
if (expanded.contains( obj )) {
expanded.remove( obj );
tree.expandRow(i);
}
if (selected.contains( obj )) {
selected.remove( obj );
selectedList.add(treePath);
}
}
}
tree.setSelectionPaths(selectedList.toArray(new TreePath[selectedList.size()]));
return selectedList.size() != selected.size();
}
public void setMultiSelect(boolean bMultiSelect) {
this.bMultiSelect = bMultiSelect;
if ( bMultiSelect) {
jTree.getSelectionModel().setSelectionMode(TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION);
} else {
jTree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
} // end of else
}
public static class TreeIterator implements Iterator<TreeNode> {
Stack<TreeNode> nodeStack = new Stack<TreeNode>();
public TreeIterator(TreeNode node) {
nodeStack.push(node);
}
public boolean hasNext() {
return !nodeStack.isEmpty();
}
public TreeNode next() {
TreeNode node = nodeStack.pop();
int count = node.getChildCount();
for (int i=count-1;i>=0;i--) {
nodeStack.push(node.getChildAt(i));
}
return node;
}
public void remove() {
throw new UnsupportedOperationException();
}
}
private TreePath getPath(TreeNode node) {
if (node.getParent() == null)
return new TreePath(node);
else
return getPath(node.getParent()).pathByAddingChild(node);
}
public void select(Collection<Object> selectedObjects) {
Collection<TreeNode> selectedNodes = new ArrayList<TreeNode>();
Collection<Object> selectedToRemove = new LinkedHashSet<Object>( );
selectedToRemove.addAll( selectedObjects);
Iterator<TreeNode> it = new TreeIterator((TreeNode)jTree.getModel().getRoot());
while (it.hasNext()) {
TreeNode node = it.next();
Object object = getObject(node);
if (node != null && selectedToRemove.contains( object ))
{
selectedNodes.add(node);
selectedToRemove.remove( object);
}
}
TreePath[] path = new TreePath[selectedNodes.size()];
int i=0;
it = selectedNodes.iterator();
while (it.hasNext()) {
path[i] = getPath(it.next());
jTree.expandPath(path[i]);
i++;
}
jTree.setSelectionPaths(path);
}
public Object getSelectedElement() {
Collection<Object> col = getSelectedElements();
if ( col.size()>0) {
return col.iterator().next();
} else {
return null;
} // end of else
}
public List<Object> getSelectedElements() {
return getSelectedElements( false);
}
public List<Object> getSelectedElements(boolean includeChilds) {
TreePath[] path = jTree.getSelectionPaths();
List<Object> list = new LinkedList<Object>();
if ( path == null)
{
return list;
}
for (TreePath p:path) {
TreeNode node = (TreeNode) p.getLastPathComponent();
Object obj = getFromNode(node);
if (obj != null)
list.add(obj);
if ( includeChilds )
{
addChildNodeObjects(list, node);
}
}
return list;
}
protected void addChildNodeObjects(List<Object> list, TreeNode node) {
int childCount = node.getChildCount();
for ( int i = 0;i<childCount;i++)
{
TreeNode child = node.getChildAt( i);
Object obj = getFromNode(child);
if (obj != null)
list.add(obj);
addChildNodeObjects(list, child);
}
}
public Object getInfoElement() {
if ( bMultiSelect) {
return getLastSelectedElement();
} else {
return getSelectedElement();
} // end of else
}
public void unselectAll() {
jTree.setSelectionInterval(-1,-1);
}
public void requestFocus() {
jTree.requestFocus();
}
public void expandAll() {
int i = 0;
while (i<jTree.getRowCount()) {
jTree.expandRow(i);
i++;
}
}
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/RaplaTree.java | Java | gpl3 | 16,946 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.toolkit;
import java.awt.Insets;
import javax.swing.Action;
import javax.swing.JButton;
public class RaplaButton extends JButton {
private static final long serialVersionUID = 1L;
public static int SMALL= -1;
public static int LARGE = 1;
public static int DEFAULT = 0;
private static Insets smallInsets = new Insets(0,0,0,0);
private static Insets largeInsets = new Insets(5,10,5,10);
public RaplaButton(String text,int style) {
this(style);
setText(text);
}
public RaplaButton(int style) {
if (style == SMALL) {
setMargin(smallInsets);
} else if (style == LARGE) {
setMargin(largeInsets);
} else {
setMargin(null);
}
}
public void setAction(Action action) {
String oldText = null;
if (action.getValue(Action.NAME) == null)
oldText = getText();
super.setAction(action);
if (oldText != null)
setText(oldText);
}
public RaplaButton() {
}
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/RaplaButton.java | Java | gpl3 | 2,010 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.toolkit;
import java.awt.Component;
import javax.swing.JComponent;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
public class RaplaMenu extends JMenu implements IdentifiableMenuEntry, MenuInterface {
private static final long serialVersionUID = 1L;
String id;
public RaplaMenu(String id) {
super(id);
this.id = id;
}
public String getId() {
return id;
}
public int getIndexOfEntryWithId(String id) {
int size = getMenuComponentCount();
for ( int i=0;i< size;i++)
{
Component component = getMenuComponent( i );
if ( component instanceof IdentifiableMenuEntry) {
IdentifiableMenuEntry comp = (IdentifiableMenuEntry) component;
if ( id != null && id.equals( comp.getId() ) )
{
return i;
}
}
}
return -1;
}
public void removeAllBetween(String startId, String endId) {
int startIndex = getIndexOfEntryWithId( startId );
int endIndex = getIndexOfEntryWithId( endId);
if ( startIndex < 0 || endIndex < 0 )
return;
for ( int i= startIndex + 1; i< endIndex ;i++)
{
remove( startIndex + 1);
}
}
public boolean hasId(String id) {
return getIndexOfEntryWithId( id )>=0;
}
public void insertAfterId(Component component,String id) {
if ( id == null) {
getPopupMenu().add( component );
} else {
int index = getIndexOfEntryWithId( id ) ;
getPopupMenu().insert( component, index + 1);
}
}
public void insertBeforeId(JComponent component,String id) {
int index = getIndexOfEntryWithId( id );
getPopupMenu().insert( component, index);
}
@Override
public JMenuItem getMenuElement() {
return this;
}
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/RaplaMenu.java | Java | gpl3 | 2,886 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.toolkit;
import java.awt.Component;
import java.util.ArrayList;
import java.util.Iterator;
import javax.swing.JMenuBar;
public class RaplaMenubar extends JMenuBar {
private static final long serialVersionUID = 1L;
public RaplaMenubar() {
super();
}
/** returns -1 if there is no */
private int getIndexOfEntryWithId(String id) {
int size = getComponentCount();
for ( int i=0;i< size;i++)
{
Component component = getComponent( i );
if ( component instanceof IdentifiableMenuEntry) {
IdentifiableMenuEntry comp = (IdentifiableMenuEntry) component;
if ( id != null && id.equals( comp.getId() ) )
{
return i;
}
}
}
return -1;
}
public void insertAfterId(String id,Component component) {
int index = getIndexOfEntryWithId( id ) + 1;
insert( component, index);
}
public void insertBeforeId(String id,Component component) {
int index = getIndexOfEntryWithId( id );
insert( component, index);
}
private void insert(Component component, int index) {
int size = getComponentCount();
ArrayList<Component> list = new ArrayList<Component>();
// save the components begining with index
for (int i = index ; i < size; i++)
{
list.add( getComponent(index) );
}
// now remove all components begining with index
for (int i = index ; i < size; i++)
{
remove(index);
}
// now add the new component
add( component );
// and the removed components
for (Iterator<Component> it = list.iterator();it.hasNext();)
{
add( it.next() );
}
}
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/RaplaMenubar.java | Java | gpl3 | 2,804 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.toolkit;
import java.awt.Component;
import java.awt.Container;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Point;
import java.awt.Toolkit;
import java.awt.Window;
import java.util.ArrayList;
import java.util.Stack;
import org.rapla.components.util.Assert;
import org.rapla.components.util.Tools;
import org.rapla.framework.logger.Logger;
/**All rapla-windows are registered on the FrameControllerList.
The FrameControllerList is responsible for positioning the windows
and closing all open windows on exit.
*/
final public class FrameControllerList {
private Stack<FrameController> openFrameController = new Stack<FrameController>();
private Window mainWindow = null;
Point center;
Logger logger = null;
ArrayList<FrameControllerListener> listenerList = new ArrayList<FrameControllerListener>();
public FrameControllerList(Logger logger)
{
this.logger = logger;
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
center = new Point(screenSize.width / 2
,screenSize.height / 2);
}
protected Logger getLogger() {
return logger;
}
/** the center will be used by the
<code>centerWindow()</code> function. */
public void setCenter(Container window) {
center.x = window.getLocationOnScreen().x + window.getSize().width/2;
center.y = window.getLocationOnScreen().y + window.getSize().height/2;
}
/** the center will be used by the
<code>centerWindow(Window)</code> function.
@see #centerWindow(Window)
*/
public void setCenter(Point center) {
this.center = center;
}
/** the main-window will be used by the
<code>placeRelativeToMain(Window)</code> function.
@see #placeRelativeToMain(Window)
*/
public void setMainWindow(Window window) {
this.mainWindow = window;
}
public Window getMainWindow() {
return mainWindow;
}
/** places the window relative to the main-window if set.
Otherwise the the <code>centerWindow(Window)</code> method is called.
@param newWindow the window to place
*/
public void placeRelativeToMain(Window newWindow) {
if (getLogger() != null && getLogger().isDebugEnabled() && mainWindow != null)
getLogger().debug("placeRelativeToMainWindow(" + Tools.left(mainWindow.toString(),60) + ")");
if (mainWindow ==null)
centerWindow(newWindow);
else
placeRelativeToWindow(newWindow,mainWindow);
}
/** adds a window to the FrameControllerList */
synchronized public void add(FrameController c) {
Assert.notNull(c);
Assert.isTrue(!openFrameController.contains(c),"Duplicated Entries are not allowed");
openFrameController.add(c);
}
/** removes a window from the FrameControllerList */
public void remove(FrameController c) {
openFrameController.remove(c);
String s = c.toString();
if (getLogger() != null && getLogger().isDebugEnabled())
getLogger().debug("Frame closed " + Tools.left(s,60) + "...");
fireFrameClosed(c);
if (openFrameController.size() == 0)
fireListEmpty();
}
/** closes all windows registered on the FrameControllerList */
public void closeAll() {
while (!openFrameController.empty()) {
FrameController c = openFrameController.peek();
int size = openFrameController.size();
c.close();
if ( size <= openFrameController.size())
getLogger().error("removeFrameController() not called in close() in " + c);
}
}
public void setCursor(Cursor cursor) {
FrameController[] anArray = openFrameController.toArray( new FrameController[] {});
for ( FrameController frame:anArray)
{
frame.setCursor(cursor);
}
}
public void addFrameControllerListener(FrameControllerListener listener) {
listenerList.add(listener);
}
public void removeFrameControllerListener(FrameControllerListener listener) {
listenerList.remove(listener);
}
public FrameControllerListener[] getFrameControllerListeners() {
synchronized(listenerList) {
return listenerList.toArray(new FrameControllerListener[]{});
}
}
protected void fireFrameClosed(FrameController controller) {
if (listenerList.size() == 0)
return;
FrameControllerListener[] listeners = getFrameControllerListeners();
for (int i = 0;i<listeners.length;i++) {
listeners[i].frameClosed(controller);
}
}
protected void fireListEmpty() {
if (listenerList.size() == 0)
return;
FrameControllerListener[] listeners = getFrameControllerListeners();
for (int i = 0;i<listeners.length;i++) {
listeners[i].listEmpty();
}
}
/** centers the window around the specified center */
public void centerWindow(Window window) {
Dimension preferredSize = window.getSize();
int x = center.x - (preferredSize.width / 2);
int y = center.y - (preferredSize.height / 2);
fitIntoScreen(x,y,window);
}
/** centers the window around the specified center */
static public void centerWindowOnScreen(Window window) {
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
Dimension preferredSize = window.getSize();
int x = screenSize.width/2 - (preferredSize.width / 2);
int y = screenSize.height/2 - (preferredSize.height / 2);
fitIntoScreen(x,y,window);
}
/** Tries to place the window, that it fits into the screen. */
static public void fitIntoScreen(int x, int y, Component window) {
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
Dimension windowSize = window.getSize();
if (x + windowSize.width > screenSize.width)
x = screenSize.width - windowSize.width;
if (y + windowSize.height > screenSize.height)
y = screenSize.height - windowSize.height;
if (x<0) x = 0;
if (y<0) y = 0;
window.setLocation(x,y);
}
/** places the window relative to the owner-window.
The newWindow will be placed in the middle of the owner-window.
@param newWindow the window to place
@param owner the window to place into
*/
public static void placeRelativeToWindow(Window newWindow,Window owner) {
placeRelativeToComponent(newWindow,owner,null);
}
public static void placeRelativeToComponent(Window newWindow,Component component,Point point) {
if (component == null)
return;
Dimension dlgSize = newWindow.getSize();
Dimension parentSize = component.getSize();
Point loc = component.getLocationOnScreen();
if (point != null) {
int x = loc.x + point.x - (dlgSize.width) / 2;
int y = loc.y + point.y - ((dlgSize.height) * 2) / 3;
//System.out.println (loc + ", " + point + " x: " + x + " y: " + y);
fitIntoScreen(x,y,newWindow);
} else {
int x = (parentSize.width - dlgSize.width) / 2 + loc.x;
int y = loc.y + 10;
fitIntoScreen(x,y,newWindow);
}
}
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/FrameControllerList.java | Java | gpl3 | 8,379 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.toolkit;
public interface PopupListener {
public void showPopup(PopupEvent evt);
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/PopupListener.java | Java | gpl3 | 1,047 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.toolkit;
import javax.swing.ActionMap;
public interface WizardPanel extends RaplaWidget {
String NEXT = "next";
String ABORT = "abort";
String PREV = "prev";
String FINISH = "finish";
public ActionMap getActionMap();
public String getHelp();
public String getDefaultAction();
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/WizardPanel.java | Java | gpl3 | 1,269 |
package org.rapla.gui.toolkit;
import java.awt.Color;
public class AWTColorUtil {
final static public Color getAppointmentColor(int nr)
{
String string = RaplaColors.getAppointmentColor(nr);
Color color = getColorForHex(string);
return color;
}
public static Color getColorForHex(String hexString) throws NumberFormatException {
if ( hexString == null || hexString.indexOf('#') != 0 || hexString.length()!= 7 )
throw new NumberFormatException("Can't parse HexValue " + hexString);
String rString = hexString.substring(1,3).toUpperCase();
String gString = hexString.substring(3,5).toUpperCase();
String bString = hexString.substring(5,7).toUpperCase();
int r = RaplaColors.decode( rString);
int g = RaplaColors.decode( gString);
int b = RaplaColors.decode( bString);
return new Color(r, g, b);
}
public static String getHexForColor(Color color) {
if ( color == null)
return "";
int r = color.getRed();
int g = color.getGreen();
int b = color.getBlue();
return RaplaColors.getHex(r, g, b);
}
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/AWTColorUtil.java | Java | gpl3 | 1,139 |
package org.rapla.gui.toolkit;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.Icon;
import javax.swing.JComponent;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
import javax.swing.MenuSelectionManager;
import javax.swing.Timer;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.event.PopupMenuEvent;
import javax.swing.event.PopupMenuListener;
/**
* Found on http://tips4java.wordpress.com/2009/02/01/menu-scroller/
* Does not have copyright information
* A class that provides scrolling capabilities to a long menu dropdown or
* popup menu. A number of items can optionally be frozen at the top and/or
* bottom of the menu.
* <P>
* <B>Implementation note:</B> The default number of items to display
* at a time is 15, and the default scrolling interval is 125 milliseconds.
* <P>
*
* @version 1.5.0 04/05/12
* @author Darryl Burke
*/
public class MenuScroller {
//private JMenu menu;
private JPopupMenu menu;
private Component[] menuItems;
private MenuScrollItem upItem;
private MenuScrollItem downItem;
private final MenuScrollListener menuListener = new MenuScrollListener();
private int scrollCount;
private int interval;
private int topFixedCount;
private int bottomFixedCount;
private int firstIndex = 0;
private int keepVisibleIndex = -1;
/**
* Registers a menu to be scrolled with the default number of items to
* display at a time and the default scrolling interval.
*
* @param menu the menu
* @return the MenuScroller
*/
public static MenuScroller setScrollerFor(JMenu menu) {
return new MenuScroller(menu);
}
/**
* Registers a popup menu to be scrolled with the default number of items to
* display at a time and the default scrolling interval.
*
* @param menu the popup menu
* @return the MenuScroller
*/
public static MenuScroller setScrollerFor(JPopupMenu menu) {
return new MenuScroller(menu);
}
/**
* Registers a menu to be scrolled with the default number of items to
* display at a time and the specified scrolling interval.
*
* @param menu the menu
* @param scrollCount the number of items to display at a time
* @return the MenuScroller
* @throws IllegalArgumentException if scrollCount is 0 or negative
*/
public static MenuScroller setScrollerFor(JMenu menu, int scrollCount) {
return new MenuScroller(menu, scrollCount);
}
/**
* Registers a popup menu to be scrolled with the default number of items to
* display at a time and the specified scrolling interval.
*
* @param menu the popup menu
* @param scrollCount the number of items to display at a time
* @return the MenuScroller
* @throws IllegalArgumentException if scrollCount is 0 or negative
*/
public static MenuScroller setScrollerFor(JPopupMenu menu, int scrollCount) {
return new MenuScroller(menu, scrollCount);
}
/**
* Registers a menu to be scrolled, with the specified number of items to
* display at a time and the specified scrolling interval.
*
* @param menu the menu
* @param scrollCount the number of items to be displayed at a time
* @param interval the scroll interval, in milliseconds
* @return the MenuScroller
* @throws IllegalArgumentException if scrollCount or interval is 0 or negative
*/
public static MenuScroller setScrollerFor(JMenu menu, int scrollCount, int interval) {
return new MenuScroller(menu, scrollCount, interval);
}
/**
* Registers a popup menu to be scrolled, with the specified number of items to
* display at a time and the specified scrolling interval.
*
* @param menu the popup menu
* @param scrollCount the number of items to be displayed at a time
* @param interval the scroll interval, in milliseconds
* @return the MenuScroller
* @throws IllegalArgumentException if scrollCount or interval is 0 or negative
*/
public static MenuScroller setScrollerFor(JPopupMenu menu, int scrollCount, int interval) {
return new MenuScroller(menu, scrollCount, interval);
}
/**
* Registers a menu to be scrolled, with the specified number of items
* to display in the scrolling region, the specified scrolling interval,
* and the specified numbers of items fixed at the top and bottom of the
* menu.
*
* @param menu the menu
* @param scrollCount the number of items to display in the scrolling portion
* @param interval the scroll interval, in milliseconds
* @param topFixedCount the number of items to fix at the top. May be 0.
* @param bottomFixedCount the number of items to fix at the bottom. May be 0
* @throws IllegalArgumentException if scrollCount or interval is 0 or
* negative or if topFixedCount or bottomFixedCount is negative
* @return the MenuScroller
*/
public static MenuScroller setScrollerFor(JMenu menu, int scrollCount, int interval,
int topFixedCount, int bottomFixedCount) {
return new MenuScroller(menu, scrollCount, interval,
topFixedCount, bottomFixedCount);
}
/**
* Registers a popup menu to be scrolled, with the specified number of items
* to display in the scrolling region, the specified scrolling interval,
* and the specified numbers of items fixed at the top and bottom of the
* popup menu.
*
* @param menu the popup menu
* @param scrollCount the number of items to display in the scrolling portion
* @param interval the scroll interval, in milliseconds
* @param topFixedCount the number of items to fix at the top. May be 0
* @param bottomFixedCount the number of items to fix at the bottom. May be 0
* @throws IllegalArgumentException if scrollCount or interval is 0 or
* negative or if topFixedCount or bottomFixedCount is negative
* @return the MenuScroller
*/
public static MenuScroller setScrollerFor(JPopupMenu menu, int scrollCount, int interval,
int topFixedCount, int bottomFixedCount) {
return new MenuScroller(menu, scrollCount, interval,
topFixedCount, bottomFixedCount);
}
/**
* Constructs a <code>MenuScroller</code> that scrolls a menu with the
* default number of items to display at a time, and default scrolling
* interval.
*
* @param menu the menu
*/
public MenuScroller(JMenu menu) {
this(menu, 15);
}
/**
* Constructs a <code>MenuScroller</code> that scrolls a popup menu with the
* default number of items to display at a time, and default scrolling
* interval.
*
* @param menu the popup menu
*/
public MenuScroller(JPopupMenu menu) {
this(menu, 15);
}
/**
* Constructs a <code>MenuScroller</code> that scrolls a menu with the
* specified number of items to display at a time, and default scrolling
* interval.
*
* @param menu the menu
* @param scrollCount the number of items to display at a time
* @throws IllegalArgumentException if scrollCount is 0 or negative
*/
public MenuScroller(JMenu menu, int scrollCount) {
this(menu, scrollCount, 150);
}
/**
* Constructs a <code>MenuScroller</code> that scrolls a popup menu with the
* specified number of items to display at a time, and default scrolling
* interval.
*
* @param menu the popup menu
* @param scrollCount the number of items to display at a time
* @throws IllegalArgumentException if scrollCount is 0 or negative
*/
public MenuScroller(JPopupMenu menu, int scrollCount) {
this(menu, scrollCount, 150);
}
/**
* Constructs a <code>MenuScroller</code> that scrolls a menu with the
* specified number of items to display at a time, and specified scrolling
* interval.
*
* @param menu the menu
* @param scrollCount the number of items to display at a time
* @param interval the scroll interval, in milliseconds
* @throws IllegalArgumentException if scrollCount or interval is 0 or negative
*/
public MenuScroller(JMenu menu, int scrollCount, int interval) {
this(menu, scrollCount, interval, 0, 0);
}
/**
* Constructs a <code>MenuScroller</code> that scrolls a popup menu with the
* specified number of items to display at a time, and specified scrolling
* interval.
*
* @param menu the popup menu
* @param scrollCount the number of items to display at a time
* @param interval the scroll interval, in milliseconds
* @throws IllegalArgumentException if scrollCount or interval is 0 or negative
*/
public MenuScroller(JPopupMenu menu, int scrollCount, int interval) {
this(menu, scrollCount, interval, 0, 0);
}
/**
* Constructs a <code>MenuScroller</code> that scrolls a menu with the
* specified number of items to display in the scrolling region, the
* specified scrolling interval, and the specified numbers of items fixed at
* the top and bottom of the menu.
*
* @param menu the menu
* @param scrollCount the number of items to display in the scrolling portion
* @param interval the scroll interval, in milliseconds
* @param topFixedCount the number of items to fix at the top. May be 0
* @param bottomFixedCount the number of items to fix at the bottom. May be 0
* @throws IllegalArgumentException if scrollCount or interval is 0 or
* negative or if topFixedCount or bottomFixedCount is negative
*/
public MenuScroller(JMenu menu, int scrollCount, int interval,
int topFixedCount, int bottomFixedCount) {
this(menu.getPopupMenu(), scrollCount, interval, topFixedCount, bottomFixedCount);
}
/**
* Constructs a <code>MenuScroller</code> that scrolls a popup menu with the
* specified number of items to display in the scrolling region, the
* specified scrolling interval, and the specified numbers of items fixed at
* the top and bottom of the popup menu.
*
* @param menu the popup menu
* @param scrollCount the number of items to display in the scrolling portion
* @param interval the scroll interval, in milliseconds
* @param topFixedCount the number of items to fix at the top. May be 0
* @param bottomFixedCount the number of items to fix at the bottom. May be 0
* @throws IllegalArgumentException if scrollCount or interval is 0 or
* negative or if topFixedCount or bottomFixedCount is negative
*/
public MenuScroller(JPopupMenu menu, int scrollCount, int interval,
int topFixedCount, int bottomFixedCount) {
if (scrollCount <= 0 || interval <= 0) {
throw new IllegalArgumentException("scrollCount and interval must be greater than 0");
}
if (topFixedCount < 0 || bottomFixedCount < 0) {
throw new IllegalArgumentException("topFixedCount and bottomFixedCount cannot be negative");
}
upItem = new MenuScrollItem(MenuIcon.UP, -1);
downItem = new MenuScrollItem(MenuIcon.DOWN, +1);
setScrollCount(scrollCount);
setInterval(interval);
setTopFixedCount(topFixedCount);
setBottomFixedCount(bottomFixedCount);
this.menu = menu;
menu.addPopupMenuListener(menuListener);
}
/**
* Returns the scroll interval in milliseconds
*
* @return the scroll interval in milliseconds
*/
public int getInterval() {
return interval;
}
/**
* Sets the scroll interval in milliseconds
*
* @param interval the scroll interval in milliseconds
* @throws IllegalArgumentException if interval is 0 or negative
*/
public void setInterval(int interval) {
if (interval <= 0) {
throw new IllegalArgumentException("interval must be greater than 0");
}
upItem.setInterval(interval);
downItem.setInterval(interval);
this.interval = interval;
}
/**
* Returns the number of items in the scrolling portion of the menu.
*
* @return the number of items to display at a time
*/
public int getscrollCount() {
return scrollCount;
}
/**
* Sets the number of items in the scrolling portion of the menu.
*
* @param scrollCount the number of items to display at a time
* @throws IllegalArgumentException if scrollCount is 0 or negative
*/
public void setScrollCount(int scrollCount) {
if (scrollCount <= 0) {
throw new IllegalArgumentException("scrollCount must be greater than 0");
}
this.scrollCount = scrollCount;
MenuSelectionManager.defaultManager().clearSelectedPath();
}
/**
* Returns the number of items fixed at the top of the menu or popup menu.
*
* @return the number of items
*/
public int getTopFixedCount() {
return topFixedCount;
}
/**
* Sets the number of items to fix at the top of the menu or popup menu.
*
* @param topFixedCount the number of items
*/
public void setTopFixedCount(int topFixedCount) {
if (firstIndex <= topFixedCount) {
firstIndex = topFixedCount;
} else {
firstIndex += (topFixedCount - this.topFixedCount);
}
this.topFixedCount = topFixedCount;
}
/**
* Returns the number of items fixed at the bottom of the menu or popup menu.
*
* @return the number of items
*/
public int getBottomFixedCount() {
return bottomFixedCount;
}
/**
* Sets the number of items to fix at the bottom of the menu or popup menu.
*
* @param bottomFixedCount the number of items
*/
public void setBottomFixedCount(int bottomFixedCount) {
this.bottomFixedCount = bottomFixedCount;
}
/**
* Scrolls the specified item into view each time the menu is opened. Call this method with
* <code>null</code> to restore the default behavior, which is to show the menu as it last
* appeared.
*
* @param item the item to keep visible
* @see #keepVisible(int)
*/
public void keepVisible(JMenuItem item) {
if (item == null) {
keepVisibleIndex = -1;
} else {
int index = menu.getComponentIndex(item);
keepVisibleIndex = index;
}
}
/**
* Scrolls the item at the specified index into view each time the menu is opened. Call this
* method with <code>-1</code> to restore the default behavior, which is to show the menu as
* it last appeared.
*
* @param index the index of the item to keep visible
* @see #keepVisible(javax.swing.JMenuItem)
*/
public void keepVisible(int index) {
keepVisibleIndex = index;
}
/**
* Removes this MenuScroller from the associated menu and restores the
* default behavior of the menu.
*/
public void dispose() {
if (menu != null) {
menu.removePopupMenuListener(menuListener);
menu = null;
}
}
/**
* Ensures that the <code>dispose</code> method of this MenuScroller is
* called when there are no more refrences to it.
*
* @exception Throwable if an error occurs.
* @see MenuScroller#dispose()
*/
@Override
public void finalize() throws Throwable {
dispose();
}
private void refreshMenu() {
if (menuItems != null && menuItems.length > 0) {
firstIndex = Math.max(topFixedCount, firstIndex);
firstIndex = Math.min(menuItems.length - bottomFixedCount - scrollCount, firstIndex);
upItem.setEnabled(firstIndex > topFixedCount);
downItem.setEnabled(firstIndex + scrollCount < menuItems.length - bottomFixedCount);
menu.removeAll();
for (int i = 0; i < topFixedCount; i++) {
menu.add(menuItems[i]);
}
if (topFixedCount > 0) {
menu.addSeparator();
}
menu.add(upItem);
for (int i = firstIndex; i < scrollCount + firstIndex; i++) {
menu.add(menuItems[i]);
}
menu.add(downItem);
if (bottomFixedCount > 0) {
menu.addSeparator();
}
for (int i = menuItems.length - bottomFixedCount; i < menuItems.length; i++) {
menu.add(menuItems[i]);
}
JComponent parent = (JComponent) upItem.getParent();
parent.revalidate();
parent.repaint();
}
}
private class MenuScrollListener implements PopupMenuListener {
@Override
public void popupMenuWillBecomeVisible(PopupMenuEvent e) {
setMenuItems();
}
@Override
public void popupMenuWillBecomeInvisible(PopupMenuEvent e) {
restoreMenuItems();
}
@Override
public void popupMenuCanceled(PopupMenuEvent e) {
restoreMenuItems();
}
private void setMenuItems() {
menuItems = menu.getComponents();
if (keepVisibleIndex >= topFixedCount
&& keepVisibleIndex <= menuItems.length - bottomFixedCount
&& (keepVisibleIndex > firstIndex + scrollCount
|| keepVisibleIndex < firstIndex)) {
firstIndex = Math.min(firstIndex, keepVisibleIndex);
firstIndex = Math.max(firstIndex, keepVisibleIndex - scrollCount + 1);
}
if (menuItems.length > topFixedCount + scrollCount + bottomFixedCount) {
refreshMenu();
}
}
private void restoreMenuItems() {
menu.removeAll();
for (Component component : menuItems) {
menu.add(component);
}
}
}
private class MenuScrollTimer extends Timer {
private static final long serialVersionUID = 1L;
public MenuScrollTimer(final int increment, int interval) {
super(interval, new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
firstIndex += increment;
refreshMenu();
}
});
}
}
private class MenuScrollItem extends JMenuItem
implements ChangeListener {
private static final long serialVersionUID = 1L;
private MenuScrollTimer timer;
public MenuScrollItem(MenuIcon icon, int increment) {
setIcon(icon);
setDisabledIcon(icon);
timer = new MenuScrollTimer(increment, interval);
addChangeListener(this);
}
public void setInterval(int interval) {
timer.setDelay(interval);
}
@Override
public void stateChanged(ChangeEvent e) {
if (isArmed() && !timer.isRunning()) {
timer.start();
}
if (!isArmed() && timer.isRunning()) {
timer.stop();
}
}
}
private static enum MenuIcon implements Icon {
UP(9, 1, 9),
DOWN(1, 9, 1);
final int[] xPoints = {1, 5, 9};
final int[] yPoints;
MenuIcon(int... yPoints) {
this.yPoints = yPoints;
}
@Override
public void paintIcon(Component c, Graphics g, int x, int y) {
Dimension size = c.getSize();
Graphics g2 = g.create(size.width / 2 - 5, size.height / 2 - 5, 10, 10);
g2.setColor(Color.GRAY);
g2.drawPolygon(xPoints, yPoints, 3);
if (c.isEnabled()) {
g2.setColor(Color.BLACK);
g2.fillPolygon(xPoints, yPoints, 3);
}
g2.dispose();
}
@Override
public int getIconWidth() {
return 0;
}
@Override
public int getIconHeight() {
return 10;
}
}
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/MenuScroller.java | Java | gpl3 | 18,987 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas, Bettina Lademann |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.toolkit;
import java.util.Locale;
import javax.swing.DefaultComboBoxModel;
import javax.swing.JComboBox;
import org.rapla.components.calendarview.MonthMapper;
/** ComboBox that displays the month in long format
*/
public final class MonthChooser extends JComboBox
{
private static final long serialVersionUID = 1L;
MonthMapper mapper;
public MonthChooser()
{
this( Locale.getDefault() );
}
public MonthChooser( Locale locale )
{
setLocale( locale );
}
@SuppressWarnings("unchecked")
public void setLocale( Locale locale )
{
super.setLocale( locale );
if ( locale == null )
return;
mapper = new MonthMapper( locale );
DefaultComboBoxModel aModel = new DefaultComboBoxModel( mapper.getNames() );
setModel( aModel );
}
public void selectMonth( int month )
{
setSelectedIndex( month );
}
/** returns the selected day or -1 if no day is selected.
@see java.util.Calendar
*/
public int getSelectedMonth()
{
if ( getSelectedIndex() == -1 )
return -1;
else
return getSelectedIndex();
}
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/MonthChooser.java | Java | gpl3 | 2,139 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.toolkit;
import java.awt.Component;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import javax.swing.JSeparator;
import javax.swing.MenuElement;
import javax.swing.MenuSelectionManager;
public class RaplaSeparator extends JSeparator implements IdentifiableMenuEntry, MenuElement {
private static final long serialVersionUID = 1L;
String id;
public RaplaSeparator(String id) {
super();
this.id = id;
}
public String getId() {
return id;
}
public MenuElement getMenuElement() {
return this;
}
public void processMouseEvent(MouseEvent event, MenuElement[] path,
MenuSelectionManager manager) {
}
public void processKeyEvent(KeyEvent event, MenuElement[] path,
MenuSelectionManager manager) {
}
public void menuSelectionChanged(boolean isIncluded) {
}
public MenuElement[] getSubElements() {
return new MenuElement[] {};
}
public Component getComponent() {
return this;
}
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/RaplaSeparator.java | Java | gpl3 | 1,951 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.toolkit;
public interface FrameControllerListener {
void frameClosed(FrameController frameController);
void listEmpty();
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/FrameControllerListener.java | Java | gpl3 | 1,105 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2006 Gereon Fassbender, Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.toolkit;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;
/** WARNING: This class is about to change its API. Dont use it */
final public class RaplaColors {
private final static String[] COLORS=
{
/*
* using hex codes of colorsis easier than using
* the Color constructor with separated r, g and b values
*
* thus we decided to use the getColorForHex method
* which takes a hex String and returns a new Color object
*
* in the end this is an array of seven different colors
*
*/
"#a3ddff", // light blue
"#b5e97e", // light green
"#ffb85e", // orange
"#b099dc", // violet
"#cccccc", // light grey
"#fef49d", // yellow
"#fc9992", // red
};
public final static String DEFAULT_COLOR_AS_STRING = COLORS[0];
private static ArrayList<String> colors = new ArrayList<String>(Arrays.asList(COLORS));
private static Random randomA = null;
private static Random randomB = null;
static private float rndA()
{
if (randomA == null)
randomA = new Random(7913);
return (float) (0.45 + randomA.nextFloat()/2.0);
}
static float rndB()
{
if (randomB == null)
randomB = new Random(5513);
return (float) (0.4 + randomB.nextFloat()/2.0);
}
final static public String getResourceColor(int nr)
{
if (colors.size()<=nr)
{
int fillSize = nr - colors.size() + 1;
for (int i=0;i<fillSize;i++)
{
int r = (int) ((float) (0.1 + rndA() /1.1) * 255);
int g = (int) (rndA() * 255);
int b = (int) (rndA() * 255);
String color = getHex( r , g, b);
colors.add ( color);
}
}
return colors.get(nr);
}
private final static String[] APPOINTMENT_COLORS=
{
"#eeeecc",
"#cc99cc",
"#adaca2",
"#ccaa66",
"#ccff88"
};
static ArrayList<String> appointmentColors = new ArrayList<String>(Arrays.asList(APPOINTMENT_COLORS));
final static public String getAppointmentColor(int nr)
{
if (appointmentColors.size()<=nr) {
int fillSize = nr - appointmentColors.size() + 1;
for (int i=0;i<fillSize;i++)
{
int r = (int) ((float) (0.1 + rndB() /1.1) * 255);
int g = (int) (rndB() * 255);
int b = (int) (rndB() * 255);
String color = getHex( r , g, b);
appointmentColors.add( color );
}
}
return appointmentColors.get(nr);
}
public static String getHex(int r, int g, int b) {
StringBuffer buf = new StringBuffer();
buf.append("#");
printHex( buf, r, 2 );
printHex( buf, g, 2 );
printHex( buf, b, 2 );
return buf.toString();
}
/** Converts int to hex string. If the resulting string is smaller than size,
* it will be filled with leading zeros. Example:
* <code>printHex( buf,10, 2 )</code> appends "0A" to the string buffer.*/
static void printHex(StringBuffer buf,int value,int size) {
String hexString = Integer.toHexString(value);
int fill = size - hexString.length();
if (fill>0) {
for (int i=0;i<fill;i ++)
buf.append('0');
}
buf.append(hexString);
}
static int decode(String value) {
int result = 0;
int basis = 1;
for ( int i=value.length()-1;i>=0;i --) {
char c = value.charAt( i );
int number;
if ( c >= '0' && c<='9') {
number = c - '0';
} else if ( c >= 'A' && c<='F') {
number = (c - 'A') + 10;
} else {
throw new NumberFormatException("Can't parse HexValue " + value);
}
result += number * basis;
basis = basis * 16;
}
return result;
}
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/RaplaColors.java | Java | gpl3 | 4,828 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.toolkit;
import javax.swing.JMenuItem;
public class RaplaMenuItem extends JMenuItem implements IdentifiableMenuEntry {
private static final long serialVersionUID = 1L;
String id;
public RaplaMenuItem(String id) {
super();
this.id = id;
}
public String getId() {
return id;
}
public static RaplaMenuItem[] EMPTY_ARRAY = new RaplaMenuItem[] {};
public JMenuItem getMenuElement() {
return this;
}
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/RaplaMenuItem.java | Java | gpl3 | 1,428 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.toolkit;
import java.awt.Cursor;
/** All classes implementing this Interface must call
FrameControllerList.addFrameController(this) on initialization
FrameControllerList.removeFrameController(this) on close
This Class is used for automated close of all Frames on Logout.
*/
public interface FrameController {
void close(); // must call FrameControllerList.remove(this);
void setCursor(Cursor cursor);
}
| 04900db4-clienttest | src/org/rapla/gui/toolkit/FrameController.java | Java | gpl3 | 1,391 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui;
import java.awt.BorderLayout;
import java.util.Locale;
import javax.swing.JCheckBox;
import javax.swing.JComponent;
import javax.swing.JPanel;
import org.rapla.entities.configuration.Preferences;
import org.rapla.entities.configuration.RaplaConfiguration;
import org.rapla.entities.configuration.internal.PreferencesImpl;
import org.rapla.facade.RaplaComponent;
import org.rapla.framework.Configuration;
import org.rapla.framework.DefaultConfiguration;
import org.rapla.framework.PluginDescriptor;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
abstract public class DefaultPluginOption extends RaplaGUIComponent implements PluginOptionPanel {
public DefaultPluginOption(RaplaContext sm) {
super(sm);
}
protected JCheckBox activate = new JCheckBox("Aktivieren");
protected Configuration config;
protected Preferences preferences;
JComponent container;
abstract public Class<? extends PluginDescriptor<?>> getPluginClass();
/**
* @throws RaplaException
*/
protected JPanel createPanel() throws RaplaException {
JPanel panel = new JPanel();
panel.setLayout( new BorderLayout());
panel.add( activate, BorderLayout.NORTH );
return panel;
}
/**
* @see org.rapla.gui.OptionPanel#setPreferences(org.rapla.entities.configuration.Preferences)
*/
public void setPreferences(Preferences preferences) {
this.preferences = preferences;
}
/**
* @see org.rapla.gui.OptionPanel#commit()
*/
public void commit() throws RaplaException {
writePluginConfig(true);
}
protected void writePluginConfig(boolean addChildren) {
RaplaConfiguration config = preferences.getEntry(RaplaComponent.PLUGIN_CONFIG);
if ( config == null)
{
config = new RaplaConfiguration("org.rapla.plugin");
}
String className = getPluginClass().getName();
//getDescritorClassName()
RaplaConfiguration newChild = new RaplaConfiguration("plugin" );
newChild.setAttribute( "enabled", activate.isSelected());
newChild.setAttribute( "class", className);
if ( addChildren)
{
addChildren( newChild );
}
RaplaConfiguration newConfig = config.replace(config.find("class", className), newChild);
preferences.putEntry( RaplaComponent.PLUGIN_CONFIG,newConfig);
}
/**
*
* @param newConfig
*/
protected void addChildren( DefaultConfiguration newConfig) {
}
/**
*
* @param config
* @throws RaplaException
*/
protected void readConfig( Configuration config) {
}
/**
* @see org.rapla.gui.OptionPanel#show()
*/
@SuppressWarnings("deprecation")
public void show() throws RaplaException
{
activate.setText( getString("selected"));
container = createPanel();
Class<? extends PluginDescriptor<?>> pluginClass = getPluginClass();
boolean defaultSelection = false;
try {
defaultSelection = ((Boolean )pluginClass.getField("ENABLE_BY_DEFAULT").get( null));
} catch (Throwable e) {
}
config = ((PreferencesImpl)preferences).getOldPluginConfig(pluginClass.getName());
activate.setSelected( config.getAttributeAsBoolean("enabled", defaultSelection));
readConfig( config );
}
/**
* @see org.rapla.gui.toolkit.RaplaWidget#getComponent()
*/
public JComponent getComponent() {
return container;
}
/**
* @see org.rapla.entities.Named#getName(java.util.Locale)
*/
public String getName(Locale locale) {
return getPluginClass().getSimpleName();
}
public String toString()
{
return getName(getLocale());
}
}
| 04900db4-clienttest | src/org/rapla/gui/DefaultPluginOption.java | Java | gpl3 | 4,803 |
package org.rapla.gui;
import org.rapla.entities.RaplaObject;
import org.rapla.gui.toolkit.RaplaMenuItem;
public interface ObjectMenuFactory
{
RaplaMenuItem[] create(MenuContext menuContext,RaplaObject focusedObject);
}
| 04900db4-clienttest | src/org/rapla/gui/ObjectMenuFactory.java | Java | gpl3 | 226 |
package org.rapla.gui;
import org.rapla.entities.Annotatable;
import org.rapla.framework.RaplaException;
import org.rapla.framework.TypedComponentRole;
public interface AnnotationEditExtension {
TypedComponentRole<AnnotationEditExtension> ATTRIBUTE_ANNOTATION_EDIT = new TypedComponentRole<AnnotationEditExtension>("org.rapla.gui.attributeAnnotation");
TypedComponentRole<AnnotationEditExtension> CATEGORY_ANNOTATION_EDIT = new TypedComponentRole<AnnotationEditExtension>("org.rapla.gui.categoryAnnotation");
TypedComponentRole<AnnotationEditExtension> DYNAMICTYPE_ANNOTATION_EDIT = new TypedComponentRole<AnnotationEditExtension>("org.rapla.gui.typeAnnotation");
EditField createEditField(Annotatable annotatable);
void mapTo(EditField field,Annotatable annotatable) throws RaplaException;
}
| 04900db4-clienttest | src/org/rapla/gui/AnnotationEditExtension.java | Java | gpl3 | 820 |
package org.rapla.gui;
import javax.swing.JPanel;
import javax.swing.JTextField;
import org.rapla.plugin.autoexport.AutoExportPlugin;
public interface PublishExtension
{
JPanel getPanel();
/** can return null if no url status should be displayed */
JTextField getURLField();
void mapOptionTo();
/** returns if getAddress can be used to generate an address */
boolean hasAddressCreationStrategy();
/** returns the generated address */
String getAddress( String filename, String generator);
/** returns the generator (pagename) for the file.
*
* For the htmlexport plugin for example is this AutoExportPlugin.CALENDAR_GENERATOR
* @see AutoExportPlugin
**/
String getGenerator();
} | 04900db4-clienttest | src/org/rapla/gui/PublishExtension.java | Java | gpl3 | 730 |
<body>
This is the base package of the GUI-client. Communication through the backend
is done through the modules of <code>org.rapla.facade</code> package.
The gui-client is normally started through the <code>RaplaClientService</code>.
You can also plug-in your own components into the gui.
</body>
| 04900db4-clienttest | src/org/rapla/gui/package.html | HTML | gpl3 | 301 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas, Bettina Lademann |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import javax.swing.Action;
import org.rapla.framework.RaplaContext;
public abstract class RaplaAction extends RaplaGUIComponent implements Action {
private Map<String,Object> values = new HashMap<String,Object>();
private ArrayList<PropertyChangeListener> listenerList = new ArrayList<PropertyChangeListener>();
public RaplaAction(RaplaContext sm) {
super( sm );
setEnabled(true);
}
public Object getValue(String key) {
return values.get(key);
}
public void putValue(String key,Object value) {
Object oldValue = getValue(key);
values.put(key,value);
firePropertyChange(key,oldValue,value);
}
public void addPropertyChangeListener(PropertyChangeListener listener) {
listenerList.add(listener);
}
public void removePropertyChangeListener(PropertyChangeListener listener) {
listenerList.remove(listener);
}
protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
if (listenerList.size() == 0)
return;
if (oldValue == newValue)
return;
// if (oldValue != null && newValue != null && oldValue.equals(newValue))
//return;
PropertyChangeEvent evt = new PropertyChangeEvent(this,propertyName,oldValue,newValue);
PropertyChangeListener[] listeners = getPropertyChangeListeners();
for (int i = 0;i<listeners.length; i++) {
listeners[i].propertyChange(evt);
}
}
public PropertyChangeListener[] getPropertyChangeListeners() {
return listenerList.toArray(new PropertyChangeListener[]{});
}
public void setEnabled(boolean enabled) {
putValue("enabled", new Boolean(enabled));
}
public boolean isEnabled() {
Boolean enabled = (Boolean)getValue("enabled");
return (enabled != null && enabled.booleanValue());
}
}
| 04900db4-clienttest | src/org/rapla/gui/RaplaAction.java | Java | gpl3 | 3,047 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui;
import java.awt.Color;
import java.awt.Component;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.StringSelection;
import java.awt.datatransfer.Transferable;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.security.AccessControlException;
import java.text.SimpleDateFormat;
import java.util.Iterator;
import java.util.Map;
import javax.swing.Action;
import javax.swing.ImageIcon;
import javax.swing.JComponent;
import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
import javax.swing.JTable;
import javax.swing.KeyStroke;
import javax.swing.text.DefaultEditorKit;
import javax.swing.text.JTextComponent;
import org.rapla.client.ClientService;
import org.rapla.components.calendar.DateRenderer;
import org.rapla.components.calendar.RaplaCalendar;
import org.rapla.components.calendar.RaplaTime;
import org.rapla.components.calendar.TimeRenderer;
import org.rapla.components.iolayer.IOInterface;
import org.rapla.entities.DependencyException;
import org.rapla.facade.RaplaComponent;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.framework.logger.Logger;
import org.rapla.gui.toolkit.ErrorDialog;
import org.rapla.gui.toolkit.FrameControllerList;
import org.rapla.storage.RaplaNewVersionException;
import org.rapla.storage.RaplaSecurityException;
import org.rapla.storage.dbrm.RaplaConnectException;
import org.rapla.storage.dbrm.RaplaRestartingException;
import org.rapla.storage.dbrm.WrongRaplaVersionException;
/**
Base class for most components in the gui package. Eases
access to frequently used services, e.g. {@link org.rapla.components.xmlbundle.I18nBundle}.
It also provides some methods for Exception displaying.
*/
public class RaplaGUIComponent extends RaplaComponent
{
public RaplaGUIComponent(RaplaContext context) {
super(context);
}
/** lookup FrameControllerList from the context */
final protected FrameControllerList getFrameList() {
return getService(FrameControllerList.class);
}
/** Creates a new ErrorDialog with the specified owner and displays the exception
@param ex the exception that should be displayed.
@param owner the exception that should be displayed. Can be null, but providing
a parent-component will lead to a more appropriate display.
*/
public void showException(Exception ex,Component owner) {
RaplaContext context = getContext();
Logger logger = getLogger();
showException(ex, owner, context, logger);
}
static public void showException(Throwable ex, Component owner,
RaplaContext context, Logger logger) {
if ( ex instanceof RaplaConnectException)
{
String message = ex.getMessage();
Throwable cause = ex.getCause();
String additionalInfo = "";
if ( cause != null)
{
additionalInfo = " " + cause.getClass() + ":" + cause.getMessage();
}
logger.warn(message + additionalInfo);
if ( ex instanceof RaplaRestartingException)
{
return;
}
try {
ErrorDialog dialog = new ErrorDialog(context);
dialog.showWarningDialog( message, owner);
} catch (RaplaException e) {
} catch (Throwable e) {
logger.error(e.getMessage(), e);
}
return;
}
try {
ErrorDialog dialog = new ErrorDialog(context);
if (ex instanceof DependencyException) {
dialog.showWarningDialog( getHTML( (DependencyException)ex ), owner);
}
else if (isWarningOnly(ex)) {
dialog.showWarningDialog( ex.getMessage(), owner);
} else {
dialog.showExceptionDialog(ex,owner);
}
} catch (RaplaException ex2) {
logger.error(ex2.getMessage(),ex2);
} catch (Throwable ex2) {
logger.error(ex2.getMessage(),ex2);
}
}
static public boolean isWarningOnly(Throwable ex) {
return ex instanceof RaplaNewVersionException || ex instanceof RaplaSecurityException || ex instanceof WrongRaplaVersionException || ex instanceof RaplaConnectException;
}
static private String getHTML(DependencyException ex){
StringBuffer buf = new StringBuffer();
buf.append(ex.getMessage()+":");
buf.append("<br><br>");
Iterator<String> it = ex.getDependencies().iterator();
int i = 0;
while (it.hasNext()) {
Object obj = it.next();
buf.append((++i));
buf.append(") ");
buf.append( obj);
buf.append("<br>");
if (i == 30 && it.hasNext()) {
buf.append("... " + (ex.getDependencies().size() - 30) + " more");
break;
}
}
return buf.toString();
}
/** Creates a new ErrorDialog with the specified owner and displays the waring */
public void showWarning(String warning,Component owner) {
RaplaContext context = getContext();
Logger logger = getLogger();
showWarning(warning, owner, context, logger);
}
public static void showWarning(String warning, Component owner, RaplaContext context, Logger logger) {
try {
ErrorDialog dialog = new ErrorDialog(context);
dialog.showWarningDialog(warning,owner);
} catch (RaplaException ex2) {
logger.error(ex2.getMessage(),ex2);
}
}
public RaplaCalendar createRaplaCalendar() {
RaplaCalendar cal = new RaplaCalendar( getI18n().getLocale(),getRaplaLocale().getTimeZone());
cal.setDateRenderer(getDateRenderer());
addCopyPaste(cal.getDateField());
return cal;
}
/** lookup DateRenderer from the serviceManager */
final protected DateRenderer getDateRenderer() {
return getService(DateRenderer.class);
}
static Color NON_WORKTIME = new Color(0xcc, 0xcc, 0xcc);
final protected TimeRenderer getTimeRenderer() {
// BJO 00000070
final int start = getCalendarOptions().getWorktimeStartMinutes();
final int end = getCalendarOptions().getWorktimeEndMinutes();
// BJO 00000070
return new TimeRenderer() {
public Color getBackgroundColor( int hourOfDay, int minute )
{
// BJO 00000070
int worktime = hourOfDay * 60 + minute;
// BJO 00000070
if ( start >= end)
{
// BJO 00000070
if ( worktime >= end && worktime < start)
// BJO 00000070
{
return NON_WORKTIME;
}
}
// BJO 00000070
else if ( worktime < start || worktime >= end) {
// BJO 00000070
return NON_WORKTIME;
}
return null;
}
public String getToolTipText( int hourOfDay, int minute )
{
return null;
}
public String getDurationString(int durationInMinutes) {
if ( durationInMinutes > 0 )
{
int hours = durationInMinutes / 60;
int minutes = durationInMinutes % 60;
if ( hours == 0)
{
return "("+minutes + " " + getString("minutes.abbreviation") + ")";
}
if ( minutes % 30 != 0)
{
return "";
}
StringBuilder builder = new StringBuilder();
builder.append(" (");
if ( hours > 0)
{
builder.append(hours );
}
if ( minutes % 60 != 0)
{
char c = 189; // 1/2
builder.append(c);
}
if ( minutes % 30 == 0)
{
builder.append( " " + getString((hours == 1 && minutes % 60 == 0 ? "hour.abbreviation" :"hours.abbreviation")) + ")");
}
return builder.toString();
}
return "";
}
};
}
public RaplaTime createRaplaTime() {
RaplaTime cal = new RaplaTime( getI18n().getLocale(), getRaplaLocale().getTimeZone());
cal.setTimeRenderer( getTimeRenderer() );
int rowsPerHour =getCalendarOptions().getRowsPerHour() ;
cal.setRowsPerHour( rowsPerHour );
addCopyPaste(cal.getTimeField());
return cal;
}
public Map<Object,Object> getSessionMap() {
return getService( ClientService.SESSION_MAP);
}
protected InfoFactory getInfoFactory() {
return getService( InfoFactory.class );
}
/** calls getI18n().getIcon(key) */
final public ImageIcon getIcon(String key) {
return getI18n().getIcon(key);
}
protected EditController getEditController() {
return getService( EditController.class );
}
protected ReservationController getReservationController() {
return getService( ReservationController.class );
}
public Component getMainComponent() {
return getService(ClientService.MAIN_COMPONENT);
}
public void addCopyPaste(final JComponent component) {
ActionListener pasteListener = new ActionListener() {
public void actionPerformed(ActionEvent e) {
paste(component, e);
}
};
ActionListener copyListener = new ActionListener()
{
public void actionPerformed(ActionEvent e) {
copy(component, e);
}
};
final JPopupMenu menu = new JPopupMenu();
{
final JMenuItem copyItem = new JMenuItem();
copyItem.addActionListener( copyListener);
copyItem.setText(getString("copy"));
menu.add(copyItem);
}
{
final JMenuItem pasteItem = new JMenuItem();
pasteItem.addActionListener( pasteListener);
pasteItem.setText(getString("paste"));
menu.add(pasteItem);
}
component.add(menu);
component.addMouseListener(new MouseAdapter()
{
private void showMenuIfPopupTrigger(MouseEvent e) {
if (e.isPopupTrigger()) {
menu.show(component,e.getX() + 3, e.getY() + 3);
}
}
public void mousePressed(MouseEvent e) {
showMenuIfPopupTrigger(e);
}
public void mouseReleased(MouseEvent e) {
showMenuIfPopupTrigger(e);
}
}
);
component.registerKeyboardAction(copyListener,getString("copy"),COPY_STROKE,JComponent.WHEN_FOCUSED);
component.registerKeyboardAction(pasteListener,getString("paste"),PASTE_STROKE,JComponent.WHEN_FOCUSED);
}
public static KeyStroke COPY_STROKE = KeyStroke.getKeyStroke(KeyEvent.VK_C,ActionEvent.CTRL_MASK,false);
public static KeyStroke PASTE_STROKE = KeyStroke.getKeyStroke(KeyEvent.VK_V,ActionEvent.CTRL_MASK,false);
protected IOInterface getIOService()
{
try {
return getService( IOInterface.class);
} catch (Exception e) {
return null;
}
}
protected void copy(final JComponent component, ActionEvent e) {
final Transferable transferable;
if ( component instanceof JTextComponent)
{
String selectedText = ((JTextComponent)component).getSelectedText();
transferable = new StringSelection(selectedText);
}
else if ( component instanceof JTable)
{
JTable table = (JTable)component;
transferable = getSelectedContent(table);
}
else
{
transferable = new StringSelection(component.toString());
}
if ( transferable != null)
{
try
{
final IOInterface service = getIOService();
if (service != null) {
service.setContents(transferable, null);
}
else
{
Action action = component.getActionMap().get(DefaultEditorKit.copyAction);
if ( action != null)
{
action.actionPerformed(e);
}
}
}
catch (AccessControlException ex)
{
clipboard.set( transferable);
}
}
}
static ThreadLocal<Transferable> clipboard = new ThreadLocal<Transferable>();
/** Code from
http://www.javaworld.com/javatips/jw-javatip77.html
*/
private static final String LINE_BREAK = "\n";
private static final String CELL_BREAK = "\t";
private StringSelection getSelectedContent(JTable table) {
int numCols=table.getSelectedColumnCount();
int[] rowsSelected=table.getSelectedRows();
int[] colsSelected=table.getSelectedColumns();
// int numRows=table.getSelectedRowCount();
// if (numRows!=rowsSelected[rowsSelected.length-1]-rowsSelected[0]+1 || numRows!=rowsSelected.length ||
// numCols!=colsSelected[colsSelected.length-1]-colsSelected[0]+1 || numCols!=colsSelected.length) {
//
// JOptionPane.showMessageDialog(null, "Invalid Copy Selection", "Invalid Copy Selection", JOptionPane.ERROR_MESSAGE);
// return null;
// }
StringBuffer excelStr=new StringBuffer();
for (int row:rowsSelected)
{
int j=0;
for (int col:colsSelected)
{
Object value = table.getValueAt(row, col);
String formated;
Class<?> columnClass = table.getColumnClass( col);
boolean isDate = columnClass.isAssignableFrom( java.util.Date.class);
if ( isDate)
{
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
format.setTimeZone( getRaplaLocale().getTimeZone());
if ( value instanceof java.util.Date)
{
String timestamp = format.format( (java.util.Date)value);
formated = timestamp;
}
else
{
String escaped = escape(value);
formated = escaped;
}
}
else
{
String escaped = escape(value);
formated = escaped;
}
excelStr.append( formated );
boolean isLast = j==numCols-1;
if (!isLast) {
excelStr.append(CELL_BREAK);
}
j++;
}
excelStr.append(LINE_BREAK);
}
String string = excelStr.toString();
StringSelection sel = new StringSelection(string);
return sel;
}
private String escape(Object cell) {
return cell.toString().replace(LINE_BREAK, " ").replace(CELL_BREAK, " ");
}
/** Code End */
protected void paste(final JComponent component, ActionEvent e) {
try
{
final IOInterface service = getIOService();
if (service != null) {
final Transferable transferable = service.getContents( null);
Object transferData;
try {
transferData = transferable.getTransferData(DataFlavor.stringFlavor);
if ( transferData != null)
{
if ( component instanceof JTextComponent)
{
((JTextComponent)component).replaceSelection( transferData.toString());
}
if ( component instanceof JTable)
{
// Paste currently not supported
}
}
} catch (Exception ex) {
}
}
else
{
Action action = component.getActionMap().get(DefaultEditorKit.pasteAction);
if ( action != null)
{
action.actionPerformed(e);
}
}
}
catch (AccessControlException ex)
{
Transferable transferable =clipboard.get();
if ( transferable != null)
{
if ( component instanceof JTextComponent)
{
Object transferData;
try {
transferData = transferable.getTransferData(DataFlavor.stringFlavor);
((JTextComponent)component).replaceSelection( transferData.toString());
} catch (Exception e1) {
getLogger().error( e1.getMessage(),e1);
}
}
}
}
}
}
| 04900db4-clienttest | src/org/rapla/gui/RaplaGUIComponent.java | Java | gpl3 | 17,327 |
package org.rapla.gui;
import java.awt.Component;
import java.awt.Point;
import java.util.Collection;
import java.util.Date;
import org.rapla.entities.domain.Allocatable;
import org.rapla.entities.domain.Appointment;
import org.rapla.entities.domain.AppointmentBlock;
import org.rapla.entities.domain.Reservation;
import org.rapla.framework.RaplaException;
/** Use the ReservationController to modify or create a {@link Reservation}.
This class handles all interactions with the user. Examples:
<li>
If you edit a reservation it will first check, if there is already is an
open edit-window for the reservation and will give focus to that window instead of
creating a new one.
</li>
<li>
If you move or delete an repeating appointment it will display dialogs
where the user will be asked if he wants to delete/move the complete appointment
or just the occurrence on the selected date.
</li>
<li>
If conflicts are found, a conflict panel will be displayed on saving.
</li>
*/
public interface ReservationController
{
ReservationEdit edit( Reservation reservation ) throws RaplaException;
ReservationEdit edit( AppointmentBlock appointmentBlock) throws RaplaException;
boolean save(Reservation reservation,Component sourceComponent) throws RaplaException;
public ReservationEdit[] getEditWindows();
/** copies an appointment without interaction */
Appointment copyAppointment( Appointment appointment ) throws RaplaException;
void deleteAppointment( AppointmentBlock appointmentBlock, Component sourceComponent, Point point ) throws RaplaException;
Appointment copyAppointment( AppointmentBlock appointmentBlock, Component sourceComponent, Point point,Collection<Allocatable> contextAllocatables ) throws RaplaException;
void pasteAppointment( Date start, Component sourceComponent, Point point, boolean asNewReservation, boolean keepTime ) throws RaplaException;
/**
* @param keepTime when moving only the date part and not the time part is modified*/
void moveAppointment( AppointmentBlock appointmentBlock, Date newStart, Component sourceComponent, Point point, boolean keepTime ) throws RaplaException;
/**
* @param keepTime when moving only the date part and not the time part is modified*/
void resizeAppointment( AppointmentBlock appointmentBlock, Date newStart, Date newEnd, Component sourceComponent, Point p, boolean keepTime ) throws RaplaException;
void exchangeAllocatable(AppointmentBlock appointmentBlock, Allocatable oldAlloc, Allocatable newAlloc,Date newStart, Component sourceComponent, Point p) throws RaplaException;
boolean isAppointmentOnClipboard();
void deleteBlocks(Collection<AppointmentBlock> blockList, Component parent,Point point) throws RaplaException;
} | 04900db4-clienttest | src/org/rapla/gui/ReservationController.java | Java | gpl3 | 2,833 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2006 Gereon Fassbender, Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.images;
import java.awt.Image;
import java.awt.Toolkit;
import java.io.InputStream;
import java.net.URL;
import javax.swing.ImageIcon;
/**
* Offers direct access to the images.
*/
public class Images
{
public static InputStream getInputStream(String filename)
{
return Images.class.getResourceAsStream(filename);
}
public static Image getImage(String filename)
{
try {
URL url = Images.class.getResource(filename);
if ( url == null)
return null;
return Toolkit.getDefaultToolkit().createImage( url);
} catch (Exception ex) {
return null;
}
}
public static ImageIcon getIcon(String filename)
{
return new ImageIcon(getImage( filename));
}
}
| 04900db4-clienttest | src/org/rapla/gui/images/Images.java | Java | gpl3 | 1,685 |
package org.rapla.gui;
import org.rapla.framework.PluginDescriptor;
public interface PluginOptionPanel extends OptionPanel {
Class<? extends PluginDescriptor<?>> getPluginClass();
}
| 04900db4-clienttest | src/org/rapla/gui/PluginOptionPanel.java | Java | gpl3 | 185 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui;
import java.util.Collection;
import java.util.EventListener;
import org.rapla.entities.domain.Appointment;
public interface AppointmentListener extends EventListener {
void appointmentAdded(Collection<Appointment> appointment);
void appointmentRemoved(Collection<Appointment> appointment);
void appointmentChanged(Collection<Appointment> appointment);
void appointmentSelected(Collection<Appointment> appointment);
}
| 04900db4-clienttest | src/org/rapla/gui/AppointmentListener.java | Java | gpl3 | 1,395 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas, Bettina Lademann |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui;
import java.awt.Component;
import java.awt.Point;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaDefaultContext;
public class MenuContext extends RaplaDefaultContext
{
Collection<?> selectedObjects = Collections.EMPTY_LIST;
Point p;
Object focused;
Component parent;
public MenuContext(RaplaContext parentContext, Object focusedObject) {
this( parentContext, focusedObject, null, null );
}
public MenuContext(RaplaContext parentContext, Object focusedObject, Component parent,Point p) {
super( parentContext);
this.focused = focusedObject;
this.parent= parent ;
this.p = p;
}
public void setSelectedObjects(Collection<?> selectedObjects) {
this.selectedObjects= new ArrayList<Object>(selectedObjects);
}
public Collection<?> getSelectedObjects() {
return selectedObjects;
}
public Point getPoint() {
return p;
}
public Component getComponent() {
return parent;
}
public Object getFocusedObject() {
return focused;
}
}
| 04900db4-clienttest | src/org/rapla/gui/MenuContext.java | Java | gpl3 | 2,169 |
package org.rapla.gui;
import java.awt.Component;
import org.rapla.entities.domain.Reservation;
import org.rapla.framework.RaplaException;
/** performs a check, if the reservation is entered correctly. An example of a reservation check is the conflict checker*/
public interface ReservationCheck
{
/** @param sourceComponent
* @return true if the reservation check is successful and false if the save dialog should be aborted*/
boolean check(Reservation reservation, Component sourceComponent) throws RaplaException;
}
| 04900db4-clienttest | src/org/rapla/gui/ReservationCheck.java | Java | gpl3 | 552 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui;
import java.util.List;
import org.rapla.framework.RaplaException;
import org.rapla.gui.toolkit.RaplaWidget;
public interface EditComponent<T> extends RaplaWidget
{
/** maps all fields back to the current object.*/
public void mapToObjects() throws RaplaException;
public List<T> getObjects();
public void setObjects(List<T> o) throws RaplaException;
}
| 04900db4-clienttest | src/org/rapla/gui/EditComponent.java | Java | gpl3 | 1,331 |
package org.rapla.gui;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.toolkit.RaplaWidget;
public interface AppointmentStatusFactory {
RaplaWidget createStatus(RaplaContext context, ReservationEdit reservationEdit) throws RaplaException;
}
| 04900db4-clienttest | src/org/rapla/gui/AppointmentStatusFactory.java | Java | gpl3 | 310 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2006 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui;
import javax.swing.JComponent;
import org.rapla.framework.RaplaException;
import org.rapla.gui.toolkit.RaplaWidget;
public interface SwingCalendarView extends RaplaWidget
{
public void update( ) throws RaplaException;
/** you can provide a DateSelection component if you want */
public JComponent getDateSelection();
/** Most times you can only scroll programaticaly if the window is visible and the size of
* the component is known, so this method gets called when the window is visible.
* */
public void scrollToStart();
}
| 04900db4-clienttest | src/org/rapla/gui/SwingCalendarView.java | Java | gpl3 | 1,521 |
package org.rapla.gui;
import java.util.Collection;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.TreeCellRenderer;
import javax.swing.tree.TreeModel;
import org.rapla.entities.Category;
import org.rapla.entities.Named;
import org.rapla.entities.domain.Allocatable;
import org.rapla.entities.domain.Reservation;
import org.rapla.facade.Conflict;
import org.rapla.framework.RaplaException;
import org.rapla.gui.toolkit.TreeToolTipRenderer;
public interface TreeFactory {
TreeModel createClassifiableModel(Allocatable[] classifiables, boolean useCategorizations);
TreeModel createClassifiableModel(Allocatable[] classifiables);
TreeModel createClassifiableModel(Reservation[] classifiables);
TreeModel createConflictModel(Collection<Conflict> conflicts ) throws RaplaException;
DefaultMutableTreeNode newNamedNode(Named element);
TreeModel createModel(Category category);
TreeModel createModel(Collection<Category> categories, boolean includeChildren);
TreeModel createModelFlat(Named[] element);
TreeToolTipRenderer createTreeToolTipRenderer();
TreeCellRenderer createConflictRenderer();
TreeCellRenderer createRenderer();
} | 04900db4-clienttest | src/org/rapla/gui/TreeFactory.java | Java | gpl3 | 1,183 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2006 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui;
import javax.swing.Icon;
import org.rapla.facade.CalendarModel;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.framework.TypedComponentRole;
public interface SwingViewFactory
{
public TypedComponentRole<Boolean> PRINT_CONTEXT = new TypedComponentRole<Boolean>("org.rapla.PrintContext");
public SwingCalendarView createSwingView(RaplaContext context, CalendarModel model, boolean editable) throws RaplaException;
public String getViewId();
/** return the key that is responsible for placing the view in the correct position in the drop down selection menu*/
public String getMenuSortKey();
public String getName();
public Icon getIcon();
}
| 04900db4-clienttest | src/org/rapla/gui/SwingViewFactory.java | Java | gpl3 | 1,686 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas, Bettina Lademann |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui;
import org.rapla.framework.RaplaException;
import org.rapla.gui.toolkit.MenuInterface;
public interface MenuFactory
{
public MenuInterface addObjectMenu(MenuInterface menu, MenuContext context, String afterId) throws RaplaException;
public void addReservationWizards(MenuInterface menu, MenuContext context,String afterId) throws RaplaException;
}
| 04900db4-clienttest | src/org/rapla/gui/MenuFactory.java | Java | gpl3 | 1,326 |
package org.rapla.gui;
import java.util.Collection;
import java.util.Date;
import javax.swing.event.ChangeListener;
import org.rapla.entities.domain.Appointment;
import org.rapla.entities.domain.Reservation;
import org.rapla.framework.RaplaException;
public interface ReservationEdit
{
boolean isModifiedSinceLastChange();
void addAppointment( Date start, Date end) throws RaplaException;
Reservation getReservation();
void save() throws RaplaException;
void delete() throws RaplaException;
/** You can add a listener that gets notified everytime a reservation is changed: Reservation attributes, appointments or allocation changes all count*/
void addReservationChangeListener(ChangeListener listener);
void removeReservationChangeListener(ChangeListener listener);
void addAppointmentListener(AppointmentListener listener);
void removeAppointmentListener(AppointmentListener listener);
Collection<Appointment> getSelectedAppointments();
} | 04900db4-clienttest | src/org/rapla/gui/ReservationEdit.java | Java | gpl3 | 1,000 |
package org.rapla.gui;
import java.awt.Component;
import org.rapla.entities.Entity;
import org.rapla.framework.RaplaException;
public interface EditController
{
<T extends Entity> EditComponent<T> createUI( T obj ) throws RaplaException;
<T extends Entity> void edit( T obj, Component owner ) throws RaplaException;
<T extends Entity> void editNew( T obj, Component owner ) throws RaplaException;
<T extends Entity> void edit( T obj, String title, Component owner ) throws RaplaException;
// neue Methoden zur Bearbeitung von mehreren gleichartigen Elementen (Entities-Array)
// orientieren sich an den oberen beiden Methoden zur Bearbeitung von einem Element
<T extends Entity> void edit( T[] obj, Component owner ) throws RaplaException;
<T extends Entity> void edit( T[] obj, String title, Component owner ) throws RaplaException;
} | 04900db4-clienttest | src/org/rapla/gui/EditController.java | Java | gpl3 | 872 |
package org.rapla.gui;
import org.rapla.components.util.TimeInterval;
public interface VisibleTimeInterval {
TimeInterval getVisibleTimeInterval();
}
| 04900db4-clienttest | src/org/rapla/gui/VisibleTimeInterval.java | Java | gpl3 | 160 |
package org.rapla.gui;
import java.beans.PropertyChangeListener;
import org.rapla.facade.CalendarSelectionModel;
import org.rapla.framework.RaplaException;
public interface PublishExtensionFactory
{
PublishExtension creatExtension(CalendarSelectionModel model, PropertyChangeListener revalidateCallback) throws RaplaException;
} | 04900db4-clienttest | src/org/rapla/gui/PublishExtensionFactory.java | Java | gpl3 | 342 |
package org.rapla.gui.internal;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import javax.swing.AbstractAction;
import javax.swing.BorderFactory;
import javax.swing.ComboBoxModel;
import javax.swing.DefaultComboBoxModel;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JComboBox;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextField;
import javax.swing.JToolBar;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import org.rapla.components.layout.TableLayout;
import org.rapla.entities.Entity;
import org.rapla.entities.EntityNotFoundException;
import org.rapla.entities.configuration.CalendarModelConfiguration;
import org.rapla.entities.configuration.Preferences;
import org.rapla.facade.CalendarModel;
import org.rapla.facade.CalendarSelectionModel;
import org.rapla.facade.internal.CalendarModelImpl;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.RaplaAction;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.internal.common.InternMenus;
import org.rapla.gui.internal.common.MultiCalendarView;
import org.rapla.gui.toolkit.DialogUI;
import org.rapla.gui.toolkit.RaplaMenu;
import org.rapla.plugin.autoexport.AutoExportPlugin;
import org.rapla.plugin.tableview.internal.AppointmentTableViewFactory;
import org.rapla.plugin.tableview.internal.ReservationTableViewFactory;
import org.rapla.storage.UpdateResult;
public class SavedCalendarView extends RaplaGUIComponent implements ActionListener {
JComboBox selectionBox;
private boolean listenersEnabled = true;
List<FileEntry> filenames = new ArrayList<FileEntry>();
final MultiCalendarView calendarContainer;
final CalendarSelectionModel model;
final ResourceSelection resourceSelection;
JToolBar toolbar = new JToolBar();
class SaveAction extends RaplaAction
{
public SaveAction(RaplaContext sm) {
super(sm);
final String name = getString("save") ;
putValue(NAME,name);
putValue(SHORT_DESCRIPTION,name);
putValue(SMALL_ICON,getIcon("icon.save"));
}
public void actionPerformed(ActionEvent arg0) {
save();
}
}
class PublishAction extends RaplaAction
{
PublishDialog publishDialog;
public PublishAction(RaplaContext sm) throws RaplaException {
super(sm);
final String name = getString("publish") ;
putValue(NAME,name);
putValue(SHORT_DESCRIPTION,name);
putValue(SMALL_ICON,getIcon("icon.export"));
publishDialog = new PublishDialog(getContext());
}
public void actionPerformed(ActionEvent arg0) {
try
{
CalendarSelectionModel model = getService( CalendarSelectionModel.class);
FileEntry filename = getSelectedFile();
Component parentComponent = getMainComponent();
if ( filename.isDefault)
{
publishDialog.export(model, parentComponent, null);
}
else
{
publishDialog.export(model, parentComponent, filename.name);
}
}
catch (RaplaException ex) {
showException( ex, getMainComponent());
}
}
public boolean hasPublishActions()
{
return publishDialog.hasPublishActions();
}
}
class DeleteAction extends RaplaAction
{
public DeleteAction(RaplaContext sm)
{
super(sm);
final String name = getString("delete");
putValue(NAME,name);
putValue(SHORT_DESCRIPTION,name);
putValue(SMALL_ICON,getIcon("icon.delete"));
}
public void actionPerformed(ActionEvent arg0) {
try
{
String[] objects = new String[] { getSelectedFile().name};
DialogUI dlg = getInfoFactory().createDeleteDialog( objects, getMainComponent());
dlg.start();
if (dlg.getSelectedIndex() != 0)
return;
delete();
}
catch (RaplaException ex) {
showException( ex, getMainComponent());
}
}
}
final SaveAction saveAction;
final PublishAction publishAction;
final DeleteAction deleteAction;
class FileEntry implements Comparable<FileEntry>
{
String name;
boolean isDefault;
public FileEntry(String name) {
this.name=name;
}
public String toString()
{
return name;
}
public int compareTo(FileEntry o)
{
return toString().compareTo( o.toString());
}
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + getOuterType().hashCode();
result = prime * result + (isDefault ? 1231 : 1237);
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
FileEntry other = (FileEntry) obj;
if (!getOuterType().equals(other.getOuterType()))
return false;
if (isDefault != other.isDefault)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
private SavedCalendarView getOuterType() {
return SavedCalendarView.this;
}
}
public SavedCalendarView(RaplaContext context, final MultiCalendarView calendarContainer, final ResourceSelection resourceSelection, final CalendarSelectionModel model) throws RaplaException {
super(context);
// I18nBundle i18n = getI18n();
saveAction = new SaveAction(context);
publishAction = new PublishAction(context);
deleteAction = new DeleteAction( context);
this.model = model;
this.calendarContainer = calendarContainer;
this.resourceSelection = resourceSelection;
JButton save = new JButton();
JButton publish = new JButton();
JButton delete = new JButton();
toolbar.setFloatable( false);
selectionBox = new JComboBox();
selectionBox.setToolTipText( getString("calendar"));
selectionBox.setMinimumSize( new Dimension(120,30));
selectionBox.setSize( new Dimension(150,30));
// rku: updated, the next line prevented resizing the combobox when using the divider of the splitpane
// especially, when having long filenames this is annoying
//selectionBox.setMaximumSize( new Dimension(200,30));
selectionBox.setPreferredSize( new Dimension(150,30));
save.setAction( saveAction);
publish.setAction(publishAction);
RaplaMenu settingsMenu = getService(InternMenus.CALENDAR_SETTINGS);
settingsMenu.insertAfterId(new JMenuItem(saveAction), null);
if ( publishAction.hasPublishActions())
{
settingsMenu.insertAfterId(new JMenuItem(publishAction), null);
}
settingsMenu.insertAfterId(new JMenuItem(deleteAction),null);
delete.setAction( deleteAction);
// toolbar.add(new JLabel(getString("calendar")));
// toolbar.add(new JToolBar.Separator());
toolbar.add( selectionBox);
toolbar.add(new JToolBar.Separator());
toolbar.add(save);
save.setText("");
publish.setText("");
delete.setText("");
if ( publishAction.hasPublishActions())
{
toolbar.add(publish);
}
toolbar.add(delete);
toolbar.setBorder( BorderFactory.createEmptyBorder(5, 5, 5, 5));
update();
final int defaultIndex = getDefaultIndex();
if (defaultIndex != -1)
selectionBox.setSelectedIndex(defaultIndex);
else
selectionBox.setSelectedIndex(0);
updateTooltip();
selectionBox.addActionListener( this);
}
public void actionPerformed(ActionEvent e) {
updateTooltip();
if ( !listenersEnabled)
{
return;
}
try
{
changeSelection();
}
catch (RaplaException ex) {
showException( ex, getMainComponent());
}
}
protected void updateTooltip() {
Object selectedItem = selectionBox.getSelectedItem();
if ( selectedItem != null )
{
selectionBox.setToolTipText(selectedItem.toString());
}
}
public JComponent getComponent() {
return toolbar;
}
private void changeSelection() throws RaplaException
{
FileEntry selectedFile = getSelectedFile();
// keep current date in mind
final Date tmpDate = model.getSelectedDate();
// keep in mind if current model had saved date
String tmpModelHasStoredCalenderDate = model.getOption(CalendarModel.SAVE_SELECTED_DATE);
if(tmpModelHasStoredCalenderDate == null)
tmpModelHasStoredCalenderDate = "false";
// load sets stored date
if ( selectedFile.isDefault)
{
model.load(null);
}
else
{
model.load(selectedFile.name);
}
closeFilter();
// check if new model had stored date
String newModelHasStoredCalenderDate = model.getOption(CalendarModel.SAVE_SELECTED_DATE);
if(newModelHasStoredCalenderDate == null)
newModelHasStoredCalenderDate = "false";
if ("false".equals(newModelHasStoredCalenderDate)) {
if ("false".equals(tmpModelHasStoredCalenderDate))
// if we are switching from a model with saved date to a model without date we reset to current date
{
model.setSelectedDate(tmpDate);
} else {
model.setSelectedDate(new Date());
}
}
updateActions();
Entity preferences = getQuery().getPreferences();
UpdateResult modificationEvt = new UpdateResult( getUser());
modificationEvt.addOperation( new UpdateResult.Change(preferences, preferences));
resourceSelection.dataChanged(modificationEvt);
calendarContainer.update(modificationEvt);
calendarContainer.getSelectedCalendar().scrollToStart();
}
public void closeFilter() {
// CKO Not a good solution. FilterDialogs should close themselfs when model changes.
// BJO 00000139
if(resourceSelection.getFilterButton().isOpen())
resourceSelection.getFilterButton().doClick();
if(calendarContainer.getFilterButton().isOpen())
calendarContainer.getFilterButton().doClick();
// BJO 00000139
}
public void update() throws RaplaException
{
updateActions();
try
{
listenersEnabled = false;
final FileEntry item = getSelectedFile();
DefaultComboBoxModel model = updateModel();
if ( item != null )
{
model.setSelectedItem( item );
}
}
finally
{
listenersEnabled = true;
}
}
@SuppressWarnings("unchecked")
protected DefaultComboBoxModel updateModel() throws RaplaException,
EntityNotFoundException {
final Preferences preferences = getQuery().getPreferences();
Map<String, CalendarModelConfiguration> exportMap= preferences.getEntry(AutoExportPlugin.PLUGIN_ENTRY);
filenames.clear();
if ( exportMap != null) {
for (Iterator<String> it= exportMap.keySet().iterator();it.hasNext();) {
String filename = it.next();
filenames.add( new FileEntry(filename));
}
}
// rku: sort entries by name
Collections.sort(filenames);
final FileEntry defaultEntry = new FileEntry(getString("default") );
defaultEntry.isDefault = true;
filenames.add(0,defaultEntry);
DefaultComboBoxModel model = new DefaultComboBoxModel(filenames.toArray());
selectionBox.setModel(model);
return model;
}
private void updateActions() {
FileEntry selectedFile = getSelectedFile();
boolean isDefault = selectedFile == null || selectedFile.isDefault ;
final boolean modifyPreferencesAllowed = isModifyPreferencesAllowed() && getModification().getTemplateName() == null;
saveAction.setEnabled(modifyPreferencesAllowed );
publishAction.setEnabled( modifyPreferencesAllowed);
deleteAction.setEnabled( !isDefault && modifyPreferencesAllowed);
}
public void save(final String filename) throws RaplaException
{
Preferences preferences = ((CalendarModelImpl)model).createStorablePreferences(filename);
getModification().store( preferences);
// TODO Enable undo with a specific implementation, that does not overwrite all preference changes and regards dynamic type changes
// Map<Preferences, Preferences> originalMap = getModification().getPersistant(Collections.singletonList(preferences) );
// Preferences original = originalMap.get(preferences);
// Collection<Preferences> originalList = original != null ? Collections.singletonList( original): null;
// Collection<Preferences> newList = Collections.singletonList(preferences);
// String file = (filename != null) ? filename : getString("default");
// String commandoName = getString("save")+ " " + getString("calendar") + " " + file ;
// SaveUndo<Preferences> cmd = new SaveUndo<Preferences>(getContext(), newList, originalList, commandoName);
// getModification().getCommandHistory().storeAndExecute( cmd);
}
private void delete() throws RaplaException
{
final FileEntry selectedFile = getSelectedFile();
if ( selectedFile == null || selectedFile.isDefault)
{
return;
}
final Preferences preferences = newEditablePreferences();
Map<String,CalendarModelConfiguration> exportMap= preferences.getEntry(AutoExportPlugin.PLUGIN_ENTRY);
Map<String,CalendarModelConfiguration> newMap = new TreeMap<String,CalendarModelConfiguration>();
for (Iterator<String> it= exportMap.keySet().iterator();it.hasNext();) {
String filename = it.next();
if (!filename.equals( selectedFile.name)) {
CalendarModelConfiguration entry = exportMap.get( filename );
newMap.put( filename, entry);
}
}
preferences.putEntry( AutoExportPlugin.PLUGIN_ENTRY, getModification().newRaplaMap( newMap ));
getModification().store( preferences);
// TODO Enable undo with a specific implementation, that does not overwrite all preference changes and regards dynamic type changes
// Collection<Preferences> originalList = Collections.singletonList(getQuery().getPreferences());
// Collection<Preferences> newList = Collections.singletonList(preferences);
// String commandoName = getString("delete")+ " " + getString("calendar") + " " + selectedFile.name;
// SaveUndo<Preferences> cmd = new SaveUndo<Preferences>(getContext(), newList, originalList, commandoName);
// getModification().getCommandHistory().storeAndExecute( cmd);
final int defaultIndex = getDefaultIndex();
if (defaultIndex != -1)
selectionBox.setSelectedIndex(defaultIndex);
else
selectionBox.setSelectedIndex(0);
//changeSelection();
}
private int getDefaultIndex() {
return ((DefaultComboBoxModel) selectionBox.getModel()).getIndexOf(getString("default"));
}
private void save() {
final FileEntry selectedFile = getSelectedFile();
final Component parentComponent = getMainComponent();
try {
JPanel panel = new JPanel();
final JTextField textField = new JTextField(20);
addCopyPaste( textField);
String dateString;
if( model.getViewId().equals(ReservationTableViewFactory.TABLE_VIEW)
|| model.getViewId().equals(AppointmentTableViewFactory.TABLE_VIEW))
dateString = getRaplaLocale().formatDate(model.getStartDate()) + " - " + getRaplaLocale().formatDate(model.getEndDate());
else
dateString = getRaplaLocale().formatDate(model.getSelectedDate());
final JCheckBox saveSelectedDateField = new JCheckBox(getI18n().format("including_date",dateString));
panel.setPreferredSize( new Dimension(600,300));
panel.setLayout(new TableLayout( new double[][] {{TableLayout.PREFERRED,5,TableLayout.FILL},{TableLayout.PREFERRED,5,TableLayout.PREFERRED,5,TableLayout.FILL}}));
panel.setBorder(BorderFactory.createEmptyBorder(10,10,10,10));
panel.add(new JLabel(getString("file.enter_name") +":"), "0,0");
panel.add(textField, "2,0");
addCopyPaste( textField);
panel.add(saveSelectedDateField, "2,2");
final String entry = model.getOption(CalendarModel.SAVE_SELECTED_DATE);
if(entry != null)
saveSelectedDateField.setSelected(entry.equals("true"));
@SuppressWarnings("unchecked")
final JList list = new JList(filenames.toArray());
panel.add( new JScrollPane(list), "0,4,2,1");
//int selectedIndex = selectionBox.getSelectedIndex();
Object selectedItem = selectionBox.getSelectedItem();
if ( selectedItem != null)
{
list.setSelectedValue( selectedItem,true);
}
textField.setText( selectedFile.toString());
list.addListSelectionListener( new ListSelectionListener() {
public void valueChanged( ListSelectionEvent e )
{
FileEntry filename = (FileEntry) list.getSelectedValue();
if ( filename != null) {
textField.setText( filename.toString() );
try {
final CalendarSelectionModel m = getModification().newCalendarModel( getUser());
if (filename.isDefault )
{
m.load(null);
}
else
{
m.load(filename.toString());
}
final String entry = m.getOption(CalendarModel.SAVE_SELECTED_DATE);
if( entry != null)
saveSelectedDateField.setSelected(entry.equals("true"));
} catch (RaplaException ex) {
showException( ex, getMainComponent());
}
}
}
});
final DialogUI dlg = DialogUI.create(
getContext(),
parentComponent,true,panel,
new String[] {
getString("save")
,getString("cancel")
});
dlg.setTitle(getString("save") + " " +getString("calendar_settings"));
dlg.getButton(0).setIcon(getIcon("icon.save"));
dlg.getButton(1).setIcon(getIcon("icon.cancel"));
dlg.getButton(0).setAction( new AbstractAction() {
private static final long serialVersionUID = 1L;
public void actionPerformed(ActionEvent e) {
String filename = textField.getText().trim();
if (filename.length() == 0)
{
showWarning(getString("error.no_name"), parentComponent);
return;
}
dlg.close();
try
{
String saveSelectedDate = saveSelectedDateField.isSelected() ? "true" : "false";
model.setOption( CalendarModel.SAVE_SELECTED_DATE, saveSelectedDate);
FileEntry selectedValue = (FileEntry)list.getSelectedValue();
final boolean isDefault;
if ( selectedValue != null)
{
isDefault = selectedValue.isDefault && filename.equals( selectedValue.name );
}
else
{
isDefault = filename.equals( getString("default") );
}
if ( isDefault)
{
save(null);
try
{
listenersEnabled = false;
selectionBox.setSelectedIndex(0);
}
finally
{
listenersEnabled = true;
}
}
else
{
// We reset exports for newly created files
{
FileEntry fileEntry = findInModel(filename);
if ( fileEntry == null)
{
model.resetExports();
}
}
save(filename);
try
{
listenersEnabled = false;
updateModel();
FileEntry fileEntry = findInModel(filename);
if ( fileEntry != null)
{
selectionBox.setSelectedItem( fileEntry);
}
else
{
selectionBox.setSelectedIndex(0);
}
}
finally
{
listenersEnabled = true;
}
}
}
catch (RaplaException ex)
{
showException( ex, parentComponent);
}
}
private FileEntry findInModel(String filename)
{
ComboBoxModel selection = selectionBox.getModel();
for ( int i=0;i<selection.getSize();i++)
{
final FileEntry elementAt = (FileEntry) selection.getElementAt( i);
if ( !elementAt.isDefault && elementAt.toString().equals(filename))
{
return elementAt;
}
}
return null;
}
});
dlg.start();
} catch (RaplaException ex) {
showException( ex, parentComponent);
}
}
private FileEntry getSelectedFile()
{
ComboBoxModel model2 = selectionBox.getModel();
FileEntry selectedItem = (FileEntry)model2.getSelectedItem();
return selectedItem;
}
}
| 04900db4-clienttest | src/org/rapla/gui/internal/SavedCalendarView.java | Java | gpl3 | 23,990 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2006 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal;
import java.awt.BorderLayout;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import javax.swing.BorderFactory;
import javax.swing.JComponent;
import javax.swing.JPanel;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.tree.DefaultTreeModel;
import org.rapla.components.calendar.RaplaArrowButton;
import org.rapla.components.layout.TableLayout;
import org.rapla.entities.Entity;
import org.rapla.entities.RaplaObject;
import org.rapla.entities.RaplaType;
import org.rapla.entities.User;
import org.rapla.entities.domain.Allocatable;
import org.rapla.entities.domain.Period;
import org.rapla.entities.dynamictype.ClassificationFilter;
import org.rapla.entities.dynamictype.DynamicType;
import org.rapla.facade.CalendarSelectionModel;
import org.rapla.facade.ModificationEvent;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.MenuContext;
import org.rapla.gui.MenuFactory;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.TreeFactory;
import org.rapla.gui.internal.action.RaplaObjectAction;
import org.rapla.gui.internal.common.InternMenus;
import org.rapla.gui.internal.common.MultiCalendarView;
import org.rapla.gui.internal.edit.ClassifiableFilterEdit;
import org.rapla.gui.internal.view.TreeFactoryImpl;
import org.rapla.gui.toolkit.PopupEvent;
import org.rapla.gui.toolkit.PopupListener;
import org.rapla.gui.toolkit.RaplaMenu;
import org.rapla.gui.toolkit.RaplaPopupMenu;
import org.rapla.gui.toolkit.RaplaTree;
import org.rapla.gui.toolkit.RaplaWidget;
public class ResourceSelection extends RaplaGUIComponent implements RaplaWidget {
protected JPanel content = new JPanel();
public RaplaTree treeSelection = new RaplaTree();
TableLayout tableLayout;
protected JPanel buttonsPanel = new JPanel();
protected final CalendarSelectionModel model;
MultiCalendarView view;
Listener listener = new Listener();
protected FilterEditButton filterEdit;
public ResourceSelection(RaplaContext context, MultiCalendarView view, CalendarSelectionModel model) throws RaplaException {
super(context);
this.model = model;
this.view = view;
/*double[][] sizes = new double[][] { { TableLayout.FILL }, { TableLayout.PREFERRED, TableLayout.PREFERRED, TableLayout.FILL } };
tableLayout = new TableLayout(sizes);*/
content.setLayout(new BorderLayout());
content.add(treeSelection);
// content.setPreferredSize(new Dimension(260,400));
content.setBorder(BorderFactory.createRaisedBevelBorder());
content.add(buttonsPanel, BorderLayout.NORTH);
buttonsPanel.setLayout( new BorderLayout());
filterEdit = new FilterEditButton(context, model, listener,true);
buttonsPanel.add(filterEdit.getButton(), BorderLayout.EAST);
treeSelection.setToolTipRenderer(getTreeFactory().createTreeToolTipRenderer());
treeSelection.setMultiSelect(true);
treeSelection.getTree().setSelectionModel(((TreeFactoryImpl) getTreeFactory()).createComplexTreeSelectionModel());
updateTree();
updateSelection();
treeSelection.addChangeListener(listener);
treeSelection.addPopupListener(listener);
treeSelection.addDoubleclickListeners(listener);
treeSelection.getTree().addFocusListener(listener);
javax.swing.ToolTipManager.sharedInstance().registerComponent(treeSelection.getTree());
updateMenu();
}
protected HashSet<?> setSelectedObjects(){
HashSet<Object> elements = new HashSet<Object>(treeSelection.getSelectedElements());
getModel().setSelectedObjects(elements);
return elements;
}
public RaplaArrowButton getFilterButton() {
return filterEdit.getButton();
}
public RaplaTree getTreeSelection() {
return treeSelection;
}
protected CalendarSelectionModel getModel() {
return model;
}
public void dataChanged(ModificationEvent evt) throws RaplaException {
if ( evt != null && evt.isModified())
{
updateTree();
updateMenu();
}
// No longer needed here as directly done in RaplaClientServiceImpl
// ((CalendarModelImpl) model).dataChanged( evt);
}
final protected TreeFactory getTreeFactory() {
return getService(TreeFactory.class);
}
boolean treeListenersEnabled = true;
/*
* (non-Javadoc)
*
* @see org.rapla.gui.internal.view.ITreeFactory#createClassifiableModel(org.rapla.entities.dynamictype.Classifiable[], org.rapla.entities.dynamictype.DynamicType[])
*/
protected void updateTree() throws RaplaException {
treeSelection.getTree().setRootVisible(false);
treeSelection.getTree().setShowsRootHandles(true);
treeSelection.getTree().setCellRenderer(((TreeFactoryImpl) getTreeFactory()).createRenderer());
DefaultTreeModel treeModel = generateTree();
try {
treeListenersEnabled = false;
treeSelection.exchangeTreeModel(treeModel);
updateSelection();
} finally {
treeListenersEnabled = true;
}
}
protected DefaultTreeModel generateTree() throws RaplaException {
ClassificationFilter[] filter = getModel().getAllocatableFilter();
final TreeFactoryImpl treeFactoryImpl = (TreeFactoryImpl) getTreeFactory();
DefaultTreeModel treeModel = treeFactoryImpl.createModel(filter);
return treeModel;
}
protected void updateSelection() {
Collection<Object> selectedObjects = new ArrayList<Object>(getModel().getSelectedObjects());
treeSelection.select(selectedObjects);
}
public JComponent getComponent() {
return content;
}
protected MenuContext createMenuContext(Point p, Object obj) {
MenuContext menuContext = new MenuContext(getContext(), obj, getComponent(), p);
return menuContext;
}
protected void showTreePopup(PopupEvent evt) {
try {
Point p = evt.getPoint();
Object obj = evt.getSelectedObject();
List<?> list = treeSelection.getSelectedElements();
MenuContext menuContext = createMenuContext(p, obj);
menuContext.setSelectedObjects(list);
RaplaPopupMenu menu = new RaplaPopupMenu();
RaplaMenu newMenu = new RaplaMenu("new");
newMenu.setText(getString("new"));
boolean addNewReservationMenu = obj instanceof Allocatable || obj instanceof DynamicType;
((MenuFactoryImpl) getMenuFactory()).addNew(newMenu, menuContext, null, addNewReservationMenu);
getMenuFactory().addObjectMenu(menu, menuContext, "EDIT_BEGIN");
newMenu.setEnabled( newMenu.getMenuComponentCount() > 0);
menu.insertAfterId(newMenu, "EDIT_BEGIN");
JComponent component = (JComponent) evt.getSource();
menu.show(component, p.x, p.y);
} catch (RaplaException ex) {
showException(ex, getComponent());
}
}
class Listener implements PopupListener, ChangeListener, ActionListener, FocusListener {
public void showPopup(PopupEvent evt) {
showTreePopup(evt);
}
public void actionPerformed(ActionEvent evt) {
Object focusedObject = evt.getSource();
if ( focusedObject == null || !(focusedObject instanceof RaplaObject))
return;
// System.out.println(focusedObject.toString());
RaplaType type = ((RaplaObject) focusedObject).getRaplaType();
if ( type == User.TYPE
|| type == Allocatable.TYPE
|| type ==Period.TYPE
)
{
RaplaObjectAction editAction = new RaplaObjectAction( getContext(), getComponent(),null);
if (editAction.canModify( focusedObject))
{
editAction.setEdit((Entity<?>)focusedObject);
editAction.actionPerformed(null);
}
}
}
public void stateChanged(ChangeEvent evt) {
if (!treeListenersEnabled) {
return;
}
try {
Object source = evt.getSource();
ClassifiableFilterEdit filterUI = filterEdit.getFilterUI();
if ( filterUI != null && source == filterUI)
{
final ClassificationFilter[] filters = filterUI.getFilters();
model.setAllocatableFilter( filters);
updateTree();
applyFilter();
}
else if ( source == treeSelection)
{
updateChange();
}
} catch (Exception ex) {
showException(ex, getComponent());
}
}
public void focusGained(FocusEvent e) {
try {
if (!getUserModule().isSessionActive())
{
return;
}
updateMenu();
} catch (Exception ex) {
showException(ex, getComponent());
}
}
public void focusLost(FocusEvent e) {
}
}
public void updateChange() throws RaplaException {
setSelectedObjects();
updateMenu();
applyFilter();
}
public void applyFilter() throws RaplaException {
view.getSelectedCalendar().update();
}
public void updateMenu() throws RaplaException {
RaplaMenu editMenu = getService(InternMenus.EDIT_MENU_ROLE);
RaplaMenu newMenu = getService(InternMenus.NEW_MENU_ROLE);
editMenu.removeAllBetween("EDIT_BEGIN", "EDIT_END");
newMenu.removeAll();
List<?> list = treeSelection.getSelectedElements();
Object focusedObject = null;
if (list.size() == 1) {
focusedObject = treeSelection.getSelectedElement();
}
MenuContext menuContext = createMenuContext( null, focusedObject);
menuContext.setSelectedObjects(list);
if ( treeSelection.getTree().hasFocus())
{
getMenuFactory().addObjectMenu(editMenu, menuContext, "EDIT_BEGIN");
}
((MenuFactoryImpl) getMenuFactory()).addNew(newMenu, menuContext, null, true);
newMenu.setEnabled(newMenu.getMenuComponentCount() > 0 );
}
public MenuFactory getMenuFactory() {
return getService(MenuFactory.class);
}
}
| 04900db4-clienttest | src/org/rapla/gui/internal/ResourceSelection.java | Java | gpl3 | 11,749 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2013 Christopher Kohlhaas, Bettina Lademann |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal;
import java.awt.Component;
import java.awt.Point;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import javax.swing.Action;
import javax.swing.JMenuItem;
import javax.swing.MenuElement;
import org.rapla.client.RaplaClientExtensionPoints;
import org.rapla.components.util.DateTools;
import org.rapla.components.util.TimeInterval;
import org.rapla.entities.Category;
import org.rapla.entities.Entity;
import org.rapla.entities.RaplaObject;
import org.rapla.entities.RaplaType;
import org.rapla.entities.User;
import org.rapla.entities.domain.Allocatable;
import org.rapla.entities.domain.Period;
import org.rapla.entities.domain.Reservation;
import org.rapla.entities.dynamictype.DynamicType;
import org.rapla.entities.dynamictype.DynamicTypeAnnotations;
import org.rapla.facade.CalendarModel;
import org.rapla.facade.CalendarSelectionModel;
import org.rapla.facade.internal.CalendarModelImpl;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.MenuContext;
import org.rapla.gui.MenuFactory;
import org.rapla.gui.ObjectMenuFactory;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.internal.action.DynamicTypeAction;
import org.rapla.gui.internal.action.RaplaObjectAction;
import org.rapla.gui.internal.action.user.PasswordChangeAction;
import org.rapla.gui.internal.action.user.UserAction;
import org.rapla.gui.toolkit.IdentifiableMenuEntry;
import org.rapla.gui.toolkit.MenuInterface;
import org.rapla.gui.toolkit.RaplaMenuItem;
import org.rapla.gui.toolkit.RaplaSeparator;
public class MenuFactoryImpl extends RaplaGUIComponent implements MenuFactory
{
public void addReservationWizards( MenuInterface menu, MenuContext context, String afterId ) throws RaplaException
{
if (canCreateReservation())
{
addNewMenus(menu, afterId);
}
}
/**
* @param model
* @param startDate
* @return
*/
protected Date getEndDate( CalendarModel model,Date startDate) {
Collection<TimeInterval> markedIntervals = model.getMarkedIntervals();
Date endDate = null;
if ( markedIntervals.size() > 0)
{
TimeInterval first = markedIntervals.iterator().next();
endDate = first.getEnd();
}
if ( endDate != null)
{
return endDate;
}
return new Date(startDate.getTime() + DateTools.MILLISECONDS_PER_HOUR);
}
protected Date getStartDate(CalendarModel model) {
Collection<TimeInterval> markedIntervals = model.getMarkedIntervals();
Date startDate = null;
if ( markedIntervals.size() > 0)
{
TimeInterval first = markedIntervals.iterator().next();
startDate = first.getStart();
}
if ( startDate != null)
{
return startDate;
}
Date selectedDate = model.getSelectedDate();
if ( selectedDate == null)
{
selectedDate = getQuery().today();
}
Date time = new Date (DateTools.MILLISECONDS_PER_MINUTE * getCalendarOptions().getWorktimeStartMinutes());
startDate = getRaplaLocale().toDate(selectedDate,time);
return startDate;
}
private void addNewMenus(MenuInterface menu, String afterId) throws RaplaException
{
boolean canAllocateSelected = canAllocateSelected();
if ( canAllocateSelected )
{
Collection<IdentifiableMenuEntry> wizards = getContainer().lookupServicesFor( RaplaClientExtensionPoints.RESERVATION_WIZARD_EXTENSION);
Map<String,IdentifiableMenuEntry> sortedMap = new TreeMap<String, IdentifiableMenuEntry>();
for (IdentifiableMenuEntry entry:wizards)
{
sortedMap.put(entry.getId(), entry);
}
for ( IdentifiableMenuEntry wizard: sortedMap.values())
{
MenuElement menuElement = wizard.getMenuElement();
if ( menuElement != null)
{
menu.insertAfterId(menuElement.getComponent(), afterId);
}
}
}
// else
// {
// JMenuItem cantAllocate = new JMenuItem(getString("permission.denied"));
// cantAllocate.setEnabled( false);
// menu.insertAfterId(cantAllocate, afterId);
// }
}
protected boolean canAllocateSelected() throws RaplaException {
User user = getUser();
Date today = getQuery().today();
boolean canAllocate = false;
CalendarSelectionModel model = getService(CalendarSelectionModel.class);
Collection<Allocatable> selectedAllocatables = model.getMarkedAllocatables();
Date start = getStartDate( model);
Date end = getEndDate( model, start);
for ( Allocatable alloc: selectedAllocatables) {
if (alloc.canAllocate( user, start, end, today))
canAllocate = true;
}
boolean canAllocateSelected = canAllocate || (selectedAllocatables.size() == 0 && canUserAllocateSomething( getUser()));
return canAllocateSelected;
}
public MenuFactoryImpl(RaplaContext sm) {
super(sm);
}
public MenuInterface addNew( MenuInterface menu, MenuContext context,String afterId) throws RaplaException
{
return addNew(menu, context, afterId, false);
}
public MenuInterface addNew( MenuInterface menu, MenuContext context,String afterId, boolean addNewReservationMenu ) throws RaplaException
{
// Do nothing if the user can't allocate anything
User user = getUser();
if (!canUserAllocateSomething( user) )
{
return menu;
}
Component parent = context.getComponent();
Object focusedObject = context.getFocusedObject();
Point p = context.getPoint();
if ( addNewReservationMenu)
{
addReservationWizards(menu, context, afterId);
}
boolean allocatableType = false;
boolean reservationType = false;
if ( focusedObject instanceof DynamicType)
{
DynamicType type = (DynamicType) focusedObject;
String classificationType = type.getAnnotation( DynamicTypeAnnotations.KEY_CLASSIFICATION_TYPE );
allocatableType = classificationType.equals( DynamicTypeAnnotations.VALUE_CLASSIFICATION_TYPE_PERSON ) || classificationType.equals( DynamicTypeAnnotations.VALUE_CLASSIFICATION_TYPE_RESOURCE );
reservationType = classificationType.equals( DynamicTypeAnnotations.VALUE_CLASSIFICATION_TYPE_RESERVATION );
}
boolean allocatableNodeContext = allocatableType || focusedObject instanceof Allocatable || focusedObject == CalendarModelImpl.ALLOCATABLES_ROOT;
if ( isRegisterer() || isAdmin()) {
if ( allocatableNodeContext)
{
menu.addSeparator();
addAllocatableMenuNew( menu, parent,p, focusedObject);
}
}
if ( isAdmin() )
{
boolean reservationNodeContext = reservationType || (focusedObject!= null && focusedObject.equals( getString("reservation_type" )));
boolean userNodeContext = focusedObject instanceof User || (focusedObject != null && focusedObject.equals( getString("users")));
boolean periodNodeContext = focusedObject instanceof Period || (focusedObject != null && focusedObject.equals( getString("periods")));
boolean categoryNodeContext = focusedObject instanceof Category || (focusedObject != null && focusedObject.equals( getString("categories")));
if (userNodeContext || allocatableNodeContext || reservationNodeContext || periodNodeContext || categoryNodeContext )
{
if ( allocatableNodeContext || addNewReservationMenu)
{
menu.addSeparator();
}
}
if ( userNodeContext)
{
addUserMenuNew( menu , parent, p);
}
if (allocatableNodeContext)
{
addTypeMenuNew(menu, DynamicTypeAnnotations.VALUE_CLASSIFICATION_TYPE_RESOURCE,parent, p);
addTypeMenuNew(menu, DynamicTypeAnnotations.VALUE_CLASSIFICATION_TYPE_PERSON,parent, p);
}
if ( periodNodeContext)
{
addPeriodMenuNew( menu , parent, p );
}
if ( categoryNodeContext )
{
addCategoryMenuNew( menu , parent, p, focusedObject );
}
if ( reservationNodeContext)
{
addTypeMenuNew(menu, DynamicTypeAnnotations.VALUE_CLASSIFICATION_TYPE_RESERVATION,parent, p);
}
/*
*/
}
return menu;
}
public MenuInterface addObjectMenu( MenuInterface menu, MenuContext context) throws RaplaException
{
return addObjectMenu( menu, context, "EDIT_BEGIN");
}
public MenuInterface addObjectMenu( MenuInterface menu, MenuContext context, String afterId ) throws RaplaException
{
Component parent = context.getComponent();
Object focusedObject = context.getFocusedObject();
Point p = context.getPoint();
Collection<Entity<?>> list = new LinkedHashSet<Entity<?>>();
if ( focusedObject != null && (focusedObject instanceof Entity))
{
Entity<?> obj = (Entity<?>) focusedObject;
list.add( obj );
addAction(menu, parent, p, afterId).setView(obj);
}
for ( Object obj: context.getSelectedObjects())
{
if ( obj instanceof Entity)
{
list.add( (Entity<?>) obj);
}
}
{
List<Entity<?>> deletableObjects = getDeletableObjects(list);
if ( deletableObjects.size() > 0)
{
addAction(menu,parent,p, afterId).setDeleteSelection(deletableObjects);
Collection<Entity<?>> editObjects = getObjectsWithSameType( deletableObjects );
if ( deletableObjects.size() == 1 )
{
Entity<?> first = editObjects.iterator().next();
addAction(menu, parent, p, afterId).setEdit(first);
}
else if (isMultiEditSupported(deletableObjects))
{
addAction(menu, parent, p, afterId).setEditSelection(editObjects);
}
}
}
List<Entity<?>> editableObjects = getEditableObjects(list);
if ( editableObjects.size() == 1 )
{
RaplaObject next = editableObjects.iterator().next();
if ( next.getRaplaType() == User.TYPE)
{
addUserMenuEdit( menu , parent, p, (User) next , afterId);
}
}
Iterator<ObjectMenuFactory> it = getContainer().lookupServicesFor( RaplaClientExtensionPoints.OBJECT_MENU_EXTENSION).iterator();
while (it.hasNext())
{
ObjectMenuFactory objectMenuFact = it.next();
RaplaObject obj = focusedObject instanceof RaplaObject ? (RaplaObject) focusedObject : null;
RaplaMenuItem[] items = objectMenuFact.create( context, obj);
for ( int i =0;i<items.length;i++)
{
RaplaMenuItem item = items[i];
menu.insertAfterId( item, afterId);
}
}
return menu;
}
private boolean isMultiEditSupported(List<Entity<?>> editableObjects) {
if ( editableObjects.size() > 0 )
{
RaplaType raplaType = editableObjects.iterator().next().getRaplaType();
if ( raplaType == Allocatable.TYPE || raplaType == User.TYPE || raplaType == Reservation.TYPE)
{
return true;
}
}
return false;
}
private void addAllocatableMenuNew(MenuInterface menu,Component parent,Point p,Object focusedObj) throws RaplaException {
RaplaObjectAction newResource = addAction(menu,parent,p).setNew( Allocatable.TYPE );
if (focusedObj != CalendarModelImpl.ALLOCATABLES_ROOT)
{
if (focusedObj instanceof DynamicType)
{
if (((DynamicType) focusedObj).getAnnotation(DynamicTypeAnnotations.KEY_CLASSIFICATION_TYPE).equals(DynamicTypeAnnotations.VALUE_CLASSIFICATION_TYPE_PERSON))
{
newResource.setPerson(true);
}
newResource.changeObject( (DynamicType)focusedObj );
}
if (focusedObj instanceof Allocatable)
{
if (((Allocatable) focusedObj).isPerson())
{
newResource.setPerson(true);
}
newResource.changeObject( (Allocatable)focusedObj );
}
DynamicType[] types = newResource.guessTypes();
if (types.length == 1) //user has clicked on a resource/person type
{
DynamicType type = types[0];
newResource.putValue(Action.NAME,type.getName( getLocale() ));
return;
}
}
else
{
//user has clicked on top "resources" folder :
//add an entry to create a new resource and another to create a new person
DynamicType[] resourceType= getQuery().getDynamicTypes(DynamicTypeAnnotations.VALUE_CLASSIFICATION_TYPE_RESOURCE );
if ( resourceType.length == 1)
{
newResource.putValue(Action.NAME,resourceType[0].getName( getLocale() ));
}
else
{
newResource.putValue(Action.NAME,getString("resource"));
}
RaplaObjectAction newPerson = addAction(menu,parent,p).setNew( Allocatable.TYPE );
newPerson.setPerson( true );
DynamicType[] personType= getQuery().getDynamicTypes(DynamicTypeAnnotations.VALUE_CLASSIFICATION_TYPE_PERSON );
if ( personType.length == 1)
{
newPerson.putValue(Action.NAME,personType[0].getName( getLocale()));
}
else
{
newPerson.putValue(Action.NAME,getString("person"));
}
}
}
private void addTypeMenuNew(MenuInterface menu,String classificationType,Component parent,Point p) {
DynamicTypeAction newReservationType = newDynamicTypeAction(parent,p);
menu.add(new JMenuItem(newReservationType));
newReservationType.setNewClassificationType(classificationType);
newReservationType.putValue(Action.NAME,getString(classificationType + "_type"));
}
private void addUserMenuEdit(MenuInterface menu,Component parent,Point p,User obj,String afterId) {
menu.insertAfterId( new RaplaSeparator("sep1"), afterId);
menu.insertAfterId( new RaplaSeparator("sep2"), afterId);
PasswordChangeAction passwordChangeAction = new PasswordChangeAction(getContext(),parent);
passwordChangeAction.changeObject( obj );
menu.insertAfterId( new JMenuItem( passwordChangeAction ), "sep2");
UserAction switchUserAction = newUserAction(parent,p);
switchUserAction.setSwitchToUser();
switchUserAction.changeObject( obj );
menu.insertAfterId( new JMenuItem( switchUserAction ), "sep2");
}
private void addUserMenuNew(MenuInterface menu,Component parent,Point p) {
UserAction newUserAction = newUserAction(parent,p);
newUserAction.setNew();
menu.add( new JMenuItem( newUserAction ));
}
private void addCategoryMenuNew(MenuInterface menu, Component parent, Point p, Object obj) {
RaplaObjectAction newAction = addAction(menu,parent,p).setNew( Category.TYPE );
if ( obj instanceof Category)
{
newAction.changeObject((Category)obj);
}
else if ( obj != null && obj.equals( getString("categories")))
{
newAction.changeObject(getQuery().getSuperCategory());
}
newAction.putValue(Action.NAME,getString("category"));
}
private void addPeriodMenuNew(MenuInterface menu, Component parent, Point p) {
Action newAction = addAction(menu,parent,p).setNew( Period.TYPE );
newAction.putValue(Action.NAME,getString("period"));
}
private RaplaObjectAction addAction(MenuInterface menu, Component parent,Point p) {
RaplaObjectAction action = newObjectAction(parent,p);
menu.add(new JMenuItem(action));
return action;
}
private RaplaObjectAction addAction(MenuInterface menu, Component parent,Point p,String id) {
RaplaObjectAction action = newObjectAction(parent,p);
menu.insertAfterId( new JMenuItem(action), id);
return action;
}
private RaplaObjectAction newObjectAction(Component parent,Point point) {
RaplaObjectAction action = new RaplaObjectAction(getContext(),parent, point);
return action;
}
private DynamicTypeAction newDynamicTypeAction(Component parent,Point point) {
DynamicTypeAction action = new DynamicTypeAction(getContext(),parent,point);
return action;
}
private UserAction newUserAction(Component parent,Point point) {
UserAction action = new UserAction(getContext(),parent,point);
return action;
}
// This will exclude DynamicTypes and non editable Objects from the list
private List<Entity<?>> getEditableObjects(Collection<?> list) {
Iterator<?> it = list.iterator();
ArrayList<Entity<?>> editableObjects = new ArrayList<Entity<?>>();
while (it.hasNext()) {
Object o = it.next();
if (canModify(o) )
editableObjects.add((Entity<?>)o);
}
return editableObjects;
}
private List<Entity<?>> getDeletableObjects(Collection<?> list) {
Iterator<?> it = list.iterator();
Category superCategory = getQuery().getSuperCategory();
ArrayList<Entity<?>> deletableObjects = new ArrayList<Entity<?>>();
while (it.hasNext()) {
Object o = it.next();
if (canModify(o) && !o.equals( superCategory) )
deletableObjects.add((Entity<?>)o);
}
return deletableObjects;
}
// method for filtering a selection(Parameter: list) of similar RaplaObjekte
// (from type raplaType)
// criteria: RaplaType: isPerson-Flag
private <T extends RaplaObject> List<T> getObjectsWithSameType(Collection<T> list,
RaplaType raplaType, boolean isPerson) {
ArrayList<T> objects = new ArrayList<T>();
for (RaplaObject o : list) {
// element will be added if it is from the stated RaplaType...
if (raplaType != null && (o.getRaplaType() == raplaType))
{
// ...furthermore the flag isPerson at allocatables has to
// be conform, because person and other resources aren't
// able to process at the same time
if (raplaType!=Allocatable.TYPE || ((Allocatable) o).isPerson() == isPerson)
{
@SuppressWarnings("unchecked")
T casted = (T)o;
objects.add(casted);
}
}
}
return objects;
}
private <T extends RaplaObject> Collection<T> getObjectsWithSameType(Collection<T> list)
{
Iterator<T> iterator = list.iterator();
if ( !iterator.hasNext())
{
return list;
}
RaplaObject obj = iterator.next();
RaplaType raplaType = obj.getRaplaType();
boolean isPerson = raplaType == Allocatable.TYPE && ((Allocatable) obj).isPerson();
return getObjectsWithSameType(list, raplaType, isPerson);
}
}
| 04900db4-clienttest | src/org/rapla/gui/internal/MenuFactoryImpl.java | Java | gpl3 | 20,372 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas, Bettina Lademann |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.view;
import java.awt.Component;
import java.awt.Font;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import javax.swing.BorderFactory;
import javax.swing.Icon;
import javax.swing.JTree;
import javax.swing.UIManager;
import javax.swing.border.Border;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.DefaultTreeSelectionModel;
import javax.swing.tree.MutableTreeNode;
import javax.swing.tree.TreeCellRenderer;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;
import org.rapla.components.util.Assert;
import org.rapla.components.util.InverseComparator;
import org.rapla.entities.Category;
import org.rapla.entities.MultiLanguageName;
import org.rapla.entities.Named;
import org.rapla.entities.NamedComparator;
import org.rapla.entities.RaplaType;
import org.rapla.entities.User;
import org.rapla.entities.domain.Allocatable;
import org.rapla.entities.domain.Period;
import org.rapla.entities.domain.Reservation;
import org.rapla.entities.domain.ReservationStartComparator;
import org.rapla.entities.dynamictype.Attribute;
import org.rapla.entities.dynamictype.Classifiable;
import org.rapla.entities.dynamictype.Classification;
import org.rapla.entities.dynamictype.ClassificationFilter;
import org.rapla.entities.dynamictype.DynamicType;
import org.rapla.entities.dynamictype.DynamicTypeAnnotations;
import org.rapla.entities.dynamictype.internal.DynamicTypeImpl;
import org.rapla.facade.Conflict;
import org.rapla.facade.internal.CalendarModelImpl;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.TreeFactory;
import org.rapla.gui.toolkit.TreeToolTipRenderer;
import org.rapla.storage.StorageOperator;
public class TreeFactoryImpl extends RaplaGUIComponent implements TreeFactory {
public TreeFactoryImpl(RaplaContext sm) {
super(sm);
}
class DynamicTypeComperator implements Comparator<DynamicType>
{
public int compare(DynamicType o1,DynamicType o2)
{
int rang1 = getRang(o1);
int rang2 = getRang(o2);
if ( rang1 < rang2)
{
return -1;
}
if ( rang1 > rang2)
{
return 1;
}
return compareIds((DynamicTypeImpl)o1, (DynamicTypeImpl)o2);
}
private int compareIds(DynamicTypeImpl o1, DynamicTypeImpl o2) {
return o1.compareTo( o2);
}
private int getRang(DynamicType o1) {
String t2 = o1.getAnnotation(DynamicTypeAnnotations.KEY_CLASSIFICATION_TYPE);
if ( t2 != null && t2.equals( DynamicTypeAnnotations.VALUE_CLASSIFICATION_TYPE_RESOURCE))
{
return 1;
}
if ( t2 != null && t2.equals( DynamicTypeAnnotations.VALUE_CLASSIFICATION_TYPE_PERSON))
{
return 2;
}
else
{
return 3;
}
}
}
public TreeModel createClassifiableModel(Reservation[] classifiables) {
@SuppressWarnings({ "unchecked", "rawtypes" })
Comparator<Classifiable> comp = new InverseComparator(new ReservationStartComparator(getLocale()));
return createClassifiableModel( classifiables, comp,false);
}
public TreeModel createClassifiableModel(Allocatable[] classifiables, boolean useCategorizations) {
@SuppressWarnings({ "rawtypes", "unchecked" })
Comparator<Classifiable> comp = new NamedComparator(getLocale());
return createClassifiableModel( classifiables, comp, useCategorizations);
}
public TreeModel createClassifiableModel(Allocatable[] classifiables) {
boolean useCategorizations = true;
return createClassifiableModel( classifiables, useCategorizations);
}
private TreeModel createClassifiableModel(Classifiable[] classifiables, Comparator<Classifiable> comp,boolean useCategorizations) {
Set<DynamicType> typeSet = new LinkedHashSet<DynamicType>();
for (Classifiable classifiable: classifiables)
{
DynamicType type = classifiable.getClassification().getType();
typeSet.add( type);
}
List<DynamicType> typeList = new ArrayList<DynamicType>(typeSet);
Collections.sort(typeList, new DynamicTypeComperator());
Map<DynamicType,DefaultMutableTreeNode> nodeMap = new HashMap<DynamicType,DefaultMutableTreeNode>();
for (DynamicType type: typeList) {
DefaultMutableTreeNode node = new NamedNode(type);
nodeMap.put(type, node);
}
DefaultMutableTreeNode root = new DefaultMutableTreeNode("ROOT");
Set<Classifiable> sortedClassifiable = new TreeSet<Classifiable>(comp);
sortedClassifiable.addAll(Arrays.asList(classifiables));
addClassifiables(nodeMap, sortedClassifiable, useCategorizations);
int count = 0;
for (DynamicType type: typeList) {
DefaultMutableTreeNode typeNode = nodeMap.get(type);
root.insert(typeNode, count++);
}
return new DefaultTreeModel(root);
}
private Map<Classifiable, Collection<NamedNode>> addClassifiables(Map<DynamicType, DefaultMutableTreeNode > nodeMap,Collection<? extends Classifiable> classifiables,boolean useCategorizations)
{
Map<DynamicType,Map<Object,DefaultMutableTreeNode>> categorization = new LinkedHashMap<DynamicType, Map<Object,DefaultMutableTreeNode>>();
Map<Classifiable, Collection<NamedNode>> childMap = new HashMap<Classifiable, Collection<NamedNode>>();
Map<DynamicType,Collection<NamedNode>> uncategorized = new LinkedHashMap<DynamicType, Collection<NamedNode>>();
for ( DynamicType type: nodeMap.keySet())
{
categorization.put( type, new LinkedHashMap<Object, DefaultMutableTreeNode>());
uncategorized.put( type, new ArrayList<NamedNode>());
}
for (Iterator<? extends Classifiable> it = classifiables.iterator(); it.hasNext();) {
Classifiable classifiable = it.next();
Classification classification = classifiable.getClassification();
Collection<NamedNode> childNodes = new ArrayList<NamedNode>();
childMap.put( classifiable, childNodes);
DynamicType type = classification.getType();
Assert.notNull(type);
DefaultMutableTreeNode typeNode = nodeMap.get(type);
DefaultMutableTreeNode parentNode = typeNode;
Attribute categorizationAtt = classification.getAttribute("categorization");
if (useCategorizations && categorizationAtt != null && classification.getValues(categorizationAtt).size() > 0)
{
Collection<Object> values = classification.getValues(categorizationAtt);
for ( Object value:values)
{
NamedNode childNode = new NamedNode((Named) classifiable);
childNodes.add( childNode);
Map<Object, DefaultMutableTreeNode> map = categorization.get(type);
parentNode = map.get( value);
if ( parentNode == null)
{
String name = getName( value);
parentNode = new DefaultMutableTreeNode(new Categorization(name));
map.put( value, parentNode);
}
parentNode.add(childNode);
}
}
else
{
NamedNode childNode = new NamedNode((Named) classifiable);
childNodes.add( childNode);
Assert.notNull(typeNode);
uncategorized.get(type).add( childNode);
}
}
for ( DynamicType type:categorization.keySet())
{
DefaultMutableTreeNode parentNode = nodeMap.get( type);
//Attribute categorizationAtt = type.getAttribute("categorization");
Map<Object, DefaultMutableTreeNode> map = categorization.get( type);
Collection<Object> sortedCats = getSortedCategorizations(map.keySet());
for ( Object cat: sortedCats)
{
DefaultMutableTreeNode childNode = map.get(cat);
parentNode.add(childNode);
}
}
for ( DynamicType type: uncategorized.keySet())
{
DefaultMutableTreeNode parentNode = nodeMap.get( type);
for (NamedNode node:uncategorized.get( type))
{
parentNode.add(node);
}
}
return childMap;
}
@SuppressWarnings({ "rawtypes", "unchecked" })
private Collection<Object> getSortedCategorizations(Collection<Object> unsortedCats) {
ArrayList<Comparable> sortableCats = new ArrayList<Comparable>();
ArrayList<Object> unsortableCats = new ArrayList<Object>();
// All attribute values should implement Comparable but for the doubts we test if value is not comparable
for ( Object cat: unsortedCats)
{
if ( cat instanceof Comparable)
{
sortableCats.add( (Comparable<?>) cat);
}
else
{
unsortableCats.add( cat);
}
}
Collections.sort( sortableCats);
List<Object> allCats = new ArrayList<Object>( sortableCats);
allCats.addAll( unsortableCats);
return allCats;
}
class Categorization implements Comparable<Categorization>
{
String cat;
public Categorization(String cat) {
this.cat = cat.intern();
}
public String toString()
{
return cat;
}
public boolean equals( Object obj)
{
return cat.equals( obj.toString());
}
public int hashCode() {
return cat.hashCode();
}
public int compareTo(Categorization o)
{
return cat.compareTo( o.cat);
}
}
public TreeCellRenderer createConflictRenderer() {
return new ConflictTreeCellRenderer();
}
private boolean isInFilter(ClassificationFilter[] filter, Classifiable classifiable) {
if (filter == null)
return true;
for (int i = 0; i < filter.length; i++) {
if (filter[i].matches(classifiable.getClassification())) {
return true;
}
}
return false;
}
private boolean isInFilter(ClassificationFilter[] filter, DynamicType type) {
if (filter == null)
return true;
for (int i = 0; i < filter.length; i++) {
if (filter[i].getType().equals(type)) {
return true;
}
}
return false;
}
private boolean hasRulesFor(ClassificationFilter[] filter, DynamicType type) {
if (filter == null)
return false;
for (int i = 0; i < filter.length; i++) {
if (filter[i].getType().equals(type) && filter[i].ruleSize() > 0) {
return true;
}
}
return false;
}
/**
* Returns the Resources root
*
* @param filter
* @param selectedUser
* @return
* @throws RaplaException
*/
public TypeNode createResourcesModel(ClassificationFilter[] filter) throws RaplaException {
TypeNode treeNode = new TypeNode(Allocatable.TYPE, CalendarModelImpl.ALLOCATABLES_ROOT, getString("resources"));
Map<DynamicType,DefaultMutableTreeNode> nodeMap = new HashMap<DynamicType, DefaultMutableTreeNode>();
boolean resourcesFiltered = false;
DynamicType[] types = getQuery().getDynamicTypes(DynamicTypeAnnotations.VALUE_CLASSIFICATION_TYPE_RESOURCE);
for (int i = 0; i < types.length; i++) {
DynamicType type = types[i];
if (hasRulesFor(filter, type)) {
resourcesFiltered = true;
}
if (!isInFilter(filter, type)) {
resourcesFiltered = true;
continue;
}
NamedNode node = new NamedNode(type);
treeNode.add(node);
nodeMap.put(type, node);
}
// creates typ folders
types = getQuery().getDynamicTypes(DynamicTypeAnnotations.VALUE_CLASSIFICATION_TYPE_PERSON);
for (int i = 0; i < types.length; i++) {
DynamicType type = types[i];
if (hasRulesFor(filter, type)) {
resourcesFiltered = true;
}
if (!isInFilter(filter, type)) {
resourcesFiltered = true;
continue;
}
NamedNode node = new NamedNode(type);
treeNode.add(node);
nodeMap.put(type, node);
}
treeNode.setFiltered(resourcesFiltered);
// adds elements to typ folders
Allocatable[] allocatables = getQuery().getAllocatables();
Collection<Allocatable> sorted = sorted(Arrays.asList(allocatables));
Collection<Allocatable> filtered = new ArrayList<Allocatable>();
for (Allocatable classifiable: sorted) {
if (!isInFilter(filter, classifiable)) {
continue;
}
filtered.add( classifiable);
}
addClassifiables(nodeMap, filtered, true);
for (Map.Entry<DynamicType, DefaultMutableTreeNode> entry: nodeMap.entrySet())
{
MutableTreeNode value = entry.getValue();
if (value.getChildCount() == 0 && (!isAdmin() && !isRegisterer()))
{
treeNode.remove( value);
}
}
return treeNode;
}
private <T extends Named> Collection<T> sorted(Collection<T> allocatables) {
TreeSet<T> sortedList = new TreeSet<T>(new NamedComparator<T>(getLocale()));
sortedList.addAll(allocatables);
return sortedList;
}
public TypeNode createReservationsModel() throws RaplaException {
TypeNode treeNode = new TypeNode(Reservation.TYPE, getString("reservation_type"));
// creates typ folders
DynamicType[] types = getQuery().getDynamicTypes(DynamicTypeAnnotations.VALUE_CLASSIFICATION_TYPE_RESERVATION);
for (int i = 0; i < types.length; i++) {
DynamicType type = types[i];
NamedNode node = new NamedNode(type);
treeNode.add(node);
}
treeNode.setFiltered(false);
return treeNode;
}
@SuppressWarnings("deprecation")
public DefaultTreeModel createModel(ClassificationFilter[] filter) throws RaplaException
{
DefaultMutableTreeNode root = new DefaultMutableTreeNode("ROOT");
// Resources and Persons
// Add the resource types
// Add the resources
// Add the person types
// Add the persons
TypeNode resourceRoot = createResourcesModel(filter);
root.add(resourceRoot);
if (isAdmin())
{
// If admin
// Eventtypes
// Add the event types
// Users
// Add the users
// Categories (the root category)
// Add the periods
DefaultMutableTreeNode userRoot = new TypeNode(User.TYPE, getString("users"));
User[] userList = getQuery().getUsers();
SortedSet<User> sorted = new TreeSet<User>( User.USER_COMPARATOR);
sorted.addAll( Arrays.asList( userList));
for (final User user: sorted) {
DefaultMutableTreeNode node = new DefaultMutableTreeNode();
node.setUserObject( user);
userRoot.add(node);
}
root.add(userRoot);
TypeNode reservationsRoot = createReservationsModel();
root.add(reservationsRoot);
NamedNode categoryRoot = createRootNode( Collections.singleton(getQuery().getSuperCategory()),true);
root.add(categoryRoot);
// set category root name
MultiLanguageName multiLanguageName = (MultiLanguageName)getQuery().getSuperCategory().getName();
// TODO try to replace hack
multiLanguageName.setNameWithoutReadCheck(getI18n().getLang(), getString("categories"));
// Add the periods
DefaultMutableTreeNode periodRoot = new TypeNode(Period.TYPE, getString("periods"));
DynamicType periodType = getQuery().getDynamicType(StorageOperator.PERIOD_TYPE);
Allocatable[] periodList = getQuery().getAllocatables(periodType.newClassificationFilter().toArray());
for (final Allocatable period: sorted(Arrays.asList(periodList))) {
NamedNode node = new NamedNode(period);
periodRoot.add(node);
}
root.add(periodRoot);
}
return new DefaultTreeModel(root);
}
public DefaultTreeModel createConflictModel(Collection<Conflict> conflicts ) throws RaplaException {
String conflict_number = conflicts != null ? new Integer(conflicts.size()).toString() : getString("nothing_selected") ;
String conflictText = getI18n().format("conflictUC", conflict_number);
DefaultMutableTreeNode treeNode = new TypeNode(Conflict.TYPE, conflictText);
if ( conflicts != null )
{
Map<DynamicType,DefaultMutableTreeNode> nodeMap = new LinkedHashMap<DynamicType, DefaultMutableTreeNode>();
DynamicType[] types = getQuery().getDynamicTypes(DynamicTypeAnnotations.VALUE_CLASSIFICATION_TYPE_RESOURCE);
for (int i = 0; i < types.length; i++) {
DynamicType type = types[i];
NamedNode node = new NamedNode(type);
treeNode.add(node);
nodeMap.put(type, node);
}
// creates typ folders
types = getQuery().getDynamicTypes(DynamicTypeAnnotations.VALUE_CLASSIFICATION_TYPE_PERSON);
for (int i = 0; i < types.length; i++) {
DynamicType type = types[i];
NamedNode node = new NamedNode(type);
treeNode.add(node);
nodeMap.put(type, node);
}
Collection<Allocatable> allocatables = new LinkedHashSet<Allocatable>();
for (Iterator<Conflict> it = conflicts.iterator(); it.hasNext();) {
Conflict conflict = it.next();
Allocatable allocatable = conflict.getAllocatable();
allocatables.add( allocatable );
}
Collection<Allocatable> sorted = sorted(allocatables);
Map<Classifiable, Collection<NamedNode>> childMap = addClassifiables(nodeMap, sorted, true);
for (Iterator<Conflict> it = conflicts.iterator(); it.hasNext();) {
Conflict conflict = it.next();
Allocatable allocatable = conflict.getAllocatable();
for(NamedNode allocatableNode : childMap.get( allocatable))
{
allocatableNode.add(new NamedNode( conflict));
}
}
for (Map.Entry<DynamicType, DefaultMutableTreeNode> entry: nodeMap.entrySet())
{
MutableTreeNode value = entry.getValue();
if (value.getChildCount() == 0 )
{
treeNode.remove( value);
}
}
}
return new DefaultTreeModel(treeNode);
}
class TypeNode extends DefaultMutableTreeNode {
private static final long serialVersionUID = 1L;
boolean filtered;
RaplaType type;
String title;
TypeNode(RaplaType type, Object userObject, String title) {
this.type = type;
this.title = title;
setUserObject(userObject);
}
TypeNode(RaplaType type, Object userObject) {
this(type, userObject, null);
}
public RaplaType getType() {
return type;
}
public boolean isFiltered() {
return filtered;
}
public void setFiltered(boolean filtered) {
this.filtered = filtered;
}
public Object getTitle() {
if (title != null) {
return title;
} else {
return userObject.toString();
}
}
}
public DefaultMutableTreeNode newNamedNode(Named element) {
return new NamedNode(element);
}
public TreeModel createModel(Category category) {
return createModel(Collections.singleton(category), true );
}
public TreeModel createModel(Collection<Category> categories, boolean includeChildren)
{
DefaultMutableTreeNode rootNode = createRootNode(categories,includeChildren);
return new DefaultTreeModel( rootNode);
}
protected NamedNode createRootNode(
Collection<Category> categories, boolean includeChildren) {
Map<Category,NamedNode> nodeMap = new HashMap<Category, NamedNode>();
Category superCategory = null;
{
Category persistantSuperCategory = getQuery().getSuperCategory();
for ( Category cat:categories)
{
if ( persistantSuperCategory.equals( cat))
{
superCategory = cat;
}
}
if (superCategory == null)
{
superCategory = persistantSuperCategory;
}
}
nodeMap.put( superCategory, new NamedNode(superCategory));
LinkedHashSet<Category> uniqueCategegories = new LinkedHashSet<Category>( );
for ( Category cat:categories)
{
if ( includeChildren)
{
for( Category child:getAllChildren( cat))
{
uniqueCategegories.add( child);
}
}
uniqueCategegories.add( cat);
}
LinkedList<Category> list = new LinkedList<Category>();
list.addAll( uniqueCategegories);
while ( !list.isEmpty())
{
Category cat = list.pop();
NamedNode node = nodeMap.get( cat);
if (node == null)
{
node = new NamedNode( cat);
nodeMap.put( cat , node);
}
Category parent = cat.getParent();
if ( parent != null)
{
NamedNode parentNode = nodeMap.get( parent);
if ( parentNode == null)
{
parentNode = new NamedNode( parent);
nodeMap.put( parent , parentNode);
list.push( parent);
}
parentNode.add( node);
}
}
NamedNode rootNode = nodeMap.get( superCategory);
while ( true)
{
int childCount = rootNode.getChildCount();
if ( childCount <= 0 || childCount >1)
{
break;
}
Category cat = (Category) rootNode.getUserObject();
if ( categories.contains( cat))
{
break;
}
NamedNode firstChild = (NamedNode)rootNode.getFirstChild();
rootNode.remove( firstChild);
rootNode = firstChild;
}
return rootNode;
}
private Collection<Category> getAllChildren(Category cat) {
ArrayList<Category> result = new ArrayList<Category>();
for ( Category child: cat.getCategories())
{
result.add( child);
Collection<Category> childsOfChild = getAllChildren( child);
result.addAll(childsOfChild);
}
return result;
}
public TreeModel createModelFlat(Named[] element) {
DefaultMutableTreeNode root = new DefaultMutableTreeNode("");
for (int i = 0; i < element.length; i++) {
root.add(new NamedNode(element[i]));
}
return new DefaultTreeModel(root);
}
public TreeToolTipRenderer createTreeToolTipRenderer() {
return new RaplaTreeToolTipRenderer();
}
public TreeCellRenderer createRenderer() {
return new ComplexTreeCellRenderer();
}
public class NamedNode extends DefaultMutableTreeNode {
private static final long serialVersionUID = 1L;
NamedNode(Named obj) {
super(obj);
}
public String toString() {
Named obj = (Named) getUserObject();
if (obj != null) {
Locale locale = getI18n().getLocale();
if ( obj instanceof Classifiable)
{
Classification classification = ((Classifiable)obj).getClassification();
if ( classification.getType().getAnnotation(DynamicTypeAnnotations.KEY_NAME_FORMAT_PLANNING) != null)
{
return classification.getNamePlaning(locale);
}
}
String name = obj.getName(locale);
return name;
} else {
return super.toString();
}
}
public int getIndexOfUserObject(Object object) {
if (children == null)
{
return -1;
}
for (int i=0;i<children.size();i++) {
if (((DefaultMutableTreeNode)children.get(i)).getUserObject().equals(object))
return i;
}
return -1;
}
public TreeNode findNodeFor( Object obj ) {
return findNodeFor( this, obj);
}
private TreeNode findNodeFor( DefaultMutableTreeNode node,Object obj ) {
Object userObject = node.getUserObject();
if ( userObject != null && userObject.equals( obj ) )
return node;
@SuppressWarnings("rawtypes")
Enumeration e = node.children();
while (e.hasMoreElements())
{
TreeNode result = findNodeFor((DefaultMutableTreeNode) e.nextElement(), obj );
if ( result != null ) {
return result;
}
}
return null;
}
}
Icon bigFolderUsers = getIcon("icon.big_folder_users");
Icon bigFolderPeriods = getIcon("icon.big_folder_periods");
Icon bigFolderResourcesFiltered = getIcon("icon.big_folder_resources_filtered");
Icon bigFolderResourcesUnfiltered = getIcon("icon.big_folder_resources");
Icon bigFolderEvents = getIcon("icon.big_folder_events");
Icon bigFolderCategories = getIcon("icon.big_folder_categories");
Icon bigFolderConflicts = getIcon("icon.big_folder_conflicts");
Icon defaultIcon = getIcon("icon.tree.default");
Icon personIcon = getIcon("icon.tree.persons");
Icon folderClosedIcon =getIcon("icon.folder");
Icon folderOpenIcon = getIcon("icon.folder");
Icon forbiddenIcon = getIcon("icon.no_perm");
Font normalFont = UIManager.getFont("Tree.font");
Font bigFont = normalFont.deriveFont(Font.BOLD, (float) (normalFont.getSize() * 1.2));
class ComplexTreeCellRenderer extends DefaultTreeCellRenderer {
private static final long serialVersionUID = 1L;
Border nonIconBorder = BorderFactory.createEmptyBorder(1, 0, 1, 0);
Border conflictBorder = BorderFactory.createEmptyBorder(2, 0, 2, 0);
Date today;
public ComplexTreeCellRenderer() {
setLeafIcon(defaultIcon);
today = getQuery().today();
}
public void setLeaf(Object object) {
Icon icon = null;
if (object instanceof Allocatable) {
Allocatable allocatable = (Allocatable) object;
try {
User user = getUser();
if ( !allocatable.canAllocate(user, today))
{
icon = forbiddenIcon;
}
else
{
if (allocatable.isPerson()) {
icon = personIcon;
} else {
icon = defaultIcon;
}
}
} catch (RaplaException ex) {
}
} else if (object instanceof DynamicType) {
DynamicType type = (DynamicType) object;
String classificationType = type.getAnnotation(DynamicTypeAnnotations.KEY_CLASSIFICATION_TYPE);
if (DynamicTypeAnnotations.VALUE_CLASSIFICATION_TYPE_RESERVATION.equals(classificationType)) {
setBorder(conflictBorder);
} else {
icon = folderClosedIcon;
}
}
if (icon == null) {
setBorder(nonIconBorder);
}
setLeafIcon(icon);
}
public Component getTreeCellRendererComponent(JTree tree, Object value, boolean sel, boolean expanded, boolean leaf, int row, boolean hasFocus) {
setBorder(null);
setFont(normalFont);
if (value != null && value instanceof TypeNode) {
TypeNode typeNode = (TypeNode) value;
Icon bigFolderIcon;
if (typeNode.getType().equals(User.TYPE)) {
bigFolderIcon = bigFolderUsers;
} else if (typeNode.getType().equals(Period.TYPE)) {
bigFolderIcon = bigFolderPeriods;
} else if (typeNode.getType().equals(Reservation.TYPE)) {
bigFolderIcon = bigFolderEvents;
} else {
if (typeNode.isFiltered()) {
bigFolderIcon = bigFolderResourcesFiltered;
} else {
bigFolderIcon = bigFolderResourcesUnfiltered;
}
}
setClosedIcon(bigFolderIcon);
setOpenIcon(bigFolderIcon);
setLeafIcon(bigFolderIcon);
setFont(bigFont);
value = typeNode.getTitle();
} else {
Object nodeInfo = getUserObject(value);
if (nodeInfo instanceof Category && ((Category)nodeInfo).getParent() == null) {
setClosedIcon(bigFolderCategories);
setOpenIcon(bigFolderCategories);
setFont(bigFont);
}
else
{
setClosedIcon(folderClosedIcon);
setOpenIcon(folderOpenIcon);
if (leaf) {
setLeaf(nodeInfo);
}
}
}
Component result = super.getTreeCellRendererComponent(tree, value, sel, expanded, leaf, row, hasFocus);
return result;
}
}
class ConflictTreeCellRenderer extends DefaultTreeCellRenderer {
private static final long serialVersionUID = 1L;
Border nonIconBorder = BorderFactory.createEmptyBorder(1, 0, 1, 0);
Border conflictBorder = BorderFactory.createEmptyBorder(2, 0, 2, 0);
public ConflictTreeCellRenderer() {
setFont(normalFont);
setLeafIcon(null);
setBorder(conflictBorder);
}
protected String getText( Conflict conflict) {
StringBuffer buf = new StringBuffer();
buf.append("<html>");
buf.append( getRaplaLocale().formatTimestamp(conflict.getStartDate()));
// buf.append( getAppointmentFormater().getSummary(conflict.getAppointment1()));
buf.append( "<br>" );
buf.append( conflict.getReservation1Name() );
buf.append( " " );
buf.append( getString("with"));
buf.append( "\n" );
buf.append( "<br>" );
buf.append( conflict.getReservation2Name() );
// TOD add the rest of conflict
// buf.append( ": " );
// buf.append( " " );
// buf.append( getRaplaLocale().formatTime(conflict.getAppointment1().getStart()));
//// buf.append( " - ");
//// buf.append( getRaplaLocale().formatTime(conflict.getAppointment1().getEnd()));
// buf.append( "<br>" );
// buf.append( getString("reservation.owner") + " ");
// buf.append( conflict.getUser2().getUsername());
buf.append("</html>");
String result = buf.toString();
return result;
}
public Component getTreeCellRendererComponent(JTree tree, Object value, boolean sel, boolean expanded, boolean leaf, int row, boolean hasFocus) {
if (value != null && value instanceof TypeNode) {
TypeNode typeNode = (TypeNode) value;
setFont(bigFont);
value = typeNode.getTitle();
setClosedIcon(bigFolderConflicts);
setOpenIcon(bigFolderConflicts);
} else {
setClosedIcon(folderClosedIcon);
setOpenIcon(folderOpenIcon);
Object nodeInfo = getUserObject(value);
setFont(normalFont);
if (nodeInfo instanceof Conflict) {
Conflict conflict = (Conflict) nodeInfo;
String text = getText(conflict);
value = text;
}
else if (nodeInfo instanceof Allocatable) {
Allocatable allocatable = (Allocatable) nodeInfo;
Icon icon;
if (allocatable.isPerson()) {
icon = personIcon;
} else {
icon = defaultIcon;
}
setClosedIcon(icon);
setOpenIcon(icon);
String text = allocatable.getName(getLocale()) ;
if ( value instanceof TreeNode)
{
text+= " (" + getRecursiveChildCount(((TreeNode) value)) +")";
}
value = text;
}
else
{
String text = TreeFactoryImpl.this.getName( nodeInfo);
if ( value instanceof TreeNode)
{
//text+= " (" + getRecursiveChildCount(((TreeNode) value)) +")";
text+= " (" + getRecursiveList(((TreeNode) value)).size() +")";
}
value = text;
}
}
Component result = super.getTreeCellRendererComponent(tree, value, sel, expanded, leaf, row, hasFocus);
return result;
}
private int getRecursiveChildCount(TreeNode treeNode)
{
int count = 0;
int children= treeNode.getChildCount();
if ( children == 0)
{
return 1;
}
for ( int i=0;i<children;i++)
{
TreeNode child = treeNode.getChildAt(i);
count+= getRecursiveChildCount( child);
}
return count;
}
private Set<Conflict> getRecursiveList(TreeNode treeNode)
{
int children= treeNode.getChildCount();
if ( children == 0)
{
return Collections.emptySet();
}
HashSet<Conflict> set = new HashSet<Conflict>();
for ( int i=0;i<children;i++)
{
TreeNode child = treeNode.getChildAt(i);
Object userObject = ((DefaultMutableTreeNode)child).getUserObject();
if ( userObject != null && userObject instanceof Conflict)
{
set.add((Conflict)userObject);
}
else
{
set.addAll(getRecursiveList( child));
}
}
return set;
}
}
public TreeSelectionModel createComplexTreeSelectionModel()
{
return new DelegatingTreeSelectionModel()
{
private static final long serialVersionUID = 1L;
boolean isSelectable(TreePath treePath)
{
Object lastPathComponent = treePath.getLastPathComponent();
Object object = getUserObject( lastPathComponent);
if ( object instanceof Categorization)
{
return false;
}
return true;
}
};
}
public TreeSelectionModel createConflictTreeSelectionModel()
{
return new DelegatingTreeSelectionModel()
{
private static final long serialVersionUID = 1L;
boolean isSelectable(TreePath treePath)
{
Object lastPathComponent = treePath.getLastPathComponent();
Object object = getUserObject( lastPathComponent);
if ( object instanceof Conflict)
{
return true;
}
if ( object instanceof Allocatable)
{
return true;
}
if ( object instanceof DynamicType)
{
return true;
}
return false;
}
};
}
private abstract class DelegatingTreeSelectionModel extends DefaultTreeSelectionModel {
abstract boolean isSelectable(TreePath treePath);
private static final long serialVersionUID = 1L;
private TreePath[] getSelectablePaths(TreePath[] pathList) {
List<TreePath> result = new ArrayList<TreePath>(pathList.length);
for (TreePath treePath : pathList) {
if (isSelectable(treePath)) {
result.add(treePath);
}
}
return result.toArray(new TreePath[result.size()]);
}
@Override
public void setSelectionPath(TreePath path) {
if (isSelectable(path)) {
super.setSelectionPath(path);
}
}
@Override
public void setSelectionPaths(TreePath[] paths) {
paths = getSelectablePaths(paths);
super.setSelectionPaths(paths);
}
@Override
public void addSelectionPath(TreePath path) {
if (isSelectable(path)) {
super.addSelectionPath(path);
}
}
@Override
public void addSelectionPaths(TreePath[] paths) {
paths = getSelectablePaths(paths);
super.addSelectionPaths(paths);
}
}
private static Object getUserObject(Object node) {
if (node instanceof DefaultMutableTreeNode)
return ((DefaultMutableTreeNode) node).getUserObject();
return node;
}
class RaplaTreeToolTipRenderer implements TreeToolTipRenderer {
public String getToolTipText(JTree tree, int row) {
Object node = tree.getPathForRow(row).getLastPathComponent();
Object value = getUserObject(node);
if (value instanceof Conflict) {
return null;
}
return getInfoFactory().getToolTip(value);
}
}
}
| 04900db4-clienttest | src/org/rapla/gui/internal/view/TreeFactoryImpl.java | Java | gpl3 | 39,739 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.view;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import org.rapla.entities.User;
import org.rapla.entities.domain.Allocatable;
import org.rapla.entities.domain.Appointment;
import org.rapla.entities.domain.Period;
import org.rapla.entities.domain.Repeating;
import org.rapla.entities.domain.Reservation;
import org.rapla.framework.RaplaContext;
public class ReservationInfoUI extends ClassificationInfoUI<Reservation> {
public ReservationInfoUI(RaplaContext sm) {
super(sm);
}
private void addRestriction(Reservation reservation, Allocatable allocatable, StringBuffer buf) {
Appointment[] appointments = reservation.getRestriction(allocatable);
if ( appointments.length == 0 )
return;
buf.append("<small>");
buf.append(" (");
for (int i=0; i<appointments.length ; i++) {
if (i >0)
buf.append(", ");
encode(getAppointmentFormater().getShortSummary(appointments[i]), buf );
}
buf.append(")");
buf.append("</small>");
}
private String allocatableList(Reservation reservation,Allocatable[] allocatables, User user, LinkController controller) {
StringBuffer buf = new StringBuffer();
for (int i = 0;i<allocatables.length;i++) {
Allocatable allocatable = allocatables[i];
if ( user != null && !allocatable.canReadOnlyInformation(user))
continue;
if (controller != null)
controller.createLink(allocatable,getName(allocatable),buf);
else
encode(getName(allocatable), buf);
addRestriction(reservation, allocatable, buf);
if (i<allocatables.length-1) {
buf.append (",");
}
}
return buf.toString();
}
@Override
protected String getTooltip(Reservation reservation) {
StringBuffer buf = new StringBuffer();
insertModificationRow( reservation, buf );
insertClassificationTitle( reservation, buf );
createTable( getAttributes( reservation, null, null, true),buf,false);
return buf.toString();
}
@Override
protected String createHTMLAndFillLinks(Reservation reservation,LinkController controller) {
StringBuffer buf = new StringBuffer();
insertModificationRow( reservation, buf );
insertClassificationTitle( reservation, buf );
createTable( getAttributes( reservation, controller, null, false),buf,false);
this.insertAllAppointments( reservation, buf );
return buf.toString();
}
public List<Row> getAttributes(Reservation reservation,LinkController controller, User user, boolean excludeAdditionalInfos) {
ArrayList<Row> att = new ArrayList<Row>();
att.addAll( getClassificationAttributes( reservation, excludeAdditionalInfos ));
User owner = reservation.getOwner();
final Locale locale = getLocale();
if ( owner != null)
{
final String ownerName = owner.getName(locale);
String ownerText = encode(ownerName);
if (controller != null)
ownerText = controller.createLink(owner,ownerName);
att.add( new Row(getString("reservation.owner"), ownerText));
}
User lastChangeBy = reservation.getLastChangedBy();
if ( lastChangeBy != null && (owner == null ||! lastChangeBy.equals(owner))) {
final String lastChangedName = lastChangeBy.getName(locale);
String lastChangeByText = encode(lastChangedName);
if (controller != null)
lastChangeByText = controller.createLink(lastChangeBy,lastChangedName);
att.add( new Row(getString("last_changed_by"), lastChangeByText));
}
Allocatable[] resources = reservation.getResources();
String resourceList = allocatableList(reservation, resources, user, controller);
if (resourceList.length() > 0) {
att.add (new Row( getString("resources"), resourceList ));
}
Allocatable[] persons = reservation.getPersons();
String personList = allocatableList(reservation, persons, user, controller);
if (personList.length() > 0) {
att.add (new Row( getString("persons"), personList ) );
}
return att;
}
void insertAllAppointments(Reservation reservation, StringBuffer buf) {
buf.append( "<table cellpadding=\"2\">");
buf.append( "<tr>\n" );
buf.append( "<td colspan=\"2\" class=\"label\">");
String appointmentLabel = getString("appointments");
encode(appointmentLabel, buf);
buf.append( ":");
buf.append( "</td>\n" );
buf.append( "</tr>\n");
Appointment[] appointments = reservation.getAppointments();
for (int i = 0;i<appointments.length;i++) {
buf.append( "<tr>\n" );
buf.append( "<td valign=\"top\">\n");
if (appointments[i].getRepeating() != null) {
buf.append ("<img width=\"16\" height=\"16\" src=\"org/rapla/gui/images/repeating.png\">");
} else {
buf.append ("<img width=\"16\" height=\"16\" src=\"org/rapla/gui/images/single.png\">");
}
buf.append( "</td>\n");
buf.append( "<td>\n");
String appointmentSummary =
getAppointmentFormater().getSummary( appointments[i] );
encode( appointmentSummary, buf );
Repeating repeating = appointments[i].getRepeating();
if ( repeating != null ) {
buf.append("<br>");
buf.append("<small>");
List<Period> periods = getPeriodModel().getPeriodsFor(appointments[i].getStart());
String repeatingSummary =
getAppointmentFormater().getSummary(repeating,periods);
encode( repeatingSummary, buf ) ;
if ( repeating.hasExceptions() ) {
buf.append("<br>");
buf.append( getAppointmentFormater().getExceptionSummary(repeating) );
}
buf.append("</small>");
}
buf.append( "</td>\n");
buf.append( "<td></td>");
buf.append( "</tr>\n");
}
buf.append( "</table>\n");
}
}
| 04900db4-clienttest | src/org/rapla/gui/internal/view/ReservationInfoUI.java | Java | gpl3 | 7,402 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.view;
import java.awt.Component;
import java.awt.Dimension;
import javax.swing.JComponent;
import javax.swing.JScrollPane;
import javax.swing.event.HyperlinkEvent;
import javax.swing.event.HyperlinkListener;
import org.rapla.components.xmlbundle.LocaleChangeEvent;
import org.rapla.components.xmlbundle.LocaleChangeListener;
import org.rapla.components.xmlbundle.LocaleSelector;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.toolkit.DialogUI;
import org.rapla.gui.toolkit.HTMLView;
import org.rapla.gui.toolkit.RaplaWidget;
final public class LicenseInfoUI
extends
RaplaGUIComponent
implements
HyperlinkListener
,RaplaWidget
,LocaleChangeListener
{
JScrollPane scrollPane;
HTMLView license;
LocaleSelector localeSelector;
public LicenseInfoUI(RaplaContext context) throws RaplaException {
super( context);
license = new HTMLView();
license.addHyperlinkListener(this);
scrollPane= new JScrollPane(license);
scrollPane.setOpaque(true);
scrollPane.setPreferredSize(new Dimension(450, 100));
scrollPane.setBorder(null);
localeSelector = context.lookup( LocaleSelector.class);
localeSelector.addLocaleChangeListener(this);
setLocale();
}
public void localeChanged(LocaleChangeEvent evt) {
setLocale();
scrollPane.invalidate();
scrollPane.repaint();
}
private void setLocale() {
license.setBody(getString("license.text"));
}
public void hyperlinkUpdate(HyperlinkEvent e) {
if (e.getEventType() == HyperlinkEvent.EventType.ACTIVATED) {
String link = e.getDescription();
viewLicense(getComponent(), false, link);
}
}
public JComponent getComponent() {
return scrollPane;
}
public void viewLicense(Component owner,boolean modal,String link) {
try {
LicenseUI license = new LicenseUI( getContext());
DialogUI dialog = DialogUI.create(getContext(),owner,modal,license.getComponent(), new String[] {getString("ok")} );
dialog.setTitle(getString("licensedialog.title"));
dialog.setSize(600,400);
if (link.equals("warranty")) {
dialog.start();
license.getComponent().revalidate();
license.showBottom();
} else {
dialog.start();
license.getComponent().revalidate();
license.showTop();
}
} catch (Exception ex) {
showException(ex,owner);
}
}
}
| 04900db4-clienttest | src/org/rapla/gui/internal/view/LicenseInfoUI.java | Java | gpl3 | 3,692 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.view;
import java.util.ArrayList;
import java.util.Collection;
import org.rapla.components.util.DateTools;
import org.rapla.entities.domain.Period;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaLocale;
class PeriodInfoUI extends HTMLInfo<Period> {
public PeriodInfoUI(RaplaContext sm) {
super(sm);
}
protected String createHTMLAndFillLinks(Period period,LinkController controller) {
Collection<Row> att = new ArrayList<Row>();
RaplaLocale loc = getRaplaLocale();
att.add(new Row(getString("name"), strong( encode( getName( period ) ))));
att.add(new Row(
getString("start_date")
,loc.getWeekday( period.getStart() )
+ ' '
+ loc.formatDate(period.getStart())
)
);
att.add(new Row(
getString("end_date"),
loc.getWeekday( DateTools.subDay(period.getEnd()) )
+ ' '
+ loc.formatDate( DateTools.subDay(period.getEnd()) )
)
);
return createTable(att, false);
}
protected String getTooltip(Period object) {
return createHTMLAndFillLinks( object, null);
}
}
| 04900db4-clienttest | src/org/rapla/gui/internal/view/PeriodInfoUI.java | Java | gpl3 | 2,316 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.view;
import org.rapla.entities.Category;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
class CategoryInfoUI extends HTMLInfo<Category> {
public CategoryInfoUI(RaplaContext sm){
super(sm);
}
protected String createHTMLAndFillLinks(Category category,LinkController controller) throws RaplaException{
return category.getName( getRaplaLocale().getLocale());
}
} | 04900db4-clienttest | src/org/rapla/gui/internal/view/CategoryInfoUI.java | Java | gpl3 | 1,399 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.view;
import org.rapla.entities.domain.Appointment;
import org.rapla.entities.domain.Reservation;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
public class AppointmentInfoUI extends HTMLInfo<Appointment> {
ReservationInfoUI parent;
public AppointmentInfoUI(RaplaContext sm) {
super(sm);
parent = new ReservationInfoUI( sm);
}
public String getTooltip(Appointment appointment) {
Reservation reservation = appointment.getReservation();
StringBuffer buf = new StringBuffer();
parent.insertModificationRow( reservation, buf );
insertAppointmentSummary( appointment, buf );
parent.insertClassificationTitle( reservation, buf );
createTable( parent.getAttributes( reservation, null, null, true),buf,false);
return buf.toString();
}
void insertAppointmentSummary(Appointment appointment, StringBuffer buf) {
buf.append("<div>");
buf.append( getAppointmentFormater().getSummary( appointment ) );
buf.append("</div>");
}
protected String createHTMLAndFillLinks(Appointment appointment,
LinkController controller) throws RaplaException {
Reservation reservation = appointment.getReservation();
return parent.createHTMLAndFillLinks(reservation, controller);
}
}
| 04900db4-clienttest | src/org/rapla/gui/internal/view/AppointmentInfoUI.java | Java | gpl3 | 2,304 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.view;
import java.awt.Dimension;
import java.awt.Point;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import javax.swing.BorderFactory;
import javax.swing.JComponent;
import javax.swing.JScrollPane;
import javax.swing.JViewport;
import javax.swing.SwingUtilities;
import javax.swing.event.HyperlinkEvent;
import javax.swing.event.HyperlinkListener;
import org.rapla.components.util.Assert;
import org.rapla.entities.RaplaObject;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.toolkit.HTMLView;
import org.rapla.gui.toolkit.RaplaWidget;
/**Information of the entity-classes displayed in an HTML-Component */
public class ViewTable<T> extends RaplaGUIComponent
implements
HyperlinkListener
,RaplaWidget
,LinkController
{
String title;
HTMLView htmlView = new HTMLView();
JScrollPane pane = new JScrollPane(htmlView, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_NEVER) {
private static final long serialVersionUID = 1L;
public Dimension getPreferredSize() {
Dimension pref = super.getPreferredSize();
Dimension max = getMaximumSize();
//System.out.println( "PREF: " + pref + " MAX: " + max);
if ( pref.height > max.height )
return max;
else
return pref;
}
};
Map<Integer,Object> linkMap;
int linkId = 0;
boolean packText = true;
public ViewTable(RaplaContext sm) {
super( sm);
linkMap = new HashMap<Integer,Object>(7);
htmlView.addHyperlinkListener(this);
htmlView.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
pane.setMaximumSize( new Dimension( 600, 500 ));
}
/** HTML-text-component should be sized according to the displayed text. Default is true. */
public void setPackText(boolean packText) {
this.packText = packText;
}
public JComponent getComponent() {
return pane;
}
public String getDialogTitle() {
return title;
}
public void updateInfo(T object) throws RaplaException
{
if ( object instanceof RaplaObject)
{
final InfoFactoryImpl infoFactory = (InfoFactoryImpl)getInfoFactory();
@SuppressWarnings("unchecked")
HTMLInfo<RaplaObject<T>> createView = infoFactory.createView((RaplaObject<T>)object);
@SuppressWarnings("unchecked")
final HTMLInfo<T> view = (HTMLInfo<T>) createView;
updateInfo(object,view);
}
else
{
updateInfoHtml( object.toString());
}
}
public void updateInfo(T object, HTMLInfo<T> info) throws RaplaException {
linkMap.clear();
final String html = info.createHTMLAndFillLinks( object, this);
setTitle (info.getTitle( object));
updateInfoHtml(html);
}
public void updateInfoHtml( String html) {
if (html !=null ) {
setText( html);
} else {
setText(getString("nothing_selected"));
htmlView.revalidate();
htmlView.repaint();
}
final JViewport viewport = pane.getViewport();
SwingUtilities.invokeLater( new Runnable() {
@Override
public void run() {
viewport.setViewPosition(new Point(0,0));
}
});
}
public void setTitle(String text) {
this.title = text;
}
public void setText(String text) {
String message = HTMLView.createHTMLPage(text);
htmlView.setText(message, packText);
}
public void createLink(Object object,String link,StringBuffer buf) {
linkMap.put(new Integer(linkId),object);
buf.append("<A href=\"");
buf.append(linkId++);
buf.append("\">");
HTMLInfo.encode(link,buf);
buf.append("</A>");
}
public String createLink(Object object,String link) {
StringBuffer buf = new StringBuffer();
createLink(object,link,buf);
return buf.toString();
}
public void hyperlinkUpdate(HyperlinkEvent e) {
if (e.getEventType() == HyperlinkEvent.EventType.ACTIVATED) {
if ( true)
{
}
String link = e.getDescription();
try
{
Integer index= Integer.parseInt(link);
getLogger().debug("Hyperlink pressed: " + link);
Object object = linkMap.get(index);
Assert.notNull(object,"link was not found in linkMap");
Assert.notNull(getInfoFactory());
try {
getInfoFactory().showInfoDialog(object,htmlView);
} catch (RaplaException ex) {
showException(ex,getComponent());
} // end of try-catch
}
catch ( NumberFormatException ex)
{
try
{
getIOService().openUrl(new URL(link));
}
catch (Exception e1)
{
showException(ex,getComponent());
}
}
}
}
}
| 04900db4-clienttest | src/org/rapla/gui/internal/view/ViewTable.java | Java | gpl3 | 6,162 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.view;
import org.rapla.framework.RaplaContext;
class DeleteInfoUI extends HTMLInfo<Object[]> {
public DeleteInfoUI(RaplaContext sm) {
super(sm);
}
protected String createHTMLAndFillLinks(Object[] deletables,LinkController controller) {
StringBuffer buf = new StringBuffer();
buf.append(getString("delete.question"));
buf.append("<br>");
for (int i = 0; i<deletables.length; i++) {
buf.append((i + 1));
buf.append(") ");
final Object deletable = deletables[i];
controller.createLink( deletable, getName( deletable ), buf);
buf.append("<br>");
}
return buf.toString();
}
@Override
protected String getTitle(Object[] deletables){
return getString("delete.title");
}
}
| 04900db4-clienttest | src/org/rapla/gui/internal/view/DeleteInfoUI.java | Java | gpl3 | 1,813 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.view;
import java.awt.Component;
import java.awt.Point;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.StringSelection;
import java.awt.event.ActionEvent;
import java.util.HashMap;
import java.util.Map;
import javax.swing.AbstractAction;
import javax.swing.JComponent;
import org.rapla.components.iolayer.ComponentPrinter;
import org.rapla.components.iolayer.IOInterface;
import org.rapla.entities.Category;
import org.rapla.entities.Named;
import org.rapla.entities.RaplaObject;
import org.rapla.entities.RaplaType;
import org.rapla.entities.User;
import org.rapla.entities.domain.Allocatable;
import org.rapla.entities.domain.Appointment;
import org.rapla.entities.domain.Period;
import org.rapla.entities.domain.Reservation;
import org.rapla.entities.dynamictype.DynamicType;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.InfoFactory;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.toolkit.DialogUI;
import org.rapla.gui.toolkit.HTMLView;
/** The factory can creatres an information-panel or dialog for
the entities of rapla.
@see ViewTable*/
public class InfoFactoryImpl extends RaplaGUIComponent implements InfoFactory
{
Map<RaplaType,HTMLInfo> views = new HashMap<RaplaType,HTMLInfo>();
public InfoFactoryImpl(RaplaContext sm) {
super( sm);
views.put( DynamicType.TYPE, new DynamicTypeInfoUI(sm) );
views.put( Reservation.TYPE, new ReservationInfoUI(sm) );
views.put( Appointment.TYPE, new AppointmentInfoUI(sm) );
views.put( Allocatable.TYPE, new AllocatableInfoUI(sm) );
views.put( User.TYPE, new UserInfoUI(sm) );
views.put( Period.TYPE, new PeriodInfoUI(sm) );
views.put( Category.TYPE, new CategoryInfoUI(sm) );
}
/** this method is used by the viewtable to dynamicaly create an
* appropriate HTMLInfo for the passed object
*/
<T extends RaplaObject> HTMLInfo<T> createView( T object ) throws RaplaException {
if ( object == null )
throw new RaplaException( "Could not create view for null object" );
@SuppressWarnings("unchecked")
HTMLInfo<T> result = views.get( object.getRaplaType() );
if (result != null)
return result;
throw new RaplaException( "Could not create view for this object: " + object.getClass() );
}
public <T> JComponent createInfoComponent( T object ) throws RaplaException {
ViewTable<T> viewTable = new ViewTable<T>(getContext());
viewTable.updateInfo( object );
return viewTable.getComponent();
}
public String getToolTip(Object obj) {
return getToolTip(obj,true);
}
public String getToolTip(Object obj,boolean wrapHtml) {
try {
if ( !(obj instanceof RaplaObject))
{
return null;
}
RaplaObject o = (RaplaObject )obj;
if ( !views.containsKey( o.getRaplaType()))
{
return null;
}
String text = createView( o ).getTooltip( o);
if (wrapHtml && text != null)
return HTMLView.createHTMLPage( text );
else
return text;
} catch(RaplaException ex) {
getLogger().error( ex.getMessage(), ex );
}
if (obj instanceof Named)
return ((Named) obj).getName(getI18n().getLocale());
return null;
}
/* (non-Javadoc)
* @see org.rapla.gui.view.IInfoUIFactory#showInfoDialog(java.lang.Object, java.awt.Component)
*/
public void showInfoDialog( Object object, Component owner )
throws RaplaException
{
showInfoDialog( object, owner, null);
}
/* (non-Javadoc)
* @see org.rapla.gui.view.IInfoUIFactory#showInfoDialog(java.lang.Object, java.awt.Component, java.awt.Point)
*/
public <T> void showInfoDialog( T object, Component owner, Point point )
throws RaplaException
{
final ViewTable<T> viewTable = new ViewTable<T>(getContext());
final DialogUI dlg = DialogUI.create(getContext(),owner
,false
,viewTable.getComponent()
,new String[] {
getString( "copy_to_clipboard" )
,getString( "print" )
,getString( "back" )
});
if ( !(object instanceof RaplaObject)) {
viewTable.updateInfoHtml( object.toString());
}
else
{
@SuppressWarnings("unchecked")
HTMLInfo<RaplaObject<T>> createView = createView((RaplaObject<T>)object);
@SuppressWarnings("unchecked")
final HTMLInfo<T> view = (HTMLInfo<T>) createView;
viewTable.updateInfo( object, view );
}
dlg.setTitle( viewTable.getDialogTitle() );
dlg.setDefault(2);
dlg.start( point );
dlg.getButton(0).setAction( new AbstractAction() {
private static final long serialVersionUID = 1L;
public void actionPerformed(ActionEvent e) {
try {
DataFlavor.getTextPlainUnicodeFlavor();
viewTable.htmlView.selectAll();
String plainText = viewTable.htmlView.getSelectedText();
//String htmlText = viewTable.htmlView.getText();
//InfoSelection selection = new InfoSelection( htmlText, plainText );
StringSelection selection = new StringSelection( plainText );
IOInterface printTool = getService(IOInterface.class);
printTool.setContents( selection, null);
} catch (Exception ex) {
showException(ex, dlg);
}
}
});
dlg.getButton(1).setAction( new AbstractAction() {
private static final long serialVersionUID = 1L;
public void actionPerformed(ActionEvent e) {
try {
IOInterface printTool = getService(IOInterface.class);
HTMLView htmlView = viewTable.htmlView;
printTool.print(
new ComponentPrinter(htmlView, htmlView.getPreferredSize())
, printTool.defaultPage()
,true
);
} catch (Exception ex) {
showException(ex, dlg);
}
}
});
}
/* (non-Javadoc)
* @see org.rapla.gui.view.IInfoUIFactory#createDeleteDialog(java.lang.Object[], java.awt.Component)
*/
public DialogUI createDeleteDialog( Object[] deletables, Component owner ) throws RaplaException {
ViewTable<Object[]> viewTable = new ViewTable<Object[]>(getContext());
DeleteInfoUI deleteView = new DeleteInfoUI(getContext());
DialogUI dlg = DialogUI.create(getContext(),owner
,true
,viewTable.getComponent()
,new String[] {
getString( "delete.ok" )
,getString( "delete.abort" )
});
dlg.setIcon( getIcon("icon.warning") );
dlg.getButton( 0).setIcon(getIcon("icon.delete") );
dlg.getButton( 1).setIcon(getIcon("icon.abort") );
dlg.setDefault(1);
viewTable.updateInfo( deletables, deleteView );
dlg.setTitle( viewTable.getDialogTitle() );
return dlg;
}
}
| 04900db4-clienttest | src/org/rapla/gui/internal/view/InfoFactoryImpl.java | Java | gpl3 | 8,634 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.view;
import java.util.Iterator;
import org.rapla.entities.DependencyException;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.storage.StorageOperator;
class DependencyInfoUI extends HTMLInfo<DependencyException> {
public DependencyInfoUI(RaplaContext sm){
super(sm);
}
@Override
protected String createHTMLAndFillLinks(DependencyException ex,LinkController controller) throws RaplaException{
StringBuffer buf = new StringBuffer();
buf.append(getString("error.dependencies")+":");
buf.append("<br>");
Iterator<String> it = ex.getDependencies().iterator();
int i = 0;
while (it.hasNext()) {
Object obj = it.next();
buf.append((++i));
buf.append(") ");
buf.append( obj );
buf.append("<br>");
if (i >= StorageOperator.MAX_DEPENDENCY && it.hasNext()) { //BJO
buf.append("... more"); //BJO
break;
}
}
return buf.toString();
}
@Override
protected String getTitle(DependencyException ex) {
return getString("info") + ": " + getString("error.dependencies");
}
}
| 04900db4-clienttest | src/org/rapla/gui/internal/view/DependencyInfoUI.java | Java | gpl3 | 2,229 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.view;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Locale;
import org.rapla.entities.dynamictype.Attribute;
import org.rapla.entities.dynamictype.AttributeAnnotations;
import org.rapla.entities.dynamictype.Classifiable;
import org.rapla.entities.dynamictype.Classification;
import org.rapla.entities.dynamictype.internal.AttributeImpl;
import org.rapla.framework.RaplaContext;
class ClassificationInfoUI<T extends Classifiable> extends HTMLInfo<T> {
public ClassificationInfoUI(RaplaContext sm) {
super(sm);
}
public void insertClassificationTitle( Classifiable classifiable, StringBuffer buf ) {
Classification classification = classifiable.getClassification();
buf.append( "<strong>");
Locale locale = getRaplaLocale().getLocale();
encode( classification.getType().getName(locale), buf );
buf.append( "</strong>");
}
protected void insertClassification( Classifiable classifiable, StringBuffer buf ) {
insertClassificationTitle( classifiable, buf );
Collection<Row> att = new ArrayList<Row>();
att.addAll(getClassificationAttributes(classifiable, false));
createTable(att,buf,false);
}
protected Collection<HTMLInfo.Row> getClassificationAttributes(Classifiable classifiable, boolean excludeAdditionalInfos) {
Collection<Row> att = new ArrayList<Row>();
Classification classification = classifiable.getClassification();
Attribute[] attributes = classification.getAttributes();
for (int i=0; i< attributes.length; i++) {
Attribute attribute = attributes[i];
String view = attribute.getAnnotation( AttributeAnnotations.KEY_EDIT_VIEW, AttributeAnnotations.VALUE_EDIT_VIEW_MAIN );
if ( view.equals(AttributeAnnotations.VALUE_EDIT_VIEW_NO_VIEW )) {
continue;
}
if ( excludeAdditionalInfos && !view.equals( AttributeAnnotations.VALUE_EDIT_VIEW_MAIN ) ) {
continue;
}
Collection<Object> values = classification.getValues( attribute);
/*
if (value == null)
continue;
*/
String name = getName(attribute);
String valueString = null;
Locale locale = getRaplaLocale().getLocale();
String pre = name;
for (Object value:values)
{
if (value instanceof Boolean) {
valueString = getString(((Boolean) value).booleanValue() ? "yes":"no");
} else {
valueString = ((AttributeImpl)attribute).getValueAsString( locale, value);
}
att.add (new Row(pre,encode(valueString)));
pre = "";
}
}
return att;
}
@Override
protected String getTooltip(Classifiable classifiable) {
StringBuffer buf = new StringBuffer();
Collection<Row> att = new ArrayList<Row>();
att.addAll(getClassificationAttributes(classifiable, false));
createTable(att,buf,false);
return buf.toString();
}
@Override
protected String createHTMLAndFillLinks(Classifiable classifiable,LinkController controller) {
StringBuffer buf = new StringBuffer();
insertClassification( classifiable, buf );
return buf.toString();
}
/**
* @param object
* @param controller
* @return
*/
protected String getTitle(Object object, LinkController controller) {
Classifiable classifiable = (Classifiable) object;
Classification classification = classifiable.getClassification();
return getString("view") + ": " + classification.getType().getName(getLocale());
}
}
| 04900db4-clienttest | src/org/rapla/gui/internal/view/ClassificationInfoUI.java | Java | gpl3 | 4,766 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.view;
import java.util.ArrayList;
import java.util.Collection;
import org.rapla.entities.Category;
import org.rapla.entities.User;
import org.rapla.entities.domain.Allocatable;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
class UserInfoUI extends HTMLInfo<User> {
ClassificationInfoUI<Allocatable> classificationInfo;
public UserInfoUI(RaplaContext sm) {
super(sm);
classificationInfo = new ClassificationInfoUI<Allocatable>(sm);
}
@Override
protected String createHTMLAndFillLinks(User user,LinkController controller) {
StringBuffer buf = new StringBuffer();
if (user.isAdmin()) {
highlight(getString("admin"),buf);
}
Collection<Row> att = new ArrayList<Row>();
att.add(new Row(getString("username"), strong( encode( user.getUsername() ) ) ) );
final Allocatable person = user.getPerson();
if ( person == null)
{
att.add(new Row(getString("name"), encode(user.getName())));
att.add(new Row(getString("email"), encode(user.getEmail())));
}
else
{
Collection<Row> classificationAttributes = classificationInfo.getClassificationAttributes(person, false);
att.addAll(classificationAttributes);
}
createTable(att,buf,false);
Category userGroupsCategory;
try {
userGroupsCategory = getQuery().getUserGroupsCategory();
} catch (RaplaException e) {
// Should not happen, but null doesnt harm anyway
userGroupsCategory = null;
}
Category[] groups = user.getGroups();
if ( groups.length > 0 ) {
buf.append(getString("groups") + ":");
buf.append("<ul>");
for ( int i = 0; i < groups.length; i++ ) {
buf.append("<li>");
String groupName = groups[i].getPath( userGroupsCategory , getI18n().getLocale());
encode ( groupName , buf);
buf.append("</li>\n");
}
buf.append("</ul>");
}
return buf.toString();
}
@Override
public String getTooltip(User user) {
return createHTMLAndFillLinks(user, null );
}
}
| 04900db4-clienttest | src/org/rapla/gui/internal/view/UserInfoUI.java | Java | gpl3 | 3,214 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.view;
interface LinkController
{
void createLink(Object object,String link,StringBuffer buf);
String createLink(Object object,String link);
}
| 04900db4-clienttest | src/org/rapla/gui/internal/view/LinkController.java | Java | gpl3 | 1,120 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.view;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import org.rapla.components.util.TimeInterval;
import org.rapla.entities.User;
import org.rapla.entities.domain.Allocatable;
import org.rapla.framework.RaplaContext;
public class AllocatableInfoUI extends ClassificationInfoUI<Allocatable> {
public AllocatableInfoUI(RaplaContext sm) {
super(sm);
}
void insertPermissions( Allocatable allocatable, StringBuffer buf ) {
User user;
Date today;
try {
user = getUser();
today = getQuery().today();
} catch (Exception ex) {
return;
}
TimeInterval accessInterval = allocatable.getAllocateInterval( user , today);
if ( accessInterval != null)
{
buf.append( "<strong>" );
buf.append( getString( "allocatable_in_timeframe" ) );
buf.append( ":</strong>" );
buf.append("<br>");
Date start = accessInterval.getStart();
Date end = accessInterval.getEnd();
if ( start == null && end == null ) {
buf.append( getString("everytime") );
}
else
{
if ( start != null ) {
buf.append( getRaplaLocale().formatDate( start ) );
} else {
buf.append(getString("open"));
}
buf.append(" - ");
if ( end != null ) {
buf.append( getRaplaLocale().formatDate( end ) );
} else {
buf.append(getString("open"));
}
buf.append("<br>");
}
}
}
@Override
protected String createHTMLAndFillLinks(Allocatable allocatable,LinkController controller) {
StringBuffer buf = new StringBuffer();
insertModificationRow( allocatable, buf );
insertClassificationTitle( allocatable, buf );
createTable( getAttributes( allocatable, controller, false),buf,false);
return buf.toString();
}
public List<Row> getAttributes(Allocatable allocatable,LinkController controller, boolean excludeAdditionalInfos) {
ArrayList<Row> att = new ArrayList<Row>();
att.addAll( super.getClassificationAttributes( allocatable, excludeAdditionalInfos ));
final Locale locale = getLocale();
User owner = allocatable.getOwner();
User lastChangeBy = allocatable.getLastChangedBy();
if ( owner != null)
{
final String ownerName = owner.getName(locale);
String ownerText = encode(ownerName);
if (controller != null)
ownerText = controller.createLink(owner,ownerName);
att.add( new Row(getString("resource.owner"), ownerText));
}
if ( lastChangeBy != null && (owner == null || !lastChangeBy.equals(owner))) {
final String lastChangedName = lastChangeBy.getName(locale);
String lastChangeByText = encode(lastChangedName);
if (controller != null)
lastChangeByText = controller.createLink(lastChangeBy,lastChangedName);
att.add( new Row(getString("last_changed_by"), lastChangeByText));
}
return att;
}
@Override
public String getTooltip(Allocatable allocatable) {
StringBuffer buf = new StringBuffer();
insertClassificationTitle( allocatable, buf );
insertModificationRow( allocatable, buf );
Collection<Row> att = new ArrayList<Row>();
att.addAll(getAttributes(allocatable, null, true));
createTable(att,buf);
insertPermissions( allocatable, buf );
return buf.toString();
}
}
| 04900db4-clienttest | src/org/rapla/gui/internal/view/AllocatableInfoUI.java | Java | gpl3 | 4,763 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.view;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.GridLayout;
import java.awt.Point;
import java.io.IOException;
import java.net.URL;
import javax.swing.JComponent;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextPane;
import javax.swing.JViewport;
import javax.swing.SwingUtilities;
import org.rapla.components.util.IOUtil;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.internal.ConfigTools;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.toolkit.RaplaWidget;
public class LicenseUI extends RaplaGUIComponent
implements
RaplaWidget
{
JPanel panel = new JPanel();
BorderLayout borderLayout1 = new BorderLayout();
GridLayout gridLayout2 = new GridLayout();
FlowLayout flowLayout1 = new FlowLayout();
JTextPane license = new JTextPane();
JScrollPane jScrollPane = new JScrollPane(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
public LicenseUI(RaplaContext sm) {
super( sm);
panel.setOpaque(true);
panel.setLayout(borderLayout1);
panel.add(jScrollPane,BorderLayout.CENTER);
license.setOpaque(false);
license.setEditable(false);
panel.setPreferredSize(new Dimension(640,400));
try {
String text = getLicense();
license.setText(text);
} catch (IOException ex) {
license.setText(ex.getMessage());
}
license.revalidate();
}
public JComponent getComponent() {
return panel;
}
private String getLicense() throws IOException {
URL url= ConfigTools.class.getClassLoader().getResource("META-INF/license.txt");
return new String(IOUtil.readBytes(url),"UTF-8");
}
public void showTop() {
final JViewport viewport = new JViewport();
viewport.setView(license);
jScrollPane.setViewport(viewport);
SwingUtilities.invokeLater( new Runnable() {
@Override
public void run() {
viewport.setViewPosition(new Point(0,0));
}
});
}
public void showBottom() {
JViewport viewport = new JViewport();
viewport.setView(license);
jScrollPane.setViewport(viewport);
Dimension dim = viewport.getViewSize();
viewport.setViewPosition(new Point(dim.width,dim.height));
}
}
| 04900db4-clienttest | src/org/rapla/gui/internal/view/LicenseUI.java | Java | gpl3 | 3,519 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.view;
import java.util.ArrayList;
import java.util.Collection;
import org.rapla.entities.Category;
import org.rapla.entities.dynamictype.Attribute;
import org.rapla.entities.dynamictype.AttributeType;
import org.rapla.entities.dynamictype.ConstraintIds;
import org.rapla.entities.dynamictype.DynamicType;
import org.rapla.framework.RaplaContext;
class DynamicTypeInfoUI extends HTMLInfo<DynamicType> {
public DynamicTypeInfoUI(RaplaContext sm) {
super(sm);
}
protected String createHTMLAndFillLinks(DynamicType object,LinkController controller){
DynamicType dynamicType = object;
StringBuffer buf = new StringBuffer();
insertModificationRow( object, buf );
Collection<Row> att = new ArrayList<Row>();
att.add(new Row(getString("dynamictype.name"), strong( encode( getName( dynamicType ) ))));
Attribute[] attributes = dynamicType.getAttributes();
for (int i=0;i<attributes.length;i++) {
String name = getName(attributes[i]);
String type = getString("type." + attributes[i].getType());
if (attributes[i].getType().equals(AttributeType.CATEGORY)) {
Category category = (Category) attributes[i].getConstraint(ConstraintIds.KEY_ROOT_CATEGORY);
if (category.getParent()!=null)
type = type + " " +getName(category);
}
att.add(new Row(encode(name), encode(type)));
}
createTable(att, buf, false);
return buf.toString();
}
protected String getTooltip(DynamicType object) {
if ( this.isAdmin()) {
return createHTMLAndFillLinks( object, null);
} else {
return null;
}
}
}
| 04900db4-clienttest | src/org/rapla/gui/internal/view/DynamicTypeInfoUI.java | Java | gpl3 | 2,713 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.view;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import org.rapla.components.util.xml.XMLWriter;
import org.rapla.entities.Named;
import org.rapla.entities.RaplaObject;
import org.rapla.entities.RaplaType;
import org.rapla.entities.Timestamp;
import org.rapla.facade.RaplaComponent;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.framework.RaplaLocale;
public abstract class HTMLInfo<T> extends RaplaComponent {
public HTMLInfo(RaplaContext sm) {
super(sm);
}
/** performs xml-encoding of a string the output goes to the buffer*/
static public void encode(String text,StringBuffer buf) {
buf.append( encode ( text ));
}
static public String encode(String string) {
String text = XMLWriter.encode( string );
if ( text.indexOf('\n') > 0 ) {
StringBuffer buf = new StringBuffer();
int size = text.length();
for ( int i= 0; i<size; i++) {
char c = text.charAt(i);
if ( c == '\n' ) {
buf.append("<br>");
} else {
buf.append( c );
} // end of switch ()
} // end of for ()
text = buf.toString();
}
return text;
}
protected void insertModificationRow( Timestamp timestamp, StringBuffer buf ) {
final Date createTime = timestamp.getCreateTime();
final Date lastChangeTime = timestamp.getLastChanged();
if ( lastChangeTime != null)
{
buf.append("<div style=\"font-size:7px;margin-bottom:4px;\">");
RaplaLocale raplaLocale = getRaplaLocale();
if ( createTime != null)
{
buf.append(getString("created_at"));
buf.append(" ");
buf.append(raplaLocale.formatTimestamp(createTime));
buf.append(", ");
}
buf.append(getString("last_changed"));
buf.append(" ");
buf.append(raplaLocale.formatTimestamp(lastChangeTime));
buf.append("</div>");
buf.append("\n");
}
}
static public void addColor(String color,StringBuffer buf) {
buf.append(" color=\"");
buf.append(color);
buf.append('\"');
}
static public void createTable(Collection<Row> attributes,StringBuffer buf,boolean encodeValues) {
buf.append("<table class=\"infotable\" cellpadding=\"1\">");
Iterator<Row> it = attributes.iterator();
while (it.hasNext()) {
Row att = it.next();
buf.append("<tr>\n");
buf.append("<td class=\"label\" valign=\"top\" style=\"white-space:nowrap\">");
encode(att.field,buf);
if ( att.field.length() > 0)
{
buf.append(":");
}
buf.append("</td>\n");
buf.append("<td class=\"value\" valign=\"top\">");
String value = att.value;
if (value != null)
{
try{
int httpEnd = Math.max( value.indexOf(" ")-1, value.length());
URL url = new URL( value.substring(0,httpEnd));
buf.append("<a href=\"");
buf.append(url.toExternalForm());
buf.append("\">");
if (encodeValues)
encode(value,buf);
else
buf.append(value);
buf.append("</a>");
}
catch (MalformedURLException ex)
{
if (encodeValues)
encode(value,buf);
else
buf.append(value);
}
}
buf.append("</td>");
buf.append("</tr>\n");
}
buf.append("</table>");
}
static public String createTable(Collection<Row> attributes, boolean encodeValues) {
StringBuffer buf = new StringBuffer();
createTable(attributes, buf, encodeValues);
return buf.toString();
}
static public void createTable(Collection<Row> attributes,StringBuffer buf) {
createTable(attributes,buf,true);
}
static public String createTable(Collection<Row> attributes) {
StringBuffer buf = new StringBuffer();
createTable(attributes,buf);
return buf.toString();
}
static public void highlight(String text,StringBuffer buf) {
buf.append("<FONT color=\"red\">");
encode(text,buf);
buf.append("</FONT>");
}
static public String highlight(String text) {
StringBuffer buf = new StringBuffer();
highlight(text,buf);
return buf.toString();
}
static public void strong(String text,StringBuffer buf) {
buf.append("<strong>");
encode(text,buf);
buf.append("</strong>");
}
static public String strong(String text) {
StringBuffer buf = new StringBuffer();
strong(text,buf);
return buf.toString();
}
abstract protected String createHTMLAndFillLinks(T object,LinkController controller) throws RaplaException ;
protected String getTitle(T object) {
StringBuffer buf = new StringBuffer();
buf.append(getString("view"));
if ( object instanceof RaplaObject)
{
RaplaType raplaType = ((RaplaObject) object).getRaplaType();
String localName = raplaType.getLocalName();
try
{
String name = getString(localName);
buf.append( " ");
buf.append( name);
}
catch (Exception ex)
{
// in case rapla type translation not found do nothing
}
}
if ( object instanceof Named)
{
buf.append(" ");
buf.append( ((Named) object).getName( getLocale()));
}
return buf.toString();
}
protected String getTooltip(T object) {
if (object instanceof Named)
return ((Named) object).getName(getI18n().getLocale());
return null;
}
static public class Row {
String field;
String value;
Row(String field,String value) {
this.field = field;
this.value = value;
}
public String getField() {
return field;
}
public String getValue() {
return value;
}
}
}
| 04900db4-clienttest | src/org/rapla/gui/internal/view/HTMLInfo.java | Java | gpl3 | 7,581 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal;
import java.awt.BorderLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.LinkedHashMap;
import java.util.Locale;
import java.util.Map;
import javax.swing.AbstractAction;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextField;
import org.rapla.client.internal.LanguageChooser;
import org.rapla.components.layout.TableLayout;
import org.rapla.entities.User;
import org.rapla.entities.configuration.Preferences;
import org.rapla.entities.domain.Allocatable;
import org.rapla.entities.dynamictype.Attribute;
import org.rapla.entities.dynamictype.Classification;
import org.rapla.entities.dynamictype.DynamicType;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.framework.RaplaLocale;
import org.rapla.gui.OptionPanel;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.internal.action.user.PasswordChangeAction;
import org.rapla.gui.toolkit.DialogUI;
import org.rapla.gui.toolkit.RaplaButton;
public class UserOption extends RaplaGUIComponent
implements
OptionPanel
{
JPanel superPanel = new JPanel();
JLabel emailLabel = new JLabel();
JLabel nameLabel = new JLabel();
JLabel usernameLabel = new JLabel();
LanguageChooser languageChooser;
Preferences preferences;
public UserOption(RaplaContext sm) {
super(sm);
}
private void create() throws RaplaException {
superPanel.removeAll();
TableLayout tableLayout = new TableLayout(new double[][]{{TableLayout.PREFERRED,5,TableLayout.PREFERRED,5,TableLayout.PREFERRED,5,TableLayout.PREFERRED},{TableLayout.PREFERRED,5,TableLayout.PREFERRED,5,TableLayout.PREFERRED,5,TableLayout.PREFERRED,5,TableLayout.PREFERRED,5,TableLayout.PREFERRED,5,TableLayout.PREFERRED}});
languageChooser= new LanguageChooser( getLogger(), getContext());
RaplaButton changeNameButton = new RaplaButton();
RaplaButton changeEmailButton = new RaplaButton();
RaplaButton changePasswordButton = new RaplaButton();
superPanel.setLayout(tableLayout);
superPanel.add( new JLabel(getString("language") + ": "),"0,0" );
superPanel.add( languageChooser.getComponent(),"2,0");
superPanel.add(new JLabel(getString("username") + ": "), "0,2");
superPanel.add(usernameLabel, "2,2");
superPanel.add(new JLabel(), "4,2");
superPanel.add(new JLabel(getString("name") + ": "), "0,4");
superPanel.add(nameLabel, "2,4");
superPanel.add(changeNameButton, "4,4");
superPanel.add(new JLabel(getString("email") + ": "), "0,6");
superPanel.add(emailLabel, "2,6");
superPanel.add(changeEmailButton, "4,6");
changeNameButton.setText(getString("change"));
changeNameButton.addActionListener(new MyActionListener());
nameLabel.setText(this.getClientFacade().getUser().getName());
emailLabel.setText(this.getClientFacade().getUser().getEmail());
changeEmailButton.setText(getString("change"));
changeEmailButton.addActionListener(new MyActionListener2( ));
superPanel.add(new JLabel(getString("password") + ":"), "0,8");
superPanel.add(new JLabel("****"), "2,8");
superPanel.add(changePasswordButton, "4,8");
PasswordChangeAction passwordChangeAction;
passwordChangeAction = new PasswordChangeAction(getContext(),getComponent());
User user = getUser();
passwordChangeAction.changeObject(user);
changePasswordButton.setAction(passwordChangeAction);
changePasswordButton.setText(getString("change"));
usernameLabel.setText(user.getUsername());
}
public void show() throws RaplaException {
create();
String language = preferences.getEntryAsString(RaplaLocale.LANGUAGE_ENTRY,null);
languageChooser.setSelectedLanguage( language);
}
public void setPreferences(Preferences preferences) {
this.preferences = preferences;
}
public void commit() {
String language = languageChooser.getSelectedLanguage();
preferences.putEntry( RaplaLocale.LANGUAGE_ENTRY,language );
}
public String getName(Locale locale) {
return getString("personal_options");
}
public JComponent getComponent() {
return superPanel;
}
class MyActionListener implements ActionListener{
public void actionPerformed(ActionEvent arg0)
{
try
{
JPanel test = new JPanel();
test.setLayout( new BorderLayout());
JPanel content = new JPanel();
GridLayout layout = new GridLayout();
layout.setColumns(2);
layout.setHgap(5);
layout.setVgap(5);
//content.setLayout(new TableLayout(new double[][]{{TableLayout.PREFERRED,5,TableLayout.PREFERRED},{TableLayout.PREFERRED,5,TableLayout.PREFERRED,5,TableLayout.PREFERRED, 5, TableLayout.PREFERRED}}));
content.setLayout( layout);
test.add(new JLabel(getString("enter_name")), BorderLayout.NORTH);
test.add(content, BorderLayout.CENTER);
User user = getUserModule().getUser();
Allocatable person = user.getPerson();
JTextField inputSurname = new JTextField();
addCopyPaste(inputSurname);
JTextField inputFirstname = new JTextField();
addCopyPaste(inputFirstname);
JTextField inputTitle= new JTextField();
addCopyPaste(inputTitle);
// Person connected?
if ( person != null)
{
Classification classification = person.getClassification();
DynamicType type = classification.getType();
Map<String,JTextField> map = new LinkedHashMap<String, JTextField>();
map.put("title", inputTitle);
map.put("firstname", inputFirstname);
map.put("forename", inputFirstname);
map.put("surname", inputSurname);
map.put("lastname", inputSurname);
int rows = 0;
for (Map.Entry<String, JTextField> entry: map.entrySet())
{
String fieldName = entry.getKey();
Attribute attribute = type.getAttribute(fieldName);
JTextField value = entry.getValue();
if ( attribute!= null && !content.isAncestorOf(value))
{
Locale locale = getLocale();
content.add( new JLabel(attribute.getName(locale)));
content.add( value);
Object value2 = classification.getValue( attribute);
rows++;
if ( value2 != null)
{
value.setText( value2.toString());
}
}
}
layout.setRows(rows); }
else
{
content.add( new JLabel(getString("name")));
content.add( inputSurname);
inputSurname.setText( user.getName());
layout.setRows(1);
}
DialogUI dlg = DialogUI.create(getContext(),getComponent(),true,test,new String[] {getString("save"),getString("abort")});
dlg.start();
if (dlg.getSelectedIndex() == 0)
{
String title = inputTitle.getText();
String firstname = inputFirstname.getText();
String surname =inputSurname.getText();
getUserModule().changeName(title,firstname,surname);
nameLabel.setText(user.getName());
}
}
catch (RaplaException ex)
{
showException( ex, getMainComponent());
}
}
}
class MyActionListener2 implements ActionListener {
JTextField emailField = new JTextField();
JTextField codeField = new JTextField();
RaplaButton sendCode = new RaplaButton();
RaplaButton validate = new RaplaButton();
public void actionPerformed(ActionEvent arg0) {
try
{
DialogUI dlg;
JPanel content = new JPanel();
GridLayout layout = new GridLayout();
layout.setColumns(3);
layout.setRows(2);
content.setLayout(layout);
content.add(new JLabel(getString("new_mail")));
content.add(emailField);
sendCode.setText(getString("send_code"));
content.add(sendCode);
sendCode.setAction(new EmailChangeActionB( emailField, codeField, validate));
content.add(new JLabel(getString("code_message3") + " "));
codeField.setEnabled(false);
content.add(codeField);
validate.setText(getString("code_validate"));
content.add(validate);
addCopyPaste(emailField);
addCopyPaste(codeField);
dlg = DialogUI.create(getContext(),getComponent(),true,content,new String[] {getString("save"),getString("abort")});
validate.setAction(new EmailChangeActionA(dlg));
validate.setEnabled(false);
dlg.setDefault(0);
dlg.setTitle("Email");
dlg.getButton(0).setAction(new EmailChangeActionC(getUserModule().getUser(), dlg));
dlg.getButton(0).setEnabled(false);
dlg.start();
}
catch (RaplaException ex)
{
showException( ex, getMainComponent());
}
}
class EmailChangeActionA extends AbstractAction {
private static final long serialVersionUID = 1L;
DialogUI dlg;
public EmailChangeActionA( DialogUI dlg){
this.dlg = dlg;
}
public void actionPerformed(ActionEvent arg0) {
try
{
User user = getUserModule().getUser();
boolean correct;
try {
int wert = Integer.parseInt(codeField.getText());
correct = wert == (Math.abs(user.getEmail().hashCode()));
} catch (NumberFormatException er)
{
correct = false;
}
if ( correct)
{
dlg.getButton(0).setEnabled(true);
}
else
{
JOptionPane.showMessageDialog(getMainComponent(),
getString("code_error1"),
getString("error"),
JOptionPane.ERROR_MESSAGE);
}
} catch (RaplaException ex) {
showException(ex, getMainComponent());
}
}
}
class EmailChangeActionB extends AbstractAction {
private static final long serialVersionUID = 1L;
JTextField rec;
JTextField code;
RaplaButton button;
public EmailChangeActionB(JTextField rec, JTextField code, RaplaButton button){
this.rec = rec;
this.button = button;
this.code = code;
}
public void actionPerformed(ActionEvent arg0)
{
try
{
String recepient = rec.getText();
getUserModule().confirmEmail(recepient);
button.setEnabled(true);
code.setEnabled(true);
}
catch (Exception ex) {
showException(ex, getMainComponent());
}
}
}
class EmailChangeActionC extends AbstractAction {
private static final long serialVersionUID = 1L;
User user;
DialogUI dlg;
public EmailChangeActionC(User user, DialogUI dlg){
this.user = user;
this.dlg = dlg;
}
public void actionPerformed(ActionEvent e) {
try {
String newMail = emailField.getText();
getUserModule().changeEmail(newMail);
emailLabel.setText(user.getEmail());
dlg.close();
} catch (RaplaException e1) {
e1.printStackTrace();
}
}
}
}
} | 04900db4-clienttest | src/org/rapla/gui/internal/UserOption.java | Java | gpl3 | 11,872 |
/*--------------------------------------------------------------------------* | Copyright (C) 2008 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal;
import java.awt.BorderLayout;
import java.awt.Component;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import javax.swing.BorderFactory;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTree;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;
import org.rapla.components.util.TimeInterval;
import org.rapla.entities.RaplaObject;
import org.rapla.entities.RaplaType;
import org.rapla.entities.User;
import org.rapla.entities.configuration.Preferences;
import org.rapla.facade.CalendarSelectionModel;
import org.rapla.facade.Conflict;
import org.rapla.facade.ModificationEvent;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.TreeFactory;
import org.rapla.gui.internal.common.MultiCalendarView;
import org.rapla.gui.internal.view.TreeFactoryImpl;
import org.rapla.gui.toolkit.RaplaTree;
import org.rapla.gui.toolkit.RaplaWidget;
public class ConflictSelection extends RaplaGUIComponent implements RaplaWidget {
public RaplaTree treeSelection = new RaplaTree();
protected final CalendarSelectionModel model;
MultiCalendarView view;
protected JPanel content = new JPanel();
JLabel summary = new JLabel();
Collection<Conflict> conflicts;
public ConflictSelection(RaplaContext context,final MultiCalendarView view, final CalendarSelectionModel model) throws RaplaException {
super(context);
this.model = model;
this.view = view;
conflicts = new LinkedHashSet<Conflict>( Arrays.asList(getQuery().getConflicts( )));
updateTree();
final JTree navTree = treeSelection.getTree();
content.setLayout(new BorderLayout());
content.add(treeSelection);
// content.setPreferredSize(new Dimension(260,400));
content.setBorder(BorderFactory.createRaisedBevelBorder());
JTree tree = treeSelection.getTree();
tree.setRootVisible(true);
tree.setShowsRootHandles(true);
tree.setCellRenderer(((TreeFactoryImpl) getTreeFactory()).createConflictRenderer());
tree.setSelectionModel(((TreeFactoryImpl) getTreeFactory()).createConflictTreeSelectionModel());
navTree.addTreeSelectionListener(new TreeSelectionListener() {
public void valueChanged(TreeSelectionEvent e)
{
Collection<Conflict> selectedConflicts = getSelectedConflicts();
showConflicts(selectedConflicts);
}
});
}
public RaplaTree getTreeSelection() {
return treeSelection;
}
protected CalendarSelectionModel getModel() {
return model;
}
public void dataChanged(ModificationEvent evt) throws RaplaException {
TimeInterval invalidateInterval = evt.getInvalidateInterval();
if ( invalidateInterval != null && invalidateInterval.getStart() == null)
{
Conflict[] conflictArray = getQuery().getConflicts( );
conflicts = new LinkedHashSet<Conflict>( Arrays.asList(conflictArray));
updateTree();
}
else if ( evt.isModified(Conflict.TYPE) || (evt.isModified( Preferences.TYPE) ) )
{
Set<Conflict> changed = RaplaType.retainObjects(evt.getChanged(), conflicts);;
removeAll( conflicts,changed);
Set<Conflict> removed = RaplaType.retainObjects(evt.getRemoved(), conflicts);
removeAll( conflicts,removed);
conflicts.addAll( changed);
for (RaplaObject obj:evt.getAddObjects())
{
if ( obj.getRaplaType()== Conflict.TYPE)
{
Conflict conflict = (Conflict) obj;
conflicts.add( conflict );
}
}
updateTree();
}
else
{
treeSelection.repaint();
}
}
private void removeAll(Collection<Conflict> list,
Set<Conflict> changed) {
Iterator<Conflict> it = list.iterator();
while ( it.hasNext())
{
if ( changed.contains(it.next()))
{
it.remove();
}
}
}
public JComponent getComponent() {
return content;
}
final protected TreeFactory getTreeFactory() {
return getService(TreeFactory.class);
}
private void showConflicts(Collection<Conflict> selectedConflicts) {
ArrayList<RaplaObject> arrayList = new ArrayList<RaplaObject>(model.getSelectedObjects());
for ( Iterator<RaplaObject> it = arrayList.iterator();it.hasNext();)
{
RaplaObject obj = it.next();
if (obj.getRaplaType() == Conflict.TYPE )
{
it.remove();
}
}
arrayList.addAll( selectedConflicts);
model.setSelectedObjects( arrayList);
if ( !selectedConflicts.isEmpty() )
{
Conflict conflict = selectedConflicts.iterator().next();
Date date = conflict.getStartDate();
if ( date != null)
{
model.setSelectedDate(date);
}
}
try {
view.getSelectedCalendar().update();
} catch (RaplaException e1) {
getLogger().error("Can't switch to conflict dates.", e1);
}
}
private Collection<Conflict> getSelectedConflictsInModel() {
Set<Conflict> result = new LinkedHashSet<Conflict>();
for (RaplaObject obj:model.getSelectedObjects())
{
if (obj.getRaplaType() == Conflict.TYPE )
{
result.add( (Conflict) obj);
}
}
return result;
}
private Collection<Conflict> getSelectedConflicts() {
List<Object> lastSelected = treeSelection.getSelectedElements( true);
Set<Conflict> selectedConflicts = new LinkedHashSet<Conflict>();
for ( Object selected:lastSelected)
{
if (selected instanceof Conflict)
{
selectedConflicts.add((Conflict)selected );
}
}
return selectedConflicts;
}
private void updateTree() throws RaplaException {
Collection<Conflict> conflicts = getConflicts();
TreeModel treeModel = getTreeFactory().createConflictModel(conflicts);
try {
treeSelection.exchangeTreeModel(treeModel);
treeSelection.getTree().expandRow(0);
} finally {
}
summary.setText( getString("conflicts") + " (" + conflicts.size() + ") ");
Collection<Conflict> selectedConflicts = new ArrayList<Conflict>(getSelectedConflicts());
Collection<Conflict> inModel = new ArrayList<Conflict>(getSelectedConflictsInModel());
if ( !selectedConflicts.equals( inModel ))
{
showConflicts(selectedConflicts);
}
}
public Collection<Conflict> getConflicts() throws RaplaException {
Collection<Conflict> conflicts;
boolean onlyOwn = model.isOnlyCurrentUserSelected();
User conflictUser = onlyOwn ? getUser() : null;
conflicts= getConflicts( conflictUser);
return conflicts;
}
private Collection<Conflict> getConflicts( User user) {
List<Conflict> result = new ArrayList<Conflict>();
for (Conflict conflict:conflicts) {
if (conflict.isOwner(user))
{
result.add(conflict);
}
}
Collections.sort( result, new ConflictStartDateComparator( ));
return result;
}
class ConflictStartDateComparator implements Comparator<Conflict>
{
public int compare(Conflict c1, Conflict c2) {
if ( c1.equals( c2))
{
return 0;
}
Date d1 = c1.getStartDate();
Date d2 = c2.getStartDate();
if ( d1 != null )
{
if ( d2 == null)
{
return -1;
}
else
{
int result = d1.compareTo( d2);
return result;
}
}
else if ( d2 != null)
{
return 1;
}
return new Integer(c1.hashCode()).compareTo( new Integer(c2.hashCode()));
}
}
public void clearSelection()
{
treeSelection.getTree().setSelectionPaths( new TreePath[] {});
}
public Component getSummaryComponent() {
return summary;
}
}
| 04900db4-clienttest | src/org/rapla/gui/internal/ConflictSelection.java | Java | gpl3 | 9,820 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
import javax.swing.AbstractAction;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JPanel;
import javax.swing.JTree;
import javax.swing.border.TitledBorder;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;
import org.rapla.entities.NamedComparator;
import org.rapla.entities.domain.Allocatable;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.TreeFactory;
import org.rapla.gui.toolkit.DialogUI;
import org.rapla.gui.toolkit.RaplaTree;
public class TreeAllocatableSelection extends RaplaGUIComponent implements ChangeListener {
JPanel content= new JPanel();
RaplaTree treeSelection;
JPanel buttonPanel;
JButton deleteButton;
JButton addButton;
NotificationAction deleteAction;
NotificationAction addAction;
String addDialogTitle;
public TreeAllocatableSelection(RaplaContext sm) {
super( sm);
treeSelection = new RaplaTree();
TitledBorder border = BorderFactory.createTitledBorder(BorderFactory.createEtchedBorder(Color.white,new Color(178, 178, 178)),getString("selection_resource"));
content.setBorder(border);
buttonPanel = new JPanel();
buttonPanel.setLayout(new FlowLayout(FlowLayout.LEFT));
deleteButton = new JButton();
addButton = new JButton();
buttonPanel.add(addButton);
buttonPanel.add(deleteButton);
content.setLayout(new BorderLayout());
content.add(buttonPanel, BorderLayout.NORTH);
content.add(treeSelection, BorderLayout.CENTER);
deleteAction = new NotificationAction().setDelete();
addAction = new NotificationAction().setAdd();
deleteButton.setAction(deleteAction);
addButton.setAction(addAction);
treeSelection.addChangeListener(this);
TreeFactory treeFactory = getTreeFactory();
treeSelection.getTree().setCellRenderer(treeFactory.createRenderer());
treeSelection.getTree().setModel( treeFactory.createClassifiableModel( Allocatable.ALLOCATABLE_ARRAY));
addDialogTitle = getString( "add") ;
}
Set<Allocatable> allocatables = new TreeSet<Allocatable>(new NamedComparator<Allocatable>(getLocale()));
public JComponent getComponent() {
return content;
}
final private TreeFactory getTreeFactory() {
return getService(TreeFactory.class);
}
public void setAllocatables(Collection<Allocatable> list) {
allocatables.clear();
if ( list != null ){
allocatables.addAll(list);
}
update();
}
public Collection<Allocatable> getAllocatables() {
return allocatables;
}
private void update() {
TreeFactory treeFactory = getTreeFactory();
TreeModel model = treeFactory.createClassifiableModel(allocatables.toArray(Allocatable.ALLOCATABLE_ARRAY), false);
treeSelection.exchangeTreeModel(model);
}
public void stateChanged(ChangeEvent e) {
deleteAction.setEnabled(!deleteAction.getSelected().isEmpty());
}
public String getAddDialogTitle() {
return addDialogTitle;
}
public void setAddDialogTitle(String addDialogTitle) {
this.addDialogTitle = addDialogTitle;
}
class NotificationAction extends AbstractAction {
private static final long serialVersionUID = 1L;
int ADD = 1;
int DELETE = 2;
int type;
NotificationAction setDelete() {
putValue(NAME,getString("delete"));
putValue(SMALL_ICON,getIcon("icon.delete"));
setEnabled(false);
type = DELETE;
return this;
}
NotificationAction setAdd() {
putValue(NAME,getString("add"));
putValue(SMALL_ICON,getIcon("icon.new"));
type = ADD;
return this;
}
protected List<Allocatable> getSelected() {
return getSelectedAllocatables(treeSelection);
}
protected List<Allocatable> getSelectedAllocatables(RaplaTree tree) {
List<Allocatable> allocatables = new ArrayList<Allocatable>();
List<Object> selectedElements = tree.getSelectedElements();
for ( Object obj:selectedElements)
{
allocatables.add((Allocatable) obj);
}
return allocatables;
}
public void actionPerformed(ActionEvent evt) {
try {
if (type == DELETE) {
allocatables.removeAll( getSelected());
update();
} else if (type == ADD) {
showAddDialog();
}
} catch (Exception ex) {
showException(ex,getComponent());
}
}
private void showAddDialog() throws RaplaException {
final DialogUI dialog;
RaplaTree treeSelection = new RaplaTree();
treeSelection.setMultiSelect(true);
treeSelection.getTree().setCellRenderer(getTreeFactory().createRenderer());
treeSelection.exchangeTreeModel(getTreeFactory().createClassifiableModel(getQuery().getAllocatables(),true));
treeSelection.setMinimumSize(new java.awt.Dimension(300, 200));
treeSelection.setPreferredSize(new java.awt.Dimension(400, 260));
dialog = DialogUI.create(
getContext()
,getComponent()
,true
,treeSelection
,new String[] { getString("add"),getString("cancel")});
dialog.setTitle(addDialogTitle);
dialog.getButton(0).setEnabled(false);
final JTree tree = treeSelection.getTree();
tree.addMouseListener(new MouseAdapter() {
// End dialog when a leaf is double clicked
public void mousePressed(MouseEvent e) {
TreePath selPath = tree.getPathForLocation(e.getX(), e.getY());
if (selPath != null && e.getClickCount() == 2) {
final Object lastPathComponent = selPath.getLastPathComponent();
if (((TreeNode) lastPathComponent).isLeaf() ) {
dialog.getButton(0).doClick();
return;
}
}
else
if (selPath != null && e.getClickCount() == 1) {
final Object lastPathComponent = selPath.getLastPathComponent();
if (((TreeNode) lastPathComponent).isLeaf() ) {
dialog.getButton(0).setEnabled(true);
return;
}
}
tree.removeSelectionPath(selPath);
}
});
dialog.start();
if (dialog.getSelectedIndex() == 0) {
List<Allocatable> selected = getSelectedAllocatables(treeSelection);
allocatables.addAll(selected);
update();
}
}
}
}
| 04900db4-clienttest | src/org/rapla/gui/internal/TreeAllocatableSelection.java | Java | gpl3 | 8,550 |
package org.rapla.gui.internal.edit.annotation;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.rapla.entities.Annotatable;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.AnnotationEditExtension;
import org.rapla.gui.EditField;
import org.rapla.gui.internal.edit.AbstractEditUI;
public class AnnotationEditUI extends AbstractEditUI<Annotatable>
{
Collection<AnnotationEditExtension> annotationExtensions;
Map<AnnotationEditExtension,EditField> fieldMap = new HashMap<AnnotationEditExtension,EditField>();
public AnnotationEditUI(RaplaContext context, Collection<AnnotationEditExtension> annotationExtensions) {
super(context);
this.annotationExtensions = annotationExtensions;
}
@Override
public void mapToObjects() throws RaplaException {
}
@Override
protected void mapFromObjects() throws RaplaException {
List<EditField> fields = new ArrayList<EditField>();
Annotatable annotatable = objectList.get(0);
for ( AnnotationEditExtension annot: annotationExtensions)
{
EditField field = annot.createEditField(annotatable);
if ( field != null)
{
fields.add( field);
fieldMap.put( annot, field);
}
}
setFields(fields);
}
public void mapTo(List<Annotatable> annotatables) throws RaplaException {
Annotatable annotatable = annotatables.get(0);
for ( AnnotationEditExtension annot: annotationExtensions)
{
EditField field = fieldMap.get( annot);
annot.mapTo(field, annotatable);
}
}
}
| 04900db4-clienttest | src/org/rapla/gui/internal/edit/annotation/AnnotationEditUI.java | Java | gpl3 | 1,798 |
package org.rapla.gui.internal.edit.annotation;
import org.rapla.entities.Annotatable;
import org.rapla.entities.dynamictype.Attribute;
import org.rapla.entities.dynamictype.AttributeAnnotations;
import org.rapla.entities.dynamictype.AttributeType;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.AnnotationEditExtension;
import org.rapla.gui.EditField;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.internal.edit.fields.BooleanField;
public class EmailAnnotationEdit extends RaplaGUIComponent implements AnnotationEditExtension{
private final String annotationName = AttributeAnnotations.KEY_EMAIL;
public EmailAnnotationEdit(RaplaContext context) {
super(context);
}
@Override
public EditField createEditField(Annotatable annotatable) {
if (!( annotatable instanceof Attribute))
{
return null;
}
Attribute attribute = (Attribute)annotatable;
AttributeType type = attribute.getType();
if (type!= AttributeType.STRING)
{
return null;
}
String annotation = annotatable.getAnnotation(annotationName);
BooleanField field = new BooleanField(getContext(),getString("email"));
if ( annotation != null )
{
field.setValue( annotation.equalsIgnoreCase("true"));
}
else
{
if ( attribute.getKey().equalsIgnoreCase("email"))
{
field.setValue( true );
}
}
return field;
}
@Override
public void mapTo(EditField field, Annotatable annotatable) throws RaplaException
{
if ( field != null)
{
Boolean value = ((BooleanField)field).getValue();
if ( value != null )
{
if ( value )
{
annotatable.setAnnotation(annotationName, Boolean.TRUE.toString());
return;
}
else if (( (Attribute)annotatable).getKey().equals("email"))
{
annotatable.setAnnotation(annotationName, Boolean.FALSE.toString());
}
}
}
annotatable.setAnnotation(annotationName, null);
}
}
| 04900db4-clienttest | src/org/rapla/gui/internal/edit/annotation/EmailAnnotationEdit.java | Java | gpl3 | 2,320 |
package org.rapla.gui.internal.edit.annotation;
import org.rapla.entities.Annotatable;
import org.rapla.entities.dynamictype.Attribute;
import org.rapla.entities.dynamictype.AttributeAnnotations;
import org.rapla.entities.dynamictype.AttributeType;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.AnnotationEditExtension;
import org.rapla.gui.EditField;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.internal.edit.fields.BooleanField;
public class ColorAnnotationEdit extends RaplaGUIComponent implements AnnotationEditExtension{
private final String annotationName = AttributeAnnotations.KEY_COLOR;
public ColorAnnotationEdit(RaplaContext context) {
super(context);
}
@Override
public EditField createEditField(Annotatable annotatable) {
if (!( annotatable instanceof Attribute))
{
return null;
}
Attribute attribute = (Attribute)annotatable;
AttributeType type = attribute.getType();
if ( type!=AttributeType.CATEGORY && type!= AttributeType.STRING)
{
return null;
}
String annotation = annotatable.getAnnotation(annotationName);
BooleanField field = new BooleanField(getContext(),getString("color"));
if ( annotation != null)
{
field.setValue( annotation.equalsIgnoreCase("true"));
}
return field;
}
@Override
public void mapTo(EditField field, Annotatable annotatable) throws RaplaException
{
if ( field != null)
{
Boolean value = ((BooleanField)field).getValue();
if ( value != null && value == true)
{
annotatable.setAnnotation(annotationName, Boolean.TRUE.toString());
return;
}
}
annotatable.setAnnotation(annotationName, null);
}
}
| 04900db4-clienttest | src/org/rapla/gui/internal/edit/annotation/ColorAnnotationEdit.java | Java | gpl3 | 1,929 |
package org.rapla.gui.internal.edit.annotation;
import org.rapla.entities.Annotatable;
import org.rapla.entities.dynamictype.Attribute;
import org.rapla.entities.dynamictype.AttributeAnnotations;
import org.rapla.entities.dynamictype.AttributeType;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.AnnotationEditExtension;
import org.rapla.gui.EditField;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.internal.edit.fields.LongField;
public class ExpectedRowsAnnotationEdit extends RaplaGUIComponent implements AnnotationEditExtension {
protected String annotationName = AttributeAnnotations.KEY_EXPECTED_ROWS;
protected Long DEFAULT_VALUE = new Long(1);
protected String fieldName = "expected_rows";
public ExpectedRowsAnnotationEdit(RaplaContext context) {
super(context);
}
@Override
public EditField createEditField(Annotatable annotatable) {
if (!( annotatable instanceof Attribute))
{
return null;
}
Attribute attribute = (Attribute)annotatable;
AttributeType type = attribute.getType();
if ( type!=AttributeType.STRING)
{
return null;
}
String annotation = annotatable.getAnnotation(annotationName);
LongField field = new LongField(getContext(),fieldName);
if ( annotation != null)
{
field.setValue( Integer.parseInt(annotation));
}
else
{
field.setValue( DEFAULT_VALUE);
}
addCopyPaste(field.getComponent());
return field;
}
@Override
public void mapTo(EditField field, Annotatable annotatable) throws RaplaException {
if ( field != null)
{
Long value = ((LongField)field).getValue();
if ( value != null && !value.equals(DEFAULT_VALUE))
{
annotatable.setAnnotation(annotationName, value.toString());
return;
}
}
annotatable.setAnnotation(annotationName, null);
}
}
| 04900db4-clienttest | src/org/rapla/gui/internal/edit/annotation/ExpectedRowsAnnotationEdit.java | Java | gpl3 | 2,118 |
package org.rapla.gui.internal.edit.annotation;
import org.rapla.entities.Annotatable;
import org.rapla.entities.dynamictype.Attribute;
import org.rapla.entities.dynamictype.AttributeAnnotations;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.AnnotationEditExtension;
import org.rapla.gui.EditField;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.internal.edit.fields.BooleanField;
public class CategorizationAnnotationEdit extends RaplaGUIComponent implements AnnotationEditExtension{
final String annotationName = AttributeAnnotations.KEY_CATEGORIZATION;
public CategorizationAnnotationEdit(RaplaContext context) {
super(context);
}
@Override
public EditField createEditField(Annotatable annotatable) {
if (!( annotatable instanceof Attribute))
{
return null;
}
Attribute attribute = (Attribute)annotatable;
String annotation = annotatable.getAnnotation(annotationName);
BooleanField field = new BooleanField(getContext(),getString("categorization"));
if ( annotation != null)
{
field.setValue( annotation.equalsIgnoreCase("true"));
}
else
{
if ( attribute.getKey().equalsIgnoreCase("categorization"))
{
field.setValue( true );
}
}
return field;
}
@Override
public void mapTo(EditField field, Annotatable annotatable) throws RaplaException
{
if ( field != null)
{
Boolean value = ((BooleanField)field).getValue();
if ( value != null )
{
if ( value)
{
annotatable.setAnnotation(annotationName, Boolean.TRUE.toString());
return;
}
else if (( (Attribute)annotatable).getKey().equals("categorization"))
{
annotatable.setAnnotation(annotationName, Boolean.FALSE.toString());
return;
}
}
}
annotatable.setAnnotation(annotationName, null);
}
}
| 04900db4-clienttest | src/org/rapla/gui/internal/edit/annotation/CategorizationAnnotationEdit.java | Java | gpl3 | 2,204 |
package org.rapla.gui.internal.edit.annotation;
import org.rapla.entities.dynamictype.AttributeAnnotations;
import org.rapla.framework.RaplaContext;
import org.rapla.gui.AnnotationEditExtension;
import org.rapla.gui.internal.edit.fields.TextField;
public class ExpectedColumnsAnnotationEdit extends ExpectedRowsAnnotationEdit implements AnnotationEditExtension {
public ExpectedColumnsAnnotationEdit(RaplaContext context) {
super(context);
fieldName="expected_columns";
annotationName = AttributeAnnotations.KEY_EXPECTED_COLUMNS;
DEFAULT_VALUE = new Long(TextField.DEFAULT_LENGTH);
}
}
| 04900db4-clienttest | src/org/rapla/gui/internal/edit/annotation/ExpectedColumnsAnnotationEdit.java | Java | gpl3 | 635 |
/*--------------------------------------------------------------------------*
| Copyright (C) 2014 Christopher Kohlhaas |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation. A copy of the license has been included with |
| these distribution in the COPYING file, if not go to www.fsf.org |
| |
| As a special exception, you are granted the permissions to link this |
| program with every library, which license fulfills the Open Source |
| Definition as published by the Open Source Initiative (OSI). |
*--------------------------------------------------------------------------*/
package org.rapla.gui.internal.edit;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import org.rapla.components.layout.TableLayout;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.EditComponent;
import org.rapla.gui.EditField;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.internal.edit.fields.EditFieldLayout;
import org.rapla.gui.internal.edit.fields.EditFieldWithLayout;
/**
*/
public abstract class AbstractEditUI<T> extends RaplaGUIComponent
implements
EditComponent<T>
,ChangeListener
{
protected JPanel editPanel = new JPanel();
protected List<T> objectList;
protected List<EditField> fields = Collections.emptyList();
public AbstractEditUI(RaplaContext context)
{
super(context);
}
final protected void setFields(Collection<? extends EditField> fields) {
for (EditField field:fields) {
field.removeChangeListener(this);
}
this.fields = new ArrayList<EditField>(fields);
for (EditField field:fields) {
field.addChangeListener(this);
}
editPanel.removeAll();
layout();
editPanel.revalidate();
}
protected void layout() {
TableLayout tableLayout = new TableLayout();
editPanel.setLayout(tableLayout);
tableLayout.insertColumn(0,5);
tableLayout.insertColumn(1,TableLayout.PREFERRED);
tableLayout.insertColumn(2,5);
tableLayout.insertColumn(3,TableLayout.FILL);
tableLayout.insertColumn(4,5);
int variableSizedBlocks = 0;
for (EditField field:fields) {
EditFieldLayout layout = getLayout(field);
if (layout.isVariableSized())
{
variableSizedBlocks ++;
}
}
int row = 0;
for (EditField field:fields) {
tableLayout.insertRow(row,5);
row ++;
EditFieldLayout layout = getLayout(field);
if (layout.isVariableSized()) {
@SuppressWarnings("cast")
double size = 0.99 / ((double) variableSizedBlocks);
tableLayout.insertRow(row,size);
} else{
tableLayout.insertRow(row,TableLayout.PREFERRED);
}
if (layout.isBlock()) {
editPanel.add("1," + row + ",3," + row+",l", field.getComponent());
} else {
editPanel.add("1," + row +",l,c", new JLabel(getFieldName(field) + ":"));
editPanel.add("3," + row +",l,c", field.getComponent());
}
row ++;
}
if (variableSizedBlocks == 0) {
tableLayout.insertRow(row,TableLayout.FILL);
editPanel.add("0," + row + ",4," + row ,new JLabel(""));
}
}
private EditFieldLayout getLayout(EditField field)
{
if ( field instanceof EditFieldWithLayout)
{
return ((EditFieldWithLayout) field).getLayout();
}
else
{
return new EditFieldLayout();
}
}
final public String getFieldName(EditField field)
{
String fieldName = field.getFieldName();
if ( fieldName == null)
{
return "";
}
return fieldName;
}
public void setObjects(List<T> o) throws RaplaException {
this.objectList = o;
mapFromObjects();
}
abstract protected void mapFromObjects() throws RaplaException;
public List<T> getObjects() {
return objectList;
}
public boolean isBlock() {
return false;
}
public JComponent getComponent() {
return editPanel;
}
public void stateChanged(ChangeEvent evt) {
}
}
| 04900db4-clienttest | src/org/rapla/gui/internal/edit/AbstractEditUI.java | Java | gpl3 | 4,966 |
<body>
Edit-dialogs for all rapla entities.
</body>
| 04900db4-clienttest | src/org/rapla/gui/internal/edit/package.html | HTML | gpl3 | 55 |