Integration notes for version 3.2

Introduction……………………………………………………………………………………………………………………
Command line version……………………………………………………………………………………………………
Creating Alto Studio plug-ins………………………………………………………………………………………….
Importer plug-ins……………………………………………………………………………………………………………
Exporter plug-ins……………………………………………………………………………………………………………
Tool plug-ins…………………………………………………………………………………………………………………..
Exposing plug-in parameters………………………………………………………………………………………….
Testing a plug-in…………………………………………………………………………………………………………….

#205 e-Kigyokan 2-6-2 Yoneyama
Chuo-ku, 950-0916 Niigata City, Japan
www.tsugi-studio.com

2
3
4
7
10
11
16
20

2

Introduction
Alto Studio can import dialogue from various sources: from game middleware projects(Audiokinetic’s Wwise, Firelight Technologies’ FMOD, CRI Middleware’s ADX2 or Tazman
Audio’s Fabric) to Excel sheets, or directly from folders of audio files with various hierarchies
and naming conventions.
However, it is sometimes necessary to interface with proprietary tools or dialogue
databases. For this reason, Alto Studio also includes a plug-in system. This plug-in system
makes it possible to write “Importer” plug-ins that allow the import of dialogue files,“Exporter” plug-ins that can save the data in a proprietary format and “Tool” plug-ins thatcan be used to extend the feature set of Alto Studio. Furthermore, the command line
version of Alto Studio can be run from a script while using the same .alto project files thanthe GUI version.

This documentation focuses on these ways to integrate Alto with your current build pipelineor tool chain.
Please note that the plug-in API and the options of the command line version are constantly
extended based on the requests from our clients. Therefore, don’t hesitate to contact us if
you need an extra feature.

#205 e-Kigyokan 2-6-2 Yoneyama
Chuo-ku, 950-0916 Niigata City, Japan
www.tsugi-studio.com

3

Command line version
You can integrate Alto Studio to your build pipeline by using the command line version,
which is located in the same folder than the tool. The name of the executable is AltoCLI.exe.
The command line version reads the exact same project files than the GUI version. This
makes it easy to configure a project and keeps the calling syntax simple:

As can be seen above, only two parameters are required. The first one is the Alto Studio
project (.alto) you saved with the tool. The second one is the name of the report file thatwill be generated. Depending on the extension, AltoCLI will generate an XML file, an Excel
workbook, a PDF document or HTML pages. The third - optional - parameter is a flag thatindicates that the errors found should be corrected (accordingly to the correction settings
saved in the Alto Studio project).
Please note that for the moment it is only possible to run one Alto Studio process at any
given time. The figure below describes an example of integration.

#205 e-Kigyokan 2-6-2 Yoneyama
Chuo-ku, 950-0916 Niigata City, Japan
www.tsugi-studio.com

4Creating Alto Studio plug-ins
This section describes the steps required to create an Alto Studio plug-in. This is very easy
and can usually be done in a couple of hours.

1 – Create a new Visual C# project of type “Class Library”
Please note that Alto being a C# application, plug-ins must be written in C# or any othermanaged language.

2 – Add a reference to AltoPlugIns
In the Solution Explorer, click on your project and select “Add Reference…” from the popup
menu. Select the “Browse” tab and browse to the location of the AltoPlugIns.dll file (i.e. theroot of the Alto Studio installation folder). This assembly contains the interfaces necessary
to write a plug-in for Alto. You can now add the required namespace:using AltoPlugIns;

3 – Derive your plug-in from the right interface
Alto Studio supports three types of plug-ins, which are all derived from the base IPlugIninterface. There are import plug-ins (IImporterPlugIn) that let you get dialogue files into
Alto Studio, export plug-ins (IExporterPlugIn) to save the data in the format of your choice
and tool plug-ins (IToolPlugIn) to add features to the software.
To create an SQL importer plug-in for example, derive your class from the IImporterPlugIninterface.

#205 e-Kigyokan 2-6-2 Yoneyama
Chuo-ku, 950-0916 Niigata City, Japan
www.tsugi-studio.com

5

4 – Add the plug-in attribute to your class[AltoPluginAttribute(PlugInType.Importer)]public class SQLPlugIn : ImporterPlugIn{}

This is how the Alto Studio plug-in manager detects that a DLL is an Alto-compatible plug-in.
The attribute takes only one parameter, which is the type of the plug-in:
PlugInType.Importer, PlugInType.Exporter or PlugInType.Tool.

5 – Implement the IPlugIn interface
All plug-in interfaces derive from the base IPlugIn interface that any Alto-compatible plugin must implement.
public interface IPlugIn{
string Name { get; }string Description { get; }string Author { get; }Guid GUID { get; }Version Version { get; }PlugInType Type { get; }Image Logo { get; }bool HasEditor { get; }bool EditParameters();bool ValidateParameters( out string errorMessage );}Name, Description, Author
These properties are strings that help you describe your plug-in. They will be displayed by
the user interface of Alto Studio. The name does not have to be the same name than theplug-in assembly itself.
GUID
A unique identifier must be assigned the plug-in. You can create a new GUID by selecting theTools->Create GUID menu command in Visual Studio. Do not copy an existing GUID! In thecase of importer plug-ins, the GUID and the version of the plug-in will be saved in the Alto
Studio project if the dialogue lines were imported through that plug-in.

#205 e-Kigyokan 2-6-2 Yoneyama
Chuo-ku, 950-0916 Niigata City, Japan
www.tsugi-studio.com

6

VersionThis property will allow you to track several versions of a plug-in, which is especially usefulwhen loading or saving data. The version of a plug-in is always displayed by Alto Studiowhen using it.
Type
The type of the plug-in is again PlugInType.Importer, PlugInType.Exporter or
PlugInType.Tool.
Logo
The plug-in logo: if null, the Alto Studio’s default plug-in logo will be displayed by the GUI.
HasEditor
The HasEditor property should be set to true if you are planning on providing your own GUI
to edit the parameters of the plug-in. In this case, the EditParameters() method will becalled. If HasEditor is set to false, a default editor will be generated by Alto Studio based on
the parameter definitions (i.e. using reflection).
EditParameters
Typically, this method should open a form and allow the editing of the parameters. It should
return true if the parameters have been changed and false otherwise.
ValidateParameters
The ValidateParameters method is called when the OK button of the plug-in configuration
form is pressed, before the form is closed. It is the responsibility of the plug-in to make surethat the parameter values are valid. If a parameter value is invalid, the method should
return false and send a description of the problem in errorMessage. In that case, themessage will be displayed by Alto Studio and the form will not be closed.

#205 e-Kigyokan 2-6-2 Yoneyama
Chuo-ku, 950-0916 Niigata City, Japan
www.tsugi-studio.com

7

Importer plug-ins
This section describes the methods that must be implemented to create an importer plug-in
and comply with the IImporterPlugIn interface. The CSV Importer is an example of a very
simple importer plug-in. Examining its source code is a great starting point to learn how tobuild importer plug-ins.

The IImporterPlugIn interface is defined like this:public interface IImporterPlugIn : IPlugIn{
string ProjectFilterString { get; }bool IsValidProjectFile(string projectPath);bool Initialize(string projectPath);
void Terminate();List<string> GetLanguages();string GetReferenceLanguage();
List<string> GetReferencePaths();
string GetLocalizedPath(string refFilePath, string language);
void WriteSpecific(ref XmlTextWriter writer);void ReadSpecific(ref XmlNode parentNode);}#205 e-Kigyokan 2-6-2 Yoneyama
Chuo-ku, 950-0916 Niigata City, Japan
www.tsugi-studio.com

8

ProjectFilterString
This property must return filter string to use in an open file dialog in order to load projects
for the game audio middleware / tool / database we target.
IsValidProjectFile
This method is responsible for checking the validity of the file passed. It should return true isthe file passed is in the expected format, and false otherwise.
Initialize
This method is only called once, when the plug-in is loaded (when Alto Studio is started).
Any consequent initialization or resources allocation should be done here.
TerminateThis method is only called once, when the plug-in is released (when Alto Studio is closed).
Any resources used by the plug-in should be freed here.
GetLanguages
This method must return the list of all the available languages in the project (including thereference language). There are no rules about the names of the languages, however theymust be unique.
GetReferenceLanguage
This method must return the reference language. This is the language against which allcomparisons will be done. The reference language must be part of the languages retuned by
GetLanguages.
GetReferencePaths
This method must return the list of all the reference files in the project (i.e. all the files
which are in the reference language).
GetLocalizedPath
This method must return the path of a localized file based on the path of the reference fileand the name of a localization language. Unlike the other methods, GetLocalizedPath canbe called a lot. During analysis, it is called for each file of the reference language times thenumber of localized languages which are being analysed. It is also called by various Alto
Studio tools or GUI elements. If your projects handle large numbers of files, it isrecommended to ensure that this method is optimized.

#205 e-Kigyokan 2-6-2 Yoneyama
Chuo-ku, 950-0916 Niigata City, Japan
www.tsugi-studio.com

9

WriteSpecific, ReadSpecificEach importer plug-in has a few built-in controls by default: the first one is to browse to theproject, the second one is the list of languages available in the project and the last one is acombo box to select the reference language. For example, the CSV Importer plug-in
depicted above does not have any other parameters so that is all that is displayed and saved.
However, if more parameters are required, then Alto Studio needs to be able to save themin the project file (.alto) and read them again. This is achieved by using the WriteSpecificand ReadSpecific methods. These methods are called when an Alto Studio project is saved
and loaded respectively.
Alto Studio saves its project files in XML format therefore the WriteSpecific method is
passed a reference to a XmlTextWriter object and the ReadSpecific method is passed areference to the root node (of type XmlNode). A very simple example of implementation
would look like this:void WriteSpecific(ref XmlTextWriter writer){writer.WriteStartElement("MyPlugInSpecific");
writer.WriteStartElement("MaxNumberOfFiles");
writer.WriteAttributeString("value", m_maxNumberOfFiles.ToString());
writer.WriteEndElement();
writer.WriteEndElement();}
void ReadSpecific(ref XmlNode rootNode){
XmlNode myPlugInNode = rootNode.SelectSingleNode(".//MyPlugInSpecific");
XmlNode infoNode = myPlugInNode.SelectSingleNode(".//MaxNumberOfFiles");m_maxNumberOfFiles = Convert.ToUInt32(infoNode.Attributes["value"].Value);}#205 e-Kigyokan 2-6-2 Yoneyama
Chuo-ku, 950-0916 Niigata City, Japan
www.tsugi-studio.com

10

Exporter plug-ins
This section describes the methods that must be implemented to create an exporter plug-in
and comply with the IExporterPlugIn interface. The XML Exporter is an example of a very
simple exporter plug-in. Examining its source code is a great starting point to learn how tobuild exporter plug-ins.
public interface IExporterPlugIn : IPlugIn{
string ProjectFilterString { get; }bool IsValidProjectFile(string projectPath);bool Initialize(string projectPath);
void Terminate();bool Export(string refLanguage,
List<string> locLanguages,Dictionary<string,List<string>> files);void WriteSpecific(ref XmlTextWriter writer);void ReadSpecific(ref XmlNode parentNode);}

As you can see, the IExporterPlugIn interface is very similar to the IImporterPlugIninterface.
It also contains a ProjectFilterString property as well as a IsValidProjectFile method.
There is also an Initialize and a Terminate method, which can be used to create a file andclose it respectively.
The difference comes from the Export method. This method is used by Alto Studio to pass
all the dialogue files information to the exporter plug-in, so that it can write it or send it asneeded.
The Export method has 3 parameters:-

The first one is a string containing the name of the reference language.
The second parameter is a list of strings, each of them containing the name of one of
the localized languages.
Finally, the third parameter is a dictionary whose key is the path of an audio file in
the reference language, and whose value is a list of string containing the paths of thecorresponding audio files in the different localized languages.
Note that the paths of the localized files follow the order of the languages in the listof the second parameter.

#205 e-Kigyokan 2-6-2 Yoneyama
Chuo-ku, 950-0916 Niigata City, Japan
www.tsugi-studio.com

11

Tool plug-ins
This section describes the methods that must be implemented to create a tool plug-in andcomply with the IToolPlugIn interface. The Silence Trimmer is an example of tool plug-in. It
removes silence at the beginning and at the end of dialogue files. Examining its source code
is a great starting point to learn how to build tool plug-ins. In addition, the Silence Trimmer
plug-in takes advantage of the automatic GUI generation feature of Alto Studio by using C#
attributes for its parameters (see next section).

The IToolPlugIn interface is defined like this:public interface IToolPlugIn : IPlugIn{bool RequiresProject { get; }bool Initialize();
void Terminate();bool Execute(AltoServerCommands commands, out bool bDialogueModified);}

RequiresProjectThis property describes if the tool plug-in requires an Alto project to be loaded to work. For
example, The Silence Trimmer plug-in allows you to specify an input folder from which thefiles will be processed. It is therefore independent from the Alto project. If you start Altoand no project is loaded, you will still be able to access the Silence Trimmer tool. However, if
this flag is set to true for a plug-in, the corresponding entry in the tool menu will be greyed
until a project is loaded.

#205 e-Kigyokan 2-6-2 Yoneyama
Chuo-ku, 950-0916 Niigata City, Japan
www.tsugi-studio.com

12

Initialize
This method is only called once, when the plug-in is loaded (when Alto Studio is started).
Any consequential initialization or resources allocation should be done here.
TerminateThis method is only called once, when the plug-in is released (when Alto Studio is closed).
Any resources used by the plug-in should be freed here.
ExecuteThis method does the actual work when the OK button is pressed in the tool’s window. It
receives a set of delegate functions (see the description of AltoServerCommands below) thatallow the plug-in to use Alto Studio internal functions and to access the current project’sdata. The method must return true if the processing was successfully completed or false
otherwise. In addition, bDialogueModified must be set to true by the plug-in if it changes
the data of the dialogue files in the project and therefore the analysis must be redone. If it is
set to true, Alto Studio will display a message to warn the user.
The AltoServerCommands class provides methods to get information about the current
project and to trigger functions in Alto Studio. In future versions, we may also give access tothe current report and analysis settings. Please let us know what your company needs andwe will do our best to add it.
public class AltoServerCommands{
public StartPlayback StartPlayback;public StopPlayback StopPlayback;public GetSampleData GetSampleData;public UpdateSampleData UpdateSampleData;public WriteSampleData WriteSampleData;public GetReferenceLanguage GetReferenceLanguage;
public GetLanguages GetLanguages;
public GetReferenceFiles GetReferenceFiles;
public GetLocalizedFile GetLocalizedFile;public CalculateLKFS CalculateLKFS;
public CalculateLRA CalculateLRA
public CalculatedBTP CalculatedBTP;
public CalculateRMS CalculateRMS;
public GetSpectrum GetSpectrum;
public GetSpectralBands GetSpectralBands;
public GetPitchEnvelope GetPitchEnvelope;
public GetAmplitudeEnvelope GetAmplitudeEnvelope;
public CorrectLKFS CorrectLKFS;}#205 e-Kigyokan 2-6-2 Yoneyama
Chuo-ku, 950-0916 Niigata City, Japan
www.tsugi-studio.com

13

The definitions of these delegates are as follows:
delegate void PlaybackFinished();delegate bool StartPlayback(string path,PlaybackFinished callback);
delegate void StopPlayback();
delegate float[] GetSampleData(string path,out UInt16 bitDepth, out float
sampleRate,out UInt16 channels);delegate bool UpdateSampleData(string path,float[] data, UInt16 bitDepth, float
sampleRate, UInt16 channels);delegate bool WriteSampleData(string path, float[] data, UInt16 bitDepth, float
sampleRate, UInt16 channels);delegate string GetReferenceLanguage();delegate List<string> GetLanguages();delegate List<string> GetReferenceFiles();delegate string GetLocalizedFile(string referencePath, string language);
public delegate float CalculateLKFS(float[] data, float sampleRate, uint channels,
ChannelMapping channelMapping, out float[] momentaryLoudness);public delegate float CalculateLRA(float[] data, float sampleRate, uint channels,
ChannelMapping channelMapping, out float[] shortTermLoudness);public delegate float CalculatedBTP(float[] data, float sampleRate, uint channels,
ChannelMapping channelMapping);
public delegate float CalculateRMS(float[] data, uint channels, ChannelMapping
channelMapping);
public delegate float[] GetSpectrum(float[] data);
public delegate float[] GetSpectralBands(float[] data,float sampleRate, out float[]
centerFreq,out float[] bandwidth);
public delegate float[] GetPitchEnvelope(float[] data,float sampleRate, float
blockDuration, float minPitch, float maxPitch, float noiseThreshold);
public delegate float[] GetAmplitudeEnvelope(float[] data,float sampleRate);public delegate void CorrectLKFS(ref float[] data,float samplerate,uint channels,float
targetLKFS, out bool clipping);

Playback commands
StartPlayback
This command uses Alto’s audio engine to start the playback of a file. The plug-in canreceive a notification when the playback is finished if a callback function of type
PlaybackFinished was passed as an argument.
StopPlayback
This command stops the playback of a file started with StartPlayback.

#205 e-Kigyokan 2-6-2 Yoneyama
Chuo-ku, 950-0916 Niigata City, Japan
www.tsugi-studio.com

14

Audio files commands
GetSampleData
This command gets the sample data of an audio file (as well as its number of channels andits sample rate).
UpdateSampleData
This command updates the sample data of an audio file (as well as number of channels andsample rate).
WriteSampleData
This command writes a new audio file given its sample data, bit depth, number of channels
and sample rate.

Languages and file paths commands
GetReferenceLanguage
This command gets the name of the reference language of the project.
GetLanguages
This command gets the names of all the languages in the project (including the reference
language).
GetReferenceFiles
This command gets all the paths of the reference files in the project.
GetLocalizedFile
This command gets the path of a localized file given the path of a reference file and alanguage.

Analysis and correction commands
Some of these commands require information about the channels mapping, which is passed
as a value from the enum below:
public enum ChannelMapping{
DTS,// L R Ls Rs C LFE
ITU,// L R C LFE LS Rs
Film,// L C R Ls Rs LFE}#205 e-Kigyokan 2-6-2 Yoneyama
Chuo-ku, 950-0916 Niigata City, Japan
www.tsugi-studio.com

15

CalculateLKFSThis command calculates the integrated - or program - loudness (LKFS) following the EBU R128 specifications. It also returns the momentary loudness. If the file is shorter than 400 ms
it is extended to 400 ms and the original signal is looped. This ensures that we can calculate
the loudness even for short signals while following the specifications.
CalculateLRAThis command calculates the loudness range (LRA) following the EBU R-128 specifications. It
also returns the short-term loudness. If the file is shorter than 3 seconds it is extended to 3
seconds and the original signal is looped. This ensures that we can calculate the loudness
range even for short signals while following the specifications.
CalculatedBTP
This command calculates the true peak value (dBTP) following the EBU R-128 specifications.
CalculateRMS
This command calculates the Root Mean Square (RMS) over the whole signal.
GetSpectrum
This command calculates the spectrum of a mono signal and returns the magnitudes. It
essentially performs a Fast Fourier Transform (FFT). Therefore, an error will occur if the sizeof the signal passed is not a power of two (you can pass the signal with zeroes if needed).
GetSpectralBands
This command calculates the loudness in equidistant spectral bands (ERB) of a mono signal.
The spectrum is divided in 31 spectral bands.
GetPitchEnvelope
This command extracts the pitch envelope of a mono signal. The signal is divided in blocks of
20 ms and an array is returned with a pitch estimation for each block. If the pitch could not
be estimated or the signal was silent in a block, a value of 0.0f is returned for that block.
GetAmplitudeEnvelope;This command extracts the amplitude envelope of a mono signal. It returns an array of thesame size than the original signal containing the envelope.
CorrectLKFS;
This command calculates the current loudness of a signal and corrects it if the value isdifferent from the specified LKFS target. A flag is also returned that indicates if clipping
occurred during the correction.

#205 e-Kigyokan 2-6-2 Yoneyama
Chuo-ku, 950-0916 Niigata City, Japan
www.tsugi-studio.com

16

Exposing plug-in parameters
Alto Studio will interpret any property marked with an attribute derived from
PlugInParameterAttribute as a plug-in parameter. If the plug-in does not provide agraphical user interface, Alto Studio will use these parameters to create a settings window
for the plug-in. Currently, five types of plug-in parameter attributes are available, dependingon the type of the parameter.

PlugInNumberParameter
This attribute is used to specify any parameter whose value is a number (it can be integer or
floating point).
public PlugInNumberParameter(string name, string description, string group, UInt16line, string unit, float def, float min, float max,bool bInteger)

The name, description and unit are self-explanatory. They will be used by the tool to display
the parameter. Most importantly, the default (def), minimum (min) and maximum (max)values of the parameter are to be specified. A boolean (bInteger) specifies if the parameteris an integer or not. The group name is used by Alto Studio to create headers under whichparameters from the same group will be located. The line number is used to force several
control on a same line.
Here is for example the parameter definition for a fade-in duration (floating point value):
private float m_fadeIn = 0.10f;[PlugInNumberParameter("Fade in", "Duration of the fade in", "Audio Parameters", 1,"s", 0.1f, 0.0f, 100000.0f, false)]
public float FadeIn{
set { m_fadeIn = value; }get { return m_fadeIn; }}#205 e-Kigyokan 2-6-2 Yoneyama
Chuo-ku, 950-0916 Niigata City, Japan
www.tsugi-studio.com

17

If a GUI is automatically generated for your plug-in, a NumericUpDown control will becreated for this type of parameter.

PlugInEnumParameter
This attribute is used to specify a parameter which can take discrete values among a set.
public PlugInEnumParameter( string name, string description, string group, UInt16line, string unit, Int16 def, string[] valueNames )As for the number parameter attribute, the name, description and unit are required, thegroup name and line number as well. valueNames is an array of strings that contains all thepossible values of the parameter in textual format. def is the index of the default value inthat array.
Here is the parameter definition for a fade-in curve:
public enum LevelCurve{
Linear,Exponential,
HalfSine,}

private LevelCurve m_curveIn = LevelCurve.Linear;[PlugInEnumParameter("Fade in curve", "Level curve to use to do the fade in.","Audio Parameters", 2, "", 1, new string[] { "Linear","Exponential","HalfSine" })]public LevelCurve FadeInCurve{
set { m_curveIn = value; }get { return m_curveIn; }}If a GUI is automatically generated for your plug-in, a ComboBox control will be created forthis type of parameter.

#205 e-Kigyokan 2-6-2 Yoneyama
Chuo-ku, 950-0916 Niigata City, Japan
www.tsugi-studio.com

18

PlugInStringParameter
This attribute is used to specify a parameter whose value is a string.
public PlugInStringParameter(string name, string description, string group, UInt16line, string def,StringType stringType)In addition to the usual name, description, group and line of the parameter - no unit
needed this time – the type of the string (stringType) as well as its default value (def) mustbe specified.
The string type is defined like this:public enum StringType{
String,
FileReadPath,
FileWritePath,
FolderPath,}
String is a regular string: it can be the name of an object, a comment, a copyright etc …
FileReadPath, FileWritePath, and FolderPath all correspond to a path. If a GUI is to be

automatically generated for the plug-in, these string parameters will have an extra browse
button (“…”) in addition to the regular TextBox, therefore allowing the selection of a file or afolder. The difference between FileReadPath and FileWritePath is that the first one
requires the selection of an existing path (similar to when you want to read a file) whereas
the second one accepts a new path (similar to when you want to write a file).
Here is an example of usage of this attribute:
private string m_file = "";[PlugInStringParameter("File", "File which will receive all the stripped
metadata.", "Export",1, "", StringType.FileWritePath)]public string File{set { m_file = value; }get { return m_file; }}#205 e-Kigyokan 2-6-2 Yoneyama
Chuo-ku, 950-0916 Niigata City, Japan
www.tsugi-studio.com

19

PlugInBooleanParameter
This attribute corresponds to a boolean value and is represented by a checkbox when a GUI
is automatically created by Alto Studio.
public PlugInBooleanParameter( string name, string description, string group,
UInt16 line, bool def )Its only specific parameter is the default boolean value. Here is an example of definition:bool m_bOpenEditor = false;[PlugInBooleanParameter("Open Editor", "Open the project in editor after export","Export", 2, false)]
public bool OpenEditor{
set { m_bOpenEditor = value; }get { return m_bOpenEditor; }}PlugInLanguagesParameter
This attribute is used to specify a parameter whose value is a list of strings. In the GUI, it isdisplayed as a checked listbox populated with the names of the languages in the projects.
The user can include or exclude languages by clicking on the checkboxes. The list of string
will then contain the names of the languages selected.
public PlugInLanguagesParameter(string name, string description, string group, UInt16line, bool bIncludeReference)

In addition to the usual name, description, group and line of the parameter, thebIncludeReference boolean determines if the reference language must also be included in
the languages displayed by the listbox.
Here is an example of definition:
List<string> m_selectedLanguages = new List<string>();[PlugInLanguagesParameter("Languages", "Select the languages you want to check","Languages", 0, false)]
public List<string> SelectedLanguages{
set { m_selectedLanguages = value; }get { return m_selectedLanguages; }}#205 e-Kigyokan 2-6-2 Yoneyama
Chuo-ku, 950-0916 Niigata City, Japan
www.tsugi-studio.com

20

Testing a plug-in
To test your plug-in in Alto Studio, simply copy the plug-in DLL in the folder where the Alto
Studio executable is located. If it has been marked correctly with the AltoPluginAttribute,
it will be automatically recognized and loaded when Alto Studio starts.
If you didn’t specify an editor for it but marked your parameters appropriately, a GUI will be
automatically generated for it when you call it.
Importer plug-ins can be accessed through the “New project” command. They will appear in
the list of project types you can create. The name of the plug-in, followed by its description
appears in the window. If you select it and press OK the window of the importer plug-in will
be displayed.

Similarly, all the exporter plug-ins and the tool plug-ins found in Alto Studio’s root folder are
added to the “Export Project…” window and to the “Tools” menu respectively. When thetool command in the “Tools plug-ins” submenu is selected, the user interface of the plug-in(either automatically generated or customized) is displayed.

#205 e-Kigyokan 2-6-2 Yoneyama
Chuo-ku, 950-0916 Niigata City, Japan
www.tsugi-studio.com

21

Please note that all plug-ins are detected and loaded by the Alto Studio plug-in manager
when the software is started. A plug-in cannot be hot-swapped, or added to Alto Studiowhile it is already running. You will have to restart Alto Studio for the new plug-in to
become available.

#205 e-Kigyokan 2-6-2 Yoneyama
Chuo-ku, 950-0916 Niigata City, Japan
www.tsugi-studio.com