public ArrayList<ListGridField> getListGridFields() {
    ArrayList<ListGridField> fields = new ArrayList<ListGridField>(7);

    ListGridField dirPathField = new ListGridField(ATTR_DIR_PATH, "Directory");
    fields.add(dirPathField);

    ListGridField filesField = new ListGridField(ATTR_FILES, "Files");
    fields.add(filesField);

    ListGridField addedField = new ListGridField(ATTR_ADDED, "Added");
    fields.add(addedField);

    ListGridField changedField = new ListGridField(ATTR_CHANGED, "Changed");
    fields.add(changedField);

    ListGridField removedField = new ListGridField(ATTR_REMOVED, "Removed");
    fields.add(removedField);

    dirPathField.setWidth("*");
    filesField.setWidth("10%");
    addedField.setWidth("10%");
    changedField.setWidth("10%");
    removedField.setWidth("10%");

    return fields;
  }
  public VoteListGrid() {
    super();

    // initialize the List Grid fields
    ListGridField iconField = new ListGridField(ICON, ICON_DISPLAY_NAME, ICON_COLUMN_LENGTH);
    iconField.setImageSize(16);
    iconField.setAlign(Alignment.CENTER);
    iconField.setType(ListGridFieldType.IMAGE);
    iconField.setImageURLPrefix(URL_PREFIX);
    iconField.setImageURLSuffix(URL_SUFFIX);

    ListGridField voteCodeField = new ListGridField(VOTE_CODE, VOTE_CODE_DISPLAY);
    voteCodeField.setWidth("20%");
    ListGridField voteNameField = new ListGridField(VOTE_NAME, VOTE_NAME_DISPLAY);
    voteNameField.setWidth("20%");
    ListGridField voteIDField = new ListGridField(VOTE_ID, VOTE_ID_DISPLAY);
    voteIDField.setHidden(true);
    ListGridField createdByField = new ListGridField(CREATED_BY, CREATED_BY_DISPLAY);
    createdByField.setWidth("20%");
    ListGridField changedByField = new ListGridField(CHANGED_BY, CHANGED_BY_DISPLAY);
    changedByField.setWidth("20%");
    ListGridField emptyField = new ListGridField(EMPTY_FIELD, EMPTY_FIELD_DISPLAY_NAME);

    this.setCanPickFields(false);
    this.setShowRowNumbers(true);
    this.setFields(voteIDField, voteNameField, voteCodeField, createdByField, changedByField);
  }
  @Override
  protected void configureTable() {
    ListGridField idField = new ListGridField(FIELD_ID, MSG.common_title_id());

    ListGridField versionField =
        new ListGridField(BundleVersionDataSource.FIELD_VERSION, MSG.common_title_version());
    versionField.setCellFormatter(
        new CellFormatter() {
          public String format(Object o, ListGridRecord listGridRecord, int i, int i1) {
            Integer _bundleId = listGridRecord.getAttributeAsInt("bundleId");
            Integer _bvId = listGridRecord.getAttributeAsInt("id");
            return "<a href=\""
                + LinkManager.getBundleVersionLink(_bundleId, _bvId)
                + "\">"
                + o
                + "</a>";
          }
        });

    ListGridField nameField =
        new ListGridField(BundleVersionDataSource.FIELD_NAME, MSG.common_title_name());

    ListGridField descriptionField =
        new ListGridField(
            BundleVersionDataSource.FIELD_DESCRIPTION, MSG.common_title_description());

    ListGridField fileCountField =
        new ListGridField(BundleVersionDataSource.FIELD_FILECOUNT, MSG.view_bundle_bundleFiles());

    idField.setWidth(50);
    versionField.setWidth("20%");
    nameField.setWidth("25%");
    descriptionField.setWidth("*");
    fileCountField.setWidth("10%");

    setListGridFields(idField, versionField, nameField, descriptionField, fileCountField);

    setListGridDoubleClickHandler(
        new DoubleClickHandler() {
          @Override
          public void onDoubleClick(DoubleClickEvent event) {
            ListGrid listGrid = (ListGrid) event.getSource();
            ListGridRecord[] selectedRows = listGrid.getSelectedRecords();
            if (selectedRows != null && selectedRows.length == 1) {
              String selectedId =
                  selectedRows[0].getAttribute(BundleVersionDataSource.FIELD_BUNDLE_ID);
              String selectedVersionId =
                  selectedRows[0].getAttribute(BundleVersionDataSource.FIELD_ID);
              CoreGUI.goToView(
                  LinkManager.getBundleVersionLink(
                      Integer.valueOf(selectedId), Integer.valueOf(selectedVersionId)));
            }
          }
        });
  }
  /*
   * (non-Javadoc)
   * @see
   * cz.fi.muni.xkremser.editor.client.presenter.DigitalObjectMenuPresenter.
   * MyView#setDS(com.gwtplatform.dispatch.client.DispatchAsync)
   */
  @Override
  public void setDS(DispatchAsync dispatcher, EventBus bus) {
    this.sideNavGrid.setDataSource(new RecentlyTreeGwtRPCDS(dispatcher, lang, bus));
    ListGridField nameField = new ListGridField(Constants.ATTR_NAME, lang.name());
    nameField.setRequired(true);
    nameField.setWidth("40%");
    nameField.setCellFormatter(
        new CellFormatter() {

          @Override
          public String format(Object value, ListGridRecord record, int rowNum, int colNum) {
            String owner = record.getAttribute(Constants.ATTR_LOCK_OWNER);
            if (owner != null) {
              return ("".equals(owner)
                      ? RecentlyTreeGwtRPCDS.FIRST_PART_OF_COLOR_LOCK_BY_USER
                      : RecentlyTreeGwtRPCDS.FIRST_PART_OF_COLOR_LOCK)
                  + record.getAttribute(Constants.ATTR_NAME)
                  + RecentlyTreeGwtRPCDS.SECOND_PART_OF_COLOR_LOCK;
            } else {
              return record.getAttribute(Constants.ATTR_NAME);
            }
          }
        });
    ListGridField uuidField = new ListGridField(Constants.ATTR_UUID, "PID");
    uuidField.setRequired(true);
    uuidField.setWidth("*");
    uuidField.setCellFormatter(
        new CellFormatter() {

          @Override
          public String format(Object value, ListGridRecord record, int rowNum, int colNum) {
            String owner = record.getAttribute(Constants.ATTR_LOCK_OWNER);
            if (owner != null) {
              return ("".equals(owner)
                      ? RecentlyTreeGwtRPCDS.FIRST_PART_OF_COLOR_LOCK_BY_USER
                      : RecentlyTreeGwtRPCDS.FIRST_PART_OF_COLOR_LOCK)
                  + record.getAttribute(Constants.ATTR_UUID)
                  + RecentlyTreeGwtRPCDS.SECOND_PART_OF_COLOR_LOCK;
            } else {
              return record.getAttribute(Constants.ATTR_UUID);
            }
          }
        });
    sideNavGrid.setFields(nameField, uuidField);
  }
  /** Instantiates a new digital object menu view. */
  @Inject
  public DigitalObjectMenuView(final LangConstants lang, final EventBus eventBus) {
    this.lang = lang;
    this.eventBus = eventBus;

    layout = new VLayout();

    layout.setHeight100();
    layout.setWidth100();
    layout.setOverflow(Overflow.AUTO);

    relatedGrid = new ListGrid();
    relatedGrid.setWidth100();
    relatedGrid.setHeight100();
    relatedGrid.setShowSortArrow(SortArrow.CORNER);
    relatedGrid.setShowAllRecords(true);
    relatedGrid.setAutoFetchData(false);
    relatedGrid.setCanHover(true);
    relatedGrid.setCanSort(false);
    ListGridField field1 = new ListGridField("relation", lang.relation());
    field1.setWidth("40%");
    ListGridField field2 = new ListGridField("uuid", "PID");
    field2.setWidth("*");
    relatedGrid.setFields(field1, field2);
    sectionRelated = new SectionStackSection();
    sectionRelated.setID(SECTION_RELATED_ID);
    sectionRelated.setTitle(lang.referencedBy());
    sectionRelated.setResizeable(true);
    sectionRelated.setItems(relatedGrid);
    sectionRelated.setExpanded(false);

    sideNavGrid =
        new ListGrid() {

          @Override
          protected Canvas getRollOverCanvas(Integer rowNum, Integer colNum) {
            final ListGridRecord rollOverRecord = this.getRecord(rowNum);
            if (rollOverCanvas == null) {
              rollOverCanvas = new HLayout();
              rollOverCanvas.setSnapTo("TR");
              rollOverCanvas.setWidth(50);
              rollOverCanvas.setHeight(22);
            }

            if (rollOverCanvas.getChildren().length > 0) {
              rollOverCanvas.removeChild(rollOverCanvas.getChildren()[0]);
            }
            final String lockOwner = rollOverRecord.getAttributeAsString(Constants.ATTR_LOCK_OWNER);
            if (lockOwner != null) {
              ImgButton lockImg = new ImgButton();
              lockImg.setShowDown(false);
              lockImg.setShowRollOver(false);
              lockImg.setLayoutAlign(Alignment.CENTER);

              if ("".equals(lockOwner)) {
                lockImg.setSrc("icons/16/lock_lock_all.png");
              } else if (lockOwner.length() > 0) {
                lockImg.setSrc("icons/16/lock_lock_all_red.png");
              }

              lockImg.setPrompt(lang.lockInfoButton());
              lockImg.setHeight(16);
              lockImg.setWidth(16);
              lockImg.addClickHandler(
                  new com.smartgwt.client.widgets.events.ClickHandler() {

                    @Override
                    public void onClick(com.smartgwt.client.widgets.events.ClickEvent event) {
                      EditorSC.objectIsLock(
                          lang,
                          new LockInfo(
                              lockOwner,
                              rollOverRecord.getAttributeAsString(Constants.ATTR_LOCK_DESCRIPTION),
                              rollOverRecord.getAttributeAsStringArray(
                                  Constants.ATTR_TIME_TO_EXP_LOCK)));
                    }
                  });
              rollOverCanvas.addChild(lockImg);
            }
            return rollOverCanvas;
          }
        };
    sideNavGrid.setShowSelectionCanvas(false);

    sideNavGrid.setWidth100();
    sideNavGrid.setHeight100();
    sideNavGrid.setShowSortArrow(SortArrow.CORNER);
    sideNavGrid.setShowAllRecords(true);
    sideNavGrid.setAutoFetchData(true);
    sideNavGrid.setCanHover(true);
    sideNavGrid.setHoverOpacity(75);
    sideNavGrid.setHoverStyle("interactImageHover");
    sideNavGrid.setShowRollOverCanvas(true);

    final DynamicForm form = new DynamicForm();
    form.setHeight(1);
    form.setWidth(60);
    form.setNumCols(1);

    selectItem.setWidth(60);
    selectItem.setShowTitle(false);
    selectItem.setValueMap(lang.me(), lang.all());
    selectItem.setDefaultValue(lang.me());
    selectItem.setHoverOpacity(75);
    selectItem.setHoverStyle("interactImageHover");
    selectItem.addItemHoverHandler(
        new ItemHoverHandler() {

          @Override
          public void onItemHover(ItemHoverEvent event) {
            selectItem.setPrompt(
                DigitalObjectMenuView.this.lang.showModifiedHint() + selectItem.getValue());
          }
        });
    selectItem.addChangedHandler(
        new ChangedHandler() {

          @Override
          public void onChanged(ChangedEvent event) {
            getUiHandlers().refreshRecentlyModified();
          }
        });

    form.setFields(selectItem);
    form.setTitle("by:");

    sectionRecentlyModified = new SectionStackSection();
    sectionRecentlyModified.setTitle(lang.recentlyModified());
    sectionRecentlyModified.setResizeable(true);
    sectionRecentlyModified.setItems(sideNavGrid);
    sectionRecentlyModified.setControls(form);
    sectionRecentlyModified.setExpanded(true);

    sectionStack = new SectionStack();
    sectionStack.addSection(sectionRelated);
    sectionStack.addSection(sectionRecentlyModified);
    sectionStack.setVisibilityMode(VisibilityMode.MULTIPLE);
    sectionStack.setAnimateSections(true);
    sectionStack.setWidth100();
    sectionStack.setHeight100();
    sectionStack.setOverflow(Overflow.HIDDEN);
    layout.addMember(sectionStack);
  }
  public SearchValueSetItemsListGrid() {
    super();

    i_valueSetItemSearchXmlDS = ValueSetItemSearchXmlDS.getInstance();

    setWidth100();
    setHeight100();
    setShowAllRecords(true);
    setWrapCells(false);
    setDataSource(i_valueSetItemSearchXmlDS);
    setEmptyMessage(EMPTY_MESSAGE);

    ListGridField addField = new ListGridField("add", "Add");
    addField.setType(ListGridFieldType.BOOLEAN);
    addField.setShowHover(false);
    addField.setDefaultValue(false);
    addField.setCanEdit(true);
    addField.addChangedHandler(
        new ChangedHandler() {
          @Override
          public void onChanged(ChangedEvent changedEvent) {
            if ((Boolean) changedEvent.getValue()) {
              ListGridRecord selected = getSelectedRecord();
              String uri = selected.getAttribute("uri");
              String code = selected.getAttribute("name");
              String description = selected.getAttribute("designation");
              String codeSystem = selected.getAttribute("namespace");
              String codeSystemVersion = selected.getAttribute("codeSystemVersion");
              Cts2Editor.EVENT_BUS.fireEvent(
                  new AddEntitySelectedEvent(
                      uri, code, description, codeSystem, codeSystemVersion));
            } else {
              ListGridRecord selected = getSelectedRecord();
              String href = selected.getAttribute("uri");
              Cts2Editor.EVENT_BUS.fireEvent(new AddEntityDeselectedEvent(href));
            }
          }
        });

    ListGridField nameField = new ListGridField(ID_NAME, TITLE_NAME);
    nameField.setWrap(false);
    nameField.setWidth("25%");
    nameField.setShowHover(false);
    nameField.setCanEdit(false);

    nameField.setCellFormatter(
        new CellFormatter() {

          @Override
          public String format(Object value, ListGridRecord record, int rowNum, int colNum) {
            if (value != null) {
              return addCellHighlights(value.toString());
            } else {
              return null;
            }
          }
        });

    ListGridField designationField = new ListGridField(ID_DESIGNATION, TITLE_DESIGNATION);
    designationField.setWrap(false);
    designationField.setWidth("*");
    designationField.setCanEdit(false);

    designationField.setCellFormatter(
        new CellFormatter() {

          @Override
          public String format(Object value, ListGridRecord record, int rowNum, int colNum) {
            if (value != null) {
              return addCellHighlights(value.toString());
            } else {
              return null;
            }
          }
        });

    setFields(addField, nameField, designationField);

    setSelectOnEdit(true);
    setSelectionAppearance(SelectionAppearance.ROW_STYLE);
    setSelectionType(SelectionStyle.SINGLE);

    // Set edit and edit event to get the download checkbox to work
    // correctly.
    setCanEdit(true);

    setAutoFetchData(false);

    setCanHover(true);
    setShowHover(true);
    setShowHoverComponents(true);

    // set the initial sort
    SortSpecifier[] sortspec = new SortSpecifier[1];
    sortspec[0] = new SortSpecifier(ID_NAME, SortDirection.ASCENDING);
    setInitialSort(sortspec);

    //		addEventHandlers();
  }
    public teamsInClass_Team_Widget(
        final Criteria criteria, final UserDetailsReceivedEvent userDetails) {
      this.userDetails = userDetails;

      final TeamModelMessages targetMessages =
          (TeamModelMessages) GWT.create(TeamModelMessages.class);

      BoatTypeModelMessages boatTypeMessages =
          (BoatTypeModelMessages) GWT.create(BoatTypeModelMessages.class);

      setPadding(10);
      setIsGroup(true);
      setGroupTitle(
          classMessages.richFormView_teamsInClass_coupling_with_Team(
              targetMessages.tab_name_TeamModel()));

      // all elements from the target reference, to be picked from to make a connection

      setWidth100();
      setHeight100();

      this.grid.setWidth100();
      // grid.setHeight(150); //automatically ought to use all the space
      // grid.setHeight("*");

      this.grid.setAlternateRecordStyles(false);
      this.grid.setCellHeight(32);
      this.grid.setDataSource(dataSource);
      this.grid.setAutoFetchData(false);
      this.grid.setCanEdit(true);
      this.grid.setModalEditing(true);
      this.grid.setShowFilterEditor(true);
      this.grid.setDoubleClickDelay(100);
      this.grid.setEditEvent(ListGridEditEvent.DOUBLECLICK);
      this.grid.setListEndEditAction(RowEndEditAction.DONE);
      this.grid.setCanRemoveRecords(true);
      this.grid.setAutoSaveEdits(true);
      this.grid.setCanSelectText(true);
      this.grid.setAllowFilterExpressions(true);

      this.grid.setCanDragSelectText(true);
      this.grid.setCanRemoveRecords(
          false); // we have our own delete button, with extra functionality

      /*

      */

      ListGridField idField = new ListGridField("Team_id", "Team id");

      ListGridField sailNumberField = new ListGridField("sailNumber", targetMessages.sailNumber());

      sailNumberField.setAlign(Alignment.LEFT);

      sailNumberField = TeamRichTableView.setFormatterForsailNumber(sailNumberField);

      ListGridField teamNameField = new ListGridField("teamName", targetMessages.teamName());

      teamNameField.setAlign(Alignment.LEFT);

      teamNameField = TeamRichTableView.setFormatterForteamName(teamNameField);

      ListGridField nameCaptainField =
          new ListGridField("nameCaptain", targetMessages.nameCaptain());

      nameCaptainField.setAlign(Alignment.LEFT);

      nameCaptainField = TeamRichTableView.setFormatterFornameCaptain(nameCaptainField);

      ListGridField streetField = new ListGridField("street", targetMessages.street());

      streetField.setAlign(Alignment.LEFT);

      streetField = TeamRichTableView.setFormatterForstreet(streetField);

      ListGridField zipcodeField = new ListGridField("zipcode", targetMessages.zipcode());

      zipcodeField.setAlign(Alignment.LEFT);

      zipcodeField = TeamRichTableView.setFormatterForzipcode(zipcodeField);

      ListGridField cityField = new ListGridField("city", targetMessages.city());

      cityField.setAlign(Alignment.LEFT);

      cityField = TeamRichTableView.setFormatterForcity(cityField);

      ListGridField emailField = new ListGridField("email", targetMessages.email());

      emailField.setAlign(Alignment.LEFT);

      emailField = TeamRichTableView.setFormatterForemail(emailField);

      ListGridField phoneField = new ListGridField("phone", targetMessages.phone());

      phoneField.setAlign(Alignment.LEFT);

      phoneField = TeamRichTableView.setFormatterForphone(phoneField);

      ListGridField numPersonsField = new ListGridField("numPersons", targetMessages.numPersons());

      numPersonsField.setAlign(Alignment.LEFT);

      numPersonsField = TeamRichTableView.setFormatterFornumPersons(numPersonsField);

      ListGridField toerField = new ListGridField("toer", targetMessages.toer());

      toerField = TeamRichTableView.setFormatterFortoer(toerField);

      ListGridField spinField = new ListGridField("spin", targetMessages.spin());

      spinField = TeamRichTableView.setFormatterForspin(spinField);

      ListGridField waitinglistField =
          new ListGridField("waitinglist", targetMessages.waitinglist());

      waitinglistField = TeamRichTableView.setFormatterForwaitinglist(waitinglistField);

      ListGridField femaleTeamField = new ListGridField("femaleTeam", targetMessages.femaleTeam());

      femaleTeamField = TeamRichTableView.setFormatterForfemaleTeam(femaleTeamField);

      ListGridField remark_Field = new ListGridField("remark_", targetMessages.remark_());

      remark_Field.setAlign(Alignment.LEFT);

      remark_Field = TeamRichTableView.setFormatterForremark_(remark_Field);

      ListGridField teamStartTimeField =
          new ListGridField("teamStartTime", targetMessages.teamStartTime());

      teamStartTimeField.setAlign(Alignment.LEFT);

      teamStartTimeField = TeamRichTableView.setFormatterForteamStartTime(teamStartTimeField);

      teamStartTimeField.setTimeFormatter(TimeDisplayFormat.TOSHORTPADDED24HOURTIME);

      // call to a custom field, this class should be created customly
      teamStartTimeField =
          nl.sytematic.projects.BrioRaceSystem.client.custom.TeamTeamStartTimeCustomFieldFactory
              .getCustomField(grid, teamStartTimeField, userDetails);

      ListGridField endTimeField = new ListGridField("endTime", targetMessages.endTime());

      endTimeField.setAlign(Alignment.LEFT);

      endTimeField = TeamRichTableView.setFormatterForendTime(endTimeField);

      endTimeField.setTimeFormatter(TimeDisplayFormat.TOSHORTPADDED24HOURTIME);

      ListGridField sailingTimeField =
          new ListGridField("sailingTime", targetMessages.sailingTime());

      sailingTimeField.setAlign(Alignment.LEFT);

      sailingTimeField = TeamRichTableView.setFormatterForsailingTime(sailingTimeField);

      sailingTimeField.setTimeFormatter(TimeDisplayFormat.TOSHORTPADDED24HOURTIME);

      // call to a custom field, this class should be created customly
      sailingTimeField =
          nl.sytematic.projects.BrioRaceSystem.client.custom.TeamSailingTimeCustomFieldFactory
              .getCustomField(grid, sailingTimeField, userDetails);

      ListGridField swTimeField = new ListGridField("swTime", targetMessages.swTime());

      swTimeField.setAlign(Alignment.LEFT);

      swTimeField = TeamRichTableView.setFormatterForswTime(swTimeField);

      swTimeField.setTimeFormatter(TimeDisplayFormat.TOSHORTPADDED24HOURTIME);

      // call to a custom field, this class should be created customly
      swTimeField =
          nl.sytematic.projects.BrioRaceSystem.client.custom.TeamSwTimeCustomFieldFactory
              .getCustomField(grid, swTimeField, userDetails);

      ListGridField registrationDateTimeField =
          new ListGridField("registrationDateTime", targetMessages.registrationDateTime());

      registrationDateTimeField.setAlign(Alignment.LEFT);

      registrationDateTimeField =
          TeamRichTableView.setFormatterForregistrationDateTime(registrationDateTimeField);

      //	registrationDateTimeField.setDateFormatter(DateDisplayFormat.TOEUROPEANSHORTDATETIME);
      DateTimeItem registrationDateTimeEditor = new DateTimeItem();
      registrationDateTimeEditor.setUseTextField(true);
      registrationDateTimeEditor.setUseMask(true);
      //	registrationDateTimeEditor.setDateFormatter(DateDisplayFormat.TOEUROPEANSHORTDATETIME);
      registrationDateTimeField.setEditorType(registrationDateTimeEditor);
      //   registrationDateTimeField.setFilterEditorType(registrationDateTimeEditor);

      // call to a custom field, this class should be created customly
      registrationDateTimeField =
          nl.sytematic.projects.BrioRaceSystem.client.custom
              .TeamRegistrationDateTimeCustomFieldFactory.getCustomField(
              grid, registrationDateTimeField, userDetails);

      ListGridField payDateField = new ListGridField("payDate", targetMessages.payDate());

      payDateField.setAlign(Alignment.LEFT);

      payDateField = TeamRichTableView.setFormatterForpayDate(payDateField);

      //	payDateField.setDateFormatter(DateDisplayFormat.TOEUROPEANSHORTDATE);
      DateItem payDateEditor = new DateItem();
      payDateEditor.setUseTextField(true);
      payDateEditor.setUseMask(true);
      //	payDateEditor.setDateFormatter(DateDisplayFormat.TOEUROPEANSHORTDATE);
      payDateField.setEditorType(payDateEditor);
      // payDateField.setFilterEditorType(payDateEditor);

      ListGridField payOrderField = new ListGridField("payOrder", targetMessages.payOrder());

      payOrderField.setAlign(Alignment.LEFT);

      payOrderField = TeamRichTableView.setFormatterForpayOrder(payOrderField);

      ListGridField payIdField = new ListGridField("payId", targetMessages.payId());

      payIdField.setAlign(Alignment.LEFT);

      payIdField = TeamRichTableView.setFormatterForpayId(payIdField);

      ListGridField acceptedField = new ListGridField("accepted", targetMessages.accepted());

      acceptedField = TeamRichTableView.setFormatterForaccepted(acceptedField);

      ListGridField payStatusField = new ListGridField("payStatus", targetMessages.payStatus());

      payStatusField.setAlign(Alignment.LEFT);

      payStatusField = TeamRichTableView.setFormatterForpayStatus(payStatusField);

      ListGridField BoatTypeField =
          new ListGridField("BoatType_id", boatTypeMessages.name_single());

      ListGridField ClassField = new ListGridField("Class_id", classMessages.name_single());

      final SelectItem BoatTypeSelectItem =
          new SelectItem("BoatType_id", boatTypeMessages.name_single());

      BoatTypeSelectItem.setOptionDataSource(DataSource.get("BoatType"));
      BoatTypeSelectItem.setValueField("BoatType_id");
      BoatTypeSelectItem.setAlign(Alignment.LEFT);

      BoatTypeSelectItem.setTextAlign(Alignment.LEFT);
      BoatTypeSelectItem.setTitleAlign(Alignment.LEFT);
      ListGrid BoatTypeListGrid = new ListGrid();
      BoatTypeListGrid.setShowFilterEditor(true);
      BoatTypeListGrid.setFilterOnKeypress(true);

      SortSpecifier BoatTypeSort = new SortSpecifier("typeName", SortDirection.ASCENDING);
      SortSpecifier[] BoatTypeSorts = new SortSpecifier[] {BoatTypeSort};
      BoatTypeListGrid.setInitialSort(BoatTypeSorts);

      BoatTypeSelectItem.setDisplayField("typeName");

      BoatTypeSelectItem.setAllowEmptyValue(true);

      BoatTypeSelectItem.setPickListWidth(800);
      BoatTypeSelectItem.setPickListFields(
          new ListGridField("typeName", boatTypeMessages.typeName()),
          new ListGridField("SW_value", boatTypeMessages.SW_value()));

      BoatTypeSelectItem.setPickListProperties(BoatTypeListGrid);

      BoatTypeField.setAlign(Alignment.LEFT);

      BoatTypeField.setEditorType(BoatTypeSelectItem);
      BoatTypeField.setOptionDataSource(DataSource.get("BoatType"));
      BoatTypeField.setDisplayField("typeName");

      BoatTypeField.setFilterEditorType(BoatTypeSelectItem); // reusing this is okay appareantly

      ButtonItem newBoatType = new ButtonItem("newBoatType", boatTypeMessages.new_window());
      newBoatType.addClickHandler(
          new com.smartgwt.client.widgets.form.fields.events.ClickHandler() {
            @Override
            public void onClick(com.smartgwt.client.widgets.form.fields.events.ClickEvent event) {
              BoatTypeNewEntryWindow w =
                  new BoatTypeNewEntryWindow(
                      null,
                      new DSCallback() {
                        @Override
                        public void execute(
                            DSResponse response, Object rawData, DSRequest request) {
                          RecordList rl = response.getDataAsRecordList();
                          if (rl.getLength() > 0) {
                            Record r = rl.get(0);
                            Log.debug("Record found in callback");
                            Integer id = r.getAttributeAsInt("BoatType_id");
                            Log.debug("ID is " + id);
                            BoatTypeSelectItem.setValue(id); // select the just added value
                          }
                        }
                      });

              w.show();
              w.bringToFront();
            }
          });

      final SelectItem ClassSelectItem = new SelectItem("Class_id", classMessages.name_single());

      ClassSelectItem.setOptionDataSource(DataSource.get("Class"));
      ClassSelectItem.setValueField("Class_id");
      ClassSelectItem.setAlign(Alignment.LEFT);

      ClassSelectItem.setTextAlign(Alignment.LEFT);
      ClassSelectItem.setTitleAlign(Alignment.LEFT);
      ListGrid ClassListGrid = new ListGrid();
      ClassListGrid.setShowFilterEditor(true);
      ClassListGrid.setFilterOnKeypress(true);

      SortSpecifier ClassSort = new SortSpecifier("className", SortDirection.ASCENDING);
      SortSpecifier[] ClassSorts = new SortSpecifier[] {ClassSort};
      ClassListGrid.setInitialSort(ClassSorts);

      ClassSelectItem.setDisplayField("className");

      ClassSelectItem.setAllowEmptyValue(true);

      ClassSelectItem.setPickListWidth(800);
      ClassSelectItem.setPickListFields(
          new ListGridField("className", classMessages.className()),
          new ListGridField("startTime", classMessages.startTime()));

      ClassSelectItem.setPickListProperties(ClassListGrid);

      ClassField.setAlign(Alignment.LEFT);

      ClassField.setEditorType(ClassSelectItem);
      ClassField.setOptionDataSource(DataSource.get("Class"));
      ClassField.setDisplayField("className");

      ClassField.setFilterEditorType(ClassSelectItem); // reusing this is okay appareantly

      ButtonItem newClass = new ButtonItem("newClass", classMessages.new_window());
      newClass.addClickHandler(
          new com.smartgwt.client.widgets.form.fields.events.ClickHandler() {
            @Override
            public void onClick(com.smartgwt.client.widgets.form.fields.events.ClickEvent event) {
              ClassNewEntryWindow w =
                  new ClassNewEntryWindow(
                      null,
                      new DSCallback() {
                        @Override
                        public void execute(
                            DSResponse response, Object rawData, DSRequest request) {
                          RecordList rl = response.getDataAsRecordList();
                          if (rl.getLength() > 0) {
                            Record r = rl.get(0);
                            Log.debug("Record found in callback");
                            Integer id = r.getAttributeAsInt("Class_id");
                            Log.debug("ID is " + id);
                            ClassSelectItem.setValue(id); // select the just added value
                          }
                        }
                      });

              w.show();
              w.bringToFront();
            }
          });

      ListGridField deleteField = new ListGridField("deleteField", "-");
      deleteField.setShouldPrint(false);
      deleteField.setCellIcon(
          GWT.getHostPageBaseURL() + "images/icons/32/woofunction/remove_32.png");
      deleteField.setType(ListGridFieldType.ICON);
      deleteField.setTitle("");
      deleteField.setWidth(32);
      deleteField.setIconSize(24);
      deleteField.setCanDragResize(false);
      deleteField.setCanSort(false);
      deleteField.setCanEdit(false);
      deleteField.setCanGroupBy(false);
      deleteField.setCanFreeze(false);
      deleteField.setCanFilter(false);
      deleteField.setCanHide(false);
      deleteField.setCanReorder(false);
      this.grid.addRecordClickHandler(
          new RecordClickHandler() {
            public void onRecordClick(RecordClickEvent event) {
              ListGridField clicked = event.getField();
              final Record r = event.getRecord();
              if ("deleteField".equals(clicked.getName())) {

                SC.confirm(
                    radosMessages.delete_confirm_coupling(),
                    new BooleanCallback() {
                      public void execute(Boolean confirmed) {
                        if (confirmed != null && confirmed) {
                          grid.removeData(r);
                        } else {
                          // Cancel
                        }
                      }
                    });
              }
            }
          });

      ArrayList<ListGridField> fields = new ArrayList<ListGridField>();

      fields.add(idField);

      fields.add(sailNumberField);

      fields.add(teamNameField);

      fields.add(nameCaptainField);

      fields.add(streetField);

      fields.add(zipcodeField);

      fields.add(cityField);

      fields.add(emailField);

      fields.add(phoneField);

      fields.add(numPersonsField);

      fields.add(toerField);

      fields.add(spinField);

      fields.add(waitinglistField);

      fields.add(femaleTeamField);

      fields.add(remark_Field);

      fields.add(teamStartTimeField);

      fields.add(endTimeField);

      fields.add(sailingTimeField);

      fields.add(swTimeField);

      fields.add(registrationDateTimeField);

      fields.add(payDateField);

      fields.add(payOrderField);

      fields.add(payIdField);

      fields.add(acceptedField);

      fields.add(payStatusField);

      fields.add(BoatTypeField);

      if (userDetails.hasAuthority("CAN_DELETE_TEAM")) {
        fields.add(deleteField);
      }

      ListGridField[] fieldsArr = fields.toArray(new ListGridField[fields.size()]);

      this.grid.setFields(fieldsArr);

      this.grid.fetchData(criteria);
      buttonPanel.setMargin(2);

      grid.hideField("Team_id");

      // newButton.setSize(32);
      newButton.setIcon(GWT.getHostPageBaseURL() + "images/icons/32/woofunction/add_32.png");
      newButton.setIconOrientation("right");
      newButton.addClickHandler(
          new ClickHandler() {
            public void onClick(ClickEvent event) {

              Map<String, Object> defaultValues = new HashMap<String, Object>();
              defaultValues.put("Class_id", criteria.getAttribute("Class_id"));
              grid.startEditingNew(defaultValues);
            }
          });

      buttonPanel.addMember(newButton);

      /*IButton printButton = new IButton(radosMessages.richTableView_print_button());*/
      IButton printButton = new IButton(radosMessages.richTableView_print_button());
      printButton.setShowRollOver(false);
      printButton.setIcon(GWT.getHostPageBaseURL() + "images/icons/32/woofunction/printer_32.png");
      printButton.setIconOrientation("right");

      // Img printButton = new
      // Img(GWT.getHostPageBaseURL()+"images/icons/32/woofunction/printer_32.png");
      // printButton.setSize(32);
      // printButton.setAltText(radosMessages.richTableView_print_button());
      printButton.addClickHandler(
          new ClickHandler() {
            public void onClick(ClickEvent event) {
              Canvas.showPrintPreview(grid);
            }
          });
      buttonPanel.addMember(printButton);

      EmailGridButtonWidget email = new EmailGridButtonWidget(new Canvas[] {grid});
      email.setDefaultMessage(targetMessages.name_single() + "overzicht");
      email.setDefaultSubject(targetMessages.name_single() + "overzicht");
      email.setDefaultFrom(BrioRaceSystemApplicationPanel.getUserdetails().getEmail());
      buttonPanel.addMember(email);

      ExportButtonWidget exportButton = new ExportButtonWidget(grid, dataSource);
      buttonPanel.addMember(exportButton);

      buttonPanel.setHeight(30);

      this.addMember(buttonPanel);
      this.addMember(grid);

      handleRights();
    }
  /** TODO: document */
  public WFSLayerSelector(final EventBus eventBus) {
    layerList =
        new ListGrid() {

          @Override
          protected Canvas createRecordComponent(final ListGridRecord record, Integer colNum) {
            String fieldName = this.getFieldName(colNum);
            if (fieldName.equals("addButton")) {
              final IButton button = new IButton();
              button.setHeight(18);
              button.setWidth(50);
              button.setTitle("Add");
              button.addClickHandler(
                  new ClickHandler() {
                    @Override
                    public void onClick(ClickEvent event) {
                      SC.showPrompt("Retrieving layer details...");

                      // Set up the callback object.
                      AsyncCallback<WFSDescribeFeatureTypeResponse> callback =
                          new AsyncCallback<WFSDescribeFeatureTypeResponse>() {
                            @Override
                            public void onFailure(Throwable caught) {
                              caught.printStackTrace();
                              SC.say("Failed to contact server");
                              SC.clearPrompt();
                            }

                            @Override
                            public void onSuccess(WFSDescribeFeatureTypeResponse result) {
                              GWT.log("SUCCESS");
                              WFSFeatureType featureType = result.getFeatureType();
                              HashSet<Data> layers = new HashSet<Data>(1);
                              layers.add(featureType);
                              eventBus.fireEvent(new AddLayersEvent(layers));
                              SC.clearPrompt();
                            }
                          };

                      // Make the call to the stock price service.
                      GWT.log("Making service call");
                      WFSFeatureTypeBase featureTypeBase =
                          ((WFSLayerRecord) record).getWFSFeatureType();
                      WFSDescribeFeatureTypeRequest request =
                          new WFSDescribeFeatureTypeRequest(featureTypeBase);
                      WFS_RPC_SERVICE.wfsDescribeFeatureType(request, callback);
                    }
                  });
              return button;
            }

            return null;
          }
        };
    layerList.setShowRecordComponents(true);
    layerList.setShowRecordComponentsByCell(true);

    ListGridField idField = new ListGridField("typename", "TypeName");
    ListGridField titleField = new ListGridField("title", "Title");
    ListGridField addField = new ListGridField("addButton", "Add");
    addField.setWidth(50);
    layerList.setFields(idField, titleField, addField);

    layerList.setWidth("*");
    layerList.setHeight100();

    this.addMember(layerList);
  }
    FlashUploadComponentImpl(final UploadComponentOptions options) {
      filesGrid.setHeight(100);
      filesGrid.setWidth100();
      if (options.isAllowMultiple()) {
        filesGrid.setEmptyMessage("No files selected.");
      } else {
        filesGrid.setEmptyMessage("File not selected.");
      }
      final ListGridField nameField = new ListGridField("name", "File Name");
      nameField.setType(ListGridFieldType.TEXT);
      nameField.setWidth("*");

      filesGrid.setFields(nameField);

      final UploadBuilder builder = new UploadBuilder();
      // Configure which file types may be selected
      if (options.getTypes() != null) {
        builder.setFileTypes(options.getTypes());
      }
      if (options.getTypesDescription() != null) {
        builder.setFileTypesDescription(options.getTypesDescription());
      }
      if (options.getTypesDescription() != null) {
        builder.setFileTypesDescription(options.getTypesDescription());
      }
      clientId = getUniqueId();

      final HTMLPane pane = new HTMLPane();
      pane.setHeight(22);
      builder.setButtonPlaceholderID(clientId);
      builder.setButtonHeight(22);
      builder.setButtonWidth(100);
      pane.setWidth(100);
      if (options.isAllowMultiple()) {
        builder.setButtonImageURL(GWT.getHostPageBaseURL() + "images/uploadImageAddFiles.jpg");
      } else {
        builder.setButtonImageURL(GWT.getHostPageBaseURL() + "images/uploadImageChooseFile.jpg");
      }
      // Use ButtonAction.SELECT_FILE to only allow selection of a single file

      builder.setButtonAction(
          options.isAllowMultiple() ? ButtonAction.SELECT_FILES : ButtonAction.SELECT_FILE);
      builder.setFileQueuedHandler(
          new FileQueuedHandler() {
            public void onFileQueued(final FileQueuedEvent queuedEvent) {
              if (!options.isAllowMultiple()) {
                SmartUtils.removeAllRecords(filesGrid);
              }
              final ListGridRecord record = new ListGridRecord();
              record.setAttribute("id", queuedEvent.getFile().getId());
              record.setAttribute("name", queuedEvent.getFile().getName());
              filesGrid.addData(record);
            }
          });
      builder.setUploadSuccessHandler(
          new UploadSuccessHandler() {
            public void onUploadSuccess(final UploadSuccessEvent uploadEvent) {
              try {
                filesUploaded++;
                bytesUploaded += uploadEvent.getFile().getSize();
                final String serverResponse = uploadEvent.getServerData();
                fileSources.addAll(toFileSources(serverResponse));
                updateUrl();
                if (upload.getStats().getFilesQueued() > 0) {
                  upload.startUpload();
                } else {
                  options.getCompletionCallback().onSuccess(fileSources);
                }
              } catch (final Exception e) {
                options.getCompletionCallback().onFailure(e);
              }
            }
          });
      builder.setUploadErrorHandler(
          new UploadErrorHandler() {
            public void onUploadError(final UploadErrorEvent e) {
              options
                  .getCompletionCallback()
                  .onFailure(new Exception("Upload failed " + e.getMessage()));
            }
          });

      // The button to start the transfer
      final Layout parent = getParentCanvas(options);
      setWidget(parent);

      // pane.setMargin(5);
      pane.setContents("<span id=\"" + clientId + "\" />");
      reg =
          get()
              .addDrawHandler(
                  new DrawHandler() {
                    public void onDraw(final DrawEvent event) {
                      upload = builder.build();
                      reg.removeHandler();
                    }
                  });
      final Button removeButton = SmartUtils.getButton("Remove File", Resources.CROSS);
      removeButton.addClickHandler(
          new ClickHandler() {
            public void onClick(final ClickEvent event) {
              final ListGridRecord record = filesGrid.getSelectedRecord();
              final String id = record.getAttribute("id");
              filesGrid.removeData(record);
              upload.cancelUpload(id, false);
            }
          });
      SmartUtils.enabledWhenHasSelection(removeButton, filesGrid);
      removeButton.setDisabled(true);
      if (!options.isAllowMultiple()) {
        removeButton.hide();
      }

      final CanvasWithOpsLayout<ClientListGrid> layout =
          new CanvasWithOpsLayout<ClientListGrid>(filesGrid, pane, removeButton);
      if (debug) {
        layout.setBorder("1px solid red");
        parent.setBorder("1px solid orange");
      }
      parent.addMember(layout);
    }
    TableListGrid(String[] intervals, HashMap<String, Integer[]> userValues) {
      setWidth100();

      if (userValues.size() < 6) {
        setHeight(userValues.size() * 25 + 30);
      }
      setShowAllRecords(true);
      setCanDragSelect(true);

      List<ListGridField> fields = new ArrayList<ListGridField>();
      int fieldsIndex = 0;

      if (userValues.size() > 1) {
        ListGridField nameField =
            new ListGridField(Constants.ATTR_NAME, HtmlCode.bold(lang.name()));
        nameField.setWidth(140);
        fields.add(nameField);
      }
      ArrayList<Integer> indexes = new ArrayList<Integer>();

      for (String interv : intervals) {
        for (String user : userValues.keySet()) {
          if (userValues.get(user)[fieldsIndex] > 0) {
            indexes.add(fieldsIndex);
            fields.add(
                new ListGridField(
                    Constants.ATTR_INTERVAL + fieldsIndex, interv.replaceAll(" ", "")));
            break;
          }
        }
        fieldsIndex++;
      }

      Integer layoutWidth = UserStatisticsLayout.this.getWidth();
      int width = indexes.size() * 115 + (userValues.size() > 1 ? 200 : 65);
      if (width < layoutWidth - 10) setWidth(width);

      fields.add(new ListGridField(Constants.ATTR_OBJECT, HtmlCode.bold(lang.inTotal())));
      ListGridField[] fieldsArray = new ListGridField[fields.size()];
      fields.toArray(fieldsArray);
      setFields(fieldsArray);

      ListGridRecord[] records =
          new ListGridRecord
              [intervals.length > userValues.size() ? intervals.length : userValues.size()];

      fieldsIndex = 0;
      for (String user : userValues.keySet()) {

        ListGridRecord userRecord = new ListGridRecord();
        if (userValues.size() > 1)
          userRecord.setAttribute(Constants.ATTR_NAME, HtmlCode.bold(user));

        int overall = 0;
        for (Integer ind : indexes) {
          int val = userValues.get(user)[ind];
          overall += val;
          userRecord.setAttribute(Constants.ATTR_INTERVAL + ind, val);
        }
        userRecord.setAttribute(Constants.ATTR_OBJECT, HtmlCode.bold(String.valueOf(overall)));
        records[fieldsIndex++] = userRecord;
      }
      setData(records);
    }
    @Override
    public ArrayList<ListGridField> getListGridFields() {
      ArrayList<ListGridField> fields = super.getListGridFields();

      // hide the created/modified fields, we don't need to show them by default
      // add cell formatter on the name field so we can make it a link
      for (ListGridField field : fields) {
        String fieldName = field.getName();
        if (fieldName.equals(FIELD_CTIME) || fieldName.equals(FIELD_MTIME)) {
          field.setHidden(true);
        } else if (fieldName.equals(FIELD_NAME)) {
          field.setCellFormatter(
              new CellFormatter() {
                @Override
                public String format(Object value, ListGridRecord record, int rowNum, int colNum) {
                  AlertDefinition alertDef = copyValues(record);
                  int resourceId = alertDef.getResource().getId();
                  int alertDefId = alertDef.getId();
                  String link = LinkManager.getSubsystemAlertDefinitionLink(resourceId, alertDefId);
                  return "<a href=\""
                      + link
                      + "\">"
                      + StringUtility.escapeHtml(alertDef.getName())
                      + "</a>";
                }
              });
        }
      }

      // add more columns
      ListGridField parentField = new ListGridField(FIELD_PARENT, MSG.view_alerts_field_parent());
      parentField.setWidth(100);
      parentField.setShowHover(true);
      parentField.setHoverCustomizer(
          new HoverCustomizer() {
            @Override
            public String hoverHTML(Object value, ListGridRecord record, int rowNum, int colNum) {
              if (record.getAttribute(FIELD_PARENT) != null) {
                return MSG.view_reports_alertDefinitions_parentHover();
              }
              return MSG.common_val_na();
            }
          });
      parentField.addRecordClickHandler(
          new RecordClickHandler() {
            @Override
            public void onRecordClick(RecordClickEvent event) {
              // we only do something if we really have a parent.
              // if we have a template parent, we have to get the resource's type and go to the
              // template page for that type
              // if we have a group parent, we can directly go to the group's alert def page
              Record record = event.getRecord();
              AlertDefinition alertDef = copyValues(record);
              if (alertDef.getParentId() != null && alertDef.getParentId().intValue() > 0) {
                final Integer templateId = alertDef.getParentId().intValue();
                final Integer resourceId = alertDef.getResource().getId();

                ResourceCriteria resCriteria = new ResourceCriteria();
                resCriteria.addFilterId(resourceId);
                resCriteria.fetchResourceType(true);

                GWTServiceLookup.getResourceService()
                    .findResourcesByCriteria(
                        resCriteria,
                        new AsyncCallback<PageList<Resource>>() {
                          @Override
                          public void onSuccess(PageList<Resource> result) {
                            if (result == null || result.size() != 1) {
                              CoreGUI.getErrorHandler()
                                  .handleError(
                                      MSG.view_reports_alertDefinitions_resTypeLoadError());
                            } else {
                              int typeId = result.get(0).getResourceType().getId();
                              CoreGUI.goToView(
                                  LinkManager.getAdminTemplatesLink()
                                      + "/Alert/"
                                      + typeId
                                      + "/"
                                      + templateId);
                            }
                          }

                          @Override
                          public void onFailure(Throwable caught) {
                            CoreGUI.getErrorHandler()
                                .handleError(
                                    MSG.view_reports_alertDefinitions_resTypeLoadError(), caught);
                          }
                        });
              } else if (alertDef.getGroupAlertDefinition() != null) {
                AlertDefinition groupAlertDef = alertDef.getGroupAlertDefinition();
                CoreGUI.goToView(
                    LinkManager.getEntityTabLink(
                            EntityContext.forGroup(groupAlertDef.getResourceGroup()),
                            "Alert",
                            "Definitions")
                        + "/"
                        + groupAlertDef.getId());
              }
            }
          });
      fields.add(parentField);

      ListGridField resourceField = new ListGridField(FIELD_RESOURCE, MSG.common_title_resource());
      resourceField.setCellFormatter(
          new CellFormatter() {
            public String format(Object value, ListGridRecord listGridRecord, int i, int i1) {
              String url =
                  LinkManager.getResourceLink(
                      listGridRecord.getAttributeAsInt(AncestryUtil.RESOURCE_ID));
              return SeleniumUtility.getLocatableHref(
                  url, StringUtility.escapeHtml(value.toString()), null);
            }
          });
      resourceField.setShowHover(true);
      resourceField.setHoverCustomizer(
          new HoverCustomizer() {
            public String hoverHTML(
                Object value, ListGridRecord listGridRecord, int rowNum, int colNum) {
              return AncestryUtil.getResourceHoverHTML(listGridRecord, 0);
            }
          });
      fields.add(resourceField);

      ListGridField ancestryField = AncestryUtil.setupAncestryListGridField();
      fields.add(ancestryField);

      return fields;
    }
  private void init() {

    this.ownRulesGrid = new OwnRulesListGrid();
    this.otherRulesGrid = new OtherUserRulesListGrid();

    // grid fields
    ListGridField typeField = new ListGridField(EDIT_RULES_TYPE, i18n.type());
    typeField.setWidth(60);
    typeField.setAlign(Alignment.CENTER);

    ListGridField nameField = new ListGridField(EDIT_RULES_NAME, i18n.name());
    nameField.setAlign(Alignment.CENTER);

    ListGridField descriptionField = new ListGridField(EDIT_RULES_DESCRIPTION, i18n.description());
    descriptionField.setAlign(Alignment.CENTER);

    ListGridField editField = new ListGridField(EDIT_RULES_EDIT, i18n.edit());
    editField.setWidth(110);
    editField.setCanFilter(false);
    editField.setAlign(Alignment.CENTER);

    ListGridField publishField = new ListGridField(EDIT_RULES_PUBLISHED, i18n.publishButton());
    publishField.setWidth(130);
    publishField.setCanFilter(false);
    publishField.setAlign(Alignment.CENTER);

    ListGridField deleteField = new ListGridField(EDIT_RULES_DELETE, i18n.delete());
    deleteField.setWidth(110);
    deleteField.setCanFilter(false);
    deleteField.setAlign(Alignment.CENTER);

    ListGridField copyField = new ListGridField(EDIT_RULES_COPY, i18n.copy());
    copyField.setWidth(110);
    copyField.setCanFilter(false);
    copyField.setAlign(Alignment.CENTER);

    // fill grid with rows and data
    ListGridField[] ownRulesFields =
        new ListGridField[] {
          typeField, nameField, descriptionField, editField, publishField, deleteField
        };
    this.ownRulesGrid.setFields(ownRulesFields);
    this.ownRulesGrid.setCanResizeFields(false);

    ListGridField[] otherRulesfields =
        new ListGridField[] {typeField, nameField, descriptionField, copyField};
    this.otherRulesGrid.setDefaultFields(otherRulesfields);
    this.otherRulesGrid.setCanResizeFields(false);

    this.form.setFields(this.headerItem);

    DynamicForm headerForm1 = new DynamicForm();
    HeaderItem header1 = new HeaderItem();
    header1.setDefaultValue(i18n.ownRules());
    headerForm1.setItems(header1);

    DynamicForm headerForm2 = new DynamicForm();
    HeaderItem header2 = new HeaderItem();
    header2.setDefaultValue(i18n.otherRules());
    headerForm2.setItems(header2);

    // add to mainLayout
    addMember(this.form);
    addMember(this.spacer);
    addMember(headerForm1);
    addMember(this.ownRulesGrid);
    addMember(this.spacer);
    addMember(headerForm2);
    addMember(this.otherRulesGrid);
  }
Exemple #13
0
  public ListaVentas(final Sgc_capa_web mainWindow) {

    String PATH_IMG = "/sgc_capa_web/images/";
    VLayout layout = new VLayout(10);
    layout.setBackgroundColor("#006633");
    final ListGrid facturaGrid = new ListGrid();

    facturaGrid.setWidth(500);
    facturaGrid.setHeight(224);
    facturaGrid.setShowAllRecords(true);
    facturaGrid.setAlternateRecordStyles(true);
    facturaGrid.setShowEdges(true);
    facturaGrid.setBorder("0px");
    facturaGrid.setBodyStyleName("normal");
    facturaGrid.setLeaveScrollbarGap(false);
    facturaGrid.setBackgroundColor("#99ffcc");

    /*-Buscar ------------------------------*/
    DynamicForm buscarFields = new DynamicForm();
    // buscarFields.setBackgroundColor("#99ffcc");
    buscarFields.setItemLayout(FormLayoutType.ABSOLUTE);

    final TextItem codigoText = new TextItem("codigo");
    codigoText.setWrapTitle(false);
    codigoText.setLeft(10);
    codigoText.setWidth(43);
    codigoText.addKeyPressHandler(
        new KeyPressHandler() {
          public void onKeyPress(KeyPressEvent event) {
            if ("Enter".equals(event.getKeyName())) {
              /* buscar por el campo correspondiente */
              if (codigoText.getValue() != null) {

                Factura factura = new Factura();
                factura.setId(Integer.parseInt(codigoText.getValue().toString()));
                listar(facturaGrid, factura, "codigo");
              }
            }
          }
        });

    ButtonItem buscarButton = new ButtonItem("find", "");
    buscarButton.setIcon("view.png");
    buscarButton.setWidth(50);
    buscarButton.setLeft(443);
    buscarButton.addClickHandler(
        new ClickHandler() {
          @Override
          public void onClick(ClickEvent event) {
            /* buscar por el campo correspondiente */
            Factura factura = new Factura();

            if (codigoText.getValue() != null)
              factura.setId(Integer.parseInt(codigoText.getValue().toString()));
            /*if(nombreusuarioText.getValue() != null)
            cliente.setNombreusuario(nombreusuarioText.getValue().toString());*/
            listar(facturaGrid, factura, "nombre");
          }
        });

    buscarFields.setFields(codigoText, buscarButton);
    /*--------------------------------------*/

    ListGridField codigoField = new ListGridField("codigo", "Codigo");
    ListGridField fechaField = new ListGridField("fecha", "Fecha");
    ListGridField numeroField = new ListGridField("numero", "Numero");
    ListGridField pendienteField = new ListGridField("pendiente", "Pendiente");
    ListGridField saldoField = new ListGridField("saldo", "Saldo");
    ListGridField editarField = new ListGridField("edit", "Editar");
    ListGridField borrarField = new ListGridField("remove", "Borrar");

    codigoField.setAlign(Alignment.CENTER);
    editarField.setAlign(Alignment.CENTER);
    borrarField.setAlign(Alignment.CENTER);

    editarField.setType(ListGridFieldType.IMAGE);
    borrarField.setType(ListGridFieldType.IMAGE);

    editarField.setImageURLPrefix(PATH_IMG);
    borrarField.setImageURLPrefix(PATH_IMG);

    editarField.setImageURLSuffix(".png");
    borrarField.setImageURLSuffix(".png");

    facturaGrid.addCellClickHandler(
        new CellClickHandler() {
          @Override
          public void onCellClick(CellClickEvent event) {
            ListGridRecord record = event.getRecord();
            int col = event.getColNum();
            if (col > 4) {

              Factura factura = new Factura();
              factura.setId(record.getAttributeAsInt("codigo"));
              factura.setFecha(record.getAttributeAsDate("fecha"));
              factura.setNumero(Integer.parseInt(record.getAttribute("numero")));
              factura.setPendiente(record.getAttribute("pendiente"));
              factura.setSaldo(Double.parseDouble(record.getAttribute("saldo")));

              if (col == 5) {
                /* Editar */

                new VentaDetalle(factura, mainWindow);

              } else {
                /* Borrar */

                FacturaServiceAsync service = GWT.create(FacturaService.class);
                ServiceDefTarget serviceDef = (ServiceDefTarget) service;
                serviceDef.setServiceEntryPoint(GWT.getModuleBaseURL() + "facturaService");
                try {
                  service.eliminar(
                      record.getAttributeAsInt("codigo"),
                      new AsyncCallback<Void>() {

                        @Override
                        public void onFailure(Throwable caught) {
                          Window.alert(
                              "Ocurrio un error y no se puedo eliminar (objeto referenciado)"); // "
                          // +
                          // caught.getClass().getName() + " " + caught.getMessage()) ;
                        }

                        @Override
                        public void onSuccess(Void result) {
                          new ListaVentas(mainWindow);
                        }
                      });
                } catch (NumberFormatException e) {
                  e.printStackTrace();
                } catch (Exception e) {
                  e.printStackTrace();
                }
              }
            }
          }
        });

    codigoField.setWidth(50);
    fechaField.setWidth(180);
    numeroField.setWidth(50);
    pendienteField.setWidth(50);
    saldoField.setWidth(50);
    facturaGrid.setFields(
        codigoField, fechaField, numeroField, pendienteField, saldoField, editarField, borrarField);
    facturaGrid.setCanResizeFields(true);

    ButtonItem button = new ButtonItem("add", "Agregar");
    button.setStartRow(false);
    button.setWidth(80);
    button.setIcon("add.png");
    button.setAlign(Alignment.CENTER);
    button.addClickHandler(
        new ClickHandler() {
          @Override
          public void onClick(ClickEvent event) {
            new VentaDetalle(mainWindow);
          }
        });

    listar(facturaGrid, new Factura(), "nombre");

    Label label = new Label();
    label.setBackgroundColor("#99ffcc");
    label.setHeight(30);
    label.setWidth(500);
    label.setPadding(10);
    label.setAlign(Alignment.CENTER);
    label.setValign(VerticalAlignment.CENTER);
    label.setWrap(false);
    label.setShowEdges(true);
    label.setContents("<div style='color:black;font-size:15'><b>Lista de Ventas</b></div>");

    layout.addMember(label);
    layout.addMember(buscarFields);
    layout.addMember(facturaGrid);

    DynamicForm form = new DynamicForm();
    // form.setBackgroundColor("#99ffcc");
    form.setWidth(300);
    form.setItems(button);
    layout.addMember(form);
    mainWindow.showDialog(layout);
  }
Exemple #14
0
  @Override
  protected void configureTable() {
    getListGrid().setEmptyMessage(MSG.view_messageCenter_noRecentMessages());

    updateTitleCanvas(
        MSG.view_messageCenter_lastNMessages(
            String.valueOf(CoreGUI.getMessageCenter().getMaxMessages())));

    ListGridField severityField = new ListGridField(FIELD_SEVERITY);
    severityField.setType(ListGridFieldType.ICON);
    severityField.setAlign(Alignment.CENTER);
    severityField.setShowValueIconOnly(true);
    HashMap<String, String> severityIcons = new HashMap<String, String>(5);
    severityIcons.put(Severity.Blank.name(), getSeverityIcon(Severity.Blank));
    severityIcons.put(Severity.Info.name(), getSeverityIcon(Severity.Info));
    severityIcons.put(Severity.Warning.name(), getSeverityIcon(Severity.Warning));
    severityIcons.put(Severity.Error.name(), getSeverityIcon(Severity.Error));
    severityIcons.put(Severity.Fatal.name(), getSeverityIcon(Severity.Fatal));
    severityField.setValueIcons(severityIcons);
    severityField.setShowHover(true);
    severityField.setHoverCustomizer(
        new HoverCustomizer() {
          @Override
          public String hoverHTML(Object value, ListGridRecord record, int rowNum, int colNum) {
            try {
              Severity severity =
                  ((Message) record.getAttributeAsObject(FIELD_OBJECT)).getSeverity();
              switch (severity) {
                case Info:
                  return MSG.common_severity_info();
                case Warning:
                  return MSG.common_severity_warn();
                case Error:
                  return MSG.common_severity_error();
                case Fatal:
                  return MSG.common_severity_fatal();
              }
            } catch (Throwable e) {
              Log.error("Cannot get severity hover", e);
            }
            return null;
          }
        });
    severityField.setSortNormalizer(
        new SortNormalizer() {
          @Override
          public Object normalize(ListGridRecord record, String fieldName) {
            try {
              Severity severity =
                  ((Message) record.getAttributeAsObject(FIELD_OBJECT)).getSeverity();
              return Integer.valueOf(severity.ordinal());
            } catch (Throwable e) {
              Log.error("Cannot get sort nomalizer", e);
            }
            return Integer.valueOf(0);
          }
        });

    ListGridField timeField = new ListGridField(FIELD_TIME, MSG.view_messageCenter_messageTime());
    timeField.setType(ListGridFieldType.TIME);
    timeField.setAttribute("displayFormat", TimeFormatter.TOPADDEDTIME);
    timeField.setAlign(Alignment.LEFT);
    timeField.setShowHover(true);
    timeField.setHoverCustomizer(TimestampCellFormatter.getHoverCustomizer(FIELD_TIME));

    ListGridField messageField =
        new ListGridField(FIELD_CONCISEMESSAGE, MSG.common_title_message());

    severityField.setWidth(25);
    timeField.setWidth("15%");
    messageField.setWidth("*");

    getListGrid().setFields(severityField, timeField, messageField);

    setListGridDoubleClickHandler(
        new DoubleClickHandler() {
          @Override
          public void onDoubleClick(DoubleClickEvent event) {
            try {
              ListGrid listGrid = (ListGrid) event.getSource();
              ListGridRecord[] selectedRows = listGrid.getSelection();
              if (selectedRows != null && selectedRows.length > 0) {
                Message message =
                    (Message)
                        selectedRows[0].getAttributeAsObject(
                            FIELD_OBJECT); // show the first selected
                showDetails(message);
              }
            } catch (Throwable e) {
              Log.error("Cannot show details for message", e);
            }
          }
        });

    addTableAction(
        extendLocatorId("delete"),
        MSG.common_button_delete(),
        MSG.common_msg_areYouSure(),
        new AbstractTableAction(TableActionEnablement.ANY) {
          @Override
          public void executeAction(ListGridRecord[] selection, Object actionValue) {
            try {
              for (ListGridRecord record : selection) {
                Object doomed = record.getAttributeAsObject(FIELD_OBJECT);
                CoreGUI.getMessageCenter().getMessages().remove(doomed);
              }
              refresh();
            } catch (Throwable e) {
              Log.error("Cannot delete messages", e);
            }
          }
        });

    addTableAction(
        extendLocatorId("deleteAll"),
        MSG.common_button_delete_all(),
        MSG.common_msg_areYouSure(),
        new AbstractTableAction(TableActionEnablement.ALWAYS) {
          @Override
          public void executeAction(ListGridRecord[] selection, Object actionValue) {
            try {
              CoreGUI.getMessageCenter().getMessages().clear();
              refresh();
            } catch (Throwable e) {
              Log.error("Cannot delete all messages", e);
            }
          }
        });

    LinkedHashMap<String, Integer> maxMessagesMap = new LinkedHashMap<String, Integer>();
    maxMessagesMap.put("10", Integer.valueOf("10"));
    maxMessagesMap.put("25", Integer.valueOf("25"));
    maxMessagesMap.put("50", Integer.valueOf("50"));
    maxMessagesMap.put("100", Integer.valueOf("100"));
    maxMessagesMap.put("200", Integer.valueOf("200"));
    addTableAction(
        extendLocatorId("maxMessageMenu"),
        MSG.view_messageCenter_maxMessages(),
        null,
        maxMessagesMap,
        new AbstractTableAction(TableActionEnablement.ALWAYS) {
          @Override
          public void executeAction(ListGridRecord[] selection, Object actionValue) {
            try {
              Integer maxSize = (Integer) actionValue;
              CoreGUI.getMessageCenter().setMaxMessages(maxSize.intValue());
              updateTitleCanvas(MSG.view_messageCenter_lastNMessages(maxSize.toString()));
              refresh();
            } catch (Throwable e) {
              Log.error("Cannot set max messages", e);
            }
          }
        });

    /*
    // TODO only for testing, remove this when done testing
    addTableAction(extendLocatorId("test"), "TEST MSG", null,
        new AbstractTableAction(TableActionEnablement.ALWAYS) {
            @Override
            public void executeAction(ListGridRecord[] selection, Object actionValue) {
                for (Severity severity : java.util.EnumSet.allOf(Severity.class)) {
                    Message m = new Message(severity.name() + ':' + System.currentTimeMillis(), severity);
                    CoreGUI.getMessageCenter().notify(m);
                }
            }
        });
    */

    // initial population of the list with current messages
    try {
      refresh();
    } catch (Throwable e) {
      Log.error("Cannot perform initial refresh", e);
    }
  }
Exemple #15
0
  private void initColumns(List<String> currencyGroupList) {

    if (currencyGroupList.size() > 0) {
      List<ListGridField> currencyFieldList = new LinkedList<ListGridField>();

      ListGridField dateField = new ListGridField("dt", constants.date());
      dateField.setAlign(Alignment.CENTER);
      dateField.setCellFormatter(
          new CellFormatter() {

            @Override
            public String format(Object value, ListGridRecord record, int rowNum, int colNum) {
              if (value instanceof Date) {
                DateTimeFormat dateFormatter = DateTimeFormat.getFormat("dd.MM.yyyy");
                Date date = (Date) value;
                String format = dateFormatter.format(date);
                return format;
              } else if (value != null) return value.toString();
              else return null;
            }
          });
      currencyFieldList.add(dateField);

      CustomValidator customValidator =
          new CustomValidator() {
            protected boolean condition(Object value) {
              try {
                if (value instanceof Float) {
                  return (Float) value > 0.0;
                } else if (value instanceof Integer) {
                  return ((Integer) value).floatValue() > 0.0;
                } else {
                  Float result = Float.parseFloat((String) value);
                  return result > 0.0;
                }
              } catch (Exception ex) {
              }
              return false;
            }
          };

      FloatItem floatItem = new FloatItem();
      floatItem.setEditorValueFormatter(
          new FormItemValueFormatter() {

            @Override
            public String formatValue(
                Object value, Record record, DynamicForm form, FormItem item) {

              if (value == null) return "";
              String formattedValue = String.valueOf(value);
              formattedValue = formattedValue.replace('.', ',');
              return formattedValue;
            }
          });
      floatItem.setEditorValueParser(
          new FormItemValueParser() {

            @Override
            public Object parseValue(String value, DynamicForm form, FormItem item) {

              try {
                if (value != null) {
                  String newValue = value.replace(',', '.');
                  Float result = Float.parseFloat(newValue);
                  return result;
                }
              } catch (Exception ex) {
              }
              return null;
            }
          });

      for (int index = 0; index < currencyGroupList.size(); index++) {
        String currencyName = currencyGroupList.get(index);
        if (currencyName != null
            && !baseCurrencyPrefix.equals(currencyName)
            && !docCurrencyPrefix.equals(currencyName)) {
          ListGridField currencyField =
              new ListGridField(CurrencyRecord.IDENTITY_CURRENCY + currencyName, currencyName);
          currencyField.setCellFormatter(
              new CellFormatter() {
                public String format(Object value, ListGridRecord record, int rowNum, int colNum) {
                  if (value == null) {
                    return null;
                  } else {
                    NumberFormat nf = NumberFormat.getFormat("0.###");
                    try {
                      return nf.format((Number) value);
                    } catch (Exception e) {
                      return value.toString();
                    }
                  }
                }
              });
          currencyField.setAlign(Alignment.CENTER);
          currencyField.setRequired(true);
          currencyField.setValidators(customValidator);
          currencyField.setEditorType(floatItem);
          currencyFieldList.add(currencyField);
        }
      }

      // --------------------------------------------------------------------
      // 	Remove Row column
      // --------------------------------------------------------------------
      ListGridField removeField = new ListGridField("remove", constants.remove());
      removeField.setAlign(Alignment.CENTER);
      removeField.setType(ListGridFieldType.IMAGE);
      removeField.setCanEdit(false);
      removeField.setCanFilter(false);
      removeField.setCellFormatter(
          new CellFormatter() {

            @Override
            public String format(Object value, ListGridRecord record, int rowNum, int colNum) {

              return Canvas.imgHTML("[SKIN]/actions/remove.png");
            }
          });
      removeField.setWidth(60);
      currencyFieldList.add(removeField);
      ListGridField[] currencyFieldArray = new ListGridField[currencyFieldList.size()];
      currencyFieldList.toArray(currencyFieldArray);

      currencyGrid.setFields(currencyFieldArray);
    }
  }
  private void initWidgets() {
    addGoodsCategory = new AddGoodsCategory();

    mainLayout = new VLayout();
    gridLayout = new HLayout();
    gridLayout.setBackgroundColor("BurlyWood");
    gridLayout.setHeight100();
    gridLayout.setOverflow(Overflow.SCROLL);
    controlLayout = new HLayout();
    controlLayout.setMargin(10);
    controlLayout.setHeight(buttonSizeHeight);
    goodsCategoryList = new ListGrid();
    goodsCategoryList.setDataSource(DataSource.get("goodsCategory"));
    goodsCategoryList.setCanEdit(false);
    goodsCategoryList.setAutoSaveEdits(true);
    goodsCategoryList.setAutoFetchData(true);
    ListGridField goodsCategoryId = new ListGridField();
    goodsCategoryId.setTitle(Constants.GOODSCATEGORY_GOODSCATEGORYID_TITLE);
    goodsCategoryId.setName(Constants.GOODSCATEGORY_GOODSCATEGORYID);
    goodsCategoryId.setWidth("10%");
    ListGridField goodsCategoryShortNameTH = new ListGridField();
    goodsCategoryShortNameTH.setTitle(Constants.GOODSCATEGORY_GOODSCATEGORYSHORTNAME_TH_TITLE);
    goodsCategoryShortNameTH.setName(Constants.GOODSCATEGORY_GOODSCATEGORYSHORTNAME_TH);
    goodsCategoryShortNameTH.setWidth("10%");
    ListGridField goodsCategoryDetailsTH = new ListGridField();
    goodsCategoryDetailsTH.setTitle(Constants.GOODSCATEGORY_GOODSCATEGORYDETAILS_TH_TITLE);
    goodsCategoryDetailsTH.setName(Constants.GOODSCATEGORY_GOODSCATEGORYDETAILS_TH);
    goodsCategoryDetailsTH.setWidth("60%");

    goodsCategoryList.setFields(goodsCategoryId, goodsCategoryShortNameTH, goodsCategoryDetailsTH);
    goodsCategoryList.addRecordDoubleClickHandler(
        new RecordDoubleClickHandler() {
          @Override
          public void onRecordDoubleClick(RecordDoubleClickEvent event) {
            Record record = new Record();
            record.setAttribute("goodsCategory", event.getRecord());
            AddGoods.setGoodsCategoryAsRecord(record);
          }
        });

    submit = new IButton(Constants.BUTTON_TITLE_SUBMIT);
    submit.setMargin(1);
    cancel = new IButton(Constants.BUTTON_TITLE_CANCEL);
    cancel.setMargin(1);
    search = new IButton(Constants.BUTTON_TITLE_SEARCH);
    search.setMargin(1);

    add = new IButton(Constants.BUTTON_TITLE_ADD);
    add.setMargin(1);
    edit = new IButton(Constants.BUTTON_TITLE_EDIT);
    edit.setMargin(1);

    submit.setSize(buttonSizeHeight, buttonSizeHeight);
    cancel.setSize(buttonSizeHeight, buttonSizeHeight);
    search.setSize(buttonSizeHeight, buttonSizeHeight);

    add.setSize(buttonSizeWidth, buttonSizeHeight);
    edit.setSize(buttonSizeWidth, buttonSizeHeight);

    add.addClickHandler(
        new ClickHandler() {
          @Override
          public void onClick(ClickEvent event) {
            addGoodsCategory.showAddGoodsCategory();
          }
        });

    edit.addClickHandler(
        new ClickHandler() {
          @Override
          public void onClick(ClickEvent event) {
            addGoodsCategory.showAddGoodsCategory(
                Constants.RECORD_ACTION_EDIT, goodsCategoryList.getSelectedRecord());
          }
        });

    cancel.addClickHandler(
        new ClickHandler() {
          @Override
          public void onClick(ClickEvent event) {
            hide();
          }
        });

    submit.addClickHandler(
        new ClickHandler() {
          @Override
          public void onClick(ClickEvent event) {
            Record record = new Record();
            record.setAttribute("goodsCategory", goodsCategoryList.getSelectedRecord());
            // SC.say("GoodsCategoryList:"+"goodCategory");
            AddGoods.setGoodsCategoryAsRecord(record);
            hide();
          }
        });

    addKeyPressHandler(
        new KeyPressHandler() {
          @Override
          public void onKeyPress(KeyPressEvent event) {
            if (event.getKeyName().equals(KeyNames.ENTER)) {
              Record record = new Record();
              record.setAttribute("goodsCategory", goodsCategoryList.getSelectedRecord());
              AddGoods.setGoodsCategoryAsRecord(record);
              hide();
            }
            if (event.isAltKeyDown() && event.getKeyName().equals("A")) {
              addGoodsCategory.showAddGoodsCategory();
            }
            if (event.isAltKeyDown() && event.getKeyName().equals("E")) {
              addGoodsCategory.showAddGoodsCategory(
                  Constants.RECORD_ACTION_EDIT, goodsCategoryList.getSelectedRecord());
            }
          }
        });

    Canvas emptyButtonWSize = new Canvas();
    emptyButtonWSize.setSize(buttonSizeWidth, buttonSizeHeight);
    gridLayout.addMember(goodsCategoryList);
    controlLayout.addMembers(submit, cancel, search, emptyButtonWSize, add, edit);
    mainLayout.addMembers(gridLayout, controlLayout);

    setDataSectionBackgroundColor("Grey");
    addDataSection(mainLayout);
  }