public override Rectangle GetBounds(ObjectEntry obj, Point camera)
{
if (obj.SubType < labels.Length)
return new Rectangle(obj.X + imgs[obj.SubType].X - camera.X, obj.Y + imgs[obj.SubType].Y - camera.Y, imgs[obj.SubType].Width, imgs[obj.SubType].Height);
else
return new Rectangle(obj.X + img.X - camera.X, obj.Y + img.Y - camera.Y, img.Width, img.Height);
}
public override Rectangle Bounds(ObjectEntry obj, Point camera)
{
if (obj.SubType <= 10)
return new Rectangle(obj.X + offsets[obj.SubType].X - camera.X, obj.Y + offsets[obj.SubType].Y - camera.Y, imgs[obj.SubType].Width, imgs[obj.SubType].Height);
else
return new Rectangle(obj.X + offset.X - camera.X, obj.Y + offset.Y - camera.Y, img.Width, img.Height);
}
public override Sprite GetSprite(ObjectEntry obj)
{
byte subtype = obj.SubType;
if (obj.SubType > labels.Length) subtype = 0;
BitmapBits bits = new BitmapBits(imgs[subtype].Image);
bits.Flip(obj.XFlip, obj.YFlip);
return new Sprite(bits, new Point(obj.X + imgs[subtype].Offset.X, obj.Y + imgs[subtype].Offset.Y));
}
public override Sprite GetSprite(ObjectEntry obj)
{
int st = -(((obj.SubType & 0x1F) * img.Width) / 2) + img.X;
List<Sprite> sprs = new List<Sprite>();
for (int i = 0; i < (obj.SubType & 0x1F); i++)
sprs.Add(new Sprite(img.Image, new Point(st + (i * img.Width), img.Y)));
Sprite spr = new Sprite(sprs.ToArray());
spr.Offset = new Point(spr.X + obj.X, spr.Y + obj.Y);
return spr;
}
public override Sprite GetSprite(ObjectEntry obj)
{
int w = ((obj.SubType >> 4) + 1) * 16;
int h = ((obj.SubType & 0xF) + 1) * 16;
BitmapBits bmp = new BitmapBits(w, h);
bmp.DrawRectangle(0x1C, 0, 0, w - 1, h - 1);
Sprite spr = new Sprite(new Sprite(bmp, new Point(-(w / 2), -(h / 2))), img);
spr.Offset = new Point(spr.X + obj.X, spr.Y + obj.Y);
return spr;
}
public override Sprite GetSprite(ObjectEntry obj)
{
int count = Math.Min(6, obj.SubType & 7) + 1;
Size space = Spacing[obj.SubType >> 4];
Point loc = new Point(img.X, img.Y);
List<Sprite> sprs = new List<Sprite>();
for (int i = 0; i < count; i++)
{
sprs.Add(new Sprite(img.Image, loc));
loc += space;
}
Sprite spr = new Sprite(sprs.ToArray());
spr.Offset = new Point(spr.X + obj.X, spr.Y + obj.Y);
return spr;
}
public override Sprite GetSprite(ObjectEntry obj)
{
int length = obj.SubType & 15;
List<Sprite> sprs = new List<Sprite>();
sprs.Add(imgs[2]);
int yoff = 16;
for (int i = 0; i < length; i++)
{
sprs.Add(new Sprite(imgs[1].Image, new Point(imgs[1].X, yoff + imgs[1].Y)));
yoff += 16;
}
yoff -= 8;
sprs.Add(new Sprite(imgs[0].Image, new Point(imgs[0].X, yoff + imgs[0].Y)));
Sprite spr = new Sprite(sprs.ToArray());
spr.Offset = new Point(spr.X + obj.X, spr.Y + obj.Y);
return spr;
}
public override Control CreateInstance(COMRegistry registry, COMCLSIDEntry entry, string strObjName, ObjectEntry pObject)
{
return(new ElevatedFactoryServerTypeViewer(registry, entry, strObjName, pObject.Instance));
}
public override Sprite GetSprite(ObjectEntry obj)
{
Sprite spr = new Sprite(imgs[obj.SubType & 0x1F].Image, imgs[obj.SubType & 0x1F].Offset);
spr.Offset = new Point(obj.X + spr.X, obj.Y + spr.Y);
return spr;
}
public override Rectangle Bounds(ObjectEntry obj, Point camera)
{
return new Rectangle(obj.X + offset.X - camera.X, obj.Y + offset.Y - camera.Y, img.Width, img.Height);
}
public Control CreateInstance(COMRegistry registry, ICOMClassEntry entry, string strObjName, ObjectEntry pObject)
{
return(new PersistStreamTypeViewer(strObjName, pObject.Instance));
}
private static void SetLUPriority(ObjectEntry obj, object value)
{
obj.SubType = (byte)((obj.SubType & ~64) | ((Priority)value == Priority.High ? 64 : 0));
}
public override Rectangle GetBounds(ObjectEntry obj, Point camera)
{
int frame = obj.SubType >> 4;
if (frame > 5) frame = 0;
return new Rectangle(obj.X + imgs[frame].X - camera.X, obj.Y + imgs[frame].Y - camera.Y, imgs[frame].Width, imgs[frame].Height);
}
private static object GetCount(ObjectEntry obj)
{
return(Math.Min(6, obj.SubType & 7) + 1);
}
private static object GetSize(ObjectEntry obj)
{
return (byte)(obj.SubType & 3);
}
private static object GetDirection(ObjectEntry obj)
{
return(obj.SubType >> 4);
}
private static void SetDirection(ObjectEntry obj, object value)
{
obj.SubType = (byte)((obj.SubType & ~0xF0) | (((int)value & 0xF) << 4));
}
private static void SetCount(ObjectEntry obj, object value)
{
obj.SubType = (byte)((obj.SubType & ~7) | (Math.Min((int)value, 7) - 1));
}
/// <devdoc>
/// Stores the given value in the key.
/// </devdoc>
public void SetObject(int key, object value)
{
int index;
short element;
short entryKey = SplitKey(key, out element);
if (!LocateObjectEntry(entryKey, out index))
{
// We must allocate a new entry.
//
if (objEntries != null)
{
ObjectEntry[] newEntries = new ObjectEntry[objEntries.Length + 1];
if (index > 0)
{
Array.Copy(objEntries, 0, newEntries, 0, index);
}
if (objEntries.Length - index > 0)
{
Array.Copy(objEntries, index, newEntries, index + 1, objEntries.Length - index);
}
objEntries = newEntries;
}
else
{
objEntries = new ObjectEntry[1];
Debug.Assert(index == 0, "LocateObjectEntry should have given us a zero index.");
}
objEntries[index].Key = entryKey;
}
// Now determine which value to set.
//
switch (element)
{
case 0:
objEntries[index].Value1 = value;
break;
case 1:
objEntries[index].Value2 = value;
break;
case 2:
objEntries[index].Value3 = value;
break;
case 3:
objEntries[index].Value4 = value;
break;
default:
Debug.Fail("Invalid element obtained from LocateObjectEntry");
break;
}
objEntries[index].Mask = (short)((ushort)(objEntries[index].Mask) | (1 << element));
}
public void RemoveObject(int key)
{
int index;
short element;
short entryKey = SplitKey(key, out element);
if (LocateObjectEntry(entryKey, out index))
{
if (((1 << element) & objEntries[index].Mask) == 0)
{
// this element is not being used - return right away
return;
}
// declare that the element is no longer used
objEntries[index].Mask &= (short)(~((short)(1 << element)));
if (objEntries[index].Mask == 0)
{
// this object entry is no longer in use - let's remove it all together
// not great for perf but very simple and we don't expect to remove much
if (objEntries.Length == 1)
{
// instead of allocating an array of length 0, we simply reset the array to null.
objEntries = null;
}
else
{
ObjectEntry[] newEntries = new ObjectEntry[objEntries.Length - 1];
if (index > 0)
{
Array.Copy(objEntries, 0, newEntries, 0, index);
}
if (index < newEntries.Length)
{
Debug.Assert(objEntries.Length - index - 1 > 0);
Array.Copy(objEntries, index + 1, newEntries, index, objEntries.Length - index - 1);
}
objEntries = newEntries;
}
}
else
{
// this object entry is still in use - let's just clean up the deleted element
switch (element)
{
case 0:
objEntries[index].Value1 = null;
break;
case 1:
objEntries[index].Value2 = null;
break;
case 2:
objEntries[index].Value3 = null;
break;
case 3:
objEntries[index].Value4 = null;
break;
default:
Debug.Fail("Invalid element obtained from LocateObjectEntry");
break;
}
}
}
}
private static object GetGroundOnly(ObjectEntry obj)
{
return (obj.SubType & 128) != 0 ? true : false;
}
public override Sprite GetSprite(ObjectEntry obj)
{
return(new Sprite(sprite, 0, obj.SubType << 3));
}
private static object GetRDPath(ObjectEntry obj)
{
return (obj.SubType & 8) >> 3;
}
public override Sprite GetDebugOverlay(ObjectEntry obj)
{
return(overlay);
}
private static void SetGroundOnly(ObjectEntry obj, object value)
{
obj.SubType = (byte)((obj.SubType & ~128) | ((bool)value == true ? 128 : 0));
}
public override Sprite GetDebugOverlay(ObjectEntry obj)
{
return(new Sprite(overlay, 0, obj.SubType << 3));
}
private static void SetRDPriority(ObjectEntry obj, object value)
{
obj.SubType = (byte)((obj.SubType & ~32) | ((Priority)value == Priority.High ? 32 : 0));
}
public override Sprite GetSprite(ObjectEntry obj)
{
return(GetSubtypeSprites(obj.SubType)[(obj.XFlip ? 1 : 0) | (obj.YFlip ? 2 : 0)]);
}
internal void AddObject (object instance, bool absolute)
{
if (_closed)
throw new InvalidOperationException ("store is closed");
if (_objects == null)
_objects = new Dictionary <string, ObjectEntry> ();
string objectName = GetName (instance);
if (!_objects.ContainsKey (objectName)) {
ObjectEntry objectEntry = new ObjectEntry (instance, objectName);
objectEntry.Absolute = absolute;
objectEntry.IsEntireObject = true;
_objects[objectName] = objectEntry;
}
}
public override Sprite GetSprite(ObjectEntry obj)
{
return(sprite[(obj.XFlip ? 1 : 0) | (obj.YFlip ? 2 : 0)]);
}
public void RemoveObject(int key)
{
int num;
short num2;
short entryKey = this.SplitKey(key, out num2);
if (this.LocateObjectEntry(entryKey, out num) && (((((int) 1) << num2) & this.objEntries[num].Mask) != 0))
{
this.objEntries[num].Mask = (short) (this.objEntries[num].Mask & ~((short) (((int) 1) << num2)));
if (this.objEntries[num].Mask == 0)
{
if (this.objEntries.Length == 1)
{
this.objEntries = null;
}
else
{
ObjectEntry[] destinationArray = new ObjectEntry[this.objEntries.Length - 1];
if (num > 0)
{
Array.Copy(this.objEntries, 0, destinationArray, 0, num);
}
if (num < destinationArray.Length)
{
Array.Copy(this.objEntries, num + 1, destinationArray, num, (this.objEntries.Length - num) - 1);
}
this.objEntries = destinationArray;
}
}
else
{
switch (num2)
{
case 0:
this.objEntries[num].Value1 = null;
return;
case 1:
this.objEntries[num].Value2 = null;
return;
case 2:
this.objEntries[num].Value3 = null;
return;
case 3:
this.objEntries[num].Value4 = null;
return;
}
}
}
}
public override Rectangle GetBounds(ObjectEntry obj)
{
return(new Rectangle(obj.X - 32, obj.Y - 32, 64, 64));
}
public override Control CreateInstance(COMRegistry registry, ICOMClassEntry entry, string strObjName, ObjectEntry pObject)
{
return(new ClassFactoryTypeViewer(registry, entry, strObjName, pObject.Instance));
}
public override Sprite GetSprite(ObjectEntry obj)
{
return(sprites[obj.SubType == 0 ? 0 : 1][(obj.XFlip ? 1 : 0) | (obj.YFlip ? 2 : 0)]);
}
public override Sprite GetSprite(ObjectEntry obj)
{
var sprite = this.sprite[(obj.XFlip ? 1 : 0) | (obj.YFlip ? 2 : 0)];
return((obj.SubType & 0x80) == 0 ? sprite : new Sprite(sprite, extraSprite));
}
public override Sprite GetSprite(ObjectEntry obj)
{
return(sprite);
}
private static object GetDirection(ObjectEntry obj)
{
return (obj.SubType & 4) != 0 ? Direction.Horizontal : Direction.Vertical;
}
public override Sprite GetSprite(ObjectEntry obj)
{
var sprite = GetFlippedSprite(obj);
return(new Sprite(extraSprite, sprite));
}
private static object GetLUPath(ObjectEntry obj)
{
return (obj.SubType & 16) >> 4;
}
private Sprite GetFlippedSprite(ObjectEntry obj)
{
return(sprite[(obj.XFlip ? 1 : 0) | (obj.YFlip ? 2 : 0)]);
}
private static object GetRDPriority(ObjectEntry obj)
{
return (obj.SubType & 32) != 0 ? Priority.High : Priority.Low;
}
public override int GetDepth(ObjectEntry obj)
{
return(1);
}
private static void SetDirection(ObjectEntry obj, object value)
{
obj.SubType = (byte)((obj.SubType & ~4) | ((Direction)value == Direction.Horizontal ? 4 : 0));
}
private static object GetWidth(ObjectEntry obj)
{
return((obj.SubType & 0xF0) >> 4);
}
private static void SetLUPath(ObjectEntry obj, object value)
{
obj.SubType = (byte)((obj.SubType & ~16) | ((int)value << 4));
}
private static void SetWidth(ObjectEntry obj, object value)
{
obj.SubType = (byte)((Math.Min((int)value, 0xF) << 4) | (obj.SubType & 0xF));
}
private static void SetRDPath(ObjectEntry obj, object value)
{
obj.SubType = (byte)((obj.SubType & ~8) | ((int)value << 3));
}
private static object GetHeight(ObjectEntry obj)
{
return(obj.SubType & 0xF);
}
private static void SetSize(ObjectEntry obj, object value)
{
obj.SubType = (byte)((obj.SubType & ~3) | ((byte)value & 3));
}
private static void SetHeight(ObjectEntry obj, object value)
{
obj.SubType = (byte)(Math.Min((int)value, 0xF) | (obj.SubType & 0xF0));
}
public override Sprite GetSprite(ObjectEntry obj)
{
int frame = obj.SubType >> 4;
if (frame > 5) frame = 0;
BitmapBits bits = new BitmapBits(imgs[frame].Image);
bits.Flip(obj.XFlip, obj.YFlip);
return new Sprite(bits, new Point(obj.X + imgs[frame].X, obj.Y + imgs[frame].Y));
}
private Sprite GetFlippedSprite(ObjectEntry obj, int index)
{
return(sprites[index][(obj.XFlip ? 1 : 0) | (obj.YFlip ? 2 : 0)]);
}
private object DeserializeEntry (IDesignerSerializationManager manager, ObjectEntry objectEntry)
{
object deserialized = null;
if (objectEntry.IsEntireObject) {
CodeDomSerializer serializer = (CodeDomSerializer) manager.GetSerializer (objectEntry.Type,
typeof (CodeDomSerializer));
if (serializer != null) {
deserialized = serializer.Deserialize (manager, objectEntry.Serialized);
// check if the name of the object has changed
// (if it e.g clashes with another name)
string newName = manager.GetName (deserialized);
if (newName != objectEntry.Name)
objectEntry.Name = newName;
}
} else {
foreach (MemberEntry memberEntry in objectEntry.Members.Values) {
CodeDomSerializer serializer = (CodeDomSerializer) manager.GetSerializer (objectEntry.Type,
typeof (CodeDomSerializer));
if (serializer != null)
serializer.Deserialize (manager, memberEntry.Serialized);
}
}
return deserialized;
}
public override Rectangle GetBounds(ObjectEntry obj, Point camera)
{
int w = (obj.SubType & 0x1F) * img.Width;
return new Rectangle((obj.X - (w / 2) + img.X) - camera.X, (obj.Y + img.Y) - camera.Y, w, img.Height);
}
public override void Draw(BitmapBits bmp, Point camera, ObjectEntry obj, bool includeDebug)
{
BitmapBits bits = new BitmapBits(img);
bits.Flip(obj.XFlip, obj.YFlip);
bmp.DrawBitmapComposited(bits, new Point(obj.X + offset.X - camera.X, obj.Y + offset.Y - camera.Y));
}
private static void SetSpikes(ObjectEntry obj, object value)
{
obj.SubType = (byte)(Math.Max(1, (Math.Min(0x16, (int)value))));
}
public void SetObject(int key, object value)
{
int num;
short num2;
short entryKey = this.SplitKey(key, out num2);
if (!this.LocateObjectEntry(entryKey, out num))
{
if (this.objEntries != null)
{
ObjectEntry[] destinationArray = new ObjectEntry[this.objEntries.Length + 1];
if (num > 0)
{
Array.Copy(this.objEntries, 0, destinationArray, 0, num);
}
if ((this.objEntries.Length - num) > 0)
{
Array.Copy(this.objEntries, num, destinationArray, num + 1, this.objEntries.Length - num);
}
this.objEntries = destinationArray;
}
else
{
this.objEntries = new ObjectEntry[1];
}
this.objEntries[num].Key = entryKey;
}
switch (num2)
{
case 0:
this.objEntries[num].Value1 = value;
break;
case 1:
this.objEntries[num].Value2 = value;
break;
case 2:
this.objEntries[num].Value3 = value;
break;
case 3:
this.objEntries[num].Value4 = value;
break;
}
this.objEntries[num].Mask = (short) (((ushort) this.objEntries[num].Mask) | (((int) 1) << num2));
}
public override Control CreateInstance(COMRegistry registry, ICOMClassEntry entry, string strObjName, ObjectEntry pObject)
{
COMCLSIDEntry clsid_entry = entry as COMCLSIDEntry;
if (clsid_entry == null)
{
throw new ArgumentException("Entry must be a COM class", "entry");
}
return(new ElevatedFactoryServerTypeViewer(registry, clsid_entry, strObjName, pObject.Instance));
}
public override int GetDepth(ObjectEntry obj)
{
return(obj.SubType == 0x28 ? 2 : 3);
}
private static object GetSpikes(ObjectEntry obj)
{
return(Math.Min(0x16, (int)obj.SubType));
}
