public static void SerializeContentTo([NotNull] this ContentControl control, [NotNull] Stream stream) => XamlWriter.Save(control.Content, stream);
 public static T DeepCopy <T>(this T element)
 {
     return((T)XamlReader.Load(new XmlTextReader(new
                                                 StringReader(XamlWriter.Save(element)))));
 }
Пример #3
0
 public static string RoundtripXaml(string xaml)
 {
     return(XamlWriter.Save(XamlReader.Parse(xaml)));
 }
Пример #4
0
        private bool ConvertDocument(string filePath = null)
        {
            if (string.IsNullOrWhiteSpace(filePath) || File.Exists(filePath) == false)
            {
                filePath = _svgFilePath;
            }
            try
            {
                if (string.IsNullOrWhiteSpace(filePath) || File.Exists(filePath) == false)
                {
                    return(false);
                }
                //DrawingGroup drawing = _fileReader.Read(filePath, _directoryInfo);
                //if (drawing == null)
                //{
                //    return false;
                //}

                //if (_xamlPage != null && !string.IsNullOrWhiteSpace(_xamlFilePath))
                //{
                //    if (File.Exists(_xamlFilePath))
                //    {
                //        _xamlPage.LoadDocument(_xamlFilePath);

                //        // Delete the file after loading it...
                //        File.Delete(_xamlFilePath);
                //    }
                //    else
                //    {
                //        string xamlFilePath = IoPath.Combine(_directoryInfo.FullName,
                //            IoPath.GetFileNameWithoutExtension(filePath) + ".xaml");
                //        if (File.Exists(xamlFilePath))
                //        {
                //            _xamlPage.LoadDocument(xamlFilePath);

                //            // Delete the file after loading it...
                //            File.Delete(xamlFilePath);
                //        }
                //    }
                //}
                //_currentDrawing = drawing;

                //Rect drawingBounds = drawing.Bounds;

                svgDrawing.UnloadDiagrams();

                string xamlFilePath = IoPath.Combine(_directoryInfo.FullName,
                                                     IoPath.GetFileNameWithoutExtension(filePath) + ".xaml");

                //svgDrawing.RenderDiagrams(drawing);
                if (svgDrawing.RenderDiagrams(filePath))
                {
                    if (_xamlPage != null)
                    {
                        //using (MemoryStream stream = new MemoryStream())
                        using (FileStream stream = File.Create(xamlFilePath))
                        {
                            XmlWriterSettings writerSettings = new XmlWriterSettings();
                            writerSettings.Indent             = true;
                            writerSettings.OmitXmlDeclaration = true;
                            writerSettings.Encoding           = Encoding.UTF8;

                            using (XmlWriter writer = XmlWriter.Create(stream, writerSettings))
                            {
                                XamlWriter.Save(svgDrawing.Drawing, writer);
                            }
                            //using (XmlWriter writer = XmlWriter.Create(stream, writerSettings))
                            //{
                            //    try
                            //    {
                            //        XmlXamlWriter xamlWriter = new XmlXamlWriter();
                            //        xamlWriter.Save(svgDrawing.Drawing, writer);

                            //    }
                            //    catch (Exception)
                            //    {
                            //        stream.Flush();
                            //        throw;
                            //    }
                            //}

                            if (stream.Length > 0)
                            {
                                stream.Position = 0;
                            }

                            _xamlPage.LoadDocument(stream);
                        }
                    }
                }

                zoomPanControl.InvalidateMeasure();

                Rect bounds = svgDrawing.Bounds;

                //zoomPanControl.AnimatedScaleToFit();
                //Rect rect = new Rect(0, 0,
                //    mainFrame.RenderSize.Width, mainFrame.RenderSize.Height);
                //Rect rect = new Rect(0, 0,
                //    bounds.Width, bounds.Height);
                if (bounds.IsEmpty)
                {
                    bounds = new Rect(0, 0, viewerFrame.ActualWidth, viewerFrame.ActualHeight);
                }
                zoomPanControl.AnimatedZoomTo(bounds);

                return(true);
            }
            catch (Exception ex)
            {
                //svgDrawing.Source = null;
                svgDrawing.UnloadDiagrams();

                this.ReportError(ex);

                return(false);
            }
        }
        /// <summary>
        /// Add new translation row (a panel with respective elements) to the dialog.
        /// </summary>
        private void AddTranslationRow(Translation tr)
        {
            var copy         = (FrameworkElement)XamlReader.Parse(XamlWriter.Save(translationRow));
            int addButtonIdx = translationsPanel.Children.IndexOf(addTranslationBtn);

            copy.Name       = null; //To show that it's a new item
            copy.Visibility = Visibility.Visible;
            copy.Tag        = tr;

            var newTranslationLbl = (TextBlock)copy.FindName(nameof(translationLbl));

            newTranslationLbl.Text     = TranslationConverter.ConvertToString(tr);
            newTranslationLbl.MouseUp += (s, e) =>
            { //Edit the translation
                var dlg = new TranslationsEditDlg(tr.Text, tr.Part)
                {
                    Owner = this
                };

                if (dlg.ShowDialog() == true)
                {
                    tr.Text = dlg.Translation.Value.translation;
                    tr.Part = dlg.Translation.Value.partOfSpeech;

                    newTranslationLbl.Text = TranslationConverter.ConvertToString(tr);

                    ChangesHaveBeenMade();
                }
            };

            var newRemoveBtn = (Button)copy.FindName(nameof(trRemoveBtn));

            newRemoveBtn.Click += (s, e) =>
            { //Remove the translation
                LooseHeight();

                translationsPanel.Children.Remove(copy);
                translations.Remove(tr);

                FixHeight();

                countOfShownTranslations--;
                UpdateAddButtonState();
                UpdateTranslationsArrowsState();
                ChangesHaveBeenMade();
            };

            var newTrUpBtn = (Button)copy.FindName(nameof(trUpBtn));

            newTrUpBtn.Click += (s, e) => MoveTranslationRow(copy, moveUp: true);

            var newTrDownBtn = (Button)copy.FindName(nameof(trDownBtn));

            newTrDownBtn.Click += (s, e) => MoveTranslationRow(copy, moveUp: false);

            LooseHeight();

            translationsPanel.Children.Insert(addButtonIdx, copy);

            if (Visibility == Visibility.Visible) //Only if form is already shown and knows its size
            {
                FixHeight();
            }

            countOfShownTranslations++;
            UpdateAddButtonState();
        }
 private string XamlConvert(Border image)
 {
     return(XamlWriter.Save(image));
 }
Пример #7
0
        /// <summary>
        /// Create a XamlPropertyValue for the specified value instance.
        /// </summary>
        public XamlPropertyValue CreatePropertyValue(object instance, XamlProperty forProperty)
        {
            if (instance == null)
            {
                throw new ArgumentNullException("instance");
            }

            Type          elementType = instance.GetType();
            TypeConverter c           = TypeDescriptor.GetConverter(instance);
            var           ctx         = new DummyTypeDescriptorContext(this.ServiceProvider);

            ctx.Instance = instance;
            bool hasStringConverter = c.CanConvertTo(ctx, typeof(string)) && c.CanConvertFrom(typeof(string));

            if (forProperty != null && hasStringConverter)
            {
                if (instance is SolidColorBrush && _colorBrushDictionary.ContainsKey(((SolidColorBrush)instance).Color))
                {
                    var name = _colorBrushDictionary[((SolidColorBrush)instance).Color];
                    return(new XamlTextValue(this, name));
                }

                return(new XamlTextValue(this, c.ConvertToInvariantString(ctx, instance)));
            }

            string ns     = GetNamespaceFor(elementType);
            string prefix = GetPrefixForNamespace(ns);

            XmlElement xml = _xmlDoc.CreateElement(prefix, elementType.Name, ns);

            if (hasStringConverter && (XamlObject.GetContentPropertyName(elementType) != null || IsNativeType(instance)))
            {
                xml.InnerText = c.ConvertToInvariantString(instance);
            }
            else if (instance is Brush && forProperty != null)                  // TODO: this is a hacky fix, because Brush Editor doesn't
            // edit Design Items and so we have no XML, only the Brush
            // object and we need to parse the Brush to XAML!
            {
                var s = new MemoryStream();
                XamlWriter.Save(instance, s);
                s.Seek(0, SeekOrigin.Begin);
                XmlDocument doc = new XmlDocument();
                doc.Load(s);
                xml = (XmlElement)_xmlDoc.ImportNode(doc.DocumentElement, true);

                var attLst = xml.Attributes.Cast <XmlAttribute>().ToList();
                foreach (XmlAttribute att in attLst)
                {
                    if (att.Name.StartsWith(XamlConstants.Xmlns))
                    {
                        var rootAtt = doc.DocumentElement.GetAttributeNode(att.Name);
                        if (rootAtt != null && rootAtt.Value == att.Value)
                        {
                            xml.Attributes.Remove(att);
                        }
                    }
                }
            }

            return(new XamlObject(this, xml, elementType, instance));
        }
Пример #8
0
 public static T Duplicate <T>(this T reference) where T : FrameworkElement
 {
     return(XamlReader.Parse(XamlWriter.Save(reference)) as T);
 }
Пример #9
0
 /// <summary>
 /// Serializes <code>obj</code> into a XAML string
 /// </summary>
 /// <param name="obj">Object to serialize</param>
 /// <returns>Serialized XAML version of <code>obj</code></returns>
 public static string SerializeObject(object obj)
 {
     return(XamlWriter.Save(obj));
 }
Пример #10
0
 public virtual string ToCtrb()
 {
     return($"{XamlWriter.Save(Element)}");
 }
Пример #11
0
        protected override void OnPreviewMouseUp(MouseButtonEventArgs e)
        {
            string xamlString;

            base.OnPreviewMouseUp(e);
            if (IsDown == false)
            {
                return;
            }
            IsDown = false;
            if (!(this.Parent is Toolbox) && !(this.Parent is WrapPanel))
            {
                return;
            }


            switch (this.AssetType)
            {
            case jg.Editor.Library.AssetType.Text:
                xamlString = "Text";
                break;

            case jg.Editor.Library.AssetType.Topic:
                xamlString = "Topic";
                break;

            case jg.Editor.Library.AssetType.TopicDrag:
                xamlString = "TopicDrag";
                break;

            case jg.Editor.Library.AssetType.Image:
                xamlString = "Image";
                break;

            case jg.Editor.Library.AssetType.Movie:
                xamlString = "Movie";
                break;

            case jg.Editor.Library.AssetType.TextGrid:
                xamlString = "TextGrid";
                break;

            case jg.Editor.Library.AssetType.Sound:
                xamlString = "Sound";
                break;

            case Editor.Library.AssetType.Document:
                xamlString = "Document";
                break;

            case Editor.Library.AssetType.Message:
                xamlString = "Message";
                break;

            case Editor.Library.AssetType.Line:
                xamlString = "Line";
                break;

            case Editor.Library.AssetType.HTML5:
                xamlString = "HTML5";
                break;

            case Editor.Library.AssetType.TPageGroup:
                xamlString = "TPageGroup";
                break;

            default:
                xamlString = XamlWriter.Save(this);
                break;
            }
            if (AddAsset != null)
            {
                AddAsset(xamlString);
            }
        }
Пример #12
0
        public FileChoice()
        {
            InitializeComponent();
            listOfFiles = (from a in Directory.GetFiles(Directory.GetCurrentDirectory().ToString(), "*.dat") select System.IO.Path.GetFileName(a)).ToList();
            if (listOfFiles.Count == 0)
            {
                var noFiles = new Label
                {
                    Style   = this.Resources["LabelStyle"] as Style,
                    Content = "У вас нет сохранённых симуляций",
                    Width   = 494,
                    HorizontalContentAlignment = HorizontalAlignment.Center
                };
                ListOfFiles.Children.Add(noFiles);
            }
            else
            {
                for (int i = 0; i < listOfFiles.Count; i++)
                {
                    var fileLine = new StackPanel
                    {
                        MinHeight   = 70,
                        Orientation = Orientation.Horizontal
                    };
                    var fileName = new TextBlock
                    {
                        Width             = 300,
                        Style             = this.Resources["TextBlockStyle"] as Style,
                        Text              = listOfFiles[i].Substring(0, listOfFiles[i].Length - 4),
                        VerticalAlignment = VerticalAlignment.Center,
                        TextWrapping      = TextWrapping.Wrap
                    };
                    fileLine.Children.Add(fileName);

                    var EmptySpace = new Label
                    {
                        Width = 55
                    };
                    fileLine.Children.Add(EmptySpace);

                    string       template     = XamlWriter.Save(LoadTemplate.Template);
                    StringReader stringReader = new StringReader(template);
                    XmlReader    xmlReader    = XmlReader.Create(stringReader);
                    var          okButton     = new Button
                    {
                        Name              = "File" + i.ToString(),
                        Height            = 50,
                        Width             = 50,
                        VerticalAlignment = VerticalAlignment.Center,
                        Template          = (ControlTemplate)XamlReader.Load(xmlReader)
                    };
                    okButton.Click += OkButton_Click;
                    fileLine.Children.Add(okButton);

                    var EmptySpace2 = new Label
                    {
                        Width = 10
                    };
                    fileLine.Children.Add(EmptySpace2);

                    string       template2     = XamlWriter.Save(DeleteTemplate.Template);
                    StringReader stringReader2 = new StringReader(template2);
                    XmlReader    xmlReader2    = XmlReader.Create(stringReader2);
                    var          deleteButton  = new Button
                    {
                        Name              = "File" + i.ToString(),
                        Template          = (ControlTemplate)XamlReader.Load(xmlReader2),
                        Height            = 50,
                        Width             = 50,
                        VerticalAlignment = VerticalAlignment.Center
                    };
                    deleteButton.Click += DeleteButton_Click;
                    fileLine.Children.Add(deleteButton);

                    ListOfFiles.Children.Add(fileLine);
                }
            }
        }
Пример #13
0
 private static void ConvertToXml <T>(string name, XContainer xRoot, T value)
 {
     xRoot.Add(new XElement(name, XamlWriter.Save(value)));
 }
Пример #14
0
        public static string ConvertRtfToHtml(FlowDocument doc)
        {
            var xamlText = XamlWriter.Save(doc);

            return(XamlToHtmlConverter.ConvertXamlToHtml(xamlText, false));
        }
Пример #15
0
        /// <summary>
        /// Fills document with data
        /// </summary>
        /// <exception cref="InvalidDataException">ReportTableRow must have a TableRowGroup as parent</exception>
        protected virtual void FillData()
        {
            ArrayList blockDocumentValues  = _dynamicCache.GetFlowDocumentVisualListByInterface(typeof(IInlineDocumentValue));  // walker.Walk<IInlineDocumentValue>(_flowDocument);
            ArrayList blockTableRows       = _dynamicCache.GetFlowDocumentVisualListByInterface(typeof(ITableRowForDataTable)); // walker.Walk<TableRowForDataTable>(_flowDocument);
            ArrayList blockAggregateValues = _dynamicCache.GetFlowDocumentVisualListByType(typeof(InlineAggregateValue));       // walker.Walk<InlineAggregateValue>(_flowDocument);
            ArrayList charts = _dynamicCache.GetFlowDocumentVisualListByInterface(typeof(IChart));                              // walker.Walk<IChart>(_flowDocument);
            ArrayList dynamicHeaderTableRows = _dynamicCache.GetFlowDocumentVisualListByInterface(typeof(ITableRowForDynamicHeader));
            ArrayList dynamicDataTableRows   = _dynamicCache.GetFlowDocumentVisualListByInterface(typeof(ITableRowForDynamicDataTable));
            ArrayList documentConditions     = _dynamicCache.GetFlowDocumentVisualListByInterface(typeof(IDocumentCondition));

            List <Block> blocks = new List <Block>();

            if (_blockPageHeader != null)
            {
                blocks.Add(_blockPageHeader);
            }
            if (_blockPageFooter != null)
            {
                blocks.Add(_blockPageFooter);
            }

            DocumentWalker walker = new DocumentWalker();

            blockDocumentValues.AddRange(walker.TraverseBlockCollection <IInlineDocumentValue>(blocks));

            Dictionary <string, List <object> > aggregateValues = new Dictionary <string, List <object> >();

            FillCharts(charts);

            // hide conditional text blocks
            foreach (IDocumentCondition dc in documentConditions)
            {
                if (dc == null)
                {
                    continue;
                }
                dc.PerformRenderUpdate(_data);
            }

            // fill report values
            foreach (IInlineDocumentValue dv in blockDocumentValues)
            {
                if (dv == null)
                {
                    continue;
                }
                object obj;
                if ((dv.PropertyName != null) && (_data.ReportDocumentValues.TryGetValue(dv.PropertyName, out obj)))
                {
                    dv.Value = obj;
                    RememberAggregateValue(aggregateValues, dv.AggregateGroup, obj);
                }
                else
                {
                    if ((_data.ShowUnknownValues) && (dv.Value == null))
                    {
                        dv.Value = "[" + ((dv.PropertyName != null) ? dv.PropertyName : "NULL") + "]";
                    }
                    RememberAggregateValue(aggregateValues, dv.AggregateGroup, null);
                }
            }

            // fill dynamic tables
            foreach (ITableRowForDynamicDataTable iTableRow in dynamicDataTableRows)
            {
                TableRow tableRow = iTableRow as TableRow;
                if (tableRow == null)
                {
                    continue;
                }

                TableRowGroup tableGroup = tableRow.Parent as TableRowGroup;
                if (tableGroup == null)
                {
                    continue;
                }

                TableRow currentRow;

                DataTable table = _data.GetDataTableByName(iTableRow.TableName);

                for (int i = 0; i < table.Rows.Count; i++)
                {
                    currentRow = new TableRow();

                    DataRow dataRow = table.Rows[i];
                    for (int j = 0; j < table.Columns.Count; j++)
                    {
                        string value = dataRow[j].ToString();
                        currentRow.Cells.Add(new TableCell(new Paragraph(new Run(value))));
                    }
                    tableGroup.Rows.Add(currentRow);
                }
            }

            foreach (ITableRowForDynamicHeader iTableRow in dynamicHeaderTableRows)
            {
                TableRow tableRow = iTableRow as TableRow;
                if (tableRow == null)
                {
                    continue;
                }

                DataTable table = _data.GetDataTableByName(iTableRow.TableName);

                foreach (DataRow row in table.Rows)
                {
                    string    value     = row[0].ToString();
                    TableCell tableCell = new TableCell(new Paragraph(new Run(value)));
                    tableRow.Cells.Add(tableCell);
                }
            }

            // group table row groups
            Dictionary <TableRowGroup, List <TableRow> > groupedRows = new Dictionary <TableRowGroup, List <TableRow> >();
            Dictionary <TableRowGroup, string>           tableNames  = new Dictionary <TableRowGroup, string>();

            foreach (TableRow tableRow in blockTableRows)
            {
                TableRowGroup rowGroup = tableRow.Parent as TableRowGroup;
                if (rowGroup == null)
                {
                    continue;
                }

                ITableRowForDataTable iTableRow = tableRow as ITableRowForDataTable;
                if ((iTableRow != null) && (iTableRow.TableName != null))
                {
                    string tableName;
                    if (tableNames.TryGetValue(rowGroup, out tableName))
                    {
                        if (tableName != iTableRow.TableName.Trim().ToLowerInvariant())
                        {
                            throw new ReportingException("TableRowGroup cannot be mapped to different DataTables in TableRowForDataTable");
                        }
                    }
                    else
                    {
                        tableNames[rowGroup] = iTableRow.TableName.Trim().ToLowerInvariant();
                    }
                }

                List <TableRow> rows;
                if (!groupedRows.TryGetValue(rowGroup, out rows))
                {
                    rows = new List <TableRow>();
                    groupedRows[rowGroup] = rows;
                }
                rows.Add(tableRow);
            }

            // fill tables
            foreach (KeyValuePair <TableRowGroup, List <TableRow> > groupedRow in groupedRows)
            {
                TableRowGroup rowGroup = groupedRow.Key;

                ITableRowForDataTable iTableRow = groupedRow.Value[0] as ITableRowForDataTable;
                if (iTableRow == null)
                {
                    continue;
                }

                DataTable table = _data.GetDataTableByName(iTableRow.TableName);
                if (table == null)
                {
                    if (_data.ShowUnknownValues)
                    {
                        // show unknown values
                        foreach (TableRow tableRow in groupedRow.Value)
                        {
                            foreach (TableCell cell in tableRow.Cells)
                            {
                                DocumentWalker         localWalker = new DocumentWalker();
                                List <ITableCellValue> tableCells  = localWalker.TraverseBlockCollection <ITableCellValue>(cell.Blocks);
                                foreach (ITableCellValue cv in tableCells)
                                {
                                    IPropertyValue dv = cv as IPropertyValue;
                                    if (dv == null)
                                    {
                                        continue;
                                    }
                                    dv.Value = "[" + dv.PropertyName + "]";
                                    RememberAggregateValue(aggregateValues, cv.AggregateGroup, null);
                                }
                            }
                        }
                    }
                    else
                    {
                        continue;
                    }
                }
                else
                {
                    List <TableRow> listNewRows = new List <TableRow>();
                    TableRow        newTableRow;

                    // clone XAML rows
                    List <string> clonedRows = new List <string>();
                    foreach (TableRow row in rowGroup.Rows)
                    {
                        TableRowForDataTable reportTableRow = row as TableRowForDataTable;
                        if (reportTableRow == null)
                        {
                            clonedRows.Add(null);
                        }
                        clonedRows.Add(XamlWriter.Save(reportTableRow));
                    }

                    for (int i = 0; i < table.Rows.Count; i++)
                    {
                        DataRow dataRow = table.Rows[i];

                        for (int j = 0; j < rowGroup.Rows.Count; j++)
                        {
                            TableRow row = rowGroup.Rows[j];

                            TableRowForDataTable reportTableRow = row as TableRowForDataTable;
                            if (reportTableRow == null)
                            {
                                // clone regular row
                                listNewRows.Add(XamlHelper.CloneTableRow(row));
                            }
                            else
                            {
                                // clone ReportTableRows
                                newTableRow = (TableRow)XamlHelper.LoadXamlFromString(clonedRows[j]);

                                foreach (TableCell cell in newTableRow.Cells)
                                {
                                    DocumentWalker         localWalker = new DocumentWalker();
                                    List <ITableCellValue> newCells    = localWalker.TraverseBlockCollection <ITableCellValue>(cell.Blocks);
                                    foreach (ITableCellValue cv in newCells)
                                    {
                                        IPropertyValue dv = cv as IPropertyValue;
                                        if (dv == null)
                                        {
                                            continue;
                                        }
                                        try
                                        {
                                            object obj = dataRow[dv.PropertyName];
                                            if (obj == DBNull.Value)
                                            {
                                                obj = null;
                                            }
                                            dv.Value = obj;

                                            RememberAggregateValue(aggregateValues, cv.AggregateGroup, obj);
                                        }
                                        catch
                                        {
                                            if (_data.ShowUnknownValues)
                                            {
                                                dv.Value = "[" + dv.PropertyName + "]";
                                            }
                                            else
                                            {
                                                dv.Value = "";
                                            }
                                            RememberAggregateValue(aggregateValues, cv.AggregateGroup, null);
                                        }
                                    }
                                }
                                listNewRows.Add(newTableRow);

                                // fire event
                                _report.FireEventDataRowBoundEventArgs(new DataRowBoundEventArgs(_report, dataRow)
                                {
                                    TableName = dataRow.Table.TableName, TableRow = newTableRow
                                });
                            }
                        }
                    }
                    rowGroup.Rows.Clear();
                    foreach (TableRow row in listNewRows)
                    {
                        rowGroup.Rows.Add(row);
                    }
                }
            }

            // fill aggregate values
            foreach (InlineAggregateValue av in blockAggregateValues)
            {
                if (String.IsNullOrEmpty(av.AggregateGroup))
                {
                    continue;
                }

                string[] aggregateGroups = av.AggregateGroup.Split(new char[] { ',', ';', ' ' }, StringSplitOptions.RemoveEmptyEntries);

                foreach (var group in aggregateGroups)
                {
                    if (!aggregateValues.ContainsKey(group))
                    {
                        av.Text = av.EmptyValue;
                        break;
                    }
                }
                av.Text = av.ComputeAndFormat(aggregateValues);
            }
        }
Пример #16
0
 private static void SaveInlineNote(XmlWriter wr, OutlinerNote outlinerNote)
 {
     wr.WriteStartElement("InlineNote");
     wr.WriteRaw(XamlWriter.Save(outlinerNote.InlineNoteDocument));
     wr.WriteEndElement();
 }
        protected override void OnExecute(object param)
        {
            System.Windows.Forms.DialogResult dresult = System.Windows.Forms.MessageBox.Show(
                BSky.GlobalResources.Properties.Resources.RestartToApplyChanges +
                BSky.GlobalResources.Properties.Resources.ConfirmDialogInstall,
                BSky.GlobalResources.Properties.Resources.InstallNewDialog,
                System.Windows.Forms.MessageBoxButtons.YesNoCancel,
                System.Windows.Forms.MessageBoxIcon.Question);
            if (dresult == System.Windows.Forms.DialogResult.Yes)//save
            {
                IUnityContainer   container        = LifetimeService.Instance.Container;
                IDataService      service          = container.Resolve <IDataService>();
                IUIController     controller       = container.Resolve <IUIController>();
                IDashBoardService dashboardService = container.Resolve <IDashBoardService>();
                Window1           mainWin          = container.Resolve <Window1>();//15Jan2013

                extractedfiles = new List <string>();
                OpenFileDialog openFileDialog = new OpenFileDialog();
                openFileDialog.Filter = FileNameFilter;
                bool?output = openFileDialog.ShowDialog(Application.Current.MainWindow);
                if (output.HasValue && output.Value)
                {
                    FileStream     fileStreamIn = new FileStream(openFileDialog.FileName, FileMode.Open, FileAccess.Read);
                    ZipInputStream zipInStream = new ZipInputStream(fileStreamIn);
                    string         xamlFile = string.Empty, outputFile = string.Empty;
                    ZipEntry       entry   = zipInStream.GetNextEntry();
                    string         tempDir = Path.GetTempPath();

                    //Extract the files
                    while (entry != null)
                    {
                        //if(System.IO.File.Exists((@".\config\" + entry.Name)))
                        //{
                        //    if(MessageBox.Show("Do you want to replace existing file?","Warning",MessageBoxButton.YesNo,MessageBoxImage.Hand) == MessageBoxResult.No)
                        //        continue;
                        //}
                        FileStream fileStreamOut = new FileStream(Path.Combine(tempDir, entry.Name), FileMode.Create, FileAccess.Write);
                        if (entry.Name.EndsWith(".xaml"))
                        {
                            xamlFile = entry.Name;
                        }
                        if (entry.Name.EndsWith(".xml"))
                        {
                            outputFile = entry.Name;
                        }
                        int    size;
                        byte[] buffer = new byte[1024];
                        do
                        {
                            size = zipInStream.Read(buffer, 0, buffer.Length);
                            fileStreamOut.Write(buffer, 0, size);
                        } while (size > 0);
                        fileStreamOut.Close();
                        entry = zipInStream.GetNextEntry();
                        MessageBox.Show("Extracted:" + entry.Name + " in " + tempDir);
                        //adding fullpath filename to list //08May2015
                        extractedfiles.Add(Path.Combine(tempDir, entry.Name));
                    }
                    zipInStream.Close();
                    fileStreamIn.Close();

                    if (string.IsNullOrEmpty(outputFile))
                    {
                        MessageBox.Show(BSky.GlobalResources.Properties.Resources.CantInstallDialogNoOutFile);
                        return;
                    }
                    //Load the dialog object, check the location and modify menu file.
                    if (!string.IsNullOrEmpty(xamlFile) && !string.IsNullOrEmpty(outputFile))
                    {
                        FileStream stream = System.IO.File.Open(Path.Combine(tempDir, xamlFile), FileMode.Open);
                        try
                        {
                            object obj = XamlReader.Load(stream);
                            BSky.Controls.BSkyCanvas canvas = obj as BSky.Controls.BSkyCanvas;

                            string menulocation = canvas.MenuLocation;
                            string title        = canvas.Title;
                            if (string.IsNullOrEmpty(canvas.Title))
                            {
                                title = Microsoft.VisualBasic.Interaction.InputBox("Get Item Name", "Item Name", "New Node");
                                if (!string.IsNullOrEmpty(title))
                                {
                                    MessageBox.Show(BSky.GlobalResources.Properties.Resources.CantInstallDialogNoTitle, BSky.GlobalResources.Properties.Resources.DialogTitleEmpty);
                                    return;
                                }
                            }

                            //23Apr2015 bool? result = dashboardService.SetElementLocaton(menulocation, title, Path.Combine(@".\config\", xamlFile), false, "");
                            bool?            result    = dashboardService.SetElementLocaton(menulocation, title, Path.Combine(string.Format(@"{0}", BSkyAppData.RoamingUserBSkyConfigL18nPath), xamlFile), false, "");//23Apr2015
                            MessageBoxResult msgResult = MessageBoxResult.No;
                            if (result.HasValue && !result.Value)
                            {
                                msgResult = MessageBox.Show(BSky.GlobalResources.Properties.Resources.ConfirmDialogOverwrite, BSky.GlobalResources.Properties.Resources.WarnOverwrite, MessageBoxButton.YesNo);
                            }
                            if (result.HasValue && (result.Value || msgResult == MessageBoxResult.Yes))
                            {
                                //23Apr2015 canvas.OutputDefinition = Path.GetFullPath(@".\Config\" + outputFile);
                                canvas.OutputDefinition = Path.GetFullPath(string.Format(@"{0}", BSkyAppData.RoamingUserBSkyConfigL18nPath) + outputFile);//23Apr2015

                                System.IO.File.Copy(Path.Combine(tempDir, outputFile), canvas.OutputDefinition, true);

                                string xaml = XamlWriter.Save(canvas);
                                //23Apr2015 FileStream outputstream = System.IO.File.Create(@".\Config\" + xamlFile);
                                FileStream outputstream = System.IO.File.Create(string.Format(@"{0}", BSkyAppData.RoamingUserBSkyConfigL18nPath) + xamlFile);//23Apr2015
                                TextWriter writer       = new StreamWriter(outputstream);
                                writer.Write(xaml);
                                writer.Close();

                                MessageBox.Show(BSky.GlobalResources.Properties.Resources.RestartToApplyChanges2, BSky.GlobalResources.Properties.Resources.DialogInstalled);
                            }
                            else
                            {
                                string sInput            = "New Command Node";
                                string aboveBelowSibling = "Below";//position of new command based on sibling location. Enum can be used for Above/Below
                                string location          = dashboardService.SelectLocation(ref sInput, ref aboveBelowSibling);
                                //sInput is prefixed to XAML and XML filenames. You can think of dropping it for prefixing
                                //string sInput = Microsoft.VisualBasic.Interaction.InputBox("Get Item Name", "Item Name", "Command Name");
                                if (!string.IsNullOrEmpty(location))
                                {
                                    //string sInputNoBlanks = sInput.Replace(' ','_');//26sep2012
                                    //23Apr2015 dashboardService.SetElementLocaton(location, sInput, Path.Combine(@".\Config\", sInput + xamlFile), true, aboveBelowSibling);
                                    dashboardService.SetElementLocaton(location, sInput, Path.Combine(string.Format(@"{0}", BSkyAppData.RoamingUserBSkyConfigL18nPath), sInput + xamlFile), true, aboveBelowSibling);//23Apr2015

                                    ///12Oct2012 canvas.OutputDefinition = Path.GetFullPath(@".\config\" + sInput + outputFile);///output template filename will be same as in zip
                                    //23Apr2015 canvas.OutputDefinition = Path.GetFullPath(@".\Config\" + sInput + xamlFile.Replace("xaml", "xml"));///output template filename will be same as dialog filename. No matter whats in zip file.
                                    canvas.OutputDefinition = Path.GetFullPath(string.Format(@"{0}", BSkyAppData.RoamingUserBSkyConfigL18nPath) + sInput + xamlFile.Replace("xaml", "xml"));//23Apr2015 //output template filename will be same as dialog filename. No matter whats in zip file.

                                    System.IO.File.Copy(Path.Combine(tempDir, outputFile), canvas.OutputDefinition, true);

                                    ///Following commented lines should not execute 17Jan2013
                                    ///These are writing a xaml and putting datatemplate tag in XAML while installing.
                                    //string xaml = XamlWriter.Save(canvas);
                                    //FileStream outputstream = System.IO.File.Create(@".\Config\" + sInput + xamlFile);
                                    //TextWriter writer = new StreamWriter(outputstream);
                                    //writer.Write(xaml);
                                    //writer.Close();
                                    //23Apr2015 string installpath = Path.GetFullPath(@".\Config\" + sInput + xamlFile);
                                    string installpath = Path.GetFullPath(string.Format(@"{0}", BSkyAppData.RoamingUserBSkyConfigL18nPath) + sInput + xamlFile);//23Apr2015

                                    System.IO.File.Copy(Path.Combine(tempDir, xamlFile), installpath, true);

                                    MessageBox.Show(BSky.GlobalResources.Properties.Resources.RestartToApplyChanges2, BSky.GlobalResources.Properties.Resources.DialogInstalled);
                                    mainWin.Window_Refresh_Menus();//15Jan2013
                                }
                            }
                            CleanTempFiles();
                        }
                        catch (Exception e)
                        {
                            MessageBox.Show(BSky.GlobalResources.Properties.Resources.CantInstallDialog, BSky.GlobalResources.Properties.Resources.InstallFailed);
                            logService.WriteToLogLevel("Couldn't install Dialog", LogLevelEnum.Error);
                        }
                    }
                }
            }
        }
Пример #18
0
        /// <summary>
        /// This sets the source SVG for a <see cref="SvgCanvas"/> by using the supplied Uniform Resource Identifier (URI)
        /// and optionally processing the result asynchronously.
        /// </summary>
        /// <param name="uriSource">A reference to the SVG source file.</param>
        /// <param name="useAsync">
        /// A value indicating whether to process the result asynchronously. The default value is <see langword="false"/>,
        /// the SVG conversion is processed synchronously.
        /// </param>
        /// <returns>
        /// A value that indicates whether the operation was successful. This is <see langword="true"/>
        /// if successful, otherwise, it is <see langword="false"/>.
        /// </returns>
        public bool Load(Uri uriSource, bool useAsync = false)
        {
            if (uriSource == null)
            {
                return(false);
            }

            var sourceUri = this.ResolveUri(uriSource);

            WpfDrawingSettings settings = new WpfDrawingSettings();

            settings.IncludeRuntime = _includeRuntime;
            settings.TextAsGeometry = _textAsGeometry;
            settings.OptimizePath   = _optimizePath;
            if (_culture != null)
            {
                settings.CultureInfo = _culture;
            }

            try
            {
                if (useAsync)
                {
                    MemoryStream drawingStream = new MemoryStream();

                    // Get the UI thread's context
                    var context = TaskScheduler.FromCurrentSynchronizationContext();

                    Task.Factory.StartNew(() =>
                    {
                        DrawingGroup drawing = this.CreateDrawing(sourceUri, settings);
                        if (drawing != null)
                        {
                            _sourceUri    = sourceUri;
                            _sourceStream = null;

                            XamlWriter.Save(drawing, drawingStream);
                            drawingStream.Seek(0, SeekOrigin.Begin);
                        }
                    }).ContinueWith((t) => {
                        if (drawingStream.Length != 0)
                        {
                            DrawingGroup drawing = (DrawingGroup)XamlReader.Load(drawingStream);

                            this.OnLoadDrawing(drawing);
                        }
                    }, context);

                    return(true);
                }
                else
                {
                    DrawingGroup drawing = this.CreateDrawing(uriSource, settings);
                    if (drawing != null)
                    {
                        _sourceUri    = uriSource;
                        _sourceStream = null;

                        this.OnLoadDrawing(drawing);

                        return(true);
                    }
                }

                return(false);
            }
            catch
            {
                //TODO: Rethrow the exception?
                return(false);
            }
        }
Пример #19
0
        private static void OnTargetChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var me     = (XamlView)d;
            var target = e.NewValue;
            var styles = me._styles;
            var tabs   = me._tabs;

            if (target != null)
            {
                var tabsToRemove = new HashSet <string>(tabs.Select(o => o.Name));
                foreach (var propertyInfo in target.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public))
                {
                    if (!propertyInfo.CanRead || propertyInfo.GetIndexParameters().Length > 0)
                    {
                        continue;
                    }
                    if (AcceptableTypes.All(o => !o.IsAssignableFrom(propertyInfo.PropertyType)))
                    {
                        continue;
                    }

                    var propertyXaml = tabs.FirstOrDefault(o => o.Name == propertyInfo.Name);
                    if (propertyXaml == null)
                    {
                        propertyXaml = new PropertyXaml(propertyInfo.Name);
                        var insertIndex = tabs.Count;
                        for (var i = 0; i < tabs.Count; i++)
                        {
                            if (string.CompareOrdinal(propertyInfo.Name, tabs[i].Name) < 0)
                            {
                                insertIndex = i;
                                break;
                            }
                        }
                        tabs.Insert(insertIndex, propertyXaml);
                    }
                    else
                    {
                        tabsToRemove.Remove(propertyInfo.Name);
                    }

                    var value = propertyInfo.GetValue(target, null);
                    if (value != null)
                    {
                        try
                        {
                            string serializedStyle;
                            using (var stringWriter = new StringWriter())
                                using (var xmlTextWriter = new XmlTextWriter(stringWriter)
                                {
                                    Formatting = Formatting.Indented
                                })
                                {
                                    XamlWriter.Save(value, xmlTextWriter);
                                    serializedStyle = stringWriter.ToString();
                                }
                            var paragraph = new Paragraph {
                                Style = styles.GeneralStyle
                            };
                            paragraph.FillParagraph(serializedStyle, styles);
                            propertyXaml.Document = new FlowDocument {
                                Blocks = { paragraph }
                            };
                        }
                        catch (Exception ex)
                        {
                            var message   = "[Exception]" + Environment.NewLine + Environment.NewLine + ex;
                            var paragraph = new Paragraph {
                                Style = styles.GeneralStyle
                            };
                            paragraph.AddRun(message, styles.ErrorStyle);
                            propertyXaml.Document = new FlowDocument {
                                Blocks = { paragraph }
                            };
                        }
                    }
                    else
                    {
                        var paragraph = new Paragraph {
                            Style = styles.GeneralStyle
                        };
                        paragraph.AddRun("(NULL)", styles.TextStyle);
                        propertyXaml.Document = new FlowDocument {
                            Blocks = { paragraph }
                        };
                    }
                }
                foreach (var tabName in tabsToRemove)
                {
                    var tab = tabs.FirstOrDefault(o => o.Name == tabName);
                    if (tab != null)
                    {
                        tabs.Remove(tab);
                    }
                }
            }
            else
            {
                tabs.Clear();
            }
        }
Пример #20
0
        /// <summary>
        /// This sets the source SVG for a <see cref="SvgCanvas"/> by accessing a stream
        /// and processing the result asynchronously.
        /// </summary>
        /// <param name="streamSource">The stream source that sets the SVG source value.</param>
        /// <param name="useCopyStream">
        /// A value specifying whether to use a copy of the stream. The default is <see langword="true"/>,
        /// the SVG source stream is copied, rendered and stored.
        /// </param>
        /// <returns>
        /// A value that indicates whether the operation was successful. This is <see langword="true"/>
        /// if successful, otherwise, it is <see langword="false"/>.
        /// </returns>
        /// <remarks>
        /// The control will by default create a copy of the source stream to prevent any effect of disposing.
        /// If the source stream is stored, then use the <paramref name="useCopyStream"/> to prevent the control
        /// from creating its own copy.
        /// </remarks>
        public Task <bool> LoadAsync(Stream streamSource, bool useCopyStream = true)
        {
            TaskCompletionSource <bool> result = new TaskCompletionSource <bool>();

            if (streamSource == null)
            {
                result.SetResult(false);
                return(result.Task);
            }
            WpfDrawingSettings settings = new WpfDrawingSettings();

            settings.IncludeRuntime = _includeRuntime;
            settings.TextAsGeometry = _textAsGeometry;
            settings.OptimizePath   = _optimizePath;
            if (_culture != null)
            {
                settings.CultureInfo = _culture;
            }

            try
            {
                Stream svgStream = streamSource;
                if (useCopyStream)
                {
                    svgStream = new MemoryStream();
                    // On dispose, the stream is close so copy it to the memory stream.
                    streamSource.CopyTo(svgStream); //NOTE: Not working within the task scope

                    // Move the position to the start of the stream
                    svgStream.Seek(0, SeekOrigin.Begin);
                }
                else
                {
                    if (svgStream.CanSeek && svgStream.Position != 0)
                    {
                        // Move the position to the start of the stream
                        svgStream.Seek(0, SeekOrigin.Begin);
                    }
                }

                _sourceUri    = null;
                _sourceStream = svgStream;

                MemoryStream drawingStream = new MemoryStream();

                // Get the UI thread's context
                var context = TaskScheduler.FromCurrentSynchronizationContext();

                return(Task.Factory.StartNew <bool>(() =>
                {
                    DrawingGroup drawing = this.CreateDrawing(svgStream, settings);
                    if (drawing != null)
                    {
                        XamlWriter.Save(drawing, drawingStream);
                        drawingStream.Seek(0, SeekOrigin.Begin);

                        return true;
                    }
                    return false;
                }).ContinueWith((t) => {
                    if (t.Result && drawingStream.Length != 0)
                    {
                        DrawingGroup drawing = (DrawingGroup)XamlReader.Load(drawingStream);

                        this.OnLoadDrawing(drawing);

                        return true;
                    }

                    return false;
                }, context));
            }
            catch (Exception ex)
            {
                result.SetResult(false);
                result.SetException(ex);

                return(result.Task);
            }
        }
Пример #21
0
        /// <summary>
        /// Clone an element
        /// </summary>
        /// <param name="elementToClone"></param>
        /// <returns></returns>
        public static object CloneElement(object elementToClone)
        {
            string xaml = XamlWriter.Save(elementToClone);

            return(XamlReader.Load(new XmlTextReader(new StringReader(xaml))));
        }
Пример #22
0
        void UpdateDisplayTabs(object o, object o1)
        {
            Exception exception = null;

            try
            {
                if (o == MainTab && MainTab.SelectedItem == PanelTab)
                {
                    TabControl.SelectedItem = TabCoreXaml;
                }

                TabItem selectedItem = TabControl.SelectedItem as TabItem;
                switch (selectedItem.Header.ToString())
                {
                case "CoreXaml":
                    TextRange range = new TextRange(CoreXaml.Document.ContentEnd, CoreXaml.Document.ContentStart);
                    if (((TabItem)MainTab.SelectedItem).Header.ToString() == "RichTextBox")
                    {
                        XamlHelper.TextRange_SetXml(range, XamlHelper.ColoringXaml(XamlHelper.IndentXaml(XamlWriter.Save(MainEditor.Document))));
                    }
                    else if (((TabItem)MainTab.SelectedItem).Header.ToString() == "Panel")
                    {
                        XamlHelper.TextRange_SetXml(range, XamlHelper.ColoringXaml(XamlHelper.IndentXaml(XamlWriter.Save(PanelTab.Content))));
                    }
                    break;

                case "SelectionXaml":
                    SelectionXaml.Text = XamlHelper.IndentXaml(XamlHelper.TextRange_GetXml(MainEditor.Selection)); break;

                case "TextSerializedXaml":
                    TextSerializedXaml.Text = XamlHelper.IndentXaml(XamlHelper.TextRange_GetXml(new TextRange(MainEditor.Document.ContentEnd, MainEditor.Document.ContentStart))); break;

                case "DocumentTree":
                    TreeViewhelper.SetupTreeView(TextTreeView, MainEditor.Document); break;

                default:
                    OnError(new Exception("Can't find specified TabItem!"));
                    break;
                }
            }
            catch (Exception e)
            {
                exception = e;
            }
            if (exception == null)
            {
                OnError(null);
            }
            else
            {
                OnError(exception);
            }
        }
Пример #23
0
        public static string ExportToXaml(OutlinerDocument Document, MainWindow wnd)
        {
            FlowDocument wholeDocument = new FlowDocument();

            wholeDocument.FontFamily = UVOutliner.Settings.DefaultFontFamily;
            wholeDocument.FontSize   = UVOutliner.Settings.DefaultFontSize;

            List <OutlinerNote> linearList = new List <OutlinerNote>();

            DocumentHelpers.GetLinearNotesList(Document.RootNode, linearList, false);

            double totalWidth = 0;

            for (int i = 0; i < Document.ColumnDefinitions.Count; i++)
            {
                totalWidth += Document.ColumnDefinitions[i].Width;
            }

            // just random
            if (totalWidth == 0)
            {
                totalWidth = 300;
            }

            Table table = new Table();

            table.LineHeight = 1;
            table.Margin     = new Thickness(0);
            table.Padding    = new Thickness(0);
            wholeDocument.Blocks.Add(table);
            for (int i = 0; i < wnd.OutlinerTreeColumns.Count; i++)
            {
                int         columnId = wnd.GetColumnIdByView(i);
                TableColumn column   = new TableColumn();
                column.Width = new GridLength(Document.ColumnDefinitions[columnId].Width / totalWidth, GridUnitType.Star);
                table.Columns.Add(column);
            }

            // add column headers
            if (Document.ColumnDefinitions.Count > 1)
            {
                TableRowGroup rowGroup = new TableRowGroup();
                table.RowGroups.Add(rowGroup);

                TableRow row = new TableRow();
                rowGroup.Rows.Add(row);
                for (int i = 0; i < wnd.OutlinerTreeColumns.Count; i++)
                {
                    int columnId = wnd.GetColumnIdByView(i);
                    row.Cells.Add(new TableCell(new Paragraph(new Run(Document.ColumnDefinitions[columnId].ColumnName))));
                }
            }

            TableRowGroup mainRowGroup = new TableRowGroup();

            table.RowGroups.Add(mainRowGroup);

            // add all other columns
            for (int i = 0; i < linearList.Count; i++)
            {
                TableRow     tableRow = new TableRow();
                OutlinerNote note     = linearList[i];

                if (note.IsEmpty)
                {
                    tableRow.Cells.Add(new TableCell(new Paragraph()));
                    mainRowGroup.Rows.Add(tableRow);
                    continue;
                }

                for (int c = 0; c < wnd.OutlinerTreeColumns.Count; c++)
                {
                    int columnId = wnd.GetColumnIdByView(c);

                    FlowDocument flowDocument = linearList[i].Columns[columnId].ColumnData as FlowDocument;
                    if (flowDocument == null)
                    {
                        tableRow.Cells.Add(new TableCell());
                        continue;
                    }

                    double indent = note.Level * 20;

                    TableCell cell = new TableCell();
                    tableRow.Cells.Add(cell);

                    Section section = XamlReader.Load(TransformFlowDocumentToSection(flowDocument)) as Section;
                    if (section == null)
                    {
                        continue;
                    }

                    if (columnId != 0)
                    {
                        cell.Blocks.Add(section);
                    }
                    else
                    {
                        Table tbl = new Table();
                        tbl.LineHeight = 1;
                        tbl.Margin     = new Thickness(0);
                        tbl.Padding    = new Thickness(0);
                        TableColumn c1 = new TableColumn();
                        c1.Width = new GridLength(indent + 20 + (Document.CheckboxesVisble ? 20 : 0), GridUnitType.Pixel);
                        TableColumn c2 = new TableColumn();
                        c2.Width = new GridLength(1, GridUnitType.Auto);
                        tbl.Columns.Add(c1);
                        tbl.Columns.Add(c2);

                        var tmpRowGroup = new TableRowGroup();
                        var tmpRow      = new TableRow();
                        tmpRowGroup.Rows.Add(tmpRow);
                        tbl.RowGroups.Add(tmpRowGroup);


                        Paragraph para = new Paragraph();
                        para.Margin = new Thickness(indent, 0, 0, 0);
                        AddImages(Document, note, para);

                        tmpRow.Cells.Add(new TableCell(para));
                        tmpRow.Cells.Add(new TableCell(section));
                        cell.Blocks.Add(tbl);
                    }
                }

                mainRowGroup.Rows.Add(tableRow);
                if (note.HasInlineNote)
                {
                    AddInlineNote(mainRowGroup.Rows, note);
                }
            }


            MemoryStream      outStream = new MemoryStream();
            XmlWriterSettings settings  = new XmlWriterSettings();

            settings.Indent = true;
            XmlWriter writer = XmlWriter.Create(outStream, settings);
            XamlDesignerSerializationManager manager = new XamlDesignerSerializationManager(writer);

            XamlWriter.Save(wholeDocument, manager);

            outStream.Seek(0, SeekOrigin.Begin);
            StreamReader reader = new StreamReader(outStream);

            return(reader.ReadToEnd());
        }
Пример #24
0
        public string ExportReportToHTMLString()
        {
            try
            {
                FlowDocument new_fd  = this.CloneCurrentReportDocument(true);
                string       htmlRep = Helpers.FlowDocToHTMLConverter.ConvertXamlToHtml(XamlWriter.Save(new_fd));

                return(htmlRep);
            }
            catch (Exception ex)
            {
                SiliconStudio.DebugManagers.DebugReporter.Report(
                    SiliconStudio.DebugManagers.MessageType.Error,
                    "EjpControls - Report Editor",
                    "Failed to export Report to HTML" +
                    "\nParent Study ID: " + this.ParentStudyId.ToString() +
                    "\nReport ID: " + this._reportObject.Id.ToString() +
                    "\nError: " + ex.Message);

                MessageBox.Show("レポートをHTML化した際に失敗しました。", "エラー", MessageBoxButton.OK, MessageBoxImage.Error);
                return("");
            }
        }
Пример #25
0
        public static void CreateWindowsAccentStyle(bool changeImmediately = false)
        {
            var resourceDictionary = new ResourceDictionary();

            var color = SystemParameters.WindowGlassColor;

            resourceDictionary.Add("HighlightColor", color);
            resourceDictionary.Add("AccentColor", Color.FromArgb(204, color.R, color.G, color.B));
            resourceDictionary.Add("AccentColor2", Color.FromArgb(153, color.R, color.G, color.B));
            resourceDictionary.Add("AccentColor3", Color.FromArgb(102, color.R, color.G, color.B));
            resourceDictionary.Add("AccentColor4", Color.FromArgb(51, color.R, color.G, color.B));
            resourceDictionary.Add("HighlightBrush", new SolidColorBrush((Color)resourceDictionary["HighlightColor"]));
            resourceDictionary.Add("AccentColorBrush", new SolidColorBrush((Color)resourceDictionary["AccentColor"]));
            resourceDictionary.Add("AccentColorBrush2", new SolidColorBrush((Color)resourceDictionary["AccentColor2"]));
            resourceDictionary.Add("AccentColorBrush3", new SolidColorBrush((Color)resourceDictionary["AccentColor3"]));
            resourceDictionary.Add("AccentColorBrush4", new SolidColorBrush((Color)resourceDictionary["AccentColor4"]));
            resourceDictionary.Add("WindowTitleColorBrush", new SolidColorBrush((Color)resourceDictionary["AccentColor"]));
            resourceDictionary.Add("ProgressBrush", new LinearGradientBrush(new GradientStopCollection(new[]
            {
                new GradientStop((Color)resourceDictionary["HighlightColor"], 0),
                new GradientStop((Color)resourceDictionary["AccentColor3"], 1)
            }),
                                                                            new Point(0.001, 0.5), new Point(1.002, 0.5)));

            resourceDictionary.Add("CheckmarkFill", new SolidColorBrush((Color)resourceDictionary["AccentColor"]));
            resourceDictionary.Add("RightArrowFill", new SolidColorBrush((Color)resourceDictionary["AccentColor"]));

            resourceDictionary.Add("IdealForegroundColor", Colors.White);

            resourceDictionary.Add("IdealForegroundColorBrush", new SolidColorBrush((Color)resourceDictionary["IdealForegroundColor"]));
            resourceDictionary.Add("AccentSelectedColorBrush", new SolidColorBrush((Color)resourceDictionary["IdealForegroundColor"]));
            resourceDictionary.Add("MetroDataGrid.HighlightBrush", new SolidColorBrush((Color)resourceDictionary["AccentColor"]));
            resourceDictionary.Add("MetroDataGrid.HighlightTextBrush", new SolidColorBrush((Color)resourceDictionary["IdealForegroundColor"]));
            resourceDictionary.Add("MetroDataGrid.MouseOverHighlightBrush", new SolidColorBrush((Color)resourceDictionary["AccentColor3"]));
            resourceDictionary.Add("MetroDataGrid.FocusBorderBrush", new SolidColorBrush((Color)resourceDictionary["AccentColor"]));
            resourceDictionary.Add("MetroDataGrid.InactiveSelectionHighlightBrush", new SolidColorBrush((Color)resourceDictionary["AccentColor2"]));
            resourceDictionary.Add("MetroDataGrid.InactiveSelectionHighlightTextBrush", new SolidColorBrush((Color)resourceDictionary["IdealForegroundColor"]));

            var fileName = Path.Combine(Config.Instance.ConfigDir, "WindowsAccent.xaml");

            try
            {
                using (var stream = new FileStream(fileName, FileMode.OpenOrCreate, FileAccess.ReadWrite))
                    using (var writer = XmlWriter.Create(stream, new XmlWriterSettings {
                        Indent = true
                    }))
                        XamlWriter.Save(resourceDictionary, writer);
            }
            catch (Exception e)
            {
                Log.Error("Error creating WindowsAccent: " + e);
                return;
            }

            resourceDictionary = new ResourceDictionary {
                Source = new Uri(Path.GetFullPath(fileName), UriKind.Absolute)
            };

            ThemeManager.AddAccent(WindowAccentName, resourceDictionary.Source);

            var oldWindowsAccent = ThemeManager.GetAccent(WindowAccentName);

            oldWindowsAccent.Resources.Source = resourceDictionary.Source;

            if (changeImmediately)
            {
                ThemeManager.ChangeAppStyle(Application.Current, CurrentAccent, CurrentTheme);
            }
        }
 /// <summary>
 /// Save the column layout of lvResults to the application settings.
 /// </summary>
 public void PersistColumns()
 {
     Properties.Settings.Default.SearchColumns = XamlWriter.Save(((GridView)listView1.View).Columns);
 }
Пример #27
0
        public CitiesSelection(Country country)
        {
            InitializeComponent();
            Country = country;
            for (int i = 0; i < Country.CitiesCount; i++)
            {
                var SP = new StackPanel
                {
                    Name        = "City" + i.ToString(),
                    Orientation = Orientation.Horizontal,
                    Height      = 70
                };
                var CityName = new Label
                {
                    Name              = "City" + i.ToString() + "Name",
                    Width             = 300,
                    VerticalAlignment = VerticalAlignment.Center
                };
                if (Country.Cities[i].Name == "")
                {
                    CityName.Content = "Название города " + (i + 1).ToString();
                }
                else if (Country.Cities[i].Name.Length > 17)
                {
                    CityName.Content = Country.Cities[i].Name.Substring(0, 17) + "...";
                }
                else
                {
                    CityName.Content = Country.Cities[i].Name;
                }
                CityName.Style = this.Resources["LabelStyle"] as Style;
                SP.Children.Add(CityName);

                var EmptySpace = new Label
                {
                    Width = 100
                };
                SP.Children.Add(EmptySpace);

                string       template     = XamlWriter.Save(EditButtonTemplate.Template);
                StringReader stringReader = new StringReader(template);
                XmlReader    xmlReader    = XmlReader.Create(stringReader);
                var          EditButton   = new Button
                {
                    Name     = "City" + i.ToString() + "Edit",
                    Width    = 60,
                    Height   = 60,
                    Template = (ControlTemplate)XamlReader.Load(xmlReader)
                };
                EditButton.Click += CityEdit_Click;
                SP.Children.Add(EditButton);

                Cities.Children.Add(SP);

                if (i != Country.CitiesCount - 1)
                {
                    var BlackSpace = new Label
                    {
                        Style = this.Resources["Label2Style"] as Style
                    };
                    Cities.Children.Add(BlackSpace);
                }
            }
        }
Пример #28
0
        public Task <bool> LoadDocumentAsync(string svgFilePath)
        {
            if (_isLoadingDrawing || string.IsNullOrWhiteSpace(svgFilePath) || !File.Exists(svgFilePath))
            {
#if DOTNET40
                return(TaskEx.FromResult <bool>(false));
#else
                return(Task.FromResult <bool>(false));
#endif
            }

            string fileExt = Path.GetExtension(svgFilePath);

            if (!(string.Equals(fileExt, SvgConverter.SvgExt, StringComparison.OrdinalIgnoreCase) ||
                  string.Equals(fileExt, SvgConverter.CompressedSvgExt, StringComparison.OrdinalIgnoreCase)))
            {
                _svgFilePath = null;
#if DOTNET40
                return(TaskEx.FromResult <bool>(false));
#else
                return(Task.FromResult <bool>(false));
#endif
            }

            _isLoadingDrawing = true;

            this.UnloadDocument(true);

            DirectoryInfo workingDir = _workingDir;
            if (_directoryInfo != null)
            {
                workingDir = _directoryInfo;
            }

            _svgFilePath = svgFilePath;
            _saveXaml    = _optionSettings.ShowOutputFile;

            _embeddedImageVisitor.SaveImages    = !_wpfSettings.IncludeRuntime;
            _embeddedImageVisitor.SaveDirectory = _drawingDir;
            _wpfSettings.Visitors.ImageVisitor  = _embeddedImageVisitor;

            if (_fileReader == null)
            {
                _fileReader          = new FileSvgReader(_wpfSettings);
                _fileReader.SaveXaml = _saveXaml;
                _fileReader.SaveZaml = false;
            }

            var drawingStream = new MemoryStream();

            // Get the UI thread's context
            var context = TaskScheduler.FromCurrentSynchronizationContext();

            return(Task <bool> .Factory.StartNew(() =>
            {
//                var saveXaml = _fileReader.SaveXaml;
//                _fileReader.SaveXaml = true; // For threaded, we will save to avoid loading issue later...

                //Stopwatch stopwatch = new Stopwatch();

                //stopwatch.Start();

                //DrawingGroup drawing = _fileReader.Read(svgFilePath, workingDir);

                //stopwatch.Stop();

                //Trace.WriteLine(string.Format("FileName={0}, Time={1}",
                //    Path.GetFileName(svgFilePath), stopwatch.ElapsedMilliseconds));

                DrawingGroup drawing = _fileReader.Read(svgFilePath, workingDir);

//                _fileReader.SaveXaml = saveXaml;
                _drawingDocument = _fileReader.DrawingDocument;
                if (drawing != null)
                {
                    XamlWriter.Save(drawing, drawingStream);
                    drawingStream.Seek(0, SeekOrigin.Begin);

                    return true;
                }
                _svgFilePath = null;
                return false;
            }).ContinueWith((t) => {
                try
                {
                    if (!t.Result)
                    {
                        _isLoadingDrawing = false;
                        _svgFilePath = null;
                        return false;
                    }
                    if (drawingStream.Length != 0)
                    {
                        DrawingGroup drawing = (DrawingGroup)XamlReader.Load(drawingStream);

                        svgViewer.UnloadDiagrams();
                        svgViewer.RenderDiagrams(drawing);

                        Rect bounds = svgViewer.Bounds;

                        if (bounds.IsEmpty)
                        {
                            bounds = new Rect(0, 0, svgViewer.ActualWidth, svgViewer.ActualHeight);
                        }

                        zoomPanControl.AnimatedZoomTo(bounds);
                        CommandManager.InvalidateRequerySuggested();

                        // The drawing changed, update the source...
                        _fileReader.Drawing = drawing;
                    }

                    _isLoadingDrawing = false;

                    return true;
                }
                catch
                {
                    _isLoadingDrawing = false;
                    throw;
                }
            }, context));
        }
Пример #29
0
 public static string ConvertToXaml(object ui)
 {
     return(XamlWriter.Save(ui));
 }
 public static void SerializeContentTo([NotNull] this ContentControl control, [NotNull] TextWriter writer) => XamlWriter.Save(control.Content, writer);