/// <summary>
/// Converts the given object to the reference type.
/// </summary>
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
if (value is string)
{
string text = ((string)value).Trim();
if (!string.Equals(text, s_none) && context != null)
{
// Try the reference service first.
IReferenceService refSvc = (IReferenceService)context.GetService(typeof(IReferenceService));
if (refSvc != null)
{
object obj = refSvc.GetReference(text);
if (obj != null)
{
return(obj);
}
}
// Now try IContainer
IContainer cont = context.Container;
if (cont != null)
{
object obj = cont.Components[text];
if (obj != null)
{
return(obj);
}
}
}
return(null);
}
return(base.ConvertFrom(context, culture, value));
}
/// <summary>Gets a collection of standard values for the reference data type.</summary>
/// <returns>A <see cref="T:System.ComponentModel.TypeConverter.StandardValuesCollection" /> that holds a standard set of valid values, or null if the data type does not support a standard set of values.</returns>
/// <param name="context">An <see cref="T:System.ComponentModel.ITypeDescriptorContext" /> that provides a format context. </param>
public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
{
ArrayList arrayList = new ArrayList();
if (context != null)
{
IReferenceService referenceService = context.GetService(typeof(IReferenceService)) as IReferenceService;
if (referenceService != null)
{
object[] references = referenceService.GetReferences(reference_type);
foreach (object value in references)
{
if (IsValueAllowed(context, value))
{
arrayList.Add(value);
}
}
}
else if (context.Container != null && context.Container.Components != null)
{
foreach (object component in context.Container.Components)
{
if (component != null && IsValueAllowed(context, component) && reference_type.IsInstanceOfType(component))
{
arrayList.Add(component);
}
}
}
arrayList.Add(null);
}
return(new StandardValuesCollection(arrayList));
}
/// <summary>Converts the given value object to the reference type using the specified context and arguments.</summary>
/// <returns>The converted object.</returns>
/// <param name="context">An <see cref="T:System.ComponentModel.ITypeDescriptorContext" /> that provides a format context. </param>
/// <param name="culture">A <see cref="T:System.Globalization.CultureInfo" /> that specifies the culture used to represent the font. </param>
/// <param name="value">The <see cref="T:System.Object" /> to convert. </param>
/// <param name="destinationType">The type to convert the object to. </param>
/// <exception cref="T:System.ArgumentNullException">
/// <paramref name="destinationType" /> is null. </exception>
/// <exception cref="T:System.NotSupportedException">The conversion cannot be performed. </exception>
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (destinationType != typeof(string))
{
return(base.ConvertTo(context, culture, value, destinationType));
}
if (value == null)
{
return("(none)");
}
string text = string.Empty;
if (context != null)
{
IReferenceService referenceService = context.GetService(typeof(IReferenceService)) as IReferenceService;
if (referenceService != null)
{
text = referenceService.GetName(value);
}
if ((text == null || text.Length == 0) && value is IComponent)
{
IComponent component = (IComponent)value;
if (component.Site != null && component.Site.Name != null)
{
text = component.Site.Name;
}
}
}
return(text);
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
string stringValue = value as string;
if (stringValue != null)
{
try
{
Debug.Assert(_actionList != null && _actionList.Actions != null);
if (string.IsNullOrEmpty(stringValue))
{
return(_actionList.Actions.Null);
}
IReferenceService rs = (IReferenceService)context.GetService(typeof(IReferenceService));
Debug.Assert(rs != null);
if (rs == null)
{
return(_actionList.Actions.Null);
}
return(rs.GetReference(stringValue));
}
catch
{
throw new ArgumentException("Can not convert '" + stringValue + "' to type Object");
}
}
return(base.ConvertFrom(context, culture, value));
}
public AssociateController(
IMembershipService membershipService,
IMembershipService associateMembershipService,
IAssociateService associateService,
IDocumentService documentService,
IReferenceService referenceService,
IEmployeeService employeeService,
IProspectService prospectService,
IPrincipal user,
IClientProjectSharedService clientProjectSharedService,
IIndividualService individualService,
IRoleService roleService,
Admin.Services.IEmailService emailService)
: base(membershipService, associateService, user)
{
this.associateService = associateService;
this.documentService = documentService;
this.referenceService = referenceService;
this.employeeService = employeeService;
this.prospectService = prospectService;
this.associateMembershipService = associateMembershipService;
this.clientProjectSharedService = clientProjectSharedService;
this.individualService = individualService;
this.roleService = roleService;
this.emailService = emailService;
}
/// <summary>
/// Initializes a new instance of the <see cref="ReferencesController" /> class
/// </summary>
/// <param name="mapper"><see cref="IMapper"/></param>
/// <param name="referenceService"><see cref="IReferenceService"/></param>
public ReferencesController(
IMapper mapper,
IReferenceService referenceService)
{
this.mapper = mapper;
this.referenceService = referenceService;
}
public void PopulateAvailableOptions(IReferenceService referenceService)
{
Occupations = referenceService.Get <RefOccupation>()
.Select(o => new SelectListItem {
Text = o.Description, Value = o.Id.ToString()
}).ToList();
}
public AssessmentReferenceDataController(IOutputConverter outputConverter, IAssessmentScopeService scopeService, IAssessmentStatusService statusService, IAssessmentTypeService typeService, IReferenceService referenceService)
{
_scopeService = scopeService;
_statusService = statusService;
_typeService = typeService;
_referenceService = referenceService;
}
public override object EditValue(ITypeDescriptorContext typeDescriptorContext, IServiceProvider serviceProvider, object o)
{
if (typeDescriptorContext == null)
{
throw new ArgumentNullException("typeDescriptorContext");
}
if (serviceProvider == null)
{
throw new ArgumentNullException("serviceProvider");
}
object selectedName = o;
this.editorService = (IWindowsFormsEditorService)serviceProvider.GetService(typeof(IWindowsFormsEditorService));
if (this.editorService != null)
{
Activity component = null;
IReferenceService service = serviceProvider.GetService(typeof(IReferenceService)) as IReferenceService;
if (service != null)
{
component = service.GetComponent(typeDescriptorContext.Instance) as Activity;
}
string name = typeDescriptorContext.PropertyDescriptor.GetValue(typeDescriptorContext.Instance) as string;
ConditionBrowserDialog dialog = new ConditionBrowserDialog(component, name);
if (DialogResult.OK == this.editorService.ShowDialog(dialog))
{
selectedName = dialog.SelectedName;
}
}
return(selectedName);
}
internal IFacadeUpdateResult <ReferenceData> SetPublish(object instanceId, bool status)
{
ArgumentValidator.IsNotNull("instanceId", instanceId);
FacadeUpdateResult <ReferenceData> result = new FacadeUpdateResult <ReferenceData>();
IReferenceService service = UnitOfWork.GetService <IReferenceService>();
var query = service.Retrieve(instanceId);
if (query.HasResult)
{
Reference instance = query.ToBo <Reference>();
if (instance.IsPublished != status)
{
instance.IsPublished = status;
var saveQuery = service.Save(instance);
result.AttachResult(instance.RetrieveData <ReferenceData>());
result.Merge(saveQuery);
}
}
else
{
AddError(result.ValidationResult, "ReferenceCannotBeFound");
}
return(result);
}
internal IFacadeUpdateResult <ReferenceData> SaveReferenceBasic(ReferenceData dto)
{
ArgumentValidator.IsNotNull("dto", dto);
FacadeUpdateResult <ReferenceData> result = new FacadeUpdateResult <ReferenceData>();
IReferenceService service = UnitOfWork.GetService <IReferenceService>();
Reference instance = RetrieveOrNew <ReferenceData, Reference, IReferenceService>(result.ValidationResult, dto.Id);
if (result.IsSuccessful)
{
instance.Slug = dto.Slug;
instance.Title = dto.Title;
instance.ThumbnailUrl = dto.ThumbnailUrl;
instance.Description = dto.Description;
instance.Keywords = dto.Keywords;
instance.EnableAds = dto.EnableAds;
instance.EnableTopAd = dto.EnableTopAd;
instance.ModifiedDate = DateTime.Now;
instance.LocationId = dto.LocationId;
var saveQuery = service.Save(instance);
result.AttachResult(instance.RetrieveData <ReferenceData>());
result.Merge(saveQuery);
}
return(result);
}
internal IFacadeUpdateResult <ReferenceData> SaveReferenceKeywords(object referenceId, IList <ReferenceKeywordData> referenceKeywords)
{
ArgumentValidator.IsNotNull("referenceId", referenceId);
ArgumentValidator.IsNotNull("referenceKeywords", referenceKeywords);
FacadeUpdateResult <ReferenceData> result = new FacadeUpdateResult <ReferenceData>();
IReferenceService service = UnitOfWork.GetService <IReferenceService>();
Reference instance = RetrieveOrNew <ReferenceData, Reference, IReferenceService>(result.ValidationResult, referenceId);
if (result.IsSuccessful)
{
instance.ModifiedDate = DateTime.Now;
// Remove all existing ReferenceKeywords
instance.ReferenceKeywords.Clear();
// Keywords
foreach (ReferenceKeywordData item in referenceKeywords)
{
ReferenceKeyword child = instance.ReferenceKeywords.AddNewBo();
child.KeywordId = item.KeywordId;
child.Sort = item.Sort;
}
var saveQuery = service.Save(instance);
result.AttachResult(instance.RetrieveData <ReferenceData>());
result.Merge(saveQuery);
}
return(result);
}
internal IFacadeUpdateResult <ReferenceData> SaveReferenceLanguageBasic(ReferenceData dto, object languageId)
{
ArgumentValidator.IsNotNull("dto", dto);
ArgumentValidator.IsNotNull("languageId", languageId);
FacadeUpdateResult <ReferenceData> result = new FacadeUpdateResult <ReferenceData>();
IReferenceService service = UnitOfWork.GetService <IReferenceService>();
Reference instance = RetrieveOrNew <ReferenceData, Reference, IReferenceService>(result.ValidationResult, dto.Id);
if (result.IsSuccessful)
{
instance.ModifiedDate = DateTime.Now;
// Check existence of current language
ReferenceLanguage referenceLanguage = instance.ReferenceLanguages.FirstOrDefault(o => object.Equals(o.LanguageId, languageId));
if (referenceLanguage == null)
{
referenceLanguage = instance.ReferenceLanguages.AddNewBo();
referenceLanguage.LanguageId = languageId;
}
referenceLanguage.Title = dto.Title;
referenceLanguage.Description = dto.Description;
referenceLanguage.Keywords = dto.Keywords;
var saveQuery = service.Save(instance);
result.AttachResult(instance.RetrieveData <ReferenceData>());
result.Merge(saveQuery);
}
return(result);
}
protected virtual void ResetReferenceName()
{
IReferenceService svc = GetService(typeof(IReferenceService)) as IReferenceService;
if (svc != null)
{
FieldInfo fi = svc.GetType().GetField("referenceList", BindingFlags.GetField | (BindingFlags.NonPublic | BindingFlags.Instance));
if (fi != null)
{
ArrayList values = fi.GetValue(svc) as ArrayList;
if (values != null)
{
foreach (object val in values)
{
PropertyInfo pi = val.GetType().GetProperty("SitedComponent", BindingFlags.GetProperty | (BindingFlags.Public | BindingFlags.Instance));
if (pi != null)
{
object obj = pi.GetValue(val, null);
if (obj == Editor)
{
MethodInfo mi = val.GetType().GetMethod("ResetName", BindingFlags.InvokeMethod | (BindingFlags.NonPublic | BindingFlags.Instance));
if (mi != null)
{
mi.Invoke(val, null);
}
}
}
}
}
}
}
}
public override void Populate(ReferenceInfoDto referenceInfo)
{
int pageSize = 0;
bool showPagination = false;
if (referenceInfo.ValuesDic.ContainsKey(BlockRegister.ListViewWidget.PageSize))
{
DucValueDto value = referenceInfo.ValuesDic[BlockRegister.ListViewWidget.PageSize];
if (value.ValueInt.HasValue)
{
pageSize = value.ValueInt.Value;
}
showPagination = pageSize > 0;
}
if (pageSize == 0)
{
pageSize = WebContext.Current.MaxPageSize;
}
int currentPage = PageIndex.HasValue && showPagination ? PageIndex.Value : 1;
object languageId = CurrentLanguage != null ? CurrentLanguage.Id : null;
IReferenceService service = ServiceLocator.Current.GetInstance <IReferenceService>();
Items = service.GetAttachedSubjects(referenceInfo.ReferenceId,
BlockRegister.ListViewWidget.ReferenceList,
currentPage, pageSize, languageId);
int totalCount = Items.Any() ? Items.First <SubjectInfoDto>().TotalCount : 0;
PaginationViewModel = new PaginationViewModel(totalCount, currentPage, pageSize, WebContext.Current.PagerWindowSize);
PaginationViewModel.ShowTotal = false;
}
public override object ConvertFrom(ITypeDescriptorContext context,
CultureInfo culture,
object value)
{
if (!(value is string))
{
return(base.ConvertFrom(context, culture, value));
}
if (context != null)
{
object reference = null;
// try 1 - IReferenceService
IReferenceService referenceService = context.GetService(typeof(IReferenceService)) as IReferenceService;
if (referenceService != null)
{
reference = referenceService.GetReference((string)value);
}
// try 2 - Component by name
if (reference == null)
{
if (context.Container != null && context.Container.Components != null)
{
reference = context.Container.Components[(string)value];
}
}
return(reference);
}
return(null);
}
public static TypeConverter.StandardValuesCollection GetReferences(
IServiceProvider context,
Type type)
{
if (context != null)
{
ArrayList arrayList = new ArrayList();
IReferenceService service = (IReferenceService)context.GetService(typeof(IReferenceService));
if (service != null)
{
object[] references = service.GetReferences(type);
int length = references.Length;
for (int index = 0; index < length; ++index)
{
IComponent component = references[index] as IComponent;
if (component != null && component.Site != null && component.Site.DesignMode)
{
arrayList.Add(references[index]);
}
}
return(new TypeConverter.StandardValuesCollection((ICollection)arrayList.ToArray()));
}
}
return((TypeConverter.StandardValuesCollection)null);
}
public ItSystemUsageService(
IGenericRepository <ItSystemUsage> usageRepository,
IAuthorizationContext authorizationContext,
IItSystemRepository systemRepository,
IItContractRepository contractRepository,
IOptionsService <SystemRelation, RelationFrequencyType> frequencyService,
IGenericRepository <SystemRelation> relationRepository,
IGenericRepository <ItInterface> interfaceRepository,
IReferenceService referenceService,
ITransactionManager transactionManager,
IDomainEvents domainEvents,
ILogger logger,
IGenericRepository <ItSystemUsageSensitiveDataLevel> sensitiveDataLevelRepository)
{
_usageRepository = usageRepository;
_authorizationContext = authorizationContext;
_systemRepository = systemRepository;
_contractRepository = contractRepository;
_frequencyService = frequencyService;
_transactionManager = transactionManager;
_domainEvents = domainEvents;
_relationRepository = relationRepository;
_interfaceRepository = interfaceRepository;
_referenceService = referenceService;
_logger = logger;
_sensitiveDataLevelRepository = sensitiveDataLevelRepository;
}
public PawningController()
{
_pawningService = new PawningService(new UnitOfWorkFactory());
_appraisalService = new AppraisalService(new UnitOfWorkFactory());
_customerService = new CustomerService(new UnitOfWorkFactory());
_referenceService = new ReferenceService(new UnitOfWorkFactory());
}
private void OnComponentChanged(object source, ComponentChangedEventArgs ce)
{
if (this.cache != null)
{
if (ce.Component != null)
{
this.RemoveEntry(ce.Component);
if (!(ce.Component is IComponent) && (this.serManager != null))
{
IReferenceService service = this.serManager.GetService(typeof(IReferenceService)) as IReferenceService;
if (service != null)
{
IComponent component = service.GetComponent(ce.Component);
if (component != null)
{
this.RemoveEntry(component);
}
else
{
this.cache.Clear();
}
}
}
}
else
{
this.cache.Clear();
}
}
}
/// <summary>
/// Converts the given value object to the specified type, using the specified context and culture information.
/// </summary>
/// <param name="context">An ITypeDescriptorContext that provides a format context.</param>
/// <param name="culture">A CultureInfo object. If a null reference (Nothing in Visual Basic) is passed, the current culture is assumed.</param>
/// <param name="value">The Object to convert.</param>
/// <param name="destinationType">The Type to convert the value parameter to.</param>
/// <returns>An Object that represents the converted value.</returns>
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (destinationType == typeof(string) && context != null)
{
IReferenceService rs = (IReferenceService)context.GetService(typeof(IReferenceService));
//Debug.Assert(rs != null);
Action a = (Action)value;
if (a != null)
{
// here's the hack for getting a reference to the associated collection
_actionList = a.Parent;
//Debug.Assert(_actionList != null && _actionList.Actions != null);
if (a == _actionList.Actions.Null)
{
return("");
}
return(rs.GetName(a));
}
}
return(base.ConvertTo(context, culture, value, destinationType));
}
public override object ConvertFrom(
ITypeDescriptorContext context,
CultureInfo culture,
object value)
{
if (!(value is string))
{
return(base.ConvertFrom(context, culture, value));
}
string index = ((string)value).Trim();
if (!string.Equals(index, CommandBaseConverter.none) && context != null)
{
IReferenceService service = (IReferenceService)context.GetService(typeof(IReferenceService));
if (service != null)
{
object reference = service.GetReference(index);
if (reference != null)
{
return(reference);
}
}
IContainer container = context.Container;
if (container != null)
{
object component = (object)container.Components[index];
if (component != null)
{
return(component);
}
}
}
return((object)null);
}
public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
{
MapperInfo info = (MapperInfo)context.Instance;
//if (!info.DataUIMapper.DisplayMember)
//{
// string[] sv = new string[] { string.Empty };
// return new StandardValuesCollection(sv);
//}
IDesignerHost host = (IDesignerHost)context.GetService(typeof(IDesignerHost));
IReferenceService svc = (IReferenceService)host.GetService(typeof(IReferenceService));
if (svc == null)
{
return(null);
}
object ctl = svc.GetReference(info.ControlID);
if (ctl == null)
{
throw new ArgumentException("当前容器中未发现名称为 '" + info.ControlID + "' 的控件。");
}
else
{
return(new StandardValuesCollection(MemberHelper.GetControlProperties(ctl)));
}
}
public AssessmentController(IDiscoveryCache discoveryCache, ProdDbContext dbContext, IReferenceService referenceService, IHubContext <MessageHub> hubContext) : base(discoveryCache, dbContext)
//public AssessmentController(IDiscoveryCache discoveryCache, ProdDbContext dbContext, IReferenceService referenceService) : base(discoveryCache, dbContext)
{
_dbContext = dbContext;
_referenceService = referenceService;
_hubContext = hubContext;
}
public override object EditValue(ITypeDescriptorContext typeDescriptorContext, IServiceProvider serviceProvider, object o)
{
if (typeDescriptorContext == null)
{
throw new ArgumentNullException("typeDescriptorContext");
}
if (serviceProvider == null)
{
throw new ArgumentNullException("serviceProvider");
}
object obj2 = o;
this.editorService = (IWindowsFormsEditorService)serviceProvider.GetService(typeof(IWindowsFormsEditorService));
if (this.editorService != null)
{
Activity component = null;
IReferenceService service = serviceProvider.GetService(typeof(IReferenceService)) as IReferenceService;
if (service != null)
{
component = service.GetComponent(typeDescriptorContext.Instance) as Activity;
}
string name = null;
RuleSetReference reference = typeDescriptorContext.PropertyDescriptor.GetValue(typeDescriptorContext.Instance) as RuleSetReference;
if (reference != null)
{
name = reference.RuleSetName;
}
RuleSetBrowserDialog dialog = new RuleSetBrowserDialog(component, name);
if (DialogResult.OK == this.editorService.ShowDialog(dialog))
{
obj2 = typeDescriptorContext.PropertyDescriptor.Converter.ConvertFrom(typeDescriptorContext, CultureInfo.CurrentUICulture, dialog.SelectedName);
}
}
return(obj2);
}
internal string GetName(object obj, bool generateNew)
{
string name = null;
if (obj != null)
{
IReferenceService service = this.GetService(typeof(IReferenceService)) as IReferenceService;
if (service != null)
{
name = service.GetName(obj);
}
else
{
IComponent component = obj as IComponent;
if (component != null)
{
ISite site = component.Site;
if (site != null)
{
name = site.Name;
}
}
}
}
if ((name != null) || !generateNew)
{
return(name);
}
if (obj == null)
{
return("(null)");
}
return(obj.GetType().Name);
}
internal static ISite GetSite(IServiceProvider serviceProvider, object component)
{
ISite site = null;
if (component != null)
{
if ((component is IComponent) && (((IComponent)component).Site != null))
{
site = ((IComponent)component).Site;
}
if (((site == null) && component.GetType().IsArray) && (((component as object[]).Length > 0) && ((component as object[])[0] is IComponent)))
{
site = ((IComponent)(component as object[])[0]).Site;
}
if ((site == null) && (serviceProvider != null))
{
IReferenceService service = serviceProvider.GetService(typeof(IReferenceService)) as IReferenceService;
if (service != null)
{
IComponent component2 = service.GetComponent(component);
if (component2 != null)
{
site = component2.Site;
}
}
}
}
if (site == null)
{
site = serviceProvider as ISite;
}
return(site);
}
public DataErrorsController(IUserService usrSvc, IEmployeeService empSvc, IDataErrorService deSvc, IReferenceService refSvc)
{
_userService = usrSvc;
_employeeService = empSvc;
_dataErrorService = deSvc;
_referenceService = refSvc;
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
if (!(value is string))
{
return(base.ConvertFrom(context, culture, value));
}
string a = ((string)value).Trim();
if (!string.Equals(a, none) && (context != null))
{
IReferenceService service = (IReferenceService)context.GetService(typeof(IReferenceService));
if (service != null)
{
object reference = service.GetReference(a);
if (reference != null)
{
return(reference);
}
}
IContainer container = context.Container;
if (container != null)
{
object obj3 = container.Components[a];
if (obj3 != null)
{
return(obj3);
}
}
}
return(null);
}
public ReferenceController(IReferenceService referenceService,
IHttpContextAccessor httpContextAccessor,
IUserService userService) : base(httpContextAccessor, userService)
{
_referenceService = referenceService;
_userService = userService;
}
protected RuleDefinitions GetRuleDefinitions(object component)
{
IReferenceService service = (IReferenceService)base.ServiceProvider.GetService(typeof(IReferenceService));
if (service == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.MissingService, new object[] { typeof(IReferenceService).FullName }));
}
Activity activity = service.GetComponent(component) as Activity;
if (activity == null)
{
return(null);
}
Activity rootActivity = Helpers.GetRootActivity(activity);
if (rootActivity == null)
{
return(null);
}
Activity declaringActivity = Helpers.GetDeclaringActivity(activity);
if ((declaringActivity != rootActivity) && (declaringActivity != null))
{
return(ConditionHelper.GetRuleDefinitionsFromManifest(declaringActivity.GetType()));
}
return(ConditionHelper.Load_Rules_DT(base.ServiceProvider, rootActivity));
}
public void Dispose()
{
IDisposable d;
if (this.designerLoader != null)
{
try
{
this.designerLoader.Flush();
}
catch (Exception e1)
{
Debug.Fail("Designer loader '" + this.designerLoader.GetType().Name + "' threw during Flush: " + e1.ToString());
e1 = null;
}
try
{
this.designerLoader.Dispose();
}
catch (Exception e2)
{
Debug.Fail("Designer loader '" + this.designerLoader.GetType().Name + "' threw during Dispose: " + e2.ToString());
e2 = null;
}
this.designerLoader = null;
}
this.UnloadDocument();
this.serviceContainer = null;
if (this.menuEditorService != null)
{
d = this.menuEditorService as IDisposable;
if (d != null)
{
d.Dispose();
}
this.menuEditorService = null;
}
if (this.selectionService != null)
{
d = this.selectionService as IDisposable;
if (d != null)
{
d.Dispose();
}
this.selectionService = null;
}
if (this.menuCommandService != null)
{
d = this.menuCommandService as IDisposable;
if (d != null)
{
d.Dispose();
}
this.menuCommandService = null;
}
if (this.toolboxService != null)
{
d = this.toolboxService as IDisposable;
if (d != null)
{
d.Dispose();
}
this.toolboxService = null;
}
if (this.helpService != null)
{
d = this.helpService as IDisposable;
if (d != null)
{
d.Dispose();
}
this.helpService = null;
}
if (this.referenceService != null)
{
d = this.referenceService as IDisposable;
if (d != null)
{
d.Dispose();
}
this.referenceService = null;
}
if (this.documentWindow != null)
{
this.documentWindow.Dispose();
this.documentWindow = null;
}
}
/// <summary>
///
/// </summary>
/// <param name="referenceService"></param>
/// <param name="todoService"></param>
public TodoController(IReferenceService referenceService, ITodoService todoService)
: base(referenceService)
{
_todoService = todoService;
}
public ActivityCodeDomReferenceService(IReferenceService referenceService)
{
this.refService = referenceService;
}
public TestTypeDescriptorContext (IReferenceService referenceService)
{
reference_service = referenceService;
}
//****
//****
//**** IDisposable Implementation
//****
//****
/// Disposes of the DesignContainer. This cleans up any objects we may be holding
/// and removes any services that we created.
public void Dispose() {
// Dispose the loader before destroying the designer. Otherwise, the
// act of destroying all the components on the designer surface will
// be reflected in the loader, deleting the user's file.
if (designerLoader != null) {
try
{
designerLoader.Flush();
}
catch (Exception e1)
{
Debug.Fail("Designer loader '" + designerLoader.GetType().Name + "' threw during Flush: " + e1.ToString());
e1 = null;
}
try {
designerLoader.Dispose();
}
catch (Exception e2) {
Debug.Fail("Designer loader '" + designerLoader.GetType().Name + "' threw during Dispose: " + e2.ToString());
e2 = null;
}
designerLoader = null;
}
// Unload the document.
UnloadDocument();
// No services after this!
serviceContainer = null;
// Now tear down all of our services.
if (menuEditorService != null) {
IDisposable d = menuEditorService as IDisposable;
if (d != null) d.Dispose();
menuEditorService = null ;
}
if (selectionService != null) {
IDisposable d = selectionService as IDisposable;
if (d != null) d.Dispose();
selectionService = null;
}
if (menuCommandService != null) {
IDisposable d = menuCommandService as IDisposable;
if (d != null) d.Dispose();
menuCommandService = null;
}
if (toolboxService != null)
{
IDisposable d = toolboxService as IDisposable;
if (d != null) d.Dispose();
toolboxService = null;
}
if (helpService != null) {
IDisposable d = helpService as IDisposable;
if (d != null) d.Dispose();
helpService = null;
}
if (referenceService != null) {
IDisposable d = referenceService as IDisposable;
if (d != null) d.Dispose();
referenceService = null;
}
// Destroy our document window.
if (documentWindow != null) {
documentWindow.Dispose();
documentWindow = null;
}
}
/// <summary>
///
/// </summary>
/// <param name="referenceService"></param>
public BaseController(IReferenceService referenceService)
{
_referenceService = referenceService;
}
