C#

ypki wrote:

Please give me some links of speech to text convertion project.
what are the concept behind this to develop this application.

Colin Angus Mackay wrote:

wreck a nice beach

linkLabel1.Text = "Go to Microsoft's web site";
linkLabel1.Links[0].LinkData = "http://www.microsoft.com";

private void linkLabel1_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
    if (e.Link.LinkData is string)
    {
        string url = (string)e.Link.LinkData;
        System.Diagnostics.Process.Start(url);
    }
}

string keyText = "Microsoft";
linkLabel1.Text = string.Format("Go to {0}'s web site", keyText);
linkLabel1.Links[0].Start = linkLabel1.Text.IndexOf(keyText);
linkLabel1.Links[0].Length = keyText.Length;
linkLabel1.Links[0].LinkData = string.Format("http://www.{0}.com", keyText);

using System.Windows.Forms;

namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            linkLabel1.LinkClicked += new LinkLabelLinkClickedEventHandler(linkLabel1_LinkClicked);
            string keyText = "Microsoft"; 
            linkLabel1.Text = string.Format("Go to {0}'s web site", keyText); 
            linkLabel1.Links[0].Start = linkLabel1.Text.IndexOf(keyText);
            linkLabel1.Links[0].Length = keyText.Length;
            linkLabel1.Links[0].LinkData = string.Format("http://www.{0}.com", keyText);
        }

        private void linkLabel1_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
        {
            if (e.Link.LinkData is string) 
            { 
                string url = (string)e.Link.LinkData; 
                System.Diagnostics.Process.Start(url); 
            }
        }
    }
}

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Windows.Forms;
namespace WinForms.Controls
{
    /// <summary>
    /// LinkLabel with URL.
    /// </summary>
    public class URLLabel : LinkLabel
    {
        /// <summary>
        /// Creates a new instance of the URLLabel.
        /// </summary>
        public URLLabel()
        {
            URL = "about:blank";
        }
        /// <summary>
        /// Gets or sets the URL that will launched in the default browser when the label is clicked.
        /// </summary>
        [DefaultValue("about:blank"),
        Description("The URL that will launched in the default browser when the label is clicked.")]
        public string URL
        {
            get;
            set;
        }
        protected override void OnClick(EventArgs e)
        {
            try
            {
                Process.Start(URL);
            }
            catch (Exception ex)
            {
                // Log error here, or alert user.
                Console.WriteLine(ex.Message);
            }
            finally
            {
                base.OnClick(e);
            }
        }
    }
}

//Encrypt Value formatted as a base64-encoded string.
public static string Encrypt(string plainText,
                             string passPhrase,
                             string saltValue,
                             string hashAlgorithm,
                             int passwordIterations,
                             string initVector,
                             int keySize)
{
    //Covert strings into byte arrays.
    byte[] initVectorBytes = Encoding.ASCII.GetBytes(initVector);
    byte[] salValueBytes = Encoding.ASCII.GetBytes(saltValue);
    //Convert our plaintext password to a byte array.
    byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);
    //Create a password from which the value will be derived
    PasswordDeriveBytes password = new PasswordDeriveBytes(passPhrase,
        salValueBytes, hashAlgorithm, passwordIterations);
    //Use the password to generate psuedo-random bytes for encryption key.
    //Specify the size of the key in bytes (intead of bits).
    byte[] keyBytes = password.GetBytes(keySize / 8);
    //Create uninitialized Rijndael encryption object.
    RijndaelManaged symmetricKey = new RijndaelManaged();
    //Set encryption mode to Cipher Block Chaining(CBC).
    symmetricKey.Mode = CipherMode.CBC;
    //Generate encryptor from the existing key bytes and initialization vector.
    ICryptoTransform encryptor = symmetricKey.CreateEncryptor(keyBytes,
        initVectorBytes);
    //Define memorystream to hold encrypted data.
    MemoryStream memoryStream = new MemoryStream();
    //Define Cryptographic stream. (Always use write mode)
    CryptoStream cryptoStream = new CryptoStream(memoryStream, encryptor,
        CryptoStreamMode.Write);
    //Start Encrypting
    cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length);
    //Finish encrypting
    cryptoStream.FlushFinalBlock();
    //Convert encrypted stream to a byte array
    byte[] cipherTextBytes = memoryStream.ToArray();
    //Close both streams
    memoryStream.Close();
    cryptoStream.Close();
    //Convert to encrypted into base64-encoding string
    string cipherText = Convert.ToBase64String(cipherTextBytes);
    //return encrypted string
    return cipherText;
}

//Now for the Decyption.

public static string Decrypt(string cipherText,
                             string passPhrase,
                             string saltValue,
                             string hashAlgorithm,
                             int passwordIterations,
                             string initVector,
                             int keySize)
{
    byte[] initVectorBytes = Encoding.ASCII.GetBytes(initVector);
    byte[] saltValueBytes = Encoding.ASCII.GetBytes(saltValue);
    byte[] cipherTextBytes = Convert.FromBase64String(cipherText);
    PasswordDeriveBytes password = new PasswordDeriveBytes(
                                                    passPhrase,
                                                    saltValueBytes,
                                                    hashAlgorithm,
                                                    passwordIterations);
    byte[] keyBytes = password.GetBytes(keySize / 8);
    RijndaelManaged symmetricKey = new RijndaelManaged();
    symmetricKey.Mode = CipherMode.CBC;
    ICryptoTransform decryptor = symmetricKey.CreateDecryptor(
                                                     keyBytes,
                                                     initVectorBytes);
    MemoryStream memoryStream = new MemoryStream(cipherTextBytes);
    CryptoStream cryptoStream = new CryptoStream(memoryStream,
                                                  decryptor,
                                                  CryptoStreamMode.Read);
    byte[] plainTextBytes = new byte[cipherTextBytes.Length];
    int decryptedByteCount = cryptoStream.Read(plainTextBytes,
                                               0,
                                               plainTextBytes.Length);
    memoryStream.Close();
    cryptoStream.Close();
    string plainText = Encoding.UTF8.GetString(plainTextBytes,
                                               0,
                                               decryptedByteCount);
    return plainText;
}