1698 lines
56 KiB
Java
1698 lines
56 KiB
Java
package org.gcube.portlets.admin.accountingmanager.client.filters;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
|
|
import org.gcube.portlets.admin.accountingmanager.client.event.AccountingPeriodEvent;
|
|
import org.gcube.portlets.admin.accountingmanager.client.event.AccountingPeriodRequestEvent;
|
|
import org.gcube.portlets.admin.accountingmanager.client.event.SessionExpiredEvent;
|
|
import org.gcube.portlets.admin.accountingmanager.client.event.StateChangeEvent;
|
|
import org.gcube.portlets.admin.accountingmanager.client.monitor.AccountingMonitor;
|
|
import org.gcube.portlets.admin.accountingmanager.client.properties.AccountingFilterProperties;
|
|
import org.gcube.portlets.admin.accountingmanager.client.properties.GenresDataProperties;
|
|
import org.gcube.portlets.admin.accountingmanager.client.properties.GenresDataPropertiesCombo;
|
|
import org.gcube.portlets.admin.accountingmanager.client.resource.AccountingManagerResources;
|
|
import org.gcube.portlets.admin.accountingmanager.client.rpc.AccountingManagerServiceAsync;
|
|
import org.gcube.portlets.admin.accountingmanager.client.state.AccountingClientStateData;
|
|
import org.gcube.portlets.admin.accountingmanager.client.type.SessionExpiredType;
|
|
import org.gcube.portlets.admin.accountingmanager.client.util.UtilsGXT3;
|
|
import org.gcube.portlets.admin.accountingmanager.shared.data.AccountingFilter;
|
|
import org.gcube.portlets.admin.accountingmanager.shared.data.AccountingFilterBasic;
|
|
import org.gcube.portlets.admin.accountingmanager.shared.data.AccountingFilterContext;
|
|
import org.gcube.portlets.admin.accountingmanager.shared.data.AccountingFilterDefinition;
|
|
import org.gcube.portlets.admin.accountingmanager.shared.data.AccountingFilterSpaces;
|
|
import org.gcube.portlets.admin.accountingmanager.shared.data.AccountingFilterTop;
|
|
import org.gcube.portlets.admin.accountingmanager.shared.data.ChartType;
|
|
import org.gcube.portlets.admin.accountingmanager.shared.data.FilterKey;
|
|
import org.gcube.portlets.admin.accountingmanager.shared.data.FilterValue;
|
|
import org.gcube.portlets.admin.accountingmanager.shared.data.FilterValuesRequest;
|
|
import org.gcube.portlets.admin.accountingmanager.shared.data.FilterValuesResponse;
|
|
import org.gcube.portlets.admin.accountingmanager.shared.data.GenresData;
|
|
import org.gcube.portlets.admin.accountingmanager.shared.data.Spaces;
|
|
import org.gcube.portlets.admin.accountingmanager.shared.exception.SessionExpiredException;
|
|
|
|
import com.allen_sauer.gwt.log.client.Log;
|
|
import com.google.gwt.cell.client.AbstractCell;
|
|
import com.google.gwt.core.client.GWT;
|
|
import com.google.gwt.editor.client.Editor;
|
|
import com.google.gwt.editor.client.Editor.Path;
|
|
import com.google.gwt.editor.client.EditorError;
|
|
import com.google.gwt.event.logical.shared.SelectionEvent;
|
|
import com.google.gwt.event.logical.shared.SelectionHandler;
|
|
import com.google.gwt.event.logical.shared.ValueChangeEvent;
|
|
import com.google.gwt.event.logical.shared.ValueChangeHandler;
|
|
import com.google.gwt.event.shared.EventBus;
|
|
import com.google.gwt.safehtml.shared.SafeHtml;
|
|
import com.google.gwt.safehtml.shared.SafeHtmlBuilder;
|
|
import com.google.gwt.safehtml.shared.SafeHtmlUtils;
|
|
import com.google.gwt.user.client.rpc.AsyncCallback;
|
|
import com.google.gwt.user.client.ui.HasValue;
|
|
import com.sencha.gxt.cell.core.client.ButtonCell.IconAlign;
|
|
import com.sencha.gxt.cell.core.client.form.ComboBoxCell.TriggerAction;
|
|
import com.sencha.gxt.core.client.IdentityValueProvider;
|
|
import com.sencha.gxt.core.client.Style.SelectionMode;
|
|
import com.sencha.gxt.core.client.XTemplates;
|
|
import com.sencha.gxt.core.client.util.Margins;
|
|
import com.sencha.gxt.core.client.util.ToggleGroup;
|
|
import com.sencha.gxt.data.shared.LabelProvider;
|
|
import com.sencha.gxt.data.shared.ListStore;
|
|
import com.sencha.gxt.data.shared.ModelKeyProvider;
|
|
import com.sencha.gxt.data.shared.PropertyAccess;
|
|
import com.sencha.gxt.dnd.core.client.DND.Feedback;
|
|
import com.sencha.gxt.dnd.core.client.DndDragStartEvent;
|
|
import com.sencha.gxt.dnd.core.client.DndDragStartEvent.DndDragStartHandler;
|
|
import com.sencha.gxt.dnd.core.client.GridDragSource;
|
|
import com.sencha.gxt.dnd.core.client.GridDropTarget;
|
|
import com.sencha.gxt.widget.core.client.button.ButtonBar;
|
|
import com.sencha.gxt.widget.core.client.button.TextButton;
|
|
import com.sencha.gxt.widget.core.client.container.BoxLayoutContainer.BoxLayoutData;
|
|
import com.sencha.gxt.widget.core.client.container.BoxLayoutContainer.BoxLayoutPack;
|
|
import com.sencha.gxt.widget.core.client.container.HBoxLayoutContainer;
|
|
import com.sencha.gxt.widget.core.client.container.HBoxLayoutContainer.HBoxLayoutAlign;
|
|
import com.sencha.gxt.widget.core.client.container.MarginData;
|
|
import com.sencha.gxt.widget.core.client.container.SimpleContainer;
|
|
import com.sencha.gxt.widget.core.client.container.VerticalLayoutContainer;
|
|
import com.sencha.gxt.widget.core.client.container.VerticalLayoutContainer.VerticalLayoutData;
|
|
import com.sencha.gxt.widget.core.client.event.BeforeStartEditEvent;
|
|
import com.sencha.gxt.widget.core.client.event.BeforeStartEditEvent.BeforeStartEditHandler;
|
|
import com.sencha.gxt.widget.core.client.event.CancelEditEvent;
|
|
import com.sencha.gxt.widget.core.client.event.CancelEditEvent.CancelEditHandler;
|
|
import com.sencha.gxt.widget.core.client.event.CompleteEditEvent;
|
|
import com.sencha.gxt.widget.core.client.event.CompleteEditEvent.CompleteEditHandler;
|
|
import com.sencha.gxt.widget.core.client.event.SelectEvent;
|
|
import com.sencha.gxt.widget.core.client.event.SelectEvent.SelectHandler;
|
|
import com.sencha.gxt.widget.core.client.form.ComboBox;
|
|
import com.sencha.gxt.widget.core.client.form.FieldLabel;
|
|
import com.sencha.gxt.widget.core.client.form.FieldSet;
|
|
import com.sencha.gxt.widget.core.client.form.IntegerSpinnerField;
|
|
import com.sencha.gxt.widget.core.client.form.Radio;
|
|
import com.sencha.gxt.widget.core.client.form.StringComboBox;
|
|
import com.sencha.gxt.widget.core.client.form.error.DefaultEditorError;
|
|
import com.sencha.gxt.widget.core.client.form.validator.EmptyValidator;
|
|
import com.sencha.gxt.widget.core.client.grid.CheckBoxSelectionModel;
|
|
import com.sencha.gxt.widget.core.client.grid.ColumnConfig;
|
|
import com.sencha.gxt.widget.core.client.grid.ColumnModel;
|
|
import com.sencha.gxt.widget.core.client.grid.Grid;
|
|
import com.sencha.gxt.widget.core.client.grid.Grid.GridCell;
|
|
import com.sencha.gxt.widget.core.client.grid.GridSelectionModel;
|
|
import com.sencha.gxt.widget.core.client.grid.editing.GridRowEditing;
|
|
import com.sencha.gxt.widget.core.client.toolbar.ToolBar;
|
|
|
|
/**
|
|
*
|
|
* @author Giancarlo Panichi
|
|
*
|
|
*
|
|
*/
|
|
public class ActiveFiltersPanel extends SimpleContainer {
|
|
|
|
private static final int TOP_NUMBER_DEFAULT = 5;
|
|
private static final int TOP_NUMBER_MAX = 10;
|
|
private static final int TOP_NUMBER_MIN = 1;
|
|
private EventBus eventBus;
|
|
private Grid<AccountingFilter> gridFilter;
|
|
private ListStore<AccountingFilter> storeFilter;
|
|
private Grid<GenresData> gridGenres;
|
|
private ListStore<GenresData> storeGenres;
|
|
private CheckBoxSelectionModel<GenresData> smGenres;
|
|
private ColumnConfig<GenresData, String> labelGenresCol;
|
|
private boolean addStatus;
|
|
private AccountingClientStateData accountingStateData;
|
|
private ListStore<FilterKey> storeComboFilterKey;
|
|
private ComboBox<FilterKey> comboFilterKey;
|
|
private ListStore<String> storeComboFilterValue;
|
|
private StringComboBox comboFilterValue;
|
|
private GridRowEditing<AccountingFilter> editing;
|
|
private TextButton addButton;
|
|
private int seq;
|
|
private FieldLabel comboChartTypeLabel;
|
|
private ListStore<ChartType> storeComboChartType;
|
|
private ComboBox<ChartType> comboChartType;
|
|
private ListStore<GenresData> storeComboScope;
|
|
private ComboBox<GenresData> comboScope;
|
|
private FieldLabel comboScopeLabel;
|
|
private ListStore<FilterKey> storeComboTopFilterKey;
|
|
private ComboBox<FilterKey> comboTopFilterKey;
|
|
private FieldLabel comboTopFilterKeyLabel;
|
|
private ToolBar toolBar;
|
|
// private CheckBox showOthers;
|
|
private FieldLabel showOthersLabel;
|
|
private FieldLabel noContextLabel;
|
|
private IntegerSpinnerField topNumber;
|
|
private FieldLabel topNumberLabel;
|
|
|
|
private FilterKey filterKey;
|
|
private boolean cancelValue;
|
|
private AccountingMonitor accountingMonitor;
|
|
|
|
private Radio showOthersYes;
|
|
private Radio showOthersNo;
|
|
private ToggleGroup showOthersToggle;
|
|
|
|
private Radio noContextYes;
|
|
private Radio noContextNo;
|
|
private ToggleGroup noContextToggle;
|
|
|
|
public interface FilterKeyPropertiesCombo extends PropertyAccess<FilterKey> {
|
|
|
|
@Path("id")
|
|
ModelKeyProvider<FilterKey> id();
|
|
|
|
LabelProvider<FilterKey> key();
|
|
|
|
}
|
|
|
|
/*
|
|
* public interface FilterValuePropertiesCombo extends
|
|
* PropertyAccess<FilterValue> {
|
|
*
|
|
* @Path("id") ModelKeyProvider<FilterValue> id();
|
|
*
|
|
* LabelProvider<FilterValue> value();
|
|
*
|
|
* }
|
|
*/
|
|
|
|
interface FilterKeyTemplates extends XTemplates {
|
|
@XTemplate("<span title=\"{value}\">{value}</span>")
|
|
SafeHtml format(String value);
|
|
}
|
|
|
|
interface FilterValueTemplates extends XTemplates {
|
|
@XTemplate("<span title=\"{value}\">{value}</span>")
|
|
SafeHtml format(String value);
|
|
}
|
|
|
|
public ActiveFiltersPanel(EventBus eventBus) {
|
|
super();
|
|
Log.debug("ActiveFiltersPanel");
|
|
this.eventBus = eventBus;
|
|
init();
|
|
create();
|
|
bindToEvents();
|
|
|
|
}
|
|
|
|
private void init() {
|
|
|
|
}
|
|
|
|
private void create() {
|
|
// Grid
|
|
AccountingFilterProperties props = GWT.create(AccountingFilterProperties.class);
|
|
|
|
ColumnConfig<AccountingFilter, FilterKey> keyColumn = new ColumnConfig<AccountingFilter, FilterKey>(
|
|
props.filterKey(), 130, "Key");
|
|
keyColumn.setMenuDisabled(true);
|
|
keyColumn.setCell(new AbstractCell<FilterKey>() {
|
|
|
|
@Override
|
|
public void render(Context context, FilterKey filterKey, SafeHtmlBuilder sb) {
|
|
FilterKeyTemplates filterKeyTemplates = GWT.create(FilterKeyTemplates.class);
|
|
sb.append(filterKeyTemplates.format(filterKey.getKey()));
|
|
}
|
|
});
|
|
|
|
/*
|
|
* ColumnConfig<AccountingFilter, FilterValue> valueColumn = new
|
|
* ColumnConfig<AccountingFilter, FilterValue>( props.filterValue(),
|
|
* 130, "Value"); valueColumn.setMenuDisabled(true);
|
|
* valueColumn.setCell(new AbstractCell<FilterValue>() {
|
|
*
|
|
* @Override public void render(Context context, FilterValue
|
|
* filterValue, SafeHtmlBuilder sb) { FilterValueTemplates
|
|
* filterValueTemplates = GWT .create(FilterValueTemplates.class);
|
|
* sb.append(filterValueTemplates.format(filterValue.getValue())); } });
|
|
*/
|
|
|
|
ColumnConfig<AccountingFilter, String> valueColumn = new ColumnConfig<AccountingFilter, String>(
|
|
props.filterValue(), 130, "Value");
|
|
valueColumn.setMenuDisabled(true);
|
|
valueColumn.setCell(new AbstractCell<String>() {
|
|
|
|
@Override
|
|
public void render(Context context, String filterValue, SafeHtmlBuilder sb) {
|
|
FilterValueTemplates filterValueTemplates = GWT.create(FilterValueTemplates.class);
|
|
sb.append(filterValueTemplates.format(filterValue));
|
|
}
|
|
});
|
|
|
|
ArrayList<ColumnConfig<AccountingFilter, ?>> l = new ArrayList<ColumnConfig<AccountingFilter, ?>>();
|
|
l.add(keyColumn);
|
|
l.add(valueColumn);
|
|
|
|
ColumnModel<AccountingFilter> columns = new ColumnModel<AccountingFilter>(l);
|
|
|
|
storeFilter = new ListStore<AccountingFilter>(props.id());
|
|
|
|
final GridSelectionModel<AccountingFilter> sm = new GridSelectionModel<AccountingFilter>();
|
|
sm.setSelectionMode(SelectionMode.SINGLE);
|
|
|
|
gridFilter = new Grid<AccountingFilter>(storeFilter, columns);
|
|
gridFilter.setSelectionModel(sm);
|
|
gridFilter.getView().setStripeRows(true);
|
|
gridFilter.getView().setColumnLines(true);
|
|
gridFilter.getView().setAutoFill(true);
|
|
gridFilter.setBorders(true);
|
|
gridFilter.setColumnReordering(false);
|
|
gridFilter.getView().setAutoExpandColumn(valueColumn);
|
|
gridFilter.getView().setSortingEnabled(false);
|
|
|
|
GridDragSource<AccountingFilter> ds = new GridDragSource<AccountingFilter>(gridFilter);
|
|
ds.addDragStartHandler(new DndDragStartHandler() {
|
|
|
|
@Override
|
|
public void onDragStart(DndDragStartEvent event) {
|
|
@SuppressWarnings("unchecked")
|
|
ArrayList<AccountingFilter> draggingSelection = (ArrayList<AccountingFilter>) event.getData();
|
|
Log.debug("Start Drag: " + draggingSelection);
|
|
|
|
}
|
|
});
|
|
GridDropTarget<AccountingFilter> dt = new GridDropTarget<AccountingFilter>(gridFilter);
|
|
dt.setFeedback(Feedback.BOTH);
|
|
dt.setAllowSelfAsSource(true);
|
|
|
|
// EDITING //
|
|
// Key
|
|
FilterKeyPropertiesCombo filterKeyPropertiesCombo = GWT.create(FilterKeyPropertiesCombo.class);
|
|
|
|
storeComboFilterKey = new ListStore<FilterKey>(filterKeyPropertiesCombo.id());
|
|
|
|
comboFilterKey = new ComboBox<FilterKey>(storeComboFilterKey, filterKeyPropertiesCombo.key());
|
|
comboFilterKey.setClearValueOnParseError(false);
|
|
comboFilterKey.setEditable(false);
|
|
comboFilterKey.addValidator(new EmptyValidator<FilterKey>() {
|
|
|
|
@Override
|
|
public List<EditorError> validate(Editor<FilterKey> editor, FilterKey value) {
|
|
if (value == null || value.getKey() == null || value.getKey().isEmpty()) {
|
|
List<EditorError> errors = new ArrayList<EditorError>();
|
|
errors.add(new DefaultEditorError(editor, getMessages().blankText(), ""));
|
|
return errors;
|
|
}
|
|
return null;
|
|
}
|
|
});
|
|
comboFilterKey.setTriggerAction(TriggerAction.ALL);
|
|
addHandlersForComboFilterKey(filterKeyPropertiesCombo.key());
|
|
|
|
// Value
|
|
/*
|
|
* FilterValuePropertiesCombo filterValuePropertiesCombo = GWT
|
|
* .create(FilterValuePropertiesCombo.class);
|
|
*/
|
|
storeComboFilterValue = new ListStore<String>(new ModelKeyProvider<String>() {
|
|
|
|
@Override
|
|
public String getKey(String item) {
|
|
return item;
|
|
}
|
|
});
|
|
|
|
comboFilterValue = new StringComboBox();
|
|
comboFilterValue.setStore(storeComboFilterValue);
|
|
comboFilterValue.setClearValueOnParseError(false);
|
|
comboFilterValue.setEditable(true);
|
|
comboFilterValue.setForceSelection(false);
|
|
// comboFilterValue.setAllowBlank(false);
|
|
|
|
// comboFilterValue.setFinishEditOnEnter(false);
|
|
// comboFilterValue.setAutoValidate(true);
|
|
comboFilterValue.addValidator(new EmptyValidator<String>());
|
|
|
|
comboFilterValue.setTriggerAction(TriggerAction.ALL);
|
|
|
|
// final TextField valueField = new TextField();
|
|
// valueField.addValidator(new EmptyValidator<String>());
|
|
|
|
editing = new GridRowEditing<AccountingFilter>(gridFilter);
|
|
editing.addEditor(keyColumn, comboFilterKey);
|
|
editing.addEditor(valueColumn, comboFilterValue);
|
|
|
|
addButton = new TextButton("Add Filter");
|
|
addButton.setIcon(AccountingManagerResources.INSTANCE.accountingFilter24());
|
|
addButton.setIconAlign(IconAlign.RIGHT);
|
|
addButton.setToolTip("Add Filter");
|
|
addButton.addSelectHandler(new SelectHandler() {
|
|
|
|
@Override
|
|
public void onSelect(SelectEvent event) {
|
|
addNewFilter(event);
|
|
}
|
|
|
|
});
|
|
|
|
TextButton deleteBtn = new TextButton("Delete");
|
|
deleteBtn.addSelectHandler(new SelectEvent.SelectHandler() {
|
|
public void onSelect(SelectEvent event) {
|
|
GridCell cell = editing.getActiveCell();
|
|
int rowIndex = cell.getRow();
|
|
|
|
editing.cancelEditing();
|
|
|
|
storeFilter.remove(rowIndex);
|
|
storeFilter.commitChanges();
|
|
|
|
editing.getCancelButton().setVisible(true);
|
|
addButton.setEnabled(true);
|
|
if (addStatus) {
|
|
addStatus = false;
|
|
}
|
|
}
|
|
});
|
|
ButtonBar buttonBar = editing.getButtonBar();
|
|
buttonBar.add(deleteBtn);
|
|
|
|
editing.addBeforeStartEditHandler(new BeforeStartEditHandler<AccountingFilter>() {
|
|
|
|
@Override
|
|
public void onBeforeStartEdit(BeforeStartEditEvent<AccountingFilter> event) {
|
|
editingBeforeStart(event);
|
|
|
|
}
|
|
});
|
|
|
|
editing.addCancelEditHandler(new CancelEditHandler<AccountingFilter>() {
|
|
|
|
@Override
|
|
public void onCancelEdit(CancelEditEvent<AccountingFilter> event) {
|
|
storeFilter.rejectChanges();
|
|
addButton.setEnabled(true);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
editing.addCompleteEditHandler(new CompleteEditHandler<AccountingFilter>() {
|
|
|
|
@Override
|
|
public void onCompleteEdit(CompleteEditEvent<AccountingFilter> event) {
|
|
try {
|
|
// GridCell cell = event.getEditCell();
|
|
// int rowIndex = cell.getRow();
|
|
// AccountingFilter editingFilter =
|
|
// storeFilter.get(rowIndex);
|
|
|
|
if (addStatus) {
|
|
addStatus = false;
|
|
}
|
|
|
|
GWT.log("Complete Change on store filter");
|
|
storeFilter.commitChanges();
|
|
editing.getCancelButton().setVisible(true);
|
|
addButton.setEnabled(true);
|
|
|
|
} catch (Throwable e) {
|
|
Log.error("Error in RuleOnTableNewDefinitionCard: " + e.getLocalizedMessage());
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
});
|
|
|
|
//
|
|
toolBar = new ToolBar();
|
|
toolBar.add(addButton, new BoxLayoutData(new Margins(0)));
|
|
|
|
// ChartTypeSelection
|
|
|
|
storeComboChartType = new ListStore<ChartType>(new ModelKeyProvider<ChartType>() {
|
|
|
|
@Override
|
|
public String getKey(ChartType item) {
|
|
return item.name();
|
|
}
|
|
|
|
});
|
|
|
|
LabelProvider<ChartType> comboChartTypeLabelProvider = new LabelProvider<ChartType>() {
|
|
|
|
@Override
|
|
public String getLabel(ChartType item) {
|
|
|
|
return item.getLabel();
|
|
}
|
|
|
|
};
|
|
|
|
// /Grid Context
|
|
GenresDataProperties propsGenresData = GWT.create(GenresDataProperties.class);
|
|
|
|
IdentityValueProvider<GenresData> identity = new IdentityValueProvider<GenresData>();
|
|
smGenres = new CheckBoxSelectionModel<GenresData>(identity);
|
|
|
|
labelGenresCol = new ColumnConfig<GenresData, String>(propsGenresData.label(), 356, "Genres");
|
|
|
|
labelGenresCol.setCell(new AbstractCell<String>() {
|
|
|
|
@Override
|
|
public void render(Context context, String value, SafeHtmlBuilder sb) {
|
|
sb.appendHtmlConstant("<span style='white-space: normal;' title='" + SafeHtmlUtils.htmlEscape(value)
|
|
+ "'>" + SafeHtmlUtils.htmlEscape(value) + "</span>");
|
|
|
|
}
|
|
|
|
});
|
|
|
|
List<ColumnConfig<GenresData, ?>> lGenres = new ArrayList<ColumnConfig<GenresData, ?>>();
|
|
lGenres.add(smGenres.getColumn());
|
|
lGenres.add(labelGenresCol);
|
|
ColumnModel<GenresData> cmGenresData = new ColumnModel<GenresData>(lGenres);
|
|
|
|
storeGenres = new ListStore<GenresData>(propsGenresData.id());
|
|
|
|
gridGenres = new Grid<GenresData>(storeGenres, cmGenresData);
|
|
|
|
sm.setSelectionMode(SelectionMode.MULTI);
|
|
gridGenres.setHeight("130px");
|
|
gridGenres.setSelectionModel(smGenres);
|
|
gridGenres.getView().setStripeRows(true);
|
|
gridGenres.getView().setColumnLines(true);
|
|
gridGenres.getView().setAutoFill(true);
|
|
gridGenres.setBorders(true);
|
|
gridGenres.setColumnReordering(false);
|
|
gridGenres.getView().setAutoExpandColumn(labelGenresCol);
|
|
gridGenres.getView().setSortingEnabled(true);
|
|
|
|
// /
|
|
|
|
comboChartType = new ComboBox<>(storeComboChartType, comboChartTypeLabelProvider);
|
|
comboChartType.setClearValueOnParseError(false);
|
|
comboChartType.setEditable(false);
|
|
comboChartType.setForceSelection(true);
|
|
// comboFilterValue.setAllowBlank(false);
|
|
comboChartType.setValue(ChartType.Basic);
|
|
// comboFilterValue.setFinishEditOnEnter(false);
|
|
// comboFilterValue.setAutoValidate(true);
|
|
// comboFilterValue.addValidator(new EmptyValidator<String>());
|
|
comboChartType.setTriggerAction(TriggerAction.ALL);
|
|
addHandlersForComboChartType(comboChartTypeLabelProvider);
|
|
comboChartTypeLabel = new FieldLabel(comboChartType, "Chart");
|
|
|
|
// TODO ScopeCombo for Top and Basic
|
|
GenresDataPropertiesCombo genresDataPropertiesCombo = GWT.create(GenresDataPropertiesCombo.class);
|
|
|
|
storeComboScope = new ListStore<GenresData>(genresDataPropertiesCombo.id());
|
|
comboScope = new ComboBox<GenresData>(storeComboScope, genresDataPropertiesCombo.label());
|
|
comboScope.setClearValueOnParseError(false);
|
|
//comboScope.setEditable(false);
|
|
comboScope.setTypeAhead(true);
|
|
comboScope.setTriggerAction(TriggerAction.ALL);
|
|
|
|
comboScope.getListView().addStyleName(AccountingManagerResources.INSTANCE.accountingManagerCSS().getScopeListView());
|
|
|
|
addHandlersForComboScope(genresDataPropertiesCombo.label());
|
|
|
|
comboScopeLabel = new FieldLabel(comboScope, "Scope");
|
|
|
|
// FileterKeyCombo for Top Chart
|
|
storeComboTopFilterKey = new ListStore<FilterKey>(filterKeyPropertiesCombo.id());
|
|
|
|
comboTopFilterKey = new ComboBox<FilterKey>(storeComboTopFilterKey, filterKeyPropertiesCombo.key());
|
|
comboTopFilterKey.setClearValueOnParseError(false);
|
|
comboTopFilterKey.setEditable(false);
|
|
|
|
comboTopFilterKey.setTriggerAction(TriggerAction.ALL);
|
|
addHandlersForComboTopFilterKey(filterKeyPropertiesCombo.key());
|
|
|
|
comboTopFilterKeyLabel = new FieldLabel(comboTopFilterKey, "Key");
|
|
|
|
// ShowOthers
|
|
showOthersYes = new Radio();
|
|
showOthersYes.setBoxLabel("Yes");
|
|
|
|
showOthersNo = new Radio();
|
|
showOthersNo.setBoxLabel("No");
|
|
showOthersNo.setValue(true);
|
|
|
|
showOthersToggle = new ToggleGroup();
|
|
showOthersToggle.add(showOthersYes);
|
|
showOthersToggle.add(showOthersNo);
|
|
|
|
showOthersToggle.addValueChangeHandler(new ValueChangeHandler<HasValue<Boolean>>() {
|
|
|
|
@Override
|
|
public void onValueChange(ValueChangeEvent<HasValue<Boolean>> event) {
|
|
ToggleGroup group = (ToggleGroup) event.getSource();
|
|
Radio radio = (Radio) group.getValue();
|
|
Log.debug("ShowOthers selected: " + radio.getBoxLabel());
|
|
}
|
|
});
|
|
|
|
HBoxLayoutContainer hp = new HBoxLayoutContainer();
|
|
hp.setHBoxLayoutAlign(HBoxLayoutAlign.MIDDLE);
|
|
hp.setPack(BoxLayoutPack.START);
|
|
hp.add(showOthersYes, new BoxLayoutData(new Margins(0)));
|
|
hp.add(showOthersNo, new BoxLayoutData(new Margins(0)));
|
|
|
|
showOthersLabel = new FieldLabel(hp, "Show Others");
|
|
|
|
// TODO NoContext Flag
|
|
noContextYes = new Radio();
|
|
noContextYes.setBoxLabel("Yes");
|
|
|
|
noContextNo = new Radio();
|
|
noContextNo.setBoxLabel("No");
|
|
noContextNo.setValue(true);
|
|
|
|
noContextToggle = new ToggleGroup();
|
|
noContextToggle.add(noContextYes);
|
|
noContextToggle.add(noContextNo);
|
|
|
|
noContextToggle.addValueChangeHandler(new ValueChangeHandler<HasValue<Boolean>>() {
|
|
|
|
@Override
|
|
public void onValueChange(ValueChangeEvent<HasValue<Boolean>> event) {
|
|
ToggleGroup group = (ToggleGroup) event.getSource();
|
|
Radio radio = (Radio) group.getValue();
|
|
Log.debug("No Context selected: " + radio.getBoxLabel());
|
|
}
|
|
});
|
|
|
|
HBoxLayoutContainer hpNoContext = new HBoxLayoutContainer();
|
|
hpNoContext.setHBoxLayoutAlign(HBoxLayoutAlign.MIDDLE);
|
|
hpNoContext.setPack(BoxLayoutPack.START);
|
|
hpNoContext.add(noContextYes, new BoxLayoutData(new Margins(0)));
|
|
hpNoContext.add(noContextNo, new BoxLayoutData(new Margins(0)));
|
|
|
|
noContextLabel = new FieldLabel(hpNoContext, "No Context");
|
|
|
|
//
|
|
topNumber = new IntegerSpinnerField();
|
|
topNumber.setMaxValue(TOP_NUMBER_MAX);
|
|
topNumber.setMinValue(TOP_NUMBER_MIN);
|
|
topNumber.setAllowNegative(false);
|
|
topNumber.setAllowBlank(false);
|
|
topNumber.setValue(TOP_NUMBER_DEFAULT);
|
|
topNumber.setEditable(false);
|
|
|
|
topNumberLabel = new FieldLabel(topNumber, "Number");
|
|
|
|
// //
|
|
VerticalLayoutContainer vlc = new VerticalLayoutContainer();
|
|
|
|
vlc.add(comboChartTypeLabel, new VerticalLayoutData(1, -1, new Margins(0)));
|
|
vlc.add(comboScopeLabel, new VerticalLayoutData(1, -1, new Margins(0)));
|
|
vlc.add(gridGenres, new VerticalLayoutData(1, -1, new Margins(0)));
|
|
vlc.add(noContextLabel, new VerticalLayoutData(1, -1, new Margins(0)));
|
|
vlc.add(comboTopFilterKeyLabel, new VerticalLayoutData(1, -1, new Margins(0)));
|
|
vlc.add(showOthersLabel, new VerticalLayoutData(1, -1, new Margins(0)));
|
|
vlc.add(topNumberLabel, new VerticalLayoutData(1, -1, new Margins(0)));
|
|
vlc.add(toolBar, new VerticalLayoutData(1, -1, new Margins(0)));
|
|
vlc.add(gridFilter, new VerticalLayoutData(1, 1, new Margins(0)));
|
|
|
|
FieldSet fieldSet = new FieldSet();
|
|
fieldSet.setHeight("360px");
|
|
fieldSet.setHeadingHtml("<b>Active Filters</b>");
|
|
fieldSet.setCollapsible(false);
|
|
fieldSet.add(vlc);
|
|
|
|
add(fieldSet, new MarginData(0));
|
|
comboChartTypeLabel.setVisible(false);
|
|
comboScopeLabel.setVisible(false);
|
|
gridGenres.setVisible(false);
|
|
noContextLabel.setVisible(false);
|
|
comboTopFilterKeyLabel.setVisible(false);
|
|
showOthersLabel.setVisible(false);
|
|
topNumberLabel.setVisible(false);
|
|
}
|
|
|
|
// Bind to Events
|
|
private void bindToEvents() {
|
|
eventBus.addHandler(StateChangeEvent.TYPE, new StateChangeEvent.StateChangeEventHandler() {
|
|
|
|
@Override
|
|
public void onStateChange(StateChangeEvent event) {
|
|
Log.debug("Catch State Change Event");
|
|
doStateChangeCommand(event);
|
|
|
|
}
|
|
});
|
|
|
|
eventBus.addHandler(AccountingPeriodEvent.TYPE, new AccountingPeriodEvent.AccountingPeriodEventHandler() {
|
|
|
|
@Override
|
|
public void onPeriod(AccountingPeriodEvent event) {
|
|
Log.debug("Catch Accounting Period Event");
|
|
manageAccountingPeriodEvent(event);
|
|
|
|
}
|
|
});
|
|
}
|
|
|
|
private void doStateChangeCommand(StateChangeEvent event) {
|
|
if (event.getStateChangeType() == null) {
|
|
return;
|
|
}
|
|
switch (event.getStateChangeType()) {
|
|
case Restore:
|
|
onRestoreStateChange(event);
|
|
break;
|
|
case Update:
|
|
break;
|
|
default:
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
private void onRestoreStateChange(StateChangeEvent event) {
|
|
Log.debug("onRestoreStateChange: " + event);
|
|
if (event.getAccountingStateData() != null) {
|
|
|
|
accountingStateData = event.getAccountingStateData();
|
|
if (accountingStateData.getAccountingType() != null) {
|
|
switch (accountingStateData.getAccountingType()) {
|
|
case JOB:
|
|
case PORTLET:
|
|
case SERVICE:
|
|
case STORAGE:
|
|
case TASK:
|
|
List<ChartType> chartsTypeForDefault = new ArrayList<>(ChartType.asList());
|
|
Log.debug("ChartsType: " + chartsTypeForDefault);
|
|
chartsTypeForDefault.remove(ChartType.Spaces);
|
|
Log.debug("ChartsType after remove: " + chartsTypeForDefault);
|
|
storeComboChartType.clear();
|
|
storeComboChartType.addAll(chartsTypeForDefault);
|
|
storeComboChartType.commitChanges();
|
|
comboChartTypeLabel.setVisible(true);
|
|
break;
|
|
case SPACE:
|
|
List<ChartType> chartsTypeForSpace = new ArrayList<>();
|
|
chartsTypeForSpace.add(ChartType.Spaces);
|
|
Log.debug("ChartsType: " + chartsTypeForSpace);
|
|
storeComboChartType.clear();
|
|
storeComboChartType.addAll(chartsTypeForSpace);
|
|
storeComboChartType.commitChanges();
|
|
comboChartTypeLabel.setVisible(false);
|
|
break;
|
|
default:
|
|
storeComboChartType.clear();
|
|
storeComboChartType.commitChanges();
|
|
comboChartTypeLabel.setVisible(false);
|
|
break;
|
|
|
|
}
|
|
} else {
|
|
storeComboChartType.clear();
|
|
storeComboChartType.commitChanges();
|
|
comboChartTypeLabel.setVisible(false);
|
|
|
|
}
|
|
changeActiveFilters();
|
|
|
|
} else {
|
|
accountingStateData = null;
|
|
seq = 0;
|
|
}
|
|
Log.debug("Set seq to: " + seq);
|
|
forceLayout();
|
|
}
|
|
|
|
private void changeActiveFilters() {
|
|
storeComboFilterKey.clear();
|
|
storeComboFilterKey.addAll(accountingStateData.getAvailableFilterKeys());
|
|
storeComboFilterKey.commitChanges();
|
|
storeComboTopFilterKey.clear();
|
|
storeComboTopFilterKey.addAll(accountingStateData.getAvailableFilterKeys());
|
|
storeComboTopFilterKey.commitChanges();
|
|
|
|
ChartType chartType = accountingStateData.getSeriesRequest().getAccountingFilterDefinition().getChartType();
|
|
|
|
switch (chartType) {
|
|
case Basic:
|
|
changeActiveFiltersForBasic();
|
|
break;
|
|
case Top:
|
|
changeActiveFiltersForTop();
|
|
break;
|
|
case Context:
|
|
changeActiveFiltersForContext();
|
|
break;
|
|
case Spaces:
|
|
changeActiveFiltersForSpaces();
|
|
break;
|
|
|
|
default:
|
|
changeActiveFiltersForBasic();
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
private void changeActiveFiltersForBasic() {
|
|
if (accountingStateData.getSeriesRequest() != null
|
|
&& accountingStateData.getSeriesRequest().getAccountingFilterDefinition() != null && accountingStateData
|
|
.getSeriesRequest().getAccountingFilterDefinition() instanceof AccountingFilterBasic) {
|
|
AccountingFilterBasic accountingFilterBasic = (AccountingFilterBasic) accountingStateData.getSeriesRequest()
|
|
.getAccountingFilterDefinition();
|
|
|
|
if (accountingStateData.getAvailableContext().getContexts() != null
|
|
&& !accountingStateData.getAvailableContext().getContexts().isEmpty()) {
|
|
|
|
ArrayList<String> scopesAvailables = accountingStateData.getAvailableContext().getContexts();
|
|
ArrayList<GenresData> scopes = new ArrayList<>();
|
|
for (String scopeAvailable : scopesAvailables) {
|
|
scopes.add(new GenresData(scopeAvailable));
|
|
}
|
|
storeComboScope.clear();
|
|
storeComboScope.addAll(scopes);
|
|
storeComboScope.commitChanges();
|
|
if (accountingFilterBasic.getScope() != null && !accountingFilterBasic.getScope().isEmpty()) {
|
|
comboScope.setValue(new GenresData(accountingFilterBasic.getScope()));
|
|
} else {
|
|
comboScope.setValue(storeComboScope.get(0));
|
|
}
|
|
} else {
|
|
storeComboScope.clear();
|
|
storeComboScope.commitChanges();
|
|
}
|
|
|
|
|
|
if (accountingFilterBasic.getFilters() != null) {
|
|
List<AccountingFilter> filters = accountingFilterBasic.getFilters();
|
|
storeFilter.clear();
|
|
storeFilter.addAll(filters);
|
|
seq = 0;
|
|
for (AccountingFilter filter : filters) {
|
|
if (filter.getId() > seq) {
|
|
seq = filter.getId();
|
|
}
|
|
}
|
|
storeFilter.commitChanges();
|
|
} else {
|
|
storeFilter.clear();
|
|
storeFilter.commitChanges();
|
|
seq = 0;
|
|
}
|
|
|
|
if (accountingStateData.getRootScope()) {
|
|
noContextToggle.reset();
|
|
if (accountingFilterBasic.isNoContext()) {
|
|
noContextYes.setValue(true);
|
|
} else {
|
|
noContextNo.setValue(true);
|
|
}
|
|
noContextLabel.setVisible(true);
|
|
} else {
|
|
noContextToggle.reset();
|
|
noContextNo.setValue(true);
|
|
noContextLabel.setVisible(false);
|
|
}
|
|
|
|
} else {
|
|
storeFilter.clear();
|
|
storeFilter.commitChanges();
|
|
seq = 0;
|
|
|
|
if (accountingStateData.getAvailableContext().getContexts() != null
|
|
&& !accountingStateData.getAvailableContext().getContexts().isEmpty()) {
|
|
|
|
ArrayList<String> scopesAvailables = accountingStateData.getAvailableContext().getContexts();
|
|
ArrayList<GenresData> scopes = new ArrayList<>();
|
|
for (String scopeAvailable : scopesAvailables) {
|
|
scopes.add(new GenresData(scopeAvailable));
|
|
}
|
|
|
|
storeComboScope.clear();
|
|
storeComboScope.addAll(scopes);
|
|
storeComboScope.commitChanges();
|
|
comboScope.setValue(storeComboScope.get(0));
|
|
|
|
} else {
|
|
storeComboScope.clear();
|
|
storeComboScope.commitChanges();
|
|
}
|
|
|
|
|
|
if (accountingStateData.getRootScope()) {
|
|
noContextToggle.reset();
|
|
noContextNo.setValue(true);
|
|
noContextLabel.setVisible(true);
|
|
} else {
|
|
noContextToggle.reset();
|
|
noContextNo.setValue(true);
|
|
noContextLabel.setVisible(false);
|
|
}
|
|
|
|
}
|
|
|
|
comboChartType.setValue(ChartType.Basic);
|
|
comboScopeLabel.setVisible(true);
|
|
gridGenres.setVisible(false);
|
|
comboTopFilterKey.reset();
|
|
comboTopFilterKeyLabel.setVisible(false);
|
|
showOthersToggle.reset();
|
|
showOthersNo.setValue(true);
|
|
showOthersLabel.setVisible(false);
|
|
|
|
topNumber.reset();
|
|
topNumberLabel.setVisible(false);
|
|
forceLayout();
|
|
|
|
}
|
|
|
|
private void changeActiveFiltersForTop() {
|
|
if (accountingStateData.getSeriesRequest() != null
|
|
&& accountingStateData.getSeriesRequest().getAccountingFilterDefinition() != null && accountingStateData
|
|
.getSeriesRequest().getAccountingFilterDefinition() instanceof AccountingFilterTop) {
|
|
AccountingFilterTop accountingFilterTop = (AccountingFilterTop) accountingStateData.getSeriesRequest()
|
|
.getAccountingFilterDefinition();
|
|
|
|
if (accountingStateData.getAvailableContext().getContexts() != null
|
|
&& !accountingStateData.getAvailableContext().getContexts().isEmpty()) {
|
|
|
|
ArrayList<String> scopesAvailables = accountingStateData.getAvailableContext().getContexts();
|
|
ArrayList<GenresData> scopes = new ArrayList<>();
|
|
for (String scopeAvailable : scopesAvailables) {
|
|
scopes.add(new GenresData(scopeAvailable));
|
|
}
|
|
storeComboScope.clear();
|
|
storeComboScope.addAll(scopes);
|
|
storeComboScope.commitChanges();
|
|
if (accountingFilterTop.getScope() != null && !accountingFilterTop.getScope().isEmpty()) {
|
|
comboScope.setValue(new GenresData(accountingFilterTop.getScope()));
|
|
} else {
|
|
comboScope.setValue(storeComboScope.get(0));
|
|
}
|
|
} else {
|
|
storeComboScope.clear();
|
|
storeComboScope.commitChanges();
|
|
comboScope.reset();
|
|
}
|
|
|
|
if (accountingFilterTop.getFilterKey() != null) {
|
|
comboTopFilterKey.setValue(accountingFilterTop.getFilterKey());
|
|
topNumber.setValue(accountingFilterTop.getTopNumber());
|
|
|
|
// /////////
|
|
if (accountingFilterTop.getFilters() != null) {
|
|
List<AccountingFilter> filters = accountingFilterTop.getFilters();
|
|
storeFilter.clear();
|
|
storeFilter.addAll(filters);
|
|
seq = 0;
|
|
for (AccountingFilter filter : filters) {
|
|
if (filter.getId() > seq) {
|
|
seq = filter.getId();
|
|
}
|
|
}
|
|
storeFilter.commitChanges();
|
|
} else {
|
|
storeFilter.clear();
|
|
storeFilter.commitChanges();
|
|
seq = 0;
|
|
}
|
|
|
|
} else {
|
|
comboTopFilterKey.reset();
|
|
showOthersToggle.reset();
|
|
showOthersNo.setValue(true);
|
|
topNumber.reset();
|
|
topNumber.setValue(TOP_NUMBER_DEFAULT);
|
|
storeFilter.clear();
|
|
storeFilter.commitChanges();
|
|
seq = 0;
|
|
}
|
|
} else {
|
|
|
|
if (accountingStateData.getAvailableContext().getContexts() != null
|
|
&& !accountingStateData.getAvailableContext().getContexts().isEmpty()) {
|
|
|
|
ArrayList<String> scopesAvailables = accountingStateData.getAvailableContext().getContexts();
|
|
ArrayList<GenresData> scopes = new ArrayList<>();
|
|
for (String scopeAvailable : scopesAvailables) {
|
|
scopes.add(new GenresData(scopeAvailable));
|
|
}
|
|
storeComboScope.clear();
|
|
storeComboScope.addAll(scopes);
|
|
storeComboScope.commitChanges();
|
|
comboScope.setValue(storeComboScope.get(0));
|
|
|
|
} else {
|
|
storeComboScope.clear();
|
|
storeComboScope.commitChanges();
|
|
comboScope.reset();
|
|
}
|
|
|
|
comboScopeLabel.setVisible(true);
|
|
comboTopFilterKey.reset();
|
|
showOthersToggle.reset();
|
|
showOthersNo.setValue(true);
|
|
topNumber.reset();
|
|
topNumber.setValue(TOP_NUMBER_DEFAULT);
|
|
storeFilter.clear();
|
|
storeFilter.commitChanges();
|
|
seq = 0;
|
|
|
|
}
|
|
|
|
comboChartType.setValue(ChartType.Top);
|
|
gridGenres.setVisible(false);
|
|
comboTopFilterKeyLabel.setVisible(true);
|
|
showOthersLabel.setVisible(true);
|
|
noContextToggle.reset();
|
|
noContextNo.setValue(true);
|
|
noContextLabel.setVisible(false);
|
|
topNumberLabel.setVisible(true);
|
|
forceLayout();
|
|
}
|
|
|
|
private void changeActiveFiltersForContext() {
|
|
if (accountingStateData.getSeriesRequest() != null
|
|
&& accountingStateData.getSeriesRequest().getAccountingFilterDefinition() != null && accountingStateData
|
|
.getSeriesRequest().getAccountingFilterDefinition() instanceof AccountingFilterContext) {
|
|
AccountingFilterContext accountingFilterContext = (AccountingFilterContext) accountingStateData
|
|
.getSeriesRequest().getAccountingFilterDefinition();
|
|
if (accountingStateData.getAvailableContext() != null
|
|
&& accountingStateData.getAvailableContext().getContexts() != null
|
|
&& !accountingStateData.getAvailableContext().getContexts().isEmpty()) {
|
|
|
|
if (accountingFilterContext.getContext() != null
|
|
&& accountingFilterContext.getContext().getContexts() != null
|
|
&& !accountingFilterContext.getContext().getContexts().isEmpty()) {
|
|
ArrayList<String> contexts = accountingStateData.getAvailableContext().getContexts();
|
|
ArrayList<GenresData> genres = new ArrayList<GenresData>();
|
|
for (String context : contexts) {
|
|
GenresData genresData = new GenresData(context);
|
|
genres.add(genresData);
|
|
}
|
|
storeGenres.clear();
|
|
storeGenres.addAll(genres);
|
|
storeGenres.commitChanges();
|
|
|
|
smGenres.deselectAll();
|
|
|
|
if (accountingFilterContext.getContext().getContexts() == null
|
|
|| accountingFilterContext.getContext().getContexts().isEmpty()) {
|
|
} else {
|
|
ArrayList<GenresData> selected = new ArrayList<>();
|
|
for (String c : accountingFilterContext.getContext().getContexts()) {
|
|
for (GenresData genresData : storeGenres.getAll()) {
|
|
if (c.compareTo(genresData.getGenre()) == 0) {
|
|
selected.add(genresData);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!selected.isEmpty()) {
|
|
if (selected.size() == storeGenres.getAll().size()) {
|
|
smGenres.selectAll();
|
|
} else {
|
|
smGenres.select(selected, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
smGenres.refresh();
|
|
|
|
} else {
|
|
repopulatesContexts();
|
|
}
|
|
|
|
} else {
|
|
resetContexts();
|
|
}
|
|
|
|
if (accountingFilterContext.getFilters() != null) {
|
|
List<AccountingFilter> filters = accountingFilterContext.getFilters();
|
|
storeFilter.clear();
|
|
storeFilter.addAll(filters);
|
|
seq = 0;
|
|
for (AccountingFilter filter : filters) {
|
|
if (filter.getId() > seq) {
|
|
seq = filter.getId();
|
|
}
|
|
}
|
|
storeFilter.commitChanges();
|
|
} else {
|
|
storeFilter.clear();
|
|
storeFilter.commitChanges();
|
|
seq = 0;
|
|
}
|
|
|
|
} else {
|
|
reconfigureContext();
|
|
storeFilter.clear();
|
|
storeFilter.commitChanges();
|
|
seq = 0;
|
|
|
|
}
|
|
comboChartType.setValue(ChartType.Context);
|
|
comboScopeLabel.setVisible(false);
|
|
gridGenres.setVisible(true);
|
|
labelGenresCol.setHeader("Scope");
|
|
gridGenres.getView().refresh(true);
|
|
comboTopFilterKey.reset();
|
|
comboTopFilterKeyLabel.setVisible(false);
|
|
showOthersToggle.reset();
|
|
showOthersNo.setValue(true);
|
|
showOthersLabel.setVisible(false);
|
|
noContextToggle.reset();
|
|
noContextNo.setValue(true);
|
|
noContextLabel.setVisible(false);
|
|
topNumber.reset();
|
|
topNumberLabel.setVisible(false);
|
|
forceLayout();
|
|
|
|
}
|
|
|
|
private void reconfigureContext() {
|
|
if (accountingStateData.getAvailableContext() != null
|
|
&& accountingStateData.getAvailableContext().getContexts() != null
|
|
&& !accountingStateData.getAvailableContext().getContexts().isEmpty()) {
|
|
repopulatesContexts();
|
|
} else {
|
|
resetContexts();
|
|
}
|
|
}
|
|
|
|
private void resetContexts() {
|
|
storeGenres.clear();
|
|
storeGenres.commitChanges();
|
|
smGenres.deselectAll();
|
|
smGenres.refresh();
|
|
}
|
|
|
|
private void repopulatesContexts() {
|
|
ArrayList<String> contexts = accountingStateData.getAvailableContext().getContexts();
|
|
ArrayList<GenresData> genres = new ArrayList<GenresData>();
|
|
for (String context : contexts) {
|
|
GenresData genresData = new GenresData(context);
|
|
genres.add(genresData);
|
|
}
|
|
storeGenres.clear();
|
|
storeGenres.addAll(genres);
|
|
storeGenres.commitChanges();
|
|
smGenres.selectAll();
|
|
smGenres.refresh();
|
|
}
|
|
|
|
private void changeActiveFiltersForSpaces() {
|
|
if (accountingStateData.getSeriesRequest() != null
|
|
&& accountingStateData.getSeriesRequest().getAccountingFilterDefinition() != null && accountingStateData
|
|
.getSeriesRequest().getAccountingFilterDefinition() instanceof AccountingFilterSpaces) {
|
|
AccountingFilterSpaces accountingFilterSapces = (AccountingFilterSpaces) accountingStateData
|
|
.getSeriesRequest().getAccountingFilterDefinition();
|
|
if (accountingStateData.getAvailableSpaces() != null
|
|
&& accountingStateData.getAvailableSpaces().getSpacesList() != null
|
|
&& !accountingStateData.getAvailableSpaces().getSpacesList().isEmpty()) {
|
|
|
|
if (accountingFilterSapces.getSpaces() != null
|
|
&& accountingFilterSapces.getSpaces().getSpacesList() != null
|
|
&& !accountingFilterSapces.getSpaces().getSpacesList().isEmpty()) {
|
|
ArrayList<String> spacesList = accountingStateData.getAvailableSpaces().getSpacesList();
|
|
ArrayList<GenresData> genres = new ArrayList<GenresData>();
|
|
for (String space : spacesList) {
|
|
GenresData genresData = new GenresData(space);
|
|
genres.add(genresData);
|
|
}
|
|
storeGenres.clear();
|
|
storeGenres.addAll(genres);
|
|
storeGenres.commitChanges();
|
|
|
|
smGenres.deselectAll();
|
|
|
|
if (accountingFilterSapces.getSpaces().getSpacesList() == null
|
|
|| accountingFilterSapces.getSpaces().getSpacesList().isEmpty()) {
|
|
} else {
|
|
ArrayList<GenresData> selected = new ArrayList<>();
|
|
for (String s : accountingFilterSapces.getSpaces().getSpacesList()) {
|
|
for (GenresData genresData : storeGenres.getAll()) {
|
|
if (s.compareTo(genresData.getGenre()) == 0) {
|
|
selected.add(genresData);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!selected.isEmpty()) {
|
|
if (selected.size() == storeGenres.getAll().size()) {
|
|
smGenres.selectAll();
|
|
} else {
|
|
smGenres.select(selected, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
smGenres.refresh();
|
|
|
|
} else {
|
|
repopulatesSpaces();
|
|
}
|
|
|
|
} else {
|
|
resetSpaces();
|
|
}
|
|
|
|
if (accountingFilterSapces.getFilters() != null) {
|
|
List<AccountingFilter> filters = accountingFilterSapces.getFilters();
|
|
storeFilter.clear();
|
|
storeFilter.addAll(filters);
|
|
seq = 0;
|
|
for (AccountingFilter filter : filters) {
|
|
if (filter.getId() > seq) {
|
|
seq = filter.getId();
|
|
}
|
|
}
|
|
storeFilter.commitChanges();
|
|
} else {
|
|
storeFilter.clear();
|
|
storeFilter.commitChanges();
|
|
seq = 0;
|
|
}
|
|
|
|
} else {
|
|
reconfigureSpaces();
|
|
storeFilter.clear();
|
|
storeFilter.commitChanges();
|
|
seq = 0;
|
|
|
|
}
|
|
comboChartType.setValue(ChartType.Spaces);
|
|
comboScopeLabel.setVisible(false);
|
|
gridGenres.setVisible(true);
|
|
labelGenresCol.setHeader("Space");
|
|
gridGenres.getView().refresh(true);
|
|
comboTopFilterKey.reset();
|
|
comboTopFilterKeyLabel.setVisible(false);
|
|
showOthersToggle.reset();
|
|
showOthersNo.setValue(true);
|
|
showOthersLabel.setVisible(false);
|
|
noContextToggle.reset();
|
|
noContextNo.setValue(true);
|
|
noContextLabel.setVisible(false);
|
|
topNumber.reset();
|
|
topNumberLabel.setVisible(false);
|
|
forceLayout();
|
|
|
|
}
|
|
|
|
private void reconfigureSpaces() {
|
|
if (accountingStateData.getAvailableSpaces() != null
|
|
&& accountingStateData.getAvailableSpaces().getSpacesList() != null
|
|
&& !accountingStateData.getAvailableSpaces().getSpacesList().isEmpty()) {
|
|
repopulatesSpaces();
|
|
} else {
|
|
resetSpaces();
|
|
}
|
|
}
|
|
|
|
private void resetSpaces() {
|
|
storeGenres.clear();
|
|
storeGenres.commitChanges();
|
|
smGenres.deselectAll();
|
|
smGenres.refresh();
|
|
}
|
|
|
|
private void repopulatesSpaces() {
|
|
ArrayList<String> spaces = accountingStateData.getAvailableSpaces().getSpacesList();
|
|
ArrayList<GenresData> genres = new ArrayList<GenresData>();
|
|
for (String space : spaces) {
|
|
GenresData genresData = new GenresData(space);
|
|
genres.add(genresData);
|
|
}
|
|
storeGenres.clear();
|
|
storeGenres.addAll(genres);
|
|
storeGenres.commitChanges();
|
|
smGenres.selectAll();
|
|
smGenres.refresh();
|
|
}
|
|
|
|
public AccountingFilterDefinition getActiveFilters() {
|
|
try {
|
|
ChartType chartType = comboChartType.getCurrentValue();
|
|
|
|
switch (chartType) {
|
|
case Basic:
|
|
return getActiveFiltersForBasic();
|
|
case Top:
|
|
return getActiveFiltersForTop();
|
|
case Context:
|
|
return getActiveFiltersForContext();
|
|
case Spaces:
|
|
return getActiveFiltersForSpaces();
|
|
default:
|
|
return null;
|
|
|
|
}
|
|
|
|
} catch (Throwable e) {
|
|
Log.error(e.getLocalizedMessage());
|
|
e.printStackTrace();
|
|
UtilsGXT3.alert("Attention", e.getLocalizedMessage());
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// TODO
|
|
private AccountingFilterDefinition getActiveFiltersForBasic() {
|
|
String scope = null;
|
|
if (comboScopeLabel != null && comboScopeLabel.isVisible()) {
|
|
GenresData genresData = comboScope.getCurrentValue();
|
|
if (genresData != null) {
|
|
scope = genresData.getLabel();
|
|
}
|
|
}
|
|
Log.debug("Scope selected: " + scope);
|
|
|
|
Boolean noContextValue = false;
|
|
if (noContextLabel != null && noContextLabel.isVisible()) {
|
|
noContextValue = noContextYes.getValue();
|
|
} else {
|
|
noContextValue = false;
|
|
}
|
|
Log.debug("noContextValue: " + noContextValue);
|
|
|
|
if (storeFilter == null || storeFilter.size() <= 0) {
|
|
return new AccountingFilterBasic(scope, noContextValue);
|
|
} else {
|
|
List<AccountingFilter> filtersActives = storeFilter.getAll();
|
|
ArrayList<AccountingFilter> filtersReady = new ArrayList<AccountingFilter>();
|
|
for (AccountingFilter filter : filtersActives) {
|
|
if (filter.getFilterValue() != null && !filter.getFilterValue().isEmpty()) {
|
|
filtersReady.add(filter);
|
|
}
|
|
}
|
|
|
|
if (filtersReady.size() > 0) {
|
|
return new AccountingFilterBasic(scope, filtersReady, noContextValue);
|
|
} else {
|
|
return new AccountingFilterBasic(scope, noContextValue);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
private AccountingFilterDefinition getActiveFiltersForTop() {
|
|
String scope = null;
|
|
if (comboScopeLabel != null && comboScopeLabel.isVisible()) {
|
|
GenresData genresData = comboScope.getCurrentValue();
|
|
if (genresData != null) {
|
|
scope = genresData.getLabel();
|
|
}
|
|
}
|
|
Log.debug("Scope selected: " + scope);
|
|
|
|
Boolean showOthersValue = showOthersYes.getValue();
|
|
Integer topN = topNumber.getCurrentValue();
|
|
FilterKey filterKey = comboTopFilterKey.getCurrentValue();
|
|
if (filterKey == null) {
|
|
return new AccountingFilterTop(scope, showOthersValue, topN);
|
|
} else {
|
|
if (storeFilter == null || storeFilter.size() <= 0) {
|
|
return new AccountingFilterTop(scope, filterKey, null, showOthersValue, topN);
|
|
} else {
|
|
List<AccountingFilter> filtersActives = storeFilter.getAll();
|
|
ArrayList<AccountingFilter> filtersReady = new ArrayList<AccountingFilter>();
|
|
for (AccountingFilter filter : filtersActives) {
|
|
if (filter.getFilterValue() != null && !filter.getFilterValue().isEmpty()) {
|
|
filtersReady.add(filter);
|
|
}
|
|
}
|
|
if (filtersReady.size() > 0) {
|
|
return new AccountingFilterTop(scope, filterKey, filtersReady, showOthersValue, topN);
|
|
} else {
|
|
return new AccountingFilterTop(scope, filterKey, null, showOthersValue, topN);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
private AccountingFilterDefinition getActiveFiltersForContext() {
|
|
ArrayList<String> contextsSelected = new ArrayList<String>();
|
|
if (storeGenres != null && storeGenres.size() > 0 && smGenres != null) {
|
|
List<GenresData> selected = smGenres.getSelectedItems();
|
|
for (GenresData cd : selected) {
|
|
contextsSelected.add(cd.getGenre());
|
|
}
|
|
}
|
|
org.gcube.portlets.admin.accountingmanager.shared.data.Context context = new org.gcube.portlets.admin.accountingmanager.shared.data.Context(
|
|
contextsSelected);
|
|
|
|
List<AccountingFilter> filtersActives = storeFilter.getAll();
|
|
ArrayList<AccountingFilter> filtersReady = new ArrayList<AccountingFilter>();
|
|
for (AccountingFilter filter : filtersActives) {
|
|
if (filter.getFilterValue() != null && !filter.getFilterValue().isEmpty()) {
|
|
filtersReady.add(filter);
|
|
}
|
|
}
|
|
if (filtersReady.size() > 0) {
|
|
return new AccountingFilterContext(context, filtersReady);
|
|
} else {
|
|
return new AccountingFilterContext(context, null);
|
|
}
|
|
|
|
}
|
|
|
|
private AccountingFilterDefinition getActiveFiltersForSpaces() {
|
|
ArrayList<String> spacesSelected = new ArrayList<String>();
|
|
if (storeGenres != null && storeGenres.size() > 0 && smGenres != null) {
|
|
List<GenresData> selected = smGenres.getSelectedItems();
|
|
for (GenresData cd : selected) {
|
|
spacesSelected.add(cd.getGenre());
|
|
}
|
|
}
|
|
Spaces spaces = new Spaces(spacesSelected);
|
|
|
|
List<AccountingFilter> filtersActives = storeFilter.getAll();
|
|
ArrayList<AccountingFilter> filtersReady = new ArrayList<AccountingFilter>();
|
|
for (AccountingFilter filter : filtersActives) {
|
|
if (filter.getFilterValue() != null && !filter.getFilterValue().isEmpty()) {
|
|
filtersReady.add(filter);
|
|
}
|
|
}
|
|
if (filtersReady.size() > 0) {
|
|
return new AccountingFilterSpaces(spaces, filtersReady);
|
|
} else {
|
|
return new AccountingFilterSpaces(spaces, null);
|
|
}
|
|
|
|
}
|
|
|
|
private void addNewFilter(SelectEvent event) {
|
|
List<AccountingFilter> filtersSet = storeFilter.getAll();
|
|
FilterKey fk = null;
|
|
|
|
if (accountingStateData == null || accountingStateData.getAvailableFilterKeys() == null
|
|
|| accountingStateData.getAvailableFilterKeys().size() < 0) {
|
|
UtilsGXT3.info("No key available", "No key available");
|
|
|
|
} else {
|
|
List<FilterKey> remainingFilterKeys = new ArrayList<FilterKey>(
|
|
accountingStateData.getAvailableFilterKeys());
|
|
List<FilterKey> removableFilterKeys = new ArrayList<FilterKey>();
|
|
|
|
for (AccountingFilter filterSet : filtersSet) {
|
|
removableFilterKeys.add(filterSet.getFilterKey());
|
|
}
|
|
|
|
if (comboChartType.getCurrentValue() != null
|
|
&& comboChartType.getCurrentValue().compareTo(ChartType.Top) == 0) {
|
|
if (comboTopFilterKey.getCurrentValue() != null) {
|
|
removableFilterKeys.add(comboTopFilterKey.getCurrentValue());
|
|
}
|
|
}
|
|
|
|
remainingFilterKeys.removeAll(removableFilterKeys);
|
|
|
|
if (remainingFilterKeys.size() > 0) {
|
|
/*
|
|
* if (comboChartType.getCurrentValue() != null &&
|
|
* comboChartType.getCurrentValue().compareTo( ChartType.Top) ==
|
|
* 0) { if(!(store.getAll().size()<2)){
|
|
* UtilsGXT3.info("Attention",
|
|
* "You can add at most 2 filters for top chart!"); return; } }
|
|
*/
|
|
// fk = remainingFilterKeys.get(0);
|
|
fk = new FilterKey("");
|
|
seq++;
|
|
AccountingFilter newAccountingFilter = new AccountingFilter(seq, fk, "");
|
|
Log.debug("newAccountingFilter: " + newAccountingFilter);
|
|
editing.cancelEditing();
|
|
addStatus = true;
|
|
editing.getCancelButton().setVisible(false);
|
|
|
|
storeFilter.add(newAccountingFilter);
|
|
int row = storeFilter.indexOf(newAccountingFilter);
|
|
|
|
storeComboFilterKey.clear();
|
|
storeComboFilterKey.addAll(remainingFilterKeys);
|
|
storeComboFilterKey.commitChanges();
|
|
|
|
editing.startEditing(new GridCell(row, 0));
|
|
|
|
} else {
|
|
UtilsGXT3.info("No key available", "No key available");
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
private void retrieveFilterValuesByKey(FilterKey filterKey, final boolean cancelValue) {
|
|
this.filterKey = filterKey;
|
|
this.cancelValue = cancelValue;
|
|
AccountingPeriodRequestEvent event = new AccountingPeriodRequestEvent();
|
|
eventBus.fireEvent(event);
|
|
|
|
}
|
|
|
|
private void manageAccountingPeriodEvent(AccountingPeriodEvent event) {
|
|
if (event == null || event.getAccountingPeriod() == null) {
|
|
Log.debug("AccountingPeriod not valid");
|
|
return;
|
|
}
|
|
|
|
if (filterKey == null || filterKey.getKey() == null || filterKey.getKey().isEmpty()) {
|
|
Log.debug("FilterKey: " + filterKey);
|
|
comboFilterValue.clear();
|
|
storeComboFilterValue.clear();
|
|
storeComboFilterValue.commitChanges();
|
|
return;
|
|
}
|
|
|
|
accountingMonitor = new AccountingMonitor();
|
|
FilterValuesRequest requestFilterValue = new FilterValuesRequest(filterKey,
|
|
accountingStateData.getAccountingType(), event.getAccountingPeriod());
|
|
|
|
AccountingManagerServiceAsync.INSTANCE.getFilterValues(requestFilterValue,
|
|
new AsyncCallback<FilterValuesResponse>() {
|
|
|
|
@Override
|
|
public void onFailure(Throwable caught) {
|
|
accountingMonitor.hide();
|
|
if (caught instanceof SessionExpiredException) {
|
|
eventBus.fireEvent(new SessionExpiredEvent(SessionExpiredType.EXPIREDONSERVER));
|
|
} else {
|
|
Log.error("Error retrieving filter values:" + caught.getLocalizedMessage());
|
|
UtilsGXT3.alert("Error retrieving filter values", caught.getLocalizedMessage());
|
|
}
|
|
|
|
}
|
|
|
|
@Override
|
|
public void onSuccess(FilterValuesResponse result) {
|
|
Log.debug("FilterValues: " + result);
|
|
accountingMonitor.hide();
|
|
ArrayList<String> values = new ArrayList<String>();
|
|
for (FilterValue fv : result.getFilterValues()) {
|
|
values.add(fv.getValue());
|
|
}
|
|
if (cancelValue) {
|
|
comboFilterValue.clear();
|
|
}
|
|
storeComboFilterValue.clear();
|
|
storeComboFilterValue.addAll(values);
|
|
storeComboFilterValue.commitChanges();
|
|
}
|
|
});
|
|
}
|
|
|
|
private void editingBeforeStart(BeforeStartEditEvent<AccountingFilter> event) {
|
|
GridCell cell = event.getEditCell();
|
|
int rowIndex = cell.getRow();
|
|
AccountingFilter editingFilter = storeFilter.get(rowIndex);
|
|
|
|
List<AccountingFilter> filtersSet = storeFilter.getAll();
|
|
|
|
List<FilterKey> remainingFilterKeys = null;
|
|
if (accountingStateData == null || accountingStateData.getAvailableFilterKeys() == null) {
|
|
remainingFilterKeys = new ArrayList<FilterKey>();
|
|
} else {
|
|
remainingFilterKeys = new ArrayList<FilterKey>(accountingStateData.getAvailableFilterKeys());
|
|
|
|
}
|
|
|
|
List<FilterKey> setFilterKeys = new ArrayList<FilterKey>();
|
|
|
|
if (comboChartType.getCurrentValue() != null
|
|
&& comboChartType.getCurrentValue().compareTo(ChartType.Top) == 0) {
|
|
if (comboTopFilterKey.getCurrentValue() != null) {
|
|
setFilterKeys.add(comboTopFilterKey.getCurrentValue());
|
|
}
|
|
}
|
|
|
|
for (AccountingFilter filterSet : filtersSet) {
|
|
if (filterSet.getFilterKey().getKey().compareTo(editingFilter.getFilterKey().getKey()) != 0) {
|
|
setFilterKeys.add(filterSet.getFilterKey());
|
|
}
|
|
}
|
|
|
|
remainingFilterKeys.removeAll(setFilterKeys);
|
|
|
|
storeComboFilterKey.clear();
|
|
storeComboFilterKey.addAll(remainingFilterKeys);
|
|
storeComboFilterKey.commitChanges();
|
|
|
|
if (editingFilter.getFilterKey() != null) {
|
|
retrieveFilterValuesByKey(editingFilter.getFilterKey(), false);
|
|
}
|
|
|
|
addButton.setEnabled(false);
|
|
|
|
}
|
|
|
|
private void addHandlersForComboFilterKey(final LabelProvider<FilterKey> labelProvider) {
|
|
comboFilterKey.addSelectionHandler(new SelectionHandler<FilterKey>() {
|
|
public void onSelection(SelectionEvent<FilterKey> event) {
|
|
Log.debug("FilterKey selected: " + event.getSelectedItem());
|
|
updateFilterKey(event.getSelectedItem());
|
|
}
|
|
|
|
});
|
|
}
|
|
|
|
private void updateFilterKey(FilterKey selectedFilterKey) {
|
|
retrieveFilterValuesByKey(selectedFilterKey, true);
|
|
}
|
|
|
|
private void addHandlersForComboChartType(final LabelProvider<ChartType> labelProvider) {
|
|
comboChartType.addSelectionHandler(new SelectionHandler<ChartType>() {
|
|
public void onSelection(SelectionEvent<ChartType> event) {
|
|
Log.debug("FilterKey selected: " + event.getSelectedItem());
|
|
updateComboChartType(event.getSelectedItem());
|
|
}
|
|
|
|
});
|
|
}
|
|
|
|
// TODO
|
|
private void updateComboChartType(ChartType chartType) {
|
|
if (chartType == null) {
|
|
return;
|
|
}
|
|
switch (chartType) {
|
|
case Basic:
|
|
comboScopeLabel.setVisible(true);
|
|
gridGenres.setVisible(false);
|
|
comboTopFilterKey.reset();
|
|
comboTopFilterKeyLabel.setVisible(false);
|
|
showOthersToggle.reset();
|
|
showOthersNo.setValue(true);
|
|
showOthersLabel.setVisible(false);
|
|
|
|
if (accountingStateData.getRootScope()) {
|
|
noContextToggle.reset();
|
|
noContextNo.setValue(true);
|
|
noContextLabel.setVisible(true);
|
|
} else {
|
|
noContextToggle.reset();
|
|
noContextNo.setValue(true);
|
|
noContextLabel.setVisible(false);
|
|
}
|
|
|
|
topNumber.reset();
|
|
topNumberLabel.setVisible(false);
|
|
storeFilter.clear();
|
|
storeFilter.commitChanges();
|
|
seq = 0;
|
|
forceLayout();
|
|
break;
|
|
case Top:
|
|
comboScopeLabel.setVisible(true);
|
|
gridGenres.setVisible(false);
|
|
comboTopFilterKey.reset();
|
|
if (accountingStateData != null && accountingStateData.getAvailableFilterKeys() != null
|
|
&& accountingStateData.getAvailableFilterKeys().size() > 0) {
|
|
comboTopFilterKey.setValue(accountingStateData.getAvailableFilterKeys().get(0));
|
|
}
|
|
comboTopFilterKeyLabel.setVisible(true);
|
|
showOthersToggle.reset();
|
|
showOthersNo.setValue(true);
|
|
showOthersLabel.setVisible(true);
|
|
noContextToggle.reset();
|
|
noContextYes.setValue(false);
|
|
noContextNo.setValue(true);
|
|
noContextLabel.setVisible(false);
|
|
topNumber.reset();
|
|
topNumber.setValue(TOP_NUMBER_DEFAULT);
|
|
topNumberLabel.setVisible(true);
|
|
storeFilter.clear();
|
|
storeFilter.commitChanges();
|
|
seq = 0;
|
|
forceLayout();
|
|
break;
|
|
case Context:
|
|
reconfigureContext();
|
|
comboScopeLabel.setVisible(false);
|
|
gridGenres.setVisible(true);
|
|
labelGenresCol.setHeader("Scope");
|
|
gridGenres.getView().refresh(true);
|
|
comboTopFilterKey.reset();
|
|
comboTopFilterKeyLabel.setVisible(false);
|
|
showOthersToggle.reset();
|
|
showOthersNo.setValue(true);
|
|
showOthersLabel.setVisible(false);
|
|
noContextToggle.reset();
|
|
noContextYes.setValue(false);
|
|
noContextNo.setValue(true);
|
|
noContextLabel.setVisible(false);
|
|
topNumber.reset();
|
|
topNumberLabel.setVisible(false);
|
|
storeFilter.clear();
|
|
storeFilter.commitChanges();
|
|
seq = 0;
|
|
forceLayout();
|
|
break;
|
|
case Spaces:
|
|
reconfigureSpaces();
|
|
comboScopeLabel.setVisible(false);
|
|
gridGenres.setVisible(true);
|
|
labelGenresCol.setHeader("Space");
|
|
gridGenres.getView().refresh(true);
|
|
comboTopFilterKey.reset();
|
|
comboTopFilterKeyLabel.setVisible(false);
|
|
showOthersToggle.reset();
|
|
showOthersNo.setValue(true);
|
|
showOthersLabel.setVisible(false);
|
|
noContextToggle.reset();
|
|
noContextYes.setValue(false);
|
|
noContextNo.setValue(true);
|
|
noContextLabel.setVisible(false);
|
|
topNumber.reset();
|
|
topNumberLabel.setVisible(false);
|
|
storeFilter.clear();
|
|
storeFilter.commitChanges();
|
|
seq = 0;
|
|
forceLayout();
|
|
break;
|
|
default:
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
private void addHandlersForComboTopFilterKey(final LabelProvider<FilterKey> labelProvider) {
|
|
comboTopFilterKey.addSelectionHandler(new SelectionHandler<FilterKey>() {
|
|
public void onSelection(SelectionEvent<FilterKey> event) {
|
|
Log.debug("FilterKey selected: " + event.getSelectedItem());
|
|
updateTopFilterKey(event.getSelectedItem());
|
|
}
|
|
|
|
});
|
|
}
|
|
|
|
private void updateTopFilterKey(FilterKey selectedFilterKey) {
|
|
storeFilter.clear();
|
|
storeFilter.commitChanges();
|
|
seq = 0;
|
|
}
|
|
|
|
private void addHandlersForComboScope(final LabelProvider<GenresData> labelProvider) {
|
|
comboScope.addSelectionHandler(new SelectionHandler<GenresData>() {
|
|
public void onSelection(SelectionEvent<GenresData> event) {
|
|
Log.debug("Scope selected: " + event.getSelectedItem());
|
|
updateScope(event.getSelectedItem());
|
|
}
|
|
|
|
});
|
|
}
|
|
|
|
private void updateScope(GenresData selectedFilterKey) {
|
|
|
|
}
|
|
|
|
}
|