Initial commit

1 files changed, 647 insertions, 0 deletions

diff --git a/NET/worlds/console/WorldsMarkPart.java b/NET/worlds/console/WorldsMarkPart.java
new file mode 100644
index 0000000..d9afcab
--- /dev/null
+++ b/NET/worlds/console/WorldsMarkPart.java
@@ -0,0 +1,647 @@
+package NET.worlds.console;
+
+import NET.worlds.core.IniFile;
+import NET.worlds.network.NetUpdate;
+import NET.worlds.network.RemoteFileConst;
+import NET.worlds.network.URL;
+import NET.worlds.scape.FrameEvent;
+import NET.worlds.scape.Pilot;
+import NET.worlds.scape.Restorer;
+import NET.worlds.scape.Room;
+import NET.worlds.scape.Saver;
+import NET.worlds.scape.TeleportAction;
+import NET.worlds.scape.TeleportStatus;
+import NET.worlds.scape.World;
+import java.awt.Container;
+import java.awt.Event;
+import java.awt.Font;
+import java.awt.Menu;
+import java.awt.MenuItem;
+import java.awt.PopupMenu;
+import java.io.File;
+import java.util.Hashtable;
+import java.util.Locale;
+import java.util.Vector;
+
+public class WorldsMarkPart implements FramePart, DialogReceiver, TeleportStatus, RemoteFileConst {
+   private static final String worldsMarksFileName = "Gamma.worldsmarks";
+   private static final int MAX_HISTORY = 10;
+   private static URL userMarksURL = URL.make("home:Gamma.worldsmarks");
+   private String name;
+   private Menu menu;
+   private Menu letsMenu;
+   private MenuItem addItem = new MenuItem(Console.message("Add-WorldsMark"));
+   private MenuItem deleteItem = new MenuItem(Console.message("Delete-WorldsMark"));
+   private MenuItem editItem = new MenuItem(Console.message("Edit-WorldsMark"));
+   private MenuItem locationItem = new MenuItem(Console.message("Change-Location"));
+   private Menu historyMenu = new Menu(Console.message("Back"));
+   private static Font font;
+   private boolean teleporting = false;
+   private boolean startLocationDialog = false;
+   static Vector<String> systemMarksNames;
+   private static Vector<Vector<BookmarkMenuItem>> systemMarks;
+   private static Vector<BookmarkMenuItem> userMarks;
+   private static Vector<BookmarkMenuItem> historyItems;
+   private static int firstUserItem;
+   private static Hashtable<String, String> renamed;
+   private static Vector<String> excludes;
+   private static Vector<String> sequence;
+
+   static {
+      Locale currentLocale = Locale.getDefault();
+      System.out.println("System Locale is " + currentLocale);
+      String defLang = IniFile.gamma().getIniString("DEFAULTLANGUAGE", "");
+      if (!defLang.equals("")) {
+         String code1 = null;
+         String code2 = null;
+         if (defLang.length() >= 2) {
+            code1 = defLang.substring(0, 2);
+         }
+
+         if (defLang.length() >= 5) {
+            code2 = defLang.substring(3, 5);
+         }
+
+         if (code1 != null && code2 != null) {
+            Locale.setDefault(new Locale(code1, code2));
+            currentLocale = Locale.getDefault();
+            System.out.println("New Locale is " + currentLocale);
+         } else {
+            System.out.println("ERROR: DEFAULTLANGUAGE mustbe in the form xx_XX");
+         }
+      }
+
+      font = new Font(Console.message("MenuFont"), 0, 12);
+      historyItems = new Vector<BookmarkMenuItem>();
+      historyItems.addElement(new BookmarkMenuItem(Console.message("end-of-last"), "world:restart"));
+      renamed = new Hashtable<String, String>();
+      renamed.put("lets", "Hang");
+      renamed.put("worldschat", "WorldsCenter");
+      renamed.put("polygram", "WorldsStore.com");
+      renamed.put("stadium", "NY Yankees");
+      renamed.put("bowie", "Bowie I");
+      renamed.put("texas", "Texas");
+      renamed.put("hanson", "Hanson I");
+      excludes = new Vector<String>();
+      excludes.addElement("funhouse");
+      excludes.addElement("chaos");
+      sequence = new Vector<String>();
+      sequence.addElement(getFirstWorld().toLowerCase());
+      sequence.addElement("avatargallery");
+      sequence.addElement("dressingroom");
+   }
+
+   public WorldsMarkPart() {
+      this(null);
+   }
+
+   public WorldsMarkPart(String name) {
+      this.name = name;
+   }
+
+   public boolean isTeleporting() {
+      return this.teleporting;
+   }
+
+   public static String getExternalName(String name) {
+      String extName = renamed.get(name.toLowerCase());
+      return extName != null ? extName : name;
+   }
+
+   public Menu getMenu() {
+      if (this.menu == null) {
+         if (this.name != null) {
+            this.menu = new Menu(this.name);
+         } else {
+            this.menu = new PopupMenu();
+         }
+
+         this.letsMenu = new PopupMenu();
+         this.historyMenu.setFont(font);
+         this.letsMenu.add(this.historyMenu);
+         this.letsMenu.addSeparator();
+         if (userMarks == null) {
+            loadMarks();
+         }
+
+         if (systemMarks.size() != 0) {
+            for (int i = 0; i < systemMarks.size(); i++) {
+               String subName = systemMarksNames.elementAt(i);
+               Menu subMenu = new Menu(getExternalName(subName));
+               addItems(subMenu, systemMarks.elementAt(i));
+               subMenu.setFont(font);
+               this.letsMenu.add(subMenu);
+            }
+         }
+
+         this.addMainMenuItem(this.addItem);
+         this.addMainMenuItem(this.deleteItem);
+         this.addMainMenuItem(this.editItem);
+         this.addMainMenuItem(this.locationItem);
+         this.addMainMenuSeparator();
+         addItems(this.menu, userMarks);
+         addItems(this.historyMenu, historyItems);
+      }
+
+      return this.menu;
+   }
+
+   public Menu getLetsMenu() {
+      if (this.letsMenu == null) {
+         this.getMenu();
+      }
+
+      return this.letsMenu;
+   }
+
+   public static PopupMenu getPackageMenu(String pname) {
+      int p = findPackageNum(pname);
+      if (p < 0) {
+         return null;
+      } else {
+         PopupMenu m = new PopupMenu();
+         Vector<BookmarkMenuItem> v = systemMarks.elementAt(p);
+
+         for (int i = 0; i < v.size(); i++) {
+            MenuItem mi = v.elementAt(i);
+            if (mi instanceof BookmarkMenuItem) {
+               BookmarkMenuItem bmi = v.elementAt(i);
+               String name = bmi.getLabel();
+               String targ = bmi.getTarget();
+               URL u = URL.make(TeleportAction.toURLString(targ));
+               String pkg = TeleportAction.getPackageNameOfWorld(u);
+               if (pkg != null && findPackage(pkg) == null) {
+                  String dirName = URL.make("home:" + pkg).unalias();
+                  if (!new File(dirName).isDirectory()) {
+                     name = "Download " + name;
+                  }
+               }
+
+               m.add(new BookmarkMenuItem(name, targ));
+            }
+         }
+
+         boolean isFirst = true;
+
+         for (int ix = 0; ix < userMarks.size(); ix++) {
+            URL u = URL.make(TeleportAction.toURLString(getBookmarkTarget(ix)));
+            String s = TeleportAction.getPackageNameOfWorld(u);
+            if (s != null && s.equalsIgnoreCase(pname)) {
+               if (isFirst) {
+                  isFirst = false;
+                  m.addSeparator();
+               }
+
+               BookmarkMenuItem item = new BookmarkMenuItem(getBookmarkName(ix), getBookmarkTarget(ix));
+               m.add(item);
+            }
+         }
+
+         return m;
+      }
+   }
+
+   private static void addItems(Menu m, Vector<BookmarkMenuItem> v) {
+      for (int i = 0; i < v.size(); i++) {
+         MenuItem mItem = v.elementAt(i);
+         mItem.setFont(font);
+         m.add(mItem);
+      }
+   }
+
+   private void addMainMenuItem(MenuItem item) {
+      item.setFont(font);
+      this.menu.add(item);
+      firstUserItem++;
+   }
+
+   private void addMainMenuSeparator() {
+      this.menu.addSeparator();
+      firstUserItem++;
+   }
+
+   public static String getFirstWorld() {
+      IniFile ini = new IniFile("InstalledWorlds");
+      return ini.getIniString("InstalledWorld0", "");
+   }
+
+   public static String getFirstSystemMarkURL() {
+      if (userMarks == null) {
+         loadMarks();
+      }
+
+      for (int i = 0; i < systemMarks.size(); i++) {
+         Vector<BookmarkMenuItem> v = systemMarks.elementAt(i);
+         if (v.size() > 0) {
+            return v.elementAt(0).getTarget();
+         }
+      }
+
+      int j = 0;
+      return j < userMarks.size() ? userMarks.elementAt(j).getTarget() : null;
+   }
+
+   private static void shortenNames(String prefix, Vector<BookmarkMenuItem> v) {
+      int count = v.size();
+      int pfxlen = prefix.length();
+
+      for (int i = 0; i < count; i++) {
+         MenuItem item = v.elementAt(i);
+         String label = item.getLabel();
+         if (label.startsWith(prefix)) {
+            item.setLabel(label.substring(pfxlen).trim());
+         }
+      }
+   }
+
+   private static int findPackageNum(String pname) {
+      Vector<String> v = systemMarksNames;
+      if (v != null) {
+         int i = v.size();
+
+         while (--i >= 0) {
+            String s = v.elementAt(i);
+            if (s.equalsIgnoreCase(pname)) {
+               return i;
+            }
+         }
+      }
+
+      return -1;
+   }
+
+   public static String findPackage(String pname) {
+      int i = findPackageNum(pname);
+      return i < 0 ? null : systemMarksNames.elementAt(i);
+   }
+
+   private static void loadMarks() {
+      systemMarks = new Vector<Vector<BookmarkMenuItem>>();
+      systemMarksNames = new Vector<String>();
+      IniFile ini = new IniFile("InstalledWorlds");
+      String[] sequenced = new String[sequence.size()];
+
+      for (int count = 0; count < NetUpdate.maxInstalledWorlds(); count++) {
+         String curvalue = ini.getIniString("InstalledWorld" + count, "");
+         if (!curvalue.equals("")) {
+            NetUpdate.maxInstalledWorld(count);
+            String pkgLower = curvalue.toLowerCase();
+            if (!excludes.contains(pkgLower) && (!pkgLower.equals("polygram") || !World.isWorldsStoreProscribed())) {
+               int index = sequence.indexOf(pkgLower);
+               if (index != -1) {
+                  sequenced[index] = curvalue;
+               } else {
+                  systemMarksNames.addElement(curvalue);
+               }
+            }
+         }
+      }
+
+      for (int i = sequenced.length - 1; i >= 0; i--) {
+         if (sequenced[i] != null) {
+            systemMarksNames.insertElementAt(sequenced[i], 0);
+         }
+      }
+
+      int ix = 0;
+
+      while (ix < systemMarksNames.size()) {
+         String worldName = systemMarksNames.elementAt(ix);
+         Vector<BookmarkMenuItem> v = (Vector<BookmarkMenuItem>)loadVector(URL.make("home:" + worldName + "/" + "Gamma.worldsmarks"));
+         if (v.size() != 0) {
+            shortenNames(worldName, v);
+            systemMarks.addElement(v);
+            ix++;
+         } else {
+            systemMarksNames.removeElementAt(ix);
+         }
+      }
+
+      userMarks = (Vector<BookmarkMenuItem>)loadVector(userMarksURL);
+   }
+
+   private static Vector<?> loadVector(URL url) {
+      Vector<?> v = null;
+
+      try {
+         Restorer r = new Restorer(url);
+         v = r.restoreVector();
+         r.done();
+      } catch (Exception var3) {
+         if (v != null) {
+            saveVector(url, (Vector<BookmarkMenuItem>)v);
+         } else {
+            v = new Vector();
+         }
+      }
+
+      return v;
+   }
+
+   private static void saveMarks() {
+      saveVector(userMarksURL, userMarks);
+   }
+
+   private static void saveVector(URL url, Vector<BookmarkMenuItem> v) {
+      try {
+         Saver s = new Saver(url);
+         s.saveVector(v);
+         s.done();
+      } catch (Exception var3) {
+      }
+   }
+
+   static void gotoBookmark(int index) {
+      TeleportAction.teleport(getBookmarkTarget(index), null);
+   }
+
+   static int getBookmarkCount() {
+      return userMarks.size();
+   }
+
+   private static BookmarkMenuItem getBookmark(int index) {
+      return userMarks.elementAt(index);
+   }
+
+   static String getBookmarkName(int index) {
+      return getBookmark(index).getLabel();
+   }
+
+   static String getBookmarkTarget(int index) {
+      return getBookmark(index).getTarget();
+   }
+
+   void addBookmark(String name, String target) {
+      BookmarkMenuItem item = new BookmarkMenuItem(name, target);
+      this.menu.add(item);
+      userMarks.addElement(item);
+      saveMarks();
+   }
+
+   void removeBookmark(int index) {
+      userMarks.removeElementAt(index);
+      this.menu.remove(index + firstUserItem);
+      saveMarks();
+   }
+
+   void changeBookmark(int index, String name, String target) {
+      BookmarkMenuItem item = getBookmark(index);
+      item.setLabel(name);
+      item.setTarget(target);
+      saveMarks();
+   }
+
+   @Override
+   public void dialogDone(Object who, boolean confirmed) {
+      if (confirmed) {
+         if (who instanceof LocationDialog) {
+            LocationDialog locationDialog = (LocationDialog)who;
+            String location = locationDialog.getLocationURL();
+            if (location.length() != 0) {
+               TeleportAction.teleport(location, null);
+            }
+         } else {
+            BookmarkAddDialog adder = (BookmarkAddDialog)who;
+            BookmarkEditDialog editor = adder.getEditor();
+            this.addBookmark(editor.getName(), editor.getTarget());
+         }
+      }
+   }
+
+   private static BookmarkMenuItem getHistory(int index) {
+      return historyItems.elementAt(index);
+   }
+
+   private static BookmarkMenuItem getItemFromTarget(String target, Vector<BookmarkMenuItem> vec) {
+      for (int i = 0; i < vec.size(); i++) {
+         BookmarkMenuItem item = vec.elementAt(i);
+         if (item.getTarget().equals(target)) {
+            return item;
+         }
+      }
+
+      return null;
+   }
+
+   private static BookmarkMenuItem getItemFromName(String name, Vector<BookmarkMenuItem> vec) {
+      for (int i = 0; i < vec.size(); i++) {
+         BookmarkMenuItem item = vec.elementAt(i);
+         if (item.getLabel().equals(name)) {
+            return item;
+         }
+      }
+
+      return null;
+   }
+
+   private static String getWorldName(String url) {
+      int rindex = url.toLowerCase().lastIndexOf(".world");
+      int windex;
+      return rindex == -1 || (windex = url.lastIndexOf(47, rindex)) == -1 && (windex = url.lastIndexOf(58, rindex)) == -1
+         ? null
+         : url.substring(windex + 1, rindex);
+   }
+
+   public static String getCurrentPackageName() {
+      Pilot pilot = Pilot.getActive();
+      if (pilot == null) {
+         return null;
+      } else {
+         World world = pilot.getWorld();
+         if (world == null) {
+            return null;
+         } else {
+            URL url = world.getSourceURL();
+            return url == null ? null : TeleportAction.getPackageNameOfWorld(url);
+         }
+      }
+   }
+
+   private static String getCurrentURLName() {
+      String name = "";
+      Pilot pilot = Pilot.getActive();
+      if (pilot != null) {
+         World world = pilot.getWorld();
+         if (world != null) {
+            URL url = world.getSourceURL();
+            if (url != null) {
+               String worldFileName = getWorldName(url.getAbsolute());
+               if (worldFileName != null) {
+                  name = worldFileName;
+               }
+            }
+
+            String worldName = world.getName();
+            if (worldName != null) {
+               if (!name.equals("")) {
+                  name = name + " ";
+               }
+
+               name = name + worldName;
+            }
+
+            Room room = pilot.getRoom();
+            if (room != null) {
+               String roomName = room.getName();
+               if (roomName != null) {
+                  if (!name.equals("")) {
+                     name = name + " ";
+                  }
+
+                  name = name + roomName;
+               }
+            }
+         }
+      }
+
+      return name;
+   }
+
+   static String getCurrentPositionName() {
+      return getCurrentPositionName(userMarks);
+   }
+
+   static String getCurrentPositionName(Vector<BookmarkMenuItem> v) {
+      String position = getCurrentPositionURL(false);
+      int count = systemMarks.size();
+
+      for (int i = 0; i < count; i++) {
+         BookmarkMenuItem item;
+         if ((item = getItemFromTarget(position, systemMarks.elementAt(i))) != null) {
+            return systemMarksNames.elementAt(i) + " " + item.getLabel();
+         }
+      }
+
+      BookmarkMenuItem item;
+      if ((item = getItemFromTarget(position, userMarks)) == null && (item = getItemFromTarget(position, historyItems)) == null) {
+         String defaultName = getCurrentURLName();
+         String name = defaultName;
+         int number = 1;
+
+         while (getItemFromName(name, v) != null) {
+            name = defaultName + "-" + ++number;
+         }
+
+         return name;
+      } else {
+         return item.getLabel();
+      }
+   }
+
+   static String getCurrentPositionURL(boolean mustHaveChannel) {
+      Pilot pilot = Pilot.getActive();
+      if (pilot == null) {
+         return "";
+      } else {
+         String newURL = pilot.getURL();
+         if (newURL == null) {
+            return "";
+         } else {
+            if (!mustHaveChannel) {
+               int dynamicChannelIndex = newURL.indexOf("<dimension-");
+               if (dynamicChannelIndex < 0) {
+                  dynamicChannelIndex = newURL.indexOf("<>@");
+               }
+
+               int channelEndIndex = newURL.indexOf(">@");
+               if (dynamicChannelIndex > 0 && dynamicChannelIndex < channelEndIndex) {
+                  newURL = newURL.substring(0, dynamicChannelIndex) + newURL.substring(channelEndIndex + 1);
+               }
+            }
+
+            return newURL;
+         }
+      }
+   }
+
+   @Override
+   public void teleportStatus(String err, String url) {
+      this.teleporting = err != null && err.length() == 0;
+      if (err == null) {
+         url = getCurrentPositionURL(true);
+         if (url.length() == 0) {
+            return;
+         }
+
+         Menu menu = this.getMenu();
+
+         for (int i = 0; i < historyItems.size(); i++) {
+            if (getHistory(i).getTarget().equals(url)) {
+               historyItems.removeElementAt(i);
+               this.historyMenu.remove(i);
+               break;
+            }
+         }
+
+         BookmarkMenuItem item = new BookmarkMenuItem(getCurrentPositionName(historyItems), url);
+         historyItems.insertElementAt(item, 0);
+         this.historyMenu.insert(item, 0);
+
+         while (historyItems.size() > 10) {
+            historyItems.removeElementAt(10);
+            this.historyMenu.remove(10);
+         }
+      }
+   }
+
+   @Override
+   public void activate(Console c, Container f, Console prev) {
+   }
+
+   @Override
+   public void deactivate() {
+      if (this.menu != null) {
+         this.menu.removeAll();
+      }
+
+      this.menu = null;
+      this.letsMenu = null;
+      firstUserItem = 0;
+   }
+
+   @Override
+   public boolean action(Event event, Object what) {
+      Object target = event.target;
+      if (this.menu != null) {
+         if (target == this.addItem) {
+            if (Pilot.getActive().getRoom().getAllowTeleport()) {
+               new BookmarkAddDialog(Console.getFrame(), this);
+            } else {
+               Console.println(Console.message("no-teleport"));
+            }
+         } else if (target == this.deleteItem) {
+            new BookmarkDeleteDialog(this);
+         } else if (target == this.editItem) {
+            new BookmarkListDialog(this);
+         } else if (target == this.locationItem) {
+            this.startLocationDialog = true;
+         } else {
+            if (!(target instanceof BookmarkMenuItem)) {
+               return false;
+            }
+
+            TeleportAction.teleport(((BookmarkMenuItem)target).getTarget(), null);
+         }
+
+         return true;
+      } else {
+         return false;
+      }
+   }
+
+   @Override
+   public boolean handle(FrameEvent f) {
+      if (this.startLocationDialog) {
+         this.startLocationDialog = false;
+         String url = "";
+         Pilot pilot = Pilot.getActive();
+         if (pilot != null) {
+            url = pilot.getURL();
+         }
+
+         new LocationDialog(Console.getFrame(), this, Console.message("Change-Location"), url);
+      }
+
+      return true;
+   }
+}