/////////////////////////////////////////////////////////////////////////////////
// Paint.NET //
// Copyright (C) dotPDN LLC, Rick Brewster, Tom Jackson, and contributors. //
// Portions Copyright (C) Microsoft Corporation. All Rights Reserved. //
// See src/Resources/Files/License.txt for full licensing and attribution //
// details. //
// . //
/////////////////////////////////////////////////////////////////////////////////
using PaintDotNet.Actions;
using PaintDotNet.Effects;
using PaintDotNet.HistoryFunctions;
using PaintDotNet.HistoryMementos;
using PaintDotNet.SystemLayer;
using PaintDotNet.Tools;
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Security;
using System.Text;
using System.Windows.Forms;
namespace PaintDotNet{
internal class AppWorkspace
: UserControl,
ISnapObstacleHost
{
private readonly string cursorInfoStatusBarFormat = PdnResources.GetString("StatusBar.CursorInfo.Format");
private readonly string imageInfoStatusBarFormat = PdnResources.GetString("StatusBar.Size.Format");
private Type defaultToolTypeChoice;
private Type globalToolTypeChoice = null;
private bool globalRulersChoice = false;
private AppEnvironment appEnvironment;
private DocumentWorkspace activeDocumentWorkspace;
// if a new workspace is added, and this workspace is not dirty, then it will be removed.
// This keeps track of the last workspace added via CreateBlankDocumentInNewWorkspace (if
// true was passed for its 2nd parameter)
private DocumentWorkspace initialWorkspace;
private List<DocumentWorkspace> documentWorkspaces = new List<DocumentWorkspace>();
private WorkspaceWidgets widgets;
private Panel workspacePanel;
private PdnToolBar toolBar;
private PdnStatusBar statusBar;
private ToolsForm mainToolBarForm;
private LayerForm layerForm;
private HistoryForm historyForm;
private ColorsForm colorsForm;
private MostRecentFiles mostRecentFiles = null;
private const int defaultMostRecentFilesMax = 8;
private SnapObstacleController snapObstacle;
private bool addedToSnapManager = false;
private int ignoreUpdateSnapObstacle = 0;
private int suspendThumbnailUpdates = 0;
public void CheckForUpdates()
{
this.toolBar.MainMenu.CheckForUpdates();
}
public IDisposable SuspendThumbnailUpdates()
{
CallbackOnDispose resumeFn = new CallbackOnDispose(ResumeThumbnailUpdates);
++this.suspendThumbnailUpdates;
if (this.suspendThumbnailUpdates == 1)
{
Widgets.DocumentStrip.SuspendThumbnailUpdates();
Widgets.LayerControl.SuspendLayerPreviewUpdates();
}
return resumeFn;
}
private void ResumeThumbnailUpdates()
{
--this.suspendThumbnailUpdates;
if (this.suspendThumbnailUpdates == 0)
{
Widgets.DocumentStrip.ResumeThumbnailUpdates();
Widgets.LayerControl.ResumeLayerPreviewUpdates();
}
}
public Type DefaultToolType
{
get
{
return this.defaultToolTypeChoice;
}
set
{
this.defaultToolTypeChoice = value;
Settings.CurrentUser.SetString(SettingNames.DefaultToolTypeName, value.Name);
}
}
public Type GlobalToolTypeChoice
{
get
{
return this.globalToolTypeChoice;
}
set
{
this.globalToolTypeChoice = value;
if (ActiveDocumentWorkspace != null)
{
ActiveDocumentWorkspace.SetToolFromType(value);
}
}
}
public DocumentWorkspace InitialWorkspace
{
set
{
this.initialWorkspace = value;
}
}
public event EventHandler RulersEnabledChanged;
protected virtual void OnRulersEnabledChanged()
{
if (RulersEnabledChanged != null)
{
RulersEnabledChanged(this, EventArgs.Empty);
}
}
public bool RulersEnabled
{
get
{
return this.globalRulersChoice;
}
set
{
if (this.globalRulersChoice != value)
{
this.globalRulersChoice = value;
if (ActiveDocumentWorkspace != null)
{
ActiveDocumentWorkspace.RulersEnabled = value;
}
OnRulersEnabledChanged();
}
}
}
private void DocumentWorkspace_DrawGridChanged(object sender, EventArgs e)
{
DrawGrid = this.activeDocumentWorkspace.DrawGrid;
}
private void ViewConfigStrip_DrawGridChanged(object sender, EventArgs e)
{
DrawGrid = ((ViewConfigStrip)sender).DrawGrid;
}
private bool DrawGrid
{
get
{
return this.Widgets.ViewConfigStrip.DrawGrid;
}
set
{
if (this.Widgets.ViewConfigStrip.DrawGrid != value)
{
this.Widgets.ViewConfigStrip.DrawGrid = value;
}
if (this.activeDocumentWorkspace != null && this.activeDocumentWorkspace.DrawGrid != value)
{
this.activeDocumentWorkspace.DrawGrid = value;
}
Settings.CurrentUser.SetBoolean(SettingNames.DrawGrid, this.DrawGrid);
}
}
public event EventHandler UnitsChanged;
protected virtual void OnUnitsChanged()
{
if (UnitsChanged != null)
{
UnitsChanged(this, EventArgs.Empty);
}
}
public MeasurementUnit Units
{
get
{
return this.widgets.ViewConfigStrip.Units;
}
set
{
this.widgets.ViewConfigStrip.Units = value;
}
}
public SnapObstacle SnapObstacle
{
get
{
if (this.snapObstacle == null)
{
// HACK: for some reason retrieving the ClientRectangle can raise a VisibleChanged event
// so we initially pass in Rectangle.Empty for the rectangle bounds
this.snapObstacle = new SnapObstacleController(
this.Name,
Rectangle.Empty,
SnapRegion.Interior,
true);
this.snapObstacle.EnableSave = false;
PdnBaseForm pdbForm = FindForm() as PdnBaseForm;
pdbForm.Moving += new MovingEventHandler(ParentForm_Moving);
pdbForm.Move += new EventHandler(ParentForm_Move);
pdbForm.ResizeEnd += new EventHandler(ParentForm_ResizeEnd);
pdbForm.Layout += new LayoutEventHandler(ParentForm_Layout);
pdbForm.SizeChanged += new EventHandler(ParentForm_SizeChanged);
UpdateSnapObstacle();
}
return this.snapObstacle;
}
}
private void ParentForm_Move(object sender, EventArgs e)
{
UpdateSnapObstacle();
}
private void ParentForm_SizeChanged(object sender, EventArgs e)
{
UpdateSnapObstacle();
}
private void ParentForm_Layout(object sender, LayoutEventArgs e)
{
UpdateSnapObstacle();
}
private void ParentForm_ResizeEnd(object sender, EventArgs e)
{
UpdateSnapObstacle();
}
private void ParentForm_Moving(object sender, MovingEventArgs e)
{
UpdateSnapObstacle();
}
private void SuspendUpdateSnapObstacle()
{
++this.ignoreUpdateSnapObstacle;
}
private void ResumeUpdateSnapObstacle()
{
--this.ignoreUpdateSnapObstacle;
}
private void UpdateSnapObstacle()
{
if (this.ignoreUpdateSnapObstacle > 0)
{
return;
}
if (this.snapObstacle == null)
{
return;
}
if (!this.addedToSnapManager)
{
SnapManager sm = SnapManager.FindMySnapManager(this);
if (sm != null)
{
SnapObstacle so = this.SnapObstacle;
if (!this.addedToSnapManager)
{
sm.AddSnapObstacle(this.SnapObstacle);
this.addedToSnapManager = true;
FindForm().Shown += new EventHandler(AppWorkspace_Shown);
}
}
}
if (this.snapObstacle != null)
{
Rectangle clientRect;
if (ActiveDocumentWorkspace != null)
{
clientRect = ActiveDocumentWorkspace.VisibleViewRectangle;
}
else
{
clientRect = this.workspacePanel.ClientRectangle;
}
Rectangle screenRect = this.workspacePanel.RectangleToScreen(clientRect);
this.snapObstacle.SetBounds(screenRect);
this.snapObstacle.Enabled = this.Visible && this.Enabled;
}
}
private void AppWorkspace_Shown(object sender, EventArgs e)
{
UpdateSnapObstacle();
}
protected override void OnLayout(LayoutEventArgs levent)
{
UpdateSnapObstacle();
base.OnLayout(levent);
}
protected override void OnLocationChanged(EventArgs e)
{
UpdateSnapObstacle();
base.OnLocationChanged(e);
}
protected override void OnSizeChanged(EventArgs e)
{
UpdateSnapObstacle();
base.OnSizeChanged(e);
}
protected override void OnEnabledChanged(EventArgs e)
{
UpdateSnapObstacle();
base.OnEnabledChanged(e);
}
protected override void OnVisibleChanged(EventArgs e)
{
UpdateSnapObstacle();
base.OnVisibleChanged(e);
}
public void ResetFloatingForms()
{
ResetFloatingForm(Widgets.ToolsForm);
ResetFloatingForm(Widgets.HistoryForm);
ResetFloatingForm(Widgets.LayerForm);
ResetFloatingForm(Widgets.ColorsForm);
}
public void ResetFloatingForm(FloatingToolForm ftf)
{
SnapManager sm = SnapManager.FindMySnapManager(this);
if (ftf == Widgets.ToolsForm)
{
sm.ParkObstacle(Widgets.ToolsForm, this, HorizontalSnapEdge.Top, VerticalSnapEdge.Left);
}
else if (ftf == Widgets.HistoryForm)
{
sm.ParkObstacle(Widgets.HistoryForm, this, HorizontalSnapEdge.Top, VerticalSnapEdge.Right);
}
else if (ftf == Widgets.LayerForm)
{
sm.ParkObstacle(Widgets.LayerForm, this, HorizontalSnapEdge.Bottom, VerticalSnapEdge.Right);
}
else if (ftf == Widgets.ColorsForm)
{
sm.ParkObstacle(Widgets.ColorsForm, this, HorizontalSnapEdge.Bottom, VerticalSnapEdge.Left);
}
else
{
throw new ArgumentException();
}
}
private Set<Triple<Assembly, Type, Exception>> effectLoadErrors = new Set<Triple<Assembly, Type, Exception>>();
public void ReportEffectLoadError(Triple<Assembly, Type, Exception> error)
{
lock (this.effectLoadErrors)
{
if (!this.effectLoadErrors.Contains(error))
{
this.effectLoadErrors.Add(error);
}
}
}
public static string GetLocalizedEffectErrorMessage(Assembly assembly, Type type, Exception exception)
{
IPluginSupportInfo supportInfo;
string typeName;
if (type != null)
{
typeName = type.FullName;
supportInfo = PluginSupportInfo.GetPluginSupportInfo(type);
}
else if (exception is TypeLoadException)
{
TypeLoadException asTlex = exception as TypeLoadException;
typeName = asTlex.TypeName;
supportInfo = PluginSupportInfo.GetPluginSupportInfo(assembly);
}
else
{
supportInfo = PluginSupportInfo.GetPluginSupportInfo(assembly);
typeName = null;
}
return GetLocalizedEffectErrorMessage(assembly, typeName, supportInfo, exception);
}
public static string GetLocalizedEffectErrorMessage(Assembly assembly, string typeName, Exception exception)
{
IPluginSupportInfo supportInfo = PluginSupportInfo.GetPluginSupportInfo(assembly);
return GetLocalizedEffectErrorMessage(assembly, typeName, supportInfo, exception);
}
private static string GetLocalizedEffectErrorMessage(Assembly assembly, string typeName, IPluginSupportInfo supportInfo, Exception exception)
{
string fileName = assembly.Location;
string shortErrorFormat = PdnResources.GetString("EffectErrorMessage.ShortFormat");
string fullErrorFormat = PdnResources.GetString("EffectErrorMessage.FullFormat");
string notSuppliedText = PdnResources.GetString("EffectErrorMessage.InfoNotSupplied");
string errorText;
if (supportInfo == null)
{
errorText = string.Format(
shortErrorFormat,
fileName ?? notSuppliedText,
typeName ?? notSuppliedText,
exception.ToString());
}
else
{
errorText = string.Format(
fullErrorFormat,
fileName ?? notSuppliedText,
typeName ?? supportInfo.DisplayName ?? notSuppliedText,
(supportInfo.Version ?? new Version()).ToString(),
supportInfo.Author ?? notSuppliedText,
supportInfo.Copyright ?? notSuppliedText,
(supportInfo.WebsiteUri == null ? notSuppliedText : supportInfo.WebsiteUri.ToString()),
exception.ToString());
}
return errorText;
}
public IList<Triple<Assembly, Type, Exception>> GetEffectLoadErrors()
{
return this.effectLoadErrors.ToArray();
}
public void RunEffect(Type effectType)
{
// TODO: this is kind of a hack
this.toolBar.MainMenu.RunEffect(effectType);
}
public PdnToolBar ToolBar
{
get
{
return this.toolBar;
}
}
private ImageResource FileNewIcon
{
get
{
return PdnResources.GetImageResource("Icons.MenuFileNewIcon.png");
}
}
private ImageResource ImageFromDiskIcon
{
get
{
return PdnResources.GetImageResource("Icons.ImageFromDiskIcon.png");
}
}
public MostRecentFiles MostRecentFiles
{
get
{
if (this.mostRecentFiles == null)
{
this.mostRecentFiles = new MostRecentFiles(defaultMostRecentFilesMax);
}
return this.mostRecentFiles;
}
}
private void DocumentWorkspace_DocumentChanging(object sender, EventArgs<Document> e)
{
UI.SuspendControlPainting(this);
}
private void DocumentWorkspace_DocumentChanged(object sender, EventArgs e)
{
UpdateDocInfoInStatusBar();
UI.ResumeControlPainting(this);
Invalidate(true);
}
private void CoordinatesToStrings(int x, int y, out string xString, out string yString, out string unitsString)
{
this.activeDocumentWorkspace.Document.CoordinatesToStrings(this.Units, x, y, out xString, out yString, out unitsString);
}
private void UpdateCursorInfoInStatusBar(int cursorX, int cursorY)
{
SuspendLayout();
if (this.activeDocumentWorkspace == null ||
this.activeDocumentWorkspace.Document == null)
{
this.statusBar.CursorInfoText = string.Empty;
}
else
{
string xString;
string yString;
string units;
CoordinatesToStrings(cursorX, cursorY, out xString, out yString, out units);
string cursorText = string.Format(
CultureInfo.InvariantCulture,
this.cursorInfoStatusBarFormat,
xString,
units,
yString,
units);
this.statusBar.CursorInfoText = cursorText;
}
ResumeLayout(false);
}
private void UpdateDocInfoInStatusBar()
{
if (this.activeDocumentWorkspace == null ||
this.activeDocumentWorkspace.Document == null)
{
this.statusBar.ImageInfoStatusText = string.Empty;
}
else if (this.activeDocumentWorkspace != null &&
this.activeDocumentWorkspace.Document != null)
{
string widthString;
string heightString;
string units;
CoordinatesToStrings(
this.activeDocumentWorkspace.Document.Width,
this.activeDocumentWorkspace.Document.Height,
out widthString,
out heightString,
out units);
string imageText = string.Format(
CultureInfo.InvariantCulture,
this.imageInfoStatusBarFormat,
widthString,
units,
heightString,
units);
this.statusBar.ImageInfoStatusText = imageText;
}
}
[Browsable(false)]
public WorkspaceWidgets Widgets
{
get
{
return this.widgets;
}
}
[Browsable(false)]
public AppEnvironment AppEnvironment
{
get
{
return this.appEnvironment;
}
}
[Browsable(false)]
public DocumentWorkspace ActiveDocumentWorkspace
{
get
{
return this.activeDocumentWorkspace;
}
set
{
if (value != this.activeDocumentWorkspace)
{
if (value != null &&
this.documentWorkspaces.IndexOf(value) == -1)
{
throw new ArgumentException("DocumentWorkspace was not created with AddNewDocumentWorkspace");
}
bool focused = false;
if (this.activeDocumentWorkspace != null)
{
focused = this.activeDocumentWorkspace.Focused;
}
UI.SuspendControlPainting(this);
OnActiveDocumentWorkspaceChanging();
this.activeDocumentWorkspace = value;
OnActiveDocumentWorkspaceChanged();
UI.ResumeControlPainting(this);
Refresh();
if (value != null)
{
value.Focus();
}
}
}
}
private void ActiveDocumentWorkspace_FirstInputAfterGotFocus(object sender, EventArgs e)
{
this.toolBar.DocumentStrip.EnsureItemFullyVisible(this.toolBar.DocumentStrip.SelectedDocumentIndex);
}
public DocumentWorkspace[] DocumentWorkspaces
{
get
{
return this.documentWorkspaces.ToArray();
}
}
public DocumentWorkspace AddNewDocumentWorkspace()
{
if (this.initialWorkspace != null)
{
if (this.initialWorkspace.Document == null || !this.initialWorkspace.Document.Dirty)
{
this.globalToolTypeChoice = this.initialWorkspace.GetToolType();
RemoveDocumentWorkspace(this.initialWorkspace);
this.initialWorkspace = null;
}
}
DocumentWorkspace dw = new DocumentWorkspace();
dw.AppWorkspace = this;
this.documentWorkspaces.Add(dw);
this.toolBar.DocumentStrip.AddDocumentWorkspace(dw);
return dw;
}
public Image GetDocumentWorkspaceThumbnail(DocumentWorkspace dw)
{
this.toolBar.DocumentStrip.SyncThumbnails();
Image[] images = this.toolBar.DocumentStrip.DocumentThumbnails;
DocumentWorkspace[] documents = this.toolBar.DocumentStrip.DocumentList;
for (int i = 0; i < documents.Length; ++i)
{
if (documents[i] == dw)
{
return images[i];
}
}
throw new ArgumentException("The requested DocumentWorkspace doesn't exist in this AppWorkspace");
}
public void RemoveDocumentWorkspace(DocumentWorkspace documentWorkspace)
{
int dwIndex = this.documentWorkspaces.IndexOf(documentWorkspace);
if (dwIndex == -1)
{
throw new ArgumentException("DocumentWorkspace was not created with AddNewDocumentWorkspace");
}
bool removingCurrentDW;
if (this.ActiveDocumentWorkspace == documentWorkspace)
{
removingCurrentDW = true;
this.globalToolTypeChoice = documentWorkspace.GetToolType();
}
else
{
removingCurrentDW = false;
}
documentWorkspace.SetTool(null);
// Choose new active DW if removing the current DW
if (removingCurrentDW)
{
if (this.documentWorkspaces.Count == 1)
{
this.ActiveDocumentWorkspace = null;
}
else if (dwIndex == 0)
{
this.ActiveDocumentWorkspace = this.documentWorkspaces[1];
}
else
{
this.ActiveDocumentWorkspace = this.documentWorkspaces[dwIndex - 1];
}
}
this.documentWorkspaces.Remove(documentWorkspace);
this.toolBar.DocumentStrip.RemoveDocumentWorkspace(documentWorkspace);
if (this.initialWorkspace == documentWorkspace)
{
this.initialWorkspace = null;
}
// Clean up the DocumentWorkspace
Document document = documentWorkspace.Document;
documentWorkspace.Document = null;
document.Dispose();
documentWorkspace.Dispose();
documentWorkspace = null;
}
private void UpdateHistoryButtons()
{
if (ActiveDocumentWorkspace == null)
{
widgets.CommonActionsStrip.SetButtonEnabled(CommonAction.Undo, false);
widgets.CommonActionsStrip.SetButtonEnabled(CommonAction.Redo, false);
}
else
{
if (ActiveDocumentWorkspace.History.UndoStack.Count > 1)
{
widgets.CommonActionsStrip.SetButtonEnabled(CommonAction.Undo, true);
}
else
{
widgets.CommonActionsStrip.SetButtonEnabled(CommonAction.Undo, false);
}
if (ActiveDocumentWorkspace.History.RedoStack.Count > 0)
{
widgets.CommonActionsStrip.SetButtonEnabled(CommonAction.Redo, true);
}
else
{
widgets.CommonActionsStrip.SetButtonEnabled(CommonAction.Redo, false);
}
}
}
private void HistoryChangedHandler(object sender, EventArgs e)
{
UpdateHistoryButtons();
// some actions change the document size: make sure we update our status bar panel
// TODO: shouldn't this be handled by our DocumentWorkspace.DocumentChanged handler...?
UpdateDocInfoInStatusBar();
}
public event EventHandler ActiveDocumentWorkspaceChanging;
protected virtual void OnActiveDocumentWorkspaceChanging()
{
SuspendUpdateSnapObstacle();
if (ActiveDocumentWorkspaceChanging != null)
{
ActiveDocumentWorkspaceChanging(this, EventArgs.Empty);
}
if (this.activeDocumentWorkspace != null)
{
this.activeDocumentWorkspace.FirstInputAfterGotFocus +=
ActiveDocumentWorkspace_FirstInputAfterGotFocus;
this.activeDocumentWorkspace.RulersEnabledChanged -= this.DocumentWorkspace_RulersEnabledChanged;
this.activeDocumentWorkspace.DocumentMouseEnter -= this.DocumentMouseEnterHandler;
this.activeDocumentWorkspace.DocumentMouseLeave -= this.DocumentMouseLeaveHandler;
this.activeDocumentWorkspace.DocumentMouseMove -= this.DocumentMouseMoveHandler;
this.activeDocumentWorkspace.DocumentMouseDown -= this.DocumentMouseDownHandler;
this.activeDocumentWorkspace.Scroll -= this.DocumentWorkspace_Scroll;
this.activeDocumentWorkspace.Layout -= this.DocumentWorkspace_Layout;
this.activeDocumentWorkspace.DrawGridChanged -= this.DocumentWorkspace_DrawGridChanged;
this.activeDocumentWorkspace.DocumentClick -= this.DocumentClick;
this.activeDocumentWorkspace.DocumentMouseUp -= this.DocumentMouseUpHandler;
this.activeDocumentWorkspace.DocumentKeyPress -= this.DocumentKeyPress;
this.activeDocumentWorkspace.DocumentKeyUp -= this.DocumenKeyUp;
this.activeDocumentWorkspace.DocumentKeyDown -= this.DocumentKeyDown;
this.activeDocumentWorkspace.History.Changed -= HistoryChangedHandler;
this.activeDocumentWorkspace.StatusChanged -= OnDocumentWorkspaceStatusChanged;
this.activeDocumentWorkspace.DocumentChanging -= DocumentWorkspace_DocumentChanging;
this.activeDocumentWorkspace.DocumentChanged -= DocumentWorkspace_DocumentChanged;
this.activeDocumentWorkspace.Selection.Changing -= SelectedPathChangingHandler;
this.activeDocumentWorkspace.Selection.Changed -= SelectedPathChangedHandler;
this.activeDocumentWorkspace.ScaleFactorChanged -= ZoomChangedHandler;
this.activeDocumentWorkspace.ZoomBasisChanged -= DocumentWorkspace_ZoomBasisChanged;
this.activeDocumentWorkspace.Visible = false;
this.historyForm.HistoryControl.HistoryStack = null;
this.activeDocumentWorkspace.ToolChanging -= this.ToolChangingHandler;
this.activeDocumentWorkspace.ToolChanged -= this.ToolChangedHandler;
if (this.activeDocumentWorkspace.Tool != null)
{
while (this.activeDocumentWorkspace.Tool.IsMouseEntered)
{
this.activeDocumentWorkspace.Tool.PerformMouseLeave();
}
}
Type toolType = this.activeDocumentWorkspace.GetToolType();
if (toolType != null)
{
this.globalToolTypeChoice = this.activeDocumentWorkspace.GetToolType();
}
}
ResumeUpdateSnapObstacle();
UpdateSnapObstacle();
}
public event EventHandler ActiveDocumentWorkspaceChanged;
protected virtual void OnActiveDocumentWorkspaceChanged()
{
SuspendUpdateSnapObstacle();
if (this.activeDocumentWorkspace == null)
{
this.toolBar.CommonActionsStrip.SetButtonEnabled(CommonAction.Print, false);
this.toolBar.CommonActionsStrip.SetButtonEnabled(CommonAction.Save, false);
}
else
{
this.activeDocumentWorkspace.SuspendLayout();
this.toolBar.CommonActionsStrip.SetButtonEnabled(CommonAction.Print, true);
this.toolBar.CommonActionsStrip.SetButtonEnabled(CommonAction.Save, true);
this.activeDocumentWorkspace.BackColor = System.Drawing.SystemColors.ControlDark;
this.activeDocumentWorkspace.Dock = System.Windows.Forms.DockStyle.Fill;
this.activeDocumentWorkspace.DrawGrid = this.DrawGrid;
this.activeDocumentWorkspace.PanelAutoScroll = true;
this.activeDocumentWorkspace.RulersEnabled = this.globalRulersChoice;
this.activeDocumentWorkspace.TabIndex = 0;
this.activeDocumentWorkspace.TabStop = false;
this.activeDocumentWorkspace.RulersEnabledChanged += this.DocumentWorkspace_RulersEnabledChanged;
this.activeDocumentWorkspace.DocumentMouseEnter += this.DocumentMouseEnterHandler;
this.activeDocumentWorkspace.DocumentMouseLeave += this.DocumentMouseLeaveHandler;
this.activeDocumentWorkspace.DocumentMouseMove += this.DocumentMouseMoveHandler;
this.activeDocumentWorkspace.DocumentMouseDown += this.DocumentMouseDownHandler;
this.activeDocumentWorkspace.Scroll += this.DocumentWorkspace_Scroll;
this.activeDocumentWorkspace.DrawGridChanged += this.DocumentWorkspace_DrawGridChanged;
this.activeDocumentWorkspace.DocumentClick += this.DocumentClick;
this.activeDocumentWorkspace.DocumentMouseUp += this.DocumentMouseUpHandler;
this.activeDocumentWorkspace.DocumentKeyPress += this.DocumentKeyPress;
this.activeDocumentWorkspace.DocumentKeyUp += this.DocumenKeyUp;
this.activeDocumentWorkspace.DocumentKeyDown += this.DocumentKeyDown;
if (this.workspacePanel.Controls.Contains(this.activeDocumentWorkspace))
{
this.activeDocumentWorkspace.Visible = true;
}
else
{
this.activeDocumentWorkspace.Dock = DockStyle.Fill;
this.workspacePanel.Controls.Add(this.activeDocumentWorkspace);
}
this.activeDocumentWorkspace.Layout += this.DocumentWorkspace_Layout;
this.toolBar.ViewConfigStrip.ScaleFactor = this.activeDocumentWorkspace.ScaleFactor;
this.toolBar.ViewConfigStrip.ZoomBasis = this.activeDocumentWorkspace.ZoomBasis;
this.activeDocumentWorkspace.AppWorkspace = this;
this.activeDocumentWorkspace.History.Changed += HistoryChangedHandler;
this.activeDocumentWorkspace.StatusChanged += OnDocumentWorkspaceStatusChanged;
this.activeDocumentWorkspace.DocumentChanging += DocumentWorkspace_DocumentChanging;
this.activeDocumentWorkspace.DocumentChanged += DocumentWorkspace_DocumentChanged;
this.activeDocumentWorkspace.Selection.Changing += SelectedPathChangingHandler;
this.activeDocumentWorkspace.Selection.Changed += SelectedPathChangedHandler;
this.activeDocumentWorkspace.ScaleFactorChanged += ZoomChangedHandler;
this.activeDocumentWorkspace.ZoomBasisChanged += DocumentWorkspace_ZoomBasisChanged;
this.activeDocumentWorkspace.Units = this.widgets.ViewConfigStrip.Units;
this.historyForm.HistoryControl.HistoryStack = this.ActiveDocumentWorkspace.History;
this.activeDocumentWorkspace.ToolChanging += this.ToolChangingHandler;
this.activeDocumentWorkspace.ToolChanged += this.ToolChangedHandler;
this.toolBar.ViewConfigStrip.RulersEnabled = this.activeDocumentWorkspace.RulersEnabled;
this.toolBar.DocumentStrip.SelectDocumentWorkspace(this.activeDocumentWorkspace);
this.activeDocumentWorkspace.SetToolFromType(this.globalToolTypeChoice);
UpdateSelectionToolbarButtons();
UpdateHistoryButtons();
UpdateDocInfoInStatusBar();
this.activeDocumentWorkspace.ResumeLayout();
this.activeDocumentWorkspace.PerformLayout();
this.activeDocumentWorkspace.FirstInputAfterGotFocus +=
ActiveDocumentWorkspace_FirstInputAfterGotFocus;
}
if (ActiveDocumentWorkspaceChanged != null)
{
ActiveDocumentWorkspaceChanged(this, EventArgs.Empty);
}
UpdateStatusBarContextStatus();
ResumeUpdateSnapObstacle();
UpdateSnapObstacle();
}
public AppWorkspace()
{
SuspendLayout();
// initialize!
InitializeComponent();
InitializeFloatingForms();
this.mainToolBarForm.ToolsControl.SetTools(DocumentWorkspace.ToolInfos);
this.mainToolBarForm.ToolsControl.ToolClicked += new ToolClickedEventHandler(this.MainToolBar_ToolClicked);
this.toolBar.ToolChooserStrip.SetTools(DocumentWorkspace.ToolInfos);
this.toolBar.ToolChooserStrip.ToolClicked += new ToolClickedEventHandler(this.MainToolBar_ToolClicked);
this.toolBar.AppWorkspace = this;
// init the Widgets container
this.widgets = new WorkspaceWidgets(this);
this.widgets.ViewConfigStrip = this.toolBar.ViewConfigStrip;
this.widgets.CommonActionsStrip = this.toolBar.CommonActionsStrip;
this.widgets.ToolConfigStrip = this.toolBar.ToolConfigStrip;
this.widgets.ToolsForm = this.mainToolBarForm;
this.widgets.LayerForm = this.layerForm;
this.widgets.HistoryForm = this.historyForm;
this.widgets.ColorsForm = this.colorsForm;
this.widgets.StatusBarProgress = this.statusBar;
this.widgets.DocumentStrip = this.toolBar.DocumentStrip;
// Load our settings and initialize the AppEnvironment
LoadSettings();
// hook into Environment *Changed events
AppEnvironment.PrimaryColorChanged += PrimaryColorChangedHandler;
AppEnvironment.SecondaryColorChanged += SecondaryColorChangedHandler;
AppEnvironment.ShapeDrawTypeChanged += ShapeDrawTypeChangedHandler;
AppEnvironment.GradientInfoChanged += GradientInfoChangedHandler;
AppEnvironment.ToleranceChanged += OnEnvironmentToleranceChanged;
AppEnvironment.AlphaBlendingChanged += AlphaBlendingChangedHandler;
AppEnvironment.FontInfo = this.toolBar.ToolConfigStrip.FontInfo;
AppEnvironment.TextAlignment = this.toolBar.ToolConfigStrip.FontAlignment;
AppEnvironment.AntiAliasingChanged += Environment_AntiAliasingChanged;
AppEnvironment.FontInfoChanged += Environment_FontInfoChanged;
AppEnvironment.FontSmoothingChanged += Environment_FontSmoothingChanged;
AppEnvironment.TextAlignmentChanged += Environment_TextAlignmentChanged;
AppEnvironment.PenInfoChanged += Environment_PenInfoChanged;
AppEnvironment.BrushInfoChanged += Environment_BrushInfoChanged;
AppEnvironment.ColorPickerClickBehaviorChanged += Environment_ColorPickerClickBehaviorChanged;
AppEnvironment.ResamplingAlgorithmChanged += Environment_ResamplingAlgorithmChanged;
AppEnvironment.SelectionCombineModeChanged += Environment_SelectionCombineModeChanged;
AppEnvironment.FloodModeChanged += Environment_FloodModeChanged;
AppEnvironment.SelectionDrawModeInfoChanged += Environment_SelectionDrawModeInfoChanged;
this.toolBar.DocumentStrip.RelinquishFocus += RelinquishFocusHandler;
this.toolBar.ToolConfigStrip.ToleranceChanged += OnToolBarToleranceChanged;
this.toolBar.ToolConfigStrip.FontAlignmentChanged += ToolConfigStrip_TextAlignmentChanged;
this.toolBar.ToolConfigStrip.FontInfoChanged += ToolConfigStrip_FontTextChanged;
this.toolBar.ToolConfigStrip.FontSmoothingChanged += ToolConfigStrip_FontSmoothingChanged;
this.toolBar.ToolConfigStrip.RelinquishFocus += RelinquishFocusHandler2;
this.toolBar.CommonActionsStrip.RelinquishFocus += OnToolStripRelinquishFocus;
this.toolBar.CommonActionsStrip.MouseWheel += OnToolStripMouseWheel;
this.toolBar.CommonActionsStrip.ButtonClick += CommonActionsStrip_ButtonClick;
this.toolBar.ViewConfigStrip.DrawGridChanged += ViewConfigStrip_DrawGridChanged;
this.toolBar.ViewConfigStrip.RulersEnabledChanged += ViewConfigStrip_RulersEnabledChanged;
this.toolBar.ViewConfigStrip.ZoomBasisChanged += ViewConfigStrip_ZoomBasisChanged;
this.toolBar.ViewConfigStrip.ZoomScaleChanged += ViewConfigStrip_ZoomScaleChanged;
this.toolBar.ViewConfigStrip.ZoomIn += ViewConfigStrip_ZoomIn;
this.toolBar.ViewConfigStrip.ZoomOut += ViewConfigStrip_ZoomOut;
this.toolBar.ViewConfigStrip.UnitsChanged += ViewConfigStrip_UnitsChanged;
this.toolBar.ViewConfigStrip.RelinquishFocus += OnToolStripRelinquishFocus;
this.toolBar.ViewConfigStrip.MouseWheel += OnToolStripMouseWheel;
this.toolBar.ToolConfigStrip.BrushInfoChanged += DrawConfigStrip_BrushChanged;
this.toolBar.ToolConfigStrip.ShapeDrawTypeChanged += DrawConfigStrip_ShapeDrawTypeChanged;
this.toolBar.ToolConfigStrip.PenInfoChanged += DrawConfigStrip_PenChanged;
this.toolBar.ToolConfigStrip.GradientInfoChanged += ToolConfigStrip_GradientInfoChanged;
this.toolBar.ToolConfigStrip.AlphaBlendingChanged += OnDrawConfigStripAlphaBlendingChanged;
this.toolBar.ToolConfigStrip.AntiAliasingChanged += DrawConfigStrip_AntiAliasingChanged;
this.toolBar.ToolConfigStrip.RelinquishFocus += OnToolStripRelinquishFocus;
this.toolBar.ToolConfigStrip.ColorPickerClickBehaviorChanged += ToolConfigStrip_ColorPickerClickBehaviorChanged;
this.toolBar.ToolConfigStrip.ResamplingAlgorithmChanged += ToolConfigStrip_ResamplingAlgorithmChanged;
this.toolBar.ToolConfigStrip.SelectionCombineModeChanged += ToolConfigStrip_SelectionCombineModeChanged;
this.toolBar.ToolConfigStrip.FloodModeChanged += ToolConfigStrip_FloodModeChanged;
this.toolBar.ToolConfigStrip.SelectionDrawModeInfoChanged += ToolConfigStrip_SelectionDrawModeInfoChanged;
this.toolBar.ToolConfigStrip.SelectionDrawModeUnitsChanging += ToolConfigStrip_SelectionDrawModeUnitsChanging;
this.toolBar.ToolConfigStrip.MouseWheel += OnToolStripMouseWheel;
this.toolBar.DocumentStrip.RelinquishFocus += OnToolStripRelinquishFocus;
this.toolBar.DocumentStrip.DocumentClicked += DocumentStrip_DocumentTabClicked;
this.toolBar.DocumentStrip.DocumentListChanged += DocumentStrip_DocumentListChanged;
// Synchronize
AppEnvironment.PerformAllChanged();
this.globalToolTypeChoice = this.defaultToolTypeChoice;
this.toolBar.ToolConfigStrip.ToolBarConfigItems = ToolBarConfigItems.None;
this.layerForm.LayerControl.AppWorkspace = this;
ResumeLayout();
PerformLayout();
}
private void ToolConfigStrip_ColorPickerClickBehaviorChanged(object sender, EventArgs e)
{
this.appEnvironment.ColorPickerClickBehavior = this.widgets.ToolConfigStrip.ColorPickerClickBehavior;
}
private void Environment_ColorPickerClickBehaviorChanged(object sender, EventArgs e)
{
this.widgets.ToolConfigStrip.ColorPickerClickBehavior = this.appEnvironment.ColorPickerClickBehavior;
}
private void ToolConfigStrip_ResamplingAlgorithmChanged(object sender, EventArgs e)
{
this.appEnvironment.ResamplingAlgorithm = this.widgets.ToolConfigStrip.ResamplingAlgorithm;
}
private void Environment_ResamplingAlgorithmChanged(object sender, EventArgs e)
{
this.widgets.ToolConfigStrip.ResamplingAlgorithm = this.appEnvironment.ResamplingAlgorithm;
}
private void ToolConfigStrip_SelectionCombineModeChanged(object sender, EventArgs e)
{
this.appEnvironment.SelectionCombineMode = this.widgets.ToolConfigStrip.SelectionCombineMode;
}
private void Environment_SelectionCombineModeChanged(object sender, EventArgs e)
{
this.widgets.ToolConfigStrip.SelectionCombineMode = this.appEnvironment.SelectionCombineMode;
}
private void ToolConfigStrip_FloodModeChanged(object sender, EventArgs e)
{
this.appEnvironment.FloodMode = this.widgets.ToolConfigStrip.FloodMode;
}
private void Environment_FloodModeChanged(object sender, EventArgs e)
{
this.widgets.ToolConfigStrip.FloodMode = this.appEnvironment.FloodMode;
}
private void ToolConfigStrip_SelectionDrawModeInfoChanged(object sender, EventArgs e)
{
this.appEnvironment.SelectionDrawModeInfo = this.widgets.ToolConfigStrip.SelectionDrawModeInfo;
}
private void Environment_SelectionDrawModeInfoChanged(object sender, EventArgs e)
{
this.widgets.ToolConfigStrip.SelectionDrawModeInfo = this.appEnvironment.SelectionDrawModeInfo;
}
private sealed class ToolConfigStrip_SelectionDrawModeUnitsChangeHandler
{
private ToolConfigStrip toolConfigStrip;
private Document activeDocument;
private MeasurementUnit oldUnits;
public ToolConfigStrip_SelectionDrawModeUnitsChangeHandler(ToolConfigStrip toolConfigStrip, Document activeDocument)
{
this.toolConfigStrip = toolConfigStrip;
this.activeDocument = activeDocument;
this.oldUnits = toolConfigStrip.SelectionDrawModeInfo.Units;
}
public void Initialize()
{
this.toolConfigStrip.SelectionDrawModeUnitsChanged += ToolConfigStrip_SelectionDrawModeUnitsChanged;
}
public void ToolConfigStrip_SelectionDrawModeUnitsChanged(object sender, EventArgs e)
{
try
{
SelectionDrawModeInfo sdmi = this.toolConfigStrip.SelectionDrawModeInfo;
MeasurementUnit newUnits = sdmi.Units;
double oldWidth = sdmi.Width;
double oldHeight = sdmi.Height;
double newWidth;
double newHeight;
newWidth = Document.ConvertMeasurement(oldWidth, this.oldUnits, this.activeDocument.DpuUnit, this.activeDocument.DpuX, newUnits);
newHeight = Document.ConvertMeasurement(oldHeight, this.oldUnits, this.activeDocument.DpuUnit, this.activeDocument.DpuY, newUnits);
SelectionDrawModeInfo newSdmi = sdmi.CloneWithNewWidthAndHeight(newWidth, newHeight);
this.toolConfigStrip.SelectionDrawModeInfo = newSdmi;
}
finally
{
this.toolConfigStrip.SelectionDrawModeUnitsChanged -= ToolConfigStrip_SelectionDrawModeUnitsChanged;
}
}
}
private void ToolConfigStrip_SelectionDrawModeUnitsChanging(object sender, EventArgs e)
{
if (this.ActiveDocumentWorkspace != null && this.ActiveDocumentWorkspace.Document != null)
{
ToolConfigStrip_SelectionDrawModeUnitsChangeHandler tcsSdmuch = new ToolConfigStrip_SelectionDrawModeUnitsChangeHandler(
this.toolBar.ToolConfigStrip, this.ActiveDocumentWorkspace.Document);
tcsSdmuch.Initialize();
}
}
private void DocumentStrip_DocumentListChanged(object sender, EventArgs e)
{
bool enableThem = (this.widgets.DocumentStrip.DocumentCount != 0);
this.widgets.ToolsForm.Enabled = enableThem;
this.widgets.HistoryForm.Enabled = enableThem;
this.widgets.LayerForm.Enabled = enableThem;
this.widgets.ColorsForm.Enabled = enableThem;
this.widgets.CommonActionsStrip.SetButtonEnabled(CommonAction.Paste, enableThem);
UpdateHistoryButtons();
UpdateDocInfoInStatusBar();
UpdateCursorInfoInStatusBar(0, 0);
}
public void SaveSettings()
{
Settings.CurrentUser.SetBoolean(SettingNames.Rulers, this.globalRulersChoice);
Settings.CurrentUser.SetBoolean(SettingNames.DrawGrid, this.DrawGrid);
Settings.CurrentUser.SetString(SettingNames.DefaultToolTypeName, this.defaultToolTypeChoice.Name);
this.MostRecentFiles.SaveMruList();
}
private void LoadDefaultToolType()
{
string defaultToolTypeName = Settings.CurrentUser.GetString(SettingNames.DefaultToolTypeName, Tool.DefaultToolType.Name);
ToolInfo[] tis = DocumentWorkspace.ToolInfos;
ToolInfo ti = Array.Find(
tis,
delegate(ToolInfo check)
{
if (string.Compare(defaultToolTypeName, check.ToolType.Name, StringComparison.InvariantCultureIgnoreCase) == 0)
{
return true;
}
else
{
return false;
}
});
if (ti == null)
{
this.defaultToolTypeChoice = Tool.DefaultToolType;
}
else
{
this.defaultToolTypeChoice = ti.ToolType;
}
}
public void LoadSettings()
{
try
{
LoadDefaultToolType();
this.globalToolTypeChoice = this.defaultToolTypeChoice;
this.globalRulersChoice = Settings.CurrentUser.GetBoolean(SettingNames.Rulers, false);
this.DrawGrid = Settings.CurrentUser.GetBoolean(SettingNames.DrawGrid, false);
this.appEnvironment = AppEnvironment.GetDefaultAppEnvironment();
this.widgets.ViewConfigStrip.Units = (MeasurementUnit)Enum.Parse(typeof(MeasurementUnit),
Settings.CurrentUser.GetString(SettingNames.Units, MeasurementUnit.Pixel.ToString()), true);
}
catch (Exception)
{
this.appEnvironment = new AppEnvironment();
this.appEnvironment.SetToDefaults();
try
{
Settings.CurrentUser.Delete(
new string[]
{
SettingNames.Rulers,
SettingNames.DrawGrid,
SettingNames.Units,
SettingNames.DefaultAppEnvironment,
SettingNames.DefaultToolTypeName,
});
}
catch (Exception)
{
}
}
try
{
this.toolBar.ToolConfigStrip.LoadFromAppEnvironment(this.appEnvironment);
}
catch (Exception)
{
this.appEnvironment = new AppEnvironment();
this.appEnvironment.SetToDefaults();
this.toolBar.ToolConfigStrip.LoadFromAppEnvironment(this.appEnvironment);
}
}
protected override void OnLoad(EventArgs e)
{
if (this.ActiveDocumentWorkspace != null)
{
this.ActiveDocumentWorkspace.Select();
}
UpdateSnapObstacle();
base.OnLoad(e);
}
public void RefreshTool()
{
Type toolType = activeDocumentWorkspace.GetToolType();
Widgets.ToolsControl.SelectTool(toolType);
}
private void GradientInfoChangedHandler(object sender, EventArgs e)
{
if (widgets.ToolConfigStrip.GradientInfo != AppEnvironment.GradientInfo)
{
widgets.ToolConfigStrip.GradientInfo = AppEnvironment.GradientInfo;
}
}
private void ToolConfigStrip_GradientInfoChanged(object sender, EventArgs e)
{
if (AppEnvironment.GradientInfo != widgets.ToolConfigStrip.GradientInfo)
{
AppEnvironment.GradientInfo = widgets.ToolConfigStrip.GradientInfo;
}
}
/// <summary>
/// Keeps the Environment's ShapeDrawType and the corresponding widget synchronized
/// </summary>
private void ShapeDrawTypeChangedHandler(object sender, EventArgs e)
{
if (widgets.ToolConfigStrip.ShapeDrawType != AppEnvironment.ShapeDrawType)
{
widgets.ToolConfigStrip.ShapeDrawType = AppEnvironment.ShapeDrawType;
}
}
/// <summary>
/// Keeps the Environment's alpha blending value and the corresponding widget synchronized
/// </summary>
private void AlphaBlendingChangedHandler(object sender, EventArgs e)
{
if (widgets.ToolConfigStrip.AlphaBlending != AppEnvironment.AlphaBlending)
{
widgets.ToolConfigStrip.AlphaBlending = AppEnvironment.AlphaBlending;
}
}
private void ColorDisplay_UserPrimaryAndSecondaryColorsChanged(object sender, EventArgs e)
{
// We need to make sure that we don't change which user color is selected (primary vs. secondary)
// To do this we choose the ordering based on which one is currently active (primary vs. secondary)
if (widgets.ColorsForm.WhichUserColor == WhichUserColor.Primary)
{
widgets.ColorsForm.SetColorControlsRedraw(false);
SecondaryColorChangedHandler(sender, e);
PrimaryColorChangedHandler(sender, e);
widgets.ColorsForm.SetColorControlsRedraw(true);
widgets.ColorsForm.WhichUserColor = WhichUserColor.Primary;
}
else //if (widgets.ColorsForm.WhichUserColor == WhichUserColor.Background)
{
widgets.ColorsForm.SetColorControlsRedraw(false);
PrimaryColorChangedHandler(sender, e);
SecondaryColorChangedHandler(sender, e);
widgets.ColorsForm.SetColorControlsRedraw(true);
widgets.ColorsForm.WhichUserColor = WhichUserColor.Secondary;
}
}
private void PrimaryColorChangedHandler(object sender, EventArgs e)
{
if (sender == appEnvironment)
{
widgets.ColorsForm.UserPrimaryColor = AppEnvironment.PrimaryColor;
}
}
private void OnToolBarToleranceChanged(object sender, EventArgs e)
{
AppEnvironment.Tolerance = widgets.ToolConfigStrip.Tolerance;
this.Focus();
}
private void OnEnvironmentToleranceChanged(object sender, EventArgs e)
{
widgets.ToolConfigStrip.Tolerance = AppEnvironment.Tolerance;
this.Focus();
}
private void SecondaryColorChangedHandler(object sender, EventArgs e)
{
if (sender == appEnvironment)
{
widgets.ColorsForm.UserSecondaryColor = AppEnvironment.SecondaryColor;
}
}
private void RelinquishFocusHandler(object sender, EventArgs e)
{
this.Focus();
}
private void RelinquishFocusHandler2(object sender, EventArgs e)
{
if (this.activeDocumentWorkspace != null)
{
this.activeDocumentWorkspace.Focus();
}
}
private void ColorsForm_UserPrimaryColorChanged(object sender, ColorEventArgs e)
{
ColorsForm cf = (ColorsForm)sender;
AppEnvironment.PrimaryColor = e.Color;
}
private void ColorsForm_UserSecondaryColorChanged(object sender, ColorEventArgs e)
{
ColorsForm cf = (ColorsForm)sender;
AppEnvironment.SecondaryColor = e.Color;
}
/// <summary>
/// Handles the SelectedPathChanging event that is raised by the AppEnvironment.
/// </summary>
private void SelectedPathChangingHandler(object sender, EventArgs e)
{
}
private void UpdateSelectionToolbarButtons()
{
if (ActiveDocumentWorkspace == null || ActiveDocumentWorkspace.Selection.IsEmpty)
{
widgets.CommonActionsStrip.SetButtonEnabled(CommonAction.Cut, false);
widgets.CommonActionsStrip.SetButtonEnabled(CommonAction.Copy, false);
widgets.CommonActionsStrip.SetButtonEnabled(CommonAction.Deselect, false);
widgets.CommonActionsStrip.SetButtonEnabled(CommonAction.CropToSelection, false);
}
else
{
widgets.CommonActionsStrip.SetButtonEnabled(CommonAction.Cut, true);
widgets.CommonActionsStrip.SetButtonEnabled(CommonAction.Copy, true);
widgets.CommonActionsStrip.SetButtonEnabled(CommonAction.Deselect, true);
widgets.CommonActionsStrip.SetButtonEnabled(CommonAction.CropToSelection, true);
}
}
/// <summary>
/// Handles the SelectedPathChanged event that is raised by the AppEnvironment.
/// </summary>
private void SelectedPathChangedHandler(object sender, EventArgs e)
{
UpdateSelectionToolbarButtons();
}
private void ZoomChangedHandler(object sender, EventArgs e)
{
ScaleFactor sf = this.activeDocumentWorkspace.ScaleFactor;
this.toolBar.ViewConfigStrip.SuspendEvents();
this.toolBar.ViewConfigStrip.ZoomBasis = this.activeDocumentWorkspace.ZoomBasis;
this.toolBar.ViewConfigStrip.ScaleFactor = sf;
this.toolBar.ViewConfigStrip.ResumeEvents();
}
private void InitializeComponent()
{
this.toolBar = new PdnToolBar();
this.statusBar = new PdnStatusBar();
this.workspacePanel = new Panel();
this.workspacePanel.SuspendLayout();
this.statusBar.SuspendLayout();
this.SuspendLayout();
//
// toolBar
//
this.toolBar.Name = "toolBar";
this.toolBar.Dock = DockStyle.Top;
//
// statusBar
//
this.statusBar.Name = "statusBar";
//
// workspacePanel
//
this.workspacePanel.Name = "workspacePanel";
this.workspacePanel.Dock = DockStyle.Fill;
//
// AppWorkspace
//
this.Controls.Add(this.workspacePanel);
this.Controls.Add(this.statusBar);
this.Controls.Add(this.toolBar);
this.Name = "AppWorkspace";
this.Size = new System.Drawing.Size(872, 640);
this.workspacePanel.ResumeLayout(false);
this.statusBar.ResumeLayout(false);
this.statusBar.PerformLayout();
this.ResumeLayout(false);
}
private void DocumentStrip_DocumentTabClicked(
object sender,
EventArgs<Pair<DocumentWorkspace, DocumentClickAction>> e)
{
switch (e.Data.Second)
{
case DocumentClickAction.Select:
this.ActiveDocumentWorkspace = e.Data.First;
break;
case DocumentClickAction.Close:
CloseWorkspaceAction cwa = new CloseWorkspaceAction(e.Data.First);
PerformAction(cwa);
break;
default:
throw new NotImplementedException("Code for DocumentClickAction." + e.Data.Second.ToString() + " not implemented");
}
Update();
}
private void OnToolStripMouseWheel(object sender, MouseEventArgs e)
{
if (this.activeDocumentWorkspace != null)
{
this.activeDocumentWorkspace.PerformMouseWheel((Control)sender, e);
}
}
private void OnToolStripRelinquishFocus(object sender, EventArgs e)
{
if (this.activeDocumentWorkspace != null)
{
this.activeDocumentWorkspace.Focus();
}
}
// The Document* events are raised by the Document class, handled here,
// and relayed as necessary. For instance, for the DocumentMouse* events,
// these are all relayed to the active tool.
private void DocumentMouseEnterHandler(object sender, EventArgs e)
{
if (ActiveDocumentWorkspace.Tool != null)
{
ActiveDocumentWorkspace.Tool.PerformMouseEnter();
}
}
private void DocumentMouseLeaveHandler(object sender, EventArgs e)
{
if (ActiveDocumentWorkspace.Tool != null)
{
ActiveDocumentWorkspace.Tool.PerformMouseLeave();
}
}
private void DocumentMouseUpHandler(object sender, MouseEventArgs e)
{
if (ActiveDocumentWorkspace.Tool != null)
{
ActiveDocumentWorkspace.Tool.PerformMouseUp(e);
}
}
private void DocumentMouseDownHandler(object sender, MouseEventArgs e)
{
if (ActiveDocumentWorkspace.Tool != null)
{
ActiveDocumentWorkspace.Tool.PerformMouseDown(e);
}
}
private void DocumentMouseMoveHandler(object sender, MouseEventArgs e)
{
if (ActiveDocumentWorkspace.Tool != null)
{
ActiveDocumentWorkspace.Tool.PerformMouseMove(e);
}
UpdateCursorInfoInStatusBar(e.X, e.Y);
}
private void DocumentClick(object sender, EventArgs e)
{
if (ActiveDocumentWorkspace.Tool != null)
{
ActiveDocumentWorkspace.Tool.PerformClick();
}
}
private void DocumentKeyPress(object sender, KeyPressEventArgs e)
{
if (ActiveDocumentWorkspace.Tool != null)
{
ActiveDocumentWorkspace.Tool.PerformKeyPress(e);
}
}
private void DocumentKeyDown(object sender, KeyEventArgs e)
{
if (ActiveDocumentWorkspace.Tool != null)
{
ActiveDocumentWorkspace.Tool.PerformKeyDown(e);
}
}
private void DocumenKeyUp(object sender, KeyEventArgs e)
{
if (ActiveDocumentWorkspace.Tool != null)
{
ActiveDocumentWorkspace.Tool.PerformKeyUp(e);
}
}
private void InitializeFloatingForms()
{
// MainToolBarForm
mainToolBarForm = new ToolsForm();
mainToolBarForm.RelinquishFocus += RelinquishFocusHandler;
mainToolBarForm.ProcessCmdKeyEvent += OnToolFormProcessCmdKeyEvent;
// LayerForm
layerForm = new LayerForm();
layerForm.LayerControl.AppWorkspace = this;
layerForm.LayerControl.ClickedOnLayer += LayerControl_ClickedOnLayer;
layerForm.NewLayerButtonClick += LayerForm_NewLayerButtonClicked;
layerForm.DeleteLayerButtonClick += LayerForm_DeleteLayerButtonClicked;
layerForm.DuplicateLayerButtonClick += LayerForm_DuplicateLayerButtonClick;
layerForm.MergeLayerDownClick += new EventHandler(LayerForm_MergeLayerDownClick);
layerForm.MoveLayerUpButtonClick += LayerForm_MoveLayerUpButtonClicked;
layerForm.MoveLayerDownButtonClick += LayerForm_MoveLayerDownButtonClicked;
layerForm.PropertiesButtonClick += LayerForm_PropertiesButtonClick;
layerForm.RelinquishFocus += RelinquishFocusHandler;
layerForm.ProcessCmdKeyEvent += OnToolFormProcessCmdKeyEvent;
// HistoryForm
historyForm = new HistoryForm();
historyForm.RewindButtonClicked += HistoryForm_RewindButtonClicked;
historyForm.UndoButtonClicked += HistoryForm_UndoButtonClicked;
historyForm.RedoButtonClicked += HistoryForm_RedoButtonClicked;
historyForm.FastForwardButtonClicked += HistoryForm_FastForwardButtonClicked;
historyForm.RelinquishFocus += RelinquishFocusHandler;
historyForm.ProcessCmdKeyEvent += OnToolFormProcessCmdKeyEvent;
// ColorsForm
colorsForm = new ColorsForm();
colorsForm.PaletteCollection = new PaletteCollection();
colorsForm.WhichUserColor = WhichUserColor.Primary;
colorsForm.UserPrimaryColorChanged += ColorsForm_UserPrimaryColorChanged;
colorsForm.UserSecondaryColorChanged += ColorsForm_UserSecondaryColorChanged;
colorsForm.RelinquishFocus += RelinquishFocusHandler;
colorsForm.ProcessCmdKeyEvent += OnToolFormProcessCmdKeyEvent;
}
// TODO: put at correct scope
public event CmdKeysEventHandler ProcessCmdKeyEvent;
private bool OnToolFormProcessCmdKeyEvent(object sender, ref Message msg, Keys keyData)
{
if (ProcessCmdKeyEvent != null)
{
return ProcessCmdKeyEvent(sender, ref msg, keyData);
}
else
{
return false;
}
}
public void PerformActionAsync(AppWorkspaceAction performMe)
{
this.BeginInvoke(new Procedure<AppWorkspaceAction>(PerformAction), new object[] { performMe });
}
public void PerformAction(AppWorkspaceAction performMe)
{
Update();
using (new WaitCursorChanger(this))
{
performMe.PerformAction(this);
}
Update();
}
private void MainToolBar_ToolClicked(object sender, ToolClickedEventArgs e)
{
if (ActiveDocumentWorkspace != null)
{
ActiveDocumentWorkspace.Focus();
ActiveDocumentWorkspace.SetToolFromType(e.ToolType);
}
}
private void ToolChangingHandler(object sender, EventArgs e)
{
UI.SuspendControlPainting(this.toolBar);
if (ActiveDocumentWorkspace.Tool != null)
{
// unregister for events here (none at this time)
}
}
private void ToolChangedHandler(object sender, EventArgs e)
{
if (ActiveDocumentWorkspace.Tool != null)
{
this.widgets.ToolsControl.SelectTool(ActiveDocumentWorkspace.GetToolType(), false);
this.toolBar.ToolChooserStrip.SelectTool(ActiveDocumentWorkspace.GetToolType(), false);
this.toolBar.ToolConfigStrip.Visible = true; // HACK: see bug #2702
this.toolBar.ToolConfigStrip.ToolBarConfigItems = ActiveDocumentWorkspace.Tool.ToolBarConfigItems;
this.globalToolTypeChoice = ActiveDocumentWorkspace.GetToolType();
}
UpdateStatusBarContextStatus();
UI.ResumeControlPainting(this.toolBar);
this.toolBar.Refresh();
}
private void DrawConfigStrip_AntiAliasingChanged(object sender, System.EventArgs e)
{
AppEnvironment.AntiAliasing = ((ToolConfigStrip)sender).AntiAliasing;
}
private void DrawConfigStrip_PenChanged(object sender, System.EventArgs e)
{
AppEnvironment.PenInfo = this.toolBar.ToolConfigStrip.PenInfo;
}
private void DrawConfigStrip_BrushChanged(object sender, System.EventArgs e)
{
AppEnvironment.BrushInfo = this.toolBar.ToolConfigStrip.BrushInfo;
}
private void LayerControl_ClickedOnLayer(object sender, EventArgs<Layer> ce)
{
if (ActiveDocumentWorkspace != null)
{
if (ce.Data != ActiveDocumentWorkspace.ActiveLayer)
{
ActiveDocumentWorkspace.ActiveLayer = ce.Data;
}
}
this.RelinquishFocusHandler(sender, EventArgs.Empty);
}
private void LayerForm_NewLayerButtonClicked(object sender, System.EventArgs e)
{
if (ActiveDocumentWorkspace != null)
{
ActiveDocumentWorkspace.ExecuteFunction(new AddNewBlankLayerFunction());
}
}
private void LayerForm_DeleteLayerButtonClicked(object sender, System.EventArgs e)
{
if (ActiveDocumentWorkspace != null && ActiveDocumentWorkspace.Document.Layers.Count > 1)
{
ActiveDocumentWorkspace.ExecuteFunction(new DeleteLayerFunction(ActiveDocumentWorkspace.ActiveLayerIndex));
}
}
private void LayerForm_MergeLayerDownClick(object sender, EventArgs e)
{
if (ActiveDocumentWorkspace != null)
{
if (ActiveDocumentWorkspace != null &&
ActiveDocumentWorkspace.ActiveLayerIndex > 0)
{
// TODO: keep this in sync with LayersMenu. not appropriate to refactor into an Action for a 'dot' release
int newLayerIndex = Utility.Clamp(
ActiveDocumentWorkspace.ActiveLayerIndex - 1,
0,
ActiveDocumentWorkspace.Document.Layers.Count - 1);
ActiveDocumentWorkspace.ExecuteFunction(
new MergeLayerDownFunction(ActiveDocumentWorkspace.ActiveLayerIndex));
ActiveDocumentWorkspace.ActiveLayerIndex = newLayerIndex;
}
}
}
private void LayerForm_DuplicateLayerButtonClick(object sender, System.EventArgs e)
{
if (ActiveDocumentWorkspace != null)
{
ActiveDocumentWorkspace.ExecuteFunction(new DuplicateLayerFunction(ActiveDocumentWorkspace.ActiveLayerIndex));
}
}
private void LayerForm_MoveLayerUpButtonClicked(object sender, System.EventArgs e)
{
if (ActiveDocumentWorkspace != null && ActiveDocumentWorkspace.Document.Layers.Count >= 2)
{
ActiveDocumentWorkspace.PerformAction(new MoveActiveLayerUpAction());
}
}
private void LayerForm_MoveLayerDownButtonClicked(object sender, System.EventArgs e)
{
if (ActiveDocumentWorkspace != null && ActiveDocumentWorkspace.Document.Layers.Count >= 2)
{
ActiveDocumentWorkspace.PerformAction(new MoveActiveLayerDownAction());
}
}
private void DrawConfigStrip_ShapeDrawTypeChanged(object sender, System.EventArgs e)
{
if (AppEnvironment.ShapeDrawType != widgets.ToolConfigStrip.ShapeDrawType)
{
AppEnvironment.ShapeDrawType = widgets.ToolConfigStrip.ShapeDrawType;
}
}
private void HistoryForm_UndoButtonClicked(object sender, System.EventArgs e)
{
if (ActiveDocumentWorkspace != null)
{
ActiveDocumentWorkspace.PerformAction(new HistoryUndoAction());
}
}
private void HistoryForm_RedoButtonClicked(object sender, System.EventArgs e)
{
if (ActiveDocumentWorkspace != null)
{
ActiveDocumentWorkspace.PerformAction(new HistoryRedoAction());
}
}
private void ViewConfigStrip_RulersEnabledChanged(object sender, System.EventArgs e)
{
if (ActiveDocumentWorkspace != null)
{
ActiveDocumentWorkspace.RulersEnabled = this.toolBar.ViewConfigStrip.RulersEnabled;
}
}
private void HistoryForm_RewindButtonClicked(object sender, EventArgs e)
{
if (ActiveDocumentWorkspace != null)
{
ActiveDocumentWorkspace.PerformAction(new HistoryRewindAction());
}
}
private void HistoryForm_FastForwardButtonClicked(object sender, EventArgs e)
{
if (ActiveDocumentWorkspace != null)
{
ActiveDocumentWorkspace.PerformAction(new HistoryFastForwardAction());
}
}
private void LayerForm_PropertiesButtonClick(object sender, EventArgs e)
{
if (ActiveDocumentWorkspace != null)
{
ActiveDocumentWorkspace.PerformAction(new OpenActiveLayerPropertiesAction());
}
}
private void Environment_FontInfoChanged(object sender, EventArgs e)
{
this.widgets.ToolConfigStrip.FontInfo = AppEnvironment.FontInfo;
}
private void Environment_FontSmoothingChanged(object sender, EventArgs e)
{
this.widgets.ToolConfigStrip.FontSmoothing = AppEnvironment.FontSmoothing;
}
private void Environment_TextAlignmentChanged(object sender, EventArgs e)
{
this.widgets.ToolConfigStrip.FontAlignment = AppEnvironment.TextAlignment;
}
private void Environment_PenInfoChanged(object sender, EventArgs e)
{
this.widgets.ToolConfigStrip.PenInfo = AppEnvironment.PenInfo;
}
private void Environment_BrushInfoChanged(object sender, EventArgs e)
{
}
private void ToolConfigStrip_TextAlignmentChanged(object sender, EventArgs e)
{
AppEnvironment.TextAlignment = widgets.ToolConfigStrip.FontAlignment;
}
private void ToolConfigStrip_FontTextChanged(object sender, EventArgs e)
{
AppEnvironment.FontInfo = widgets.ToolConfigStrip.FontInfo;
}
private void ToolConfigStrip_FontSmoothingChanged(object sender, EventArgs e)
{
AppEnvironment.FontSmoothing = widgets.ToolConfigStrip.FontSmoothing;
}
protected override void OnResize(EventArgs e)
{
UpdateSnapObstacle();
base.OnResize(e);
if (ParentForm != null && this.ActiveDocumentWorkspace != null)
{
if (ParentForm.WindowState == FormWindowState.Minimized)
{
this.ActiveDocumentWorkspace.EnableToolPulse = false;
}
else
{
this.ActiveDocumentWorkspace.EnableToolPulse = true;
}
}
}
private void DocumentWorkspace_Scroll(object sender, System.Windows.Forms.ScrollEventArgs e)
{
OnScroll(e);
}
private void DocumentWorkspace_Layout(object sender, LayoutEventArgs e)
{
UpdateSnapObstacle();
}
private void ViewConfigStrip_ZoomBasisChanged(object sender, EventArgs e)
{
if (ActiveDocumentWorkspace != null)
{
if (ActiveDocumentWorkspace.ZoomBasis != this.toolBar.ViewConfigStrip.ZoomBasis)
{
ActiveDocumentWorkspace.ZoomBasis = this.toolBar.ViewConfigStrip.ZoomBasis;
}
}
}
private void DocumentWorkspace_ZoomBasisChanged(object sender, EventArgs e)
{
if (this.toolBar.ViewConfigStrip.ZoomBasis != this.ActiveDocumentWorkspace.ZoomBasis)
{
this.toolBar.ViewConfigStrip.ZoomBasis = this.ActiveDocumentWorkspace.ZoomBasis;
}
}
private void ViewConfigStrip_ZoomScaleChanged(object sender, EventArgs e)
{
if (ActiveDocumentWorkspace != null)
{
if (this.toolBar.ViewConfigStrip.ZoomBasis == ZoomBasis.ScaleFactor)
{
this.activeDocumentWorkspace.ScaleFactor = this.toolBar.ViewConfigStrip.ScaleFactor;
}
}
}
private void DocumentWorkspace_RulersEnabledChanged(object sender, EventArgs e)
{
this.toolBar.ViewConfigStrip.RulersEnabled = this.activeDocumentWorkspace.RulersEnabled;
this.globalRulersChoice = this.activeDocumentWorkspace.RulersEnabled;
PerformLayout();
ActiveDocumentWorkspace.UpdateRulerSelectionTinting();
Settings.CurrentUser.SetBoolean(SettingNames.Rulers, this.activeDocumentWorkspace.RulersEnabled);
}
private void Environment_AntiAliasingChanged(object sender, EventArgs e)
{
this.toolBar.ToolConfigStrip.AntiAliasing = AppEnvironment.AntiAliasing;
}
private void ViewConfigStrip_ZoomIn(object sender, EventArgs e)
{
if (this.ActiveDocumentWorkspace != null)
{
this.ActiveDocumentWorkspace.ZoomIn();
}
}
private void ViewConfigStrip_ZoomOut(object sender, EventArgs e)
{
if (this.ActiveDocumentWorkspace != null)
{
this.ActiveDocumentWorkspace.ZoomOut();
}
}
private void ViewConfigStrip_UnitsChanged(object sender, EventArgs e)
{
if (this.toolBar.ViewConfigStrip.Units != MeasurementUnit.Pixel)
{
Settings.CurrentUser.SetString(SettingNames.LastNonPixelUnits, this.toolBar.ViewConfigStrip.Units.ToString());
}
if (this.activeDocumentWorkspace != null)
{
this.activeDocumentWorkspace.Units = this.Units;
}
Settings.CurrentUser.SetString(SettingNames.Units, this.toolBar.ViewConfigStrip.Units.ToString());
UpdateDocInfoInStatusBar();
this.statusBar.CursorInfoText = string.Empty;
OnUnitsChanged();
}
private void OnDrawConfigStripAlphaBlendingChanged(object sender, EventArgs e)
{
if (AppEnvironment.AlphaBlending != widgets.ToolConfigStrip.AlphaBlending)
{
AppEnvironment.AlphaBlending = widgets.ToolConfigStrip.AlphaBlending;
}
}
public event EventHandler StatusChanged;
private void OnStatusChanged()
{
if (StatusChanged != null)
{
StatusChanged(this, EventArgs.Empty);
}
}
private void OnDocumentWorkspaceStatusChanged(object sender, EventArgs e)
{
OnStatusChanged();
UpdateStatusBarContextStatus();
}
private void UpdateStatusBarContextStatus()
{
if (ActiveDocumentWorkspace != null)
{
this.statusBar.ContextStatusText = this.activeDocumentWorkspace.StatusText;
this.statusBar.ContextStatusImage = this.activeDocumentWorkspace.StatusIcon;
}
else
{
this.statusBar.ContextStatusText = string.Empty;
this.statusBar.ContextStatusImage = null;
}
}
private static bool NullGetThumbnailImageAbort()
{
return false;
}
/// <summary>
/// Creates a blank document of the given size in a new workspace, and activates that workspace.
/// </summary>
/// <remarks>
/// If isInitial=true, then last workspace added by this method is kept track of, and if it is not modified by
/// the time the next workspace is added, then it will be removed.
/// </remarks>
/// <returns>true if everything was successful, false if there wasn't enough memory</returns>
public bool CreateBlankDocumentInNewWorkspace(Size size, MeasurementUnit dpuUnit, double dpu, bool isInitial)
{
DocumentWorkspace dw1 = this.activeDocumentWorkspace;
if (dw1 != null)
{
dw1.SuspendRefresh();
}
try
{
Document untitled = new Document(size.Width, size.Height);
untitled.DpuUnit = dpuUnit;
untitled.DpuX = dpu;
untitled.DpuY = dpu;
BitmapLayer bitmapLayer;
try
{
using (new WaitCursorChanger(this))
{
bitmapLayer = Layer.CreateBackgroundLayer(size.Width, size.Height);
}
}
catch (OutOfMemoryException)
{
Utility.ErrorBox(this, PdnResources.GetString("NewImageAction.Error.OutOfMemory"));
return false;
}
using (new WaitCursorChanger(this))
{
bool focused = false;
if (this.ActiveDocumentWorkspace != null && this.ActiveDocumentWorkspace.Focused)
{
focused = true;
}
untitled.Layers.Add(bitmapLayer);
DocumentWorkspace dw = this.AddNewDocumentWorkspace();
this.Widgets.DocumentStrip.LockDocumentWorkspaceDirtyValue(dw, false);
dw.SuspendRefresh();
try
{
dw.Document = untitled;
}
catch (OutOfMemoryException)
{
Utility.ErrorBox(this, PdnResources.GetString("NewImageAction.Error.OutOfMemory"));
RemoveDocumentWorkspace(dw);
untitled.Dispose();
return false;
}
dw.ActiveLayer = (Layer)dw.Document.Layers[0];
this.ActiveDocumentWorkspace = dw;
dw.SetDocumentSaveOptions(null, null, null);
dw.History.ClearAll();
dw.History.PushNewMemento(
new NullHistoryMemento(PdnResources.GetString("NewImageAction.Name"),
this.FileNewIcon));
dw.Document.Dirty = false;
dw.ResumeRefresh();
if (isInitial)
{
this.initialWorkspace = dw;
}
if (focused)
{
this.ActiveDocumentWorkspace.Focus();
}
this.Widgets.DocumentStrip.UnlockDocumentWorkspaceDirtyValue(dw);
}
}
finally
{
if (dw1 != null)
{
dw1.ResumeRefresh();
}
}
return true;
}
public bool OpenFilesInNewWorkspace(string[] fileNames)
{
if (IsDisposed)
{
return false;
}
bool result = true;
foreach (string fileName in fileNames)
{
result &= OpenFileInNewWorkspace(fileName);
if (!result)
{
break;
}
}
return result;
}
public bool OpenFileInNewWorkspace(string fileName)
{
return OpenFileInNewWorkspace(fileName, true);
}
public bool OpenFileInNewWorkspace(string fileName, bool addToMruList)
{
if (fileName == null)
{
throw new ArgumentNullException("fileName");
}
if (fileName.Length == 0)
{
throw new ArgumentOutOfRangeException("fileName.Length == 0");
}
PdnBaseForm.UpdateAllForms();
FileType fileType;
Document document;
this.widgets.StatusBarProgress.ResetProgressStatusBar();
ProgressEventHandler progressCallback =
delegate(object sender, ProgressEventArgs e)
{
this.widgets.StatusBarProgress.SetProgressStatusBar(e.Percent);
};
document = DocumentWorkspace.LoadDocument(this, fileName, out fileType, progressCallback);
this.widgets.StatusBarProgress.EraseProgressStatusBar();
if (document == null)
{
this.Cursor = Cursors.Default;
}
else
{
using (new WaitCursorChanger(this))
{
DocumentWorkspace dw = AddNewDocumentWorkspace();
Widgets.DocumentStrip.LockDocumentWorkspaceDirtyValue(dw, false);
try
{
dw.Document = document;
}
catch (OutOfMemoryException)
{
Utility.ErrorBox(this, PdnResources.GetString("LoadImage.Error.OutOfMemoryException"));
RemoveDocumentWorkspace(dw);
document.Dispose();
return false;
}
dw.ActiveLayer = (Layer)document.Layers[0];
dw.SetDocumentSaveOptions(fileName, fileType, null);
this.ActiveDocumentWorkspace = dw;
dw.History.ClearAll();
dw.History.PushNewMemento(
new NullHistoryMemento(
PdnResources.GetString("OpenImageAction.Name"),
this.ImageFromDiskIcon));
document.Dirty = false;
Widgets.DocumentStrip.UnlockDocumentWorkspaceDirtyValue(dw);
}
if (document != null)
{
ActiveDocumentWorkspace.ZoomBasis = ZoomBasis.FitToWindow;
}
// add to MRU list
if (addToMruList)
{
ActiveDocumentWorkspace.AddToMruList();
}
this.toolBar.DocumentStrip.SyncThumbnails();
WarnAboutSavedWithVersion(document.SavedWithVersion);
}
if (ActiveDocumentWorkspace != null)
{
ActiveDocumentWorkspace.Focus();
}
return document != null;
}
private void WarnAboutSavedWithVersion(Version savedWith)
{
// warn about version?
// 2.1 Build 1897 signifies when the file format changed and broke backwards compatibility (for saving)
// 2.1 Build 1921 signifies when MemoryBlock was upgraded to support 64-bits, which broke it again
// 2.1 Build 1924 upgraded to "unimportant ordering" for MemoryBlock serialization so we can to faster multiproc saves
// (in v2.5 we always save in order, although that doesn't change the file format's laxness)
// 2.5 Build 2105 changed the way PropertyItems are serialized
// 2.6 Build upgrade to .NET 2.0, does not appear to be compatible with 2.5 and earlier files as a result
if (savedWith < new Version(2, 6, 0))
{
Version ourVersion = PdnInfo.GetVersion();
Version ourVersion2 = new Version(ourVersion.Major, ourVersion.Minor);
Version ourVersion3 = new Version(ourVersion.Major, ourVersion.Minor, ourVersion.Build);
int fields;
if (savedWith < ourVersion2)
{
fields = 2;
}
else
{
fields = 3;
}
string format = PdnResources.GetString("SavedWithOlderVersion.Format");
string text = string.Format(format, savedWith.ToString(fields), ourVersion.ToString(fields));
// TODO: should we even bother to inform them? It is probably more annoying than not,
// especially since older versions will say "Hey this file is corrupt OR saved with a newer version"
//Utility.InfoBox(this, text);
}
}
/// <summary>
/// Computes what the size of a new document should be. If the screen is in a normal,
/// wider-than-tall (landscape) mode then it returns 800x600. If the screen is in a
/// taller-than-wide (portrait) mode then it retusn 600x800. If the screen is square
/// then it returns 800x600.
/// </summary>
public Size GetNewDocumentSize()
{
PdnBaseForm findForm = this.FindForm() as PdnBaseForm;
if (findForm != null && findForm.ScreenAspect < 1.0)
{
return new Size(600, 800);
}
else
{
return new Size(800, 600);
}
}
private void CommonActionsStrip_ButtonClick(object sender, EventArgs<CommonAction> e)
{
CommonAction ca = e.Data;
switch (ca)
{
case CommonAction.New:
PerformAction(new NewImageAction());
break;
case CommonAction.Open:
PerformAction(new OpenFileAction());
break;
case CommonAction.Save:
if (ActiveDocumentWorkspace != null)
{
ActiveDocumentWorkspace.DoSave();
}
break;
case CommonAction.Print:
if (ActiveDocumentWorkspace != null)
{
PrintAction pa = new PrintAction();
ActiveDocumentWorkspace.PerformAction(pa);
}
break;
case CommonAction.Cut:
if (ActiveDocumentWorkspace != null)
{
CutAction cutAction = new CutAction();
cutAction.PerformAction(ActiveDocumentWorkspace);
}
break;
case CommonAction.Copy:
if (ActiveDocumentWorkspace != null)
{
CopyToClipboardAction ctca = new CopyToClipboardAction(ActiveDocumentWorkspace);
ctca.PerformAction();
}
break;
case CommonAction.Paste:
if (ActiveDocumentWorkspace != null)
{
PasteAction pa = new PasteAction(ActiveDocumentWorkspace);
pa.PerformAction();
}
break;
case CommonAction.CropToSelection:
if (ActiveDocumentWorkspace != null)
{
using (new PushNullToolMode(ActiveDocumentWorkspace))
{
ActiveDocumentWorkspace.ExecuteFunction(new CropToSelectionFunction());
}
}
break;
case CommonAction.Deselect:
if (ActiveDocumentWorkspace != null)
{
ActiveDocumentWorkspace.ExecuteFunction(new DeselectFunction());
}
break;
case CommonAction.Undo:
if (ActiveDocumentWorkspace != null)
{
ActiveDocumentWorkspace.PerformAction(new HistoryUndoAction());
}
break;
case CommonAction.Redo:
if (ActiveDocumentWorkspace != null)
{
ActiveDocumentWorkspace.PerformAction(new HistoryRedoAction());
}
break;
default:
throw new InvalidEnumArgumentException("e.Data");
}
if (ActiveDocumentWorkspace != null)
{
ActiveDocumentWorkspace.Focus();
}
}
}
}
|