public Peer(IMachine o, Effector e, Relation r, PPTarget t)
{
owner = o;
InputEffector = e;
Relations.Add(r);
Target = t;
}
public Peer(IMachine o, Effector e, List<Relation> r, PPTarget t)
{
owner = o;
InputEffector = e;
Relations = r;
Target = t;
}
public void AddMachine(IMachine machine)
{
if (machine == null)
{
throw new ArgumentNullException("The added machine cannot be null.");
}
this.machines.Add(machine);
}
public void AddMachine(IMachine machine)
{
if (machine==null)
{
throw new ArgumentNullException();
}
this.machines.Add(machine);
}
public MachineTargetGUI(PPTarget c, IMachine t, Types m)
{
InitializeComponent();
DataContext = this;
caller = c;
Target = t;
mode = m;
}
public void AddMachine(IMachine machine)
{
this.engagedMachines.Add(machine);
// Ordering machines
this.engagedMachines =
new List<IMachine>(this.engagedMachines.OrderBy(i => i.HealthPoints).ThenBy(i => i.Name).ToList());
}
public void AddMachine(IMachine machine)
{
if (machine == null)
{
throw new ApplicationException("The machine that is added cannot be null!");
}
this.machines.Add(machine);
}
public void AddMachine(IMachine machine)
{
if (machine == null)
{
throw new ArgumentException("Machine cannot be null");
}
this.machines.Add(machine);
}
internal Match (Regex regex, IMachine machine, string text, int text_length, int n_groups,
int index, int length, int n_caps) :
base (text, index, length, n_caps)
{
this.regex = regex;
this.machine = machine;
this.text_length = text_length;
this.groups = new GroupCollection (n_groups);
groups.SetValue (this, 0);
}
public void AddMachine(IMachine machine)
{
if (machine == null)
{
throw new ArgumentNullException("Machine can't be null");
}
else
{
this.machines.Add(machine);
}
}
public void AddMachine(IMachine machine)
{
var machinee = (Machine)machine;
if (machinee != null)
{
this.machines.Add(machinee);
this.machines.Sort();
}
}
public void AddMachine(IMachine machine)
{
this.listOfMachines.Add(machine);
var sortedList = this.listOfMachines
.OrderBy(x => x.HealthPoints)
.ThenBy(x => x.Name)
.ToList();
this.listOfMachines = sortedList;
}
public SnapshotObject(IMachine machine, string snapshotId)
{
this.machine = machine;
this.snapshotId = snapshotId;
defineProperty ("toString",
new ObjectReturningFunction(toString ()),
ScriptableObject.PERMANENT);
defineProperty("Restore",
new ActionFunction(Restore ),
ScriptableObject.PERMANENT);
}
private Match (Regex regex, IMachine machine,
GroupCollection groups,
string text, int text_length,
int index, int length, int n_caps)
: base (text, index, length, n_caps) {
this.regex = regex;
this.machine = machine;
this.text_length = text_length;
this.groups = groups;
groups.SetValue (this, 0);
}
public AlloyClient(IMachine machine, Func<IPublicKeyCrypto> cryptoFactory, IAsymmetricKey key)
: base(new NetworkClientConnection (AlloyProtocol.Instance, cryptoFactory), MessageTypes.Reliable)
{
if (machine == null)
throw new ArgumentNullException ("machine");
this.machine = machine;
this.machine.ScreenChanged += OnMachineScreensChanged;
//this.machine.KeyboardEvent += OnKeyboardEvent;
//this.machine.MouseEvent += OnMouseEvent;
this.RegisterMessageHandler<MachineStateMessage> (OnMachineStateMessage);
this.RegisterMessageHandler<MouseEventMessage> (OnMouseEventMessage);
this.RegisterMessageHandler<KeyboardEventMessage> (OnKeyboardEventMessage);
}
public static bool CreateReservation(IEmployee employee, IMachine machine, DateTime day,
DateTime start, DateTime end, string jamType, string description)
{
bool result;
try
{
ReservationEntity reservationEntity = new ReservationEntity(employee.Id, machine.Id,
day, start, end, jamType, description);
result = Persistens.CreateReservationEntity(reservationEntity);
return result;
}
catch (Exception)
{
return false;
}
}
public MainPresenter(IMainfForm view, IMachine machineActionsManager, IBuyer buyer)
{
_view = view;
_machineActionsManager = machineActionsManager;
_buyer = buyer;
_view.setBuyerSum(150);
_view.radio10Click += _view_radio10Click;
_view.radio5Click += _view_radio5Click;
_view.radio2Click += _view_radio2Click;
_view.radio1Click += _view_radio1Click;
_view.insertCoin += _view_insertCoin;
_view.takeProductsClick += _view_takeProductsClick;
_view.takeChangeClick += _view_takeChangeClick;
}
internal StateManager( ILogManager logManager, IPluginManager pluginManager, IMachine stateMachine, INGinCore core )
{
if ( logManager == null )
{
string message = "The log manager must not be null.";
ArgumentNullException argnEx = new ArgumentNullException( "logManager", message );
throw argnEx;
}
if ( pluginManager == null )
{
string message = "The plugin manager must not be null.";
ArgumentNullException argnEx = new ArgumentNullException( "pluginManager", message );
logManager.Trace( Namespace.LoggerName, LogLevel.Error, argnEx, message );
throw argnEx;
}
if ( stateMachine == null )
{
string message = "The state machine must not be null.";
ArgumentNullException argnEx = new ArgumentNullException( "stateMachine", message );
logManager.Trace( Namespace.LoggerName, LogLevel.Error, argnEx, message );
throw argnEx;
}
if ( core == null )
{
string message = "The core must not be null.";
ArgumentNullException argnEx = new ArgumentNullException( "core", message );
logManager.Trace( Namespace.LoggerName, LogLevel.Error, argnEx, message );
throw argnEx;
}
this.LogManager = logManager;
this.PluginManager = pluginManager;
this.StateMachine = stateMachine;
this.Core = core;
this.Core.RunStarted += new CoreStateDelegate( this.Core_RunStarted );
this.Core.RunStopped += new CoreStateDelegate( this.Core_RunStopped );
}
public AlloyServer(IMachine hostMachine)
: base(MessageTypes.Reliable)
{
if (hostMachine == null)
throw new ArgumentNullException ("hostMachine");
this.machine = hostMachine;
this.machine.MouseEvent += OnMouseEvent;
this.machine.KeyboardEvent += OnKeyboardEvent;
this.machine.ScreenChanged += OnMachineScreenChanged;
this.centerPosition = new Position ((short)(this.machine.Screen.Height / 2), (short)(this.machine.Screen.Width / 2));
this.RegisterMessageHandler<ConnectMessage> (OnConnectMessage);
this.RegisterMessageHandler<MouseEventMessage> (OnMouseEventMessage);
this.RegisterMessageHandler<KeyboardEventMessage> (OnKeyboardEventMessage);
this.RegisterMessageHandler<ScreenChangedMessage> (OnScreenChangedMessage);
this.manager = new ScreenManager (new PositionedScreen (hostMachine.Screen));
this.manager.ActiveScreenChanged += OnActiveScreenChanged;
}
public Peer newPeer(IMachine m)
{
// make a straight relation
Relations.StraightRelation sr = new MT_Peer_Pressure.Relations.StraightRelation();
// make the relations list
List<Relation> lr = new List<Relation>();
lr.Add(sr);
// make null effector and target
Effectors.NullEffector ne = new MT_Peer_Pressure.Effectors.NullEffector();
Targets.NullTarget nt = new MT_Peer_Pressure.Targets.NullTarget();
// make the peer
Peer p = new Peer(m, ne, lr, nt);
// add peer
Peers.Add(p);
// if we are getting a request from self
if (m == host.Machine)
{
// add track
PPTrackVM t = new PPTrackVM();
t.peerIndex = Peers.Count();
tracks.Add(t);
}
return p;
}
public OtherButtonPushMovement(IMachine Machine) : base(Machine, "OtherUserPressed")
{
OnReceiveData += ReceiveData;
}
public void AddMachine(IMachine machine)
{
Validator.CheckIfNull(machine, "Machine cannot be null!");
this.machines.Add(machine);
}
internal Match (Regex regex, IMachine machine,
GroupCollection groups,
string text, int text_length,
int index, int length)
: this (regex, machine, groups, text, text_length, index, length, 1) { }
internal VirtualBoxVirtualMachine(VirtualMachineManager vmManager, IMachine vboxMachine) : base(vmManager)
{
this.vboxMachine = vboxMachine;
}
public void SetNextChain(IMachine machine)
{
this.nextMachine = machine;
}
internal Match(Regex regex, IMachine machine, string text, int text_length, int n_groups, int index, int length) : base(text, index, length)
{
this.regex = regex;
this.machine = machine;
this.text_length = text_length;
}
public static void Overflow(IMachine machine, bool exp)
{
Assert.True(exp == machine.CPU.SR.Overflow, "Invalid overflow flag");
}
public static void Negative(IMachine machine, bool exp)
{
Assert.True(exp == machine.CPU.SR.Negative, "Invalid negative flag");
}
public static void Zero(IMachine machine, bool exp)
{
Assert.True(exp == machine.CPU.SR.Zero, "Invalid zero flag");
}
/// <summary>
/// Initializes a new instance of the <see cref="CryptCombo"/> class.
/// </summary>
/// <param name="hash">The hash<see cref="HashAlgorithm"/></param>
/// <param name="machine">The machine<see cref="IMachine"/></param>
public CryptCombo(HashAlgorithm hash, IMachine machine)
{
this.Hasher = hash;
this.Machine = machine;
}
public string MachineReport(string machineName)
{
IMachine repot = machines.FirstOrDefault(x => x.Name == machineName);
return(repot.ToString());
}
public xFormaData(string plugin_id, IMachine machine, IConfigurationManagerExtension config)
{
_source = plugin_id;
_config = config;
_machine = machine;
}
public string MachineReport(string machineName)
{
IMachine machine = this.machines.FirstOrDefault(p => p.Name == machineName);
return(machine.ToString());
}
public ButtonTwoPushMovement(IMachine Machine) : base(Machine, "Buton2Pushed")
{
OnReceiveData += ReceiveData;
}
public void AddMachine(IMachine machine)
{
this.ListOfMachines.Add(machine);
}
public static void Decimal(IMachine machine, bool exp)
{
Assert.True(exp == machine.CPU.SR.Decimal, "Invalid decimal flag");
}
public IMachine SetNextMachine(IMachine machine)
{
this.nextMachine = machine;
return(machine);
}
string GetInitSnapshotId(IMachine m)
{
return m.GetSnapshots()
.Where (ss => ss.Name == initSnapshotName)
.Select (ss => ss.Id)
.FirstOrDefault();
}
public void ReceiveData(IMachine Sender, object Data)
{
Console.WriteLine(Sender.Name + " Okunan Veri : Sol tuşuna basılıyor");
}
public INISystem(IMachine machine, int n)
{
this.Display = new INIDisplay();
this.Form = new Form(machine, n);
}
internal Match (Regex regex, IMachine machine, string text, int text_length, int n_groups,
int index, int length, int n_caps)
: this (regex, machine, new GroupCollection (n_groups), text,
text_length, index, length, n_caps) { }
public Form(IMachine machine, int n)
{
this.machine = machine;
this.n = n;
}
public SolMovement(IMachine Machine) : base(Machine, "00 7F 00 00 00 00 00 00 00 00 00 00")
{
OnReceiveData += ReceiveData;
}
internal Match (Regex regex, IMachine machine, string text, int text_length, int n_groups,
int index, int length) :
base (text, index, length) {
this.regex = regex;
this.machine = machine;
this.text_length = text_length;
}
public static void Interrupt(IMachine machine, bool exp)
{
Assert.True(exp == machine.CPU.SR.Interrupt, "Invalid interrupt flag");
}
public void ReceiveData(IMachine Sender, object Data)
{
Console.WriteLine(Sender.Name + String.Format(" Okunan Veri : {0}", Data.ToString()));
Gifbulib.WebSocketClient.SendData(Data.ToString());
}
/// <summary>
/// If the machine has not been accessed before, revert it to initial snapshot
/// </summary>
void PossiblyInitializeMachine(IMachine m)
{
if(!usedMachines.Contains(m.Id))
{
usedMachines.Add(m.Id);
string ssId = GetInitSnapshotId(m);
if(ssId != null)
{
m.Start(ssId);
}
}
}
public static void Unused(IMachine machine, bool exp)
{
Assert.True(exp == machine.CPU.SR.Unused, "Invalid unused/B flag");
}
public XMLSystem(IMachine machine, int n)
{
this.Display = new XMLDisplay();
this.Form = new Form(machine, n);
}
protected Command(IMachine machine)
{
Machine = machine;
}
public void Initialize()
{
XiServerConfigProvider.XiServerConfig.ServerUrl =
MachineConfigProvider.MachineConfig.PLC_OpcXiServerConfig_ServerUrl;
XiServerConfigProvider.XiServerConfig.UserName =
MachineConfigProvider.MachineConfig.PLC_OpcXiServerConfig_UserName;
XiServerConfigProvider.XiServerConfig.Password =
MachineConfigProvider.MachineConfig.PLC_OpcXiServerConfig_Password;
var localDbInstanceName = MachineConfigProvider.MachineConfig.General_LocalDbInstanceName;
string connectionStringForLocalDb = ConnectionStringForLocalDb.Replace("LocalDbInstanceName", localDbInstanceName);
var dc = new DatasContext(connectionStringForLocalDb);
Container.RegisterInstance <IDatasContext>(dc, new ContainerControlledLifetimeManager());
TestDb();
//return;
string channelName = MachineConfigProvider.MachineConfig.PLC_SimulationAccessChannelEnabled
? AccessChannelNames.SimAccessChannelFactory
: AccessChannelNames.AccessChannelFactory;
EventAggregator
.GetEvent <SplashFinishedEvent>()
.Subscribe(async e =>
{
Debug.WriteLine(DateTime.Now + ": AccessChannelController.Start begin.");
await AccessChannelController.StartAsync(channelName);
EventAggregator
.GetEvent <CommunicationInitializedEvent>()
.Publish(new CommunicationInitializedEvent());
IMachine machine = Container.Resolve <IMachineProvider>().Machine;
int speed = 25000;
machine.TestME_Slider_JogSpeedDevice.Write(speed);
machine.TestME_Slider_ScanSpeedDevice.Write(speed);
machine.TestME_Slider_StartSpeedDevice.Write(speed);
Debug.WriteLine(DateTime.Now + ": Speeds have been set. ");
Observable
.Interval(TimeSpan.FromSeconds(5))
.ObserveOnTaskPool()
.Subscribe(x =>
{
var mp = Container.Resolve <IMachineProvider>();
mp.Machine.General_PlcStartedPlcEventDevice.Subscribe(
p =>
{
mp.Machine.General_PlcStartedPlcEventDevice.WriteTrue();
// mp.Machine.TestME_Slider_JogSpeedDevice.Write(speed);
mp.Machine.TestME_Slider_ScanSpeedDevice.Write(speed);
// mp.Machine.TestME_Slider_StartSpeedDevice.Write(speed);
// Debug.WriteLine(DateTime.Now + ": Speeds have been set. ");
});
if (!_isConnected)
{
mp.Machine.General_AppStartedPcEventDevice.WriteTrue();
_isConnected = true;
}
if (_isStoped)
{
return;
}
mp.Machine.General_UpdateWatchdogCommandDevice.WriteTrue();
// mp.Machine.TestME_Slider_JogSpeedDevice.Write(speed);
mp.Machine.TestME_Slider_ScanSpeedDevice.Write(speed);
// mp.Machine.TestME_Slider_StartSpeedDevice.Write(speed);
//Debug.WriteLine(DateTime.Now + ": Speeds have been set. ");
});
Debug.WriteLine(DateTime.Now + ": AccessChannelController.Start end.");
}, ThreadOption.BackgroundThread, true);
var mvmp = Container.Resolve <IMachineViewModelProvider>();
// var inspectorProvider = Container.Resolve<IInspectorControllerProvider>();
// var productionService = Container.Resolve<IInspectionDomainService>();
AccessChannelController
.Config(cfg =>
{
cfg.ServerUrl = MachineConfigProvider.MachineConfig.PLC_OpcXiServerConfig_ServerUrl;
cfg.UserName = MachineConfigProvider.MachineConfig.PLC_OpcXiServerConfig_UserName;
cfg.Password = MachineConfigProvider.MachineConfig.PLC_OpcXiServerConfig_Password;
});
var xmlLocalizationService = new XmlLocalizationService();
// string lcidString = MachineConfigProvider.MachineConfig.Language;
string lcidString = "zh-CN";
xmlLocalizationService.Update(lcidString);
LocalizationServiceLocator.Service = xmlLocalizationService;
Container.RegisterInstance <ILocalizationService>(
xmlLocalizationService,
new ContainerControlledLifetimeManager());
Application.Current.Exit += (sender, args) =>
{
_isStoped = true;
AccessChannelController.Stop();
};
// Start watchdog.
// Interval = 10s, PLC Timeout = 60s
_isConnected = false;
}
private void Stop(IMachine m)
{
m.Stop();
}
internal static void AddMachine(IMachine machineEntry)
{
throw new NotImplementedException();
}
public void AddMachine(IMachine machine)
{
this.MachinesEngaged.Add(machine);
}
public void AddMachine(IMachine machine)
{
this.machines.Add(machine);
}
public string MachineReport(string machineName)
{
IMachine machine = this.machines[machineName];
return(machine.ToString());
}
public Pressure(IBuzzMachineHost host)
{
this.host = host;
isMasterPeer = false;
IMachine master = null;
// set up the first empty track
tracks = new List<PPTrackVM>();
foreach (IMachine m in Global.Buzz.Song.Machines)
if ((m.DLL.Name == "MT Peer Pressure")&&(m != host.Machine))
master = m;
// if one exists, link to that
if (master != null)
{
//peers = ((Pressure)master.ManagedMachine).Peers;
//targets = ((Pressure)master.ManagedMachine).Targets;
//effectors = ((Pressure)master.ManagedMachine).Effectors;
//relations = ((Pressure)master.ManagedMachine).Relations;
masterPeer = master;
}
// if none exist, setup the peers and module lists
else
{
// claim MasterPeer
isMasterPeer = true;
//PeerPressure.masterMachine = host;
// setup main collections
PeerPressure.peers = new List<Peer>();
// modules
//PeerPressure.targets = new List<PPTarget>();
//PeerPressure.effectors = new List<Effector>();
//PeerPressure.relations = new List<Relation>();
// add the default modules
PeerPressure.targets.Add(new Targets.MultiTarget());
PeerPressure.targets.Add(new Targets.MuteTarget());
PeerPressure.targets.Add(new Targets.NullTarget());
PeerPressure.targets.Add(new Targets.ParameterTarget());
PeerPressure.effectors.Add(new Effectors.AudioEffector());
PeerPressure.effectors.Add(new Effectors.ButtonEffector());
PeerPressure.effectors.Add(new Effectors.LFOEffector());
PeerPressure.effectors.Add(new Effectors.MidiEffector(0, 0));
PeerPressure.effectors.Add(new Effectors.NoiseEffector());
PeerPressure.effectors.Add(new Effectors.NullEffector());
PeerPressure.effectors.Add(new Effectors.OSCEffector());
PeerPressure.effectors.Add(new Effectors.SliderEffector(this, null, 0));
PeerPressure.relations.Add(new Relations.ASDREnvelopeRelation(host));
PeerPressure.relations.Add(new Relations.CropRelation());
PeerPressure.relations.Add(new Relations.ExponentialRelation());
PeerPressure.relations.Add(new Relations.FrequencyRelation());
PeerPressure.relations.Add(new Relations.InertiaRelation());
PeerPressure.relations.Add(new Relations.InverseRelation());
PeerPressure.relations.Add(new Relations.NoiseRelation());
PeerPressure.relations.Add(new Relations.QuadraticRelation());
PeerPressure.relations.Add(new Relations.ScaledRelation());
PeerPressure.relations.Add(new Relations.SteppedRelation());
PeerPressure.relations.Add(new Relations.StraightRelation());
PeerPressure.relations.Add(new Relations.TriggerRelation());
//tracks.Add(new PPTrackVM());
// and a first peer
newPeer(this.HostMachine);
/* lock (PeerPressure.peers)
{
PeerPressure.peers.Add(newPeer(host.Machine));
}*/
}
/*
if (machineState.Peers.Count() > 0)[
{
// we are loading?
//machineState.IsMaster = isMasterPeer;
tracks = machineState.Tracks;
foreach (PeerState ps in machineState.Peers)
{
Peers.Add(ps.toPeer());
}
}*/
}
/// <summary>
/// Initializes a new <see cref="PickAndPlace.StackList"/>
/// </summary>
/// <param name="machineType">Machine type of the new stacklist</param>
/// <param name="phaseNumber">Phase number of the new stacklist</param>
/// <exception cref="System.ArgumentNullException">Thrown when machineType is null</exception>
public StackList(IMachine machineType, int phaseNumber)
: this(machineType)
{
this.phaseNumber_ = phaseNumber;
}
public static void Carry(IMachine machine, bool exp)
{
Assert.True(exp == machine.CPU.SR.Carry, "Invalid carry flag");
}
private void Start(IMachine m)
{
m.Start();
}
