private FrameTypesMgr m_typesMgr; // object manage FamilySymbols

        #endregion Fields

        #region Constructors

        /// <summary>
        /// constructor
        /// </summary>
        /// <param name="obj">FamilySymbol object</param>
        /// <param name="typesMgr">FamilySymbols' manager</param>
        public DuplicateTypeForm(object obj, FrameTypesMgr typesMgr)
        {
            InitializeComponent();

            m_copiedSymbol = obj as FamilySymbol;
            m_typesMgr = typesMgr;
        }

        // Create a data structure, attach it to a wall, populate it with data, and retrieve the data back from the wall
        public void CreateSchemeAndStoreData(FamilySymbol titleblock)
        {
            SchemaBuilder schemaBuilder = new SchemaBuilder(new Guid("1a68d420-96dd-44aa-a1de-000774a6104b"));
            schemaBuilder.SetReadAccessLevel(AccessLevel.Public); // allow anyone to read the object
            schemaBuilder.SetSchemaName("TitleBlockSettings");

            // create a field to store data
            FieldBuilder fieldBuilder_titleblockName = schemaBuilder.AddSimpleField("titleblockName", typeof(string));

            FieldBuilder fieldBuilder_cellSizeDistance_X = schemaBuilder.AddSimpleField("cellSizeDistance_X", typeof(string));
            //fieldBuilder_cellSizeDistance_X.SetUnitType(UnitType.UT_Length);
            FieldBuilder fieldBuilder_lowerGap_X = schemaBuilder.AddSimpleField("lowerGap_X", typeof(string));
            //fieldBuilder_lowerGap_X.SetUnitType(UnitType.UT_Length);
            FieldBuilder fieldBuilder_additionalEdge_X = schemaBuilder.AddSimpleField("additionalEdge_X", typeof(string));
            //fieldBuilder_additionalEdge_X.SetUnitType(UnitType.UT_Length);
            FieldBuilder fieldBuilder_fineTune_X = schemaBuilder.AddSimpleField("fineTune_X", typeof(string));
            //fieldBuilder_fineTune_X.SetUnitType(UnitType.UT_Length);

            FieldBuilder fieldBuilder_cellSizeDistance_Y = schemaBuilder.AddSimpleField("cellSizeDistance_Y", typeof(string));
            //fieldBuilder_cellSizeDistance_Y.SetUnitType(UnitType.UT_Length);
            FieldBuilder fieldBuilder_lowerGap_Y = schemaBuilder.AddSimpleField("lowerGap_Y", typeof(string));
            //fieldBuilder_lowerGap_Y.SetUnitType(UnitType.UT_Length);
            FieldBuilder fieldBuilder_additionalEdge_Y = schemaBuilder.AddSimpleField("additionalEdge_Y", typeof(string));
            //fieldBuilder_additionalEdge_Y.SetUnitType(UnitType.UT_Length);
            FieldBuilder fieldBuilder_fineTune_Y = schemaBuilder.AddSimpleField("fineTune_Y", typeof(string));
            //fieldBuilder_fineTune_Y.SetUnitType(UnitType.UT_Length);

            FieldBuilder fieldBuilder_cellGrid_Length = schemaBuilder.AddSimpleField("cellGrid_Length", typeof(string));
            FieldBuilder fieldBuilder_cellGrid_Height = schemaBuilder.AddSimpleField("cellGrid_Height", typeof(string));

            //fieldBuilder.SetDocumentation("store length of cell size in X direction.");

            Schema schema = schemaBuilder.Finish(); // register the Schema object
        }

 public FamilySymbol getFamilySymbol(string familyname)
 {
     foreach (FamilySymbol fs in titleBlockList)
     {
         if (familyname == fs.Name)
         {
             familySymbol = fs;
             return familySymbol;
         }
     }
     return familySymbol;
 }

 // works in Revit Structure 2009 API, but not in 2010:
 bool IsColumnRound(
     FamilySymbol symbol)
 {
     GenericFormSet solid = symbol.Family.SolidForms;
       GenericFormSetIterator i = solid.ForwardIterator();
       i.MoveNext();
       Extrusion extr = i.Current as Extrusion;
       CurveArray cr = extr.Sketch.CurveLoop;
       CurveArrayIterator i2 = cr.ForwardIterator();
       i2.MoveNext();
       String s = i2.Current.GetType().ToString();
       return s.Contains( "Arc" );
 }

        public static IList<Element> OfFamilyType(FamilySymbol familyType)
        {
            var instanceFilter = new ElementClassFilter(typeof(Autodesk.Revit.DB.FamilyInstance));
            var fec = new FilteredElementCollector(DocumentManager.Instance.CurrentDBDocument);

            var familyInstances = fec.WherePasses(instanceFilter)
                .WhereElementIsNotElementType()
                .ToElements()
                .Cast<Autodesk.Revit.DB.FamilyInstance>()
                .Where(x => x.Symbol.IsSimilarType(familyType.InternalFamilySymbol.Id));

            var instances = familyInstances
                .Select(x => ElementSelector.ByElementId(x.Id.IntegerValue)).ToList();
            return instances;
        }

 /// <summary>
 /// constructor used only for object factory
 /// </summary>
 /// <param name="symbol">FamilySymbol object has parameters</param>
 private FrameTypeParameters(FamilySymbol symbol)
 {
     // iterate and initialize parameters
     foreach (Parameter para in symbol.Parameters)
     {
         if (para.Definition.Name == "h")
         {
             m_hDimension = para;
             continue;
         }
         if (para.Definition.Name == "b")
         {
             m_bDimension = para;
             continue;
         }
     }
 }

        /// <summary>
        /// create column of certain type in certain position
        /// </summary>
        /// <param name="point2D">2D coordinate of the column</param>
        /// <param name="columnType">type of column</param>
        /// <param name="baseLevel">the base level of the column</param>
        /// <param name="topLevel">the top level of the column</param>
        private void PlaceColumn(Autodesk.Revit.DB.UV point2D, FamilySymbol columnType, Level baseLevel, Level topLevel)
        {
            //create column of certain type in certain level and start point
            Autodesk.Revit.DB.XYZ point = new Autodesk.Revit.DB.XYZ (point2D.U, point2D.V, 0);
            STRUCTURALTYPE structuralType;
            structuralType = Autodesk.Revit.DB.Structure.StructuralType.Column;
            FamilyInstance column = m_revit.ActiveUIDocument.Document.Create.NewFamilyInstance(point, columnType, topLevel, structuralType);

            //set base level & top level of the column
            if (null != column)
            {
                Parameter baseLevelParameter = column.get_Parameter(Autodesk.Revit.DB.BuiltInParameter.FAMILY_BASE_LEVEL_PARAM);
                Parameter topLevelParameter = column.get_Parameter(Autodesk.Revit.DB.BuiltInParameter.FAMILY_TOP_LEVEL_PARAM);
                Parameter topOffsetParameter = column.get_Parameter(BuiltInParameter.FAMILY_TOP_LEVEL_OFFSET_PARAM);
                Parameter baseOffsetParameter = column.get_Parameter(BuiltInParameter.FAMILY_BASE_LEVEL_OFFSET_PARAM);

                if (null != baseLevelParameter)
                {
                    Autodesk.Revit.DB.ElementId baseLevelId;
                    baseLevelId = baseLevel.Id;
                    baseLevelParameter.Set(baseLevelId);
                }

                if (null != topLevelParameter)
                {
                    Autodesk.Revit.DB.ElementId topLevelId;
                    topLevelId = topLevel.Id;
                    topLevelParameter.Set(topLevelId);
                }

                if (null != topOffsetParameter)
                {
                    topOffsetParameter.Set(0.0);
                }

                if (null != baseOffsetParameter)
                {
                    baseOffsetParameter.Set(0.0);
                }
            }
        }

    FrameWall( Autodesk.Revit.ApplicationServices.Application rvtApp, Autodesk.Revit.DB.Wall wall, double spacing, FamilySymbol columnType )
    {
      Document rvtDoc = wall.Document;

      LocationCurve loc = (LocationCurve) wall.Location;
      XYZ startPt = loc.Curve.GetEndPoint( 0 );
      XYZ endPt = loc.Curve.GetEndPoint( 1 );

      UV wallVec = new UV( endPt.X - startPt.X, endPt.Y - startPt.Y );

      UV axis = new UV( 1.0, 0.0 );


      ElementId baseLevelId = wall.get_Parameter( BuiltInParameter.WALL_BASE_CONSTRAINT ).AsElementId();
      ElementId topLevelId = wall.get_Parameter( BuiltInParameter.WALL_HEIGHT_TYPE ).AsElementId();

      double wallLength = VecLength( wallVec );
      wallVec = VecNormalise( wallVec );

      int nmax = (int) ( wallLength / spacing );

      MessageBox.Show( "Wall Length = " + wallLength + "\nSpacing = " + spacing + "\nMax Number = " + nmax, "Structural Sample", MessageBoxButtons.OK, MessageBoxIcon.Information );

      double angle = VecAngle( wallVec, axis );

      XYZ loc2 = startPt;

      double dx = wallVec.U * spacing;
      double dy = wallVec.V * spacing;

      for( int i = 0; i < nmax; i++ )
      {
        PlaceColumn( rvtApp, rvtDoc, loc2, angle, columnType, baseLevelId, topLevelId );
        loc2 = new XYZ( startPt.X + dx, startPt.Y + dy, startPt.Z );
      }

      PlaceColumn( rvtApp, rvtDoc, endPt, angle, columnType, baseLevelId, topLevelId );
    }

    PlaceColumn( Autodesk.Revit.ApplicationServices.Application rvtApp, Document rvtDoc, Autodesk.Revit.DB.XYZ point2, double angle, FamilySymbol columnType, ElementId baseLevelId, ElementId topLevelId )
    {
      Autodesk.Revit.DB.XYZ point = point2;
      // Note: Must use level-hosted NewFamilyInstance!
      Level instLevel = (Level) rvtDoc.GetElement( baseLevelId );
      Autodesk.Revit.DB.FamilyInstance column = rvtDoc.Create.NewFamilyInstance( point, columnType, instLevel, StructuralType.Column );

      if( column == null )
      {
        MessageBox.Show( "failed to create an instance of a column." );
        return;
      }

      Autodesk.Revit.DB.XYZ zVec = new Autodesk.Revit.DB.XYZ( 0, 0, 1 );


      Autodesk.Revit.DB.Line axis = Line.CreateUnbound( point, zVec );

      column.Location.Rotate( axis, angle );

      // Set the level Ids
      Parameter baseLevelParameter = column.get_Parameter( Autodesk.Revit.DB.BuiltInParameter.FAMILY_BASE_LEVEL_PARAM );
      Parameter topLevelParameter = column.get_Parameter( Autodesk.Revit.DB.BuiltInParameter.FAMILY_TOP_LEVEL_PARAM ); ;
      baseLevelParameter.Set( baseLevelId );
      topLevelParameter.Set( topLevelId );

    }

 SetTitleBlock(string name)
 {
     foreach (FamilySymbol f in m_allTitleBlocks) {
         if (name.Equals(f.Name)) {
             m_titleBlock = f;
             return;
         }
     }
 }

        GetTitleBlocks(Document doc)
        {
            m_allTitleBlocks = new FilteredElementCollector(doc).OfClass(typeof(FamilySymbol)).OfCategory(BuiltInCategory.OST_TitleBlocks).Cast<FamilySymbol>() as List<FamilySymbol>;
            if (0 == m_allTitleBlocks.Count) {
                throw new Exception("There is no title block to generate sheet.");
            }

            foreach (FamilySymbol f in m_allTitleBlocks) {
                m_titleBlockNames.Add(f.Name);

                if (null == m_titleBlock) {
                    m_titleBlock = f;
                }
            }
        }

 private static FScheme.Value _getParam(FamilySymbol fi, Parameter p)
 {
     if (p.StorageType == StorageType.Double)
     {
         return FScheme.Value.NewNumber(p.AsDouble());
     }
     else if (p.StorageType == StorageType.Integer)
     {
         return FScheme.Value.NewNumber(p.AsInteger());
     }
     else if (p.StorageType == StorageType.String)
     {
         return FScheme.Value.NewString(p.AsString());
     }
     else
     {
         return FScheme.Value.NewContainer(p.AsElementId());
     }
 }

        /// <summary>
        /// Retrieve all available title blocks in the currently active document.
        /// </summary>
        /// <param name="doc">the currently active document</param>
        private void GetTitleBlocks(Document doc)
        {
            m_allTitleBlocks = doc.TitleBlocks;
            if (0 == m_allTitleBlocks.Size)
            {
                throw new InvalidOperationException("There is no title block to generate sheet.");
            }

            foreach (FamilySymbol f in m_allTitleBlocks)
            {
                AllTitleBlocksNames.Add(f.Name);

                if (null == m_titleBlock)
                {
                    m_titleBlock = f;
                }
            }
        }

        private Value makeFamilyInstance(object location, FamilySymbol fs, int count)
        {
            XYZ pos = location is ReferencePoint
                          ? (location as ReferencePoint).Position
                          : (XYZ) location;

            FamilyInstance fi;

            if (this.Elements.Count > count)
            {
                if (dynUtils.TryGetElement(this.Elements[count], out fi))
                {
                    fi.Symbol = fs;
                    LocationPoint lp = fi.Location as LocationPoint;
                    lp.Point = pos;
                }
                else
                {
                    fi = this.UIDocument.Document.IsFamilyDocument
                             ? this.UIDocument.Document.FamilyCreate.NewFamilyInstance(
                                 pos, fs, Autodesk.Revit.DB.Structure.StructuralType.NonStructural
                                   )
                             : this.UIDocument.Document.Create.NewFamilyInstance(
                                 pos, fs, Autodesk.Revit.DB.Structure.StructuralType.NonStructural
                                   );

                    this.Elements[count] = fi.Id;
                }
            }
            else
            {
                fi = this.UIDocument.Document.IsFamilyDocument
                         ? this.UIDocument.Document.FamilyCreate.NewFamilyInstance(
                             pos, fs, Autodesk.Revit.DB.Structure.StructuralType.NonStructural)
                         : this.UIDocument.Document.Create.NewFamilyInstance(
                             pos, fs, Autodesk.Revit.DB.Structure.StructuralType.NonStructural);

                this.Elements.Add(fi.Id);
            }

            return Value.NewContainer(fi);
        }

 /// <summary>
 /// Gets minimum height of a family symbol.
 /// </summary>
 /// <param name="symbol">
 /// The family symbol.
 /// </param>
 static double GetMinSymbolHeight(FamilySymbol symbol)
 {
     return ExporterIFCUtils.GetMinSymbolHeight(symbol);
 }

        public void StoreData(FamilySymbol titleblock)
        {
            Schema schema = Schema.Lookup(new Guid("1a68d420-96dd-44aa-a1de-000774a6104b"));
            Entity entity = new Entity(schema);

            Field field_titleblockName = schema.GetField("titleblockName");

            Field field_cellSizeDistance_X = schema.GetField("cellSizeDistance_X");
            Field field_lowerGap_X = schema.GetField("lowerGap_X");
            Field field_additionalEdge_X = schema.GetField("additionalEdge_X");
            Field field_fineTune_X = schema.GetField("fineTune_X");

            Field field_cellSizeDistance_Y = schema.GetField("cellSizeDistance_Y");
            Field field_lowerGap_Y = schema.GetField("lowerGap_Y");
            Field field_additionalEdge_Y = schema.GetField("additionalEdge_Y");
            Field field_fineTune_Y = schema.GetField("fineTune_Y");

            Field field_cellGrid_Length = schema.GetField("cellGrid_Length");
            Field field_cellGrid_Height = schema.GetField("cellGrid_Height");

            entity.Set<string>(field_titleblockName, titleblockName);

            entity.Set<string>(field_cellSizeDistance_X, cellSizeDistance_X, DisplayUnitType.DUT_DECIMAL_INCHES);
            entity.Set<string>(field_lowerGap_X, lowerGap_X, DisplayUnitType.DUT_DECIMAL_INCHES);
            entity.Set<string>(field_additionalEdge_X, additionalEdge_X, DisplayUnitType.DUT_DECIMAL_INCHES);
            entity.Set<string>(field_fineTune_X, fineTune_X, DisplayUnitType.DUT_DECIMAL_INCHES);

            entity.Set<string>(field_cellSizeDistance_Y, cellSizeDistance_Y, DisplayUnitType.DUT_DECIMAL_INCHES);
            entity.Set<string>(field_lowerGap_Y, lowerGap_Y, DisplayUnitType.DUT_DECIMAL_INCHES);
            entity.Set<string>(field_additionalEdge_Y, additionalEdge_Y, DisplayUnitType.DUT_DECIMAL_INCHES);
            entity.Set<string>(field_fineTune_Y, fineTune_Y, DisplayUnitType.DUT_DECIMAL_INCHES);

            entity.Set<string>(field_cellGrid_Length, cellGrid_Length);
            entity.Set<string>(field_cellGrid_Height, cellGrid_Height);
            titleblock.SetEntity(entity); // store the entity in the element
        }

        /// <summary>
        /// create beam of certain type in certain position
        /// </summary>
        /// <param name="point2D1">one point of the location line in 2D</param>
        /// <param name="point2D2">another point of the location line in 2D</param>
        /// <param name="baseLevel">the base level of the beam</param>
        /// <param name="topLevel">the top level of the beam</param>
        /// <param name="beamType">type of beam</param>
        /// <returns>nothing</returns>
        private void PlaceBeam(Autodesk.Revit.DB.UV point2D1, Autodesk.Revit.DB.UV point2D2, Level baseLevel, Level topLevel, FamilySymbol beamType)
        {
            double height         = topLevel.Elevation;
            Autodesk.Revit.DB.XYZ startPoint         = new Autodesk.Revit.DB.XYZ (point2D1.U, point2D1.V, height);
            Autodesk.Revit.DB.XYZ endPoint         = new Autodesk.Revit.DB.XYZ (point2D2.U, point2D2.V, height);
            Autodesk.Revit.DB.ElementId topLevelId = topLevel.Id;

            Line line = m_revit.Application.Create.NewLineBound(startPoint, endPoint);
            STRUCTURALTYPE structuralType = Autodesk.Revit.DB.Structure.StructuralType.Beam;
            m_revit.ActiveUIDocument.Document.Create.NewFamilyInstance(line, beamType, topLevel, structuralType);
        }

        //-----------------------------------
        public bool StorageExists(FamilySymbol titleblock)
        {
            IList<Schema> schemas = Schema.ListSchemas();

            foreach (Schema schema in schemas)
            {
                try
                {
                    Entity entity = titleblock.GetEntity(schema);
                    if (entity.IsValid())
                    {
                        return true;
                    }
                }
                catch { }

            }
            return false;
        }

        public void RetrieveData(FamilySymbol titleblock)
        {
            string[] objects = new string[9];

            Schema schema = Schema.Lookup(new Guid("1a68d420-96dd-44aa-a1de-000774a6104b"));
            // get the field from the schema
            Field field_titleblockName = schema.GetField("titleblockName");

            Field field_cellSizeDistance_X = schema.GetField("cellSizeDistance_X");
            Field field_lowerGap_X = schema.GetField("lowerGap_X");
            Field field_additionalEdge_X = schema.GetField("additionalEdge_X");
            Field field_fineTune_X = schema.GetField("fineTune_X");

            Field field_cellSizeDistance_Y = schema.GetField("cellSizeDistance_Y");
            Field field_lowerGap_Y = schema.GetField("lowerGap_Y");
            Field field_additionalEdge_Y = schema.GetField("additionalEdge_Y");
            Field field_fineTune_Y = schema.GetField("fineTune_Y");

            Field field_cellGrid_Length = schema.GetField("cellGrid_Length");
            Field field_cellGrid_Height = schema.GetField("cellGrid_Height");

            // get the data back from the titleblock
            Entity retrievedEntity = titleblock.GetEntity(schema);
            string retrievedData_titleblockName = retrievedEntity.Get<string>(schema.GetField("titleblockName"));

            string retrievedData_cellSizeDistance_X = retrievedEntity.Get<string>(schema.GetField("cellSizeDistance_X"), DisplayUnitType.DUT_DECIMAL_INCHES);
            string retrievedData_lowerGap_X = retrievedEntity.Get<string>(schema.GetField("lowerGap_X"), DisplayUnitType.DUT_DECIMAL_INCHES);
            string retrievedData_additionalEdge_X = retrievedEntity.Get<string>(schema.GetField("additionalEdge_X"), DisplayUnitType.DUT_DECIMAL_INCHES);
            string retrievedData_fineTune_X = retrievedEntity.Get<string>(schema.GetField("fineTune_X"), DisplayUnitType.DUT_DECIMAL_INCHES);

            string retrievedData_cellSizeDistance_Y = retrievedEntity.Get<string>(schema.GetField("cellSizeDistance_Y"), DisplayUnitType.DUT_DECIMAL_INCHES);
            string retrievedData_lowerGap_Y = retrievedEntity.Get<string>(schema.GetField("lowerGap_Y"), DisplayUnitType.DUT_DECIMAL_INCHES);
            string retrievedData_additionalEdge_Y = retrievedEntity.Get<string>(schema.GetField("additionalEdge_Y"), DisplayUnitType.DUT_DECIMAL_INCHES);
            string retrievedData_fineTune_Y = retrievedEntity.Get<string>(schema.GetField("fineTune_Y"), DisplayUnitType.DUT_DECIMAL_INCHES);

            //string retrievedData_cellGrid = retrievedEntity.Get<string>(schema.GetField("cellGrid"));
            string retrievedData_cellGrid_Length = retrievedEntity.Get<string>(schema.GetField("cellGrid_Length"));
            string retrievedData_cellGrid_Height = retrievedEntity.Get<string>(schema.GetField("cellGrid_Height"));

            titleblockName = retrievedData_titleblockName;

            cellSizeDistance_X = retrievedData_cellSizeDistance_X;
            lowerGap_X = retrievedData_lowerGap_X;
            additionalEdge_X = retrievedData_additionalEdge_X;
            fineTune_X = retrievedData_fineTune_X;

            cellSizeDistance_Y = retrievedData_cellSizeDistance_Y;
            lowerGap_Y = retrievedData_lowerGap_Y;
            additionalEdge_Y = retrievedData_additionalEdge_Y;
            fineTune_Y = retrievedData_fineTune_Y;

            cellGrid_Length = retrievedData_cellGrid_Length;
            cellGrid_Height = retrievedData_cellGrid_Height;
        }

 private static FScheme.Value getParam(FamilySymbol fi, string paramName)
 {
     var p = fi.get_Parameter(paramName);
     if (p != null)
     {
         return _getParam(fi, p);
     }
     throw new Exception("Parameter \"" + paramName + "\" was not found!");
 }