private static Color ConnectionColor(Knob outputKnob, Knob inputKnob)
{
return(outputKnob.Color == inputKnob.Color
? outputKnob.Color
: Color.Lerp(inputKnob.Color, outputKnob.Color, 0.5f));
}
// Ctor.
public Joystick()
{
InitializeComponent();
storyboard = Knob.FindResource("CenterKnob") as Storyboard;
}
//CTOR
public Joystick()
{
InitializeComponent();
RectangleSize = 100;
this.Story = Knob.FindResource("CenterKnob") as Storyboard;
}
public void GrabMade(Gesture gesture, Knob knob)
{
latestGrabSide = gesture.hand.Side();
}
// download all required tasks.
// make sure all task's condition inputs are valid.
// build up three list of steps for jobrunner. (pre-job, job, post-job)
public async Task <List <IStep> > InitializeJob(IExecutionContext jobContext, Pipelines.AgentJobRequestMessage message)
{
Trace.Entering();
ArgUtil.NotNull(jobContext, nameof(jobContext));
ArgUtil.NotNull(message, nameof(message));
// create a new timeline record node for 'Initialize job'
IExecutionContext context = jobContext.CreateChild(Guid.NewGuid(), StringUtil.Loc("InitializeJob"), $"{nameof(JobExtension)}_Init");
List <IStep> preJobSteps = new List <IStep>();
List <IStep> jobSteps = new List <IStep>();
List <IStep> postJobSteps = new List <IStep>();
using (var register = jobContext.CancellationToken.Register(() => { context.CancelToken(); }))
{
try
{
context.Start();
context.Section(StringUtil.Loc("StepStarting", StringUtil.Loc("InitializeJob")));
// Set agent version variable.
context.SetVariable(Constants.Variables.Agent.Version, BuildConstants.AgentPackage.Version);
context.Output(StringUtil.Loc("AgentNameLog", context.Variables.Get(Constants.Variables.Agent.Name)));
context.Output(StringUtil.Loc("AgentMachineNameLog", context.Variables.Get(Constants.Variables.Agent.MachineName)));
context.Output(StringUtil.Loc("AgentVersion", BuildConstants.AgentPackage.Version));
string imageVersion = System.Environment.GetEnvironmentVariable(Constants.ImageVersionVariable);
if (imageVersion != null)
{
context.Output(StringUtil.Loc("ImageVersionLog", imageVersion));
}
context.Output(StringUtil.Loc("UserNameLog", System.Environment.UserName));
// Print proxy setting information for better diagnostic experience
var agentWebProxy = HostContext.GetService <IVstsAgentWebProxy>();
if (!string.IsNullOrEmpty(agentWebProxy.ProxyAddress))
{
context.Output(StringUtil.Loc("AgentRunningBehindProxy", agentWebProxy.ProxyAddress));
}
// Give job extension a chance to initialize
Trace.Info($"Run initial step from extension {this.GetType().Name}.");
InitializeJobExtension(context, message.Steps, message.Workspace);
// Download tasks if not already in the cache
Trace.Info("Downloading task definitions.");
var taskManager = HostContext.GetService <ITaskManager>();
await taskManager.DownloadAsync(context, message.Steps);
// Parse all Task conditions.
Trace.Info("Parsing all task's condition inputs.");
var expression = HostContext.GetService <IExpressionManager>();
Dictionary <Guid, IExpressionNode> taskConditionMap = new Dictionary <Guid, IExpressionNode>();
foreach (var task in message.Steps.OfType <Pipelines.TaskStep>())
{
IExpressionNode condition;
if (!string.IsNullOrEmpty(task.Condition))
{
context.Debug($"Task '{task.DisplayName}' has following condition: '{task.Condition}'.");
condition = expression.Parse(context, task.Condition);
}
else
{
condition = ExpressionManager.Succeeded;
}
task.DisplayName = context.Variables.ExpandValue(nameof(task.DisplayName), task.DisplayName);
taskConditionMap[task.Id] = condition;
}
context.Output("Checking job knob settings.");
foreach (var knob in Knob.GetAllKnobsFor <AgentKnobs>())
{
var value = knob.GetValue(jobContext);
if (value.Source.GetType() != typeof(BuiltInDefaultKnobSource))
{
var tag = "";
if (knob.IsDeprecated)
{
tag = "(DEPRECATED)";
}
else if (knob.IsExperimental)
{
tag = "(EXPERIMENTAL)";
}
var outputLine = $" Knob: {knob.Name} = {value.AsString()} Source: {value.Source.GetDisplayString()} {tag}";
if (knob.IsDeprecated)
{
context.Warning(outputLine);
}
else
{
context.Output(outputLine);
}
}
}
context.Output("Finished checking job knob settings.");
if (PlatformUtil.RunningOnWindows)
{
// This is for internal testing and is not publicly supported. This will be removed from the agent at a later time.
var prepareScript = Environment.GetEnvironmentVariable("VSTS_AGENT_INIT_INTERNAL_TEMP_HACK");
ServiceEndpoint systemConnection = context.Endpoints.Single(x => string.Equals(x.Name, WellKnownServiceEndpointNames.SystemVssConnection, StringComparison.OrdinalIgnoreCase));
if (!string.IsNullOrEmpty(prepareScript) && context.StepTarget() is HostInfo)
{
var prepareStep = new ManagementScriptStep(
scriptPath: prepareScript,
condition: ExpressionManager.Succeeded,
displayName: "Agent Initialization");
Trace.Verbose($"Adding agent init script step.");
prepareStep.Initialize(HostContext);
prepareStep.ExecutionContext = jobContext.CreateChild(Guid.NewGuid(), prepareStep.DisplayName, nameof(ManagementScriptStep));
prepareStep.AccessToken = systemConnection.Authorization.Parameters["AccessToken"];
prepareStep.Condition = ExpressionManager.Succeeded;
preJobSteps.Add(prepareStep);
}
}
// build up 3 lists of steps, pre-job, job, post-job
Stack <IStep> postJobStepsBuilder = new Stack <IStep>();
Dictionary <Guid, Variables> taskVariablesMapping = new Dictionary <Guid, Variables>();
if (context.Containers.Count > 0 || context.SidecarContainers.Count > 0)
{
var containerProvider = HostContext.GetService <IContainerOperationProvider>();
var containers = new List <ContainerInfo>();
containers.AddRange(context.Containers);
containers.AddRange(context.SidecarContainers);
preJobSteps.Add(new JobExtensionRunner(runAsync: containerProvider.StartContainersAsync,
condition: ExpressionManager.Succeeded,
displayName: StringUtil.Loc("InitializeContainer"),
data: (object)containers));
postJobStepsBuilder.Push(new JobExtensionRunner(runAsync: containerProvider.StopContainersAsync,
condition: ExpressionManager.Always,
displayName: StringUtil.Loc("StopContainer"),
data: (object)containers));
}
foreach (var task in message.Steps.OfType <Pipelines.TaskStep>())
{
var taskDefinition = taskManager.Load(task);
List <string> warnings;
taskVariablesMapping[task.Id] = new Variables(HostContext, new Dictionary <string, VariableValue>(), out warnings);
// Add pre-job steps from Tasks
if (taskDefinition.Data?.PreJobExecution != null)
{
Trace.Info($"Adding Pre-Job {task.DisplayName}.");
var taskRunner = HostContext.CreateService <ITaskRunner>();
taskRunner.Task = task;
taskRunner.Stage = JobRunStage.PreJob;
taskRunner.Condition = taskConditionMap[task.Id];
preJobSteps.Add(taskRunner);
}
// Add execution steps from Tasks
if (taskDefinition.Data?.Execution != null)
{
Trace.Verbose($"Adding {task.DisplayName}.");
var taskRunner = HostContext.CreateService <ITaskRunner>();
taskRunner.Task = task;
taskRunner.Stage = JobRunStage.Main;
taskRunner.Condition = taskConditionMap[task.Id];
jobSteps.Add(taskRunner);
}
// Add post-job steps from Tasks
if (taskDefinition.Data?.PostJobExecution != null)
{
Trace.Verbose($"Adding Post-Job {task.DisplayName}.");
var taskRunner = HostContext.CreateService <ITaskRunner>();
taskRunner.Task = task;
taskRunner.Stage = JobRunStage.PostJob;
taskRunner.Condition = ExpressionManager.Always;
postJobStepsBuilder.Push(taskRunner);
}
}
// Add pre-job step from Extension
Trace.Info("Adding pre-job step from extension.");
var extensionPreJobStep = GetExtensionPreJobStep(jobContext);
if (extensionPreJobStep != null)
{
preJobSteps.Add(extensionPreJobStep);
}
// Add post-job step from Extension
Trace.Info("Adding post-job step from extension.");
var extensionPostJobStep = GetExtensionPostJobStep(jobContext);
if (extensionPostJobStep != null)
{
postJobStepsBuilder.Push(extensionPostJobStep);
}
// create execution context for all pre-job steps
foreach (var step in preJobSteps)
{
if (PlatformUtil.RunningOnWindows && step is ManagementScriptStep)
{
continue;
}
if (step is JobExtensionRunner)
{
JobExtensionRunner extensionStep = step as JobExtensionRunner;
ArgUtil.NotNull(extensionStep, extensionStep.DisplayName);
Guid stepId = Guid.NewGuid();
extensionStep.ExecutionContext = jobContext.CreateChild(stepId, extensionStep.DisplayName, stepId.ToString("N"));
}
else if (step is ITaskRunner)
{
ITaskRunner taskStep = step as ITaskRunner;
ArgUtil.NotNull(taskStep, step.DisplayName);
taskStep.ExecutionContext = jobContext.CreateChild(Guid.NewGuid(), StringUtil.Loc("PreJob", taskStep.DisplayName), taskStep.Task.Name, taskVariablesMapping[taskStep.Task.Id], outputForward: true);
}
}
// create task execution context for all job steps from task
foreach (var step in jobSteps)
{
ITaskRunner taskStep = step as ITaskRunner;
ArgUtil.NotNull(taskStep, step.DisplayName);
taskStep.ExecutionContext = jobContext.CreateChild(taskStep.Task.Id, taskStep.DisplayName, taskStep.Task.Name, taskVariablesMapping[taskStep.Task.Id], outputForward: true);
}
// Add post-job steps from Tasks
Trace.Info("Adding post-job steps from tasks.");
while (postJobStepsBuilder.Count > 0)
{
postJobSteps.Add(postJobStepsBuilder.Pop());
}
// create task execution context for all post-job steps from task
foreach (var step in postJobSteps)
{
if (step is JobExtensionRunner)
{
JobExtensionRunner extensionStep = step as JobExtensionRunner;
ArgUtil.NotNull(extensionStep, extensionStep.DisplayName);
Guid stepId = Guid.NewGuid();
extensionStep.ExecutionContext = jobContext.CreateChild(stepId, extensionStep.DisplayName, stepId.ToString("N"));
}
else if (step is ITaskRunner)
{
ITaskRunner taskStep = step as ITaskRunner;
ArgUtil.NotNull(taskStep, step.DisplayName);
taskStep.ExecutionContext = jobContext.CreateChild(Guid.NewGuid(), StringUtil.Loc("PostJob", taskStep.DisplayName), taskStep.Task.Name, taskVariablesMapping[taskStep.Task.Id], outputForward: true);
}
}
if (PlatformUtil.RunningOnWindows)
{
// Add script post steps.
// This is for internal testing and is not publicly supported. This will be removed from the agent at a later time.
var finallyScript = Environment.GetEnvironmentVariable("VSTS_AGENT_CLEANUP_INTERNAL_TEMP_HACK");
if (!string.IsNullOrEmpty(finallyScript) && context.StepTarget() is HostInfo)
{
var finallyStep = new ManagementScriptStep(
scriptPath: finallyScript,
condition: ExpressionManager.Always,
displayName: "Agent Cleanup");
Trace.Verbose($"Adding agent cleanup script step.");
finallyStep.Initialize(HostContext);
finallyStep.ExecutionContext = jobContext.CreateChild(Guid.NewGuid(), finallyStep.DisplayName, nameof(ManagementScriptStep));
finallyStep.Condition = ExpressionManager.Always;
ServiceEndpoint systemConnection = context.Endpoints.Single(x => string.Equals(x.Name, WellKnownServiceEndpointNames.SystemVssConnection, StringComparison.OrdinalIgnoreCase));
finallyStep.AccessToken = systemConnection.Authorization.Parameters["AccessToken"];
postJobSteps.Add(finallyStep);
}
}
List <IStep> steps = new List <IStep>();
steps.AddRange(preJobSteps);
steps.AddRange(jobSteps);
steps.AddRange(postJobSteps);
// Start agent log plugin host process
var logPlugin = HostContext.GetService <IAgentLogPlugin>();
await logPlugin.StartAsync(context, steps, jobContext.CancellationToken);
// Prepare for orphan process cleanup
_processCleanup = jobContext.Variables.GetBoolean("process.clean") ?? true;
if (_processCleanup)
{
// Set the VSTS_PROCESS_LOOKUP_ID env variable.
context.SetVariable(Constants.ProcessLookupId, _processLookupId, false, false);
context.Output("Start tracking orphan processes.");
// Take a snapshot of current running processes
Dictionary <int, Process> processes = SnapshotProcesses();
foreach (var proc in processes)
{
// Pid_ProcessName
_existingProcesses.Add($"{proc.Key}_{proc.Value.ProcessName}");
}
}
_taskKeyCleanup = jobContext.Variables.GetBoolean("process.cleanTaskKey") ?? true;
return(steps);
}
catch (OperationCanceledException ex) when(jobContext.CancellationToken.IsCancellationRequested)
{
// Log the exception and cancel the JobExtension Initialization.
Trace.Error($"Caught cancellation exception from JobExtension Initialization: {ex}");
context.Error(ex);
context.Result = TaskResult.Canceled;
throw;
}
catch (Exception ex)
{
// Log the error and fail the JobExtension Initialization.
Trace.Error($"Caught exception from JobExtension Initialization: {ex}");
context.Error(ex);
context.Result = TaskResult.Failed;
throw;
}
finally
{
context.Section(StringUtil.Loc("StepFinishing", StringUtil.Loc("InitializeJob")));
context.Complete();
}
}
}
// when the mouse button is released
private void Base_MouseUp(object sender, MouseButtonEventArgs e)
{
Knob.ReleaseMouseCapture();
Reset();
}
public void HasAgentKnobs()
{
Assert.True(Knob.GetAllKnobsFor <TestKnobs>().Count == 3, "GetAllKnobsFor returns the right amount");
}
private static void SaveKnobToDrawConnections(Vector2 _knobPosition, AssetType _assetType, Knob _knob)
{
switch (_assetType)
{
case AssetType.Reference:
m_referenceKnobs.Add(_knobPosition);
break;
case AssetType.Selected:
if (_knob == Knob.Left)
{
m_mainLeftKnob = _knobPosition;
}
else
{
m_mainRightKnob = _knobPosition;
}
break;
case AssetType.Dependency:
m_dependencyKnobs.Add(_knobPosition);
break;
default:
throw new ArgumentOutOfRangeException(nameof(_assetType), _assetType, null);
}
}
private void Knob_MouseUp(object sender, System.Windows.Input.MouseButtonEventArgs e)
{
mousePressed = false;
Knob.ReleaseMouseCapture();
centerKnob.Begin();
}
private void Knob_LostFocus(object sender, RoutedEventArgs e)
{
Knob.ReleasePointerCapture(pointer);
centerKnob.Begin();
}
public Editor(Rodent instance)
{
this.Rodent = instance;
this.ClientSize = new Size(BaseBitmap.Width, BaseBitmap.Height + TopBarBitmap.Height);
Gain = new BitmapKnob(KnobsBitmap, Knob1Width, KnobHeight, Positions, 0, 0, 0, KnobHeight);
Gain.Brush = Brushes.White;
Gain.Top = TopH;
Gain.Left = Knob1X;
Filter = new BitmapKnob(KnobsBitmap, Knob2Width, KnobHeight, Positions, Knob1Width, 0, 0, KnobHeight);
Filter.Brush = Brushes.White;
Filter.Top = TopH;
Filter.Left = Knob2X;
Vol = new BitmapKnob(KnobsBitmap, Knob3Width, KnobHeight, Positions, Knob1Width + Knob2Width, 0, 0, KnobHeight);
Vol.Brush = Brushes.White;
Vol.Top = TopH;
Vol.Left = Knob3X;
Ruetz = new BitmapSwitch(SwitchBitmap, Switch1Width, SwitchHeight, false, true, Switch1X, SwitchY);
Ruetz.Brush = Brushes.White;
Ruetz.OffBrush = Brushes.White;
Ruetz.Top = TopH + SwitchY;
Ruetz.Left = Switch1X;
Turbo = new BitmapSwitch(SwitchBitmap, Switch2Width, SwitchHeight, false, true, Switch2X, SwitchY);
Turbo.Brush = Brushes.White;
Turbo.OffBrush = Brushes.White;
Turbo.Top = TopH + SwitchY;
Turbo.Left = Switch2X;
Tight = new BitmapSwitch(SwitchBitmap, Switch3Width, SwitchHeight, false, true, Switch3X, SwitchY);
Tight.Brush = Brushes.White;
Tight.OffBrush = Brushes.White;
Tight.Top = TopH + SwitchY;
Tight.Left = Switch3X;
OD = new BitmapSwitch(SwitchBitmap, Switch4Width, SwitchHeight, false, true, Switch4X, SwitchY);
OD.Brush = Brushes.White;
OD.OffBrush = Brushes.White;
OD.Top = TopH + SwitchY;
OD.Left = Switch4X;
Light = new BitmapIndicator(SwitchBitmap, LightWidth, SwitchHeight, false, true, LightX, SwitchY);
Light.Left = LightX;
Light.Top = TopH + SwitchY;
Stomp = new BitmapSwitch(SwitchBitmap, StompWidth, StompHeight, false, true, StompX, StompY);
Stomp.Left = StompX;
Stomp.Top = TopH + StompY;
Stomp.Mode = Switch.SwitchMode.Toggle;
Controls.Add(Gain);
Controls.Add(Filter);
Controls.Add(Vol);
Controls.Add(Ruetz);
Controls.Add(Turbo);
Controls.Add(Tight);
Controls.Add(OD);
Controls.Add(Light);
Controls.Add(Stomp);
Gain.ValueChanged += ParameterChanged;
Filter.ValueChanged += ParameterChanged;
Vol.ValueChanged += ParameterChanged;
Ruetz.ValueChanged += ParameterChanged;
Turbo.ValueChanged += ParameterChanged;
Tight.ValueChanged += ParameterChanged;
OD.ValueChanged += ParameterChanged;
Stomp.ValueChanged += ParameterChanged;
var about = new AboutButton();
about.Top = 0;
about.Left = TopBarBitmap.Width - about.Width;
about.Click += about_Click;
Controls.Add(about);
}
public Joystick()
{
InitializeComponent();
this.mousePressed = false;
story = (Storyboard)Knob.FindResource("CenterKnob");
}
public Editor()
{
this.ClientSize = new Size(BackgroundBitmap.Width, BackgroundBitmap.Height + TopBarBitmap.Height);
InputA = new BitmapSliderSimple(TopSliderBitmap);
InputA.Top = SliderY;
InputA.Left = Slider1X;
InputB = new BitmapSliderSimple(TopSliderBitmap);
InputB.Top = SliderY;
InputB.Left = Slider2X;
// -------- first 4 knobs
GainA = new BitmapKnob(KnobsBitmap, KnobW, KnobH, Positions, KnobX1, KnobY1, 0, BackgroundBitmap.Height);
GainA.Left = KnobX1;
GainA.Top = KnobY1 + TopH;
VolA = new BitmapKnob(KnobsBitmap, KnobW, KnobH, Positions, KnobX1 + KnobW, KnobY1, 0, BackgroundBitmap.Height);
VolA.Left = KnobX1 + KnobW;
VolA.Top = KnobY1 + TopH;
GainB = new BitmapKnob(KnobsBitmap, KnobW, KnobH, Positions, KnobX1, KnobY2, 0, BackgroundBitmap.Height);
GainB.Left = KnobX1;
GainB.Top = KnobY1 + KnobH + TopH;
VolB = new BitmapKnob(KnobsBitmap, KnobW, KnobH, Positions, KnobX1 + KnobW, KnobY2, 0, BackgroundBitmap.Height);
VolB.Left = KnobX1 + KnobW;
VolB.Top = KnobY1 + KnobH + TopH;
// ------- Channel Switch
Channel = new BitmapSwitch(SwitchBitmap, SwitchBitmap.Width / 2, SwitchBitmap.Height, true, false);
Channel.Left = SwitchX;
Channel.Top = SwitchY + TopH;
// -------- Channel Indicators
LightA = new BitmapIndicator(Light1Bitmap, Light1Bitmap.Width / 2, Light1Bitmap.Height, false, false);
LightA.Left = Light1X;
LightA.Top = Light1Y + TopH;
LightB = new BitmapIndicator(Light2Bitmap, Light2Bitmap.Width / 2, Light2Bitmap.Height, false, false);
LightB.Left = Light2X;
LightB.Top = Light2Y + TopH;
LightC = new BitmapIndicator(Light3Bitmap, Light3Bitmap.Width / 2, Light3Bitmap.Height, false, false);
LightC.Left = Light3X;
LightC.Top = Light3Y + TopH;
// -------- Channel A Controls
BassA = new BitmapKnob(KnobsBitmap, KnobW, KnobH, Positions, KnobX2, KnobY1, 0, BackgroundBitmap.Height);
BassA.Left = KnobX2;
BassA.Top = KnobY1 + TopH;
MidA = new BitmapKnob(KnobsBitmap, KnobW, KnobH, Positions, KnobX2 + KnobW, KnobY1, 0, BackgroundBitmap.Height);
MidA.Left = KnobX2 + KnobW;
MidA.Top = KnobY1 + TopH;
TrebleA = new BitmapKnob(KnobsBitmap, KnobW, KnobH, Positions, KnobX2 + 2 * KnobW, KnobY1, 0, BackgroundBitmap.Height);
TrebleA.Left = KnobX2 + 2 * KnobW;
TrebleA.Top = KnobY1 + TopH;
PresA = new BitmapKnob(KnobsBitmap, KnobW, KnobH, Positions, KnobX2 + 3 * KnobW, KnobY1, 0, BackgroundBitmap.Height);
PresA.Left = KnobX2 + 3 * KnobW;
PresA.Top = KnobY1 + TopH;
// -------- Channel B Controls
BassB = new BitmapKnob(KnobsBitmap, KnobW, KnobH, Positions, KnobX2, KnobY2, 0, BackgroundBitmap.Height);
BassB.Left = KnobX2;
BassB.Top = KnobY2 + TopH;
MidB = new BitmapKnob(KnobsBitmap, KnobW, KnobH, Positions, KnobX2 + KnobW, KnobY2, 0, BackgroundBitmap.Height);
MidB.Left = KnobX2 + KnobW;
MidB.Top = KnobY2 + TopH;
TrebleB = new BitmapKnob(KnobsBitmap, KnobW, KnobH, Positions, KnobX2 + 2 * KnobW, KnobY2, 0, BackgroundBitmap.Height);
TrebleB.Left = KnobX2 + 2 * KnobW;
TrebleB.Top = KnobY2 + TopH;
PresB = new BitmapKnob(KnobsBitmap, KnobW, KnobH, Positions, KnobX2 + 3 * KnobW, KnobY2, 0, BackgroundBitmap.Height);
PresB.Left = KnobX2 + 3 * KnobW;
PresB.Top = KnobY2 + TopH;
// Switches
Boost = new BitmapSwitch(BoostBitmap, BoostBitmap.Width / 2, BoostBitmap.Height, false, false);
Boost.Left = BoostX;
Boost.Top = BoostY + TopH;
MapControls();
foreach (var ctrl in ControlMap)
{
if (ctrl.Value == null)
{
continue;
}
if (ctrl.Value as Knob != null)
{
((Knob)ctrl.Value).ValueChanged += ParameterChanged;
}
else if (ctrl.Value as Switch != null)
{
((Switch)ctrl.Value).Brush = Brushes.White;
((Switch)ctrl.Value).OffBrush = Brushes.White;
((Switch)ctrl.Value).ValueChanged += ParameterChanged;
}
else if (ctrl.Value as BitmapSliderSimple != null)
{
((BitmapSliderSimple)ctrl.Value).ValueChanged += ParameterChanged;
}
Controls.Add((Control)ctrl.Value);
}
Controls.Add(LightA);
Controls.Add(LightB);
Controls.Add(LightC);
var about = new AboutButton();
about.Top = 0;
about.Left = TopBarBitmap.Width - about.Width;
about.Click += about_Click;
Controls.Add(about);
}
public Joystic()
{
InitializeComponent();
myBoard = (Storyboard)Knob.FindResource("CenterKnob");
myBoard.Stop();
}
private void Knob_MouseUp(object sender, MouseButtonEventArgs e)
{
// Update that the joystick has been released.
Knob.ReleaseMouseCapture();
centerknob.Begin();
}
private void Base_MouseUp(object sender, MouseButtonEventArgs e)
{
isMousePressed = false;
Knob.ReleaseMouseCapture();
moveKnobToCenter();
}
// on click event
private void Knob_Clicked(object sender, MouseButtonEventArgs e)
{
// save the coords of the mouse when the knob was clicked
_InitPos = e.GetPosition(this);
Knob.CaptureMouse();
}
public Joystick()
{
InitializeComponent();
mySTB = Knob.FindResource("CenterKnob") as Storyboard;
// Storyboard.SetTarget(mySTB, knobPosition);
}
private void Approach(Knob knob)
{
grab.approached = knob;
knob.ChangeColour(Color.black);
}
public int OutputKnobIndex(Knob knob) => _editorNode.Knobs.IndexOf(knob) - 1;
private void Knob_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
{
Knob.ReleaseMouseCapture();
centerKnob.Begin();
}
private void Knob_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
clickPoint = e.GetPosition(Base);
Knob.CaptureMouse();
centerKnob.Stop();
}
