Plugins

{ "Name": "bst-users", "Version": "latest", "URLzip": "https://github.com/brainstorm-tools/bst-users/archive/refs/heads/master.zip", "URLinfo": "https://github.com/brainstorm-tools/bst-users/", "TestFile": "processes/examples/process_beamformer_test.m", "LoadFolders": [ "processes/*" ], "ExtraMenus": [["Plugin tutorial","web('https://neuroimage.usc.edu/brainstorm/Tutorials/Plugins', '-browser')"], ["Show Brainstorm license","bst_license"], ["Print cat in Matlab", "disp('=^_^=')"]], "CompiledStatus": 0 }

1 function [varargout] = bst_plugin(varargin) 2 % BST_PLUGIN: Manages Brainstorm plugins 3 % 4 % USAGE: PlugDesc = bst_plugin('GetSupported') % List all the plugins supported by Brainstorm 5 % PlugDesc = bst_plugin('GetSupported', PlugName/PlugDesc) % Get only one specific supported plugin 6 % PlugDesc = bst_plugin('GetInstalled') % Get all the installed plugins 7 % PlugDesc = bst_plugin('GetInstalled', PlugName/PlugDesc) % Get a specific installed plugin 8 % [PlugDesc, errMsg] = bst_plugin('GetDescription', PlugName/PlugDesc) % Get a full structure representing a plugin 9 % [Version, URLzip] = bst_plugin('GetVersionOnline', PlugName, URLzip, isCache) % Get the latest online version of some plugins 10 % sha = bst_plugin('GetGithubCommit', URLzip) % Get SHA of the last commit of a GitHub repository from a master.zip url 11 % ReadmeFile = bst_plugin('GetReadmeFile', PlugDesc) % Get full path to plugin readme file 12 % LogoFile = bst_plugin('GetLogoFile', PlugDesc) % Get full path to plugin logo file 13 % Version = bst_plugin('CompareVersions', v1, v2) % Compare two version strings 14 % [isOk, errMsg] = bst_plugin('AddUserDefDesc', RegMethod, jsonLocation=[]) % Register user-defined plugin definition 15 % [isOk, errMsg] = bst_plugin('RemoveUserDefDesc' PlugName) % Remove user-defined plugin definition 16 % [isOk, errMsg, PlugDesc] = bst_plugin('Load', PlugName/PlugDesc, isVerbose=1) 17 % [isOk, errMsg, PlugDesc] = bst_plugin('LoadInteractive', PlugName/PlugDesc) 18 % [isOk, errMsg, PlugDesc] = bst_plugin('Unload', PlugName/PlugDesc, isVerbose=1) 19 % [isOk, errMsg, PlugDesc] = bst_plugin('UnloadInteractive', PlugName/PlugDesc) 20 % [isOk, errMsg, PlugDesc] = bst_plugin('Install', PlugName, isInteractive=0, minVersion=[]) % Install and Load a plugin and its dependencies 21 % [isOk, errMsg, PlugDesc] = bst_plugin('InstallMultipleChoice',PlugNames, isInteractive=0) % Install at least one of the input plugins 22 % [isOk, errMsg, PlugDesc] = bst_plugin('InstallInteractive', PlugName) 23 % [isOk, errMsg] = bst_plugin('Uninstall', PlugName, isInteractive=0, isDependencies=1) 24 % [isOk, errMsg] = bst_plugin('UninstallInteractive', PlugName) 25 % bst_plugin('Configure', PlugDesc) % Execute some additional tasks after loading or installation 26 % bst_plugin('SetCustomPath', PlugName, PlugPath) 27 % bst_plugin('List', Target='installed') % Target={'supported','installed'} 28 % bst_plugin('Archive', OutputFile=[ask]) % Archive software environment 29 % bst_plugin('MenuCreate', jMenu) 30 % bst_plugin('MenuUpdate', jMenu) 31 % bst_plugin('LinkCatSpm', Action) % 0=Delete/1=Create/2=Check a symbolic link for CAT12 in SPM12 toolbox folder 32 % bst_plugin('UpdateDescription', PlugDesc, doDelete=0) % Update plugin description after load 33 % 34 % 35 % PLUGIN DEFINITION 36 % ================= 37 % 38 % The plugins registered in Brainstorm are listed in function GetSupported(). 39 % Each one is an entry in the PlugDesc array, following the structure defined in db_template('plugdesc'). 40 % The fields allowed are described below. 41 % 42 % Mandatory fields 43 % ================ 44 % - Name : String: Plugin name = subfolder in the Brainstorm user folder 45 % - Version : String: Version of the plugin (eg. '1.2', '21a', 'github-master', 'latest') 46 % - URLzip : String: Download URL, zip or tgz file accessible over HTTP/HTTPS/FTP 47 % - URLinfo : String: Information URL = Software website 48 % 49 % Optional fields 50 % =============== 51 % - AutoUpdate : Boolean: If true, the plugin is updated automatically when there is a new version available (default: true). 52 % - AutoLoad : Boolean: If true, the plugin is loaded automatically at Brainstorm startup 53 % - Category : String: Sub-menu in which the plugin is listed 54 % - ExtraMenus : Cell matrix {Nx2}: List of entries to add to the plugins menu 55 % | ExtraMenus{i,1}: String: Label of the menu 56 % | ExtraMenus{i,2}: String: Matlab code to eval when the menu is clicked 57 % - TestFile : String: Name of a file that should be located in one of the loaded folders of the plugin (eg. 'spm.m' for SPM12). 58 % | This is used to test whether the plugin was correctly installed, or whether it is available somewhere else in the Matlab path. 59 % - ReadmeFile : String: Name of the text file to display after installing the plugin (must be in the plugin folder). 60 % | If empty, it tries using brainstorm3/doc/plugin/plugname_readme.txt 61 % - LogoFile : String: Name of the image file to display during the plugin download, installation, and associated computations (must be in the plugin folder). 62 % | Supported extensions: gif, png. If empty, try using brainstorm3/doc/plugin/<Name>_logo.[gif|png] 63 % - MinMatlabVer : Integer: Minimum Matlab version required for using this plugin, as returned by bst_get('MatlabVersion') 64 % - CompiledStatus : Integer: Behavior of this plugin in the compiled version of Brainstorm: 65 % | 0: Plugin is not available in the compiled distribution of Brainstorm 66 % | 1: Plugin is available for download (only for plugins based on native compiled code) 67 % | 2: Plugin is included in the compiled distribution of Brainstorm 68 % - RequiredPlugs : Cell-array: Additional plugins required by this plugin, that must be installed/loaded beforehand. 69 % | {Nx2} => {'plugname','version'; ...} or 70 % | {Nx1} => {'plugname'; ...} 71 % - UnloadPlugs : Cell-array of names of incompatible plugin, to unload before loaing this one 72 % - LoadFolders : Cell-array of subfolders to add to the Matlab path when setting up the plugin. Use {'*'} to add all the plugin subfolders. 73 % - GetVersionFcn : String to eval or function handle to call to get the version after installation 74 % - InstalledFcn : String to eval or function handle to call after installing the plugin 75 % - UninstalledFcn : String to eval or function handle to call after uninstalling the plugin 76 % - LoadedFcn : String to eval or function handle to call after loading the plugin 77 % - UnloadedFcn : String to eval or function handle to call after unloading the plugin 78 % - DeleteFiles : List of files to delete after installation 79 % 80 % Fields set when installing the plugin 81 % ===================================== 82 % - Processes : List of process functions to be added to the pipeline manager 83 % 84 % Fields set when loading the plugin 85 % ================================== 86 % - Path : Installation path (eg. /home/username/.brainstorm/plugins/fieldtrip) 87 % - SubFolder : If all the code is in a single subfolder (eg. /plugins/fieldtrip/fieldtrip-20210304), 88 % this is detected and the full path to the TestFile would be typically fullfile(Path, SubFolder). 89 % - isLoaded : 0=Not loaded, 1=Loaded 90 % - isManaged : 0=Installed manually by the user, 1=Installed automatically by Brainstorm 91 % 92 93 % @============================================================================= 94 % This function is part of the Brainstorm software: 95 % https://neuroimage.usc.edu/brainstorm 96 % 97 % Copyright (c) University of Southern California & McGill University 98 % This software is distributed under the terms of the GNU General Public License 99 % as published by the Free Software Foundation. Further details on the GPLv3 100 % license can be found at http://www.gnu.org/copyleft/gpl.html. 101 % 102 % FOR RESEARCH PURPOSES ONLY. THE SOFTWARE IS PROVIDED "AS IS," AND THE 103 % UNIVERSITY OF SOUTHERN CALIFORNIA AND ITS COLLABORATORS DO NOT MAKE ANY 104 % WARRANTY, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO WARRANTIES OF 105 % MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, NOR DO THEY ASSUME ANY 106 % LIABILITY OR RESPONSIBILITY FOR THE USE OF THIS SOFTWARE. 107 % 108 % For more information type "brainstorm license" at command prompt. 109 % =============================================================================@ 110 % 111 % Authors: Francois Tadel, 2021-2023 112 113 eval(macro_method); 114 end 115 116 117 %% ===== GET SUPPORTED PLUGINS ===== 118 % USAGE: PlugDesc = bst_plugin('GetSupported') % List all the plugins supported by Brainstorm 119 % PlugDesc = bst_plugin('GetSupported', PlugName/PlugDesc) % Get only one specific supported plugin 120 % PlugDesc = bst_plugin('GetSupported', ..., UserDefVerbose) % Print info on user-defined plugins 121 function PlugDesc = GetSupported(SelPlug, UserDefVerbose) 122 % Parse inputs 123 if (nargin < 2) || isempty(UserDefVerbose) 124 UserDefVerbose = 0; 125 end 126 if (nargin < 1) || isempty(SelPlug) 127 SelPlug = []; 128 end 129 % Initialized returned structure 130 PlugDesc = repmat(db_template('PlugDesc'), 0); 131 % Get OS 132 OsType = bst_get('OsType', 0); 133 134 % Add new curated plugins by 'CATEGORY:' and alphabetic order 135 % ================================================================================================================ 136 % === ANATOMY: BRAIN2MESH === 137 PlugDesc(end+1) = GetStruct('brain2mesh'); 138 PlugDesc(end).Version = 'github-master'; 139 PlugDesc(end).Category = 'Anatomy'; 140 PlugDesc(end).URLzip = 'https://github.com/fangq/brain2mesh/archive/master.zip'; 141 PlugDesc(end).URLinfo = 'http://mcx.space/brain2mesh/'; 142 PlugDesc(end).TestFile = 'brain2mesh.m'; 143 PlugDesc(end).ReadmeFile = 'README.md'; 144 PlugDesc(end).CompiledStatus = 2; 145 PlugDesc(end).RequiredPlugs = {'spm12'; 'iso2mesh'}; 146 PlugDesc(end).DeleteFiles = {'examples', 'brain1020.m', 'closestnode.m', 'label2tpm.m', 'slicesurf.m', 'slicesurf3.m', 'tpm2label.m', 'polylineinterp.m', 'polylinelen.m', 'polylinesimplify.m'}; 147 148 % === ANATOMY: CAT12 === 149 PlugDesc(end+1) = GetStruct('cat12'); 150 PlugDesc(end).Version = 'latest'; 151 PlugDesc(end).Category = 'Anatomy'; 152 PlugDesc(end).AutoUpdate = 1; 153 PlugDesc(end).URLzip = 'http://www.neuro.uni-jena.de/cat12/cat12_latest.zip'; 154 PlugDesc(end).URLinfo = 'http://www.neuro.uni-jena.de/cat/'; 155 PlugDesc(end).TestFile = 'cat_version.m'; 156 PlugDesc(end).ReadmeFile = 'Contents.txt'; 157 PlugDesc(end).CompiledStatus = 0; 158 PlugDesc(end).RequiredPlugs = {'spm12'}; 159 PlugDesc(end).GetVersionFcn = 'bst_getoutvar(2, @cat_version)'; 160 PlugDesc(end).InstalledFcn = 'LinkCatSpm(1);'; 161 PlugDesc(end).UninstalledFcn = 'LinkCatSpm(0);'; 162 PlugDesc(end).LoadedFcn = 'LinkCatSpm(2);'; 163 PlugDesc(end).ExtraMenus = {'Online tutorial', 'web(''https://neuroimage.usc.edu/brainstorm/Tutorials/SegCAT12'', ''-browser'')'}; 164 165 % === ANATOMY: CT2MRIREG === 166 PlugDesc(end+1) = GetStruct('ct2mrireg'); 167 PlugDesc(end).Version = 'github-master'; 168 PlugDesc(end).Category = 'Anatomy'; 169 PlugDesc(end).AutoUpdate = 1; 170 PlugDesc(end).URLzip = 'https://github.com/ajoshiusc/USCCleveland/archive/master.zip'; 171 PlugDesc(end).URLinfo = 'https://github.com/ajoshiusc/USCCleveland/tree/master/ct2mrireg'; 172 PlugDesc(end).TestFile = 'ct2mrireg.m'; 173 PlugDesc(end).ReadmeFile = 'ct2mrireg/README.md'; 174 PlugDesc(end).CompiledStatus = 2; 175 PlugDesc(end).LoadFolders = {'ct2mrireg'}; 176 PlugDesc(end).DeleteFiles = {'fmri_analysis', 'for_clio', 'mixed_atlas', 'process_script', 'reg_prepost', 'visualize_channels', '.gitignore', 'README.md'}; 177 178 % === ANATOMY: ISO2MESH === 179 PlugDesc(end+1) = GetStruct('iso2mesh'); 180 PlugDesc(end).Version = '1.9.6'; 181 PlugDesc(end).Category = 'Anatomy'; 182 PlugDesc(end).AutoUpdate = 1; 183 PlugDesc(end).URLzip = 'https://github.com/fangq/iso2mesh/releases/download/v1.9.6/iso2mesh-1.9.6-allinone.zip'; 184 PlugDesc(end).URLinfo = 'http://iso2mesh.sourceforge.net'; 185 PlugDesc(end).TestFile = 'iso2meshver.m'; 186 PlugDesc(end).ReadmeFile = 'README.txt'; 187 PlugDesc(end).CompiledStatus = 2; 188 PlugDesc(end).LoadedFcn = 'assignin(''base'', ''ISO2MESH_TEMP'', bst_get(''BrainstormTmpDir''));'; 189 PlugDesc(end).DeleteFiles = {'doc', 'tools', '.git_filters', 'sample', ... 190 'bin/cgalmesh.exe', 'bin/cgalmesh.mexglx', 'bin/cgalmesh.mexmaci', ... 191 'bin/cgalpoly.exe', 'bin/cgalpoly.mexglx', 'bin/cgalpoly.mexmaci', 'bin/cgalpoly.mexa64', 'bin/cgalpoly.mexmaci64', 'bin/cgalpoly_x86-64.exe', ... % Removing cgalpoly completely (not used) 192 'bin/cgalsurf.exe', 'bin/cgalsurf.mexglx', 'bin/cgalsurf.mexmaci', ... 193 'bin/cork.exe', ... 194 'bin/gtsrefine.mexglx', 'bin/gtsrefine.mexmaci', 'bin/gtsrefine.mexarmhf', 'bin/gtsrefine.exe', 'bin/gtsrefine.mexmaci64', ... % Removing gtsrefine completely (not used) 195 'bin/jmeshlib.exe', 'bin/jmeshlib.mexglx', 'bin/jmeshlib.mexmaci', 'bin/jmeshlib.mexmac', 'bin/jmeshlib.mexarmhf', ... 196 'bin/meshfix.exe', 'bin/meshfix.mexglx', 'bin/meshfix.mexmaci', 'bin/meshfix.mexarmhf', ... 197 'bin/tetgen.mexglx', 'bin/tetgen.mexmac', 'bin/tetgen.mexarmhf', ... 198 'bin/tetgen1.5.mexglx'}; 199 PlugDesc(end).DeleteFilesBin = {'bin/tetgen.exe', 'bin/tetgen.mexa64', 'bin/tetgen.mexmaci', 'bin/tetgen.mexmaci64', 'bin/tetgen_x86-64.exe', ... % Removing older tetgen completely (very sparsely used) 200 'bin/tetgen1.5.exe'}; 201 202 % === ANATOMY: ROAST === 203 PlugDesc(end+1) = GetStruct('roast'); 204 PlugDesc(end).Version = '3.0'; 205 PlugDesc(end).Category = 'Anatomy'; 206 PlugDesc(end).AutoUpdate = 1; 207 PlugDesc(end).URLzip = 'https://www.parralab.org/roast/roast-3.0.zip'; 208 PlugDesc(end).URLinfo = 'https://www.parralab.org/roast/'; 209 PlugDesc(end).TestFile = 'roast.m'; 210 PlugDesc(end).ReadmeFile = 'README.md'; 211 PlugDesc(end).CompiledStatus = 0; 212 PlugDesc(end).UnloadPlugs = {'spm12', 'iso2mesh'}; 213 PlugDesc(end).LoadFolders = {'lib/spm12', 'lib/iso2mesh', 'lib/cvx', 'lib/ncs2daprox', 'lib/NIFTI_20110921'}; 214 215 216 % === FORWARD: OPENMEEG === 217 PlugDesc(end+1) = GetStruct('openmeeg'); 218 PlugDesc(end).Version = '2.4.1'; 219 PlugDesc(end).Category = 'Forward'; 220 PlugDesc(end).AutoUpdate = 1; 221 switch(OsType) 222 case 'linux64' 223 PlugDesc(end).URLzip = 'https://files.inria.fr/OpenMEEG/download/OpenMEEG-2.4.1-Linux.tar.gz'; 224 PlugDesc(end).TestFile = 'libOpenMEEG.so'; 225 case 'mac64' 226 PlugDesc(end).URLzip = 'https://files.inria.fr/OpenMEEG/download/OpenMEEG-2.4.1-MacOSX.tar.gz'; 227 PlugDesc(end).TestFile = 'libOpenMEEG.1.1.0.dylib'; 228 case 'mac64arm' 229 PlugDesc(end).Version = '2.5.8'; 230 PlugDesc(end).URLzip = ['https://github.com/openmeeg/openmeeg/releases/download/', PlugDesc(end).Version, '/OpenMEEG-', PlugDesc(end).Version, '-', 'macOS_M1.tar.gz']; 231 PlugDesc(end).TestFile = 'libOpenMEEG.1.1.0.dylib'; 232 case 'win32' 233 PlugDesc(end).URLzip = 'https://files.inria.fr/OpenMEEG/download/release-2.2/OpenMEEG-2.2.0-win32-x86-cl-OpenMP-shared.tar.gz'; 234 PlugDesc(end).TestFile = 'om_assemble.exe'; 235 case 'win64' 236 PlugDesc(end).URLzip = 'https://files.inria.fr/OpenMEEG/download/OpenMEEG-2.4.1-Win64.tar.gz'; 237 PlugDesc(end).TestFile = 'om_assemble.exe'; 238 end 239 PlugDesc(end).URLinfo = 'https://openmeeg.github.io/'; 240 PlugDesc(end).ExtraMenus = {'Alternate versions', 'web(''https://files.inria.fr/OpenMEEG/download/'', ''-browser'')'; ... 241 'Download Visual C++', 'web(''http://www.microsoft.com/en-us/download/details.aspx?id=14632'', ''-browser'')'; ... 242 'Online tutorial', 'web(''https://neuroimage.usc.edu/brainstorm/Tutorials/TutBem'', ''-browser'')'}; 243 PlugDesc(end).CompiledStatus = 1; 244 PlugDesc(end).LoadFolders = {'bin', 'lib'}; 245 246 % === FORWARD: DUNEURO === 247 PlugDesc(end+1) = GetStruct('duneuro'); 248 PlugDesc(end).Version = 'latest'; 249 PlugDesc(end).Category = 'Forward'; 250 PlugDesc(end).AutoUpdate = 1; 251 PlugDesc(end).URLzip = 'http://neuroimage.usc.edu/bst/getupdate.php?d=bst_duneuro.zip'; 252 PlugDesc(end).URLinfo = 'https://neuroimage.usc.edu/brainstorm/Tutorials/Duneuro'; 253 PlugDesc(end).TestFile = 'bst_duneuro_meeg_win64.exe'; 254 PlugDesc(end).CompiledStatus = 1; 255 PlugDesc(end).LoadFolders = {'bin'}; 256 257 % === INVERSE: BRAINENTROPY === 258 PlugDesc(end+1) = GetStruct('brainentropy'); 259 PlugDesc(end).Version = 'github-master'; 260 PlugDesc(end).Category = 'Inverse'; 261 PlugDesc(end).AutoUpdate = 1; 262 PlugDesc(end).URLzip = 'https://github.com/multi-funkim/best-brainstorm/archive/master.zip'; 263 PlugDesc(end).URLinfo = 'https://neuroimage.usc.edu/brainstorm/Tutorials/TutBEst'; 264 PlugDesc(end).TestFile = 'process_inverse_mem.m'; 265 PlugDesc(end).AutoLoad = 1; 266 PlugDesc(end).CompiledStatus = 2; 267 PlugDesc(end).LoadFolders = {'*'}; 268 PlugDesc(end).GetVersionFcn = @be_versions; 269 PlugDesc(end).DeleteFiles = {'docs', '.github'}; 270 271 % === I/O: ADI-SDK === ADInstrument SDK for reading LabChart files 272 PlugDesc(end+1) = GetStruct('adi-sdk'); 273 PlugDesc(end).Version = 'github-master'; 274 PlugDesc(end).Category = 'I/O'; 275 switch (OsType) 276 case 'win64', PlugDesc(end).URLzip = 'https://github.com/JimHokanson/adinstruments_sdk_matlab/archive/master.zip'; 277 end 278 PlugDesc(end).URLinfo = 'https://github.com/JimHokanson/adinstruments_sdk_matlab'; 279 PlugDesc(end).TestFile = 'adi.m'; 280 PlugDesc(end).CompiledStatus = 0; 281 282 % === I/O: AXION === 283 PlugDesc(end+1) = GetStruct('axion'); 284 PlugDesc(end).Version = '1.0'; 285 PlugDesc(end).Category = 'I/O'; 286 PlugDesc(end).URLzip = 'http://neuroimage.usc.edu/bst/getupdate.php?d=AxionBioSystems.zip'; 287 PlugDesc(end).URLinfo = 'https://www.axionbiosystems.com/products/software/neural-module'; 288 PlugDesc(end).TestFile = 'AxisFile.m'; 289 % PlugDesc(end).ReadmeFile = 'README.md'; 290 PlugDesc(end).CompiledStatus = 0; 291 292 % === I/O: BCI2000 === 293 PlugDesc(end+1) = GetStruct('bci2000'); 294 PlugDesc(end).Version = 'latest'; 295 PlugDesc(end).Category = 'I/O'; 296 PlugDesc(end).URLzip = 'https://bci2000.org/downloads/mex.zip'; 297 PlugDesc(end).URLinfo = 'https://www.bci2000.org/mediawiki/index.php/User_Reference:Matlab_MEX_Files'; 298 PlugDesc(end).TestFile = 'load_bcidat.m'; 299 PlugDesc(end).CompiledStatus = 0; 300 301 % === I/O: BLACKROCK === 302 PlugDesc(end+1) = GetStruct('blackrock'); 303 PlugDesc(end).Version = 'github-master'; 304 PlugDesc(end).Category = 'I/O'; 305 PlugDesc(end).URLzip = 'https://github.com/BlackrockMicrosystems/NPMK/archive/master.zip'; 306 PlugDesc(end).URLinfo = 'https://github.com/BlackrockMicrosystems/NPMK/blob/master/NPMK/Users%20Guide.pdf'; 307 PlugDesc(end).TestFile = 'openNSx.m'; 308 PlugDesc(end).CompiledStatus = 2; 309 PlugDesc(end).LoadFolders = {'*'}; 310 PlugDesc(end).DeleteFiles = {'NPMK/installNPMK.m', 'NPMK/Users Guide.pdf', 'NPMK/Versions.txt', ... 311 'NPMK/@KTUEAImpedanceFile', 'NPMK/@KTNSPOnline', 'NPMK/@KTNEVComments', 'NPMK/@KTFigureAxis', 'NPMK/@KTFigure', 'NPMK/@KTUEAMapFile/.svn', ... 312 'NPMK/openNSxSync.m', 'NPMK/NTrode Utilities', 'NPMK/NSx Utilities', 'NPMK/NEV Utilities', 'NPMK/LoadingEngines', ... 313 'NPMK/Other tools/.svn', 'NPMK/Other tools/edgeDetect.m', 'NPMK/Other tools/kshuffle.m', 'NPMK/Other tools/openCCF.m', 'NPMK/Other tools/parseCCF.m', ... 314 'NPMK/Other tools/periEventPlot.asv', 'NPMK/Other tools/periEventPlot.m', 'NPMK/Other tools/playSound.m', ... 315 'NPMK/Dependent Functions/.svn', 'NPMK/Dependent Functions/.DS_Store', 'NPMK/Dependent Functions/bnsx.dat', 'NPMK/Dependent Functions/syncPatternDetectNEV.m', ... 316 'NPMK/Dependent Functions/syncPatternDetectNSx.m', 'NPMK/Dependent Functions/syncPatternFinderNSx.m'}; 317 318 % === I/O: EASYH5 === 319 PlugDesc(end+1) = GetStruct('easyh5'); 320 PlugDesc(end).Version = 'github-master'; 321 PlugDesc(end).Category = 'I/O'; 322 PlugDesc(end).URLzip = 'https://github.com/NeuroJSON/easyh5/archive/master.zip'; 323 PlugDesc(end).URLinfo = 'https://github.com/NeuroJSON/easyh5'; 324 PlugDesc(end).TestFile = 'loadh5.m'; 325 PlugDesc(end).CompiledStatus = 2; 326 PlugDesc(end).LoadFolders = {'*'}; 327 PlugDesc(end).DeleteFiles = {'examples'}; 328 PlugDesc(end).ReadmeFile = 'README.md'; 329 330 % === I/O: JSNIRF === 331 PlugDesc(end+1) = GetStruct('jsnirfy'); 332 PlugDesc(end).Version = 'github-master'; 333 PlugDesc(end).Category = 'I/O'; 334 PlugDesc(end).URLzip = 'https://github.com/NeuroJSON/jsnirfy/archive/master.zip'; 335 PlugDesc(end).URLinfo = 'https://github.com/NeuroJSON/jsnirfy'; 336 PlugDesc(end).TestFile = 'loadsnirf.m'; 337 PlugDesc(end).CompiledStatus = 2; 338 PlugDesc(end).LoadFolders = {'*'}; 339 PlugDesc(end).DeleteFiles = {'loadjsnirf.m', 'savejsnirf.m'}; 340 PlugDesc(end).ReadmeFile = 'README.md'; 341 PlugDesc(end).RequiredPlugs = {'easyh5'}; 342 343 % === I/O: MFF === 344 PlugDesc(end+1) = GetStruct('mff'); 345 PlugDesc(end).Version = 'github-master'; 346 PlugDesc(end).Category = 'I/O'; 347 PlugDesc(end).AutoUpdate = 0; 348 PlugDesc(end).URLzip = 'https://github.com/arnodelorme/mffmatlabio/archive/master.zip'; 349 PlugDesc(end).URLinfo = 'https://github.com/arnodelorme/mffmatlabio'; 350 PlugDesc(end).TestFile = 'eegplugin_mffmatlabio.m'; 351 PlugDesc(end).ReadmeFile = 'README.md'; 352 PlugDesc(end).MinMatlabVer = 803; % 2014a 353 PlugDesc(end).CompiledStatus = 0; 354 PlugDesc(end).LoadedFcn = @Configure; 355 % Stable version: http://neuroimage.usc.edu/bst/getupdate.php?d='mffmatlabio-3.5.zip' 356 357 % === I/O: NEUROELECTRICS === 358 PlugDesc(end+1) = GetStruct('neuroelectrics'); 359 PlugDesc(end).Version = '1.8'; 360 PlugDesc(end).Category = 'I/O'; 361 PlugDesc(end).AutoUpdate = 0; 362 PlugDesc(end).URLzip = 'https://sccn.ucsd.edu/eeglab/plugins/Neuroelectrics1.8.zip'; 363 PlugDesc(end).URLinfo = 'https://www.neuroelectrics.com/wiki/index.php/EEGLAB'; 364 PlugDesc(end).TestFile = 'pop_nedf.m'; 365 PlugDesc(end).ReadmeFile = 'README.txt'; 366 PlugDesc(end).CompiledStatus = 2; 367 PlugDesc(end).InstalledFcn = ['d=pwd; cd(fileparts(which(''pop_nedf''))); mkdir(''private''); ' ... 368 'f=fopen(''private' filesep 'eeg_emptyset.m'',''wt''); fprintf(f,''function EEG=eeg_emptyset()\nEEG=struct();''); fclose(f);' ... 369 'f=fopen(''private' filesep 'eeg_checkset.m'',''wt''); fprintf(f,''function EEG=eeg_checkset(EEG)''); fclose(f);' ... 370 'cd(d);']; 371 372 % === I/O: npy-matlab === 373 PlugDesc(end+1) = GetStruct('npy-matlab'); 374 PlugDesc(end).Version = 'github-master'; 375 PlugDesc(end).Category = 'I/O'; 376 PlugDesc(end).URLzip = 'https://github.com/kwikteam/npy-matlab/archive/refs/heads/master.zip'; 377 PlugDesc(end).URLinfo = 'https://github.com/kwikteam/npy-matlab'; 378 PlugDesc(end).TestFile = 'constructNPYheader.m'; 379 PlugDesc(end).LoadFolders = {'*'}; 380 PlugDesc(end).ReadmeFile = 'README.md'; 381 PlugDesc(end).CompiledStatus = 0; 382 383 % === I/O: NWB === 384 PlugDesc(end+1) = GetStruct('nwb'); 385 PlugDesc(end).Version = 'github-master'; 386 PlugDesc(end).Category = 'I/O'; 387 PlugDesc(end).URLzip = 'https://github.com/NeurodataWithoutBorders/matnwb/archive/master.zip'; 388 PlugDesc(end).URLinfo = 'https://github.com/NeurodataWithoutBorders/matnwb'; 389 PlugDesc(end).TestFile = 'nwbRead.m'; 390 PlugDesc(end).ReadmeFile = 'README.md'; 391 PlugDesc(end).MinMatlabVer = 901; % 2016b 392 PlugDesc(end).CompiledStatus = 0; 393 PlugDesc(end).LoadFolders = {'*'}; 394 PlugDesc(end).LoadedFcn = @Configure; 395 396 % === I/O: PLEXON === 397 PlugDesc(end+1) = GetStruct('plexon'); 398 PlugDesc(end).Version = '1.8.4'; 399 PlugDesc(end).Category = 'I/O'; 400 PlugDesc(end).URLzip = 'https://plexon.com/wp-content/uploads/2017/08/OmniPlex-and-MAP-Offline-SDK-Bundle_0.zip'; 401 PlugDesc(end).URLinfo = 'https://plexon.com/software-downloads/#software-downloads-SDKs'; 402 PlugDesc(end).TestFile = 'plx_info.m'; 403 PlugDesc(end).ReadmeFile = 'Change Log.txt'; 404 PlugDesc(end).CompiledStatus = 0; 405 PlugDesc(end).DownloadedFcn = ['d = fullfile(PlugDesc.Path, ''OmniPlex and MAP Offline SDK Bundle'');' ... 406 'unzip(fullfile(d, ''Matlab Offline Files SDK.zip''), PlugDesc.Path);' ... 407 'file_delete(d,1,3);']; 408 PlugDesc(end).InstalledFcn = ['if (exist(''mexPlex'', ''file'') ~= 3), d = pwd;' ... 409 'cd(fullfile(fileparts(which(''plx_info'')), ''mexPlex''));', ... 410 'build_and_verify_mexPlex; cd(d); end']; 411 412 % === I/O: PLOTLY === 413 PlugDesc(end+1) = GetStruct('plotly'); 414 PlugDesc(end).Version = 'github-master'; 415 PlugDesc(end).Category = 'I/O'; 416 PlugDesc(end).URLzip = 'https://github.com/plotly/plotly_matlab/archive/master.zip'; 417 PlugDesc(end).URLinfo = 'https://plotly.com/matlab/'; 418 PlugDesc(end).TestFile = 'plotlysetup_online.m'; 419 PlugDesc(end).ReadmeFile = 'README.mkdn'; 420 PlugDesc(end).CompiledStatus = 0; 421 PlugDesc(end).LoadFolders = {'*'}; 422 PlugDesc(end).ExtraMenus = {'Online tutorial', 'web(''https://neuroimage.usc.edu/brainstorm/Tutorials/Plotly'', ''-browser'')'}; 423 424 % === I/O: TDT-SDK === Tucker-Davis Technologies Matlab SDK 425 PlugDesc(end+1) = GetStruct('tdt-sdk'); 426 PlugDesc(end).Version = 'latest'; 427 PlugDesc(end).Category = 'I/O'; 428 PlugDesc(end).URLzip = 'https://www.tdt.com/files/examples/TDTMatlabSDK.zip'; 429 PlugDesc(end).URLinfo = 'https://www.tdt.com/support/matlab-sdk/'; 430 PlugDesc(end).TestFile = 'TDT_Matlab_Tools.pdf'; 431 PlugDesc(end).CompiledStatus = 0; 432 PlugDesc(end).LoadFolders = {'*'}; 433 434 % === I/O: XDF === 435 PlugDesc(end+1) = GetStruct('xdf'); 436 PlugDesc(end).Version = 'github-master'; 437 PlugDesc(end).Category = 'I/O'; 438 PlugDesc(end).AutoUpdate = 0; 439 PlugDesc(end).URLzip = 'https://github.com/xdf-modules/xdf-Matlab/archive/refs/heads/master.zip'; 440 PlugDesc(end).URLinfo = 'https://github.com/xdf-modules/xdf-Matlab'; 441 PlugDesc(end).TestFile = 'load_xdf.m'; 442 PlugDesc(end).ReadmeFile = 'readme.md'; 443 PlugDesc(end).CompiledStatus = 2; 444 445 % === SIMULATION: SIMMEEG === 446 PlugDesc(end+1) = GetStruct('simmeeg'); 447 PlugDesc(end).Version = 'github-master'; 448 PlugDesc(end).Category = 'Simulation'; 449 PlugDesc(end).AutoUpdate = 1; 450 PlugDesc(end).URLzip = 'https://github.com/branelab/SimMEEG/archive/master.zip'; 451 PlugDesc(end).URLinfo = 'https://audiospeech.ubc.ca/research/brane/brane-lab-software/'; 452 PlugDesc(end).TestFile = 'SimMEEG_GUI.m'; 453 PlugDesc(end).ReadmeFile = 'SIMMEEG_TERMS_OF_USE.txt'; 454 PlugDesc(end).CompiledStatus = 0; 455 PlugDesc(end).RequiredPlugs = {'fieldtrip', '20200911'}; 456 457 458 % === STATISTICS: FASTICA === 459 PlugDesc(end+1) = GetStruct('fastica'); 460 PlugDesc(end).Version = '2.5'; 461 PlugDesc(end).Category = 'Statistics'; 462 PlugDesc(end).URLzip = 'https://research.ics.aalto.fi/ica/fastica/code/FastICA_2.5.zip'; 463 PlugDesc(end).URLinfo = 'https://research.ics.aalto.fi/ica/fastica/'; 464 PlugDesc(end).TestFile = 'fastica.m'; 465 PlugDesc(end).ReadmeFile = 'Contents.m'; 466 PlugDesc(end).CompiledStatus = 2; 467 468 % === STATISTICS: LIBSVM === 469 PlugDesc(end+1) = GetStruct('libsvm'); 470 PlugDesc(end).Version = 'github-master'; 471 PlugDesc(end).Category = 'Statistics'; 472 PlugDesc(end).URLzip = 'https://github.com/cjlin1/libsvm/archive/master.zip'; 473 PlugDesc(end).URLinfo = 'https://www.csie.ntu.edu.tw/~cjlin/libsvm/'; 474 PlugDesc(end).TestFile = 'svm.cpp'; 475 PlugDesc(end).ReadmeFile = 'README'; 476 PlugDesc(end).MinMatlabVer = 803; % 2014a 477 PlugDesc(end).CompiledStatus = 2; 478 PlugDesc(end).LoadFolders = {'*'}; 479 PlugDesc(end).InstalledFcn = 'd=pwd; cd(fileparts(which(''make''))); make; cd(d);'; 480 481 % === STATISTICS: PICARD === 482 PlugDesc(end+1) = GetStruct('picard'); 483 PlugDesc(end).Version = 'github-master'; 484 PlugDesc(end).Category = 'Statistics'; 485 PlugDesc(end).URLzip = 'https://github.com/pierreablin/picard/archive/refs/heads/master.zip'; 486 PlugDesc(end).URLinfo = 'https://github.com/pierreablin/picard'; 487 PlugDesc(end).TestFile = 'picard.m'; 488 PlugDesc(end).ReadmeFile = 'README.rst'; 489 PlugDesc(end).CompiledStatus = 2; 490 PlugDesc(end).LoadFolders = {'matlab_octave'}; 491 492 % === ELECTROPHYSIOLOGY: DERIVELFP === 493 PlugDesc(end+1) = GetStruct('derivelfp'); 494 PlugDesc(end).Version = '1.0'; 495 PlugDesc(end).Category = 'e-phys'; 496 PlugDesc(end).AutoUpdate = 0; 497 PlugDesc(end).URLzip = 'http://packlab.mcgill.ca/despikingtoolbox.zip'; 498 PlugDesc(end).URLinfo = 'https://journals.physiology.org/doi/full/10.1152/jn.00642.2010'; 499 PlugDesc(end).TestFile = 'despikeLFP.m'; 500 PlugDesc(end).ReadmeFile = 'readme.txt'; 501 PlugDesc(end).CompiledStatus = 2; 502 PlugDesc(end).LoadFolders = {'toolbox'}; 503 PlugDesc(end).DeleteFiles = {'ExampleDespiking.m', 'appendixpaper.pdf', 'downsample2x.m', 'examplelfpdespiking.mat', 'sta.m', ... 504 'toolbox/delineSignal.m', 'toolbox/despikeLFPbyChunks.asv', 'toolbox/despikeLFPbyChunks.m'}; 505 506 % === ELECTROPHYSIOLOGY: Kilosort === 507 PlugDesc(end+1) = GetStruct('kilosort'); 508 PlugDesc(end).Version = 'github-master'; 509 PlugDesc(end).Category = 'e-phys'; 510 PlugDesc(end).URLzip = 'https://github.com/cortex-lab/KiloSort/archive/refs/heads/master.zip'; 511 PlugDesc(end).URLinfo = 'https://papers.nips.cc/paper/2016/hash/1145a30ff80745b56fb0cecf65305017-Abstract.html'; 512 PlugDesc(end).TestFile = 'fitTemplates.m'; 513 PlugDesc(end).ReadmeFile = 'readme.md'; 514 PlugDesc(end).CompiledStatus = 0; 515 PlugDesc(end).LoadFolders = {'*'}; 516 PlugDesc(end).RequiredPlugs = {'kilosort-wrapper'; 'phy'; 'npy-matlab'}; 517 PlugDesc(end).InstalledFcn = 'process_spikesorting_kilosort(''copyKilosortConfig'', bst_fullfile(bst_get(''UserPluginsDir''), ''kilosort'', ''KiloSort-master'', ''configFiles'', ''StandardConfig_MOVEME.m''), bst_fullfile(bst_get(''UserPluginsDir''), ''kilosort'', ''KiloSort-master'', ''KilosortStandardConfig.m''));'; 518 519 520 % === ELECTROPHYSIOLOGY: Kilosort Wrapper === 521 PlugDesc(end+1) = GetStruct('kilosort-wrapper'); 522 PlugDesc(end).Version = 'github-master'; 523 PlugDesc(end).Category = 'e-phys'; 524 PlugDesc(end).URLzip = 'https://github.com/brendonw1/KilosortWrapper/archive/refs/heads/master.zip'; 525 PlugDesc(end).URLinfo = 'https://zenodo.org/record/3604165'; 526 PlugDesc(end).TestFile = 'Kilosort2Neurosuite.m'; 527 PlugDesc(end).ReadmeFile = 'README.md'; 528 PlugDesc(end).CompiledStatus = 0; 529 530 % === ELECTROPHYSIOLOGY: phy === 531 PlugDesc(end+1) = GetStruct('phy'); 532 PlugDesc(end).Version = 'github-master'; 533 PlugDesc(end).Category = 'e-phys'; 534 PlugDesc(end).URLzip = 'https://github.com/cortex-lab/phy/archive/refs/heads/master.zip'; 535 PlugDesc(end).URLinfo = 'https://phy.readthedocs.io/en/latest/'; 536 PlugDesc(end).TestFile = 'feature_view_custom_grid.py'; 537 PlugDesc(end).LoadFolders = {'*'}; 538 PlugDesc(end).ReadmeFile = 'README.md'; 539 PlugDesc(end).CompiledStatus = 0; 540 PlugDesc(end).RequiredPlugs = {'npy-matlab'}; 541 542 % === ELECTROPHYSIOLOGY: ultramegasort2000 === 543 PlugDesc(end+1) = GetStruct('ultramegasort2000'); 544 PlugDesc(end).Version = 'github-master'; 545 PlugDesc(end).Category = 'e-phys'; 546 PlugDesc(end).URLzip = 'https://github.com/danamics/UMS2K/archive/refs/heads/master.zip'; 547 PlugDesc(end).URLinfo = 'https://github.com/danamics/UMS2K/blob/master/UltraMegaSort2000%20Manual.pdf'; 548 PlugDesc(end).TestFile = 'UltraMegaSort2000 Manual.pdf'; 549 PlugDesc(end).LoadFolders = {'*'}; 550 PlugDesc(end).ReadmeFile = 'README.md'; 551 PlugDesc(end).CompiledStatus = 0; 552 553 % === ELECTROPHYSIOLOGY: waveclus === 554 PlugDesc(end+1) = GetStruct('waveclus'); 555 PlugDesc(end).Version = 'github-master'; 556 PlugDesc(end).Category = 'e-phys'; 557 PlugDesc(end).URLzip = 'https://github.com/csn-le/wave_clus/archive/refs/heads/master.zip'; 558 PlugDesc(end).URLinfo = 'https://journals.physiology.org/doi/full/10.1152/jn.00339.2018'; 559 PlugDesc(end).TestFile = 'wave_clus.m'; 560 PlugDesc(end).LoadFolders = {'*'}; 561 PlugDesc(end).ReadmeFile = 'README.md'; 562 PlugDesc(end).CompiledStatus = 0; 563 564 % === fNIRS: NIRSTORM === 565 PlugDesc(end+1) = GetStruct('nirstorm'); 566 PlugDesc(end).Version = 'github-master'; 567 PlugDesc(end).Category = 'fNIRS'; 568 PlugDesc(end).AutoUpdate = 0; 569 PlugDesc(end).AutoLoad = 1; 570 PlugDesc(end).CompiledStatus = 2; 571 PlugDesc(end).URLzip = 'https://github.com/Nirstorm/nirstorm/archive/master.zip'; 572 PlugDesc(end).URLinfo = 'https://github.com/Nirstorm/nirstorm'; 573 PlugDesc(end).LoadFolders = {'bst_plugin/core','bst_plugin/forward','bst_plugin/GLM', 'bst_plugin/inverse' , 'bst_plugin/io','bst_plugin/math' ,'bst_plugin/mbll' ,'bst_plugin/misc', 'bst_plugin/OM', 'bst_plugin/preprocessing', 'bst_plugin/ppl'}; 574 PlugDesc(end).TestFile = 'process_nst_mbll.m'; 575 PlugDesc(end).ReadmeFile = 'README.md'; 576 PlugDesc(end).GetVersionFcn = 'nst_get_version'; 577 PlugDesc(end).RequiredPlugs = {'brainentropy'}; 578 PlugDesc(end).MinMatlabVer = 803; % 2014a 579 PlugDesc(end).DeleteFiles = {'scripts', 'test', 'run_tests.m', 'test_suite_bak.m', '.gitignore'}; 580 581 % === fNIRS: MCXLAB CUDA === 582 PlugDesc(end+1) = GetStruct('mcxlab-cuda'); 583 PlugDesc(end).Version = '2021.12.04'; 584 PlugDesc(end).Category = 'fNIRS'; 585 PlugDesc(end).AutoUpdate = 1; 586 PlugDesc(end).URLzip = 'http://mcx.space/nightly/release/v2020/lite/mcxlab-allinone-x86_64-v2020.zip'; 587 PlugDesc(end).TestFile = 'mcxlab.m'; 588 PlugDesc(end).URLinfo = 'http://mcx.space/wiki/'; 589 PlugDesc(end).CompiledStatus = 0; 590 PlugDesc(end).LoadFolders = {'*'}; 591 PlugDesc(end).UnloadPlugs = {'mcxlab-cl'}; 592 593 % === fNIRS: MCXLAB CL === 594 PlugDesc(end+1) = GetStruct('mcxlab-cl'); 595 PlugDesc(end).Version = '2020'; 596 PlugDesc(end).Category = 'fNIRS'; 597 PlugDesc(end).AutoUpdate = 0; 598 PlugDesc(end).URLzip = 'http://mcx.space/nightly/release/v2020/lite/mcxlabcl-allinone-x86_64-v2020.zip'; 599 PlugDesc(end).TestFile = 'mcxlabcl.m'; 600 PlugDesc(end).URLinfo = 'http://mcx.space/wiki/'; 601 PlugDesc(end).CompiledStatus = 2; 602 PlugDesc(end).LoadFolders = {'*'}; 603 PlugDesc(end).UnloadPlugs = {'mcxlab-cuda'}; 604 605 % === sEEG: MIA === 606 PlugDesc(end+1) = GetStruct('mia'); 607 PlugDesc(end).Version = 'github-master'; 608 PlugDesc(end).Category = 'sEEG'; 609 PlugDesc(end).AutoUpdate = 0; 610 PlugDesc(end).AutoLoad = 1; 611 PlugDesc(end).CompiledStatus = 2; 612 PlugDesc(end).URLzip = 'https://github.com/MIA-iEEG/mia/archive/refs/heads/master.zip'; 613 PlugDesc(end).URLinfo = 'http://www.neurotrack.fr/mia/'; 614 PlugDesc(end).ReadmeFile = 'README.md'; 615 PlugDesc(end).MinMatlabVer = 803; % 2014a 616 PlugDesc(end).LoadFolders = {'*'}; 617 PlugDesc(end).TestFile = 'process_mia_export_db.m'; 618 PlugDesc(end).ExtraMenus = {'Start MIA', 'mia', 'loaded'}; 619 620 % === FIELDTRIP === 621 PlugDesc(end+1) = GetStruct('fieldtrip'); 622 PlugDesc(end).Version = 'latest'; 623 PlugDesc(end).AutoUpdate = 0; 624 PlugDesc(end).URLzip = 'https://download.fieldtriptoolbox.org/fieldtrip-lite-20240405.zip'; 625 PlugDesc(end).URLinfo = 'http://www.fieldtriptoolbox.org'; 626 PlugDesc(end).TestFile = 'ft_defaults.m'; 627 PlugDesc(end).ReadmeFile = 'README'; 628 PlugDesc(end).CompiledStatus = 2; 629 PlugDesc(end).UnloadPlugs = {'spm12', 'roast'}; 630 PlugDesc(end).LoadFolders = {'specest', 'preproc', 'forward', 'src', 'utilities'}; 631 PlugDesc(end).GetVersionFcn = 'ft_version'; 632 PlugDesc(end).LoadedFcn = ['global ft_default; ' ... 633 'ft_default = []; ' ... 634 'if exist(''filtfilt'', ''file''), ft_default.toolbox.signal=''matlab''; end; ' ... 635 'if exist(''nansum'', ''file''), ft_default.toolbox.stats=''matlab''; end; ' ... 636 'if exist(''rgb2hsv'', ''file''), ft_default.toolbox.images=''matlab''; end; ' ... 637 'ft_defaults;']; 638 639 % === SPM12 === 640 PlugDesc(end+1) = GetStruct('spm12'); 641 PlugDesc(end).Version = 'latest'; 642 PlugDesc(end).AutoUpdate = 0; 643 switch(OsType) 644 case 'mac64arm' 645 PlugDesc(end).URLzip = 'https://github.com/spm/spm12/archive/refs/heads/maint.zip'; 646 PlugDesc(end).Version = 'github-maint'; 647 otherwise 648 PlugDesc(end).Version = 'latest'; 649 PlugDesc(end).URLzip = 'https://www.fil.ion.ucl.ac.uk/spm/download/restricted/eldorado/spm12.zip'; 650 end 651 PlugDesc(end).URLinfo = 'https://www.fil.ion.ucl.ac.uk/spm/'; 652 PlugDesc(end).TestFile = 'spm.m'; 653 PlugDesc(end).ReadmeFile = 'README.md'; 654 PlugDesc(end).CompiledStatus = 2; 655 PlugDesc(end).UnloadPlugs = {'fieldtrip', 'roast'}; 656 PlugDesc(end).LoadFolders = {'matlabbatch'}; 657 PlugDesc(end).GetVersionFcn = 'bst_getoutvar(2, @spm, ''Ver'')'; 658 PlugDesc(end).LoadedFcn = 'spm(''defaults'',''EEG'');'; 659 660 % === USER DEFINED PLUGINS === 661 plugJsonFiles = dir(fullfile(bst_get('UserPluginsDir'), 'plugin_*.json')); 662 badJsonFiles = {}; 663 plugUserDefNames = {}; 664 for ix = 1:length(plugJsonFiles) 665 plugJsonText = fileread(fullfile(plugJsonFiles(ix).folder, plugJsonFiles(ix).name)); 666 try 667 PlugUserDesc = bst_jsondecode(plugJsonText); 668 catch 669 badJsonFiles{end+1} = plugJsonFiles(ix).name; 670 continue 671 end 672 % Reshape fields "ExtraMenus" 673 if isfield(PlugUserDesc, 'ExtraMenus') && ~isempty(PlugUserDesc.ExtraMenus) && iscell(PlugUserDesc.ExtraMenus{1}) 674 PlugUserDesc.ExtraMenus = cat(2, PlugUserDesc.ExtraMenus{:})'; 675 end 676 % Reshape fields "RequiredPlugs" 677 if isfield(PlugUserDesc, 'RequiredPlugs') && ~isempty(PlugUserDesc.RequiredPlugs) && iscell(PlugUserDesc.RequiredPlugs{1}) 678 PlugUserDesc.RequiredPlugs = cat(2, PlugUserDesc.RequiredPlugs{:})'; 679 end 680 % Check for uniqueness for user-defined plugin 681 if ~ismember(PlugUserDesc.Name, {PlugDesc.Name}) 682 plugUserDefNames{end+1} = PlugUserDesc.Name; 683 PlugDesc(end+1) = struct_copy_fields(GetStruct(PlugUserDesc.Name), PlugUserDesc); 684 end 685 end 686 % Print info on user-defined plugins 687 if UserDefVerbose 688 if ~isempty(plugUserDefNames) 689 fprintf(['BST> User-defined plugins... ' strjoin(plugUserDefNames, ' ') '\n']); 690 end 691 for iBad = 1 : length(badJsonFiles) 692 fprintf(['BST> User-defined plugins, error reading .json file... ' badJsonFiles{iBad} '\n']); 693 end 694 end 695 696 % ================================================================================================================ 697 698 % Select only one plugin 699 if ~isempty(SelPlug) 700 % Get plugin name 701 if ischar(SelPlug) 702 PlugName = SelPlug; 703 else 704 PlugName = SelPlug.Name; 705 end 706 % Find in the list of plugins 707 iPlug = find(strcmpi({PlugDesc.Name}, PlugName)); 708 if ~isempty(iPlug) 709 PlugDesc = PlugDesc(iPlug); 710 else 711 PlugDesc = []; 712 end 713 end 714 end 715 716 717 %% ===== PLUGIN STRUCT ===== 718 function s = GetStruct(PlugName) 719 s = db_template('PlugDesc'); 720 s.Name = PlugName; 721 end 722 723 724 %% ===== ADD USER DEFINED PLUGIN DESCRIPTION ===== 725 function [isOk, errMsg] = AddUserDefDesc(RegMethod, jsonLocation) 726 isOk = 1; 727 errMsg = ''; 728 isInteractive = strcmp(RegMethod, 'manual') || nargin < 2 || isempty(jsonLocation); 729 730 % Get json file location from user 731 if ismember(RegMethod, {'file', 'url'}) && isInteractive 732 if strcmp(RegMethod, 'file') 733 jsonLocation = java_getfile('open', 'Plugin description JSON file...', '', 'single', 'files', {{'.json'}, 'Brainstorm plugin description (*.json)', 'JSON'}, 1); 734 elseif strcmp(RegMethod, 'url') 735 jsonLocation = java_dialog('input', 'Enter the URL the plugin description file (.json)', 'Plugin description JSON file...', [], ''); 736 end 737 if isempty(jsonLocation) 738 return 739 end 740 res = java_dialog('question', ['Warning: This plugin has not been verified.' 10 ... 741 'Malicious plugins can alter your database, proceed with caution and only install plugins from trusted sources.' 10 ... 742 'If any unusual behavior occurs after installation, start by uninstalling the plugins.' 10 ... 743 'Are you sure you want to proceed?'], ... 744 'Warning', [], {'yes', 'no'}); 745 if strcmp(res, 'no') 746 return 747 end 748 end 749 750 % Get plugin description 751 switch RegMethod 752 case 'file' 753 jsonText = fileread(jsonLocation); 754 try 755 PlugDesc = bst_jsondecode(jsonText); 756 catch 757 errMsg = sprintf(['Could not parse JSON file:' 10 '%s'], jsonLocation); 758 end 759 760 case 'url' 761 % Handle GitHub links, convert the link to load the raw content 762 if strcmp(jsonLocation(1:4),'http') && strcmp(jsonLocation(end-4:end),'.json') 763 if ~isempty(regexp(jsonLocation, '^http[s]*://github.com', 'once')) 764 jsonLocation = strrep(jsonLocation, 'github.com','raw.githubusercontent.com'); 765 jsonLocation = strrep(jsonLocation, 'blob/', ''); 766 end 767 end 768 jsonText = bst_webread(jsonLocation); 769 try 770 PlugDesc = bst_jsondecode(jsonText); 771 catch 772 errMsg = sprintf(['Could not parse JSON file at:' 10 '%s'], jsonLocation); 773 end 774 775 case 'manual' 776 % Get info for user-defined plugin description from user 777 res = java_dialog('input', { ['<HTML>Provide the <B>mandatory</B> fields for a user defined Brainstorm plugin<BR>' ... 778 'See this page for further details:<BR>' ... 779 '<FONT COLOR="#0000FF">https://neuroimage.usc.edu/brainstorm/Tutorials/Plugins</FONT>' ... 780 '<BR><BR>' ... 781 'Plugin name<BR>' ... 782 '<I><FONT color="#707070">EXAMPLE: bst-users</FONT></I>'], ... 783 ['<HTML>Version<BR>' ... 784 '<I><FONT color="#707070">EXAMPLE: github-main or 3.1.4</FONT></I>'], ... 785 ['<HTML>URL for zip<BR>' ... 786 '<I><FONT color="#707070">EXAMPLE: https://github.com/brainstorm-tools/bst-users/archive/refs/heads/master.zip</FONT></I>'], ... 787 ['<HTML>URL for information<BR>' ... 788 '<I><FONT color="#707070">EXAMPLE: https://github.com/brainstorm-tools/bst-users</FONT></I>']}, ... 789 'User defined plugin', [], {'', '', '', ''}); 790 if isempty(res) || any(cellfun(@isempty,res)) 791 return 792 end 793 PlugDesc.Name = lower(res{1}); 794 PlugDesc.Version = res{2}; 795 PlugDesc.URLzip = res{3}; 796 PlugDesc.URLinfo = res{4}; 797 end 798 if ~isempty(errMsg) 799 bst_error(errMsg); 800 isOk = 0; 801 return; 802 end 803 804 % Validate retrieved plugin description 805 if length(PlugDesc) > 1 806 errMsg = 'JSON file should contain only one plugin description'; 807 elseif ~all(ismember({'Name', 'Version', 'URLzip', 'URLinfo'}, fieldnames(PlugDesc))) 808 errMsg = 'Plugin description must contain the fields ''Name'', ''Version'', ''URLzip'' and ''URLinfo'''; 809 else 810 PlugDesc.Name = lower(PlugDesc.Name); 811 PlugDescs = GetSupported(); 812 if ismember(PlugDesc.Name, {PlugDescs.Name}) 813 errMsg = sprintf('Plugin ''%s'' already exist in Brainstorm', PlugDesc.Name); 814 end 815 end 816 if ~isempty(errMsg) 817 bst_error(errMsg); 818 isOk = 0; 819 return; 820 end 821 % Override category 822 PlugDesc.Category = 'User defined'; 823 824 % Write validated JSON file 825 pluginJsonFileOut = fullfile(bst_get('UserPluginsDir'), sprintf('plugin_%s.json', file_standardize(PlugDesc.Name))); 826 fid = fopen(pluginJsonFileOut, 'wt'); 827 jsonText = bst_jsonencode(PlugDesc, 0); 828 fprintf(fid, jsonText); 829 fclose(fid); 830 831 fprintf(1, 'BST> Plugin ''%s'' was added to ''User defined'' plugins\n', PlugDesc.Name); 832 end 833 834 835 %% ===== REMOVE USER DEFINED PLUGIN DESCRIPTION ===== 836 function [isOk, errMsg] = RemoveUserDefDesc(PlugName) 837 isOk = 1; 838 errMsg = ''; 839 if nargin < 1 || isempty(PlugName) 840 PlugDescs = GetSupported(); 841 PlugDescs = PlugDescs(ismember({PlugDescs.Category}, 'User defined')); 842 PlugName = java_dialog('combo', 'Indicate the name of the plugin to remove:', 'Remove plugin from ''User defined'' list', [], {PlugDescs.Name}); 843 end 844 if isempty(PlugName) 845 return 846 end 847 PlugDesc = GetSupported(PlugName); 848 if ~isempty(PlugDesc.Path) || file_exist(bst_fullfile(bst_get('UserPluginsDir'), PlugDesc.Name)) 849 [isOk, errMsg] = Uninstall(PlugDesc.Name, 0); 850 end 851 % Delete json file 852 if isOk 853 isOk = file_delete(fullfile(bst_get('UserPluginsDir'), sprintf('plugin_%s.json', file_standardize(PlugDesc.Name))), 1); 854 end 855 856 fprintf(1, 'BST> Plugin ''%s'' was removed from ''User defined'' plugins\n', PlugDesc.Name); 857 end 858 859 860 %% ===== CONFIGURE PLUGIN ===== 861 function Configure(PlugDesc) 862 switch (PlugDesc.Name) 863 case 'mff' 864 % Add .jar file to static classpath 865 if ~exist('com.egi.services.mff.api.MFFFactory', 'class') 866 jarList = dir(bst_fullfile(PlugDesc.Path, PlugDesc.SubFolder, 'MFF-*.jar')); 867 jarPath = bst_fullfile(PlugDesc.Path, PlugDesc.SubFolder, jarList(1).name); 868 disp(['BST> Adding to Java classpath: ' jarPath]); 869 warning off 870 javaaddpathstatic(jarPath); 871 javaaddpath(jarPath); 872 warning on 873 end 874 875 case 'nwb' 876 % Add .jar file to static classpath 877 if ~exist('Schema', 'class') 878 jarPath = bst_fullfile(PlugDesc.Path, PlugDesc.SubFolder, 'jar', 'schema.jar'); 879 disp(['BST> Adding to Java classpath: ' jarPath]); 880 warning off 881 javaaddpathstatic(jarPath); 882 javaaddpath(jarPath); 883 warning on 884 schema = Schema(); 885 end 886 % Go to NWB folder 887 curDir = pwd; 888 cd(bst_fullfile(PlugDesc.Path, PlugDesc.SubFolder)); 889 % Generate the NWB Schema (must be executed from the NWB folder) 890 generateCore(); 891 % Restore current directory 892 cd(curDir); 893 end 894 end 895 896 897 %% ===== GET ONLINE VERSION ===== 898 % Get the latest online version of some plugins 899 function [Version, URLzip] = GetVersionOnline(PlugName, URLzip, isCache) 900 global GlobalData; 901 Version = []; 902 % Parse inputs 903 if (nargin < 2) || isempty(URLzip) 904 URLzip = []; 905 end 906 % Use cache by default, to avoid fetching online too many times the same info 907 if (nargin < 3) || isempty(isCache) 908 isCache = 1; 909 end 910 % No internet: skip 911 if ~GlobalData.Program.isInternet 912 return; 913 end 914 % Check for existing plugin cache 915 strCache = [PlugName, '_online_', strrep(date,'-','')]; 916 if isCache && isfield(GlobalData.Program.PluginCache, strCache) && isfield(GlobalData.Program.PluginCache.(strCache), 'Version') 917 Version = GlobalData.Program.PluginCache.(strCache).Version; 918 URLzip = GlobalData.Program.PluginCache.(strCache).URLzip; 919 return; 920 end 921 % Get version online 922 try 923 switch (PlugName) 924 case 'spm12' 925 bst_progress('text', ['Checking latest online version for ' PlugName '...']); 926 disp(['BST> Checking latest online version for ' PlugName '...']); 927 s = bst_webread('http://www.fil.ion.ucl.ac.uk/spm/download/spm12_updates/'); 928 if ~isempty(s) 929 n = regexp(s,'spm12_updates_r(\d.*?)\.zip','tokens','once'); 930 if ~isempty(n) && ~isempty(n{1}) 931 Version = n{1}; 932 end 933 end 934 case 'cat12' 935 bst_progress('text', ['Checking latest online version for ' PlugName '...']); 936 disp(['BST> Checking latest online version for ' PlugName '...']); 937 s = bst_webread('http://www.neuro.uni-jena.de/cat12/'); 938 if ~isempty(s) 939 n = regexp(s,'cat12_r(\d.*?)\.zip','tokens'); 940 if ~isempty(n) 941 Version = max(cellfun(@str2double, [n{:}])); 942 Version = num2str(Version); 943 end 944 end 945 case 'fieldtrip' 946 bst_progress('text', ['Checking latest online version for ' PlugName '...']); 947 disp(['BST> Checking latest online version for ' PlugName '...']); 948 s = bst_webread('https://download.fieldtriptoolbox.org'); 949 if ~isempty(s) 950 n = regexp(s,'fieldtrip-lite-(\d.*?)\.zip','tokens'); 951 if ~isempty(n) 952 Version = max(cellfun(@str2double, [n{:}])); 953 Version = num2str(Version); 954 URLzip = ['https://download.fieldtriptoolbox.org/fieldtrip-lite-' Version '.zip']; 955 end 956 end 957 case 'duneuro' 958 bst_progress('text', ['Checking latest online version for ' PlugName '...']); 959 disp(['BST> Checking latest online version for ' PlugName '...']); 960 str = bst_webread('http://neuroimage.usc.edu/bst/getversion_duneuro.php'); 961 Version = str(1:6); 962 case 'nirstorm' 963 bst_progress('text', ['Checking latest online version for ' PlugName '...']); 964 disp(['BST> Checking latest online version for ' PlugName '...']); 965 str = bst_webread('https://raw.githubusercontent.com/Nirstorm/nirstorm/master/bst_plugin/VERSION'); 966 Version = strtrim(str(9:end)); 967 case 'brainentropy' 968 bst_progress('text', ['Checking latest online version for ' PlugName '...']); 969 disp(['BST> Checking latest online version for ' PlugName '...']); 970 str = bst_webread('https://raw.githubusercontent.com/multifunkim/best-brainstorm/master/best/VERSION.txt'); 971 str = strsplit(str,'\n'); 972 Version = strtrim(str{1}); 973 otherwise 974 % If downloading from github: Get last GitHub commit SHA 975 if isGithubMaster(URLzip) 976 Version = GetGithubCommit(URLzip); 977 else 978 return; 979 end 980 end 981 % Executed only if the version was fetched successfully: Keep cached version 982 GlobalData.Program.PluginCache.(strCache).Version = Version; 983 GlobalData.Program.PluginCache.(strCache).URLzip = URLzip; 984 catch 985 disp(['BST> Error: Could not get online version for plugin: ' PlugName]); 986 end 987 end 988 989 990 %% ===== IS GITHUB MASTER ====== 991 % Returns 1 if the URL is a github master/main branch 992 function isMaster = isGithubMaster(URLzip) 993 isMaster = ~isempty(strfind(URLzip, 'https://github.com/')) && (~isempty(strfind(URLzip, 'master.zip')) || ~isempty(strfind(URLzip, 'main.zip'))); 994 end 995 996 997 %% ===== GET GITHUB COMMIT ===== 998 % Get SHA of the GitHub HEAD commit 999 function sha = GetGithubCommit(URLzip) 1000 zipUri = matlab.net.URI(URLzip); 1001 % Primary branch name: master or main 1002 [~, primaryBranch] = bst_fileparts(char(zipUri.Path(end))); 1003 % Default result 1004 sha = ['github-', primaryBranch]; 1005 % Only available after Matlab 2016b (because of matlab.net.http.RequestMessage) 1006 if (bst_get('MatlabVersion') < 901) 1007 return; 1008 end 1009 % Try getting the SHA from the GitHub API 1010 try 1011 % Get GitHub repository path 1012 zipUri = matlab.net.URI(URLzip); 1013 gitUser = char(zipUri.Path(2)); 1014 gitRepo = char(zipUri.Path(3)); 1015 % Request last commit SHA with GitHub API 1016 apiUri = matlab.net.URI(['https://api.github.com/repos/' gitUser '/' gitRepo '/commits/' primaryBranch]); 1017 request = matlab.net.http.RequestMessage; 1018 request = request.addFields(matlab.net.http.HeaderField('Accept', 'application/vnd.github.VERSION.sha')); 1019 r = send(request, apiUri); 1020 sha = char(r.Body.Data); 1021 catch 1022 disp(['BST> Warning: Could not get GitHub version for URL: ' zipUrl]); 1023 end 1024 end 1025 1026 1027 %% ===== COMPARE VERSIONS ===== 1028 % Returns: 0: v1==v2 1029 % -1: v1<v2 1030 % 1: v1>v2 1031 function res = CompareVersions(v1, v2) 1032 % Get numbers 1033 iNum1 = find(ismember(v1, '0123456789')); 1034 iNum2 = find(ismember(v2, '0123456789')); 1035 iDot1 = find(v1 == '.'); 1036 iDot2 = find(v2 == '.'); 1037 % Equality (or one input empty) 1038 if isequal(v1,v2) || isempty(v1) || isempty(v2) 1039 res = 0; 1040 % Only numbers 1041 elseif (length(iNum1) == length(v1)) && (length(iNum2) == length(v2)) 1042 n1 = str2double(v1); 1043 n2 = str2double(v2); 1044 if (n1 > n2) 1045 res = 1; 1046 elseif (n1 < n2) 1047 res = -1; 1048 else 1049 res = 0; 1050 end 1051 % Format '1.2.3' 1052 elseif (~isempty(iDot1) || ~isempty(iDot2)) && ~isempty(iNum1) && ~isempty(iNum2) 1053 % Get subversions 1 1054 split1 = str_split(v1, '.'); 1055 sub1 = []; 1056 for i = 1:length(split1) 1057 t = str2num(split1{i}(ismember(split1{i},'0123456789'))); 1058 if ~isempty(t) 1059 sub1(end+1) = t; 1060 else 1061 break; 1062 end 1063 end 1064 % Get subversions 1 1065 split2 = str_split(v2, '.'); 1066 sub2 = []; 1067 for i = 1:length(split2) 1068 t = str2num(split2{i}(ismember(split2{i},'0123456789'))); 1069 if ~isempty(t) 1070 sub2(end+1) = t; 1071 else 1072 break; 1073 end 1074 end 1075 % Add extra zeros to the shortest (so that "1.2" is higher than "1") 1076 if (length(sub1) < length(sub2)) 1077 tmp = sub1; 1078 sub1 = zeros(size(sub2)); 1079 sub1(1:length(tmp)) = tmp; 1080 elseif (length(sub1) > length(sub2)) 1081 tmp = sub2; 1082 sub2 = zeros(size(sub1)); 1083 sub2(1:length(tmp)) = tmp; 1084 end 1085 % Compare number by number 1086 for i = 1:length(sub1) 1087 if (sub1(i) > sub2(i)) 1088 res = 1; 1089 return; 1090 elseif (sub1(i) < sub2(i)) 1091 res = -1; 1092 return; 1093 else 1094 res = 0; 1095 end 1096 end 1097 % Mixture of numbers and digits: natural sorting of strings 1098 else 1099 [s,I] = sort_nat({v1, v2}); 1100 if (I(1) == 1) 1101 res = -1; 1102 else 1103 res = 1; 1104 end 1105 end 1106 end 1107 1108 1109 %% ===== EXECUTE CALLBACK ===== 1110 function [isOk, errMsg] = ExecuteCallback(PlugDesc, f) 1111 isOk = 0; 1112 errMsg = ''; 1113 if ~isempty(PlugDesc.(f)) 1114 try 1115 if ischar(PlugDesc.(f)) 1116 disp(['BST> Executing callback ' f ': ' PlugDesc.(f)]); 1117 eval(PlugDesc.(f)); 1118 elseif isa(PlugDesc.(f), 'function_handle') 1119 disp(['BST> Executing callback ' f ': ' func2str(PlugDesc.(f))]); 1120 feval(PlugDesc.(f), PlugDesc); 1121 end 1122 catch 1123 errMsg = ['Error executing callback ' f ': ' 10 lasterr]; 1124 return; 1125 end 1126 end 1127 isOk = 1; 1128 end 1129 1130 1131 %% ===== GET INSTALLED PLUGINS ===== 1132 % USAGE: [PlugDesc, SearchPlugs] = bst_plugin('GetInstalled', PlugName/PlugDesc) % Get one installed plugin 1133 % [PlugDesc, SearchPlugs] = bst_plugin('GetInstalled') % Get all installed plugins 1134 function [PlugDesc, SearchPlugs] = GetInstalled(SelPlug) 1135 % Parse inputs 1136 if (nargin < 1) || isempty(SelPlug) 1137 SelPlug = []; 1138 end 1139 1140 % === DEFINE SEARCH LIST === 1141 % Looking for a single plugin 1142 if ~isempty(SelPlug) 1143 SearchPlugs = GetSupported(SelPlug); 1144 % Looking for all supported plugins 1145 else 1146 SearchPlugs = GetSupported(); 1147 end 1148 % Brainstorm plugin folder 1149 UserPluginsDir = bst_get('UserPluginsDir'); 1150 % Custom plugin paths 1151 PluginCustomPath = bst_get('PluginCustomPath'); 1152 % Matlab path 1153 matlabPath = str_split(path, pathsep); 1154 % Compiled distribution 1155 isCompiled = bst_iscompiled(); 1156 1157 % === LOOK FOR SUPPORTED PLUGINS === 1158 % Empty plugin structure 1159 PlugDesc = repmat(db_template('PlugDesc'), 0); 1160 % Look for each plugin in the search list 1161 for iSearch = 1:length(SearchPlugs) 1162 % Compiled: skip plugins that are not available 1163 if isCompiled && (SearchPlugs(iSearch).CompiledStatus == 0) 1164 continue; 1165 end 1166 % Theoretical plugin path 1167 PlugName = SearchPlugs(iSearch).Name; 1168 PlugPath = bst_fullfile(UserPluginsDir, PlugName); 1169 % Check if test function is available in the Matlab path 1170 TestFilePath = GetTestFilePath(SearchPlugs(iSearch)); 1171 % If installed software found in Matlab path 1172 if ~isempty(TestFilePath) 1173 % Register loaded plugin 1174 iPlug = length(PlugDesc) + 1; 1175 PlugDesc(iPlug) = SearchPlugs(iSearch); 1176 PlugDesc(iPlug).isLoaded = 1; 1177 % Check if the file is inside the Brainstorm user folder (where it is supposed to be) => Managed plugin 1178 if ~isempty(strfind(TestFilePath, PlugPath)) 1179 PlugDesc(iPlug).isManaged = 1; 1180 % Process compiled together with Brainstorm 1181 elseif isCompiled && ~isempty(strfind(TestFilePath, ['.brainstorm' filesep 'plugins' filesep PlugName])) 1182 compiledDir = ['.brainstorm' filesep 'plugins' filesep PlugName]; 1183 iPath = strfind(TestFilePath, compiledDir); 1184 PlugPath = [TestFilePath(1:iPath-2), filesep, compiledDir]; 1185 % Otherwise: Custom installation 1186 else 1187 % If the test file was found in a defined subfolder: remove the subfolder from the plugin path 1188 PlugPath = TestFilePath; 1189 for iSub = 1:length(PlugDesc(iPlug).LoadFolders) 1190 subDir = strrep(PlugDesc(iPlug).LoadFolders{iSub}, '/', filesep); 1191 if (length(PlugPath) > length(subDir)) && isequal(PlugPath(end-length(subDir)+1:end), subDir) 1192 PlugPath = PlugPath(1:end - length(subDir) - 1); 1193 break; 1194 end 1195 end 1196 PlugDesc(iPlug).isManaged = 0; 1197 end 1198 PlugDesc(iPlug).Path = PlugPath; 1199 % Plugin installed: Managed by Brainstorm 1200 elseif isdir(PlugPath) && file_exist(bst_fullfile(PlugPath, 'plugin.mat')) 1201 iPlug = length(PlugDesc) + 1; 1202 PlugDesc(iPlug) = SearchPlugs(iSearch); 1203 PlugDesc(iPlug).Path = PlugPath; 1204 PlugDesc(iPlug).isLoaded = 0; 1205 PlugDesc(iPlug).isManaged = 1; 1206 % Plugin installed: Custom path 1207 elseif isfield(PluginCustomPath, PlugName) && ~isempty(PluginCustomPath.(PlugName)) && file_exist(PluginCustomPath.(PlugName)) 1208 iPlug = length(PlugDesc) + 1; 1209 PlugDesc(iPlug) = SearchPlugs(iSearch); 1210 PlugDesc(iPlug).Path = PluginCustomPath.(PlugName); 1211 PlugDesc(iPlug).isLoaded = 0; 1212 PlugDesc(iPlug).isManaged = 0; 1213 end 1214 end 1215 1216 % === LOOK FOR UNREFERENCED PLUGINS === 1217 % Compiled: do not look for unreferenced plugins 1218 if isCompiled 1219 PlugList = []; 1220 % Get a specific unlisted plugin 1221 elseif ~isempty(SelPlug) 1222 % Get plugin name 1223 if ischar(SelPlug) 1224 PlugName = lower(SelPlug); 1225 else 1226 PlugName = SelPlug.Name; 1227 end 1228 % If plugin is already referenced: skip 1229 if ismember(PlugName, {PlugDesc.Name}) 1230 PlugList = []; 1231 % Else: Try to get target plugin as unreferenced 1232 else 1233 PlugList = struct('name', PlugName); 1234 end 1235 % Get all folders in Brainstorm plugins folder 1236 else 1237 PlugList = dir(UserPluginsDir); 1238 end 1239 % Process folders containing a plugin.mat file 1240 for iDir = 1:length(PlugList) 1241 % Ignore entry if plugin name is already in list of documented plugins 1242 PlugName = PlugList(iDir).name; 1243 if ismember(PlugName, {PlugDesc.Name}) 1244 continue; 1245 end 1246 % Process only folders 1247 PlugDir = bst_fullfile(UserPluginsDir, PlugName); 1248 if ~isdir(PlugDir) || (PlugName(1) == '.') 1249 continue; 1250 end 1251 % Process only folders containing a 'plugin.mat' file 1252 PlugMatFile = bst_fullfile(PlugDir, 'plugin.mat'); 1253 if ~file_exist(PlugMatFile) 1254 continue; 1255 end 1256 % If selecting only one plugin 1257 if ~isempty(SelPlug) && ischar(SelPlug) && ~strcmpi(PlugName, SelPlug) 1258 continue; 1259 end 1260 % Add plugin to list 1261 iPlug = length(PlugDesc) + 1; 1262 PlugDesc(iPlug) = GetStruct(PlugList(iDir).name); 1263 PlugDesc(iPlug).Path = PlugDir; 1264 PlugDesc(iPlug).isManaged = 1; 1265 PlugDesc(iPlug).isLoaded = ismember(PlugDir, matlabPath); 1266 end 1267 1268 % === READ PLUGIN.MAT === 1269 for iPlug = 1:length(PlugDesc) 1270 % Try to load the plugin.mat file in the plugin folder 1271 PlugMatFile = bst_fullfile(PlugDesc(iPlug).Path, 'plugin.mat'); 1272 if file_exist(PlugMatFile) 1273 try 1274 PlugMat = load(PlugMatFile); 1275 catch 1276 PlugMat = struct(); 1277 end 1278 % Copy fields 1279 excludedFields = {'Name', 'Path', 'isLoaded', 'isManaged', 'LoadedFcn', 'UnloadedFcn', 'DownloadedFcn', 'InstalledFcn', 'UninstalledFcn'}; 1280 loadFields = setdiff(fieldnames(db_template('PlugDesc')), excludedFields); 1281 for iField = 1:length(loadFields) 1282 if isfield(PlugMat, loadFields{iField}) && ~isempty(PlugMat.(loadFields{iField})) 1283 PlugDesc(iPlug).(loadFields{iField}) = PlugMat.(loadFields{iField}); 1284 end 1285 end 1286 else 1287 PlugDesc(iPlug).URLzip = []; 1288 end 1289 end 1290 end 1291 1292 1293 %% ===== GET DESCRIPTION ===== 1294 % USAGE: [PlugDesc, errMsg] = GetDescription(PlugName/PlugDesc) 1295 function [PlugDesc, errMsg] = GetDescription(PlugName) 1296 % Initialize returned values 1297 errMsg = ''; 1298 PlugDesc = []; 1299 % CALL: GetDescription(PlugDesc) 1300 if isstruct(PlugName) 1301 % Add the missing fields 1302 PlugDesc = struct_copy_fields(PlugName, db_template('PlugDesc'), 0); 1303 % CALL: GetDescription(PlugName) 1304 elseif ischar(PlugName) 1305 % Get supported plugins 1306 AllPlugs = GetSupported(); 1307 % Find plugin in supported plugins 1308 iPlug = find(strcmpi({AllPlugs.Name}, PlugName)); 1309 if isempty(iPlug) 1310 errMsg = ['Unknown plugin: ' PlugName]; 1311 return; 1312 end 1313 % Return found plugin 1314 PlugDesc = AllPlugs(iPlug); 1315 else 1316 errMsg = 'Invalid call to GetDescription().'; 1317 end 1318 end 1319 1320 1321 %% ===== GET TEST FILE PATH ===== 1322 function TestFilePath = GetTestFilePath(PlugDesc) 1323 % If a test file is defined 1324 if ~isempty(PlugDesc.TestFile) 1325 % Try to find the test function in the path 1326 whichTest = which(PlugDesc.TestFile); 1327 % If it was found: use the parent folder 1328 if ~isempty(whichTest) 1329 % Get the test file path 1330 TestFilePath = bst_fileparts(whichTest); 1331 % FieldTrip: Ignore if found embedded in SPM12 1332 if strcmpi(PlugDesc.Name, 'fieldtrip') 1333 p = which('spm.m'); 1334 if ~isempty(p) && ~isempty(strfind(TestFilePath, bst_fileparts(p))) 1335 TestFilePath = []; 1336 end 1337 % SPM12: Ignore if found embedded in ROAST 1338 elseif strcmpi(PlugDesc.Name, 'spm12') 1339 p = which('roast.m'); 1340 if ~isempty(p) && ~isempty(strfind(TestFilePath, bst_fileparts(p))) 1341 TestFilePath = []; 1342 end 1343 % Iso2mesh: Ignore if found embedded in ROAST 1344 elseif strcmpi(PlugDesc.Name, 'iso2mesh') 1345 p = which('roast.m'); 1346 if ~isempty(p) && ~isempty(strfind(TestFilePath, bst_fileparts(p))) 1347 TestFilePath = []; 1348 end 1349 end 1350 else 1351 TestFilePath = []; 1352 end 1353 else 1354 TestFilePath = []; 1355 end 1356 end 1357 1358 1359 %% ===== GET README FILE ==== 1360 % Get full path to the readme file 1361 function ReadmeFile = GetReadmeFile(PlugDesc) 1362 ReadmeFile = []; 1363 % If readme file is defined in the plugin structure 1364 if ~isempty(PlugDesc.ReadmeFile) 1365 % If full path already set: use it 1366 if file_exist(PlugDesc.ReadmeFile) 1367 ReadmeFile = PlugDesc.ReadmeFile; 1368 % Else: check in the plugin Path/SubFolder 1369 else 1370 tmpFile = bst_fullfile(PlugDesc.Path, PlugDesc.ReadmeFile); 1371 if file_exist(tmpFile) 1372 ReadmeFile = tmpFile; 1373 elseif ~isempty(PlugDesc.SubFolder) 1374 tmpFile = bst_fullfile(PlugDesc.Path, PlugDesc.SubFolder, PlugDesc.ReadmeFile); 1375 if file_exist(tmpFile) 1376 ReadmeFile = tmpFile; 1377 end 1378 end 1379 end 1380 end 1381 % Search for default readme 1382 if isempty(ReadmeFile) 1383 tmpFile = bst_fullfile(bst_get('BrainstormDocDir'), 'plugins', [PlugDesc.Name '_readme.txt']); 1384 if file_exist(tmpFile) 1385 ReadmeFile = tmpFile; 1386 end 1387 end 1388 end 1389 1390 1391 %% ===== GET LOGO FILE ==== 1392 % Get full path to the logo file 1393 function LogoFile = GetLogoFile(PlugDesc) 1394 LogoFile = []; 1395 % If logo file is defined in the plugin structure 1396 if ~isempty(PlugDesc.LogoFile) 1397 % If full path already set: use it 1398 if file_exist(PlugDesc.LogoFile) 1399 LogoFile = PlugDesc.LogoFile; 1400 % Else: check in the plugin Path/SubFolder 1401 else 1402 tmpFile = bst_fullfile(PlugDesc.Path, PlugDesc.LogoFile); 1403 if file_exist(tmpFile) 1404 LogoFile = tmpFile; 1405 elseif ~isempty(PlugDesc.SubFolder) 1406 tmpFile = bst_fullfile(PlugDesc.Path, PlugDesc.SubFolder, PlugDesc.LogoFile); 1407 if file_exist(tmpFile) 1408 LogoFile = tmpFile; 1409 end 1410 end 1411 end 1412 end 1413 % Search for default logo 1414 if isempty(LogoFile) 1415 tmpFile = bst_fullfile(bst_get('BrainstormDocDir'), 'plugins', [PlugDesc.Name '_logo.gif']); 1416 if file_exist(tmpFile) 1417 LogoFile = tmpFile; 1418 end 1419 end 1420 if isempty(LogoFile) 1421 tmpFile = bst_fullfile(bst_get('BrainstormDocDir'), 'plugins', [PlugDesc.Name '_logo.png']); 1422 if file_exist(tmpFile) 1423 LogoFile = tmpFile; 1424 end 1425 end 1426 end 1427 1428 1429 %% ===== INSTALL ===== 1430 % USAGE: [isOk, errMsg, PlugDesc] = bst_plugin('Install', PlugName, isInteractive=0, minVersion=[]) 1431 function [isOk, errMsg, PlugDesc] = Install(PlugName, isInteractive, minVersion) 1432 % Returned variables 1433 isOk = 0; 1434 % Parse inputs 1435 if (nargin < 3) || isempty(minVersion) 1436 minVersion = []; 1437 elseif isnumeric(minVersion) 1438 minVersion = num2str(minVersion); 1439 end 1440 if (nargin < 2) || isempty(isInteractive) 1441 isInteractive = 0; 1442 end 1443 if ~ischar(PlugName) 1444 errMsg = 'Invalid call to Install()'; 1445 PlugDesc = []; 1446 return; 1447 end 1448 % Get plugin structure from name 1449 [PlugDesc, errMsg] = GetDescription(PlugName); 1450 if ~isempty(errMsg) 1451 return; 1452 end 1453 % Check if plugin is supported on Apple silicon 1454 OsType = bst_get('OsType', 0); 1455 if strcmpi(OsType, 'mac64arm') && ismember(PlugName, PluginsNotSupportAppleSilicon()) 1456 errMsg = ['Plugin ', PlugName ' is not supported on Apple silicon yet.']; 1457 PlugDesc = []; 1458 return; 1459 end 1460 % Check if there is a URL to download 1461 if isempty(PlugDesc.URLzip) 1462 errMsg = ['No download URL for ', OsType, ': ', PlugName '']; 1463 return; 1464 end 1465 % Compiled version 1466 isCompiled = bst_iscompiled(); 1467 if isCompiled && (PlugDesc.CompiledStatus == 0) 1468 errMsg = ['Plugin ', PlugName ' is not available in the compiled version of Brainstorm.']; 1469 return; 1470 end 1471 % Minimum Matlab version 1472 if ~isempty(PlugDesc.MinMatlabVer) && (PlugDesc.MinMatlabVer > 0) && (bst_get('MatlabVersion') < PlugDesc.MinMatlabVer) 1473 strMinVer = sprintf('%d.%d', ceil(PlugDesc.MinMatlabVer / 100), mod(PlugDesc.MinMatlabVer, 100)); 1474 errMsg = ['Plugin ', PlugName ' is not supported for versions of Matlab <= ' strMinVer]; 1475 return; 1476 end 1477 % Get online update (use existing cache) 1478 [newVersion, newURLzip] = GetVersionOnline(PlugName, PlugDesc.URLzip, 1); 1479 if ~isempty(newVersion) 1480 PlugDesc.Version = newVersion; 1481 end 1482 if ~isempty(newURLzip) 1483 PlugDesc.URLzip = newURLzip; 1484 end 1485 1486 % === PROCESS DEPENDENCIES === 1487 % Check required plugins 1488 if ~isempty(PlugDesc.RequiredPlugs) 1489 bst_progress('text', ['Processing dependencies for ' PlugName '...']); 1490 disp(['BST> Processing dependencies: ' PlugName ' requires: ' sprintf('%s ', PlugDesc.RequiredPlugs{:,1})]); 1491 % Get the list of plugins that need to be installed 1492 installPlugs = {}; 1493 installVer = {}; 1494 strInstall = ''; 1495 for iPlug = 1:size(PlugDesc.RequiredPlugs,1) 1496 PlugCheck = GetInstalled(PlugDesc.RequiredPlugs{iPlug,1}); 1497 % Plugin not install: Install it 1498 if isempty(PlugCheck) 1499 installPlugs{end+1} = PlugDesc.RequiredPlugs{iPlug,1}; 1500 installVer{end+1} = []; 1501 strInstall = [strInstall, '<B>' installPlugs{end} '</B> ']; 1502 % Plugin installed: check version 1503 elseif (size(PlugDesc.RequiredPlugs,2) == 2) 1504 minVerDep = PlugDesc.RequiredPlugs{iPlug,2}; 1505 if ~isempty(minVerDep) && (CompareVersions(minVerDep, PlugCheck.Version) > 0) 1506 installPlugs{end+1} = PlugDesc.RequiredPlugs{iPlug,1}; 1507 installVer{end+1} = PlugDesc.RequiredPlugs{iPlug,2}; 1508 strInstall = [strInstall, '<B>' installPlugs{end} '</B>(' installVer{end} ') ']; 1509 end 1510 end 1511 end 1512 % If there are plugins to install 1513 if ~isempty(installPlugs) 1514 if isInteractive 1515 java_dialog('msgbox', ['<HTML>Plugin <B>' PlugName '</B> requires: ' strInstall ... 1516 '<BR><BR>Brainstorm will now install these plugins.' 10 10], 'Plugin manager'); 1517 end 1518 for iPlug = 1:length(installPlugs) 1519 [isInstalled, errMsg] = Install(installPlugs{iPlug}, isInteractive, installVer{iPlug}); 1520 if ~isInstalled 1521 errMsg = ['Error processing dependency: ' PlugDesc.RequiredPlugs{iPlug,1} 10 errMsg]; 1522 return; 1523 end 1524 end 1525 end 1526 end 1527 1528 % === UPDATE: CHECK PREVIOUS INSTALL === 1529 % Check if installed 1530 OldPlugDesc = GetInstalled(PlugName); 1531 % If already installed 1532 if ~isempty(OldPlugDesc) 1533 % If the plugin is not managed by Brainstorm: do not check versions 1534 if ~OldPlugDesc.isManaged 1535 isUpdate = 0; 1536 % If the requested version is higher 1537 elseif ~isempty(minVersion) && (CompareVersions(minVersion, OldPlugDesc.Version) > 0) 1538 isUpdate = 1; 1539 strUpdate = ['the installed version is outdated.<BR>Minimum version required: <I>' minVersion '</I>']; 1540 % If an update is available and auto-updates are requested 1541 elseif (PlugDesc.AutoUpdate == 1) && bst_get('AutoUpdates') && ... % If updates are enabled 1542 ((isGithubMaster(PlugDesc.URLzip) && ~strcmpi(PlugDesc.Version, OldPlugDesc.Version)) || ... % GitHub-master: update if different commit SHA strings 1543 (~isGithubMaster(PlugDesc.URLzip) && (CompareVersions(PlugDesc.Version, OldPlugDesc.Version) > 0))) % Regular stable version: update if online version is newer 1544 isUpdate = 1; 1545 strUpdate = 'an update is available online.'; 1546 else 1547 isUpdate = 0; 1548 end 1549 % Update plugin 1550 if isUpdate 1551 % Compare versions 1552 strCompare = ['<FONT color="#707070">' ... 1553 'Old version :     <I>' OldPlugDesc.Version '</I><BR>' ... 1554 'New version :   <I>' PlugDesc.Version '</I></FONT><BR><BR>']; 1555 % Ask user for updating 1556 if isInteractive 1557 isConfirm = java_dialog('confirm', ... 1558 ['<HTML>Plugin <B>' PlugName '</B>: ' strUpdate '<BR>' ... 1559 'Download and install the latest version?<BR><BR>' strCompare], 'Plugin manager'); 1560 % If update not confirmed: simply load the existing plugin 1561 if ~isConfirm 1562 [isOk, errMsg, PlugDesc] = Load(PlugDesc); 1563 return; 1564 end 1565 end 1566 disp(['BST> Plugin ' PlugName ' is outdated and will be updated.']); 1567 % Uninstall existing plugin 1568 [isOk, errMsg] = Uninstall(PlugName, 0, 0); 1569 if ~isOk 1570 errMsg = ['An error occurred while updating plugin ' PlugName ':' 10 10 errMsg 10]; 1571 return; 1572 end 1573 1574 % No update: Load existing plugin and return 1575 else 1576 % Load plugin 1577 if ~OldPlugDesc.isLoaded 1578 [isLoaded, errMsg, PlugDesc] = Load(OldPlugDesc); 1579 if ~isLoaded 1580 errMsg = ['Could not load plugin ' PlugName ':' 10 errMsg]; 1581 return; 1582 end 1583 else 1584 disp(['BST> Plugin ' PlugName ' already loaded: ' OldPlugDesc.Path]); 1585 end 1586 % Return old plugin 1587 PlugDesc = OldPlugDesc; 1588 isOk = 1; 1589 return; 1590 end 1591 else 1592 % Get user confirmation 1593 if isInteractive 1594 if ~isempty(PlugDesc.Version) && ~isequal(PlugDesc.Version, 'github-master') && ~isequal(PlugDesc.Version, 'latest') 1595 strVer = ['<FONT color="#707070">Latest version: ' PlugDesc.Version '</FONT><BR><BR>']; 1596 else 1597 strVer = ''; 1598 end 1599 isConfirm = java_dialog('confirm', ... 1600 ['<HTML>Plugin <B>' PlugName '</B> is not installed on your computer.<BR>' ... 1601 '<B>Download</B> the latest version of ' PlugName ' now?<BR><BR>' ... 1602 strVer, ... 1603 '<FONT color="#707070">If this program is available on your computer,<BR>' ... 1604 'cancel this installation and use the menu: Plugins > <BR>' ... 1605 PlugName ' > Custom install > Set installation folder.</FONT><BR><BR>'], 'Plugin manager'); 1606 if ~isConfirm 1607 errMsg = 'Installation aborted by user.'; 1608 return; 1609 end 1610 end 1611 end 1612 1613 % === INSTALL PLUGIN === 1614 bst_progress('text', ['Installing plugin ' PlugName '...']); 1615 % Managed plugin folder 1616 PlugPath = bst_fullfile(bst_get('UserPluginsDir'), PlugName); 1617 % Delete existing folder 1618 if isdir(PlugPath) 1619 file_delete(PlugPath, 1, 3); 1620 end 1621 % Create folder 1622 if ~isdir(PlugPath) 1623 res = mkdir(PlugPath); 1624 if ~res 1625 errMsg = ['Error: Cannot create folder' 10 PlugPath]; 1626 return 1627 end 1628 end 1629 % Setting progressbar image 1630 LogoFile = GetLogoFile(PlugDesc); 1631 if ~isempty(LogoFile) 1632 bst_progress('setimage', LogoFile); 1633 end 1634 % Get package file format 1635 if strcmpi(PlugDesc.URLzip(end-3:end), '.zip') 1636 pkgFormat = 'zip'; 1637 elseif strcmpi(PlugDesc.URLzip(end-6:end), '.tar.gz') || strcmpi(PlugDesc.URLzip(end-3:end), '.tgz') 1638 pkgFormat = 'tgz'; 1639 else 1640 disp('BST> Could not guess file format, trying ZIP...'); 1641 pkgFormat = 'zip'; 1642 end 1643 % Download file 1644 pkgFile = bst_fullfile(PlugPath, ['plugin.' pkgFormat]); 1645 disp(['BST> Downloading URL : ' PlugDesc.URLzip]); 1646 disp(['BST> Saving to file : ' pkgFile]); 1647 errMsg = gui_brainstorm('DownloadFile', PlugDesc.URLzip, pkgFile, ['Download plugin: ' PlugName], LogoFile); 1648 % If file was not downloaded correctly 1649 if ~isempty(errMsg) 1650 errMsg = ['Impossible to download ' PlugName ' automatically:' 10 errMsg]; 1651 if ~isCompiled 1652 errMsg = [errMsg 10 10 ... 1653 'Alternative download solution:' 10 ... 1654 '1) Copy the URL below from the Matlab command window: ' 10 ... 1655 ' ' PlugDesc.URLzip 10 ... 1656 '2) Paste it in a web browser' 10 ... 1657 '3) Save the file and unzip it' 10 ... 1658 '4) Add to the Matlab path the folder containing ' PlugDesc.TestFile '.']; 1659 end 1660 bst_progress('removeimage'); 1661 return; 1662 end 1663 % Update progress bar 1664 bst_progress('text', ['Installing plugin: ' PlugName '...']); 1665 if ~isempty(LogoFile) 1666 bst_progress('setimage', LogoFile); 1667 end 1668 % Unzip file 1669 switch (pkgFormat) 1670 case 'zip' 1671 bst_unzip(pkgFile, PlugPath); 1672 case 'tgz' 1673 if ispc 1674 untar(pkgFile, PlugPath); 1675 else 1676 curdir = pwd; 1677 cd(PlugPath); 1678 system(['tar -xf ' pkgFile]); 1679 cd(curdir); 1680 end 1681 end 1682 file_delete(pkgFile, 1, 3); 1683 1684 % === SAVE PLUGIN.MAT === 1685 PlugDesc.Path = PlugPath; 1686 PlugMatFile = bst_fullfile(PlugDesc.Path, 'plugin.mat'); 1687 excludedFields = {'LoadedFcn', 'UnloadedFcn', 'DownloadedFcn', 'InstalledFcn', 'UninstalledFcn', 'Path', 'isLoaded', 'isManaged'}; 1688 PlugDescSave = rmfield(PlugDesc, excludedFields); 1689 bst_save(PlugMatFile, PlugDescSave, 'v6'); 1690 1691 % === CALLBACK: POST-DOWNLOADED === 1692 [isOk, errMsg] = ExecuteCallback(PlugDesc, 'DownloadedFcn'); 1693 if ~isOk 1694 return; 1695 end 1696 1697 % === LOAD PLUGIN === 1698 % Load plugin 1699 [isOk, errMsg, PlugDesc] = Load(PlugDesc); 1700 if ~isOk 1701 bst_progress('removeimage'); 1702 return; 1703 end 1704 % Update plugin description after first load, and delete unwanted files 1705 [isOk, errMsg, PlugDesc] = UpdateDescription(PlugDesc, 1); 1706 if ~isOk 1707 return; 1708 end 1709 1710 % === SHOW PLUGIN INFO === 1711 % Log install 1712 bst_webread(['http://neuroimage.usc.edu/bst/pluglog.php?c=K8Yda7B&plugname=' PlugDesc.Name '&action=install']); 1713 % Show plugin information (interactive mode only) 1714 if isInteractive 1715 % Hide progress bar 1716 isProgress = bst_progress('isVisible'); 1717 if isProgress 1718 bst_progress('hide'); 1719 end 1720 % Message box: aknowledgements 1721 java_dialog('msgbox', ['<HTML>Plugin <B>' PlugName '</B> was sucessfully installed.<BR><BR>' ... 1722 'This software is not distributed by the Brainstorm developers.<BR>' ... 1723 'Please take a few minutes to read the license information,<BR>' ... 1724 'check the authors'' website and register online if recommended.<BR><BR>' ... 1725 '<B>Cite the authors</B> in your publications if you are using their software.<BR><BR>'], 'Plugin manager'); 1726 % Show the readme file 1727 if ~isempty(PlugDesc.ReadmeFile) 1728 view_text(PlugDesc.ReadmeFile, ['Installed plugin: ' PlugName], 1, 1); 1729 end 1730 % Open the website 1731 if ~isempty(PlugDesc.URLinfo) 1732 web(PlugDesc.URLinfo, '-browser') 1733 end 1734 % Restore progress bar 1735 if isProgress 1736 bst_progress('show'); 1737 end 1738 end 1739 % Remove logo 1740 bst_progress('removeimage'); 1741 % Return success 1742 isOk = 1; 1743 end 1744 1745 1746 %% ===== UPDATE DESCRIPTION ===== 1747 % USAGE: [isOk, errMsg, PlugDesc] = bst_plugin('UpdateDescription', PlugDesc, doDelete=0) 1748 function [isOk, errMsg, PlugDesc] = UpdateDescription(PlugDesc, doDelete) 1749 isOk = 1; 1750 errMsg = ''; 1751 PlugPath = PlugDesc.Path; 1752 PlugName = PlugDesc.Name; 1753 1754 if nargin < 2 1755 doDelete = 0; 1756 end 1757 1758 % Plug in needs to be installed 1759 if isempty(bst_plugin('GetInstalled', PlugDesc.Name)) 1760 isOk = 0; 1761 errMsg = ['Cannot update description, plugin ''' PlugDesc.Name ''' needs to be installed']; 1762 return 1763 end 1764 1765 % === DELETE UNWANTED FILES === 1766 if doDelete && ~isempty(PlugDesc.DeleteFiles) && iscell(PlugDesc.DeleteFiles) 1767 warning('off', 'MATLAB:RMDIR:RemovedFromPath'); 1768 for iDel = 1:length(PlugDesc.DeleteFiles) 1769 if ~isempty(PlugDesc.SubFolder) 1770 fileDel = bst_fullfile(PlugDesc.Path, PlugDesc.SubFolder, PlugDesc.DeleteFiles{iDel}); 1771 else 1772 fileDel = bst_fullfile(PlugDesc.Path, PlugDesc.DeleteFiles{iDel}); 1773 end 1774 if file_exist(fileDel) 1775 try 1776 file_delete(fileDel, 1, 3); 1777 catch 1778 disp(['BST> Plugin ' PlugName ': Could not delete file: ' PlugDesc.DeleteFiles{iDel}]); 1779 end 1780 else 1781 disp(['BST> Plugin ' PlugName ': Missing file: ' PlugDesc.DeleteFiles{iDel}]); 1782 end 1783 end 1784 warning('on', 'MATLAB:RMDIR:RemovedFromPath'); 1785 end 1786 1787 % === SEARCH PROCESSES === 1788 % Look for process_* functions in the process folder 1789 PlugProc = file_find(PlugPath, 'process_*.m', Inf, 0); 1790 if ~isempty(PlugProc) 1791 % Remove absolute path: use only path relative to the plugin Path 1792 PlugDesc.Processes = cellfun(@(c)file_win2unix(strrep(c, [PlugPath, filesep], '')), PlugProc, 'UniformOutput', 0); 1793 end 1794 1795 % === SAVE PLUGIN.MAT === 1796 % Save installation date 1797 c = clock(); 1798 PlugDesc.InstallDate = datestr(datenum(c(1), c(2), c(3), c(4), c(5), c(6)), 'dd-mmm-yyyy HH:MM:SS'); 1799 % Get readme and logo 1800 PlugDesc.ReadmeFile = GetReadmeFile(PlugDesc); 1801 PlugDesc.LogoFile = GetLogoFile(PlugDesc); 1802 % Update plugin.mat 1803 excludedFields = {'LoadedFcn', 'UnloadedFcn', 'DownloadedFcn', 'InstalledFcn', 'UninstalledFcn', 'Path', 'isLoaded', 'isManaged'}; 1804 PlugDescSave = rmfield(PlugDesc, excludedFields); 1805 PlugMatFile = bst_fullfile(PlugDesc.Path, 'plugin.mat'); 1806 bst_save(PlugMatFile, PlugDescSave, 'v6'); 1807 1808 % === CALLBACK: POST-INSTALL === 1809 [isOk, errMsg] = ExecuteCallback(PlugDesc, 'InstalledFcn'); 1810 if ~isOk 1811 return; 1812 end 1813 1814 % === GET INSTALLED VERSION === 1815 % Get installed version 1816 if ~isempty(PlugDesc.GetVersionFcn) 1817 testVer = []; 1818 try 1819 if ischar(PlugDesc.GetVersionFcn) 1820 testVer = eval(PlugDesc.GetVersionFcn); 1821 elseif isa(PlugDesc.GetVersionFcn, 'function_handle') 1822 testVer = feval(PlugDesc.GetVersionFcn); 1823 end 1824 catch 1825 disp(['BST> Could not get installed version with callback: ' PlugDesc.GetVersionFcn]); 1826 end 1827 if ~isempty(testVer) 1828 PlugDesc.Version = testVer; 1829 % Update plugin.mat 1830 PlugDescSave.Version = testVer; 1831 bst_save(PlugMatFile, PlugDescSave, 'v6'); 1832 end 1833 end 1834 end 1835 1836 %% ===== INSTALL INTERACTIVE ===== 1837 % USAGE: [isOk, errMsg, PlugDesc] = bst_plugin('InstallInteractive', PlugName) 1838 function [isOk, errMsg, PlugDesc] = InstallInteractive(PlugName) 1839 % Open progress bar 1840 isProgress = bst_progress('isVisible'); 1841 if ~isProgress 1842 bst_progress('start', 'Plugin manager', 'Initialization...'); 1843 end 1844 % Call silent function 1845 [isOk, errMsg, PlugDesc] = Install(PlugName, 1); 1846 % Handle errors 1847 if ~isOk 1848 bst_error(['Installation error:' 10 10 errMsg 10], 'Plugin manager', 0); 1849 elseif ~isempty(errMsg) 1850 java_dialog('msgbox', ['Installation message:' 10 10 errMsg 10], 'Plugin manager'); 1851 end 1852 % Close progress bar 1853 if ~isProgress 1854 bst_progress('stop'); 1855 end 1856 end 1857 1858 1859 %% ===== INSTALL MULTIPLE CHOICE ===== 1860 % If multiple plugins provide the same functions (eg. FieldTrip and SPM): make sure at least one is installed 1861 % USAGE: [isOk, errMsg, PlugDesc] = bst_plugin('InstallMultipleChoice', PlugNames, isInteractive) 1862 function [isOk, errMsg, PlugDesc] = InstallMultipleChoice(PlugNames, isInteractive) 1863 % Check if one of the plugins is loaded 1864 for iPlug = 1:length(PlugNames) 1865 PlugInst = GetInstalled(PlugNames{iPlug}); 1866 if ~isempty(PlugInst) 1867 [isOk, errMsg, PlugDesc] = Load(PlugNames{iPlug}); 1868 if isOk 1869 return; 1870 end 1871 end 1872 end 1873 % If no plugin is loaded: Install the first in the list 1874 [isOk, errMsg, PlugDesc] = Install(PlugNames{1}, isInteractive); 1875 end 1876 1877 1878 %% ===== UNINSTALL ===== 1879 % USAGE: [isOk, errMsg] = bst_plugin('Uninstall', PlugName, isInteractive=0, isDependencies=1) 1880 function [isOk, errMsg] = Uninstall(PlugName, isInteractive, isDependencies) 1881 % Returned variables 1882 isOk = 0; 1883 errMsg = ''; 1884 % Parse inputs 1885 if (nargin < 3) || isempty(isDependencies) 1886 isDependencies = 1; 1887 end 1888 if (nargin < 2) || isempty(isInteractive) 1889 isInteractive = 0; 1890 end 1891 if ~ischar(PlugName) 1892 errMsg = 'Invalid call to Uninstall()'; 1893 return; 1894 end 1895 1896 % === CHECK INSTALLATION === 1897 % Get installation 1898 PlugDesc = GetInstalled(PlugName); 1899 % External plugin 1900 if ~isempty(PlugDesc) && ~isequal(PlugDesc.isManaged, 1) 1901 errMsg = ['<HTML>Plugin <B>' PlugName '</B> is not managed by Brainstorm.' 10 'Delete folder manually:' 10 PlugDesc.Path]; 1902 return; 1903 % Plugin not installed: check if folder exists 1904 elseif isempty(PlugDesc) || isempty(PlugDesc.Path) 1905 % Get plugin structure from name 1906 [PlugDesc, errMsg] = GetDescription(PlugName); 1907 if ~isempty(errMsg) 1908 return; 1909 end 1910 % Managed plugin folder 1911 PlugPath = bst_fullfile(bst_get('UserPluginsDir'), PlugName); 1912 else 1913 PlugPath = PlugDesc.Path; 1914 end 1915 % Plugin not installed 1916 if ~file_exist(PlugPath) 1917 errMsg = ['Plugin ' PlugName ' is not installed.']; 1918 return; 1919 end 1920 1921 % === USER CONFIRMATION === 1922 if isInteractive 1923 isConfirm = java_dialog('confirm', ['<HTML>Delete permanently plugin <B>' PlugName '</B>?' 10 10 PlugPath 10 10], 'Plugin manager'); 1924 if ~isConfirm 1925 errMsg = 'Uninstall aborted by user.'; 1926 return; 1927 end 1928 end 1929 1930 % === PROCESS DEPENDENCIES === 1931 % Uninstall dependent plugins 1932 if isDependencies 1933 AllPlugs = GetSupported(); 1934 for iPlug = 1:length(AllPlugs) 1935 if ~isempty(AllPlugs(iPlug).RequiredPlugs) && ismember(PlugDesc.Name, AllPlugs(iPlug).RequiredPlugs(:,1)) 1936 disp(['BST> Uninstalling dependent plugin: ' AllPlugs(iPlug).Name]); 1937 Uninstall(AllPlugs(iPlug).Name, isInteractive); 1938 end 1939 end 1940 end 1941 1942 % === UNLOAD === 1943 if isequal(PlugDesc.isLoaded, 1) 1944 [isUnloaded, errMsgUnload] = Unload(PlugDesc); 1945 if ~isempty(errMsgUnload) 1946 disp(['BST> Error unloading plugin ' PlugName ': ' errMsgUnload]); 1947 end 1948 end 1949 1950 % === UNINSTALL === 1951 disp(['BST> Deleting plugin ' PlugName ': ' PlugPath]); 1952 % Delete plugin folder 1953 isDeleted = file_delete(PlugPath, 1, 3); 1954 if (isDeleted ~= 1) 1955 errMsg = ['Could not delete plugin folder: ' 10 PlugPath 10 10 ... 1956 'There is probably a file in that folder that is currently ' 10 ... 1957 'loaded in Matlab, but that cannot be unloaded dynamically.' 10 10 ... 1958 'Brainstorm will now close Matlab.' 10 ... 1959 'Restart Matlab and install again the plugin.' 10 10]; 1960 if isInteractive 1961 java_dialog('error', errMsg, 'Restart Matlab'); 1962 else 1963 disp([10 10 'BST> ' errMsg]); 1964 end 1965 quit('force'); 1966 end 1967 1968 % === CALLBACK: POST-UNINSTALL === 1969 [isOk, errMsg] = ExecuteCallback(PlugDesc, 'UninstalledFcn'); 1970 if ~isOk 1971 return; 1972 end 1973 1974 % Return success 1975 isOk = 1; 1976 end 1977 1978 1979 %% ===== UNINSTALL INTERACTIVE ===== 1980 % USAGE: [isOk, errMsg] = bst_plugin('UninstallInteractive', PlugName) 1981 function [isOk, errMsg] = UninstallInteractive(PlugName) 1982 % Open progress bar 1983 isProgress = bst_progress('isVisible'); 1984 if ~isProgress 1985 bst_progress('start', 'Plugin manager', 'Initialization...'); 1986 end 1987 % Call silent function 1988 [isOk, errMsg] = Uninstall(PlugName, 1); 1989 % Handle errors 1990 if ~isOk 1991 bst_error(['An error occurred while uninstalling plugin ' PlugName ':' 10 10 errMsg 10], 'Plugin manager', 0); 1992 elseif ~isempty(errMsg) 1993 java_dialog('msgbox', ['Uninstall message:' 10 10 errMsg 10], 'Plugin manager'); 1994 end 1995 % Close progress bar 1996 if ~isProgress 1997 bst_progress('stop'); 1998 end 1999 end 2000 2001 2002 %% ===== UPDATE INTERACTIVE ===== 2003 % USAGE: [isOk, errMsg] = bst_plugin('UpdateInteractive', PlugName) 2004 function [isOk, errMsg] = UpdateInteractive(PlugName) 2005 % Open progress bar 2006 isProgress = bst_progress('isVisible'); 2007 if ~isProgress 2008 bst_progress('start', 'Plugin manager', 'Initialization...'); 2009 end 2010 % Get new plugin 2011 [PlugRef, errMsg] = GetDescription(PlugName); 2012 isOk = isempty(errMsg); 2013 % Get installed plugin 2014 if isOk 2015 PlugInst = GetInstalled(PlugName); 2016 if isempty(PlugInst) || ~PlugInst.isManaged 2017 isOk = 0; 2018 errMsg = ['Plugin ' PlugName ' is not installed or not managed by Brainstorm.']; 2019 end 2020 end 2021 % Get online update (use cache when available) 2022 [newVersion, newURLzip] = GetVersionOnline(PlugName, PlugRef.URLzip, 1); 2023 if ~isempty(newVersion) 2024 PlugRef.Version = newVersion; 2025 end 2026 if ~isempty(newURLzip) 2027 PlugRef.URLzip = newURLzip; 2028 end 2029 % User confirmation 2030 if isOk 2031 isOk = java_dialog('confirm', ['<HTML>Update plugin <B>' PlugName '</B> ?<BR><BR><FONT color="#707070">' ... 2032 'Old version :     <I>' PlugInst.Version '</I><BR>' ... 2033 'New version :   <I>' PlugRef.Version '</I><BR><BR></FONT>'], 'Plugin manager'); 2034 if ~isOk 2035 errMsg = 'Update aborted by user.'; 2036 end 2037 end 2038 % Uninstall old 2039 if isOk 2040 [isOk, errMsg] = Uninstall(PlugName, 0, 0); 2041 end 2042 % Install new 2043 if isOk 2044 [isOk, errMsg, PlugDesc] = Install(PlugName, 0); 2045 else 2046 PlugDesc = []; 2047 end 2048 % Handle errors 2049 if ~isOk 2050 bst_error(['An error occurred while updating plugin ' PlugName ':' 10 10 errMsg 10], 'Plugin manager', 0); 2051 elseif ~isempty(errMsg) 2052 java_dialog('msgbox', ['Update message:' 10 10 errMsg 10], 'Plugin manager'); 2053 end 2054 % Close progress bar 2055 if ~isProgress 2056 bst_progress('stop'); 2057 end 2058 % Plugin was updated successfully 2059 if ~isempty(PlugDesc) 2060 % Show the readme file 2061 if ~isempty(PlugDesc.ReadmeFile) 2062 view_text(PlugDesc.ReadmeFile, ['Installed plugin: ' PlugName], 1, 1); 2063 end 2064 % Open the website 2065 if ~isempty(PlugDesc.URLinfo) 2066 web(PlugDesc.URLinfo, '-browser') 2067 end 2068 end 2069 end 2070 2071 2072 %% ===== LOAD ===== 2073 % USAGE: [isOk, errMsg, PlugDesc] = Load(PlugDesc, isVerbose=1) 2074 function [isOk, errMsg, PlugDesc] = Load(PlugDesc, isVerbose) 2075 % Parse inputs 2076 if (nargin < 2) || isempty(isVerbose) 2077 isVerbose = 1; 2078 end 2079 % Initialize returned variables 2080 isOk = 0; 2081 % Get plugin structure from name 2082 [PlugDesc, errMsg] = GetDescription(PlugDesc); 2083 if ~isempty(errMsg) 2084 return; 2085 end 2086 % Check if plugin is supported on Apple silicon 2087 OsType = bst_get('OsType', 0); 2088 if strcmpi(OsType, 'mac64arm') && ismember(PlugDesc.Name, PluginsNotSupportAppleSilicon()) 2089 errMsg = ['Plugin ', PlugDesc.Name ' is not supported on Apple silicon yet.']; 2090 return; 2091 end 2092 % Minimum Matlab version 2093 if ~isempty(PlugDesc.MinMatlabVer) && (PlugDesc.MinMatlabVer > 0) && (bst_get('MatlabVersion') < PlugDesc.MinMatlabVer) 2094 strMinVer = sprintf('%d.%d', ceil(PlugDesc.MinMatlabVer / 100), mod(PlugDesc.MinMatlabVer, 100)); 2095 errMsg = ['Plugin ', PlugDesc.Name ' is not supported for versions of Matlab <= ' strMinVer]; 2096 return; 2097 end 2098 2099 % === ALREADY LOADED === 2100 % If plugin is already full loaded 2101 if isequal(PlugDesc.isLoaded, 1) && ~isempty(PlugDesc.Path) 2102 if isVerbose 2103 errMsg = ['Plugin ' PlugDesc.Name ' already loaded: ' PlugDesc.Path]; 2104 end 2105 return; 2106 end 2107 % Managed plugin path 2108 PlugPath = bst_fullfile(bst_get('UserPluginsDir'), PlugDesc.Name); 2109 if file_exist(PlugPath) 2110 PlugDesc.isManaged = 1; 2111 % Custom installation 2112 else 2113 PluginCustomPath = bst_get('PluginCustomPath'); 2114 if isfield(PluginCustomPath, PlugDesc.Name) && ~isempty(bst_fullfile(PluginCustomPath.(PlugDesc.Name))) && file_exist(bst_fullfile(PluginCustomPath.(PlugDesc.Name))) 2115 PlugPath = PluginCustomPath.(PlugDesc.Name); 2116 end 2117 PlugDesc.isManaged = 0; 2118 end 2119 % Managed install: Detect if there is a single subfolder containing all the files 2120 if PlugDesc.isManaged && ~isempty(PlugDesc.TestFile) && ~file_exist(bst_fullfile(PlugPath, PlugDesc.TestFile)) 2121 dirList = dir(PlugPath); 2122 for iDir = 1:length(dirList) 2123 % Not folder or . : skip 2124 if (dirList(iDir).name(1) == '.') || ~dirList(iDir).isdir 2125 continue; 2126 end 2127 % Check if test file is in the folder 2128 if file_exist(bst_fullfile(PlugPath, dirList(iDir).name, PlugDesc.TestFile)) 2129 PlugDesc.SubFolder = dirList(iDir).name; 2130 break; 2131 % Otherwise, check in any of the subfolders 2132 elseif ~isempty(PlugDesc.LoadFolders) 2133 for iSubDir = 1:length(PlugDesc.LoadFolders) 2134 if file_exist(bst_fullfile(PlugPath, dirList(iDir).name, PlugDesc.LoadFolders{iSubDir}, PlugDesc.TestFile)) 2135 PlugDesc.SubFolder = dirList(iDir).name; 2136 break; 2137 end 2138 end 2139 end 2140 end 2141 end 2142 % Check if test function already available in the path 2143 TestFilePath = GetTestFilePath(PlugDesc); 2144 if ~isempty(TestFilePath) 2145 PlugDesc.isLoaded = 1; 2146 PlugDesc.isManaged = ~isempty(strfind(which(PlugDesc.TestFile), PlugPath)); 2147 if PlugDesc.isManaged 2148 PlugDesc.Path = PlugPath; 2149 else 2150 PlugDesc.Path = TestFilePath; 2151 end 2152 if isVerbose 2153 disp(['BST> Plugin ' PlugDesc.Name ' already loaded: ' PlugDesc.Path]); 2154 end 2155 isOk = 1; 2156 return; 2157 end 2158 2159 % === CHECK LOADABILITY === 2160 PlugDesc.Path = PlugPath; 2161 if ~file_exist(PlugDesc.Path) 2162 errMsg = ['Plugin ' PlugDesc.Name ' not installed.' 10 'Missing folder: ' PlugDesc.Path]; 2163 return; 2164 end 2165 % Set logo 2166 LogoFile = GetLogoFile(PlugDesc); 2167 if ~isempty(LogoFile) 2168 bst_progress('setimage', LogoFile); 2169 end 2170 2171 % === PROCESS DEPENDENCIES === 2172 % Unload incompatible plugins 2173 if ~isempty(PlugDesc.UnloadPlugs) 2174 for iPlug = 1:length(PlugDesc.UnloadPlugs) 2175 % disp(['BST> Unloading incompatible plugin: ' PlugDesc.UnloadPlugs{iPlug}]); 2176 Unload(PlugDesc.UnloadPlugs{iPlug}, isVerbose); 2177 end 2178 end 2179 % Load required plugins 2180 if ~isempty(PlugDesc.RequiredPlugs) 2181 for iPlug = 1:size(PlugDesc.RequiredPlugs,1) 2182 % disp(['BST> Loading required plugin: ' PlugDesc.RequiredPlugs{iPlug,1}]); 2183 [isOk, errMsg] = Load(PlugDesc.RequiredPlugs{iPlug,1}, isVerbose); 2184 if ~isOk 2185 errMsg = ['Error processing dependencies: ', PlugDesc.Name, 10, errMsg]; 2186 bst_progress('removeimage'); 2187 return; 2188 end 2189 end 2190 end 2191 2192 % === LOAD PLUGIN === 2193 % Add plugin folder to path 2194 if ~isempty(PlugDesc.SubFolder) 2195 PlugHomeDir = bst_fullfile(PlugPath, PlugDesc.SubFolder); 2196 else 2197 PlugHomeDir = PlugPath; 2198 end 2199 % Do not modify path in compiled mode 2200 isCompiled = bst_iscompiled(); 2201 if ~isCompiled 2202 addpath(PlugHomeDir); 2203 if isVerbose 2204 disp(['BST> Adding plugin ' PlugDesc.Name ' to path: ' PlugHomeDir]); 2205 end 2206 % Add specific subfolders to path 2207 if ~isempty(PlugDesc.LoadFolders) 2208 % Load all all subfolders 2209 if isequal(PlugDesc.LoadFolders, '*') || isequal(PlugDesc.LoadFolders, {'*'}) 2210 if isVerbose 2211 disp(['BST> Adding plugin ' PlugDesc.Name ' to path: ', PlugHomeDir, filesep, '*']); 2212 end 2213 addpath(genpath(PlugHomeDir)); 2214 % Load specific subfolders 2215 else 2216 for i = 1:length(PlugDesc.LoadFolders) 2217 subDir = PlugDesc.LoadFolders{i}; 2218 if isequal(filesep, '\') 2219 subDir = strrep(subDir, '/', '\'); 2220 end 2221 if ~isempty(dir([PlugHomeDir, filesep, subDir])) 2222 if isVerbose 2223 disp(['BST> Adding plugin ' PlugDesc.Name ' to path: ', PlugHomeDir, filesep, subDir]); 2224 end 2225 if regexp(subDir, '\*[/\\]*$') 2226 subDir = regexprep(subDir, '\*[/\\]*$', ''); 2227 addpath(genpath([PlugHomeDir, filesep, subDir])); 2228 else 2229 addpath([PlugHomeDir, filesep, subDir]); 2230 end 2231 end 2232 end 2233 end 2234 end 2235 end 2236 2237 % === TEST FUNCTION === 2238 % Check if test function is available on path 2239 if ~isCompiled && ~isempty(PlugDesc.TestFile) && (exist(PlugDesc.TestFile, 'file') == 0) 2240 errMsg = ['Plugin ' PlugDesc.Name ' successfully loaded from:' 10 PlugHomeDir 10 10 ... 2241 'However, the function ' PlugDesc.TestFile ' is not accessible in the Matlab path.' 10 ... 2242 'Try restarting Matlab and Brainstorm.']; 2243 bst_progress('removeimage') 2244 return; 2245 end 2246 2247 % === CALLBACK: POST-LOAD === 2248 [isOk, errMsg] = ExecuteCallback(PlugDesc, 'LoadedFcn'); 2249 2250 % Remove logo 2251 bst_progress('removeimage'); 2252 % Return success 2253 PlugDesc.isLoaded = isOk; 2254 end 2255 2256 2257 %% ===== LOAD INTERACTIVE ===== 2258 % USAGE: [isOk, errMsg, PlugDesc] = LoadInteractive(PlugName/PlugDesc) 2259 function [isOk, errMsg, PlugDesc] = LoadInteractive(PlugDesc) 2260 % Open progress bar 2261 isProgress = bst_progress('isVisible'); 2262 if ~isProgress 2263 bst_progress('start', 'Plugin manager', 'Loading plugin...'); 2264 end 2265 % Call silent function 2266 [isOk, errMsg, PlugDesc] = Load(PlugDesc); 2267 % Handle errors 2268 if ~isOk 2269 bst_error(['Load error:' 10 10 errMsg 10], 'Plugin manager', 0); 2270 elseif ~isempty(errMsg) 2271 java_dialog('msgbox', ['Load message:' 10 10 errMsg 10], 'Plugin manager'); 2272 end 2273 % Close progress bar 2274 if ~isProgress 2275 bst_progress('stop'); 2276 end 2277 end 2278 2279 2280 %% ===== UNLOAD ===== 2281 % USAGE: [isOk, errMsg, PlugDesc] = Unload(PlugName/PlugDesc, isVerbose) 2282 function [isOk, errMsg, PlugDesc] = Unload(PlugDesc, isVerbose) 2283 % Parse inputs 2284 if (nargin < 2) || isempty(isVerbose) 2285 isVerbose = 1; 2286 end 2287 % Initialize returned variables 2288 isOk = 0; 2289 errMsg = ''; 2290 % Get installation 2291 InstPlugDesc = GetInstalled(PlugDesc); 2292 % Plugin not installed: check if folder exists 2293 if isempty(InstPlugDesc) || isempty(InstPlugDesc.Path) 2294 % Get plugin structure from name 2295 [PlugDesc, errMsg] = GetDescription(PlugDesc); 2296 if ~isempty(errMsg) 2297 return; 2298 end 2299 % Managed plugin folder 2300 PlugPath = bst_fullfile(bst_get('UserPluginsDir'), PlugDesc.Name); 2301 else 2302 PlugDesc = InstPlugDesc; 2303 PlugPath = PlugDesc.Path; 2304 end 2305 % Plugin not installed 2306 if ~file_exist(PlugPath) 2307 errMsg = ['Plugin ' PlugDesc.Name ' is not installed.' 10 'Missing folder: ' PlugPath]; 2308 return; 2309 end 2310 % Get plugin structure from name 2311 [PlugDesc, errMsg] = GetDescription(PlugDesc); 2312 if ~isempty(errMsg) 2313 return; 2314 end 2315 2316 % === PROCESS DEPENDENCIES === 2317 % Unload dependent plugins 2318 AllPlugs = GetSupported(); 2319 for iPlug = 1:length(AllPlugs) 2320 if ~isempty(AllPlugs(iPlug).RequiredPlugs) && ismember(PlugDesc.Name, AllPlugs(iPlug).RequiredPlugs(:,1)) 2321 Unload(AllPlugs(iPlug)); 2322 end 2323 end 2324 2325 % === UNLOAD PLUGIN === 2326 % Do not modify path in compiled mode 2327 if ~bst_iscompiled() 2328 matlabPath = str_split(path, pathsep); 2329 % Remove plugin folder and subfolders from path 2330 allSubFolders = str_split(genpath(PlugPath), pathsep); 2331 for i = 1:length(allSubFolders) 2332 if ismember(allSubFolders{i}, matlabPath) 2333 rmpath(allSubFolders{i}); 2334 if isVerbose 2335 disp(['BST> Removing plugin ' PlugDesc.Name ' from path: ' allSubFolders{i}]); 2336 end 2337 end 2338 end 2339 end 2340 2341 % === TEST FUNCTION === 2342 % Check if test function is still available on path 2343 if ~isempty(PlugDesc.TestFile) && ~isempty(which(PlugDesc.TestFile)) 2344 errMsg = ['Plugin ' PlugDesc.Name ' successfully unloaded from: ' 10 PlugPath 10 10 ... 2345 'However, another version is still accessible on the Matlab path:' 10 which(PlugDesc.TestFile) 10 10 ... 2346 'Please remove this folder from the Matlab path.']; 2347 return; 2348 end 2349 2350 % === CALLBACK: POST-UNLOAD === 2351 [isOk, errMsg] = ExecuteCallback(PlugDesc, 'UnloadedFcn'); 2352 if ~isOk 2353 return; 2354 end 2355 2356 % Return success 2357 PlugDesc.isLoaded = 0; 2358 isOk = 1; 2359 end 2360 2361 2362 %% ===== UNLOAD INTERACTIVE ===== 2363 % USAGE: [isOk, errMsg, PlugDesc] = UnloadInteractive(PlugName/PlugDesc) 2364 function [isOk, errMsg, PlugDesc] = UnloadInteractive(PlugDesc) 2365 % Open progress bar 2366 isProgress = bst_progress('isVisible'); 2367 if ~isProgress 2368 bst_progress('start', 'Plugin manager', 'Unloading plugin...'); 2369 end 2370 % Call silent function 2371 [isOk, errMsg, PlugDesc] = Unload(PlugDesc); 2372 % Handle errors 2373 if ~isOk 2374 bst_error(['Unload error:' 10 10 errMsg 10], 'Plugin manager', 0); 2375 elseif ~isempty(errMsg) 2376 java_dialog('msgbox', ['Unload message:' 10 10 errMsg 10], 'Plugin manager'); 2377 end 2378 % Close progress bar 2379 if ~isProgress 2380 bst_progress('stop'); 2381 end 2382 end 2383 2384 2385 %% ===== LIST ===== 2386 % USAGE: strList = bst_plugin('List', Target='installed', isGui=0) % Target={'supported','installed', 'loaded'} 2387 function strList = List(Target, isGui) 2388 % Parse inputs 2389 if (nargin < 2) || isempty(isGui) 2390 isGui = 0; 2391 end 2392 if (nargin < 1) || isempty(Target) 2393 Target = 'Installed'; 2394 else 2395 Target = [upper(Target(1)), lower(Target(2:end))]; 2396 end 2397 % Get plugins to list 2398 strTitle = sprintf('%s plugins', Target); 2399 switch (Target) 2400 case 'Supported' 2401 PlugDesc = GetSupported(); 2402 isInstalled = 0; 2403 case 'Installed' 2404 strTitle = [strTitle ' (*=Loaded)']; 2405 PlugDesc = GetInstalled(); 2406 isInstalled = 1; 2407 case 'Loaded' 2408 PlugDesc = GetInstalled(); 2409 PlugDesc = PlugDesc([PlugDesc.isLoaded] == 1); 2410 isInstalled = 1; 2411 otherwise 2412 error(['Invalid target: ' Target]); 2413 end 2414 if isempty(PlugDesc) 2415 return; 2416 end 2417 % Sort by plugin names 2418 [tmp,I] = sort({PlugDesc.Name}); 2419 PlugDesc = PlugDesc(I); 2420 2421 % Get Brainstorm info 2422 bstVer = bst_get('Version'); 2423 bstDir = bst_get('BrainstormHomeDir'); 2424 % Cut version string (short github SHA) 2425 if (length(bstVer.Commit) > 13) 2426 bstGit = ['git @', bstVer.Commit(1:7)]; 2427 bstURL = ['https://github.com/brainstorm-tools/brainstorm3/archive/' bstVer.Commit '.zip']; 2428 structVer = bstGit; 2429 else 2430 bstGit = ''; 2431 bstURL = ''; 2432 structVer = bstVer.Version; 2433 end 2434 2435 % Max lengths 2436 headerName = ' Name'; 2437 headerVersion = 'Version'; 2438 headerPath = 'Install path'; 2439 headerUrl = 'Downloaded from'; 2440 headerDate = 'Install date'; 2441 maxName = max(cellfun(@length, {PlugDesc.Name, headerName, 'brainstorm'})); 2442 maxVer = min(13, max(cellfun(@length, {PlugDesc.Version, headerVersion, bstGit}))); 2443 maxUrl = max(cellfun(@length, {PlugDesc.URLzip, headerUrl, bstURL})); 2444 maxDate = 12; 2445 if isInstalled 2446 strDate = [' | ', headerDate, repmat(' ', 1, maxDate-length(headerDate))]; 2447 strDateSep = ['-|-', repmat('-',1,maxDate)]; 2448 maxPath = max(cellfun(@length, {PlugDesc.Path, headerPath})); 2449 strPath = [' | ', headerPath, repmat(' ', 1, maxPath-length(headerPath))]; 2450 strPathSep = ['-|-', repmat('-',1,maxPath)]; 2451 strBstVer = [' | ', bstVer.Date, repmat(' ', 1, maxDate-length(bstVer.Date))]; 2452 strBstDir = [' | ', bstDir, repmat(' ', 1, maxPath-length(bstDir))]; 2453 else 2454 strDate = ''; 2455 strDateSep = ''; 2456 strPath = ''; 2457 strPathSep = ''; 2458 strBstVer = ''; 2459 strBstDir = ''; 2460 end 2461 % Print column headers 2462 strList = [headerName, repmat(' ', 1, maxName-length(headerName) + 2) ... 2463 ' | ', headerVersion, repmat(' ', 1, maxVer-length(headerVersion)), ... 2464 strDate, strPath, ... 2465 ' | ' headerUrl 10 ... 2466 repmat('-',1,maxName + 2), '-|-', repmat('-',1,maxVer), strDateSep, strPathSep, '-|-', repmat('-',1,maxUrl) 10]; 2467 2468 % Print Brainstorm information 2469 strList = [strList '* ', ... 2470 'brainstorm', repmat(' ', 1, maxName-length('brainstorm')) ... 2471 ' | ', bstGit, repmat(' ', 1, maxVer-length(bstGit)), ... 2472 strBstVer, strBstDir, ... 2473 ' | ' bstURL 10]; 2474 2475 % Print installed plugins to standard output 2476 for iPlug = 1:length(PlugDesc) 2477 % Loaded plugin 2478 if PlugDesc(iPlug).isLoaded 2479 strLoaded = '* '; 2480 else 2481 strLoaded = ' '; 2482 end 2483 % Cut installation date: Only date, no time 2484 if (length(PlugDesc(iPlug).InstallDate) > 11) 2485 plugDate = PlugDesc(iPlug).InstallDate(1:11); 2486 else 2487 plugDate = PlugDesc(iPlug).InstallDate; 2488 end 2489 % Installed listing 2490 if isInstalled 2491 strDate = [' | ', plugDate, repmat(' ', 1, maxDate-length(plugDate))]; 2492 strPath = [' | ', PlugDesc(iPlug).Path, repmat(' ', 1, maxPath-length(PlugDesc(iPlug).Path))]; 2493 else 2494 strDate = ''; 2495 strPath = ''; 2496 end 2497 % Get installed version 2498 if (length(PlugDesc(iPlug).Version) > 13) % Cut version string (short github SHA) 2499 plugVer = ['git @', PlugDesc(iPlug).Version(1:7)]; 2500 else 2501 plugVer = PlugDesc(iPlug).Version; 2502 end 2503 % Get installed version with GetVersionFcn 2504 if isempty(plugVer) && isfield(PlugDesc(iPlug),'GetVersionFcn') && ~isempty(PlugDesc(iPlug).GetVersionFcn) 2505 % Load plugin if needed 2506 tmpLoad = 0; 2507 if ~PlugDesc(iPlug).isLoaded 2508 tmpLoad = 1; 2509 Load(PlugDesc(iPlug), 0); 2510 end 2511 try 2512 if ischar(PlugDesc(iPlug).GetVersionFcn) 2513 plugVer = eval(PlugDesc(iPlug).GetVersionFcn); 2514 elseif isa(PlugDesc(iPlug).GetVersionFcn, 'function_handle') 2515 plugVer = feval(PlugDesc(iPlug).GetVersionFcn); 2516 end 2517 catch 2518 disp(['BST> Could not get installed version with callback: ' PlugDesc(iPlug).GetVersionFcn]); 2519 end 2520 % Unload plugin 2521 if tmpLoad 2522 Unload(PlugDesc(iPlug), 0); 2523 end 2524 end 2525 % Assemble plugin text row 2526 strList = [strList strLoaded, ... 2527 PlugDesc(iPlug).Name, repmat(' ', 1, maxName-length(PlugDesc(iPlug).Name)) ... 2528 ' | ', plugVer, repmat(' ', 1, maxVer-length(plugVer)), ... 2529 strDate, strPath, ... 2530 ' | ' PlugDesc(iPlug).URLzip 10]; 2531 end 2532 % Display output 2533 if isGui 2534 view_text(strList, strTitle); 2535 % No string returned: display it in the command window 2536 elseif (nargout == 0) 2537 disp([10 strTitle 10 10 strList]); 2538 end 2539 end 2540 2541 2542 %% ===== MENUS: CREATE ===== 2543 function j = MenuCreate(jMenu, jPlugsPrev, fontSize) 2544 import org.brainstorm.icon.*; 2545 % Get all the supported plugins 2546 PlugDesc = GetSupported(); 2547 % Get Matlab version 2548 MatlabVersion = bst_get('MatlabVersion'); 2549 isCompiled = bst_iscompiled(); 2550 % Submenus array 2551 jSub = {}; 2552 % Generate submenus array from existing menu 2553 if ~isCompiled && jMenu.getMenuComponentCount > 0 2554 for iItem = 0 : jMenu.getItemCount-1 2555 if ~isempty(regexp(jMenu.getMenuComponent(iItem).class, 'JMenu$', 'once')) 2556 jSub(end+1,1:2) = {char(jMenu.getMenuComponent(iItem).getText), jMenu.getMenuComponent(iItem)}; 2557 end 2558 end 2559 end 2560 % Editing an existing menu? 2561 if isempty(jPlugsPrev) 2562 isNewMenu = 1; 2563 j = repmat(struct(), 0); 2564 else 2565 isNewMenu = 0; 2566 j = repmat(jPlugsPrev(1), 0); 2567 end 2568 % Process each plugin 2569 for iPlug = 1:length(PlugDesc) 2570 Plug = PlugDesc(iPlug); 2571 % Skip if Matlab is too old 2572 if ~isempty(Plug.MinMatlabVer) && (Plug.MinMatlabVer > 0) && (MatlabVersion < Plug.MinMatlabVer) 2573 continue; 2574 end 2575 % Skip if not supported in compiled version 2576 if isCompiled && (Plug.CompiledStatus == 0) 2577 continue; 2578 end 2579 % === Add menus for each plugin === 2580 % One menu per plugin 2581 ij = length(j) + 1; 2582 j(ij).name = Plug.Name; 2583 % Skip if it is already a menu item 2584 if ~isNewMenu 2585 iPlugPrev = ismember({jPlugsPrev.name}, Plug.Name); 2586 if any(iPlugPrev) 2587 j(ij) = jPlugsPrev(iPlugPrev); 2588 continue 2589 end 2590 end 2591 % Category=submenu 2592 if ~isempty(Plug.Category) 2593 if isempty(jSub) || ~ismember(Plug.Category, jSub(:,1)) 2594 jParent = gui_component('Menu', jMenu, [], Plug.Category, IconLoader.ICON_FOLDER_OPEN, [], [], fontSize); 2595 jSub(end+1,1:2) = {Plug.Category, jParent}; 2596 else 2597 iSub = find(strcmpi(jSub(:,1), Plug.Category)); 2598 jParent = jSub{iSub,2}; 2599 end 2600 else 2601 jParent = jMenu; 2602 end 2603 % Compiled and included: Simple static menu 2604 if isCompiled && (Plug.CompiledStatus == 2) 2605 j(ij).menu = gui_component('MenuItem', jParent, [], Plug.Name, [], [], [], fontSize); 2606 % Do not create submenus for compiled version 2607 else 2608 % Main menu 2609 j(ij).menu = gui_component('Menu', jParent, [], Plug.Name, [], [], [], fontSize); 2610 % Version 2611 j(ij).version = gui_component('MenuItem', j(ij).menu, [], 'Version', [], [], [], fontSize); 2612 j(ij).versep = java_create('javax.swing.JSeparator'); 2613 j(ij).menu.add(j(ij).versep); 2614 % Install 2615 j(ij).install = gui_component('MenuItem', j(ij).menu, [], 'Install', IconLoader.ICON_DOWNLOAD, [], @(h,ev)InstallInteractive(Plug.Name), fontSize); 2616 % Update 2617 j(ij).update = gui_component('MenuItem', j(ij).menu, [], 'Update', IconLoader.ICON_RELOAD, [], @(h,ev)UpdateInteractive(Plug.Name), fontSize); 2618 % Uninstall 2619 j(ij).uninstall = gui_component('MenuItem', j(ij).menu, [], 'Uninstall', IconLoader.ICON_DELETE, [], @(h,ev)UninstallInteractive(Plug.Name), fontSize); 2620 j(ij).menu.addSeparator(); 2621 % Custom install 2622 j(ij).custom = gui_component('Menu', j(ij).menu, [], 'Custom install', IconLoader.ICON_FOLDER_OPEN, [], [], fontSize); 2623 j(ij).customset = gui_component('MenuItem', j(ij).custom, [], 'Select installation folder', [], [], @(h,ev)SetCustomPath(Plug.Name), fontSize); 2624 j(ij).custompath = gui_component('MenuItem', j(ij).custom, [], 'Path not set', [], [], [], fontSize); 2625 j(ij).custompath.setEnabled(0); 2626 j(ij).custom.addSeparator(); 2627 j(ij).customdel = gui_component('MenuItem', j(ij).custom, [], 'Ignore local installation', [], [], @(h,ev)SetCustomPath(Plug.Name, 0), fontSize); 2628 j(ij).menu.addSeparator(); 2629 % Load 2630 j(ij).load = gui_component('MenuItem', j(ij).menu, [], 'Load', IconLoader.ICON_GOOD, [], @(h,ev)LoadInteractive(Plug.Name), fontSize); 2631 j(ij).unload = gui_component('MenuItem', j(ij).menu, [], 'Unload', IconLoader.ICON_BAD, [], @(h,ev)UnloadInteractive(Plug.Name), fontSize); 2632 j(ij).menu.addSeparator(); 2633 % Website 2634 j(ij).web = gui_component('MenuItem', j(ij).menu, [], 'Website', IconLoader.ICON_EXPLORER, [], @(h,ev)web(Plug.URLinfo, '-browser'), fontSize); 2635 j(ij).usage = gui_component('MenuItem', j(ij).menu, [], 'Usage statistics', IconLoader.ICON_TS_DISPLAY, [], @(h,ev)bst_userstat(0,Plug.Name), fontSize); 2636 % Extra menus 2637 if ~isempty(Plug.ExtraMenus) 2638 j(ij).menu.addSeparator(); 2639 for iMenu = 1:size(Plug.ExtraMenus,1) 2640 j(ij).extra(iMenu) = gui_component('MenuItem', j(ij).menu, [], Plug.ExtraMenus{iMenu,1}, IconLoader.ICON_EXPLORER, [], @(h,ev)bst_call(@eval, Plug.ExtraMenus{iMenu,2}), fontSize); 2641 end 2642 end 2643 end 2644 end 2645 % === Remove menus for plugins with description === 2646 if ~isempty(jPlugsPrev) 2647 [~, iOld] = setdiff({jPlugsPrev.name}, {PlugDesc.Name}); 2648 for ix = 1 : length(iOld) 2649 % Find category menu component 2650 jMenuCat = jPlugsPrev(iOld(ix)).menu.getParent.getInvoker; 2651 % Find index in parent 2652 iDel = []; 2653 for ic = 0 : jMenuCat.getMenuComponentCount-1 2654 if jPlugsPrev(iOld(ix)).menu == jMenuCat.getMenuComponent(ic) 2655 iDel = ic; 2656 break 2657 end 2658 end 2659 % Remove from parent 2660 if ~isempty(iDel) 2661 jMenuCat.remove(iDel); 2662 end 2663 end 2664 end 2665 % Create options for adding user-defined plugins 2666 if ~isCompiled && isNewMenu 2667 menuCategory = 'User defined'; 2668 jMenuUserDef = []; 2669 for iMenuItem = 0 : jMenu.getItemCount-1 2670 if ~isempty(regexp(jMenu.getMenuComponent(iMenuItem).class, 'JMenu$', 'once')) && strcmp(char(jMenu.getMenuComponent(iMenuItem).getText), menuCategory) 2671 jMenuUserDef = jMenu.getMenuComponent(iMenuItem); 2672 end 2673 end 2674 if isempty(jMenuUserDef) 2675 jMenuUserDef = gui_component('Menu', jMenu, [], menuCategory, IconLoader.ICON_FOLDER_OPEN, [], [], fontSize); 2676 end 2677 jAddUserDefMan = gui_component('MenuItem', [], [], 'Add manually', IconLoader.ICON_EDIT, [], @(h,ev)AddUserDefDesc('manual'), fontSize); 2678 jAddUserDefFile = gui_component('MenuItem', [], [], 'Add from file', IconLoader.ICON_EDIT, [], @(h,ev)AddUserDefDesc('file'), fontSize); 2679 jAddUserDefUrl = gui_component('MenuItem', [], [], 'Add from URL', IconLoader.ICON_EDIT, [], @(h,ev)AddUserDefDesc('url'), fontSize); 2680 jRmvUserDefMan = gui_component('MenuItem', [], [], 'Remove plugin', IconLoader.ICON_DELETE, [], @(h,ev)RemoveUserDefDesc, fontSize); 2681 % Insert "Add" options at the begining of the 'User defined' menu 2682 jMenuUserDef.insert(jAddUserDefMan, 0); 2683 jMenuUserDef.insert(jAddUserDefFile, 1); 2684 jMenuUserDef.insert(jAddUserDefUrl, 2); 2685 jMenuUserDef.insert(jRmvUserDefMan, 3); 2686 jMenuUserDef.insertSeparator(4); 2687 end 2688 % List 2689 if ~isCompiled && isNewMenu 2690 jMenu.addSeparator(); 2691 gui_component('MenuItem', jMenu, [], 'List', IconLoader.ICON_EDIT, [], @(h,ev)List('Installed', 1), fontSize); 2692 end 2693 end 2694 2695 2696 %% ===== MENUS: UPDATE ===== 2697 function MenuUpdate(jMenu, fontSize) 2698 import org.brainstorm.icon.*; 2699 % Regenerate plugin menu to look for new plugins 2700 global GlobalData 2701 jPlugs = GlobalData.Program.GUI.pluginMenus; 2702 jPlugs = MenuCreate(jMenu, jPlugs, fontSize); 2703 GlobalData.Program.GUI.pluginMenus = jPlugs; 2704 % If compiled: disable most menus 2705 isCompiled = bst_iscompiled(); 2706 % Interface scaling 2707 InterfaceScaling = bst_get('InterfaceScaling'); 2708 % Update all the plugins 2709 for iPlug = 1:length(jPlugs) 2710 j = jPlugs(iPlug); 2711 PlugName = j.name; 2712 % Is installed? 2713 PlugRef = GetSupported(PlugName); 2714 Plug = GetInstalled(PlugName); 2715 if ~isempty(Plug) 2716 isInstalled = 1; 2717 elseif ~isempty(PlugRef) 2718 Plug = PlugRef; 2719 isInstalled = 0; 2720 else 2721 disp(['BST> Error: Description not found for plugin: ' PlugName]); 2722 continue; 2723 end 2724 isLoaded = isInstalled && Plug.isLoaded; 2725 isManaged = isInstalled && Plug.isManaged; 2726 % Compiled included: no submenus 2727 if isCompiled && (PlugRef.CompiledStatus == 2) 2728 j.menu.setEnabled(1); 2729 if (InterfaceScaling ~= 100) 2730 j.menu.setIcon(IconLoader.scaleIcon(IconLoader.ICON_GOOD, InterfaceScaling / 100)); 2731 else 2732 j.menu.setIcon(IconLoader.ICON_GOOD); 2733 end 2734 % Otherwise: all available 2735 else 2736 % Main menu: Available/Not available 2737 j.menu.setEnabled(isInstalled || ~isempty(Plug.URLzip)); 2738 % Current version 2739 if ~isInstalled 2740 j.version.setText('<HTML><FONT color="#707070"><I>Not installed</I></FONT>'); 2741 elseif ~isManaged && ~isempty(Plug.Path) 2742 j.version.setText('<HTML><FONT color="#707070"><I>Custom install</I></FONT>') 2743 elseif ~isempty(Plug.Version) && ischar(Plug.Version) 2744 strVer = Plug.Version; 2745 % If downloading from github 2746 if isGithubMaster(Plug.URLzip) 2747 % Show installation date, if available 2748 if ~isempty(Plug.InstallDate) 2749 strVer = Plug.InstallDate(1:11); 2750 % Show only the short SHA (7 chars) 2751 elseif (length(Plug.Version) >= 30) 2752 strVer = Plug.Version(1:7); 2753 end 2754 end 2755 j.version.setText(['<HTML><FONT color="#707070"><I>Installed version: ' strVer '</I></FONT>']) 2756 elseif isInstalled 2757 j.version.setText('<HTML><FONT color="#707070"><I>Installed</I></FONT>'); 2758 end 2759 % Main menu: Icon 2760 if isCompiled && isInstalled 2761 menuIcon = IconLoader.ICON_GOOD; 2762 elseif isLoaded % Loaded 2763 menuIcon = IconLoader.ICON_GOOD; 2764 elseif isInstalled % Not loaded 2765 menuIcon = IconLoader.ICON_BAD; 2766 else 2767 menuIcon = IconLoader.ICON_NEUTRAL; 2768 end 2769 if (InterfaceScaling ~= 100) 2770 j.menu.setIcon(IconLoader.scaleIcon(menuIcon, InterfaceScaling / 100)); 2771 else 2772 j.menu.setIcon(menuIcon); 2773 end 2774 % Install 2775 j.install.setEnabled(~isInstalled); 2776 if ~isInstalled && ~isempty(PlugRef.Version) && ischar(PlugRef.Version) 2777 j.install.setText(['<HTML>Install    <FONT color="#707070"><I>(' PlugRef.Version ')</I></FONT>']) 2778 else 2779 j.install.setText('Install'); 2780 end 2781 % Update 2782 j.update.setEnabled(isManaged); 2783 if isInstalled && ~isempty(PlugRef.Version) && ischar(PlugRef.Version) 2784 j.update.setText(['<HTML>Update    <FONT color="#707070"><I>(' PlugRef.Version ')</I></FONT>']) 2785 else 2786 j.update.setText('Update'); 2787 end 2788 % Uninstall 2789 j.uninstall.setEnabled(isManaged); 2790 % Custom install 2791 j.custom.setEnabled(~isManaged); 2792 if ~isempty(Plug.Path) 2793 j.custompath.setText(Plug.Path); 2794 else 2795 j.custompath.setText('Path not set'); 2796 end 2797 % Load/Unload 2798 j.load.setEnabled(isInstalled && ~isLoaded && ~isCompiled); 2799 j.unload.setEnabled(isLoaded && ~isCompiled); 2800 % Web 2801 j.web.setEnabled(~isempty(Plug.URLinfo)); 2802 % Extra menus: Update availability 2803 if ~isempty(Plug.ExtraMenus) 2804 for iMenu = 1:size(Plug.ExtraMenus,1) 2805 if (size(Plug.ExtraMenus,2) == 3) && ~isempty(Plug.ExtraMenus{3}) 2806 if (strcmpi(Plug.ExtraMenus{3}, 'loaded') && isLoaded) ... 2807 || (strcmpi(Plug.ExtraMenus{3}, 'installed') && isInstalled) ... 2808 || (strcmpi(Plug.ExtraMenus{3}, 'always')) 2809 j.extra(iMenu).setEnabled(1); 2810 else 2811 j.extra(iMenu).setEnabled(0); 2812 end 2813 end 2814 end 2815 end 2816 end 2817 end 2818 j.menu.repaint() 2819 j.menu.getParent().repaint() 2820 end 2821 2822 2823 %% ===== SET CUSTOM PATH ===== 2824 function SetCustomPath(PlugName, PlugPath) 2825 % Parse inputs 2826 if (nargin < 2) || isempty(PlugPath) 2827 PlugPath = []; 2828 end 2829 % Custom plugin paths 2830 PluginCustomPath = bst_get('PluginCustomPath'); 2831 % Get plugin description 2832 PlugDesc = GetSupported(PlugName); 2833 if isempty(PlugDesc) 2834 return; 2835 end 2836 % Get installed plugin 2837 PlugInst = GetInstalled(PlugName); 2838 isInstalled = ~isempty(PlugInst); 2839 isManaged = isInstalled && PlugInst.isManaged; 2840 if isManaged 2841 bst_error(['Plugin ' PlugName ' is already installed by Brainstorm, uninstall it first.'], 0); 2842 return; 2843 end 2844 % Ask install path to user 2845 isWarning = 1; 2846 if isempty(PlugPath) 2847 PlugPath = uigetdir(PlugInst.Path, ['Select ' PlugName ' directory.']); 2848 if isequal(PlugPath, 0) 2849 PlugPath = []; 2850 end 2851 % If removal is requested 2852 elseif isequal(PlugPath, 0) 2853 PlugPath = []; 2854 isWarning = 0; 2855 end 2856 % If the directory did not change: nothing to do 2857 if (isInstalled && isequal(PlugInst.Path, PlugPath)) || (~isInstalled && isempty(PlugPath)) 2858 return; 2859 end 2860 % Unload previous version 2861 if isInstalled && ~isempty(PlugInst.Path) && PlugInst.isLoaded 2862 Unload(PlugName); 2863 end 2864 % Check if this is a valid plugin folder 2865 if isempty(PlugPath) || ~file_exist(PlugPath) 2866 PlugPath = []; 2867 end 2868 if ~isempty(PlugPath) && ~isempty(PlugDesc.TestFile) 2869 isValid = 0; 2870 if file_exist(bst_fullfile(PlugPath, PlugDesc.TestFile)) 2871 isValid = 1; 2872 elseif ~isempty(PlugDesc.LoadFolders) 2873 for iFolder = 1:length(PlugDesc.LoadFolders) 2874 if file_exist(bst_fullfile(PlugPath, PlugDesc.LoadFolders{iFolder}, PlugDesc.TestFile)) 2875 isValid = 1; 2876 end 2877 end 2878 end 2879 if ~isValid 2880 PlugPath = []; 2881 end 2882 end 2883 % Save path 2884 PluginCustomPath.(PlugName) = PlugPath; 2885 bst_set('PluginCustomPath', PluginCustomPath); 2886 % Load plugin 2887 if ~isempty(PlugPath) 2888 [isOk, errMsg, PlugDesc] = Load(PlugName); 2889 % Ignored warnings 2890 elseif ~isWarning 2891 isOk = 1; 2892 errMsg = []; 2893 % Invalid path 2894 else 2895 isOk = 0; 2896 if ~isempty(PlugDesc.TestFile) 2897 errMsg = ['The file ' PlugDesc.TestFile ' could not be found in selected folder.']; 2898 else 2899 errMsg = 'No valid folder was found.'; 2900 end 2901 end 2902 % Handle errors 2903 if ~isOk 2904 bst_error(['An error occurred while configuring plugin ' PlugName ':' 10 10 errMsg 10], 'Plugin manager', 0); 2905 elseif ~isempty(errMsg) 2906 java_dialog('msgbox', ['Configuration message:' 10 10 errMsg 10], 'Plugin manager'); 2907 elseif isWarning 2908 java_dialog('msgbox', ['Plugin ' PlugName ' successfully loaded.']); 2909 end 2910 end 2911 2912 2913 %% ===== ARCHIVE SOFTWARE ENVIRONMENT ===== 2914 % USAGE: Archive(OutputFile=[ask]) 2915 function Archive(OutputFile) 2916 % Parse inputs 2917 if (nargin < 1) || isempty(OutputFile) 2918 OutputFile = []; 2919 end 2920 % Get date string 2921 c = clock(); 2922 strDate = sprintf('%02d%02d%02d', c(1)-2000, c(2), c(3)); 2923 % Get output filename 2924 if isempty(OutputFile) 2925 % Get default directories 2926 LastUsedDirs = bst_get('LastUsedDirs'); 2927 % Default output filename 2928 OutputFile = bst_fullfile(LastUsedDirs.ExportScript, ['bst_env_' strDate '.zip']); 2929 % File selection 2930 OutputFile = java_getfile('save', 'Export environment', OutputFile, 'single', 'files', ... 2931 {{'.zip'}, 'Zip files (*.zip)', 'ZIP'}, 1); 2932 if isempty(OutputFile) 2933 return 2934 end 2935 % Save new default export path 2936 LastUsedDirs.ExportScript = bst_fileparts(OutputFile); 2937 bst_set('LastUsedDirs', LastUsedDirs); 2938 end 2939 2940 % ===== TEMP FOLDER ===== 2941 bst_progress('start', 'Export environment', 'Creating temporary folder...'); 2942 2943 % ===== COPY BRAINSTORM ===== 2944 bst_progress('text', 'Copying: brainstorm...'); 2945 % Get Brainstorm path and version 2946 bstVer = bst_get('Version'); 2947 bstDir = bst_get('BrainstormHomeDir'); 2948 % Create temporary folder for storing all the files to package 2949 TmpDir = bst_get('BrainstormTmpDir', 0, 'bstenv'); 2950 % Get brainstorm3 destination folder: add version number 2951 if ~isempty(bstVer.Version) && ~any(bstVer.Version == '?') 2952 envBst = bst_fullfile(TmpDir, ['brainstorm', bstVer.Version]); 2953 else 2954 [tmp, bstName] = bst_fileparts(bstDir); 2955 envBst = bst_fullfile(TmpDir, bstName); 2956 end 2957 % Add git commit hash 2958 if (length(bstVer.Commit) >= 30) 2959 envBst = [envBst, '_', bstVer.Commit(1:7)]; 2960 end 2961 % Copy brainstorm3 folder 2962 isOk = file_copy(bstDir, envBst); 2963 if ~isOk 2964 error(['Cannot copy folder: "' bstDir '" to "' envBst '"']); 2965 end 2966 2967 % ===== COPY DEFAULTS ===== 2968 bst_progress('text', 'Copying: user defaults...'); 2969 % Get user defaults folder 2970 userDef = bst_get('UserDefaultsDir'); 2971 envDef = bst_fullfile(envBst, 'defaults'); 2972 isOk = file_copy(userDef, envDef); 2973 if ~isOk 2974 error(['Cannot merge folder: "' userDef '" into "' envDef '"']); 2975 end 2976 2977 % ===== COPY USER PROCESSES ===== 2978 bst_progress('text', 'Copying: user processes...'); 2979 % Get user process folder 2980 userProc = bst_get('UserProcessDir'); 2981 envProc = bst_fullfile(envBst, 'toolbox', 'process', 'functions'); 2982 isOk = file_copy(userProc, envProc); 2983 if ~isOk 2984 error(['Cannot merge folder: "' userProc '" into "' envProc '"']); 2985 end 2986 2987 % ===== COPY PLUGINS ====== 2988 % Get list of plugins to package 2989 PlugDesc = GetInstalled(); 2990 % Destination plugin directory 2991 envPlugins = bst_fullfile(envBst, 'plugins'); 2992 % Copy each installed plugin 2993 for iPlug = 1:length(PlugDesc) 2994 bst_progress('text', ['Copying plugin: ' PlugDesc(iPlug).Name '...']); 2995 envPlug = bst_fullfile(envPlugins, PlugDesc(iPlug).Name); 2996 isOk = file_copy(PlugDesc(iPlug).Path, envPlug); 2997 if ~isOk 2998 error(['Cannot copy folder: "' PlugDesc(iPlug).Path '" into "' envProc '"']); 2999 end 3000 end 3001 % Copy user-defined JSON files 3002 PlugJson = dir(fullfile(bst_get('UserPluginsDir'), 'plugin_*.json')); 3003 for iPlugJson = 1:length(PlugJson) 3004 bst_progress('text', ['Copying use-defined plugin JSON file: ' PlugJson(iPlugJson).name '...']); 3005 plugJsonFile = bst_fullfile(PlugJson(iPlugJson).folder, PlugJson(iPlugJson).name); 3006 envPlugJson = bst_fullfile(envPlugins, PlugJson(iPlugJson).name); 3007 isOk = file_copy(plugJsonFile, envPlugJson); 3008 if ~isOk 3009 error(['Cannot copy file: "' plugJsonFile '" into "' envProc '"']); 3010 end 3011 end 3012 3013 % ===== SAVE LIST OF VERSIONS ===== 3014 strList = bst_plugin('List', 'installed', 0); 3015 % Open file versions.txt 3016 VersionFile = bst_fullfile(TmpDir, 'versions.txt'); 3017 fid = fopen(VersionFile, 'wt'); 3018 if (fid < 0) 3019 error(['Cannot save file: ' VersionFile]); 3020 end 3021 % Save Brainstorm plugins list 3022 fwrite(fid, strList); 3023 % Save Matlab ver command 3024 strMatlab = evalc('ver'); 3025 fwrite(fid, [10 10 strMatlab]); 3026 % Close file 3027 fclose(fid); 3028 3029 % ===== ZIP FILES ===== 3030 bst_progress('text', 'Zipping environment...'); 3031 % Zip files with bst_env_* being the first level 3032 zip(OutputFile, TmpDir, bst_fileparts(TmpDir)); 3033 % Delete the temporary files 3034 file_delete(TmpDir, 1, 1); 3035 % Close progress bar 3036 bst_progress('stop'); 3037 end 3038 3039 3040 %% ============================================================================ 3041 % ===== PLUGIN-SPECIFIC FUNCTIONS ============================================ 3042 % ============================================================================ 3043 3044 %% ===== LINK CAT-SPM ===== 3045 % USAGE: bst_plugin('LinkCatSpm', Action) 3046 % 0=Delete/1=Create/2=Check a symbolic link for CAT12 in SPM12 toolbox folder 3047 function LinkCatSpm(Action) 3048 % Get SPM12 plugin 3049 PlugSpm = GetInstalled('spm12'); 3050 if isempty(PlugSpm) 3051 error('Plugin SPM12 is not loaded.'); 3052 elseif ~PlugSpm.isLoaded 3053 [isOk, errMsg, PlugSpm] = Load('spm12'); 3054 if ~isOk 3055 error('Plugin SPM12 cannot be loaded.'); 3056 end 3057 end 3058 % Get SPM plugin path 3059 if ~isempty(PlugSpm.SubFolder) 3060 spmToolboxDir = bst_fullfile(PlugSpm.Path, PlugSpm.SubFolder, 'toolbox'); 3061 else 3062 spmToolboxDir = bst_fullfile(PlugSpm.Path, 'toolbox'); 3063 end 3064 if ~file_exist(spmToolboxDir) 3065 error(['Could not find SPM12 toolbox folder: ' spmToolboxDir]); 3066 end 3067 % CAT12 plugin path 3068 spmCatDir = bst_fullfile(spmToolboxDir, 'cat12'); 3069 % Check link 3070 if (Action == 2) 3071 % Link exists and works: return here 3072 if file_exist(bst_fullfile(spmCatDir, 'cat12.m')) 3073 return; 3074 % Link doesn't exist: Create it 3075 else 3076 Action = 1; 3077 end 3078 end 3079 % If folder already exists 3080 if file_exist(spmCatDir) 3081 % If setting install and SPM is not managed by Brainstorm: do not risk deleting user's install of CAT12 3082 if (Action == 1) && ~PlugSpm.isManaged 3083 error(['CAT12 seems already set up: ' spmCatDir]); 3084 end 3085 % All the other cases: delete existing CAT12 folder 3086 if ispc 3087 rmCall = ['rmdir /q /s "' spmCatDir '"']; 3088 else 3089 rmCall = ['rm -rf "' spmCatDir '"']; 3090 end 3091 disp(['BST> Deleting existing SPM12 toolbox: ' rmCall]); 3092 [status,result] = system(rmCall); 3093 if (status ~= 0) 3094 error(['Error deleting link: ' result]); 3095 end 3096 end 3097 % Create new link 3098 if (Action == 1) 3099 % Get CAT12 plugin 3100 PlugCat = GetInstalled('cat12'); 3101 if isempty(PlugCat) || ~PlugCat.isLoaded 3102 error('Plugin CAT12 is not loaded.'); 3103 end 3104 % Return if installation is not complete yet (first load before installation ends) 3105 if isempty(PlugCat.InstallDate) 3106 return 3107 end 3108 % Define source and target for the link 3109 if ~isempty(PlugCat.SubFolder) 3110 linkTarget = bst_fullfile(PlugCat.Path, PlugCat.SubFolder); 3111 else 3112 linkTarget = PlugCat.Path; 3113 end 3114 linkFile = spmCatDir; 3115 % Create link 3116 if ispc 3117 linkCall = ['mklink /D "' linkFile '" "' linkTarget '"']; 3118 else 3119 linkCall = ['ln -s "' linkTarget '" "' linkFile '"']; 3120 end 3121 disp(['BST> Creating symbolic link: ' linkCall]); 3122 [status,result] = system(linkCall); 3123 if (status ~= 0) 3124 error(['Error creating link: ' result]); 3125 end 3126 end 3127 end 3128 3129 3130 %% ===== SET PROGRESS LOGO ===== 3131 % USAGE: SetProgressLogo(PlugDesc/PlugName) % Set progress bar image 3132 % SetProgressLogo([]) % Remove progress bar image 3133 function SetProgressLogo(PlugDesc) 3134 % Remove image 3135 if (nargin < 1) || isempty(PlugDesc) 3136 bst_progress('removeimage'); 3137 bst_progress('removelink'); 3138 % Set image 3139 else 3140 % Get plugin description 3141 if ischar(PlugDesc) 3142 PlugDesc = GetSupported(PlugDesc); 3143 end 3144 % Set logo file 3145 if isempty(PlugDesc.LogoFile) 3146 PlugDesc.LogoFile = GetLogoFile(PlugDesc); 3147 end 3148 if ~isempty(PlugDesc.LogoFile) 3149 bst_progress('setimage', PlugDesc.LogoFile); 3150 end 3151 % Set link 3152 if ~isempty(PlugDesc.URLinfo) 3153 bst_progress('setlink', PlugDesc.URLinfo); 3154 end 3155 end 3156 end 3157 3158 3159 %% ===== NOT SUPPORTED APPLE SILICON ===== 3160 % Return list of plugins not supported on Apple silicon 3161 function pluginNames = PluginsNotSupportAppleSilicon() 3162 pluginNames = {'brain2mesh', 'duneuro', 'iso2mesh', 'mcxlab-cl', 'mcxlab-cuda', 'xdf'}; 3163 end