private int move(int index, int direction, boolean allTheWay) {
Vector<Mod> visibleMods = getVisible();
int newIndex;
if (!allTheWay) {
newIndex = index + direction;
} else if (direction < 0) {
newIndex = 0;
} else {
newIndex = visibleMods.size() - 1;
}
if (index >= 0
&& index < visibleMods.size()
&& newIndex >= 0
&& newIndex < visibleMods.size()
&& newIndex != index) {
List<Mod> mods =
visibleMods.subList(Math.min(index, newIndex), Math.max(index, newIndex) + 1);
for (int i = 0; i < modsByIndex.size(); i++) {
for (int j = 0; j < mods.size(); j++) {
if (modsByIndex.get(i) == mods.get(j)) {
modsByIndex.set(i, mods.get((j + direction + mods.size()) % mods.size()));
break;
}
}
}
index = newIndex;
}
return index;
}
private void refreshInternalMods() {
modsByIndex.remove(baseMod);
modsByIndex.remove(texturePackMod);
modsByIndex.add(0, baseMod);
modsByIndex.add(1, texturePackMod);
outer:
while (true) {
for (int i = 0; i < modsByIndex.size() - 1; i++) {
Mod mod1 = modsByIndex.get(i);
Mod mod2 = modsByIndex.get(i + 1);
if (mod1.internal && !dependsOn(mod2, mod1)) {
modsByIndex.set(i, mod2);
modsByIndex.set(i + 1, mod1);
continue outer;
}
}
break;
}
for (Mod mod : modsByIndex) {
if (mod.internal) {
mod.setEnabled(false);
}
}
HashMap<Mod, Boolean> changes = new HashMap<Mod, Boolean>();
for (Mod mod : modsByIndex) {
try {
if (mod.internal) {
// nothing
} else if (mod.isEnabled()) {
enableMod(changes, mod, false);
} else {
disableMod(changes, mod, false);
}
} catch (ModDependencyException e) {
Logger.log(e);
}
}
for (Map.Entry<Mod, Boolean> entry : changes.entrySet()) {
Mod mod = entry.getKey();
mod.setEnabled(entry.getValue());
}
}
int replace(Mod oldMod, Mod newMod) {
int index = indexOf(oldMod);
if (index >= 0 && oldMod.getName().equals(newMod.getName())) {
modsByIndex.set(index, newMod);
modsByName.put(newMod.getName(), newMod);
oldMod.close();
return indexOfVisible(newMod);
} else {
remove(oldMod);
return addFirst(newMod);
}
}
