path: root/comm/calendar/base/content/calendar-command-controller.js

/* 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/. */

/* globals goUpdateCommand, currentView, TodayPane, createEventWithDialog,
   getSelectedCalendar, editSelectedEvents, viewSelectedEvents,
   modifyTaskFromContext, deleteSelectedEvents, setupAttendanceMenu,
   createTodoWithDialog, deleteToDoCommand, promptDeleteCalendar,
   toImport, loadEventsFromFile, exportEntireCalendar, saveEventsToFile,
   publishEntireCalendar, publishCalendarData, toggleUnifinder, toggleOrientation
   toggleWorkdaysOnly, switchCalendarView, getTaskTree, selectAllEvents,
   gCurrentMode, getSelectedTasks, canPaste, goSetMenuValue, canUndo, canRedo,
   cutToClipboard, copyToClipboard, pasteFromClipboard, undo, redo,
   PrintUtils */

var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");

var CalendarDeleteCommandEnabled = false;
var CalendarNewEventsCommandEnabled = false;
var CalendarNewTasksCommandEnabled = false;

/**
 * Command controller to execute calendar specific commands
 *
 * @see nsICommandController
 */
var calendarController = {
  commands: new Set([
    // Common commands
    "calendar_new_event_command",
    "calendar_new_event_context_command",
    "calendar_new_event_todaypane_command",
    "calendar_modify_event_command",
    "calendar_view_event_command",
    "calendar_delete_event_command",

    "calendar_modify_focused_item_command",
    "calendar_delete_focused_item_command",

    "calendar_new_todo_command",
    "calendar_new_todo_context_command",
    "calendar_new_todo_todaypane_command",
    "calendar_toggle_tasks_in_view_command",
    "calendar_modify_todo_command",
    "calendar_modify_todo_todaypane_command",
    "calendar_delete_todo_command",

    "calendar_new_calendar_command",
    "calendar_edit_calendar_command",
    "calendar_delete_calendar_command",

    "calendar_import_command",
    "calendar_export_command",
    "calendar_export_selection_command",

    "calendar_publish_selected_calendar_command",
    "calendar_publish_calendar_command",
    "calendar_publish_selected_events_command",

    "calendar_view_next_command",
    "calendar_view_prev_command",

    "calendar_toggle_orientation_command",
    "calendar_toggle_workdays_only_command",

    "calendar_day-view_command",
    "calendar_week-view_command",
    "calendar_multiweek-view_command",
    "calendar_month-view_command",

    "calendar_task_filter_command",
    "calendar_reload_remote_calendars",
    "calendar_show_unifinder_command",
    "calendar_toggle_completed_command",
    "calendar_percentComplete-0_command",
    "calendar_percentComplete-25_command",
    "calendar_percentComplete-50_command",
    "calendar_percentComplete-75_command",
    "calendar_percentComplete-100_command",
    "calendar_priority-0_command",
    "calendar_priority-9_command",
    "calendar_priority-5_command",
    "calendar_priority-1_command",
    "calendar_general-priority_command",
    "calendar_general-progress_command",
    "calendar_general-postpone_command",
    "calendar_postpone-1hour_command",
    "calendar_postpone-1day_command",
    "calendar_postpone-1week_command",
    "calendar_task_category_command",

    "calendar_attendance_command",

    // for events/tasks in a tab
    "cmd_save",
    "cmd_accept",

    // Pseudo commands
    "calendar_in_foreground",
    "calendar_in_background",
    "calendar_mode_calendar",
    "calendar_mode_task",

    "cmd_selectAll",
  ]),

  updateCommands() {
    this.commands.forEach(goUpdateCommand);
  },

  supportsCommand(aCommand) {
    if (this.commands.has(aCommand)) {
      return true;
    }
    return false;
  },

  /* eslint-disable complexity */
  isCommandEnabled(aCommand) {
    switch (aCommand) {
      case "calendar_new_event_command":
      case "calendar_new_event_context_command":
      case "calendar_new_event_todaypane_command":
        return CalendarNewEventsCommandEnabled;
      case "calendar_modify_focused_item_command":
        return this.item_selected && canEditSelectedItems();
      case "calendar_modify_event_command":
        return this.item_selected && canEditSelectedItems();
      case "calendar_view_event_command":
        return this.item_selected;
      case "calendar_delete_focused_item_command":
        return CalendarDeleteCommandEnabled && this.selected_items_writable;
      case "calendar_delete_event_command":
        return CalendarDeleteCommandEnabled && this.selected_items_writable;
      case "calendar_new_todo_command":
      case "calendar_new_todo_context_command":
      case "calendar_new_todo_todaypane_command":
      case "calendar_toggle_tasks_in_view_command":
        return CalendarNewTasksCommandEnabled;
      case "calendar_modify_todo_command":
      case "calendar_modify_todo_todaypane_command":
        return this.todo_items_selected;
      // This code is temporarily commented out due to
      // bug 469684 Unifinder-todo: raising of the context menu fires blur-event
      // this.todo_tasktree_focused;
      case "calendar_edit_calendar_command":
        return this.isCalendarInForeground();
      case "calendar_task_filter_command":
        return true;
      case "calendar_delete_todo_command":
        if (!CalendarDeleteCommandEnabled) {
          return false;
        }
      // falls through otherwise
      case "calendar_toggle_completed_command":
      case "calendar_percentComplete-0_command":
      case "calendar_percentComplete-25_command":
      case "calendar_percentComplete-50_command":
      case "calendar_percentComplete-75_command":
      case "calendar_percentComplete-100_command":
      case "calendar_priority-0_command":
      case "calendar_priority-9_command":
      case "calendar_priority-5_command":
      case "calendar_priority-1_command":
      case "calendar_task_category_command":
      case "calendar_general-progress_command":
      case "calendar_general-priority_command":
      case "calendar_general-postpone_command":
      case "calendar_postpone-1hour_command":
      case "calendar_postpone-1day_command":
      case "calendar_postpone-1week_command":
        return (
          ((this.isCalendarInForeground() || this.todo_tasktree_focused) &&
            this.writable &&
            this.todo_items_selected &&
            this.todo_items_writable) ||
          document.getElementById("tabmail").currentTabInfo.mode.type == "calendarTask"
        );
      case "calendar_delete_calendar_command":
        return this.isCalendarInForeground() && !this.last_calendar;
      case "calendar_import_command":
        return this.writable;
      case "calendar_export_selection_command":
        return this.item_selected;
      case "calendar_toggle_orientation_command":
        return this.isInMode("calendar") && currentView().supportsRotation;
      case "calendar_toggle_workdays_only_command":
        return this.isInMode("calendar") && currentView().supportsWorkdaysOnly;
      case "calendar_publish_selected_events_command":
        return this.item_selected;

      case "calendar_reload_remote_calendars":
        return this.has_enabled_reloadable_calendars && !this.offline;
      case "calendar_attendance_command": {
        let attendSel = false;
        if (this.todo_tasktree_focused) {
          attendSel =
            this.writable &&
            this.todo_items_invitation &&
            this.todo_items_selected &&
            this.todo_items_writable;
        } else {
          attendSel =
            this.item_selected && this.selected_events_invitation && this.selected_items_writable;
        }

        // Small hack, we want to hide instead of disable.
        document.getElementById("calendar_attendance_command").setAttribute("hidden", !attendSel);
        return attendSel;
      }

      // The following commands all just need the calendar in foreground,
      // make sure you take care when changing things here.
      case "calendar_view_next_command":
      case "calendar_view_prev_command":
      case "calendar_in_foreground":
        return this.isCalendarInForeground();
      case "calendar_in_background":
        return !this.isCalendarInForeground();

      // The following commands need calendar mode, be careful when
      // changing things.
      case "calendar_day-view_command":
      case "calendar_week-view_command":
      case "calendar_multiweek-view_command":
      case "calendar_month-view_command":
      case "calendar_show_unifinder_command":
      case "calendar_mode_calendar":
        return this.isInMode("calendar");

      case "calendar_mode_task":
        return this.isInMode("task");

      case "cmd_selectAll":
        return this.todo_tasktree_focused || this.isInMode("calendar");

      // for events/tasks in a tab
      case "cmd_save":
      // falls through
      case "cmd_accept": {
        let tabType = document.getElementById("tabmail").currentTabInfo.mode.type;
        return tabType == "calendarTask" || tabType == "calendarEvent";
      }

      default:
        if (this.commands.has(aCommand)) {
          // All other commands we support should be enabled by default
          return true;
        }
    }
    return false;
  },
  /* eslint-enable complexity */

  doCommand(aCommand) {
    switch (aCommand) {
      // Common Commands
      case "calendar_new_event_command":
        createEventWithDialog(
          getSelectedCalendar(),
          cal.dtz.getDefaultStartDate(currentView().selectedDay)
        );
        break;
      case "calendar_new_event_context_command": {
        let newStart = currentView().selectedDateTime;
        if (!newStart) {
          newStart = cal.dtz.getDefaultStartDate(currentView().selectedDay);
        }
        createEventWithDialog(getSelectedCalendar(), newStart, null, null, null, newStart.isDate);
        break;
      }
      case "calendar_new_event_todaypane_command":
        createEventWithDialog(getSelectedCalendar(), cal.dtz.getDefaultStartDate(TodayPane.start));
        break;
      case "calendar_modify_event_command":
        editSelectedEvents();
        break;
      case "calendar_view_event_command":
        viewSelectedEvents();
        break;
      case "calendar_modify_focused_item_command": {
        let focusedElement = document.commandDispatcher.focusedElement;
        if (focusedElement == TodayPane.agenda) {
          TodayPane.agenda.editSelectedItem();
        } else if (focusedElement && focusedElement.className == "calendar-task-tree") {
          modifyTaskFromContext();
        } else if (this.isInMode("calendar")) {
          editSelectedEvents();
        }
        break;
      }
      case "calendar_delete_event_command":
        deleteSelectedEvents();
        break;
      case "calendar_delete_focused_item_command": {
        let focusedElement = document.commandDispatcher.focusedElement;
        if (focusedElement == TodayPane.agenda) {
          TodayPane.agenda.deleteSelectedItem(false);
        } else if (focusedElement && focusedElement.className == "calendar-task-tree") {
          deleteToDoCommand(false);
        } else if (this.isInMode("calendar")) {
          deleteSelectedEvents();
        }
        break;
      }
      case "calendar_new_todo_command":
        createTodoWithDialog(
          getSelectedCalendar(),
          null,
          null,
          null,
          cal.dtz.getDefaultStartDate(currentView().selectedDay)
        );
        break;
      case "calendar_new_todo_context_command": {
        let initialDate = currentView().selectedDateTime;
        if (!initialDate || initialDate.isDate) {
          initialDate = cal.dtz.getDefaultStartDate(currentView().selectedDay);
        }
        createTodoWithDialog(getSelectedCalendar(), null, null, null, initialDate);
        break;
      }
      case "calendar_new_todo_todaypane_command":
        createTodoWithDialog(
          getSelectedCalendar(),
          null,
          null,
          null,
          cal.dtz.getDefaultStartDate(TodayPane.start)
        );
        break;
      case "calendar_delete_todo_command":
        deleteToDoCommand();
        break;
      case "calendar_modify_todo_command":
        modifyTaskFromContext(cal.dtz.getDefaultStartDate(currentView().selectedDay));
        break;
      case "calendar_modify_todo_todaypane_command":
        modifyTaskFromContext(cal.dtz.getDefaultStartDate(TodayPane.start));
        break;

      case "calendar_new_calendar_command":
        cal.window.openCalendarWizard(window);
        break;
      case "calendar_edit_calendar_command":
        cal.window.openCalendarProperties(window, { calendar: getSelectedCalendar() });
        break;
      case "calendar_delete_calendar_command":
        promptDeleteCalendar(getSelectedCalendar());
        break;

      case "calendar_import_command":
        if (Services.prefs.getBoolPref("mail.import.in_new_tab")) {
          toImport("calendar");
        } else {
          loadEventsFromFile();
        }
        break;
      case "calendar_export_command":
        exportEntireCalendar();
        break;
      case "calendar_export_selection_command":
        saveEventsToFile(currentView().getSelectedItems());
        break;

      case "calendar_publish_selected_calendar_command":
        publishEntireCalendar(getSelectedCalendar());
        break;
      case "calendar_publish_calendar_command":
        publishEntireCalendar();
        break;
      case "calendar_publish_selected_events_command":
        publishCalendarData();
        break;

      case "calendar_reload_remote_calendars":
        cal.view.getCompositeCalendar(window).refresh();
        break;
      case "calendar_show_unifinder_command":
        toggleUnifinder();
        break;
      case "calendar_view_next_command":
        currentView().moveView(1);
        break;
      case "calendar_view_prev_command":
        currentView().moveView(-1);
        break;
      case "calendar_toggle_orientation_command":
        toggleOrientation();
        break;
      case "calendar_toggle_workdays_only_command":
        toggleWorkdaysOnly();
        break;

      case "calendar_day-view_command":
        switchCalendarView("day", true);
        break;
      case "calendar_week-view_command":
        switchCalendarView("week", true);
        break;
      case "calendar_multiweek-view_command":
        switchCalendarView("multiweek", true);
        break;
      case "calendar_month-view_command":
        switchCalendarView("month", true);
        break;
      case "calendar_attendance_command":
        // This command is actually handled inline, since it takes a value
        break;

      case "cmd_selectAll":
        if (this.todo_tasktree_focused) {
          getTaskTree().selectAll();
        } else if (this.isInMode("calendar")) {
          selectAllEvents();
        }
        break;
    }
  },

  onEvent(aEvent) {},

  isCalendarInForeground() {
    return gCurrentMode && gCurrentMode != "mail";
  },

  isInMode(mode) {
    switch (mode) {
      case "mail":
        return !this.isCalendarInForeground();
      case "calendar":
        return gCurrentMode && gCurrentMode == "calendar";
      case "task":
        return gCurrentMode && gCurrentMode == "task";
    }
    return false;
  },

  onSelectionChanged(aEvent) {
    let selectedItems = aEvent.detail;

    calendarUpdateDeleteCommand(selectedItems);
    calendarController.item_selected = selectedItems && selectedItems.length > 0;

    let selLength = selectedItems === undefined ? 0 : selectedItems.length;
    let selected_events_readonly = 0;
    let selected_events_requires_network = 0;
    let selected_events_invitation = 0;

    if (selLength > 0) {
      for (let item of selectedItems) {
        if (item.calendar.readOnly) {
          selected_events_readonly++;
        }
        if (
          item.calendar.getProperty("requiresNetwork") &&
          !item.calendar.getProperty("cache.enabled") &&
          !item.calendar.getProperty("cache.always")
        ) {
          selected_events_requires_network++;
        }

        if (cal.itip.isInvitation(item)) {
          selected_events_invitation++;
        } else if (item.organizer) {
          // If we are the organizer and there are attendees, then
          // this is likely also an invitation.
          let calOrgId = item.calendar.getProperty("organizerId");
          if (item.organizer.id == calOrgId && item.getAttendees().length) {
            selected_events_invitation++;
          }
        }
      }
    }

    calendarController.selected_events_readonly = selected_events_readonly == selLength;

    calendarController.selected_events_requires_network =
      selected_events_requires_network == selLength;
    calendarController.selected_events_invitation = selected_events_invitation == selLength;

    calendarController.updateCommands();
    calendarController2.updateCommands();
    document.commandDispatcher.updateCommands("mail-toolbar");
  },

  /**
   * Condition Helpers
   */

  // These attributes will be set up manually.
  item_selected: false,
  selected_events_readonly: false,
  selected_events_requires_network: false,
  selected_events_invitation: false,

  /**
   * Returns a boolean indicating if its possible to write items to any
   * calendar.
   */
  get writable() {
    return cal.manager.getCalendars().some(cal.acl.isCalendarWritable);
  },

  /**
   * Returns a boolean indicating if the application is currently in offline
   * mode.
   */
  get offline() {
    return Services.io.offline;
  },

  /**
   * Returns a boolean indicating whether there is at least one enabled
   * calendar that can be reloaded. Note: ICS calendars can have a network URL
   * or a file URL, but both are reloadable.
   */
  get has_enabled_reloadable_calendars() {
    return cal.manager
      .getCalendars()
      .some(
        calendar =>
          !calendar.getProperty("disabled") &&
          (calendar.type == "ics" || calendar.getProperty("requiresNetwork") !== false)
      );
  },

  /**
   * Returns a boolean indicating that there is only one calendar left.
   */
  get last_calendar() {
    return cal.manager.calendarCount < 2;
  },

  /**
   * Returns a boolean indicating that at least one of the items selected
   * in the current view has a writable calendar.
   */
  get selected_items_writable() {
    return (
      this.writable &&
      this.item_selected &&
      !this.selected_events_readonly &&
      (!this.offline || !this.selected_events_requires_network)
    );
  },

  /**
   * Returns a boolean indicating that tasks are selected.
   */
  get todo_items_selected() {
    let selectedTasks = getSelectedTasks();
    return selectedTasks.length > 0;
  },

  get todo_items_invitation() {
    let selectedTasks = getSelectedTasks();
    let selected_tasks_invitation = 0;

    for (let item of selectedTasks) {
      if (cal.itip.isInvitation(item)) {
        selected_tasks_invitation++;
      } else if (item.organizer) {
        // If we are the organizer and there are attendees, then
        // this is likely also an invitation.
        let calOrgId = item.calendar.getProperty("organizerId");
        if (item.organizer.id == calOrgId && item.getAttendees().length) {
          selected_tasks_invitation++;
        }
      }
    }

    return selectedTasks.length == selected_tasks_invitation;
  },

  /**
   * Returns a boolean indicating that at least one task in the selection is
   * on a calendar that is writable.
   */
  get todo_items_writable() {
    let selectedTasks = getSelectedTasks();
    for (let task of selectedTasks) {
      if (cal.acl.isCalendarWritable(task.calendar)) {
        return true;
      }
    }
    return false;
  },
};

/**
 * XXX This is a temporary hack so we can release 1.0b2. This will soon be
 * superseded by a new command controller architecture.
 */
var calendarController2 = {
  commands: new Set([
    "cmd_cut",
    "cmd_copy",
    "cmd_paste",
    "cmd_undo",
    "cmd_redo",
    "cmd_print",
    "button_print",
    "button_delete",
    "cmd_delete",
    "cmd_properties",
    "cmd_goForward",
    "cmd_goBack",
    "cmd_fullZoomReduce",
    "cmd_fullZoomEnlarge",
    "cmd_fullZoomReset",
    "cmd_showQuickFilterBar",
  ]),

  // These functions can use the same from the calendar controller for now.
  updateCommands: calendarController.updateCommands,
  supportsCommand: calendarController.supportsCommand,
  onEvent: calendarController.onEvent,

  isCommandEnabled(aCommand) {
    switch (aCommand) {
      // Thunderbird Commands
      case "cmd_cut":
        return calendarController.selected_items_writable;
      case "cmd_copy":
        return calendarController.item_selected;
      case "cmd_paste":
        return canPaste();
      case "cmd_undo":
        goSetMenuValue(aCommand, "valueDefault");
        return canUndo();
      case "cmd_redo":
        goSetMenuValue(aCommand, "valueDefault");
        return canRedo();
      case "button_delete":
      case "cmd_delete":
        return calendarController.isCommandEnabled("calendar_delete_focused_item_command");
      case "cmd_fullZoomReduce":
      case "cmd_fullZoomEnlarge":
      case "cmd_fullZoomReset":
        return calendarController.isInMode("calendar") && currentView().supportsZoom;
      case "cmd_properties":
        return false;
      case "cmd_showQuickFilterBar":
        return calendarController.isInMode("task");
      default:
        return true;
    }
  },

  doCommand(aCommand) {
    if (!this.isCommandEnabled(aCommand)) {
      // doCommand is triggered for cmd_cut even if the command is disabled
      // so we bail out here
      return;
    }
    switch (aCommand) {
      case "cmd_cut":
        cutToClipboard();
        break;
      case "cmd_copy":
        copyToClipboard();
        break;
      case "cmd_paste":
        pasteFromClipboard();
        break;
      case "cmd_undo":
        undo();
        break;
      case "cmd_redo":
        redo();
        break;
      case "button_print":
      case "cmd_print":
        printCalendar();
        break;
      // Thunderbird commands
      case "cmd_goForward":
        currentView().moveView(1);
        break;
      case "cmd_goBack":
        currentView().moveView(-1);
        break;
      case "cmd_fullZoomReduce":
        currentView().zoomIn();
        break;
      case "cmd_fullZoomEnlarge":
        currentView().zoomOut();
        break;
      case "cmd_fullZoomReset":
        currentView().zoomReset();
        break;
      case "cmd_showQuickFilterBar":
        document.getElementById("task-text-filter-field").select();
        break;

      case "button_delete":
      case "cmd_delete":
        calendarController.doCommand("calendar_delete_focused_item_command");
        break;
    }
  },
};

/**
 * Inserts the command controller into the document. Make sure that it is
 * inserted before the conflicting Thunderbird command controller.
 */
function injectCalendarCommandController() {
  // This is the third-highest priority controller. It's preceded by
  // DefaultController and tabmail.tabController, and followed by
  // calendarController, then whatever Gecko adds.
  top.controllers.insertControllerAt(2, calendarController);
  document.commandDispatcher.updateCommands("calendar_commands");
}

/**
 * Remove the calendar command controller from the document.
 */
function removeCalendarCommandController() {
  top.controllers.removeController(calendarController);
}

/**
 * Handler function to set up the item context menu, depending on the given
 * items. Changes the delete menuitem to fit the passed items.
 *
 * @param  {DOMEvent}              aEvent   The DOM popupshowing event that is
 *                                   triggered by opening the context menu
 * @param  {Array.<calIItemBase>}  aItems   An array of items (usually the selected
 *                                            items) to adapt the context menu for
 * @returns {boolean} True, to show the popup menu.
 */
function setupContextItemType(aEvent, aItems) {
  function adaptModificationMenuItem(aMenuItemId, aItemType) {
    let menuItem = document.getElementById(aMenuItemId);
    if (menuItem) {
      menuItem.setAttribute("label", cal.l10n.getCalString(`delete${aItemType}Label`));
      menuItem.setAttribute("accesskey", cal.l10n.getCalString(`delete${aItemType}Accesskey`));
    }
  }
  if (aItems.some(item => item.isEvent()) && aItems.some(item => item.isTodo())) {
    aEvent.target.setAttribute("type", "mixed");
    adaptModificationMenuItem("calendar-item-context-menu-delete-menuitem", "Item");
  } else if (aItems.length && aItems[0].isEvent()) {
    aEvent.target.setAttribute("type", "event");
    adaptModificationMenuItem("calendar-item-context-menu-delete-menuitem", "Event");
  } else if (aItems.length && aItems[0].isTodo()) {
    aEvent.target.setAttribute("type", "todo");
    adaptModificationMenuItem("calendar-item-context-menu-delete-menuitem", "Task");
  } else {
    aEvent.target.removeAttribute("type");
    adaptModificationMenuItem("calendar-item-context-menu-delete-menuitem", "Item");
  }

  let menu = document.getElementById("calendar-item-context-menu-attendance-menu");
  setupAttendanceMenu(menu, aItems);
  return true;
}

/**
 * Tests whether the items currently selected can be edited in the event dialog.
 * Invitations are not considered editable here.
 */
function canEditSelectedItems() {
  let items = currentView().getSelectedItems();
  return items.every(item => {
    let calendar = item.calendar;
    return (
      cal.acl.isCalendarWritable(calendar) &&
      cal.acl.userCanModifyItem(item) &&
      calendar.supportsScheduling &&
      !calendar.getSchedulingSupport().isInvitation(item)
    );
  });
}

/**
 * Returns the selected items, based on which mode we are currently in and what task tree is focused.
 */
function getSelectedItems() {
  if (calendarController.todo_tasktree_focused) {
    return getSelectedTasks();
  }

  return currentView().getSelectedItems();
}

/**
 * Deletes the selected items, based on which mode we are currently in and what task tree is focused
 */
function deleteSelectedItems() {
  if (calendarController.todo_tasktree_focused) {
    deleteToDoCommand();
  } else if (calendarController.isInMode("calendar")) {
    deleteSelectedEvents();
  }
}

/**
 * Checks if any calendar allows new events and tasks to be added, otherwise
 * disables the creation buttons.
 */
function calendarUpdateNewItemsCommand() {
  // Re-calculate command status.
  let calendars = cal.manager
    .getCalendars()
    .filter(cal.acl.isCalendarWritable)
    .filter(cal.acl.userCanAddItemsToCalendar);

  CalendarNewEventsCommandEnabled = calendars.some(cal.item.isEventCalendar);
  CalendarNewTasksCommandEnabled = calendars.some(cal.item.isTaskCalendar);

  [
    "calendar_new_event_command",
    "calendar_new_event_context_command",
    "calendar_new_event_todaypane_command",
    "calendar_new_todo_command",
    "calendar_new_todo_context_command",
    "calendar_new_todo_todaypane_command",
    "calendar_toggle_tasks_in_view_command",
  ].forEach(goUpdateCommand);

  document.getElementById("sidePanelNewEvent").disabled = !CalendarNewEventsCommandEnabled;
  document.getElementById("sidePanelNewTask").disabled = !CalendarNewTasksCommandEnabled;
}

function calendarUpdateDeleteCommand(selectedItems) {
  let oldValue = CalendarDeleteCommandEnabled;
  CalendarDeleteCommandEnabled = selectedItems.length > 0;

  /* we must disable "delete" when at least one item cannot be deleted */
  for (let item of selectedItems) {
    if (!cal.acl.userCanDeleteItemsFromCalendar(item.calendar)) {
      CalendarDeleteCommandEnabled = false;
      break;
    }
  }

  if (CalendarDeleteCommandEnabled != oldValue) {
    [
      "calendar_delete_event_command",
      "calendar_delete_todo_command",
      "calendar_delete_focused_item_command",
      "button_delete",
      "cmd_delete",
    ].forEach(goUpdateCommand);
  }
}

/**
 * Loads the printing template into a hidden browser then starts the printing
 * process for that browser.
 */
async function printCalendar() {
  // Ensure the printing of this file will be detected by calPrintUtils.jsm.
  cal.print.ensureInitialized();

  await PrintUtils.loadPrintBrowser("chrome://calendar/content/printing-template.html");
  PrintUtils.startPrintWindow(PrintUtils.printBrowser.browsingContext, {});
}
/**
 * Toggle the visibility of the calendars list.
 *
 * @param {Event} event - The click DOMEvent.
 */
function toggleVisibilityCalendarsList(event) {
  document.getElementById("calendar-list-inner-pane").togglePane(event);
}