Example #1
0
 public TextScrollWidget(PrinterConfig printer, List <string> sourceLines)
 {
     this.printer = new TypeFacePrinter("", new StyledTypeFace(ApplicationController.GetTypeFace(NamedTypeFace.Liberation_Mono), 12));
     this.printer.DrawFromHintedCache = true;
     this.allSourceLines = sourceLines;
     this.visibleLines   = sourceLines;
     printer.Connection.TerminalLog.HasChanged.RegisterEvent(RecievedNewLine, ref unregisterEvents);
 }
        public TextScrollWidget(PrinterConfig printer, List <TerminalLine> sourceLines)
        {
            this.printer         = printer;
            this.typeFacePrinter = new TypeFacePrinter("", new StyledTypeFace(ApplicationController.GetTypeFace(NamedTypeFace.Liberation_Mono), 12));
            this.typeFacePrinter.DrawFromHintedCache = true;
            this.allSourceLines = sourceLines;
            this.visibleLines   = sourceLines.Select(ld => ld.Line).ToList();

            // Register listeners
            printer.TerminalLog.LineAdded  += this.TerminalLog_LineAdded;
            printer.TerminalLog.LogCleared += this.TerminalLog_LogCleared;
        }
Example #3
0
        public TextScrollWidget(PrinterConfig printer, TerminalLog terminalLog)
        {
            this.printer         = printer;
            this.typeFacePrinter = new TypeFacePrinter("", new StyledTypeFace(ApplicationController.GetTypeFace(NamedTypeFace.Liberation_Mono), 12));
            this.typeFacePrinter.DrawFromHintedCache = true;
            this.terminalLog  = terminalLog;
            this.visibleLines = terminalLog.AllLines().ToList();

            // Register listeners
            printer.Connection.TerminalLog.LineAdded  += this.TerminalLog_LineAdded;
            printer.Connection.TerminalLog.LogCleared += this.TerminalLog_LogCleared;
        }
        public MacroDetailPage(GCodeMacro gcodeMacro, PrinterSettings printerSettings)
        {
            // Form validation fields
            MHTextEditWidget macroNameInput;
            MHTextEditWidget macroCommandInput;
            TextWidget       macroCommandError;
            TextWidget       macroNameError;

            this.HeaderText      = "Edit Macro".Localize();
            this.printerSettings = printerSettings;

            var elementMargin = new BorderDouble(top: 3);

            contentRow.Padding += 3;

            contentRow.AddChild(new TextWidget("Macro Name".Localize() + ":", 0, 0, 12)
            {
                TextColor = theme.Colors.PrimaryTextColor,
                HAnchor   = HAnchor.Stretch,
                Margin    = new BorderDouble(0, 0, 0, 1)
            });

            contentRow.AddChild(macroNameInput = new MHTextEditWidget(GCodeMacro.FixMacroName(gcodeMacro.Name))
            {
                HAnchor = HAnchor.Stretch
            });

            contentRow.AddChild(macroNameError = new TextWidget("Give the macro a name".Localize() + ".", 0, 0, 10)
            {
                TextColor = theme.Colors.PrimaryTextColor,
                HAnchor   = HAnchor.Stretch,
                Margin    = elementMargin
            });

            contentRow.AddChild(new TextWidget("Macro Commands".Localize() + ":", 0, 0, 12)
            {
                TextColor = theme.Colors.PrimaryTextColor,
                HAnchor   = HAnchor.Stretch,
                Margin    = new BorderDouble(0, 0, 0, 1)
            });

            macroCommandInput = new MHTextEditWidget(gcodeMacro.GCode, pixelHeight: 120, multiLine: true, typeFace: ApplicationController.GetTypeFace(NamedTypeFace.Liberation_Mono))
            {
                HAnchor = HAnchor.Stretch,
                VAnchor = VAnchor.Stretch
            };
            macroCommandInput.ActualTextEditWidget.VAnchor = VAnchor.Stretch;
            macroCommandInput.DrawFromHintedCache();
            contentRow.AddChild(macroCommandInput);

            contentRow.AddChild(macroCommandError = new TextWidget("This should be in 'G-Code'".Localize() + ".", 0, 0, 10)
            {
                TextColor = theme.Colors.PrimaryTextColor,
                HAnchor   = HAnchor.Stretch,
                Margin    = elementMargin
            });

            var container = new FlowLayoutWidget
            {
                Margin  = new BorderDouble(0, 5),
                HAnchor = HAnchor.Stretch
            };

            contentRow.AddChild(container);

            var addMacroButton = theme.CreateDialogButton("Save".Localize());

            addMacroButton.Click += (s, e) =>
            {
                UiThread.RunOnIdle(() =>
                {
                    if (ValidateMacroForm())
                    {
                        // SaveActiveMacro
                        gcodeMacro.Name  = macroNameInput.Text;
                        gcodeMacro.GCode = macroCommandInput.Text;

                        if (!printerSettings.Macros.Contains(gcodeMacro))
                        {
                            printerSettings.Macros.Add(gcodeMacro);
                            printerSettings.Save();
                        }

                        this.DialogWindow.ChangeToPage(new MacroListPage(printerSettings));
                    }
                });
            };

            this.AddPageAction(addMacroButton);

            // Define field validation
            var validationMethods        = new ValidationMethods();
            var stringValidationHandlers = new FormField.ValidationHandler[] { validationMethods.StringIsNotEmpty };

            formFields = new List <FormField>
            {
                new FormField(macroNameInput, macroNameError, stringValidationHandlers),
                new FormField(macroCommandInput, macroCommandError, stringValidationHandlers)
            };
        }
Example #5
0
        public TerminalWidget(PrinterConfig printer, ThemeConfig theme)
            : base(FlowDirection.TopToBottom)
        {
            this.printer = printer;
            this.Name    = "TerminalWidget";
            this.Padding = new BorderDouble(5, 0);

            // Header
            var headerRow = new FlowLayoutWidget(FlowDirection.LeftToRight)
            {
                HAnchor = HAnchor.Left | HAnchor.Stretch,
                Padding = new BorderDouble(0, 8)
            };

            this.AddChild(headerRow);

            headerRow.AddChild(CreateVisibilityOptions(theme));

            autoUppercase = new CheckBox("Auto Uppercase".Localize(), textSize: theme.DefaultFontSize)
            {
                Margin    = new BorderDouble(left: 25),
                Checked   = UserSettings.Instance.Fields.GetBool(UserSettingsKey.TerminalAutoUppercase, true),
                TextColor = theme.TextColor,
                VAnchor   = VAnchor.Center
            };
            autoUppercase.CheckedStateChanged += (s, e) =>
            {
                UserSettings.Instance.Fields.SetBool(UserSettingsKey.TerminalAutoUppercase, autoUppercase.Checked);
            };
            headerRow.AddChild(autoUppercase);

            // Body
            var bodyRow = new FlowLayoutWidget()
            {
                Margin  = new BorderDouble(bottom: 4),
                HAnchor = HAnchor.Stretch,
                VAnchor = VAnchor.Stretch
            };

            this.AddChild(bodyRow);

            textScrollWidget = new TextScrollWidget(printer, printer.Connection.TerminalLog)
            {
                BackgroundColor = theme.MinimalShade,
                TextColor       = theme.TextColor,
                HAnchor         = HAnchor.Stretch,
                VAnchor         = VAnchor.Stretch,
                Margin          = 0,
                Padding         = new BorderDouble(3, 0)
            };
            bodyRow.AddChild(textScrollWidget);
            bodyRow.AddChild(new TextScrollBar(textScrollWidget, 15)
            {
                ThumbColor      = theme.AccentMimimalOverlay,
                BackgroundColor = theme.SlightShade,
                Margin          = 0
            });

            textScrollWidget.LineFilterFunction = lineData =>
            {
                var line       = lineData.Line;
                var output     = lineData.Direction == TerminalLine.MessageDirection.ToPrinter;
                var outputLine = line;

                var lineWithoutChecksum = GCodeFile.GetLineWithoutChecksum(line);

                // and set this as the output if desired
                if (output &&
                    !UserSettings.Instance.Fields.GetBool(UserSettingsKey.TerminalShowChecksum, true))
                {
                    outputLine = lineWithoutChecksum;
                }

                if (!output &&
                    lineWithoutChecksum == "ok" &&
                    !UserSettings.Instance.Fields.GetBool(UserSettingsKey.TerminalShowOks, true))
                {
                    return(null);
                }
                else if (output &&
                         lineWithoutChecksum.StartsWith("M105") &&
                         !UserSettings.Instance.Fields.GetBool(UserSettingsKey.TerminalShowTempRequests, true))
                {
                    return(null);
                }
                else if (output &&
                         (lineWithoutChecksum.StartsWith("G0 ") || lineWithoutChecksum.StartsWith("G1 ")) &&
                         !UserSettings.Instance.Fields.GetBool(UserSettingsKey.TerminalShowMovementRequests, true))
                {
                    return(null);
                }
                else if (!output &&
                         (lineWithoutChecksum.StartsWith("T") || lineWithoutChecksum.StartsWith("ok T")) &&
                         !UserSettings.Instance.Fields.GetBool(UserSettingsKey.TerminalShowTempResponse, true))
                {
                    return(null);
                }
                else if (!output &&
                         lineWithoutChecksum == "wait" &&
                         !UserSettings.Instance.Fields.GetBool(UserSettingsKey.TerminalShowWaitResponse, false))
                {
                    return(null);
                }

                if (UserSettings.Instance.Fields.GetBool(UserSettingsKey.TerminalShowInputOutputMarks, true))
                {
                    switch (lineData.Direction)
                    {
                    case TerminalLine.MessageDirection.FromPrinter:
                        outputLine = "→ " + outputLine;
                        break;

                    case TerminalLine.MessageDirection.ToPrinter:
                        outputLine = "← " + outputLine;
                        break;

                    case TerminalLine.MessageDirection.ToTerminal:
                        outputLine = "* " + outputLine;
                        break;
                    }
                }

                return(outputLine);
            };

            // Input Row
            var inputRow = new FlowLayoutWidget(FlowDirection.LeftToRight)
            {
                BackgroundColor = this.BackgroundColor,
                HAnchor         = HAnchor.Stretch,
                Margin          = new BorderDouble(bottom: 2)
            };

            this.AddChild(inputRow);

            manualCommandTextEdit = new MHTextEditWidget("", theme, typeFace: ApplicationController.GetTypeFace(NamedTypeFace.Liberation_Mono))
            {
                Margin  = new BorderDouble(right: 3),
                HAnchor = HAnchor.Stretch,
                VAnchor = VAnchor.Bottom
            };
            manualCommandTextEdit.ActualTextEditWidget.EnterPressed += (s, e) =>
            {
                SendManualCommand();
            };
            manualCommandTextEdit.ActualTextEditWidget.KeyDown += (s, keyEvent) =>
            {
                bool changeToHistory = false;
                if (keyEvent.KeyCode == Keys.Up)
                {
                    commandHistoryIndex--;
                    if (commandHistoryIndex < 0)
                    {
                        commandHistoryIndex = 0;
                    }

                    changeToHistory = true;
                }
                else if (keyEvent.KeyCode == Keys.Down)
                {
                    commandHistoryIndex++;
                    if (commandHistoryIndex > commandHistory.Count - 1)
                    {
                        commandHistoryIndex = commandHistory.Count - 1;
                    }
                    else
                    {
                        changeToHistory = true;
                    }
                }
                else if (keyEvent.KeyCode == Keys.Escape)
                {
                    manualCommandTextEdit.Text = "";
                }

                if (changeToHistory && commandHistory.Count > 0)
                {
                    manualCommandTextEdit.Text = commandHistory[commandHistoryIndex];
                }
            };
            inputRow.AddChild(manualCommandTextEdit);

            // Footer
            var toolbarPadding = theme.ToolbarPadding;
            var footerRow      = new FlowLayoutWidget
            {
                HAnchor = HAnchor.Stretch,
                Padding = new BorderDouble(0, toolbarPadding.Bottom, toolbarPadding.Right, toolbarPadding.Top)
            };

            this.AddChild(footerRow);

            var sendButton = theme.CreateDialogButton("Send".Localize());

            sendButton.Margin = theme.ButtonSpacing;
            sendButton.Click += (s, e) =>
            {
                SendManualCommand();
            };
            footerRow.AddChild(sendButton);

            var clearButton = theme.CreateDialogButton("Clear".Localize());

            clearButton.Margin = theme.ButtonSpacing;
            clearButton.Click += (s, e) =>
            {
                printer.Connection.TerminalLog.Clear();
            };

            footerRow.AddChild(clearButton);

            var exportButton = theme.CreateDialogButton("Export".Localize());

            exportButton.Margin = theme.ButtonSpacing;
            exportButton.Click += (s, e) =>
            {
                UiThread.RunOnIdle(() =>
                {
                    AggContext.FileDialogs.SaveFileDialog(
                        new SaveFileDialogParams("Save as Text|*.txt")
                    {
                        Title             = "MatterControl: Terminal Log",
                        ActionButtonLabel = "Export",
                        FileName          = "print_log.txt"
                    },
                        (saveParams) =>
                    {
                        if (!string.IsNullOrEmpty(saveParams.FileName))
                        {
                            string filePathToSave = saveParams.FileName;

                            if (filePathToSave != null && filePathToSave != "")
                            {
                                try
                                {
                                    textScrollWidget.WriteToFile(filePathToSave);
                                }
                                catch (UnauthorizedAccessException ex)
                                {
                                    Debug.Print(ex.Message);

                                    printer.Connection.TerminalLog.WriteLine("");
                                    printer.Connection.TerminalLog.WriteLine("WARNING: Write Failed!".Localize());
                                    printer.Connection.TerminalLog.WriteLine("Can't access".Localize() + " " + filePathToSave);
                                    printer.Connection.TerminalLog.WriteLine("");

                                    UiThread.RunOnIdle(() =>
                                    {
                                        StyledMessageBox.ShowMessageBox(ex.Message, "Couldn't save file".Localize());
                                    });
                                }
                            }
                        }
                    });
                });
            };
            footerRow.AddChild(exportButton);

            footerRow.AddChild(new HorizontalSpacer());

            this.AnchorAll();
        }
Example #6
0
        public static SystemWindow LoadRootWindow(int width, int height)
        {
            timer = Stopwatch.StartNew();

            if (false)
            {
                // set the default font
                AggContext.DefaultFont           = ApplicationController.GetTypeFace(NamedTypeFace.Nunito_Regular);
                AggContext.DefaultFontBold       = ApplicationController.GetTypeFace(NamedTypeFace.Nunito_Bold);
                AggContext.DefaultFontItalic     = ApplicationController.GetTypeFace(NamedTypeFace.Nunito_Italic);
                AggContext.DefaultFontBoldItalic = ApplicationController.GetTypeFace(NamedTypeFace.Nunito_Bold_Italic);
            }

            var systemWindow = new RootSystemWindow(width, height);

            var overlay = new GuiWidget()
            {
                BackgroundColor = AppContext.Theme.BackgroundColor,
            };

            overlay.AnchorAll();

            systemWindow.AddChild(overlay);

            var mutedAccentColor = AppContext.Theme.SplashAccentColor;

            var spinner = new LogoSpinner(overlay, rotateX: -0.05)
            {
                MeshColor = mutedAccentColor
            };

            progressPanel = new FlowLayoutWidget(FlowDirection.TopToBottom)
            {
                Position    = new Vector2(0, height * .25),
                HAnchor     = HAnchor.Center | HAnchor.Fit,
                VAnchor     = VAnchor.Fit,
                MinimumSize = new Vector2(400, 100),
                Margin      = new BorderDouble(0, 0, 0, 200)
            };
            overlay.AddChild(progressPanel);

            progressPanel.AddChild(statusText = new TextWidget("", textColor: AppContext.Theme.TextColor)
            {
                MinimumSize            = new Vector2(200, 30),
                HAnchor                = HAnchor.Center,
                AutoExpandBoundsToText = true
            });

            progressPanel.AddChild(progressBar = new ProgressBar()
            {
                FillColor   = mutedAccentColor,
                BorderColor = Color.Gray,                 // theme.BorderColor75,
                Height      = 11,
                Width       = 230,
                HAnchor     = HAnchor.Center,
                VAnchor     = VAnchor.Absolute
            });

            AppContext.RootSystemWindow = systemWindow;

            // hook up a keyboard watcher to rout keys when not handled by children

            systemWindow.KeyPressed += SystemWindow_KeyPressed;

            systemWindow.KeyDown += (s, keyEvent) =>
            {
                var view3D            = systemWindow.Descendants <View3DWidget>().Where((v) => v.ActuallyVisibleOnScreen()).FirstOrDefault();
                var printerTabPage    = systemWindow.Descendants <PrinterTabPage>().Where((v) => v.ActuallyVisibleOnScreen()).FirstOrDefault();
                var offsetDist        = 50;
                var arrowKeyOperation = keyEvent.Shift ? TrackBallTransformType.Translation : TrackBallTransformType.Rotation;

                var gcode2D = systemWindow.Descendants <GCode2DWidget>().Where((v) => v.ActuallyVisibleOnScreen()).FirstOrDefault();

                if (keyEvent.KeyCode == Keys.F1)
                {
                    ApplicationController.Instance.ActivateHelpTab();
                }

                if (EnableF5Collect &&
                    keyEvent.KeyCode == Keys.F5)
                {
                    GC.Collect();
                    systemWindow.Invalidate();
                }

                if (!keyEvent.Handled &&
                    gcode2D != null)
                {
                    switch (keyEvent.KeyCode)
                    {
                    case Keys.Oemplus:
                    case Keys.Add:
                        if (keyEvent.Control)
                        {
                            // Zoom out
                            gcode2D.Zoom(1.2);
                            keyEvent.Handled = true;
                        }

                        break;

                    case Keys.OemMinus:
                    case Keys.Subtract:
                        if (keyEvent.Control)
                        {
                            // Zoom in
                            gcode2D.Zoom(.8);
                            keyEvent.Handled = true;
                        }

                        break;
                    }
                }

                if (!keyEvent.Handled &&
                    view3D != null)
                {
                    switch (keyEvent.KeyCode)
                    {
                    case Keys.C:
                        if (keyEvent.Control)
                        {
                            view3D.Scene.Copy();
                            keyEvent.Handled = true;
                        }

                        break;

                    case Keys.P:
                        if (keyEvent.Control)
                        {
                            view3D.PushToPrinterAndPrint();
                        }

                        break;

                    case Keys.X:
                        if (keyEvent.Control)
                        {
                            view3D.Scene.Cut();
                            keyEvent.Handled = true;
                        }

                        break;

                    case Keys.Y:
                        if (keyEvent.Control)
                        {
                            view3D.Scene.UndoBuffer.Redo();
                            keyEvent.Handled = true;
                        }

                        break;

                    case Keys.A:
                        if (keyEvent.Control)
                        {
                            view3D.SelectAll();
                            keyEvent.Handled = true;
                        }

                        break;

                    case Keys.S:
                        if (keyEvent.Control)
                        {
                            view3D.Save();
                            keyEvent.Handled = true;
                        }

                        break;

                    case Keys.V:
                        if (keyEvent.Control)
                        {
                            view3D.sceneContext.Paste();
                            keyEvent.Handled = true;
                        }

                        break;

                    case Keys.Oemplus:
                    case Keys.Add:
                        if (keyEvent.Control)
                        {
                            // Zoom out
                            Offset3DView(view3D, new Vector2(0, offsetDist), TrackBallTransformType.Scale);
                            keyEvent.Handled = true;
                        }

                        break;

                    case Keys.OemMinus:
                    case Keys.Subtract:
                        if (keyEvent.Control)
                        {
                            // Zoom in
                            Offset3DView(view3D, new Vector2(0, -offsetDist), TrackBallTransformType.Scale);
                            keyEvent.Handled = true;
                        }

                        break;

                    case Keys.Z:
                        if (keyEvent.Control)
                        {
                            if (keyEvent.Shift)
                            {
                                view3D.Scene.Redo();
                            }
                            else
                            {
                                // undo last operation
                                view3D.Scene.Undo();
                            }

                            keyEvent.Handled = true;
                        }

                        break;

                    case Keys.Insert:
                        if (keyEvent.Shift)
                        {
                            view3D.sceneContext.Paste();
                            keyEvent.Handled = true;
                        }

                        break;

                    case Keys.Delete:
                    case Keys.Back:
                        view3D.Scene.DeleteSelection();
                        keyEvent.Handled          = true;
                        keyEvent.SuppressKeyPress = true;
                        break;

                    case Keys.Escape:
                        if (view3D.CurrentSelectInfo.DownOnPart)
                        {
                            view3D.CurrentSelectInfo.DownOnPart = false;

                            view3D.Scene.SelectedItem.Matrix = view3D.TransformOnMouseDown;

                            keyEvent.Handled          = true;
                            keyEvent.SuppressKeyPress = true;
                        }

                        foreach (var interactionVolume in view3D.InteractionLayer.InteractionVolumes)
                        {
                            interactionVolume.CancelOperation();
                        }

                        break;

                    case Keys.Left:
                        if (keyEvent.Control &&
                            printerTabPage != null &&
                            !printerTabPage.sceneContext.ViewState.ModelView)
                        {
                            // Decrement slider
                            printerTabPage.LayerFeaturesIndex -= 1;
                        }
                        else
                        {
                            if (view3D.sceneContext.Scene.SelectedItem is IObject3D object3D)
                            {
                                NudgeItem(view3D, object3D, ArrowDirection.Left, keyEvent);
                            }
                            else
                            {
                                // move or rotate view left
                                Offset3DView(view3D, new Vector2(-offsetDist, 0), arrowKeyOperation);
                            }
                        }

                        keyEvent.Handled          = true;
                        keyEvent.SuppressKeyPress = true;
                        break;

                    case Keys.Right:
                        if (keyEvent.Control &&
                            printerTabPage != null &&
                            !printerTabPage.sceneContext.ViewState.ModelView)
                        {
                            // Increment slider
                            printerTabPage.LayerFeaturesIndex += 1;
                        }
                        else
                        {
                            if (view3D.sceneContext.Scene.SelectedItem is IObject3D object3D)
                            {
                                NudgeItem(view3D, object3D, ArrowDirection.Right, keyEvent);
                            }
                            else
                            {
                                // move or rotate view right
                                Offset3DView(view3D, new Vector2(offsetDist, 0), arrowKeyOperation);
                            }
                        }

                        keyEvent.Handled          = true;
                        keyEvent.SuppressKeyPress = true;
                        break;

                    case Keys.Up:
                        if (view3D.Printer != null &&
                            printerTabPage != null &&
                            view3D.Printer.ViewState.ViewMode != PartViewMode.Model)
                        {
                            printerTabPage.LayerScrollbar.Value += 1;
                        }
                        else
                        {
                            if (view3D.sceneContext.Scene.SelectedItem is IObject3D object3D)
                            {
                                NudgeItem(view3D, object3D, ArrowDirection.Up, keyEvent);
                            }
                            else
                            {
                                Offset3DView(view3D, new Vector2(0, offsetDist), arrowKeyOperation);
                            }
                        }

                        keyEvent.Handled          = true;
                        keyEvent.SuppressKeyPress = true;
                        break;

                    case Keys.Down:
                        if (view3D.Printer != null &&
                            printerTabPage != null &&
                            view3D.Printer.ViewState.ViewMode != PartViewMode.Model)
                        {
                            printerTabPage.LayerScrollbar.Value -= 1;
                        }
                        else
                        {
                            if (view3D.sceneContext.Scene.SelectedItem is IObject3D object3D)
                            {
                                NudgeItem(view3D, object3D, ArrowDirection.Down, keyEvent);
                            }
                            else
                            {
                                Offset3DView(view3D, new Vector2(0, -offsetDist), arrowKeyOperation);
                            }
                        }

                        keyEvent.Handled          = true;
                        keyEvent.SuppressKeyPress = true;
                        break;
                    }
                }
            };

            // Hook SystemWindow load and spin up MatterControl once we've hit first draw
            systemWindow.Load += (s, e) =>
            {
                // Show the End User License Agreement if it has not been shown (on windows it is shown in the installer)
                if (AggContext.OperatingSystem != OSType.Windows &&
                    UserSettings.Instance.get(UserSettingsKey.SoftwareLicenseAccepted) != "true")
                {
                    var eula = new LicenseAgreementPage(LoadMC)
                    {
                        Margin = new BorderDouble(5)
                    };

                    systemWindow.AddChild(eula);
                }
                else
                {
                    LoadMC();
                }
            };

            void LoadMC()
            {
                ReportStartupProgress(0.02, "First draw->RunOnIdle");

                // UiThread.RunOnIdle(() =>
                Task.Run(async() =>
                {
                    try
                    {
                        ReportStartupProgress(0.15, "MatterControlApplication.Initialize");

                        ApplicationController.LoadTranslationMap();

                        var mainView = await Initialize(systemWindow, (progress0To1, status) =>
                        {
                            ReportStartupProgress(0.2 + progress0To1 * 0.7, status);
                        });

                        ReportStartupProgress(0.9, "AddChild->MainView");
                        systemWindow.AddChild(mainView, 0);

                        ReportStartupProgress(1, "");
                        systemWindow.BackgroundColor = Color.Transparent;
                        overlay.Close();
                    }
                    catch (Exception ex)
                    {
                        UiThread.RunOnIdle(() =>
                        {
                            statusText.Visible = false;

                            var errorTextColor = Color.White;

                            progressPanel.Margin          = 0;
                            progressPanel.VAnchor         = VAnchor.Center | VAnchor.Fit;
                            progressPanel.BackgroundColor = Color.DarkGray;
                            progressPanel.Padding         = 20;
                            progressPanel.Border          = 1;
                            progressPanel.BorderColor     = Color.Red;

                            var theme = new ThemeConfig();

                            progressPanel.AddChild(
                                new TextWidget("Startup Failure".Localize() + ":", pointSize: theme.DefaultFontSize, textColor: errorTextColor));

                            progressPanel.AddChild(
                                new TextWidget(ex.Message, pointSize: theme.FontSize9, textColor: errorTextColor));

                            var closeButton = new TextButton("Close", theme)
                            {
                                BackgroundColor = theme.SlightShade,
                                HAnchor         = HAnchor.Right,
                                VAnchor         = VAnchor.Absolute
                            };
                            closeButton.Click += (s1, e1) =>
                            {
                                systemWindow.Close();
                            };

                            spinner.SpinLogo    = false;
                            progressBar.Visible = false;

                            progressPanel.AddChild(closeButton);
                        });
                    }

                    AppContext.IsLoading = false;
                });
            }

            ReportStartupProgress(0, "ShowAsSystemWindow");

            return(systemWindow);
        }
Example #7
0
        public MarkdownEditPage(UIField uiField)
        {
            this.WindowTitle = "MatterControl - " + "Markdown Edit".Localize();
            this.HeaderText  = "Edit Page".Localize() + ":";

            var tabControl = new SimpleTabs(theme, new GuiWidget())
            {
                HAnchor = HAnchor.Stretch,
                VAnchor = VAnchor.Stretch,
            };

            tabControl.TabBar.BackgroundColor = theme.TabBarBackground;
            tabControl.TabBar.Padding         = 0;

            contentRow.AddChild(tabControl);
            contentRow.Padding = 0;

            var editContainer = new GuiWidget()
            {
                HAnchor         = HAnchor.Stretch,
                VAnchor         = VAnchor.Stretch,
                Padding         = theme.DefaultContainerPadding,
                BackgroundColor = theme.BackgroundColor
            };

            editWidget = new MHTextEditWidget("", theme, multiLine: true, typeFace: ApplicationController.GetTypeFace(NamedTypeFace.Liberation_Mono))
            {
                HAnchor = HAnchor.Stretch,
                VAnchor = VAnchor.Stretch,
                Name    = this.Name
            };
            editWidget.DrawFromHintedCache();
            editWidget.ActualTextEditWidget.VAnchor = VAnchor.Stretch;

            editContainer.AddChild(editWidget);

            markdownWidget = new MarkdownWidget(theme, true)
            {
                HAnchor = HAnchor.Stretch,
                VAnchor = VAnchor.Stretch,
                Margin  = 0,
                Padding = 0,
            };

            var previewTab = new ToolTab("Preview", "Preview".Localize(), tabControl, markdownWidget, theme, hasClose: false)
            {
                Name = "Preview Tab"
            };

            tabControl.AddTab(previewTab);

            var editTab = new ToolTab("Edit", "Edit".Localize(), tabControl, editContainer, theme, hasClose: false)
            {
                Name = "Edit Tab"
            };

            tabControl.AddTab(editTab);

            tabControl.ActiveTabChanged += (s, e) =>
            {
                if (tabControl.SelectedTabIndex == 1)
                {
                    markdownWidget.Markdown = editWidget.Text;
                }
            };

            tabControl.SelectedTabIndex = 0;

            var saveButton = theme.CreateDialogButton("Save".Localize());

            saveButton.Click += (s, e) =>
            {
                uiField.SetValue(
                    editWidget.Text.Replace("\n", "\\n"),
                    userInitiated: true);

                this.DialogWindow.CloseOnIdle();
            };
            this.AddPageAction(saveButton);

            var link = new LinkLabel("Markdown Help", theme)
            {
                Margin  = new BorderDouble(right: 20),
                VAnchor = VAnchor.Center
            };

            link.Click += (s, e) =>
            {
                ApplicationController.Instance.LaunchBrowser("https://guides.github.com/features/mastering-markdown/");
            };
            footerRow.AddChild(link, 0);
        }
Example #8
0
        public TerminalWidget(PrinterConfig printer, ThemeConfig theme)
            : base(FlowDirection.TopToBottom)
        {
            this.printer = printer;
            this.Name    = "TerminalWidget";
            this.Padding = new BorderDouble(5, 0);

            // Header
            var headerRow = new FlowLayoutWidget(FlowDirection.LeftToRight)
            {
                HAnchor = HAnchor.Left | HAnchor.Stretch,
                Padding = new BorderDouble(0, 8)
            };

            this.AddChild(headerRow);

            filterOutput = new CheckBox("Filter Output".Localize(), textSize: theme.DefaultFontSize)
            {
                TextColor = theme.TextColor,
                VAnchor   = VAnchor.Bottom,
            };
            filterOutput.CheckedStateChanged += (s, e) =>
            {
                if (filterOutput.Checked)
                {
                    textScrollWidget.SetLineStartFilter(new string[] { "<-wait", "<-ok", "<-T" });
                }
                else
                {
                    textScrollWidget.SetLineStartFilter(null);
                }

                UserSettings.Instance.Fields.SetBool(UserSettingsKey.TerminalFilterOutput, filterOutput.Checked);
            };
            headerRow.AddChild(filterOutput);

            autoUppercase = new CheckBox("Auto Uppercase".Localize(), textSize: theme.DefaultFontSize)
            {
                Margin    = new BorderDouble(left: 25),
                Checked   = UserSettings.Instance.Fields.GetBool(UserSettingsKey.TerminalAutoUppercase, true),
                TextColor = theme.TextColor,
                VAnchor   = VAnchor.Bottom
            };
            autoUppercase.CheckedStateChanged += (s, e) =>
            {
                UserSettings.Instance.Fields.SetBool(UserSettingsKey.TerminalAutoUppercase, autoUppercase.Checked);
            };
            headerRow.AddChild(autoUppercase);

            // Body
            var bodyRow = new FlowLayoutWidget()
            {
                Margin  = new BorderDouble(bottom: 4),
                HAnchor = HAnchor.Stretch,
                VAnchor = VAnchor.Stretch
            };

            this.AddChild(bodyRow);

            textScrollWidget = new TextScrollWidget(printer, printer.Connection.TerminalLog.PrinterLines)
            {
                BackgroundColor = theme.MinimalShade,
                TextColor       = theme.TextColor,
                HAnchor         = HAnchor.Stretch,
                VAnchor         = VAnchor.Stretch,
                Margin          = 0,
                Padding         = new BorderDouble(3, 0)
            };
            bodyRow.AddChild(textScrollWidget);
            bodyRow.AddChild(new TextScrollBar(textScrollWidget, 15)
            {
                ThumbColor      = theme.AccentMimimalOverlay,
                BackgroundColor = theme.SlightShade,
                Margin          = 0
            });

            // Input Row
            var inputRow = new FlowLayoutWidget(FlowDirection.LeftToRight)
            {
                BackgroundColor = this.BackgroundColor,
                HAnchor         = HAnchor.Stretch,
                Margin          = new BorderDouble(bottom: 2)
            };

            this.AddChild(inputRow);

            manualCommandTextEdit = new MHTextEditWidget("", theme, typeFace: ApplicationController.GetTypeFace(NamedTypeFace.Liberation_Mono))
            {
                Margin  = new BorderDouble(right: 3),
                HAnchor = HAnchor.Stretch,
                VAnchor = VAnchor.Bottom
            };
            manualCommandTextEdit.ActualTextEditWidget.EnterPressed += (s, e) =>
            {
                SendManualCommand();
            };
            manualCommandTextEdit.ActualTextEditWidget.KeyDown += (s, keyEvent) =>
            {
                bool changeToHistory = false;
                if (keyEvent.KeyCode == Keys.Up)
                {
                    commandHistoryIndex--;
                    if (commandHistoryIndex < 0)
                    {
                        commandHistoryIndex = 0;
                    }
                    changeToHistory = true;
                }
                else if (keyEvent.KeyCode == Keys.Down)
                {
                    commandHistoryIndex++;
                    if (commandHistoryIndex > commandHistory.Count - 1)
                    {
                        commandHistoryIndex = commandHistory.Count - 1;
                    }
                    else
                    {
                        changeToHistory = true;
                    }
                }
                else if (keyEvent.KeyCode == Keys.Escape)
                {
                    manualCommandTextEdit.Text = "";
                }

                if (changeToHistory && commandHistory.Count > 0)
                {
                    manualCommandTextEdit.Text = commandHistory[commandHistoryIndex];
                }
            };
            inputRow.AddChild(manualCommandTextEdit);

            // Footer
            var toolbarPadding = theme.ToolbarPadding;
            var footerRow      = new FlowLayoutWidget
            {
                HAnchor = HAnchor.Stretch,
                Padding = new BorderDouble(0, toolbarPadding.Bottom, toolbarPadding.Right, toolbarPadding.Top)
            };

            this.AddChild(footerRow);

            var sendButton = theme.CreateDialogButton("Send".Localize());

            sendButton.Margin = theme.ButtonSpacing;
            sendButton.Click += (s, e) =>
            {
                SendManualCommand();
            };
            footerRow.AddChild(sendButton);

            var clearButton = theme.CreateDialogButton("Clear".Localize());

            clearButton.Margin = theme.ButtonSpacing;
            clearButton.Click += (s, e) =>
            {
                printer.Connection.TerminalLog.Clear();
            };
            footerRow.AddChild(clearButton);

            var exportButton = theme.CreateDialogButton("Export".Localize());

            exportButton.Margin = theme.ButtonSpacing;
            exportButton.Click += (s, e) =>
            {
                UiThread.RunOnIdle(() =>
                {
                    AggContext.FileDialogs.SaveFileDialog(
                        new SaveFileDialogParams("Save as Text|*.txt")
                    {
                        Title             = "MatterControl: Terminal Log",
                        ActionButtonLabel = "Export",
                        FileName          = "print_log.txt"
                    },
                        (saveParams) =>
                    {
                        if (!string.IsNullOrEmpty(saveParams.FileName))
                        {
                            string filePathToSave = saveParams.FileName;
                            if (filePathToSave != null && filePathToSave != "")
                            {
                                try
                                {
                                    textScrollWidget.WriteToFile(filePathToSave);
                                }
                                catch (UnauthorizedAccessException ex)
                                {
                                    Debug.Print(ex.Message);

                                    printer.Connection.TerminalLog.PrinterLines.Add("");
                                    printer.Connection.TerminalLog.PrinterLines.Add(writeFaildeWaring);
                                    printer.Connection.TerminalLog.PrinterLines.Add(cantAccessPath.FormatWith(filePathToSave));
                                    printer.Connection.TerminalLog.PrinterLines.Add("");

                                    UiThread.RunOnIdle(() =>
                                    {
                                        StyledMessageBox.ShowMessageBox(ex.Message, "Couldn't save file".Localize());
                                    });
                                }
                            }
                        }
                    });
                });
            };
            footerRow.AddChild(exportButton);

            footerRow.AddChild(new HorizontalSpacer());

            this.AnchorAll();
        }