///--------------------------------------------------------------------------------
/// <summary>This method deletes an instance of Entity.</summary>
///
/// <param name="entity">The Entity to delete.</param>
///--------------------------------------------------------------------------------
public void DeleteEntity(Entity entity)
{
bool isItemMatch = false;
foreach (EntityViewModel item in Entities.ToList <EntityViewModel>())
{
if (item.Entity.EntityID == entity.EntityID)
{
// remove item from tabs, if present
WorkspaceEventArgs message = new WorkspaceEventArgs();
message.ItemID = item.Entity.EntityID;
Mediator.NotifyColleagues <WorkspaceEventArgs>(MediatorMessages.Command_CloseItemRequested, message);
// delete Entity
isItemMatch = true;
Entities.Remove(item);
Feature.EntityList.Remove(item.Entity);
Solution.EntityList.Remove(item.Entity);
Items.Remove(item);
Feature.ResetModified(true);
OnUpdated(this, null);
break;
}
}
if (isItemMatch == false)
{
ShowIssue(DisplayValues.Issue_DeleteItemNotFound);
}
}
///--------------------------------------------------------------------------------
/// <summary>This method applies xml specification source deletes.</summary>
///--------------------------------------------------------------------------------
public void ProcessDeleteXmlSourcePerformed(XmlSourceEventArgs data)
{
bool isItemMatch = false;
if (data != null && data.XmlSource != null)
{
foreach (XmlSourceViewModel item in XmlSources.ToList <XmlSourceViewModel>())
{
if (item.XmlSource.SpecificationSourceID == data.XmlSource.SpecificationSourceID)
{
// remove item from tabs, if present
WorkspaceEventArgs message = new WorkspaceEventArgs();
message.ItemID = item.XmlSource.SpecificationSourceID;
Mediator.NotifyColleagues <WorkspaceEventArgs>(MediatorMessages.Command_CloseItemRequested, message);
// delete item
isItemMatch = true;
XmlSources.Remove(item);
Solution.XmlSourceList.Remove(item.XmlSource);
Items.Remove(item);
Solution.ResetModified(true);
OnUpdated(this, null);
break;
}
}
if (isItemMatch == false)
{
ShowIssue(DisplayValues.Issue_DeleteItemNotFound);
}
}
}
private void ModalWorkspaceSmartPartClosedEventHandler(object sender, WorkspaceEventArgs e)
{
if (modalWorkspace.SmartParts.Count == 0)
{
modalGrid.Visibility = Visibility.Hidden;
}
}
void parentWorkspace_SmartPartActivated(object sender, WorkspaceEventArgs e)
{
if ((e.SmartPart == customerSummaryView) && (this.Status == WorkItemStatus.Inactive))
{
this.Activate();
}
}
private void DialogWorkspaceSmartPartActivatedEventHandler(object sender, WorkspaceEventArgs e)
{
ISmartPartInfo info = GetDialogSmartPartInfo();
if (!dialogList.Contains(e.SmartPart))
{
dialogList.Add(e.SmartPart);
breadCrumb.AddDirectory(info.Title, e.SmartPart);
if (dialogList.Count > 1)
{
BreadCrumbItem item = breadCrumb.Items[breadCrumb.Items.Count - 2] as BreadCrumbItem;
FrameworkElement element = dialogList[dialogList.Count - 2] as FrameworkElement;
if (Presenter.GetDialogType(dialogList[dialogList.Count - 1]) != DialogType.Create)
{
AppendHeaderInfo(item, element);
}
}
if (typeof(IImportEnabledView).IsAssignableFrom(e.SmartPart.GetType()))
{
IImportEnabledView view = (IImportEnabledView)e.SmartPart;
view.ShowImportView += new EventHandler <ShowImportViewArgs>(view_ShowImportView);
}
}
else
{
BreadCrumbItem item = breadCrumb.Items[breadCrumb.Items.Count - 1] as BreadCrumbItem;
item.Header = info.Title;
}
}
/// <summary>
/// Raises the <see cref="SmartPartActivated"/> event.
/// </summary>
protected virtual void OnSmartPartActivated(WorkspaceEventArgs e)
{
if (SmartPartActivated != null)
{
SmartPartActivated(this, e);
}
}
///--------------------------------------------------------------------------------
/// <summary>This method removes a template from the view models (and tree and designer).</summary>
///
/// <param name="templateID">The ID of the template to remove.</param>
///--------------------------------------------------------------------------------
public SpecTemplateViewModel RemoveTemplate(Guid templateID, bool removeFromTabs = true)
{
foreach (SpecTemplateViewModel template in Items.OfType <SpecTemplateViewModel>())
{
if (template.SpecTemplate.TemplateID == templateID)
{
if (removeFromTabs == true)
{
// remove item from tabs, if present
WorkspaceEventArgs message = new WorkspaceEventArgs();
message.ItemID = templateID;
Mediator.NotifyColleagues <WorkspaceEventArgs>(MediatorMessages.Command_CloseItemRequested, message);
}
// remove item from Items and tree
Items.Remove(template);
template.Updated -= Children_Updated;
return(template);
}
}
foreach (SpecTemplatesViewModel folder in Items.OfType <SpecTemplatesViewModel>())
{
SpecTemplateViewModel template = folder.RemoveTemplate(templateID, removeFromTabs);
if (template != null)
{
if (folder.TemplateModelNode != ModelContextTypeCode.Solution.ToString() && folder.Items.Count == 0)
{
Items.Remove(folder);
folder.Updated -= Children_Updated;
}
return(template);
}
}
return(null);
}
public void RaiseSmartPartClosed(WorkspaceEventArgs e)
{
if (SmartPartClosed != null)
{
SmartPartClosed(this, e);
}
}
///--------------------------------------------------------------------------------
/// <summary>This method deletes an instance of PropertyInstance.</summary>
///
/// <param name="propertyInstance">The PropertyInstance to delete.</param>
///--------------------------------------------------------------------------------
public void DeletePropertyInstance(PropertyInstance propertyInstance)
{
bool isItemMatch = false;
foreach (PropertyInstanceViewModel item in PropertyInstances.ToList <PropertyInstanceViewModel>())
{
if (item.PropertyInstance.PropertyInstanceID == propertyInstance.PropertyInstanceID)
{
// remove item from tabs, if present
WorkspaceEventArgs message = new WorkspaceEventArgs();
message.ItemID = item.PropertyInstance.PropertyInstanceID;
Mediator.NotifyColleagues <WorkspaceEventArgs>(MediatorMessages.Command_CloseItemRequested, message);
// delete PropertyInstance
isItemMatch = true;
PropertyInstances.Remove(item);
ObjectInstance.PropertyInstanceList.Remove(item.PropertyInstance);
Solution.PropertyInstanceList.Remove(item.PropertyInstance);
Items.Remove(item);
ObjectInstance.ResetModified(true);
OnUpdated(this, null);
break;
}
}
if (isItemMatch == false)
{
ShowIssue(DisplayValues.Issue_DeleteItemNotFound);
}
}
// Задать выбранную зону как активную рабочую зону.
private void View_InvokeSetActiveWorkspace(object sender, WorkspaceEventArgs e)
{
if (view.IsEditWorkspaceMode)
{
return;
}
try
{
var workspace = workspaceManager.RobotWorkspaces[e.Index];
var action = new Action(() =>
{
workspaceManager.ActiveWorkspace = workspace;
messageService.ShowMessage(string.Format("Рабочая зона «{0}» установлена в качестве активной", workspace.Name));
});
if (workspaceManager.IsRobotInWorkspace(workspace))
{
action();
return;
}
if (messageService.ShowExclamation("Робот находится вне выбранной рабочей зоны. Переместить плечи робота в рабочую зону ?") == UserResponse.OK)
{
movement.MoveRobotByPath(workspaceManager.GetLeversPositionToWorkspaceRange(workspace), action);
}
}
catch (Exception ex)
{
messageService.ShowError(ex.Message);
}
}
public void RaiseSmartPartActivated(WorkspaceEventArgs e)
{
RaiseSmartPartActivatedCalls++;
if (SmartPartActivated != null)
{
SmartPartActivated(this, e);
}
}
private void OnSmartPartClosed(object sender, WorkspaceEventArgs e)
{
Control control = (Control)e.SmartPart;
control.Dispose();
control = null;
this.Shell.PerformLayout();
}
private void DockPanelWorkspaceSmartPartActivated(object sender, WorkspaceEventArgs e)
{
// Workaround to activate the WorkItem (Only necessary for Windows Forms Controls)
if (dockPanelWorkspace.ActiveSmartPart is Control)
{
((Control)dockPanelWorkspace.ActiveSmartPart).Focus();
}
}
private void WindowFormActivated(object sender, WorkspaceEventArgs e)
{
if (fireActivatedFromForm)
{
RaiseSmartPartActivated(e.SmartPart);
SetActiveSmartPart(e.SmartPart);
}
}
// Отменить изменения.
private void View_InvokeCloseEditWorkspaceMode(object sender, WorkspaceEventArgs e)
{
view.SetEditWorkspaceMode(false, null, MovableValueTypes.None);
view.SetWorkspaces(workspaceManager.RobotWorkspaces, editingWorkspaceIndex);
editingWorkspace = null;
editingWorkspaceIndex = -1;
return;
}
///--------------------------------------------------------------------------------
/// <summary>This method requests the tree view to show the item.</summary>
///
/// <param name="itemToShow">The item to.</param>
///--------------------------------------------------------------------------------
public void ShowItemInTreeView(IWorkspaceViewModel itemToShow, bool needsFocus = true)
{
WorkspaceEventArgs message = new WorkspaceEventArgs();
message.ItemID = itemToShow.ItemID;
message.Workspace = itemToShow;
message.NeedsFocus = needsFocus;
Mediator.NotifyColleagues <WorkspaceEventArgs>(MediatorMessages.Command_ShowItemRequested, message);
}
public void TestWorkspaceEventArgs()
{
//Arrange/Act
//It will execute the constructor and internally the Set for Workspace property
var args = new WorkspaceEventArgs(CurrentDynamoModel.CurrentWorkspace);
//Assert
//This will execute the Get method for Workspace property
Assert.IsNotNull(args.Workspace);
}
protected WorkspaceEventArgs <Workspace> RaiseWorkspaceEvent(EventHandler <WorkspaceEventArgs <Workspace> > eventHandler, Workspace workspace)
{
var e = new WorkspaceEventArgs <Workspace>(workspace);
if (eventHandler != null)
{
eventHandler(this, e);
}
return(e);
}
private void View_InvokeCreateScript(object sender, WorkspaceEventArgs e)
{
view.SetScriptCreatingMode(true);
scriptBuilder = new ScriptBuilder(movement, e.Name);
scriptBuilder.OnPathChanged += ScriptBuilder_OnPathChanged;
scriptBuilder.OnNewStartPoint += ScriptBuilder_OnNewStartPoint;
scriptBuilder.OnNewEndPoint += ScriptBuilder_OnNewEndPoint;
scriptBuilder.SetCurrentPositionAsStart();
}
private void OnSmartPartActivated(object sender, WorkspaceEventArgs e)
{
Control control = (Control)e.SmartPart;
if (control != null)
{
control = control.FindForm();
Shell.ErrorListControl.CurrentOwner = control;
Shell.ErrorListControl.FilterAll(control);
}
}
/// <summary>
/// 此处修复了Window Workspace视图关闭后再次打开出错的问题
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void WindowFormClosed(object sender, WorkspaceEventArgs e)
{
Form form = windows[(Control)e.SmartPart];
if (form != null)
{
form.Controls.Remove((Control)e.SmartPart);
}
windows.Remove((Control)e.SmartPart);
InnerSmartParts.Remove((Control)e.SmartPart);
}
// This is the event handler for when a workspace is removed from the
// WorkspaceManager. Not to be confused with OnWorkspaceClosed.
private void OnWorkspaceRemoved(object sender, WorkspaceEventArgs e)
{
try
{
RemoveWorkspace(e.Workspace);
}
catch (Exception ex)
{
Platform.Log(ex);
}
}
/// <summary>
/// Raises the <see cref="SmartPartActivated"/> event.
/// </summary>
/// <param name="smartPart">The smart part that was activated.</param>
protected void RaiseSmartPartActivated(object smartPart)
{
if (this.SmartPartActivated != null)
{
if (smartPart is ElementHost)
{
smartPart = elementHosts.Unwrap((ElementHost)smartPart);
}
WorkspaceEventArgs args = new WorkspaceEventArgs(smartPart);
this.SmartPartActivated(this, args);
}
}
private void OnWorkspaceActivated(object sender, WorkspaceEventArgs e)
{
try
{
BuildMenusAndToolBars(e.Workspace);
UpdateToolViews(e.Workspace);
}
catch (Exception ex)
{
Platform.Log(ex);
}
}
///--------------------------------------------------------------------------------
/// <summary>This method applies relationship deletes.</summary>
///--------------------------------------------------------------------------------
public void ProcessDeleteRelationshipPerformed(RelationshipEventArgs data)
{
try
{
bool isItemMatch = false;
if (data != null && data.Relationship != null)
{
foreach (RelationshipViewModel item in Relationships.ToList <RelationshipViewModel>())
{
if (item.Relationship.RelationshipID == data.Relationship.RelationshipID)
{
// remove item from tabs, if present
WorkspaceEventArgs message = new WorkspaceEventArgs();
message.ItemID = item.Relationship.RelationshipID;
Mediator.NotifyColleagues <WorkspaceEventArgs>(MediatorMessages.Command_CloseItemRequested, message);
// delete children
for (int i = item.Items.Count - 1; i >= 0; i--)
{
if (item.Items[i] is RelationshipPropertyViewModel)
{
RelationshipPropertyViewModel child = item.Items[i] as RelationshipPropertyViewModel;
RelationshipPropertyEventArgs childMessage = new RelationshipPropertyEventArgs();
childMessage.RelationshipProperty = child.RelationshipProperty;
childMessage.RelationshipID = item.Relationship.RelationshipID;
childMessage.Solution = Solution;
childMessage.WorkspaceID = child.WorkspaceID;
item.ProcessDeleteRelationshipPropertyPerformed(childMessage);
}
}
// delete item
isItemMatch = true;
Relationships.Remove(item);
Entity.RelationshipList.Remove(item.Relationship);
Items.Remove(item);
Entity.ResetModified(true);
OnUpdated(this, null);
break;
}
}
if (isItemMatch == false)
{
ShowIssue(DisplayValues.Issue_DeleteItemNotFound);
}
}
}
catch (Exception ex)
{
ShowIssue(ex.Message + ex.StackTrace);
}
}
///--------------------------------------------------------------------------------
/// <summary>This method applies method deletes.</summary>
///--------------------------------------------------------------------------------
public void ProcessDeleteMethodPerformed(MethodEventArgs data)
{
try
{
bool isItemMatch = false;
if (data != null && data.Method != null)
{
foreach (MethodViewModel item in Methods.ToList <MethodViewModel>())
{
if (item.Method.MethodID == data.Method.MethodID)
{
// remove item from tabs, if present
WorkspaceEventArgs message = new WorkspaceEventArgs();
message.ItemID = item.Method.MethodID;
Mediator.NotifyColleagues <WorkspaceEventArgs>(MediatorMessages.Command_CloseItemRequested, message);
// delete children
for (int i = item.Items.Count - 1; i >= 0; i--)
{
if (item.Items[i] is ParameterViewModel)
{
ParameterViewModel child = item.Items[i] as ParameterViewModel;
ParameterEventArgs childMessage = new ParameterEventArgs();
childMessage.Parameter = child.Parameter;
childMessage.MethodID = item.Method.MethodID;
childMessage.Solution = Solution;
childMessage.WorkspaceID = child.WorkspaceID;
item.ProcessDeleteParameterPerformed(childMessage);
}
}
// delete item
isItemMatch = true;
Methods.Remove(item);
Entity.MethodList.Remove(item.Method);
Items.Remove(item);
Entity.ResetModified(true);
OnUpdated(this, null);
break;
}
}
if (isItemMatch == false)
{
ShowIssue(DisplayValues.Issue_DeleteItemNotFound);
}
}
}
catch (Exception ex)
{
ShowIssue(ex.Message + ex.StackTrace);
}
}
///--------------------------------------------------------------------------------
/// <summary>This method applies workflow deletes.</summary>
///--------------------------------------------------------------------------------
public void ProcessDeleteWorkflowPerformed(WorkflowEventArgs data)
{
try
{
bool isItemMatch = false;
if (data != null && data.Workflow != null)
{
foreach (WorkflowViewModel item in Workflows.ToList <WorkflowViewModel>())
{
if (item.Workflow.WorkflowID == data.Workflow.WorkflowID)
{
// remove item from tabs, if present
WorkspaceEventArgs message = new WorkspaceEventArgs();
message.ItemID = item.Workflow.WorkflowID;
Mediator.NotifyColleagues <WorkspaceEventArgs>(MediatorMessages.Command_CloseItemRequested, message);
// delete children
for (int i = item.Items.Count - 1; i >= 0; i--)
{
if (item.Items[i] is StageViewModel)
{
StageViewModel child = item.Items[i] as StageViewModel;
StageEventArgs childMessage = new StageEventArgs();
childMessage.Stage = child.Stage;
childMessage.WorkflowID = item.Workflow.WorkflowID;
childMessage.Solution = Solution;
childMessage.WorkspaceID = child.WorkspaceID;
item.ProcessDeleteStagePerformed(childMessage);
}
}
// delete item
isItemMatch = true;
Workflows.Remove(item);
Solution.WorkflowList.Remove(item.Workflow);
Items.Remove(item);
Solution.ResetModified(true);
OnUpdated(this, null);
break;
}
}
if (isItemMatch == false)
{
ShowIssue(DisplayValues.Issue_DeleteItemNotFound);
}
}
}
catch (Exception ex)
{
ShowIssue(ex.Message + ex.StackTrace);
}
}
/// <summary>
/// 数据列表激活事件
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="Microsoft.Practices.CompositeUI.SmartParts.WorkspaceEventArgs"/> instance containing the event data.</param>
private void DataList_SmartPartActivated(object sender, WorkspaceEventArgs e)
{
if (!smartParts.Contains(e.SmartPart))
{
AuthorizationAttribute[] attrs = (AuthorizationAttribute[])e.SmartPart.GetType().GetCustomAttributes(typeof(AuthorizationAttribute), true);
if (attrs.Length > 0)
{
try {
ResotreLayout((Control)e.SmartPart, attrs[0]);
}
catch { }
}
smartParts.Add(e.SmartPart);
}
}
void ModuleController_SmartPartActivated(object sender, WorkspaceEventArgs e)
{
log.Debug("PartModelingManager.ModuleController.ModuleController_SmartPartActivated");
if (WorkItem.Items.ContainsObject(e.SmartPart))
{
log.Debug("Module got focus");
ModuleGotFocus();
_layout = e.SmartPart;
}
else
{
log.Debug("Module lost focus");
ModuleLostFocus();
}
}
// Сохранить изменения.
private void View_InvokeSaveWorkspaceValues(object sender, WorkspaceEventArgs e)
{
if (!view.IsEditWorkspaceMode || editingWorkspace == null)
{
return;
}
try
{
var errors = editingWorkspace.GetDesignParametersExceptions(this.parameters);
if (editingWorkspaceIndex == 0)
{
this.movement.DesignParameters.Lever1.ABzero = editingWorkspace.Lever1.ABzero;
this.movement.DesignParameters.Lever2.ABzero = editingWorkspace.Lever2.ABzero;
this.movement.DesignParameters.HorizontalLever.ABzero = editingWorkspace.HorizontalLever.ABzero;
UpdateDesignParameters(this.movement.DesignParameters);
}
if (errors.Count() == 0)
{
view.SetEditWorkspaceMode(false, null, MovableValueTypes.None);
workspaceManager.SetWorkspace(editingWorkspaceIndex, editingWorkspace);
view.SetWorkspaces(workspaceManager.RobotWorkspaces, editingWorkspaceIndex);
editingWorkspace = null;
editingWorkspaceIndex = -1;
return;
}
string errorMessage = "Рабочая зона не сохранена. Ошибки:";
foreach (var error in errors)
{
errorMessage += string.Format("\n\n{0} : {1}", (error.Key), error.Value.Message);
}
throw new Exception(errorMessage);
}
catch (Exception ex)
{
messageService.ShowError(ex.Message);
}
}
private void VersionControlServerOnPendingChangesChanged(object sender, WorkspaceEventArgs workspaceEventArgs)
{
this.Logger().Debug("VersionControlServerOnPendingChangesChanged");
RefreshPendingChanges();
}
private void OnWorkspaceActivated(object sender, WorkspaceEventArgs e)
{
try
{
BuildMenusAndToolBars(e.Workspace);
UpdateToolViews(e.Workspace);
}
catch (Exception ex)
{
Platform.Log(ex);
}
}
// This is the event handler for when a workspace is removed from the
// WorkspaceManager. Not to be confused with OnWorkspaceClosed.
private void OnWorkspaceRemoved(object sender, WorkspaceEventArgs e)
{
try
{
RemoveWorkspace(e.Workspace);
}
catch (Exception ex)
{
Platform.Log(ex);
}
}
protected WorkspaceEventArgs<Workspace> RaiseWorkspaceEvent(EventHandler<WorkspaceEventArgs<Workspace>> eventHandler, Workspace workspace)
{
var e = new WorkspaceEventArgs<Workspace>(workspace);
if (eventHandler != null)
{
eventHandler(this, e);
}
return e;
}
private void RefreshWorkspaces(object sender, WorkspaceEventArgs e)
{
var tfs = Context.TeamProjectCollection;
var versionControl = tfs.GetService<VersionControlServer>();
Workspaces = new ObservableCollection<Workspace>(versionControl.QueryWorkspaces(null, tfs.AuthorizedIdentity.UniqueName, Environment.MachineName));
if (Workspaces.Count > 0)
{
Workspace = Workspaces[0];
ShowWorkspaceChooser = Workspaces.Count > 1;
}
else
{
Workspace = null;
}
Refresh();
}
private void VersionControlServerOnPendingChangesChanged(object sender, WorkspaceEventArgs workspaceEventArgs)
{
this.Logger().Debug("VersionControlServerOnPendingChangesChanged");
Application.Current.Dispatcher.Invoke(DispatcherPriority.Normal, (Action)RefreshPendingChanges);
}
