public FreeformShapeTool(DocumentWorkspace documentWorkspace) : base(documentWorkspace, PdnResources.GetImageResource("Icons.FreeformShapeToolIcon.png"), PdnResources.GetString("FreeformShapeTool.Name"), PdnResources.GetString("FreeformShapeTool.HelpText")) { }
public override HistoryMemento PerformAction(DocumentWorkspace documentWorkspace) { DateTime lastUpdate = DateTime.Now; documentWorkspace.History.BeginStepGroup(); using (new WaitCursorChanger(documentWorkspace)) { documentWorkspace.SuspendToolCursorChanges(); while (documentWorkspace.History.RedoStack.Count > 0) { documentWorkspace.History.StepForward(); if ((DateTime.Now - lastUpdate).TotalMilliseconds >= 500) { documentWorkspace.History.EndStepGroup(); documentWorkspace.Update(); lastUpdate = DateTime.Now; documentWorkspace.History.BeginStepGroup(); } } documentWorkspace.ResumeToolCursorChanges(); } documentWorkspace.History.EndStepGroup(); Utility.GCFullCollect(); documentWorkspace.Document.Invalidate(); documentWorkspace.Update(); return null; }
public EllipseTool(DocumentWorkspace documentWorkspace) : base(documentWorkspace, ImageResource.Get("Icons.EllipseToolIcon.png"), PdnResources.GetString("EllipseTool.Name"), PdnResources.GetString("EllipseTool.HelpText")) { }
public RoundedRectangleTool(DocumentWorkspace documentWorkspace) : base(documentWorkspace, ImageResource.Get("Icons.RoundedRectangleToolIcon.png"), PdnResources.GetString("RoundedRectangleTool.Name"), PdnResources.GetString("RoundedRectangleTool.HelpText")) { }
public EllipseSelectTool(DocumentWorkspace documentWorkspace) : base(documentWorkspace, ImageResource.Get("Icons.EllipseSelectToolIcon.png"), PdnResources.GetString("EllipseSelectTool.Name"), PdnResources.GetString("EllipseSelectTool.HelpText"), 's', ToolBarConfigItems.None) { }
public LassoSelectTool(DocumentWorkspace documentWorkspace) : base(documentWorkspace, PdnResources.GetImageResource("Icons.LassoSelectToolIcon.png"), PdnResources.GetString("LassoSelectTool.Name"), PdnResources.GetString("LassoSelectTool.HelpText"), 's', ToolBarConfigItems.None) { }
public GradientTool(DocumentWorkspace documentWorkspace) : base(documentWorkspace, StaticImage, StaticName, PdnResources.GetString("GradientTool.HelpText"), 'g', false, ToolBarConfigItems.Gradient | ToolBarConfigItems.AlphaBlending) { }
public PaintBucketTool(DocumentWorkspace documentWorkspace) : base(documentWorkspace, ImageResource.Get("Icons.PaintBucketIcon.png"), PdnResources.GetString("PaintBucketTool.Name"), PdnResources.GetString("PaintBucketTool.HelpText"), 'f', false, ToolBarConfigItems.Brush | ToolBarConfigItems.Antialiasing | ToolBarConfigItems.AlphaBlending) { }
public EraserTool(DocumentWorkspace documentWorkspace) : base(documentWorkspace, ImageResource.Get("Icons.EraserToolIcon.png"), PdnResources.GetString("EraserTool.Name"), PdnResources.GetString("EraserTool.HelpText"), //"Click and drag to erase a portion of the image", 'e', false, ToolBarConfigItems.Pen | ToolBarConfigItems.Antialiasing) { }
public RecolorTool(DocumentWorkspace documentWorkspace) : base(documentWorkspace, ImageResource.Get("Icons.RecoloringToolIcon.png"), PdnResources.GetString("RecolorTool.Name"), PdnResources.GetString("RecolorTool.HelpText"), 'r', false, ToolBarConfigItems.Pen | ToolBarConfigItems.Antialiasing | ToolBarConfigItems.Tolerance) { }
public CloneStampTool(DocumentWorkspace documentWorkspace) : base(documentWorkspace, ImageResource.Get("Icons.CloneStampToolIcon.png"), PdnResources.GetString("CloneStampTool.Name"), PdnResources.GetString("CloneStampTool.HelpText"), 'l', false, ToolBarConfigItems.Pen | ToolBarConfigItems.Antialiasing) { }
public MagicWandTool(DocumentWorkspace documentWorkspace) : base(documentWorkspace, ImageResource.Get("Icons.MagicWandToolIcon.png"), PdnResources.GetString("MagicWandTool.Name"), PdnResources.GetString("MagicWandTool.HelpText"), 's', false, ToolBarConfigItems.None) { LimitToSelection = false; }
public LineTool(DocumentWorkspace documentWorkspace) : base(documentWorkspace, ImageResource.Get("Icons.LineToolIcon.png"), PdnResources.GetString("LineTool.Name"), PdnResources.GetString("LineTool.HelpText"), ToolBarConfigItems.None, ToolBarConfigItems.ShapeType) { this.ForceShapeDrawType = true; this.ForcedShapeDrawType = ShapeDrawType.Outline; }
public MoveSelectionTool(DocumentWorkspace documentWorkspace) : base(documentWorkspace, ImageResource.Get("Icons.MoveSelectionToolIcon.png"), MoveSelectionTool.StaticName, PdnResources.GetString("MoveSelectionTool.HelpText"), // "Click and drag to move a selected region", 'm', false, ToolBarConfigItems.None) { this.context = new Context(); }
public ZoomTool(DocumentWorkspace documentWorkspace) : base(documentWorkspace, ImageResource.Get("Icons.ZoomToolIcon.png"), PdnResources.GetString("ZoomTool.Name"), PdnResources.GetString("ZoomTool.HelpText"), 'z', false, ToolBarConfigItems.None) { this.mouseDown = MouseButtons.None; }
public ColorPickerTool(DocumentWorkspace documentWorkspace) : base(documentWorkspace, ImageResource.Get("Icons.ColorPickerToolIcon.png"), PdnResources.GetString("ColorPickerTool.Name"), PdnResources.GetString("ColorPickerTool.HelpText"), 'p', true, ToolBarConfigItems.ColorPickerBehavior) { // initialize any state information you need mouseDown = false; }
public MoveTool(DocumentWorkspace documentWorkspace) : base(documentWorkspace, ImageResource.Get("Icons.MoveToolIcon.png"), MoveTool.StaticName, PdnResources.GetString("MoveTool.HelpText"), // "Click and drag to move a selected region", 'm', false, ToolBarConfigItems.Resampling) { this.context = new MoveToolContext(); this.enableOutline = false; }
public PencilTool(DocumentWorkspace documentWorkspace) : base(documentWorkspace, ImageResource.Get("Icons.PencilToolIcon.png"), PdnResources.GetString("PencilTool.Name"), PdnResources.GetString("PencilTool.HelpText"), 'p', true, ToolBarConfigItems.AlphaBlending) { // initialize any state information you need mouseDown = false; }
public PanTool(DocumentWorkspace documentWorkspace) : base(documentWorkspace, ImageResource.Get("Icons.PanToolIcon.png"), PdnResources.GetString("PanTool.Name"), PdnResources.GetString("PanTool.HelpText"), 'h', false, ToolBarConfigItems.None) { autoScroll = false; tracking = false; }
public PaintBrushTool(DocumentWorkspace documentWorkspace) : base(documentWorkspace, ImageResource.Get("Icons.PaintBrushToolIcon.png"), PdnResources.GetString("PaintBrushTool.Name"), PdnResources.GetString("PaintBrushTool.HelpText"), 'b', false, ToolBarConfigItems.Brush | ToolBarConfigItems.Pen | ToolBarConfigItems.Antialiasing | ToolBarConfigItems.AlphaBlending) { // initialize any state information you need mouseDown = false; }
public override HistoryMemento PerformAction(DocumentWorkspace documentWorkspace) { if (!ScanningAndPrinting.CanPrint) { Utility.ShowWiaError(documentWorkspace); return null; } using (new PushNullToolMode(documentWorkspace)) { // render image to a bitmap, save it to disk Surface scratch = documentWorkspace.BorrowScratchSurface(this.GetType().Name + ".PerformAction()"); try { scratch.Clear(); RenderArgs ra = new RenderArgs(scratch); documentWorkspace.Update(); using (new WaitCursorChanger(documentWorkspace)) { ra.Surface.Clear(ColorBgra.White); documentWorkspace.Document.Render(ra, false); } string tempName = Path.GetTempFileName() + ".bmp"; ra.Bitmap.Save(tempName, ImageFormat.Bmp); try { ScanningAndPrinting.Print(documentWorkspace, tempName); } catch (Exception ex) { Utility.ShowWiaError(documentWorkspace); Tracing.Ping(ex.ToString()); // TODO: do a "better" error dialog here } // Try to delete the temp file but don't worry if we can't bool result = FileSystem.TryDeleteFile(tempName); } finally { documentWorkspace.ReturnScratchSurface(scratch); } } return null; }
public override HistoryMemento PerformAction(DocumentWorkspace documentWorkspace) { if (documentWorkspace.ZoomBasis == ZoomBasis.FitToWindow) { documentWorkspace.ZoomBasis = ZoomBasis.ScaleFactor; } else { documentWorkspace.ZoomBasis = ZoomBasis.FitToWindow; } return null; }
public ShapeTool(DocumentWorkspace documentWorkspace, ImageResource toolBarImage, string name, string helpText) : this(documentWorkspace, toolBarImage, name, helpText, defaultShortcut, ToolBarConfigItems.None, ToolBarConfigItems.None) { }
public override HistoryMemento PerformAction(DocumentWorkspace documentWorkspace) { if (DialogResult.Yes == Utility.AskYesNo(documentWorkspace, PdnResources.GetString("ClearHistory.Confirmation"))) { documentWorkspace.History.ClearAll(); documentWorkspace.History.PushNewMemento(new NullHistoryMemento( PdnResources.GetString("ClearHistory.HistoryMementoName"), ImageResource.Get("Icons.MenuLayersDeleteLayerIcon.png"))); } return null; }
public override HistoryMemento PerformAction(DocumentWorkspace documentWorkspace) { bool oldDirtyValue = documentWorkspace.Document.Dirty; using (Form lpd = documentWorkspace.ActiveLayer.CreateConfigDialog()) { DialogResult result = Utility.ShowDialog(lpd, documentWorkspace.FindForm()); if (result == DialogResult.Cancel) { documentWorkspace.Document.Dirty = oldDirtyValue; } } return null; }
public SelectionTool( DocumentWorkspace documentWorkspace, ImageResource toolBarImage, string name, string helpText, char hotKey, ToolBarConfigItems toolBarConfigItems) : base(documentWorkspace, toolBarImage, name, helpText, hotKey, false, toolBarConfigItems) { this.tracking = false; }
private HistoryMemento DoCanvasResize(DocumentWorkspace documentWorkspace, Size newLayerSize) { HistoryMemento retHA; int layerIndex = documentWorkspace.ActiveLayerIndex; Size newSize = new Size(Math.Max(newLayerSize.Width, documentWorkspace.Document.Width), Math.Max(newLayerSize.Height, documentWorkspace.Document.Height)); Document newDoc; try { using (new WaitCursorChanger(documentWorkspace)) { Utility.GCFullCollect(); newDoc = CanvasSizeAction.ResizeDocument(documentWorkspace.Document, newSize, AnchorEdge.TopLeft, documentWorkspace.AppWorkspace.AppEnvironment.SecondaryColor); } } catch (OutOfMemoryException) { Utility.ErrorBox(documentWorkspace, PdnResources.GetString("ImportFromFileAction.AskForCanvasResize.OutOfMemory")); newDoc = null; } if (newDoc == null) { retHA = null; } else { retHA = new ReplaceDocumentHistoryMemento(string.Empty, null, documentWorkspace); using (new WaitCursorChanger(documentWorkspace)) { documentWorkspace.Document = newDoc; } documentWorkspace.ActiveLayer = (Layer)documentWorkspace.Document.Layers[layerIndex]; } return retHA; }
public override HistoryMemento PerformAction(DocumentWorkspace documentWorkspace) { if (documentWorkspace.History.RedoStack.Count > 0) { if (!(documentWorkspace.History.RedoStack[documentWorkspace.History.RedoStack.Count - 1] is NullHistoryMemento)) { using (new WaitCursorChanger(documentWorkspace.FindForm())) { documentWorkspace.History.StepForward(); documentWorkspace.Update(); } } Utility.GCFullCollect(); } return null; }
public override HistoryMemento PerformAction(DocumentWorkspace documentWorkspace) { HistoryMemento hm = null; int index = documentWorkspace.ActiveLayerIndex; if (index != 0) { SwapLayerHistoryMemento slhm = new SwapLayerHistoryMemento( StaticName, StaticImage, documentWorkspace, index, index - 1); hm = slhm.PerformUndo(); } return hm; }
public override HistoryMemento PerformAction(DocumentWorkspace documentWorkspace) { HistoryMemento hm = null; int index = documentWorkspace.ActiveLayerIndex; if (index != documentWorkspace.Document.Layers.Count - 1) { SwapLayerFunction slf = new SwapLayerFunction(index, index + 1); HistoryMemento slfhm = slf.Execute(documentWorkspace); hm = new CompoundHistoryMemento( StaticName, StaticImage, new HistoryMemento[] { slfhm }); documentWorkspace.ActiveLayer = (Layer)documentWorkspace.Document.Layers[index + 1]; } return hm; }
/// <summary> /// This method is called when the tool is active and a keyboard key is pressed /// and released. If you respond to the keyboard key, set e.Handled to true. /// </summary> protected virtual void OnKeyPress(KeyPressEventArgs e) { if (!e.Handled && DocumentWorkspace.Focused) { if (e.KeyChar == swapColorsShortcut) { AppWorkspace.Widgets.ColorsForm.SwapUserColors(); e.Handled = true; } else if (e.KeyChar == swapPrimarySecondaryChoice) { AppWorkspace.Widgets.ColorsForm.ToggleWhichUserColor(); e.Handled = true; } else if (e.KeyChar == decPenSizeShortcut) { AppWorkspace.Widgets.ToolConfigStrip.AddToPenSize(-1.0f); e.Handled = true; } else if (e.KeyChar == decPenSizeBy5Shortcut && (ModifierKeys & Keys.Control) != 0) { AppWorkspace.Widgets.ToolConfigStrip.AddToPenSize(-5.0f); e.Handled = true; } else if (e.KeyChar == incPenSizeShortcut) { AppWorkspace.Widgets.ToolConfigStrip.AddToPenSize(+1.0f); e.Handled = true; } else if (e.KeyChar == incPenSizeBy5Shortcut && (ModifierKeys & Keys.Control) != 0) { AppWorkspace.Widgets.ToolConfigStrip.AddToPenSize(+5.0f); e.Handled = true; } else { ToolInfo[] toolInfos = DocumentWorkspace.ToolInfos; Type currentToolType = DocumentWorkspace.GetToolType(); int currentTool = 0; if (0 != (ModifierKeys & Keys.Shift)) { Array.Reverse(toolInfos); } if (char.ToLower(this.HotKey) != char.ToLower(e.KeyChar) || (DateTime.Now - lastToolSwitch) > toolSwitchReset) { // If it's been a short time since they pressed a tool switching hotkey, // we will start from the beginning of this list. This helps to enable two things: // 1) If multiple tools have the same hotkey, the user may press that hotkey // to cycle through them // 2) After a period of time, pressing the hotkey will revert to always // choosing the first tool in that list of tools which have the same hotkey. currentTool = -1; } else { for (int t = 0; t < toolInfos.Length; ++t) { if (toolInfos[t].ToolType == currentToolType) { currentTool = t; break; } } } for (int t = 0; t < toolInfos.Length; ++t) { int newTool = (t + currentTool + 1) % toolInfos.Length; ToolInfo localToolInfo = toolInfos[newTool]; if (localToolInfo.ToolType == DocumentWorkspace.GetToolType() && localToolInfo.SkipIfActiveOnHotKey) { continue; } if (char.ToLower(localToolInfo.HotKey) == char.ToLower(e.KeyChar)) { if (!this.IsMouseDown) { AppWorkspace.Widgets.ToolsControl.SelectTool(localToolInfo.ToolType); } e.Handled = true; lastToolSwitch = DateTime.Now; break; } } // If the keypress is still not handled ... if (!e.Handled) { switch (e.KeyChar) { // By default, Esc/Enter clear the current selection if there is any case (char)13: // Enter case (char)27: // Escape if (this.mouseDown == 0 && !Selection.IsEmpty) { e.Handled = true; DocumentWorkspace.ExecuteFunction(new DeselectFunction()); } break; } } } } }
public FloodToolBase(DocumentWorkspace documentWorkspace, ImageResource toolBarImage, string name, string helpText, char hotKey, bool skipIfActiveOnHotKey, ToolBarConfigItems toolBarConfigItems) : base(documentWorkspace, toolBarImage, name, helpText, hotKey, skipIfActiveOnHotKey, ToolBarConfigItems.Tolerance | toolBarConfigItems) { }
public override HistoryMemento PerformAction(DocumentWorkspace documentWorkspace) { int newWidth; int newHeight; double newDpu; MeasurementUnit newDpuUnit; string resamplingAlgorithm = Settings.CurrentUser.GetString(SettingNames.LastResamplingMethod, ResamplingAlgorithm.SuperSampling.ToString()); ResamplingAlgorithm alg; try { alg = (ResamplingAlgorithm)Enum.Parse(typeof(ResamplingAlgorithm), resamplingAlgorithm, true); } catch { alg = ResamplingAlgorithm.SuperSampling; } bool maintainAspect = Settings.CurrentUser.GetBoolean(SettingNames.LastMaintainAspectRatio, true); using (ResizeDialog rd = new ResizeDialog()) { rd.OriginalSize = documentWorkspace.Document.Size; rd.OriginalDpuUnit = documentWorkspace.Document.DpuUnit; rd.OriginalDpu = documentWorkspace.Document.DpuX; rd.ImageHeight = documentWorkspace.Document.Height; rd.ImageWidth = documentWorkspace.Document.Width; rd.ResamplingAlgorithm = alg; rd.LayerCount = documentWorkspace.Document.Layers.Count; rd.Units = rd.OriginalDpuUnit; rd.Resolution = documentWorkspace.Document.DpuX; rd.Units = SettingNames.GetLastNonPixelUnits(); rd.ConstrainToAspect = maintainAspect; DialogResult result = rd.ShowDialog(documentWorkspace); if (result == DialogResult.Cancel) { return(null); } Settings.CurrentUser.SetString(SettingNames.LastResamplingMethod, rd.ResamplingAlgorithm.ToString()); Settings.CurrentUser.SetBoolean(SettingNames.LastMaintainAspectRatio, rd.ConstrainToAspect); newDpuUnit = rd.Units; newWidth = rd.ImageWidth; newHeight = rd.ImageHeight; newDpu = rd.Resolution; alg = rd.ResamplingAlgorithm; if (newDpuUnit != MeasurementUnit.Pixel) { Settings.CurrentUser.SetString(SettingNames.LastNonPixelUnits, newDpuUnit.ToString()); if (documentWorkspace.AppWorkspace.Units != MeasurementUnit.Pixel) { documentWorkspace.AppWorkspace.Units = newDpuUnit; } } // if the new size equals the old size, there's really no point in doing anything if (documentWorkspace.Document.Size == new Size(rd.ImageWidth, rd.ImageHeight) && documentWorkspace.Document.DpuX == newDpu && documentWorkspace.Document.DpuUnit == newDpuUnit) { return(null); } } HistoryMemento ha; if (newWidth == documentWorkspace.Document.Width && newHeight == documentWorkspace.Document.Height) { // Only adjusting Dpu or DpuUnit ha = new MetaDataHistoryMemento(StaticName, StaticImage, documentWorkspace); documentWorkspace.Document.DpuUnit = newDpuUnit; documentWorkspace.Document.DpuX = newDpu; documentWorkspace.Document.DpuY = newDpu; } else { try { using (new WaitCursorChanger(documentWorkspace)) { ha = new ReplaceDocumentHistoryMemento(StaticName, StaticImage, documentWorkspace); } Document newDocument = new Document(newWidth, newHeight); newDocument.ReplaceMetaDataFrom(documentWorkspace.Document); newDocument.DpuUnit = newDpuUnit; newDocument.DpuX = newDpu; newDocument.DpuY = newDpu; ResizeProgressDialog rpd = new ResizeProgressDialog(documentWorkspace, newDocument, documentWorkspace.Document, new Size(newWidth, newHeight), alg); Utility.GCFullCollect(); bool result = rpd.DoResize(); if (!result) { return(null); } documentWorkspace.Document = newDocument; } catch (WorkerThreadException ex) { if (ex.InnerException is OutOfMemoryException) { Utility.ErrorBox(documentWorkspace, PdnResources.GetString("ResizeAction.PerformAction.OutOfMemory")); return(null); } else { throw; } } catch (OutOfMemoryException) { Utility.ErrorBox(documentWorkspace, PdnResources.GetString("ResizeAction.PerformAction.OutOfMemory")); return(null); } } return(ha); }
public CopyToClipboardAction(DocumentWorkspace documentWorkspace) { SystemLayer.Tracing.LogFeature("CopyToClipboardAction"); this.documentWorkspace = documentWorkspace; }
public MoveSelectedPixelsTool(DocumentWorkspace docWorkspace) : base(docWorkspace, PdnResources.GetImageResource("Icons.MoveToolIcon.png"), PdnResources.GetString("MoveTool.Name"), PdnResources.GetString("MoveTool.HelpText"), 'm', false, ToolBarConfigItems.None | ToolBarConfigItems.Resampling, true) { }
public override HistoryMemento PerformAction(DocumentWorkspace docWorkspace) { int newWidth; int newHeight; MeasurementUnit newDpuUnit; double newDpu; ResamplingAlgorithm algorithm = AppSettings.Instance.Workspace.LastResamplingMethod.Value; if (algorithm == ResamplingAlgorithm.SuperSampling) { algorithm = ResamplingAlgorithm.Fant; } bool flag = AppSettings.Instance.Workspace.LastMaintainAspectRatio.Value; using (ResizeDialog dialog = new ResizeDialog()) { dialog.OriginalSize = docWorkspace.Document.Size; dialog.OriginalDpuUnit = docWorkspace.Document.DpuUnit; dialog.OriginalDpu = docWorkspace.Document.DpuX; dialog.ImageHeight = docWorkspace.Document.Height; dialog.ImageWidth = docWorkspace.Document.Width; dialog.ResamplingAlgorithm = algorithm; dialog.LayerCount = docWorkspace.Document.Layers.Count; dialog.Units = dialog.OriginalDpuUnit; dialog.Resolution = docWorkspace.Document.DpuX; dialog.Units = AppSettings.Instance.Workspace.LastNonPixelUnits.Value; dialog.ConstrainToAspect = flag; if (dialog.ShowDialog(docWorkspace) == DialogResult.Cancel) { return(null); } AppSettings.Instance.Workspace.LastResamplingMethod.Value = dialog.ResamplingAlgorithm; AppSettings.Instance.Workspace.LastMaintainAspectRatio.Value = dialog.ConstrainToAspect; newDpuUnit = dialog.Units; newWidth = dialog.ImageWidth; newHeight = dialog.ImageHeight; newDpu = dialog.Resolution; algorithm = dialog.ResamplingAlgorithm; if (newDpuUnit != MeasurementUnit.Pixel) { AppSettings.Instance.Workspace.LastNonPixelUnits.Value = newDpuUnit; if (docWorkspace.AppWorkspace.Units != MeasurementUnit.Pixel) { docWorkspace.AppWorkspace.Units = newDpuUnit; } } if (((docWorkspace.Document.Size == new Size(dialog.ImageWidth, dialog.ImageHeight)) && (docWorkspace.Document.DpuX == newDpu)) && (docWorkspace.Document.DpuUnit == newDpuUnit)) { return(null); } } if ((newWidth == docWorkspace.Document.Width) && (newHeight == docWorkspace.Document.Height)) { MetadataHistoryMemento memento2 = new MetadataHistoryMemento(StaticName, PdnResources.GetImageResource(StaticImageName), docWorkspace); docWorkspace.Document.DpuUnit = newDpuUnit; docWorkspace.Document.DpuX = newDpu; docWorkspace.Document.DpuY = newDpu; return(memento2); } docWorkspace.FlushTool(); using (TaskProgressDialog progressDialog = new TaskProgressDialog()) {
public override void PerformAction(AppWorkspace appWorkspace) { DocumentWorkspace originalDW = appWorkspace.ActiveDocumentWorkspace; int oldLatency = 10; try { oldLatency = appWorkspace.Widgets.DocumentStrip.ThumbnailUpdateLatency; appWorkspace.Widgets.DocumentStrip.ThumbnailUpdateLatency = 0; } catch (NullReferenceException) { // See bug #2544 } List <DocumentWorkspace> unsavedDocs = new List <DocumentWorkspace>(); foreach (DocumentWorkspace dw in appWorkspace.DocumentWorkspaces) { if (dw.Document != null && dw.Document.Dirty) { unsavedDocs.Add(dw); } } if (unsavedDocs.Count == 1) { CloseWorkspaceAction cwa = new CloseWorkspaceAction(unsavedDocs[0]); cwa.PerformAction(appWorkspace); this.Cancelled = cwa.Cancelled; } else if (unsavedDocs.Count > 1) { using (UnsavedChangesDialog dialog = new UnsavedChangesDialog()) { dialog.DocumentClicked += (s, e2) => { appWorkspace.ActiveDocumentWorkspace = e2.Data; }; dialog.Documents = unsavedDocs.ToArray(); if (appWorkspace.ActiveDocumentWorkspace.Document.Dirty) { dialog.SelectedDocument = appWorkspace.ActiveDocumentWorkspace; } Form mainForm = appWorkspace.FindForm(); if (mainForm != null) { if (mainForm is PdnBaseForm asPDF) { asPDF.RestoreWindow(); } } DialogResult dr = Utility.ShowDialog(dialog, appWorkspace); switch (dr) { case DialogResult.Yes: { foreach (DocumentWorkspace dw in unsavedDocs) { appWorkspace.ActiveDocumentWorkspace = dw; bool result = dw.DoSave(); if (result) { appWorkspace.RemoveDocumentWorkspace(dw); } else { this.Cancelled = true; break; } } } break; case DialogResult.No: this.Cancelled = false; break; case DialogResult.Cancel: this.Cancelled = true; break; default: throw new InvalidEnumArgumentException(); } } } try { appWorkspace.Widgets.DocumentStrip.ThumbnailUpdateLatency = oldLatency; } catch (NullReferenceException) { // See bug #2544 } if (this.Cancelled) { if (appWorkspace.ActiveDocumentWorkspace != originalDW && !originalDW.IsDisposed) { appWorkspace.ActiveDocumentWorkspace = originalDW; } } else { UI.SuspendControlPainting(appWorkspace); foreach (DocumentWorkspace dw in appWorkspace.DocumentWorkspaces) { appWorkspace.RemoveDocumentWorkspace(dw); } UI.ResumeControlPainting(appWorkspace); appWorkspace.Invalidate(true); } }
protected void Update() { DocumentWorkspace.Update(); }
/// <summary> /// This method is called when the tool is active and a keyboard key is pressed /// and released that is not representable with a regular Unicode chararacter. /// An example would be the arrow keys. /// </summary> protected virtual void OnKeyPress(Keys key) { Point dir = Point.Empty; if (key != lastKey) { lastKeyboardMove = DateTime.MinValue; } lastKey = key; switch (key) { case Keys.Left: --dir.X; break; case Keys.Right: ++dir.X; break; case Keys.Up: --dir.Y; break; case Keys.Down: ++dir.Y; break; } if (!dir.Equals(Point.Empty)) { long span = DateTime.Now.Ticks - lastKeyboardMove.Ticks; if ((span * 4) > TimeSpan.TicksPerSecond) { keyboardMoveRepeats = 0; keyboardMoveSpeed = 1; } else { keyboardMoveRepeats++; if (keyboardMoveRepeats > 15 && (keyboardMoveRepeats % 4) == 0) { keyboardMoveSpeed++; } } lastKeyboardMove = DateTime.Now; int offset = (int)(Math.Ceiling(DocumentWorkspace.ScaleFactor.Ratio) * (double)keyboardMoveSpeed); Cursor.Position = new Point(Cursor.Position.X + offset * dir.X, Cursor.Position.Y + offset * dir.Y); Point location = DocumentWorkspace.PointToScreen(Point.Truncate(DocumentWorkspace.DocumentToClient(PointF.Empty))); PointF stylusLocF = new PointF((float)Cursor.Position.X - (float)location.X, (float)Cursor.Position.Y - (float)location.Y); Point stylusLoc = new Point(Cursor.Position.X - location.X, Cursor.Position.Y - location.Y); stylusLoc = DocumentWorkspace.ScaleFactor.UnscalePoint(stylusLoc); stylusLocF = DocumentWorkspace.ScaleFactor.UnscalePoint(stylusLocF); DocumentWorkspace.PerformDocumentMouseMove(new StylusEventArgs(lastButton, 1, stylusLocF.X, stylusLocF.Y, 0, 1.0f)); DocumentWorkspace.PerformDocumentMouseMove(new MouseEventArgs(lastButton, 1, stylusLoc.X, stylusLoc.Y, 0)); } }
protected object GetStaticData() { return(DocumentWorkspace.GetStaticToolData(this.GetType())); }
public ContextHistoryMemento(DocumentWorkspace documentWorkspace, Context context, string name, ImageResource image) : base(documentWorkspace, name, image) { this.Data = new OurHistoryMementoData(context); }
public PanTool(DocumentWorkspace documentWorkspace) : base(documentWorkspace, PdnResources.GetImageResource("Icons.PanToolIcon.png"), PdnResources.GetString("PanTool.Name"), PdnResources.GetString("PanTool.HelpText"), 'r', false, ToolBarConfigItems.All) { }
private HistoryMemento ImportOneLayer(DocumentWorkspace documentWorkspace, BitmapLayer layer) { HistoryMemento retHA; List <HistoryMemento> historyMementos = new List <HistoryMemento>(); bool success = true; if (success) { if (!documentWorkspace.Selection.IsEmpty) { HistoryMemento ha = new DeselectFunction().Execute(documentWorkspace); historyMementos.Add(ha); } } if (success) { if (layer.Width > documentWorkspace.Document.Width || layer.Height > documentWorkspace.Document.Height) { HistoryMemento ha = DoCanvasResize(documentWorkspace, layer.Size); if (ha == null) { success = false; } else { historyMementos.Add(ha); } } } if (success) { if (layer.Size != documentWorkspace.Document.Size) { BitmapLayer newLayer; try { using (new WaitCursorChanger(documentWorkspace)) { Utility.GCFullCollect(); newLayer = CanvasSizeAction.ResizeLayer((BitmapLayer)layer, documentWorkspace.Document.Size, AnchorEdge.TopLeft, ColorBgra.White.NewAlpha(0)); } } catch (OutOfMemoryException) { Utility.ErrorBox(documentWorkspace, PdnResources.GetString("ImportFromFileAction.ImportOneLayer.OutOfMemory")); success = false; newLayer = null; } if (newLayer != null) { layer.Dispose(); layer = newLayer; } } } if (success) { NewLayerHistoryMemento nlha = new NewLayerHistoryMemento(string.Empty, null, documentWorkspace, documentWorkspace.Document.Layers.Count); documentWorkspace.Document.Layers.Add(layer); historyMementos.Add(nlha); } if (success) { HistoryMemento[] has = historyMementos.ToArray(); retHA = new CompoundHistoryMemento(string.Empty, null, has); } else { Rollback(historyMementos); retHA = null; } return(retHA); }
/// <summary> /// Presents a user interface and performs the operations required for importing an entire document. /// </summary> /// <param name="document"></param> /// <returns></returns> /// <remarks> /// This function will take ownership of the Document given to it, and will Dispose() of it. /// </remarks> private HistoryMemento ImportDocument(DocumentWorkspace documentWorkspace, Document document, out Rectangle lastLayerBounds) { List <HistoryMemento> historyMementos = new List <HistoryMemento>(); bool[] selected; selected = new bool[document.Layers.Count]; for (int i = 0; i < selected.Length; ++i) { selected[i] = true; } lastLayerBounds = Rectangle.Empty; if (selected != null) { List <Layer> layers = new List <Layer>(); for (int i = 0; i < selected.Length; ++i) { if (selected[i]) { layers.Add((Layer)document.Layers[i]); } } foreach (Layer layer in layers) { document.Layers.Remove(layer); } document.Dispose(); document = null; foreach (Layer layer in layers) { lastLayerBounds = layer.Bounds; HistoryMemento ha = ImportOneLayer(documentWorkspace, (BitmapLayer)layer); if (ha != null) { historyMementos.Add(ha); } else { Rollback(historyMementos); historyMementos.Clear(); break; } } } if (document != null) { document.Dispose(); document = null; } if (historyMementos.Count > 0) { HistoryMemento[] has = historyMementos.ToArray(); return(new CompoundHistoryMemento(string.Empty, null, has)); } else { lastLayerBounds = Rectangle.Empty; return(null); } }
public PushNullToolMode(DocumentWorkspace documentWorkspace) { this.documentWorkspace = documentWorkspace; this.documentWorkspace.PushNullTool(); }
public RectangleSelectTool(DocumentWorkspace documentWorkspace) : base(documentWorkspace, PdnResources.GetImageResource("Icons.RectangleSelectToolIcon.png"), PdnResources.GetString("RectangleSelectTool.Name"), PdnResources.GetString("RectangleSelectTool.HelpText"), 's', ToolBarConfigItems.None | ToolBarConfigItems.SelectionDrawMode) { }
public MagicWandTool(DocumentWorkspace documentWorkspace) : base(documentWorkspace, PdnResources.GetImageResource("Icons.MagicWandToolIcon.png"), PdnResources.GetString("MagicWandTool.Name"), PdnResources.GetString("MagicWandTool.HelpText"), 's', false, ToolBarConfigItems.FloodMode | ToolBarConfigItems.SampleImageOrLayer | ToolBarConfigItems.SelectionCombineMode | ToolBarConfigItems.Tolerance) { this.onUIGestureRegion = new ProtectedRegion("OnUIGesture*", ProtectedRegionOptions.None); }
public CloseWorkspaceAction(DocumentWorkspace closeMe) { this.closeMe = closeMe; this.cancelled = false; }
public ToolHistoryMemento(DocumentWorkspace documentWorkspace, string name, ImageResource image) : base(name, image) { this.documentWorkspace = documentWorkspace; this.toolType = documentWorkspace.GetToolType(); }
public TransactedToolEditHistoryMemento(DocumentWorkspace docWorkspace, string name, ImageResource image, TChanges previousChanges) : base(docWorkspace, name, image) { this.previousChanges = previousChanges; }
private void Done() { if (Tracking) { // Truth table for what we should do based on three flags: // append | moved | tooQuick | result | optimized expression to yield true // ---------+-------+----------+----------------------------------------------------------------------- // F | T | T | clear selection | !append && (!moved || tooQuick) // F | T | F | emit new selected area | !append && moved && !tooQuick // F | F | T | clear selection | !append && (!moved || tooQuick) // F | F | F | clear selection | !append && (!moved || tooQuick) // T | T | T | append to selection | append && moved // T | T | F | append to selection | append && moved // T | F | T | reset selection | append && !moved // T | F | F | reset selection | append && !moved // // append --> If the user was holding control, then true. Else false. // moved --> If they never moved the mouse, false. Else true. // tooQuick --> If they held the mouse button down for more than 50ms, false. Else true. // // "Clear selection" means to result in no selected area. If the selection area was previously empty, // then no HistoryMemento is emitted. Otherwise a Deselect HistoryMemento is emitted. // // "Reset selection" means to reset the selected area to how it was before interaction with the tool, // without a HistoryMemento. PointF[] polygon = CreateSelectionPolygon(); HasMoved &= (polygon.Length > 1); // They were "too quick" if they weren't doing a selection for more than 50ms // This takes care of the case where someone wants to click to deselect, but accidentally moves // the mouse. This happens VERY frequently. bool tooQuick = Utility.TicksToMs((DateTime.Now - StartTime).Ticks) <= 50; // If their selection was completedly out of bounds, it will be clipped bool clipped = (polygon.Length == 0); // What the user drew had no effect on the selection, e.g. subtraction where there was nothing in the first place bool noEffect = false; WhatToDo whatToDo; // If their selection gets completely clipped (i.e. outside the image canvas), // then result in a no-op if (Append) { if (!HasMoved || clipped || noEffect) { whatToDo = WhatToDo.Reset; } else { whatToDo = WhatToDo.Emit; } } else { if (HasMoved && !tooQuick && !clipped && !noEffect) { whatToDo = WhatToDo.Emit; } else { whatToDo = WhatToDo.Clear; } } switch (whatToDo) { case WhatToDo.Clear: if (WasNotEmpty) { // emit a deselect history action UndoAction.Name = DeselectFunction.StaticName; UndoAction.Image = DeselectFunction.StaticImage; HistoryStack.PushNewMemento(UndoAction); } Selection.Reset(); break; case WhatToDo.Emit: // emit newly selected area UndoAction.Name = Name; HistoryStack.PushNewMemento(UndoAction); Selection.CommitContinuation(); break; case WhatToDo.Reset: // reset selection, no HistoryMemento Selection.ResetContinuation(); break; } DocumentWorkspace.ResetOutlineWhiteOpacity(); NewSelectionRenderer.ResetOutlineWhiteOpacity(); NewSelection.Reset(); NewSelectionRenderer.Visible = false; Tracking = false; DocumentWorkspace.EnableSelectionOutline = true; DocumentWorkspace.InvalidateSurface(Utility.RoundRectangle(DocumentWorkspace.VisibleDocumentRectangleF)); } }
public override HistoryMemento PerformAction(DocumentWorkspace documentWorkspace) { documentWorkspace.ZoomOut(); return(null); }
protected BrushToolBase(DocumentWorkspace documentWorkspace, ImageResource toolBarImage, string name, string helpText, char hotKey, bool skipIfActiveOnHotKey, ToolBarConfigItems toolBarConfigItems) : base(documentWorkspace, toolBarImage, name, helpText, hotKey, skipIfActiveOnHotKey, (((toolBarConfigItems | (ToolBarConfigItems.None | ToolBarConfigItems.PenWidth)) | (ToolBarConfigItems.None | ToolBarConfigItems.PenHardness)) | ToolBarConfigItems.Antialiasing) | (ToolBarConfigItems.None | ToolBarConfigItems.SelectionRenderingQuality), false) { this.txHandler = new BitmapLayerTransactionHandler <TDerived, TChanges>((TDerived)this); }
private void Workspace_CompositionUpdated(object sender, EventArgs e) { DocumentWorkspace dw = (DocumentWorkspace)sender; QueueThumbnailUpdate(dw); }
public TransactedToolHistoryMementoBase(DocumentWorkspace docWorkspace, string name, ImageResource image) : base(docWorkspace, name, image) { }
/// <summary> /// Implement this to provide an action. You must return a HistoryMemento so that you /// can be undone. However, you should return null if you didn't do anything that /// affected the document. /// </summary> /// <returns>A HistoryMemento object that will be placed onto the HistoryStack.</returns> public abstract HistoryMemento PerformAction(DocumentWorkspace documentWorkspace);
private bool ProcessMessage(string message) { if (IsDisposed) { return(false); } bool result = SplitMessage(message, out ArgumentAction action, out string actionParm); if (!result) { return(true); } switch (action) { case ArgumentAction.NoOp: result = true; break; case ArgumentAction.Open: Activate(); if (IsCurrentModalForm && Enabled) { result = this.appWorkspace.OpenFileInNewWorkspace(actionParm); } break; case ArgumentAction.OpenUntitled: Activate(); if (!string.IsNullOrEmpty(actionParm) && IsCurrentModalForm && Enabled) { result = this.appWorkspace.OpenFileInNewWorkspace(actionParm, false); if (result) { this.appWorkspace.ActiveDocumentWorkspace.SetDocumentSaveOptions(null, null, null); this.appWorkspace.ActiveDocumentWorkspace.Document.Dirty = true; } } break; case ArgumentAction.Print: Activate(); if (!string.IsNullOrEmpty(actionParm) && IsCurrentModalForm && Enabled) { result = this.appWorkspace.OpenFileInNewWorkspace(actionParm); if (result) { DocumentWorkspace dw = this.appWorkspace.ActiveDocumentWorkspace; PrintAction pa = new PrintAction(); dw.PerformAction(pa); CloseWorkspaceAction cwa = new CloseWorkspaceAction(dw); this.appWorkspace.PerformAction(cwa); if (this.appWorkspace.DocumentWorkspaces.Length == 0) { Startup.CloseApplication(); } } } break; default: throw new InvalidEnumArgumentException(); } return(result); }
public HistoryStack(DocumentWorkspace documentWorkspace) { this.documentWorkspace = documentWorkspace; this.undoStack = new SegmentedList <HistoryMemento>(); this.redoStack = new SegmentedList <HistoryMemento>(); }
private bool IsOverflow(MouseEventArgs e) { PointF clientPt = DocumentWorkspace.DocumentToClient(new PointF(e.X, e.Y)); return(clientPt.X < -16384 || clientPt.Y < -16384); }
protected void SetStaticData(object data) { DocumentWorkspace.SetStaticToolData(this.GetType(), data); }