package NET.worlds.scape;

import NET.worlds.console.Console;
import NET.worlds.console.Gamma;
import NET.worlds.console.RightMenu;
import NET.worlds.core.IniFile;
import NET.worlds.core.Std;
import NET.worlds.network.NetworkObject;
import NET.worlds.network.URL;
import NET.worlds.network.WorldServer;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Vector;

public class WObject extends Transform implements Prerenderable {
   private boolean mouseOver = false;
   private String _toolTipText;
   private Vector<WObject> contents = null;
   private Shadow shadow;
   public static boolean shadowsOn = IniFile.gamma().getIniInt("shadows", 0) != 0;
   protected boolean discarded = false;
   protected int clumpID;
   protected int highlightID = 0;
   protected static final int isVisibleMask = 1;
   protected static final int isBumpableMask = 2;
   protected static final int isHologramRoughCutMask = 4;
   protected static final int isMirrored = 4;
   protected static final int isOptimizableMask = 8;
   protected static final int isDrawFirstOnIntersectionMask = 16;
   protected static final int isDrawOrderUnimportantMask = 32;
   protected static final int isMaterialVisible = 64;
   protected static final int isHighlitMask = 128;
   protected static final int isAutoGapMask = 256;
   protected static final int isAutoGapFromLocalMask = 512;
   protected static final int isDisablePixelDoublingMask = 1024;
   protected static final int isSharerMode0 = 2048;
   protected static final int isSharerMode1 = 4096;
   protected static final int isSharerMode2 = 8192;
   protected static final int duringRestore = 16384;
   protected static final int isShadowedLocally = 32768;
   protected static final int isShadowed = 65536;
   protected static final int isAutobuiltMask = 131072;
   protected static final int isHologramViewplaneAlignedMask = 262144;
   protected static final int isDontConnect = 262144;
   protected static final int isSurfaceUFlippedMask = 524288;
   protected static final int isSurfaceVFlippedMask = 1048576;
   protected static final int isReclumpingMask = 2097152;
   protected static final int isHologramAutosize = 4194304;
   protected int flags = 3;
   Vector<Object> eventHandlers;
   protected Vector<Action> actions = null;
   protected BumpCalc bumpCalc = null;
   static BumpCalc standardBoxBumpCalc = new BoxBumpCalc();
   private static Object classCookie = new Object();
   public static boolean replaceWithMontyDoor = IniFile.gamma().getIniInt("replaceWithMontyDoor", 0) != 0;
   private Sharer _sharer = null;
   public VisiAttribute _visibilityAttribute;
   public TransAttribute _transformAttribute;
   public BumpAttribute _bumpableAttribute;

   static {
      nativeInit();
      standardBoxBumpCalc.setName("defaultBoxBumpCalc");
   }

   public static native void nativeInit();

   public boolean getMouseOver() {
      if (this.mouseOver) {
         return true;
      } else {
         WObject obj;
         try {
            obj = (WObject)this.getOwner();
         } catch (ClassCastException var3) {
            return false;
         }

         return obj == null ? false : obj.getMouseOver();
      }
   }

   public void setMouseOver(boolean m) {
      this.mouseOver = m;
   }

   public String getToolTipText() {
      if (this._toolTipText != null) {
         return this._toolTipText;
      } else {
         WObject obj;
         try {
            obj = (WObject)this.getOwner();
         } catch (ClassCastException var3) {
            return null;
         }

         return obj == null ? null : obj.getToolTipText();
      }
   }

   public void setToolTipText(String newText) {
      this._toolTipText = newText;
   }

   @Override
   public void setName(String v) {
      super.setName(this.getBangName(v));
   }

   private String getBangName(String s) {
      boolean hasBang = s.startsWith("!");
      if (hasBang != this.isDynamic()) {
         return hasBang ? s.substring(1) : "!" + s;
      } else {
         return s;
      }
   }

   @Override
   public void markEdited() {
      if (!this.isDynamic()) {
         super.markEdited();
      }
   }

   @Override
   public void getChildren(DeepEnumeration d) {
      if (this.contents != null) {
         d.addChildVector(this.contents);
      }

      if (this.eventHandlers != null) {
         d.addChildVector(this.eventHandlers);
      }

      if (this.actions != null) {
         d.addChildVectorAction(this.actions);
      }

      if (this._sharer != null) {
         d.addChildElement(this._sharer);
      }
   }

   public void add(WObject child) {
      super.add(child);
      if (this.hasClump()) {
         child.recursiveAddRwChildren(this);
      }

      if (child._sharer != null) {
         child._sharer.adjustShare();
      }

      if (this.contents == null) {
         this.contents = new Vector<WObject>();
      }

      this.contents.addElement(child);
   }

   public Enumeration<?> getContents() {
      return this.contents == null ? new Vector().elements() : this.contents.elements();
   }

   public boolean hasContents() {
      return this.contents != null;
   }

   public boolean contentsContain(WObject w) {
      return this.contents == null ? false : this.contents.contains(w);
   }

   @Override
   protected void noteUnadding(SuperRoot child) {
      if (this.contents != null && this.contents.removeElement(child) && this.contents.size() == 0) {
         this.contents = null;
      }
   }

   public void makeShadow() {
      assert this.shadow == null;

      this.shadow = new DiskShadow(this);
   }

   @Override
   public void detach() {
      if (this.clumpID != 0) {
         this.markVoid();
      }

      super.detach();
      if (this._sharer != null) {
         this._sharer.adjustShare();
      }

      if (this.shadow != null) {
         this.shadow.adjustShadow(this);
         this.shadow = null;
      }
   }

   @Override
   public void discard() {
      super.discard();
      this.discarded = true;
      if (this.contents != null) {
         int i = this.contents.size();

         while (--i >= 0) {
            this.contents.elementAt(i).discard();
         }
      }

      if (this.eventHandlers != null) {
         int i = this.eventHandlers.size();

         while (--i >= 0) {
            this.removeHandler((SuperRoot)this.eventHandlers.elementAt(i));
         }
      }

      if (this.actions != null) {
         int i = this.actions.size();

         while (--i >= 0) {
            this.removeAction(this.actions.elementAt(i));
         }
      }

      this.releaseAuxilaryData();
   }

   @Override
   protected void finalize() {
      if (!this.discarded) {
         this.releaseAuxilaryData();
      }

      super.finalize();
   }

   public void reclump() {
      if (this.clumpID != 0) {
         assert (this.flags & 2097152) == 0;

         this.flags |= 2097152;
         this.markVoid();
         this.recursiveAddRwChildren((WObject)this.getOwner());

         assert (this.flags & 2097152) != 0;

         this.flags &= -2097153;
      }
   }

   public boolean isReclumping() {
      return (this.flags & 2097152) != 0;
   }

   @Override
   protected void noteTransformChange() {
      this.setClumpMatrix();
      this.updateHighlight();
      if (this.shadow != null) {
         this.shadow.adjustShadow(this);
      }

      if (this._transformAttribute != null) {
         this._transformAttribute.noteChange();
      }
   }

   protected void markVoid() {
      if (this.contents != null) {
         int i = this.contents.size();

         while (--i >= 0) {
            this.contents.elementAt(i).markVoid();
         }
      }

      Room r = this.getRoomFromClump();
      if (this instanceof FrameHandler) {
         r.removeFrameHandler((FrameHandler)this, this);
      }

      if (this.eventHandlers != null) {
         int i = this.eventHandlers.size();

         while (--i >= 0) {
            Object f = this.eventHandlers.elementAt(i);
            if (f instanceof FrameHandler) {
               r.removeFrameHandler((FrameHandler)f, this);
            }
         }
      }

      this.voidClump();
      if (this.shadow != null) {
         this.shadow.adjustShadow(this);
      }
   }

   protected void addRwChildren(WObject parent) {
      this.addNewRwChild(parent);
   }

   public void recursiveAddRwChildren(WObject parent) {
      this.addRwChildren(parent);
      if (this.contents != null) {
         int end = this.contents.size();

         for (int i = 0; i < end; i++) {
            this.contents.elementAt(i).recursiveAddRwChildren(this);
         }
      }
   }

   protected final void addNewRwChild(WObject container) {
      assert this.clumpID == 0;

      this.createClump();
      this.newRwClumpChildHelper(container);
   }

   protected void newRwClumpChildHelper(WObject container) {
      assert container != null;

      this.addChildToClump(container);
      this.newRwChildHelper();
      if (!this.getVisible()) {
         this.updateVisible();
      }

      if (this.shadow != null) {
         this.shadow.adjustShadow(this);
      } else {
         if (this.getShadowedLocally() ? !this.getLocalShadowed() : !shadowsOn) {
            return;
         }

         if (this.inRoomContents() && this.getOwner() instanceof Room) {
            this.makeShadow();
         }
      }
   }

   protected void newRwChildHelper() {
      this.initClumpData();
      this.setClumpMatrix();
      Room r = this.getRoom();
      if (this instanceof FrameHandler) {
         r.addFrameHandler((FrameHandler)this, this);
      }

      if (this.eventHandlers != null) {
         for (int i = 0; i < this.eventHandlers.size(); i++) {
            Object f = this.eventHandlers.elementAt(i);
            if (f instanceof FrameHandler) {
               r.addFrameHandler((FrameHandler)f, this);
            }
         }
      }
   }

   native void createClump();

   public final boolean hasClump() {
      return this.clumpID != 0;
   }

   public final int getID() {
      return this.clumpID;
   }

   public native boolean nativeInCamSpace(Camera var1, Point3Temp var2);

   public Point3Temp inCamSpace(Camera cam) {
      Point3Temp p = Point3Temp.make();
      return this.nativeInCamSpace(cam, p) ? p : null;
   }

   protected native void voidClump();

   protected native int extractClump();

   native void addChildToClump(WObject var1);

   native void setClumpMatrix();

   private native void initClumpData();

   native void doneWithEditing();

   native int getNumVerts();

   @Override
   public Transform getObjectToWorldMatrix() {
      if (this.hasClump()) {
         return this.getObjectToWorldMatrix(Transform.make());
      } else {
         Transform t = this.getTransform();
         SuperRoot o = this.getOwner();
         if (o instanceof WObject) {
            Transform ot = ((WObject)o).getObjectToWorldMatrix();
            t.post(ot);
            ot.recycle();
         }

         return t;
      }
   }

   private native Transform getObjectToWorldMatrix(Transform var1);

   protected native Transform getJointedObjectToWorldMatrix(Transform var1);

   public Point3Temp getWorldPosition() {
      Transform t = this.getObjectToWorldMatrix();
      Point3Temp ret = t.getPosition();
      t.recycle();
      return ret;
   }

   public native void updateHighlight();

   public native void getClumpBBox(Point3Temp var1, Point3Temp var2);

   public BoundBoxTemp getClumpBBox() {
      Point3Temp start = Point3Temp.make();
      Point3Temp right = Point3Temp.make();
      this.getClumpBBox(start, right);
      return BoundBoxTemp.make(start, right);
   }

   public WObject setHighlit(boolean b) {
      if (b) {
         this.flags |= 128;
      } else {
         this.flags &= -129;
      }

      this.updateHighlight();
      return this;
   }

   public final boolean getHighlit() {
      return (this.flags & 128) != 0;
   }

   public void setAutobuilt(boolean b) {
      if (b) {
         this.flags |= 131072;
      } else {
         this.flags &= -131073;
      }
   }

   public final boolean getAutobuilt() {
      return (this.flags & 131072) != 0;
   }

   public WObject setOptimizable(boolean b) {
      if (b) {
         this.flags |= 8;
      } else {
         this.flags &= -9;
      }

      return this;
   }

   public final boolean getOptimizable() {
      return (this.flags & 8) != 0;
   }

   final void setSharerMode(int mode) {
      assert mode >= 0 && mode < 8;

      this.flags &= -14337;
      this.flags |= mode << 11;
      this.setName(this.getName());
   }

   final int getSharerMode() {
      return this.flags >>> 11 & 7;
   }

   public final boolean isDynamic() {
      return (this.getSharerMode() & 4) != 0;
   }

   public WObject setLocalAutoGap(boolean b) {
      if (b) {
         this.flags |= 256;
      } else {
         this.flags &= -257;
      }

      if (this instanceof Room) {
         Enumeration<Object> e = this.getDeepOwned();

         while (e.hasMoreElements()) {
            Object o = e.nextElement();
            if (o instanceof WObject) {
               ((WObject)o).noteTransformChange();
            }
         }
      }

      return this;
   }

   public final boolean getLocalAutoGap() {
      return (this.flags & 256) != 0;
   }

   public WObject setAutoGapFromRoom(boolean b) {
      if (b) {
         this.flags &= -513;
      } else {
         this.flags |= 512;
      }

      this.noteTransformChange();
      return this;
   }

   public final boolean getAutoGapFromRoom() {
      return (this.flags & 512) == 0;
   }

   public boolean getAutoGap() {
      return ((WObject)(this.getAutoGapFromRoom() ? this.getRoom() : this)).getLocalAutoGap();
   }

   public void setVisible(boolean b) {
      if (b != this.getVisible()) {
         if (b) {
            this.flags |= 1;
         } else {
            this.flags &= -2;
         }

         this.updateVisible();
         if (this.shadow != null) {
            this.shadow.adjustShadow(this);
         }

         if (this._visibilityAttribute != null) {
            this._visibilityAttribute.noteChange();
         }
      }
   }

   public boolean getLocalShadowed() {
      return (this.flags & 65536) != 0;
   }

   public void setLocalShadowed(boolean b) {
      if (b) {
         this.flags |= 65536;
      } else {
         this.flags &= -65537;
      }
   }

   public boolean getShadowedLocally() {
      return (this.flags & 32768) != 0;
   }

   public void setShadowedLocally(boolean b) {
      if (b) {
         this.flags |= 32768;
      } else {
         this.flags &= -32769;
      }
   }

   protected native void updateVisible();

   public final boolean getVisible() {
      return (this.flags & 1) != 0;
   }

   public WObject setBumpable(boolean b) {
      if (b) {
         this.flags |= 2;
      } else {
         this.flags &= -3;
      }

      if (this._bumpableAttribute != null) {
         this._bumpableAttribute.noteChange();
      }

      return this;
   }

   public final boolean getBumpable() {
      return (this.flags & 2) != 0;
   }

   public boolean deliver(Event event) {
      event.receiver = this;
      boolean delivered = event.deliver(this);
      if (this.eventHandlers != null) {
         Enumeration<Object> e = this.eventHandlers.elements();

         while (e.hasMoreElements()) {
            event.receiver = this;
            if (event.deliver(e.nextElement())) {
               delivered = true;
            }
         }
      }

      if (delivered) {
         return true;
      } else {
         if (event instanceof UserEvent) {
            Object o = this.getOwner();
            if (o instanceof WObject) {
               return ((WObject)o).deliver(event);
            }
         }

         return false;
      }
   }

   public Enumeration<Object> getHandlers() {
      return this.eventHandlers == null ? new Vector<Object>().elements() : this.eventHandlers.elements();
   }

   public boolean hasHandler(SuperRoot h) {
      return this.eventHandlers != null && this.eventHandlers.indexOf(h) != -1;
   }

   public WObject addHandler(SuperRoot h) {
      if (this.eventHandlers == null) {
         this.eventHandlers = new Vector<Object>();
      }

      this.eventHandlers.addElement(h);
      if (this.clumpID != 0 && h instanceof FrameHandler) {
         this.getRoomFromClump().addFrameHandler((FrameHandler)h, this);
      }

      super.add(h);
      return this;
   }

   @Override
   public Room getRoom() {
      return this.clumpID != 0 ? this.getRoomFromClump() : this.getRoomNotFromClump();
   }

   public Room getRoomNotFromClump() {
      SuperRoot o = this.getOwner();
      return o instanceof WObject ? ((WObject)o).getRoomNotFromClump() : null;
   }

   public native Room getRoomFromClump();

   public native boolean inRoomContents();

   @Override
   public World getWorld() {
      if (this.clumpID != 0) {
         return this.getRoomFromClump().getWorld();
      } else {
         Room r = this.getRoomNotFromClump();
         return r == null ? null : r.getWorld();
      }
   }

   @Override
   public boolean isActive() {
      return this.clumpID != 0 ? true : super.isActive();
   }

   public void removeHandler(SuperRoot h) {
      if (this.eventHandlers.contains(h)) {
         h.detach();
         this.eventHandlers.removeElement(h);
         if (this.eventHandlers.size() == 0) {
            this.eventHandlers = null;
         }

         if (this.clumpID != 0 && h instanceof FrameHandler) {
            this.getRoomFromClump().removeFrameHandler((FrameHandler)h, this);
         }
      }
   }

   public Enumeration<Action> getActions() {
      return this.actions == null ? new Vector<Action>().elements() : this.actions.elements();
   }

   public boolean hasActions() {
      return this.actions != null;
   }

   public WObject addAction(Action a) {
      if (this.actions == null) {
         this.actions = new Vector<Action>();
      }

      this.actions.addElement(a);
      super.add(a);
      return this;
   }

   public void removeAction(Action a) {
      assert a.getOwner() == this;

      a.detach();
      this.actions.removeElement(a);
      if (this.actions.size() == 0) {
         this.actions = null;
      }
   }

   public void rightMenu() {
      new RightMenu(this, this.getActions());
   }

   public void doAction(String actionLabel, Event evt) {
      if (actionLabel != null && !actionLabel.equals("")) {
         if (Gamma.getShaper() != null && actionLabel.equals("Edit Properties...")) {
            Console.getFrame().getEditTile().viewProperties(this);
         } else if (this.actions != null) {
            int i = 0;

            while (i < this.actions.size()) {
               Action candidate = this.actions.elementAt(i);
               i++;
               if (actionLabel.equals(candidate.rightMenuLabel)) {
                  RunningActionHandler.trigger(candidate, this.getWorld(), evt);
               }
            }
         }
      }
   }

   public WObject setBumpCalc(BumpCalc b) {
      if (this.bumpCalc != null) {
         this.bumpCalc.detach();
      }

      this.bumpCalc = b;
      if (this.bumpCalc != null) {
         super.add(this.bumpCalc);
      }

      return this;
   }

   public BumpCalc getBumpCalc(BumpEventTemp b) {
      return this.bumpCalc == null ? standardBoxBumpCalc : this.bumpCalc;
   }

   public Point3Temp getPlaneExtent() {
      return Point3Temp.make();
   }

   public BoundBoxTemp getBoundBox() {
      if (this.getVisible()) {
         return this.getClumpBBox();
      } else {
         Transform xfrm = this.getObjectToWorldMatrix();
         BoundBoxTemp ret = BoundBoxTemp.make(xfrm.getPosition(), this.getPlaneExtent().times(xfrm));
         xfrm.recycle();
         return ret;
      }
   }

   public float getMinXYExtent() {
      if (this.getVisible()) {
         return this.getClumpMinXYExtent();
      } else {
         BoundBoxTemp box = this.getBoundBox();
         float x = box.hi.x - box.lo.x;
         float y = box.hi.y - box.lo.y;
         return x < y ? x : y;
      }
   }

   public native float getClumpMinXYExtent();

   public void detectBump(BumpEventTemp b) {
      BoundBoxTemp box = this.getBoundBox();
      if (!box.isEmpty() && b.bound.overlaps(box)) {
         this.getBumpCalc(b).detectBump(b, this);
      }

      if (this.contents != null) {
         int i = this.contents.size();

         while (--i >= 0) {
            WObject w = this.contents.elementAt(i);
            if (w.getBumpable() && b.source != w) {
               w.detectBump(b);
            }
         }
      }
   }

   public void premoveThrough(Point3Temp motion) {
      Point3Temp pos = this.getPosition();
      this.moveThrough(Point3Temp.make(motion).times(this).minus(pos));
   }

   public void moveThrough(Point3Temp motion) {
      if (this.getRoom() == null || !this.getBumpable()) {
         this.moveBy(motion);
      } else if (this.getRoom().hasClump()) {
         int now = Std.getRealTime();
         WObject me = this;

         for (int loopCount = 4; loopCount > 0; loopCount--) {
            BumpEventTemp be = BumpEventTemp.make(now, me, motion);

            try {
               if (be.target == null) {
                  me.moveBy(be.fullPath);
                  break;
               }

               be.postBumpRoom = me.getRoom();
               be.postBumpPosition = me.getObjectToWorldMatrix().moveBy(be.path);
               be.postBumpPath = Point3Temp.make(be.fullPath).times(1.0F - be.fraction);
               Transform t = me.getTransform();

               try {
                  Room r = this.getRoom();
                  be.target.deliver(be);
                  me.deliver(be);
                  if (!me.isTransformEqual(t) || r != this.getRoom()) {
                     break;
                  }
               } finally {
                  t.recycle();
               }

               Transform invPos = be.postBumpRoom.getObjectToWorldMatrix();
               invPos.invert();
               if (me.getRoom() != be.postBumpRoom) {
                  invPos.pre(be.postBumpPosition);
                  me = me.changeRoom(be.postBumpRoom, invPos);
                  if (me == null) {
                     break;
                  }
               } else {
                  me.makeIdentity();
                  me.pre(invPos);
                  me.pre(be.postBumpPosition);
               }

               be.postBumpPosition.recycle();
               be.postBumpPosition = null;
               invPos.recycle();
               motion = be.postBumpPath;
            } finally {
               be.recycle();
            }
         }
      }
   }

   protected WObject changeRoom(Room newRoom, Transform invPos) {
      this.detach();
      newRoom.add(this);
      this.makeIdentity();
      this.pre(invPos);
      return this;
   }

   @Override
   public Object properties(int index, int offset, int mode, Object value) throws NoSuchPropertyException {
      Object ret = null;
      switch (index - offset) {
         case 0:
            if (mode == 0) {
               ret = PropAdder.make(new VectorProperty(this, index, "Contents"));
            } else if (mode == 1) {
               if (this.contents != null) {
                  ret = this.contents.clone();
               }
            } else if (mode == 4) {
               ((WObject)value).detach();
            } else if (mode == 3) {
               this.add((WObject)value);
            } else if (mode == 5 && value instanceof WObject && !(value instanceof Room)) {
               ret = value;
            }
            break;
         case 1:
            if (mode == 0) {
               ret = PropAdder.make(new VectorProperty(this, index, "Event Handlers"));
            } else if (mode == 1) {
               if (this.eventHandlers != null) {
                  ret = this.eventHandlers.clone();
               }
            } else if (mode == 4) {
               this.removeHandler((SuperRoot)value);
            } else if (mode == 3) {
               this.addHandler((SuperRoot)value);
            } else if (mode == 5 && (value instanceof SwitchableBehavior || value instanceof Sensor)) {
               ret = value;
            }
            break;
         case 2:
            if (mode == 0) {
               ret = PropAdder.make(new VectorProperty(this, index, "Actions"));
            } else if (mode == 1) {
               if (this.actions != null) {
                  ret = this.actions.clone();
               }
            } else if (mode == 4) {
               this.removeAction((Action)value);
            } else if (mode == 3) {
               this.addAction((Action)value);
            } else if (mode == 5 && value instanceof Action) {
               ret = value;
            }
            break;
         case 3:
            if (mode == 0) {
               ret = BooleanPropertyEditor.make(new Property(this, index, "Bumpable"), "No", "Yes");
            } else if (mode == 1) {
               ret = new Boolean(this.getBumpable());
            } else if (mode == 2) {
               this.setBumpable((Boolean)value);
            }
            break;
         case 4:
            if (mode == 0) {
               ret = BooleanPropertyEditor.make(new Property(this, index, "Visible"), "No", "Yes");
            } else if (mode == 1) {
               ret = new Boolean(this.getVisible());
            } else if (mode == 2) {
               this.setVisible((Boolean)value);
            }
            break;
         case 5:
            if (mode == 0) {
               ret = IntegerPropertyEditor.make(new Property(this, index, "Sharing Mode (100 for help)", true));
            } else if (mode == 1) {
               ret = new Integer(this.getSharerMode());
            } else if (mode == 2) {
               int val = (Integer)value;
               if (this instanceof Room && val >= 0 && val <= 5) {
                  Console.println("A Room's sharing mode\nmust be 2, and is\nautomatically set by the shaper.");
               } else if (val != 0 && val != 3 && val != 5) {
                  Console.println("0 = default (chooses 2 or 3 for you)");
                  Console.println("2 = static (stored in .world)");
                  Console.println("3 = forwarded static");
                  Console.println("4 = dynamic (stored only on server)");
                  Console.println("5 = forwarded dynamic");
                  Console.println("Modes 2, and 4, are not generally\nsupported, except that mode 2\nis required for Rooms");
               } else if (val == 5 && this.getSourceURL() == null) {
                  Console.println("Only WObjects read from files may be forwarded dynamic.");
               } else {
                  this.getSharer().setMode(val);
               }
            }
            break;
         case 6:
            if (mode == 0) {
               ret = PropAdder.make(new VectorProperty(this, index, "Shared Attributes"));
            } else if (mode == 1) {
               if (this._sharer != null) {
                  ret = this._sharer.getAttributesList();
               } else {
                  ret = new Vector();
               }
            } else if (mode == 4) {
               this.removeShareableAttribute((Attribute)value);
            } else if (mode == 3) {
               this.addShareableAttribute((Attribute)value);
            } else if (mode == 5 && value instanceof Attribute) {
               ret = value;
            }
            break;
         case 7:
            if (mode == 0) {
               ret = StringPropertyEditor.make(new Property(this, index, "Tool Tip Text"));
            } else if (mode == 1) {
               ret = this.getToolTipText();
            } else if (mode == 2) {
               this.setToolTipText((String)value);
            }
            break;
         case 8:
            if (mode == 0) {
               ret = BooleanPropertyEditor.make(new Property(this, index, "Mouse Change"), "No", "Yes");
            } else if (mode == 1) {
               ret = new Boolean(this.getMouseOver());
            } else if (mode == 2) {
               this.setMouseOver((Boolean)value);
            }
            break;
         default:
            ret = super.properties(index, offset + 9, mode, value);
      }

      return ret;
   }

   public static void saveUnsharedWObjects(Saver s, Vector<WObject> v) throws IOException {
      int length = 0;
      Enumeration<WObject> en = v.elements();

      while (en.hasMoreElements()) {
         WObject w = en.nextElement();
         if (w instanceof Persister && !(w instanceof NonPersister) && !w.isDynamic()) {
            length++;
         }
      }

      s.saveInt(length);
      en = v.elements();

      while (en.hasMoreElements()) {
         WObject w = en.nextElement();
         if (w instanceof Persister && !(w instanceof NonPersister) && !w.isDynamic()) {
            s.save(w);
         }
      }
   }

   @Override
   public void saveState(Saver s) throws IOException {
      s.saveVersion(10, classCookie);
      super.saveState(s);
      s.saveInt(this.flags & -129);
      if (this.contents == null) {
         s.saveBoolean(false);
      } else {
         s.saveBoolean(true);
         saveUnsharedWObjects(s, this.contents);
      }

      s.saveVectorMaybeNull(this.eventHandlers);
      s.saveVectorMaybeNull(this.actions);
      s.saveMaybeNull(this.bumpCalc);
      if (this._sharer != null && this._sharer.isEmpty()) {
         s.saveMaybeNull(null);
      } else {
         s.saveMaybeNull(this._sharer);
      }

      s.saveString(this.getToolTipText());
      s.saveBoolean(this.getMouseOver());
   }

   @Override
   public void restoreState(Restorer r) throws IOException, TooNewException {
      this.restoreWObjectState(r);
   }

   public void restoreWObjectState(Restorer r) throws IOException, TooNewException {
      Vector<Object> newContents = null;
      Vector<Object> newActions = null;
      Vector<Object> newHandlers = null;
      int vers = r.restoreVersion(classCookie);
      switch (vers) {
         case 0:
            r.setOldFlag();
            super.restoreState(r);
            this.flags = r.restoreInt();
            r.restoreMaybeNull();
            this.flags |= 16384;
            newContents = r.restoreVectorMaybeNull();
            newHandlers = r.restoreVectorMaybeNull();
            newActions = new Vector<Object>();
            break;
         case 1:
            r.setOldFlag();
            super.restoreState(r);
            this.flags = r.restoreInt();
            r.restoreMaybeNull();
            this.flags |= 16384;
            newContents = r.restoreVectorMaybeNull();
            newHandlers = r.restoreVectorMaybeNull();
            newActions = r.restoreVectorMaybeNull();
            break;
         case 2:
            r.setOldFlag();
            super.restoreState(r);
            this.flags = r.restoreInt() | 16384;
            newContents = r.restoreVectorMaybeNull();
            newHandlers = r.restoreVectorMaybeNull();
            newActions = r.restoreVectorMaybeNull();
            break;
         case 3:
            super.restoreState(r);
            this.flags = r.restoreInt() | 16384;
            newContents = r.restoreVectorMaybeNull();
            newHandlers = r.restoreVectorMaybeNull();
            newActions = r.restoreVectorMaybeNull();
            r.restore();
            break;
         case 4:
            super.restoreState(r);
            this.flags = r.restoreInt() | 16384;
            newContents = r.restoreVectorMaybeNull();
            newHandlers = r.restoreVectorMaybeNull();
            newActions = r.restoreVectorMaybeNull();
            r.restore();
            this._sharer = (Sharer)r.restoreMaybeNull();
            break;
         case 5:
         case 7:
         case 8:
            super.restoreState(r);
            this.flags = r.restoreInt() | 16384;
            newContents = r.restoreVectorMaybeNull();
            newHandlers = r.restoreVectorMaybeNull();
            newActions = r.restoreVectorMaybeNull();
            this.setBumpCalc((BumpCalc)r.restoreMaybeNull());
            this._sharer = (Sharer)r.restoreMaybeNull();
            break;
         case 6:
            super.restoreState(r);
            this.flags = r.restoreInt() | 16384;
            newContents = r.restoreVectorMaybeNull();
            newHandlers = r.restoreVectorMaybeNull();
            newActions = r.restoreVectorMaybeNull();
            this.setBumpCalc((BumpCalc)r.restoreMaybeNull());
            this._sharer = (Sharer)r.restoreMaybeNull();
            r.restoreString();
            break;
         case 9:
            super.restoreState(r);
            this.flags = r.restoreInt() | 16384;
            newContents = r.restoreVectorMaybeNull();
            newHandlers = r.restoreVectorMaybeNull();
            newActions = r.restoreVectorMaybeNull();
            this.setBumpCalc((BumpCalc)r.restoreMaybeNull());
            this._sharer = (Sharer)r.restoreMaybeNull();
            this.setToolTipText(r.restoreString());
            break;
         case 10:
            super.restoreState(r);
            this.flags = r.restoreInt() | 16384;
            newContents = r.restoreVectorMaybeNull();
            newHandlers = r.restoreVectorMaybeNull();
            newActions = r.restoreVectorMaybeNull();
            this.setBumpCalc((BumpCalc)r.restoreMaybeNull());
            this._sharer = (Sharer)r.restoreMaybeNull();
            this.setToolTipText(r.restoreString());
            this.setMouseOver(r.restoreBoolean());
            break;
         default:
            throw new TooNewException();
      }

      if (vers < 8) {
         this.flags &= -65;
      }

      if (newContents != null) {
         for (int i = 0; i < newContents.size(); i++) {
            this.add((WObject)newContents.elementAt(i));
         }
      }

      if (newActions != null) {
         for (int i = 0; i < newActions.size(); i++) {
            this.addAction((Action)newActions.elementAt(i));
         }
      }

      if (newHandlers != null) {
         for (int i = 0; i < newHandlers.size(); i++) {
            this.addHandler((SuperRoot)newHandlers.elementAt(i));
         }
      }

      if (this._sharer != null) {
         super.add(this._sharer);
      }
   }

   @Override
   public void postRestore(int version) {
      super.postRestore(version);
      if (version < 7) {
         Enumeration<Object> en = this.getHandlers();

         while (en.hasMoreElements()) {
            SuperRoot h = (SuperRoot)en.nextElement();
            if (h.getOwner() != this) {
               SuperRoot newH = (SuperRoot)h.clone();
               this.eventHandlers.removeElement(h);
               if (this.eventHandlers.size() == 0) {
                  this.eventHandlers = null;
               }

               if (this.clumpID != 0 && h instanceof FrameHandler) {
                  this.getRoomFromClump().removeFrameHandler((FrameHandler)h, this);
               }

               this.addHandler(newH);
            }
         }
      }

      if (replaceWithMontyDoor && this.getClass() == WObject.class) {
         this.replaceMonty();
      }

      if (this._sharer != null) {
         this._sharer.ownerPostRestore();
      }

      this.flags &= -16385;
      if (this.isDynamic()) {
         this.getSharer();
      }
   }

   private void replaceMonty() {
      if (this.actions != null && this.actions.size() == 3 && this.getOwner() instanceof WObject) {
         int stage = 0;

         try {
            if (this.actions.elementAt(0) instanceof SetURLAction) {
               SetURLAction sua = (SetURLAction)this.actions.elementAt(0);
               if (sua._propName.equals("File") && sua._roomName != null) {
                  stage = 1;
                  Object db = this.actions.elementAt(1);
                  Object cancel = this.actions.elementAt(2);
                  if (db instanceof DialogAction && cancel.getClass() == db.getClass() && ((DialogAction)cancel).cancelOnly != ((DialogAction)db).cancelOnly) {
                     if (((DialogAction)db).cancelOnly) {
                        db = cancel;
                     }

                     stage = 2;
                     if (this.actions.elementAt(0) instanceof SetURLAction) {
                        stage = 3;
                        if (this.contents != null
                           && this.contents.size() >= 2
                           && this.contents.size() <= 3
                           && this.contents.elementAt(0).getClass() == Rect.class
                           && this.contents.elementAt(1).getClass() == Portal.class) {
                           stage = 4;
                           boolean isTwoPart = this.contents.size() == 3;
                           Rect top = (Rect)this.contents.elementAt(0);
                           Portal port = (Portal)this.contents.elementAt(1);
                           Rect bottom = null;
                           if (isTwoPart) {
                              if (this.contents.elementAt(2).getClass() != Rect.class) {
                                 return;
                              }

                              bottom = (Rect)this.contents.elementAt(2);
                           }

                           stage = 5;
                           if (top.eventHandlers != null && top.eventHandlers.size() == 1 && top.eventHandlers.elementAt(0).getClass() == ClickSensor.class) {
                              stage = 6;
                              ClickSensor cs = (ClickSensor)top.eventHandlers.elementAt(0);
                              if (cs.countActions() == 1) {
                                 stage = 7;
                                 if (top.actions != null && top.actions.size() == 3 && top.actions.elementAt(2).getClass() == SequenceAction.class) {
                                    stage = 8;
                                    SequenceAction seq = (SequenceAction)top.actions.elementAt(2);
                                    if (seq.actions != null && seq.actions.size() == (isTwoPart ? 9 : 7)) {
                                       stage = 9;
                                       if (port.actions != null && port.actions.size() == 2 && port._farSideRoomName != null && port._farSidePortalName != null
                                          )
                                        {
                                          stage = 10;
                                          URL texture = (isTwoPart ? bottom : top).getMaterial().textureName;
                                          if (texture != null) {
                                             stage = 11;
                                             MontyDoor md = new MontyDoor();
                                             md.setsAvatar = db instanceof SelectAvatarAction;
                                             if (!md.setsAvatar) {
                                                if (!(db instanceof SendURLAction)) {
                                                   return;
                                                }

                                                md.description = ((SendURLAction)db).description;
                                                md.url = ((SendURLAction)db).destination;
                                             } else {
                                                md.url = ((SelectAvatarAction)db).url;
                                             }

                                             stage = 12;
                                             md.viewURL = sua._value;
                                             md.viewName = sua._targetName;
                                             md.setFarSideInfo(null, sua._roomName, port._farSidePortalName);
                                             md.post(port);
                                             md.post(this);
                                             String texName = texture.getInternal();
                                             if (isTwoPart) {
                                                if (!texName.endsWith("b.cmp")) {
                                                   Console.println("Texture: " + texName);
                                                   return;
                                                }

                                                int len = texName.length();
                                                texName = texName.substring(0, len - 5) + "m2v*.mov";
                                             }

                                             stage = 13;
                                             md.setMaterial(new Material(URL.make(texName)));
                                             ((WObject)this.getOwner()).add(md);
                                             this.detach();
                                             port.detach();
                                             md.reset();
                                             stage = 100;
                                          }
                                       }
                                    }
                                 }
                              }
                           }
                        }
                     }
                  }
               }
            }
         } finally {
            if (stage != 100) {
               Console.println("Failed MontyDoor conversion of " + this.getName() + " in stage " + stage + ".\n");
            }
         }
      }
   }

   @Override
   public String toString() {
      String base = this.getName();
      if (!this.isActive()) {
         base = base + "(inactive)";
      }

      base = base + this.toTransformSubstring();
      return this.contents == null ? base : base + this.contents.toString();
   }

   public static String getSaveExtension() {
      return "wob";
   }

   public WObject getServed() {
      int mode = this.getSharerMode();
      if (mode == 0) {
         Sharer s = this.getSharer();
         if (s != null) {
            mode = s.getMode();
         }
      }

      if ((mode & 1) == 0) {
         return this;
      } else {
         SuperRoot r = this.getOwner();
         return r != null && r instanceof WObject ? ((WObject)r).getServed() : null;
      }
   }

   @Override
   public void prerender(Camera cam) {
      WorldScriptManager.getInstance().onPrerender(this, cam);
   }

   public WorldServer getServer() {
      WObject wo = this.getServed();
      NetworkObject no;
      if (wo instanceof Room) {
         no = ((Room)wo).getNetworkRoom();
      } else {
         no = (NetworkObject)wo;
      }

      if (no == null) {
         return null;
      } else {
         assert no != this;

         return no.getServer();
      }
   }

   public Enumeration<Attribute> getAttributes() {
      return this.getSharer().getAttributes();
   }

   public Sharer getSharer() {
      if (this._sharer == null) {
         assert (this.flags & 16384) == 0;

         this._sharer = new Sharer();
         super.add(this._sharer);
      }

      return this._sharer;
   }

   public boolean hasSharer() {
      return this._sharer != null;
   }

   public Attribute getAttribute(int attrID) {
      return this.getSharer().getAttribute(attrID);
   }

   public int addAttribute(Attribute a) {
      return this.getSharer().addAttribute(a);
   }

   public int addShareableAttribute(Attribute a) {
      return this.addAttribute(a);
   }

   public void removeAttribute(Attribute a) {
      this.getSharer().removeAttribute(a);
   }

   public void removeShareableAttribute(Attribute a) {
      this.removeAttribute(a);
   }

   public boolean isShared() {
      return this._sharer != null;
   }

   public void notifyRegister(int wid) {
   }

   public boolean acceptsLeftClicks() {
      return this.getMouseOver();
   }

   public void releaseAuxilaryData() {
      if (this._sharer != null) {
         this._sharer.releaseAuxilaryData();
      }
   }
}