Exemple #1
0
        private void SetBackend(IBackend value)
        {
            bool changingBackend = false;

            if (this.backend != null)
            {
                UnhookFromTooltipTaskGroupModels();
                changingBackend = true;
                // Cleanup the old backend
                try {
                    Logger.Debug("Cleaning up backend: {0}",
                                 this.backend.Name);
                    this.backend.Cleanup();
                } catch (Exception e) {
                    Logger.Warn("Exception cleaning up '{0}': {1}",
                                this.backend.Name,
                                e);
                }
            }

            // Initialize the new backend
            this.backend = value;
            if (this.backend == null)
            {
                RefreshTrayIconTooltip();
                return;
            }

            Logger.Info("Using backend: {0} ({1})",
                        this.backend.Name,
                        this.backend.GetType().ToString());
            this.backend.Initialize();

            if (!changingBackend)
            {
                TaskWindow.Reinitialize(!this.quietStart);
            }
            else
            {
                TaskWindow.Reinitialize(true);
            }

            RebuildTooltipTaskGroupModels();
            RefreshTrayIconTooltip();

            Logger.Debug("Configuration status: {0}",
                         this.backend.Configured.ToString());
        }
Exemple #2
0
        private bool CheckForDaySwitch()
        {
            if (DateTime.Today != currentDay)
            {
                Logger.Debug("Day has changed, reloading tasks");
                currentDay = DateTime.Today;
                // Reinitialize window according to new date
                if (TaskWindow.IsOpen)
                {
                    TaskWindow.Reinitialize(true);
                }

                UnhookFromTooltipTaskGroupModels();
                RebuildTooltipTaskGroupModels();
                RefreshTrayIconTooltip();
            }

            return(true);
        }
Exemple #3
0
        protected void InitializeIdle()
        {
            string backend = null;

            if (customBackendId != null)
            {
                backend = customBackendId;
            }
            else
            {
                var backendIdString = preferences.Get(PreferencesKeys.CurrentBackend);
                Logger.Debug("CurrentBackend specified in Preferences: {0}",
                             backendIdString);
                var bs = backendManager.AvailableBackends.SingleOrDefault(
                    b => b.Key == backendIdString).Key;
                if (!string.IsNullOrWhiteSpace(bs))
                {
                    backend = bs;
                }
            }

            backendManager.SetBackend(backend);

            trayIcon = GtkTray.CreateTray(this);

            BackendManager.BackendChanging += delegate {
                backendWasNullBeforeChange = BackendManager.CurrentBackend == null;
            };

            BackendManager.BackendInitialized += delegate {
                if (backendWasNullBeforeChange)
                {
                    TaskWindow.Reinitialize(!quietStart, this);
                }
                else
                {
                    TaskWindow.Reinitialize(true, this);
                }

                if (trayIcon != null)
                {
                    trayIcon.RefreshTrayIconTooltip();
                }
            };

            if (backendManager.CurrentBackend == null)
            {
                // Pop open the preferences dialog so the user can choose a
                // backend service to use.
                ShowPreferences();
            }
            else if (!quietStart)
            {
                TaskWindow.ShowWindow(this);
            }

            if (backendManager.CurrentBackend == null ||
                !backendManager.IsBackendConfigured)
            {
                GLib.Timeout.Add(1000, new GLib.TimeoutHandler(delegate {
                    try {
                        if (backendManager.CurrentBackend != null &&
                            !backendManager.IsBackendConfigured)
                        {
                            backendManager.ReInitializeBackend();
                        }
                    } catch (Exception e) {
                        Logger.Error("{0}", e.Message);
                    }
                    return(backendManager.CurrentBackend == null ||
                           !backendManager.IsBackendConfigured);
                }));
            }

            OnInitializeIdle();
        }