added Revit 2022 SDK minus except *rvt and *rfa

SDK/Samples/ScheduleToHTML/CS/ScheduleHTMLExporter.cs

@@ -0,0 +1,361 @@
+using System;
+using System.Collections.Generic;
+using System.Web.UI;
+using System.IO;
+using Autodesk.Revit.DB;
+
+namespace Revit.SDK.Samples.ScheduleToHTML.CS
+{
+    /// <summary>
+    /// A class that can export a schedule to HTML.
+    /// </summary>
+    class ScheduleHTMLExporter
+    {
+        /// <summary>
+        /// Constructs a new instance of the schedule exporter operating on the input schedule.
+        /// </summary>
+        /// <param name="input">The schedule to be exported.</param>
+        public ScheduleHTMLExporter(ViewSchedule input)
+        {
+            theSchedule = input;
+        }
+
+        /// <summary>
+        /// Exports the schedule to formatted HTML.
+        /// </summary>
+        /// <param name="bInteractive">true if the export is being run interactively, false for journal playback.</param>
+        /// <param name="errMessage">String to contain message to display if the export fails.</param>
+        /// <returns>true if HTML exported without error, false otherswise.</returns>
+        public bool ExportToHTML(bool bInteractive, ref string errMessage)
+        {
+            // Setup file location in temp directory
+            string folder = Environment.GetEnvironmentVariable("TEMP");
+            string htmlFile = System.IO.Path.Combine(folder, ReplaceIllegalCharacters(theSchedule.Name) + ".html");
+
+            // Initialize StringWriter instance, but handle any io exceptions and close as appropriate. 
+            StreamWriter stringWriter = null;
+            try
+            {
+                stringWriter = new StreamWriter(htmlFile);
+         
+                // Put HtmlTextWriter in using block because it needs to call Dispose.
+                using (writer = new HtmlTextWriter(stringWriter))
+                {
+                    writer.AddAttribute(HtmlTextWriterAttribute.Align, "center");
+                    writer.RenderBeginTag(HtmlTextWriterTag.Div);
+
+                    //Write schedule header
+                    WriteHeader();
+
+                    //Write schedule body
+                    WriteBody();
+
+                    writer.RenderEndTag();
+                }
+            }
+            catch(System.IO.IOException e)
+            {
+                // set error message and return failure,  finally will close stringWriter if necessary. 
+                errMessage = "Exception occured generating HTML: " + e.Message + " Command canceled.";
+                return false;
+            }
+            finally
+            {
+                if (stringWriter != null)
+                    stringWriter.Close();
+            }
+
+            // Show the created file, but only if in interactive mode.
+            if (bInteractive) 
+                System.Diagnostics.Process.Start(htmlFile);
+            return true;
+        }
+
+        /// <summary>
+        /// Writes the header section of the table to the HTML file.
+        /// </summary>
+        private void WriteHeader()
+        {
+            // Clear written cells
+            writtenCells.Clear();
+
+            // Start table to represent the header
+            writer.AddAttribute(HtmlTextWriterAttribute.Border, "1");
+            writer.RenderBeginTag(HtmlTextWriterTag.Table);
+
+            // Get header section and write each cell
+            headerSection = theSchedule.GetTableData().GetSectionData(SectionType.Header);
+            int numberOfRows = headerSection.NumberOfRows;
+            int numberOfColumns = headerSection.NumberOfColumns;
+
+            for (int iRow = headerSection.FirstRowNumber; iRow < numberOfRows; iRow++)
+            {
+                WriteHeaderSectionRow(iRow, numberOfColumns);
+            }
+
+            // Close header table
+            writer.RenderEndTag();
+        }
+
+        /// <summary>
+        /// Writes the body section of the table to the HTML file.
+        /// </summary>
+        private void WriteBody()
+        {
+            // Clear written cells
+            writtenCells.Clear();
+
+            // Write the start of the body table
+            writer.AddAttribute(HtmlTextWriterAttribute.Border, "1");
+            writer.RenderBeginTag(HtmlTextWriterTag.Table);
+
+            // Get body section and write contents
+            bodySection = theSchedule.GetTableData().GetSectionData(SectionType.Body);
+            int numberOfRows = bodySection.NumberOfRows;
+            int numberOfColumns = bodySection.NumberOfColumns;
+
+            for (int iRow = bodySection.FirstRowNumber; iRow < numberOfRows; iRow++)
+            {
+                WriteBodySectionRow(iRow, numberOfColumns);
+            }
+
+            // Close the table
+            writer.RenderEndTag();
+        }
+
+        /// <summary>
+        /// Gets the Color value formatted for HTML (#XXXXXX) output.
+        /// </summary>
+        /// <param name="color">he color.</param>
+        /// <returns>The color string.</returns>
+        private static String GetColorHtmlString(Color color)
+        {
+            return String.Format("#{0}{1}{2}", color.Red.ToString("X"), color.Green.ToString("X"), color.Blue.ToString("X"));
+        }
+
+        /// <summary>
+        /// A predefined color value used for comparison.
+        /// </summary>
+        private static Color Black
+        {
+            get
+            {
+                return new Color(0, 0, 0);
+            }
+        }
+
+        /// <summary>
+        /// A predefined color value used for comparison.
+        /// </summary>
+        private static Color White
+        {
+            get
+            {
+                return new Color(255, 255, 255);
+            }
+        }
+
+        /// <summary>
+        /// Compares two colors.
+        /// </summary>
+        /// <param name="color1">The first color.</param>
+        /// <param name="color2">The second color.</param>
+        /// <returns>True if the colors are equal, false otherwise.</returns>
+        private bool ColorsEqual(Color color1, Color color2)
+        {
+            return color1.Red == color2.Red && color1.Green == color2.Green && color1.Blue == color2.Blue;
+        }
+
+        /// <summary>
+        /// Gets the HTML string representing this horizontal alignment.
+        /// </summary>
+        /// <param name="style">The horizontal alignment.</param>
+        /// <returns>The related string.</returns>
+        private static String GetAlignString(HorizontalAlignmentStyle style)
+        {
+            switch (style)
+            {
+                case HorizontalAlignmentStyle.Left:
+                    return "left";
+                case HorizontalAlignmentStyle.Center:
+                    return "center";
+                case HorizontalAlignmentStyle.Right:
+                    return "right";
+            }
+            return "";
+        }
+
+        /// <summary>
+        /// Writes a row of the header.
+        /// </summary>
+        /// <param name="iRow">The row number.</param>
+        /// <param name="numberOfColumns">The number of columns to write.</param>
+        private void WriteHeaderSectionRow(int iRow, int numberOfColumns)
+        {
+            WriteSectionRow(SectionType.Header, headerSection, iRow, numberOfColumns);
+        }
+
+        /// <summary>
+        /// Writes a row of the body.
+        /// </summary>
+        /// <param name="iRow">The row number.</param>
+        /// <param name="numberOfColumns">The number of columns to write.</param>
+        private void WriteBodySectionRow(int iRow, int numberOfColumns)
+        {
+            WriteSectionRow(SectionType.Body, bodySection, iRow, numberOfColumns);
+        }
+
+
+        /// <summary>
+        /// Writes a row of a table section.
+        /// </summary>
+        /// <param name="iRow">The row number.</param>
+        /// <param name="numberOfColumns">The number of columns to write.</param>
+        /// <param name="secType">The section type.</param>
+        /// <param name="data">The table section data.</param>
+        private void WriteSectionRow(SectionType secType, TableSectionData data, int iRow, int numberOfColumns)
+        {
+            // Start the table row tag.
+            writer.RenderBeginTag(HtmlTextWriterTag.Tr);
+
+            // Loop over the table section row.
+            for (int iCol = data.FirstColumnNumber; iCol < numberOfColumns; iCol++)
+            {
+                // Skip already written cells
+                if (writtenCells.Contains(new Tuple<int, int>(iRow, iCol)))
+                    continue;
+
+                // Get style
+                TableCellStyle style = data.GetTableCellStyle(iRow, iCol);
+                int numberOfStyleTags = 1;
+
+
+
+                // Merged cells
+                TableMergedCell mergedCell = data.GetMergedCell(iRow, iCol);
+
+                // If merged cell spans multiple columns
+                if (mergedCell.Left != mergedCell.Right)
+                {
+                    writer.AddAttribute(HtmlTextWriterAttribute.Colspan, (mergedCell.Right - mergedCell.Left + 1).ToString());
+                }
+
+                // If merged cell spans multiple rows
+                if (mergedCell.Top != mergedCell.Bottom)
+                {
+                    writer.AddAttribute(HtmlTextWriterAttribute.Rowspan, (mergedCell.Bottom - mergedCell.Top + 1).ToString());
+                }
+
+                // Remember all written cells related to the merge 
+                for (int iMergedRow = mergedCell.Top; iMergedRow <= mergedCell.Bottom; iMergedRow++)
+                {
+                    for (int iMergedCol = mergedCell.Left; iMergedCol <= mergedCell.Right; iMergedCol++)
+                    {
+                        writtenCells.Add(new Tuple<int, int>(iMergedRow, iMergedCol));
+                    }
+                }
+
+                // Write formatting attributes for the upcoming cell
+                // Background color
+                if (!ColorsEqual(style.BackgroundColor, White))
+                {
+                    writer.AddAttribute(HtmlTextWriterAttribute.Bgcolor, GetColorHtmlString(style.BackgroundColor));
+                }
+
+                // Horizontal alignment
+                writer.AddAttribute(HtmlTextWriterAttribute.Align, GetAlignString(style.FontHorizontalAlignment));
+
+                // Write cell tag
+                writer.RenderBeginTag(HtmlTextWriterTag.Td);
+
+                // Write subtags for the cell
+                // Underline
+                if (style.IsFontUnderline)
+                {
+                    writer.RenderBeginTag(HtmlTextWriterTag.U);
+                    numberOfStyleTags++;
+                }
+
+                //Italic
+                if (style.IsFontItalic)
+                {
+                    writer.RenderBeginTag(HtmlTextWriterTag.I);
+                    numberOfStyleTags++;
+                }
+
+                //Bold
+                if (style.IsFontBold)
+                {
+                    writer.RenderBeginTag(HtmlTextWriterTag.B);
+                    numberOfStyleTags++;
+                }
+
+                // Write cell text
+                String cellText = theSchedule.GetCellText(secType, iRow, iCol);
+                if (cellText.Length > 0)
+                {
+                    writer.Write(cellText);
+                }
+                else
+                {
+                    writer.Write("&nbsp;");
+                }
+
+                // Close open style tags & cell tag
+                for (int i = 0; i < numberOfStyleTags; i++)
+                {
+                    writer.RenderEndTag();
+                }
+            }
+            // Close row tag
+            writer.RenderEndTag();
+        }
+
+        /// <summary>
+        /// An utility method to replace illegal characters of the Schedule name when creating the HTML file name.
+        /// </summary>
+        /// <param name="stringWithIllegalChar">The Schedule name.</param>
+        /// <returns>The updated string without illegal characters.</returns>
+        private static string ReplaceIllegalCharacters(string stringWithIllegalChar)
+        {
+            char[] illegalChars = System.IO.Path.GetInvalidFileNameChars();
+
+            string updated = stringWithIllegalChar;
+            foreach (char ch in illegalChars)
+            {
+                updated = updated.Replace(ch, '_');
+            }
+
+            return updated;
+        }
+
+
+        /// <summary>
+        /// The writer for the HTML file.
+        /// </summary>
+        private HtmlTextWriter writer;
+
+        /// <summary>
+        /// The schedule being exported.
+        /// </summary>
+        private ViewSchedule theSchedule;
+
+        /// <summary>
+        /// The body section of the table.
+        /// </summary>
+        private TableSectionData bodySection;
+
+        /// <summary>
+        /// The header section of the table.
+        /// </summary>
+        private TableSectionData headerSection;
+
+        /// <summary>
+        /// A collection of cells which have already been output.  This is needed to deal with
+        /// cell merging - each cell should be written only once even as all the cells are iterated in
+        /// order.
+        /// </summary>
+        List<Tuple<int, int>> writtenCells = new List<Tuple<int, int>>();
+    }
+}
+