Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 171 insertions, 0 deletions

diff --git a/comm/calendar/base/modules/calCalendarDeactivator.jsm b/comm/calendar/base/modules/calCalendarDeactivator.jsm
new file mode 100644
index 0000000000..c987d17728
--- /dev/null
+++ b/comm/calendar/base/modules/calCalendarDeactivator.jsm
@@ -0,0 +1,171 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const EXPORTED_SYMBOLS = ["calendarDeactivator"];
+
+const { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+
+/**
+ * Handles deactivation of calendar UI and background processes/services (such
+ * as the alarms service) when users do not want to use calendar functionality.
+ * Also handles re-activation when users change their mind.
+ *
+ * If all of a user's calendars are disabled (e.g. calendar > properties >
+ * "turn this calendar on") then full calendar functionality is deactivated.
+ * If one or more calendars are enabled then full calendar functionality is
+ * activated.
+ *
+ * Note we use "disabled"/"enabled" for a user's individual calendars and
+ * "deactivated"/"activated" for the calendar component as a whole.
+ *
+ * @implements {calICalendarManagerObserver}
+ * @implements {calIObserver}
+ */
+var calendarDeactivator = {
+  windows: new Set(),
+  calendars: null,
+  isCalendarActivated: null,
+  QueryInterface: ChromeUtils.generateQI(["calICalendarManagerObserver", "calIObserver"]),
+
+  initializeDeactivator() {
+    this.calendars = new Set(cal.manager.getCalendars());
+    cal.manager.addObserver(this);
+    cal.manager.addCalendarObserver(this);
+    this.isCalendarActivated = this.checkCalendarsEnabled();
+  },
+
+  /**
+   * Register a window to allow future modifications, and set up the window's
+   * deactivated/activated state. Deregistration is not required.
+   *
+   * @param {ChromeWindow} window - A ChromeWindow object.
+   */
+  registerWindow(window) {
+    if (this.calendars === null) {
+      this.initializeDeactivator();
+    }
+    this.windows.add(window);
+    window.addEventListener("unload", () => this.windows.delete(window));
+
+    if (this.isCalendarActivated) {
+      window.document.documentElement.removeAttribute("calendar-deactivated");
+    } else {
+      this.refreshNotificationBoxes(window, false);
+    }
+  },
+
+  /**
+   * Check the enabled state of all of the user's calendars.
+   *
+   * @returns {boolean} True if any calendars are enabled, false if all are disabled.
+   */
+  checkCalendarsEnabled() {
+    for (let calendar of this.calendars) {
+      if (!calendar.getProperty("disabled")) {
+        return true;
+      }
+    }
+    return false;
+  },
+
+  /**
+   * If needed, change the calendar activated/deactivated state and update the
+   * UI and background processes/services accordingly.
+   */
+  refreshDeactivatedState() {
+    let someCalsEnabled = this.checkCalendarsEnabled();
+
+    if (someCalsEnabled == this.isCalendarActivated) {
+      return;
+    }
+
+    for (let window of this.windows) {
+      if (someCalsEnabled) {
+        window.document.documentElement.removeAttribute("calendar-deactivated");
+      } else {
+        window.document.documentElement.setAttribute("calendar-deactivated", "");
+      }
+      this.refreshNotificationBoxes(window, someCalsEnabled);
+    }
+
+    if (someCalsEnabled) {
+      Services.prefs.setBoolPref("calendar.itip.showImipBar", true);
+    }
+
+    this.isCalendarActivated = someCalsEnabled;
+  },
+
+  /**
+   * Show or hide the notification boxes that appear at the top of the calendar
+   * and tasks tabs when calendar functionality is deactivated.
+   *
+   * @param {ChromeWindow} window - A ChromeWindow object.
+   * @param {boolean} isEnabled - Whether any calendars are enabled.
+   */
+  refreshNotificationBoxes(window, isEnabled) {
+    let notificationboxes = [
+      [
+        window.calendarTabType.modes.calendar.notificationbox,
+        "calendar-deactivated-notification-events",
+      ],
+      [
+        window.calendarTabType.modes.tasks.notificationbox,
+        "calendar-deactivated-notification-tasks",
+      ],
+    ];
+
+    let value = "calendarDeactivated";
+    for (let [notificationbox, l10nId] of notificationboxes) {
+      let existingNotification = notificationbox.getNotificationWithValue(value);
+
+      if (isEnabled) {
+        notificationbox.removeNotification(existingNotification);
+      } else if (!existingNotification) {
+        notificationbox.appendNotification(
+          value,
+          {
+            label: { "l10n-id": l10nId },
+            priority: notificationbox.PRIORITY_WARNING_MEDIUM,
+          },
+          null
+        );
+      }
+    }
+  },
+
+  // calICalendarManagerObserver methods
+  onCalendarRegistered(calendar) {
+    this.calendars.add(calendar);
+
+    if (!this.isCalendarActivated && !calendar.getProperty("disabled")) {
+      this.refreshDeactivatedState();
+    }
+  },
+
+  onCalendarUnregistering(calendar) {
+    this.calendars.delete(calendar);
+
+    if (!calendar.getProperty("disabled")) {
+      this.refreshDeactivatedState();
+    }
+  },
+  onCalendarDeleting(calendar) {},
+
+  // calIObserver methods
+  onStartBatch() {},
+  onEndBatch() {},
+  onLoad() {},
+  onAddItem(item) {},
+  onModifyItem(newItem, oldItem) {},
+  onDeleteItem(deletedItem) {},
+  onError(calendar, errNo, message) {},
+
+  onPropertyChanged(calendar, name, value, oldValue) {
+    if (name == "disabled") {
+      this.refreshDeactivatedState();
+    }
+  },
+
+  onPropertyDeleting(calendar, name) {},
+};