membernavigator.java

OLAP 的客户端代码

  /**
   * crerates a MemberNavigator that is not connected to a query. Before callin setHierarchies() the
   * client must call setOlapModel().
   */
  public MemberNavigator(String id, Component parent, RequestListener okHandler,
      RequestListener cancelHandler) {
    this(id, parent, null, okHandler, cancelHandler);
  }

  public void setOlapModel(OlapModel newOlapModel) {
    if (olapModel != null)
      olapModel.removeModelChangeListener(this);
    olapModel = newOlapModel;
    if (olapModel != null)
      olapModel.addModelChangeListener(this);
    trees.clear();
  }

  /**
   * Returns the title.
   *
   * @return String
   */
  public String getTitle() {
    return title;
  }

  public void initialize(RequestContext context) throws Exception {
    super.initialize(context);

    Dispatcher disp = super.getDispatcher();
    disp.addRequestListener(selectVisibleButtonId, null, new SelectVisibleHandler());
    disp.addRequestListener(selectNoneButtonId, null, new SelectNoneHandler());
    disp.addRequestListener(enableGroupingButtonId, null, new SetGroupingHandler(true));
    disp.addRequestListener(disableGroupingButtonId, null, new SetGroupingHandler(false));
    disp.addRequestListener(okButtonId, null, okHandler);
    disp.addRequestListener(cancelButtonId, null, cancelHandler);
    resources = context.getResources(MemberNavigator.class);
    groupingMemberCount = resources.getInteger("MemberNavigator.groupingMemberCount");
  }

  public Element render(RequestContext context, Document factory) throws Exception {
    if (getModel() == null)
      throw new IllegalStateException("must call MemberNavigator.setHierarchy() before rendering");
    Element elem = super.render(context, factory);
    elem.setAttribute("title", title);
    elem.setAttribute("closeId", cancelButtonId);
    renderButtons(elem, factory);
    setError(null);
    return elem;
  }

  private void renderButtons(Element parent, Document factory) {
    Element buttons = factory.createElement("buttons");
    parent.appendChild(buttons);
    appendSelectButton(buttons);
    appendGroupingButton(buttons);
    Button.addButton(buttons, okButtonId, resources.getString("MemberNavigator.ok.title"));
    Button.addButton(buttons, cancelButtonId, resources.getString("MemberNavigator.cancel.title"));
  }

  private void appendGroupingButton(Element buttons) {
    if (isGrouping()) {
      String label = resources.getString("MemberNavigator.disableGrouping.title");
      Button.addButton(buttons, disableGroupingButtonId, label);
    } else {
      String label = resources.getString("MemberNavigator.enableGrouping.title");
      Button.addButton(buttons, enableGroupingButtonId, label);
    }
  }

  private void appendSelectButton(Element buttons) {
    // in multiple selection mode append toggle-button "select all" / "select none"
    if (getSelectionModel().getMode() == SelectionModel.MULTIPLE_SELECTION) {
      if (getSelectionModel().isEmpty()) {
        String label = resources.getString("MemberNavigator.selectVisible.title");
        Button.addButton(buttons, selectVisibleButtonId, label);
      } else {
        String label = resources.getString("MemberNavigator.selectNone.title");
        Button.addButton(buttons, selectNoneButtonId, label);
      }
    }
    // in single selection mode optionally append "select none"
    else if (showSelectNoneButton) {
      String label = resources.getString("MemberNavigator.selectNone.title");
      Button.addButton(buttons, selectNoneButtonId, label);
    }
  }

  public static LabelProvider labelProvider = new DefaultLabelProvider() {
    public String getLabel(Object node) {
      if (node instanceof Displayable)
        return ((Displayable) node).getLabel();
      return super.getLabel(node);
    }
  };

  private TreeModelAdapter.OverflowListener overflowListener = new TreeModelAdapter.OverflowListener() {
    public void overflowOccured() {
      setError(resources.getString("MemberNavigator.overflowOccurred"));
    }
  };

  /**
   * sets the hierarchies for the members to choose from. Sets a default title.
   *
   * @param hierarchies
   * @param allowChangeOrder
   */
  public void setHierarchies(Hierarchy[] hierarchies, boolean allowChangeOrder) {
    if (!isAvailable())
      return;
    HierarchyArray hierarchyArray = new HierarchyArray(hierarchies);
    Tree tree = (Tree) trees.get(hierarchyArray);
    if (tree == null) {
      Locale locale = resources.getLocale();
      MemberTree mtree = (MemberTree) olapModel.getExtension(MemberTree.ID);
      TreeModelAdapter tma = new TreeModelAdapter(hierarchies, mtree, locale);
      tma.setOverflowListener(overflowListener);

      // the singleRecord level can not be opened because it contains
      // too many children
      for (int i = 0; i < hierarchies.length; i++) {
        if (OlapUtils.isSingleRecord(hierarchies[i])) {
          Level[] levels = hierarchies[i].getLevels();
          tma.setNoChildrenLevel(levels[0]);
        }
      }

      // insert artificial groups for Non-Measures hierarchies
      int count = groupingMemberCount;
      if (hierarchies.length > 0 && hierarchies[0].getDimension().isMeasure())
        count = 0;
      GroupingTreeModelDecorator gtd = new GroupingTreeModelDecorator(labelProvider, tma, count);
      MutableTreeModelDecorator mtd = new MutableMemberTreeModelDecorator(gtd);

      // create and store the tree
      tree = new Tree(tma, mtd);
      trees.put(hierarchyArray, tree);
    }
    MutableTreeModelDecorator mtd = tree.getModel();
    mtd.setEnableChangeOrder(allowChangeOrder);
    super.setModel(mtd);
    super.setChangeOrderModel(mtd);
    this.title = hierarchyArray.getLabel();
  }

  /**
   * sets the hierarchy of members to choose from. Sets a default title.
   */
  public void setHierarchy(Hierarchy hierarchy, boolean allowChangeOrder) {
    setHierarchies(new Hierarchy[] { hierarchy}, allowChangeOrder);
  }

  /**
   * Sets the title.
   *
   * @param title
   *          The title to set
   */
  public void setTitle(String title) {
    this.title = title;
  }

  public void modelChanged(ModelChangeEvent e) {
    for (Iterator it = trees.values().iterator(); it.hasNext();) {
      Tree tree = (Tree) it.next();
      TreeModelAdapter tma = tree.getAdapter();
      tma.modelChanged();
    }
  }

  public void structureChanged(ModelChangeEvent e) {
    // clear all references
    logger.info("cleaning up");
    trees.clear();
    super.setModel(null);
    super.getSelectionModel().clear();
  }

  /**
   * shows "Select None" button in single selection mode
   */
  public boolean isShowSelectNoneButton() {
    return showSelectNoneButton;
  }

  /**
   * shows "Select None" button in single selection mode
   */
  public void setShowSelectNoneButton(boolean b) {
    showSelectNoneButton = b;
  }

  /**
   * Number of members of a non-selectable pseudo level
   * @return Returns the groupingMemberCount.
   */
  public int getGroupingMemberCount() {
    return groupingMemberCount;
  }

  /**
   * Number of members of a non-selectable pseudo level
   * @param groupingMemberCount The groupingMemberCount to set.
   */
  public void setGroupingMemberCount(int groupingMemberCount) {
    this.groupingMemberCount = groupingMemberCount;
  }

  public boolean isGrouping() {
    return getGroupingTreeModelDecorator().getLimit() > 0;
  }

  public void setGrouping(boolean b) {
    GroupingTreeModelDecorator gtd = getGroupingTreeModelDecorator();
    gtd.setLimit(b ? groupingMemberCount : 0);
  }

  private GroupingTreeModelDecorator getGroupingTreeModelDecorator() {
    MutableTreeModelDecorator mtd = (MutableTreeModelDecorator) getModel();
    return (GroupingTreeModelDecorator) mtd.getDecoree();
  }

  /**
   * returns true if the OlapModel supports all extensions that are required
   * to use the MemberNavigator
   */
  public boolean isAvailable() {
    return olapModel.getExtension(MemberTree.ID) != null;
  }
  
  public void setVisible(boolean b) {
    if  (!isAvailable())
      b = false;
    super.setVisible(b);
  }

}