Example #1
0
        private async void LoadRageXML_Click(object sender, RoutedEventArgs e)
        {
            Ragecomic comic = new Ragecomic();

            System.Windows.Forms.OpenFileDialog ofd = new System.Windows.Forms.OpenFileDialog();
            //ofd.InitialDirectory = ".";
            ofd.RestoreDirectory = true;
            ofd.Filter           = "Ragemaker .xml file (*.xml)|*.xml";
            ofd.Title            = "Select ragemaker .xml file to convert to PDF";
            if (ofd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                string filename = ofd.FileNames[0];

                // Open File
                using (FileStream fs = new FileStream(filename, FileMode.Open))
                {
                    XmlReaderSettings settings = new XmlReaderSettings();
                    settings.Async = true;

                    // Read XML
                    using (XmlReader reader = XmlReader.Create(fs, settings))
                    {
                        while (await reader.ReadAsync())
                        {
                            string elementName = reader.Name;
                            switch (elementName)
                            {
                            /*
                             * <panels>8</panels>
                             * <gridLinesArray>111001110011100</gridLinesArray>
                             * <gridAboveAll>true</gridAboveAll>
                             * <showGrid>true</showGrid>
                             * <redditWatermark>false</redditWatermark>
                             */
                            case "panels":
                                int panels = int.Parse(reader.ReadInnerXml());
                                status.Text += "panels: " + panels.ToString() + "\n";
                                comic.panels = panels;
                                break;

                            case "gridLinesArray":
                                string gridLinesArray = reader.ReadInnerXml();
                                status.Text += "gridLinesArray: " + gridLinesArray + "\n";
                                int matrices = gridLinesArray.Length / 5;
                                comic.gridLines = new int[matrices, 5];
                                for (var i = 0; i < gridLinesArray.Length; i++)
                                {
                                    int matrixIndex = (int)Math.Floor((double)i / 5);
                                    int subIndex    = i % 5;
                                    comic.gridLines[matrixIndex, subIndex] = int.Parse(gridLinesArray[i].ToString());
                                    //status.Text += comic.gridLines[i] + "\n";
                                }
                                //comic.panels = panels;
                                break;

                            case "gridAboveAll":
                                comic.gridAboveAll = bool.Parse(reader.ReadInnerXml());
                                status.Text       += "gridAboveAll: " + comic.gridAboveAll + "\n";
                                break;

                            case "showGrid":
                                comic.showGrid = bool.Parse(reader.ReadInnerXml());
                                status.Text   += "showGrid: " + comic.showGrid + "\n";
                                break;

                            case "redditWatermark":
                                comic.redditWatermark = bool.Parse(reader.ReadInnerXml());
                                status.Text          += "redditWatermark: " + comic.redditWatermark + "\n";
                                break;

                            case "Face":
                            case "Text":
                            case "AnyFont":
                            case "Draw":
                            case "Image":
                                if (reader.NodeType == XmlNodeType.EndElement)
                                {
                                    break;
                                }
                                using (XmlReader subtreeReader = reader.ReadSubtree())
                                {
                                    RageItem newItem = await RageItem.createRageItem(elementName, subtreeReader);

                                    comic.items.Add(newItem);
                                    status.Text += "new item: " + newItem.ToString() + "\n";
                                }
                                break;

                            default:
                                break;
                            }
                        }
                    }
                }
                status.Text += filename + " was parsed successfully.\n\n\nProceeding to PDF generation\n\n\n";

                RagecomicToPDF.MakePDF(comic, filename + ".pdf");
            }
            else
            {
                MessageBox.Show("error");
            }

            Thread thread = new Thread(LoadAndProcessRageXML);

            thread.Start();
        }
Example #2
0
        public static async Task <RageItem> createRageItem(string elementName, XmlReader subtree)
        {
            RageItem item = new RageItem();

            switch (elementName)
            {
            case "Face":
                item = new Face();
                break;

            case "Text":
                item = new Text();
                break;

            case "AnyFont":
                item = new AnyFontText();
                break;

            case "Draw":
            case "Image":
                item = new DrawImage();
                break;

            default:
                break;
            }

            while (await subtree.ReadAsync())
            {
                switch (subtree.Name)
                {
                case "itemx":
                    item.x = float.Parse(subtree.ReadInnerXml());
                    break;

                case "itemy":
                    item.y = float.Parse(subtree.ReadInnerXml());
                    break;

                case "opacity":
                    item.opacity = float.Parse(subtree.ReadInnerXml());
                    break;

                case "rotation":
                    item.rotation = float.Parse(subtree.ReadInnerXml());
                    break;

                default:
                    break;
                }

                //Image or Draw
                if (item is DrawImage)
                {
                    switch (subtree.Name)
                    {
                    //DrawImage
                    case "bytes":
                        byte[] decoded = System.Convert.FromBase64String(subtree.ReadInnerXml());
                        ((DrawImage)item).imagedata = decoded;
                        break;

                    default:
                        break;
                    }
                }

                //Text
                if (item is Text)
                {
                    switch (subtree.Name)
                    {
                    case "width":
                        ((Text)item).width = float.Parse(subtree.ReadInnerXml());
                        break;

                    case "height":
                        ((Text)item).height = float.Parse(subtree.ReadInnerXml());
                        break;

                    case "color":
                        ((Text)item).color = "#" + (int.Parse(subtree.ReadInnerXml())).ToString("X").PadLeft(6, "0"[0]);
                        break;

                    case "style":
                        ((Text)item).style = int.Parse(subtree.ReadInnerXml());
                        break;

                    case "size":
                        ((Text)item).size = float.Parse(subtree.ReadInnerXml());
                        break;

                    case "text":
                        ((Text)item).text = HttpUtility.HtmlDecode(subtree.ReadInnerXml());
                        break;

                    case "align":
                        string align = subtree.ReadInnerXml();
                        ((Text)item).align = align == "left" ? Text.ALIGN.LEFT : (align == "right" ? Text.ALIGN.RIGHT : Text.ALIGN.CENTER);
                        break;

                    case "bgOn":
                        ((Text)item).bgOn = bool.Parse(subtree.ReadInnerXml());
                        break;

                    case "bgColor":
                        ((Text)item).bgColor = "#" + (int.Parse(subtree.ReadInnerXml())).ToString("X").PadLeft(6, "0"[0]);
                        break;

                    default:
                        break;
                    }

                    if (item is AnyFontText)
                    {
                        switch (subtree.Name)
                        {
                        case "font":
                            ((AnyFontText)item).font = HttpUtility.HtmlDecode(subtree.ReadInnerXml());
                            break;

                        case "bold":
                            ((AnyFontText)item).bold = bool.Parse(subtree.ReadInnerXml());
                            break;

                        case "italic":
                            ((AnyFontText)item).italic = bool.Parse(subtree.ReadInnerXml());
                            break;

                        case "underline":
                            ((AnyFontText)item).underline = bool.Parse(subtree.ReadInnerXml());
                            break;

                        default:
                            break;
                        }
                    }
                }

                //Face
                if (item is Face)
                {
                    switch (subtree.Name)
                    {
                    case "facename":
                        ((Face)item).file = HttpUtility.UrlDecode(subtree.ReadInnerXml());
                        break;

                    case "scalex":
                        ((Face)item).scalex = float.Parse(subtree.ReadInnerXml());
                        break;

                    case "scaley":
                        ((Face)item).scaley = float.Parse(subtree.ReadInnerXml());
                        break;

                    case "mirrored":
                        ((Face)item).mirrored = bool.Parse(subtree.ReadInnerXml());
                        break;

                    default:
                        break;
                    }
                }
            }

            return(item);
        }