public void Handle (TMessageInternal message)
{
if (message.NotNull ()) {
if (message.IsModule (TResource.TModule.Factory)) {
// from Sibling
if (message.Node.IsSiblingToMe (TChild.Design, TypeInfo)) {
// PropertySelect
if (message.IsAction (TInternalMessageAction.PropertySelect)) {
if (message.Support.Argument.Args.Param1 is TActionComponent component) {
var propertyName = message.Support.Argument.Args.PropertyName;
Model.SelectModel (component);
}
TDispatcher.Invoke (RefreshDesignDispatcher);
}
// Request
if (message.IsAction (TInternalMessageAction.Request)) {
TDispatcher.BeginInvoke (RequestDesignDispatcher, TEntityAction.Request (message.Support.Argument.Types.EntityAction));
}
// Cleanup
if (message.IsAction (TInternalMessageAction.Cleanup)) {
TDispatcher.Invoke (RefreshDesignDispatcher);
}
}
}
}
}
public void Handle (TMessageInternal message)
{
if (message.NotNull ()) {
if (message.IsModule (TResource.TModule.Factory)) {
// from child only
if (message.Node.IsRelationChild) {
if (message.IsAction (TInternalMessageAction.DatabaseRequest)) {
var authentication = message.Support.Argument.Types.Authentication;
// to sibiling
var messageInternal = new TFactoryMessageInternal (TInternalMessageAction.DatabaseResponse, authentication, TypeInfo);
messageInternal.Node.SelectRelationParent (TChild.Front);
messageInternal.Support.Argument.Types.ConnectionData.CopyFrom (Model.Request (authentication));
DelegateCommand.PublishInternalMessage.Execute (messageInternal);
}
if (message.IsAction (TInternalMessageAction.Change)) {
// to module
var messageModule = new TFactoryMessage (TMessageAction.Changed, TypeInfo);
messageModule.Support.Argument.Types.ConnectionData.CopyFrom (message.Support.Argument.Types.ConnectionData);
DelegateCommand.PublishMessage.Execute (messageModule);
}
}
}
}
}
public void Handle (TMessageInternal message)
{
if (message.NotNull ()) {
if (message.IsModule (TResource.TModule.Factory)) {
// from parent
if (message.Node.IsParentToMe (TChild.List)) {
// DatabaseValidated
if (message.IsAction (TInternalMessageAction.DatabaseValidated)) {
TDispatcher.Invoke (RequestDataDispatcher);
}
// Response
if (message.IsAction (TInternalMessageAction.Response)) {
// Collection-Full
if (message.Support.Argument.Types.IsOperation (TOperation.Collection, TExtension.Full)) {
if (message.Result.IsValid) {
// Gadget Material
if (message.Support.Argument.Types.IsOperationCategory (TCategory.Material)) {
var action = TEntityAction.Request (message.Support.Argument.Types.EntityAction);
TDispatcher.BeginInvoke (MaterialCollectionFullDispatcher, action);
}
}
}
}
}
// from sibilig
if (message.Node.IsSiblingToMe (TChild.List, TypeInfo)) {
// PropertySelect
if (message.IsAction (TInternalMessageAction.PropertySelect)) {
var propertyName = message.Support.Argument.Args.PropertyName;
if (propertyName.Equals ("edit", StringComparison.InvariantCulture)) {
if (message.Support.Argument.Args.Param1 is TActionComponent component) {
TDispatcher.BeginInvoke (EditDispatcher, component);
}
}
if (propertyName.Equals ("GadgetAdd", StringComparison.InvariantCulture) || propertyName.Equals ("GadgetRemove", StringComparison.InvariantCulture)) {
Model.PropertyChanged (message.Support.Argument.Args.PropertyName, message.Support.Argument.Types.ReportData.Locked);
TDispatcher.Invoke (RefreshAllDispatcher);
}
}
// Reload
if (message.IsAction (TInternalMessageAction.Reload)) {
// to parent
DelegateCommand.PublishInternalMessage.Execute (message);
}
// Cleanup
if (message.IsAction (TInternalMessageAction.Cleanup)) {
Model.Cleanup ();
TDispatcher.Invoke (RefreshAllDispatcher);
}
}
}
}
}
public void Handle (TMessageInternal message)
{
if (message.NotNull ()) {
if (message.IsModule (TResource.TModule.Collection)) {
// from parent
if (message.Node.IsParentToMe (TChild.List)) {
// DatabaseValidated
if (message.IsAction (TInternalMessageAction.DatabaseValidated)) {
TDispatcher.Invoke (RequestDataDispatcher);
}
// Response
if (message.IsAction (TInternalMessageAction.Response)) {
// Collection-Full
if (message.Support.Argument.Types.IsOperation (Server.Models.Infrastructure.TOperation.Collection, Server.Models.Infrastructure.TExtension.Full)) {
if (message.Result.IsValid) {
// Gadget Target
if (message.Support.Argument.Types.IsOperationCategory (Server.Models.Infrastructure.TCategory.Target)) {
var action = TEntityAction.Request (message.Support.Argument.Types.EntityAction);
TDispatcher.BeginInvoke (ResponseDataDispatcher, action);
}
// Gadget Material
if (message.Support.Argument.Types.IsOperationCategory (Server.Models.Infrastructure.TCategory.Material)) {
var action = TEntityAction.Request (message.Support.Argument.Types.EntityAction);
TDispatcher.BeginInvoke (RefreshModelDispatcher, action);
}
}
}
// Select-ById
if (message.Support.Argument.Types.IsOperation (Server.Models.Infrastructure.TOperation.Select, Server.Models.Infrastructure.TExtension.ById)) {
if (message.Result.IsValid) {
var action = TEntityAction.Request (message.Support.Argument.Types.EntityAction);
TDispatcher.BeginInvoke (ResponseModelDispatcher, action);
}
}
}
// Reload
if (message.IsAction (TInternalMessageAction.Reload)) {
TDispatcher.Invoke (RefreshAllDispatcher);
TDispatcher.Invoke (RequestDataDispatcher);
}
}
// from sibilig
if (message.Node.IsSiblingToMe (TChild.List, TypeInfo)) {
// Reload
if (message.IsAction (TInternalMessageAction.Reload)) {
TDispatcher.Invoke (RefreshAllDispatcher);
TDispatcher.Invoke (RequestDataDispatcher);
TDispatcher.Invoke (ReloadDispatcher);
}
}
}
}
}
public void Handle (TMessageInternal message)
{
if (message.NotNull ()) {
if (message.IsModule (TResource.TModule.Collection)) {
// from child only
if (message.Node.IsRelationChild) {
// Request
if (message.IsAction (TInternalMessageAction.Request)) {
// to module
var messageModule = new TCollectionMessage (TMessageAction.Request, TypeInfo);
messageModule.Node.SelectRelationModule (message.Node.Child, TModuleName.Collection);
messageModule.Support.Argument.Types.CopyFrom (message.Support.Argument.Types);
DelegateCommand.PublishMessage.Execute (messageModule);
}
// RefreshModel
if (message.IsAction (TInternalMessageAction.RefreshModel)) {
// to module
var messageModule = new TCollectionMessage (TMessageAction.RefreshModel, TypeInfo);
messageModule.Node.SelectRelationModule (TChild.None);
messageModule.Support.Argument.Types.CopyFrom (message.Support.Argument.Types);
DelegateCommand.PublishMessage.Execute (messageModule);
}
// reload
if (message.IsAction (TInternalMessageAction.Reload)) {
// to module
DelegateCommand.PublishMessage.Execute (new TCollectionMessage (TMessageAction.Reload, TypeInfo));
// to module (Update)
var messageModule = new TCollectionMessage (TMessageAction.Update, TypeInfo);
messageModule.Node.SelectRelationModule (TChild.None);
DelegateCommand.PublishMessage.Execute (messageModule);
}
// Edit
if (message.IsAction (TInternalMessageAction.Edit)) {
// to module
var messageModule = new TCollectionMessage (TMessageAction.Edit, TypeInfo);
messageModule.Node.SelectRelationModule (TChild.None);
messageModule.Support.Argument.Args.Select (message.Support.Argument.Args.Param1);
DelegateCommand.PublishMessage.Execute (messageModule);
}
}
}
}
}
public void Handle (TMessageInternal message)
{
if (message.NotNull ()) {
if (message.IsModule (TResource.TModule.Factory)) {
// from Sibling
if (message.Node.IsSiblingToMe (TChild.Design, TypeInfo)) {
// PropertySelect
if (message.IsAction (TInternalMessageAction.PropertySelect)) {
var propertyName = message.Support.Argument.Args.PropertyName;
if (propertyName.Equals ("GadgetAdd", StringComparison.InvariantCulture)) {
if (message.Support.Argument.Args.Param1 is TActionComponent component) {
Model.AddModel (component);
}
TDispatcher.Invoke (RefreshDesignDispatcher);
}
if (propertyName.Equals ("GadgetRemove", StringComparison.InvariantCulture)) {
if (message.Support.Argument.Args.Param1 is TActionComponent component) {
Model.RemoveModel (component);
}
TDispatcher.Invoke (RefreshDesignDispatcher);
}
if (propertyName.Equals ("edit", StringComparison.InvariantCulture)) {
if (message.Support.Argument.Args.Param1 is TActionComponent component) {
Model.Edit (component);
}
TDispatcher.Invoke (RefreshDesignDispatcher);
}
var action = TEntityAction.Request (message.Support.Argument.Types.EntityAction);
if (action.NotNull ()) {
action.Param1 = propertyName;
TDispatcher.BeginInvoke (PropertySelectDispatcher, action);
}
}
// Cleanup
if (message.IsAction (TInternalMessageAction.Cleanup)) {
Model.Cleanup ();
TDispatcher.Invoke (RefreshDesignDispatcher);
}
}
}
}
}
public void Handle (TMessageInternal message)
{
if (message.NotNull ()) {
if (message.IsModule (TResource.TModule.Factory)) {
// from parent
if (message.Node.IsParentToMe (TChild.Property)) {
// RefreshModel
if (message.IsAction (TInternalMessageAction.RefreshModel)) {
TDispatcher.BeginInvoke (RefreshModelDispatcher, TEntityAction.Request (message.Support.Argument.Types.EntityAction));
}
// Edit
if (message.IsAction (TInternalMessageAction.Edit)) {
if (message.Support.Argument.Args.Param1 is TActionComponent component) {
TDispatcher.BeginInvoke (EditDispatcher, component);
}
}
// EditLeave
if (message.IsAction (TInternalMessageAction.EditLeave)) {
if (IsViewModeEdit) {
OnCancelCommadClicked ();
}
}
// Response
if (message.IsAction (TInternalMessageAction.Response)) {
// Insert
if (message.Support.Argument.Types.IsOperation (TOperation.Insert)) {
TDispatcher.Invoke (InsertSuccessDispatcher);
}
// Change - Full
if (message.Support.Argument.Types.IsOperation (TOperation.Change, TExtension.Full)) {
TDispatcher.Invoke (ChangeSuccessDispatcher);
}
}
}
// from Sibling
if (message.Node.IsSiblingToMe (TChild.Property, TypeInfo)) {
// Response
if (message.IsAction (TInternalMessageAction.Response)) {
TDispatcher.BeginInvoke (ResponseModelDispatcher, TEntityAction.Request (message.Support.Argument.Types.EntityAction));
}
}
}
}
}
public void Handle (TMessageInternal message)
{
if (message.NotNull ()) {
// from sibiling
if (message.Node.IsSiblingToMe (TChild.Back, TypeInfo)) {
if (message.Support.Argument.Types.Authentication.Equals (TAuthentication.Windows)) {
if (message.IsAction (TInternalMessageAction.Select)) {
Model.ClearCheck ();
Model.Populate (message.Support.Argument.Types.ConnectionData);
ApplyChanges ();
}
}
}
}
}
public void Handle (TMessageInternal message)
{
if (message.NotNull ()) {
}
if (message.IsModule (TResource.TModule.Factory)) {
// from child only
if (message.Node.IsRelationChild) {
// request
if (message.IsAction (TInternalMessageAction.Request)) {
// to module
var messageModule = new TFactoryMessage (TMessageAction.Request, TypeInfo);
messageModule.Node.SelectRelationModule (message.Node.Child, TModuleName.Factory);
messageModule.Support.Argument.Types.CopyFrom (message.Support.Argument.Types);
DelegateCommand.PublishMessage.Execute (messageModule);
}
// reload
if (message.IsAction (TInternalMessageAction.Reload)) {
// to module
DelegateCommand.PublishMessage.Execute (new TFactoryMessage (TMessageAction.Reload, TypeInfo));
}
// navigateform
if (message.IsAction (TInternalMessageAction.NavigateForm)) {
// to module
var messageModule = new TFactoryMessage (TMessageAction.Focus, TypeInfo);
messageModule.Support.Argument.Args.Select (message.Support.Argument.Args.Where);
DelegateCommand.PublishMessage.Execute (messageModule);
}
// edit enter
if (message.IsAction (TInternalMessageAction.EditEnter)) {
// to module
DelegateCommand.PublishMessage.Execute (new TFactoryMessage (TMessageAction.EditEnter, TypeInfo));
}
// edit leave
if (message.IsAction (TInternalMessageAction.EditLeave)) {
// to module
DelegateCommand.PublishMessage.Execute (new TFactoryMessage (TMessageAction.EditLeave, TypeInfo));
}
}
}
}
public void Handle (TMessageInternal message)
{
if (message.NotNull ()) {
if (message.IsModule (TResource.TModule.Factory)) {
// from parent
if (message.Node.IsParentToMe (TChild.List)) {
// Response
if (message.IsAction (TInternalMessageAction.Response)) {
// Change - Content
if (message.Support.Argument.Types.IsOperation (TOperation.Change, TExtension.Content)) {
if (message.Result.IsValid) {
TDispatcher.Invoke (ChangeSuccessDispatcher);
}
}
// Change - Status
if (message.Support.Argument.Types.IsOperation (TOperation.Change, TExtension.Status)) {
if (message.Result.IsValid) {
TDispatcher.Invoke (CleanupDispatcher);
}
}
}
}
// from Sibling
if (message.Node.IsSiblingToMe (TChild.List, TypeInfo)) {
// PropertySelect
if (message.IsAction (TInternalMessageAction.PropertySelect)) {
var propertyName = message.Support.Argument.Args.PropertyName;
if (propertyName.Equals ("modify", StringComparison.InvariantCulture)) {
if (message.Support.Argument.Args.Param1 is TActionComponent component) {
TDispatcher.BeginInvoke (ModifyDispatcher, component);
}
}
}
// Cleanup
if (message.IsAction (TInternalMessageAction.Cleanup)) {
Model.Cleanup ();
TDispatcher.Invoke (RefreshAllDispatcher);
}
}
}
}
}
public void Handle (TMessageInternal message)
{
if (message.NotNull ()) {
if (message.IsModule (TResource.TModule.Collection)) {
// from parent
if (message.Node.IsParentToMe (TChild.Display)) {
// Response
if (message.IsAction (TInternalMessageAction.Response)) {
// Remove
if (message.Support.Argument.Types.IsOperation (TOperation.Remove)) {
if (message.Result.IsValid) {
Model.Cleanup ();
ApplyChanges ();
// notify List
TDispatcher.Invoke (ReloadDispatcher);
}
}
}
}
// from sibilig
if (message.Node.IsSiblingToMe (TChild.Display, TypeInfo)) {
// Select
if (message.IsAction (TInternalMessageAction.Select)) {
if (message.Support.Argument.Args.Param1 is TActionComponent component) {
if (message.Support.Argument.Args.Param2 is Dictionary<Guid, GadgetMaterial> materialDictionary) {
var tuple = Tuple.Create (component, materialDictionary);
TDispatcher.BeginInvoke (SelectDispatcher, tuple);
}
}
}
// Cleanup
if (message.IsAction (TInternalMessageAction.Cleanup)) {
TDispatcher.Invoke (CleanupDispatcher);
}
}
}
}
}
public void Handle (TMessageInternal message)
{
if (message.NotNull ()) {
if (message.IsModule (TResource.TModule.Factory)) {
// from Sibling
if (message.Node.IsSiblingToMe (TChild.Design, TypeInfo)) {
// PropertySelect
if (message.IsAction (TInternalMessageAction.PropertySelect)) {
var action = TEntityAction.Request (message.Support.Argument.Types.EntityAction);
var propertyName = message.Support.Argument.Args.PropertyName;
if (propertyName.Equals ("edit", StringComparison.InvariantCulture)) {
if (message.Support.Argument.Args.Param1 is TActionComponent component) {
Model.SelectModel (component, propertyName);
}
}
else {
var component = TActionComponent.Create (TCategory.Target);
TActionConverter.Select (TCategory.Target, component, action);
Model.SelectModel (component, propertyName);
}
TDispatcher.Invoke (RefreshDesignDispatcher);
}
// Request
if (message.IsAction (TInternalMessageAction.Request)) {
TDispatcher.BeginInvoke (RequestDesignDispatcher, TEntityAction.Request (message.Support.Argument.Types.EntityAction));
}
// Cleanup
if (message.IsAction (TInternalMessageAction.Cleanup)) {
Model.Cleanup ();
TDispatcher.Invoke (RefreshDesignDispatcher);
}
}
}
}
}
public void Handle (TMessageInternal message)
{
if (message.NotNull ()) {
if (message.IsModule (TResource.TModule.Collection)) {
// from parent
if (message.Node.IsParentToMe (TChild.Display)) {
// Response
if (message.IsAction (TInternalMessageAction.Response)) {
// Remove
if (message.Support.Argument.Types.IsOperation (Server.Models.Infrastructure.TOperation.Remove)) {
if (message.Result.IsValid) {
Model.Cleanup ();
ApplyChanges ();
// notify List
TDispatcher.Invoke (ReloadDispatcher);
}
}
}
}
// from sibilig
if (message.Node.IsSiblingToMe (TChild.Display, TypeInfo)) {
// Select
if (message.IsAction (TInternalMessageAction.Select)) {
if (message.Support.Argument.Args.Param1 is TActionComponent component) {
TDispatcher.BeginInvoke (SelectDispatcher, component);
}
}
// Cleanup
if (message.IsAction (TInternalMessageAction.Cleanup)) {
TDispatcher.Invoke (CleanupDispatcher);
}
}
}
}
}
public void Handle (TMessageInternal message)
{
if (message.NotNull ()) {
// from parent
if (message.Node.IsParentToMe (TChild.Front)) {
if (message.Support.Argument.Types.Authentication.Equals (TAuthentication.SQL)) {
if (message.IsAction (TInternalMessageAction.DatabaseResponse)) {
Model.Populate (message.Support.Argument.Types.ConnectionData);
ApplyChanges ();
}
}
}
// from sibiling
if (message.Node.IsSiblingToMe (TChild.Front, TypeInfo)) {
if (message.Support.Argument.Types.Authentication.Equals (TAuthentication.SQL)) {
if (message.IsAction (TInternalMessageAction.Request)) {
TDispatcher.Invoke (ResponseDataDispatcher);
}
if (message.IsAction (TInternalMessageAction.EditEnter)) {
Model.FactoryEnter ();
ApplyChanges ();
}
if (message.IsAction (TInternalMessageAction.EditLeave)) {
Model.FactoryLeave ();
ApplyChanges ();
}
if (message.IsAction (TInternalMessageAction.Change)) {
Model.Populate (message.Support.Argument.Types.ConnectionData);
ApplyChanges ();
}
}
}
}
}
public void Handle (TMessageInternal message)
{
if (message.NotNull ()) {
if (message.IsModule (TResource.TModule.Factory)) {
// from parent
if (message.Node.IsParentToMe (TChild.List)) {
}
// from Sibling
if (message.Node.IsSiblingToMe (TChild.List, TypeInfo)) {
// PropertySelect
if (message.IsAction (TInternalMessageAction.PropertySelect)) {
var propertyName = message.Support.Argument.Args.PropertyName;
if (propertyName.Equals ("edit", StringComparison.InvariantCulture)) {
Model.SlideIndex = 0;
}
if (propertyName.Equals ("modify", StringComparison.InvariantCulture)) {
Model.SlideIndex = 1;
}
ApplyChanges ();
}
// Cleanup
if (message.IsAction (TInternalMessageAction.Cleanup)) {
Model.SlideIndex = 0;
ApplyChanges ();
}
}
}
}
}
public void Handle (TMessageInternal message)
{
if (message.NotNull ()) {
if (message.IsModule (TResource.TModule.Factory)) {
// from parent
if (message.Node.IsParentToMe (TChild.Property)) {
// RefreshModel
if (message.IsAction (TInternalMessageAction.RefreshModel)) {
TDispatcher.BeginInvoke (RefreshModelDispatcher, TEntityAction.Request (message.Support.Argument.Types.EntityAction));
}
// Edit
if (message.IsAction (TInternalMessageAction.Edit)) {
if (message.Support.Argument.Args.Param1 is TActionComponent component) {
TDispatcher.BeginInvoke (EditDispatcher, component);
}
}
// EditLeave
if (message.IsAction (TInternalMessageAction.EditLeave)) {
if (IsViewModeEdit) {
OnCancelCommadClicked ();
}
}
// Modify
if (message.IsAction (TInternalMessageAction.Modify)) {
if (message.Support.Argument.Args.Param1 is TActionComponent component) {
TDispatcher.BeginInvoke (ModifyDispatcher, component);
}
}
// Response
if (message.IsAction (TInternalMessageAction.Response)) {
// Insert
if (message.Support.Argument.Types.IsOperation (TOperation.Insert)) {
TDispatcher.Invoke (InsertSuccessDispatcher);
}
// Change - Full
if (message.Support.Argument.Types.IsOperation (TOperation.Change, TExtension.Full)) {
TDispatcher.Invoke (ChangeSuccessDispatcher);
}
}
}
// from Sibling
if (message.Node.IsSiblingToMe (TChild.Property, TypeInfo)) {
// Response
if (message.IsAction (TInternalMessageAction.Response)) {
TDispatcher.BeginInvoke (ResponseModelDispatcher, TEntityAction.Request (message.Support.Argument.Types.EntityAction));
}
// Response
if (message.IsAction (TInternalMessageAction.PropertySelect)) {
if (message.Support.Argument.Args.PropertyName.Equals ("RegistrationChanged", StringComparison.InvariantCulture)) {
if (message.Support.Argument.Args.Param1 is GadgetRegistration gadget) {
Model.Select (gadget);
ApplyChanges ();
}
}
}
// Back
if (message.IsAction (TInternalMessageAction.Back)) {
TDispatcher.Invoke (ChangeSuccessDispatcher);
}
}
}
}
}
public void Handle (TMessageInternal message)
{
if (message.NotNull ()) {
if (message.IsModule (TResource.TModule.Factory)) {
// from parent
if (message.Node.IsParentToMe (TChild.List)) {
// DatabaseValidated
if (message.IsAction (TInternalMessageAction.DatabaseValidated)) {
TDispatcher.Invoke (RequestDataDispatcher);
}
// Response
if (message.IsAction (TInternalMessageAction.Response)) {
// Collection - Full
if (message.Support.Argument.Types.IsOperation (TOperation.Collection, TExtension.Full)) {
if (message.Result.IsValid) {
// Gadget Test
if (message.Support.Argument.Types.IsOperationCategory (TCategory.Test)) {
var action = TEntityAction.Request (message.Support.Argument.Types.EntityAction);
TDispatcher.BeginInvoke (ResponseDataDispatcher, action);
}
}
}
// Select - Many
if (message.Support.Argument.Types.IsOperation (TOperation.Select, TExtension.Many)) {
if (message.Result.IsValid) {
var action = TEntityAction.Request (message.Support.Argument.Types.EntityAction);
TDispatcher.BeginInvoke (ResponseSelectManyDispatcher, action);
}
}
// Select - ById
if (message.Support.Argument.Types.IsOperation (TOperation.Select, TExtension.ById)) {
if (message.Result.IsValid) {
// Gadget Test
if (message.Support.Argument.Types.IsOperationCategory (TCategory.Test)) {
var action = TEntityAction.Request (message.Support.Argument.Types.EntityAction);
TDispatcher.BeginInvoke (ResponseSelectByIdDispatcher, action);
}
}
}
}
}
// from sibilig
if (message.Node.IsSiblingToMe (TChild.List, TypeInfo)) {
// Select
if (message.IsAction (TInternalMessageAction.Select)) {
// material
if (message.Support.Argument.Args.Param1 is TActionComponent component) {
Model.MaterialItemChanged (component);
}
TDispatcher.Invoke (RefreshAllDispatcher);
}
// PropertySelect
if (message.IsAction (TInternalMessageAction.PropertySelect)) {
if (message.Support.Argument.Args.PropertyName.Equals ("edit", StringComparison.InvariantCulture)) {
if (message.Support.Argument.Args.Param1 is TActionComponent component) {
TDispatcher.BeginInvoke (EditDispatcher, component);
}
}
}
// Request
if (message.IsAction (TInternalMessageAction.Request)) {
TDispatcher.BeginInvoke (RequestDesignDispatcher, TEntityAction.Request (message.Support.Argument.Types.EntityAction));
}
// Cleanup
if (message.IsAction (TInternalMessageAction.Cleanup)) {
Model.Cleanup ();
TDispatcher.Invoke (RefreshAllDispatcher);
TDispatcher.Invoke (RequestDataDispatcher);
}
}
}
}
}
internal void PublishInternalMessageHandler (TMessageInternal message)
{
PublishInvoke (message);
}
