MoneyWiseXAnalysisSelect.java
/*
* MoneyWise: Finance Application
* Copyright 2012-2026. Tony Washer
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy
* of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package io.github.tonywasher.joceanus.moneywise.atlas.ui.controls;
import io.github.tonywasher.joceanus.oceanus.date.OceanusDateRange;
import io.github.tonywasher.joceanus.oceanus.date.OceanusDateResource;
import io.github.tonywasher.joceanus.oceanus.event.OceanusEventManager;
import io.github.tonywasher.joceanus.oceanus.event.OceanusEventRegistrar;
import io.github.tonywasher.joceanus.oceanus.event.OceanusEventRegistrar.OceanusEventProvider;
import io.github.tonywasher.joceanus.metis.data.MetisDataDifference;
import io.github.tonywasher.joceanus.metis.ui.MetisIcon;
import io.github.tonywasher.joceanus.moneywise.atlas.data.analysis.analyse.MoneyWiseXAnalysisManager;
import io.github.tonywasher.joceanus.moneywise.atlas.data.analysis.base.MoneyWiseXAnalysisAttribute;
import io.github.tonywasher.joceanus.moneywise.atlas.data.analysis.buckets.MoneyWiseXAnalysis;
import io.github.tonywasher.joceanus.moneywise.atlas.data.analysis.buckets.MoneyWiseXAnalysisType;
import io.github.tonywasher.joceanus.moneywise.atlas.views.MoneyWiseXAnalysisFilter;
import io.github.tonywasher.joceanus.moneywise.atlas.views.MoneyWiseXAnalysisFilter.MoneyWiseXAnalysisAllFilter;
import io.github.tonywasher.joceanus.moneywise.ui.MoneyWiseAnalysisColumnSet;
import io.github.tonywasher.joceanus.moneywise.ui.MoneyWiseUIResource;
import io.github.tonywasher.joceanus.moneywise.views.MoneyWiseView;
import io.github.tonywasher.joceanus.prometheus.views.PrometheusDataEvent;
import io.github.tonywasher.joceanus.tethys.api.base.TethysUIArrowIconId;
import io.github.tonywasher.joceanus.tethys.api.base.TethysUIComponent;
import io.github.tonywasher.joceanus.tethys.api.base.TethysUIEvent;
import io.github.tonywasher.joceanus.tethys.api.button.TethysUIButton;
import io.github.tonywasher.joceanus.tethys.api.button.TethysUIButtonFactory;
import io.github.tonywasher.joceanus.tethys.api.button.TethysUIDateRangeSelector;
import io.github.tonywasher.joceanus.tethys.api.button.TethysUIScrollButtonManager;
import io.github.tonywasher.joceanus.tethys.api.control.TethysUIControlFactory;
import io.github.tonywasher.joceanus.tethys.api.control.TethysUILabel;
import io.github.tonywasher.joceanus.tethys.api.factory.TethysUIFactory;
import io.github.tonywasher.joceanus.tethys.api.menu.TethysUIScrollMenu;
import io.github.tonywasher.joceanus.tethys.api.pane.TethysUIBoxPaneManager;
import io.github.tonywasher.joceanus.tethys.api.pane.TethysUICardPaneManager;
import io.github.tonywasher.joceanus.tethys.api.pane.TethysUIPaneFactory;
import java.util.EnumMap;
import java.util.Map;
import java.util.Map.Entry;
/**
* Selection panel for Analysis Statement.
*/
public class MoneyWiseXAnalysisSelect
implements OceanusEventProvider<PrometheusDataEvent>, TethysUIComponent {
/**
* Text for DateRange Label.
*/
private static final String NLS_RANGE = MoneyWiseUIResource.ANALYSIS_PROMPT_RANGE.getValue();
/**
* Text for Filter Label.
*/
private static final String NLS_FILTER = MoneyWiseUIResource.ANALYSIS_PROMPT_FILTER.getValue();
/**
* Text for FilterType Label.
*/
private static final String NLS_FILTERTYPE = MoneyWiseUIResource.ANALYSIS_PROMPT_FILTERTYPE.getValue();
/**
* Text for ColumnSet Label.
*/
private static final String NLS_COLUMNS = MoneyWiseUIResource.ANALYSIS_PROMPT_COLUMNSET.getValue();
/**
* Text for BucketType Label.
*/
private static final String NLS_BUCKET = MoneyWiseUIResource.ANALYSIS_PROMPT_BUCKET.getValue();
/**
* Text for Title.
*/
private static final String NLS_TITLE = MoneyWiseUIResource.ANALYSIS_TITLE.getValue();
/**
* Text for NoBucket.
*/
private static final String NLS_NONE = MoneyWiseUIResource.ANALYSIS_BUCKET_NONE.getValue();
/**
* Text for Title.
*/
private static final String NLS_FILTERTITLE = MoneyWiseUIResource.ANALYSIS_FILTER_TITLE.getValue();
/**
* Text for Box Title.
*/
private static final String NLS_RANGETITLE = OceanusDateResource.TITLE_BOX.getValue();
/**
* The Event Manager.
*/
private final OceanusEventManager<PrometheusDataEvent> theEventManager;
/**
* View.
*/
private final MoneyWiseView theView;
/**
* Panel.
*/
private final TethysUIBoxPaneManager thePanel;
/**
* Range Button.
*/
private final TethysUIButton theRangeButton;
/**
* Filter Button.
*/
private final TethysUIButton theFilterButton;
/**
* Filter Type Button.
*/
private final TethysUIScrollButtonManager<MoneyWiseXAnalysisType> theFilterTypeButton;
/**
* Bucket Type Button.
*/
private final TethysUIScrollButtonManager<MoneyWiseXAnalysisAttribute> theBucketButton;
/**
* ColumnSet Button.
*/
private final TethysUIScrollButtonManager<MoneyWiseAnalysisColumnSet> theColumnButton;
/**
* The bucket label.
*/
private final TethysUILabel theBucketLabel;
/**
* The column label.
*/
private final TethysUILabel theColumnLabel;
/**
* The filter detail panel.
*/
private final TethysUIBoxPaneManager theFilterDetail;
/**
* DateRange Select Panel.
*/
private final TethysUIDateRangeSelector theRangeSelect;
/**
* Filter Select Panel.
*/
private final TethysUIBoxPaneManager theFilterSelect;
/**
* Deposit Select Panel.
*/
private final MoneyWiseXDepositAnalysisSelect theDepositSelect;
/**
* Cash Select Panel.
*/
private final MoneyWiseXCashAnalysisSelect theCashSelect;
/**
* Loan Select Panel.
*/
private final MoneyWiseXLoanAnalysisSelect theLoanSelect;
/**
* Security Select Panel.
*/
private final MoneyWiseXSecurityAnalysisSelect theSecuritySelect;
/**
* Portfolio Select Panel.
*/
private final MoneyWiseXPortfolioAnalysisSelect thePortfolioSelect;
/**
* Payee Select Panel.
*/
private final MoneyWiseXPayeeAnalysisSelect thePayeeSelect;
/**
* TransCategory Select Panel.
*/
private final MoneyWiseXTransCategoryAnalysisSelect theCategorySelect;
/**
* TaxBasis Select Panel.
*/
private final MoneyWiseXTaxBasisAnalysisSelect theTaxBasisSelect;
/**
* TransactionTag Select Panel.
*/
private final MoneyWiseXTransTagSelect theTagSelect;
/**
* All Select Panel.
*/
private final MoneyWiseXAllSelect theAllSelect;
/**
* The card panel.
*/
private final TethysUICardPaneManager<MoneyWiseXAnalysisFilterSelection> theCardPanel;
/**
* The analysis manager.
*/
private final MoneyWiseXAnalysisManager theAnalysisMgr;
/**
* Select panel map.
*/
private final Map<MoneyWiseXAnalysisType, MoneyWiseXAnalysisFilterSelection> theMap;
/**
* AnalysisType menu.
*/
private final TethysUIScrollMenu<MoneyWiseXAnalysisType> theTypeMenu;
/**
* Bucket menu.
*/
private final TethysUIScrollMenu<MoneyWiseXAnalysisAttribute> theBucketMenu;
/**
* Column menu.
*/
private final TethysUIScrollMenu<MoneyWiseAnalysisColumnSet> theColumnMenu;
/**
* Analysis.
*/
private MoneyWiseXAnalysis theAnalysis;
/**
* Analysis State.
*/
private MoneyWiseAnalysisState theState;
/**
* The savePoint.
*/
private MoneyWiseAnalysisState theSavePoint;
/**
* Is the control refreshing?
*/
private boolean isRefreshing;
/**
* Is the range visible?
*/
private boolean isRangeVisible;
/**
* Is the filter visible?
*/
private boolean isFilterVisible;
/**
* Constructor.
*
* @param pFactory the GUI factory
* @param pView the view
* @param pAnalysisMgr the analysis manager
* @param pNewButton the new button
*/
public MoneyWiseXAnalysisSelect(final TethysUIFactory<?> pFactory,
final MoneyWiseView pView,
final MoneyWiseXAnalysisManager pAnalysisMgr,
final TethysUIButton pNewButton) {
/* Access the analysis manager */
theView = pView;
theAnalysisMgr = pAnalysisMgr;
/* Create Event Manager */
theEventManager = new OceanusEventManager<>();
/* Create the range button */
final TethysUIButtonFactory<?> myButtons = pFactory.buttonFactory();
theRangeButton = myButtons.newButton();
theRangeButton.setIcon(TethysUIArrowIconId.DOWN);
theRangeButton.setTextAndIcon();
/* Create the filter button */
theFilterButton = myButtons.newButton();
theFilterButton.setIcon(TethysUIArrowIconId.DOWN);
theFilterButton.setTextAndIcon();
/* Create the filter type button */
theFilterTypeButton = myButtons.newScrollButton(MoneyWiseXAnalysisType.class);
/* Create the columnSet button */
final TethysUIControlFactory myControls = pFactory.controlFactory();
theColumnLabel = myControls.newLabel(NLS_COLUMNS);
theColumnButton = myButtons.newScrollButton(MoneyWiseAnalysisColumnSet.class);
/* Create the bucket button */
theBucketLabel = myControls.newLabel(NLS_BUCKET);
theBucketButton = myButtons.newScrollButton(MoneyWiseXAnalysisAttribute.class);
/* Create the Range Select panel */
theRangeSelect = myButtons.newDateRangeSelector();
theRangeSelect.setBorderTitle(NLS_RANGETITLE);
/* Create the panel map */
theMap = new EnumMap<>(MoneyWiseXAnalysisType.class);
/* Create the filter selection panels */
theDepositSelect = new MoneyWiseXDepositAnalysisSelect(pFactory);
theCashSelect = new MoneyWiseXCashAnalysisSelect(pFactory);
theLoanSelect = new MoneyWiseXLoanAnalysisSelect(pFactory);
theSecuritySelect = new MoneyWiseXSecurityAnalysisSelect(pFactory);
thePortfolioSelect = new MoneyWiseXPortfolioAnalysisSelect(pFactory);
thePayeeSelect = new MoneyWiseXPayeeAnalysisSelect(pFactory);
theCategorySelect = new MoneyWiseXTransCategoryAnalysisSelect(pFactory);
theTaxBasisSelect = new MoneyWiseXTaxBasisAnalysisSelect(pFactory);
theTagSelect = new MoneyWiseXTransTagSelect(pFactory);
theAllSelect = new MoneyWiseXAllSelect(pFactory);
/* Create the card panel */
final TethysUIPaneFactory myPanes = pFactory.paneFactory();
theCardPanel = myPanes.newCardPane();
/* Create the filter detail panel */
theFilterDetail = buildFilterDetail(pFactory);
/* Create the filter selection panel */
theFilterSelect = buildFilterSelect(pFactory);
/* Create the control panel */
final TethysUIBoxPaneManager myPanel = buildControlPanel(pFactory, pNewButton);
/* Create the panel */
thePanel = myPanes.newVBoxPane();
thePanel.addNode(myPanel);
thePanel.addNode(theRangeSelect);
thePanel.addNode(theFilterSelect);
/* Initially hide the select boxes */
theRangeSelect.setVisible(false);
theFilterSelect.setVisible(false);
/* Create initial state */
theState = new MoneyWiseAnalysisState();
theState.showColumns(true);
final MoneyWiseXStatementSelect mySelect = new MoneyWiseXStatementSelect(theRangeSelect, new MoneyWiseXAnalysisAllFilter());
selectStatement(mySelect);
/* Access the menus */
theTypeMenu = theFilterTypeButton.getMenu();
theBucketMenu = theBucketButton.getMenu();
theColumnMenu = theColumnButton.getMenu();
/* Create the listeners */
OceanusEventRegistrar<TethysUIEvent> myRegistrar = theFilterTypeButton.getEventRegistrar();
myRegistrar.addEventListener(TethysUIEvent.NEWVALUE, e -> handleFilterType());
theFilterTypeButton.setMenuConfigurator(e -> buildAnalysisTypeMenu());
myRegistrar = theBucketButton.getEventRegistrar();
myRegistrar.addEventListener(TethysUIEvent.NEWVALUE, e -> handleNewBucket());
theBucketButton.setMenuConfigurator(e -> buildBucketMenu());
myRegistrar = theColumnButton.getEventRegistrar();
myRegistrar.addEventListener(TethysUIEvent.NEWVALUE, e -> handleNewColumns());
theColumnButton.setMenuConfigurator(e -> buildColumnsMenu());
/* Handle Analysis Manager */
theAnalysisMgr.getEventRegistrar().addEventListener(e -> refreshData());
/* Handle buttons */
theRangeButton.getEventRegistrar().addEventListener(e -> setRangeVisibility(!isRangeVisible));
theFilterButton.getEventRegistrar().addEventListener(e -> setFilterVisibility(!isFilterVisible));
theRangeSelect.getEventRegistrar().addEventListener(TethysUIEvent.NEWVALUE, e -> handleNewRange());
/* handle sub-selections */
theDepositSelect.getEventRegistrar().addEventListener(e -> buildDepositFilter());
theCashSelect.getEventRegistrar().addEventListener(e -> buildCashFilter());
theLoanSelect.getEventRegistrar().addEventListener(e -> buildLoanFilter());
theSecuritySelect.getEventRegistrar().addEventListener(e -> buildSecurityFilter());
thePortfolioSelect.getEventRegistrar().addEventListener(e -> buildPortfolioFilter());
thePayeeSelect.getEventRegistrar().addEventListener(e -> buildPayeeFilter());
theCategorySelect.getEventRegistrar().addEventListener(e -> buildCategoryFilter());
theTaxBasisSelect.getEventRegistrar().addEventListener(e -> buildTaxBasisFilter());
theTagSelect.getEventRegistrar().addEventListener(e -> buildTagFilter());
}
@Override
public TethysUIComponent getUnderlying() {
return thePanel;
}
@Override
public OceanusEventRegistrar<PrometheusDataEvent> getEventRegistrar() {
return theEventManager.getEventRegistrar();
}
/**
* Obtain the DateDayRange.
*
* @return the range.
*/
public OceanusDateRange getRange() {
return theState.getRange();
}
/**
* Obtain the analysis.
*
* @return the range.
*/
public MoneyWiseXAnalysis getAnalysis() {
return theAnalysis;
}
/**
* Obtain the Filter.
*
* @return the filter.
*/
public MoneyWiseXAnalysisFilter<?, ?> getFilter() {
return theState.getFilter();
}
/**
* Obtain the ColumnSet.
*
* @return the columnSet.
*/
public MoneyWiseAnalysisColumnSet getColumns() {
return theState.getColumns();
}
/**
* Are we showing columns?
*
* @return true/false.
*/
public boolean showColumns() {
return theState.showColumns();
}
/**
* Create control panel.
*
* @param pFactory the GUI factory
* @param pNewButton the new button
* @return the panel
*/
private TethysUIBoxPaneManager buildControlPanel(final TethysUIFactory<?> pFactory,
final TethysUIButton pNewButton) {
/* Create the control panel */
final TethysUIBoxPaneManager myPanel = pFactory.paneFactory().newHBoxPane();
/* Create the labels */
final TethysUILabel myRangeLabel = pFactory.controlFactory().newLabel(NLS_RANGE);
/* Create save button */
final TethysUIButton mySave = pFactory.buttonFactory().newButton();
MetisIcon.configureSaveIconButton(mySave);
/* Create the panel */
myPanel.setBorderTitle(NLS_TITLE);
myPanel.addNode(myRangeLabel);
myPanel.addNode(theRangeButton);
myPanel.addSpacer();
myPanel.addNode(theFilterDetail);
myPanel.addSpacer();
myPanel.addNode(mySave);
myPanel.addNode(pNewButton);
/* Pass through the save event */
final OceanusEventRegistrar<TethysUIEvent> myRegistrar = mySave.getEventRegistrar();
myRegistrar.addEventListener(e -> theEventManager.fireEvent(PrometheusDataEvent.SAVETOFILE));
/* Return the panel */
return myPanel;
}
/**
* Create filter detail panel.
*
* @param pFactory the GUI factory
* @return the panel
*/
private TethysUIBoxPaneManager buildFilterDetail(final TethysUIFactory<?> pFactory) {
/* Create the control panel */
final TethysUIBoxPaneManager myPanel = pFactory.paneFactory().newHBoxPane();
/* Create the labels */
final TethysUILabel myFilterLabel = pFactory.controlFactory().newLabel(NLS_FILTER);
/* Create the panel */
myPanel.addNode(myFilterLabel);
myPanel.addNode(theFilterButton);
myPanel.addSpacer();
myPanel.addNode(theBucketLabel);
myPanel.addNode(theColumnLabel);
myPanel.addNode(theBucketButton);
myPanel.addNode(theColumnButton);
/* Return the panel */
return myPanel;
}
/**
* Create filter select panel.
*
* @param pFactory the GUI factory
* @return the panel
*/
private TethysUIBoxPaneManager buildFilterSelect(final TethysUIFactory<?> pFactory) {
/* Create the filter panel */
final TethysUIBoxPaneManager myPanel = pFactory.paneFactory().newHBoxPane();
/* Create the labels */
final TethysUILabel myTypeLabel = pFactory.controlFactory().newLabel(NLS_FILTERTYPE);
/* Add to the card panels */
theCardPanel.addCard(MoneyWiseXAnalysisType.DEPOSIT.name(), theDepositSelect);
theCardPanel.addCard(MoneyWiseXAnalysisType.CASH.name(), theCashSelect);
theCardPanel.addCard(MoneyWiseXAnalysisType.LOAN.name(), theLoanSelect);
theCardPanel.addCard(MoneyWiseXAnalysisType.SECURITY.name(), theSecuritySelect);
theCardPanel.addCard(MoneyWiseXAnalysisType.PORTFOLIO.name(), thePortfolioSelect);
theCardPanel.addCard(MoneyWiseXAnalysisType.PAYEE.name(), thePayeeSelect);
theCardPanel.addCard(MoneyWiseXAnalysisType.CATEGORY.name(), theCategorySelect);
theCardPanel.addCard(MoneyWiseXAnalysisType.TAXBASIS.name(), theTaxBasisSelect);
theCardPanel.addCard(MoneyWiseXAnalysisType.TRANSTAG.name(), theTagSelect);
theCardPanel.addCard(MoneyWiseXAnalysisType.ALL.name(), theAllSelect);
/* Build the map */
theMap.put(MoneyWiseXAnalysisType.DEPOSIT, theDepositSelect);
theMap.put(MoneyWiseXAnalysisType.CASH, theCashSelect);
theMap.put(MoneyWiseXAnalysisType.LOAN, theLoanSelect);
theMap.put(MoneyWiseXAnalysisType.SECURITY, theSecuritySelect);
theMap.put(MoneyWiseXAnalysisType.PORTFOLIO, thePortfolioSelect);
theMap.put(MoneyWiseXAnalysisType.PAYEE, thePayeeSelect);
theMap.put(MoneyWiseXAnalysisType.TAXBASIS, theTaxBasisSelect);
theMap.put(MoneyWiseXAnalysisType.TRANSTAG, theTagSelect);
theMap.put(MoneyWiseXAnalysisType.ALL, theAllSelect);
/* Create the panel */
myPanel.setBorderTitle(NLS_FILTERTITLE);
myPanel.addNode(myTypeLabel);
myPanel.addNode(theFilterTypeButton);
myPanel.addSpacer();
myPanel.addNode(theCardPanel);
/* Return the panel */
return myPanel;
}
/**
* Select Statement.
*
* @param pSelect the selection
*/
public void selectStatement(final MoneyWiseXStatementSelect pSelect) {
/* Set refreshing flag */
isRefreshing = true;
/* Update the range */
final TethysUIDateRangeSelector mySelect = pSelect.getRangeSelect();
if (mySelect != null) {
theRangeSelect.setSelection(mySelect);
theRangeSelect.lockPeriod(false);
theState.setRange(mySelect);
/* Update the analysis */
theAnalysis = theAnalysisMgr.getRangedAnalysis(mySelect.getRange());
setAnalysis();
}
/* Access the filter and the selection panel */
final MoneyWiseXAnalysisFilter<?, ?> myFilter = pSelect.getFilter();
final MoneyWiseXAnalysisType myType = myFilter.getAnalysisType();
final MoneyWiseXAnalysisFilterSelection myPanel = theMap.get(myType);
/* Move correct card to front and update it */
theCardPanel.selectCard(myType.name());
myPanel.setFilter(myFilter);
/* Determine the state */
theState.determineState(myPanel);
/* Clear refreshing flag */
isRefreshing = false;
}
/**
* Refresh data.
*/
private void refreshData() {
/* Update the range selection */
final OceanusDateRange myRange = theView.getRange();
theRangeSelect.setOverallRange(myRange);
/* Refresh the analysisView */
theAnalysis = theAnalysisMgr.getRangedAnalysis(getRange());
/* Update the filter selection */
checkType();
}
/**
* Declare analysis.
*/
private void setAnalysis() {
/* Only update if we have an analysis */
if (theAnalysis != null) {
/* Update filters */
theDepositSelect.setAnalysis(theAnalysis);
theCashSelect.setAnalysis(theAnalysis);
theLoanSelect.setAnalysis(theAnalysis);
theSecuritySelect.setAnalysis(theAnalysis);
thePortfolioSelect.setAnalysis(theAnalysis);
theCategorySelect.setAnalysis(theAnalysis);
thePayeeSelect.setAnalysis(theAnalysis);
theTaxBasisSelect.setAnalysis(theAnalysis);
theTagSelect.setAnalysis(theAnalysis);
theAllSelect.setAnalysis(theAnalysis);
/* Update the filter */
updateFilter();
}
}
/**
* Update the filter.
*/
private void updateFilter() {
/* Access the active panel */
final MoneyWiseXAnalysisType myType = theState.getType();
final MoneyWiseXAnalysisFilterSelection myPanel = theMap.get(myType);
/* Update filters */
if (myPanel != null) {
final MoneyWiseXAnalysisFilter<?, ?> myFilter = myPanel.getFilter();
myFilter.setCurrentAttribute(theState.getBucket());
theState.setFilter(myFilter);
}
/* Notify updated filter */
theEventManager.fireEvent(PrometheusDataEvent.SELECTIONCHANGED);
}
/**
* Create SavePoint.
*/
protected void createSavePoint() {
/* Create the savePoint */
theSavePoint = new MoneyWiseAnalysisState(theState);
}
/**
* Restore SavePoint.
*/
protected void restoreSavePoint() {
/* Restore the savePoint */
theState = new MoneyWiseAnalysisState(theSavePoint);
/* Apply the state */
theState.applyState();
}
@Override
public void setEnabled(final boolean bEnabled) {
/* If there are filters available */
if (isAvailable()) {
/* Enabled disable range selection */
theRangeButton.setEnabled(bEnabled);
/* Enable filter detail */
theFilterDetail.setVisible(true);
theFilterButton.setEnabled(bEnabled);
theColumnButton.setEnabled(bEnabled);
theBucketButton.setEnabled(bEnabled);
/* If we are disabling */
if (!bEnabled) {
/* Hide panels */
setRangeVisibility(false);
setFilterVisibility(false);
}
/* else no filters available */
} else {
/* Enabled disable range selection */
theRangeButton.setEnabled(false);
/* Hide panels */
setRangeVisibility(false);
setFilterVisibility(false);
theFilterDetail.setVisible(false);
theRangeSelect.setEnabled(bEnabled);
}
}
@Override
public void setVisible(final boolean pVisible) {
thePanel.setVisible(pVisible);
}
/**
* Is there any filter available?
*
* @return true/false
*/
private boolean isAvailable() {
/* Loop through the panels */
for (MoneyWiseXAnalysisFilterSelection myEntry : theMap.values()) {
/* If the filter is possible */
if (myEntry.isAvailable()) {
/* Filter available */
return true;
}
}
/* No available filters */
return false;
}
/**
* Check analysis type.
*/
private void checkType() {
/* If the type is not appropriate */
MoneyWiseXAnalysisType myType = theState.getType();
/* If the type is selected */
if (myType != null) {
/* Check that the filter is appropriate */
final MoneyWiseXAnalysisFilterSelection myPanel = theMap.get(myType);
if (myPanel.isAvailable()) {
/* We are OK */
final MoneyWiseXAnalysisFilter<?, ?> myFilter = myPanel.getFilter();
theState.setFilter(myFilter);
return;
}
}
/* Loop through the panels */
for (Entry<MoneyWiseXAnalysisType, MoneyWiseXAnalysisFilterSelection> myEntry : theMap.entrySet()) {
/* If the filter is possible */
final MoneyWiseXAnalysisFilterSelection myPanel = myEntry.getValue();
if (myPanel.isAvailable()) {
/* Access Analysis type */
myType = myEntry.getKey();
/* Move correct card to front */
theCardPanel.selectCard(myType.name());
/* Obtain the relevant filter */
final MoneyWiseXAnalysisFilter<?, ?> myFilter = myPanel.getFilter();
final MoneyWiseXAnalysisAttribute myDefault = myType.getDefaultValue();
if (myFilter != null) {
myFilter.setCurrentAttribute(myDefault);
}
/* Set new bucket type and apply state */
theState.setAnalysisType(myType);
theState.setFilter(myFilter);
theState.setBucket(myDefault);
theState.applyState();
/* Filter available */
return;
}
}
/* No available filters */
theState.setFilter(null);
theState.setAnalysisType(null);
theState.setBucket(null);
}
/**
* Build AnalysisType menu.
*/
private void buildAnalysisTypeMenu() {
/* Reset the popUp menu */
theTypeMenu.removeAllItems();
/* Loop through the panels */
for (Entry<MoneyWiseXAnalysisType, MoneyWiseXAnalysisFilterSelection> myEntry : theMap.entrySet()) {
/* If the filter is possible */
if (myEntry.getValue().isAvailable()) {
/* Create a new MenuItem and add it to the popUp */
theTypeMenu.addItem(myEntry.getKey());
}
}
}
/**
* Build Bucket menu.
*/
private void buildBucketMenu() {
/* Reset the popUp menu */
theBucketMenu.removeAllItems();
/* Loop through the buckets */
final MoneyWiseXAnalysisFilter<?, ?> myFilter = theState.getFilter();
for (MoneyWiseXAnalysisAttribute myAttr : theState.getType().getValues()) {
/* If the value is a counter */
if (!myAttr.isPreserved()
&& myFilter.isRelevantCounter(myAttr)) {
/* Create a new MenuItem and add it to the popUp */
theBucketMenu.addItem(myAttr);
}
}
/* Add the entry for null bucket */
theBucketMenu.addNullItem(NLS_NONE);
}
/**
* Build Columns menu.
*/
private void buildColumnsMenu() {
/* Reset the popUp menu */
theColumnMenu.removeAllItems();
/* Determine whether we have balances */
final boolean hasBalances = theState.getType().hasBalances();
/* Loop through the sets */
for (MoneyWiseAnalysisColumnSet mySet : MoneyWiseAnalysisColumnSet.values()) {
/* if we have balances or this is not the balance set */
if (hasBalances
|| !mySet.isBalance()) {
/* Add the item */
theColumnMenu.addItem(mySet);
}
}
}
/**
* Build Deposit Filter.
*/
private void buildDepositFilter() {
applyFilter(theDepositSelect.getFilter());
}
/**
* Build Cash Filter.
*/
private void buildCashFilter() {
applyFilter(theCashSelect.getFilter());
}
/**
* Build Loan Filter.
*/
private void buildLoanFilter() {
applyFilter(theLoanSelect.getFilter());
}
/**
* Build Security Filter.
*/
private void buildSecurityFilter() {
applyFilter(theSecuritySelect.getFilter());
}
/**
* Build Portfolio Filter.
*/
private void buildPortfolioFilter() {
applyFilter(thePortfolioSelect.getFilter());
}
/**
* Build Payee Filter.
*/
private void buildPayeeFilter() {
applyFilter(thePayeeSelect.getFilter());
}
/**
* Build Category Filter.
*/
private void buildCategoryFilter() {
applyFilter(theCategorySelect.getFilter());
}
/**
* Build TaxBasis Filter.
*/
private void buildTaxBasisFilter() {
applyFilter(theTaxBasisSelect.getFilter());
}
/**
* Build Tag Filter.
*/
private void buildTagFilter() {
applyFilter(theTagSelect.getFilter());
}
/**
* Apply Filter.
*
* @param pFilter the filter
*/
private void applyFilter(final MoneyWiseXAnalysisFilter<?, ?> pFilter) {
/* Ignore if we are refreshing */
if (!isRefreshing) {
final MoneyWiseXAnalysisAttribute myBucket = theState.getBucket();
if (pFilter.isRelevantCounter(myBucket)) {
pFilter.setCurrentAttribute(theState.getBucket());
} else {
theState.setBucket(pFilter.getCurrentAttribute());
}
theState.setFilter(pFilter);
theState.applyState();
theEventManager.fireEvent(PrometheusDataEvent.SELECTIONCHANGED);
}
}
/**
* Handle New Range.
*/
private void handleNewRange() {
/* Ignore if we are refreshing */
if (isRefreshing) {
return;
}
/* If we have a change to the range */
if (theState.setRange(theRangeSelect)) {
/* Note that we are refreshing */
isRefreshing = true;
/* Obtain new analysis */
theAnalysis = theAnalysisMgr.getRangedAnalysis(getRange());
setAnalysis();
/* Validate state and apply */
checkType();
theState.applyState();
/* Remove refreshing flag and notify listeners */
isRefreshing = false;
theEventManager.fireEvent(PrometheusDataEvent.SELECTIONCHANGED);
}
}
/**
* Set RangeSelect visibility.
*
* @param pVisible the visibility setting
*/
private void setRangeVisibility(final boolean pVisible) {
theRangeButton.setIcon(pVisible
? TethysUIArrowIconId.UP
: TethysUIArrowIconId.DOWN);
theRangeSelect.setVisible(pVisible);
isRangeVisible = pVisible;
}
/**
* Set FilterSelect visibility.
*
* @param pVisible the visibility setting
*/
private void setFilterVisibility(final boolean pVisible) {
theFilterButton.setIcon(pVisible
? TethysUIArrowIconId.UP
: TethysUIArrowIconId.DOWN);
theFilterSelect.setVisible(pVisible);
isFilterVisible = pVisible;
}
/**
* Handle New Bucket.
*/
private void handleNewBucket() {
/* Ignore if we are refreshing */
if (isRefreshing) {
return;
}
final MoneyWiseXAnalysisAttribute myBucket = theBucketButton.getValue();
if (theState.setBucket(myBucket)) {
final MoneyWiseXAnalysisFilter<?, ?> myFilter = theState.getFilter();
if (myBucket != null) {
myFilter.setCurrentAttribute(myBucket);
}
theState.applyState();
theEventManager.fireEvent(PrometheusDataEvent.SELECTIONCHANGED);
}
}
/**
* Handle New Columns.
*/
private void handleNewColumns() {
/* Ignore if we are refreshing */
if (isRefreshing) {
return;
}
/* Record the columns */
final MoneyWiseAnalysisColumnSet mySet = theColumnButton.getValue();
if (theState.setColumns(mySet)) {
theState.applyState();
theEventManager.fireEvent(PrometheusDataEvent.SELECTIONCHANGED);
}
}
/**
* Handle FilterType.
*/
private void handleFilterType() {
/* Ignore if we are refreshing */
if (isRefreshing) {
return;
}
/* If the type has changed */
final MoneyWiseXAnalysisType myType = theFilterTypeButton.getValue();
if (theState.setAnalysisType(myType)) {
/* Determine whether we are showing balances */
final boolean showingBalances = !theState.showColumns();
if (showingBalances && !myType.hasBalances()) {
/* Move to columns if we have no balances */
theState.showColumns(true);
}
/* Move correct card to front */
theCardPanel.selectCard(myType.name());
/* Obtain the relevant filter */
final MoneyWiseXAnalysisFilterSelection myPanel = theMap.get(myType);
final MoneyWiseXAnalysisFilter<?, ?> myFilter = myPanel.getFilter();
myFilter.setCurrentAttribute(myType.getDefaultValue());
/* Set new bucket type and apply state */
theState.setFilter(myFilter);
theState.setBucket(myFilter.getCurrentAttribute());
theState.applyState();
theEventManager.fireEvent(PrometheusDataEvent.SELECTIONCHANGED);
}
}
/**
* SavePoint values.
*/
private final class MoneyWiseAnalysisState {
/**
* The Range.
*/
private OceanusDateRange theRange;
/**
* The AnalysisType.
*/
private MoneyWiseXAnalysisType theType;
/**
* The BucketAttribute.
*/
private MoneyWiseXAnalysisAttribute theBucket;
/**
* The ColumnSet.
*/
private MoneyWiseAnalysisColumnSet theColumns;
/**
* The filter.
*/
private MoneyWiseXAnalysisFilter<?, ?> theFilter;
/**
* Are we showing Columns?
*/
private boolean showColumns;
/**
* Constructor.
*/
private MoneyWiseAnalysisState() {
theRange = null;
theFilter = null;
theType = null;
theBucket = null;
theColumns = MoneyWiseAnalysisColumnSet.STANDARD;
showColumns = true;
}
/**
* Constructor.
*
* @param pState state to copy from
*/
private MoneyWiseAnalysisState(final MoneyWiseAnalysisState pState) {
theRange = pState.getRange();
theFilter = pState.getFilter();
theType = pState.getType();
theBucket = pState.getBucket();
theColumns = pState.getColumns();
showColumns = pState.showColumns();
}
/**
* Obtain the DateDayRange.
*
* @return the range.
*/
private OceanusDateRange getRange() {
return theRange;
}
/**
* Obtain the AnalysisType.
*
* @return the analysis type.
*/
private MoneyWiseXAnalysisType getType() {
return theType;
}
/**
* Obtain the BucketType.
*
* @return the bucket type.
*/
private MoneyWiseXAnalysisAttribute getBucket() {
return theBucket;
}
/**
* Obtain the Columns.
*
* @return the columns.
*/
private MoneyWiseAnalysisColumnSet getColumns() {
return theColumns;
}
/**
* Obtain the Filter.
*
* @return the filter.
*/
private MoneyWiseXAnalysisFilter<?, ?> getFilter() {
return theFilter;
}
/**
* Are we showing columns?
*
* @return true/false.
*/
private boolean showColumns() {
return showColumns;
}
/**
* Determine selection from panels.
*
* @param pFilter selection panel
*/
private void determineState(final MoneyWiseXAnalysisFilterSelection pFilter) {
/* Update the selection panels */
theRange = theRangeSelect.getRange();
theFilter = pFilter.getFilter();
theType = theFilter.getAnalysisType();
theBucket = theFilter.getCurrentAttribute();
showColumns = theBucket == null;
applyState();
}
/**
* Set new Range from select panel.
*
* @param pSelect the selection panel
* @return true/false did a change occur
*/
private boolean setRange(final TethysUIDateRangeSelector pSelect) {
/* Adjust the selected account */
final OceanusDateRange myRange = pSelect.getRange();
if (!MetisDataDifference.isEqual(myRange, theRange)) {
theRange = myRange;
return true;
}
return false;
}
/**
* Set new analysis type.
*
* @param pType the analysis type
* @return true/false did a change occur
*/
private boolean setAnalysisType(final MoneyWiseXAnalysisType pType) {
if (!MetisDataDifference.isEqual(pType, theType)) {
theType = pType;
return true;
}
return false;
}
/**
* Set new bucket type.
*
* @param pBucket the bucket type
* @return true/false did a change occur
*/
private boolean setBucket(final MoneyWiseXAnalysisAttribute pBucket) {
if (!MetisDataDifference.isEqual(pBucket, theBucket)) {
/* If this is the null bucket */
if (pBucket == null) {
showColumns = true;
} else {
theBucket = pBucket;
}
return true;
}
return false;
}
/**
* Set new column set.
*
* @param pColumnSet the column set
* @return true/false did a change occur
*/
private boolean setColumns(final MoneyWiseAnalysisColumnSet pColumnSet) {
if (!MetisDataDifference.isEqual(pColumnSet, theColumns)) {
/* If this is the balance bucket */
if (pColumnSet.equals(MoneyWiseAnalysisColumnSet.BALANCE)) {
showColumns = false;
} else {
theColumns = pColumnSet;
}
return true;
}
return false;
}
/**
* Set filter.
*
* @param pFilter the filter
*/
private void setFilter(final MoneyWiseXAnalysisFilter<?, ?> pFilter) {
theFilter = pFilter;
}
/**
* Apply the State.
*/
private void applyState() {
/* Adjust the lock-down */
setEnabled(true);
theRangeButton.setText(theRange.toString());
theFilterButton.setText((theFilter == null)
? null
: theFilter.getName());
theFilterTypeButton.setValue(theType);
theBucketButton.setValue(theBucket);
theColumnButton.setValue(theColumns);
showColumns(showColumns);
}
/**
* Show Columns.
*
* @param pShow true/false
*/
private void showColumns(final boolean pShow) {
/* Show columns */
theColumnLabel.setVisible(pShow);
theColumnButton.setVisible(pShow);
/* Hide buckets */
theBucketLabel.setVisible(!pShow);
theBucketButton.setVisible(!pShow);
/* Record details */
showColumns = pShow;
}
}
/**
* The Statement Select class.
*/
public static final class MoneyWiseXStatementSelect {
/**
* The Range Selection.
*/
private final TethysUIDateRangeSelector theRangeSelect;
/**
* The AnalysisFilter.
*/
private final MoneyWiseXAnalysisFilter<?, ?> theFilter;
/**
* Constructor.
*
* @param pRangeSelect the range selection
* @param pFilter the analysis filter
*/
public MoneyWiseXStatementSelect(final TethysUIDateRangeSelector pRangeSelect,
final MoneyWiseXAnalysisFilter<?, ?> pFilter) {
/* Store parameters */
theRangeSelect = pRangeSelect;
theFilter = pFilter;
}
/**
* Obtain the RangeSelection.
*
* @return the filter
*/
public TethysUIDateRangeSelector getRangeSelect() {
return theRangeSelect;
}
/**
* Obtain the Filter.
*
* @return the filter
*/
public MoneyWiseXAnalysisFilter<?, ?> getFilter() {
return theFilter;
}
}
}