Geant4 Cross Reference |
>> 1 // 1 // ******************************************* 2 // ******************************************************************** 2 // * License and Disclaimer 3 // * License and Disclaimer * 3 // * 4 // * * 4 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of * 5 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and * 6 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file * 7 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These * 8 // * include a list of copyright holders. 9 // * include a list of copyright holders. * 9 // * 10 // * * 10 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing * 11 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this * 12 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, * 13 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its * 14 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above * 15 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. * 16 // * 17 // * * 17 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and * 18 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. * 19 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or * 20 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its * 21 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your * 22 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. * 23 // ******************************************* 24 // ******************************************************************** 24 // 25 // 25 // G4UIcommandTree << 26 // 26 // 27 // Author: Makoto Asai (SLAC), 1998 << 27 // $Id: G4UIcommandTree.cc,v 1.13 2006/06/29 19:08:58 gunter Exp $ 28 // Midified: Makoto Asai (SLAC), 2021 << 28 // GEANT4 tag $Name: geant4-08-01 $ 29 // Improve output HTML file layout and add o << 29 // 30 // command/directory names in alphabetic ord << 31 // ------------------------------------------- << 32 30 33 #include "G4UIcommandTree.hh" 31 #include "G4UIcommandTree.hh" 34 << 35 #include "G4StateManager.hh" 32 #include "G4StateManager.hh" 36 #include "G4UIdirectory.hh" << 33 #include <fstream> 37 #include "G4UImanager.hh" << 38 #include "G4ios.hh" 34 #include "G4ios.hh" 39 35 40 #include <fstream> << 36 G4UIcommandTree::G4UIcommandTree() >> 37 :guidance(NULL) >> 38 { } 41 39 42 // ------------------------------------------- << 40 G4UIcommandTree::G4UIcommandTree(const char * thePathName) 43 G4UIcommandTree::G4UIcommandTree(const char* t << 41 :guidance(NULL) 44 { 42 { 45 pathName = thePathName; 43 pathName = thePathName; 46 } 44 } 47 45 48 // ------------------------------------------- << 49 G4UIcommandTree::~G4UIcommandTree() 46 G4UIcommandTree::~G4UIcommandTree() 50 { 47 { 51 for (auto& i : tree) { << 48 G4int i; 52 delete i; << 49 G4int n_treeEntry = tree.size(); 53 } << 50 for( i=0; i < n_treeEntry; i++ ) >> 51 { delete tree[i]; } 54 } 52 } 55 53 56 // ------------------------------------------- << 54 G4int G4UIcommandTree::operator==(const G4UIcommandTree &right) const 57 G4bool G4UIcommandTree::operator==(const G4UIc << 58 { 55 { 59 return (pathName == right.GetPathName()); << 56 return ( pathName == right.GetPathName() ); 60 } 57 } 61 58 62 // ------------------------------------------- << 59 G4int G4UIcommandTree::operator!=(const G4UIcommandTree &right) const 63 G4bool G4UIcommandTree::operator!=(const G4UIc << 64 { 60 { 65 return (pathName != right.GetPathName()); << 61 return ( pathName != right.GetPathName() ); 66 } 62 } 67 63 68 // ------------------------------------------- << 64 void G4UIcommandTree::AddNewCommand(G4UIcommand *newCommand) 69 void G4UIcommandTree::AddNewCommand(G4UIcomman << 70 { 65 { 71 G4String commandPath = newCommand->GetComman 66 G4String commandPath = newCommand->GetCommandPath(); 72 G4String remainingPath = commandPath; 67 G4String remainingPath = commandPath; 73 remainingPath.erase(0, pathName.length()); << 68 remainingPath.remove(0,pathName.length()); 74 if (remainingPath.empty()) { << 69 if( remainingPath.isNull() ) 75 if (guidance == nullptr) { << 70 { 76 guidance = newCommand; << 71 guidance = newCommand; 77 if (!(newCommand->ToBeBroadcasted())) { << 78 broadcastCommands = false; << 79 } << 80 if (workerThreadOnly) { << 81 newCommand->SetWorkerThreadOnly(); << 82 } << 83 } << 84 return; 72 return; 85 } 73 } 86 << 74 G4int i = remainingPath.first('/'); 87 if (guidance != nullptr) { << 75 if( i == G4int(std::string::npos) ) 88 auto* dir = static_cast<G4UIdirectory*>(gu << 76 { 89 ifSort = dir->IfSort(); << 77 // Find command 90 } << 78 G4int n_commandEntry = command.size(); 91 std::size_t i = remainingPath.find('/'); << 79 for( G4int i_thCommand = 0; i_thCommand < n_commandEntry; i_thCommand++ ) 92 if (i == std::string::npos) { << 80 { 93 // Adding a new command to this directory << 81 if( remainingPath == command[i_thCommand]->GetCommandName() ) 94 std::size_t n_commandEntry = command.size( << 82 { return; } 95 for (std::size_t i_thCommand = 0; i_thComm << 96 if (remainingPath == command[i_thCommand << 97 // a command of same name has already << 98 if (G4UImanager::GetUIpointer()->GetVe << 99 G4ExceptionDescription ed; << 100 ed << "Command <" << commandPath << << 101 G4Exception("G4UIcommandTree::AddNew << 102 // FatalException, << 103 JustWarning, ed); << 104 } << 105 return; << 106 } << 107 } << 108 if (!broadcastCommands) { << 109 newCommand->SetToBeBroadcasted(false); << 110 } << 111 if (workerThreadOnly) { << 112 newCommand->SetWorkerThreadOnly(); << 113 } << 114 if (ifSort) { << 115 auto j = command.cbegin(); << 116 for (; j != command.cend(); ++j) { << 117 if (newCommand->GetCommandPath() < (*j << 118 break; << 119 } << 120 } << 121 command.insert(j, newCommand); << 122 } << 123 else { << 124 command.push_back(newCommand); << 125 } 83 } >> 84 command.push_back( newCommand ); 126 return; 85 return; 127 } 86 } 128 << 87 else 129 // Adding a new command to a sub-directory << 88 { 130 G4String nextPath = pathName; << 89 // Find path 131 nextPath.append(remainingPath.substr(0, i + << 90 G4String nextPath = pathName; 132 std::size_t n_treeEntry = tree.size(); << 91 nextPath.append(remainingPath(0,i+1)); 133 for (std::size_t i_thTree = 0; i_thTree < n_ << 92 G4int n_treeEntry = tree.size(); 134 if (nextPath == tree[i_thTree]->GetPathNam << 93 for( G4int i_thTree = 0; i_thTree < n_treeEntry; i_thTree++ ) 135 if (!broadcastCommands) { << 94 { 136 newCommand->SetToBeBroadcasted(false); << 95 if( nextPath == tree[i_thTree]->GetPathName() ) 137 } << 96 { 138 tree[i_thTree]->AddNewCommand(newCommand << 97 tree[i_thTree]->AddNewCommand( newCommand ); 139 return; << 98 return; 140 } << 141 } << 142 // Creating a new sub-directory << 143 auto* newTree = new G4UIcommandTree(nextPath << 144 if (ifSort) { << 145 auto j = tree.cbegin(); << 146 for (; j != tree.cend(); ++j) { << 147 if (newTree->GetPathName() < (*j)->GetPa << 148 break; << 149 } 99 } 150 } 100 } 151 tree.insert(j, newTree); << 101 G4UIcommandTree * newTree = new G4UIcommandTree( nextPath ); 152 } << 102 tree.push_back( newTree ); 153 else { << 103 newTree->AddNewCommand( newCommand ); 154 tree.push_back(newTree); << 104 return; 155 } << 156 if (!broadcastCommands) { << 157 newCommand->SetToBeBroadcasted(false); << 158 } 105 } 159 // In case a new sub-directry is created wit << 160 // (most-likely this is the case), inherit t << 161 newCommand->SetDefaultSortFlag(ifSort); << 162 newTree->AddNewCommand(newCommand, workerThr << 163 return; << 164 } 106 } 165 107 166 // ------------------------------------------- << 108 void G4UIcommandTree::RemoveCommand(G4UIcommand *aCommand) 167 void G4UIcommandTree::RemoveCommand(G4UIcomman << 168 { 109 { 169 if (workerThreadOnly && !(aCommand->IsWorker << 170 return; << 171 } << 172 G4String commandPath = aCommand->GetCommandP 110 G4String commandPath = aCommand->GetCommandPath(); 173 commandPath.erase(0, pathName.length()); << 111 G4String remainingPath = commandPath; 174 if (commandPath.empty()) { << 112 remainingPath.remove(0,pathName.length()); 175 guidance = nullptr; << 113 if( remainingPath.isNull() ) 176 } << 114 { 177 else { << 115 guidance = NULL; 178 std::size_t i = commandPath.find('/'); << 116 } 179 if (i == std::string::npos) { << 117 else >> 118 { >> 119 G4int i = remainingPath.first('/'); >> 120 if( i == G4int(std::string::npos) ) >> 121 { 180 // Find command 122 // Find command 181 std::size_t n_commandEntry = command.siz << 123 G4int n_commandEntry = command.size(); 182 for (std::size_t i_thCommand = 0; i_thCo << 124 for( G4int i_thCommand = 0; i_thCommand < n_commandEntry; i_thCommand++ ) 183 if (commandPath == command[i_thCommand << 125 { 184 command.erase(command.begin() + i_th << 126 if( remainingPath == command[i_thCommand]->GetCommandName() ) >> 127 { >> 128 command.erase(command.begin()+i_thCommand); 185 break; 129 break; 186 } 130 } 187 } 131 } 188 } 132 } 189 else { << 133 else >> 134 { 190 // Find path 135 // Find path 191 G4String nextPath = pathName; 136 G4String nextPath = pathName; 192 nextPath.append(commandPath.substr(0, i << 137 nextPath.append(remainingPath(0,i+1)); 193 std::size_t n_treeEntry = tree.size(); << 138 G4int n_treeEntry = tree.size(); 194 for (std::size_t i_thTree = 0; i_thTree << 139 for( G4int i_thTree = 0; i_thTree < n_treeEntry; i_thTree++ ) 195 if (nextPath == tree[i_thTree]->GetPat << 140 { 196 tree[i_thTree]->RemoveCommand(aComma << 141 if( nextPath == tree[i_thTree]->GetPathName() ) 197 G4int n_commandRemain = tree[i_thTre << 142 { 198 G4int n_treeRemain = tree[i_thTree]- << 143 tree[i_thTree]->RemoveCommand( aCommand ); 199 if (n_commandRemain == 0 && n_treeRe << 144 G4int n_commandRemain = tree[i_thTree]->GetCommandEntry(); 200 G4UIcommandTree* emptyTree = tree[ << 145 if(n_commandRemain==0) 201 tree.erase(tree.begin() + i_thTree << 146 { 202 delete emptyTree; << 147 G4UIcommandTree * emptyTree = tree[i_thTree]; 203 } << 148 tree.erase(tree.begin()+i_thTree); 204 break; << 149 delete emptyTree; >> 150 } >> 151 break; 205 } 152 } 206 } 153 } 207 } 154 } 208 } 155 } 209 } 156 } 210 157 211 // ------------------------------------------- << 158 G4UIcommand * G4UIcommandTree::FindPath(const char* commandPath) 212 G4UIcommand* G4UIcommandTree::FindPath(const c << 213 { 159 { 214 // This function tries to match a command na << 215 << 216 G4String remainingPath = commandPath; 160 G4String remainingPath = commandPath; 217 if (remainingPath.find(pathName) == std::str << 161 if( remainingPath.index( pathName ) == std::string::npos ) 218 return nullptr; << 162 { return NULL; } 219 } << 163 remainingPath.remove(0,pathName.length()); 220 remainingPath.erase(0, pathName.length()); << 164 G4int i = remainingPath.first('/'); 221 std::size_t i = remainingPath.find('/'); << 165 if( i == G4int(std::string::npos) ) 222 if (i == std::string::npos) { << 166 { 223 // Find command 167 // Find command 224 std::size_t n_commandEntry = command.size( << 168 G4int n_commandEntry = command.size(); 225 for (std::size_t i_thCommand = 0; i_thComm << 169 for( G4int i_thCommand = 0; i_thCommand < n_commandEntry; i_thCommand++ ) 226 if (remainingPath == command[i_thCommand << 170 { 227 return command[i_thCommand]; << 171 if( remainingPath == command[i_thCommand]->GetCommandName() ) 228 } << 172 { return command[i_thCommand]; } 229 } << 230 } << 231 else { << 232 // Find path << 233 G4String nextPath = pathName; << 234 nextPath.append(remainingPath.substr(0, i << 235 std::size_t n_treeEntry = tree.size(); << 236 for (std::size_t i_thTree = 0; i_thTree < << 237 if (nextPath == tree[i_thTree]->GetPathN << 238 return tree[i_thTree]->FindPath(comman << 239 } << 240 } 173 } 241 } 174 } 242 return nullptr; << 175 else 243 } << 176 { 244 << 245 // ------------------------------------------- << 246 G4UIcommandTree* G4UIcommandTree::FindCommandT << 247 { << 248 // Try to match a command or a path with the << 249 // @commandPath : command or path to match << 250 // @return the commandTree found or nullptr << 251 << 252 G4String remainingPath = commandPath; << 253 if (remainingPath.find(pathName) == std::str << 254 return nullptr; << 255 } << 256 remainingPath.erase(0, pathName.length()); << 257 std::size_t i = remainingPath.find('/'); << 258 if (i != std::string::npos) { << 259 // Find path 177 // Find path 260 G4String nextPath = pathName; 178 G4String nextPath = pathName; 261 nextPath.append(remainingPath.substr(0, i << 179 nextPath.append(remainingPath(0,i+1)); 262 std::size_t n_treeEntry = tree.size(); << 180 G4int n_treeEntry = tree.size(); 263 for (std::size_t i_thTree = 0; i_thTree < << 181 for( G4int i_thTree = 0; i_thTree < n_treeEntry; i_thTree++ ) 264 if (tree[i_thTree]->GetPathName() == com << 182 { 265 return tree[i_thTree]; << 183 if( nextPath == tree[i_thTree]->GetPathName() ) 266 } << 184 { return tree[i_thTree]->FindPath( commandPath ); } 267 if (nextPath == tree[i_thTree]->GetPathN << 268 return tree[i_thTree]->FindCommandTree << 269 } << 270 } << 271 } << 272 else { << 273 return this; << 274 } << 275 return nullptr; << 276 } << 277 << 278 // ------------------------------------------- << 279 G4String G4UIcommandTree::CompleteCommandPath( << 280 { << 281 G4String pName = aCommandPath; << 282 G4String remainingPath = aCommandPath; << 283 G4String empty = ""; << 284 G4String matchingPath = empty; << 285 << 286 // find the tree << 287 auto jpre = pName.rfind('/'); << 288 if (jpre != G4String::npos) { << 289 pName.erase(jpre + 1); << 290 } << 291 G4UIcommandTree* aTree = FindCommandTree(pNa << 292 << 293 if (aTree == nullptr) { << 294 return empty; << 295 } << 296 << 297 if (pName.find(pName) == std::string::npos) << 298 return empty; << 299 } << 300 << 301 std::vector<G4String> paths; << 302 << 303 // list matched directories/commands << 304 G4String strtmp; << 305 G4int nMatch = 0; << 306 << 307 G4int Ndir = aTree->GetTreeEntry(); << 308 G4int Ncmd = aTree->GetCommandEntry(); << 309 << 310 // directory ... << 311 for (G4int idir = 1; idir <= Ndir; ++idir) { << 312 const G4String& fpdir = aTree->GetTree(idi << 313 // matching test << 314 if (fpdir.find(remainingPath, 0) == 0) { << 315 if (nMatch == 0) { << 316 matchingPath = fpdir; << 317 } << 318 else { << 319 matchingPath = GetFirstMatchedString(f << 320 } << 321 ++nMatch; << 322 paths.push_back(fpdir); << 323 } << 324 } << 325 << 326 if (paths.size() >= 2) { << 327 G4cout << "Matching directories :" << G4en << 328 for (const auto& path : paths) { << 329 G4cout << path << G4endl; << 330 } << 331 } << 332 << 333 // command ... << 334 std::vector<G4String> commands; << 335 << 336 for (G4int icmd = 1; icmd <= Ncmd; ++icmd) { << 337 G4String fpcmd = aTree->GetPathName() + aT << 338 // matching test << 339 if (fpcmd.find(remainingPath, 0) == 0) { << 340 if (nMatch == 0) { << 341 matchingPath = fpcmd + " "; << 342 } << 343 else { << 344 strtmp = fpcmd + " "; << 345 matchingPath = GetFirstMatchedString(m << 346 } << 347 nMatch++; << 348 commands.emplace_back(fpcmd + " "); << 349 } << 350 } << 351 << 352 if (commands.size() >= 2) { << 353 G4cout << "Matching commands :" << G4endl; << 354 for (const auto& matched : commands) { << 355 G4cout << matched << G4endl; << 356 } << 357 } << 358 << 359 return matchingPath; << 360 } << 361 << 362 // ------------------------------------------- << 363 G4String G4UIcommandTree::GetFirstMatchedStrin << 364 { << 365 std::size_t nlen1 = str1.length(); << 366 std::size_t nlen2 = str2.length(); << 367 << 368 std::size_t nmin = nlen1 < nlen2 ? nlen1 : n << 369 << 370 G4String strMatched; << 371 for (G4int i = 0; i < (G4int)nmin; ++i) { << 372 if (str1[i] == str2[i]) { << 373 strMatched += str1[i]; << 374 } << 375 else { << 376 break; << 377 } 185 } 378 } 186 } 379 << 187 return NULL; 380 return strMatched; << 381 } 188 } 382 189 383 // ------------------------------------------- << 190 void G4UIcommandTree::ListCurrent() 384 void G4UIcommandTree::ListCurrent() const << 385 { 191 { 386 G4cout << "Command directory path : " << pat 192 G4cout << "Command directory path : " << pathName << G4endl; 387 if (guidance != nullptr) { << 193 if( guidance != NULL ) guidance->List(); 388 guidance->List(); << 389 } << 390 G4cout << " Sub-directories : " << G4endl; 194 G4cout << " Sub-directories : " << G4endl; 391 std::size_t n_treeEntry = tree.size(); << 195 G4int n_treeEntry = tree.size(); 392 for (std::size_t i_thTree = 0; i_thTree < n_ << 196 for( G4int i_thTree = 0; i_thTree < n_treeEntry; i_thTree++ ) 393 G4cout << " " << tree[i_thTree]->GetPath << 197 { 394 if ((tree[i_thTree]->GetGuidance() != null << 198 G4cout << " " << tree[i_thTree]->GetPathName() 395 && tree[i_thTree]->GetGuidance()->IsWo << 199 << " " << tree[i_thTree]->GetTitle() << G4endl; 396 { << 397 G4cout << " @ "; << 398 } << 399 else { << 400 G4cout << " "; << 401 } << 402 G4cout << tree[i_thTree]->GetTitle() << G4 << 403 } 200 } 404 G4cout << " Commands : " << G4endl; 201 G4cout << " Commands : " << G4endl; 405 std::size_t n_commandEntry = command.size(); << 202 G4int n_commandEntry = command.size(); 406 for (std::size_t i_thCommand = 0; i_thComman << 203 for( G4int i_thCommand = 0; i_thCommand < n_commandEntry; i_thCommand++ ) 407 G4cout << " " << command[i_thCommand]->G << 204 { 408 if (command[i_thCommand]->IsWorkerThreadOn << 205 G4cout << " " << command[i_thCommand]->GetCommandName() 409 G4cout << " @ "; << 206 << " * " << command[i_thCommand]->GetTitle() << G4endl; 410 } << 411 else { << 412 G4cout << " * "; << 413 } << 414 G4cout << command[i_thCommand]->GetTitle() << 415 } 207 } 416 } 208 } 417 209 418 // ------------------------------------------- << 210 void G4UIcommandTree::ListCurrentWithNum() 419 void G4UIcommandTree::ListCurrentWithNum() con << 420 { 211 { 421 G4cout << "Command directory path : " << pat 212 G4cout << "Command directory path : " << pathName << G4endl; 422 if (guidance != nullptr) { << 213 if( guidance != NULL ) guidance->List(); 423 guidance->List(); << 424 } << 425 G4int i = 0; 214 G4int i = 0; 426 G4cout << " Sub-directories : " << G4endl; 215 G4cout << " Sub-directories : " << G4endl; 427 std::size_t n_treeEntry = tree.size(); << 216 G4int n_treeEntry = tree.size(); 428 for (std::size_t i_thTree = 0; i_thTree < n_ << 217 for( G4int i_thTree = 0; i_thTree < n_treeEntry; i_thTree++ ) 429 ++i; << 218 { 430 G4cout << " " << i << ") " << tree[i_thTre << 219 i++; 431 << tree[i_thTree]->GetTitle() << G4 << 220 G4cout << " " << i << ") " << tree[i_thTree]->GetPathName() >> 221 << " " << tree[i_thTree]->GetTitle() << G4endl; 432 } 222 } 433 G4cout << " Commands : " << G4endl; 223 G4cout << " Commands : " << G4endl; 434 std::size_t n_commandEntry = command.size(); << 224 G4int n_commandEntry = command.size(); 435 for (std::size_t i_thCommand = 0; i_thComman << 225 for( G4int i_thCommand = 0; i_thCommand < n_commandEntry; i_thCommand++ ) 436 ++i; << 226 { 437 G4cout << " " << i << ") " << command[i_th << 227 i++; 438 << command[i_thCommand]->GetTitle() << 228 G4cout << " " << i << ") " << command[i_thCommand]->GetCommandName() >> 229 << " * " << command[i_thCommand]->GetTitle() << G4endl; 439 } 230 } 440 } 231 } 441 232 442 // ------------------------------------------- << 233 void G4UIcommandTree::List() 443 void G4UIcommandTree::List() const << 444 { 234 { 445 ListCurrent(); 235 ListCurrent(); 446 std::size_t n_commandEntry = command.size(); << 236 G4int n_commandEntry = command.size(); 447 for (std::size_t i_thCommand = 0; i_thComman << 237 for( G4int i_thCommand = 0; i_thCommand < n_commandEntry; i_thCommand++ ) >> 238 { 448 command[i_thCommand]->List(); 239 command[i_thCommand]->List(); 449 } 240 } 450 std::size_t n_treeEntry = tree.size(); << 241 G4int n_treeEntry = tree.size(); 451 for (std::size_t i_thTree = 0; i_thTree < n_ << 242 for( G4int i_thTree = 0; i_thTree < n_treeEntry; i_thTree++ ) >> 243 { 452 tree[i_thTree]->List(); 244 tree[i_thTree]->List(); 453 } 245 } 454 } 246 } 455 247 456 // ------------------------------------------- << 457 G4String G4UIcommandTree::CreateFileName(const 248 G4String G4UIcommandTree::CreateFileName(const char* pName) 458 { 249 { 459 G4String fn = pName; 250 G4String fn = pName; 460 std::size_t idxs; << 251 G4int idxs; 461 while ((idxs = fn.find('/')) != std::string: << 252 while((idxs=fn.index("/"))!=G4int(std::string::npos)) 462 fn[(G4int)idxs] = '_'; << 253 { fn(idxs) = '_'; } 463 } << 464 fn += ".html"; 254 fn += ".html"; 465 return fn; 255 return fn; 466 } 256 } 467 257 468 // ------------------------------------------- << 469 G4String G4UIcommandTree::ModStr(const char* s 258 G4String G4UIcommandTree::ModStr(const char* strS) 470 { 259 { 471 G4String sx; 260 G4String sx; 472 G4String str = strS; 261 G4String str = strS; 473 for (G4int i = 0; i < G4int(str.length()); + << 262 for(G4int i=0;i<G4int(str.length());i++) 474 char c = str[i]; << 263 { 475 switch (c) { << 264 char c = str(i); 476 case '<': << 265 switch(c) 477 sx += "<"; << 266 { 478 break; << 267 case '<': 479 case '>': << 268 sx += "<"; break; 480 sx += ">"; << 269 case '>': 481 break; << 270 sx += ">"; break; 482 case '&': << 271 case '&': 483 sx += "&"; << 272 sx += "&"; break; 484 break; << 273 default: 485 default: << 274 sx += c; 486 sx += c; << 487 } 275 } 488 } 276 } 489 return sx; 277 return sx; 490 } 278 } 491 279 492 // ------------------------------------------- << 280 void G4UIcommandTree::CreateHTML() 493 void G4UIcommandTree::CreateHTML(const G4Strin << 494 { 281 { 495 G4String ofileName = CreateFileName(pathName 282 G4String ofileName = CreateFileName(pathName); 496 std::ofstream oF(ofileName, std::ios::out); 283 std::ofstream oF(ofileName, std::ios::out); 497 284 498 oF << "<html><head><title>Commands in " << M 285 oF << "<html><head><title>Commands in " << ModStr(pathName) << "</title></head>" << G4endl; 499 oF << "<style> \ << 286 oF << "<body bgcolor=\"#ffffff\"><h2>" << ModStr(pathName) << "</h2><p>" << G4endl; 500 table,table td,table th { \ << 501 border:1px solid #eee \ << 502 } \ << 503 table td,table th { \ << 504 padding:5px 20px; \ << 505 line-height:1.3; \ << 506 text-align:inherit \ << 507 } \ << 508 a { \ << 509 color:#17a81a; \ << 510 text-decoration:none; \ << 511 transition-duration:0.3s \ << 512 } \ << 513 a:hover { \ << 514 color:#17a81a \ << 515 } \ << 516 table { \ << 517 border-collapse:collapse; \ << 518 border-spacing:0; \ << 519 margin-bottom:5px; \ << 520 } \ << 521 h1 { \ << 522 font-size:2.25em; \ << 523 font-weight:300; \ << 524 letter-spacing:-1px; \ << 525 line-height:1.15em; \ << 526 margin-bottom:0.5em; \ << 527 word-wrap:break-word \ << 528 } \ << 529 h2 { \ << 530 font-size:1.5em; \ << 531 font-weight:300; \ << 532 letter-spacing:-1px; \ << 533 line-height:1.15em; \ << 534 margin-bottom:0.5em; \ << 535 word-wrap:break-word \ << 536 } \ << 537 h3 { \ << 538 color:#26282a; \ << 539 font-weight:300; \ << 540 font-size:1.3em; \ << 541 padding:15px 0 15px 0; \ << 542 border-bottom:2px #eee solid; \ << 543 word-wrap:break-word \ << 544 } \ << 545 .sidebar { \ << 546 display:block; \ << 547 position:relative; \ << 548 position:sticky; \ << 549 float:left; \ << 550 -webkit-box-sizing:border-box; \ << 551 -moz-box-sizing:border-box; \ << 552 -ms-box-sizing:border-box; \ << 553 box-sizing:border-box; \ << 554 width:20%; \ << 555 padding-right:20px \ << 556 } \ << 557 .context { \ << 558 width:80%; \ << 559 display:inline-block; \ << 560 background-color:#fff; \ << 561 padding: 25px 35px 20px 30px; \ << 562 -webkit-box-sizing:border-box; \ << 563 -moz-box-sizing:border-box; \ << 564 -ms-box-sizing:border-box; \ << 565 box-sizing:border-box \ << 566 } \ << 567 </style>" << 568 << G4endl; << 569 oF << "<body bgcolor=\"#ffffff\">" << G4endl << 570 << 571 // Left Panel << 572 if (createHTMLTreeLevel == 0) { << 573 oF << "<div class=\"sidebar\">" << sideBar << 574 } << 575 // Right Panel << 576 oF << "<div class=\"context\">"; << 577 oF << "<h1>" << ModStr(pathName) << "</h1>" << 578 << 579 if (guidance != nullptr) { << 580 for (G4int i = 0; i < (G4int)guidance->Get << 581 oF << ModStr(guidance->GetGuidanceLine(i << 582 } << 583 } << 584 if (!tree.empty()) { << 585 G4String menu = ""; << 586 G4String newSideBar = ""; << 587 menu += "<h2>Sub-directories </h2><table>" << 588 newSideBar += "<h2><a href=\"" + ofileName << 589 // Build menu short version << 590 for (auto& i_thTree : tree) { << 591 newSideBar += "<tr><td><a href=\"" + Cre << 592 + ModStr(i_thTree->GetPath << 593 } << 594 // Build menu << 595 for (auto& i_thTree : tree) { << 596 menu += "<tr><td><a href=\"" + CreateFil << 597 + ModStr(i_thTree->GetPathName() << 598 menu += "</td><td>" + ModStr(i_thTree->G << 599 } << 600 menu += "</table>"; << 601 newSideBar += "</table>"; << 602 for (auto& i_thTree : tree) { << 603 createHTMLTreeLevel++; << 604 i_thTree->CreateHTML(newSideBar); << 605 createHTMLTreeLevel--; << 606 } << 607 oF << menu << G4endl; << 608 } << 609 287 610 if (!command.empty()) { << 288 if( guidance != NULL ) 611 oF << "<h2>Commands </h2>" << G4endl; << 289 { 612 << 290 for(G4int i=0;i<guidance->GetGuidanceEntries();i++) 613 // resume << 291 { oF << ModStr(guidance->GetGuidanceLine(i)) << "<br>" << G4endl; } 614 oF << "<table>" << G4endl; << 292 } 615 for (std::size_t i_thCommand = 0; i_thComm << 293 616 G4UIcommand* cmd = command[i_thCommand]; << 294 oF << "<p><hr><p>" << G4endl; 617 oF << "<tr><td><a href=\"#c" << i_thComm << 295 618 oF << "</a></td></tr>" << G4endl; << 296 oF << "<h2>Sub-directories : </h2><dl>" << G4endl; >> 297 for( G4int i_thTree = 0; i_thTree < G4int(tree.size()); i_thTree++ ) >> 298 { >> 299 oF << "<p><br><p><dt><a href=\"" << CreateFileName(tree[i_thTree]->GetPathName()) >> 300 << "\">" << ModStr(tree[i_thTree]->GetPathName()) << "</a>" << G4endl; >> 301 oF << "<p><dd>" << ModStr(tree[i_thTree]->GetTitle()) << G4endl; >> 302 tree[i_thTree]->CreateHTML(); >> 303 } >> 304 >> 305 oF << "</dl><p><hr><p>" << G4endl; >> 306 >> 307 oF << "<h2>Commands : </h2><dl>" << G4endl; >> 308 for( G4int i_thCommand = 0; i_thCommand < G4int(command.size()); i_thCommand++ ) >> 309 { >> 310 G4UIcommand* cmd = command[i_thCommand]; >> 311 oF << "<p><br><p><dt><b>" << ModStr(cmd->GetCommandName()); >> 312 if(cmd->GetParameterEntries()>0) >> 313 { >> 314 for(G4int i_thParam=0;i_thParam<cmd->GetParameterEntries();i_thParam++) >> 315 { oF << " [<i>" << ModStr(cmd->GetParameter(i_thParam)->GetParameterName()) << "</i>]"; } 619 } 316 } 620 oF << "</table>" << G4endl; << 317 oF << "</b>" << G4endl; 621 for (std::size_t i_thCommand = 0; i_thComm << 318 oF << "<p><dd>" << G4endl; 622 G4UIcommand* cmd = command[i_thCommand]; << 319 for(G4int i=0;i<cmd->GetGuidanceEntries();i++) 623 oF << "<h3 id=\"c" << i_thCommand << "\" << 320 { oF << ModStr(cmd->GetGuidanceLine(i)) << "<br>" << G4endl; } 624 if (cmd->GetParameterEntries() > 0) { << 321 if(!(cmd->GetRange()).isNull()) 625 for (G4int i_thParam = 0; i_thParam < << 322 { oF << "<p><dd>Range : " << ModStr(cmd->GetRange()) << G4endl; } 626 oF << " [<i>" << ModStr(cmd->GetPara << 323 std::vector<G4ApplicationState>* availabelStateList = cmd->GetStateList(); 627 } << 324 if(availabelStateList->size()==6) 628 } << 325 { oF << "<p><dd>Available at all Geant4 states." << G4endl; } 629 oF << "</h3>" << G4endl; << 326 else 630 oF << "<p>" << G4endl; << 327 { 631 for (G4int i = 0; i < (G4int)cmd->GetGui << 328 oF << "<p><dd>Available Geant4 state(s) : "; 632 oF << ModStr(cmd->GetGuidanceLine(i)) << 329 for(G4int ias=0;ias<G4int(availabelStateList->size());ias++) 633 } << 330 { oF << G4StateManager::GetStateManager()->GetStateString((*availabelStateList)[ias]) << " " << G4endl; } 634 if (!(cmd->GetRange()).empty()) { << 331 } 635 oF << "<p>Range : " << ModStr(cmd->Get << 332 if(cmd->GetParameterEntries()>0) 636 } << 333 { 637 std::vector<G4ApplicationState>* availab << 334 oF << "<p><dd>Parameters<table border=1>" << G4endl; 638 if (availabelStateList->size() == 6) { << 335 for(G4int i_thParam=0;i_thParam<cmd->GetParameterEntries();i_thParam++) 639 oF << "<p>Available at all Geant4 stat << 336 { 640 } << 337 G4UIparameter* prm = cmd->GetParameter(i_thParam); 641 else { << 338 oF << "<tr><td>" << ModStr(prm->GetParameterName()) << G4endl; 642 oF << "<p>Available Geant4 state(s) : << 339 oF << "<td>type " << prm->GetParameterType() << G4endl; 643 for (auto& ias : *availabelStateList) << 340 oF << "<td>"; 644 oF << G4StateManager::GetStateManage << 341 if(prm->IsOmittable()) 645 } << 342 { 646 } << 343 oF << "Omittable : "; 647 if (cmd->GetParameterEntries() > 0) { << 344 if(prm->GetCurrentAsDefault()) 648 oF << "<p>Parameters<table border=1>" << 345 { oF << "current value is used as the default value." << G4endl; } 649 for (G4int i_thParam = 0; i_thParam < << 346 else 650 G4UIparameter* prm = cmd->GetParamet << 347 { oF << "default value = " << prm->GetDefaultValue() << G4endl; } 651 oF << "<tr><td>" << ModStr(prm->GetP << 652 oF << "<td>type " << prm->GetParamet << 653 oF << "<td>"; << 654 if (prm->IsOmittable()) { << 655 oF << "Omittable : "; << 656 if (prm->GetCurrentAsDefault()) { << 657 oF << "current value is used as << 658 } << 659 else { << 660 oF << "default value = " << prm- << 661 } << 662 } << 663 oF << "<td>"; << 664 if (!(prm->GetParameterRange()).empt << 665 oF << "Parameter range : " << ModS << 666 } << 667 else if (!(prm->GetParameterCandidat << 668 oF << "Parameter candidates : " << << 669 } << 670 } 348 } 671 oF << "</table>" << G4endl; << 349 oF << "<td>"; >> 350 if(!(prm->GetParameterRange()).isNull()) >> 351 { oF << "Parameter range : " << ModStr(prm->GetParameterRange()) << G4endl; } >> 352 else if(!(prm->GetParameterCandidates()).isNull()) >> 353 { oF << "Parameter candidates : " << ModStr(prm->GetParameterCandidates()) << G4endl; } 672 } 354 } >> 355 oF << "</table>" << G4endl; 673 } 356 } >> 357 674 } 358 } 675 oF << "</div></body></html>" << G4endl; << 359 >> 360 oF << "</dl></body></html>" << G4endl; 676 oF.close(); 361 oF.close(); 677 } 362 } 678 363 679 // ------------------------------------------- << 680 G4UIcommandTree* G4UIcommandTree::GetTree(cons << 681 { << 682 G4String comName = comNameC; << 683 for (auto& i : tree) { << 684 if (comName == i->GetPathName()) { << 685 return i; << 686 } << 687 } << 688 return nullptr; << 689 } << 690 364