diff -r 932c358ece3e -r d8fccb2cd802 Orb/Doxygen/src/xmlditaelementprefix.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Orb/Doxygen/src/xmlditaelementprefix.cpp	Fri Apr 23 20:47:58 2010 +0100
@@ -0,0 +1,275 @@
+/******************************************************************************
+ *
+ * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation under the terms of the GNU General Public License is hereby 
+ * granted. No representations are made about the suitability of this software 
+ * for any purpose. It is provided "as is" without express or implied warranty.
+ * See the GNU General Public License for more details.
+ *
+ */
+#include "xmlditaelementprefix.h"
+
+// Version to use in the DOCTYPE declaration
+// Should match regex: v(\d+)\.(\d+)\.(\d+)(\S*)
+const char *DOCTYPE_VERSION = "v0.5.0";
+
+DITAElementPrefix::DITAElementPrefix()
+{
+	//QDict<char> m_extToLang;
+	//QDict<char> m_langToPrefix;
+	// NOTE: Keys must be in lowercase as the extension will be
+	// coerced to lowercase before matching
+	// NOTE: Value is case sensitive and must match the key of m_langToPrefix
+	// C/C++ languages - our primary concern - we treat C as C++ for the moment
+	// NOTE: This is very similar to initDefaultExtensionMapping() in util.h/util.cpp
+	// TODO: Respect extension/language mapping in config file
+	// TODO: Have list of supported languages in DITA e.g. isSupported(Definition*);
+	// so that callers can decide to supress output for unsupported languages
+	m_extToLang.insert(".h",     "C++");
+	m_extToLang.insert(".c",     "C++");
+	m_extToLang.insert(".cpp",   "C++");
+	m_extToLang.insert(".cc",    "C++");
+	m_extToLang.insert(".cp",    "C++");
+	m_extToLang.insert(".cxx",   "C++");
+	m_extToLang.insert(".inl",   "C++");
+	m_extToLang.insert(".cia",   "C++");
+	m_extToLang.insert(".hrh",   "C++");
+	m_extToLang.insert(".s",     "C++");
+	// Other languages
+	m_extToLang.insert(".idl",   "IDL"); 
+	m_extToLang.insert(".ddl",   "IDL"); 
+	m_extToLang.insert(".odl",   "IDL"); 
+	m_extToLang.insert(".java",  "Java");
+	m_extToLang.insert(".as",    "JavaScript"); 
+	m_extToLang.insert(".js",    "JavaScript");
+	m_extToLang.insert(".cs",    "C Sharp");
+	m_extToLang.insert(".d",     "D");
+	m_extToLang.insert(".php",   "PHP"); 
+	m_extToLang.insert(".php4",  "PHP");
+	m_extToLang.insert(".php5",  "PHP");
+	m_extToLang.insert(".inc",   "PHP");
+	m_extToLang.insert(".phtml", "PHP");
+	m_extToLang.insert(".m",     "Objective C");
+	m_extToLang.insert(".M",     "Objective C");
+	m_extToLang.insert(".mm",    "Objective C");
+	m_extToLang.insert(".py",    "Python");
+	m_extToLang.insert(".f",     "Fortran");
+	m_extToLang.insert(".f90",   "Fortran");
+	m_extToLang.insert(".vhd",   "VHDL");
+	m_extToLang.insert(".vhdl",  "VHDL");
+	// Default Language
+	m_defaultLanguage = "C++";
+	//
+	// Now load the language to element prefix, case sensitve all round.
+	// However the class behavior is that if there is no entry then the prefix is the
+	// language in lower case with spaces removed i.e. implicitly "C Sharp" -> "csharp"
+	//
+	m_langToPrefix.insert("C++", "cxx");
+	// Map of language to the owner of the DOCTYPE
+	m_langToDoctypeOwner.insert("C++", "NOKIA");
+	m_langToDoctypeOwner.insert("Java", "IBM");
+}
+
+QString DITAElementPrefix::srcLang(const QString &fileName)
+{
+	QString retStr;
+	int i = fileName.findRev('.');
+	QFileInfo fInfo(fileName);
+	//QString ext = fileName.right(fileName.length() - i).lower();
+	QString ext = fInfo.extension();
+	if (ext.length() > 0 && m_extToLang.find(ext)) {
+		retStr = QString(m_extToLang[ext]);
+	} else {
+		// WTF?
+		//retStr = "_" + ext + "_";
+		retStr = m_defaultLanguage;
+	}
+	//printf("DITAElementPrefix::srcLang file \"%s\" extension \"%s\" gets \"%s\"\n", fileName.data(), ext.data(), retStr.data());
+	return retStr;
+}
+
+QString DITAElementPrefix::elemPrefix(const QString &srcLang)
+{
+	char *p = m_langToPrefix[srcLang];
+	if (p) {
+		return QString(p);
+	}
+	// Fall back to returning the suppied argument but in lower case and
+	// with spaces removed
+	QString retStr;
+	for (uint i = 0; i < srcLang.length(); ++i) {
+		if (srcLang[i] != " ") {
+			retStr.append(srcLang[i]);
+		}
+	}
+	return retStr.lower();
+}
+
+QString DITAElementPrefix::srcLang(const Definition *d)
+{
+	QCString myFileName = d->getDefFileName();
+	return srcLang(myFileName);
+}
+
+QString DITAElementPrefix::memberKind(const MemberDef *md)
+{
+	// Get the kind, make lower case and capitalise the first letter
+	// Special case turn "enumvalue" to "Enumerator"
+	// [ISO/IEC 9899:1999 (E) 6.7.2.2 Enumeration specifiers]
+	if (md->memberTypeName() == "enumvalue") {
+		return QString("Enumerator");
+	}
+	return capFirstLetter(md->memberTypeName());
+}
+
+QString DITAElementPrefix::memberKind(const ClassDef *cd)
+{
+	return capFirstLetter(cd->compoundTypeString());
+}
+
+/** Return a string that is the input lowercased then first letter capitalised */
+QString DITAElementPrefix::capFirstLetter(const QString& in) const
+{
+	if (in.length() == 0) {
+		return in.upper();
+	}
+	QString myStr(in.lower());
+	QString myPref(myStr.left(1).upper());
+	QString mySuff(myStr.remove(0, 1));
+	return myPref + mySuff;
+}
+
+QString DITAElementPrefix::elemPrefix(const Definition *d)
+{
+	QCString myFileName = d->getDefFileName();
+	return elemPrefix(srcLang(myFileName));
+}
+
+QString DITAElementPrefix::elemPrefix(const MemberDef *md, bool includeKind)
+{
+	QCString myFileName = md->getDefFileName();
+	if (includeKind) {
+		return elemPrefix(srcLang(myFileName)) + memberKind(md);
+	}
+	return elemPrefix(srcLang(myFileName));
+}
+
+QString DITAElementPrefix::elemPrefix(const ClassDef *cd, bool includeKind)
+{
+	QCString myFileName = cd->getDefFileName();
+	if (includeKind) {
+		// Get the kind and capitalise the first letter
+		return elemPrefix(srcLang(myFileName)) + capFirstLetter(cd->compoundTypeString());
+	}
+	return elemPrefix(srcLang(myFileName));
+}
+
+QString DITAElementPrefix::elemPrefix(const NamespaceDef *nd, bool includeKind)
+{
+	QCString myFileName = nd->getDefFileName();
+	if (includeKind) {
+		return elemPrefix(srcLang(myFileName)) + "Namespace";
+	}
+	return elemPrefix(srcLang(myFileName));
+}
+
+QString DITAElementPrefix::elemPrefix(const FileDef *fd, bool includeKind)
+{
+	QCString myFileName = fd->getDefFileName();
+	if (includeKind) {
+		return elemPrefix(srcLang(myFileName)) + "File";
+	}
+	return elemPrefix(srcLang(myFileName));
+}
+
+/** Return a string that can be use as a element name that refers to the MemberDef */
+QString DITAElementPrefix::elemReference(const MemberDef *md)
+{
+	return elemPrefix(md, true);
+}
+
+/** Return a string that can be use as a element name that refers to the ClassDef */
+QString DITAElementPrefix::elemReference(const ClassDef *cd)
+{
+	return elemPrefix(cd, true);
+}
+
+// DITA Map references to the 'big four'
+QString DITAElementPrefix::ditaMapRef(const MemberDef *md)
+{
+	return elemPrefix(md, true)+"Ref";
+}
+
+QString DITAElementPrefix::ditaMapRef(const ClassDef *cd)
+{
+	return elemPrefix(cd, true)+"Ref";
+}
+
+QString DITAElementPrefix::ditaMapRef(const NamespaceDef *nd)
+{
+	return elemPrefix(nd, true)+"Ref";
+}
+
+QString DITAElementPrefix::ditaMapRef(const FileDef *fd)
+{
+	return elemPrefix(fd, true)+"Ref";
+}
+
+
+/* Returns the DOCTYPE owner from the source code language or "???" */
+QString DITAElementPrefix::doctypeOwner(const QString &srcLang)
+{
+	char *p = m_langToDoctypeOwner[srcLang];
+	if (p) {
+		return QString(p);
+	}
+	return QString("???");
+}
+
+QString DITAElementPrefix::doctypeStr(const QString &srcLang, const QString &ePref, const QString &sInsert)
+{
+	QString retVal = ePref;
+	retVal += " PUBLIC \"-//";
+	retVal += doctypeOwner(srcLang);
+	retVal += "//DTD DITA ";
+	retVal += srcLang;
+	retVal += " API ";
+	retVal += sInsert;
+	retVal += " Reference Type ";
+	retVal += DOCTYPE_VERSION;
+	retVal += "//EN\" \"dtd/";
+	retVal += ePref;
+	retVal += ".dtd\" ";
+	return retVal;
+}
+
+QString DITAElementPrefix::doctypeStr(const Definition *d, const QString &ePref, const QString &sInsert)
+{
+	return doctypeStr(srcLang(d), ePref, sInsert);
+}
+/** Return a string that can be use as a DOCTYPE for the XML for the ClassDef */
+QString DITAElementPrefix::doctypeStr(const MemberDef *md)
+{
+	return doctypeStr(md, elemPrefix(md, true), capFirstLetter(md->memberTypeName()));
+}
+
+/** Return a string that can be use as a DOCTYPE for the XML for the MemberDef */
+QString DITAElementPrefix::doctypeStr(const ClassDef *cd)
+{
+	return doctypeStr(cd, elemPrefix(cd, true), capFirstLetter(cd->compoundTypeString()));
+}
+
+/** Return a string that can be use as a DOCTYPE for the XML for the Namespace */
+QString DITAElementPrefix::doctypeStr(const NamespaceDef *nd)
+{
+	return doctypeStr(nd, elemPrefix(nd, true), "Namespace");
+}
+
+/** Return a string that can be use as a DOCTYPE for the XML for the File */
+QString DITAElementPrefix::doctypeStr(const FileDef *fd)
+{
+	return doctypeStr(fd, elemPrefix(fd, true), "File");
+}
+