Plugins

{ "Name": "bst-users", "Version": "latest", "URLzip": "https://github.com/brainstorm-tools/bst-users/archive/refs/heads/master.zip", "URLinfo": "https://github.com/brainstorm-tools/bst-users/", "TestFile": "processes/examples/process_beamformer_test.m", "LoadFolders": [ "processes" ], }

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