Modelling 3D feather with blender

Browsing through the links found by google on the issue blender and feathers did not provide me with what I searched. For completeness sake let me list them here in the case it is what you are looking for:

Forum entries and other listings:

Ready made feather models:

Tutorials:

„Modelling 3D feather with blender“ weiterlesen

Adding context sensitive Help to your Plug-in

For my Code generation plug-in I wanted to add some context sensitive help. Looking for any hints I only found a quick description at Macrobug’s that dates back in autumn 2007 when Eclipse 3.3 (Europa) was the current platform. Following these steps I could not produce any meaningful results. Therefore I figured it out on my own and present my solution here for anyone interested.
„Adding context sensitive Help to your Plug-in“ weiterlesen

Getting started with PHP Class Generator Plugin

The Eclipse plugin PHP Class Generator is now about a month up on Eclipse Plugin Central. It was now brought to my attention (thanks Tyler) that documentation is not exactly missing but at least hard to find and you have to know where and how to look. This article should help to shed light into the dark.
„Getting started with PHP Class Generator Plugin“ weiterlesen

Durchsuchen des Classpath

Das JDK bringt von Haus aus bereits ein mächtiges Framework mit sich, mit dem sich zur Runtime Informationen über die Applikation gewinnen lassen, wie auch schon in einem früheren Beitrag beschrieben. Dies funktioniert solange einwandfrei als ich weiss auf welche Klasse ich die Reflection los lasse.
Mit Annotation lässt sich eine Vielzahl von Dingen bewerkstelligen, so kann man auch auf den Gedanken verfallen, dass man Bestimmte Aufgaben definiert (beispielsweise in einer Enumeration). Die Ausführung dieser Aufgaben übernehmen Methoden mit einer nicht näher bekannten Signatur. Was aber bekannt ist, ist dass die Methode mit einer Annotation gekennzeichnet ist, die besagt, dass diese Methode jene Aufgabe erfüllt.
Wie gelange ich nun an die Klasse in der die Methode definiert ist? Nur mit dem JDK ist dies nicht möglich. Dazu müssen aus dem Classpath alle Klassen ausgelesen werden. Dann kann jede einzelne Klasse nach der Methode untersucht werden, die die spezifizierte Annotation besitzt.
Wem dies alles etwas zu abstrakt war hier das Beispiel:

public class ClassFinder {
        /**
         * Defined classpath
         */
	private static final String CLASSPATH = System.getProperty("java.class.path");
	/**
	 * List with the jar files on the classpath
	 */
	private static String[] jarFiles;
	/**
	 * List with the directories on the classpath (containing .class files)
	 */
	private static String[] binDirs;
	/**
	 * All Classpath elements
	 */
	private static File[] classPathDirs = null;
	/**
	 * Default constructur initializes the directories indicated by the
	 * CLASSPATH, if they are not yet initialized.
	 */
	public ClassFinder() {
		if (classPathDirs == null) {
			initClassPathDir();
		}
	}
	/**
	 * Initialize the directories based on the classpath
	 */
	private void initClassPathDir() {
		StringTokenizer st = new StringTokenizer(CLASSPATH, File.pathSeparator);
		int count = st.countTokens();
		classPathDirs = new File[count];
		Vector jar = new Vector();
		Vector bin = new Vector();
		for (int i = 0; i < count; i++) {
			classPathDirs[i] = new File(st.nextToken());
			if (classPathDirs[i].isDirectory()) {
				bin.add(classPathDirs[i].getAbsolutePath());
			} else {
				jar.add(classPathDirs[i].getAbsolutePath());
			}
		}
		jarFiles = new String[jar.size()];
		binDirs = new String[bin.size()];
		jar.copyInto(jarFiles);
		bin.copyInto(binDirs);
	}

	/**
	 * Retrive all classes of the indicated package. The package is searched in
	 * all classpath directories that are directories
	 * 
	 * @param packageName
	 *            name of the package as 'ch.sahits.civ'
	 * @return Array of found classes
	 * @throws ClassNotFoundException
	 */
	public Class[] getAll(String packageName) throws ClassNotFoundException {
		String packageDir = convertPackege(packageName);
		Vector classes = new Vector();
		for (int i = 0; i < binDirs.length; i++) {
			packageDir = binDirs[i] + File.separator + packageDir;
			File dir = new File(packageDir);
			classes.addAll(extractClasses(packageName, dir));
		}
		Class[] result = new Class[classes.size()];
		classes.copyInto(result);
		return result;
	}
	/**
	 * Extract all the classes from a directory
	 * @param packageName name of the package as 'ch.sahits.civ'
	 * @param dir Package as directory
	 * @return Vector with all found directories
	 * @throws ClassNotFoundException
	 */
	private Vector extractClasses(String packageName, File dir) throws ClassNotFoundException {
		Vector classes = new Vector();
		File[] files = dir.listFiles(new FilenameFilter() {
			public boolean accept(File dir, String filename) {
				return filename.endsWith(".class");
			}
		});
		if (files!=null) {	// directories without .class files may exist
			for (int j = 0; j < files.length; j++) {
				String className = packageName + "." + files[j].getName();
				className = className.substring(0, className
						.lastIndexOf(".class"));
				classes.add(Class.forName(className));
			}
		}
		return classes;
	}
	/**
	 * Convert the package name into a relative directory path
	 * @param packageName name of the package as 'ch.sahits.civ'
	 * @return relativ directory to the package
	 */
	private String convertPackege(String packageName) {
		String sep = File.separator;
		return packageName.replace(".", sep);
	}
	/**
	 * Retrive all classes of the indicated package and all subpackages. The package is searched in
	 * all classpath directories that are directories
	 * 
	 * @param packageName
	 *            name of the package as 'ch.sahits.civ'
	 * @return Array of found classes
	 * @throws ClassNotFoundException
	 */
	public Class[] getAllRecursive(String packageName) throws ClassNotFoundException {
		String packageDir = convertPackege(packageName);
		Vector classes = new Vector();
		for (int i = 0; i < binDirs.length; i++) {
			packageDir = binDirs[i] + File.separator + packageDir;
			File dir = new File(packageDir);
			classes.addAll(extractClasses(packageName, dir));
			if (dir.isDirectory()) {
				File[] sub = dir.listFiles();
				for (int j = 0; j < sub.length; j++) {
					if (sub[j].isDirectory()) {
						Class[] rec = getAllRecursive(packageName + "."
								+ sub[j].getName());
						Vector temp = new Vector(rec.length);
						for (int k = 0; k < rec.length; k++) {
							temp.add(rec[k]);
						}
						classes.addAll(temp);
					}
				}
			}
		}
		Class[] result = new Class[classes.size()];
		classes.copyInto(result);
		return result;
	}
}

Vielleicht sollte an dieser Stelle noch bemerkt werden, dass ein solches Vorgehen wohl überlegt sein soll, denn nur mit diesen Informationen ist es nicht nicht möglich, die Methode auszuführen, den dazu wird noch ein Objekt benötigt, auf welchem die Methode ausgeführt werden kann und wenn man dieses hat, kann man sich den Umweg über den Classpath sparen.