/// <summary>
/// Ermittelt eine einzelne Einstellung.
/// </summary>
/// <param name="name">Name der Einstellung.</param>
/// <returns>Wert der Einstellung.</returns>
private static object ReadSetting(SettingNames name)
{
// Find and forward
SettingDescription settings;
return(m_Settings.TryGetValue(name, out settings) ? settings.ReadValue() : null);
}
public override HistoryMemento PerformAction(DocumentWorkspace documentWorkspace)
{
AnchorEdge initialEdge = SettingNames.GetLastCanvasSizeAnchorEdge();
Document newDoc = ResizeDocument(
documentWorkspace.FindForm(),
documentWorkspace.Document,
documentWorkspace.Document.Size,
initialEdge,
documentWorkspace.AppWorkspace.AppEnvironment.SecondaryColor,
true,
true);
if (newDoc != null)
{
using (new PushNullToolMode(documentWorkspace))
{
ReplaceDocumentHistoryMemento rdha = new ReplaceDocumentHistoryMemento(StaticName, StaticImage, documentWorkspace);
documentWorkspace.Document = newDoc;
return(rdha);
}
}
else
{
return(null);
}
}
private string LoadSetting(SettingNames setting)
{
string value;
if (settings.TryGetValue((int)setting, out value))
{
return(value);
}
return(GetSettingNameDefaultValue(setting));
}
private string GetSettingNameDefaultValue(SettingNames settingName)
{
MemberInfo enumValue = typeof(SettingNames).GetMember(settingName.ToString())[0];
DefaultValueAttribute defaultValue = (DefaultValueAttribute)enumValue.GetCustomAttributes(typeof(DefaultValueAttribute), false).FirstOrDefault();
if (defaultValue != null)
{
return(defaultValue.Value.ToString());
}
return(null);
}
void CreateCapabilityList()
{
string dummyString = "";
SettingNames.Clear();
foreach (VideoCapabilities settings in _deviceCapabilites)
{
dummyString = "";
dummyString = settings.FrameSize.Width + "x" + settings.FrameSize.Height + " " + settings.AverageFrameRate + "FPS";
SettingNames.Add(dummyString);
}
}
internal static string ToSerializedValue(this SettingNames value)
{
switch (value)
{
case SettingNames.AutoLogon:
return("AutoLogon");
case SettingNames.FirstLogonCommands:
return("FirstLogonCommands");
}
return(null);
}
protected override void AddSettingNames(SettingNames names)
{
names.Add(SettingRemoveWhenReading, SettingMaxCountToAutoStart);
names.Add(SettingMainWindow, SettingLogWindow, SettingDetailsWindow,
SettingExceptionWindow, SettingGenericEditorWindow, SettingLogColumnWidths,
SettingLogSplitterRatio, SettingDetailsSplitterRatioTop, SettingDetailsSplitterRatioBottom,
SettingDetailColumnWidths, SettingParameterColumnWidths);
names.Add(SettingPreviewPane, SettingStatusBar, SettingAutoScrollMessages, SettingDisplayTimeZone);
names.Add(SettingMaxRecentlyUsed, SettingRecentlyUsedList, SettingLastActive);
}
/// <summary>
/// Ermittelt eine einzelne Einstellung.
/// </summary>
/// <param name="name">Name der Einstellung.</param>
/// <returns>Wert der Einstellung.</returns>
private static object ReadSetting(SettingNames name)
{
// Find and forward
SettingDescription settings;
if (m_Settings.TryGetValue(name, out settings))
{
return(settings.ReadValue());
}
else
{
return(null);
}
}
private void SaveSetting(SettingNames settingName, string value)
{
int settingId = (int)settingName;
Setting setting = database.Settings.Find(settingId);
if (setting == null)
{
setting = new Setting {
Id = settingId, Description = settingName.ToString()
};
database.Settings.Add(setting);
}
setting.Value = value;
database.SaveChanges();
}
protected SettingsBase()
{
m_version = HighestSupportedVersion;
SettingNames names = new SettingNames();
AddSettingNames(names);
if (names.Count == 0)
{
throw new ApplicationException("The '" + GetType().FullName + "' settings class did not"
+ " return any setting names.");
}
m_settingNames = names.ToArray();
// Get the values twice. The first time create a dictionary of initial values that we can use
// to determine if the settings have changed from defaults.
m_settingDictionary = CreateInitialSettingsDictionary();
}
public override HistoryMemento PerformAction(DocumentWorkspace documentWorkspace)
{
AnchorEdge initialEdge = SettingNames.GetLastCanvasSizeAnchorEdge();
Document newDoc = ResizeDocument(
documentWorkspace.FindForm(),
documentWorkspace.Document,
documentWorkspace.Document.Size,
initialEdge,
documentWorkspace.AppWorkspace.AppEnvironment.SecondaryColor,
true,
true);
if (newDoc != null)
{
using (new PushNullToolMode(documentWorkspace))
{
if (newDoc.DpuUnit != MeasurementUnit.Pixel)
{
Settings.CurrentUser.SetString(SettingNames.LastNonPixelUnits, newDoc.DpuUnit.ToString());
if (documentWorkspace.AppWorkspace.Units != MeasurementUnit.Pixel)
{
documentWorkspace.AppWorkspace.Units = newDoc.DpuUnit;
}
}
ReplaceDocumentHistoryMemento rdha = new ReplaceDocumentHistoryMemento(StaticName, StaticImage, documentWorkspace);
documentWorkspace.Document = newDoc;
return(rdha);
}
}
else
{
return(null);
}
}
public static string ToSerialString(this SettingNames value) => value switch
{
public SettingBase this[SettingNames name] => _settings[name];
/// <summary>
/// Vermerkt eine Einstellung.
/// </summary>
/// <typeparam name="T">Der Datentyp des zugehörigen Wertes.</typeparam>
/// <param name="name">Der Name der Einstellung.</param>
/// <param name="defaultValue">Der voreingestellt Wert.</param>
private static void Add <T>(SettingNames name, T defaultValue)
{
// Create new
m_Settings[name] = new SettingDescription <T>(name, defaultValue);
}
protected internal ListSetting(SettingNames name, ImmutableHashSet <T> defaultValue, string description) : base(name, defaultValue, description)
{
}
/// <summary>
/// Erzeugt eine neue Beschreibung.
/// </summary>
/// <param name="name">Der Name der Beschreibung.</param>
internal SettingDescription(SettingNames name)
{
// Remember
Name = name;
}
// returns null to indicate user cancelled, or if initialNewSize = newSize that the user requested,
// or if there was an error (out of memory)
public static Document ResizeDocument(IWin32Window parent,
Document document,
Size initialNewSize,
AnchorEdge initialAnchor,
ColorBgra background,
bool loadAndSaveMaintainAspect,
bool saveAnchor)
{
using (CanvasSizeDialog csd = new CanvasSizeDialog())
{
bool maintainAspect;
if (loadAndSaveMaintainAspect)
{
maintainAspect = Settings.CurrentUser.GetBoolean(SettingNames.LastMaintainAspectRatioCS, false);
}
else
{
maintainAspect = false;
}
csd.OriginalSize = document.Size;
csd.OriginalDpuUnit = document.DpuUnit;
csd.OriginalDpu = document.DpuX;
csd.ImageWidth = initialNewSize.Width;
csd.ImageHeight = initialNewSize.Height;
csd.LayerCount = document.Layers.Count;
csd.AnchorEdge = initialAnchor;
csd.Units = csd.OriginalDpuUnit;
csd.Resolution = document.DpuX;
csd.Units = SettingNames.GetLastNonPixelUnits();
csd.ConstrainToAspect = maintainAspect;
DialogResult result = csd.ShowDialog(parent);
Size newSize = new Size(csd.ImageWidth, csd.ImageHeight);
MeasurementUnit newDpuUnit = csd.Units;
double newDpu = csd.Resolution;
// If they cancelled, get out
if (result == DialogResult.Cancel)
{
return(null);
}
// If they clicked OK, then we save the aspect checkbox, and maybe the anchor
if (loadAndSaveMaintainAspect)
{
Settings.CurrentUser.SetBoolean(SettingNames.LastMaintainAspectRatioCS, csd.ConstrainToAspect);
}
if (saveAnchor)
{
Settings.CurrentUser.SetString(SettingNames.LastCanvasSizeAnchorEdge, csd.AnchorEdge.ToString());
}
if (newSize == document.Size && newDpuUnit == document.DpuUnit && newDpu == document.DpuX)
{
return(null);
}
try
{
Utility.GCFullCollect();
Document newDoc = ResizeDocument(document, newSize, csd.AnchorEdge, background);
newDoc.DpuUnit = newDpuUnit;
newDoc.DpuX = newDpu;
newDoc.DpuY = newDpu;
return(newDoc);
}
catch (OutOfMemoryException)
{
Utility.ErrorBox(parent, PdnResources.GetString("CanvasSizeAction.ResizeDocument.OutOfMemory"));
return(null);
}
catch
{
return(null);
}
}
}
/// <summary> /// Vermerkt eine Einstellung. /// </summary> /// <typeparam name="TValueType">Der Datentyp des zugehörigen Wertes.</typeparam> /// <param name="name">Der Name der Einstellung.</param> /// <param name="defaultValue">Der voreingestellt Wert.</param> private static void Add <TValueType>(SettingNames name, TValueType defaultValue) => m_Settings[name] = new SettingDescription <TValueType>(name, defaultValue);
/// <summary>
/// Vermerkt eine Einstellung.
/// </summary>
/// <param name="name">Der Name der Einstellung.</param>
private static void Add(SettingNames name)
{
// Forward
Add(name, (string)null);
}
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);
}
protected SettingBase(SettingNames name, string description)
{
Name = name;
Description = description;
}
/// <summary> /// When implemented by a derived class adds the names of all the settings in that class. /// </summary> /// <param name="names">The collection of setting names. The derived class may only add to /// this collection.</param> protected abstract void AddSettingNames(SettingNames names);
protected internal DictionarySetting(SettingNames name, ImmutableDictionary <T1, T2> defaultValue, string description) : base(name, defaultValue,
description)
{
}
/// <summary> /// Vermerkt eine Einstellung. /// </summary> /// <param name="name">Der Name der Einstellung.</param> private static void Add(SettingNames name) => Add(name, (string)null);
public static Setting <T> Create <T>(SettingNames name, T defaultValue, string description) => new(name, defaultValue, description);
public override void PerformAction(AppWorkspace appWorkspace)
{
using (NewFileDialog nfd = new NewFileDialog())
{
Size newDocSize = appWorkspace.GetNewDocumentSize();
if (Utility.IsClipboardImageAvailable())
{
try
{
Utility.GCFullCollect();
IDataObject clipData = System.Windows.Forms.Clipboard.GetDataObject();
using (Image clipImage = (Image)clipData.GetData(DataFormats.Bitmap))
{
int width2 = clipImage.Width;
int height2 = clipImage.Height;
newDocSize = new Size(width2, height2);
}
}
catch (Exception ex)
{
if (ex is OutOfMemoryException ||
ex is ExternalException ||
ex is NullReferenceException)
{
// ignore
}
else
{
throw;
}
}
}
nfd.OriginalSize = new Size(newDocSize.Width, newDocSize.Height);
nfd.OriginalDpuUnit = SettingNames.GetLastNonPixelUnits();
nfd.OriginalDpu = Document.GetDefaultDpu(nfd.OriginalDpuUnit);
nfd.Units = nfd.OriginalDpuUnit;
nfd.Resolution = nfd.OriginalDpu;
nfd.ConstrainToAspect = Settings.CurrentUser.GetBoolean(SettingNames.LastMaintainAspectRatioNF, false);
DialogResult dr = nfd.ShowDialog(appWorkspace);
if (dr == DialogResult.OK)
{
bool success = appWorkspace.CreateBlankDocumentInNewWorkspace(new Size(nfd.ImageWidth, nfd.ImageHeight), nfd.Units, nfd.Resolution, false);
if (success)
{
appWorkspace.ActiveDocumentWorkspace.ZoomBasis = ZoomBasis.FitToWindow;
Settings.CurrentUser.SetBoolean(SettingNames.LastMaintainAspectRatioNF, nfd.ConstrainToAspect);
if (nfd.Units != MeasurementUnit.Pixel)
{
Settings.CurrentUser.SetString(SettingNames.LastNonPixelUnits, nfd.Units.ToString());
}
if (appWorkspace.Units != MeasurementUnit.Pixel)
{
appWorkspace.Units = nfd.Units;
}
}
}
}
}
