VEGASPython

This is an adaptation of the original VEGAS Scripting FAQ for VEGASPython

When we speak of scripting in VEGAS, we're not referring to what may first come to mind for many of you, a written description of the scenes and dialog in a video production. Rather, we're referring to programmatic access to the internal data structures in VEGAS projects that allows you to automate things that you might normally do via the GUI. This may help you perform repetitive tasks, integrate with external applications, and implement customized features.

VEGAS uses the .NET framework to provide its scripting interface. VEGAS can execute C#, JScript, and Visual Basic script files directly. You do not need to compile them first. VEGAS can also execute scripts written in other .NET languages but those scripts must be compiled first.

Although JScript, Visual Basic, and C# can be easy to learn, it certainly helps to have programming experience before you try to write a VEGAS script.

Microsoft's developers' web site has more information about the .NET Framework and its various programming languages.

With the VEGASPython extension Vegas can now also execute Scripts programmed in Python.

With VEGASPython and the possibility to use the Python Programing language for VEGAS scripting the hurdle for creating VEGAS scripts is getting much lower. Python is designed to be easy to learn and to use.

All Python scripts are plain text. You can use the interactive VEGASPython editor or any other text editor. If you want to debug longer scripts you can use the free version of Microsoft Visual Studio 2017 as editor and debugger. In the following we assume that you use the interactive VEGASPython editor if nothing else is defined.

Enter the following text in the interactive VEGASPython editor:

print("hello world")

Click in the manu on „Execute Script“.

You will see in the output window the text „hello world“.

Very simple.

Remember the example provided in the original FAQ for C#

using System.Windows.Forms;
using ScriptPortal.Vegas;
 
public class EntryPoint {
    public void FromVegas(Vegas vegas) {
        MessageBox.Show("hello world");
    }
}

You see the difference ?

You can copy the entire contents of the script file from your browser window and paste it into a the interactive VEGASPython Editor. With „Save As“ you can specify the script file name. You can name it anything you want but make sure to name the file with the .py extension.

Yes, scripts can be a security risk to your computer. A script run by VEGAS has the power to do almost anything: delete files, read files, write files, execute programs, access the Internet, access files on your local network, etc. You should always examine the contents of a script before running it and, if you don't understand what it is really doing, you should not run it unless it comes from a trusted source. In general, you should take the same precautions for scripts that you would take for any executable program you download.

VEGASPython is based on IRONPython. IRONPython allows to easily access .NET assemblies in the Python script:

Here is an example for System.QWindows.Forms and ScriptPortal.Vegas.

import clr
clr.AddReference('System.Windows.Forms')
import System.Windows.Forms as WinForms
clr.AddReference('ScriptPortal.Vegas')
import ScriptPortal.Vegas as VEGAS
from ScriptPortal.Vegas import *

In VEGASPython you can import Python modules using the standard Python syntax:

import sys
import os
from sys import *

As VEGASPython is based on IRONPython and on .NET it is not possible to import Python modules that are programmed using C. Most of the common modules are ported to IRONPython but some special modules may not work. Please check the IRONPython webpage for details.

Yes, the global variable ScriptPortal.Vegas.Script.File contains the full path of the currently executing script. So if your script needs access to a helper file that resides in the same directory, your code might look like this: Language: C# String scriptDirectory = Path.GetDirectoryName(ScriptPortal.Vegas.Script.File); String helperFile = Path.Combine(scriptDirectory, „HelperFile.ext“); needs to be updated

1.10: How do I add a script to the Scripting menu?

You can add a script to the Scripting menu (under Vegas' Tools menu) by placing the script in one of the following directories:

C:\Users\<username>\Documents\Vegas Script Menu\ C:\Users\<username>\AppData\Local\Vegas Pro\14.0\Script Menu\ C:\Users\<username>\AppData\Roaming\Vegas Pro\14.0\Script Menu\ C:\ProgramData\Vegas Pro\14.0\Script Menu\ C:\Users\<username>\AppData\Local\Vegas Pro\Script Menu\ C:\Users\<username>\AppData\Roaming\Vegas Pro\Script Menu\ C:\ProgramData\Vegas Pro\Script Menu\

Different systems and users will have different paths to the various documents and settings directories but VEGAS and installer programs should find them based on standard Windows APIs. Typically, you will manage the 'Vegas Script Menu' in 'Documents' yourself. Installers will use one of the other directories depending on the script's version compatibility, whether the script should appear for all users, etc. After you place the script in one of these directories, it will appear in the Scripts menu the next time you launch VEGAS or after you select the „Rescan Script Menu Folder“ menu item.

1.11: How do I add a script to the toolbar?

To add a script to the toolbar, first it must be located in one of the Scripting menu folders detailed above. Once added to the Scripting menu, you can add a script to the toolbar using the 'Customize Toolbar' dialog in VEGAS' Options menu. The available scripts are listed at the bottom of of the available toolbar button list.

1.12: How do I assign a keyboard shortcut to a script?

To assign a keyboard shortcut to a script, first it must be located in one of the Scripting menu folders detailed above. Once added to the Scripting menu, you can create a keyboard shortcut for the script using the 'Customize Keyboard' dialog in VEGAS' Options menu. The available scripts begin with the 'Script' keyword and are available under any context.

1.13: How do I make a custom icon appear for a script in the Scripting menu or toolbar?

You can make a custom icon appear for a script you've added to the Scripting menu or toolbar by placing a PNG image in the same folder that contains the script. The PNG file must have the same name as the script with the '.png' extension appended. For example, if the script is named „My Script.cs“, the toolbar image should be named „My Script.cs.png“. The image must be 16 X 16 pixels and must have 32-bit color depth with an alpha channel for transparency.

Alternatively, you can use the script's configuration file to specify the script's icon. In the configuration file, an IconFile element contains the name of the PNG file to use. For example: Language: XML

<?xml version=„1.0“ encoding=„UTF-8“ ?> <ScriptSettings>

<IconFile>C:\Icons\Icon1.png</IconFile>

</ScriptSettings>

The inner text of the IconFile element is either a full path or a file name in the same directory as the script.

1.14: How do create and debug a script using a Visual Studio?

You must create a compiled script to debug it using a Visual Studio. To create a Visual Studio project for a VEGAS script, you will typically follow these steps (for Visual Studio 2012… other versions will have similar steps):

  In Visual Studio, select the 'File.New.Project...' menu item.
  In the New Project dialog, select the Class Library template under the Visual C# / Windows project type.
  Name your new project, choose its location, and click OK to dismiss the New Project dialog. For this example, we will name our project "SampleScript1"
  Select the 'Project.Add Reference...' menu item.
  Select the Browse tab and select ScriptPortal.Vegas.dll which is located in the VEGAS install directory (typically in C:\Program Files\VEGAS\Vegas Pro...).
  Add references for any other assemblies your script will use. For example, the System.Windows.Forms assembly (located in the .NET tab of the Add Reference dialog) is frequently used.
  Edit your script. Typically, you will change the name of the auto-generated class (Class1) to EntryPoint.

At this point, you should get your script be ready to build (compile). For example, the following code provides a very simple example. Language: C#

using System; using System.Collections.Generic; using System.Text; using System.Windows.Forms; using ScriptPortal.Vegas;

namespace SampleScript1 {

  public class EntryPoint
  {
      public void FromVegas(Vegas vegas)
      {
          MessageBox.Show(vegas.Version);
      }
  }

}

The following steps describe how to debug your script.

  First build the solution in Visual Studio ('Build.Build Solution' menu item). If needed, fix any compiler errors and rebuild.
  Open the project properties using the 'Project.ProjectName Properties' menu item.
  In the Debug tab of the project properties, set the Start Action to 'Start external program'. Select vegas140.exe in the VEGAS install directory.
  Save the project.
  Set your breakpoints in your script.
  Start debugging (select the 'Debug.Start Debugging' menu item). VEGAS should start.
  In VEGAS, select the 'Tools.Run Script...' menu item. Select the assembly that was created when you built your Visual Studio project. It will be in the directory that Visual Studio created for your project. It is not the .cs file you've been editing. You need to select the .dll file that Visual Studio created. It is located in the bin/Debug subdirectory and, for this example, is named SampleScript1.dll.

When you run your precompiled script assembly in the VEGAS application that was started by the Visual Studio debugger, your break points will be hit.

1.15: How do I print debug messages from my script?

You can print debug messages using the System.Diagnostics.Debug.WriteLine method. These messages are visible in your debugger's output window. This works automatically for precompiled scripts built in Visual Studio (using your project's Dubug configuration). However, for scripts that VEGAS compiles, you must add some compiler options to your script config file to enable debug output. Language: XML

<?xml version=„1.0“ encoding=„UTF-8“ ?> <ScriptSettings>

<CompilerOptions>-debug -D:DEBUG</CompilerOptions>

</ScriptSettings>

The compiler options required for debug output depend on which language you are using to write your script. The example provided will work for C# scripts.

1.16: How do I prevent debugger failures when my script accesses Cineform templates?

This problem is caused by the Cineform codec dll. You will need to quit VEGAS, find the file named CFHD.DLL (located either in the VEGAS install directory or the WINDOWS\system32 directory) and temporarily rename it to something like CFHD.DLL.BAK.

1.17: My question is not answered in the FAQ, where can I get more help?

The Scripting Forum is a good place to ask questions. The forum is frequently monitored by VEGAS staff and friendly VEGAS users who have considerable skills and experience. Questions posted in the forum occasionally make their way into this FAQ.

1.18: Where can I get updates to the scripting SDK?

The VEGAS Pro Scripting SDK web page will have a link to download the latest scripting SDK. Updates to the SDK may be posted when we release new versions of VEGAS.

Section 2: Tracks and Events

2.1: How do I find the currently selected track or event?

You can find the currently selected track or event by iterating through each track and event and examining the Selected property. The following functions provide an example of this: Language: C#

Track FindSelectedTrack(Project project) {

  foreach (Track track in project.Tracks) {
      if (track.Selected) {
          return track;
      }
  }
  return null;

}

TrackEvent[] FindSelectedEvents(Project project) {

  List<TrackEvent> selectedEvents = new List<TrackEvent>();
  foreach (Track track in project.Tracks) {
      foreach (TrackEvent trackEvent in track.Events) {
          if (trackEvent.Selected) {
              selectedEvents.Add(trackEvent);
          }
      }
  }
  return selectedEvents.ToArray();

}

Note that multiple tracks and events selected at the same time. The first function returns only the first selected track while the second function returns all of the selected events. Events can be selected in tracks that are not selected.

2.2: How do I set the fade type (curve) for an event?

Every TrackEvent object has FadeIn and FadeOut properties which give you objects that control the event's ASR and (in the case of VideoEvents) transition effects. The Fade object has a Curve property which can be set to one of the CurveType enumeration values. The following example gives an event fade in curve the fast type. Language: C#

evnt.FadeIn.Curve = CurveType.Fast;

One tricky aspect of fades comes into play when two events overlap on the same track. In this case, only the trailing event's FadeIn really matters and, to designate the type of fade curve for the leading event, you actually must set the trailing event's ReciprocalCurve property. The following code snippet makes a slow curved fade transition between an event (trailingEvent) and any event on the same track that overlaps its leading edge: Language: C#

trailingEvent.FadeIn.Curve = CurveType.Slow; trailingEvent.FadeIn.ReciprocalCurve = CurveType.Slow;

2.3: How do I make a one second dissolve at the beginning and end of a video event?

You can add a dissolve (or any transition) to an event using its FadeIn and FadeOut properties. First you can set the length of the transition to the desired amount: Language: C#

videoEvent.FadeIn.Length = Timecode.FromSeconds(1);

or Language: C#

videoEvent.FadeOut.Length = Timecode.FromSeconds(1);

For video events, you can use a transition effect by creating a new instance of an Effect object using a transition PlugInNode then assign it to the Transition property of the appropriate Fade. To create a new transition effect, you must first find the appropriate PlugInNode. To find a transition node by name, use the GetChildByName method of the Transitions root node. The following function creates a new transition effect given its plug-in name: Language: C#

Effect CreateTransitionEffect(VEGAS vegas, String plugInName) {

  PlugInNode plugIn = vegas.Transitions.GetChildByName(plugInName);
  if (null == plugIn)
      throw new ApplicationException(String.Format("Failed to find plug-in: '{0}'", plugInName));
  return new Effect(plugIn);

}

Now you can set the event fade transitions and assign their preset: Language: C#

Effect fadeInTx = CreateTransitionEffect(„VEGAS Dissolve“); videoEvent.FadeIn.Transition = fadeInTx; fadeInTx.Preset = „Additive Dissolve“; Effect fadeOutTx = CreateTransitionEffect(„VEGAS Slide“); videoEvent.FadeOut.Transition = fadeOutTx; fadeOutTx.Preset = „Additive Dissolve“;

You must pass the full name of the plug-in to the GetChildByName method. The Plug-In Manager window shows the full name of each plug-in. Most built-in plug-ins begin with „VEGAS“.

2.4: How do I add media to the timeline?

You can use the OpenFile method of the VEGAS object to add a media file to the selected track at the current cursor position. The OpenFile method works much like the 'File.Open' menu command and will insert tracks if necessary. You can set the cursor position using the CursorPosition of the Vegas object's Transport property. The following method demonstrates how to insert a media file at a specific position on a specific track using the OpenFile method. Language: C#

void InsertFileAt(Vegas vegas, String fileName, int trackIndex, Timecode cursorPosition) {

  // first clear all track selections
  foreach (Track track in vegas.Project.Tracks) {
      track.Selected = false;
  }
  // select the desired track
  vegas.Project.Tracks[trackIndex].Selected = true;
  // set the cursor position
  vegas.Transport.CursorPosition = cursorPosition;
  vegas.OpenFile(fileName);

}

Sometimes you need more control of how you add media to the project. You can build events on the timeline by constructing media, tracks, events, and take objects individually: Language: C#

VideoEvent AddVideoEvent(Vegas vegas, String mediaFile, Timecode start, Timecode length) {

  Media media = new Media(mediaFile);
  VideoTrack track = vegas.Project.AddVideoTrack();
  VideoEvent videoEvent = track.AddVideoEvent(start, length);
  Take take = videoEvent.AddTake(media.GetVideoStreamByIndex(0));
  return videoEvent;

}

2.5: How do I add a text event to the timeline?

You can add a text event to the timeline by constructing a Media object from the text generator effect and adding the video event and take to the track. Language: C#

VideoEvent AddTextEvent(Vegas vegas, VideoTrack track, Timecode start, Timecode length) {

  // find the text generator plug-in
  PlugInNode plugIn = vegas.Generators.GetChildByName("Titler");
  // create a media object with the generator plug-in
  Media media = new Media(plugIn);
  // set the generator preset
  media.Generator.Preset = "centered";
  // add the video event
  VideoEvent videoEvent = track.AddVideoEvent(start, length);
  // add the take using the generated video stream
  Take take = videoEvent.AddTake(media.GetVideoStreamByIndex(0));
  return videoEvent;

}

2.6: How to I make a script modify the text string in a text event?

You can't. Currently, one major shortcoming of the scripting API in VEGAS is that specific parameters of video effects are not accessible to scripts. The text string of text generators are one such parameter. Scripts can only set presets values for a given key frame.

2.7: How do I modify the pan/crop settings of a video event from a script?

Pan and crop settings can be manipulated using the VideoEvent's VideoMotion property. The VideoMotion object has a Keyframes collection that contains VideoMotionKeyframe objects. Each keyframe has a Position in time relative to the start of the event. Keyframes also have a Bounds polygon representing the four corners of the view-port onto the source media. The best way to manipulate this bounds rectangle is to use the keyframe's MoveBy, ScaleBy, and RotateBy methods. The keyframe's Center defines the point at the center of rotation.

The following function moves a video event into view from a position off screen over a two second period. Language: C#

void PanFromLeft(Vegas vegas, VideoEvent videoEvent) {

  // create a new keyframe at 2 seconds.
  VideoMotionKeyframe key1 = new VideoMotionKeyframe(Timecode.FromSeconds(2));
  // add the new keyframe
  videoEvent.VideoMotion.Keyframes.Add(key1);
  // get the first keyframe
  VideoMotionKeyframe key0 = videoEvent.VideoMotion.Keyframes[0];
  // get the width of the project
  int videoWidth = vegas.Project.Video.Width;
  // move the first keyframe just off screen
  key0.MoveBy(new VideoMotionVertex(videoWidth, 0));

}

2.8: How do I set the opacity of a video track or event?

You can to set the CompositeLevel property of a VideoTrack object to effect the entire track's opacity trim level. Language: C#

videoTrack.CompositeLevel = 0.5f;

You can also add a composite level envelope to the video track (described below) if you need to the opacity to change over time.

Individual event opacity can be set using the Gain property of the video event's FadeIn object: Language: C#

videoEvent.FadeIn.Gain = 0.5;

Section 3: Envelopes

3.1: How do I find a particular envelope for a given track or event?

To find an envelope by type, you can use the FindByType method of the appropriate Envelopes collection. Language: C#

Envelope pan = audioTrack.Envelopes.FindByType(EnvelopeType.Pan);

All Track objects (AudioTrack and VideoTrack) have an Envelopes collection. So do all BusTrack objects and VideoEvent objects. Envelopes collections also have a HasEnvelope method that allows you to quickly determine whether it contains an envelope of a particular type.

If you want to find an automation envelope on an audio track, you will need to find it by name. This means you need to iterate through the Envelopes collection and compare each envelope's name to the name you're looking for. Language: C#

Envelope FindEnvelopeByName(Envelopes envelopes, String envelopeName) {

  foreach (Envelope envelope in envelopes) {
      if (envelope.Name == envelopeName) {
          return envelope;
      }
  }
  return null;

}

Automation envelopes are named by both effect name and parameter name. For example an automation envelope for the delay parameter of the chorus effect is named „Chorus: Delay“.

3.2: How do I add an envelope to a track or event?

The first step to add an envelope to a track or event is to create a new envelope of the desired type. The Envelope class constructor can take any of the values in the EnvelopeType enumeration. The next step is to add the new envelope to the appropriate Envelopes collection. Language: C#

Envelope volumeEnvelope = new Envelope(EnvelopeType.Volume); audioTrack.Envelopes.Add(volumeEnvelope);

In this case, audioTrack can be any audio track that does not already have a volume envelope. Certain envelope types can only be added to a specific context. For example, you cannot add a volume envelope to a video event. It is currently not possible for a script to add an audio effect automation envelope to an audio track or bus track.

3.3: How do I add points to an envelope?

You can add points to an envelope in much the same way you add envelopes to a track or event. The first step is to create an EnvelopePoint object then just add it to the envelope's Points collection. Language: C#

EnvelopePoint envelopePoint = new EnvelopePoint(Timecode.FromSeconds(1), 2.0, CurveType.Sharp); envelope.Points.Add(envelopePoint);

The code fragment above creates a new envelope point positioned one second after the start of the envelope. The first argument to the EnvelopePoint constructor is its position. The position represents the point's x-coordinate on the timeline. The second argument is the envelope point's value at the given position. This value must lie somewhere between the envelope's Min and Max properties. Envelopes also have a Neutral property which defines the default or middle value for envelope points. The third argument is one of the CurveType enumeration values which represents how the curve following the point should ascend or descend to reach the next point in the envelope.

One rule to keep in mind when adding envelope points is that no two points can have the same position. An exception is thrown if you attempt to add a point with the same position as another. It is illegal to set a point's position to a negative value or, in the case of event envelopes, to a time beyond the end of the event. It is also illegal to set a point's value outside the envelope's min/max range.

Section 4: Application Extensions

4.1: What are application extensions?

Application extensions are an advanced form of script that are loaded when VEGAS starts and remain active as long as VEGAS is running. Application extensions can add commands to the Extensions menus under VEGAS' Edit, View, and Tools menus. As with scripts, you can add these commands to VEGAS' toolbar and create keyboard shortcuts for them.

Applicaton extensions can have greater levels of interactivity than scripts. They can monitor the changes you make to your project and react accordingly. They can create windows that you can dock along side VEGAS' built-in windows. They can also interactivly control playback.

Unlike scripts, application extensions must be compiled and installed in specific locations before VEGAS can use them. As with scripts (or any program you run on your computer), make sure you trust the source of any application extension you install on your system.

4.2: How do I install an application extension?

Application extensions are contained in .NET assemblies which are program libraries for the .NET runtime that have a '.dll' file extension. Application extensions are generally meant to be installed by an installer program but in some cases you may need to add or remove them manually. When VEGAS starts, it looks in the following locations for application extensions.

C:\Users\<username>\Documents\Vegas Application Extensions\ C:\Users\<username>\AppData\Local\VEGAS Pro\14.0\Application Extensions\ C:\Users\<username>\AppData\Roaming\VEGAS Pro\14.0\Application Extensions\ C:\ProgramData\Vegas Pro\14.0\Application Extensions\ C:\Users\<username>\AppData\Local\Vegas Pro\Application Extensions\ C:\Users\<username>\AppData\Local\Vegas Pro\Application Extensions\ C:\ProgramData\Vegas Pro\Application Extensions\

Different systems and users will have different paths to the various directories but VEGAS and installer programs should find them based on standard Windows APIs. Typically you will manage the 'Vegas Application Extensions' directory in your 'Documents' directory yourself and intaller programs will add extensions to the 'ProgramData' directories.

4.3: How do I write a simple „hello world“ application extension?

An application extension starts with a class that implements the ICustomCommandModule interface. This interface has two methods, InitializeModule and GetCustomCommands. VEGAS calls InitializeModule after it creates the module object. After initialization, VEGAS calls the GetCustomCommands method. You should return a collection of the CustomCommand objects your module implements. This is typically an array of CustomCommand objects but any collection that implements the ICollection interface will work. Each CustomCommand object has an Invoked event which occurs when the user selects the command from the menu, toolbar, or keyboard shortcut. Language: C#

using System; using System.Collections; using System.Windows.Forms; using ScriptPortal.Vegas;

public class SampleModule : ICustomCommandModule {

  public void InitializeModule(Vegas vegas) { }

  public ICollection GetCustomCommands() {
      CustomCommand cmd = new CustomCommand(CommandCategory.Tools, "SampleToolCommand");
      cmd.DisplayName = "Hello World";
      cmd.Invoked += this.HandleInvoked;
      return new CustomCommand[] { cmd };
  }

  void HandleInvoked(Object sender, EventArgs args) {
      MessageBox.Show("hello world");
  }

}

Most command modules hold a reference to the Vegas object passed to the InitializeModule method and use it to access VEGAS' project data when the user invokes the commands. The CommandCategory value passed to the CustomCommand constructor determines which Extensions menu contains the command. The second argument to the CustomCommand constructor is its unique name which VEGAS uses to identify the command. You should never change this name because VEGAS uses it to restore the user's toolbar and keyboard binding preferences. This name must be unique so try to pick a name that other application extension authors probably won't use. If VEGAS loads a command with the same name before yours, your command will be ignored.

The DispalyName property of your CustomCommand appears in the Extension menu item for your command, in the tool-tip text for the toolbar button assigned to your command, and various other user interfaces.

4.4: How do I create a window that can be docked in VEGAS' user interface?

The DockableControl class is special type of UserControl that can be docked in VEGAS' user interface. Typically, you will associate a DockableControl with a CustomCommand that appears in VEGAS' View.Extensions menu. When this command is invoked, your module will create a DockableControl and pass it to the Vegas object's LoadDockView method. Language: C#

using System; using System.Drawing; using System.Collections; using System.Windows.Forms; using ScriptPortal.Vegas;

public class SampleModule : ICustomCommandModule {

  protected Vegas myVegas = null;
  
  public void InitializeModule(Vegas vegas)
  {
      myVegas = vegas;
  }

  CustomCommand myViewCommand = new CustomCommand(CommandCategory.View, "mySampleViewCommand");

  public ICollection GetCustomCommands() {
      myViewCommand.DisplayName = "Hello World View";
      myViewCommand.Invoked += this.HandleInvoked;
      myViewCommand.MenuPopup += this.HandleMenuPopup;
      return new CustomCommand[] { myViewCommand };
  }

  void HandleInvoked(Object sender, EventArgs args) {
      if (!myVegas.ActivateDockView("HellowWorldView"))
      {
          DockableControl dockView = new DockableControl("HellowWorldView");
          Label label = new Label();
          label.Dock = DockStyle.Fill;
          label.Text = "hello world";
          label.TextAlign = ContentAlignment.MiddleCenter;
          dockView.Controls.Add(label);
          myVegas.LoadDockView(dockView);
      }
  }

  void HandleMenuPopup(Object sender, EventArgs args)
  {
      myViewCommand.Checked = myVegas.FindDockView("HellowWorldView");
  }
  

}

The DockableControl is constructed with a unique name string which can be used to activate the window using the ActivateDockView method. If this method returns true, the control has been loaded and VEGAS will bring it to the front of other docked windows. If ActivateDockView returns false, you should construct a new DockableControl and pass it to LoadDockView.

The MenuPopup event of your CustomCommand occurs when VEGAS shows the Extensions menu that contains the command. This is your opportunity to check if your DockableControl is loaded. You can set the Checked property of your command to indicate whether VEGAS should draw a box around your command's icon in the Extensions menu.