static void Main(string[] args) { Debug.Listeners.Add(new ConsoleTraceListener()); int numeroDeEsclavos; int cantidadDeNumeros; if (ProgramHelper.ParsearParametrosMaestro(args, out numeroDeEsclavos, out cantidadDeNumeros, USO_CORRECTO)) { return; } int[] numbers = Enumerable.Range(1, cantidadDeNumeros).ToArray(); var stopWatch = Stopwatch.StartNew(); double resultado = 0; using (var ctx = new Context()) { /* Crear socket de envío */ uint PUERTO_ENVIO = ProgramHelper.PUERTO_ENVIO_MASTER; var sendSocket = ctx.Socket(SocketType.PUB); sendSocket.Bind(Transport.TCP, "*", PUERTO_ENVIO); /* Crear socket de recepción */ uint PUERTO_RECEPCION = ProgramHelper.PUERTO_RECEPCION_MASTER; Socket recvSocket = ctx.Socket(SocketType.PULL); recvSocket.Bind(Transport.TCP, "*", PUERTO_RECEPCION); /* Inicializando esclavos */ Debug.WriteLine("Master: Inicializando esclavos"); Task.Factory.StartNew(() => SlaveProgram.EjecutarEsclavos(numeroDeEsclavos)); Thread.Sleep(5); Debug.WriteLine("Master: Esperando a que se inicializen los esclavos."); SlaveProgram.EsperarEsclavosListos(); Debug.WriteLine("Master: Esclavos listos, empieza inicialización de maestro."); using (var master = new SumadorBroadcastMaestro(numbers, ctx, sendSocket, recvSocket)) { Debug.WriteLine("Master: new SumadorBroadcastMaestro(int[{0}], ctx, sendSocket, recvSocket)", numbers.Length); Console.WriteLine("Master: Ejecutando operación maestro."); Debug.Indent(); master.RecepcionesEsperadas = numeroDeEsclavos; master.EjecutarOperacion(); Debug.WriteLine("Master: Esperando a que termine la operacion..."); master.SenalDeFinalizacion.Wait(); Debug.WriteLine("Master: Se recibió la senal de finalización."); Debug.Unindent(); resultado = master.Resultado; } } stopWatch.Stop(); Console.WriteLine("Se tardó: {0} milisegundos", stopWatch.ElapsedMilliseconds); Console.WriteLine("Se tardó: {0} ticks de reloj", stopWatch.ElapsedTicks); Console.WriteLine("Resultado de sumar del 1 al {1}: {0}", resultado, numbers[numbers.Length - 1]); Console.ReadLine(); }
public App() { ProgramHelper.Initialize(Assembly.GetExecutingAssembly(), "daramkun", "DaramRenamer"); ownLocalizer = new StringTable(); if (Environment.OSVersion.Version <= new Version(5, 0)) { MessageBox.Show(StringTable.SharedStrings ["os_notice"], StringTable.SharedStrings ["daram_renamer"], MessageBoxButton.OK, MessageBoxImage.Error); Application.Current.Shutdown(-1); } TextWriterTraceListener textWriterTraceListner = new TextWriterTraceListener(Console.Out); Debug.Listeners.Add(textWriterTraceListner); AppDomain.CurrentDomain.UnhandledException += (sender, args) => { //Daramkun.DaramRenamer.MainWindow.SharedWindow.UndoManager.Backup (); Daramkun.DaramRenamer.MainWindow.MessageBox(StringTable.SharedStrings ["error_raised"], StringTable.SharedStrings ["please_check_log"], TaskDialogIcon.Error, TaskDialogCommonButtonFlags.OK); using (StreamWriter sw = File.AppendText("error.log")) { TextWriterTraceListener textWriterTraceListnerForFile = new TextWriterTraceListener(sw); Debug.Listeners.Add(textWriterTraceListnerForFile); sw.WriteLine($"Error: {DateTime.Now.ToString ( "yyyy-MM-dd hh/mm/ss" )} - from Daram Renamer"); sw.WriteLine("----"); sw.WriteLine(args.ExceptionObject.ToString()); sw.WriteLine("=========================================================="); Debug.Listeners.Remove(textWriterTraceListnerForFile); } }; }
void this_StartupNextInstance(object sender, StartupNextInstanceEventArgs e) { ProgramHelper.RevertToSelf(); MainForm form = MainForm as MainForm; form.ProcessArguments(e.CommandLine.ToArray()); }
public static ParsedLog ParseLog(string location) { var parser = new ParsingController(new TestParserSettings()); var row = new GridRow(location as string, "Ready to parse") { BgWorker = new System.ComponentModel.BackgroundWorker() { WorkerReportsProgress = true } }; var fInfo = new FileInfo(row.Location); if (!fInfo.Exists) { throw new FileNotFoundException("Error Encountered: File does not exist", fInfo.FullName); } if (!ProgramHelper.IsSupportedFormat(fInfo.Name)) { throw new InvalidDataException("Error Encountered: Not EVTC"); } return(parser.ParseLog(row, fInfo.FullName)); }
static void Main() { if (ProgramHelper.HasExist()) { Application.Exit(); } else { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); FormLogin frmL = new FormLogin(); frmL.ShowDialog(); if (GlobalVar.Oper == null) { return; } if (GlobalVar.Oper.OperCode == "" || GlobalVar.Oper == null) { return; } try { Application.Run(new FormMain()); } catch (Exception ex) { Console.WriteLine(ex.ToString()); } } }
//Main Parse method------------------------------------------------------------------------------------------------------------------------------------------------ /// <summary> /// Parses the given log /// </summary> /// <param name="operation">Operation object bound to the UI</param> /// <param name="evtc">The path to the log to parse</param> /// <returns>the ParsedLog</returns> public ParsedLog ParseLog(OperationController operation, string evtc) { operation.UpdateProgressWithCancellationCheck("Reading Binary"); using (var fs = new FileStream(evtc, FileMode.Open, FileAccess.Read, FileShare.Read)) { if (ProgramHelper.IsCompressedFormat(evtc)) { using (var arch = new ZipArchive(fs, ZipArchiveMode.Read)) { if (arch.Entries.Count != 1) { throw new InvalidDataException("Invalid Archive"); } using (Stream data = arch.Entries[0].Open()) { using (var ms = new MemoryStream()) { data.CopyTo(ms); ms.Position = 0; ParseLog(operation, ms); }; } } } else { ParseLog(operation, fs); } } operation.UpdateProgressWithCancellationCheck("Data parsed"); return(new ParsedLog(_buildVersion, _fightData, _agentData, _skillData, _combatItems, _playerList, _logEndTime - _logStartTime, _parserSettings, operation)); }
public void StartLearning() { learning = true; Debug.Log("PLACE_TO_POSE STARTED LEARNING STANDALONE"); //if (objectToPlace == null) { // objectToPlace = Instantiate(BasicObjectManipulatablePrefab, world_anchor.transform); //} Visualize(); UISoundManager.Instance.PlaySnap(); objectToPlace.GetComponent <ObjectManipulationEnabler>().EnableManipulation(); objectToPlace.transform.GetChild(0).GetComponent <Collider>().enabled = false; objectToPlace.GetComponent <PlaceRotateConfirm>().snapLocalRotation = objectToPlace.transform.rotation; objectToPlace.transform.parent = cursor.transform; objectToPlace.transform.localPosition = new Vector3(0, 0, objectToPlace.transform.GetChild(0).transform.localScale.x / 2); //objectToPlace.transform.localEulerAngles = new Vector3(0f, 90f, 0f); ProgramItemMsg referenceItem = ProgramHelper.GetProgramItemById(interfaceStateMsg.GetBlockID(), programItemMsg.GetRefID()[0]); objectToPlace.GetComponent <PlaceRotateConfirm>().Arm = (ROSUnityCoordSystemTransformer.ConvertVector(referenceItem.GetPose()[0].GetPose().GetPosition().GetPoint()).x > MainMenuManager.Instance.currentSetup.GetTableWidth() / 2) ? RobotHelper.RobotArmType.LEFT_ARM : RobotHelper.RobotArmType.RIGHT_ARM; objectToPlace.GetComponent <PlaceRotateConfirm>().object_attached = true; //objectToPlace.transform.localPosition = placePose; //objectToPlace.transform.localRotation = placeOrientation; //objectToPlace.transform.GetChild(0).transform.localScale = objectDims; }
public void Visualize() { if (ProgramHelper.ItemLearned(programItemMsg)) { //TODO get reference ID of previous PICK and get ObjectType ProgramItemMsg referenceItem = ProgramHelper.GetProgramItemById(interfaceStateMsg.GetBlockID(), programItemMsg.GetRefID()[0]); Vector3 placePose = ROSUnityCoordSystemTransformer.ConvertVector(programItemMsg.GetPose()[0].GetPose().GetPosition().GetPoint()); Quaternion placeOrientation = ROSUnityCoordSystemTransformer.ConvertQuaternion(programItemMsg.GetPose()[0].GetPose().GetOrientation().GetQuaternion()); Vector3 objectDims = ObjectsManager.Instance.GetObjectTypeDimensions(referenceItem.GetObject()[0]); //objectToPlaceUnmanipulatable = Instantiate(BasicObjectUnmanipulatablePrefab, world_anchor.transform); //objectToPlaceUnmanipulatable.transform.localPosition = placePose; //objectToPlaceUnmanipulatable.transform.localRotation = placeOrientation; //objectToPlaceUnmanipulatable.transform.GetChild(0).transform.localScale = objectDims; if (objectToPlace == null || objectToPlace.Equals(null)) { objectToPlace = Instantiate(BasicObjectManipulatablePrefab, world_anchor.transform); Debug.Log("Instantiating object"); } objectToPlace.GetComponent <ObjectManipulationEnabler>().DisableManipulation(); objectToPlace.transform.localPosition = placePose; objectToPlace.transform.localRotation = placeOrientation; objectToPlace.transform.GetChild(0).transform.localScale = objectDims; } }
public async Task Run() { WriteLine("1. Use UDF"); WriteLine("2. Create"); UDFOption option = (UDFOption)ProgramHelper.EnterInt(""); switch (option) { case UDFOption.Use: { // The function work with zips collection and msnet18sql database. // If you need a different collection or database, please write a piece of code to input data into the program. string id = ProgramHelper.EnterText("Id "); SqlQuerySpec query = new SqlQuerySpec() { QueryText = "SELECT c.id, c.loc, udf.udfCityState(c) as CityState FROM c where c.id = @id", Parameters = new SqlParameterCollection() { new SqlParameter("@id", id) } }; Document document = _documentRepository.ReadDocumentByQuery <Document>(UriFactory.CreateDocumentCollectionUri(DatabaseId, CollectionId), query).ToList().FirstOrDefault(); WriteLine(document.ToString()); break; } case UDFOption.Create: { UserDefinedFunction udfDefinition = new UserDefinedFunction { Id = "udfRegex", Body = File.ReadAllText(@"Scripts\udfRegex.js") }; string databaseName = ""; DocumentCollection collectionName = null; if (!InsertCollAndDatabase(ref databaseName, ref collectionName)) { Warning("Collection >>> " + collectionName + " <<< don't exist."); collectionName = await _collectionRepository.CreateCollection(databaseName, collectionName.Id); ProgramHelper.Wait(); } UserDefinedFunction newUDFunction = await _udfRepository.CreateUDFAsync(UriFactory.CreateDocumentCollectionUri(databaseName, collectionName.Id), udfDefinition); WriteLine(string.Format("Created trigger {0}; RID: {1}", newUDFunction.Id, newUDFunction.ResourceId)); break; } default: break; } }
static void Main() { ProgramConverter[] converters = ProgramConverterGenerator(10); for (int i = 0; i < converters.Length; i++) { if (converters[i] is ICodeChecker) { ProgramHelper programHelper = converters[i] as ProgramHelper; Console.WriteLine("Code check complete: " + programHelper.CheckCodeSyntax("dim next", "vb")); Console.WriteLine("Converting to C#. Before conversion: var a"); Console.WriteLine("After conversion: " + programHelper.ConvertToCSharp("var a")); Console.WriteLine("Converting to VB. Before conversion: int a"); Console.WriteLine("After conversion: " + programHelper.ConvertToCSharp("int a")); } else { Console.WriteLine("Converting to C#. Before conversion: var a"); System.Console.WriteLine(converters[i].ConvertToCSharp("var a")); Console.WriteLine("Converting to VB. Before conversion: int a"); System.Console.WriteLine(converters[i].ConvertToVB("int a")); } } }
/// <summary> /// Cancel the lot, return asset to owner /// </summary> /// <param name="lotId"> Id of the lot </param> /// <remarks> /// If the lot is closed, it is not to be shown /// in Expload Auction UI (eXPept for lot creator's lot history). /// The lot is permanently closed and archived, it can't be reopened. /// </remarks> public void CloseLot(long lotId) { // Check if sender has permission to do this AssertIsLotCreator(lotId); // Get the lot object var lot = GetLot(lotId); // Check if the lot is already closed if (lot.Closed) { Error.Throw("The lot is already closed."); } // Change the lot state and write it to the storage lot.Closed = true; _new_lots[lotId] = lot; // Return the asset to the owner var gameAddress = _GetGameAddress(lot.GameId, lot.IsXG); if (lot.IsXG) { ProgramHelper.Program <TradableXGAsset>(gameAddress).TransferXGAsset(lot.AssetId, lot.Owner); } else { ProgramHelper.Program <TradableXPAsset>(gameAddress).TransferXPAsset(lot.AssetId, lot.Owner); } // Emit an event Log.Event("lotClosed", lot.Id); }
public void TestUpdateCheck() { String s = ProgramHelper.UpdateCheck(); String[] temp = s.Split(','); Assert.AreEqual(4, temp.Length); }
//Main Parse method------------------------------------------------------------------------------------------------------------------------------------------------ /// <summary> /// Parses the given log /// </summary> /// <param name="row">GridRow object bound to the UI</param> /// <param name="evtc">The path to the log to parse</param> /// <returns>the ParsedLog</returns> public ParsedLog ParseLog(GridRow row, string evtc) { row.BgWorker.UpdateProgress(row, "10% - Reading Binary...", 10); using (var fs = new FileStream(evtc, FileMode.Open, FileAccess.Read, FileShare.Read)) { if (ProgramHelper.IsCompressedFormat(evtc)) { using (var arch = new ZipArchive(fs, ZipArchiveMode.Read)) { if (arch.Entries.Count != 1) { throw new InvalidDataException("Error Encountered: Invalid Archive"); } using (Stream data = arch.Entries[0].Open()) { using (var ms = new MemoryStream()) { data.CopyTo(ms); ms.Position = 0; ParseLog(row, ms); }; } } } else { ParseLog(row, fs); } } row.BgWorker.ThrowIfCanceled(row); row.BgWorker.UpdateProgress(row, "45% - Data parsed", 45); return(new ParsedLog(_buildVersion, _fightData, _agentData, _skillData, _combatItems, _playerList, _logEndTime - _logStartTime, _parserSettings)); }
//Main Parse method------------------------------------------------------------------------------------------------------------------------------------------------ /// <summary> /// Parses the given log /// </summary> /// <param name="row">GridRow object bound to the UI</param> /// <param name="evtc">The path to the log to parse</param> /// <returns>the ParsedLog</returns> public ParsedLog ParseLog(GridRow row, string evtc) { row.BgWorker.UpdateProgress(row, "10% - Reading Binary...", 10); using (var fs = new FileStream(evtc, FileMode.Open, FileAccess.Read, FileShare.Read)) { if (ProgramHelper.IsCompressedFormat(evtc)) { using (var arch = new ZipArchive(fs, ZipArchiveMode.Read)) { if (arch.Entries.Count != 1) { throw new InvalidDataException("Invalid Archive"); } using (var data = arch.Entries[0].Open()) { ParseLog(row, data); } } } else { ParseLog(row, fs); } } row.BgWorker.ThrowIfCanceled(row); row.BgWorker.UpdateProgress(row, "40% - Data parsed", 40); return(new ParsedLog(_buildVersion, _fightData, _agentData, _skillData, _combatItems, _playerList)); }
public Asset[] test_UsersItems() { // Init addresses and get program by address Bytes programOwner = new Bytes("fb75559bb4bb172ca0795e50b390109a50ce794466a14c24c73acdb40604065b"); Bytes assetOwner = new Bytes("a1fe824f193bcee32f33b9e01245bd41f05a157eca73daf65d70ebd27430836d"); // Set auction address to this contract address ProgramHelper.Program <TradableXGAsset>(programOwner).SetAuction(Info.ProgramAddress()); // Emit 3 assets Bytes classId = new Bytes("0000000000000000000000000000000000000000000000000000000000000001"); Bytes instanceId = new Bytes("0000000000000000000000000000000000000000000000000000000000000001"); long assetId = ProgramHelper.Program <TradableXGAsset>(programOwner).EmitXGAsset( assetOwner, classId, instanceId ); classId = new Bytes("0000000000000000000000000000000000000000000000000000000000000002"); instanceId = new Bytes("0000000000000000000000000000000000000000000000000000000000000002"); assetId = ProgramHelper.Program <TradableXGAsset>(programOwner).EmitXGAsset( assetOwner, classId, instanceId ); classId = new Bytes("0000000000000000000000000000000000000000000000000000000000000003"); instanceId = new Bytes("0000000000000000000000000000000000000000000000000000000000000003"); assetId = ProgramHelper.Program <TradableXGAsset>(programOwner).EmitXGAsset( assetOwner, classId, instanceId ); // Return list of asset objects return(ProgramHelper.Program <TradableXGAsset>(programOwner).GetUsersAllXGAssetsData(assetOwner)); }
public AddGroupSubjectModel(School injectedContext) { db = injectedContext; helper = new ProgramHelper(db); GroupSubjects = db.GroupSubjects; Groups = db.SchoolGroups; Subjects = db.Subjects; }
public AddTeacherSubjectModel(School injectedContext) { db = injectedContext; helper = new ProgramHelper(db); TeacherSubjects = db.TeacherSubjects; Teachers = db.Teachers; Subjects = db.Subjects; }
/// <summary> /// Buy desired lot /// </summary> /// <param name="lotId"> Id of the lot </param> public void BuyLot(long lotId) { // Get the lot object Lot lot = GetLot(lotId); // Check if the lot is not closed yet if (lot.Closed) { Error.Throw("The lot is already closed."); } // Take the money from buyer and transfer the asset to him Bytes gameAddress = _GetGameAddress(lot.GameId, lot.IsXG); long ownerFee = (long)(lot.Price / (1 + ((double)(lot.AuctionCommission + lot.GameCommission)) / 100)); long gameFee = (long)(ownerFee * (1 + ((double)lot.GameCommission) / 100)) - ownerFee; if (lot.IsXG) { ProgramHelper.Program <XGold>(XGAddress).Spend(Info.ProgramAddress(), lot.Price); ProgramHelper.Program <XGold>(XGAddress).Refund(Info.ProgramAddress(), lot.Owner, ownerFee); if (gameFee > 0) { ProgramHelper.Program <XGold>(XGAddress).Refund(Info.ProgramAddress(), gameAddress, gameFee); } ProgramHelper.Program <TradableXGAsset>(gameAddress).TransferXGAsset(lot.AssetId, Info.Sender()); } else { Actions.Transfer(Info.ProgramAddress(), lot.Price); Actions.TransferFromProgram(lot.Owner, ownerFee); if (gameFee > 0) { Actions.TransferFromProgram(gameAddress, gameFee); } ProgramHelper.Program <TradableXPAsset>(gameAddress).TransferXPAsset(lot.AssetId, Info.Sender()); } // Alter the lot state and write it to the storage lot.Closed = true; lot.Buyer = Info.Sender(); lot.PurchaseTime = Info.LastBlockTime(); _new_lots[lotId] = lot; // Put the lot into buyer storage (for history log) var userStorageLastId = _userLotsCount.GetOrDefault(Info.Sender(), 0); var userLotsKey = GetUserLotKey(Info.Sender(), userStorageLastId); _userLots[userLotsKey] = lotId; _userLotsCount[Info.Sender()] = userStorageLastId + 1; // Emit an event Log.Event("lotBought", lot.Id); }
public void Calculate(object obj) { try { var programConverters = new ProgramConverter[ConvertersCount]; for (var i = 0; i < programConverters.Length / 2; i++) { programConverters[i] = new ProgramConverter(); } for (var i = programConverters.Length / 2; i < programConverters.Length; i++) { programConverters[i] = new ProgramHelper(); } OutputWriteLine($"[0 - {-1 + programConverters.Length / 2}] elements is {nameof(ProgramConverter)}"); OutputWriteLine( $"[{programConverters.Length / 2} - {programConverters.Length - 1}] elements is {nameof(ProgramHelper)}"); OutputWriteLine(string.Empty); const string vbCode = "var"; for (var i = 0; i < programConverters.Length; i++) { var converter = programConverters[i]; if (converter is ICodeChecker) { var codeChecker = converter as ICodeChecker; OutputWriteLine($"[{i}] is ICodeChecker"); if (codeChecker.CheckCodeSyntax(vbCode, Language.CSharp_Code)) { OutputWriteLine($"\t{vbCode} -> {converter.ConvertToVB(vbCode)}"); } else if (codeChecker.CheckCodeSyntax(vbCode, Language.VB_Code)) { OutputWriteLine($"\t{vbCode} -> {converter.ConvertToCSharp(vbCode)}"); } else { OutputWriteLine("\t{str} - Unknown language"); } } else { OutputWriteLine($"[{i}] is not ICodeChecker"); OutputWriteLine($"\t{programConverters[i].ConvertToCSharp(vbCode)}"); OutputWriteLine($"\t{programConverters[i].ConvertToVB(vbCode)}"); } } } catch (Exception exception) { MessageBox.Show(exception.Message); } OnPropertyChanged(nameof(Output)); }
public int TestPcall() { Bytes address1 = new Bytes("1eaed20b7ce2b336043e4b340b031f95bb1ce6d935ef733ae4df1b66e1e3d91f"); int a = ProgramHelper.Program <PcallProgram>(address1).Add(1, 2); Bytes address2 = new Bytes(new sbyte[] { 30, -82, -46, 11, 124, -30, -77, 54, 4, 62, 75, 52, 11, 3, 31, -107, -69, 28, -26, -39, 53, -17, 115, 58, -28, -33, 27, 102, -31, -29, -39, 31 }); int b = ProgramHelper.Program <PcallProgram>(address2).Add(3, 4); return(a + b); }
public int TestPcall() { Bytes address1 = new Bytes("1eaed20b7ce2b336043e4b340b031f95bb1ce6d935ef733ae4df1b66e1e3d91f"); int a = ProgramHelper.Program <PcallProgram>(address1).Add(1, 2); Bytes address2 = new Bytes(new byte[] { 30, 174, 210, 11, 124, 226, 179, 54, 4, 62, 75, 52, 11, 3, 31, 149, 187, 28, 230, 217, 53, 239, 115, 58, 228, 223, 27, 102, 225, 227, 217, 31 }); int b = ProgramHelper.Program <PcallProgram>(address2).Add(3, 4); return(a + b); }
private static Project GetProject(IEnumerable <string> sourceFiles, bool runInSerial) { StageStopwatch.Restart(); Report.NewStatus("Analysing project block structure... "); var proj = ProgramHelper.ParseProject(sourceFiles, runInSerial); SaveTiming("project-parsing", StageStopwatch.ElapsedMilliseconds); Report.ContinueStatus("Done"); return(proj); }
public void ProcessArguments(string[] args) { argumentDictionary = ProgramHelper.GetArgumentPair(args.ToList()); ValidateArguments(); titelLabel.Text = argumentDictionary["programname"]; Text = argumentDictionary["programname"]; webSiteUrl.Text = argumentDictionary["activationurl"]; }
/// <summary> /// Returns a reference to the ProgramHelper of a program. /// </summary> /// <returns>ProgramHelper.</returns> /// <param name="programName">Program name.</param> public ProgramHelper WithName(string programName) { var program = homegenie.ProgramManager.Programs.Find(p => p.Name.ToLower() == programName.ToLower()); ProgramHelper programHelper = null; if (program != null) { programHelper = new ProgramHelper(homegenie, program.Address); } return(programHelper); }
/// <summary> /// Returns a reference to the ProgramHelper of a program. /// </summary> /// <returns>ProgramHelper.</returns> /// <param name="programAddress">Program address (id).</param> public ProgramHelper WithAddress(int programAddress) { var program = homegenie.ProgramManager.Programs.Find(p => p.Address == programAddress); ProgramHelper programHelper = null; if (program != null) { programHelper = new ProgramHelper(homegenie, program.Address); } return(programHelper); }
public void SaveObjectPosition(Vector3 position, Quaternion rotation) { learning = false; ProgramHelper.LoadProgram = true; PlacePosition = new Vector3(position.x, position.y, ObjectsManager.Instance.GetObjectTypeDimensions(ProgramHelper.GetProgramItemById(interfaceStateMsg.GetBlockID(), programItemMsg.GetRefID()[0]).GetObject()[0]).x / 2); PlaceOrientation = rotation; StartCoroutine(SaveToROS()); }
static void Main() { ProgramHelper.MainWrapper(() => { CultureInfo culture = CultureInfo.InvariantCulture; CultureInfo.DefaultThreadCurrentCulture = culture; CultureInfo.DefaultThreadCurrentUICulture = culture; Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new MainForm()); }); }
public new static void CallBack(ROSBridgeMsg msg) { InterfaceStateMsg Imsg = (InterfaceStateMsg)msg; VisualizationManager.Instance.SetInterfaceStateMsgFromROS(Imsg); //InteractiveEditManager.Instance.SetInterfaceStateMsgFromROS(Imsg); //PickFromPolygonIE.Instance.SetInterfaceStateMsgFromROS(Imsg); //PlaceToPoseIE.Instance.SetInterfaceStateMsgFromROS(Imsg); //InteractiveProgrammingManager.Instance.SetInterfaceStateMsgFromROS(Imsg); ProgramHelper.SetInterfaceStateMsgFromROS(Imsg); }
private static void Main() { if (ProgramHelper.HasExist()) { Application.Exit(); } else { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new FormMain()); } }
// Checks if caller owns a particular asset private void AssertIsItemOwner(long gameId, long assetId, bool isXG) { var gameAddress = _GetGameAddress(gameId, isXG); var assetOwner = isXG ? ProgramHelper.Program <TradableXGAsset>(gameAddress).GetXGAssetOwner(assetId) : ProgramHelper.Program <TradableXPAsset>(gameAddress).GetXPAssetOwner(assetId); if (Info.Sender() != assetOwner) { Error.Throw("Only asset owner can do this."); } }