AODLException is a special exception which will let you also access possible broken XmlNodes.
Inheritance: System.Exception
Exemplo n.º 1
0
        /// <summary>
        /// Gets the first importer that match the parameter criteria.
        /// </summary>
        /// <param name="documentType">Type of the document.</param>
        /// <param name="loadPath">The save path.</param>
        /// <returns></returns>
        public IImporter GetFirstImporter(DocumentTypes documentType, string loadPath)
        {
            string targetExtension			= ExportHandler.GetExtension(loadPath);

            foreach(IImporter iImporter in this.LoadImporter())
            {
                foreach(DocumentSupportInfo documentSupportInfo in iImporter.DocumentSupportInfos)
                    if(documentSupportInfo.Extension.ToLower().Equals(targetExtension.ToLower()))
                        if(documentSupportInfo.DocumentType == documentType)
                            return iImporter;
            }

            AODLException exception		= new AODLException("No importer available for type "+documentType.ToString()+" and extension "+targetExtension);
            exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
            throw exception;
        }
Exemplo n.º 2
0
        /// <summary>
        /// Gets the I text collection as HTML.
        /// </summary>
        /// <param name="iTextCollection">The i text collection.</param>
        /// <param name="paragraphStyle">The paragraph style.</param>
        /// <returns></returns>
        public string GetITextCollectionAsHtml(ITextCollection iTextCollection, ParagraphStyle paragraphStyle)
        {
            string html					= "";
            int tabStopCnt				= 0;

            try
            {
                if(iTextCollection != null)
                {
                    foreach(IText iText in iTextCollection)
                    {
                        //determine type
                        if(iText is SimpleText)
                        {
                            string textContent	= iText.Node.InnerText;
                            html				+= this.ReplaceControlNodes(textContent);
                        }
                        else if(iText is FormatedText)
                            html			+= this.GetFormatedTextAsHtml(iText as FormatedText);
                        else if(iText is WhiteSpace)
                            html			+= this.GetWhiteSpacesAsHtml(iText as WhiteSpace);
                        else if(iText is TabStop)
                        {
                            html			+= this.GetTabStopAsHtml(iText as TabStop, tabStopCnt, html, paragraphStyle);
                            tabStopCnt++;
                        }
                        else if(iText is XLink)
                            html			+= this.GetXLinkAsHtml(iText as XLink);
                        else if(iText is LineBreak)
                            html			+= this.GetLineBreakAsHtml();
                        else if(iText is UnknownTextContent)
                            html			+= this.GetUnknowTextContentAsHtml(iText as UnknownTextContent);
                        else
                            //this should never happens, because all not implemented elements
                            //are unknwon content
                            if(OnWarning != null)
                        {
                            AODLWarning warning			= new AODLWarning("Finding total unknown text content. This should (could) never happen.");
                            warning.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                            OnWarning(warning);
                        }
                    }
                }
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Exception while trying to build a HTML string from an ITextCollection.");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                exception.OriginalException	= ex;

                throw exception;
            }

            return html;
        }
Exemplo n.º 3
0
        /// <summary>
        /// Creates the table.
        /// </summary>
        /// <param name="tableNode">The tablenode.</param>
        /// <returns></returns>
        private Table CreateTable(XmlNode tableNode)
        {
            try
            {
                //Create a new table
                Table table					= new Table(this._document, tableNode);
                IContentCollection iColl	= new IContentCollection();
                //Recieve the table style
                IStyle tableStyle		= this._document.Styles.GetStyleByName(table.StyleName);

                if(tableStyle != null)
                    table.Style				= tableStyle;
                else
                {
                    if(this.OnWarning != null)
                    {
                        AODLWarning warning			= new AODLWarning("Couldn't recieve a TableStyle.");
                        warning.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                        warning.Node				= tableNode;
                        this.OnWarning(warning);
                    }
                }

                //Create the table content
                foreach(XmlNode nodeChild in table.Node.ChildNodes)
                {
                    IContent iContent				= this.CreateContent(nodeChild);

                    if(iContent != null)
                    {
                        iColl.Add(iContent);
                    }
                    else
                    {
                        if(this.OnWarning != null)
                        {
                            AODLWarning warning			= new AODLWarning("Couldn't create IContent from a table node. Content is unknown table content!");
                            warning.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                            warning.Node				= iContent.Node;
                            this.OnWarning(warning);
                        }
                    }
                }

                table.Node.InnerText					= "";

                foreach(IContent iContent in iColl)
                {
                    if(iContent is Column)
                    {
                        ((Column)iContent).Table	= table;
                        table.ColumnCollection.Add(iContent as Column);
                    }
                    else if(iContent is Row)
                    {
                        ((Row)iContent).Table		= table;
                        table.RowCollection.Add(iContent as Row);
                    }
                    else if(iContent is RowHeader)
                    {
                        ((RowHeader)iContent).Table	= table;
                        table.RowHeader			= iContent as RowHeader;
                    }
                    else
                    {
                        if(this.OnWarning != null)
                        {
                            AODLWarning warning			= new AODLWarning("Couldn't create IContent from a table node.");
                            warning.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                            warning.Node				= tableNode;
                            this.OnWarning(warning);
                            table.Node.AppendChild(iContent.Node);
                        }
                    }
                }

                return table;
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Exception while trying to create a Table.");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                exception.Node				= tableNode;
                exception.OriginalException	= ex;

                throw exception;
            }
        }
Exemplo n.º 4
0
        /// <summary>
        /// Creates the list.
        /// </summary>
        /// <param name="listNode">The list node.</param>
        /// <returns>The List object</returns>
        private List CreateList(XmlNode listNode)
        {
            try
            {
                #region Old code Todo: delete
                //				string stylename				= null;
                //				XmlNode	stylenode				= null;
                //				ListStyles liststyles			= ListStyles.Bullet; //as default
                //				string paragraphstylename		= null;
                //
                //				if(outerlist == null)
                //				{
                //					stylename			= this.GetStyleName(listNode.OuterXml);
                //					stylenode			= this.GetAStyleNode("text:list-style", stylename);
                //					liststyles			= this.GetListStyle(listNode);
                //				}
                //				List list					= null;
                //
                //				if(listNode.ChildNodes.Count > 0)
                //				{
                //					try
                //					{
                //						paragraphstylename	= this.GetAValueFromAnAttribute(listNode.ChildNodes.Item(0).ChildNodes.Item(0), "@style:style-name");
                //					}
                //					catch(Exception ex)
                //					{
                //						paragraphstylename	= "P1";
                //					}
                //				}
                #endregion
                //Create a new List
                List list					= new List(this._document, listNode);
                IContentCollection iColl	= new IContentCollection();
                //Revieve the ListStyle
                IStyle listStyle			= this._document.Styles.GetStyleByName(list.StyleName);

                if(listStyle != null)
                    list.Style				= listStyle;

                foreach(XmlNode nodeChild in list.Node.ChildNodes)
                {
                    IContent iContent		= this.CreateContent(nodeChild);

                    if(iContent != null)
                        iColl.Add(iContent);
                }

                list.Node.InnerXml			= "";

                foreach(IContent iContent in iColl)
                    list.Content.Add(iContent);

                return list;
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Exception while trying to create a List.");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                exception.Node				= listNode;
                exception.OriginalException	= ex;

                throw exception;
            }
        }
Exemplo n.º 5
0
        /// <summary>
        /// Creates the graphic.
        /// </summary>
        /// <param name="graphicnode">The graphicnode.</param>
        /// <returns>The Graphic object</returns>
        private Graphic CreateGraphic(XmlNode graphicnode)
        {
            try
            {
                Graphic graphic				= new Graphic(this._document, null, null);
                graphic.Node				= graphicnode;
                graphic.GraphicRealPath		= Path.Combine(OpenDocumentImporter.dir,graphic.HRef);

                return graphic;
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Exception while trying to create a Graphic.");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                exception.Node				= graphicnode;
                exception.OriginalException	= ex;

                throw exception;
            }
        }
Exemplo n.º 6
0
        /// <summary>
        /// Creates the draw area rectangle.
        /// </summary>
        /// <param name="drawAreaRectangleNode">The draw area rectangle node.</param>
        /// <returns></returns>
        private DrawAreaRectangle CreateDrawAreaRectangle(XmlNode drawAreaRectangleNode)
        {
            try
            {
                DrawAreaRectangle dAreaRec	= new DrawAreaRectangle(this._document, drawAreaRectangleNode);
                IContentCollection iCol		= new IContentCollection();

                if(dAreaRec.Node != null)
                    foreach(XmlNode nodeChild in dAreaRec.Node.ChildNodes)
                    {
                        IContent iContent	= this.CreateContent(nodeChild);
                        if(iContent != null)
                            iCol.Add(iContent);
                    }

                dAreaRec.Node.InnerXml		= "";

                foreach(IContent iContent in iCol)
                    dAreaRec.Content.Add(iContent);

                return dAreaRec;
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Exception while trying to create a DrawAreaRectangle.");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                exception.Node				= drawAreaRectangleNode;
                exception.OriginalException	= ex;

                throw exception;
            }
        }
Exemplo n.º 7
0
        /// <summary>
        /// Creates the paragraph.
        /// </summary>
        /// <param name="paragraphNode">The paragraph node.</param>
        public Paragraph CreateParagraph(XmlNode paragraphNode)
        {
            try
            {
                //Create a new Paragraph
                Paragraph paragraph				= new Paragraph(paragraphNode, this._document);
                //Recieve the ParagraphStyle
                IStyle paragraphStyle			= this._document.Styles.GetStyleByName(paragraph.StyleName);

                if(paragraphStyle != null)
                {
                    paragraph.Style				= paragraphStyle;
                }
                else if(paragraph.StyleName != "Standard"
                    && paragraph.StyleName != "Table_20_Contents"
                    && paragraph.StyleName != "Text_20_body"
                    && this._document is TextDocument)
                {
                    //Check if it's a user defined style
                    IStyle commonStyle			= this._document.CommonStyles.GetStyleByName(paragraph.StyleName);
                    if(commonStyle == null)
                    {
                        if(this.OnWarning != null)
                        {
                            AODLWarning warning			= new AODLWarning("A ParagraphStyle wasn't found.");
                            warning.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                            warning.Node				= paragraphNode;
                            this.OnWarning(warning);
                        }
                        #region Old code Todo: delete
                        //					XmlNode styleNode		= this._document.XmlDoc.SelectSingleNode(
                        //						"/office:document-content/office:automatic-styles/style:style[@style:name='"+p.Stylename+"']",
                        //						this._document.NamespaceManager);
                        //
                        //					XmlNode styles			= this._document.XmlDoc.SelectSingleNode(
                        //						"/office:document-content/office:automatic-styles",
                        //						this._document.NamespaceManager);
                        //
                        //					if(styleNode != null)
                        //					{
                        //						ParagraphStyle pstyle		= new ParagraphStyle(p, styleNode);
                        //
                        //						XmlNode propertieNode		= styleNode.SelectSingleNode("style:paragraph-properties",
                        //							this._document.NamespaceManager);
                        //
                        //						XmlNode txtpropertieNode	= styleNode.SelectSingleNode("style:text-properties",
                        //							this._document.NamespaceManager);
                        //
                        //						ParagraphProperties pp		= null;
                        //
                        //						XmlNode tabstyles			= null;
                        //
                        //						if(propertieNode != null)
                        //						{
                        //							tabstyles				= styleNode.SelectSingleNode("style:tab-stops",
                        //								this._document.NamespaceManager);
                        //							pp	= new ParagraphProperties(pstyle, propertieNode);
                        //						}
                        //						else
                        //							pp	= new ParagraphProperties(pstyle);
                        //
                        //						pstyle.Properties			= pp;
                        //						if(tabstyles != null)
                        //							pstyle.Properties.TabStopStyleCollection	= this.GetTabStopStyles(tabstyles);
                        //						p.Style						= pstyle;
                        //
                        //						if(txtpropertieNode != null)
                        //						{
                        //							TextProperties tt		= new TextProperties(p.Style);
                        //							tt.Node					= txtpropertieNode;
                        //							((ParagraphStyle)p.Style).Textproperties = tt;
                        //						}
                        //					}
                        #endregion
                    }
                }

                return this.ReadParagraphTextContent(paragraph);
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Exception while trying to create a Paragraph.");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                exception.Node				= paragraphNode;
                exception.OriginalException	= ex;

                throw exception;
            }
        }
Exemplo n.º 8
0
        /// <summary>
        /// Creates the header.
        /// </summary>
        /// <param name="headernode">The headernode.</param>
        /// <returns></returns>
        public Header CreateHeader(XmlNode headernode)
        {
            try
            {
                #region Old code Todo: delete
                //				XmlNode node			= headernode.SelectSingleNode("//@text:style-name", this._document.NamespaceManager);
                //				if(node != null)
                //				{
                //					if(!node.InnerText.StartsWith("Heading"))
                //					{
                //						//Check if a the referenced paragraphstyle reference a heading as parentstyle
                //						XmlNode stylenode	= this._document.XmlDoc.SelectSingleNode("//style:style[@style:name='"+node.InnerText+"']", this._document.NamespaceManager);
                //						if(stylenode != null)
                //						{
                //							XmlNode parentstyle	= stylenode.SelectSingleNode("@style:parent-style-name",
                //								this._document.NamespaceManager);
                //							if(parentstyle != null)
                //								if(parentstyle.InnerText.StartsWith("Heading"))
                //									headernode.SelectSingleNode("@text:style-name",
                //										this._document.NamespaceManager).InnerText = parentstyle.InnerText;
                //						}
                //					}
                //				}
                #endregion
                if(this._debugMode)
                    this.LogNode(headernode, "Log header node before");

                //Create a new Header
                Header header				= new Header(headernode, this._document);
                //Create a ITextCollection
                ITextCollection textColl	= new ITextCollection();
                //Recieve the HeaderStyle
                IStyle headerStyle			= this._document.Styles.GetStyleByName(header.StyleName);

                if(headerStyle != null)
                    header.Style			= headerStyle;

                //Create the IText content
                foreach(XmlNode nodeChild in header.Node.ChildNodes)
                {
                    TextContentProcessor tcp	= new TextContentProcessor();
                    IText iText					= tcp.CreateTextObject(this._document, nodeChild);

                    if(iText != null)
                        textColl.Add(iText);
                    else
                    {
                        if(this.OnWarning != null)
                        {
                            AODLWarning warning			= new AODLWarning("Couldn't create IText object from header child node!.");
                            warning.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                            warning.Node				= nodeChild;
                            this.OnWarning(warning);
                        }
                    }
                }

                //Remove all
                header.Node.InnerXml		= "";

                foreach(IText iText in textColl)
                {
                    if(this._debugMode)
                        this.LogNode(iText.Node, "Log IText node read from header");
                    header.TextContent.Add(iText);
                }

                return header;
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Exception while trying to create a Header.");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                exception.Node				= headernode;
                exception.OriginalException	= ex;

                throw exception;
            }

            return null;
        }
Exemplo n.º 9
0
        /// <summary>
        /// Creates the table cell.
        /// </summary>
        /// <param name="node">The node.</param>
        /// <returns></returns>
        private Cell CreateTableCell(XmlNode node)
        {
            try
            {
                //Create a new Cel
                Cell cell					= new Cell(this._document, node);
                IContentCollection iColl	= new IContentCollection();
                //Recieve CellStyle
                IStyle cellStyle			= this._document.Styles.GetStyleByName(cell.StyleName);

                if(cellStyle != null)
                {
                    int i=0;
                    cell.Style				= cellStyle;
                    if(cellStyle.StyleName == "ce244")
                        i=1;
                }
                //No need for a warning

                //Create the cells content
                foreach(XmlNode nodeChild in cell.Node.ChildNodes)
                {
                    IContent iContent		= this.CreateContent(nodeChild);

                    if(iContent != null)
                    {
                        iColl.Add(iContent);
                    }
                    else
                    {
                        if(this.OnWarning != null)
                        {
                            AODLWarning warning			= new AODLWarning("Couldn't create IContent from a table cell.");
                            warning.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                            warning.Node				= nodeChild;
                            this.OnWarning(warning);
                        }
                    }
                }

                cell.Node.InnerXml			= "";

                foreach(IContent iContent in iColl)
                    cell.Content.Add(iContent);
                return cell;
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Exception while trying to create a Table Row.");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                exception.Node				= node;
                exception.OriginalException	= ex;

                throw exception;
            }
        }
Exemplo n.º 10
0
        /// <summary>
        /// Gets the table as HTML.
        /// </summary>
        /// <param name="table">The table.</param>
        /// <returns></returns>
        public string GetTableAsHtml(Table table)
        {
            //TODO: Implement table border algo
            string html					= "<table border=\"1\" ";

            try
            {
                if(table != null)
                {
                    string style		= this.HTMLStyleBuilder.GetTableStyleAsHtml(table.TableStyle);
                    if(style.Length > 0)
                    {
                        html			+= style;
                        html			+= ">\n";
                    }

                    if(table.RowCollection != null)
                        foreach(Row row in table.RowCollection)
                            html		+= this.GetRowAsHtml(row);
                }
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Exception while trying to build a HTML string from a Table object.");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                exception.OriginalException	= ex;

                throw exception;
            }

            if(!html.Equals("<table border=\"1\" "))
                html				+= "</table>\n";
            else
                html				= "";

            return html;
        }
Exemplo n.º 11
0
        /// <summary>
        /// Gets the row as HTML.
        /// </summary>
        /// <param name="row">The row.</param>
        /// <returns></returns>
        public string GetRowAsHtml(Row row)
        {
            string html					= "<tr>\n";

            try
            {
                if(row != null)
                {
                    if(row.CellCollection != null)
                    {
                        foreach(Cell cell in row.CellCollection)
                            html		+= this.GetCellAsHtml(cell);
                    }
                }
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Exception while trying to build a HTML string from a Row object.");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                exception.OriginalException	= ex;

                throw exception;
            }

            if(!html.Equals("<tr>\n"))
                html				+= "</tr>\n";
            else
                html				= "";

            return html;
        }
Exemplo n.º 12
0
        /// <summary>
        /// Gets the paragraph as HTML.
        /// </summary>
        /// <param name="paragraph">The paragraph.</param>
        /// <returns></returns>
        public string GetParagraphAsHtml(Paragraph paragraph)
        {
            string html					= "<p ";

            try
            {
                if(paragraph != null)
                {
                    if(paragraph.StyleName != null)
                        if(paragraph.StyleName != "Text_20_body"
                            && paragraph.StyleName != "standard"
                            && paragraph.StyleName != "Table_20_body")
                        {
                            string style	= this.HTMLStyleBuilder.GetParagraphStyleAsHtml(paragraph.ParagraphStyle);

                            if(style.Length > 0)
                                html		+= style;//+">\n";
                            else
                            {
                                //Check against a possible common style
                                IStyle iStyle		= paragraph.Document.CommonStyles.GetStyleByName(paragraph.StyleName);
                                string commonStyle	= "";
                                if(iStyle != null && iStyle is ParagraphStyle)
                                {
                                    commonStyle		= this.HTMLStyleBuilder.GetParagraphStyleAsHtml(iStyle as ParagraphStyle);
                                    if(commonStyle.Length > 0)
                                        html		+= commonStyle;
                                    else
                                        html		= html.Replace(" ", "");
                                }
                                else
                                    html		= html.Replace(" ", "");
                            }
                        }
                        else
                        {
                            html			= html.Replace(" ", "");
                        }

                    html					+= ">\n";

                    string txtstyle	= "<span ";
                    bool useTextStyle = false;
                    if(paragraph.ParagraphStyle != null)
                    {
                        string tstyle	= this.HTMLStyleBuilder.GetTextStyleAsHtml(paragraph.ParagraphStyle.TextProperties);
                        if(txtstyle.Length > 0)
                        {
                            txtstyle	+= tstyle+">\n";
                            html		+= txtstyle;
                            useTextStyle = true;
                        }
                    }
                    else
                    {
                        //Check again a possible common style
                        string commonstyle	= "";
                        IStyle iStyle	= paragraph.Document.CommonStyles.GetStyleByName(paragraph.StyleName);
                        if(iStyle != null && iStyle is ParagraphStyle)
                        {
                            commonstyle	= this.HTMLStyleBuilder.GetTextStyleAsHtml(((ParagraphStyle)iStyle).TextProperties);
                            if(commonstyle.Length > 0)
                            {
                                txtstyle	+= commonstyle+">\n";
                                html		+= txtstyle;
                                useTextStyle = true;
                            }
                        }
                    }

                    string mixedCont	= this.GetMixedContentAsHTML(paragraph.MixedContent, paragraph.ParagraphStyle);
                    if(mixedCont.Length > 0)
                        html			+= mixedCont+"&nbsp;";
                    else
                        html			+= "&nbsp;";

                    if(!html.Equals("<p "))
                        if(useTextStyle)
                            html				+= "</span>\n</p>\n";
                        else
                            html				+= "</p>\n";
                    else
                        html				= "";

            if(html.Equals("<p >"))
                html				= "";
                }
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Exception while trying to build a HTML string from a Heading object.");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                exception.OriginalException	= ex;

                throw exception;
            }

            return html;
        }
Exemplo n.º 13
0
        /// <summary>
        /// Gets the mixed content as HTML.
        /// </summary>
        /// <param name="mixedContent">ArrayList of objects. The objects could be
        /// IContent or IText.</param>
        /// <param name="paragraphStyle">The paragraph style.</param>
        /// <returns></returns>
        public string GetMixedContentAsHTML(ArrayList mixedContent, ParagraphStyle paragraphStyle)
        {
            string html					= "";
            int tabStopCnt				= 0;

            try
            {
                if(mixedContent != null)
                {
                    foreach(object ob in mixedContent)
                    {
                        //determine type text content types
                        if(ob is SimpleText)
                        {
                            html			+= this.ReplaceControlNodes(((IText)ob).Node.InnerText);
                        }
                        else if(ob is FormatedText)
                            html			+= this.GetFormatedTextAsHtml(ob as FormatedText);
                        else if(ob is WhiteSpace)
                            html			+= this.GetWhiteSpacesAsHtml(ob as WhiteSpace);
                        else if(ob is TabStop)
                        {
                            html			+= this.GetTabStopAsHtml(ob as TabStop, tabStopCnt, html, paragraphStyle);
                            tabStopCnt++;
                        }
                        else if(ob is XLink)
                            html			+= this.GetXLinkAsHtml(ob as XLink);
                        else if(ob is LineBreak)
                            html			+= this.GetLineBreakAsHtml();
                        else if(ob is UnknownTextContent)
                            html			+= this.GetUnknowTextContentAsHtml(ob as UnknownTextContent);
                            //determine type
                        else if(ob is Table)
                            html			+= this.GetTableAsHtml(ob as Table);
                        else if(ob is Paragraph)
                            html			+= this.GetParagraphAsHtml(ob as Paragraph);
                        else if(ob is List)
                            html			+= this.GetListAsHtml(ob as List);
                        else if(ob is Frame)
                            html			+= this.GetDrawFrameAsHtml(ob as Frame);
                        else if(ob is Graphic)
                            html			+= this.GetGraphicAsHtml(ob as Graphic);
                        else if(ob is ListItem)
                            html			+= this.GetListItemAsHtml(ob as ListItem);
                        else if(ob is Header)
                            html			+= this.GetHeadingAsHtml(ob as Header);
                        else if(ob is UnknownContent)
                            html			+= this.GetUnknowContentAsHtml(ob as UnknownContent);
                        else
                            //this should never happens, because all not implemented elements
                            //are unknwon content
                            if(OnWarning != null)
                        {
                            AODLWarning warning			= new AODLWarning("Finding total unknown content in mixed content. This should (could) never happen.");
                            warning.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                            OnWarning(warning);
                        }
                    }
                }
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Exception while trying to build a HTML string from an ITextCollection.");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                exception.OriginalException	= ex;

                throw exception;
            }

            return html;
        }
Exemplo n.º 14
0
        /// <summary>
        /// Gets the list item as HTML.
        /// </summary>
        /// <param name="listItem">The list item.</param>
        /// <returns></returns>
        public string GetListItemAsHtml(ListItem listItem)
        {
            string html					= "<li>\n";

            try
            {
                if(listItem != null)
                {
                    if(listItem.Content != null)
                    {
                        html			+= this.GetIContentCollectionAsHtml(listItem.Content);
                    }
                }
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Exception while trying to build a HTML string from a ListItem object.");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                exception.OriginalException	= ex;

                throw exception;
            }

            if(!html.Equals("<li>\n"))
                html				+= "</li>\n";
            else
                html				= "";

            return html;
        }
Exemplo n.º 15
0
        /// <summary>
        /// Gets the list as HTML.
        /// </summary>
        /// <param name="list">The list.</param>
        /// <returns></returns>
        public string GetListAsHtml(List list)
        {
            string html					= "<";

            try
            {
                if(list != null)
                {
                    if(list.ListType == ListStyles.Number)
                        html		+= "ol>\n";
                    else
                        html		+= "ul>\n";

                    if(list.Content != null)
                    {
                        foreach(IContent iContent in list.Content)
                            html		+= this.GetIContentCollectionAsHtml(list.Content);
                    }
                }
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Exception while trying to build a HTML string from a List object.");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                exception.OriginalException	= ex;

                throw exception;
            }

            if(html.StartsWith("<ol"))
                html				+= "</ol>\n";
            else if(html.StartsWith("<ul"))
                html				+= "</ul>\n";
            else
                html				= "";

            return html;
        }
Exemplo n.º 16
0
        /// <summary>
        /// Creates the event listeners.
        /// </summary>
        /// <param name="eventListenersNode">The event listeners node.</param>
        /// <returns></returns>
        public EventListeners CreateEventListeners(XmlNode eventListenersNode)
        {
            try
            {
                EventListeners eventList	= new EventListeners(this._document, eventListenersNode);
                IContentCollection iCol		= new IContentCollection();

                if(eventList.Node != null)
                    foreach(XmlNode nodeChild in eventList.Node.ChildNodes)
                    {
                        IContent iContent	= this.CreateContent(nodeChild);
                        if(iContent != null)
                            iCol.Add(iContent);
                    }

                eventList.Node.InnerXml		= "";

                foreach(IContent iContent in iCol)
                    eventList.Content.Add(iContent);

                return eventList;
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Exception while trying to create a ImageMap.");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                exception.Node				= eventListenersNode;
                exception.OriginalException	= ex;

                throw exception;
            }
        }
Exemplo n.º 17
0
        /// <summary>
        /// Creates the frame.
        /// </summary>
        /// <param name="frameNode">The framenode.</param>
        /// <returns>The Frame object.</returns>
        public Frame CreateFrame(XmlNode frameNode)
        {
            try
            {
                #region Old code Todo: delete
                //				Frame frame					= null;
                //				XmlNode graphicnode			= null;
                //				XmlNode graphicproperties	= null;
                //				string realgraphicname		= "";
                //				string stylename			= "";
                //				stylename					= this.GetStyleName(framenode.OuterXml);
                //				XmlNode stylenode			= this.GetAStyleNode("style:style", stylename);
                //				realgraphicname				= this.GetAValueFromAnAttribute(framenode, "@draw:name");
                //
                //				//Console.WriteLine("frame: {0}", framenode.OuterXml);
                //
                //				//Up to now, the only sopported, inner content of a frame is a graphic
                //				if(framenode.ChildNodes.Count > 0)
                //					if(framenode.ChildNodes.Item(0).OuterXml.StartsWith("<draw:image"))
                //						graphicnode			= framenode.ChildNodes.Item(0).CloneNode(true);
                //
                //				//If not graphic, it could be text-box, ole or something else
                //				//try to find graphic frame inside
                //				if(graphicnode == null)
                //				{
                //					XmlNode child		= framenode.SelectSingleNode("//draw:frame", this._document.NamespaceManager);
                //					if(child != null)
                //						frame		= this.CreateFrame(child);
                //					return frame;
                //				}
                //
                //				string graphicpath			= this.GetAValueFromAnAttribute(graphicnode, "@xlink:href");
                //
                //				if(stylenode != null)
                //					if(stylenode.ChildNodes.Count > 0)
                //						if(stylenode.ChildNodes.Item(0).OuterXml.StartsWith("<style:graphic-properties"))
                //							graphicproperties	= stylenode.ChildNodes.Item(0).CloneNode(true);
                //
                //				if(stylename.Length > 0 && stylenode != null && realgraphicname.Length > 0
                //					&& graphicnode != null && graphicpath.Length > 0 && graphicproperties != null)
                //				{
                //					graphicpath				= graphicpath.Replace("Pictures", "");
                //					graphicpath				= OpenDocumentTextImporter.dirpics+graphicpath.Replace("/", @"\");
                //
                //					frame					= new Frame(this._document, stylename,
                //												realgraphicname, graphicpath);
                //
                //					frame.Style.Node		= stylenode;
                //					frame.Graphic.Node		= graphicnode;
                //					((FrameStyle)frame.Style).GraphicProperties.Node = graphicproperties;
                //
                //					XmlNode nodeSize		= framenode.SelectSingleNode("@svg:height",
                //						this._document.NamespaceManager);
                //
                //					if(nodeSize != null)
                //						if(nodeSize.InnerText != null)
                //							frame.GraphicHeight	= nodeSize.InnerText;
                //
                //					nodeSize		= framenode.SelectSingleNode("@svg:width",
                //						this._document.NamespaceManager);
                //
                //					if(nodeSize != null)
                //						if(nodeSize.InnerText != null)
                //							frame.GraphicWidth	= nodeSize.InnerText;
                //				}
                #endregion

                //Create a new Frame
                Frame frame					= new Frame(this._document, null);
                frame.Node					= frameNode;
                IContentCollection iColl	= new IContentCollection();
                //Revieve the FrameStyle
                IStyle frameStyle			= this._document.Styles.GetStyleByName(frame.StyleName);

                if(frameStyle != null)
                    frame.Style					= frameStyle;
                else
                {
                    if(this.OnWarning != null)
                    {
                        AODLWarning warning			= new AODLWarning("Couldn't recieve a FrameStyle.");
                        warning.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                        warning.Node				= frameNode;
                        this.OnWarning(warning);
                    }
                }

                //Create the frame content
                foreach(XmlNode nodeChild in frame.Node.ChildNodes)
                {
                    IContent iContent				= this.CreateContent(nodeChild);
                    if(iContent != null)
                        iColl.Add(iContent);
                    else
                    {
                        if(this.OnWarning != null)
                        {
                            AODLWarning warning			= new AODLWarning("Couldn't create a IContent object for a frame.");
                            warning.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                            warning.Node				= nodeChild;
                            this.OnWarning(warning);
                        }
                    }
                }

                frame.Node.InnerXml					= "";

                foreach(IContent iContent in iColl)
                {
                    frame.Content.Add(iContent);
                    if(iContent is Graphic)
                    {
                        frame.LoadImageFromFile(((Graphic)iContent).GraphicRealPath);
                    }
                }

                return frame;
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Exception while trying to create a Frame.");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                exception.Node				= frameNode;
                exception.OriginalException	= ex;

                throw exception;
            }
        }
Exemplo n.º 18
0
        /// <summary>
        /// Creates the table cell span.
        /// </summary>
        /// <param name="node">The node.</param>
        /// <returns></returns>
        private CellSpan CreateTableCellSpan(XmlNode node)
        {
            try
            {
                //Create a new CellSpan
                CellSpan cellSpan			= new CellSpan(this._document, node);

                //No need for a warnings or styles

                return cellSpan;
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Exception while trying to create a Table CellSpan.");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                exception.Node				= node;
                exception.OriginalException	= ex;

                throw exception;
            }
        }
Exemplo n.º 19
0
        /// <summary>
        /// Creates the content.
        /// </summary>
        /// <param name="node">The node.</param>
        public void CreateMainContent(XmlNode node)
        {
            try
            {
                foreach(XmlNode nodeChild in node.ChildNodes)
                {
                    IContent iContent		= this.CreateContent(nodeChild.CloneNode(true));

                    if(iContent != null)
                        this._document.Content.Add(iContent);
                    else
                    {
                        if(this.OnWarning != null)
                        {
                            AODLWarning warning			= new AODLWarning("A couldn't create any content from an an first level node!.");
                            warning.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                            warning.Node				= nodeChild;
                            this.OnWarning(warning);
                        }
                    }
                }
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Exception while processing a content node.");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                exception.Node				= node;
                exception.OriginalException	= ex;

                throw exception;
            }
        }
Exemplo n.º 20
0
        /// <summary>
        /// Creates the table column.
        /// </summary>
        /// <param name="node">The node.</param>
        /// <returns></returns>
        private Column CreateTableColumn(XmlNode node)
        {
            try
            {
                //Create a new Row
                Column column				= new Column(this._document, node);
                //Recieve RowStyle
                IStyle columnStyle			= this._document.Styles.GetStyleByName(column.StyleName);

                if(columnStyle != null)
                    column.Style			= columnStyle;
                //No need for a warning

                return column;
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Exception while trying to create a Table Column.");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                exception.Node				= node;
                exception.OriginalException	= ex;

                throw exception;
            }
        }
Exemplo n.º 21
0
        /// <summary>
        /// Reads the content nodes.
        /// </summary>
        public void ReadContentNodes()
        {
            try
            {
                //				this._document.XmlDoc	= new XmlDocument();
                //				this._document.XmlDoc.Load(contentFile);

                XmlNode node				= null;

                if(this._document is TextDocument)
                    node	= this._document.XmlDoc.SelectSingleNode(TextDocumentHelper.OfficeTextPath, this._document.NamespaceManager);
                else if(this._document is SpreadsheetDocument)
                    node	= this._document.XmlDoc.SelectSingleNode(
                        "/office:document-content/office:body/office:spreadsheet", this._document.NamespaceManager);

                if(node != null)
                {
                    this.CreateMainContent(node);
                }
                else
                {
                    AODLException exception		= new AODLException("Unknow content type.");
                    exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                    throw exception;
                }
                //Remove all existing content will be created new
                node.RemoveAll();
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Error while trying to load the content file!");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                throw exception;
            }
        }
Exemplo n.º 22
0
        /// <summary>
        /// Creates the table of contents.
        /// </summary>
        /// <param name="tocNode">The toc node.</param>
        /// <returns></returns>
        private TableOfContents CreateTableOfContents(XmlNode tocNode)
        {
            try
            {
                if(this._document is TextDocument)
                {
                    //Create the TableOfContents object
                    TableOfContents tableOfContents		= new TableOfContents(
                        ((TextDocument)this._document), tocNode);
                    //Recieve the Section style
                    IStyle sectionStyle					= this._document.Styles.GetStyleByName(tableOfContents.StyleName);

                    if(sectionStyle != null)
                        tableOfContents.Style				= sectionStyle;
                    else
                    {
                        if(this.OnWarning != null)
                        {
                            AODLWarning warning			= new AODLWarning("A SectionStyle for the TableOfContents object wasn't found.");
                            warning.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                            warning.Node				= tocNode;
                            this.OnWarning(warning);
                        }
                    }

                    //Create the text entries
                    XmlNodeList paragraphNodeList	= tocNode.SelectNodes(
                        "text:index-body/text:p", this._document.NamespaceManager);
                    XmlNode indexBodyNode			= tocNode.SelectSingleNode("text:index-body",
                        this._document.NamespaceManager);
                    tableOfContents._indexBodyNode	= indexBodyNode;
                    IContentCollection pCollection	= new IContentCollection();

                    foreach(XmlNode paragraphnode in paragraphNodeList)
                    {
                        Paragraph paragraph			= this.CreateParagraph(paragraphnode);
                        if(indexBodyNode != null)
                            indexBodyNode.RemoveChild(paragraphnode);
                        pCollection.Add(paragraph);
                    }

                    foreach(IContent content in pCollection)
                        tableOfContents.Content.Add(content);

                    return tableOfContents;
                }

                return null;
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Exception while trying to create a TableOfContents.");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                exception.Node				= tocNode;
                exception.OriginalException	= ex;

                throw exception;
            }
        }
Exemplo n.º 23
0
        /// <summary>
        /// Creates the draw text box.
        /// </summary>
        /// <param name="drawTextBoxNode">The draw text box node.</param>
        /// <returns></returns>
        private DrawTextBox CreateDrawTextBox(XmlNode drawTextBoxNode)
        {
            try
            {
                DrawTextBox drawTextBox		= new DrawTextBox(this._document, drawTextBoxNode);
                IContentCollection iColl	= new IContentCollection();

                foreach(XmlNode nodeChild in drawTextBox.Node.ChildNodes)
                {
                    IContent iContent				= this.CreateContent(nodeChild);
                    if(iContent != null)
                        iColl.Add(iContent);
                    else
                    {
                        if(this.OnWarning != null)
                        {
                            AODLWarning warning			= new AODLWarning("Couldn't create a IContent object for a DrawTextBox.");
                            warning.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                            warning.Node				= nodeChild;
                            this.OnWarning(warning);
                        }
                    }
                }

                drawTextBox.Node.InnerXml					= "";

                foreach(IContent iContent in iColl)
                    drawTextBox.Content.Add(iContent);

                return drawTextBox;
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Exception while trying to create a Graphic.");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                exception.Node				= drawTextBoxNode;
                exception.OriginalException	= ex;

                throw exception;
            }
        }
Exemplo n.º 24
0
        /// <summary>
        /// Creates the table row.
        /// </summary>
        /// <param name="node">The node.</param>
        /// <returns></returns>
        private Row CreateTableRow(XmlNode node)
        {
            try
            {
                //Create a new Row
                Row row						= new Row(this._document, node);
                IContentCollection iColl	= new IContentCollection();
                //Recieve RowStyle
                IStyle rowStyle				= this._document.Styles.GetStyleByName(row.StyleName);

                if(rowStyle != null)
                    row.Style				= rowStyle;
                //No need for a warning

                //Create the cells
                foreach(XmlNode nodeChild in row.Node.ChildNodes)
                {
                    IContent iContent		= this.CreateContent(nodeChild);

                    if(iContent != null)
                    {
                        iColl.Add(iContent);
                    }
                    else
                    {
                        if(this.OnWarning != null)
                        {
                            AODLWarning warning			= new AODLWarning("Couldn't create IContent from a table row.");
                            warning.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                            warning.Node				= nodeChild;
                            this.OnWarning(warning);
                        }
                    }
                }

                row.Node.InnerXml			= "";

                foreach(IContent iContent in iColl)
                {
                    if(iContent is Cell)
                    {
                        ((Cell)iContent).Row		= row;
                        row.CellCollection.Add(iContent as Cell);
                    }
                    else if(iContent is CellSpan)
                    {
                        ((CellSpan)iContent).Row	= row;
                        row.CellSpanCollection.Add(iContent as CellSpan);
                    }
                    else
                    {
                        if(this.OnWarning != null)
                        {
                            AODLWarning warning			= new AODLWarning("Couldn't create IContent from a row node. Content is unknown table row content!");
                            warning.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                            warning.Node				= iContent.Node;
                            this.OnWarning(warning);
                        }
                    }
                }

                return row;
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Exception while trying to create a Table Row.");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                exception.Node				= node;
                exception.OriginalException	= ex;

                throw exception;
            }
        }
Exemplo n.º 25
0
        /// <summary>
        /// Creates the image map.
        /// </summary>
        /// <param name="imageMapNode">The image map node.</param>
        /// <returns></returns>
        private ImageMap CreateImageMap(XmlNode imageMapNode)
        {
            try
            {
                ImageMap imageMap			= new ImageMap(this._document, imageMapNode);
                IContentCollection iCol		= new IContentCollection();

                if(imageMap.Node != null)
                    foreach(XmlNode nodeChild in imageMap.Node.ChildNodes)
                    {
                        IContent iContent	= this.CreateContent(nodeChild);
                        if(iContent != null)
                            iCol.Add(iContent);
                    }

                imageMap.Node.InnerXml		= "";

                foreach(IContent iContent in iCol)
                    imageMap.Content.Add(iContent);

                return imageMap;
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Exception while trying to create a ImageMap.");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                exception.Node				= imageMapNode;
                exception.OriginalException	= ex;

                throw exception;
            }
        }
Exemplo n.º 26
0
        /// <summary>
        /// Reads the content of the paragraph text.
        /// </summary>
        /// <param name="paragraph">The paragraph.</param>
        /// <returns></returns>
        private Paragraph ReadParagraphTextContent(Paragraph paragraph)
        {
            try
            {
                if(this._debugMode)
                    this.LogNode(paragraph.Node, "Log Paragraph node before");

                ArrayList mixedContent			= new ArrayList();
                foreach(XmlNode nodeChild in paragraph.Node.ChildNodes)
                {
                    //Check for IText content first
                    TextContentProcessor tcp	= new TextContentProcessor();
                    IText iText					= tcp.CreateTextObject(this._document, nodeChild.CloneNode(true));

                    if(iText != null)
                        mixedContent.Add(iText);
                    else
                    {
                        //Check against IContent
                        IContent iContent		= this.CreateContent(nodeChild);

                        if(iContent != null)
                            mixedContent.Add(iContent);
                    }
                }

                //Remove all
                paragraph.Node.InnerXml			= "";

                foreach(Object ob in mixedContent)
                {
                    if(ob is IText)
                    {
                        if(this._debugMode)
                            this.LogNode(((IText)ob).Node, "Log IText node read");
                        paragraph.TextContent.Add(ob as IText);
                    }
                    else if(ob is IContent)
                    {
                        if(this._debugMode)
                            this.LogNode(((IContent)ob).Node, "Log IContent node read");
                        paragraph.Content.Add(ob as IContent);
                    }
                    else
                    {
                        if(this.OnWarning != null)
                        {
                            AODLWarning warning			= new AODLWarning("Couldn't determine the type of a paragraph child node!.");
                            warning.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                            warning.Node				= paragraph.Node;
                            this.OnWarning(warning);
                        }
                    }
                }

                if(this._debugMode)
                    this.LogNode(paragraph.Node, "Log Paragraph node after");

                return paragraph;
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Exception while trying to create the Paragraph content.");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                exception.Node				= paragraph.Node;
                exception.OriginalException	= ex;

                throw exception;
            }
        }
Exemplo n.º 27
0
        /// <summary>
        /// Creates the list item.
        /// </summary>
        /// <param name="node">The node.</param>
        /// <returns></returns>
        private ListItem CreateListItem(XmlNode node)
        {
            try
            {

                ListItem listItem			= new ListItem(this._document);
                IContentCollection iColl	= new IContentCollection();
                listItem.Node				= node;

                foreach(XmlNode nodeChild in listItem.Node.ChildNodes)
                {
                    IContent iContent		= this.CreateContent(nodeChild);
                    if(iContent != null)
                        iColl.Add(iContent);
                    else
                    {
                        if(this.OnWarning != null)
                        {
                            AODLWarning warning			= new AODLWarning("Couldn't create a IContent object for a ListItem.");
                            warning.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                            warning.Node				= nodeChild;
                            this.OnWarning(warning);
                        }
                    }
                }

                listItem.Node.InnerXml		= "";

                foreach(IContent iContent in iColl)
                    listItem.Content.Add(iContent);

                return listItem;
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Exception while trying to create a ListItem.");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                exception.Node				= node;
                exception.OriginalException	= ex;

                throw exception;
            }
        }
Exemplo n.º 28
0
        /// <summary>
        /// Gets the content.
        /// </summary>
        /// <param name="node">The node.</param>
        /// <returns></returns>
        public IContent CreateContent(XmlNode node)
        {
            try
            {
                switch(node.Name)
                {
                    case "text:p":
                        return CreateParagraph(node.CloneNode(true));
                    case "text:list":
                        return CreateList(node.CloneNode(true));
                    case "text:list-item":
                        return CreateListItem(node.CloneNode(true));
                    case "table:table":
                        return CreateTable(node.CloneNode(true));
                    case "table:table-column":
                        return CreateTableColumn(node.CloneNode(true));
                    case "table:table-row":
                        return CreateTableRow(node.CloneNode(true));
                    case "table:table-header-rows":
                        return CreateTableHeaderRow(node.CloneNode(true));
                    case "table:table-cell":
                        return CreateTableCell(node.CloneNode(true));
                    case "table:covered-table-cell":
                        return CreateTableCellSpan(node.CloneNode(true));
                    case "text:h":
                        return CreateHeader(node.CloneNode(true));
                    case "text:table-of-content":
                        //Possible?
                        return CreateTableOfContents(node.CloneNode(true));
                    case "draw:frame":
                        return CreateFrame(node.CloneNode(true));
                    case "draw:text-box":
                        return CreateDrawTextBox(node.CloneNode(true));
                    case "draw:image":
                        return CreateGraphic(node.CloneNode(true));
                    case "draw:area-rectangle":
                        return CreateDrawAreaRectangle(node.CloneNode(true));
                    case "draw:area-circle":
                        return CreateDrawAreaCircle(node.CloneNode(true));
                    case "draw:image-map":
                        return CreateImageMap(node.CloneNode(true));
                    case "office:event-listeners":
                        return CreateEventListeners(node.CloneNode(true));
                    case "script:event-listener":
                        return CreateEventListeners(node.CloneNode(true));
                    default:
                        return new UnknownContent(this._document, node.CloneNode(true));
                }
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Exception while processing a content node.");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                exception.Node				= node;
                exception.OriginalException	= ex;

                throw exception;
            }
        }
Exemplo n.º 29
0
        /// <summary>
        /// Load internal and external exporter.
        /// </summary>
        /// <returns></returns>
        private ArrayList LoadExporter()
        {
            try
            {
                ArrayList alExporter			= new ArrayList();

                alExporter.Add(new OpenDocumentTextExporter());
                alExporter.Add(new OpenDocumentHtmlExporter());

                return alExporter;
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Error while trying to load the exporter.");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                exception.OriginalException	= ex;
                throw exception;
            }
        }
Exemplo n.º 30
0
        /// <summary>
        /// Creates the event listener.
        /// </summary>
        /// <param name="eventListenerNode">The event listener node.</param>
        /// <returns></returns>
        public EventListener CreateEventListener(XmlNode eventListenerNode)
        {
            try
            {
                EventListener eventListener	= new EventListener(this._document, eventListenerNode);

                return eventListener;
            }
            catch(Exception ex)
            {
                AODLException exception		= new AODLException("Exception while trying to create a EventListener.");
                exception.InMethod			= AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
                exception.Node				= eventListenerNode;
                exception.OriginalException	= ex;

                throw exception;
            }
        }