private void btnExtractPvkSelectFiles_Click(object sender, EventArgs e)
        {
            if (!pvkBackgroundTask.IsBusy)
            {
                string directory = FileDialogs.BrowseDialog();
                if (directory == null)
                {
                    return;
                }

                string outFile = FileDialogs.SaveDialog();
                if (outFile == null)
                {
                    return;
                }

                bool delFiles     = cbExtractDeleteFiles.Checked;
                bool exportOnlyPQ = cbExportOnlyPQ.Checked;

                pvkBackgroundTask = new AsyncBackgroundTask();
                pvkBackgroundTask.RunWorkerCompleted += new RunWorkerCompletedEventHandler(
                    (a, b) =>
                {
                    pvkBackgroundTask.SetWorkerStatus(false);
                    EnableControl(groupAllControls, true);
                });

                pvkBackgroundTask.DoWork += new DoWorkEventHandler((sndr, args) =>
                {
                    PvkTaskMethod(cancleSource.Token, directory, outFile, delFiles, exportOnlyPQ);
                });
                pvkBackgroundTask.RunWorkerAsync();
            }
        }
        private void btnExtractKeystore_Click(object sender, EventArgs e)
        {
            if (!keystoreBackgroundTask.IsBusy)
            {
                string directory = FileDialogs.BrowseDialog();
                if (directory == null)
                {
                    return;
                }

                string outFile = FileDialogs.SaveDialog();
                if (outFile == null)
                {
                    return;
                }

                bool delFiles = cbExtractDeleteFiles.Checked;

                keystoreBackgroundTask = new AsyncBackgroundTask();
                keystoreBackgroundTask.RunWorkerCompleted += new RunWorkerCompletedEventHandler(
                    (a, b) =>
                {
                    EnableControl(groupAllControls, true);
                });

                keystoreBackgroundTask.DoWork += new DoWorkEventHandler((sndr, args) =>
                {
                    ExtractKeystoreTask();
                });
                keystoreBackgroundTask.RunWorkerAsync();
            }
        }
        private void btnExtractFolderCertBegin_Click(object sender, EventArgs e)
        {
            if (!cerBackgroundTask.IsBusy)
            {
                string directory = FileDialogs.BrowseDialog();
                if (directory == null)
                {
                    return;
                }

                string filename = FileDialogs.SaveDialog();
                if (filename == null)
                {
                    return;
                }

                bool privKeys    = cbExportOnlyPQ.Checked;
                bool deleteFiles = cbExtractDeleteFiles.Checked;

                cerBackgroundTask = new AsyncBackgroundTask();
                cerBackgroundTask.RunWorkerCompleted += new RunWorkerCompletedEventHandler(
                    (a, b) =>
                {
                    EnableControl(groupAllControls, true);
                    cerBackgroundTask.SetWorkerStatus(false);
                });

                cerBackgroundTask.DoWork += new DoWorkEventHandler((sndr, args) =>
                {
                    CerTaskMethod(directory, filename, privKeys, deleteFiles);
                });
                cerBackgroundTask.RunWorkerAsync();
            }
        }
        public MainForm()
        {
            InitializeComponent();

            cancleSource = new CancellationTokenSource();

            cbExtractAllKeystore.Checked = true;
            cbExtractAllKeystore.Enabled = false;

            lastDirectory = DefaultDirectory;

            panelCancel.BackColor = Color.FromArgb(120, Color.FromKnownColor(KnownColor.Control));
            panelCancel.Visible   = false;

            pvkBackgroundTask       = new AsyncBackgroundTask();
            xmlBackgroundTask       = new AsyncBackgroundTask();
            cerBackgroundTask       = new AsyncBackgroundTask();
            keystoreBackgroundTask  = new AsyncBackgroundTask();
            cryptoApiBackgroundTask = new AsyncBackgroundTask();
        }
        private void btnExtractXmlSelectFiles_Click(object sender, EventArgs e)
        {
            if (!xmlBackgroundTask.IsBusy)
            {
                string inFile = FileDialogs.OpenDialog();
                if (inFile == null)
                {
                    return;
                }

                string outFile = FileDialogs.SaveDialog();
                if (outFile == null)
                {
                    return;
                }

                //bool privKeys = false;
                //if (radioExtractPQOnly.Checked)
                //{
                //    privKeys = radioExtractPQOnly.Checked;
                //}

                xmlBackgroundTask = new AsyncBackgroundTask();
                xmlBackgroundTask.RunWorkerCompleted += new RunWorkerCompletedEventHandler(
                    (a, b) =>
                {
                    xmlBackgroundTask.SetWorkerStatus(false);
                    EnableControl(groupAllControls, true);
                });

                xmlBackgroundTask.DoWork += new DoWorkEventHandler((sndr, args) =>
                {
                    XmlTaskMethod(cancleSource.Token, inFile, outFile);
                });
                xmlBackgroundTask.RunWorkerAsync();
            }
        }
        private void btnGenerateQuantity_Click(object sender, EventArgs e)
        {
            if (!cryptoApiBackgroundTask.IsBusy)
            {
                int  keySize        = KeySize;
                int  quantity       = Quantity;
                int  timeout        = Timeout;
                bool onlyGeneratePQ = cbGenerateOnlyPrimes.Checked;

                cryptoApiBackgroundTask = new AsyncBackgroundTask();
                cryptoApiBackgroundTask.RunWorkerCompleted += new RunWorkerCompletedEventHandler(
                    (a, b) =>
                {
                    EnableControl(groupAllControls, true);
                    cryptoApiBackgroundTask.SetWorkerStatus(false);
                });

                cryptoApiBackgroundTask.DoWork += new DoWorkEventHandler((sndr, args) =>
                {
                    GenerateCryptoAPIKeysTask(keySize, quantity, timeout, onlyGeneratePQ);
                });
                cryptoApiBackgroundTask.RunWorkerAsync();
            }
        }