Technical solutions
Specially for developing XIDE plugins there is a possibility to startup XIDE without loading the plugins:
– keep the shift key pressed while XIDE starts
– add a /noplugins switch to the command line
This functionality was added yesterday ( May 25, 2016 ). So if you need this and your XIDE version is older, ask the author for an update.
The new XIDE-Build from May 2016 supports the definition of own global variables to use in Pre- and Post-Build events, for example to set some system-wide paths.
Simply add a section [GlobalVariables] to XIDE.cfg, when the program is not open, like this one:
[GlobalVariables]
GlobalVariable = %mygeneralmanifest% , C:\temp\mymanifestfile
Later versions may support these variables also in templates.
You just need to add a section in the bottom of the xide.cfg file:
[FileTools]
xml = notepad.exe
txt = wordpad.exe,%1
The 2nd syntax allows you to use command line options, for example
wordpad.exe , /param1 %1 /param2
(%1 is replaced with the filename)
If you press CTRL or SHIFT while opening a file, it gets opened inside XIDE, instead of the tool you specified. Obviously I am just sending it now but not waiting for a quick response, only when you have time about this.
The following placeholders are available:
%NETSDKPATH%
%OUTPUTFILE%
%OUTPUTPDB%
%OUTPUTPATH%
%ProjectOutputPath%
%AppPath%
%ProjectPath%
%ConfigPath%
%AppName%
%AssemblyName%
A small sample for the executable cmd.exe:
%AppPath%Prg\App.config %ProjectOutputPath%%ConfigPath%%AssemblyName%.exe.config /y
or preferred by myself:
/c c:\xsharp\xide\postbuildcopy.cmd "%AssemblyName%.dll" "%ProjectOutputPath%%ConfigPath%" "c:\devnet\libs\rdm"
where postbuildcopy.cmd has the following content:
@echo off
set assemblyname=%1
set sourcepath=%2%
set targetpath=%3%
set sourcefile=%sourcepath%\%assemblyname%
set targetfile=%targetpath%\%assemblyname%
if not exist %sourcefile% goto ende
if exist %targetfile% goto replace
copy %sourcefile% %targetfile%
goto ende
:replace
replace %sourcefile% %targetpath% /u
:ende
XIDE supports a plugin system.
The core of a plugin is to define a class that inherits from Xide.PluginSystem.Plugin and implements the METHOD Initialize() and PROPERTY Name. Initialize() passes you a PluginService object, with which you can communicate with XIDE. Type self:oService: in the sample to get a list of available methods of this class.
After you have built your plugin dll, simply copy it in the plugin subdirectory of the XIDE directory, and it will be loaded on the next start of XIDE.
And this is a sample code by Chris Pyrgas, the author of XIDE:
using Xide.PluginSystem
using System.Windows.Forms
class TestPlugin inherit Xide.PluginSystem.Plugin
protect oService as PluginService
virtual method Initialize(_oService as PluginService) as void
self:oService := _oService
local oMenuItem as MenuItem
oMenuItem := MenuItem{"Add some custom text" , PluginMenuItem_Edit_clicked }
self:oService:RegisterMenuItem(MainMenuItem.Edit , oMenuItem)
oMenuItem := MenuItem{"My Plugin" , PluginMenuItem_Window_clicked }
self:oService:RegisterMenuItem(MainMenuItem.Window , oMenuItem)
return
method PluginMenuItem_Edit_clicked(o as object,e as EventArgs) as void
local oFilePad as FilePad
local oEditor as Editor
oFilePad := self:oService:GetActiveFilePad()
if oFilePad == null
return
end if
oEditor := oFilePad:Editor
oEditor:AddLine("")
oEditor:AddLine("")
oEditor:AddLine("// This is some test enetered from the plugin!")
oEditor:AddLine("")
return
method PluginMenuItem_Window_clicked(o as object,e as EventArgs) as void
local oProject as Project
oProject := self:oService:ActiveProject
if oProject == null
return
end if
MessageBox.Show("Applications in project " + oProject:Name + " : " + oProject:GetApplications():Length:ToString() , "Message from plugin!")
return
virtual property Name as string get "A test plugin"
end class
In XIDE, it is possible to add reference templates:
You can edit them through VIDE\Config\References.cfg and they appear in the add references page by pressing the button in the bottom left named “Select from template…”
In this post I will try to list some things that are needed for registration-free use of Vulcan.NET or X# components in Visual Objects applications. Some of these issues have costed me several days of tries.
First, a background article from MSDN: How to: Configure .NET Framework-Based COM Components for Registration-Free Activation
Then: a big “Thank You” to Meinhard Schnoor who has helped me a lot not only with this issue, but often also with other issues.
How SxS (how I will call it to shorten) works basically? I’ll try to simplify at maximum what is needed and where the potential problems stay.
Normally, COM works only with “registered” components. This has some issues:
With SxS things are different:
Unfortunately, SxS is very bad documented, and there are not many helpful articles and tools available. And if something goes wrong, it may be very difficult to find out the “why”. sxstrace.exe normally is a help, but not every time. Manifest caching can also disturb.
Manifests
Manifests are the basic mechanism for SxS, they are needed for both the component and the executable. The manifest for the component needs to specify the available classes and GUIDs, and the manifest for the executable needs to specify the name of the component. At loading time, the loader first reads the manifest for the executable and then the manifest for the component. If something goes wrong, you exe will not start. Look first in the event viewer and then use sxstrace to see the errors. Because of manifest caching it can be necessary to change the time stamp of your executable (best: regenerate it). Manifests can be standalone (name of the exe or dll with added .manifest extension), or built into the executable. My recommendation would be to use standalone manifests for development and embedded manifests for deployment.
GUIDs
Every class and also the interfaces need their own GUID – generate a new one with the guidgen tool (You’ll need the Visual Studio Developer Command Prompt for this). Please pay attention to use the right GUIDs!
Versions
The entire system is very sensible to versioning! You need to use the correct version in every place: manifests and component itself (an AssemblyInfo.prg with the correct AssemblyVersionAttribute and the AssemblyFileVersionAttribute entries is needed – otherwise SxS will give no errors, but don’t load the component! This alone has costed me several days of tries.
Naming
Correct naming is the next potential issue: this is not only important for the name of the DLL and for the name of the classes, but also for the namespace used in the component. Name the component the same as the used namespace (and use a namespace!) to save you troubles (with naming errors the registered assembly may work, the SxS loading will fail silently at runtime).
Any error in one of the components will cause the failure of the entire loading mechanism.