public void Read(SnpCollection snps, CancellationToken cancel, Progress progress) {
            if (this.filename == null) throw new ArgumentNullException("filename cannot be null.");
            if (String.IsNullOrWhiteSpace(filename)) throw new ArgumentOutOfRangeException("filename cannot be empty.");

            string ext = Path.GetExtension(filename);
            if (ext.EndsWith("csv", StringComparison.InvariantCultureIgnoreCase)) {
                try {
                    Read(Genome.GenomeType.Ftdna, snps, cancel, progress);
                    return;
                }
                catch (Exception) { }
                genome.Clear();
                try {
                    Read(Genome.GenomeType.MeAnd23v2, snps, cancel, progress);
                    return;
                }
                catch (Exception) { }
            } else {
                try {
                    Read(Genome.GenomeType.MeAnd23v2, snps, cancel, progress);
                    return;
                }
                catch (Exception) { }
                genome.Clear();
                try {
                    Read(Genome.GenomeType.Ftdna, snps, cancel, progress);
                    return;
                }
                catch (Exception) { }
            }
            throw new ApplicationException("Could not read as either format.");
        }

    static void Main(string[] args)
    {
        Application.EnableVisualStyles();

        if (args.Length == 0) {
            Application.Run(new About());
        } else if (args.Length > 1 && args[0] == "--map") {
            if (File.Exists(SFMpq.DLL))
            {
                parsing = new Progress();
                parsing = new Progress();
                parsing.Visible = true;
                parsing.SetMapPath(args[1]);
                map = new Map(Application.StartupPath, args[1]);
                parsing.SetProgress(20, "comments and empty lines...");
                Preprocessor.SplitComments(map.script);
                map.script = Format.SplitEmptyLines(map.script);
                parsing.SetProgress(20, "comments and empty lines... DONE!");
                parsing.SetProgress(40, "user functions...");
                Analyzer.FindUserFunctions(map.script);
                Analyzer.GetGlobals(map.script);
                parsing.SetProgress(40, "user functions and structs... DONE!");
                parsing.SetProgress(60, "\"//! jasp\" blocks...");
                Preprocessor.ParseJaspBlock(map.script);
                parsing.SetProgress(60, "\"//! jasp\" blocks... DONE!");
                parsing.SetProgress(80, "Rebuilding parsed script...");
                map.script = Format.StringsToString(map.script).Split('\n');
                parsing.SetProgress(80, "Rebuilding parsed script... DONE!");
                parsing.SetProgress(100, "errors...");
                Preprocessor.SearchErrors(map.script);
            } else
                MessageBox.Show("File \"SFMpq.dll\" isn't exists.\nSorry :(", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
    }

    public void PrintPagesVoid()
    {
        CommandLineInterpreter oCLI = new CommandLineInterpreter();
        ActionCallingContext acc = new ActionCallingContext();

        string strPages = string.Empty;
        acc.AddParameter("TYPE", "PAGES");
        oCLI.Execute("selectionset", acc);
        acc.GetParameter("PAGES", ref strPages);

        Progress oProgress = new Progress("SimpleProgress");
        oProgress.SetAllowCancel(true);
        oProgress.SetAskOnCancel(true);
        oProgress.SetNeededSteps(3);
        oProgress.SetTitle("Drucken");
        oProgress.ShowImmediately();

        foreach (string Page in strPages.Split(';'))
        {
            if (!oProgress.Canceled())
            {
                acc.AddParameter("PAGENAME", Page);
                oCLI.Execute("print", acc);
            }
            else
            {
                break;
            }
        }
        oProgress.EndPart(true);

        return;
    }

        /// <summary>
        /// Read data into the specified SnpCollection from the SnpCollection
        /// file having the specified filename (which may include a path). 
        /// The specified CancellationToken can be used to abort the read. 
        /// The progress parameter will be updated by this method with a 
        /// value of 0-100 to reflect the percent progress of the read.
        /// </summary>
        /// <param name="snps">The SnpCollection to receive the read data.</param>
        /// <param name="filename">The path and filename of the SnpCollection file.</param>
        /// <param name="cancel">The CancellationToken that can be used to abort the read.</param>
        /// <param name="progress">The progress parameter that will be updated to reflect 
        /// the percent progress of the read.</param>
        public static void Read(SnpCollection snps, string filename, CancellationToken cancel, Progress progress) {
            if (snps == null) throw new ArgumentNullException("The SnpCollection cannot be null.");
            if (filename == null) throw new ArgumentNullException("filename cannot be null.");
            if (String.IsNullOrWhiteSpace(filename)) throw new ArgumentOutOfRangeException("filename cannot be empty.");

            using (StreamReader reader = new StreamReader(filename)) {
                long length = 0;
                if (progress != null) length = reader.BaseStream.Length;
                string[] columns = new string[6];
                string line;
                while ((line = reader.ReadLine()) != null) {
                    cancel.ThrowIfCancellationRequested();
                    line.FastSplit(',', columns);
                    byte chr = Convert.ToByte(columns[2]);
                    if (chr == 0) chr = 23; // handles legacy use of 0 for X 
                    Snp snp;
                    if ((!String.IsNullOrWhiteSpace(columns[3]) && Char.IsDigit(columns[3][0]))) {
                        // new format snp file
                        snp = new Snp(columns[0], chr, Convert.ToInt32(columns[3]), Convert.ToSingle(columns[4]), columns[1], columns[5]);
                    } else {
                        // old SnpMap format snp file
                        snp = new Snp(columns[0], chr, -1, -1, columns[1], columns[3]);
                    }
                    snps.Add(snp);
                    if (progress != null) progress.Set(reader.BaseStream.Position, length);

                }
            }
        }

        public ProgressViewModel()
        {
            this.Bookmarks = new ObservableCollection<Bookmark>();
            this.Bookmarks.CollectionChanged += Bookmarks_CollectionChanged;

            this.progress = new Progress();
        }

        void btn_list_Click(object sender, EventArgs e)
        {
            string RecievedData=null;
            names.Clear();
            ips.Clear();
            using (Client client = new Client())
            {
                Thread t = new Thread(() => RecievedData = client.Retrieve(Player.Name));
                t.Start();
                Progress p = new Progress();
                p.ShowDialog();
                string name = RecievedData.Substring(0, RecievedData.IndexOf('&'));
                string ip = RecievedData.Substring(RecievedData.IndexOf('&') + 1);

                for (int startindx = 0, length = name.IndexOf('*'), prv = length; startindx < name.Length; )
                {
                    names.Add(name.Substring(startindx, length));
                    startindx = prv + 1;
                    prv = name.IndexOf('*', startindx);
                    length = prv - startindx;

                }

                for (int startindx = 0, length = ip.IndexOf('*'), prv = length; prv != -1; )
                {
                    ips.Add(ip.Substring(startindx, length));
                    startindx = prv + 1;
                    prv = ip.IndexOf('*', startindx);
                    length = prv - startindx;

                }
                foreach (string s in names)
                    AvailablePlayers.Items.Add(s);
            }
        }

 public DownloadViewModel()
 {
     if (IsInDesignMode)
     {
         Progress = new Progress() { Saved = 50, Total = 100 };
     }
 }

        protected override Image3D OnProcess(Image3D image, Progress progress)
        {
            if (cache == null)
            {
                if (!CombineFilesToSlices)
                {
                    using (var reader = new DicomReader(Path))
                    {
                        cache = reader.ReadImage3D(progress);
                        cache.Minimum = reader.MinValue;
                        cache.Maximum = reader.MaxValue;
                    }
                }
                else
                {
                    using (var reader = new FileToSliceDicomReader(Path))
                    {
                        cache = reader.ReadImage3D(progress);
                        cache.Minimum = reader.MinValue;
                        cache.Maximum = reader.MaxValue;
                    }
                }

                Log.I("Image loaded. min: " + cache.Minimum + "; max: " + cache.Maximum);
            }

            return cache;
        }

        internal Progress(int pluginNumber, Progress.Callback progress)
        {
            if (progress == null) throw new ArgumentNullException("progress");

            this.pluginNumber = pluginNumber;
            this.progress = progress;
        }

        private void button_backup_Click(object sender, EventArgs e)
        {
            FolderBrowserDialog fbd = new FolderBrowserDialog();
            DialogResult result = fbd.ShowDialog();
            if (result == DialogResult.OK)
            {
                int lastFoo = (int)Enum.GetValues(typeof(ECRComms.program)).Cast<ECRComms.program>().Last();

                for (int p = 0; p <= lastFoo; p++)
                {
                    Progress pr = new Progress(Program.ecr);
                    pr.Show();

                    string  name = ((ECRComms.program)p).ToString();
                    data = Program.ecr.getprogram((ECRComms.program)p);

                    pr.Close();

                    try
                    {
                        writedata(data.ToArray(),  Path.Combine(fbd.SelectedPath, name + ".dat"));
                    }
                    catch (Exception _Exception)
                    {
                        Console.WriteLine("Exception caught saving file{0}", _Exception.ToString());
                    }

                }
            }
        }

 /// <summary>
 /// Instantiates a <c>BuilderVisitor</c> object.
 /// </summary>
 /// <param name="filter">The list of filters to pass in.</param>
 /// <param name="typeConflicts">A list to keep track of invalid type conflicts.</param>
 /// <param name="progress">A progress object to keep track of the progress.</param>
 public BuilderVisitor(List<Filter> filter, List<string> typeConflicts, Progress progress)
 {
     _filter = filter;
     _filterChain = new FilterChain();
     _typeConflicts = typeConflicts;
     _progress = progress;
 }

		public ContainerForm(CleanerController controller)
			: base(WorkshareFormUtility.DialogLevel.Primary, WorkshareFormUtility.BrandType.Protect, "Batch Clean")
		{
			InitializeComponent();
			TopMost = true;

			m_controller = controller;
			m_controller.CleanProcessComplete += OnCleanProcessComplete;
			m_controller.CleanProcessCancelled += OnCleanProcessCancelled;
			m_controller.ProcessComplete += OnProcessComplete;

			m_optionCtl = new Options(controller);
			m_progessCtl = new Progress(controller);
			m_reportCtl = new Report(controller);

			m_optionCtl.Visible = true;
			m_optionCtl.ShowSavingGroupBox(true);
			m_progessCtl.Visible = false;
			m_reportCtl.Visible = false;

			pnlDetail.Controls.Add(m_optionCtl);
			pnlDetail.Controls.Add(m_progessCtl);
			pnlDetail.Controls.Add(m_reportCtl);

			if (!m_optionCtl.HasValidFiles())
				btnClean_Click(this, new EventArgs());
		}

        private void Application_Startup(object sender, StartupEventArgs e)
        {
            // create a loader page
            Progress loader = new Progress();

            // set the visual root to loader page
            this.RootVisual = loader;

            // Debug helper -> make sure we have html params!
            if (e.InitParams.Count == 0)
            {
                MessageBox.Show("Error: You must tell your loader what files to load in your web page(init params) or manually in the code!", "Loader Error Message", MessageBoxButton.OK);
                //throw new Exception("Loader init params error");
                return;
            }
            // create package download manager and start the download process using html supplied InitParams
            // note the last param sets a 100KB max download speed for debuging and simulation mode!
            PackageDownloadManager pdm = new PackageDownloadManager(loader, e.InitParams, 0);

            // another option is to use a hand coded list ->
            //List<Uri> myDownloadList = new List<Uri>();
            //myDownloadList.Add(new Uri("ClientBin/Beegger.xap", UriKind.RelativeOrAbsolute));
            //ParamUtil.fixRelativeLinks(ref myDownloadList);
            //PackageDownloadManager pdm = new PackageDownloadManager(loader, myDownloadList, 50);
        }

 private static void WriteMessage(string message, Progress progress, MessageType type)
 {
     var c = Control;
     if (c!= null)
     {
         c.Write(message, progress, type);
     }
 }

        private Rectangle _rectangle; // mask bounds

        #endregion Fields

        #region Constructors

        /// <summary>
        /// Create a GSImage backed with an existing Drawable.
        /// </summary>
        /// <param name="drawable"></param>
        public GSImage(Drawable drawable)
        {
            _image = drawable.Image;
            _drawable = drawable;
            _rectangle = _drawable.MaskBounds;
            Tile.CacheDefault(_drawable);
            Progress = new Progress("Halftone Laboratory");
        }

        static void WriteProgressIndicator(Progress? progress)
        {
            if (progress == null)
                return;

            Console.ForegroundColor = ConsoleColor.Green;
            Console.Write("({0}) ", progress.Value);
        }

        private Game()
        {
            m_graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
            IsMouseVisible = true;

            m_progress = new Progress("fin");
        }

        public ProgressWorker(Progress window, int total)
        {
            this.total = total;
            this.window = window;
            this.WorkerReportsProgress = true;
            this.WorkerSupportsCancellation = true;

            ReportProgress(0);
        }

        public static BindingList<DataItem> Decode(string[] toDecode)
        {
            BatchInsert.toDecode = toDecode;

            Progress p = new Progress(0, 100, "Decoding..", "starting..", Decoding, null, null, true, true);
            p.StartWorker();

            return decodedDS;
        }

    public void Function()
    {
        string strProjectpath =
            PathMap.SubstitutePath("$(PROJECTPATH)");
        string strProjectname = PathMap.SubstitutePath("$(PROJECTNAME)");
        string strFullProjectname = PathMap.SubstitutePath("$(P)");

        string strDate = DateTime.Now.ToString("yyyy-MM-dd");
        string strTime = DateTime.Now.ToString("hh-mm-ss");
        string strBackupDirectory = strProjectpath + @"\Backup\";
        string strBackupFilename = strProjectname + "_Backup_"
            + strDate + "_" + strTime;

        if (!System.IO.Directory.Exists(strBackupDirectory))
        {
            System.IO.Directory.CreateDirectory(strBackupDirectory);
        }

        Progress oProgress = new Progress("SimpleProgress");
        oProgress.SetAllowCancel(true);
        oProgress.SetAskOnCancel(true);
        oProgress.BeginPart(100, "");
        oProgress.SetTitle("Backup");
        oProgress.ShowImmediately();

        if (!oProgress.Canceled())
        {
            CommandLineInterpreter oCLI = new CommandLineInterpreter();
            ActionCallingContext acc = new ActionCallingContext();

            acc.AddParameter("BACKUPMEDIA", "DISK");
            acc.AddParameter("ARCHIVENAME", strBackupFilename);
            acc.AddParameter("BACKUPMETHOD", "BACKUP");
            acc.AddParameter("COMPRESSPRJ", "1");
            acc.AddParameter("INCLEXTDOCS", "1");
            acc.AddParameter("BACKUPAMOUNT", "BACKUPAMOUNT_ALL");
            acc.AddParameter("INCLIMAGES", "1");
            acc.AddParameter("LogMsgActionDone", "true");
            acc.AddParameter("DESTINATIONPATH", strBackupDirectory);
            acc.AddParameter("PROJECTNAME", strFullProjectname);
            acc.AddParameter("TYPE", "PROJECT");

            oCLI.Execute("backup", acc);
        }

        oProgress.EndPart(true);

        MessageBox.Show(
            "Backup wurde erfolgreich erstellt:\n"
            + strBackupFilename,
            "Hinweis",
            MessageBoxButtons.OK,
            MessageBoxIcon.Information
            );

        return;
    }