I started by creating a WinForms app. Then I added a reference to the SAPI COM DLL. That provides basic speech capabilities. Then I added the voice:
///
/// Voice for speaking.
///
private static ISpVoice mVoice = new SpVoiceClass();
ISpVoice is the SAPI interface for text-to-speech, and SpVoiceClass is the class that implements it.
Next I added the InkEdit control, a Tablet PC control that accepts text input through either the keyboard or the pen. But InkEdit inherits from RichTextBox, which is a standard WinForms control. So I used the .NET Assembly class to attempt to load the Tablet PC Ink library, and create an InkEdit control; and if that failed at any step, I just created a RichTextBox instead:
// Create the Ink Edit or Rich Text. We can't do
// this in InitializeComponent because we want to
// support InkEdit on Tablets or just RichTextBox
// on non-Tablets.
try
{
Assembly a = Assembly.Load("Microsoft.Ink, Version=1.7.2600.2180, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
this.txtVox = a.CreateInstance(
"Microsoft.Ink.InkEdit") as RichTextBox;
}
catch(Exception ex)
{
this.txtVox = new RichTextBox();
}
Next I added a handler for the TextChanged event of the text box:
///
/// User changed text, either via voice or keyboard.
/// Get ready to speak.
///
/// Stock.
/// Stock.
private void txtVox_TextChanged(object sender, EventArgs e)
{
// We can't speak right away. If the user is typing,
// we'll get this message on every character. That
// would be REALLY annoying. So instead, we'll start
// or restart a timer, and speak when we pause.
StartTimer();
}
As per the comments, I chose not to make Vox speak after every TextChanged event. That would make it speak o n e l e t t e r a t a t i m e , which would be really annoying. Instead, I start (or restart) a delay timer. (It defaults to one second, but the user can choose half a second or two seconds). If no new text comes in before the timer expires,
then I make Vox speak:
///
/// When the timer expires, speak the new text.
///
/// Stock.
/// Stock.
private void tmrVox_Tick(object sender, EventArgs e)
{
SpeakNewText();
}
The SpeakNewText method ensures that we only speak the
new text:
///
/// Speak the text that has changed since the last call
/// to this method.
///
private void SpeakNewText()
{
// Turn off the timer.
tmrVox.Enabled = false;
// Assume the full current text.
string message = txtVox.Text.Trim();
// Strip out prior text.
if (!string.IsNullOrEmpty(mLastMessage))
{
// Find the prior text.
int idxPrevious = message.IndexOf(mLastMessage);
if (idxPrevious != -1)
{
// If it's at the start or end, strip it off.
if (idxPrevious == 0)
{
message = message.Substring(
idxPrevious + mLastMessage.Length);
}
else if ((idxPrevious + mLastMessage.Length) >= message.Length)
{
message = message.Substring(0,
idxPrevious);
}
}
}
// Remember this for next time.
mLastMessage = txtVox.Text.Trim();
// Speak!
SpeakMessage(message, true);
}
First it searches for the old text within the current text:
// Assume the full current text.
string message = txtVox.Text.Trim();
// Strip out prior text.
if (!string.IsNullOrEmpty(mLastMessage))
{
// Find the prior text.
int idxPrevious = message.IndexOf(mLastMessage);
if (idxPrevious != -1)
{
Then if the old text was found at either the start or end of the current text, it's stripped off:
// If it's at the start or end, strip it off.
if (idxPrevious == 0)
{
message = message.Substring(
idxPrevious + mLastMessage.Length);
}
else if ((idxPrevious + mLastMessage.Length)
>= message.Length)
{
message = message.Substring(0,
idxPrevious);
}
And then we store the current text for next time; and then we speak the remainder with SpeakMessage:
///
/// Speak a message and store it for recall.
///
///
/// True to add to the prior message log.
public static void SpeakMessage(string message,bool record)
{
// Test for invalid message.
if (message == null)
{
throw new ArgumentNullException("message");
}
// Test for empty message.
message = message.Trim();
if (!string.IsNullOrEmpty(message))
{
// Say it!
uint uiStream;
mVoice.Speak(message, 1, out uiStream);
// Record it.
if ((record) &&
(!sActiveForm.tcboxPrevious.Items.Contains(
message)))
{
sActiveForm.tcboxPrevious.Items.Insert(0,
message);
sActiveForm.tcboxPrevious.SelectedIndex = -1;
}
}
}
The core of this method is this call:
// Say it!
uint uiStream;
mVoice.Speak(message, 1, out uiStream);
The speak method performs the text-to-speech. The message parameter tells it what to speak. The uiStream output parameter will receive the stream number, which will increase as multiple Speak calls queue up. And the flag value, 1, indicates that we want asynchronous speech, allowing us to continue typing or writing while Vox speaks.
The other important feature we need is a way to stop speaking. Imagine you have a page of text, and Vox has just finished speaking; and then imagine that you delete the last character from it. Then as SpeakNewText is written above, the old text will be longer than the new text, and so won't be found within it; so the entire page of text will be spoken again. Now I think that this design is the best we can do, over all, but we don't want to hear the whole page over again. So Vox includes a stop button.
Now what's interesting is that ISpVoice doesn't include a Cancel or Stop method. There's no direct way to stop the voice once it's speaking. But ISpVoice does include two other useful methods: GetStatus and Skip. GetStatus allows you to test whether the voice is speaking; and skip allows you to skip ahead by some unit of speech. (The only unit supported in SAPI 5.1 is SENTENCE.) So our Stop method looks like this:
///
/// Stop speaking the current message.
///
public static void StopSpeaking()
{
// Get the status.
SPVOICESTATUS vstat;
string mark;
mVoice.GetStatus(out vstat, out mark);
// While still speaking, skip ahead.
while (vstat.dwRunningState == 2)
{
// Skip 1000 sentences. There appears to be no
// harm in skipping past the end.
uint ui;
mVoice.Skip("SENTENCE", 1000, out ui);
// Get the status again.
mVoice.GetStatus(out vstat, out mark);
}
}
Originally, I made it skip ahead 1 sentence. That worked well for small pages; but I found that in longer pages, it would speak the first fractional syllable of many of the sentences, which would be really annoying. With a little experimentation, I found that there are no errors that occur if you skip too far and pass the end of the queued up Speak calls. So to be really sure to quit quickly, I jump ahead by 1000 sentences.
Now there's more to Vox than that; but the rest of it is pretty straightforward WinForms programming. These are the parts that really show a little bit of Ink and Voice programming. If you would like to see the rest of the source code, leave me a comment, and I can send it to you.
]]>
