* Copyright 2010 Google Inc.

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

*      http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS-IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

* Page to enter content items.

* TODO: convert to using UiBinder.

*/

  private static final int MAP_HEIGHT = 256;

  private static final int MAP_WIDTH = 256;

  private static final int MAP_ZOOM = 10;

  @SuppressWarnings("deprecation")

  private static final String DEFAULT_TIME_STRING = DateUtil.formatTime(new Date(0, 0, 1, 12, 0));

 

  private static final int LONG_TEXTBOX_VISIBLE_LENGTH = 60;

  private static final ContentManagerMessages msgs = GWT.create(ContentManagerMessages.class);

 

  /**

   * Create a remote service proxy to talk to the server-side content persisting service.

   */

  private final ContentRpcServiceAsync contentRpcService = GWT.create(ContentRpcService.class);

 

  /**

   * Create a remote service proxy to talk to the server-side living story persisting service.

   */

  private final LivingStoryRpcServiceAsync livingStoryService

      = GWT.create(LivingStoryRpcService.class);

 

  private DeckPanel contentPanel;

 

  private EnumDropdown<ContentItemType> contentItemTypeSelector;

  private DeckPanel specialAttributesPanel;

  private Label contentTitle;

  private RichTextEditor contentEditor;

  private Label contentItemIdLabel;

  private Label timestamp;

  private CoordinatedLivingStorySelector livingStorySelector;

  private ChangeHandler livingStorySelectionHandler;

  private EnumDropdown<Importance> importanceSelector;

  private ContentItemListBox contentItemListBox;

  // Contributor management stuff

  private HTML contributorListHtml;

  private Label clearContributorsControl;

  private PlayerSuggestAndAddPanel contributorSuggestPanel;

  private Map<Long, String> currentContributorIdsToNamesMap;

  private Map<Long, PlayerContentItem> unassignedPlayersIdToContentItemMap;

 

  private ItemList<Theme> themeListBox;

 

  // Location related stuff

  private boolean mapsKeyExists;

  private String mapsKey;

  private TextBox latitudeTextBox;

  private TextBox longitudeTextBox;

  private TextArea locationDescriptionTextArea;

  private RadioButton useDisplayedLocation;

  private RadioButton useAlternateLocation;

  private TextBox alternateTextBox;

  private RadioButton useManualLatLong;

  private Button geocodeButton;

  private Label geocoderStatus;

  private MapWidget map;

  private Marker mapMarker;

 

  // Source related stuff

  private TextBox sourceDescriptionBox;

  private SingleContentItemSelectionPanel sourceContentItemSelector;

  private DockPanel pickerPanel;

  private SuggestionAwareContentItemListBox linkedContentItemSelector;

  private ListBox selectedLinkedContentItems;

  private Label advisoryLabel;

 

  private Label publishStateLabel;

  private SaveControlsWidgetGroup topSaveControls = new SaveControlsWidgetGroup();

  private SaveControlsWidgetGroup bottomSaveControls = new SaveControlsWidgetGroup();

  private SimplePanel previewPanel;

 

  /*** Event specific attributes ***/

  private TextBox dateTrigger;

  private PopupPanel datePopup;

  private DatePicker startDatePicker;

  private TextBox startTime;

  private CheckBox hasSeparateEndDate;

  private DatePicker endDatePicker;

  private TextBox endTime;

  private TextBox updateEditor;

  private RichTextEditor summaryEditor;

 

  /*** Player specific attributes ***/

  private TextBox nameTextBox;

  private TextBox aliasesTextBox;

  private EnumDropdown<PlayerType> playerTypeSelector;

  private SingleContentItemSelectionPanel photoSelector;

 

  /*** Story Player specific attributes ***/

  private FlowPanel parentPlayerDisplayPanel;

  private Label changeParentLink;

  private Label parentSelectionInstructions;

  private PlayerSuggestAndAddPanel generalPlayerSuggestPanel;

  private PlayerContentItem parentPlayer;

 

  private DeckPanel playerAttributesPanel;

 

  /*** Asset specific attributes ***/

  private EnumDropdown<AssetType> assetTypeSelector;

  private Label previewUrlLabel;

  private TextBox previewUrlTextBox;

  private Label captionLabel;

  private TextArea captionTextArea;

  private Label imageUrlLabel;

  private TextBox imageUrlTextBox;

 

  /*** Narrative specific attributes ***/

  private TextBox headlineTextBox;

  private EnumDropdown<NarrativeType> narrativeTypeSelector;

  private DateBox narrativeDateBox;

  private RichTextEditor narrativeSummaryTextArea;

 

  /*** Background specific attributes ***/

  private TextBox conceptNameTextBox;

 

  private Map<ContentItemType, Integer> contentItemTypeToEditorPanelMap =

      new HashMap<ContentItemType, Integer>();

 

  public ContentItemManager() {

    mapsKey = LivingStoryData.getMapsKey();

    mapsKeyExists = mapsKey != null && !mapsKey.isEmpty();

   

    HorizontalPanel container = new HorizontalPanel();

   

    container.add(createControlsPanel());

    container.add(createContentPanel());

   

    // Event handlers

    createLivingStorySelectionHandler();

    createContentItemTypeSelectionHandler();

    createContentItemSelectionHandler();

    createSaveDeleteHandlers(topSaveControls);

    createSaveDeleteHandlers(bottomSaveControls);

    initWidget(container);

  }

  private Widget createControlsPanel() {

    VerticalPanel controlsPanel = new VerticalPanel();

    controlsPanel.add(createLivingStorySelector());

    controlsPanel.add(createNewContentItemButton());

    controlsPanel.add(createContentItemListBox());

    return controlsPanel;

  }

 

  private Widget createLivingStorySelector() {

    // Our livingStorySelector extends the superclass slightly, in that when the list

    // of living stories is successfully loaded up, this triggers the list boxes

    // to load the content items and retrieve the themes for the now-selected living story.

    livingStorySelector = new CoordinatedLivingStorySelector(livingStoryService, true) {

      @Override

      public void onSuccessNextStep() {

        super.onSuccessNextStep();

        if (hasSelection()) {

          LivingStoryData.setLivingStoryId(getSelectedLivingStoryId());

          contentItemListBox.loadItemsForLivingStory(getSelectedLivingStoryId());

          linkedContentItemSelector.loadItemsForLivingStory(getSelectedLivingStoryId());

          themeListBox.refresh();

        }

      }

    };

    return livingStorySelector;

  }

 

  private Widget createNewContentItemButton() {

    Button newContentItemButton = new Button("New Content Entity");

    newContentItemButton.addClickHandler(new ClickHandler() {

      @Override

      public void onClick(ClickEvent event) {

        createOrChangeContentItem(new DefaultContentItem(

            null, livingStorySelector.getSelectedLivingStoryId()), false, null);

      }

    });

    return newContentItemButton;

  }

 

  /**

   * Create a list box for displaying all the content items for the selected living story so that

   * the user can select one to edit.

   */

  private Widget createContentItemListBox() {

    contentItemListBox = new ContentItemListBox(false);

    contentItemListBox.setVisibleItemCount(15);

    contentItemListBox.addFilterChangeHandler(new ChangeHandler() {

      @Override

      public void onChange(ChangeEvent event) {

        contentPanel.showWidget(0);

      }

    });

    return contentItemListBox;

  }

  private Widget createContentPanel() {

    contentPanel = new DeckPanel();

   

    Label chooseContentItemLabel = new Label("Choose something to edit, or create new content.");

    chooseContentItemLabel.setStylePrimaryName("title");

    DOM.setStyleAttribute(chooseContentItemLabel.getElement(), "marginTop", "5em");

    contentPanel.add(chooseContentItemLabel);

   

    VerticalPanel editorContentPanel = new VerticalPanel();

    editorContentPanel.add(createSaveDeletePanel(topSaveControls));

    editorContentPanel.add(createEditorPanel());

    editorContentPanel.add(createSaveDeletePanel(bottomSaveControls));

    contentPanel.add(editorContentPanel);

   

    Label previewTitle = new Label("Preview");

    previewTitle.setStylePrimaryName("header");

    previewPanel = new SimplePanel();

    previewPanel.setStylePrimaryName("previewPanel");

    editorContentPanel.add(previewTitle);

    editorContentPanel.add(previewPanel);   

    contentPanel.showWidget(0);

    return contentPanel;

  }

  /**

   * Create a panel for showing the text area to enter the HTML for a content piece; selectors

   * to enter its priority and type; and the timestamp.

   */

  private Widget createEditorPanel() {

    contentItemIdLabel = new Label();

    HorizontalPanel contentItemIdPanel = new HorizontalPanel();

    contentItemIdPanel.setSpacing(2);

    contentItemIdPanel.add(new Label("Id:"));

    contentItemIdPanel.add(contentItemIdLabel);

   

    contentEditor = new RichTextEditor();

   

    timestamp = new Label();

    HorizontalPanel timestampPanel = new HorizontalPanel();

    timestampPanel.setSpacing(2);

    timestampPanel.add(new Label("Publish time:"));

    timestampPanel.add(timestamp);

   

    publishStateLabel = new Label();

   

    contentTitle = new Label("Content");

    contentTitle.setStylePrimaryName("header");

   

    VerticalPanel editorPanel = new VerticalPanel();

    editorPanel.add(contentItemIdPanel);

    editorPanel.add(createContentItemTypeSelectorPanel());

    editorPanel.add(createSpecialAttributesPanel());

    editorPanel.add(contentTitle);

    editorPanel.add(contentEditor);

    editorPanel.add(createImportanceSelectorPanel());

    editorPanel.add(createContributorSelector());

    editorPanel.add(createAdditionalPropertiesPanel());

    editorPanel.add(createLinkedContentItemsPicker());

    editorPanel.add(publishStateLabel);

    editorPanel.add(timestampPanel);

    return editorPanel;

  }

 

  /**

   * Create a panel for the content priority/importance selector.

   */

  private Widget createImportanceSelectorPanel() {

    Label enterImportanceLabel = new Label("Select priority:");

   

    importanceSelector = EnumDropdown.newInstance(Importance.class);

    importanceSelector.selectConstant(Importance.MEDIUM);

   

    HorizontalPanel importanceSelectorPanel = new HorizontalPanel();

    importanceSelectorPanel.add(enterImportanceLabel);

    importanceSelectorPanel.add(importanceSelector);

    return importanceSelectorPanel;

  }

 

  /**

   * Create a selector for the content type.

   */

  private Widget createContentItemTypeSelectorPanel() {

    Label enterTypeLabel = new Label("Select content type:");

   

    contentItemTypeSelector = EnumDropdown.newInstance(ContentItemType.class);

   

    HorizontalPanel typeSelectorPanel = new HorizontalPanel();

    DOM.setStyleAttribute(typeSelectorPanel.getElement(), "paddingBottom", "10px");

    typeSelectorPanel.add(enterTypeLabel);

    typeSelectorPanel.add(contentItemTypeSelector);

    return typeSelectorPanel;

  }

 

  private Widget createAdditionalPropertiesPanel() {

    VerticalPanel additionalPanel = new VerticalPanel();

    additionalPanel.setWidth("100%");

   

    Label title = new Label("Additional Properties");

    title.setStylePrimaryName("header");

   

    additionalPanel.add(title);

    additionalPanel.add(createThemeListBox());

    if (mapsKeyExists) {

      additionalPanel.add(createLocationPanel());

    }

    additionalPanel.add(createSourceInformationPanel());

    return additionalPanel;

  }

 

  /**

   * Create a multiselect list box for displaying all the themes that a content item is a part of.

   */

  private Widget createThemeListBox() {

    themeListBox = new ItemList<Theme>(true, false) {

      @Override

      public void loadItems() {

        try {

          Long livingStoryId = livingStorySelector.getSelectedLivingStoryId();

          if (livingStoryId != null) {

            livingStoryService.getThemesForLivingStory(

                livingStoryId, getCallback(new ThemeListAdaptor()));

          }

        } catch (UnsupportedOperationException ignored) {

        }

      }

    };

    themeListBox.setVisibleItemCount(5);

    DisclosurePanel themesPanel = new DisclosurePanel("Themes");

    themesPanel.add(themeListBox);

    return themesPanel;

  }

  private class ThemeListAdaptor extends ItemList.ListItemAdapter<Theme> {

    @Override

    public String getItemText(Theme theme) {

      return theme.getName();

    }

   

    @Override

    public String getItemValue(Theme theme) {

      return Long.toString(theme.getId());

    }

  }

 

  private Widget createLocationPanel() {

    final VerticalPanel locationPanel = new VerticalPanel();

   

    // show a map based on geocoded or manually-inputted lat-long combination

   

    HorizontalPanel descriptionPanel = new HorizontalPanel();

    descriptionPanel.add(new HTML("Location name (displayed to readers):"));

    locationDescriptionTextArea = new TextArea();

    locationDescriptionTextArea.setCharacterWidth(50);

    locationDescriptionTextArea.setHeight("60px");

    descriptionPanel.add(locationDescriptionTextArea);

    Label geocodingOptions = new Label("Geocode based on:");

    useDisplayedLocation = new RadioButton("geoGroup", "The displayed location name");

    useDisplayedLocation.setValue(true);

    useAlternateLocation = new RadioButton("geoGroup",

        "An alternate location that geocodes better: ");

    alternateTextBox = new TextBox();

    alternateTextBox.setEnabled(false);

    HorizontalPanel alternatePanel = new HorizontalPanel();

    alternatePanel.add(useAlternateLocation);

    alternatePanel.add(alternateTextBox);

    useManualLatLong = new RadioButton("geoGroup",

        "Manually entered latitude and longitude numbers (enter these below)");

   

    HorizontalPanel latLongPanel = new HorizontalPanel();

    latLongPanel.add(new HTML("Latitude:&nbsp;"));

    latitudeTextBox = new TextBox();

    latitudeTextBox.setEnabled(false);

    latLongPanel.add(latitudeTextBox);

    latLongPanel.add(new HTML("&nbsp;Longitude:&nbsp;"));

    longitudeTextBox = new TextBox();

    longitudeTextBox.setEnabled(false);

    latLongPanel.add(longitudeTextBox);

    HorizontalPanel buttonPanel = new HorizontalPanel();

    geocodeButton = new Button("Geocode location");

    geocodeButton.setEnabled(false);

    buttonPanel.add(geocodeButton);

    geocoderStatus = new Label("");

    buttonPanel.add(geocoderStatus);   

   

    AjaxLoaderOptions options = AjaxLoaderOptions.newInstance();

    options.setOtherParms(mapsKey + "&sensor=false");

    AjaxLoader.loadApi("maps", "2", new Runnable() {

      @Override

      public void run() {

        map = new MapWidget();

        map.setSize(MAP_WIDTH + "px", MAP_HEIGHT + "px");

        map.addControl(new SmallMapControl());

        map.setDoubleClickZoom(true);

        map.setDraggable(true);

        map.setScrollWheelZoomEnabled(true);

        map.setZoomLevel(MAP_ZOOM);

        map.setVisible(false);

        locationPanel.add(map);

        createLocationHandlers();

      }

    }, options);

    locationPanel.add(descriptionPanel);

    locationPanel.add(geocodingOptions);

    locationPanel.add(useDisplayedLocation);

    locationPanel.add(alternatePanel);

    locationPanel.add(useManualLatLong);

    locationPanel.add(latLongPanel);

    locationPanel.add(buttonPanel);

    locationPanel.add(

        new Label("Tip: once the map is visible, right-click a point on the map to indicate that"

            + " this is the precise location you want"));

    DisclosurePanel locationZippy = new DisclosurePanel("Location");

    locationZippy.add(locationPanel);

    return locationZippy;

  }

 

  private Widget createSourceInformationPanel() {

    VerticalPanel panel = new VerticalPanel();

    panel.add(new Label("You can enter either one or both of these fields."));

   

    sourceContentItemSelector = new SingleContentItemSelectionPanel();

    sourceDescriptionBox = new TextBox();

    sourceDescriptionBox.setVisibleLength(LONG_TEXTBOX_VISIBLE_LENGTH);

   

    Grid grid = new Grid(2, 2);

    grid.setWidget(0, 0, new Label("Content item that contains source information:"));

    grid.setWidget(0, 1, sourceContentItemSelector);

    grid.setWidget(1, 0, new Label("Description of source material:"));

    grid.setWidget(1, 1, sourceDescriptionBox);

    panel.add(grid);

   

    DisclosurePanel sourcePanel = new DisclosurePanel("Source Information");

    sourcePanel.add(panel);

    return sourcePanel;

  }

 

  private Widget createContributorSelector() {

    currentContributorIdsToNamesMap = new HashMap<Long, String>();

   

    Label title = new Label("Contributors");

    title.setStylePrimaryName("header");

   

    contributorListHtml = new HTML();

   

    clearContributorsControl = new Label("Clear current contributors");

    clearContributorsControl.setStylePrimaryName("primaryLink");

    clearContributorsControl.addClickHandler(new ClickHandler() {

      @Override

      public void onClick(ClickEvent event) {

        currentContributorIdsToNamesMap.clear();

        formatCurrentContributorList();

      }

    });

   

    Label instructions = new Label("Type a contributor name into the box below to add an existing"

            + " contributor to the story, or to create and add a new contributor on-the-fly:");

       

    contributorSuggestPanel = new PlayerSuggestAndAddPanel(contentRpcService, true,

        new AsyncCallback<BaseContentItem>() {

      @Override

      public void onFailure(Throwable caught) {}

         

      @Override

      public void onSuccess(BaseContentItem result) {

        PlayerContentItem contributor = (PlayerContentItem)result;

        addUnassignedPlayer(contributor);

        currentContributorIdsToNamesMap.put(result.getId(), contributor.getName());

        formatCurrentContributorList();

      }

    });

   

    if (unassignedPlayersIdToContentItemMap == null) {

      // Asynchronously query for the contributor names:

      contentRpcService.getUnassignedPlayers(new AsyncCallback<List<PlayerContentItem>>() {

        @Override

        public void onFailure(Throwable caught) {

          contributorListHtml.setText("Could not retrieve list of available contributors");

        }

        @Override

        public void onSuccess(List<PlayerContentItem> results) {

          unassignedPlayersIdToContentItemMap = new HashMap<Long, PlayerContentItem>();

          populateUnassignedPlayersMap(results);

          populatePlayerSuggestPanel(contributorSuggestPanel);

        }

      });

    } else {

      populatePlayerSuggestPanel(contributorSuggestPanel);

    }

   

    FlowPanel contributorsPanel = new FlowPanel();

    contributorsPanel.add(title);

    contributorsPanel.add(contributorListHtml);

    contributorsPanel.add(clearContributorsControl);

    contributorsPanel.add(instructions);

    contributorsPanel.add(contributorSuggestPanel);

    return contributorsPanel;

  }

  private void formatCurrentContributorList() {

    boolean hasContributors = !currentContributorIdsToNamesMap.isEmpty();

    if (!hasContributors) {

      contributorListHtml.setHTML("<em>No contributors yet added</em>");

    } else {

      StringBuilder contributorBuilder = new StringBuilder("<ul>");

      for (String contributorName : currentContributorIdsToNamesMap.values()) {

        contributorBuilder.append("<li>").append(contributorName).append("</li>");

      }

      contributorBuilder.append("</ul>");

      contributorListHtml.setHTML(contributorBuilder.toString());

    }

    clearContributorsControl.setVisible(hasContributors);

  }

  private Widget createLinkedContentItemsPicker() {

    pickerPanel = new DockPanel();

    pickerPanel.setVerticalAlignment(HorizontalPanel.ALIGN_MIDDLE);

    Label title = new Label("Linked Items");

    title.setStylePrimaryName("header");

    Label instructions = new Label("Select items from the left list and click on the arrow in the" +

        " middle to move them to the right list. The items in the right list will be linked to" +

        " the current item.");

    instructions.setWidth("500px");

    pickerPanel.add(title, DockPanel.NORTH);

    pickerPanel.add(instructions, DockPanel.NORTH);

    linkedContentItemSelector = new SuggestionAwareContentItemListBox(true);

    linkedContentItemSelector.setVisibleItemCount(10);

       

    advisoryLabel = new Label("The system has identified one or more players"

        + " that we suggest adding to the list of linked entities. These suggestions are now shown"

        + " in the area above. You may change the filter settings to revisit other linkable"

        + " entities, and may later return to these suggestions, so long as you continue to"

        + " edit only this content entity without switching to another.");

    advisoryLabel.setStylePrimaryName("serverResponseLabelSuccess");

    advisoryLabel.setWidth("475px");

    hideSuggestions();

    pickerPanel.add(advisoryLabel, DockPanel.SOUTH);

   

    FlowPanel linkedPanel = new FlowPanel();

    linkedPanel.add(linkedContentItemSelector);

   

    pickerPanel.add(linkedPanel, DockPanel.WEST);

   

    Button addButton = new Button("&raquo;");

    addButton.addClickHandler(new ClickHandler() {

      @Override

      public void onClick(ClickEvent event) {

        List<String> selectedItems = linkedContentItemSelector.getSelectedItems();

        List<String> selectedValues = linkedContentItemSelector.getSelectedValues();

        for (int i = 0; i < selectedItems.size(); i++) {

          selectedLinkedContentItems.addItem(selectedItems.get(i), selectedValues.get(i));

        }

      }

    });

   

    Button removeButton = new Button("&laquo;");

    removeButton.addClickHandler(new ClickHandler() {

      @Override

      public void onClick(ClickEvent event) {

        for (int i = selectedLinkedContentItems.getItemCount() - 1; i >= 0; i--) {

          if (selectedLinkedContentItems.isItemSelected(i)) {

            selectedLinkedContentItems.removeItem(i);

          }

        }

      }

    });

   

    VerticalPanel buttonPanel = new VerticalPanel();

    buttonPanel.add(addButton);

    buttonPanel.add(removeButton);

    pickerPanel.add(buttonPanel, DockPanel.CENTER);

   

    selectedLinkedContentItems = new ListBox(true);

    selectedLinkedContentItems.setVisibleItemCount(10);

   

    VerticalPanel selectedPanel = new VerticalPanel();

    selectedPanel.add(new Label("Selected for linking:"));

    selectedPanel.add(selectedLinkedContentItems);

   

    pickerPanel.add(selectedPanel, DockPanel.EAST);

    return pickerPanel;

  }

 

  private Widget createSpecialAttributesPanel() {

    specialAttributesPanel = new DeckPanel();

   

    specialAttributesPanel.add(createEventAttributesPanel());

    contentItemTypeToEditorPanelMap.put(ContentItemType.EVENT, 0);

   

    specialAttributesPanel.add(createAssetAttributesPanel());

    contentItemTypeToEditorPanelMap.put(ContentItemType.ASSET, 1);

   

    playerAttributesPanel = new DeckPanel();

    playerAttributesPanel.add(createStoryPlayerAttributesPanel());

    playerAttributesPanel.add(createPlayerAttributesPanel());

    playerAttributesPanel.showWidget(0);

    specialAttributesPanel.add(playerAttributesPanel);

    contentItemTypeToEditorPanelMap.put(ContentItemType.PLAYER, 2);

    specialAttributesPanel.add(createNarrativeAttributesPanel());

    contentItemTypeToEditorPanelMap.put(ContentItemType.NARRATIVE, 3);

   

    specialAttributesPanel.add(createBackgroundAttributesPanel());

    contentItemTypeToEditorPanelMap.put(ContentItemType.BACKGROUND, 4);

   

    specialAttributesPanel.showWidget(0);

    return specialAttributesPanel;

  }

 

  private Widget createEventAttributesPanel() {

    dateTrigger = new TextBox();

    dateTrigger.setVisibleLength(LONG_TEXTBOX_VISIBLE_LENGTH);

    dateTrigger.setReadOnly(true);

    dateTrigger.setStylePrimaryName("dateTriggerBox");

   

    createDatePickerPanel();

   

    updateEditor = new TextBox();

    updateEditor.setVisibleLength(LONG_TEXTBOX_VISIBLE_LENGTH);

    summaryEditor = new RichTextEditor();

    Label updateTitle = new Label("Update");

    updateTitle.setStylePrimaryName("header");

   

    Label summaryTitle = new Label("Summary");

    summaryTitle.setStylePrimaryName("header");

   

    VerticalPanel eventPanel = new VerticalPanel();

    eventPanel.add(new Label("Event Date:"));

    eventPanel.add(dateTrigger);

    eventPanel.add(updateTitle);

    eventPanel.add(updateEditor);

    eventPanel.add(summaryTitle);

    eventPanel.add(summaryEditor);

    dateTrigger.addFocusHandler(new FocusHandler() {

      @Override

      public void onFocus(FocusEvent event) {

        datePopup.showRelativeTo(dateTrigger);

      }

    });

    dateTrigger.addClickHandler(new ClickHandler() {

      @Override

      public void onClick(ClickEvent event) {

        datePopup.showRelativeTo(dateTrigger);

      }

    });

   

    return eventPanel;

  }

 

  /** creates a panel of datePickers in a popup, including setting up appropriate event handling.*/

  private Widget createDatePickerPanel() {

    datePopup = new PopupPanel(false /* doesn't close if you click away */, true /* modal */);

    // TODO: Make it possible for the user to cancel, either by clicking away from

    // the popup panel or by hitting an explicit cancel button.

    startDatePicker = new DatePicker();

    startTime = new TextBox();

    hasSeparateEndDate = new CheckBox("Event has a separate end date & time");

    endDatePicker = new DatePicker();

    endTime = new TextBox();

    endTime.setEnabled(false);

   

    Grid table = new Grid(5, 2);

    table.setWidget(1, 0, new Label("Start date:"));

    table.setWidget(2, 0, startDatePicker);

    table.setWidget(3, 0, new Label("Start time:"));

    table.setWidget(4, 0, startTime);

    table.setWidget(0, 1, hasSeparateEndDate);

    table.setWidget(1, 1, new Label("End date:"));

    table.setWidget(2, 1, endDatePicker);

    table.setWidget(3, 1, new Label("End time:"));

    table.setWidget(4, 1, endTime);

    Button okButton = new Button("OK");

    final InlineLabel problemLabel = new InlineLabel("");

    problemLabel.setStylePrimaryName("serverResponseLabelError");

    FlowPanel panel = new FlowPanel();

    panel.add(table);

    panel.add(new Label("Event time may be blank, or should be entered as, e.g., 3:00 PM."));

    panel.add(okButton);

    panel.add(problemLabel);

   

    hasSeparateEndDate.addValueChangeHandler(new ValueChangeHandler<Boolean> () {

      @Override

      public void onValueChange(ValueChangeEvent<Boolean> event) {

        boolean isChecked = event.getValue().booleanValue();

        // endDatePicker.setEnabled(isChecked);  -- if only the API supported it. :-(

        endTime.setEnabled(isChecked);

      }

    });

    okButton.addClickHandler(new ClickHandler() {

      @Override

      public void onClick(ClickEvent event) {

        Date endDateTime = getEndDateTime();

        if (endDateTime != null && endDateTime.before(getStartDateTime())) {

          problemLabel.setText("End date/time cannot be before start date/time");

        } else {

          problemLabel.setText("");

          datePopup.hide();

          setDateTriggerText();

        }

      }

    });

   

    datePopup.setWidget(panel);

    return datePopup;

  }

  private void setDateTriggerText() {

    String dateString = DateUtil.formatDateTime(getStartDateTime());

   

    Date endDateTime = getEndDateTime();

    if (endDateTime != null) {

      dateString = msgs.dateRange(dateString, DateUtil.formatDateTime(endDateTime));

    }

    dateTrigger.setText(dateString);

  }

  private Date getStartDateTime() {

    return getDateTimeImpl(startDatePicker, startTime);

  }

 

  private Date getEndDateTime() {

    return hasSeparateEndDate.getValue() ? getDateTimeImpl(endDatePicker, endTime) : null;

  }

 

  private Date getDateTimeImpl(DatePicker picker, TextBox textBox) {

    Date ret = picker.getValue();

    String text = textBox.getText();

    if (text.isEmpty()) {

      text = DEFAULT_TIME_STRING;

    }

    DateUtil.parseTime(text, ret);

    return ret;

  }

  private Widget createPlayerAttributesPanel() {

    nameTextBox = new TextBox();

    aliasesTextBox = new TextBox();

    playerTypeSelector = EnumDropdown.newInstance(PlayerType.class);

    photoSelector = new SingleContentItemSelectionPanel();

   

    Grid generalPlayerAttributesPanel = new Grid(4, 2);

    generalPlayerAttributesPanel.setWidget(0, 0, new Label("Player name:"));

    generalPlayerAttributesPanel.setWidget(0, 1, nameTextBox);

    generalPlayerAttributesPanel.setWidget(1, 0, new Label("Aliases:"));

    generalPlayerAttributesPanel.setWidget(1, 1, aliasesTextBox);

    generalPlayerAttributesPanel.setWidget(2, 0, new Label("Player type:"));

    generalPlayerAttributesPanel.setWidget(2, 1, playerTypeSelector);

    generalPlayerAttributesPanel.setWidget(3, 0, new Label("Photo:"));

    generalPlayerAttributesPanel.setWidget(3, 1, photoSelector);

    return generalPlayerAttributesPanel;

  }

 

  private Widget createStoryPlayerAttributesPanel() {

    Label title = new Label("Parent player entity");

    title.setStylePrimaryName("header");

   

    parentPlayerDisplayPanel = new FlowPanel();

    parentPlayerDisplayPanel.setWidth("450px");

    changeParentLink = new Label("Change parent");

    changeParentLink.setStylePrimaryName("primaryLink");

   

    HorizontalPanel parentPlayerDisplayAndChangeLinkPanel = new HorizontalPanel();

    parentPlayerDisplayAndChangeLinkPanel.add(parentPlayerDisplayPanel);

    parentPlayerDisplayAndChangeLinkPanel.add(changeParentLink);

   

    parentSelectionInstructions = new Label("Type a player name into the box below. Select from the"

        + " list to add an existing player to the story. To add a new player to the story that"

        + " doesn't exist yet, type their name into the box and click on the button.");

    parentSelectionInstructions.setWidth("450px");

   

    generalPlayerSuggestPanel = new PlayerSuggestAndAddPanel(contentRpcService, false,

        new AsyncCallback<BaseContentItem>() {

      @Override

      public void onFailure(Throwable caught) {

        parentPlayer = null;

        formatParentPlayerDisplay();

      }

             

      @Override

      public void onSuccess(BaseContentItem result) {

        parentPlayer = (PlayerContentItem)result;

        addUnassignedPlayer(parentPlayer);

        formatParentPlayerDisplay();

      }

    });

   

    changeParentLink.addClickHandler(new ClickHandler() {

      @Override

      public void onClick(ClickEvent event) {

        parentPlayer = null;

        formatParentPlayerDisplay();

      }

    });

   

    if (unassignedPlayersIdToContentItemMap == null) {

      // Asynchronously query for the contributor names:

      contentRpcService.getUnassignedPlayers(new AsyncCallback<List<PlayerContentItem>>() {

        @Override

        public void onFailure(Throwable caught) {}

        @Override

        public void onSuccess(List<PlayerContentItem> results) {

          unassignedPlayersIdToContentItemMap = new HashMap<Long, PlayerContentItem>();

          populateUnassignedPlayersMap(results);

          populatePlayerSuggestPanel(generalPlayerSuggestPanel);

        }

      });

    } else {

      populatePlayerSuggestPanel(generalPlayerSuggestPanel);

    }

   

    Label contentInstructions = new Label("Please enter the role of the selected player in this " +

        "particular story in the 'Content' box below.");

    DOM.setStyleAttribute(contentInstructions.getElement(), "marginTop", "3em");

   

    formatParentPlayerDisplay();

   

    FlowPanel storyPlayerAttributesPanel = new FlowPanel();

    storyPlayerAttributesPanel.add(title);

    storyPlayerAttributesPanel.add(parentPlayerDisplayAndChangeLinkPanel);

    storyPlayerAttributesPanel.add(parentSelectionInstructions);

    storyPlayerAttributesPanel.add(generalPlayerSuggestPanel);

    storyPlayerAttributesPanel.add(contentInstructions);

    return storyPlayerAttributesPanel;

  }

 

  private void formatParentPlayerDisplay() {

    boolean isParentNull = parentPlayer == null;

    parentPlayerDisplayPanel.clear();

    if (!isParentNull) {

      parentPlayerDisplayPanel.add(new BasePlayerPreview(parentPlayer));

    }

    parentPlayerDisplayPanel.setVisible(!isParentNull);

    changeParentLink.setVisible(!isParentNull);

    parentSelectionInstructions.setVisible(isParentNull);

    generalPlayerSuggestPanel.setVisible(isParentNull);

  }

 

  private Widget createAssetAttributesPanel() {

    assetTypeSelector = EnumDropdown.newInstance(AssetType.class);

    previewUrlLabel = new Label("Asset preview url:");

    previewUrlTextBox = new TextBox();

    imageUrlLabel = new Label("Image url (images only):");

    imageUrlTextBox = new TextBox();

    captionLabel = new Label("Asset caption:");

    captionTextArea = new TextArea();

    assetTypeSelector.addChangeHandler(new ChangeHandler() {

      @Override

      public void onChange(ChangeEvent event) {

        setAssetControlVisibility();

      }

    });

   

    assetTypeSelector.selectConstant(AssetType.IMAGE);

   

    Grid assetPanel = new Grid(4, 2);

    assetPanel.setWidget(0, 0, new Label("Asset type:"));

    assetPanel.setWidget(0, 1, assetTypeSelector);

    assetPanel.setWidget(1, 0, previewUrlLabel);

    assetPanel.setWidget(1, 1, previewUrlTextBox);

    assetPanel.setWidget(2, 0, imageUrlLabel);

    assetPanel.setWidget(2, 1, imageUrlTextBox);

    assetPanel.setWidget(3, 0, captionLabel);

    assetPanel.setWidget(3, 1, captionTextArea);

   

    return assetPanel;

  }

 

  /**

   * Hides and shows labels, textareas, and other controls as appropriate for the asset

   * type a user is editing. Also may hide the main content rich text editor, if appropriate.

   */

  private void setAssetControlVisibility() {

    boolean visibleContent = true;

    boolean visiblePreviewUrl = true;

    boolean visibleImageUrl = false;

    boolean visibleCaption = true;

    if (contentItemTypeSelector.getSelectedConstant() == ContentItemType.ASSET) {

      switch (assetTypeSelector.getSelectedConstant()) {

        case AUDIO:

        case DOCUMENT:

          visiblePreviewUrl = false;

          break;

        case IMAGE:

          visibleImageUrl = true;

          visibleContent = false;

          break;

        case LINK:

          visiblePreviewUrl = false;

          visibleCaption = false;

          break;

        default:

          // nothing

          break;

      }

    }

     

    contentTitle.setVisible(visibleContent);

    contentEditor.setVisible(visibleContent);

    previewUrlLabel.setVisible(visiblePreviewUrl);

    previewUrlTextBox.setVisible(visiblePreviewUrl);

    imageUrlLabel.setVisible(visibleImageUrl);

    imageUrlTextBox.setVisible(visibleImageUrl);

    captionLabel.setVisible(visibleCaption);

    captionTextArea.setVisible(visibleCaption);

  }

  private Widget createNarrativeAttributesPanel() {

    headlineTextBox = new TextBox();

    headlineTextBox.setVisibleLength(LONG_TEXTBOX_VISIBLE_LENGTH);

    narrativeTypeSelector = EnumDropdown.newInstance(NarrativeType.class);

    narrativeDateBox = new DateBox();

    narrativeSummaryTextArea = new RichTextEditor();

    narrativeSummaryTextArea.setSize("400px", "100px");

   

    Grid narrativePanel = new Grid(4, 2);

    narrativePanel.setWidget(0, 0, new Label("Headline:"));

    narrativePanel.setWidget(0, 1, headlineTextBox);

    narrativePanel.setWidget(1, 0, new Label("Narrative type:"));

    narrativePanel.setWidget(1, 1, narrativeTypeSelector);

    narrativePanel.setWidget(2, 0, new Label("Date (optional):"));

    narrativePanel.setWidget(2, 1, narrativeDateBox);

    narrativePanel.setWidget(3, 0, new Label("Summary (optional):"));