Plugins

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