예제 #1
0
 public MachineTask(WorkPath shape, KnifeToolInstance drill)
 {
     Tool             = drill;
     Path             = shape;
     Layout           = new PathLayout();
     CompleteOrByPath = true;
 }
예제 #2
0
        private void lwFiles_PreviewMouseRightButtonDown(object sender, MouseButtonEventArgs e)
        {
            if (e.OriginalSource is TextBlock)
            {
                if (((TextBlock)e.OriginalSource).Background == Brushes.Red)
                {
                    ((TextBlock)e.OriginalSource).Background = Brushes.Transparent;
                    HitTestResult result = VisualTreeHelper.HitTest(lwFiles, e.GetPosition(lwFiles));
                    ListBoxItem   lbi    = Statik.FindParent <ListBoxItem>(result.VisualHit);
                    WKeyVal       vl     = lbi.DataContext as WKeyVal;
                    WorkPath      wp     = ((WorkPath)comboBox1.SelectedItem);

                    panel1.removeBack(vl.Val.ToString());
                }
                else
                {
                    ((TextBlock)e.OriginalSource).Background = Brushes.Red;

                    HitTestResult result = VisualTreeHelper.HitTest(lwFiles, e.GetPosition(lwFiles));
                    ListBoxItem   lbi    = Statik.FindParent <ListBoxItem>(result.VisualHit);
                    WKeyVal       vl     = lbi.DataContext as WKeyVal;
                    WorkPath      wp     = ((WorkPath)comboBox1.SelectedItem);

                    panel1.addBack(vl.Val.ToString(), wp.OverrideOldTexture);
                }
            }
            e.Handled = true;
        }
예제 #3
0
        void newProj_Click(object sender, EventArgs e)
        {
            WorkPath path = new WorkPath(null, null, inkCol.Ink);

            path.createProj();
            //path.Go();
        }
예제 #4
0
        private void comboBox1_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            lwFiles.Items.Clear();
            WorkPath wp = ((WorkPath)comboBox1.SelectedItem);

            foreach (var item in Directory.GetFiles(wp.Path).OrderBy(x => x))
            {
                FileInfo fi = new FileInfo(item);
                lwFiles.Items.Add(new WKeyVal(fi.Name, fi.FullName));
            }
        }
예제 #5
0
        void BeginAddTask(WorkPath ps)
        {
            propertyBrowser.Children.Clear();

            PathUIDef UIDef = m_UIFactory.FindUI(ps.GetType());

            if (UIDef != null)
            {
                m_ModelView.BeginAddTask(UIDef.CreateShapeModel(ps));
                CreateTaskUI(UIDef.CreateUI(), UIDef.Title, UIMode.UM_Add);
            }
        }
예제 #6
0
 /// <summary>
 /// 基本配置
 /// </summary>
 private pub()
 {
     LoadConfig(this);
     if (WorkPath == null)
     {
         WorkPath = fastCSharp.pub.ApplicationPath;
     }
     else
     {
         WorkPath = WorkPath.pathSuffix().fileNameToLower();
     }
     if (CachePath == null || !directory.Create(CachePath = CachePath.pathSuffix().fileNameToLower()))
     {
         CachePath = fastCSharp.pub.ApplicationPath;
     }
 }
예제 #7
0
        void erRead_Click(object sender, EventArgs e)
        {
            WorkPath   path   = new WorkPath();
            List <Pin> errors = new List <Pin>();

            errors.AddRange(path.errors("c:\\cats\\error.log"));

            foreach (Pin datapin in errors)
            {
                Console.Write(datapin.PinName + " ");
                Console.Write(datapin.val2str());

                if (datapin.Polarity.Equals(PinPolarity.Ouput))
                {
                    Console.Write(" ");
                    Console.Write(datapin.expected2str());
                }
                Console.WriteLine();
            }

            //path.pins2testVectors(errors, "c:\\cats\\error.log");
        }
예제 #8
0
        /// <summary>
        /// HTTP文件请求处理
        /// </summary>
        /// <param name="path">请求路径</param>
        /// <param name="ifModifiedSince">文件修改时间</param>
        /// <param name="response">HTTP响应输出</param>
        /// <param name="isCopyPath">是否复制请求路径</param>
        /// <returns>文件缓存</returns>
        protected unsafe FileCache file(byte[] path, SubArray <byte> ifModifiedSince, ref Http.Response response, bool isCopyPath)
        {
            string cacheFileName = null;

            try
            {
                if (path.Length != 0 && WorkPath.Length + path.Length <= AutoCSer.IO.File.MaxFullNameLength)
                {
                    byte[] contentType = null;
                    bool   isCompress  = true;
                    fixed(byte *pathFixed = path)
                    {
                        byte *pathStart = pathFixed, pathEnd = pathStart + path.Length;

                        if (isFile(pathEnd, ref contentType, ref isCompress) == 0)
                        {
                            if (*pathStart == '/')
                            {
                                ++pathStart;
                            }
                            for (byte *formatStart = pathStart; formatStart != pathEnd; ++formatStart)
                            {
                                if (*formatStart == ':')
                                {
                                    response = Http.Response.Blank;
                                    return(null);
                                }
                            }
                            int          cachePathLength = (int)(pathEnd - pathStart);
                            FileCacheKey cacheKey        = new FileCacheKey(pathIdentity, path, (int)(pathStart - pathFixed), cachePathLength);
                            FileCache    fileCache       = FileCacheQueue.Get(ref cacheKey);
                            if (fileCache == null)
                            {
                                cacheFileName = StringExtension.FastAllocateString(WorkPath.Length + cachePathLength);
                                fixed(char *nameFixed = cacheFileName)
                                {
                                    char *write = nameFixed + WorkPath.Length;
                                    char  directorySeparatorChar = Path.DirectorySeparatorChar;

                                    StringExtension.CopyNotNull(WorkPath, nameFixed);
                                    for (byte *start = pathStart; start != pathEnd; ++start)
                                    {
                                        *write++ = *start == '/' ? directorySeparatorChar : (char)*start;
                                    }
                                }
                                FileInfo file = new FileInfo(cacheFileName);
                                if (file.Exists)
                                {
                                    string fileName = file.FullName;
                                    if (fileName.Length > WorkPath.Length && WorkPath.equalCaseNotNull(fileName, WorkPath.Length))
                                    {
                                        if (fileName.Length <= AutoCSer.IO.File.MaxFullNameLength && file.Length <= FileCacheQueue.MaxFileSize)
                                        {
                                            if (FileCacheQueue.Get(ref cacheKey, out fileCache, isCopyPath) != 0)
                                            {
                                                try
                                                {
                                                    fileCache.LastModified = file.LastWriteTimeUtc.UniversalNewBytes();
                                                    int             extensionNameLength = (int)(pathEnd - getExtensionNameStart(pathEnd));
                                                    SubArray <byte> fileData            = readCacheFile(new SubString {
                                                        String = fileName, Start = fileName.Length - extensionNameLength, Length = extensionNameLength
                                                    });
                                                    FileCacheQueue.Set(ref cacheKey, fileCache, fileCache.Set(ref fileData, contentType, cacheControl, isCompress));
                                                    if (ifModifiedSince.Length == fileCache.LastModified.Length)
                                                    {
                                                        fixed(byte *ifModifiedSinceFixed = ifModifiedSince.Array)
                                                        {
                                                            if (Memory.EqualNotNull(fileCache.LastModified, ifModifiedSinceFixed + ifModifiedSince.Start, ifModifiedSince.Length))
                                                            {
                                                                response = Http.Response.NotChanged304;
                                                                return(null);
                                                            }
                                                        }
                                                    }
                                                }
                                                finally
                                                {
                                                    if (fileCache.IsData == 0)
                                                    {
                                                        fileCache.PulseAll();
                                                        fileCache = null;
                                                        FileCacheQueue.RemoveOnly(ref cacheKey);
                                                    }
                                                }
                                            }
                                        }
                                        else
                                        {
                                            if (ifModifiedSince.Length == Date.ToByteLength && Date.UniversalByteEquals(file.LastWriteTimeUtc, ifModifiedSince) == 0)
                                            {
                                                response = Http.Response.NotChanged304;
                                                return(null);
                                            }
                                            response = Http.Response.Get();
                                            //response.State = Http.ResponseState.Ok200;
                                            response.SetBodyFile(file);
                                            response.CacheControl = cacheControl;
                                            response.ContentType  = contentType;
                                            response.SetLastModified(file.LastWriteTimeUtc.UniversalNewBytes());
                                            return(null);
                                        }
                                    }
                                }
                            }
                            return(fileCache);
                        }
                    }
                }
            }
            catch (Exception error)
            {
                RegisterServer.TcpServer.Log.Add(AutoCSer.Log.LogType.Error, error, cacheFileName);
            }
            return(null);
        }
예제 #9
0
        /// <summary>
        /// Main process
        /// </summary>
        private static void Process(string[] args)
        {
            Console.WriteLine("FOLDER ZIP AND UPLOAD v2.0");
            Console.WriteLine("by Daniele Arrighi @ Idioblast. [email protected]");
            Console.WriteLine();
            Console.WriteLine("Processing...");

            //LOG
            Utilities.WriteToFile(string.Format("{0}: Executing...", DateTime.Now));

            /********************
            * DEFAULTS VALUES
            ********************/
            //ZIPs Temporary Path
            string zipDestinationFolder = ConfigurationManager.AppSettings["ZipDestinationFolder"];

            if (!zipDestinationFolder.EndsWith("\\"))
            {
                zipDestinationFolder += "\\";
            }

            //Configuration File to Load
            string configurationFile = AppDomain.CurrentDomain.BaseDirectory + "config.xml";

            //Verbosity
            bool verbose = false;

            /********************
            * OVERWRITE DEFAULT VALUES WITH COMMAND ARGUMENTS IF PRESENT
            ********************/
            var options = new Options();

            if (Parser.Default.ParseArguments(args, options))
            {
                //Verbosity
                verbose = options.Verbose;

                //ZIPs Temporary Path
                if (!string.IsNullOrEmpty(options.ZipDestinationFolder))
                {
                    zipDestinationFolder = options.ZipDestinationFolder;
                }

                //Configuration File to Load
                if (!string.IsNullOrEmpty(options.ConfigFile))
                {
                    configurationFile = options.ConfigFile;
                }

                //Outputs the encrypted password to save in configuration file.
                if (!string.IsNullOrEmpty(options.Password))
                {
                    Console.WriteLine("Encrypted Password is: {0}", Security.EncryptText(options.Password));
                    Console.WriteLine("Press any key to exit...");
                    Console.ReadKey();
                    return;
                }
            }

            /********************
            * CONFIGURATION
            ********************/

            //Checks if configuration files exist
            if (!File.Exists(configurationFile))
            {
                Utilities.WriteToFile(string.Format("Missing Configuration File At {0}", configurationFile));

                Console.WriteLine("Missing Configuration File At {0}", configurationFile);
                Console.WriteLine("Press any key to exit...");
                Console.ReadKey();
                return;
            }

            //Checks if the Temporary Directory Exist, or create it
            if (!Directory.Exists(zipDestinationFolder))
            {
                Directory.CreateDirectory(zipDestinationFolder);
            }

            //Gets the folders to process from XML file
            ProcessQueue folderQueue = new ProcessQueue(configurationFile);

            //Setup Directory Names
            string nowFileName = DateTime.Now.ToString("yyyyMMdd");

            /********************
            * PROCESS THE QUEUE
            ********************/
            foreach (QueueItem queue in folderQueue.Queue)
            {
                //Extra checks
                if (!queue.FtpDirectory.EndsWith("/"))
                {
                    queue.FtpDirectory += "/";
                }
                if (!queue.Directory.EndsWith("\\"))
                {
                    queue.Directory += "\\";
                }

                //Password check
                if (String.IsNullOrEmpty(queue.FtpPassword))
                {
                    Utilities.WriteToFile("Error. Missing password (Encrypted) for FTP connection");
                    Console.WriteLine("Error. Missing password (Encrypted) for FTP connection");
                    continue;
                }
                else
                {
                    try
                    {
                        queue.FtpPassword = Security.DecryptText(queue.FtpPassword);
                    }
                    catch
                    {
                        Utilities.WriteToFile("Error. Wrong password format");
                        Console.WriteLine("Error. Wrong password format");
                        continue;
                    }
                }

                //ELABORATES ALL THE FOLDERS TO ZIP AND UPLOAD
                if (queue.ProcessSubDirectories)
                {
                    DirectoryInfo startingDirectory = new DirectoryInfo(queue.Directory);
                    foreach (var currentDirectory in startingDirectory.GetDirectories())
                    {
                        if (!queue.IsPathExcluded(currentDirectory.FullName))
                        {
                            WorkPath w = new WorkPath();

                            w.FullPath    = currentDirectory.FullName;
                            w.FullZipPath = Path.Combine(zipDestinationFolder, currentDirectory.Name + ".zip");

                            if (queue.AppendDateTime)
                            {
                                w.FullZipPath = Path.Combine(zipDestinationFolder,
                                                             String.Format("{0:yyyMMddHHmmss}-{1}.zip", DateTime.Now, currentDirectory.Name));
                            }

                            w.IsZipped = ZipService.ZipFolder(currentDirectory.FullName, w.FullZipPath,
                                                              queue.ExcludedFolders.ToStringArray(), verbose);
                            w.IsUploaded = false;

                            queue.WorkList.Add(w);
                        }
                    }
                }
                else
                {
                    //IF SHOULD NOT PROCSS SUBDIRS, ZIP THE DIRECTORY DIRECTLY
                    DirectoryInfo currentDirectory = new DirectoryInfo(queue.Directory);
                    if (!queue.IsPathExcluded(currentDirectory.FullName))
                    {
                        WorkPath w = new WorkPath();

                        w.FullPath    = currentDirectory.FullName;
                        w.FullZipPath = Path.Combine(zipDestinationFolder, currentDirectory.Name + ".zip");

                        if (queue.AppendDateTime)
                        {
                            w.FullZipPath = Path.Combine(zipDestinationFolder,
                                                         String.Format("{0:yyyMMddHHmmss}-{1}.zip", DateTime.Now, currentDirectory.Name));
                        }

                        w.IsZipped = ZipService.ZipFolder(currentDirectory.FullName, w.FullZipPath,
                                                          queue.ExcludedFolders.ToStringArray(), verbose);
                        w.IsUploaded = false;

                        queue.WorkList.Add(w);
                    }
                }

                //FTP UPLOAD ALL ELABORATED FOLDER
                bool uploadSuccess = FtpService.UploadQueue(queue, queue.FtpDirectory + nowFileName + "/", queue.FtpServer, queue.FtpUser, queue.FtpPassword, verbose);

                //DELETE OLDER FOLDERS IF REQUIRED
                //TODO: Use same session in UploadQueue and in CleanOldRemoteFolders
                if (queue.CleanRemote > 0 && uploadSuccess)
                {
                    FtpService.CleanOldRemoteFolders(queue.CleanRemote, verbose, queue.FtpDirectory, queue.FtpServer, queue.FtpUser, queue.FtpPassword);
                }

                //DELETE ALL CREATED ZIP FILES
                if (queue.DeleteFilesWhenFinished)
                {
                    FileService.DeleteFilesInQueue(queue, verbose);
                }
            }

            //LOG
            Utilities.WriteToFile(String.Format("Zip & Upload routine completed at: {0}\n", DateTime.Now));

            //SEND MAIL
            string subject = String.Format("Zip & Upload routine completed at: {0}", DateTime.Now); //Todo: Send more information in the mail body.

            MailService.Send("Zip & Upload Executed", subject, verbose);

            //DONE
            if (verbose)
            {
                Console.WriteLine();
                Console.WriteLine("Press any key to exit...");
                Console.ReadLine();
            }
        }
예제 #10
0
 public MachineTask()
 {
     Path   = new WorkPath();
     Layout = new PathLayout();
     Id     = 0;
 }
예제 #11
0
 public override WorkPathModel CreateShapeModel(WorkPath ps)
 {
     return(new CirclePathModel(ps as CirclePath));
 }
예제 #12
0
 public WorkPathModel(WorkPath shape)
 {
     Shape = shape;
 }
예제 #13
0
        /// <summary>
        /// HTTP文件请求处理
        /// </summary>
        /// <param name="header">请求头部</param>
        /// <param name="response">HTTP响应输出</param>
        /// <returns>文件缓存</returns>
        protected unsafe FileCache file(Http.Header header, ref Http.Response response)
        {
            SubArray <byte> path          = header.Path;
            string          cacheFileName = null;

            try
            {
                if (path.Length != 0 && WorkPath.Length + path.Length <= AutoCSer.IO.File.MaxFullNameLength)
                {
                    byte[] contentType = null;
                    bool   isCompress  = true;
                    fixed(byte *pathFixed = path.GetFixedBuffer())
                    {
                        byte *pathStart = pathFixed + path.Start, pathEnd = pathStart + path.Length;

                        if (isFile(pathEnd, ref contentType, ref isCompress) == 0)
                        {
                            if (*pathStart == '/')
                            {
                                ++pathStart;
                            }
                            for (byte *formatStart = pathStart; formatStart != pathEnd; ++formatStart)
                            {
                                if (*formatStart == ':')
                                {
                                    response = Http.Response.Blank;
                                    return(null);
                                }
#if !MONO
                                if ((uint)(*formatStart - 'A') < 26)
                                {
                                    *formatStart |= 0x20;
                                }
#endif
                            }
                            int          cachePathLength = (int)(pathEnd - pathStart);
                            FileCacheKey cacheKey        = new FileCacheKey(pathIdentity, path.Array, (int)(pathStart - pathFixed), cachePathLength);
                            FileCache    fileCache       = FileCacheQueue.Get(ref cacheKey);
                            if (fileCache == null)
                            {
                                cacheFileName = StringExtension.FastAllocateString(WorkPath.Length + cachePathLength);
                                fixed(char *nameFixed = cacheFileName)
                                {
                                    char *write = nameFixed + WorkPath.Length;
                                    char  directorySeparatorChar = Path.DirectorySeparatorChar;

                                    StringExtension.CopyNotNull(WorkPath, nameFixed);
                                    for (byte *start = pathStart; start != pathEnd; ++start)
                                    {
                                        *write++ = *start == '/' ? directorySeparatorChar : (char)*start;
                                    }
                                }
                                FileInfo file = new FileInfo(cacheFileName);
                                bool     isFileExists = file.Exists, isCopyPath = true;
                                if (!isFileExists && cacheFileName.IndexOf('%') >= WorkPath.Length)
                                {
                                    cacheKey.CopyPath();
                                    isCopyPath = false;
                                    string newPath = AutoCSer.Net.Http.Header.UnescapeUtf8(pathStart, cachePathLength, path.Array, (int)(pathStart - pathFixed));
                                    if (Path.DirectorySeparatorChar != '/')
                                    {
                                        newPath.replaceNotNull('/', Path.DirectorySeparatorChar);
                                    }
                                    FileInfo newFile = new FileInfo(WorkPath + newPath);
                                    if (newFile.Exists)
                                    {
                                        file         = newFile;
                                        isFileExists = true;
                                    }
                                }
                                if (isFileExists)
                                {
                                    string fileName = file.FullName;
                                    if (fileName.Length > WorkPath.Length && WorkPath.equalCaseNotNull(fileName, WorkPath.Length))
                                    {
                                        if (fileName.Length <= AutoCSer.IO.File.MaxFullNameLength && file.Length <= FileCacheQueue.MaxFileSize)
                                        {
                                            if (FileCacheQueue.Get(ref cacheKey, out fileCache, isCopyPath) != 0)
                                            {
                                                try
                                                {
                                                    fileCache.LastModified = file.LastWriteTimeUtc.UniversalNewBytes();
                                                    int             extensionNameLength = (int)(pathEnd - getExtensionNameStart(pathEnd));
                                                    SubArray <byte> fileData            = readCacheFile(new SubString {
                                                        String = fileName, Start = fileName.Length - extensionNameLength, Length = extensionNameLength
                                                    });
                                                    FileCacheQueue.Set(ref cacheKey, fileCache, fileCache.Set(ref fileData, contentType, cacheControl, isCompress));
                                                    if ((header.Flag & Http.HeaderFlag.IsSetIfModifiedSince) != 0 && header.IfModifiedSinceIndex.Length == fileCache.LastModified.Length)
                                                    {
                                                        if (AutoCSer.Memory.Common.EqualNotNull(fileCache.LastModified, pathFixed + header.Buffer.StartIndex + header.IfModifiedSinceIndex.StartIndex, header.IfModifiedSinceIndex.Length))
                                                        {
                                                            response = Http.Response.NotChanged304;
                                                            return(null);
                                                        }
                                                    }
                                                }
                                                finally
                                                {
                                                    if (fileCache.IsData == 0)
                                                    {
                                                        fileCache.PulseAll();
                                                        fileCache = null;
                                                        FileCacheQueue.RemoveOnly(ref cacheKey);
                                                    }
                                                }
                                            }
                                        }
                                        else
                                        {
                                            if ((header.Flag & Http.HeaderFlag.IsSetIfModifiedSince) != 0 && header.IfModifiedSinceIndex.Length == Date.ToByteLength && Date.UniversalByteEquals(file.LastWriteTimeUtc, header.IfModifiedSince) == 0)
                                            {
                                                response = Http.Response.NotChanged304;
                                                return(null);
                                            }
                                            response = Http.Response.Get();
                                            //response.State = Http.ResponseState.Ok200;
                                            response.SetBodyFile(file);
                                            response.CacheControl = cacheControl;
                                            response.ContentType  = contentType;
                                            response.SetLastModified(file.LastWriteTimeUtc.UniversalNewBytes());
                                            return(null);
                                        }
                                    }
                                }
                            }
                            return(fileCache);
                        }
                    }
                }
            }
            catch (Exception error)
            {
                RegisterServer.TcpServer.Log.Exception(error, cacheFileName, LogLevel.Exception | LogLevel.AutoCSer);
            }
            return(null);
        }
예제 #14
0
 public virtual WorkPathModel CreateShapeModel(WorkPath ps)
 {
     return(null);
 }
예제 #15
0
        void mod2pin2ink_Click(object sender, EventArgs e)
        {
            WorkPath   path    = new WorkPath();
            Module     mod     = new Module("mistaKitties");
            List <Pin> inputs  = new List <Pin>();
            List <Pin> outputs = new List <Pin>();

            inputs.Add(new Pin(PinPolarity.Input, "clk", 1));
            inputs.Add(new Pin(PinPolarity.Input, "s", 4));
            inputs.Add(new Pin(PinPolarity.Input, "b", 1));

            /*
             * int[] insizes = new int[3];
             * inputs.Add("clk");
             * inputs.Add("s");
             * inputs.Add("b");
             * insizes[0] = 1;
             * insizes[1] = 4;
             * insizes[2] = 1;*/

            //List<Pin> outputs = new List<Pin>();
            //int[] outsizes = new int[2];

            outputs.Add(new Pin(PinPolarity.Ouput, "x", 5));
            outputs.Add(new Pin(PinPolarity.Ouput, "y", 1));
            //outsizes[0] = 5;
            //outsizes[1] = 1;

            mod.addInputs(inputs);
            mod.addOutputs(outputs);

            List <Pin> pins = new List <Pin>();

            pins.AddRange(path.mod2pin(mod));



            Module mod2 = path.pins2mod(pins, "MistaB");

            int i = 0;

            foreach (Pin str in mod2.inputPins)
            {
                Console.WriteLine(str.PinName + " " + str.bussize);
                i++;
            }
            i = 0;
            foreach (Pin str in mod2.outputPins)
            {
                Console.WriteLine(str.PinName + " " + str.bussize);
                i++;
            }

            List <Pin> pin2 = new List <Pin>();

            foreach (Pin instance in pins)
            {
                if (instance.PinName != "clk")
                {
                    pin2.Add(instance);
                }
            }

            foreach (Pin datapin in pin2)
            {
                Console.WriteLine(datapin.PinName + " " + datapin.bussize);
            }
            //        Console.WriteLine(pin2[0].PinName + " " + pins[0]);
            //      Console.WriteLine(pin2[0].Equals(pins[0]));
            //Pin dk = new Pin("in", "clk", 1);
            //pin2.Remove(pin2[0]);
            //pin2.Add(dk);
            pin2.Reverse();
            Mesh        sup  = new Mesh();
            Mesh        sup1 = new Mesh();
            Mesh        sup2 = new Mesh();
            Mesh        sup3 = new Mesh();
            Mesh        sup4 = new Mesh();
            List <Mesh> list = new List <Mesh>();

            //sup.Name = "clk";
            //sup.IOType = WirePolarity.Input;
            //list.Add(sup);
            sup1.Name    = "s";
            sup1.IOType  = WirePolarity.Input;
            sup1.Bussize = 4;
            list.Add(sup1);
            sup2.Name    = "b";
            sup2.Bussize = 1;
            sup2.IOType  = WirePolarity.Input;
            list.Add(sup2);
            sup3.Name    = "x";
            sup3.Bussize = 5;
            sup3.IOType  = WirePolarity.Output;
            list.Add(sup3);
            sup4.Name    = "y";
            sup4.Bussize = 1;
            sup4.IOType  = WirePolarity.Output;
            list.Add(sup4);
            List <Pin> pins4 = new List <Pin>();

            pins4.AddRange(path.inOutRectify(pin2, list, "c:\\cats\\test.v"));

            List <List <Pin> > sups  = new List <List <Pin> >();
            List <List <Pin> > sups3 = new List <List <Pin> >();

            sups3.Add(pin2);
            sups.Add(pins);
            sups.AddRange(sups3);

            MessageBox.Show("shows");
            foreach (Pin instance in sups[0])
            {
                Console.WriteLine(instance.PinName);
            }
        }
예제 #16
0
 void sim_Click(object sender, EventArgs e)
 {
     WorkPath path = new WorkPath("c:\\cats\\lab1_xx.ise", null, inkCol.Ink);
     //path.Go();
 }