mirror of
https://github.com/greenshot/greenshot
synced 2025-07-11 07:37:05 -07:00
01d843e8cf
git-svn-id: http://svn.code.sf.net/p/greenshot/code/trunk@704 7dccd23d-a4a3-4e1f-8c07-b4c1b4018ab4
540 lines
21 KiB
C#
540 lines
21 KiB
C#
/*
|
|
* Greenshot - a free and open source screenshot tool
|
|
* Copyright (C) 2007-2010 Thomas Braun, Jens Klingen, Robin Krom
|
|
*
|
|
* For more information see: http://getgreenshot.org/
|
|
* The Greenshot project is hosted on Sourceforge: http://sourceforge.net/projects/greenshot/
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 1 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Drawing;
|
|
using System.Drawing.Drawing2D;
|
|
using System.Drawing.Printing;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Windows.Forms;
|
|
|
|
using Greenshot.Capturing;
|
|
using Greenshot.Configuration;
|
|
using Greenshot.Drawing;
|
|
using Greenshot.Forms;
|
|
using Greenshot.Help;
|
|
using Greenshot.Helpers;
|
|
using Greenshot.Plugin;
|
|
using Greenshot.UnmanagedHelpers;
|
|
using GreenshotPlugin.Core;
|
|
|
|
namespace Greenshot {
|
|
/// <summary>
|
|
/// Description of MainForm.
|
|
/// </summary>
|
|
public partial class MainForm : Form {
|
|
private const string LOG4NET_FILE = "log4net.xml";
|
|
private static log4net.ILog LOG = null;
|
|
private static AppConfig conf;
|
|
|
|
static Mutex applicationMutex = null;
|
|
|
|
[STAThread]
|
|
public static void Main(string[] args) {
|
|
DataTransport dataTransport = null;
|
|
// Set the Thread name, is better than "1"
|
|
Thread.CurrentThread.Name = Application.ProductName;
|
|
|
|
Application.ThreadException += new System.Threading.ThreadExceptionEventHandler(Application_ThreadException);
|
|
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
|
|
|
|
// Setup log4j, currently the file is called log4net.xml
|
|
string log4netFilename = Path.Combine(Application.StartupPath, LOG4NET_FILE);
|
|
if (File.Exists(log4netFilename)) {
|
|
log4net.Config.XmlConfigurator.ConfigureAndWatch(new FileInfo(log4netFilename));
|
|
} else {
|
|
MessageBox.Show("Can't find file " + LOG4NET_FILE);
|
|
}
|
|
|
|
// Setup the LOG
|
|
LOG = log4net.LogManager.GetLogger(typeof(MainForm));
|
|
|
|
// Log the startup
|
|
LOG.Info("Starting: " + EnvironmentInfo.EnvironmentToString(false));
|
|
try {
|
|
for(int argumentNr = 0; argumentNr < args.Length; argumentNr++) {
|
|
string argument = args[argumentNr];
|
|
|
|
// Help
|
|
if (argument.Equals("--help")) {
|
|
// Try to attach to the console
|
|
bool attachedToConsole = User32.AttachConsole(User32.ATTACH_PARENT_PROCESS);
|
|
// If attach didn't work, open a console
|
|
if (!attachedToConsole) {
|
|
User32.AllocConsole();
|
|
}
|
|
StringBuilder helpOutput = new StringBuilder();
|
|
helpOutput.AppendLine();
|
|
if (argumentNr + 1 < args.Length && args[argumentNr + 1].Equals("config")) {
|
|
helpOutput.AppendLine("Available configuration settings:");
|
|
|
|
Properties properties = AppConfig.GetAvailableProperties();
|
|
foreach(string key in properties.Keys) {
|
|
helpOutput.AppendLine("\t\t" + key + "=" + properties.GetProperty(key));
|
|
}
|
|
} else {
|
|
helpOutput.AppendLine("Greenshot commandline options:");
|
|
helpOutput.AppendLine();
|
|
helpOutput.AppendLine();
|
|
helpOutput.AppendLine("\t--help [config]");
|
|
helpOutput.AppendLine("\t\tThis help.");
|
|
helpOutput.AppendLine();
|
|
helpOutput.AppendLine();
|
|
helpOutput.AppendLine("\t--uninstall");
|
|
helpOutput.AppendLine("\t\tUnstall is called from the unstaller and tries to close all running instances.");
|
|
helpOutput.AppendLine();
|
|
helpOutput.AppendLine();
|
|
helpOutput.AppendLine("\t--config [property=value] ...");
|
|
helpOutput.AppendLine("\t\tChange the configuration of Greenshot via the commandline.");
|
|
helpOutput.AppendLine("\t\tExample to change the language to English: greenshot.exe --config Ui_Language=en-US");
|
|
helpOutput.AppendLine("\t\tExample to change the destination: greenshot.exe --config Output_File_Path=\"C:\\Documents and Settings\\\"");
|
|
helpOutput.AppendLine();
|
|
helpOutput.AppendLine();
|
|
helpOutput.AppendLine("\t--openfile [filename]");
|
|
helpOutput.AppendLine("\t\tOpen the bitmap file in the running Greenshot instance or start a new instance");
|
|
|
|
}
|
|
Console.WriteLine(helpOutput.ToString());
|
|
|
|
// If attach didn't work, wait for key otherwise the console will close to quickly
|
|
if (!attachedToConsole) {
|
|
Console.ReadKey();
|
|
}
|
|
return;
|
|
}
|
|
|
|
// unregister application on uninstall (allow uninstall)
|
|
if (argument.Equals("--uninstall") || argument.Equals("uninstall")) {
|
|
try {
|
|
// Pass Exit to running instance, if any
|
|
dataTransport = new DataTransport(CommandEnum.Exit, args[0]);
|
|
SendData(dataTransport);
|
|
} catch (Exception e) {
|
|
LOG.Warn("Exception by exit.", e);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Modify configuration
|
|
if (argument.Equals("--config")) {
|
|
LOG.Debug("Setting configuration!");
|
|
conf = AppConfig.GetInstance();
|
|
Properties properties = new Properties();
|
|
int propertyNr = argumentNr + 1;
|
|
while(propertyNr < args.Length && args[propertyNr].Contains("=")) {
|
|
// "Remove" the argument from the list as we used it
|
|
argumentNr++;
|
|
string [] splitargument = args[propertyNr].Split(new Char[] {'='});
|
|
LOG.Debug("Found property: " + splitargument[0] +"="+ splitargument[1]);
|
|
properties.AddProperty(splitargument[0], splitargument[1]);
|
|
propertyNr++;
|
|
}
|
|
if (properties.Count > 0) {
|
|
conf.SetProperties(properties);
|
|
conf.Store();
|
|
// Update running instances
|
|
SendData(new DataTransport(CommandEnum.ReloadConfig));
|
|
LOG.Debug("Configuration modified!");
|
|
} else {
|
|
LOG.Debug("Configuration NOT modified!");
|
|
}
|
|
}
|
|
|
|
// Make an exit possible
|
|
if (argument.Equals("--exit")) {
|
|
return;
|
|
}
|
|
|
|
if (argument.Equals("--openfile")) {
|
|
// Take filename and send it to running instance or take it while opening
|
|
dataTransport = new DataTransport(CommandEnum.OpenFile, args[0]);
|
|
}
|
|
}
|
|
|
|
// Fix for Bug 2495900, Multi-user Environment
|
|
// check whether there's an local instance running already
|
|
|
|
// 1) Create Mutex
|
|
applicationMutex = new Mutex(false, @"Local\F48E86D3-E34C-4DB7-8F8F-9A0EA55F0D08");
|
|
// 2) Get the right to it, this returns false if it's already locked
|
|
if (!applicationMutex.WaitOne(0, false)) {
|
|
if (dataTransport != null) {
|
|
SendData(dataTransport);
|
|
} else {
|
|
conf = AppConfig.GetInstance();
|
|
ILanguage lang = Language.GetInstance();
|
|
MessageBox.Show(lang.GetString(LangKey.error_multipleinstances), lang.GetString(LangKey.error));
|
|
}
|
|
Application.Exit();
|
|
return;
|
|
}
|
|
Application.EnableVisualStyles();
|
|
Application.SetCompatibleTextRenderingDefault(false);
|
|
|
|
conf = AppConfig.GetInstance();
|
|
|
|
// if language is not set, show language dialog
|
|
if(conf.Ui_Language.Equals("")) {
|
|
LanguageDialog ld = LanguageDialog.GetInstance();
|
|
ld.ShowDialog();
|
|
conf.Ui_Language = ld.Language;
|
|
conf.Store();
|
|
}
|
|
|
|
// Check if it's the first time launch?
|
|
bool firstLaunch = (bool)conf.General_IsFirstLaunch;
|
|
if(firstLaunch) {
|
|
// todo: display basic instructions
|
|
try {
|
|
} catch (Exception ex) {
|
|
LOG.Error("Exception in MainForm.", ex);
|
|
} finally {
|
|
conf.General_IsFirstLaunch = false;
|
|
conf.Store();
|
|
}
|
|
}
|
|
// Pass firstlaunch if it is the firstlaunch and no filename is given
|
|
if (dataTransport == null && firstLaunch) {
|
|
dataTransport = new DataTransport(CommandEnum.FirstLaunch, null);
|
|
}
|
|
MainForm mainForm = new MainForm(dataTransport);
|
|
Application.Run();
|
|
} catch(Exception ex) {
|
|
LOG.Error("Exception in startup.", ex);
|
|
Application_ThreadException(MainForm.ActiveForm, new ThreadExceptionEventArgs(ex));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Send DataTransport Object via Window-messages
|
|
/// </summary>
|
|
/// <param name="dataTransport">DataTransport with data for a running instance</param>
|
|
private static void SendData(DataTransport dataTransport) {
|
|
string appName = Application.ProductName;
|
|
CopyData copyData = new CopyData();
|
|
copyData.Channels.Add(appName);
|
|
copyData.Channels[appName].Send(dataTransport);
|
|
}
|
|
|
|
public static MainForm instance = null;
|
|
|
|
private ILanguage lang;
|
|
private ToolTip tooltip;
|
|
private CaptureForm captureForm = null;
|
|
private string lastImagePath = null;
|
|
|
|
public MainForm(DataTransport dataTransport) {
|
|
instance = this;
|
|
//
|
|
// The InitializeComponent() call is required for Windows Forms designer support.
|
|
//
|
|
InitializeComponent();
|
|
lang = Language.GetInstance();
|
|
if((bool)conf.General_RegisterHotkeys) {
|
|
RegisterHotkeys();
|
|
}
|
|
|
|
tooltip = new ToolTip();
|
|
|
|
UpdateUI();
|
|
InitializeQuickSettingsMenu();
|
|
|
|
captureForm = new CaptureForm();
|
|
|
|
// Load all the plugins
|
|
PluginHelper.instance.LoadPlugins(this, captureForm);
|
|
PluginHelper.instance.OnImageOutput += new OnImageOutputHandler(ImageWritten);
|
|
SoundHelper.Initialize();
|
|
|
|
// Enable the Greenshot icon to be visible, this prevents Problems with the context menu
|
|
notifyIcon.Visible = true;
|
|
|
|
if (dataTransport != null) {
|
|
// See what the dataTransport from the static main brought us!
|
|
switch (dataTransport.Command) {
|
|
case CommandEnum.FirstLaunch:
|
|
// Show user where Greenshot is, only at first start
|
|
notifyIcon.ShowBalloonTip(3000, "Greenshot", lang.GetString(LangKey.tooltip_firststart), ToolTipIcon.Info);
|
|
break;
|
|
case CommandEnum.OpenFile:
|
|
captureForm.HandleDataTransport(dataTransport);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public ContextMenuStrip MainMenu {
|
|
get {return contextMenu;}
|
|
}
|
|
|
|
#region hotkeys
|
|
protected override void WndProc(ref Message m) {
|
|
HotkeyHelper.HandleMessages(ref m);
|
|
base.WndProc(ref m);
|
|
}
|
|
|
|
private void RegisterHotkeys() {
|
|
bool suc = true;
|
|
suc &= HotkeyHelper.RegisterHotKey((int)this.Handle, (int)HotkeyHelper.Modifiers.NONE, HotkeyHelper.VK_SNAPSHOT, new HotKeyHandler(CaptureRegion));
|
|
suc &= HotkeyHelper.RegisterHotKey((int)this.Handle, (int)HotkeyHelper.Modifiers.ALT, HotkeyHelper.VK_SNAPSHOT, new HotKeyHandler(CaptureWindow));
|
|
suc &= HotkeyHelper.RegisterHotKey((int)this.Handle, (int)HotkeyHelper.Modifiers.CTRL, HotkeyHelper.VK_SNAPSHOT, new HotKeyHandler(CaptureFullScreen));
|
|
suc &= HotkeyHelper.RegisterHotKey((int)this.Handle, (int)HotkeyHelper.Modifiers.SHIFT, HotkeyHelper.VK_SNAPSHOT, new HotKeyHandler(CaptureLastRegion));
|
|
if (!suc) {
|
|
MessageBox.Show(lang.GetString(LangKey.warning_hotkeys),lang.GetString(LangKey.warning));
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
public void UpdateUI() {
|
|
this.Text = lang.GetString(LangKey.application_title);
|
|
this.contextmenu_settings.Text = lang.GetString(LangKey.contextmenu_settings);
|
|
this.contextmenu_capturearea.Text = lang.GetString(LangKey.contextmenu_capturearea);
|
|
this.contextmenu_capturelastregion.Text = lang.GetString(LangKey.contextmenu_capturelastregion);
|
|
this.contextmenu_capturewindow.Text = lang.GetString(LangKey.contextmenu_capturewindow);
|
|
this.contextmenu_capturefullscreen.Text = lang.GetString(LangKey.contextmenu_capturefullscreen);
|
|
this.contextmenu_captureclipboard.Text = lang.GetString(LangKey.contextmenu_captureclipboard);
|
|
this.contextmenu_openfile.Text = lang.GetString(LangKey.contextmenu_openfile);
|
|
this.contextmenu_quicksettings.Text = lang.GetString(LangKey.contextmenu_quicksettings);
|
|
this.contextmenu_help.Text = lang.GetString(LangKey.contextmenu_help);
|
|
this.contextmenu_about.Text = lang.GetString(LangKey.contextmenu_about);
|
|
this.contextmenu_donate.Text = lang.GetString(LangKey.contextmenu_donate);
|
|
this.contextmenu_exit.Text = lang.GetString(LangKey.contextmenu_exit);
|
|
}
|
|
|
|
|
|
#region mainform events
|
|
void MainFormFormClosing(object sender, FormClosingEventArgs e) {
|
|
LOG.Info("Closing with reason: " + e.CloseReason);
|
|
|
|
// Inform all registed plugins
|
|
PluginHelper.instance.Shutdown();
|
|
|
|
conf.Store();
|
|
HotkeyHelper.UnregisterHotkeys((int)this.Handle);
|
|
SoundHelper.Deinitialize();
|
|
if (applicationMutex != null) {
|
|
try {
|
|
applicationMutex.ReleaseMutex();
|
|
} catch (Exception ex) {
|
|
LOG.Error("Error releasing Mutex!", ex);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region key handlers
|
|
void CaptureRegion() {
|
|
captureForm.MakeCapture(CaptureMode.Region, true);
|
|
}
|
|
void CaptureClipboard() {
|
|
captureForm.MakeCapture(CaptureMode.Clipboard, false);
|
|
}
|
|
void CaptureFile() {
|
|
OpenFileDialog openFileDialog = new OpenFileDialog();
|
|
openFileDialog.Filter = "Image files (*.png, *.jpg, *.gif, *.bmp, *.ico)|*.png; *.jpg; *.jpeg; *.gif; *.bmp; *.ico";
|
|
if (openFileDialog.ShowDialog() == DialogResult.OK) {
|
|
if (File.Exists(openFileDialog.FileName)) {
|
|
captureForm.MakeCapture(openFileDialog.FileName);
|
|
}
|
|
}
|
|
}
|
|
void CaptureFullScreen() {
|
|
captureForm.MakeCapture(CaptureMode.FullScreen, true);
|
|
}
|
|
void CaptureLastRegion() {
|
|
captureForm.MakeCapture(CaptureMode.LastRegion, true);
|
|
}
|
|
void CaptureWindow() {
|
|
CaptureMode captureMode = CaptureMode.None;
|
|
if ((conf.Capture_Windows_Interactive.HasValue && conf.Capture_Windows_Interactive.Value)) {
|
|
captureMode = CaptureMode.Window;
|
|
} else {
|
|
captureMode = CaptureMode.ActiveWindow;
|
|
}
|
|
captureForm.MakeCapture(captureMode, true);
|
|
}
|
|
#endregion
|
|
|
|
#region contextmenu
|
|
void ContextMenuOpening(object sender, System.ComponentModel.CancelEventArgs e) {
|
|
string text = Clipboard.GetText();
|
|
if ((text != null && text.StartsWith("http://")) || Clipboard.ContainsImage() || ClipboardHelper.GetFormats().Contains("HTML Format")) {
|
|
contextmenu_captureclipboard.Enabled = true;
|
|
} else {
|
|
contextmenu_captureclipboard.Enabled = false;
|
|
}
|
|
contextmenu_capturelastregion.Enabled = RuntimeConfig.LastCapturedRegion != Rectangle.Empty;
|
|
}
|
|
|
|
void CaptureAreaToolStripMenuItemClick(object sender, EventArgs e) {
|
|
captureForm.MakeCapture(CaptureMode.Region, false);
|
|
}
|
|
|
|
void CaptureClipboardToolStripMenuItemClick(object sender, System.EventArgs e) {
|
|
CaptureClipboard();
|
|
}
|
|
|
|
void OpenFileToolStripMenuItemClick(object sender, System.EventArgs e) {
|
|
CaptureFile();
|
|
}
|
|
|
|
void CaptureFullScreenToolStripMenuItemClick(object sender, System.EventArgs e) {
|
|
captureForm.MakeCapture(CaptureMode.FullScreen, false);
|
|
}
|
|
|
|
void Contextmenu_capturelastregionClick(object sender, System.EventArgs e) {
|
|
captureForm.MakeCapture(CaptureMode.LastRegion, false);
|
|
}
|
|
|
|
void Contextmenu_donateClick(object sender, System.EventArgs e) {
|
|
Process.Start("http://getgreenshot.org/support/");
|
|
}
|
|
|
|
void CaptureWindowToolStripMenuItemClick(object sender, System.EventArgs e) {
|
|
captureForm.MakeCapture(CaptureMode.Window, false);
|
|
}
|
|
|
|
void Contextmenu_settingsClick(object sender, System.EventArgs e) {
|
|
SettingsForm settings = new SettingsForm();
|
|
settings.ShowDialog();
|
|
InitializeQuickSettingsMenu();
|
|
this.Hide();
|
|
}
|
|
|
|
void Contextmenu_aboutClick(object sender, EventArgs e) {
|
|
new AboutForm().Show();
|
|
}
|
|
|
|
void Contextmenu_helpClick(object sender, System.EventArgs e) {
|
|
HelpBrowserForm hpf = new HelpBrowserForm(conf.Ui_Language);
|
|
hpf.Show();
|
|
}
|
|
|
|
void Contextmenu_exitClick(object sender, EventArgs e) {
|
|
Application.Exit();
|
|
}
|
|
|
|
private void InitializeQuickSettingsMenu() {
|
|
this.contextmenu_quicksettings.DropDownItems.Clear();
|
|
// screenshot destination
|
|
ToolStripMenuSelectList sel = new ToolStripMenuSelectList("destination",true);
|
|
sel.Text = lang.GetString(LangKey.settings_destination);
|
|
sel.AddItem(lang.GetString(LangKey.settings_destination_editor), ScreenshotDestinations.Editor, (conf.Output_Destinations&ScreenshotDestinations.Editor)==ScreenshotDestinations.Editor);
|
|
sel.AddItem(lang.GetString(LangKey.settings_destination_clipboard), ScreenshotDestinations.Clipboard, (conf.Output_Destinations&ScreenshotDestinations.Clipboard)==ScreenshotDestinations.Clipboard);
|
|
sel.AddItem(lang.GetString(LangKey.quicksettings_destination_file), ScreenshotDestinations.FileDefault, (conf.Output_Destinations&ScreenshotDestinations.FileDefault)==ScreenshotDestinations.FileDefault);
|
|
sel.AddItem(lang.GetString(LangKey.settings_destination_fileas), ScreenshotDestinations.FileWithDialog, (conf.Output_Destinations&ScreenshotDestinations.FileWithDialog)==ScreenshotDestinations.FileWithDialog);
|
|
sel.AddItem(lang.GetString(LangKey.settings_destination_printer), ScreenshotDestinations.Printer, (conf.Output_Destinations&ScreenshotDestinations.Printer)==ScreenshotDestinations.Printer);
|
|
sel.CheckedChanged += new EventHandler(this.QuickSettingItemChanged);
|
|
this.contextmenu_quicksettings.DropDownItems.Add(sel);
|
|
// print options
|
|
sel = new ToolStripMenuSelectList("printoptions",true);
|
|
sel.Text = lang.GetString(LangKey.settings_printoptions);
|
|
sel.AddItem(lang.GetString(LangKey.printoptions_allowshrink), "AllowPrintShrink", (bool)conf.Output_Print_AllowShrink);
|
|
sel.AddItem(lang.GetString(LangKey.printoptions_allowenlarge), "AllowPrintEnlarge", (bool)conf.Output_Print_AllowEnlarge);
|
|
sel.AddItem(lang.GetString(LangKey.printoptions_allowrotate), "AllowPrintRotate", (bool)conf.Output_Print_AllowRotate);
|
|
sel.AddItem(lang.GetString(LangKey.printoptions_allowcenter), "AllowPrintCenter", (bool)conf.Output_Print_Center);
|
|
sel.CheckedChanged += new EventHandler(this.QuickSettingItemChanged);
|
|
this.contextmenu_quicksettings.DropDownItems.Add(sel);
|
|
// effects
|
|
sel = new ToolStripMenuSelectList("effects",true);
|
|
sel.Text = lang.GetString(LangKey.settings_visualization);
|
|
sel.AddItem(lang.GetString(LangKey.settings_playsound), "PlaySound", (bool)conf.Ui_Effects_CameraSound);
|
|
sel.AddItem(lang.GetString(LangKey.settings_showflashlight), "ShowFlashlight", (bool)conf.Ui_Effects_Flashlight);
|
|
sel.CheckedChanged += new EventHandler(this.QuickSettingItemChanged);
|
|
this.contextmenu_quicksettings.DropDownItems.Add(sel);
|
|
}
|
|
|
|
void QuickSettingItemChanged(object sender, EventArgs e) {
|
|
ToolStripMenuSelectList selectList = (ToolStripMenuSelectList)sender;
|
|
ToolStripMenuSelectListItem item = ((ItemCheckedChangedEventArgs)e).Item;;
|
|
if(selectList.Identifier.Equals("destination")) {
|
|
IEnumerator en = selectList.DropDownItems.GetEnumerator();
|
|
ScreenshotDestinations dest = 0;
|
|
while(en.MoveNext()) {
|
|
ToolStripMenuSelectListItem i = (ToolStripMenuSelectListItem)en.Current;
|
|
if(i.Checked) dest |= (ScreenshotDestinations)i.Data;
|
|
}
|
|
conf.Output_Destinations = dest;
|
|
conf.Store();
|
|
} else if(selectList.Identifier.Equals("printoptions")) {
|
|
if(item.Data.Equals("AllowPrintShrink")) conf.Output_Print_AllowShrink = (bool?)item.Checked;
|
|
else if(item.Data.Equals("AllowPrintEnlarge")) conf.Output_Print_AllowEnlarge = (bool?)item.Checked;
|
|
else if(item.Data.Equals("AllowPrintRotate")) conf.Output_Print_AllowRotate = (bool?)item.Checked;
|
|
else if(item.Data.Equals("AllowPrintCenter")) conf.Output_Print_Center = (bool?)item.Checked;
|
|
conf.Store();
|
|
} else if(selectList.Identifier.Equals("effects")) {
|
|
if(item.Data.Equals("PlaySound")) conf.Ui_Effects_CameraSound = (bool?)item.Checked;
|
|
else if(item.Data.Equals("ShowFlashlight")) conf.Ui_Effects_Flashlight = (bool?)item.Checked;
|
|
conf.Store();
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
private static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e) {
|
|
string exceptionText = EnvironmentInfo.BuildReport(e.ExceptionObject as Exception);
|
|
LOG.Error(exceptionText);
|
|
new BugReportForm(exceptionText).ShowDialog();
|
|
}
|
|
|
|
private static void Application_ThreadException(object sender, ThreadExceptionEventArgs e) {
|
|
string exceptionText = EnvironmentInfo.BuildReport(e.Exception);
|
|
LOG.Error(exceptionText);
|
|
new BugReportForm(exceptionText).ShowDialog();
|
|
}
|
|
|
|
/// <summary>
|
|
/// The ContextMenu DoubleClick currently opens the last know save location
|
|
/// </summary>
|
|
private void ContextMenuDoubleClick(object sender, EventArgs eventArgs) {
|
|
string path;
|
|
if (lastImagePath != null && Directory.Exists(lastImagePath)) {
|
|
path = lastImagePath;
|
|
} else if (Directory.Exists(conf.Output_File_Path)) {
|
|
path = conf.Output_File_Path;
|
|
} else {
|
|
// What do I open when nothing can be found? Right, nothing...
|
|
return;
|
|
}
|
|
LOG.Debug("DoubleClick was called! Starting: " + path);
|
|
try {
|
|
System.Diagnostics.Process.Start(path);
|
|
} catch (Exception e) {
|
|
// Make sure we show what we tried to open in the exception
|
|
e.Data.Add("path", path);
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handling of the OnImageOutputHandler event, stores the save location
|
|
/// </summary>
|
|
/// <param name="ImageOutputEventArgs">Has the full path</param>
|
|
private void ImageWritten(object sender, ImageOutputEventArgs eventArgs) {
|
|
lastImagePath = Path.GetDirectoryName(eventArgs.FullPath);
|
|
}
|
|
}
|
|
}
|