예제 #1
0
        static void Main()
        {
            SetProcessDpiAwareness(PROCESS_DPI_AWARENESS.PROCESS_SYSTEM_DPI_AWARE);

            Environment.CurrentDirectory = new FileInfo(Application.ExecutablePath).DirectoryName;
            MainLog = new MessageLog();
            ResManager.Init();
            MainLog.SetOutputFile(new FileInfo(ResManager.GetLogfileName()));
            MainLog.AddLong(0, MessageType.MSG, "Program started",
                            "current directory: " + Environment.CurrentDirectory
                            + "\n\nargs:\n" + string.Join("\n", Environment.GetCommandLineArgs())
                            + "\n\nfiles:\n" + string.Join("\n", Directory.GetFiles(".")));
            MainLog.AddLong(0, MessageType.MSG, "Build info", ResManager.GetText("buildinfo.txt"));

            Configuration.StoreAsDefault();
            Configuration.LoadConfig();
            Style.SetStyle();
            ResManager.DeleteOldLogs(Configuration.NumberOfLogs);
            TmpManager.Init();
            Language.Init();
            MainLog.Add(MessageType.MSG, "Set Pointer Gamma");
            PointerManager.Gamma = Configuration.PreassureGamma;
            MainLog.Add(MessageType.MSG, "Load Window Icon");
            WindowIcon = Properties.Resources.KritzelIcon;//Icon.FromHandle(Properties.Resources.KritzelIcon.GetHicon());
            MainLog.Add(MessageType.MSG, "Look for temporary Data");
            RestoreData = TmpManager.OvertakeFirstUnused();
            MainLog.Add(MessageType.MSG, "Enable Window");
            if (Configuration.EnableVisualStyle)
            {
                Application.EnableVisualStyles();
            }
            Application.SetCompatibleTextRenderingDefault(false);
            //DebugInterface.Start();
            Application.Run(new MainWindow());
            //DebugInterface.Stop();
            HTTPCast.StopCasting();
        }
예제 #2
0
        public static void LoadConfig()
        {
            MessageLog loadingLog = new MessageLog(Program.MainLog);

            Program.MainLog.Add(MessageType.MSG, "Loading Configurations from '{0}'", FILENAME);
            if (!File.Exists(FILENAME))
            {
                Program.MainLog.Add(MessageType.MSG, "File does not exist, creating file...");
                loadingLog.Add(MessageType.MSG, "File '{0}' doesnt exist", FILENAME);
                SaveConfig();
                return;
            }

            FileStream   stream  = File.OpenRead(FILENAME);
            StreamReader reader  = new StreamReader(stream);
            Type         type    = typeof(Configuration);
            string       logText = "";

            while (!reader.EndOfStream)
            {
                string line = reader.ReadLine();
                int    sep  = line.IndexOf(SEPARATOR);
                if (sep > 0 && !line.StartsWith("#"))
                {
                    string key   = line.Substring(0, sep);
                    string value = line.Substring(sep + 1);
                    logText += key + "=" + value + "\n";

                    FieldInfo field           = type.GetField(key);
                    bool      parameterExists = false;
                    if (field != null && field.IsStatic)
                    {
                        IEnumerable <CP> cps = field.GetCustomAttributes <CP>();
                        if (cps.Count() > 0)
                        {
                            parameterExists = true;
                            Type ft = field.FieldType;
                            bool canParse;
                            if (ft == typeof(bool))
                            {
                                bool v;
                                canParse = bool.TryParse(value, out v);
                                field.SetValue(null, v);
                            }
                            else if (ft == typeof(int))
                            {
                                int v;
                                canParse = int.TryParse(value, out v);
                                field.SetValue(null, v);
                            }
                            else if (ft == typeof(float))
                            {
                                float v;
                                canParse = Util.TrySToF(value, out v);
                                field.SetValue(null, v);
                            }
                            else if (ft == typeof(string))
                            {
                                field.SetValue(null, value);
                                canParse = true;
                            }
                            else if (ft.IsEnum)
                            {
                                try
                                {
                                    object v = Enum.Parse(ft, value, true);
                                    field.SetValue(null, v);
                                    canParse = true;
                                }
                                catch (Exception)
                                {
                                    canParse = false;
                                }
                            }
                            else
                            {
                                canParse = true;
                                loadingLog.Add(MessageType.ERROR, "Internal Error: cant parse key '{0}' to type '{1}'", key, ft.FullName);
                            }

                            if (!canParse)
                            {
                                loadingLog.Add(MessageType.ERROR, "Cant parse value '{0}' for key '{0}", value, key);
                            }
                        }
                    }
                    if (!parameterExists)
                    {
                        loadingLog.Add(MessageType.WARN, "The Configuration Parameter '{0}' does not exists", key);
                    }
                }
            }
            Program.MainLog.AddLong(1, MessageType.MSG, "Configuration loaded", logText);
            reader.Close();
            stream.Close();
            stream.Dispose();
        }
예제 #3
0
 public void LoadFromString(string txt, MessageLog log)
 {
     lock (this)
     {
         StringReader input = new StringReader(txt);
         Line         line  = null;
         lines.Clear();
         using (XmlReader xml = XmlReader.Create(input))
         {
             while (xml.Read())
             {
                 if (xml.NodeType == XmlNodeType.Element)
                 {
                     if (xml.Name == "Line")
                     {
                         string typeN = xml.GetAttribute("type");
                         string param = xml.GetAttribute("params");
                         string color = null;
                         try
                         {
                             color = xml.GetAttribute("color");
                         }
                         catch (Exception) { }
                         Type t = Assembly.GetCallingAssembly().GetType(typeN);
                         line = t.GetConstructor(new Type[0]).Invoke(new object[0]) as Line;
                         if (line != null)
                         {
                             if (line is Forms.TransformableForm)
                             {
                                 try
                                 {
                                     var strMat = xml.GetAttribute("matrix");
                                     ((Forms.TransformableForm)line).Transformation
                                         = Matrix3x3.LoadFromString(strMat);
                                 }
                                 catch (Exception) { }
                             }
                             line.FromParamString(param);
                             line.CalcSpline();
                             line.CalculateBounds();
                         }
                         if (color == null)
                         {
                             line.Brush = PBrush.CreateSolid(Color.Black);
                         }
                         else
                         {
                             line.Brush = PBrush.CreateSolid(ColorTranslator.FromHtml(color));
                         }
                         lines.Add(line);
                     }
                     else if (xml.Name == "Brush")
                     {
                         PBrush brush = PBrush.FromStrings(
                             xml.GetAttribute("type"),
                             xml.GetAttribute("color"),
                             xml.GetAttribute("nums"));
                         if (line != null)
                         {
                             line.Brush = brush;
                         }
                     }
                     else if (xml.Name == "Format")
                     {
                         float w      = 1;
                         float h      = 1;
                         float border = 15;
                         Util.TrySToF(xml.GetAttribute("w"), out w);
                         Util.TrySToF(xml.GetAttribute("h"), out h);
                         Util.TrySToF(xml.GetAttribute("border"), out border);
                         Border = border;
                         Format = new PageFormat(w, h);
                         string backgroundName = xml.GetAttribute("background");
                         Type   backgroundType = Type.GetType(backgroundName);
                         Backgrounds.Background bgr;
                         if (backgroundType == null)
                         {
                             bgr = null;
                             if (backgroundName != "null")
                             {
                                 log?.Add(MessageType.WARN, "Background '{0}'", backgroundName);
                             }
                         }
                         else
                         {
                             bgr = (Backgrounds.Background)backgroundType
                                   .GetConstructor(new Type[0])
                                   .Invoke(new object[0]);
                         }
                         Background = bgr;
                     }
                     else if (xml.Name == "CreationTime")
                     {
                         bool show = xml.GetAttribute("show") == "true";
                         long time = 0;
                         long.TryParse(xml.GetAttribute("date"), out time);
                         ShowDate     = show;
                         CreationTime = DateTime.FromFileTime(time);
                     }
                     else if (xml.Name == "Name")
                     {
                         Name = xml.GetAttribute("value");
                     }
                     else if (xml.Name == "Filter")
                     {
                         string filterName = xml.ReadElementContentAsString();
                         if (Enum.TryParse <ColorFilter>(filterName, out ColorFilter filter))
                         {
                             Filter = filter;
                         }
                         else
                         {
                             log?.Add(0, MessageType.WARN, "Cant parse the ColorFilter '{0}'", filterName);
                         }
                     }
                 }
                 else if (xml.NodeType == XmlNodeType.EndElement)
                 {
                     if (xml.Name == "Line")
                     {
                         line = null;
                     }
                 }
             }
         }
     }
 }
예제 #4
0
 public MessageLog(MessageLog parent)
 {
     this.parent = parent;
 }
예제 #5
0
        public bool LoadDocument(string path, MessageLog log)
        {
            log?.Add(MessageType.MSG, "Loading File '{0}'", path);
            DirectoryInfo dir = TmpManager.GetTmpDir();

            if (path != null)
            {
                ZipFile zip = new ZipFile(path);
                if (dir.Exists)
                {
                    dir.RemoveAll();
                }
                try
                {
                    zip.ExtractAll(dir.FullName);
                }
                catch (BadPasswordException)
                {
                    Dialogues.PasswordDialog dialog = new Dialogues.PasswordDialog();
                    var res = dialog.ShowDialog(out string pw, delegate(string _password)
                    {
                        try
                        {
                            zip.Password = _password;
                            zip.ExtractAll(dir.FullName);
                            return(true);
                        }
                        catch (BadPasswordException)
                        {
                            return(false);
                        }
                    });
                    if (res == DialogResult.Cancel)
                    {
                        return(false);
                    }
                }
            }
            FileInfo    docFile = new FileInfo(dir + "\\document.kritzel");
            XmlReader   reader  = XmlReader.Create(docFile.FullName);
            XmlDocument doc     = new XmlDocument();

            doc.Load(reader);
            reader.Close();
            XmlNode root      = doc.LastChild;
            XmlNode pagesNode = root.GetNode("Pages");
            //Bitmap[] bgrs = new Bitmap[0];
            PdfDocument pdfDoc  = null;
            bool        loadPdf = false;

            if (File.Exists(dir + "\\.pdf"))
            {
                //bgrs = MupdfSharp.PageRenderer.Render(dir + "\\.pdf", Dialogues.PDFImporter.PAGETHEIGHTPIXEL);
                pdfDoc  = PdfSharp.Pdf.IO.PdfReader.Open(dir + "\\.pdf", PdfDocumentOpenMode.Modify | PdfDocumentOpenMode.Import);
                loadPdf = true;
            }
            int ind = 1;

            foreach (XmlNode xmlPage in pagesNode.GetNodes("Page"))
            {
                string src  = xmlPage.Attributes.GetNamedItem("src").InnerText;
                string text = File.ReadAllText(dir.FullName + "\\" + src);
                KPage  page = new KPage(this);
                log?.Add(MessageType.MSG, "Loading Page {0}", ind++);
                page.LoadFromString(text, log);
                int pdfInd;
                int.TryParse(xmlPage.Attributes["pdf"].Value, out pdfInd);
                if (pdfInd >= 0 && loadPdf)
                {
                    //page.BackgroundImage = new Renderer.Image(bgrs[pdfInd]);
                    page.OriginalPage  = pdfDoc.Pages[pdfInd];
                    page.PdfRenderPath = TmpManager.NewFilename(TmpManager.GetTmpDir() + "\\render", "page", ".png");
                }
                Pages.Add(page);
            }

            var defForm = doc.GetElementsByTagName("DefaultFormat");

            if (defForm.Count > 0)
            {
                DefaultFormat = defForm[0].InnerText;
            }

            if (loadPdf)
            {
                pdfDoc.Close();
                pdfDoc.Dispose();
            }

            this.FilePath = path;
            SetCurrentStateAsSaved();
            return(true);
        }
예제 #6
0
        public bool SaveDocument(string path)
        {
            try
            {
                Console.WriteLine("Saving file to ", path != null ? path : "temp");
                MessageLog log = new MessageLog(Program.MainLog);
                if (path == null)
                {
                    log.Add(MessageType.MSG, "Saving file to temp dir");
                }
                else
                {
                    log.Add(MessageType.MSG, "Saving file to {0}", path);
                }

                List <FileInfo> files = new List <FileInfo>();
                DirectoryInfo   dir   = TmpManager.GetTmpDir();
                if (dir.Exists)
                {
                    dir.RemoveAll();
                }
                dir.Create();
                FileInfo          docFile  = new FileInfo(dir + "\\document.kritzel");
                XmlWriterSettings settings = new XmlWriterSettings();
                settings.Indent       = true;
                settings.IndentChars  = "  ";
                settings.NewLineChars = "\n";
                files.Add(docFile);
                using (XmlWriter writer = XmlWriter.Create(docFile.FullName, settings))
                {
                    PdfDocument pdfDoc = new PdfDocument();
                    writer.WriteStartElement("Document");
                    writer.WriteElementString("DefaultFormat", DefaultFormat);
                    writer.WriteStartElement("Pages");
                    for (int i = 0; i < Pages.Count; i++)
                    {
                        writer.WriteStartElement("Page");
                        FileInfo pageFile = new FileInfo(dir + "\\Page" + i + ".xml");
                        string   page     = Pages[i].SaveToString();
                        File.WriteAllText(pageFile.FullName, page);
                        files.Add(pageFile);
                        writer.WriteAttributeString("src", pageFile.Name);
                        string pdf = "-1";
                        if (Pages[i].OriginalPage != null)
                        {
                            string pdfName = "Page" + i + ".pdf";
                            pdf = "" + pdfDoc.Pages.Count;
                            pdfDoc.AddPage(Pages[i].OriginalPage);
                        }
                        writer.WriteAttributeString("pdf", pdf);
                        writer.WriteEndElement(); // Page
                    }
                    writer.WriteEndElement();     // Pages
                    writer.WriteEndElement();     // Document
                    writer.Close();

                    if (pdfDoc.Pages.Count > 0)
                    {
                        files.Add(new FileInfo(dir + "\\.pdf"));
                        pdfDoc.Save(dir + "\\.pdf");
                    }

                    if (path != null)
                    {
                        ZipFile zFile = new ZipFile();
                        foreach (FileInfo file in files)
                        {
                            zFile.AddFile(file.FullName, "");
                        }
                        zFile.Save(path);
                        SetCurrentStateAsSaved();
                    }
                }
                if (path != null)
                {
                    this.FilePath = path;
                }
            }
            catch (Exception e)
            {
                Program.MainLog.Add(e);
                Dialogues.MsgBox.ShowOk(Language.GetText("Error.saveFile") + "\n" + e.Message);
                return(false);
            }
            return(true);
        }