/// <summary>
/// Event Handler to subscribed event 'SecurityReferenceSet'
/// </summary>
/// <param name="securityReferenceData">SecurityReferenceData</param>
public void HandleSecurityReferenceSet(EntitySelectionData entitySelectionData)
{
string methodNamespace = String.Format("{0}.{1}", GetType().FullName, System.Reflection.MethodInfo.GetCurrentMethod().Name);
Logging.LogBeginMethod(logger, methodNamespace);
try
{
//argument null exception
if (entitySelectionData != null)
{
SelectedSecurity = entitySelectionData;
if (SelectedEntities.ContainsKey("SECURITY"))
{
SelectedEntities.Remove("SECURITY");
}
SelectedEntities.Add("SECURITY", entitySelectionData.LongName);
if (SelectedStartDate != null && SelectedEntities != null && period != null && SelectedEntities.ContainsKey("PORTFOLIO") && IsActive)
{
dbInteractivity.RetrieveChartExtensionData(SelectedEntities, Convert.ToDateTime(SelectedStartDate), RetrieveChartExtensionDataCallbackMethod);
BusyIndicatorStatus = true;
}
}
else
{
Logging.LogMethodParameterNull(logger, methodNamespace, 1);
}
}
catch (Exception ex)
{
Prompt.ShowDialog("Message: " + ex.Message + "\nStackTrace: " + Logging.StackTraceToString(ex), "Exception", MessageBoxButton.OK);
Logging.LogException(logger, ex);
}
}
/// <summary>
/// Handle Portfolio Change Event
/// </summary>
/// <param name="portfolioSelectionData">Detail of Selected Portfolio</param>
public void HandlePortfolioReferenceSet(PortfolioSelectionData portfolioSelectionData)
{
string methodNamespace = String.Format("{0}.{1}", GetType().FullName, System.Reflection.MethodInfo.GetCurrentMethod().Name);
Logging.LogBeginMethod(logger, methodNamespace);
try
{
//ArgumentNullException
if (portfolioSelectionData != null && portfolioSelectionData.PortfolioId != null)
{
if (SelectedEntities.ContainsKey("PORTFOLIO"))
{
SelectedEntities.Remove("PORTFOLIO");
}
SelectedEntities.Add("PORTFOLIO", portfolioSelectionData.PortfolioId);
if (SelectedEntities != null && SelectedEntities.ContainsKey("PORTFOLIO") && periodSelectionData != null && IsActive)
{
dbInteractivity.RetrieveBenchmarkChartReturnData(SelectedEntities, RetrieveBenchmarkChartDataCallBackMethod);
dbInteractivity.RetrieveBenchmarkGridReturnData(SelectedEntities, RetrieveBenchmarkGridDataCallBackMethod);
BusyIndicatorStatus = true;
}
}
else
{
Logging.LogMethodParameterNull(logger, methodNamespace, 1);
}
}
catch (Exception ex)
{
MessageBox.Show("Message: " + ex.Message + "\nStackTrace: " + Logging.StackTraceToString(ex), "Exception", MessageBoxButton.OK);
Logging.LogException(logger, ex);
}
}
public bool AttackUnitsAtPosition(Point entityGameFieldPosition)
{
IDamageableUnit damageableUnit = null;
foreach (var key in UnitsByPlayer)
{
if (key.Key != Players.Global && key.Key != Players.Player)
{
damageableUnit = GetDamageableUnitAtPosition(entityGameFieldPosition, key.Key);
}
}
if (damageableUnit == null)
{
return(false);
}
var isTarget = false;
foreach (var entity in SelectedEntities.OfType <IAttackingUnit>())
{
entity.SetTarget(damageableUnit, true);
isTarget = true;
}
return(isTarget);
}
private void PasteRows([NotNull, ItemNotNull] IList <IList <string> > table)
{
var selectedEntities = SelectedEntities.ToList();
if (selectedEntities.Count != 1)
{
return;
}
var entity = selectedEntities[0];
if (!ResourceManager.CanEdit(entity, null))
{
return;
}
try
{
if (table.HasValidTableHeaderRow())
{
entity.ImportTable(table);
}
else
{
throw new ImportException(Resources.PasteSelectionSizeMismatch);
}
}
catch (ImportException ex)
{
throw new ImportException(Resources.PasteFailed + " " + ex.Message);
}
}
private void onMouseUp(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
this.selection.Region = Rectangle.Empty;
this.selectedRegion = this.selection.Region;
foreach (MapEntity entity in EntitiesToSelect)
{
if (!SelectedEntities.Contains <MapEntity>(entity))
{
if (!ShiftDown)
{
SelectedEntities.Add(entity);
}
}
if (ShiftDown)
{
SelectedEntities.Remove(entity);
}
}
EntitiesToSelect.Clear();
}
}
/// <summary>
/// Constructor that initialises the Class
/// </summary>
/// <param name="param"></param>
public ViewModelMultiLineBenchmark(DashboardGadgetParam param)
{
if (param != null)
{
dbInteractivity = param.DBInteractivity;
logger = param.LoggerFacade;
eventAggregator = param.EventAggregator;
selectedPortfolio = param.DashboardGadgetPayload.PortfolioSelectionData;
periodSelectionData = param.DashboardGadgetPayload.PeriodSelectionData;
filterSelectionData = param.DashboardGadgetPayload.FilterSelectionData;
if (eventAggregator != null)
{
SubscribeEvents(eventAggregator);
}
if ((selectedPortfolio != null) && (periodSelectionData != null))
{
Dictionary <string, string> objSelectedEntity = new Dictionary <string, string>();
if (selectedPortfolio.PortfolioId != null)
{
objSelectedEntity.Add("PORTFOLIO", selectedPortfolio.PortfolioId);
}
if (filterSelectionData != null && filterSelectionData.FilterValues != null)
{
if (SelectedEntities.ContainsKey("COUNTRY"))
{
SelectedEntities.Remove("COUNTRY");
}
if (SelectedEntities.ContainsKey("SECTOR"))
{
SelectedEntities.Remove("SECTOR");
}
if (filterSelectionData.Filtertype == "Country")
{
if (filterSelectionData.FilterValues != null)
{
SelectedEntities.Add("COUNTRY", filterSelectionData.FilterValues);
}
}
else if (filterSelectionData.Filtertype == "Sector")
{
if (filterSelectionData.FilterValues != null)
{
SelectedEntities.Add("SECTOR", filterSelectionData.FilterValues);
}
}
}
if (objSelectedEntity != null || objSelectedEntity.Count != 0 && IsActive)
{
dbInteractivity.RetrieveBenchmarkChartReturnData(objSelectedEntity, RetrieveBenchmarkChartDataCallBackMethod);
BusyIndicatorStatus = true;
}
}
}
}
protected override void SelectEntity()
{
base.SelectEntity();
if (multiSelect)
{
SelectedEntities.ForEach(x => ((HizmetL)x).BaslamaTarihi = txtHizmetBaslamaTarihi.DateTime.Date);
}
}
public virtual void EditDetailEntity()
{
if (SelectedEntities.Any())
{
var detailKey = DetailsRepository.GetPrimaryKey(SelectedEntities.First());
DocumentManagerService.ShowExistingEntityDocument <TDetailEntity, TDetailPrimaryKey>(this, detailKey);
}
}
public void SetSelectedItems(IList addedItems, IList removedItems)
{
if (_suppressNotifySelectedItems)
{
return;
}
SelectedEntities.Update(addedItems, removedItems);
_operationScopeContext.SelectItemsAsync <TEntity>(SelectedEntities);
}
public void SelectEntity(Point entityGameFieldPosition, Players playerId)
{
SelectedEntities.Clear();
var unit = GetIntersectingUnits(entityGameFieldPosition, playerId).LastOrDefault();
if (unit != null)
{
SelectedEntities.Add(unit);
}
}
/// <summary>
/// Handle Security change Event
/// </summary>
/// <param name="filterSelectionData">Details of Selected Security</param>
public void HandleFilterReferenceSet(FilterSelectionData filterSelectionData)
{
string methodNamespace = String.Format("{0}.{1}", GetType().FullName, System.Reflection.MethodInfo.GetCurrentMethod().Name);
Logging.LogBeginMethod(logger, methodNamespace);
try
{
//ArgumentNullException
if (filterSelectionData != null)
{
this.filterSelectionData = filterSelectionData;
if (SelectedEntities.ContainsKey("COUNTRY"))
{
SelectedEntities.Remove("COUNTRY");
}
if (SelectedEntities.ContainsKey("SECTOR"))
{
SelectedEntities.Remove("SECTOR");
}
if (filterSelectionData.Filtertype == "Country")
{
if (filterSelectionData.FilterValues != null)
{
SelectedEntities.Add("COUNTRY", filterSelectionData.FilterValues);
}
}
else if (filterSelectionData.Filtertype == "Sector")
{
if (filterSelectionData.FilterValues != null)
{
SelectedEntities.Add("SECTOR", filterSelectionData.FilterValues);
}
}
if (SelectedEntities != null && SelectedEntities.ContainsKey("PORTFOLIO") && IsActive)
{
dbInteractivity.RetrieveBenchmarkChartReturnData(SelectedEntities, RetrieveBenchmarkChartDataCallBackMethod);
dbInteractivity.RetrieveBenchmarkGridReturnData(SelectedEntities, RetrieveBenchmarkGridDataCallBackMethod);
BusyIndicatorStatus = true;
}
}
else
{
Logging.LogMethodParameterNull(logger, methodNamespace, 1);
}
}
catch (Exception ex)
{
MessageBox.Show("Message: " + ex.Message + "\nStackTrace: " + Logging.StackTraceToString(ex), "Exception", MessageBoxButton.OK);
Logging.LogException(logger, ex);
}
}
public void SelectEntities(Trapeze select, Players playerId, UnitTypes type = UnitTypes.Wall)
{
SelectedEntities.Clear();
foreach (var unit in UnitsByPlayer[playerId])
{
if (select.Contains(unit.Position) && (unit.UnitType == type || type == UnitTypes.Wall))
{
SelectedEntities.Add(unit);
}
}
}
public override void PerformOperation()
{
if (Order == null)
{
throw new InvalidOperationException("Order is not defined to add documents.");
}
foreach (var document in SelectedEntities.Where(document => !Order.Documents.Contains(document)))
{
Order.Documents.Add(document);
}
}
void Update()
{
if (Input.GetButtonUp("Scoreboard"))
{
uiManager.ClosePlayerList();
}
if (!uiManager.IsUIReceivingInput)
{
//meta-game input
if (Input.GetButtonDown("Scoreboard"))
{
uiManager.OpenPlayerList();
}
else if (clientGameManager.IsAcceptingGameInput)
{
SelectedEntities.RemoveAll(x => x == null);
//cancel should override all other inputs
if (Input.GetButtonDown("Cancel"))
{
DoCancel();
}
else
{
if (!EventSystem.current.IsPointerOverGameObject()) //if not over UI element
{
if (currentTargetingObject != null)
{
HandleMouseTargetingInput();
}
else
{
HandleMouseInput();
}
}
HandleMiscInputs();
if (SelectedEntities.Count > 0)
{
HandleSelectionBasedInputs();
}
}
if (SelectedEntities.Count == 0 || !SelectedEntities[0].Equals(LastFocusedEntity))
{
LastFocusedEntity = null;
rtsCamera.ClearFollowTarget();
}
}
}
}
private void SelectEntity(Entity entity)
{
SelectedEntities.Add(entity);
SelectionMarker selectionMarker = entity.GetComponentInChildren <SelectionMarker>(true);
if (selectionMarker != null)
{
selectionMarker.ToggleRendering(true);
}
entity.Select();
}
public virtual void RemoveDetailEntities()
{
if (!SelectedEntities.Any())
{
return;
}
foreach (var selectedEntity in SelectedEntities)
{
DetailEntities.Remove(selectedEntity);
}
SaveChangesAndNotify(SelectedEntities);
SelectedEntities.Clear();
}
public ResourceViewModel(ResourceManager resourceManager, IConfiguration configuration, ISourceFilesProvider sourceFilesProvider, CodeReferenceTracker codeReferenceTracker, ITracer tracer, PerformanceTracer performanceTracer)
{
ResourceManager = resourceManager;
_configuration = configuration;
_sourceFilesProvider = sourceFilesProvider;
_codeReferenceTracker = codeReferenceTracker;
_tracer = tracer;
_performanceTracer = performanceTracer;
ResourceTableEntries = SelectedEntities.ObservableSelectMany(entity => entity.Entries);
ResourceTableEntries.CollectionChanged += (_, __) => ResourceTableEntries_CollectionChanged();
resourceManager.LanguageChanged += ResourceManager_LanguageChanged;
}
private void onMouseDown(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
if (!Keyboard.GetState().IsKeyDown(Keys.LeftControl) && !Keyboard.GetState().IsKeyDown(Keys.LeftShift))
{
SelectedEntities.Clear();
}
int xt = (int)((e.X - EditorEngine.Instance.xCam) / EditorEngine.Instance.World.Camera.Scale);
int yt = (int)((e.Y - EditorEngine.Instance.yCam) / EditorEngine.Instance.World.Camera.Scale);
selection.Start(new Vector2(xt, yt));
}
}
public virtual void RemoveDetailEntities()
{
if (!SelectedEntities.Any())
{
return;
}
var entities = SelectedEntities.ToList();
foreach (var e in entities)
{
SelectedEntities.Remove(e);
DetailEntities.Remove(e);
}
SaveChangesAndNotify(entities);
this.RaiseCanExecuteChanged(x => x.RemoveDetailEntities());
}
//--------------------------------------------------------------------------------------------------
void Selection_SelectionChanged(SelectionManager selectionManager)
{
var toRemove = SelectedEntities.Except(selectionManager.SelectedEntities).ToArray();
foreach (var entity in toRemove)
{
SelectedEntities.Remove(entity);
}
var toAdd = selectionManager.SelectedEntities.Except(SelectedEntities);
foreach (var entity in toAdd)
{
SelectedEntities.Add(entity);
}
}
private void EntityChanged(object sender, PropertyChangedEventArgs e)
{
IVisualElement entity = (IVisualElement)sender;
if (e.PropertyName == "IsSelected")
{
if (entity.IsSelected && !SelectedEntities.Contains(entity))
{
SelectedEntities.Add(entity);
}
else if (!entity.IsSelected && SelectedEntities.Contains(entity))
{
SelectedEntities.Remove(entity);
}
}
}
private void DeselectEntity(Entity entity, bool removeFromSelection)
{
SelectionMarker selectionMarker = entity.GetComponentInChildren <SelectionMarker>();
if (selectionMarker != null)
{
selectionMarker.ToggleRendering(false);
}
if (removeFromSelection)
{
SelectedEntities.Remove(entity);
}
entity.Deselect();
}
public void SetSelectedItem(TEntity entity)
{
foreach (var item in SelectedEntities.ToList().Where(item => !Equals(item, entity)))
{
SelectedEntities.Remove(item);
}
if (!SelectedEntities.Contains(entity))
{
SelectedEntities.Add(entity);
}
_operationScopeContext.SelectItemsAsync <TEntity>(SelectedEntities);
if (_editEntityOperationMediator != null)
{
_editEntityOperationMediator.PerformOperation();
}
}
public override void RemoveDetailEntities()
{
if (!SelectedEntities.Any())
{
return;
}
var entityKey = Repository.GetPrimaryKey(Entity);
foreach (var selectedEntity in SelectedEntities)
{
var detailKey = DetailsRepository.GetPrimaryKey(selectedEntity);
var junction = JunctionRepository.First(GetJunctionPredicate(entityKey, detailKey));
JunctionRepository.Remove(junction);
}
SaveChangesAndNotify(SelectedEntities);
SelectedEntities.Clear();
}
public void SelectEntry([NotNull] ResourceTableEntry entry)
{
if (!ResourceManager.TableEntries.Contains(entry))
{
return;
}
var entity = entry.Container;
if (!SelectedEntities.Contains(entity))
{
SelectedEntities.Add(entity);
}
SelectedTableEntries.Clear();
SelectedTableEntries.Add(entry);
}
private void SelectedEntities_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
// handle items where selection was removed
foreach (IVisualElement element in MapEntities)
{
if (!SelectedEntities.Contains(element))
{
element.IsSelected = false;
}
}
// set selection position
_selectionLocation = new Point(0, 0);
foreach (IVisualElement element in SelectedEntities)
{
_selectionLocation.X += element.X;
_selectionLocation.Y += element.Y;
}
_selectionLocation.X /= SelectedEntities.Count;
_selectionLocation.Y /= SelectedEntities.Count;
OnPropertyChanged("EntitiesSelected");
OnPropertyChanged("SelectionLocation");
// set correct gizmo orientation
if (_selectedEntities.Count == 1 && !GizmoIsRotating)
{
GizmoOrientation = _selectedEntities[0].Orientation;
}
else if (!GizmoIsRotating)
{
GizmoOrientation = 0;
}
// update rotation capabilities
AllowRotation = true;
foreach (IVisualElement entity in SelectedEntities)
{
if (entity is VisualCornerManipulator)
{
AllowRotation = false;
}
}
}
public void SelectEntry([NotNull] ResourceTableEntry entry)
{
if (!ResourceManager.TableEntries.Contains(entry))
{
return;
}
var entity = entry.Container;
ClearFiltersRequest?.Invoke(this, EventArgs.Empty);
if (!SelectedEntities.Contains(entity))
{
SelectedEntities.Add(entity);
}
SelectedTableEntries.Clear();
SelectedTableEntries.Add(entry);
}
private void DeselectAll(bool alsoStopSelecting = true)
{
foreach (Entity entity in SelectedEntities)
{
if (entity != null)
{
DeselectEntity(entity, false);
}
}
SelectedEntities.Clear();
if (alsoStopSelecting)
{
isSelecting = false;
}
SetTargeting(null, 0);
uiManager.UpdateSelectedEntities(SelectedEntities);
}
/// <summary>
/// Event handler to handle Period change Event
/// </summary>
/// <param name="periodSelectionData">Selected Period</param>
public void HandlePeriodReferenceSet(string periodSelectionData)
{
string methodNamespace = String.Format("{0}.{1}", GetType().FullName, System.Reflection.MethodInfo.GetCurrentMethod().Name);
Logging.LogBeginMethod(logger, methodNamespace);
try
{
//ArgumentNullException
if (periodSelectionData != null)
{
this.periodSelectionData = periodSelectionData;
if (MultiLineBenchmarkUIChartData.Count != 0)
{
BusyIndicatorStatus = true;
MultiLineBenchmarkUIChartData = CalculateDataAccordingToPeriod(MultiLineBenchmarkUIChartData, periodSelectionData);
BusyIndicatorStatus = false;
}
else
{
if (SelectedEntities != null && SelectedEntities.ContainsKey("PORTFOLIO") && periodSelectionData != null && IsActive)
{
dbInteractivity.RetrieveBenchmarkChartReturnData(SelectedEntities, RetrieveBenchmarkChartDataCallBackMethod);
dbInteractivity.RetrieveBenchmarkGridReturnData(SelectedEntities, RetrieveBenchmarkGridDataCallBackMethod);
BusyIndicatorStatus = true;
}
}
}
else
{
Logging.LogMethodParameterNull(logger, methodNamespace, 1);
}
}
catch (Exception ex)
{
MessageBox.Show("Message: " + ex.Message + "\nStackTrace: " + Logging.StackTraceToString(ex), "Exception", MessageBoxButton.OK);
Logging.LogException(logger, ex);
BusyIndicatorStatus = false;
}
}
protected List <RealEstateViewModel <T> > GetCollectionForExport(ExportMode mode)
{
var collection = new List <RealEstateViewModel <T> >();
switch (mode)
{
case ExportMode.Selected:
collection = SelectedEntities.ToList();
break;
case ExportMode.All:
collection = _RealEstateService.GetAll().Select(CreateNewViewModel).ToList();
break;
case ExportMode.Filtered:
collection = Entities.ToList();
break;
}
return(collection);
}
