private async void Window_Loaded(object sender, RoutedEventArgs e)
        {
            // Checking fonts real quick

            StatusText.Content        = "Checking for fonts...";
            StatusBar.IsIndeterminate = true;

            var result = await FontInstaller.CheckFonts();

            if (!result)
            {
                StatusText.Content        = "Fail: some fonts not found!";
                StatusBar.IsIndeterminate = false;

                MessageBox.Show("This app requires SF Pro Display Black Italic font to be installed. Please read usage again and try again.",
                                "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                Environment.Exit(0);
            }

            StatusText.Content        = "Idle";
            StatusBar.IsIndeterminate = false;

            MainGrid.IsEnabled = true;

            UpdateImage();
        }
        private async void Install()
        {
            var q = await _app.ShowMessageBox("Question", "Install Fonts?", DialogButtons.YesNo);

            if (q)
            {
                FontInstaller.InstallFonts(_app, FontsToInstall);
            }
        }
Beispiel #3
0
        static void Main()
        {
            FontInstaller.InstallFont(KwFontFace.NOTOMONO);



            Application.SetHighDpiMode(HighDpiMode.SystemAware);
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Form1());
        }
Beispiel #4
0
        static void Main()
        {
            FontInstaller.AddFontResourceA(Directory.GetCurrentDirectory() + "\\MyMMUniversal.ttf");

            RegistryKey reg = Registry.CurrentUser.CreateSubKey(@"Software\Microsoft\Windows NT\CurrentVersion\AppCompatFlags\Layers");

            if (IsAlreadyRunning())
            {
                MessageBox.Show("MyInput is already running.", "MyInput", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                EnumWindows(new EnumWinCallBack(EnumWindowCallBack), 0);
                return;
            }
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            using (kh = new GlobalHook())
            {
                Application.Run(new Main());
            }
        }
        internal static void HandleSquirrelInstallEvent(string[] args)
        {
#if __MonoCS__
            Debug.Fail("HandleSquirrelInstallEvent should not run on Linux!");                  // and the code below doesn't compile on Linux
            return;
#else
            bool firstTime       = false;
            var  updateUrlResult = LookupUrlOfSquirrelUpdate();
            // Should only be null if we're not online. Not sure how squirrel will handle that,
            // but at least one of these operations is responsible for setting up shortcuts to the program,
            // which we'd LIKE to work offline. Passing it a plausible url, even though it will presumably fail,
            // seems less likely to cause problems than passing null.
            if (string.IsNullOrEmpty(updateUrlResult.URL))
            {
                updateUrlResult.URL = @"https://s3.amazonaws.com/bloomlibrary.org/squirrel";
            }
            if (args[0] == "--squirrel-uninstall")
            {
                RemoveBloomRegistryEntries();
            }
            if (args[0] == "--squirrel-updated")
            {
                var props = new Dictionary <string, string>();
                if (args.Length > 1)
                {
                    props["newVersion"] = args[1];
                }
                props["channel"] = ApplicationUpdateSupport.ChannelName;
                Analytics.Track("Update Version", props);
            }
            string iconPath = null;
            if (args[0] == "--squirrel-install")
            {
                //Using an icon in the root folder fixes the problem of losing the shortcut icon when we
                //upgrade, lose the original, and eventually the windows explorer cache loses it.
                //There was another attempt at fixing this by finding all the shortcuts and updating them, but that didn't work in our testing and this seems simpler and more robust.
                //There may be some other reason for the old approach of pointing at the icon of the app itself (e.g. could be a different icon)?
                var exePath          = Application.ExecutablePath;
                var rootAppDirectory = Path.GetDirectoryName(Path.GetDirectoryName(exePath));
                // directory that holds e.g. /3.6/Bloom.exe
                var versionIconPath = Path.ChangeExtension(exePath, "ico");                 // where this installation has icon
                iconPath = Path.ChangeExtension(Path.Combine(rootAppDirectory, Path.GetFileName(exePath)), "ico");
                // where we will put a version-independent icon
                try
                {
                    if (RobustFile.Exists(versionIconPath))
                    {
                        RobustFile.Copy(versionIconPath, iconPath, true);
                    }
                }
                catch (Exception)
                {
                    // ignore...most likely some earlier version of the icon is locked somehow, fairly harmless.
                }
                // Normally this is done on every run of the program, but if we're doing a silent allUsers install,
                // this is our only time running with admin privileges so we can actually make the entries for all users.
                MakeBloomRegistryEntries(args);
            }
            switch (args[0])
            {
            // args[1] is version number
            case "--squirrel-install":                     // (first?) installed
            case "--squirrel-updated":                     // updated to specified version
            case "--squirrel-obsolete":                    // this version is no longer newest
            case "--squirrel-uninstall":                   // being uninstalled
                using (var mgr = new UpdateManager(updateUrlResult.URL, Application.ProductName))
                {
                    // WARNING, in most of these scenarios, the app exits at the end of HandleEvents;
                    // thus, the method call does not return and nothing can be done after it!
                    // We replace two of the usual calls in order to take control of where shortcuts are installed.
                    SquirrelAwareApp.HandleEvents(

                        onInitialInstall: v =>
                    {
                        mgr.CreateShortcutsForExecutable(Path.GetFileName(Assembly.GetEntryAssembly().Location),
                                                         StartMenuLocations,
                                                         false,               // not just an update, since this is case initial install
                                                         null,                // can provide arguments to pass to Update.exe in shortcut, defaults are OK
                                                         iconPath,
                                                         SharedByAllUsers());
                        // Normally we can't do this in our quick silent run as part of install, because of the need to escalate
                        // privilege. But if we're being installed for all users we must already be running as admin.
                        // We don't need to do an extra restart of Bloom because this install-setup run of Bloom will finish
                        // right away anyway. We do this last because we've had some trouble (BL-3342) with timeouts
                        // if this install somehow ties up the CPU until Squirrel thinks Bloom is taking too long to do its
                        // install-only run.
                        if (SharedByAllUsers())
                        {
                            FontInstaller.InstallFont("AndikaNewBasic", needsRestart: false);
                        }
                    },
                        onAppUpdate: v => HandleAppUpdate(mgr),
                        onAppUninstall: v => mgr.RemoveShortcutsForExecutable(Path.GetFileName(Assembly.GetEntryAssembly().Location), StartMenuLocations, SharedByAllUsers()),
                        onFirstRun: () => firstTime = true,
                        arguments: args);
                }
                break;
            }
#endif
        }