/*
    * 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.lethe.ui.dialog;
  
  import io.github.tonywasher.joceanus.oceanus.base.OceanusException;
  import io.github.tonywasher.joceanus.oceanus.date.OceanusDate;
  import io.github.tonywasher.joceanus.oceanus.date.OceanusDateConfig;
  import io.github.tonywasher.joceanus.oceanus.date.OceanusDateRange;
  import io.github.tonywasher.joceanus.oceanus.decimal.OceanusMoney;
  import io.github.tonywasher.joceanus.oceanus.decimal.OceanusPrice;
  import io.github.tonywasher.joceanus.oceanus.decimal.OceanusRatio;
  import io.github.tonywasher.joceanus.oceanus.decimal.OceanusUnits;
  import io.github.tonywasher.joceanus.metis.data.MetisDataItem.MetisDataFieldId;
  import io.github.tonywasher.joceanus.metis.field.MetisFieldRequired;
  import io.github.tonywasher.joceanus.moneywise.data.basic.MoneyWiseAssetBase;
  import io.github.tonywasher.joceanus.moneywise.data.basic.MoneyWiseAssetBase.MoneyWiseAssetBaseList;
  import io.github.tonywasher.joceanus.moneywise.data.basic.MoneyWiseAssetDirection;
  import io.github.tonywasher.joceanus.moneywise.data.basic.MoneyWiseAssetType;
  import io.github.tonywasher.joceanus.moneywise.data.basic.MoneyWiseBasicDataType;
  import io.github.tonywasher.joceanus.moneywise.data.basic.MoneyWiseBasicResource;
  import io.github.tonywasher.joceanus.moneywise.data.basic.MoneyWiseCash.MoneyWiseCashList;
  import io.github.tonywasher.joceanus.moneywise.data.basic.MoneyWiseDataSet;
  import io.github.tonywasher.joceanus.moneywise.data.basic.MoneyWiseDataValidator.MoneyWiseDataValidatorTrans;
  import io.github.tonywasher.joceanus.moneywise.data.basic.MoneyWiseDeposit.MoneyWiseDepositList;
  import io.github.tonywasher.joceanus.moneywise.data.basic.MoneyWiseLoan.MoneyWiseLoanList;
  import io.github.tonywasher.joceanus.moneywise.data.basic.MoneyWisePayee.MoneyWisePayeeList;
  import io.github.tonywasher.joceanus.moneywise.data.basic.MoneyWisePortfolio;
  import io.github.tonywasher.joceanus.moneywise.data.basic.MoneyWisePortfolio.MoneyWisePortfolioList;
  import io.github.tonywasher.joceanus.moneywise.data.basic.MoneyWiseSecurity;
  import io.github.tonywasher.joceanus.moneywise.data.basic.MoneyWiseSecurityHolding;
  import io.github.tonywasher.joceanus.moneywise.data.basic.MoneyWiseSecurityHolding.MoneyWiseSecurityHoldingMap;
  import io.github.tonywasher.joceanus.moneywise.data.basic.MoneyWiseTransAsset;
  import io.github.tonywasher.joceanus.moneywise.data.basic.MoneyWiseTransCategory;
  import io.github.tonywasher.joceanus.moneywise.data.basic.MoneyWiseTransCategory.MoneyWiseTransCategoryList;
  import io.github.tonywasher.joceanus.moneywise.data.basic.MoneyWiseTransInfoSet;
  import io.github.tonywasher.joceanus.moneywise.data.basic.MoneyWiseTransTag;
  import io.github.tonywasher.joceanus.moneywise.data.basic.MoneyWiseTransaction;
  import io.github.tonywasher.joceanus.moneywise.data.basic.MoneyWiseTransaction.MoneyWiseTransactionList;
  import io.github.tonywasher.joceanus.moneywise.data.statics.MoneyWiseTransCategoryClass;
  import io.github.tonywasher.joceanus.moneywise.data.statics.MoneyWiseTransInfoClass;
  import io.github.tonywasher.joceanus.moneywise.data.validate.MoneyWiseValidateTransaction;
  import io.github.tonywasher.joceanus.moneywise.lethe.data.analysis.data.MoneyWiseAnalysis;
  import io.github.tonywasher.joceanus.moneywise.lethe.ui.controls.MoneyWiseAnalysisSelect;
  import io.github.tonywasher.joceanus.moneywise.lethe.views.MoneyWiseAnalysisFilter;
  import io.github.tonywasher.joceanus.moneywise.lethe.views.MoneyWiseTransactionFilters;
  import io.github.tonywasher.joceanus.moneywise.ui.MoneyWiseIcon;
  import io.github.tonywasher.joceanus.moneywise.ui.MoneyWiseUIResource;
  import io.github.tonywasher.joceanus.moneywise.ui.base.MoneyWiseBaseTable;
  import io.github.tonywasher.joceanus.moneywise.ui.base.MoneyWiseItemPanel;
  import io.github.tonywasher.joceanus.prometheus.ui.fieldset.PrometheusFieldSet;
  import io.github.tonywasher.joceanus.prometheus.ui.fieldset.PrometheusFieldSetEvent;
  import io.github.tonywasher.joceanus.prometheus.views.PrometheusEditSet;
  import io.github.tonywasher.joceanus.tethys.api.control.TethysUIControl.TethysUIIconMapSet;
  import io.github.tonywasher.joceanus.tethys.api.factory.TethysUIFactory;
  import io.github.tonywasher.joceanus.tethys.api.field.TethysUIDataEditField.TethysUIDateButtonField;
  import io.github.tonywasher.joceanus.tethys.api.field.TethysUIDataEditField.TethysUIIconButtonField;
  import io.github.tonywasher.joceanus.tethys.api.field.TethysUIDataEditField.TethysUIIntegerEditField;
  import io.github.tonywasher.joceanus.tethys.api.field.TethysUIDataEditField.TethysUIListButtonField;
  import io.github.tonywasher.joceanus.tethys.api.field.TethysUIDataEditField.TethysUIMoneyEditField;
  import io.github.tonywasher.joceanus.tethys.api.field.TethysUIDataEditField.TethysUIPriceEditField;
  import io.github.tonywasher.joceanus.tethys.api.field.TethysUIDataEditField.TethysUIRatioEditField;
  import io.github.tonywasher.joceanus.tethys.api.field.TethysUIDataEditField.TethysUIScrollButtonField;
  import io.github.tonywasher.joceanus.tethys.api.field.TethysUIDataEditField.TethysUIStringEditField;
  import io.github.tonywasher.joceanus.tethys.api.field.TethysUIDataEditField.TethysUIUnitsEditField;
  import io.github.tonywasher.joceanus.tethys.api.field.TethysUIFieldFactory;
  import io.github.tonywasher.joceanus.tethys.api.menu.TethysUIScrollItem;
  import io.github.tonywasher.joceanus.tethys.api.menu.TethysUIScrollMenu;
  import io.github.tonywasher.joceanus.tethys.api.menu.TethysUIScrollSubMenu;
  
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  
  /**
   * Panel to display/edit/create a Transaction.
   */
  public class MoneyWiseTransactionDialog
          extends MoneyWiseItemPanel<MoneyWiseTransaction> {
      /**
       * Info Tab Title.
       */
      private static final String TAB_INFO = MoneyWiseUIResource.TRANSPANEL_TAB_INFO.getValue();
  
     /**
      * Tax Tab Title.
      */
     private static final String TAB_TAXES = MoneyWiseUIResource.TRANSPANEL_TAB_TAXES.getValue();
 
     /**
      * Securities Tab Title.
      */
     private static final String TAB_SECURITIES = MoneyWiseUIResource.TRANSPANEL_TAB_SECURITIES.getValue();
 
     /**
      * Returned Tab Title.
      */
     private static final String TAB_RETURNED = MoneyWiseUIResource.TRANSPANEL_TAB_RETURNED.getValue();
 
     /**
      * The fieldSet.
      */
     private final PrometheusFieldSet<MoneyWiseTransaction> theFieldSet;
 
     /**
      * Analysis selection panel.
      */
     private final MoneyWiseAnalysisSelect theAnalysisSelect;
 
     /**
      * dateRange.
      */
     private OceanusDateRange theRange;
 
     /**
      * reconciledState.
      */
     private Boolean theReconciledState = Boolean.FALSE;
 
     /**
      * directionState.
      */
     private Boolean theDirectionState = Boolean.FALSE;
 
     /**
      * Constructor.
      *
      * @param pFactory        the GUI factory
      * @param pEditSet        the edit set
      * @param pAnalysisSelect the analysis selection panel
      * @param pOwner          the owning table
      */
     public MoneyWiseTransactionDialog(final TethysUIFactory<?> pFactory,
                                       final PrometheusEditSet pEditSet,
                                       final MoneyWiseAnalysisSelect pAnalysisSelect,
                                       final MoneyWiseBaseTable<MoneyWiseTransaction> pOwner) {
         /* Initialise the panel */
         super(pFactory, pEditSet, pOwner);
         theAnalysisSelect = pAnalysisSelect;
 
         /* Access the fieldSet */
         theFieldSet = getFieldSet();
 
         /* Build the main panel */
         buildMainPanel(pFactory);
 
         /* Build the info panel */
         buildInfoPanel(pFactory);
 
         /* Build the tax panel */
         buildTaxPanel(pFactory);
 
         /* Build the securities panel */
         buildSecuritiesPanel(pFactory);
 
         /* Build the returned panel */
         buildReturnedPanel(pFactory);
     }
 
     /**
      * Build Main subPanel.
      *
      * @param pFactory the GUI factory
      */
     private void buildMainPanel(final TethysUIFactory<?> pFactory) {
         /* Allocate fields */
         final TethysUIFieldFactory myFields = pFactory.fieldFactory();
         final TethysUIMoneyEditField myAmount = myFields.newMoneyField();
 
         /* Create the buttons */
         final TethysUIDateButtonField myDateButton = myFields.newDateField();
         final TethysUIScrollButtonField<MoneyWiseTransAsset> myAccountButton = myFields.newScrollField(MoneyWiseTransAsset.class);
         final TethysUIScrollButtonField<MoneyWiseTransAsset> myPartnerButton = myFields.newScrollField(MoneyWiseTransAsset.class);
         final TethysUIScrollButtonField<MoneyWiseTransCategory> myCategoryButton = myFields.newScrollField(MoneyWiseTransCategory.class);
         final TethysUIIconButtonField<Boolean> myReconciledButton = myFields.newIconField(Boolean.class);
         final TethysUIIconButtonField<MoneyWiseAssetDirection> myDirectionButton = myFields.newIconField(MoneyWiseAssetDirection.class);
 
         /* Assign the fields to the panel */
         theFieldSet.addField(MoneyWiseBasicResource.MONEYWISEDATA_FIELD_DATE, myDateButton, MoneyWiseTransaction::getDate);
         theFieldSet.addField(MoneyWiseBasicResource.TRANSACTION_ACCOUNT, myAccountButton, MoneyWiseTransaction::getAccount);
         theFieldSet.addField(MoneyWiseBasicDataType.TRANSCATEGORY, myCategoryButton, MoneyWiseTransaction::getCategory);
         theFieldSet.addField(MoneyWiseBasicResource.TRANSACTION_DIRECTION, myDirectionButton, MoneyWiseTransaction::getDirection);
         theFieldSet.addField(MoneyWiseBasicResource.TRANSACTION_PARTNER, myPartnerButton, MoneyWiseTransaction::getPartner);
         theFieldSet.addField(MoneyWiseBasicResource.TRANSACTION_AMOUNT, myAmount, MoneyWiseTransaction::getAmount);
         theFieldSet.addField(MoneyWiseBasicResource.TRANSACTION_RECONCILED, myReconciledButton, MoneyWiseTransaction::isReconciled);
 
         /* Configure the menuBuilders */
         myDateButton.setDateConfigurator(this::handleDateConfig);
         myAccountButton.setMenuConfigurator(c -> buildAccountMenu(c, getItem()));
         myCategoryButton.setMenuConfigurator(c -> buildCategoryMenu(c, getItem()));
         myPartnerButton.setMenuConfigurator(c -> buildPartnerMenu(c, getItem()));
         final Map<Boolean, TethysUIIconMapSet<Boolean>> myRecMapSets = MoneyWiseIcon.configureReconciledIconButton(pFactory);
         myReconciledButton.setIconMapSet(() -> myRecMapSets.get(theReconciledState));
         final Map<Boolean, TethysUIIconMapSet<MoneyWiseAssetDirection>> myDirMapSets = MoneyWiseIcon.configureDirectionIconButton(pFactory);
         myDirectionButton.setIconMapSet(() -> myDirMapSets.get(theDirectionState));
         myAmount.setDeemedCurrency(() -> getItem().getAccount().getCurrency());
     }
 
     /**
      * Build info subPanel.
      *
      * @param pFactory the GUI factory
      */
     private void buildInfoPanel(final TethysUIFactory<?> pFactory) {
         /* Create a new panel */
         theFieldSet.newPanel(TAB_INFO);
 
         /* Allocate fields */
         final TethysUIFieldFactory myFields = pFactory.fieldFactory();
         final TethysUIMoneyEditField myAmount = myFields.newMoneyField();
         final TethysUIStringEditField myComments = myFields.newStringField();
         final TethysUIStringEditField myReference = myFields.newStringField();
         final TethysUIRatioEditField myRate = myFields.newRatioField();
 
         /* Create the buttons */
         final TethysUIListButtonField<MoneyWiseTransTag> myTagButton = myFields.newListField();
 
         /* Assign the fields to the panel */
         theFieldSet.addField(MoneyWiseTransInfoClass.PARTNERAMOUNT, myAmount, MoneyWiseTransaction::getPartnerAmount);
         theFieldSet.addField(MoneyWiseTransInfoClass.COMMENTS, myComments, MoneyWiseTransaction::getComments);
         theFieldSet.addField(MoneyWiseTransInfoClass.REFERENCE, myReference, MoneyWiseTransaction::getReference);
         theFieldSet.addField(MoneyWiseTransInfoClass.TRANSTAG, myTagButton, MoneyWiseTransaction::getTransactionTags);
         theFieldSet.addField(MoneyWiseTransInfoClass.XCHANGERATE, myRate, MoneyWiseTransaction::getExchangeRate);
 
         /* Configure the tag button */
         myTagButton.setSelectables(this::buildTransactionTags);
 
         /* Set currency */
         myAmount.setDeemedCurrency(() -> getItem().getPartner().getCurrency());
     }
 
     /**
      * Build tax subPanel.
      *
      * @param pFactory the GUI factory
      */
     private void buildTaxPanel(final TethysUIFactory<?> pFactory) {
         /* Create a new panel */
         theFieldSet.newPanel(TAB_TAXES);
 
         /* Allocate fields */
         final TethysUIFieldFactory myFields = pFactory.fieldFactory();
         final TethysUIMoneyEditField myTaxCredit = myFields.newMoneyField();
         final TethysUIMoneyEditField myEeNatIns = myFields.newMoneyField();
         final TethysUIMoneyEditField myErNatIns = myFields.newMoneyField();
         final TethysUIMoneyEditField myBenefit = myFields.newMoneyField();
         final TethysUIMoneyEditField myWithheld = myFields.newMoneyField();
         final TethysUIIntegerEditField myYears = myFields.newIntegerField();
 
         /* Assign the fields to the panel */
         theFieldSet.addField(MoneyWiseTransInfoClass.TAXCREDIT, myTaxCredit, MoneyWiseTransaction::getTaxCredit);
         theFieldSet.addField(MoneyWiseTransInfoClass.EMPLOYEENATINS, myEeNatIns, MoneyWiseTransaction::getEmployeeNatIns);
         theFieldSet.addField(MoneyWiseTransInfoClass.EMPLOYERNATINS, myErNatIns, MoneyWiseTransaction::getEmployerNatIns);
         theFieldSet.addField(MoneyWiseTransInfoClass.DEEMEDBENEFIT, myBenefit, MoneyWiseTransaction::getDeemedBenefit);
         theFieldSet.addField(MoneyWiseTransInfoClass.WITHHELD, myWithheld, MoneyWiseTransaction::getWithheld);
         theFieldSet.addField(MoneyWiseTransInfoClass.QUALIFYYEARS, myYears, MoneyWiseTransaction::getYears);
 
         /* Set currency */
         myTaxCredit.setDeemedCurrency(() -> getItem().getAccount().getCurrency());
         myEeNatIns.setDeemedCurrency(() -> getItem().getAccount().getCurrency());
         myErNatIns.setDeemedCurrency(() -> getItem().getAccount().getCurrency());
         myBenefit.setDeemedCurrency(() -> getItem().getAccount().getCurrency());
         myWithheld.setDeemedCurrency(() -> getItem().getAccount().getCurrency());
     }
 
     /**
      * Build securities subPanel.
      *
      * @param pFactory the GUI factory
      */
     private void buildSecuritiesPanel(final TethysUIFactory<?> pFactory) {
         /* Create a new panel */
         theFieldSet.newPanel(TAB_SECURITIES);
 
         /* Allocate fields */
         final TethysUIFieldFactory myFields = pFactory.fieldFactory();
         final TethysUIUnitsEditField myAccountUnits = myFields.newUnitsField();
         final TethysUIUnitsEditField myPartnerUnits = myFields.newUnitsField();
         final TethysUIMoneyEditField myCommission = myFields.newMoneyField();
         final TethysUIPriceEditField myPrice = myFields.newPriceField();
         final TethysUIRatioEditField myDilution = myFields.newRatioField();
 
         /* Assign the fields to the panel */
         theFieldSet.addField(MoneyWiseTransInfoClass.ACCOUNTDELTAUNITS, myAccountUnits, MoneyWiseTransaction::getAccountDeltaUnits);
         theFieldSet.addField(MoneyWiseTransInfoClass.PARTNERDELTAUNITS, myPartnerUnits, MoneyWiseTransaction::getPartnerDeltaUnits);
         theFieldSet.addField(MoneyWiseTransInfoClass.PRICE, myPrice, MoneyWiseTransaction::getPrice);
         theFieldSet.addField(MoneyWiseTransInfoClass.COMMISSION, myCommission, MoneyWiseTransaction::getCommission);
         theFieldSet.addField(MoneyWiseTransInfoClass.DILUTION, myDilution, MoneyWiseTransaction::getDilution);
 
         /* Set currency */
         myCommission.setDeemedCurrency(() -> getItem().getAccount().getCurrency());
         myPrice.setDeemedCurrency(() -> getItem().getAccount().getCurrency());
     }
 
     /**
      * Build returned subPanel.
      *
      * @param pFactory the GUI factory
      */
     private void buildReturnedPanel(final TethysUIFactory<?> pFactory) {
         /* Create a new panel */
         theFieldSet.newPanel(TAB_RETURNED);
 
         /* Allocate fields */
         final TethysUIFieldFactory myFields = pFactory.fieldFactory();
         final TethysUIMoneyEditField myReturnedCash = myFields.newMoneyField();
 
         /* Create the buttons */
         final TethysUIScrollButtonField<MoneyWiseTransAsset> myReturnedAccountButton = myFields.newScrollField(MoneyWiseTransAsset.class);
 
         /* Assign the fields to the panel */
         theFieldSet.addField(MoneyWiseTransInfoClass.RETURNEDCASHACCOUNT, myReturnedAccountButton, MoneyWiseTransaction::getReturnedCashAccount);
         theFieldSet.addField(MoneyWiseTransInfoClass.RETURNEDCASH, myReturnedCash, MoneyWiseTransaction::getReturnedCash);
 
         /* Configure the menuBuilders */
         myReturnedAccountButton.setMenuConfigurator(c -> buildReturnedAccountMenu(c, getItem()));
 
         /* Set currency */
         myReturnedCash.setDeemedCurrency(() -> getItem().getReturnedCashAccount().getCurrency());
     }
 
     @Override
     public void refreshData() {
         /* If we have an item */
         final MoneyWiseTransaction myItem = getItem();
         if (myItem != null) {
             final MoneyWiseTransactionList myTrans = getDataList(MoneyWiseBasicDataType.TRANSACTION, MoneyWiseTransactionList.class);
             setItem(myTrans.findItemById(myItem.getIndexedId()));
         }
 
         /* Make sure that the item is not editable */
         setEditable(false);
     }
 
     /**
      * Update editors.
      *
      * @param pRange the date range.
      */
     public void updateEditors(final OceanusDateRange pRange) {
         /* Update the range */
         theRange = pRange;
     }
 
     /**
      * Handle dateConfig.
      *
      * @param pConfig the dateConfig
      */
     private void handleDateConfig(final OceanusDateConfig pConfig) {
         /* Update Date button */
         pConfig.setEarliestDate(theRange != null
                 ? theRange.getStart()
                 : null);
         pConfig.setLatestDate(theRange != null
                 ? theRange.getEnd()
                 : null);
     }
 
     @Override
     public boolean isDeletable() {
         return getItem() != null && !getItem().isReconciled();
     }
 
     @Override
     protected void adjustFields(final boolean isEditable) {
         /* Access the item */
         final MoneyWiseTransaction myTrans = getItem();
         final boolean bIsReconciled = myTrans.isReconciled();
         final boolean bIsLocked = myTrans.isLocked();
 
         /* Determine whether the comments field should be visible */
         boolean bShowField = isEditable || myTrans.getComments() != null;
         theFieldSet.setFieldVisible(MoneyWiseTransInfoClass.COMMENTS, bShowField);
 
         /* Determine whether the reference field should be visible */
         bShowField = isEditable || myTrans.getReference() != null;
         theFieldSet.setFieldVisible(MoneyWiseTransInfoClass.REFERENCE, bShowField);
 
         /* Determine whether the tags field should be visible */
         bShowField = isEditable || myTrans.getTransactionTags() != null;
         theFieldSet.setFieldVisible(MoneyWiseTransInfoClass.TRANSTAG, bShowField);
 
         /* Determine whether the partnerAmount field should be visible */
         boolean bEditField = isEditable && isEditableField(myTrans, MoneyWiseTransInfoClass.PARTNERAMOUNT);
         bShowField = bEditField || myTrans.getPartnerAmount() != null;
         theFieldSet.setFieldVisible(MoneyWiseTransInfoClass.PARTNERAMOUNT, bShowField);
         theFieldSet.setFieldEditable(MoneyWiseTransInfoClass.PARTNERAMOUNT, bEditField);
 
         /* Determine whether the exchangeRate field should be visible */
         bEditField = isEditable && isEditableField(myTrans, MoneyWiseTransInfoClass.XCHANGERATE);
         bShowField = bEditField || myTrans.getExchangeRate() != null;
         theFieldSet.setFieldVisible(MoneyWiseTransInfoClass.XCHANGERATE, bShowField);
         theFieldSet.setFieldEditable(MoneyWiseTransInfoClass.XCHANGERATE, bEditField);
 
         /* Determine whether the taxCredit field should be visible */
         bEditField = isEditable && isEditableField(myTrans, MoneyWiseTransInfoClass.TAXCREDIT);
         bShowField = bEditField || myTrans.getTaxCredit() != null;
         theFieldSet.setFieldVisible(MoneyWiseTransInfoClass.TAXCREDIT, bShowField);
         theFieldSet.setFieldEditable(MoneyWiseTransInfoClass.TAXCREDIT, bEditField);
 
         /* Determine whether the EeNatIns field should be visible */
         bEditField = isEditable && isEditableField(myTrans, MoneyWiseTransInfoClass.EMPLOYEENATINS);
         bShowField = bEditField || myTrans.getEmployeeNatIns() != null;
         theFieldSet.setFieldVisible(MoneyWiseTransInfoClass.EMPLOYEENATINS, bShowField);
         theFieldSet.setFieldEditable(MoneyWiseTransInfoClass.EMPLOYEENATINS, bEditField);
 
         /* Determine whether the ErnatIns field should be visible */
         bEditField = isEditable && isEditableField(myTrans, MoneyWiseTransInfoClass.EMPLOYERNATINS);
         bShowField = bEditField || myTrans.getEmployerNatIns() != null;
         theFieldSet.setFieldVisible(MoneyWiseTransInfoClass.EMPLOYERNATINS, bShowField);
         theFieldSet.setFieldEditable(MoneyWiseTransInfoClass.EMPLOYERNATINS, bEditField);
 
         /* Determine whether the benefit field should be visible */
         bEditField = isEditable && isEditableField(myTrans, MoneyWiseTransInfoClass.DEEMEDBENEFIT);
         bShowField = bEditField || myTrans.getDeemedBenefit() != null;
         theFieldSet.setFieldVisible(MoneyWiseTransInfoClass.DEEMEDBENEFIT, bShowField);
         theFieldSet.setFieldEditable(MoneyWiseTransInfoClass.DEEMEDBENEFIT, bEditField);
 
         /* Determine whether the donation field should be visible */
         bEditField = isEditable && isEditableField(myTrans, MoneyWiseTransInfoClass.WITHHELD);
         bShowField = bEditField || myTrans.getWithheld() != null;
         theFieldSet.setFieldVisible(MoneyWiseTransInfoClass.WITHHELD, bShowField);
         theFieldSet.setFieldEditable(MoneyWiseTransInfoClass.WITHHELD, bEditField);
 
         /* Determine whether the account units field should be visible */
         bEditField = isEditable && isEditableField(myTrans, MoneyWiseTransInfoClass.ACCOUNTDELTAUNITS);
         bShowField = bEditField || myTrans.getAccountDeltaUnits() != null;
         theFieldSet.setFieldVisible(MoneyWiseTransInfoClass.ACCOUNTDELTAUNITS, bShowField);
         theFieldSet.setFieldEditable(MoneyWiseTransInfoClass.ACCOUNTDELTAUNITS, bEditField);
 
         /* Determine whether the partnerDeltaUnits field should be visible */
         bEditField = isEditable && isEditableField(myTrans, MoneyWiseTransInfoClass.PARTNERDELTAUNITS);
         bShowField = bEditField || myTrans.getPartnerDeltaUnits() != null;
         theFieldSet.setFieldVisible(MoneyWiseTransInfoClass.PARTNERDELTAUNITS, bShowField);
         theFieldSet.setFieldEditable(MoneyWiseTransInfoClass.PARTNERDELTAUNITS, bEditField);
 
         /* Determine whether the price field should be visible */
         bEditField = isEditable && isEditableField(myTrans, MoneyWiseTransInfoClass.PRICE);
         bShowField = bEditField || myTrans.getPrice() != null;
         theFieldSet.setFieldVisible(MoneyWiseTransInfoClass.PRICE, bShowField);
         theFieldSet.setFieldEditable(MoneyWiseTransInfoClass.PRICE, bEditField);
 
         /* Determine whether the commission field should be visible */
         bEditField = isEditable && isEditableField(myTrans, MoneyWiseTransInfoClass.COMMISSION);
         bShowField = bEditField || myTrans.getCommission() != null;
         theFieldSet.setFieldVisible(MoneyWiseTransInfoClass.COMMISSION, bShowField);
         theFieldSet.setFieldEditable(MoneyWiseTransInfoClass.COMMISSION, bEditField);
 
         /* Determine whether the dilution field should be visible */
         bEditField = isEditable && isEditableField(myTrans, MoneyWiseTransInfoClass.DILUTION);
         bShowField = bEditField || myTrans.getDilution() != null;
         theFieldSet.setFieldVisible(MoneyWiseTransInfoClass.DILUTION, bShowField);
         theFieldSet.setFieldEditable(MoneyWiseTransInfoClass.DILUTION, bEditField);
 
         /* Determine whether the returnedAccount field should be visible */
         bEditField = isEditable && isEditableField(myTrans, MoneyWiseTransInfoClass.RETURNEDCASHACCOUNT);
         bShowField = bEditField || myTrans.getReturnedCashAccount() != null;
         theFieldSet.setFieldVisible(MoneyWiseTransInfoClass.RETURNEDCASHACCOUNT, bShowField);
         theFieldSet.setFieldEditable(MoneyWiseTransInfoClass.RETURNEDCASHACCOUNT, bEditField);
 
         /* Determine whether the returnedCash field should be visible */
         bEditField = isEditable && isEditableField(myTrans, MoneyWiseTransInfoClass.RETURNEDCASH);
         bShowField = bEditField || myTrans.getReturnedCash() != null;
         theFieldSet.setFieldVisible(MoneyWiseTransInfoClass.RETURNEDCASH, bShowField);
         theFieldSet.setFieldEditable(MoneyWiseTransInfoClass.RETURNEDCASH, bEditField);
 
         /* Determine whether the years field should be visible */
         bEditField = isEditable && isEditableField(myTrans, MoneyWiseTransInfoClass.QUALIFYYEARS);
         bShowField = bEditField || myTrans.getYears() != null;
         theFieldSet.setFieldVisible(MoneyWiseTransInfoClass.QUALIFYYEARS, bShowField);
         theFieldSet.setFieldEditable(MoneyWiseTransInfoClass.QUALIFYYEARS, bEditField);
 
         /* Determine whether the reconciled field should be visible */
         final boolean bShowReconciled = isEditable || bIsReconciled;
         theReconciledState = bIsLocked;
         theDirectionState = bIsReconciled;
         theFieldSet.setFieldVisible(MoneyWiseBasicResource.TRANSACTION_RECONCILED, bShowReconciled);
         theFieldSet.setFieldEditable(MoneyWiseBasicResource.TRANSACTION_RECONCILED, isEditable && !bIsLocked);
 
         /* Determine basic editing */
         final boolean canEdit = isEditable && !bIsReconciled;
         final boolean needsNullAmount = myTrans.needsNullAmount();
         theFieldSet.setFieldEditable(MoneyWiseBasicResource.TRANSACTION_DIRECTION, canEdit && myTrans.canSwitchDirection());
         theFieldSet.setFieldEditable(MoneyWiseBasicResource.TRANSACTION_ACCOUNT, canEdit);
         theFieldSet.setFieldEditable(MoneyWiseBasicResource.TRANSACTION_PARTNER, canEdit);
         theFieldSet.setFieldEditable(MoneyWiseBasicDataType.TRANSCATEGORY, canEdit);
         theFieldSet.setFieldEditable(MoneyWiseBasicResource.MONEYWISEDATA_FIELD_DATE, canEdit);
         theFieldSet.setFieldEditable(MoneyWiseBasicResource.TRANSACTION_AMOUNT, canEdit && !needsNullAmount);
         theFieldSet.setFieldVisible(MoneyWiseBasicResource.TRANSACTION_AMOUNT, !needsNullAmount);
 
         /* Set the range for the dateButton */
         final MoneyWiseValidateTransaction myBuilder = (MoneyWiseValidateTransaction) myTrans.getList().getValidator();
         theRange = myBuilder.getRange();
     }
 
     /**
      * Is the field editable?
      *
      * @param pTrans the transaction
      * @param pField the field class
      * @return true/false
      */
     public static boolean isEditableField(final MoneyWiseTransaction pTrans,
                                           final MoneyWiseTransInfoClass pField) {
         /* Access the infoSet */
         final MoneyWiseTransInfoSet myInfoSet = pTrans.getInfoSet();
 
         /* If the transaction is reconciled */
         if (Boolean.TRUE.equals(pTrans.isReconciled())) {
             /* Only allow editing of metaData */
             return myInfoSet.isMetaData(pField);
         }
 
         /* Check whether the field is available */
         final MoneyWiseValidateTransaction myValidator = (MoneyWiseValidateTransaction) pTrans.getList().getValidator();
         final MetisFieldRequired isRequired = myValidator.isClassRequired(pTrans, pField);
         return !isRequired.equals(MetisFieldRequired.NOTALLOWED);
     }
 
     @SuppressWarnings("unchecked")
     @Override
     protected void updateField(final PrometheusFieldSetEvent pUpdate) throws OceanusException {
         /* Access the field */
         final MetisDataFieldId myField = pUpdate.getFieldId();
         final MoneyWiseTransaction myTrans = getItem();
         final MoneyWiseValidateTransaction myBuilder = (MoneyWiseValidateTransaction) myTrans.getList().getValidator();
 
         /* Process updates */
         if (MoneyWiseBasicResource.MONEYWISEDATA_FIELD_DATE.equals(myField)) {
             /* Update the Date */
             myTrans.setDate(pUpdate.getValue(OceanusDate.class));
         } else if (MoneyWiseBasicResource.TRANSACTION_AMOUNT.equals(myField)) {
             /* Update the Amount */
             myTrans.setAmount(pUpdate.getValue(OceanusMoney.class));
             myBuilder.autoCorrect(myTrans);
         } else if (MoneyWiseBasicResource.TRANSACTION_ACCOUNT.equals(myField)) {
             /* Update the Account */
             myTrans.setAccount(resolveAsset(pUpdate.getValue(MoneyWiseTransAsset.class)));
             myBuilder.autoCorrect(myTrans);
         } else if (MoneyWiseBasicResource.TRANSACTION_DIRECTION.equals(myField)) {
             /* Update the Direction */
             myTrans.switchDirection();
             myBuilder.autoCorrect(myTrans);
         } else if (MoneyWiseBasicResource.TRANSACTION_PARTNER.equals(myField)) {
             /* Update the Partner */
             myTrans.setPartner(resolveAsset(pUpdate.getValue(MoneyWiseTransAsset.class)));
             myBuilder.autoCorrect(myTrans);
         } else if (MoneyWiseBasicDataType.TRANSCATEGORY.equals(myField)) {
             /* Update the Category */
             myTrans.setCategory(pUpdate.getValue(MoneyWiseTransCategory.class));
             myBuilder.autoCorrect(myTrans);
         } else if (MoneyWiseBasicResource.TRANSACTION_RECONCILED.equals(myField)) {
             /* Update the Reconciled indication */
             myTrans.setReconciled(pUpdate.getValue(Boolean.class));
         } else if (MoneyWiseTransInfoClass.COMMENTS.equals(myField)) {
             /* Update the Comments */
             myTrans.setComments(pUpdate.getValue(String.class));
         } else if (MoneyWiseTransInfoClass.REFERENCE.equals(myField)) {
             /* Update the Reference */
             myTrans.setReference(pUpdate.getValue(String.class));
         } else if (MoneyWiseTransInfoClass.TRANSTAG.equals(myField)) {
             /* Update the Tag indication */
             myTrans.setTransactionTags(pUpdate.getValue(List.class));
         } else if (MoneyWiseTransInfoClass.PARTNERAMOUNT.equals(myField)) {
             /* Update the PartnerAmount */
             myTrans.setPartnerAmount(pUpdate.getValue(OceanusMoney.class));
         } else if (MoneyWiseTransInfoClass.XCHANGERATE.equals(myField)) {
             /* Update the ExchangeRate */
             myTrans.setExchangeRate(pUpdate.getValue(OceanusRatio.class));
         } else if (MoneyWiseTransInfoClass.ACCOUNTDELTAUNITS.equals(myField)) {
             /* Update the AccountDeltaUnits */
             myTrans.setAccountDeltaUnits(pUpdate.getValue(OceanusUnits.class));
         } else if (MoneyWiseTransInfoClass.PARTNERDELTAUNITS.equals(myField)) {
             /* Update the PartnerDeltaUnits */
             myTrans.setPartnerDeltaUnits(pUpdate.getValue(OceanusUnits.class));
         } else if (MoneyWiseTransInfoClass.PRICE.equals(myField)) {
             /* Update the Price */
             myTrans.setPrice(pUpdate.getValue(OceanusPrice.class));
         } else if (MoneyWiseTransInfoClass.COMMISSION.equals(myField)) {
             /* Update the Commission */
             myTrans.setCommission(pUpdate.getValue(OceanusMoney.class));
         } else if (MoneyWiseTransInfoClass.DILUTION.equals(myField)) {
             /* Update the Dilution */
             myTrans.setDilution(pUpdate.getValue(OceanusRatio.class));
         } else if (MoneyWiseTransInfoClass.QUALIFYYEARS.equals(myField)) {
             /* Update the QualifyYears */
             myTrans.setYears(pUpdate.getValue(Integer.class));
         } else if (MoneyWiseTransInfoClass.RETURNEDCASHACCOUNT.equals(myField)) {
             /* Update the ReturnedCashAccount */
             myTrans.setReturnedCashAccount(pUpdate.getValue(MoneyWiseTransAsset.class));
             myBuilder.autoCorrect(myTrans);
         } else if (MoneyWiseTransInfoClass.RETURNEDCASH.equals(myField)) {
             /* Update the ReturnedCash */
             myTrans.setReturnedCash(pUpdate.getValue(OceanusMoney.class));
         } else if (MoneyWiseTransInfoClass.TAXCREDIT.equals(myField)) {
             /* Update the TaxCredit */
             myTrans.setTaxCredit(pUpdate.getValue(OceanusMoney.class));
         } else if (MoneyWiseTransInfoClass.EMPLOYEENATINS.equals(myField)) {
             /* Update the EmployeeNatIns */
             myTrans.setEmployeeNatIns(pUpdate.getValue(OceanusMoney.class));
         } else if (MoneyWiseTransInfoClass.EMPLOYERNATINS.equals(myField)) {
             /* Update the EmployerNayIns */
             myTrans.setEmployerNatIns(pUpdate.getValue(OceanusMoney.class));
         } else if (MoneyWiseTransInfoClass.DEEMEDBENEFIT.equals(myField)) {
             /* Update the Benefit */
             myTrans.setDeemedBenefit(pUpdate.getValue(OceanusMoney.class));
         } else if (MoneyWiseTransInfoClass.WITHHELD.equals(myField)) {
             /* Update the Withheld */
             myTrans.setWithheld(pUpdate.getValue(OceanusMoney.class));
         }
     }
 
     @Override
     protected void declareGoToItems(final boolean pUpdates) {
         /* Access the item */
         final MoneyWiseTransaction myItem = getItem();
 
         /* Access the analysis and the relevant filters */
         final MoneyWiseAnalysis myAnalysis = theAnalysisSelect.getAnalysis();
         final OceanusDateRange myDateRange = theAnalysisSelect.getRange();
         final MoneyWiseTransactionFilters myFilters = new MoneyWiseTransactionFilters(myAnalysis, myDateRange, myItem);
 
         /* Remove the current filter */
         final MoneyWiseAnalysisFilter<?, ?> myCurrent = theAnalysisSelect.getFilter();
         myFilters.remove(myCurrent);
 
         /* Loop through the filters */
         final Iterator<MoneyWiseAnalysisFilter<?, ?>> myIterator = myFilters.iterator();
         while (myIterator.hasNext()) {
             final MoneyWiseAnalysisFilter<?, ?> myFilter = myIterator.next();
 
             /* declare it */
             declareGoToFilter(myFilter);
         }
 
         /* If we have not had updates */
         if (!pUpdates) {
             /* Allow GoTo different panels */
             buildAssetGoTo(myItem.getAccount());
             buildAssetGoTo(myItem.getPartner());
             declareGoToItem(myItem.getCategory());
             buildAssetGoTo(myItem.getReturnedCashAccount());
         }
     }
 
     /**
      * Handle goto declarations for TransactionAssets.
      *
      * @param pAsset the asset
      */
     private void buildAssetGoTo(final MoneyWiseTransAsset pAsset) {
         if (pAsset instanceof MoneyWiseSecurityHolding) {
             /* Build menu Items for Portfolio and Security */
             final MoneyWiseSecurityHolding myHolding = (MoneyWiseSecurityHolding) pAsset;
             declareGoToItem(myHolding.getPortfolio());
             declareGoToItem(myHolding.getSecurity());
         } else if (pAsset instanceof MoneyWiseAssetBase) {
             declareGoToItem((MoneyWiseAssetBase) pAsset);
         }
     }
 
     /**
      * Resolve Asset.
      *
      * @param pAsset the asset to resolve
      * @return the resolved asset
      */
     public static MoneyWiseTransAsset resolveAsset(final MoneyWiseTransAsset pAsset) {
         /* If this is a security holding */
         if (pAsset instanceof MoneyWiseSecurityHolding) {
             /* declare holding via map */
             final MoneyWiseSecurityHolding myHolding = (MoneyWiseSecurityHolding) pAsset;
             final MoneyWisePortfolio myPortfolio = myHolding.getPortfolio();
             final MoneyWiseSecurity mySecurity = myHolding.getSecurity();
             final MoneyWiseDataSet myData = myPortfolio.getDataSet();
             final MoneyWiseSecurityHoldingMap myMap = myData.getPortfolios().getSecurityHoldingsMap();
             return myMap.declareHolding(myPortfolio, mySecurity);
         }
 
         /* Just return the asset */
         return pAsset;
     }
 
     /**
      * Build the account menu for an item.
      *
      * @param pMenu  the menu
      * @param pTrans the transaction to build for
      */
     public void buildAccountMenu(final TethysUIScrollMenu<MoneyWiseTransAsset> pMenu,
                                  final MoneyWiseTransaction pTrans) {
         /* Clear the menu */
         pMenu.removeAllItems();
 
         /* Add possible items */
         buildAssetMenu(pMenu, getDataList(MoneyWiseBasicDataType.DEPOSIT, MoneyWiseDepositList.class), true, pTrans);
         buildAssetMenu(pMenu, getDataList(MoneyWiseBasicDataType.CASH, MoneyWiseCashList.class), true, pTrans);
         buildAssetMenu(pMenu, getDataList(MoneyWiseBasicDataType.LOAN, MoneyWiseLoanList.class), true, pTrans);
         buildHoldingMenu(pMenu, true, pTrans);
         buildAssetMenu(pMenu, getDataList(MoneyWiseBasicDataType.PORTFOLIO, MoneyWisePortfolioList.class), true, pTrans);
     }
 
     /**
      * Build the partner menu for an item.
      *
      * @param pMenu  the menu
      * @param pTrans the transaction to build for
      */
     public void buildPartnerMenu(final TethysUIScrollMenu<MoneyWiseTransAsset> pMenu,
                                  final MoneyWiseTransaction pTrans) {
         /* Clear the menu */
         pMenu.removeAllItems();
 
         /* Add possible items */
         buildAssetMenu(pMenu, getDataList(MoneyWiseBasicDataType.DEPOSIT, MoneyWiseDepositList.class), false, pTrans);
         buildAssetMenu(pMenu, getDataList(MoneyWiseBasicDataType.CASH, MoneyWiseCashList.class), false, pTrans);
         buildAssetMenu(pMenu, getDataList(MoneyWiseBasicDataType.LOAN, MoneyWiseLoanList.class), false, pTrans);
         buildHoldingMenu(pMenu, false, pTrans);
         buildAssetMenu(pMenu, getDataList(MoneyWiseBasicDataType.PORTFOLIO, MoneyWisePortfolioList.class), false, pTrans);
         buildAssetMenu(pMenu, getDataList(MoneyWiseBasicDataType.PAYEE, MoneyWisePayeeList.class), false, pTrans);
     }
 
     /**
      * Build the asset menu for an item.
      *
      * @param <T>        the Asset type
      * @param pMenu      the menu
      * @param pIsAccount is this item the account rather than partner
      * @param pList      the asset list
      * @param pTrans     the transaction to build for
      */
     private static <T extends MoneyWiseAssetBase> void buildAssetMenu(final TethysUIScrollMenu<MoneyWiseTransAsset> pMenu,
                                                                       final MoneyWiseAssetBaseList<T> pList,
                                                                       final boolean pIsAccount,
                                                                       final MoneyWiseTransaction pTrans) {
         /* Record active item */
         final MoneyWiseTransAsset myAccount = pTrans.getAccount();
         final MoneyWiseTransCategory myCategory = pTrans.getCategory();
         final MoneyWiseDataValidatorTrans<?> myValidator = pTrans.getList().getValidator();
         final MoneyWiseTransAsset myCurr = pIsAccount
                 ? myAccount
                 : pTrans.getPartner();
         TethysUIScrollItem<MoneyWiseTransAsset> myActive = null;
         TethysUIScrollSubMenu<MoneyWiseTransAsset> myMenu = null;
 
         /* Loop through the available values */
         final Iterator<T> myIterator = pList.iterator();
         while (myIterator.hasNext()) {
             final T myAsset = myIterator.next();
 
             /* Only process non-deleted/non-closed items */
             boolean bIgnore = myAsset.isDeleted() || myAsset.isClosed();
 
             /* Check whether the asset is allowable for the owner */
             bIgnore |= !(pIsAccount
                     ? myValidator.isValidAccount(myAsset)
                     : myValidator.isValidPartner(myAccount, myCategory, myAsset));
             if (bIgnore) {
                 continue;
             }
 
             /* If this the first item */
             if (myMenu == null) {
                 /* Create a new subMenu and add it to the popUp */
                 myMenu = pMenu.addSubMenu(pList.getItemType().getItemName());
             }
 
             /* Create a new MenuItem and add it to the popUp */
             final TethysUIScrollItem<MoneyWiseTransAsset> myItem = myMenu.getSubMenu().addItem(myAsset);
 
             /* If this is the active category */
             if (myAsset.equals(myCurr)) {
                 /* Record it */
                 myActive = myItem;
             }
         }
 
         /* Ensure active item is visible */
         if (myActive != null) {
             myActive.scrollToItem();
         }
     }
 
     /**
      * Build the holding asset menu for an item.
      *
      * @param pMenu      the menu
      * @param pIsAccount is this item the account rather than partner
      * @param pTrans     the transaction to build for
      */
     private static void buildHoldingMenu(final TethysUIScrollMenu<MoneyWiseTransAsset> pMenu,
                                          final boolean pIsAccount,
                                          final MoneyWiseTransaction pTrans) {
         /* Record active item */
         final MoneyWiseTransAsset myAccount = pTrans.getAccount();
         final MoneyWiseTransCategory myCategory = pTrans.getCategory();
         final MoneyWiseDataValidatorTrans<?> myValidator = pTrans.getList().getValidator();
         final MoneyWiseTransAsset myCurr = pIsAccount
                 ? myAccount
                 : pTrans.getPartner();
         TethysUIScrollItem<MoneyWiseTransAsset> myActive = null;
         TethysUIScrollSubMenu<MoneyWiseTransAsset> myMenu = null;
 
         /* Access Portfolios and Holdings Map */
         final MoneyWiseDataSet myData = pTrans.getDataSet();
         final MoneyWisePortfolioList myPortfolios = myData.getPortfolios();
         final MoneyWiseSecurityHoldingMap myMap = myPortfolios.getSecurityHoldingsMap();
 
         /* Loop through the Portfolios */
         final Iterator<MoneyWisePortfolio> myPortIterator = myPortfolios.iterator();
         while (myPortIterator.hasNext()) {
             final MoneyWisePortfolio myPortfolio = myPortIterator.next();
             TethysUIScrollSubMenu<MoneyWiseTransAsset> myCoreMenu = null;
 
             /* Ignore deleted or closed */
             if (myPortfolio.isDeleted()
                     || Boolean.TRUE.equals(myPortfolio.isClosed())) {
                 continue;
             }
 
             /* Look for existing and new holdings */
             final Iterator<MoneyWiseSecurityHolding> myExistIterator = myMap.existingIterator(myPortfolio);
             final Iterator<MoneyWiseSecurityHolding> myNewIterator = myMap.newIterator(myPortfolio);
             if ((myExistIterator != null) || (myNewIterator != null)) {
                 /* If there are existing elements */
                 if (myExistIterator != null) {
                     /* Loop through them */
                     while (myExistIterator.hasNext()) {
                         final MoneyWiseSecurityHolding myHolding = myExistIterator.next();
                         final MoneyWiseSecurity mySecurity = myHolding.getSecurity();
 
                         /* Check whether the asset is allowable for the owner */
                         final boolean bIgnore = !(pIsAccount
                                 ? myValidator.isValidAccount(myHolding)
                                 : myValidator.isValidPartner(myAccount, myCategory, myHolding));
                         if (bIgnore) {
                             continue;
                         }
 
                         /* Ensure that hierarchy is created */
                         if (myMenu == null) {
                             /* Create a new JMenu and add it to the popUp */
                             myMenu = pMenu.addSubMenu(MoneyWiseAssetType.SECURITYHOLDING.toString());
                         }
                         if (myCoreMenu == null) {
                             /* Create a new JMenu and add it to the popUp */
                             myCoreMenu = myMenu.getSubMenu().addSubMenu(myPortfolio.getName());
                         }
 
                         /* Add the item to the menu */
                         final TethysUIScrollItem<MoneyWiseTransAsset> myItem = myCoreMenu.getSubMenu().addItem(myHolding, mySecurity.getName());
 
                         /* If this is the active holding */
                         if (mySecurity.equals(myCurr)) {
                             /* Record it */
                             myActive = myItem;
                         }
                     }
                 }
 
                 /* If there are new elements */
                 if (myNewIterator != null) {
                     /* Loop through them */
                     TethysUIScrollSubMenu<MoneyWiseTransAsset> mySubMenu = null;
                     while (myNewIterator.hasNext()) {
                         final MoneyWiseSecurityHolding myHolding = myNewIterator.next();
                         final MoneyWiseSecurity mySecurity = myHolding.getSecurity();
 
                         /* Check whether the asset is allowable for the owner */
                         final boolean bIgnore = !(pIsAccount
                                 ? myValidator.isValidAccount(myHolding)
                                 : myValidator.isValidPartner(myAccount, myCategory, myHolding));
                         if (bIgnore) {
                             continue;
                         }
 
                         /* Ensure that hierarchy is created */
                         if (myMenu == null) {
                             /* Create a new subMenu and add it to the popUp */
                             myMenu = pMenu.addSubMenu(MoneyWiseAssetType.SECURITYHOLDING.toString());
                         }
                         if (myCoreMenu == null) {
                             /* Create a new subMenu and add it to the popUp */
                             myCoreMenu = myMenu.getSubMenu().addSubMenu(myPortfolio.getName());
                         }
                         if (mySubMenu == null) {
                             /* Create a new subMenu */
                             mySubMenu = myCoreMenu.getSubMenu().addSubMenu(MoneyWiseSecurityHolding.SECURITYHOLDING_NEW);
                         }
 
                         /* Add the item to the menu */
                         mySubMenu.getSubMenu().addItem(myHolding, mySecurity.getName());
                     }
                 }
             }
         }
 
         /* Ensure active item is visible */
         if (myActive != null) {
             myActive.scrollToItem();
         }
     }
 
     /**
      * Build the category menu for an item.
      *
      * @param pMenu  the menu
      * @param pTrans the transaction to build for
      */
     public void buildCategoryMenu(final TethysUIScrollMenu<MoneyWiseTransCategory> pMenu,
                                   final MoneyWiseTransaction pTrans) {
         /* Clear the menu */
         pMenu.removeAllItems();
 
         /* Record active item */
         final MoneyWiseTransAsset myAccount = pTrans.getAccount();
         final MoneyWiseTransCategory myCurr = pTrans.getCategory();
         TethysUIScrollItem<MoneyWiseTransCategory> myActive = null;
         TethysUIScrollItem<MoneyWiseTransCategory> myItem;
 
         /* Create a simple map for top-level categories */
         final Map<String, TethysUIScrollSubMenu<MoneyWiseTransCategory>> myMap = new HashMap<>();
 
         /* Access Categories */
         final MoneyWiseTransCategoryList myCategories = getDataList(MoneyWiseBasicDataType.TRANSCATEGORY, MoneyWiseTransCategoryList.class);
         final MoneyWiseDataValidatorTrans<?> myValidator = pTrans.getList().getValidator();
 
         /* Loop through the available category values */
         final Iterator<MoneyWiseTransCategory> myIterator = myCategories.iterator();
         while (myIterator.hasNext()) {
             final MoneyWiseTransCategory myCategory = myIterator.next();
 
             /* Only process non-deleted low-level items */
             final MoneyWiseTransCategoryClass myClass = myCategory.getCategoryTypeClass();
             boolean bIgnore = myCategory.isDeleted() || myClass.canParentCategory();
 
             /* Check whether the category is allowable for the owner */
             bIgnore |= !myValidator.isValidCategory(myAccount, myCategory);
             if (bIgnore) {
                 continue;
             }
 
             /* Determine parent */
             final MoneyWiseTransCategory myParent = myCategory.getParentCategory();
 
             /* If we have a parent */
             if (myParent != null) {
                 final String myParentName = myParent.getName();
                 final TethysUIScrollSubMenu<MoneyWiseTransCategory> myMenu = myMap.computeIfAbsent(myParentName, pMenu::addSubMenu);
 
                 /* Create a new MenuItem and add it to the subMenu */
                 myItem = myMenu.getSubMenu().addItem(myCategory, myCategory.getSubCategory());
 
             } else {
                 /* Create a new MenuItem and add it to the popUp */
                 myItem = pMenu.addItem(myCategory);
             }
 
             /* If this is the active category */
             if (myCategory.equals(myCurr)) {
                 /* Record it */
                 myActive = myItem;
             }
         }
 
         /* Ensure active item is visible */
         if (myActive != null) {
             myActive.scrollToItem();
         }
     }
 
     /**
      * Build the ReturnedAccount menu for an item.
      *
      * @param pMenu  the menu
      * @param pTrans the transaction to build for
      */
     public void buildReturnedAccountMenu(final TethysUIScrollMenu<MoneyWiseTransAsset> pMenu,
                                          final MoneyWiseTransaction pTrans) {
         /* Clear the menu */
         pMenu.removeAllItems();
 
         /* Add possible items */
         buildAssetMenu(pMenu, getDataList(MoneyWiseBasicDataType.DEPOSIT, MoneyWiseDepositList.class), false, pTrans);
         buildAssetMenu(pMenu, getDataList(MoneyWiseBasicDataType.PORTFOLIO, MoneyWisePortfolioList.class), false, pTrans);
     }
 
     /**
      * Build the possible TransactionTag list.
      *
      * @return the transaction tag iterator
      */
     public Iterator<MoneyWiseTransTag> buildTransactionTags() {
         /* Create a list */
         final List<MoneyWiseTransTag> myList = new ArrayList<>();
 
         /* Loop through the TransactionTags */
         final Iterator<MoneyWiseTransTag> myIterator = getItem().getDataSet().getTransactionTags().iterator();
         while (myIterator.hasNext()) {
             final MoneyWiseTransTag myTag = myIterator.next();
 
             /* Add to list if available */
             if (!myTag.isDeleted()) {
                 myList.add(myTag);
             }
         }
 
         /* Return the iterator */
         return myList.iterator();
     }
 }