private void typeDeletion(String name) {
BibtexEntryType type = BibtexEntryType.getType(name);
if (type instanceof CustomEntryType) {
if (BibtexEntryType.getStandardType(name) == null) {
int reply =
JOptionPane.showConfirmDialog(
frame,
Globals.lang(
"All entries of this " + "type will be declared " + "typeless. Continue?"),
Globals.lang("Delete custom format") + " '" + StringUtil.nCase(name) + '\'',
JOptionPane.YES_NO_OPTION,
JOptionPane.WARNING_MESSAGE);
if (reply != JOptionPane.YES_OPTION) {
return;
}
}
BibtexEntryType.removeType(name);
updateTypesForEntries(StringUtil.nCase(name));
changed.remove(name);
reqLists.remove(name);
optLists.remove(name);
if (biblatexMode) {
opt2Lists.remove(name);
}
}
// messageLabel.setText("'"+type.getName()+"' "+
// Globals.lang("is a standard type."));
}
private void applyChanges() {
valueChanged(new ListSelectionEvent(new JList(), 0, 0, false));
// Iterate over our map of required fields, and list those types if necessary:
List<String> types = typeComp.getFields();
for (Map.Entry<String, List<String>> stringListEntry : reqLists.entrySet()) {
if (!types.contains(stringListEntry.getKey())) {
continue;
}
List<String> reqFields = stringListEntry.getValue();
List<String> optFields = optLists.get(stringListEntry.getKey());
List<String> opt2Fields = opt2Lists.get(stringListEntry.getKey());
String[] reqStr = new String[reqFields.size()];
reqStr = reqFields.toArray(reqStr);
String[] optStr = new String[optFields.size()];
optStr = optFields.toArray(optStr);
String[] opt2Str;
if (opt2Fields != null) {
opt2Str = opt2Fields.toArray(new String[opt2Fields.size()]);
} else {
opt2Str = new String[0];
}
// If this type is already existing, check if any changes have
// been made
boolean changesMade = true;
if (defaulted.contains(stringListEntry.getKey())) {
// This type should be reverted to its default setup.
// System.out.println("Defaulting: "+typeName);
String nm = StringUtil.nCase(stringListEntry.getKey());
BibtexEntryType.removeType(nm);
updateTypesForEntries(nm);
continue;
}
BibtexEntryType oldType = BibtexEntryType.getType(stringListEntry.getKey());
if (oldType != null) {
String[] oldReq = oldType.getRequiredFields(), oldOpt = oldType.getOptionalFields();
if (biblatexMode) {
String[] priOpt = oldType.getPrimaryOptionalFields();
String[] secOpt = Util.getRemainder(oldOpt, priOpt);
if (equalArrays(oldReq, reqStr)
&& equalArrays(oldOpt, optStr)
&& equalArrays(secOpt, opt2Str)) {
changesMade = false;
}
} else if (equalArrays(oldReq, reqStr) && equalArrays(oldOpt, optStr)) {
changesMade = false;
}
}
if (changesMade) {
// System.out.println("Updating: "+typeName);
CustomEntryType typ =
biblatexMode
? new CustomEntryType(
StringUtil.nCase(stringListEntry.getKey()), reqStr, optStr, opt2Str)
: new CustomEntryType(StringUtil.nCase(stringListEntry.getKey()), reqStr, optStr);
BibtexEntryType.ALL_TYPES.put(stringListEntry.getKey().toLowerCase(), typ);
updateTypesForEntries(typ.getName());
}
}
Set<Object> toRemove = new HashSet<Object>();
for (String o : BibtexEntryType.ALL_TYPES.keySet()) {
if (!types.contains(o)) {
toRemove.add(o);
}
}
// Remove those that should be removed:
if (!toRemove.isEmpty()) {
for (Object aToRemove : toRemove) {
typeDeletion((String) aToRemove);
}
}
updateTables();
}
@Override
public String format(String field) {
int i;
field =
field
.replaceAll("&|\\\\&", "&")
.replaceAll("[\\n]{2,}", "<p>")
.replaceAll("\\n", "<br>");
StringBuilder sb = new StringBuilder();
StringBuffer currentCommand = null;
char c;
boolean escaped = false, incommand = false;
for (i = 0; i < field.length(); i++) {
c = field.charAt(i);
if (escaped && (c == '\\')) {
sb.append('\\');
escaped = false;
} else if (c == '\\') {
if (incommand) {
/* Close Command */
String command = currentCommand.toString();
Object result = Globals.HTMLCHARS.get(command);
if (result != null) {
sb.append((String) result);
} else {
sb.append(command);
}
}
escaped = true;
incommand = true;
currentCommand = new StringBuffer();
} else if (!incommand && ((c == '{') || (c == '}'))) {
// Swallow the brace.
} else if (Character.isLetter(c)
|| (c == '%')
|| (Globals.SPECIAL_COMMAND_CHARS.contains(String.valueOf(c)))) {
escaped = false;
if (!incommand) {
sb.append(c);
} else {
currentCommand.append(c);
testCharCom:
if ((currentCommand.length() == 1)
&& (Globals.SPECIAL_COMMAND_CHARS.contains(currentCommand.toString()))) {
// This indicates that we are in a command of the type
// \^o or \~{n}
if (i >= (field.length() - 1)) {
break testCharCom;
}
String command = currentCommand.toString();
i++;
c = field.charAt(i);
// System.out.println("next: "+(char)c);
String combody;
if (c == '{') {
String part = StringUtil.getPart(field, i, false);
i += part.length();
combody = part;
} else {
combody = field.substring(i, i + 1);
// System.out.println("... "+combody);
}
Object result = Globals.HTMLCHARS.get(command + combody);
if (result != null) {
sb.append((String) result);
}
incommand = false;
escaped = false;
} else {
// Are we already at the end of the string?
if ((i + 1) == field.length()) {
String command = currentCommand.toString();
Object result = Globals.HTMLCHARS.get(command);
/* If found, then use translated version. If not,
* then keep
* the text of the parameter intact.
*/
if (result != null) {
sb.append((String) result);
} else {
sb.append(command);
}
}
}
}
} else {
String argument;
if (!incommand) {
sb.append(c);
} else if (Character.isWhitespace(c) || (c == '{') || (c == '}')) {
// First test if we are already at the end of the string.
// if (i >= field.length()-1)
// break testContent;
String command = currentCommand.toString();
// Then test if we are dealing with a italics or bold
// command.
// If so, handle.
if (command.equals("em") || command.equals("emph") || command.equals("textit")) {
String part = StringUtil.getPart(field, i, true);
i += part.length();
sb.append("<em>").append(part).append("</em>");
} else if (command.equals("textbf")) {
String part = StringUtil.getPart(field, i, true);
i += part.length();
sb.append("<b>").append(part).append("</b>");
} else if (c == '{') {
String part = StringUtil.getPart(field, i, true);
i += part.length();
argument = part;
if (argument != null) {
// handle common case of general latex command
Object result = Globals.HTMLCHARS.get(command + argument);
// System.out.print("command: "+command+", arg: "+argument);
// System.out.print(", result: ");
// If found, then use translated version. If not, then keep
// the
// text of the parameter intact.
if (result != null) {
sb.append((String) result);
} else {
sb.append(argument);
}
}
} else if (c == '}') {
// This end brace terminates a command. This can be the case in
// constructs like {\aa}. The correct behaviour should be to
// substitute the evaluated command and swallow the brace:
Object result = Globals.HTMLCHARS.get(command);
if (result != null) {
sb.append((String) result);
} else {
// If the command is unknown, just print it:
sb.append(command);
}
} else {
Object result = Globals.HTMLCHARS.get(command);
if (result != null) {
sb.append((String) result);
} else {
sb.append(command);
}
sb.append(' ');
}
} /* else if (c == '}') {
System.out.printf("com term by }: '%s'\n", currentCommand.toString());
argument = "";
}*/ else {
/*
* TODO: this point is reached, apparently, if a command is
* terminated in a strange way, such as with "$\omega$".
* Also, the command "\&" causes us to get here. The former
* issue is maybe a little difficult to address, since it
* involves the LaTeX math mode. We don't have a complete
* LaTeX parser, so maybe it's better to ignore these
* commands?
*/
}
incommand = false;
escaped = false;
}
}
return sb.toString();
}
