public override void Walk(IDefinition definition)
        {
            IList<Variable> list = new List<Variable>();
            if (VersionCode == VersionCode.V1)
            {
                Messenger.Walk(
                    VersionCode, 
                    Agent, 
                    GetCommunity,
                    new ObjectIdentifier(definition.GetNumericalForm()),
                    list,
                    Timeout,
                    WalkMode.WithinSubtree);
            }
            else
            {
                Messenger.BulkWalk(
                    VersionCode,
                    Agent, 
                    GetCommunity,
                    new ObjectIdentifier(definition.GetNumericalForm()), 
                    list, 
                    Timeout,
                    10,
                    WalkMode.WithinSubtree, 
                    null, 
                    null);
            }

            foreach (Variable v in list)
            {
                Logger.Info(v.ToString(Objects));
            }
        }

 public override void ExtendDefinition(IDefinition definition)
 {
     // only applies to type definitions
     var typeDef = definition as ITypeDefinition;
     if (typeDef != null)
         typeDef.Namespace = "";
 }

 public void AddShapes(VexObject vo, IDefinition def, Matrix m)
 {
     if (def.Name == "circleShape")
     {
         //Matrix m = orgInst.Transformations[0].Matrix;
         Point c = new Point(m.TranslateX, m.TranslateY);
         float r = m.ScaleX * 100 / 2;
         Shapes.Add(new CircleShape2D(def.Name, c, r));
     }
     else if (def is Symbol)
     {
         //Matrix m = orgInst.Transformations[0].Matrix;
         AddShape(def.Name, (Symbol)def, m);
     }
     else if (def is Timeline)
     {
         foreach (Instance inst in ((Timeline)def).Instances)
         {
             IDefinition def2 = vo.Definitions[inst.DefinitionId];
             if (def2 is Symbol && (def2.UserData & (int)DefinitionKind.OutlineStroke) != 0)
             {
                 //todo: Symbol may have multiple Shapes, and only one/some are red outlines
                 //Matrix m = inst.Transformations[0].Matrix;
                 AddShape(def.Name, (Symbol)def2, inst.Transformations[0].Matrix);
             }
         }
     }
 }

        public override void ExtendDefinition(IDefinition definition)
        {
            var memberDef = definition as IMemberDefinition;
            if (memberDef == null)
                return;

            // change property to field
            if (memberDef.MemberKind == MemberDefinitionKind.Property)
                memberDef.MemberKind = MemberDefinitionKind.Field;
        }

 public FormTable(IDefinition def)
 {
     _definition = def;
     InitializeComponent();
     cbColumnDisplay.SelectedIndex = 1;
     if (PlatformSupport.Platform == PlatformType.Windows)
     {
         Icon = Properties.Resources.x_office_spreadsheet;
     }
 }

 private bool PrintDefinitionSourceLocations(IDefinition definition) {
   bool result = false;
   if (this.pdbReader != null) {
     foreach (var psLoc in this.pdbReader.GetPrimarySourceLocationsFor(definition.Locations)) {
       this.PrintSourceLocation(psLoc);
       result = true;
     }
   }
   return result;
 }

		protected string GetDefinitionName(IDefinition def)
		{
			string result;
			if (def.Name != null && def.Name != "")
			{
				result = def.Name;
			}
			else
			{
				result = symbolPrefix + def.Id.ToString();
			}
			return result;
		}

        public override void ExtendDefinition(IDefinition definition)
        {
            var methodDef = definition as MethodDefinition;
            if (methodDef == null || methodDef.Symbol == null)
                return;

            if (methodDef.Symbol.ReducedFrom != null)
            {
                // use the original method symbol and force non static
                methodDef.Symbol = methodDef.Symbol.ReducedFrom;
                methodDef.Modifiers.IsStatic = false;
            }
        }

        public string GetString(IDefinition definition, int indentLevel = -1)
        {
            EnsureStringWriter();

            _string.Clear();

            if (indentLevel != -1)
                _stringWriter.SyntaxtWriter.IndentLevel = indentLevel;

            _stringWriter.WriteDeclaration(definition);

            return _string.ToString();
        }

        public IEnumerable<SyntaxToken> GetTokenList(IDefinition definition, int indentLevel = -1)
        {
            EnsureTokenWriter();

            _tokenizer.ClearTokens();

            if (indentLevel != -1)
                _tokenizer.IndentLevel = indentLevel;

            _tokenWriter.WriteDeclaration(definition);

            return _tokenizer.ToTokenList();
        }

        public DefinitionWithLocation(IDefinition definition,
            int startLine, int startColumn, int endLine, int endColumn)
        {
            Debug.Assert(startLine >= 0);
            Debug.Assert(startColumn >= 0);
            Debug.Assert(endLine >= 0);
            Debug.Assert(endColumn >= 0);

            this.Definition = definition;
            this.StartLine = (uint)startLine;
            this.StartColumn = (uint)startColumn;
            this.EndLine = (uint)endLine;
            this.EndColumn = (uint)endColumn;
        }

        public override void ExtendDefinition(IDefinition definition)
        {
            var typeDef = definition as ContainerTypeDefinition;

            if (typeDef == null)
                return;

            // set to anonymous type view
            typeDef.TypeKind = TypeDefinitionKind.Anonymous;

            // set each property to render as a field
            foreach (var prop in typeDef.Properties)
                prop.MemberKind = MemberDefinitionKind.Field;
        }

        public SearchResult(IDefinition definition, uint[] remaining)
        {
            if (definition == null)
            {
                throw new ArgumentNullException("definition");
            }

            if (remaining == null)
            {
                throw new ArgumentNullException("remaining");
            }

            Definition = definition;
            _remaining = remaining;
        }

        public static Matrix GetTransformation(IDefinition def)
        {
            Matrix translation;
            if (def.Position.X == 0.0f && def.Position.Y == 0.0f && def.Position.Z == 0.0f)
                translation = Matrix.Identity;
            else
                translation = Matrix.CreateTranslation(-(def.Position.Z - Constant.MaxXY),
                                                       -(def.Position.X - Constant.MaxXY), def.Position.Y);

            var rotation = Matrix.CreateRotationX(MathHelper.ToRadians(def.Rotation.Z))*
                           Matrix.CreateRotationY(MathHelper.ToRadians(def.Rotation.X))*Matrix.CreateRotationZ(MathHelper.ToRadians(def.Rotation.Y + 180));

            if (def.Scale < 1.0f || def.Scale > 1.0f)
                return (Matrix.CreateScale(def.Scale)*rotation)*translation;
            return rotation * translation;
        }

        public void AddDefinition(IDefinition definition)
        {
            _definitions.Add(definition);

            if (definition is FragmentDefinition)
            {
                Fragments.Add((FragmentDefinition) definition);
            }
            else if (definition is Operation)
            {
                Operations.Add((Operation) definition);
            }
            else
            {
                throw new ExecutionError("Unhandled document definition");
            }
        }

        public SymbolChange GetChange(IDefinition def)
        {
            var symbol = def as ISymbol;
            if (symbol != null)
            {
                return GetChange(symbol);
            }

            // If the def existed in the previous generation, the def is unchanged
            // (although it may contain changed defs); otherwise, it was added.
            if (this.definitionMap.DefinitionExists(def))
            {
                var typeDef = def as ITypeDefinition;
                return (typeDef != null) ? SymbolChange.ContainsChanges : SymbolChange.None;
            }
            return SymbolChange.Added;
        }

 internal override void GetTable(IDefinition def)
 {
     IList<Variable> list = new List<Variable>();
     int rows = Messenger.Walk(VersionCode, Agent, GetCommunity, new ObjectIdentifier(def.GetNumericalForm()), list, Timeout, WalkMode.WithinSubtree);
     
     // How many rows are there?
     if (rows > 0)
     {
         FormTable newTable = new FormTable(def);
         newTable.SetRows(rows);
         newTable.PopulateGrid(list);
         newTable.Show();
     }
     else
     {
         foreach (Variable t in list)
         {
             Logger.Info(t.ToString());
         }
     }
 }

        public override void GenerateXamlPart(VexObject v, IDefinition def, out string xamlFileName)
        {
            this.v = v;
            this.Log = new StringBuilder();
            xamlFileName = Directory.GetCurrentDirectory() + "/" + v.Name + "_" + def.Id + ".xaml";
            xw = new XamlWriter(xamlFileName, Encoding.UTF8);

            xw.WriteComment(headerComment);

            #if(IS_TRIAL)
            // turn off watermarking for small files
            isWatermarking = true;
            xw.WriteComment(trialComment);
            if (v.Definitions.Count < 15)
            {
                isWatermarking = false;
            }
            #else
            isWatermarking = false;
            #endif

            xw.OpenHeaderTag(def.StrokeBounds.Size.Width, def.StrokeBounds.Size.Height, v.BackgroundColor);

            Dictionary<uint, IDefinition> defList = new Dictionary<uint, IDefinition>();
            defList.Add(1, def);
            WriteDefinitions(defList, true, true);

            //WriteTimelineDefiniton(v.Root, true);
            // Write a rectangle to hold this shape
            Instance inst = new Instance();
            inst.Name = instancePrefix + def.Id;
            inst.InstanceID = 1;
            inst.DefinitionId = def.Id;
            inst.Transformations.Add(new Transform(0, 1000, Matrix.Identitiy, 1, ColorTransform.Identity));
            WriteInstance(def, inst);

            xw.CloseHeaderTag();

            xw.Close();
        }

        private static DefinitionType DetermineType(string type, string name, IDefinition parent)
        {
            if (type == typeof(OidValueAssignment).ToString()) 
            {
                return DefinitionType.OidValueAssignment;
            }

            if (type != typeof(ObjectType).ToString())
            {
                return DefinitionType.Unknown;
            }

            if (name.EndsWith("Table", StringComparison.Ordinal))
            {
                return DefinitionType.Table;
            }

            if (name.EndsWith("Entry", StringComparison.Ordinal)) 
            {
                return DefinitionType.Entry;
            }

            return parent.Type == DefinitionType.Entry ? DefinitionType.Column : DefinitionType.Scalar;
        }

 public override void ExtendDefinition(IDefinition definition)
 {
     definition.Name = _name;
 }