IOleCommandTarget
C# Definition:
//IMPORTANT: The order of the methods is critical here. You
//perform early binding in most cases, so the order of the methods
//here MUST match the order of their vtable layout (which is determined
//by their layout in IDL). The interop calls key off the vtable
//ordering, not the symbolic names. Therefore, if you switched these
//method declarations and tried to call the Exec method on an
//IOleCommandTarget interface from your application, it would
//translate into a call to the QueryStatus method instead.
void QueryStatus(
ref Guid pguidCmdGroup,
UInt32 cCmds,
[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] OLECMD[] prgCmds,
ref OLECMDTEXT CmdText);
void Exec(
ref Guid pguidCmdGroup,
uint nCmdId,
uint nCmdExecOpt,
ref object pvaIn,
ref object pvaOut);VB Definition:
<ComImport> _
<Guid("TODO")> _
'TODO: Insert <InterfaceType(ComInterfaceType.InterfaceIsIUnknown)> _ if this doesn't derive from IDispatch
Interface IOleCommandTarget
TODO
End InterfaceC# Definition:
[StructLayout(LayoutKind.Sequential)]
public struct OLECMD
{
//public UInt32 cmdID;
//public UInt64 cmdf;
public uint cmdID;
public uint cmdf; // NB: See above note (*)
}
[StructLayout(LayoutKind.Sequential)]
public struct OLECMDTEXT
{
public UInt32 cmdtextf;
public UInt32 cwActual;
public UInt32 cwBuf;
public char rgwz;
}
[ComImport, Guid("b722bccb-4e68-101b-a2bc-00aa00404770"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IOleCommandTarget
{
//IMPORTANT: The order of the methods is critical here. You
//perform early binding in most cases, so the order of the methods
//here MUST match the order of their vtable layout (which is determined
//by their layout in IDL). The interop calls key off the vtable
//ordering, not the symbolic names. Therefore, if you switched these
//method declarations and tried to call the Exec method on an
//IOleCommandTarget interface from your application, it would
//translate into a call to the QueryStatus method instead.
[PreserveSig()]
int QueryStatus([In, MarshalAs(UnmanagedType.Struct)] ref Guid pguidCmdGroup, [MarshalAs(UnmanagedType.U4)] int cCmds, [In, Out]IntPtr prgCmds, [In, Out] IntPtr pCmdText);
[PreserveSig()]
int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdExecOpt, object[] pvaIn, [In, Out, MarshalAs(UnmanagedType.LPArray)] object[] pvaOut);
}C# Definition:
//This attribute demands that all classes derived from the parent class have the specified permission.
[SecurityPermission(SecurityAction.LinkDemand),
SecurityPermission(SecurityAction.InheritanceDemand)]
/// <summary>
/// This class' methods wrap the IOLE commands.
/// </summary>
/// <purpose>
/// The class makes the calls to functions that handle going from
/// managed code to native code. The class shows the implementation necessary
/// for using IOLE Commands.
/// </purpose>
public class NativeCommands
{
private FormControl _infoPathControl;
protected const int QUERYFAILED = -1;
private string lastCommandExecuted;
/// <summary>
/// returns the last command that was executed.
/// </summary>
public string LastCommandExecuted
{
get
{
return lastCommandExecuted;
}
}
/// <summary>
/// InfoPath Form Control object
/// </summary>
public FormControl InfoPathControl
{
get
{
return _infoPathControl;
}
set
{
_infoPathControl = value;
}
}
#region Structures
/// <summary>
/// Struture passed as prgCmds parameter in the QueryStatus method
/// This structure holds the command to be queried and the result of the query
/// </summary>
[StructLayout(LayoutKind.Sequential)]
public struct OLECMD
{
/// <summary>
/// Command to be queried
/// </summary>
private uint cmdID;
/// <summary>
/// Result of the query
/// </summary>
private uint cmdf;
/// <summary>
/// Gets or sets the command to be queried.
/// </summary>
public uint CmdId
{
get
{
return cmdID;
}
set
{
cmdID = value;
}
}
public uint CmdF
{
get
{
return cmdf;
}
set
{
cmdf = value;
}
}
}
#endregion
#region Interfaces
//import the IOLECommandTarget interface to perform IOLE commands
//IOLECommandTarget is registered in the registry
[
ComImport,
Guid("B722BCCB-4E68-101B-A2BC-00AA00404770"),
InterfaceType(ComInterfaceType.InterfaceIsIUnknown)
]
private interface IOleCommandTarget
{
/// <summary>
/// Checks to see if a given command can be executed
/// </summary>
/// <param name="pguidCmdGroup">Unique identifier of the command group, NULL to specify the standard group</param>
/// <param name="cCmds">The number of commands in the prgCmds array</param>
/// <param name="prgCmds">Array of OLECMD structures that indicate the commands status information is required</param>
/// <param name="pCmdText">Pointer to name or status of command, NULL indicates this is not necessary</param>
void QueryStatus(ref Guid pguidCmdGroup, uint cCmds, [MarshalAs(UnmanagedType.LPArray), In, Out] OLECMD[] prgCmds, IntPtr pCmdText);
/// <summary>
/// Executes a specified command
/// </summary>
/// <param name="pguidCmdGroup">Command group</param>
/// <param name="nCmdID">Identifier of command to execute</param>
/// <param name="nCmdExecOpt">Options for executing the command</param>
/// <param name="pvaIn">Input arguments</param>
/// <param name="pvaOut">Command output</param>
void Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdExecOpt, ref object pvaIn, ref object pvaOut);
}
#endregion
#region Enums
/// <summary>
/// Designates the type of support provided by an object for the specified command
/// </summary>
[FlagsAttribute]
public enum OleCmdf
{
/// <summary>
/// The command is supported by this object
/// </summary>
Supported = 1,
/// <summary>
/// The command is available and enabled
/// </summary>
Enabled = 2,
/// <summary>
/// The command is an on-off toggle and is currently on
/// </summary>
Latched = 4,
/// <summary>
/// Reserved for future use
/// </summary>
Ninched = 8
}
#endregion
#region Query Status
/// <summary>
/// Queries whether or not a command can be executed
/// </summary>
/// <param name="commandID">ID number of the command to query</param>
/// <returns>True if command can be performed and false if it cannot</returns>
public bool QueryCommandStatus(FormControlCommandIds.CommandIds commandId)
{
//Create an array for the OLECMD
OLECMD[] commands = new OLECMD[1];
commands[0].CmdId = Convert.ToUInt16(commandId,CultureInfo.CurrentCulture);
commands[0].CmdF = 0;
QueryCommandStatus(commands);
//if command is supported and enabled command can be executed
return (((commands[0].CmdF & (uint)OleCmdf.Supported) != 0) && ((commands[0].CmdF & (uint)OleCmdf.Enabled) != 0));
}
/// <summary>
/// Queries whether or not a command can be executed
/// </summary>
/// <param name="commands">Group of commands to be queried</param>
public void QueryCommandStatus(OLECMD[] commands)
{
//Get a IOLECommandTarget object form the ActiveX control
IOleCommandTarget commandTarget = _infoPathControl.GetOcx() as IOleCommandTarget;
try
{
commandTarget.QueryStatus(ref FormControlCommandIds.CommandGroup, Convert.ToUInt16(commands.Length), commands, IntPtr.Zero);
}
catch (Exception ex)
{
throw new HostedException("An error occurred while attempting to query commands", ex);
}
}
#endregion
#region Command Execution
/// <summary>
/// Checks whether or not the specified command is on or off
/// </summary>
/// <param name="commandID">Command to be executed</param>
/// <returns>True if command is activated or False if not</returns>
public bool IsCommandOn(FormControlCommandIds.CommandIds commandId)
{
//Create an array for the OLECMD
OLECMD[] commands = new OLECMD[1];
commands[0].CmdId = Convert.ToUInt16(commandId,CultureInfo.CurrentCulture);
commands[0].CmdF = 0;
QueryCommandStatus(commands);
return (((commands[0].CmdF & (uint)OleCmdf.Supported) != 0) && ((commands[0].CmdF & (uint)OleCmdf.Enabled) != 0) &&
((commands[0].CmdF & (uint)OleCmdf.Latched) != 0));
}
/// <summary>
/// Executes a given command
/// </summary>
/// <param name="CommandID">Command to be executed</param>
/// <returns>Results of executing a command</returns>
public object ExecuteCommand(FormControlCommandIds.CommandIds commandId)
{
return ExecuteCommand(commandId, null);
}
/// <summary>
/// Executes a given command with specified parameters
/// </summary>
/// <param name="CommandID">Command to be executed</param>
/// <param name="vaIn">Input Arguments</param>
/// <returns>Results of executing the command</returns>
public object ExecuteCommand(FormControlCommandIds.CommandIds commandId, object vaIn)
{
//remember the last command executed
lastCommandExecuted = commandId.ToString();
//indicates to Exec call to do the default option
const int EXECUTE_OPTION_DO_DEFAULT = 0;
//holds the return result
object vaOut = null;
//make sure the command can be executed first
if (!QueryCommandStatus(commandId))
{
return QUERYFAILED;
}
// Get the commandTarget from the control
IOleCommandTarget commandTarget = _infoPathControl.GetOcx() as IOleCommandTarget;
try
{
commandTarget.Exec(ref FormControlCommandIds.CommandGroup, Convert.ToUInt16(commandId,CultureInfo.CurrentCulture),
EXECUTE_OPTION_DO_DEFAULT, ref vaIn, ref vaOut);
return vaOut;
}
catch (Exception ex)
{
throw new HostedException("An error occurred while executing command " + commandId.ToString(), ex);
}
}
#endregion
}C# Definition:
//This attribute demands that all classes derived from the parent class have the specified permission.
[SecurityPermission(SecurityAction.LinkDemand),
SecurityPermission(SecurityAction.InheritanceDemand)]
/// <summary>
/// The class makes calls to perform commands against the form control
/// </summary>
/// <purpose>
/// Class is designed to be a central point for executing commands against a form control
/// In order to use this class a user must provide an instance of a form control.
/// </purpose>
public class FormController : NativeCommands
{
#region Constructors
/// <summary>
/// Commands
/// </summary>
public FormController(FormControl parentInfoPathInstance)
{
if (parentInfoPathInstance != null)
{
InfoPathControl = parentInfoPathInstance;
}
else
{
InfoPathControl = new FormControl();
}
}
#endregion
#region Enums and Structs
/// <summary>
/// Enumeration of the Interaction type This will allow different
/// code paths to be triggered for an action
/// </summary>
public enum InteractionType
{
/// <summary>
/// Uses the InfoPath OM
/// </summary>
OM = 0,
/// <summary>
/// Uses the supported InfoPath IOLECommand
/// </summary>
IOLE = 1,
}
/// <summary>
/// Defines the directions a table can have
/// </summary>
public struct TableDirectionValues
{
public const string NODIRECTION = "none";
public const string RIGHTTOLEFT = "RTL";
public const string LEFTTORIGHT = "LTR";
}
/// <summary>
/// Defines the horizontal alignment values for a table
/// </summary>
public struct TableHorizontalAlignmentValues
{
public const string LEFT = "left";
public const string CENTER = "center";
public const string RIGHT = "right";
}
/// <summary>
/// Defines the vertical alignment values for a table
/// </summary>
public struct TableVerticalAlignmentValues
{
public const string TOP = "top";
public const string MIDDLE = "middle";
public const string BOTTOM = "bottom";
}
/// <summary>
/// Defines the picture alignment values for a table
/// </summary>
public struct PictureAlignmentValues
{
public const string LEFT = "Left";
public const string RIGHT = "Right";
public const string INLINE = "inline";
}
#endregion
/// <summary>
/// Makes sure the command was executed properly
/// </summary>
/// <param name="commandResult">The result from executing the command</param>
/// <returns>The result from executing the command</returns>
private object ChkResult(object commandResult)
{
if ((commandResult !=null) && (commandResult.GetType().Equals(typeof(int))))
{
int result = (int)commandResult;
if (result == QUERYFAILED)
{
throw new NonApplicableCommandException("The command could not be executed at this time because it is not applicable. Command: " +
LastCommandExecuted);
}
}
return commandResult;
}
/// <summary>
/// Makes sure the command was executed properly
/// </summary>
/// <param name="commandResult">The result from executing the command</param>
/// <param name="expectedReturnType">The type of object the command was expected to return</param>
/// <returns>The result from executing the command</returns>
private object ChkResult(object commandResult, Type expectedReturnType)
{
commandResult = ChkResult(commandResult);
if ((commandResult!=null) && (!commandResult.GetType().Equals(expectedReturnType)))
{
throw new HostedException("Return type was not as expected. Expected type " + expectedReturnType.ToString() +
" but received " + commandResult.GetType().ToString() + "\nCommand: " + LastCommandExecuted);
}
return commandResult;
}
/// <summary>
/// Enters text into a field
/// </summary>
/// <param name="xPath">Field for data</param>
/// <param name="data">Data to put in the field</param>
public void EnterData(string xPath, string data)
{
if (string.IsNullOrEmpty(xPath))
{
throw new InvalidDataException("Parameter 'xPath' must have a value");
}
if (string.IsNullOrEmpty(data))
{
throw new InvalidDataException("Parameter 'data' must have a value");
}
if (IsFormLoaded)
{
XPathNavigator field =
InfoPathControl.XmlForm.MainDataSource.CreateNavigator().SelectSingleNode(xPath, InfoPathControl.XmlForm.NamespaceManager);
field.SetValue(data);
}
else
{
throw new HostedException("No form is currently loaded");
}
}
#region Load Methods
/// <summary>
/// Uses a File Open Dialog to get the path and name of an InfoPath xml, xsn or xsf to load
/// </summary>
public void Open()
{
OpenFileDialog openDialog = new OpenFileDialog();
//set initial directory the my documents folder
openDialog.InitialDirectory = System.Environment.GetFolderPath(System.Environment.SpecialFolder.MyDocuments);
openDialog.Filter = "All InfoPath Forms |*.xml;*.xsn|Forms (*.xml)|*.xml,*.xsn|InfoPath Form Templates (*.xsn)|*.xsn|Manifest Files (*.xsf)|*.xsf|All files (*.*)|*.*";
//set the default filter = (InfoPath) Forms
openDialog.FilterIndex = 1;
//when the user clicks OK, call the Load method of the InfoPath Editor Control object
if (openDialog.ShowDialog() == DialogResult.OK)
{
if (openDialog.FileName.EndsWith(".xsn",StringComparison.OrdinalIgnoreCase) || openDialog.FileName.EndsWith(".xsf",StringComparison.OrdinalIgnoreCase))
{
NewFromFormTemplate(openDialog.FileName);
}
else if (openDialog.FileName.EndsWith(".xml",StringComparison.OrdinalIgnoreCase))
{
Open(openDialog.FileName);
}
else
{
throw new InvalidFileException("Specified file was not a valid InfoPath File");
}
}
else
{
throw new HostedException("Operation was cancelled by the user");
}
}
/// <summary>
/// Loads a form given the full path and file name
/// </summary>
/// <param name="filePath">Full file path and name to an InfoPath xml file</param>
public void Open(string filePath)
{
if (!String.IsNullOrEmpty(filePath))
{
try
{
if (!File.Exists(filePath))
{
throw new InvalidFileException("The file " + filePath + " cannot be found");
}
InfoPathControl.Open(filePath);
}
catch (Exception ex)
{
throw new HostedException("An error occurred while attempting to open a file", ex);
}
}
else
{
throw new InvalidDataException("Parameter 'filePath' must have a value");
}
}
#region OpenThroughStream
/// <summary>
/// Uses a Form Open Dialog to load a form. Loads the instance .xml
/// into a stream first.
/// </summary>
public void OpenThroughStream()
{
OpenFileDialog openDialog = new OpenFileDialog();
openDialog.InitialDirectory = System.Environment.GetFolderPath(System.Environment.SpecialFolder.MyDocuments);
openDialog.Filter = "Forms (*.xml)|*.xml|All files (*.*)|*.*";
openDialog.FilterIndex = 1;
if (openDialog.ShowDialog() == DialogResult.OK)
{
if (openDialog.FileName.EndsWith(".xml",StringComparison.OrdinalIgnoreCase))
{
OpenThroughStream(openDialog.FileName);
}
else
{
throw new HostedException("Invalid file type. Should be .xml");
}
}
else
{
throw new HostedException("Operation was cancelled by the user");
}
}
/// <summary>
/// Loads an xml from through stream given the full path and file name
/// </summary>
/// <param name="fileName">Full path and file name</param>
public void OpenThroughStream(string fileName)
{
if (!String.IsNullOrEmpty(fileName))
{
try
{
if (!File.Exists(fileName))
{
throw new InvalidFileException("The file " + fileName + " cannot be found");
}
XmlDocument tempXmlDoc = new XmlDocument();
tempXmlDoc.Load(fileName);
MemoryStream tempCoreStream = new MemoryStream();
tempXmlDoc.Save(tempCoreStream);
InfoPathControl.Open(tempCoreStream);
tempCoreStream.Close();
}
catch (Exception ex)
{
throw new HostedException("An error occurred while attempting to open a file", ex);
}
}
else
{
throw new InvalidDataException("Parameter 'fileName' must contain a value");
}
}
#endregionC# Definition:
/// <summary>
/// Opens an InfoPath form template in the Editor
/// </summary>
/// <param name="filePath">Full path and file name of the .xsf or .xsn file</param>
public void NewFromFormTemplate(string filePath)
{
if (!String.IsNullOrEmpty(filePath))
{
try
{
if (!File.Exists(filePath))
{
throw new InvalidFileException("The file " + filePath + " cannot be found");
}
InfoPathControl.NewFromFormTemplate(filePath);
}
catch (Exception ex)
{
throw new HostedException("An error occurred while attempting to open a file", ex);
}
}
else
{
throw new InvalidDataException("Parameter 'filePath' must contain a value");
}
}
/// <summary>
/// Uses Form Open Dialogs to get an instance .xml and a solution .xsn
/// to load. The .xml is loaded into a stream first.
/// </summary>
public void NewFromFormTemplateWithData()
{
string xmlFile = string.Empty;
string xsnFile = string.Empty;
OpenFileDialog openDialog = new OpenFileDialog();
openDialog.InitialDirectory = System.Environment.GetFolderPath(System.Environment.SpecialFolder.MyDocuments);
//get instance xml file
openDialog.Title = "Select instance .xml file.";
openDialog.Filter = "Forms (*.xml)|*.xml|All files (*.*)|*.*";
if (openDialog.ShowDialog() == DialogResult.OK)
{
if (openDialog.FileName.EndsWith(".xml",StringComparison.OrdinalIgnoreCase))
{
xmlFile = openDialog.FileName;
}
else
{
throw new InvalidFileException("Selected file " + openDialog.FileName + " was not an XML file");
}C# Definition:
//get form template xsn
openDialog.Title = "Select form tempalte .xsn.";
openDialog.Filter = "Form Templates (*.xsn)|*.xsn|All files (*.*)|*.*";
if (openDialog.ShowDialog() == DialogResult.OK)
{
if (openDialog.FileName.EndsWith(".xsn",StringComparison.OrdinalIgnoreCase))
{
xsnFile = openDialog.FileName;
}
else
{
throw new HostedException("Selected file " + openDialog.FileName + " was not an XSN file");
}
}
}
//Load files provided user did not cancel any option
if (!(string.IsNullOrEmpty(xmlFile)) && !(string.IsNullOrEmpty(xsnFile)))
{
NewFromFormTemplateWithData(xmlFile, xsnFile);
}
else
{
throw new HostedException("Operation was cancelled by user");
}
}
/// <summary>
/// Load an XSN using data specified by in an xml file
/// </summary>
/// <param name="xmlFile">Data to open xsn with</param>
/// <param name="xsnFile">XSN file to open</param>
public void NewFromFormTemplateWithData(string xmlFile, string xsnFile)
{
if (String.IsNullOrEmpty(xmlFile))
{
throw new InvalidDataException("Parameter 'xmlFile' must have a value");
}
if (String.IsNullOrEmpty(xsnFile))
{
throw new InvalidDataException("Parameter 'xsnFile' must have a value");
}
if (!File.Exists(xmlFile))
{
throw new InvalidFileException("The file " + xmlFile + " cannot be found");
}
if (!File.Exists(xsnFile))
{
throw new InvalidFileException("The file " + xsnFile + " cannot be found");
}
try
{
XmlDocument tempXmlDoc = new XmlDocument();
tempXmlDoc.Load(xmlFile);
MemoryStream tempCoreStream = new MemoryStream();
tempXmlDoc.Save(tempCoreStream);
InfoPathControl.NewFromFormTemplate(xsnFile, tempCoreStream, XmlFormOpenMode.Default);
tempCoreStream.Close();
}
catch (Exception ex)
{
throw new HostedException("An error occurred while attempting to open a file", ex);
}
}
#endregion
#region Save
/// <summary>
/// Saves the currently opened document
/// </summary>
/// <param name="interactionType">OM or IOLE</param>
public void Save(InteractionType interactionType)
{
switch (interactionType)
{
case InteractionType.OM:
if (IsFormLoaded)
{
try
{
InfoPathControl.XmlForm.Save();
}
catch(Exception ex)
{
throw new HostedException("An error occurred while attempting to save this form", ex);
}
}
break;
case InteractionType.IOLE:
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.Save));
break;
default:
throw new HostedException("Invalid InteractionType.");
}
}
/// <summary>
/// Opens the Save As dialog
/// </summary>
/// <param name="interactionType">IOLE or OM</param>
public void SaveAs(InteractionType interactionType)
{
switch (interactionType)
{
case InteractionType.OM:
if (IsFormLoaded)
{
SaveFileDialog saveFileDialog = new SaveFileDialog();
saveFileDialog.InitialDirectory = System.Environment.GetFolderPath(System.Environment.SpecialFolder.MyDocuments);
saveFileDialog.Filter = "Forms (*.xml)|*.xml|All files (*.*)|*.*";
saveFileDialog.FilterIndex = 1;
if (saveFileDialog.ShowDialog() == DialogResult.OK)
{
SaveAs(saveFileDialog.FileName);
}
}
break;
case InteractionType.IOLE:
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SaveAs));
break;
default:
throw new HostedException("Invalid InteractionType.");
}
}
/// <summary>
/// Does a save as using the object model given the save location
/// </summary>
/// <param name="savePath">Location to save the file</param>
public void SaveAs(string savePath)
{
if (String.IsNullOrEmpty(savePath))
{
throw new InvalidDataException("Parameter 'savePath' must have a value");
}
try
{
if (savePath.EndsWith(".xml",StringComparison.OrdinalIgnoreCase))
{
InfoPathControl.XmlForm.SaveAs(savePath);
}
else
{
InfoPathControl.XmlForm.SaveAs(savePath + ".xml");
}
}
catch (Exception ex)
{
throw new HostedException("An error occurred while attempting to save this form", ex);
}
}
#endregion
#region Print
/// <summary>
/// Prints the current view. Print Dialog does not appear and therefore a document
/// will be printed.with the default printer settings
/// </summary>
public void Print()
{
if (IsFormLoaded)
{
try
{
InfoPathControl.XmlForm.Print();
//NOTE: XmlForm.Print(true) will NOT show the print dialog.
//The print dialog is not supported in hosting scenarios
}
catch(Exception ex)
{
throw new HostedException("An error occurred while attempting to print this form", ex);
}
}
}
#endregion
#region Close
/// <summary>
/// Closes an XMLForm in the form control
/// </summary>
/// <param name="interactionType">Execute through IOLE or OM</param>
public void Close(InteractionType interactionType)
{
// Check to make sure there is a document loaded before
// trying to close it
if (IsFormLoaded)
{
switch (interactionType)
{
case InteractionType.OM:
try
{
InfoPathControl.XmlForm.Close();
}
catch (Exception ex)
{
throw new HostedException("An error occurred while attempting to close this form", ex);
}
break;
case InteractionType.IOLE:
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.Close));
break;
default:
throw new HostedException("Invalid InteractionType.");
}
}
}
#endregion
#region Font Formatting
#region Bold
/// <summary>
/// Sets/Unsets the formatting of the selected text to bold
/// </summary>
public void ToggleFontFormattingBold()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetFontFormattingBold));
}
#endregion
#region Italic
/// <summary>
/// Sets/Unsets the formatting of the selected text to Italics
/// </summary>
public void ToggleFontFormattingItalic()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetFontFormattingItalic));
}
#endregion
#region Underline
/// <summary>
/// Sets/Unsets the formatting of the selected text to be Underlined
/// </summary>
public void ToggleFontFormattingUnderline()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetFontFormattingUnderline));
}
#endregion
#region Strikethrough
/// <summary>
/// Sets/Unsets the formatting of the selected text to be strikethrough
/// </summary>
public void ToggleFontFormattingStrikethrough()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetFontFormattingStrikethrough));
}
#endregion
#region Superscript
/// <summary>
/// Sets the formatting of the selected text to be superscipt
/// </summary>
public void ToggleFontFormattingSuperscript()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetFontFormattingSuperscript));
}
#endregion
#region Subscript
/// <summary>
/// Sets/Unsets the formatting of the selected text to subscript
/// </summary>
public void ToggleFontFormattingSubscript()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetFontFormattingSubscript));
}
#endregion
#region IncreaseFontSizeBy2
/// <summary>
/// Increases the font size of the selected text by 2
/// </summary>
public void IncreaseFontSizeBy2()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.IncreaseFontSizeBy2));
}
#endregion
#region DecreaseFontSizeBy2
/// <summary>
/// Decreases the font size of the selected text by 2
/// </summary>
public void DecreaseFontSizeBy2()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.DecreaseFontSizeBy2));
}
#endregion
#region ClearFontFormatting
/// <summary>
/// Clears font formatting of the selected text
/// </summary>
public void ClearFontFormatting()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.ClearFontFormatting));
}
#endregion
#region Headings
/// <summary>
/// Sets the font formatting of the selected text to InfoPath's setting for heading 1
/// </summary>
public void SetFontFormattingHeading1()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetFontFormattingHeading1));
}
/// <summary>
///Sets the font formatting of the selected text to InfoPath's setting for heading 2
/// </summary>
public void SetFontFormattingHeading2()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetFontFormattingHeading2));
}
/// <summary>
/// Sets the font formatting of the selected text to InfoPath's setting for heading 3
/// </summary>
public void SetFontFormattingHeading3()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetFontFormattingHeading3));
}
/// <summary>
/// Sets the font formatting of the selected text to InfoPath's setting for heading 4
/// </summary>
public void SetFontFormattingHeading4()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetFontFormattingHeading4));
}
/// <summary>
/// Sets the font formatting of the selected text to InfoPath's setting for heading 5
/// </summary>
public void SetFontFormattingHeading5()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetFontFormattingHeading5));
}
/// <summary>
/// Sets the font formatting of the selected text to InfoPath's setting for heading 6
/// </summary>
public void SetFontFormattingHeading6()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetFontFormattingHeading6));
}
/// <summary>
/// Sets the font formatting of the selected text to InfoPath's setting for normal
/// </summary>
public void SetFontFormattingNormal()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetFontFormattingNormal));
}
#endregion
#region Font
/// <summary>
/// Gets the number of fonts in InfoPath's font list
/// </summary>
///<returns>numbers of fonts available</returns>
public int FontsAvailableCount
{
get
{
return Convert.ToInt32(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetFontsAvailableCount), typeof(int)),CultureInfo.CurrentCulture
);
}
}
/// <summary>
/// Gets the name of a font from InfoPath's font combobox at a user specified index
/// </summary>
/// <param name="index">index of the font</param>
/// <returns>The name of the font, empty if index is invalid</returns>
public string GetFontAt(int index)
{
if (index >= 0 && index < FontsAvailableCount)
{
return Convert.ToString(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetFontAvailableByIndex, index), typeof(string)),CultureInfo.CurrentCulture
);
}
else
{
throw new InvalidDataException("Index is not in a valid range");
}
}C# Definition:
/// <summary>
/// Sets/Gets the font of the currenty selected text
/// </summary>
/// <returns>The name of the font of the selected text</returns>
public string SelectedTextFont
{
get
{
return Convert.ToString(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetSelectedTextFont),typeof(string)),CultureInfo.CurrentCulture
);
}
set
{
if (!String.IsNullOrEmpty(value))
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetSelectedTextFont, value));
}
}
}
#endregion
#region FontSize
/// <summary>
/// Gets the number of font sizes in InfoPath's font size lists
/// </summary>
/// <returns>The number of font sizes available</returns>
public int FontSizesAvailableCount
{
get
{
return Convert.ToInt32(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetFontSizesAvailableCount),typeof(int)),CultureInfo.CurrentCulture
);
}
}
/// <summary>
/// Gets the value of a font size from InfoPath's font sizes combobox at a user specified index
/// </summary>
/// <param name="index">Index of the requested font size</param>
/// <returns>The font size at the specified index</returns>
public string GetFontSizeAt(int index)
{
if (index >= 0 && index < FontSizesAvailableCount)
{
return Convert.ToString(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetFontSizeAvailableByIndex, index), typeof(string)),CultureInfo.CurrentCulture
);
}
else
{
throw new InvalidDataException("Index is not in a valid range");
}
}
/// <summary>
/// Sets/Gets the font size of the currently selected text
/// </summary>
/// <returns>The name of the font size of the selected text</returns>
public string SelectedTextFontSize
{
get
{
return Convert.ToString(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetSelectedTextFontSize), typeof(string)),CultureInfo.CurrentCulture
);
}
set
{
if (!String.IsNullOrEmpty(value))
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetSelectedTextFontSize, value));
}
}
}
#endregion
#region Font Color
/// <summary>
/// Sets/Gets the font color of the selected text
/// </summary>
/// <returns>The current font color</returns>
public Color FontColor
{
get
{
try
{
return ColorTranslator.FromOle(Convert.ToInt32(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetSelectedTextFontColor), typeof(int)), CultureInfo.CurrentCulture
));
}
catch (Exception ex)
{
throw new HostedException("An error occurred while attempting to get the font color", ex);
}
}
set
{
UInt32 vaIn;
try
{
vaIn = Convert.ToUInt32(System.Drawing.ColorTranslator.ToOle(value));
}
catch (Exception ex)
{
throw new HostedException("An error occurred while attempting to set the font color", ex);
}
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetSelectedTextFontColor, vaIn));
}
}
/// <summary>
/// Gets InfoPath's default font color
/// </summary>
/// <returns>The default font color</returns>
public Color DefaultFontColor
{
get
{
try
{
return ColorTranslator.FromOle(Convert.ToInt32(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetDefaultFontColor), typeof(int)),CultureInfo.CurrentCulture
));
}
catch (Exception ex)
{
throw new HostedException("An error occurred while attempting to get the default font color", ex);
}
}
}
#endregion
#region HighlightColor
/// <summary>
/// Sets/Gets the highlight color of the selected text
/// </summary>
/// <returns type="Color">The current highlight color</returns>
public Color HighlightColor
{
get
{
try
{
return ColorTranslator.FromOle(Convert.ToInt32(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetSelectedTextHighlightColor), typeof(int)),CultureInfo.CurrentCulture
));
}
catch (Exception ex)
{
throw new HostedException("An error occurred while attempting to get the highlight color", ex);
}
}
set
{
UInt32 vaIn;
try
{
vaIn = Convert.ToUInt32(System.Drawing.ColorTranslator.ToOle(value));
}
catch (Exception ex)
{
throw new HostedException("An error occurred while attempting to set the highlight color", ex);
}
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetSelectedTextHighlightColor, vaIn));
}
}
/// <summary>
/// Gets InfoPath's default highlight color
/// </summary>
/// <returns type="Color">The default highlight color</returns>
public Color DefaultHighlightColor
{
get
{
try
{
return ColorTranslator.FromOle(Convert.ToInt32(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetDefaultHighlightColor), typeof(int)),CultureInfo.CurrentCulture
));
}
catch (Exception ex)
{
throw new HostedException("An error occurred while attempting to get the default highlight color", ex);
}
}
}
#endregion
#endregion
#region Paragraph settings
#region AlignLeft
/// <summary>
/// Aligns the selected paragraph to the left
/// </summary>
public void AlignTextLeft()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.AlignTextLeft));
}
#endregion
#region AlignCenter
/// <summary>
/// Aligns the selected paragraph to the center
/// </summary>
public void AlignTextCenter()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.AlignTextCenter));
}
#endregion
#region AlignRight
/// <summary>
/// Aligns the selected paragraph to the right
/// </summary>
public void AlignTextRight()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.AlignTextRight));
}
#endregion
#region AlignJustify
/// <summary>
/// Justifies the selected paragraph
/// </summary>
public void AlignTextJustify()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.AlignTextJustify));
}
#endregion
#region Increase Indent
/// <summary>
/// Increases indentation of the selected paragraph
/// </summary>
public void IncreaseIndent()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.IncreaseIndent));
}
#endregion
#region Decrease Indent
/// <summary>
/// Decreases indentation of the selected paragraph
/// </summary>
public void DecreaseIndent()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.DecreaseIndent));
}
#endregion
#region Single Line Spacing
/// <summary>
/// Sets the line spacing to 1.0
/// </summary>
public void SetSingleLineSpacing()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetSingleLineSpacing));
}
#endregion
#region Double Line Spacing
/// <summary>
/// Sets the line spacing to 2.0
/// </summary>
public void SetDoubleLineSpacing()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetDoubleLineSpacing));
}
#endregion
#region 1.5 Line Spacing
/// <summary>
/// Sets the line spacing to 1.5
/// </summary>
public void Set15LineSpacing()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.Set15LineSpacing));
}
#endregion
#region Background Color
/// <summary>
/// Gets the background color of the selected text
/// </summary>
/// <returns type="Color">the current background color</returns>
public Color BackgroundColor
{
get
{
try
{
return ColorTranslator.FromOle(Convert.ToInt32(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetSelectedTextBackgroundColor)),CultureInfo.CurrentCulture
));
}
catch (Exception ex)
{
throw new HostedException("An error occurred while attempting to get the background color", ex);
}
}
set
{
UInt32 vaIn;
try
{
vaIn = Convert.ToUInt32(System.Drawing.ColorTranslator.ToOle(value));
}
catch (Exception ex)
{
throw new HostedException("An error occurred while attempting to set the background color", ex);
}
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetSelectedTextBackgroundColor, vaIn));
}
}
#endregion
#endregion
#region Editing
#region Undo
/// <summary>
/// Un-does the last action
/// </summary>
public void Undo()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.Undo));
}
#endregion
#region Redo
/// <summary>
/// Re-does the last action
/// </summary>
public void Redo()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.Redo));
}
#endregion
#region Cut
/// <summary>
/// Cuts the selected text and copies it to the clipboard
/// </summary>
public void Cut()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.Cut));
}
#endregion
#region Copy
/// <summary>
/// Copies the selected text to the clipboard
/// </summary>
public void Copy()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.Copy));
}
#endregion
#region Paste
/// <summary>
/// Pastes the copied or cut text into the selected control
/// </summary>
public void Paste()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.Paste));
}
#endregion
#region Select All
/// <summary>
/// Selects all of the text in a control
/// </summary>
public void SelectAll()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SelectAll));
}
#endregion
#region Format Painter
/// <summary>
/// Applies the current formatting to other text
/// </summary>
public void FormatPainter()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.FormatPainterCopyFormatting));
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.FormatPainterApplyFormatting));
}
/// <summary>
/// Applies the current formatting to other text with the brush remaining after each paste
/// </summary>
public void FormatPainterPersistent()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.FormatPainterCopyFormattingPersistent));
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.FormatPainterApplyFormattingPersistent));
}
#endregion
#region Find and Replace
/// <summary>
/// Sets/Gets whether or not the use wildcards option is turned on
/// </summary>
/// <returns>True if use wildcards is on, otherwise false</returns>
public bool FindReplaceOptionUseWildcardsOn
{
get
{
return IsCommandOn(FormControlCommandIds.CommandIds.SetFindReplaceOptionUseWildcards);
}
set
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetFindReplaceOptionUseWildcards, value));
}
}
/// <summary>
/// Sets/Gets whether or not the match case option is turned on
/// </summary>
/// <returns>True if match case is on, otherwise false</returns>
public bool FindReplaceOptionMatchCaseOn
{
get
{
return IsCommandOn(FormControlCommandIds.CommandIds.SetFindReplaceOptionMatchCase);
}
set
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetFindReplaceOptionMatchCase, value));
}
}
/// <summary>
/// Sets/Gets whether or not the use whole words only option is turned on
/// </summary>
/// <returns>True if whole words only is on, otherwise false</returns>
public bool FindReplaceOptionWholeWordsOnlyOn
{
get
{
return IsCommandOn(FormControlCommandIds.CommandIds.SetFindReplaceOptionWholeWordOnly);
}
set
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetFindReplaceOptionWholeWordOnly, value));
}
}
/// <summary>
/// Sets/Gets the search direction
/// </summary>
/// <returns>1 for up, o for down</returns>
public int FindReplaceOptionSearchDirection
{
get
{
return Convert.ToInt32(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetFindReplaceOptionSearchDirection),typeof(int)),CultureInfo.CurrentCulture
);
}
set
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetFindReplaceOptionSearchDirection, value));
}
}
/// <summary>
/// Gets the result of the find/replace action
/// </summary>
/// <returns>The result of the find operation</returns>
public int FindReplaceResult
{
get
{
return Convert.ToInt32(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetFindReplaceState),typeof(int)),CultureInfo.CurrentCulture
);
}
}
/// <summary>
/// Sets/Gets the string being searched for
/// </summary>
/// <returns>The string being searched for</returns>
public string FindString
{
get
{
return Convert.ToString(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetFindString),typeof(string)),CultureInfo.CurrentCulture
);
}
set
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetFindString, value));
}
}
/// <summary>
/// Sets/Gets the string replacing the search string
/// </summary>
/// <returns>The replacement string</returns>
public string ReplaceString
{
get
{
return Convert.ToString(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetReplaceWithString),typeof(string)),CultureInfo.CurrentCulture
);
}
set
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetReplaceWithString, value));
}
}
/// <summary>
/// Finds the next instance of the search string in the document
/// </summary>
public void FindNext()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.FindReplaceFindNext));
}
/// <summary>
/// Replaces the currently selected search string instance
/// </summary>
/// <param name="ReplaceString">string to replace selected string</param>
public void Replace()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.Replace));
}
/// <summary>
/// Replaces all matching instances of the find parameter
/// </summary>
/// <param name="ReplaceString">string to replace find string with</param>
public void ReplaceAll()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.ReplaceAll));
}
#endregion
#endregion
#region Bulletts and Numbering
#region ClearBulletList
/// <summary>
/// Remove the bullets from the selected line(s)
/// </summary>
public void ClearBulletedList()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.ClearBulletedList));
}
/// <summary>
/// Removes the numbered list from the selected line(s)
/// </summary>
public void ClearNumberedList()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.ClearNumberedList));
}
#endregion
#region Insert Numbered and Bulleted List
/// <summary>
/// Inserts/Removes a numbered list for the current selection
/// </summary>
public void InsertNumberedList()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.InsertNumberedList));
}
/// <summary>
/// Inserts/Removes a bulleted list for the current selection
/// </summary>
public void InsertBulletedList()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.InsertBulletedList));
}
#endregion
#region Insert NumberList Decimal
/// <summary>
/// Inserts a numbered list using decimal numbers
/// </summary>
public void InsertNumberedListDecimal()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.InsertNumberedListDecimal));
}
#endregion
#region InsertNumberedListRomanUppercase
/// <summary>
/// Inserts a numbered list using upper case roman numeral numbers
/// </summary>
public void InsertNumberedListRomanUppercase()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.InsertNumberedListRomanUppercase));
}
#endregion
#region InsertNumberedListRomanLowercase
/// <summary>
/// Inserts a numbered list using lower case roman numeral numbers
/// </summary>
public void InsertNumberedListRomanLowercase()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.InsertNumberedListRomanLowercase));
}
#endregion
#region InsertNumberedListAlphaUppercase
/// <summary>
/// Inserts an numbered list using uppercase alpha numeric numbers
/// </summary>
public void InsertNumberedListAlphaUppercase()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.InsertNumberedListAlphaUppercase));
}
#endregion
#region InsertNumberedListAlphalowercase
/// <summary>
/// Inserts a numbered list using lowercase alpha numeric numbers
/// </summary>
public void InsertNumberedListAlphaLowercase()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.InsertNumberedListAlphaLowercase));
}
#endregion
#region InsertBulletListSolidCircle
/// <summary>
/// Inserts a bulleted list with solid circles
/// </summary>
public void InsertBulletedListSolidCircle()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.InsertBulletedList));
}
#endregion
#region InsertBulletListEmptyCircle
/// <summary>
/// Inserts a bulleted list with empty circles
/// </summary>
public void InsertBulletedListEmptyCircle()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.InsertBulletedListEmptyCircle));
}
#endregion
#region InsertBulletListSolidSquare
/// <summary>
/// Inserts a bulleted list with solid squares
/// </summary>
public void InsertBulletedListSolidSquare()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.InsertBulletedListSolidSquare));
}
#endregion
#endregion
#region Table Settings
#region Draw Table
/// <summary>
/// Activates/Deactivates draw pen which is used to create a table
/// </summary>
public void ToggleDrawTable()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.DrawTable));
}
#endregion
#region Erase Table
/// <summary>
/// Activates/Deactivates the eraser for erasing a table
/// </summary>
public void ToggleEraseTable()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.EraseTable));
}
#endregion
#region Insert and Delete Table
/// <summary>
/// Inserts a table into a supported control
/// </summary>
/// <param name="numRows">Number of rows the table should have</param>
/// <param name="numCols">Number of columns the table should have</param>
public void InsertTable(int rows, int columns)
{
if ((rows > 0) && (columns > 0))
{
object[] vaIn = new object[2];
vaIn[0] = rows;
vaIn[1] = columns;
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.InsertTable, vaIn));
}
else
{
throw new InvalidDataException("The number of rows and columns must be greater than zero.");
}
}
/// <summary>
/// Deletes the selected table
/// </summary>
public void DeleteSelectedTable()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.DeleteSelectedTable));
}
#endregion
#region Select a Table
/// <summary>
/// Selects all of the current table
/// </summary>
public void SelectTable()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SelectTable));
}
#endregion
#region Insert columns and rows
/// <summary>
/// Inserts a column to the left of the currently focused column
/// </summary>
public void InsertColumnLeft()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.InsertColumnLeft));
}
/// <summary>
/// Inserts a column to the right of the currently focused column
/// </summary>
public void InsertColumnRight()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.InsertColumnRight));
}
/// <summary>
/// Inserts a row above the currently focused row
/// </summary>
public void InsertRowAbove()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.InsertRowAbove));
}
/// <summary>
/// Inserts a row below the currently focused row
/// </summary>
public void InsertRowBelow()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.InsertRowBelow));
}
#endregion
#region Delete columns and rows
/// <summary>
/// Deletes the selected columns
/// </summary>
public void DeleteSelectedColumns()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.DeleteSelectedColumns));
}
/// <summary>
/// Deletes the selected rows
/// </summary>
public void DeleteSelectedRows()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.DeleteSelectedRows));
}
#endregion
#region Select columns and rows
/// <summary>
/// Selects all of the current column
/// </summary>
public void SelectColumn()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SelectColumns));
}
/// <summary>
/// Selects the column before the column with the current focus
/// </summary>
public void SelectPreviousColumn()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SelectPreviousColumn));
}
/// <summary>
/// Selects the column after the column with the current focus
/// </summary>
public void SelectNextColumn()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SelectNextColumn));
}
/// <summary>
/// Selects all of the current row
/// </summary>
public void SelectRow()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SelectRows));
}
/// <summary>
/// Selects the row before the row with the current focus
/// </summary>
public void SelectPreviousRow()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SelectPreviousRow));
}
/// <summary>
/// Selects the row after the row with the current focus
/// </summary>
public void SelectNextRow()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SelectNextRow));
}
#endregion
#region Cells
/// <summary>
/// Selects the entire current cell
/// </summary>
public void SelectCell()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SelectCell));
}
/// <summary>
/// Combines two or more cells of a table
/// </summary>
public void MergeCells()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.MergeCells));
}
/// <summary>
/// Splits Cells into different proportions
/// </summary>
/// <param name="numCols">Number of columns to split into</param>
/// <param name="numRows">Number of rows to split cells into</param>
/// <param name="merge">Flag indicating cells should be merged/not merged before splitting</param>
public void SplitCells(decimal columns, decimal rows, bool merge)
{
if ((rows > 0) && (columns > 0))
{
object[] vaIn = new object[3];
vaIn[0] = columns.ToString(CultureInfo.CurrentCulture);
vaIn[1] = rows.ToString(CultureInfo.CurrentCulture);
vaIn[2] = merge;
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SplitCells, vaIn));
}
else
{
throw new InvalidDataException("The number of rows and columns must be greater than zero");
}
}
#region Cell Alignment
/// <summary>
/// Sets the alignment of the selected cell to be at the top
/// </summary>
public void SetSelectedCellAlignmentTop()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetSelectedCellAlignmentTop));
}
/// <summary>
/// Sets the alignment of the selected cell to be in the middle
/// </summary>
public void SetSelectedCellAlignmentMiddle()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetSelectedCellAlignmentMiddle));
}
/// <summary>
/// Sets the alignment of the selected cell to be at the bottom
/// </summary>
public void SetSelectedCellAlignmentBottom()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetSelectedCellAlignmentBottom));
}
/// <summary>
/// Gets the vertical alignment of the selected cell
/// </summary>
/// <return type="string">vertical alignment value (top,middle,bottom)</return>
public string SelectedCellVerticalAlignment
{
get
{
return Convert.ToString(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetSelectedCellVerticalAlignment),typeof(string)),CultureInfo.CurrentCulture
);
}
}
#endregion
#region Table cell padding
/// <summary>
/// Sets the padding of selected cells
/// </summary>
/// <param name="padTop">padding to the top</param>
/// <param name="padRight">padding to the right</param>
/// <param name="padBottom">padding to the bottom</param>
/// <param name="padLeft">padding to the left</param>
public void SetSelectedCellPadding(string padTop, string padRight, string padBottom, string padLeft)
{
if (!String.IsNullOrEmpty(padTop) && !String.IsNullOrEmpty(padRight) && !String.IsNullOrEmpty(padBottom)
&& !String.IsNullOrEmpty(padLeft))
{
object[] vaIn = new object[4];
vaIn[0] = padTop;
vaIn[1] = padRight;
vaIn[2] = padBottom;
vaIn[3] = padLeft;
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetSelectedCellPadding, vaIn));
}
else
{
throw new InvalidDataException("One or more parameters is invalid");
}
}
/// <summary>
/// Gets the top padding of the selected cell
/// </summary>
/// <returns>The value for the top padding. Includes unit</returns>
public string SelectedCellTopPadding
{
get
{
return Convert.ToString(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetSelectedCellTopPadding),typeof(string)),CultureInfo.CurrentCulture
);
}
}
/// <summary>
/// Gets the right padding of the selected cell
/// </summary>
/// <returns>The value for the right padding. Includes unit</returns>
public string SelectedCellRightPadding
{
get
{
return Convert.ToString(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetSelectedCellRightPadding),typeof(string)),CultureInfo.CurrentCulture
);
}
}
/// <summary>
/// Gets the bottom padding of the selected cell
/// </summary>
/// <returns>The value for the bottom padding. Includes unit</returns>
public string SelectedCellBottomPadding
{
get
{
return Convert.ToString(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetSelectedCellBottomPadding),typeof(string)),CultureInfo.CurrentCulture
);
}
}
/// <summary>
/// Gets the left padding of the selected cell
/// </summary>
/// <returns>The value for the left padding. Includes unit</returns>
public string SelectedCellLeftPadding
{
get
{
return Convert.ToString(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetSelectedCellLeftPadding),typeof(string)),CultureInfo.CurrentCulture
);
}
}
#endregion
#endregion
#region Table Alignment
/// <summary>
/// Sets/Gets the alignment of the table
/// </summary>
/// <return>string (left, center, right)</return>
public string TableHorizontalAlignment
{
get
{
return Convert.ToString(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetTableHorizontalAlignment),typeof(string)),CultureInfo.CurrentCulture
);
}
set
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetTableHorizontalAlignment, value));
}
}
#endregion
#region Table Direction
/// <summary>
/// Sets/Gets the direction of the table
/// </summary>
/// <return type=string>value of direction ("LTR" (Left To Right) or "RTL" (Right To Left))</return>
public string TableDirection
{
get
{
return Convert.ToString(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetTableDirection),typeof(string)),CultureInfo.CurrentCulture
);
}
set
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetTableDirection, value));
}
}
#endregion
#region Row height and column width
/// <summary>
/// Sets/Gets the height of the selected row
/// </summary>
/// <returns>The height of the selected row with units</returns>
public string RowHeight
{
get
{
return Convert.ToString(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetSelectedRowHeight),typeof(string)),CultureInfo.CurrentCulture
);
}
set
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetSelectedRowHeight, value));
}
}
/// <summary>
/// Sets/Gets the width of the selected column
/// </summary>
/// <returns>The width of the selected column with units</returns>
public string ColumnWidth
{
get
{
return Convert.ToString(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetSelectedColumnWidth),typeof(string)),CultureInfo.CurrentCulture
);
}
set
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetSelectedColumnWidth, value));
}
}
#endregion
#region Row and column properties options
/// <summary>
/// Checks if there is a row below the currently selected row
/// </summary>
public bool IsNextRowExist
{
get
{
return IsCommandOn(FormControlCommandIds.CommandIds.SelectNextRow);
}
}
/// <summary>
/// Checks if there is a row above the currently selected row
/// </summary>
public bool IsPreviousRowExist
{
get
{
return IsCommandOn(FormControlCommandIds.CommandIds.SelectPreviousRow);
}
}
/// <summary>
/// Selects the next row in the table
/// </summary>
public void GotoNextRow()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SelectNextRow));
}
/// <summary>
/// Selects the previous row in the table
/// </summary>
public void GotoPreviousRow()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SelectPreviousRow));
}
/// <summary>
/// Checks if there is a column right of the currently selected column
/// </summary>
public bool IsNextColumnExist
{
get
{
return IsCommandOn(FormControlCommandIds.CommandIds.SelectNextColumn);
}
}
/// <summary>
/// Checks if there is a column left of the currently selected column
/// </summary>
public bool IsPreviousColumnExist
{
get
{
return IsCommandOn(FormControlCommandIds.CommandIds.SelectPreviousColumn);
}
}
/// <summary>
/// Selects the next column in the table
/// </summary>
public void GotoNextColumn()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SelectNextColumn));
}
/// <summary>
/// Selects the previous column in the table
/// </summary>
public void GotoPreviousColumn()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SelectPreviousColumn));
}
#endregion
#endregion
#region SpellChecker
/// <summary>
/// Finds and selects the next misspelled word
/// </summary>
/// <returns type="bool">true: if a misspelled word was found, false otherwise</returns>
public bool FindNextMisspelledWord()
{
return Convert.ToBoolean(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.FindNextMisspelledWord),typeof(bool)),CultureInfo.CurrentCulture
);
}
/// <summary>
/// Gets the number of suggested corrections
/// </summary>
/// <returns>The number of spelling suggestions</returns>
public int SpellingSuggestionsCount
{
get
{
return Convert.ToInt32(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetSpellingSuggestionsCount),typeof(int)),CultureInfo.CurrentCulture
);
}
}
/// <summary>
/// Gets the i-th suggestion
/// </summary>
/// <param name="index">the suggestion index</param>
/// <returns>the suggestion string</returns>
public string GetSpellingSuggestion(int index)
{
if (index >= 0 && index < SpellingSuggestionsCount)
{
return Convert.ToString(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetSpellingSuggestion, index), typeof(string)),CultureInfo.CurrentCulture
);
}
else
{
throw new InvalidDataException("Index is out of expected range");
}
}
/// <summary>
/// Gets the selected misspelled word
/// </summary>
/// <returns>The currently selected misspelled word</returns>
public string CurrentMisspelledWord
{
get
{
return Convert.ToString(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetCurrentMisspelledWord),typeof(string)),CultureInfo.CurrentCulture
);
}
}
/// <summary>
/// Ignores the selected misspelling
/// </summary>
/// <param name="misspelled">the misspelled word to ignore</param>
public void IgnoreMisspelledWord(string misspelled)
{
if (!String.IsNullOrEmpty(misspelled))
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.IgnoreMisspelledWord, misspelled));
}
else
{
throw new InvalidDataException("Misspelled word is either null or an empty string");
}
}
/// <summary>
/// Ignores all the occurences of the specified misspelled word
/// </summary>
/// <param name="misspelled">the word to ignore</param>
public void IgnoreAllOfMisspelledWord(string misspelled)
{
if (!String.IsNullOrEmpty(misspelled))
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.IgnoreAllOfMisspelledWord, misspelled));
}
else
{
throw new InvalidDataException("Misspelled word is either null or an empty string");
}
}
/// <summary>
/// Corrects the misspelled word
/// </summary>
/// <param name="misspelled">the misspelled word</param>
/// <param name="correct">correction of the misspelled word</param>
public void CorrectMisspelledWord(string misspelled, string correct)
{
if (!String.IsNullOrEmpty(misspelled) && !String.IsNullOrEmpty(correct))
{
object[] vaIn = { misspelled, correct };
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.CorrectMisspelledWord, vaIn));
}
else
{
throw new InvalidDataException("The misspelled word and the corrected word cannot be null or empty");
}
}
/// <summary>
/// Corrects all the occurences of this misspelled word
/// </summary>
/// <param name="misspelled">the word to correct</param>
/// <param name="correct">correction of the misspelled word</param>
public void CorrectAllOfMisspelledWord(string misspelled, string correct)
{
if (!String.IsNullOrEmpty(misspelled) && !String.IsNullOrEmpty(correct))
{
object[] vaIn = { misspelled, correct };
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.CorrectAllOfMisspelledWord, vaIn));
}
else
{
throw new InvalidDataException("The misspelled word and the corrected word cannot be null or empty");
}
}
/// <summary>
/// Adds the unrecognized\misspelled word to the custom dictionary
/// </summary>
/// <param name="misspelled">the new word to add to the dictionary</param>
public void AddWordToDictionary(string misspelled)
{
if (!String.IsNullOrEmpty(misspelled))
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.AddWordToDictionary, misspelled));
}
else
{
throw new InvalidDataException("The misspelled word is either null or an empty string");
}
}
/// <summary>
/// Deletes the selected misspelled word
/// </summary>
/// <param name="misspelled">the word to delete</param>
public void DeleteMisspelledWord(string misspelled)
{
if (!String.IsNullOrEmpty(misspelled))
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.DeleteMisspelledWord, misspelled));
}
else
{
throw new InvalidDataException("The misspelled word is either null or an empty string");
}
}
/// <summary>
/// Sets/Gets whether or not checking should be checked as users type
/// </summary>
/// <param name="checkAsYouType">Flag indicating whether to turn the option on or off</param>
public bool SpellingOptionCheckAsYouTypeOn
{
get
{
return IsCommandOn(FormControlCommandIds.CommandIds.SetSpellingOptionCheckAsYouType);
}
set
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetSpellingOptionCheckAsYouType, value));
}
}
#endregion
#region Picture Formatting
/// <summary>
/// Positions the picture such that it falls inline with the text
/// </summary>
public void SetPictureInlineWithText()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetPictureInlineWithText));
}
/// <summary>
/// Positions the picture such that it falls to the left of any text
/// </summary>
public void SetPictureToLeftOfText()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetPictureToLeftOfText));
}
/// <summary>
/// Positions the picture such that it falls to the right of any text
/// </summary>
public void SetPictureToRightOfText()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetPictureToRightOfText));
}
// <summary>
/// Sets/Gets the height of the selected picture
/// </summary>
/// <returns>Height of the selected picture</returns>
public string PictureHeight
{
get
{
return Convert.ToString(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetPictureHeight),typeof(string)),CultureInfo.CurrentCulture
);
}
set
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetPictureWidth, value));
}
}
/// <summary>
/// Sets/Gets the width of the selected picture
/// </summary>
/// <returns>Width of the selected picture</returns>
public string PictureWidth
{
get
{
return Convert.ToString(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetPictureWidth),typeof(string)),CultureInfo.CurrentCulture
);
}
set
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetPictureWidth, value));
}
}
/// <summary>
/// Sets/Gets the alternative text of the selected picture
/// </summary>
/// <returns>Alternative text</returns>
public string PictureAlternativeText
{
get
{
return Convert.ToString(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetPictureAlternativeText),typeof(string)),CultureInfo.CurrentCulture
);
}
set
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetPictureAlternativeText, value));
}
}
/// <summary>
/// Gets the alignment of the picture
/// </summary>
/// <returns>left,right or inline</returns>
public string PictureAlignment
{
get
{
return Convert.ToString(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetPictureTextWrapping),typeof(string)),CultureInfo.CurrentCulture
);
}
}
#endregion
#region Insertion
#region Symbol
/// <summary>
/// Shows the Insert a Symbol Dialog
/// </summary>
public void ShowInsertSymbolDialog()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.ShowInsertSymbolDialog));
}
#endregion
#region Image
/// <summary>
/// Inserts at image from the specified location
/// </summary>
/// <param name="path">path to the image</param>
public void InsertImage(string filePath)
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.InsertImage, filePath));
}
/// <summary>
/// Inserts a Picture from a File dialog
/// </summary>
public void InsertPictureFromFile()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.InsertPictureFromFile));
}
#endregion
#region Horizontal Line
/// <summary>
/// Inserts a horizontal line into a rich text control
/// </summary>
public void InsertHorizontalLine()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.InsertHorizontalLine));
}
#endregion
#region Hyperlink
/// <summary>
/// Checks if a hyperlink is currently selected
/// </summary>
public bool IsHyperlinkSelected
{
get
{
return IsCommandOn(FormControlCommandIds.CommandIds.SelectHyperlink);
}
}
/// <summary>
/// Gets the URL affiliated with the hyperlink
/// </summary>
/// <returns></returns>
public string HyperlinkAddress
{
get
{
return Convert.ToString(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetHyperlinkAddress),typeof(string)),CultureInfo.CurrentCulture
);
}
}
/// <summary>
/// Gets the text affiliated with the Hyperlink
/// </summary>
/// <returns></returns>
public string HyperlinkDisplayText
{
get
{
return Convert.ToString(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetHyperlinkDisplayText),typeof(string)),CultureInfo.CurrentCulture
);
}
}
/// <summary>
/// Selects all of the current hyperlink
/// </summary>
public void SelectHyperlink()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SelectHyperlink));
}
/// <summary>
/// Inserts a hyperlink into a control
/// </summary>
/// <param name="link">Where the hyperlink leads to</param>
/// <param name="text">Text to display for the hyperlink</param>
public void InsertHyperlink(string link, string text)
{
if (!String.IsNullOrEmpty(link) && !String.IsNullOrEmpty(text))
{
object[] vaIn = { link, text };
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.InsertHyperlink, vaIn));
}
else
{
throw new InvalidDataException("Both the link and the text information cannot be null or blank");
}
}
/// <summary>
/// Removes a hyperlink
/// </summary>
public void RemoveHyperlink()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.RemoveHyperlink));
}
#endregion
#endregion
#region Errors
/// <summary>
/// Selects the first error on the current view
/// </summary>
public void GoToFirstErrorOnView()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GotoFirstErrorOnView));
}
/// <summary>
/// Selects the next error on the current view
/// </summary>
public void GoToNextErrorOnView()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GotoNextErrorOnView));
}
/// <summary>
/// Shows the message associated with the selected error
/// </summary>
public void ShowCurrentErrorMessage()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.ShowCurrentErrorMessage));
}
#endregion
#region Work Offline
/// <summary>
/// Toggles WorkOffline On/Off
/// </summary>
public void WorkOffline()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.WorkOffline));
}
#endregion
#region Form Direction
/// <summary>
/// Checks if the current direction of the form is left to right
/// </summary>
public bool IsFormDirectionLeftToRight
{
get
{
return Convert.ToBoolean(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.IsFormDirectionLeftToRight),typeof(uint)),CultureInfo.CurrentCulture
);
}
}
/// <summary>
/// Checks if the current direction of the form is right to left
/// </summary>
public bool IsFormDirectionRightToLeft
{
get
{
return Convert.ToBoolean(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.IsFormDirectionRightToLeft),typeof(uint)),CultureInfo.CurrentCulture
);
}
}
#endregion
#region Text DirectionC# Definition:
/// Sets the direction of the text to be the default direction
/// </summary>
public void SetTextDirectionDefault()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetTextDirectionDefault));
}
/// <summary>
/// Sets the direction of the text to be left to right
/// </summary>
public void SetTextDirectionLeftToRight()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetTextDirectionLeftToRight));
}
/// <summary>
/// Sets the direction of the text to be right to left
/// </summary>
public void SetTextDirectionRightToLeft()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetTextDirectionRightToLeft));
}
#endregion
#region Submit
/// <summary>
/// Performs the submit action of the form
/// </summary>
public void Submit()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.Submit));
}
/// <summary>
/// Gets the text on the InfoPath Submit Button
/// </summary>
public string SubmitButtonCaption
{
get
{
return Convert.ToString(
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.GetSubmitButtonCaption),typeof(string)),CultureInfo.CurrentCulture
);
}
}
#endregion
#region Views
/// <summary>
/// Switches a view to the viewName
/// </summary>
/// <param name="viewName">name of the view</param>
public void SwitchView(string viewName)
{
if (string.IsNullOrEmpty(viewName))
{
throw new InvalidDataException("The view name entered is either null or empty.\nPlease use a valid view.");
}
if (IsFormLoaded)
{
try
{
InfoPathControl.XmlForm.ViewInfos.SwitchView(viewName);
}
catch (Exception ex)
{
throw new HostedException("An error occurred while attempting to switch view",ex);
}
}
}
/// <summary>
/// Gets an array of Views within the current form template
/// Will not return the hidded views
/// </summary>
/// <returns>String array of View names</returns>
public string[] GetViews()
{
string[] formTemplateViews = null;
if (IsFormLoaded)
{
try
{
// Check the view count, only proceed if there are views
if (InfoPathControl.XmlForm.ViewInfos.Count > 0)
{
// instantiate the array to hold the views to return
formTemplateViews = new string[InfoPathControl.XmlForm.ViewInfos.Count];
// Cycle through the views and populate the array
for (int viewCounter = 0; viewCounter < InfoPathControl.XmlForm.ViewInfos.Count; viewCounter++)
{
// If the HideName property is true, then we should NOT add this to the view collection
// this would indicate that the solution designer did not intend for this view to be
// available in the View menu.
if (!((ViewInfo)InfoPathControl.XmlForm.ViewInfos[viewCounter]).HideName)
{
string viewName = string.Empty;
viewName = InfoPathControl.XmlForm.ViewInfos[viewCounter].Name;
// Add the view name to the array
formTemplateViews[viewCounter] = viewName;
}
}
}
}
catch (Exception ex)
{
throw new HostedException("An error occurred while attempting to get the list of views", ex);
}
}
return formTemplateViews;
}
#endregion
#region Dialogs
#region Borders and Shading
/// <summary>
/// Shows the borders and shadings dialog
/// </summary>
public void ShowBordersShadingDialog()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.ShowBordersShadingDialog));
}
#endregion
#region Digital Signatures
/// <summary>
/// Shows the Digital Signatures Dialog
/// </summary>
public void ShowDigitalSignaturesDialog()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.ShowDigitalSignaturesDialog));
}
#endregion
#region SetLanguage
/// <summary>
/// Sets the language the editor uses using the set language dialog
/// </summary>
public void SetLanguage()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.ShowSetLanguageDialog));
}
#endregion
#region Merge Forms
/// <summary>
/// Opens the Merge Forms dialog
/// </summary>
public void MergeForms()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.ShowMergeFormDialog));
}
#endregion
#region Import Form Data
/// <summary>
/// Opens the Import form data dialog
/// </summary>
public void ImportFormData()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.ShowImportFormDataDialog));
}
#endregion
#region Export
/// <summary>
/// Shows the export to web dialog
/// </summary>
public void ExportToWeb()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.ShowExportToWebDialog));
}
/// <summary>
/// Shows the export to PDF or XPS dialog
/// </summary>
public void ExportToPDFXPS()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.ShowExportToPDFXPSDialog));
}
/// <summary>
/// Shows the export to excel dialog
/// </summary>
public void ExportToExcel()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.ShowExportToExcelDialog));
}
#endregion
#endregion
#region Asian Text Settings
/// <summary>
/// Sets whether spacing between asian text and numbers is on or off
/// </summary>
public void SetAutoSpaceBetweenAsianTextAndNumbers()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetAutoSpaceBetweenAsianTextAndNumbers));
}
/// <summary>
/// Set whether spacing between asian text and latin text is on or off
/// </summary>
public void SetAutoSpaceBetweenAsianAndLatinText()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.SetAutoSpaceBetweenAsianAndLatinText));
}
/// <summary>
/// Turns of all spacing adjustments for asian text
/// </summary>
public void ClearAutoSpace()
{
ChkResult(ExecuteCommand(FormControlCommandIds.CommandIds.ClearAutoSpace));
}
#endregion
#region Is Form Loaded
/// <summary>
/// Checks whether or not a document is loaded
/// </summary>
/// <returns>true if a document is loaded, otherwise false</returns>
public bool IsFormLoaded
{
get
{
if (InfoPathControl.XmlForm == null)
{
return false;
}
else
{
return true;
}
}
}
#endregion
}Última actualización