public override void OnEnable(ToolContext context)
{
Desk.WireToolRenderer.SetActive(true);
wireRenderer = Desk.WireToolRenderer.GetComponent <LineRenderer>();
Debug.Assert(wireRenderer != null);
wireRenderer.positionCount = 2;
}
public static void Initialize(ToolContext toolContext)
{
if (toolContext.Stocks.Any())
{
return;
}
var stocks = new List <StockModel>
{
new StockModel()
{
Id = Guid.NewGuid().ToString(),
Name = "Tool Stock N3",
Department = toolContext.Departments.First(d => d.Name == "The workshop N3")
},
new StockModel()
{
Id = Guid.NewGuid().ToString(),
Name = "Tool Stock N6",
Department = toolContext.Departments.First(d => d.Name == "The workshop N6")
},
new StockModel()
{
Id = Guid.NewGuid().ToString(),
Name = "Tool Stock N4",
Department = toolContext.Departments.First(t => t.Name == "The workshop N4")
}
};
toolContext.Stocks.AddRange(stocks);
toolContext.SaveChanges();
}
public ToolPane(DesignerContext designerContext, ToolContext toolContext)
{
this.InitializeComponent();
this.toolManager = designerContext.ToolManager;
this.designerContext = designerContext;
this.toolManager.ActiveToolChanged += new ToolEventHandler(this.ToolManager_ActiveToolChanged);
this.toolManager.ToolAdded += new ToolEventHandler(this.ToolManager_ToolAdded);
this.toolManager.ToolRemoved += new ToolEventHandler(this.ToolManager_ToolRemoved);
this.designerContext.SelectionManager.LateActiveSceneUpdatePhase += new SceneUpdatePhaseEventHandler(this.SelectionManager_LateActiveSceneUpdatePhase);
this.AddToolGroupButton(ToolCategory.Selection);
this.AddToolGroupButton(ToolCategory.Subselection);
this.AddToolSeparator();
this.AddToolGroupButton(ToolCategory.Pan);
this.AddToolGroupButton(ToolCategory.Zoom);
this.AddToolGroupButton(ToolCategory.ThreeD);
this.AddToolSeparator();
this.AddToolGroupButton(ToolCategory.Eyedropper);
this.AddToolGroupButton(ToolCategory.PaintBucket);
this.AddToolGroupButton(ToolCategory.BrushTransform);
this.AddToolSeparator();
this.AddToolGroupButton(ToolCategory.Drawing);
this.AddToolGroupButton(ToolCategory.ShapePrimitives);
this.AddToolGroupButton(ToolCategory.LayoutPanels);
this.AddToolGroupButton(ToolCategory.Text);
this.AddToolGroupButton(ToolCategory.CommonControls);
this.CreateAssetToolGroup();
this.CreateAssetPopupAndButton(designerContext, toolContext);
this.AddToolGroupButton(ToolCategory.Asset);
foreach (Tool tool in this.toolManager.Tools)
{
this.Add(tool);
}
this.IsEnabled = false;
}
public SubselectionTool(ToolContext toolContext)
: base(toolContext)
{
if (SubselectionTool.SubselectionAdornerSetCreators == null)
{
SubselectionTool.SubselectionAdornerSetCreators = (ICollection <IAdornerSetCreator>)Array.AsReadOnly <IAdornerSetCreator>(new IAdornerSetCreator[5]
{
(IAdornerSetCreator) new PathAdornerSetCreator(this.PathEditorTargetMap, PathEditMode.MotionPath),
(IAdornerSetCreator) new PathAdornerSetCreator(this.PathEditorTargetMap, PathEditMode.ScenePath),
(IAdornerSetCreator) new PathAdornerSetCreator(this.PathEditorTargetMap, PathEditMode.ClippingPath),
(IAdornerSetCreator) new RectangleGeometryMoveAdornerSetCreator(),
(IAdornerSetCreator) new RectangleGeometryScaleAdornerSetCreator()
});
}
if (SubselectionTool.SubselectionAdornerSetCreators3D != null)
{
return;
}
SubselectionTool.SubselectionAdornerSetCreators3D = (ICollection <IAdornerSetCreator>)Array.AsReadOnly <IAdornerSetCreator>(new IAdornerSetCreator[3]
{
(IAdornerSetCreator) new RotateAdornerSetCreator3D(),
(IAdornerSetCreator) new ScaleAdornerSetCreator3D(),
(IAdornerSetCreator) new TranslateAdornerSetCreator3D()
});
}
public static void Initialize(ToolContext toolContext)
{
if (toolContext.Users.Any(u => u.UserName == "*****@*****.**"))
{
return;
}
var admin = new UserModel {
Email = "*****@*****.**", UserName = "******"
};
var password = "******";
var adminUserInfo = new UserInfoModel
{
User = admin,
Name = "Admin",
Surname = "Admin",
Email = admin.Email,
Phone = "+375336340232"
};
var uManager = new UserManager <UserModel>(new UserStore <UserModel>(toolContext));
var result = uManager.Create(admin, password);
toolContext.UserInfos.Add(adminUserInfo);
// if the user creation was successful
if (result.Succeeded)
{
// create role for default admin
uManager.AddToRole(admin.Id, toolContext.Roles.FirstOrDefault(r => r.Name == "Admin")?.Name);
}
}
public static void Initialize(ToolContext toolContext)
{
if (toolContext.Departments.Any())
{
return;
}
var departments = new List <DepartmentModel>
{
new DepartmentModel {
Id = Guid.NewGuid().ToString(), Name = "The tool-die management"
},
new DepartmentModel {
Id = Guid.NewGuid().ToString(), Name = "The experimental workshop"
},
new DepartmentModel {
Id = Guid.NewGuid().ToString(), Name = "The flexible manufacturing systems workshop"
},
new DepartmentModel {
Id = Guid.NewGuid().ToString(), Name = "The workshop N3"
},
new DepartmentModel {
Id = Guid.NewGuid().ToString(), Name = "The workshop N6"
},
new DepartmentModel {
Id = Guid.NewGuid().ToString(), Name = "The workshop N4"
}
};
toolContext.Departments.AddRange(departments);
toolContext.SaveChanges();
}
public static void Initialize(ToolContext toolContext)
{
if (toolContext.Roles.Any())
{
return;
}
var roles = new List <RoleModel>
{
new RoleModel()
{
Name = "Admin"
},
new RoleModel()
{
Name = "Stock keeper"
},
new RoleModel()
{
Name = "User"
}
};
foreach (var role in roles)
{
toolContext.Roles.Add(role);
}
toolContext.SaveChanges();
}
public AssetMruList(DesignerContext designerContext, ToolContext toolContext)
{
this.designerContext = designerContext;
this.toolContext = toolContext;
this.assetLibrary = (AssetLibrary)this.designerContext.AssetLibrary;
this.assetLibrary.AssetLibraryChanged += new Action <AssetLibraryDamages>(this.OnAssetLibraryChanged);
this.designerContext.SelectionManager.LateActiveSceneUpdatePhase += new SceneUpdatePhaseEventHandler(this.SelectionManager_LateActiveSceneUpdatePhase);
}
public static void Initialize(ToolContext toolContext)
{
if (toolContext.Roles.First(r => r.Name == "Stock keeper").Users.Any())
{
return;
}
var keeper3 = new UserModel
{
Email = "*****@*****.**",
UserName = "******",
Department = toolContext.Departments.First(d => d.Name == "The workshop N3"),
Stock = toolContext.Stocks.First(s => s.Name == "Tool Stock N3")
};
var keeper6 = new UserModel
{
Email = "*****@*****.**",
UserName = "******",
Department = toolContext.Departments.First(d => d.Name == "The workshop N6"),
Stock = toolContext.Stocks.First(s => s.Name == "Tool Stock N6")
};
var keeperUserInfo3 = new UserInfoModel
{
User = keeper3,
Name = "keeper3",
Surname = "keeper3",
Email = keeper3.Email,
Phone = "33-33"
};
var keeperUserInfo6 = new UserInfoModel
{
User = keeper6,
Name = "keeper6",
Surname = "keeper6",
Email = keeper6.Email,
Phone = "66-66"
};
var uManager = new UserManager <UserModel>(new UserStore <UserModel>(toolContext));
var result3 = uManager.Create(keeper3, "Keeper3");
var result6 = uManager.Create(keeper6, "Keeper6");
toolContext.UserInfos.Add(keeperUserInfo3);
toolContext.UserInfos.Add(keeperUserInfo6);
if (result3.Succeeded)
{
// create role for default admin
uManager.AddToRole(keeper3.Id, toolContext.Roles.FirstOrDefault(r => r.Name == "Stock keeper")?.Name);
}
if (result6.Succeeded)
{
// create role for default admin
uManager.AddToRole(keeper6.Id, toolContext.Roles.FirstOrDefault(r => r.Name == "Stock keeper")?.Name);
}
}
internal AssetPane(DesignerContext designerContext, ToolContext toolContext)
{
this.designerContext = designerContext;
this.toolContext = toolContext;
this.DataContext = (object)designerContext.AssetLibrary;
this.InitializeComponent();
this.AssetView.AssetSingleClicked += new EventHandler <AssetEventArgs>(this.AssetView_AssetSingleClicked);
this.AssetView.AssetDoubleClicked += new EventHandler <AssetEventArgs>(this.AssetView_AssetDoubleClicked);
this.AssetView.SelectedAssetChanged += new EventHandler <AssetEventArgs>(this.AssetView_SelectedAssetChanged);
}
public static void Save()
{
JsonSerializer.ToJsonFile(DocumentPath, ToolContext.DocumentContainer);
JsonSerializer.ToJsonFile(EditorPath, ToolContext);
JsonSerializer.ToJsonFile(WindowPath, WindowSettings);
WindowSettings = null;
ToolContext.Dispose();
ToolContext = null;
StyleLibrary = null;
GroupLibrary = null;
ContainerFactory = null;
}
public override void OnUpdate(ToolContext context)
{
bool processed = false;
int hitCount = Physics2D.OverlapPointNonAlloc(context.mousePosWorld, raycastBuffer);
for (int i = 0; i < hitCount; i++)
{
Collider2D hit = raycastBuffer[i];
if (hit.gameObject.layer == (int)DeskLayer.Pin)
{
Pin pin = hit.gameObject.GetComponent <Pin>();
Debug.Assert(pin != null);
if (Input.GetKeyDown(KeyCode.Mouse0))
{
var wireTool = context.manager.GetTool(2) as ToolWire;
Debug.Assert(wireTool != null);
wireTool.SetInitialPin(pin);
context.manager.EnableTool(2);
}
processed = true;
break;
}
}
if (processed)
{
return;
}
for (int i = 0; i < hitCount; i++)
{
Collider2D hit = raycastBuffer[i];
if (hit.gameObject.layer == (int)DeskLayer.Part)
{
Part part = hit.gameObject.GetComponentInParent <Part>();
Debug.Assert(part != null);
if (Input.GetKeyDown(KeyCode.Mouse0))
{
part.OnClick();
}
processed = true;
break;
}
}
}
public override void OnPrimaryButtonDown(ToolContext context)
{
Pin pin = Desk.GetPinUnderCursor();
if (pin != null)
{
Wire wire = Wire.CreateWire(pin, initialPin);
if (wire)
{
context.manager.EnableTool(0);
}
}
}
public PenTool(ToolContext toolContext)
: base(toolContext)
{
if (PenTool.PenAdornerSetCreators != null)
{
return;
}
PenTool.PenAdornerSetCreators = (ICollection <IAdornerSetCreator>)Array.AsReadOnly <IAdornerSetCreator>(new IAdornerSetCreator[3]
{
(IAdornerSetCreator) new PenAdornerSetCreator(this.PathEditorTargetMap, PathEditMode.ScenePath),
(IAdornerSetCreator) new PenAdornerSetCreator(this.PathEditorTargetMap, PathEditMode.MotionPath),
(IAdornerSetCreator) new PenAdornerSetCreator(this.PathEditorTargetMap, PathEditMode.ClippingPath)
});
}
public BrushTransformTool(ToolContext toolContext)
: base(toolContext)
{
if (BrushTransformTool.BrushTransformAdornerSetCreators != null)
{
return;
}
BrushTransformTool.BrushTransformAdornerSetCreators = (ICollection <IAdornerSetCreator>)Array.AsReadOnly <IAdornerSetCreator>(new IAdornerSetCreator[4]
{
(IAdornerSetCreator) new BrushTranslateAdornerSetCreator(),
(IAdornerSetCreator) new BrushSkewAdornerSetCreator(),
(IAdornerSetCreator) new BrushRotateAdornerSetCreator(),
(IAdornerSetCreator) new BrushScaleAdornerSetCreator()
});
}
public ScriptCheckFrm(IEnvironment env)
{
InitializeComponent();
Icon = Resource.Package_32;
if(context == null) {
context = new ToolContext(env);
}
else {
updateVariableList();
}
initEditor();
fillComponents();
}
public ChatViewModel(TwitchService twitchService,
TwitchSettings twitchSettings,
IPhoneticMatch phonetic,
ToolContext context,
OverrustlelogsService overrustlelogsService)
{
Messages = new ObservableCollection <TwitchMessage>();
_twitchService = twitchService;
TwitchSettings = twitchSettings;
_phonetic = phonetic;
_context = context;
_overrustlelogsService = overrustlelogsService;
_twitchService.Client.OnMessageReceived += Client_OnMessageReceived;
_whitelistedWords = _context.WhitelistWords.ToList();
_whitelistedUsers = _context.WhitelistUsers.ToList();
}
public GradientBrushTool(ToolContext toolContext)
: base(toolContext)
{
if (GradientBrushTool.BrushTransformAdornerSetCreators != null)
{
return;
}
GradientBrushTool.BrushTransformAdornerSetCreators = (ICollection <IAdornerSetCreator>)Array.AsReadOnly <IAdornerSetCreator>(new IAdornerSetCreator[6]
{
(IAdornerSetCreator) new BrushTranslateAdornerSetCreator(),
(IAdornerSetCreator) new RadialRotateAdornerSetCreator(),
(IAdornerSetCreator) new RadialScaleAdornerSetCreator(),
(IAdornerSetCreator) new LinearGradientAdornerSetCreator(),
(IAdornerSetCreator) new RadialGradientAdornerSetCreator(),
(IAdornerSetCreator) new GradientStopAdornerSetCreator()
});
}
public ScriptCheckFrm(IEnvironment env)
{
InitializeComponent();
Icon = Resource.Package_32;
if (context == null)
{
context = new ToolContext(env);
}
else
{
updateVariableList();
}
initEditor();
fillComponents();
}
public ToolbarVm(IImageVm imageVm)
{
Should.NotBeNull(imageVm, nameof(imageVm));
SelectToolCommand = new RelayCommand <ITool>(SelectTool);
var toolContext = new ToolContext(imageVm);
PanTool = new PaintbrushTool(toolContext);
ZoomTool = new PaintbrushTool(toolContext);
PaintbrushTool = new PaintbrushTool(toolContext);
Tools = new[]
{
PanTool,
ZoomTool,
PaintbrushTool
};
SelectedTool = Tools[0];
imageVm.MouseUp += (sender, args) =>
{
foreach (var tool in Tools)
{
tool.ProcessMouseUp(args);
}
};
imageVm.MouseDown += (sender, args) =>
{
foreach (var tool in Tools)
{
tool.ProcessMouseDown(args);
}
};
imageVm.MouseMove += (sender, args) =>
{
foreach (var tool in Tools)
{
tool.ProcessMouseMove(args);
}
};
}
public static void Save()
{
#if USE_SAVE_STYLES
JsonSerializer.ToJsonFile(StylesPath, ToolContext.StyleLibrary);
#endif
#if USE_SAVE_GROUPS
JsonSerializer.ToJsonFile(GroupsPath, ToolContext.GroupLibrary);
#endif
#if USE_SAVE_EDITOR
JsonSerializer.ToJsonFile(EditorPath, ToolContext);
#endif
#if USE_SAVE_WINDOW
JsonSerializer.ToJsonFile(WindowPath, WindowSettings);
#endif
WindowSettings = null;
ToolContext.Dispose();
ToolContext = null;
StyleLibrary = null;
GroupLibrary = null;
ContainerFactory = null;
}
/// <summary>
/// Constructs a <see cref="GalleryComponent"/> with the specified data source, automatically adding the actions of
/// <see cref="GalleryToolExtensionPoint"/>s at the specified action sites.
/// </summary>
/// <param name="dataSource">An <see cref="IBindingList"/> of <see cref="IGalleryItem"/>s.</param>
/// <param name="toolbarSite">The site for toolbar actions.</param>
/// <param name="contextMenuSite">The site for context menu actions.</param>
public GalleryComponent(IBindingList dataSource, string toolbarSite, string contextMenuSite)
{
_dataSource = dataSource;
if (toolbarSite != null || contextMenuSite != null)
{
GalleryToolExtensionPoint xp = new GalleryToolExtensionPoint();
ToolContext context = new ToolContext(this);
ToolSet ts = new ToolSet(xp, context);
if (contextMenuSite != null)
{
_menuModel = ActionModelRoot.CreateModel(typeof(GalleryComponent).FullName, contextMenuSite, ts.Actions);
}
if (toolbarSite != null)
{
_toolbarModel = ActionModelRoot.CreateModel(typeof(GalleryComponent).FullName, toolbarSite, ts.Actions);
}
_toolSet = ts;
}
}
private void CreateAssetPopupAndButton(DesignerContext designerContext, ToolContext toolContext)
{
ToggleButton button = new ToggleButton();
button.Name = "AssetToolMoreButton";
button.ToolTip = (object)StringTable.AssetToolMoreButtonToolTip;
button.SetResourceReference(FrameworkElement.StyleProperty, (object)"MoreButtonStyle");
this.currentToolGroupPanel.Children.Add((UIElement)button);
AssetPopup assetPopup = new AssetPopup(designerContext.AssetLibrary, designerContext.Configuration);
assetPopup.PlacementTarget = (UIElement)button;
button.ClickMode = ClickMode.Press;
button.Checked += (RoutedEventHandler)((s, e) => assetPopup.IsOpen = true);
assetPopup.Closed += (EventHandler)((s, e) => button.IsChecked = new bool?(false));
assetPopup.SetBinding(Popup.PlacementProperty, (BindingBase) new Binding()
{
Source = (object)this.ToolsRoot,
Path = new PropertyPath("Orientation", new object[0]),
Converter = (IValueConverter) new InverseOrientationToPopupPlacementConverter(),
Mode = BindingMode.OneWay
});
ICommandService commandService = this.designerContext.CommandService;
commandService.AddTarget((ICommandTarget) new ToolPane.ToolPaneCommandTarget(commandService, assetPopup));
assetPopup.AssetView.SelectedAssetChanged += (EventHandler <AssetEventArgs>)((s, e) => toolContext.AssetMruList.OnSelectAsset(e.Asset));
assetPopup.AssetView.AssetSingleClicked += (EventHandler <AssetEventArgs>)((s, e) => assetPopup.IsOpen = false);
assetPopup.Closed += (EventHandler)((s, e) =>
{
toolContext.AssetMruList.ActivateAssetTool();
if (designerContext.ActiveView == null)
{
return;
}
designerContext.ActiveView.ReturnFocus();
});
}
public ZoomTool(ToolContext toolContext)
: base(toolContext)
{
}
public UnitOfWork(ToolContext toolContext)
{
_toolContext = toolContext;
}
public PanTool(ToolContext toolContext)
: base(toolContext)
{
}
public override void OnUpdate(ToolContext context)
{
wireRenderer.SetPosition(0, initialPin.transform.position);
wireRenderer.SetPosition(1, context.mousePosWorld);
}
public CRUDDemoModel(ToolContext context)
{
_context = context;
}
public override void OnDisable(ToolContext context)
{
Desk.WireToolRenderer.SetActive(false);
}
public PaintBucketTool(ToolContext toolContext)
: base(toolContext)
{
}
public ToolsController(ToolContext context)
{
_context = context;
}
