Exemple #1
0
        public static Image AnnotateImage(Image img, bool allowSave, string configPath, Action <Image> clipboardCopyRequested, Action <Image> imageUploadRequested)
        {
            if (!IniConfig.isInitialized)
            {
                IniConfig.AllowSave = allowSave;
                IniConfig.Init(configPath);
            }

            using (Image cloneImage = (Image)img.Clone())
                using (ICapture capture = new Capture {
                    Image = cloneImage
                })
                    using (Surface surface = new Surface(capture))
                        using (ImageEditorForm editor = new ImageEditorForm(surface, true))
                        {
                            editor.ClipboardCopyRequested += clipboardCopyRequested;
                            editor.ImageUploadRequested   += imageUploadRequested;

                            if (editor.ShowDialog() == DialogResult.OK)
                            {
                                using (img)
                                {
                                    return(editor.GetImageForExport());
                                }
                            }
                        }

            return(img);
        }
 public void SetUp()
 {
     _sut = new IniConfig("Configs//TestIni.ini");
     _sut.Init(File.ReadAllText("Configs//TestIni.ini"));
     _sut2 = new IniConfig("Configs//TestIni.ini");
     _sut2.Init(File.ReadAllText("Configs//TestIni.ini"));
     _sut2.SwitchToOrgId("org1");
 }
        /// <summary>
        /// Static initializer for the language code
        /// </summary>
        static Language()
        {
            if (!LogHelper.isInitialized)
            {
                LOG.Warn("Log4net hasn't been initialized yet! (Design mode?)");
                LogHelper.InitializeLog4NET();
            }
            if (!IniConfig.IsInited)
            {
                LOG.Warn("IniConfig hasn't been initialized yet! (Design mode?)");
                IniConfig.Init("greenshot", "greenshot");
            }
            string applicationDataFolder = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
            string applicationFolder     = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

            // PAF Path
            AddPath(Path.Combine(applicationFolder, @"App\Greenshot\Languages"));

            // Application data path
            AddPath(Path.Combine(applicationDataFolder, @"Greenshot\Languages\"));

            // Startup path
            AddPath(Path.Combine(applicationFolder, @"Languages"));

            try {
                using (RegistryKey languageGroupsKey = Registry.LocalMachine.OpenSubKey(LANGUAGE_GROUPS_KEY, false)) {
                    if (languageGroupsKey != null)
                    {
                        string [] groups = languageGroupsKey.GetValueNames();
                        foreach (string group in groups)
                        {
                            string groupValue          = (string)languageGroupsKey.GetValue(group);
                            bool   isGroupNotInstalled = "0".Equals(groupValue);
                            if (isGroupNotInstalled)
                            {
                                unsupportedLanguageGroups.Add(group.ToLower());
                            }
                        }
                    }
                }
            } catch (Exception e) {
                LOG.Warn("Couldn't read the installed language groups.", e);
            }

            coreConfig = IniConfig.GetIniSection <CoreConfiguration>();
            ScanFiles();
            if (!string.IsNullOrEmpty(coreConfig.Language))
            {
                CurrentLanguage = coreConfig.Language;
            }
            else
            {
                CurrentLanguage = DEFAULT_LANGUAGE;
            }
            LOG.Error("Couldn't set language, installation problem?");
        }
Exemple #4
0
        public static Image AnnotateImage(Image img, string imgPath, bool allowSave, string configPath,
                                          Action <Image> clipboardCopyRequested,
                                          Action <Image> imageUploadRequested,
                                          Action <Image, string> imageSaveRequested,
                                          Func <Image, string, string> imageSaveAsRequested,
                                          Action <Image> printImageRequested)
        {
            if (!IniConfig.isInitialized)
            {
                IniConfig.AllowSave = allowSave;
                IniConfig.Init(configPath);
            }

            using (Image cloneImage = img != null ? (Image)img.Clone() : LoadImage(imgPath))
                using (ICapture capture = new Capture {
                    Image = cloneImage
                })
                    using (Surface surface = new Surface(capture))
                        using (ImageEditorForm editor = new ImageEditorForm(surface, true))
                        {
                            editor.IsTaskWork = img != null;
                            editor.SetImagePath(imgPath);
                            editor.ClipboardCopyRequested += clipboardCopyRequested;
                            editor.ImageUploadRequested   += imageUploadRequested;
                            editor.ImageSaveRequested     += imageSaveRequested;
                            editor.ImageSaveAsRequested   += imageSaveAsRequested;
                            editor.PrintImageRequested    += printImageRequested;

                            DialogResult result = editor.ShowDialog();

                            if (result == DialogResult.OK && editor.IsTaskWork)
                            {
                                using (img)
                                {
                                    return(editor.GetImageForExport());
                                }
                            }

                            if (result == DialogResult.Abort)
                            {
                                return(null);
                            }
                        }

            return(img);
        }
Exemple #5
0
        public static void Start(string[] args)
        {
            bool          isAlreadyRunning = false;
            List <string> filesToOpen      = new List <string>();

            // Init Log4NET
            LogFileLocation = LogHelper.InitializeLog4NET();
            // Get logger
            LOG = log4net.LogManager.GetLogger(typeof(MainForm));

            Application.ThreadException += new System.Threading.ThreadExceptionEventHandler(Application_ThreadException);
            AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);

            // Log the startup
            LOG.Info("Starting: " + EnvironmentInfo.EnvironmentToString(false));

            IniConfig.Init();
            AppConfig.UpgradeToIni();
            // Read configuration
            conf = IniConfig.GetIniSection <CoreConfiguration>();
            try
            {
                // Fix for Bug 2495900, Multi-user Environment
                // check whether there's an local instance running already

                try
                {
                    // Added Mutex Security, hopefully this prevents the UnauthorizedAccessException more gracefully
                    // See an example in Bug #3131534
                    SecurityIdentifier sid           = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
                    MutexSecurity      mutexsecurity = new MutexSecurity();
                    mutexsecurity.AddAccessRule(new MutexAccessRule(sid, MutexRights.FullControl, AccessControlType.Allow));
                    mutexsecurity.AddAccessRule(new MutexAccessRule(sid, MutexRights.ChangePermissions, AccessControlType.Deny));
                    mutexsecurity.AddAccessRule(new MutexAccessRule(sid, MutexRights.Delete, AccessControlType.Deny));

                    bool created = false;
                    // 1) Create Mutex
                    applicationMutex = new Mutex(false, @"Local\F48E86D3-E34C-4DB7-8F8F-9A0EA55F0D08", out created, mutexsecurity);
                    // 2) Get the right to it, this returns false if it's already locked
                    if (!applicationMutex.WaitOne(0, false))
                    {
                        LOG.Debug("Greenshot seems already to be running!");
                        isAlreadyRunning = true;
                        // Clean up
                        applicationMutex.Close();
                        applicationMutex = null;
                    }
                }
                catch (AbandonedMutexException e)
                {
                    // Another Greenshot instance didn't cleanup correctly!
                    // we can ignore the exception, it happend on the "waitone" but still the mutex belongs to us
                    LOG.Warn("Greenshot didn't cleanup correctly!", e);
                }
                catch (UnauthorizedAccessException e)
                {
                    LOG.Warn("Greenshot is most likely already running for a different user in the same session, can't create mutex due to error: ", e);
                    isAlreadyRunning = true;
                }
                catch (Exception e)
                {
                    LOG.Warn("Problem obtaining the Mutex, assuming it was already taken!", e);
                    isAlreadyRunning = true;
                }

                if (args.Length > 0 && LOG.IsDebugEnabled)
                {
                    StringBuilder argumentString = new StringBuilder();
                    for (int argumentNr = 0; argumentNr < args.Length; argumentNr++)
                    {
                        argumentString.Append("[").Append(args[argumentNr]).Append("] ");
                    }
                    LOG.Debug("Greenshot arguments: " + argumentString.ToString());
                }

                for (int argumentNr = 0; argumentNr < args.Length; argumentNr++)
                {
                    string argument = args[argumentNr];
                    // Help
                    if (argument.ToLower().Equals("/help"))
                    {
                        // Try to attach to the console
                        bool attachedToConsole = Kernel32.AttachConsole(Kernel32.ATTACHCONSOLE_ATTACHPARENTPROCESS);
                        // If attach didn't work, open a console
                        if (!attachedToConsole)
                        {
                            Kernel32.AllocConsole();
                        }
                        StringBuilder helpOutput = new StringBuilder();
                        helpOutput.AppendLine();
                        helpOutput.AppendLine("Greenshot commandline options:");
                        helpOutput.AppendLine();
                        helpOutput.AppendLine();
                        helpOutput.AppendLine("\t/help");
                        helpOutput.AppendLine("\t\tThis help.");
                        helpOutput.AppendLine();
                        helpOutput.AppendLine();
                        helpOutput.AppendLine("\t/exit");
                        helpOutput.AppendLine("\t\tTries to close all running instances.");
                        helpOutput.AppendLine();
                        helpOutput.AppendLine();
                        helpOutput.AppendLine("\t/reload");
                        helpOutput.AppendLine("\t\tReload the configuration of Greenshot.");
                        helpOutput.AppendLine();
                        helpOutput.AppendLine();
                        helpOutput.AppendLine("\t/language [language code]");
                        helpOutput.AppendLine("\t\tSet the language of Greenshot, e.g. greenshot /language en-US.");
                        helpOutput.AppendLine();
                        helpOutput.AppendLine();
                        helpOutput.AppendLine("\t[filename]");
                        helpOutput.AppendLine("\t\tOpen the bitmap files 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();
                        }
                        FreeMutex();
                        return;
                    }

                    if (argument.ToLower().Equals("/exit"))
                    {
                        // unregister application on uninstall (allow uninstall)
                        try
                        {
                            LOG.Info("Sending all instances the exit command.");
                            // Pass Exit to running instance, if any
                            SendData(new CopyDataTransport(CommandEnum.Exit));
                        }
                        catch (Exception e)
                        {
                            LOG.Warn("Exception by exit.", e);
                        }
                        FreeMutex();
                        return;
                    }

                    // Reload the configuration
                    if (argument.ToLower().Equals("/reload"))
                    {
                        // Modify configuration
                        LOG.Info("Reloading configuration!");
                        // Update running instances
                        SendData(new CopyDataTransport(CommandEnum.ReloadConfig));
                        FreeMutex();
                        return;
                    }

                    // Stop running
                    if (argument.ToLower().Equals("/norun"))
                    {
                        // Make an exit possible
                        FreeMutex();
                        return;
                    }

                    // Language
                    if (argument.ToLower().Equals("/language"))
                    {
                        conf.Language = args[++argumentNr];
                        IniConfig.Save();
                        continue;
                    }

                    // Files to open
                    filesToOpen.Add(argument);
                }

                // Finished parsing the command line arguments, see if we need to do anything
                CopyDataTransport transport = new CopyDataTransport();
                if (filesToOpen.Count > 0)
                {
                    foreach (string fileToOpen in filesToOpen)
                    {
                        transport.AddCommand(CommandEnum.OpenFile, fileToOpen);
                    }
                }

                if (MainForm.instance == null)
                {
                    MainForm.instance = new MainForm(transport);
                }

                // if language is not set, show language dialog
                if (string.IsNullOrEmpty(conf.Language))
                {
                    LanguageDialog languageDialog = LanguageDialog.GetInstance();
                    languageDialog.ShowDialog();
                    conf.Language = languageDialog.SelectedLanguage;
                    IniConfig.Save();
                }

                // Check if it's the first time launch?
                if (conf.IsFirstLaunch)
                {
                    conf.IsFirstLaunch = false;
                    IniConfig.Save();
                    transport.AddCommand(CommandEnum.FirstLaunch);
                }
            }
            catch (Exception ex)
            {
                LOG.Error("Exception in startup.", ex);
                Application_ThreadException(MainForm.ActiveForm, new ThreadExceptionEventArgs(ex));
            }
        }
 public void SetUp()
 {
     _sut = new IniConfig("Configs//TestIni.ini");
     _sut.Init(File.ReadAllText("Configs//TestIni.ini"));
 }