public override void DisposeScreen()
{
if (AnimatedThreadWorker.IsBusy)
{
AnimatedThreadWorker.CancelAsync();
}
AnimatedThreadWorker.Dispose();
_purchaseArray.Clear();
_purchaseArray = null;
if (_toolStripMenuItemMoveTo != null)
{
_toolStripMenuItemMoveTo.Dispose();
}
if (_toolStripSeparator1 != null)
{
_toolStripSeparator1.Dispose();
}
if (_directivesViewer != null)
{
_directivesViewer.Dispose();
}
Dispose(true);
}
public AircraftsCore(ILoader loader, INewKeeper newKeeper, INewLoader newLoader)
{
_loader = loader;
_newKeeper = newKeeper;
_newLoader = newLoader;
_aircrafts = new AircraftCollection();
}
/// <summary>
/// Заполняет listview элементами
/// </summary>
/// <param name="itemsArray">Массив элементов</param>
public virtual void SetItemsArray(ICommonCollection itemsArray)
{
if (itemsArray == null)
{
throw new ArgumentNullException("itemsArray", "itemsArray can't be null");
}
//очищение предварительной коллекции элементов
ListViewItemList.Clear();
//очищение элементов ListViewa
itemsListView.Items.Clear();
//очищение коллекции выбранных элементов
_selectedItemsList.Clear();
try
{
AddItems(itemsArray);
SetItemsColor();
SetTotalText();
}
catch (Exception ex)
{
Program.Provider.Logger.Log("Error while building data", ex);
return;
}
}
public override void DisposeScreen()
{
if (AnimatedThreadWorker.IsBusy)
{
AnimatedThreadWorker.CancelAsync();
}
AnimatedThreadWorker.Dispose();
if (InitialDirectiveArray != null)
{
InitialDirectiveArray.Clear();
}
InitialDirectiveArray = null;
if (ResultDirectiveArray != null)
{
ResultDirectiveArray.Clear();
}
ResultDirectiveArray = null;
if (DirectivesViewer != null)
{
DirectivesViewer.Dispose();
}
Dispose(true);
}
/// <summary>
/// Добавляет элементы в начало ListView
/// </summary>
/// <param name="itemsArray"></param>
public virtual void InsertItems(ICommonCollection itemsArray)
{
if (itemsArray.Count == 0)
{
return;
}
List <ListViewItem> listViewItems = itemsArray.Cast <BaseEntityObject>().Select(GetItemforInserting).ToList();
for (int i = listViewItems.Count - 1; i >= 0; i--)
{
ListViewItemList.Add(listViewItems[i]);
}
if (SortMultiplier == 1)
{
SortMultiplier = -1;
}
else
{
SortMultiplier = 1;
}
SortItems(OldColumnIndex);
SetItemsColor(listViewItems);
SetTotalText();
}
public override void DisposeScreen()
{
if (AnimatedThreadWorker.IsBusy)
{
AnimatedThreadWorker.CancelAsync();
}
AnimatedThreadWorker.Dispose();
_initialArray.Clear();
_initialArray = null;
if (_toolStripMenuItemCreateQuatation != null)
{
_toolStripMenuItemCreateQuatation.Dispose();
}
if (_toolStripMenuItemEdit != null)
{
_toolStripMenuItemEdit.Dispose();
}
if (_toolStripMenuItemClose != null)
{
_toolStripMenuItemClose.Dispose();
}
if (_toolStripSeparator1 != null)
{
_toolStripSeparator1.Dispose();
}
if (_directivesViewer != null)
{
_directivesViewer.Dispose();
}
Dispose(true);
}
private void AddComponentAndDirectiveToBindedItemsCollections(Component component, ComponentDirective componentDirective,
ICommonCollection <BaseEntityObject> itemsToInsert,
ICommonCollection <BaseEntityObject> allbindedItems,
Dictionary <Component, List <ComponentDirective> > newBindedItems)
{
itemsToInsert.Add(componentDirective);
// Добавление задачи по компоненту из коллекции содержащих все связаные задачи
allbindedItems.Add(componentDirective);
//если в коллекции содержащей все связные задачи нет родительского компонента от задачи по компоненту
//требуется добавить компонент в коллекцию содержащую все связные задачи
if (allbindedItems.OfType <Component>().All(i => i.ItemId != component.ItemId))
{
itemsToInsert.Add(component);
allbindedItems.Add(component);
}
if (newBindedItems.ContainsKey(component))
{
newBindedItems[component].Add(componentDirective);
}
else
{
newBindedItems.Add(component, new List <ComponentDirective> {
componentDirective
});
}
}
/// <summary>
/// Производит выгруску ресурсов страницы
/// </summary>
public override void DisposeScreen()
{
if (AnimatedThreadWorker.IsBusy)
{
AnimatedThreadWorker.CancelAsync();
}
AnimatedThreadWorker.Dispose();
if (_initialDirectiveArray != null)
{
_initialDirectiveArray.Clear();
}
_initialDirectiveArray = null;
if (_resultDirectiveArray != null)
{
_resultDirectiveArray.Clear();
}
_resultDirectiveArray = null;
_openPubQuotations.Clear();
_openPubQuotations = null;
if (_toolStripMenuItemOpen != null)
{
_toolStripMenuItemOpen.Dispose();
}
if (_directivesViewer != null)
{
_directivesViewer.Dispose();
}
Dispose(true);
}
///<summary>
///</summary>
public MouthlyUtilizationListView(Aircraft parentAircraft, ICommonCollection <ATLB> atlbCollection)
: this()
{
SortMultiplier = 0;
OldColumnIndex = 1;
_parentAircraft = parentAircraft;
_atbs = atlbCollection;
}
public override void SetItemsArray(ICommonCollection itemsArray)
{
if (_selectedItemsList == null)
{
_selectedItemsList = new CommonCollection <BaseEntityObject>();
}
base.SetItemsArray(itemsArray);
}
///<summary>
///</summary>
public OilListView(Aircraft parentAircraft, ICommonCollection <ATLB> atlbCollection, OilGraphicModel graph)
: this()
{
SortDirection = SortDirection.Desc;
OldColumnIndex = 1;
_parentAircraft = parentAircraft;
_atbs = atlbCollection;
_graph = graph;
}
public override void DisposeScreen()
{
if (AnimatedThreadWorker.IsBusy)
{
AnimatedThreadWorker.CancelAsync();
}
AnimatedThreadWorker.DoWork -= AnimatedThreadWorkerDoWork;
AnimatedThreadWorker.RunWorkerCompleted -= AnimatedThreadWorkerRunWorkerCompleted;
AnimatedThreadWorker.Dispose();
_initialDirectiveArray.Clear();
_resultDirectiveArray.Clear();
_openPubWorkPackages.Clear();
_initialDirectiveArray = null;
_resultDirectiveArray = null;
_openPubWorkPackages = null;
if (_currentForecast != null)
{
_currentForecast.Dispose();
_currentForecast = null;
}
if (_currentForecast != null)
{
_currentForecast.Clear();
}
_currentForecast = null;
if (_toolStripMenuItemOpen != null)
{
_toolStripMenuItemOpen.Dispose();
}
if (_toolStripMenuItemHighlight != null)
{
foreach (var ttmi in _toolStripMenuItemHighlight.Items)
{
ttmi.Click -= HighlightItemClick;
}
_toolStripMenuItemHighlight.Items.Clear();
_toolStripMenuItemHighlight.Dispose();
}
if (_toolStripSeparator1 != null)
{
_toolStripSeparator1.Dispose();
}
if (_directivesViewer != null)
{
_directivesViewer.Dispose();
}
Dispose(true);
}
///<summary>
///</summary>
///<param name="initialCollection"></param>
///<param name="resultCollection"></param>
private void FilterZeroItems(IEnumerable <IMtopCalc> initialCollection,
ICommonCollection <IMtopCalc> resultCollection)
{
if (_filterZero == null || _filterZero.All(i => i.Values.Length == 0))
{
resultCollection.Clear();
resultCollection.AddRange(initialCollection);
return;
}
resultCollection.Clear();
foreach (var pd in initialCollection)
{
if (_filterZero.FilterTypeAnd)
{
bool acceptable = true;
foreach (ICommonFilter filter in _filterZero)
{
acceptable = filter.Acceptable((BaseEntityObject)pd);
if (!acceptable)
{
break;
}
}
if (acceptable)
{
resultCollection.Add(pd);
}
}
else
{
bool acceptable = true;
foreach (ICommonFilter filter in _filterZero)
{
if (filter.Values == null || filter.Values.Length == 0)
{
continue;
}
acceptable = filter.Acceptable((BaseEntityObject)pd);
if (acceptable)
{
break;
}
}
if (acceptable)
{
resultCollection.Add(pd);
}
}
}
}
public override void DisposeScreen()
{
if (AnimatedThreadWorker.IsBusy)
{
AnimatedThreadWorker.CancelAsync();
}
AnimatedThreadWorker.Dispose();
if (InitialDirectiveArray != null)
{
InitialDirectiveArray.Clear();
}
InitialDirectiveArray = null;
if (ResultDirectiveArray != null)
{
ResultDirectiveArray.Clear();
}
ResultDirectiveArray = null;
if (_currentForecast != null)
{
_currentForecast.Dispose();
}
_currentForecast = null;
if (_openPubWorkPackages != null)
{
_openPubWorkPackages.Clear();
}
_openPubWorkPackages = null;
_openPubQuotations.Clear();
_openPubQuotations = null;
if (_toolStripMenuItemsWorkPackages != null)
{
foreach (var item in _toolStripMenuItemsWorkPackages.Items)
{
item.Click -= AddToWorkPackageItemClick;
}
_toolStripMenuItemsWorkPackages.Items.Clear();
_toolStripMenuItemsWorkPackages.Dispose();
}
if (DirectivesViewer != null)
{
DirectivesViewer.Dispose();
}
Dispose(true);
}
///<summary>
///</summary>
///<param name="initialCollection"></param>
///<param name="resultCollection"></param>
private void FilterItems(IEnumerable <AccessoryRequired> initialCollection, ICommonCollection <AccessoryRequired> resultCollection)
{
if (_filter == null || _filter.All(i => i.Values.Length == 0))
{
resultCollection.Clear();
resultCollection.AddRange(initialCollection);
return;
}
resultCollection.Clear();
foreach (AccessoryRequired pd in initialCollection)
{
//if (pd.Parent != null && pd.Parent is MaintenanceCheck && ((MaintenanceCheck)pd.Parent).Name == "C02")
//{
// pd.ToString();
//}
if (_filter.FilterTypeAnd)
{
bool acceptable = true;
foreach (ICommonFilter filter in _filter)
{
acceptable = filter.Acceptable(pd); if (!acceptable)
{
break;
}
}
if (acceptable)
{
resultCollection.Add(pd);
}
}
else
{
bool acceptable = true;
foreach (ICommonFilter filter in _filter)
{
if (filter.Values == null || filter.Values.Length == 0)
{
continue;
}
acceptable = filter.Acceptable(pd); if (acceptable)
{
break;
}
}
if (acceptable)
{
resultCollection.Add(pd);
}
}
}
}
/// <summary>
/// Добавляет массив агрегатов в коллекцию
/// </summary>
/// <param name="objects"></param>
public void AddRange(ICommonCollection objects)
{
foreach (T o in objects)
{
o.PropertyChanged += OnItemPropertyChanged;
Items.Add(o);
}
Items.Sort();
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add,
objects.OfType <IBaseEntityObject>().ToList()));
}
///<summary>
///</summary>
///<param name="initialCollection"></param>
///<param name="resultCollection"></param>
private void FilterItems(IEnumerable <Discrepancy> initialCollection, ICommonCollection <Discrepancy> resultCollection)
{
if (_filter == null || _filter.All(i => i.Values.Length == 0))
{
resultCollection.Clear();
resultCollection.AddRange(initialCollection);
return;
}
resultCollection.Clear();
foreach (Discrepancy pd in initialCollection)
{
//if (pd.MaintenanceCheck != null && pd.MaintenanceCheck.Name == "2C")
//{
// pd.MaintenanceCheck.ToString();
//}
if (_filter.FilterTypeAnd)
{
bool acceptable = true;
foreach (ICommonFilter filter in _filter)
{
acceptable = filter.Acceptable(pd); if (!acceptable)
{
break;
}
}
if (acceptable)
{
resultCollection.Add(pd);
}
}
else
{
bool acceptable = true;
foreach (ICommonFilter filter in _filter)
{
if (filter.Values == null || filter.Values.Length == 0)
{
continue;
}
acceptable = filter.Acceptable(pd); if (acceptable)
{
break;
}
}
if (acceptable)
{
resultCollection.Add(pd);
}
}
}
}
public override void DisposeScreen()
{
if (AnimatedThreadWorker.IsBusy)
{
AnimatedThreadWorker.CancelAsync();
}
AnimatedThreadWorker.DoWork -= AnimatedThreadWorkerDoWork;
AnimatedThreadWorker.RunWorkerCompleted -= AnimatedThreadWorkerRunWorkerCompleted;
AnimatedThreadWorker.Dispose();
_resultDirectiveArray.Clear();
_resultDirectiveArray = null;
_initialDirectiveArray.Clear();
_initialDirectiveArray = null;
if (_toolStripMenuItemShowADFile != null)
{
_toolStripMenuItemShowADFile.Dispose();
}
if (_toolStripMenuItemShowSBFile != null)
{
_toolStripMenuItemShowSBFile.Dispose();
}
if (_toolStripMenuItemShowEOFile != null)
{
_toolStripMenuItemShowEOFile.Dispose();
}
if (_toolStripMenuItemOpen != null)
{
_toolStripMenuItemOpen.Dispose();
}
if (_toolStripSeparator1 != null)
{
_toolStripSeparator1.Dispose();
}
if (_toolStripSeparator2 != null)
{
_toolStripSeparator2.Dispose();
}
if (_toolStripSeparator4 != null)
{
_toolStripSeparator4.Dispose();
}
if (_directivesViewer != null)
{
_directivesViewer.Dispose();
}
Dispose(true);
}
///<summary>
///</summary>
///<param name="initialCollection"></param>
///<param name="resultCollection"></param>
private void FilterItems(IEnumerable <ILogistic> initialCollection, ICommonCollection <ILogistic> resultCollection)
{
if (_filter == null || _filter.All(i => i.Values.Length == 0))
{
resultCollection.Clear();
resultCollection.AddRange(initialCollection);
return;
}
resultCollection.Clear();
foreach (var pd in initialCollection)
{
if (_filter.FilterTypeAnd)
{
var acceptable = true;
foreach (var filter in _filter)
{
acceptable = filter.Acceptable(pd as BaseEntityObject);
}
if (!acceptable)
{
break;
}
if (acceptable)
{
resultCollection.Add(pd);
}
}
else
{
var acceptable = true;
foreach (var filter in _filter)
{
if (filter.Values == null || filter.Values.Length == 0)
{
continue;
}
acceptable = filter.Acceptable(pd as BaseEntityObject); if (acceptable)
{
break;
}
}
if (acceptable)
{
resultCollection.Add(pd);
}
}
}
}
///<summary>
///</summary>
///<param name="initialCollection"></param>
///<param name="resultCollection"></param>
private void FilterItems(IEnumerable <MailRecords> initialCollection, ICommonCollection <MailRecords> resultCollection)
{
if (_filter == null || _filter.All(i => i.Values.Length == 0))
{
resultCollection.Clear();
resultCollection.AddRange(initialCollection);
return;
}
resultCollection.Clear();
foreach (var pd in initialCollection)
{
if (_filter.FilterTypeAnd)
{
bool acceptable = true;
foreach (ICommonFilter filter in _filter)
{
acceptable = filter.Acceptable(pd); if (!acceptable)
{
break;
}
}
if (acceptable)
{
resultCollection.Add(pd);
}
}
else
{
bool acceptable = true;
foreach (ICommonFilter filter in _filter)
{
if (filter.Values == null || filter.Values.Length == 0)
{
continue;
}
acceptable = filter.Acceptable(pd); if (acceptable)
{
break;
}
}
if (acceptable)
{
resultCollection.Add(pd);
}
}
}
}
/// <summary>
/// Создает форму для фильтрации элементов переданного типа
/// </summary>
public CommonFilterForm(CommonFilterCollection filterCollection, ICommonCollection items = null)
: this()
{
if (filterCollection == null)
{
throw new ArgumentNullException("filterCollection", "can not be null");
}
_filters = filterCollection;
_items = items;
_animatedThreadWorker.DoWork += AnimatedThreadWorkerDoLoad;
_animatedThreadWorker.RunWorkerCompleted += BackgroundWorkerRunWorkerLoadCompleted;
_animatedThreadWorker.RunWorkerAsync();
}
/// <summary>
/// Создает форму для редактирования переданного объекта
/// </summary>
public CommonDeletingForm(Type type, ICommonCollection editingObjects) : this()
{
if (editingObjects == null)
{
throw new ArgumentNullException("editingObjects", "can not be null");
}
_deletingObjects = editingObjects;
_type = type;
SetHeaders();
_animatedThreadWorker.DoWork += AnimatedThreadWorkerDoLoad;
_animatedThreadWorker.RunWorkerCompleted += BackgroundWorkerRunWorkerLoadCompleted;
_animatedThreadWorker.RunWorkerAsync();
}
/// <summary>
/// Сортирует чеки по интервалу выполнения в зависимости от свойства Schedule,
/// группирует по MaintenanceCheckType (A, B, C, D, etc),
/// и проставляет связи между группами по приоритету MaintenanceCheckType
/// </summary>
public static IEnumerable <MaintenanceCheckGroupByType> GroupingCheckByType(this ICommonCollection <MaintenanceCheck> checks, int?minStep, bool schedule)
{
if (minStep == null)
{
return(null);
}
var groupChecks = new List <MaintenanceCheckGroupByType>();
Func <MaintenanceCheck, int?> predicate;
if (schedule)
{
predicate = check => check.Interval.Hours;
}
else
{
predicate = check => check.Interval.Days;
}
var v = checks.Where(c => c.Schedule == schedule)
.OrderBy(predicate)
.ThenBy(c => c.CheckType.Priority)
.GroupBy(c => c.CheckType.FullName);
foreach (var grouping in v)
{
var groupCheck = new MaintenanceCheckGroupByType(schedule);
foreach (MaintenanceCheck check in grouping)
{
groupCheck.Checks.Add(check);
}
groupCheck.Sort();
var last = groupChecks.LastOrDefault();
if (last != null)
{
last.ParentGroup = groupCheck;
last.CheckCycle = groupCheck.MinInterval();
}
groupCheck.ParentGroup = null;
groupCheck.CheckCycle = groupCheck.MaxInterval();
groupChecks.Add(groupCheck);
}
return(groupChecks.ToArray());
}
/// <summary>
/// Возвращает последнюю выполненную группу чеков, чеки которой имеют заданные парамерты
/// </summary>
/// <param name="checks"></param>
/// <param name="schedule">Чеки плановые или по программе хранения</param>
/// <param name="aircraftId">Родительское ВС чеков</param>
/// <param name="grouping">Чеки групповые или нет</param>
/// <param name="resource">По какому из ресурсов (часы, циклы или календарь) группируются чеки</param>
/// <param name="checkType">Тип чека (A B C D)</param>
/// <returns></returns>
public static MaintenanceCheckComplianceGroup GetLastComplianceCheckGroup(this ICommonCollection <MaintenanceCheck> checks,
bool schedule, int aircraftId,
bool grouping = true,
LifelengthSubResource resource = LifelengthSubResource.Hours,
MaintenanceCheckType checkType = null)
{
int last = 0;
var aircraftScheduleChecks = checks.Where(c => c.Schedule == schedule &&
c.ParentAircraftId == aircraftId &&
c.Grouping == grouping &&
c.Resource == resource).ToList();
if (checkType != null)
{
aircraftScheduleChecks = aircraftScheduleChecks.Where(c => c.CheckType == checkType).ToList();
}
foreach (MaintenanceCheck checkItem in aircraftScheduleChecks)
{
if (checkItem.LastPerformance != null && last < checkItem.LastPerformance.NumGroup)
{
last = checkItem.LastPerformance.NumGroup;
}
}
if (last <= 0)
{
return(null);
}
var lastComplianceGroup = new MaintenanceCheckComplianceGroup(schedule);
foreach (MaintenanceCheck checkItem in aircraftScheduleChecks)
{
if (checkItem.LastPerformance != null && last == checkItem.LastPerformance.NumGroup)
{
lastComplianceGroup.Checks.Add(checkItem);
}
}
if (lastComplianceGroup.GetMaxIntervalCheck() == null)
{
return(null);
}
lastComplianceGroup.Sort();
return(lastComplianceGroup);
}
public static void SetFileByFileLinkType(this ICommonCollection <ItemFileLink> files, int typeId, AttachedFile file, FileLinkType fileLinkType)
{
var link = files.FirstOrDefault(i => i.LinkType == (short)fileLinkType);
if (link != null)
{
link.File = file;
}
else if (file != null)
{
files.Add(new ItemFileLink
{
ParentTypeId = typeId,
LinkType = (short)fileLinkType,
File = file
});
}
}
public override void DisposeScreen()
{
if (AnimatedThreadWorker.IsBusy)
{
AnimatedThreadWorker.CancelAsync();
}
AnimatedThreadWorker.Dispose();
_initialArray.Clear();
_initialArray = null;
if (_directivesViewer != null)
{
_directivesViewer.Dispose();
}
Dispose(true);
}
/// <summary>
/// Данные у директивы обновляются по введенным данным
/// </summary>
/// <param name="_currentDirective"></param>
public void ApplyChanges(FlightNumber _currentDirective)
{
_currentDirective.Distance = (int)numericUpDownDistance.Value;
_currentDirective.DistanceMeasure = (Measure)comboBoxMeasure.SelectedItem;
_currentDirective.MinLevel = (CruiseLevel)dictComboBoxMinLevel.SelectedItem;
_currentDirective.MaxPassengerAmount = (int)numericUpDownPassengers.Value;
_currentDirective.MaxFuelAmount = (double)numericUpDownFuel.Value;
_currentDirective.MinFuelAmount = (double)numericUpDownFuelRemainAfter.Value;
_currentDirective.MaxPayload = (double)numericUpDownPayload.Value;
_currentDirective.MaxCargoWeight = (double)numericUpDownCargo.Value;
_currentDirective.MaxTakeOffWeight = (double)numericUpDownTakeOffWeight.Value;
_currentDirective.MaxLandWeight = (double)numericUpDownMaxLandWeight.Value;
dataGridViewCrew.ApplyChanges();
//очистка текущей коллекции элементов
_currentDirective.FlightNumberCrewRecords.Clear();
//Получение всех элементов списка
ICommonCollection icc = dataGridViewCrew.GetItemsArray();
//добавление в редактируемый объект
_currentDirective.FlightNumberCrewRecords.AddRange(icc);
//очистка коллекции элементов списка для предотвращения утечки памяти
icc.Clear();
dataGridViewAirports.ApplyChanges();
//очистка текущей коллекции элементов
_currentDirective.AlternateAirports.Clear();
//Получение всех элементов списка
icc = dataGridViewAirports.GetItemsArray();
//добавление в редактируемый объект
_currentDirective.AlternateAirports.AddRange(icc);
//очистка коллекции элементов списка для предотвращения утечки памяти
icc.Clear();
dataGridViewAircraftModels.ApplyChanges();
//очистка текущей коллекции элементов
_currentDirective.AircraftModels.Clear();
//Получение всех элементов списка
icc = dataGridViewAircraftModels.GetItemsArray();
//добавление в редактируемый объект
_currentDirective.AircraftModels.AddRange(icc);
//очистка коллекции элементов списка для предотвращения утечки памяти
icc.Clear();
}
public override void DisposeScreen()
{
if (AnimatedThreadWorker.IsBusy)
{
AnimatedThreadWorker.CancelAsync();
}
AnimatedThreadWorker.Dispose();
_resultDirectiveArray.Clear();
_preResultDirectiveArray.Clear();
_openPubWorkPackages.Clear();
_openPubQuotations.Clear();
//_deferredCategories.Clear();
_resultDirectiveArray = null;
_preResultDirectiveArray = null;
_openPubWorkPackages = null;
_openPubQuotations = null;
//_deferredCategories = null;
if (_currentForecast != null)
{
_currentForecast.Dispose();
_currentForecast = null;
}
if (_initialFilter != null)
{
_initialFilter.Filters.Clear();
_initialFilter = null;
}
if (_currentForecast != null)
{
_currentForecast.Clear();
}
_currentForecast = null;
if (_directivesViewer != null)
{
_directivesViewer.Dispose();
}
Dispose(true);
}
public override void DisposeScreen()
{
if (AnimatedThreadWorker.IsBusy)
{
AnimatedThreadWorker.CancelAsync();
}
AnimatedThreadWorker.Dispose();
_resultDirectiveArray.Clear();
_preResultDirectiveArray.Clear();
_openPubWorkPackages.Clear();
_openPubQuotations.Clear();
//_deferredCategories.Clear();
_resultDirectiveArray = null;
_preResultDirectiveArray = null;
_openPubWorkPackages = null;
_openPubQuotations = null;
//_deferredCategories = null;
if (_initialFilter != null)
{
_initialFilter.Filters.Clear();
_initialFilter = null;
}
if (_toolStripMenuItemOpen != null)
{
_toolStripMenuItemOpen.Dispose();
}
if (_toolStripSeparator1 != null)
{
_toolStripSeparator1.Dispose();
}
if (_directivesViewer != null)
{
_directivesViewer.Dispose();
}
Dispose(true);
}
/// <summary>
/// Добавляет элементы <see cref="_viewedType"/> в ListView
/// </summary>
/// <param name="itemsArray"></param>
protected virtual void AddItems(ICommonCollection itemsArray)
{
if (itemsArray.Count != 0)
{
foreach (BaseEntityObject o in itemsArray)
{
AddItem(o);
}
itemsListView.Items.AddRange(ListViewItemList.ToArray());
ShowGroups = true;
if (SortMultiplier == 1)
{
SortMultiplier = -1;
}
else
{
SortMultiplier = 1;
}
SortItems(OldColumnIndex);
}
}
