/// <summary>
/// Builds collectionSource DetailDescriptions.ItemProperties and collection of detail columns.
/// </summary>
/// <param name="collectionSource"></param>
/// <param name="xceedControl"></param>
/// <param name="detail"></param>
public void BuildDetailStructure(DataGridCollectionViewSource collectionSource, DataGridControl xceedGrid,
DetailConfiguration detail)
{
Debug.Assert(null != collectionSource.DetailDescriptions);
Debug.Assert(1 == collectionSource.DetailDescriptions.Count);
_BuildCollectionSource(collectionSource.DetailDescriptions[0].ItemProperties);
_BuildColumnsCollection(detail.Columns);
// Add stops as detail of route.
xceedGrid.DetailConfigurations.Clear();
xceedGrid.DetailConfigurations.Add(detail);
// NOTE: Set this property so that columns with custom order properties from default
// settings were not added to grid automatically.
xceedGrid.DetailConfigurations[0].AutoCreateColumns = false;
// Collapse all detail and reexpand it.
List<DataGridContext> dataGridContexts = new List<DataGridContext>(xceedGrid.GetChildContexts());
foreach (DataGridContext dataGridContext in dataGridContexts)
{
dataGridContext.ParentDataGridContext.CollapseDetails(dataGridContext.ParentItem);
dataGridContext.ParentDataGridContext.ExpandDetails(dataGridContext.ParentItem);
}
}
/// <summary>
/// Constructor.
/// </summary>
public CandidateSelectControl()
{
InitializeComponent();
this.Resources = Application.Current.Resources;
// Init datagrid control.
_collectionSource = (DataGridCollectionViewSource)LayoutRoot.FindResource("candidatesCollection");
_addressCandidates = new List<AddressCandidate>();
DataGridControl.SelectionChanged += new DataGridSelectionChangedEventHandler(_DataGridControlSelectionChanged);
}
private static void OnDataGridCollectionViewSourceDependencyPropertyChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
{
DataGridCollectionViewSource source = o as DataGridCollectionViewSource;
if (source == null)
{
return;
}
source.AdviseForwardedPropertyChanged();
}
/// <summary>
/// Builds collection of item properties.
/// </summary>
/// <param name="parametersCount">Parameters count.</param>
/// <param name="itemPorpertiesCollection">Item properties collection.</param>
/// <param name="collectionSource">Collection source.</param>
private void _BuildCollectionSource(int parametersCount,
ArrayList itemPorpertiesCollection,
DataGridCollectionViewSource collectionSource)
{
Debug.Assert(null != itemPorpertiesCollection);
Debug.Assert(null != collectionSource);
collectionSource.ItemProperties.Clear();
foreach (DataGridItemProperty property in itemPorpertiesCollection)
{
if (!property.Name.Equals(DYNAMIC_FIELDS_ALIAS))
collectionSource.ItemProperties.Add(property);
else
{
for (int index = 0; index < parametersCount; ++index)
{
string valuePath =
property.ValuePath + string.Format(DYNAMIC_VALUE_NAME_FORMAT, index);
string valueName =
_GetDynamicFieldName(index);
var newProperty =
new DataGridItemProperty(valueName, valuePath, typeof(string));
collectionSource.ItemProperties.Add(newProperty);
}
}
}
}
/// <summary>
/// Method inits all xceed data grid controls (sets collection source and columns structure foreach of them).
/// </summary>
private void _InitGridControl()
{
_isNewItemCreated = false;
// init grid structure
if (_collectionSource == null)
_collectionSource = (DataGridCollectionViewSource)LayoutRoot.FindResource(ROUTES_COLLECTION_SOURCE_NAME);
// Set collection source to null to refresh items collection.
_collectionSource.Source = null;
GridStructureInitializer initializer = new GridStructureInitializer(GridSettingsProvider.RoutesGridStructure);
initializer.BuildGridStructure(_collectionSource, RoutesGrid);
// init detail structure
DetailConfiguration orders = (DetailConfiguration)LayoutRoot.FindResource(ROUTES_DETAIL_CONFIGURATION_NAME);
GridStructureInitializer detailInitializer = new GridStructureInitializer(GridSettingsProvider.StopsGridStructure);
detailInitializer.BuildDetailStructure(_collectionSource, RoutesGrid, orders);
// load grid layout
GridLayoutLoader layoutLoader = new GridLayoutLoader(GridSettingsProvider.RoutesSettingsRepositoryName, _collectionSource.ItemProperties,
_collectionSource.DetailDescriptions[0].ItemProperties);
layoutLoader.LoadLayout(RoutesGrid);
}
/// <summary>
/// Init grid structure for Grid.
/// </summary>
/// <param name="gridStructure">Structure of the grid.</param>
/// <param name="gridSettingsRepositoryName">Repository with grid settings.</param>
/// <param name="grid">Grid.</param>
/// <param name="collectionSource">Grid's collection source.</param>
private void _InitGridStructure(string gridStructure, string gridSettingsRepositoryName,
DataGridControlEx grid, DataGridCollectionViewSource collectionSource)
{
// Initializing gridstructure and gridlayout.
GridStructureInitializer structureInitializer = new GridStructureInitializer
(gridStructure);
structureInitializer.BuildGridStructure(collectionSource, grid);
GridLayoutLoader layoutLoader = new GridLayoutLoader(gridSettingsRepositoryName,
collectionSource.ItemProperties);
layoutLoader.LoadLayout(grid);
}
/// <summary>
/// Builds collectionSource ItemPorperties collection and collection of xceedGrid columns.
/// </summary>
/// <param name="collectionSource"></param>
/// <param name="xceedControl"></param>
public void BuildGridStructure(DataGridCollectionViewSource collectionSource, DataGridControl xceedGrid)
{
_BuildCollectionSource(collectionSource.ItemProperties);
_BuildColumnsCollection(xceedGrid.Columns);
_InitPrintConfiguration(xceedGrid);
}
/// <summary>
/// Loads grid layout.
/// </summary>
private void _InitDataGridLayout()
{
if (_collectionSource == null)
_collectionSource = (DataGridCollectionViewSource)LayoutRoot.FindResource(COLLECTION_SOURCE_KEY);
GridStructureInitializer structureInitializer = new GridStructureInitializer(GridSettingsProvider.ZonesGridStructure);
structureInitializer.BuildGridStructure(_collectionSource, XceedGrid);
// Load grid layout.
GridLayoutLoader layoutLoader = new GridLayoutLoader(GridSettingsProvider.ZonesSettingsRepositoryName, _collectionSource.ItemProperties);
layoutLoader.LoadLayout(XceedGrid);
_isDataGridLayoutLoaded = true;
}
public DataGridCollectionViewDataProvider( DataGridCollectionViewSource parentSource )
: base( parentSource )
{
}
/// <summary>
/// Prepare data grid control to work.
/// </summary>
private void _InitDataGridControl()
{
_collectionSource = (DataGridCollectionViewSource)LayoutRoot.FindResource(COLLECTION_SOURCE_KEY);
// Initialize grid structure.
GridStructureInitializer structureInitializer = new GridStructureInitializer(GridSettingsProvider.FleetGeocodableGridStructure);
structureInitializer.BuildGridStructure(_collectionSource, DataGridControl);
// Find index for first non-Name field to determine it as Address Field.
int columnIndex = 0;
for (int i = 0; i < DataGridControl.Columns.Count; i++)
{
if (DataGridControl.Columns[i].FieldName != NAME_COLUMN)
{
columnIndex = i;
break; // Work done: first non-Name field found.
}
}
// Set special content template to show "Add location" string.
ColumnBase addressColumn = DataGridControl.Columns[columnIndex];
addressColumn.CellContentTemplate = (DataTemplate)App.Current.FindResource(ADDRESSLINE_CONTENT_TEMPLATE_NAME);
CommonHelpers.HidePostalCode2Column(DataGridControl);
// Load grid layout.
GridLayoutLoader layoutLoader = new GridLayoutLoader(GridSettingsProvider.FleetLocationsSettingsRepositoryName,
_collectionSource.ItemProperties);
layoutLoader.LoadLayout(DataGridControl);
}
/// <summary>
/// Inits grid structure.
/// </summary>
/// <param name="source">Grid view source.</param>
/// <param name="xceedGrid">Grid object.</param>
/// <param name="sourceXAML">Source greed XAML-file.</param>
/// <param name="cellEditorName">CheckBox cell editor resource name (can be null).</param>
private void _InitGridStructure(DataGridCollectionViewSource source,
DataGridControl xceedGrid,
string sourceXAML,
string cellEditorName)
{
Debug.Assert(null != source);
Debug.Assert(null != xceedGrid);
Debug.Assert(!string.IsNullOrEmpty(sourceXAML));
var structureInitializer = new GridStructureInitializer(sourceXAML);
structureInitializer.BuildGridStructure(source, xceedGrid);
if (!string.IsNullOrEmpty(cellEditorName))
_InitCheckBox(xceedGrid.Columns, cellEditorName);
}
/// <summary>
/// Inits page state.
/// </summary>
private void _Init()
{
Debug.Assert(!_isInited);
_viewSourceRoutes = mainGrid.FindResource(ROUTES_TABLE_CONFIGURATION_NAME)
as DataGridCollectionViewSource;
_InitGridStructure(_viewSourceRoutes, xceedGridRoutes,
GridSettingsProvider.ReportRoutesGridStructure,
CELL_EDITOR_RESOURCE_NAME);
_viewSourceTemplates = mainGrid.FindResource(TEMPLATES_TABLE_CONFIGURATION_NAME)
as DataGridCollectionViewSource;
_InitGridStructure(_viewSourceTemplates, xceedGridTemplates,
GridSettingsProvider.ReportTemplatesGridStructure,
CELL_EDITOR_RESOURCE_NAME_EX);
// init template detail structure
var subReport =
mainGrid.FindResource(REPORT_TEMPLATE_DETAIL_CONFIGURATION_NAME) as DetailConfiguration;
var detailInitializer =
new GridStructureInitializer(GridSettingsProvider.ReportTemplatesGridStructure);
detailInitializer.BuildDetailStructure(_viewSourceTemplates, xceedGridTemplates,
subReport);
_InitCheckBox(subReport.Columns, CELL_EDITOR_RESOURCE_NAME_EX);
// subscribe on value change event of ItemSource property
var dpd = DependencyPropertyDescriptor.FromProperty(DataGridControl.ItemsSourceProperty,
typeof(DataGridControl));
dpd.AddValueChanged(xceedGridTemplates, _xceedGridTemplates_OnItemSourceChanged);
_viewSourceReports = mainGrid.FindResource(REPORTS_TABLE_CONFIGURATION_NAME)
as DataGridCollectionViewSource;
_InitGridStructure(_viewSourceReports, xceedGridReports,
GridSettingsProvider.ReportReportsGridStructure, null);
_viewSourceReports.Source = new List<ReportDataWrapper>();
xceedGridReports.OnItemSourceChanged +=
new EventHandler(_xceedGridReports_OnItemSourceChanged);
_isInited = true;
}
/// <summary>
/// Method inits collection.
/// </summary>
private void _InitCollection()
{
try
{
_collectionSource =
(DataGridCollectionViewSource)LayoutRoot.FindResource(COLLECTION_SOURCE_KEY);
IList<Barrier> sortedBarriersCollection = _GetSortedCollection();
_collectionSource.Source = sortedBarriersCollection;
((INotifyCollectionChanged)XceedGrid.Items).CollectionChanged +=
new NotifyCollectionChangedEventHandler(_BarriersPageCollectionChanged);
_isDataGridCollectionInited = true;
}
catch (Exception ex)
{
Logger.Info(ex);
}
}
/// <summary>
/// Loads grid layout.
/// </summary>
private void _InitDataGridLayout()
{
if (_collectionSource == null)
{
_collectionSource =
(DataGridCollectionViewSource)LayoutRoot.FindResource(COLLECTION_SOURCE_KEY);
}
var structureInitializer =
new GridStructureInitializer(GridSettingsProvider.BarriersGridStructure);
structureInitializer.BuildGridStructure(_collectionSource, XceedGrid);
// load grid layout
var layoutLoader =
new GridLayoutLoader(GridSettingsProvider.BarriersSettingsRepositoryName,
_collectionSource.ItemProperties);
layoutLoader.LoadLayout(XceedGrid);
// Find geometry field and...
foreach (Column column in XceedGrid.Columns)
{
if (column.FieldName == GEOMETRY_FIELD_NAME)
{
// ...set field width to default one,
// to let users know about this fields is exists.
ColumnBase geometryColumn =
XceedGrid.Columns[GEOMETRY_FIELD_NAME];
if (geometryColumn.Width == 0)
geometryColumn.Width = DEFAULT_COLUMN_WIDTH;
break; // Work done.
}
}
_isLayoutLoaded = true;
}
/// <summary>
/// Inits grid structure.
/// </summary>
/// <param name="source">Data view source.</param>
/// <param name="gridName">Grid name.</param>
private void _InitGridStructure(DataGridCollectionViewSource source, string gridName)
{
Debug.Assert(null != source);
Debug.Assert(!string.IsNullOrEmpty(gridName));
var structureInitializer =
new GridStructureInitializer(GridSettingsProvider.ExportFieldsGridStructure);
var xceedGrid = (DataGridControl)ctrlFields.FindName(gridName);
structureInitializer.BuildGridStructure(source, xceedGrid);
ColumnBase columnCkecked = xceedGrid.Columns["IsChecked"];
columnCkecked.CellEditor = (CellEditor)layoutRoot.FindResource("CheckBoxCellEditor");
columnCkecked.Width = 25;
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
public ExportPage()
{
InitializeComponent();
_isValidationEnabled = true;
_viewSourceRoute =
(DataGridCollectionViewSource)ctrlFields.FindResource("fieldTableRoute");
_viewSourceStop =
(DataGridCollectionViewSource)ctrlFields.FindResource("fieldTableStop");
// hide GUI elements
var lbName = (Label)ctrlGeneral.FindName("labelName");
var tbName = (TextBox)ctrlGeneral.FindName("editName");
var lbDescription = (Label)ctrlGeneral.FindName("labelDescription");
var tbDescription = (TextBox)ctrlGeneral.FindName("editDescription");
lbName.Visibility =
tbDescription.Visibility =
lbDescription.Visibility =
tbName.Visibility = Visibility.Collapsed;
IsRequired = true;
IsAllowed = true;
// attach to events
App.Current.ApplicationInitialized += new EventHandler(_App_ApplicationInitialized);
App.Current.ProjectClosing += new EventHandler(_ProjectClosing);
this.Loaded += new RoutedEventHandler(_Page_Loaded);
this.Unloaded += new RoutedEventHandler(_Page_Unloaded);
App.Current.MainWindow.Closed += new EventHandler(_MainWindow_Closed);
}
/// <summary>
/// Init grid for the currently selected breaks type.
/// </summary>
private void _InitProperGrid()
{
// Init grid, corresponding to currently selected breaks type.
if (App.Current.Project.BreaksSettings.BreaksType == BreakType.TimeWindow)
{
// Get repository with grid setting.
_gridSettingsRepository = Properties.Settings.Default.TimeWindowBreaksGridSettings;
// If there is no - create it.
if (_gridSettingsRepository == null)
{
Properties.Settings.Default.TimeWindowBreaksGridSettings = new SettingsRepository();
_gridSettingsRepository = Properties.Settings.Default.TimeWindowBreaksGridSettings;
}
// Get grid's collection source.
_currentCollectionSource =
(DataGridCollectionViewSource)LayoutRoot.FindResource(TIMEWINDOW_COLLECTION_SOURCE_KEY);
// Make this grid visible and hide all other grids.
_InitGridVisibility(TimeWindowGrid);
_currentGrid = TimeWindowGrid;
}
else if (App.Current.Project.BreaksSettings.BreaksType == BreakType.DriveTime)
{
// Get repository with grid setting.
_gridSettingsRepository = Properties.Settings.Default.DriveTimeBreaksGridSettings;
// If there is no - create it.
if (_gridSettingsRepository == null)
{
Properties.Settings.Default.DriveTimeBreaksGridSettings = new SettingsRepository();
_gridSettingsRepository = Properties.Settings.Default.DriveTimeBreaksGridSettings;
}
// Get grid's collection source.
_currentCollectionSource =
(DataGridCollectionViewSource)LayoutRoot.FindResource(DRIVETIME_COLLECTION_SOURCE_KEY);
// Make this grid visible and hide all other grids.
_InitGridVisibility(DriveTimeGrid);
_currentGrid = DriveTimeGrid;
}
else if (App.Current.Project.BreaksSettings.BreaksType == BreakType.WorkTime)
{
// Get repository with grid setting.
_gridSettingsRepository = Properties.Settings.Default.WorkTimeBreaksGridSettings;
// If there is no - create it.
if (_gridSettingsRepository == null)
{
Properties.Settings.Default.WorkTimeBreaksGridSettings = new SettingsRepository();
_gridSettingsRepository = Properties.Settings.Default.WorkTimeBreaksGridSettings;
}
// Get grid's collection source.
_currentCollectionSource =
(DataGridCollectionViewSource)LayoutRoot.FindResource(WORKTIME_COLLECTION_SOURCE_KEY);
// Make this grid visible and hide all other grids.
_InitGridVisibility(WorkTimeGrid);
_currentGrid = WorkTimeGrid;
}
else
// This breaks type isn't supported.
Debug.Assert(false);
// Subscribe to event.
_currentGrid.SelectionChanged += new DataGridSelectionChangedEventHandler
(_XceedGridSelectionChanged);
}
/// <summary>
/// Loads grid structure (ItemPorperties and Columns) from xaml.
/// </summary>
/// <param name="key">Resource key.</param>
/// <param name="parametersCount">Parameters count.</param>
/// <param name="collectionSource">Collection source.</param>
/// <param name="xceedGrid">Xceed grid control.</param>
private void _CreateStructureFromXAML(string key,
int parametersCount,
DataGridCollectionViewSource collectionSource,
DataGridControl xceedGrid)
{
Debug.Assert(!string.IsNullOrEmpty(key));
Debug.Assert(null != collectionSource);
Debug.Assert(null != xceedGrid);
try
{
// load structure from XAML
ArrayList itemPorpertiesCollection = null;
ArrayList columns = null;
using (Stream stream = this.GetType().Assembly.GetManifestResourceStream(key))
{
string template = new StreamReader(stream).ReadToEnd();
using (StringReader stringReader = new StringReader(template))
{
using (XmlTextReader xmlReader = new XmlTextReader(stringReader))
{
var resource = XamlReader.Load(xmlReader) as ResourceDictionary;
itemPorpertiesCollection =
resource[ITEM_PROPERTIES_RESOURCE_NAME] as ArrayList;
columns = resource[COLUMNS_RESOURCE_NAME] as ArrayList;
}
}
}
_BuildCollectionSource(parametersCount, itemPorpertiesCollection, collectionSource);
_BuildColumnsCollection(parametersCount, columns, xceedGrid.Columns);
}
catch (Exception ex)
{
Logger.Info(ex.Message);
}
}
/// <summary>
/// Inits grid source.
/// </summary>
/// <param name="maxParametersCount">Maximum number of attribute parameters.</param>
/// <param name="collectionSource">Data grid collection source.</param>
private void _InitGridSource(int maxParametersCount,
DataGridCollectionViewSource collectionSource)
{
IVrpSolver solver = App.Current.Solver;
SolverSettings solverSettings = solver.SolverSettings;
NetworkDescription networkDescription = solver.NetworkDescription;
ICollection<Restriction> restrictions = solverSettings.Restrictions;
var restrictionWrappers = new List<RestrictionDataWrapper>();
var networkAttributes = networkDescription.NetworkAttributes;
foreach (NetworkAttribute attribute in networkAttributes)
{
if (attribute.UsageType == NetworkAttributeUsageType.Restriction)
{
Restriction restriction = _FindRestriction(attribute.Name, restrictions);
if (restriction.IsEditable)
{
Debug.Assert(null != attribute.Parameters);
// Create collection of all non "restriction usage" attribute parameters.
IList<NetworkAttributeParameter> attrParams;
if (attribute.RestrictionUsageParameter != null)
attrParams = attribute.Parameters.Where(
param => param.Name != attribute.RestrictionUsageParameter.Name).ToList();
else
attrParams = attribute.Parameters.ToList();
var parameters = new Parameters(maxParametersCount);
for (int index = 0; index < maxParametersCount; ++index)
{
string value = null;
if (index < attrParams.Count())
{
NetworkAttributeParameter param = attrParams.ElementAt(index);
value = _GetParameterValue(attribute.Name, param.Name, solverSettings);
parameters[index] = new Parameter(param.Name, value);
}
else
parameters[index] = new Parameter();
}
// Create wrapper for restriction.
var wrapper = new RestrictionDataWrapper(restriction.IsEnabled,
restriction.NetworkAttributeName,
restriction.Description, parameters);
// If attribute has restriction usage parameter - add this parameter
// to wrapper.
if (attribute.RestrictionUsageParameter != null)
{
var restrictionUsageParameterValue = _GetParameterValue(attribute.Name,
attribute.RestrictionUsageParameter.Name, solverSettings);
var restrictionParameter = new Parameter(attribute.RestrictionUsageParameter.Name,
restrictionUsageParameterValue);
wrapper.RestrictionUsageParameter = restrictionParameter;
}
restrictionWrappers.Add(wrapper);
}
}
}
collectionSource.Source = restrictionWrappers;
}
/// <summary>
/// Inits grid structure.
/// </summary>
private void SendRoutesGrid_Initialized(object sender, EventArgs e)
{
// NOTE: init data grid structure one time when grid initialized
_sourceCollection = (DataGridCollectionViewSource)LayoutRoot.FindResource("SendRoutesTable");
// build collection source
var itemPropertiesCollection = LayoutRoot.FindResource("itemProperties") as ArrayList;
foreach (DataGridItemProperty property in itemPropertiesCollection)
_sourceCollection.ItemProperties.Add(property);
// build column collection
var columns = LayoutRoot.FindResource("columns") as ArrayList;
foreach (Column column in columns)
SendRoutesGrid.Columns.Add(column);
ColumnBase columnCkecked = SendRoutesGrid.Columns["IsChecked"];
columnCkecked.CellEditor = (CellEditor)LayoutRoot.FindResource("CheckBoxCellEditor");
}
/// <summary>
/// Inits page GUI elements.
/// </summary>
protected void _InitPageContent()
{
App.Current.MainWindow.StatusBar.SetStatus(this, null);
if (!_isLoaded)
{
_viewSourceReports = (DataGridCollectionViewSource)mainGrid.FindResource("reportsTable");
GridStructureInitializer structureInitializer = new GridStructureInitializer(GRID_STRUCTURE_REPORT_PREFERENCES);
structureInitializer.BuildGridStructure(_viewSourceReports, xceedGridReports);
ColumnBase columnName = xceedGridReports.Columns["Name"];
columnName.ReadOnly = false;
columnName.CellValidationRules.Add(new ReportTemplateValidationRule());
xceedGridReports.OnItemSourceChanged += new EventHandler(_OnItemSourceChanged);
_InitReportTable();
_isLoaded = true;
}
}
/// <summary>
/// Method inits collection of projects.
/// </summary>
private void _InitProjectsCollection()
{
_collectionSource = (DataGridCollectionViewSource)LayoutRoot.FindResource("projectSource");
GridStructureInitializer structureInitializer = new GridStructureInitializer(GridSettingsProvider.ProjectsGridStructure);
structureInitializer.BuildGridStructure(_collectionSource, XceedGrid);
XceedGrid.Columns[IS_CURRENT_COLUMN_CAPTION].CellEditor = (CellEditor)LayoutRoot.FindResource("ProjectsRadioButtonEditor");
XceedGrid.Columns[IS_CURRENT_COLUMN_CAPTION].CellContentTemplate = (DataTemplate)LayoutRoot.FindResource("RadioButtonTemplate");
XceedGrid.Columns[IS_CURRENT_COLUMN_CAPTION].CellEditorDisplayConditions = CellEditorDisplayConditions.Always;
XceedGrid.Columns[NAME_COLUMN_CAPTION].CellValidationRules.Add(new ProjectNameValidationRule());
_BuildProjectsWrapperCollection();
_UpdateProjectsCheckboxes();
_collectionSource.Source = _projectsDataCollection;
_isInited = true;
}
/// <summary>
/// Method inits collection.
/// </summary>
private void _InitDataGridCollection()
{
try
{
_collectionSource = (DataGridCollectionViewSource)LayoutRoot.FindResource(COLLECTION_SOURCE_KEY);
_collectionSource.Source = _GetSortedCollection();
((INotifyCollectionChanged)XceedGrid.Items).CollectionChanged += new NotifyCollectionChangedEventHandler(ZonesPage_CollectionChanged);
_isDataGridCollectionInited = true;
XceedGrid.SelectedItems.Clear();
}
catch (Exception ex)
{
Logger.Info(ex);
}
}
/// <summary>
/// Method inits all xceed data grid controls (sets collection source and columns structure foreach of them).
/// </summary>
private void _InitGridControl()
{
_isNewItemCreated = false;
_collectionSource = (DataGridCollectionViewSource)LayoutRoot.FindResource(ORDERS_COLLECTION_SOURCE_NAME);
GridStructureInitializer initializer = new GridStructureInitializer(GridSettingsProvider.OrdersGridStructure);
initializer.BuildGridStructure(_collectionSource, OrdersGrid);
// load grid layout
GridLayoutLoader layoutLoader = new GridLayoutLoader(GridSettingsProvider.OrdersSettingsRepositoryName, _collectionSource.ItemProperties);
layoutLoader.LoadLayout(OrdersGrid);
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Method inits context of XceedGrid.
/// </summary>
private void _InitGUI()
{
if (!_isInited)
{
_collectionSource = (DataGridCollectionViewSource)layoutRoot.FindResource("messageTable");
GridStructureInitializer structureInitializer = new GridStructureInitializer(GridSettingsProvider.MessageWindowGridStructure);
structureInitializer.BuildGridStructure(_collectionSource, xceedGrid);
xceedGrid.DetailConfigurations.Clear();
xceedGrid.DetailConfigurations.Add((DetailConfiguration)layoutRoot.FindResource("messageDetailConfiguration"));
// collaps all detail and reexpand it.
List<DataGridContext> dataGridContexts = new List<DataGridContext>(xceedGrid.GetChildContexts());
foreach (DataGridContext dataGridContext in dataGridContexts)
{
dataGridContext.ParentDataGridContext.CollapseDetails(dataGridContext.ParentItem);
dataGridContext.ParentDataGridContext.ExpandDetails(dataGridContext.ParentItem);
}
_collectionSource.Source = _data;
_isInited = true;
}
}
internal override DataGridCollectionViewBase EnsureDataGridCollectionViewBaseCore()
{
DataGridCollectionViewSource parentSource = this.ParentSource as DataGridCollectionViewSource;
object source = parentSource.OriginalSource;
Type itemType = parentSource.ItemType;
DataSourceProvider dataSourceProvider = source as DataSourceProvider;
if (dataSourceProvider != m_dataSourceProvider)
{
if (m_dataSourceProvider != null)
{
DataChangedEventManager.RemoveListener(m_dataSourceProvider, this);
}
m_dataSourceProvider = dataSourceProvider;
if (m_dataSourceProvider != null)
{
DataChangedEventManager.AddListener(m_dataSourceProvider, this);
m_dataSourceProvider.InitialLoad();
}
}
if (dataSourceProvider != null)
{
source = dataSourceProvider.Data;
}
IListSource listSource = source as IListSource;
if (listSource != null)
{
source = listSource.GetList();
}
if (source == null)
{
return(null);
}
IEnumerable enumerableSource = source as IEnumerable;
Debug.Assert(enumerableSource != null);
DataGridCollectionViewBase currentView = this.CurrentView;
if ((currentView != null) &&
(currentView.SourceCollection == enumerableSource) &&
(currentView.DesiredItemType == itemType))
{
// No changes.
return(currentView);
}
return(new DataGridCollectionView(
enumerableSource,
itemType,
parentSource.AutoCreateItemProperties,
parentSource.AutoCreateDetailDescriptions,
parentSource.AutoCreateForeignKeyDescriptions));
}
public DataGridCollectionViewDataProvider(DataGridCollectionViewSource parentSource)
: base(parentSource)
{
}
/// <summary>
/// React on page loaded.
/// </summary>
/// <param name="sender">Ignored.</param>
/// <param name="e">Ignored.</param>
private void _FleetSetupWizardUngeocodedOrdersPageLoaded(object sender, RoutedEventArgs e)
{
// Init page if not inited yet.
if (!_inited)
{
_isParentFleetWizard = DataKeeper != null;
// Set row height.
ContentGrid.RowDefinitions[DATA_GRID_ROW_DEFINITION_INDEX].Height =
new System.Windows.GridLength(DEFAULT_ROW_HEIGHT * ROW_COUNT + DataGridControl.Margin.Top
+ DataGridControl.Margin.Bottom + ROW_COUNT);
// Create subpages.
string typeName = (string)App.Current.FindResource(ORDER_RESOURCE_NAME);
typeName = typeName.ToLower();
_matchFoundSubPage = new MatchFoundSubPage(typeName);
_candidatesNotFoundSubPage = new CandidatesNotFoundSubPage(typeName);
_candidatesFoundSubPage = new CandidatesFoundSubPage(typeName);
_SetSubPage(null);
// Init orders collection.
_collectionSource = (DataGridCollectionViewSource)LayoutRoot.FindResource(COLLECTION_SOURCE_KEY);
_CreateOrdersLayer();
// Create and init geocodable page.
_geocodablePage = new GeocodablePage(typeof(Order), mapCtrl, candidateSelect,
controlsGrid, DataGridControl, splitter, _ordersLayer);
_geocodablePage.MatchFound += new EventHandler(_MatchFound);
_geocodablePage.CandidatesFound += new EventHandler(_CandidatesFound);
_geocodablePage.CandidatesNotFound += new EventHandler(_CandidatesNotFound);
// Datakeeper is not null in fleetwizard.
_geocodablePage.ParentIsFleetWisard = _isParentFleetWizard;
mapCtrl.AddTool(new EditingTool(), null);
_collectionSource = (DataGridCollectionViewSource)LayoutRoot.FindResource(COLLECTION_SOURCE_KEY);
GridStructureInitializer structureInitializer = new GridStructureInitializer(GridSettingsProvider.FleetGeocodableGridStructure);
structureInitializer.BuildGridStructure(_collectionSource, DataGridControl);
CommonHelpers.HidePostalCode2Column(DataGridControl);
// Load grid layout.
GridLayoutLoader layoutLoader = new GridLayoutLoader(GridSettingsProvider.FleetLocationsSettingsRepositoryName,
_collectionSource.ItemProperties);
layoutLoader.LoadLayout(DataGridControl);
if (!_isParentFleetWizard)
_RemoveRedundantElements();
_inited = true;
}
// Get orders collection from datakeeper if it is not null. Otherwise - from current project.
if (_isParentFleetWizard)
{
// Fill ungeocoded orders list.
_FillUngeocodedOrders(DataKeeper.AddedOrders);
}
else
{
// Do nothing. Ungeocoded order already set by constructor.
}
_collectionSource.Source = _ungeocodedOrders;
_ordersLayer.Collection = _ungeocodedOrders;
_selectionBinding.UnregisterAllCollections();
_selectionBinding.RegisterCollection(DataGridControl);
_selectionBinding.RegisterCollection(mapCtrl.SelectedItems);
ButtonFinish.IsEnabled = _IsFinishButtonEnabled(_ungeocodedOrders);
}
