C#
The C# programming language can be used to access the Application API functionality. You could use Visual Studio 2012/2013/2015/2017/2019/2022 to create the C# code, saving it in a Visual Studio project. Create the project as follows:
1.In Microsoft Visual Studio, add a new project using File | New | Project.
2.Add a reference to the StyleVision Type Library by clicking Project | Add Reference. The Add Reference dialog appears. Browse for the StyleVision Type Library component, which is located in the StyleVision application folder, and add it.
3.Enter the code you want.
4.Compile the code and run it.
Example C# project
Your StyleVision package contains an example C# project, which is located in the API\C# subfolder of the Examples folder :
Windows 7, Windows 8, Windows 10, Windows 11 | C:\Usuarios\<usuario>\Documentos\ |
You can compile and run the project from within Visual Studio 2012/2013/2015/2017/2019/2022. The code listing below shows how basic application functionality can be used. This code is similar to the example C# project in the API Examples folder of your application package, but might differ slightly.
Platform configuration
If you have a 64-bit operating system and are using a 32-bit installation of StyleVision, you must add the x86 platform in the solution's Configuration Manager and build the sample using this configuration. A new x86 platform (for the active solution in Visual Studio) can be created in the New Solution Platform dialog (Build | Configuration Manager | Active solution platform | <New…>).
What the code listing below does
The example code listing below creates a simple user interface (screenshot below) with buttons that invoke basic StyleVision operations:
•Start StyleVision: Starts StyleVision, which is registered as an automation server, or activates the application if it is already running.
•Open OrgChart.pxf: Locates one of the example documents installed with StyleVision and opens it. If this document is already open it becomes the active document.
•Open MultiFileOutput.sps: Opens another example document.
•Shut down StyleVision: Stops StyleVision.
You can modify the code (of the code listing below or of the example C# project in the API Examples folder) in any way you like and run it.
Compiling and running the example
In the API Examples folder, double-click the file AutomateStyleVision_VS2008.sln or the file AutomateStyleVision_VS2010.sln (to open in Visual Studio 2012/2013/2015/2017/2019/2022). Alternatively the file can be opened from within Visual Studio (with File | Open | Project/Solution). To compile and run the example, select Debug | Start Debugging or Debug | Start Without Debugging.
Code listing of the example
Given below is the C# code listing of the basic functionality of the form (Form1.cs) created in the AutomateStyleVision example. Note that the code listed below might differ slightly from the code in the API Examples form.The listing below is commented for ease of understanding. Parts of the code are also presented separately in the sub-sections of this section, according to the Application API functionality they access.
The code essentially consists of a series of handlers for the buttons in the user interface shown in the screenshot above.
namespace WindowsFormsApplication2
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
// An instance of StyleVision is accessed via its automation interface.
StyleVisionLib.Application StyleVision;
// Location of examples installed with StyleVision
String strExamplesFolder;
private void Form1_Load(object sender, EventArgs e)
{
// Locate examples installed with StyleVision.
// REMARK: You might need to adapt this if you have a different major version of the product.
strExamplesFolder = Environment.GetEnvironmentVariable("USERPROFILE") + "\\My Documents\\Altova\\StyleVision2012\\StyleVisionExamples\\";
}
// Handler for the "Start StyleVision" button
private void StartStyleVision_Click(object sender, EventArgs e)
{
if (StyleVision == null)
{
Cursor.Current = Cursors.WaitCursor;
// If there is no StyleVision instance, create one and make it visible.
StyleVision = new StyleVisionLib.Application();
StyleVision.Visible = true;
Cursor.Current = Cursors.Default;
}
else
{
// If a StyleVision instance is already running, make sure it's visible.
if (!StyleVision.Visible)
StyleVision.Visible = true;
}
}
// Handler for the "Open OrgChart.pxf" button
private void openOrgChart_Click(object sender, EventArgs e)
{
// Make sure there's a running StyleVision instance, and that it's visible
StartStyleVision_Click(null, null);
// Open a sample files installed with the product.
StyleVision.Documents.OpenDocument(strExamplesFolder + "OrgChart.pxf");
updateListBox();
}
// Handler for the "Open MultiFileOutput.sps" button
private void openMultiFileOutput_Click(object sender, EventArgs e)
{
// Make sure there's a running StyleVision instance, and that it's visible
StartStyleVision_Click(null, null);
// Open one of the sample files installed with the product.
StyleVision.Documents.OpenDocument(strExamplesFolder + "MultiFileOutput.sps");
updateListBox();
}
// Handler for the "Shutdown StyleVision" button
// Shut down the application instance by explicitly releasing the COM object.
private void shutdownStyleVision_Click(object sender, EventArgs e)
{
if (StyleVision != null)
{
// Allow shut-down of StyleVision by releasing UI
StyleVision.Visible = false;
// Explicitly release the COM object
try
{
int i = System.Runtime.InteropServices.Marshal.ReleaseComObject(StyleVision);
while (System.Runtime.InteropServices.Marshal.ReleaseComObject(StyleVision) > 0) ;
}
finally
{
// Disallow subsequent access to this object.
StyleVision = null;
}
}
}
delegate void addListBoxItem_delegate(string sText);
// Called from the UI thread
private void addListBoxItem(string sText)
{
listBoxMessages.Items.Add(sText);
}
// Wrapper method to call UI control methods from a worker thread
void syncWithUIthread(Control ctrl, addListBoxItem_delegate methodToInvoke, String sText)
{
// Control.Invoke: Executes on the UI thread, but calling thread waits for completion before continuing.
// Control.BeginInvoke: Executes on the UI thread, and calling thread doesn't wait for completion.
if (ctrl.InvokeRequired)
ctrl.BeginInvoke(methodToInvoke, new Object[] { sText });
}
// Event handler for OnDocumentClosed event
private void handleOnDocumentClosed(StyleVisionLib.Document i_ipDocument)
{
String sText = "";
if (i_ipDocument.Name.Length > 0)
sText = "Document " + i_ipDocument.Name + " was closed!";
// Synchronize the calling thread with the UI thread because
// COM events are triggered from a working thread
addListBoxItem_delegate methodToInvoke = new addListBoxItem_delegate(addListBoxItem);
// Call syncWithUIthread with the following arguments:
// 1 - listBoxMessages - list box control to display messages from COM events
// 2 - methodToInvoke - a C# delegate which points to the method which will be called from the UI thread
// 3 - sText - the text to be displayed in the list box
syncWithUIthread(listBoxMessages, methodToInvoke, sText);
}
private void updateListBox()
{
// Iterate through all open documents
listBoxMessages.Items.Clear();
for (int i = 1; i <= StyleVision.Documents.Count; i++)
{
StyleVisionLib.Document doc = StyleVision.Documents[i];
if (doc != null)
{
if (checkBoxEventOnOff.Checked)
doc.OnDocumentClosed += new StyleVisionLib._IDocumentEvents_OnDocumentClosedEventHandler(handleOnDocumentClosed);
else
doc.OnDocumentClosed -= new StyleVisionLib._IDocumentEvents_OnDocumentClosedEventHandler(handleOnDocumentClosed);
listBoxMessages.Items.Add(doc.Name);
StyleVisionLib.SchemaSources sources = doc.SchemaSources;
for (int j = 1; j <= sources.Count; j++)
{
StyleVisionLib.SchemaSource source = sources[j];
if (source != null)
{
listBoxMessages.Items.Add("\tSchema file name : " + source.SchemaFileName + "\n");
listBoxMessages.Items.Add("\tWorking XML file name : " + source.WorkingXMLFileName + "\n");
listBoxMessages.Items.Add("\tIs main schema source : " + source.IsMainSchemaSource + "\tType name : " + source.TypeName + "\n");
}
}
}
}
}
}
}