Beispiel #1
0
 public Status(float AviableMoney, float currentstack, bool ontable, PT pt = PT.HUMAN)
 {
     _AviableMoney = AviableMoney;
     _currentstack = currentstack;
     _ontable      = ontable;
     player        = pt;
 }
Beispiel #2
0
        private static object GetAttachedObject(string propertyName, object attachedTo)
        {
            // This function assumes that the propertyName is not a path (no '.' in it)

            int    index = propertyName.IndexOf('[');
            string nonIndexedProperty = (index < 0) ? propertyName : propertyName.Substring(0, index);

            TrustedType         trustedType = PT.Trust(attachedTo.GetType());
            TrustedPropertyInfo property    = trustedType.GetProperty(nonIndexedProperty);
            object returnValue = property.GetValue(attachedTo, null);

            if (index < 0)
            {
                // This isn't a collection, just return what we got.
                return(returnValue);
            }
            else
            {
                // This is a collection. Parse the index string and return the value at that index.
                int    indexLength = propertyName.Length - nonIndexedProperty.Length - 2;
                string s           = propertyName.Substring(index + 1, indexLength).Trim();
                int    i           = StringConverter.ToInt(s);

                // Visual3DCollection does not implement IList like the other collections do :(
                if (returnValue is Visual3DCollection)
                {
                    return(((Visual3DCollection)returnValue)[i]);
                }
                else
                {
                    return(((IList)returnValue)[i]);
                }
            }
        }
Beispiel #3
0
        public bool Parse(string Text)
        {
            compilerDirectives = new List <compiler_directive>();

            PT parsertools = new PT(); // контекст сканера и парсера

            parsertools.errors          = Errs;
            parsertools.CurrentFileName = Path.GetFullPath(FileName);

            var scanner = new PreprocessorScanner();

            scanner.SetSource(Text, 0);
            //scanner.parsertools = parsertools;// передали parsertools в объект сканера

            var parser = new PreprocessorParser(scanner);

            parser.compilerDirectives = compilerDirectives;
            //parser.parsertools = parsertools; // передали parsertools в объект парсера

            if (!parser.Parse())
            {
                parsertools.AddError("Неопознанная синтаксическая ошибка препроцессора!", null);
                return(false);
            }
            return(true);
        }
        public expression ParseExpression(string Text, int line, int col)
        {
            PT parsertools = new PT(); // контекст сканера и парсера

            parsertools.errors          = new List <Error>();
            parsertools.warnings        = new List <CompilerWarning>();
            parsertools.CurrentFileName = System.IO.Path.GetFullPath(this.parsertools.CurrentFileName);
            parsertools.build_tree_for_format_strings = true;
            Scanner scanner = new Scanner();

            scanner.SetSource("<<expression>>" + Text, 0);
            scanner.parsertools = parsertools;// передали parsertools в объект сканера
            GPPGParser parser = new GPPGParser(scanner);

            parsertools.build_tree_for_formatter = false;
            parser.lambdaHelper = this.lambdaHelper;
            parser.parsertools  = parsertools;
            if (!parser.Parse())
            {
                if (parsertools.errors.Count == 0)
                {
                    parsertools.AddError("Неопознанная синтаксическая ошибка!", null);
                }
            }
            foreach (Error err in parsertools.errors)
            {
                this.parsertools.errors.Add(err);
            }
            return(parser.root as expression);
        }
Beispiel #5
0
        public List <PT> GetPointsInRoom(int group_id)
        {
            // find seed with matching group_id
            PT seed = new PT()
            {
                x = -1, y = -1
            };

            foreach (PT v in seeds)
            {
                if (map.t(v).group_id == group_id)
                {
                    seed = v;
                    break;
                }
            }

            // make sure we actually found something
            if (seed.x < 0 || seed.y < 0)
            {
                Console.WriteLine("group id " + group_id + " not found!");
                return(null);
            }

            List <PT>  visited   = new List <PT>();
            Queue <PT> unvisited = new Queue <PT>();

            List <PT> pointsInGroup = new List <PT>();

            unvisited.Enqueue(seed);

            while (unvisited.Count > 0)
            {
                PT pt = unvisited.Dequeue();
                visited.Add(pt);

                if (map.t(pt).group_id == group_id)
                {
                    pointsInGroup.Add(pt);
                }

                PT[] adj = MapGenerator.GetAdjacentTiles(map, pt);
                foreach (PT n in adj)
                {
                    if (map.t(n).type == Tile.Type.IMPASSABLE)
                    {
                        continue;
                    }

                    if (!visited.Contains(n))
                    {
                        visited.Add(n);
                        unvisited.Enqueue(n);
                    }
                }
            }

            return(pointsInGroup);
        }
Beispiel #6
0
        private void RefreshAngleState(bool init)
        {
            if (init)
            {
                ////////////////////////
                // Setup Ranges

                // use 'soft limits' rather than 'user limits' because the 'soft limits' *are* the user limits (or rather, the current limits-in-effect)
                int panMinSteps  = PT.GetPanPositionLimitMin();
                int panMaxSteps  = PT.GetPanPositionLimitMax();
                int tiltMinSteps = PT.GetTiltPositionLimitMin();
                int tiltMaxSteps = PT.GetTiltPositionLimitMax();

                double panMinDegs  = PT.ConvertPanStepsToDegrees(panMinSteps);
                double panMaxDegs  = PT.ConvertPanStepsToDegrees(panMaxSteps);
                double tiltMinDegs = PT.ConvertTiltStepsToDegrees(tiltMinSteps);
                double tiltMaxDegs = PT.ConvertTiltStepsToDegrees(tiltMaxSteps);

                __pan.BaseAngle  = -180d;
                __tilt.BaseAngle = -180d;

                // hmm, it seems with the D48 in 360-deg mode (and how the fark did it get into that state?) it returns a value just-beyond 180... but for the tilt axis. This is weird.
                __pan.RangeMin = panMinDegs < -180 ? -180 : panMinDegs;
                __pan.RangeMax = panMaxDegs > 180 ?  180 : panMaxDegs;

                __tilt.RangeMin = tiltMinDegs < -180 ? -180 : tiltMinDegs;
                __tilt.RangeMax = tiltMaxDegs > 180 ?  180 : tiltMaxDegs;
            }

            _q.AddCommand(new PTQueuedCommandInfo("Idle", delegate(PTUnit unit) {              // "Idle" is a lie, it's really polling, but whatever; when you set it to "Polling" it just flashes annoyingly
                ////////////////////////
                // Set position

                short panStepsDes, tiltStepsDes;
                short panStepsCur, tiltStepsCur;

                PT.GetCurrentPosition(out panStepsCur, out tiltStepsCur);
                panStepsDes  = PT.GetPanDesiredPosition();
                tiltStepsDes = PT.GetTiltDesiredPosition();

                Double panDegreesDes  = PT.ConvertPanStepsToDegrees(panStepsDes);
                Double tiltDegreesDes = PT.ConvertTiltStepsToDegrees(tiltStepsDes);
                Double panDegreesCur  = PT.ConvertPanStepsToDegrees(panStepsCur);
                Double tiltDegreesCur = PT.ConvertTiltStepsToDegrees(tiltStepsCur);

                // Angle0 = Desired Position
                // Angle1 = Current Position

                Invoke(new DoSub(delegate() {
                    if (IsDisposed)
                    {
                        return;
                    }

                    __pan.SetAngles(new Double[] { panDegreesDes, panDegreesCur });
                    __tilt.SetAngles(new Double[] { tiltDegreesDes, tiltDegreesCur });
                }));
            }));
        }
        /// <summary>
        /// 创建fieldtype,如CE,XCN等
        /// </summary>
        /// <param name="parent"></param>
        /// <param name="product"></param>
        /// <param name="name"></param>
        /// <returns></returns>
        public override abstractType Create(compositeType parent, Enum product, string name)
        {
            abstractType tmp = null;

            switch (product)
            {
            case enumField.CE: tmp = new CE(parent, name); break;

            case enumField.CM: tmp = new CM(parent, name); break;

            case enumField.CWE: tmp = new CWE(parent, name); break;

            case enumField.CX: tmp = new CX(parent, name); break;

            case enumField.DLN: tmp = new DLN(parent, name); break;

            case enumField.EI: tmp = new EI(parent, name); break;

            case enumField.ELD: tmp = new ELD(parent, name); break;

            case enumField.FN: tmp = new FN(parent, name); break;

            case enumField.HD: tmp = new HD(parent, name); break;

            case enumField.MSG: tmp = new MSG(parent, name); break;

            case enumField.PT: tmp = new PT(parent, name); break;

            case enumField.VID: tmp = new VID(parent, name); break;

            case enumField.XAD: tmp = new XAD(parent, name); break;

            case enumField.XCN: tmp = new XCN(parent, name); break;

            case enumField.XPN: tmp = new XPN(parent, name); break;

            case enumField.XTN: tmp = new XTN(parent, name); break;

            case enumField.ERL: tmp = new ERL(parent, name); break;

            case enumField.FC: tmp = new FC(parent, name); break;

            case enumField.XON: tmp = new XON(parent, name); break;

            case enumField.PL: tmp = new PL(parent, name); break;

            case enumField.CP: tmp = new CP(parent, name); break;

            case enumField.JCC: tmp = new JCC(parent, name); break;

            case enumField.TQ: tmp = new TQ(parent, name); break;

            case enumField.CQ: tmp = new CQ(parent, name); break;

            default: throw new NotSupportedException();
            }
            return(tmp);
        }
Beispiel #8
0
        public async Task <ActionResult> DeleteConfirmed(int id)
        {
            PT pT = await db.PT.FindAsync(id);

            db.PT.Remove(pT);
            await db.SaveChangesAsync();

            return(RedirectToAction("Index"));
        }
 public void RoundTripTest()
 {
     Assert.AreEqual((byte)123, PT.RoundTrip((byte)123));
     Assert.AreEqual((short)12345, PT.RoundTrip((short)12345));
     Assert.AreEqual((int)12345678, PT.RoundTrip((int)12345678));
     Assert.AreEqual((long)123456789101112, PT.RoundTrip((long)123456789101112));
     Assert.AreEqual((float)1.23, PT.RoundTrip((float)1.23));
     Assert.AreEqual((double)1.23456789, PT.RoundTrip((double)1.23456789));
 }
Beispiel #10
0
 public Status(float HP, float EN, float Money, float Food, PT pt = PT.HUMAN)
 {
     playercounter++;
     _HP    = HP;
     _EN    = EN;
     _Money = Money;
     _Food  = Food;
     player = pt;
 }
 public FuncEntry(func f, int minimum, int max, PT type)
 {
     fname          = f.Method.Name;
     numberparasmin = minimum;
     paratype       = new PT[max];
     for (int i = 0; i < max; i++)
     {
         paratype[i] = type;
     }
 }
Beispiel #12
0
 public MSH()
 {
     SendingApplication   = new EI();
     SendingFacility      = new EI();
     ReceivingApplication = new EI();
     ReceivingFacility    = new EI();
     MessageType          = new MSG();
     ProcessingID         = new PT();
     VersionID            = new VID();
 }
Beispiel #13
0
        static void Main(string[] args)
        {
            if (!Log.init())
            {   //Abort..
                Console.WriteLine("Logger initialization failed, exiting..");
                Thread.Sleep(10000);
                return;
            }

            DdMonitor.bNoSync        = false;
            DdMonitor.bEnabled       = false;
            DdMonitor.DefaultTimeout = -1;

            //Register our catch-all exception handler
            Thread.GetDomain().UnhandledException += onException;

            //Create a logging client for the main loader thread
            LogClient handlerLogger = Log.createClient("LoaderHandler");

            Log.assume(handlerLogger);

            //Is Diablo 3 available?
            IntPtr pHandle = PT.GetProcessHandle(exeName);

            if (pHandle == IntPtr.Zero)
            {
                Log.write("Failed to find game process, Is Diablo 3 running?");
                Thread.Sleep(8000);
                return;
            }

            Globals.mem.Attach();


            //Initilize the bot!
            Game.Bot bot = new Game.Bot();
            if (!bot.init())
            {
                Log.write("Failed to initialize D3BLoader, exiting...");
                Thread.Sleep(8000);
                return;
            }

            //Begin!
            bot.begin();

            Log.write("D3BLoader running...");

            while (true)
            {
                Console.Read();
            }
        }
Beispiel #14
0
        public async Task <ActionResult> Edit([Bind(Include = "Id,Monto,Interes,Plazo,Cuota,CIID,FechaInicioPrestamo")] PT pT)
        {
            if (ModelState.IsValid)
            {
                db.Entry(pT).State = EntityState.Modified;
                await db.SaveChangesAsync();

                return(RedirectToAction("Index"));
            }
            ViewBag.CIID = new SelectList(db.CI, "Id", "Nombre", pT.CIID);
            return(View(pT));
        }
Beispiel #15
0
        public void ParsePacket(CustomPacket packet)
        {
            PT packetProtocolID = (PT)packet.PopProtocalID();

            switch (packetProtocolID)
            {
            case PT.PT_CS_LOGIN_REQ:
                break;

            case PT.PT_CS_CHAT_REQ:
                CS_CHAT_REQ(packet);
                break;
            }
        }
Beispiel #16
0
        /// <summary>
        /// public wrapper of the internal API "DependencyProperty.FromName"
        /// </summary>
        /// <param name="propertyName">The name of the property to get</param>
        /// <param name="propertyType">The type of the property owner</param>
        /// <returns>The DependencyProperty represented by the name/type pair</returns>
        /// <exception cref="ArgumentException">Thrown when propertyName is not a valid DependencyProperty on propertyType</exception>
        public static DependencyProperty GetDependencyProperty(string propertyName, Type propertyType)
        {
            TrustedType      trustedType = PT.Trust(propertyType);
            TrustedFieldInfo field       = trustedType.GetField(
                propertyName + "Property",
                BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy
                );

            if (field == null)
            {
                throw new ArgumentException("Could not locate property " + propertyName + " on " + propertyType.Name, "propertyName");
            }
            return((DependencyProperty)field.GetValue(null));
        }
Beispiel #17
0
        public string GetString(PT pt, char ss)
        {
            var sb = new StringBuilder();

            if (!string.IsNullOrWhiteSpace(pt.ProcessingID.Value))
            {
                sb.Append($"{pt.ProcessingID.Value}");
            }
            if (!string.IsNullOrWhiteSpace(pt.ProcessingMode.Value))
            {
                sb.Append($"{ss}{pt.ProcessingMode.Value}");
            }
            return(sb.ToString());
        }
Beispiel #18
0
        // GET: PTs/Details/5
        public async Task <ActionResult> Details(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            PT pT = await db.PT.FindAsync(id);

            if (pT == null)
            {
                return(HttpNotFound());
            }
            return(View(pT));
        }
Beispiel #19
0
        // GET: PTs/Edit/5
        public async Task <ActionResult> Edit(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            PT pT = await db.PT.FindAsync(id);

            if (pT == null)
            {
                return(HttpNotFound());
            }
            ViewBag.CIID = new SelectList(db.CI, "Id", "Nombre", pT.CIID);
            return(View(pT));
        }
Beispiel #20
0
        private void RefreshSliderState(bool init)
        {
            ///////////////////////////////
            // Pan

            short panSpeed = (short)PT.GetPanDesiredSpeed();

            if (init)
            {
                if (panSpeed > __panSpeed.Maximum || panSpeed < __panSpeed.Minimum)
                {
                    panSpeed = (short)((__panSpeed.Maximum - __panSpeed.Minimum) / 2);
                    PT.SetPanDesiredSpeed(panSpeed);
                }

                __panSpeed.Minimum = __panBase.Minimum = PT.GetPanSpeedLimitMin();
                __panSpeed.Maximum = __panBase.Maximum = PT.GetPanSpeedLimitMax();
            }

            __panSpeed.Value = panSpeed;
            __panBase.Value  = PT.GetPanBaseSpeed();
            __panAccl.Value  = (int)PT.GetPanAcceleration();

            ///////////////////////////////
            // Tilt

            short tiltSpeed = (short)PT.GetTiltDesiredSpeed();

            if (init)
            {
                if (tiltSpeed > __tiltSpeed.Maximum || tiltSpeed < __tiltSpeed.Minimum)
                {
                    tiltSpeed = (short)((__tiltSpeed.Maximum - __tiltSpeed.Minimum) / 2);
                    PT.SetTiltDesiredSpeed(tiltSpeed);
                }

                __tiltSpeed.Minimum = __tiltBase.Minimum = PT.GetTiltSpeedLimitMin();
                __tiltSpeed.Maximum = __tiltBase.Maximum = PT.GetTiltSpeedLimitMax();
            }

            UInt32 tiltAccel = PT.GetTiltAcceleration();

            __tiltSpeed.Value = tiltSpeed;
            __tiltBase.Value  = PT.GetTiltBaseSpeed();
            __tiltAccl.Value  = (int)tiltAccel;
        }
Beispiel #21
0
        public int[] GetRoomIDs()
        {
            List <int> l = new List <int>();

            for (int a = 0; a < seeds.Count; a++)
            {
                PT   pt   = seeds[a];
                Tile tile = map.t(pt);

                if (!l.Contains(tile.group_id))
                {
                    l.Add(tile.group_id);
                }
            }

            return(l.ToArray());
        }
Beispiel #22
0
        /// <summary>
        /// Get the object that owns the property specified.
        /// </summary>
        /// <param name="complexPropertyPath">A "dot-down" path to a property</param>
        /// <param name="attachedTo">The object to start the search from</param>
        /// <returns>The object that owns the property specified</returns>
        /// <exception cref="ArgumentException">Thrown when the path does not lead to a valid object</exception>
        public static object GetPropertyOwner(string complexPropertyPath, object attachedTo)
        {
            // complexProperty will come in like this:
            //
            //  path == Thickness                   attachedTo == ScreenSpaceLines3D    return: ScreenSpaceLines3D
            //  path == Material[0].Brush.Color     attachedTo == GeometryModel3D       return: Brush
            //  path == Brush.Color                 attachedTo == Material              return: Brush
            //  path == Color                       attachedTo == Brush                 return: Brush
            //  path == Children[0]                 attachedTo == Viewport3D            return: Visual3DCollection

            int dotIndex = complexPropertyPath.IndexOf('.');

            if (dotIndex < 0)
            {
                int bracketIndex = complexPropertyPath.IndexOf('[');
                if (bracketIndex < 0)
                {
                    // The property should be on the object we're looking at right now.
                    // Throw an exception if the property does not exist on this object.
                    TrustedType         trustedType = PT.Trust(attachedTo.GetType());
                    TrustedPropertyInfo property    = trustedType.GetProperty(complexPropertyPath);
                    if (property == null)
                    {
                        throw new ArgumentException(complexPropertyPath + " does not exist on " + trustedType.Name);
                    }

                    return(attachedTo);
                }
                else
                {
                    // Trim the index from the property (the collection is the owner)
                    string nonIndexedProperty = complexPropertyPath.Substring(0, bracketIndex);
                    return(GetAttachedObject(nonIndexedProperty, attachedTo));
                }
            }

            // The property is not on the current object

            string localPropertyName   = complexPropertyPath.Substring(0, dotIndex);
            string remainingProperties = complexPropertyPath.Substring(dotIndex + 1);

            object next = GetAttachedObject(localPropertyName, attachedTo);

            return(GetPropertyOwner(remainingProperties, next));
        }
Beispiel #23
0
        /// <summary>
        /// Map query against structure & return highlighted match
        /// </summary>
        /// <param name="cs"></param>
        /// <returns></returns>

        public MoleculeMx HighlightMatchingSubstructure(
            MoleculeMx cs)
        {
            if (cs.IsBiopolymerFormat)             // fix later
            {
                return(cs);
            }

            MoleculeMx       cs2 = null;
            PerformanceTimer pt  = PT.Start("HighlightMatchingSubstructure");

            string molfile = CdkMolUtil.HilightSSSMatch(cs.GetMolfileString());

            cs2 = new MoleculeMx(MoleculeFormat.Molfile, molfile);

            pt.Update();
            return(cs2);
        }
Beispiel #24
0
        public static bool Phase3()
        {
            AntiProxyParams Params = PhaseParam;

            Params.asmReflection = Assembly.LoadFile(Globals.DeobContext.InPath);

            InitMethodCallList();

            foreach (var PT in Params.lstProxyTypes)
            {
                PT.InitProxyType(Params.ResolveFieldMD.MetadataToken.ToInt32(), Params.ResolveMethodMD.MetadataToken.ToInt32(), Params.asmReflection);

                DoAntiProxy(PT, Params);
                //MarkMember(PT.Type);
            }

            return(true);
        }
Beispiel #25
0
        /// <summary>
        /// Align supplied structure to query structure
        /// </summary>
        /// <param name="skid"></param>
        /// <returns></returns>

        public MoleculeMx AlignToMatchingSubstructure(
            MoleculeMx target)
        {
            if (target.IsBiopolymerFormat)             // fix later
            {
                return(target);
            }

            MoleculeMx       cs2 = null;
            PerformanceTimer pt  = PT.Start("AlignToMatchingSubstructure");
            Stopwatch        sw  = Stopwatch.StartNew();

            string molfile = CdkMolUtil.OrientToMatchingSubstructure(target.GetMolfileString());

            cs2 = new MoleculeMx(MoleculeFormat.Molfile, molfile);

            pt.Update();
            return(cs2);
        }
Beispiel #26
0
        public syntax_tree_node Parse(string Text, List <compiler_directive> compilerDirectives = null)
        {
#if DEBUG
#if _ERR
            FileInfo f  = new FileInfo(FileName);
            var      sv = Path.ChangeExtension(FileName, ".grmtrack1");
            var      sw = new StreamWriter(sv);
            Console.SetError(sw);
#endif
#endif
            PT parsertools = new PT(); // контекст сканера и парсера
            parsertools.errors             = Errs;
            parsertools.warnings           = Warnings;
            parsertools.compilerDirectives = compilerDirectives;
            parsertools.CurrentFileName    = Path.GetFullPath(FileName);


            Scanner scanner = new Scanner();
            scanner.SetSource(Text, 0);
            scanner.parsertools = parsertools;// передали parsertools в объект сканера
            if (DefinesList != null)
            {
                scanner.Defines.AddRange(DefinesList);
            }
            GPPGParser parser = new GPPGParser(scanner);
            parsertools.build_tree_for_formatter = build_tree_for_formatter;
            parser.parsertools = parsertools; // передали parsertools в объект парсера

            if (!parser.Parse())
            {
                if (Errs.Count == 0)
                {
                    parsertools.AddError("Неопознанная синтаксическая ошибка!", null);
                }
            }
#if DEBUG
#if _ERR
            sw.Close();
#endif
#endif
            return(parser.root);
        }
        private static BCColor SelectColor(PT Type, BlockColors basis)
        {
            switch (Type)
            {
            case PT.Light:
                return(basis.LightColor);

            case PT.Glint:
                return(basis.GlintColor);

            case PT.Center:
                return(basis.CenterColor);

            case PT.Shaded:
                return(basis.ShadedColor);

            default:
                return(basis.CenterColor);
            }
        }
        public PT GetValue <PT>()
        {
            PT  @default = (PT)DefaultValue;
            var user     = PluginManager.Instance.User;

            switch (Scope)
            {
            case PreferenceScope.Global:
                return(Config.GetGlobal(PreferenceKey, @default));

            case PreferenceScope.Profile:
                return(Config.GetProfile(user, PreferenceKey, @default));

            case PreferenceScope.User:
                return(Config.GetUser(user, PreferenceKey, @default));

            default:
                throw new Exception("Unhandled preference scope!");
            }
        }
Beispiel #29
0
        public async Task <ActionResult> Create([Bind(Include = "Id,Monto,Interes,Plazo,Cuota,CIID,FechaInicioPrestamo")] PT pT)
        {
            if (ModelState.IsValid)
            {
                double cantidadPagar = 0d;
                double interes       = 0d;
                double cuota         = 0d;

                cantidadPagar = pT.Monto / (pT.Plazo * 12);
                interes       = (pT.Monto * pT.Interes / 100) / 12;
                cuota         = cantidadPagar + interes;

                pT.Cuota = cuota;

                db.PT.Add(pT);
                await db.SaveChangesAsync();

                return(RedirectToAction("Index"));
            }

            ViewBag.CIID = new SelectList(db.CI, "Id", "Nombre", pT.CIID);
            return(View(pT));
        }
Beispiel #30
0
        private void RefreshState(bool init)
        {
            __state.SelectedObject = Program.PTUnitState;
            __joystick.Enabled     = Program.Joystick != null;
            if (init)
            {
                if (_q != null)
                {
                    _q.Stop();
                }
                _q = new PTQueue(PT);
                _q.StatusChanged += new EventHandler(_q_StatusChanged);
                _q.Start();

                __firmware.Text    = PT.GetFirmwareInfo();
                __environment.Text = PT.GetEnvironmentInfo();
                __firmwareLbl.Text = PT.ComPort + ":";
            }

            RefreshAngleState(init);
            RefreshSliderState(init);
            RefreshConfigurationState();
        }
Beispiel #31
0
 public static void EndProfile(PT etag)
 {
     // int tag = (int)etag;
     // profiles[tag].totalTime += DateTime.UtcNow - profiles[tag].lastRecorded;
     // ++profiles[tag].totalCalls;
 }
Beispiel #32
0
 public static void StartProfile(PT tag)
 {
     // profiles[(int)tag].lastRecorded = DateTime.UtcNow;
 }