Geant4 Cross Reference |
>> 1 // 1 // ******************************************* 2 // ******************************************************************** 2 // * License and Disclaimer << 3 // * DISCLAIMER * 3 // * 4 // * * 4 // * The Geant4 software is copyright of th << 5 // * The following disclaimer summarizes all the specific disclaimers * 5 // * the Geant4 Collaboration. It is provided << 6 // * of contributors to this software. The specific disclaimers,which * 6 // * conditions of the Geant4 Software License << 7 // * govern, are listed with their locations in: * 7 // * LICENSE and available at http://cern.ch/ << 8 // * http://cern.ch/geant4/license * 8 // * include a list of copyright holders. << 9 // * 9 // * * 10 // * Neither the authors of this software syst 10 // * Neither the authors of this software system, nor their employing * 11 // * institutes,nor the agencies providing fin 11 // * institutes,nor the agencies providing financial support for this * 12 // * work make any representation or warran 12 // * work make any representation or warranty, express or implied, * 13 // * regarding this software system or assum 13 // * regarding this software system or assume any liability for its * 14 // * use. Please see the license in the file << 14 // * use. * 15 // * for the full disclaimer and the limitatio << 16 // * 15 // * * 17 // * This code implementation is the result << 16 // * This code implementation is the intellectual property of the * 18 // * technical work of the GEANT4 collaboratio << 17 // * GEANT4 collaboration. * 19 // * By using, copying, modifying or distri << 18 // * By copying, distributing or modifying the Program (or any work * 20 // * any work based on the software) you ag << 19 // * based on the Program) you indicate your acceptance of this * 21 // * use in resulting scientific publicati << 20 // * statement, and all its terms. * 22 // * acceptance of all terms of the Geant4 Sof << 23 // ******************************************* 21 // ******************************************************************** 24 // 22 // 25 // G4UIcommandTree << 26 // 23 // 27 // Author: Makoto Asai (SLAC), 1998 << 24 // $Id: G4UIcommandTree.cc,v 1.10 2001/10/16 08:14:32 gcosmo Exp $ 28 // Midified: Makoto Asai (SLAC), 2021 << 25 // GEANT4 tag $Name: geant4-04-00 $ 29 // Improve output HTML file layout and add o << 26 // 30 // command/directory names in alphabetic ord << 31 // ------------------------------------------- << 32 27 33 #include "G4UIcommandTree.hh" 28 #include "G4UIcommandTree.hh" 34 << 35 #include "G4StateManager.hh" 29 #include "G4StateManager.hh" 36 #include "G4UIdirectory.hh" << 30 #include "g4std/fstream" 37 #include "G4UImanager.hh" << 38 #include "G4ios.hh" 31 #include "G4ios.hh" 39 32 40 #include <fstream> << 33 G4UIcommandTree::G4UIcommandTree() >> 34 :guidance(NULL) >> 35 { } 41 36 42 // ------------------------------------------- << 37 G4UIcommandTree::G4UIcommandTree(G4String thePathName) 43 G4UIcommandTree::G4UIcommandTree(const char* t << 38 :guidance(NULL) >> 39 { >> 40 pathName = thePathName; >> 41 } >> 42 >> 43 G4UIcommandTree::G4UIcommandTree(const char * thePathName) >> 44 :guidance(NULL) 44 { 45 { 45 pathName = thePathName; 46 pathName = thePathName; 46 } 47 } 47 48 48 // ------------------------------------------- << 49 G4UIcommandTree::~G4UIcommandTree() 49 G4UIcommandTree::~G4UIcommandTree() 50 { 50 { 51 for (auto& i : tree) { << 51 G4int i; 52 delete i; << 52 G4int n_treeEntry = tree.size(); 53 } << 53 for( i=0; i < n_treeEntry; i++ ) >> 54 { delete tree[i]; } 54 } 55 } 55 56 56 // ------------------------------------------- << 57 G4int G4UIcommandTree::operator==(const G4UIcommandTree &right) const 57 G4bool G4UIcommandTree::operator==(const G4UIc << 58 { 58 { 59 return (pathName == right.GetPathName()); << 59 return ( pathName == right.GetPathName() ); 60 } 60 } 61 61 62 // ------------------------------------------- << 62 G4int G4UIcommandTree::operator!=(const G4UIcommandTree &right) const 63 G4bool G4UIcommandTree::operator!=(const G4UIc << 64 { 63 { 65 return (pathName != right.GetPathName()); << 64 return ( pathName != right.GetPathName() ); 66 } 65 } 67 66 68 // ------------------------------------------- << 67 void G4UIcommandTree::AddNewCommand(G4UIcommand *newCommand) 69 void G4UIcommandTree::AddNewCommand(G4UIcomman << 70 { 68 { 71 G4String commandPath = newCommand->GetComman 69 G4String commandPath = newCommand->GetCommandPath(); 72 G4String remainingPath = commandPath; 70 G4String remainingPath = commandPath; 73 remainingPath.erase(0, pathName.length()); << 71 remainingPath.remove(0,pathName.length()); 74 if (remainingPath.empty()) { << 72 if( remainingPath.isNull() ) 75 if (guidance == nullptr) { << 73 { 76 guidance = newCommand; << 74 guidance = newCommand; 77 if (!(newCommand->ToBeBroadcasted())) { << 78 broadcastCommands = false; << 79 } << 80 if (workerThreadOnly) { << 81 newCommand->SetWorkerThreadOnly(); << 82 } << 83 } << 84 return; 75 return; 85 } 76 } 86 << 77 G4int i = remainingPath.first('/'); 87 if (guidance != nullptr) { << 78 if( i == G4int(G4std::string::npos) ) 88 auto* dir = static_cast<G4UIdirectory*>(gu << 79 { 89 ifSort = dir->IfSort(); << 80 // Find command 90 } << 81 G4int n_commandEntry = command.size(); 91 std::size_t i = remainingPath.find('/'); << 82 for( G4int i_thCommand = 0; i_thCommand < n_commandEntry; i_thCommand++ ) 92 if (i == std::string::npos) { << 83 { 93 // Adding a new command to this directory << 84 if( remainingPath == command[i_thCommand]->GetCommandName() ) 94 std::size_t n_commandEntry = command.size( << 85 { 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 } 86 } >> 87 command.push_back( newCommand ); 126 return; 88 return; 127 } 89 } 128 << 90 else 129 // Adding a new command to a sub-directory << 91 { 130 G4String nextPath = pathName; << 92 // Find path 131 nextPath.append(remainingPath.substr(0, i + << 93 G4String nextPath = pathName; 132 std::size_t n_treeEntry = tree.size(); << 94 nextPath.append(remainingPath(0,i+1)); 133 for (std::size_t i_thTree = 0; i_thTree < n_ << 95 G4int n_treeEntry = tree.size(); 134 if (nextPath == tree[i_thTree]->GetPathNam << 96 for( G4int i_thTree = 0; i_thTree < n_treeEntry; i_thTree++ ) 135 if (!broadcastCommands) { << 97 { 136 newCommand->SetToBeBroadcasted(false); << 98 if( nextPath == tree[i_thTree]->GetPathName() ) 137 } << 99 { 138 tree[i_thTree]->AddNewCommand(newCommand << 100 tree[i_thTree]->AddNewCommand( newCommand ); 139 return; << 101 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 } 102 } 150 } 103 } 151 tree.insert(j, newTree); << 104 G4UIcommandTree * newTree = new G4UIcommandTree( nextPath ); 152 } << 105 tree.push_back( newTree ); 153 else { << 106 newTree->AddNewCommand( newCommand ); 154 tree.push_back(newTree); << 107 return; 155 } << 156 if (!broadcastCommands) { << 157 newCommand->SetToBeBroadcasted(false); << 158 } 108 } 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 } 109 } 165 110 166 // ------------------------------------------- << 111 void G4UIcommandTree::RemoveCommand(G4UIcommand *aCommand) 167 void G4UIcommandTree::RemoveCommand(G4UIcomman << 168 { 112 { 169 if (workerThreadOnly && !(aCommand->IsWorker << 170 return; << 171 } << 172 G4String commandPath = aCommand->GetCommandP 113 G4String commandPath = aCommand->GetCommandPath(); 173 commandPath.erase(0, pathName.length()); << 114 G4String remainingPath = commandPath; 174 if (commandPath.empty()) { << 115 remainingPath.remove(0,pathName.length()); 175 guidance = nullptr; << 116 if( remainingPath.isNull() ) 176 } << 117 { 177 else { << 118 guidance = NULL; 178 std::size_t i = commandPath.find('/'); << 119 } 179 if (i == std::string::npos) { << 120 else >> 121 { >> 122 G4int i = remainingPath.first('/'); >> 123 if( i == G4int(G4std::string::npos) ) >> 124 { 180 // Find command 125 // Find command 181 std::size_t n_commandEntry = command.siz << 126 G4int n_commandEntry = command.size(); 182 for (std::size_t i_thCommand = 0; i_thCo << 127 for( G4int i_thCommand = 0; i_thCommand < n_commandEntry; i_thCommand++ ) 183 if (commandPath == command[i_thCommand << 128 { 184 command.erase(command.begin() + i_th << 129 if( remainingPath == command[i_thCommand]->GetCommandName() ) >> 130 { >> 131 command.erase(command.begin()+i_thCommand); 185 break; 132 break; 186 } 133 } 187 } 134 } 188 } 135 } 189 else { << 136 else >> 137 { 190 // Find path 138 // Find path 191 G4String nextPath = pathName; 139 G4String nextPath = pathName; 192 nextPath.append(commandPath.substr(0, i << 140 nextPath.append(remainingPath(0,i+1)); 193 std::size_t n_treeEntry = tree.size(); << 141 G4int n_treeEntry = tree.size(); 194 for (std::size_t i_thTree = 0; i_thTree << 142 for( G4int i_thTree = 0; i_thTree < n_treeEntry; i_thTree++ ) 195 if (nextPath == tree[i_thTree]->GetPat << 143 { 196 tree[i_thTree]->RemoveCommand(aComma << 144 if( nextPath == tree[i_thTree]->GetPathName() ) 197 G4int n_commandRemain = tree[i_thTre << 145 { 198 G4int n_treeRemain = tree[i_thTree]- << 146 tree[i_thTree]->RemoveCommand( aCommand ); 199 if (n_commandRemain == 0 && n_treeRe << 147 G4int n_commandRemain = tree[i_thTree]->GetCommandEntry(); 200 G4UIcommandTree* emptyTree = tree[ << 148 if(n_commandRemain==0) 201 tree.erase(tree.begin() + i_thTree << 149 { 202 delete emptyTree; << 150 G4UIcommandTree * emptyTree = tree[i_thTree]; 203 } << 151 tree.erase(tree.begin()+i_thTree); 204 break; << 152 delete emptyTree; >> 153 } >> 154 break; 205 } 155 } 206 } 156 } 207 } 157 } 208 } 158 } 209 } 159 } 210 160 211 // ------------------------------------------- << 161 G4UIcommand * G4UIcommandTree::FindPath(G4String commandPath) 212 G4UIcommand* G4UIcommandTree::FindPath(const c << 213 { 162 { 214 // This function tries to match a command na << 163 if( commandPath.index( pathName ) == G4std::string::npos ) 215 << 164 { return NULL; } 216 G4String remainingPath = commandPath; 165 G4String remainingPath = commandPath; 217 if (remainingPath.find(pathName) == std::str << 166 remainingPath.remove(0,pathName.length()); 218 return nullptr; << 167 G4int i = remainingPath.first('/'); 219 } << 168 if( i == G4int(G4std::string::npos) ) 220 remainingPath.erase(0, pathName.length()); << 169 { 221 std::size_t i = remainingPath.find('/'); << 222 if (i == std::string::npos) { << 223 // Find command 170 // Find command 224 std::size_t n_commandEntry = command.size( << 171 G4int n_commandEntry = command.size(); 225 for (std::size_t i_thCommand = 0; i_thComm << 172 for( G4int i_thCommand = 0; i_thCommand < n_commandEntry; i_thCommand++ ) 226 if (remainingPath == command[i_thCommand << 173 { 227 return command[i_thCommand]; << 174 if( remainingPath == command[i_thCommand]->GetCommandName() ) 228 } << 175 { 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 } 176 } 241 } 177 } 242 return nullptr; << 178 else 243 } << 179 { 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 180 // Find path 260 G4String nextPath = pathName; 181 G4String nextPath = pathName; 261 nextPath.append(remainingPath.substr(0, i << 182 nextPath.append(remainingPath(0,i+1)); 262 std::size_t n_treeEntry = tree.size(); << 183 G4int n_treeEntry = tree.size(); 263 for (std::size_t i_thTree = 0; i_thTree < << 184 for( G4int i_thTree = 0; i_thTree < n_treeEntry; i_thTree++ ) 264 if (tree[i_thTree]->GetPathName() == com << 185 { 265 return tree[i_thTree]; << 186 if( nextPath == tree[i_thTree]->GetPathName() ) 266 } << 187 { 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 } 188 } 378 } 189 } 379 << 190 return NULL; 380 return strMatched; << 381 } 191 } 382 192 383 // ------------------------------------------- << 193 void G4UIcommandTree::ListCurrent() 384 void G4UIcommandTree::ListCurrent() const << 385 { 194 { 386 G4cout << "Command directory path : " << pat 195 G4cout << "Command directory path : " << pathName << G4endl; 387 if (guidance != nullptr) { << 196 if( guidance != NULL ) guidance->List(); 388 guidance->List(); << 389 } << 390 G4cout << " Sub-directories : " << G4endl; 197 G4cout << " Sub-directories : " << G4endl; 391 std::size_t n_treeEntry = tree.size(); << 198 G4int n_treeEntry = tree.size(); 392 for (std::size_t i_thTree = 0; i_thTree < n_ << 199 for( G4int i_thTree = 0; i_thTree < n_treeEntry; i_thTree++ ) 393 G4cout << " " << tree[i_thTree]->GetPath << 200 { 394 if ((tree[i_thTree]->GetGuidance() != null << 201 G4cout << " " << tree[i_thTree]->GetPathName() 395 && tree[i_thTree]->GetGuidance()->IsWo << 202 << " " << tree[i_thTree]->GetTitle() << G4endl; 396 { << 397 G4cout << " @ "; << 398 } << 399 else { << 400 G4cout << " "; << 401 } << 402 G4cout << tree[i_thTree]->GetTitle() << G4 << 403 } 203 } 404 G4cout << " Commands : " << G4endl; 204 G4cout << " Commands : " << G4endl; 405 std::size_t n_commandEntry = command.size(); << 205 G4int n_commandEntry = command.size(); 406 for (std::size_t i_thCommand = 0; i_thComman << 206 for( G4int i_thCommand = 0; i_thCommand < n_commandEntry; i_thCommand++ ) 407 G4cout << " " << command[i_thCommand]->G << 207 { 408 if (command[i_thCommand]->IsWorkerThreadOn << 208 G4cout << " " << command[i_thCommand]->GetCommandName() 409 G4cout << " @ "; << 209 << " * " << command[i_thCommand]->GetTitle() << G4endl; 410 } << 411 else { << 412 G4cout << " * "; << 413 } << 414 G4cout << command[i_thCommand]->GetTitle() << 415 } 210 } 416 } 211 } 417 212 418 // ------------------------------------------- << 213 void G4UIcommandTree::ListCurrentWithNum() 419 void G4UIcommandTree::ListCurrentWithNum() con << 420 { 214 { 421 G4cout << "Command directory path : " << pat 215 G4cout << "Command directory path : " << pathName << G4endl; 422 if (guidance != nullptr) { << 216 if( guidance != NULL ) guidance->List(); 423 guidance->List(); << 424 } << 425 G4int i = 0; 217 G4int i = 0; 426 G4cout << " Sub-directories : " << G4endl; 218 G4cout << " Sub-directories : " << G4endl; 427 std::size_t n_treeEntry = tree.size(); << 219 G4int n_treeEntry = tree.size(); 428 for (std::size_t i_thTree = 0; i_thTree < n_ << 220 for( G4int i_thTree = 0; i_thTree < n_treeEntry; i_thTree++ ) 429 ++i; << 221 { 430 G4cout << " " << i << ") " << tree[i_thTre << 222 i++; 431 << tree[i_thTree]->GetTitle() << G4 << 223 G4cout << " " << i << ") " << tree[i_thTree]->GetPathName() >> 224 << " " << tree[i_thTree]->GetTitle() << G4endl; 432 } 225 } 433 G4cout << " Commands : " << G4endl; 226 G4cout << " Commands : " << G4endl; 434 std::size_t n_commandEntry = command.size(); << 227 G4int n_commandEntry = command.size(); 435 for (std::size_t i_thCommand = 0; i_thComman << 228 for( G4int i_thCommand = 0; i_thCommand < n_commandEntry; i_thCommand++ ) 436 ++i; << 229 { 437 G4cout << " " << i << ") " << command[i_th << 230 i++; 438 << command[i_thCommand]->GetTitle() << 231 G4cout << " " << i << ") " << command[i_thCommand]->GetCommandName() >> 232 << " * " << command[i_thCommand]->GetTitle() << G4endl; 439 } 233 } 440 } 234 } 441 235 442 // ------------------------------------------- << 236 void G4UIcommandTree::List() 443 void G4UIcommandTree::List() const << 444 { 237 { 445 ListCurrent(); 238 ListCurrent(); 446 std::size_t n_commandEntry = command.size(); << 239 G4int n_commandEntry = command.size(); 447 for (std::size_t i_thCommand = 0; i_thComman << 240 for( G4int i_thCommand = 0; i_thCommand < n_commandEntry; i_thCommand++ ) >> 241 { 448 command[i_thCommand]->List(); 242 command[i_thCommand]->List(); 449 } 243 } 450 std::size_t n_treeEntry = tree.size(); << 244 G4int n_treeEntry = tree.size(); 451 for (std::size_t i_thTree = 0; i_thTree < n_ << 245 for( G4int i_thTree = 0; i_thTree < n_treeEntry; i_thTree++ ) >> 246 { 452 tree[i_thTree]->List(); 247 tree[i_thTree]->List(); 453 } 248 } 454 } 249 } 455 250 456 // ------------------------------------------- << 251 G4String G4UIcommandTree::CreateFileName(G4String pName) 457 G4String G4UIcommandTree::CreateFileName(const << 458 { 252 { 459 G4String fn = pName; 253 G4String fn = pName; 460 std::size_t idxs; << 254 G4int idxs; 461 while ((idxs = fn.find('/')) != std::string: << 255 while((idxs=fn.index("/"))!=G4int(G4std::string::npos)) 462 fn[(G4int)idxs] = '_'; << 256 { fn(idxs) = '_'; } 463 } << 464 fn += ".html"; 257 fn += ".html"; 465 return fn; 258 return fn; 466 } 259 } 467 260 468 // ------------------------------------------- << 261 G4String G4UIcommandTree::ModStr(G4String str) 469 G4String G4UIcommandTree::ModStr(const char* s << 470 { 262 { 471 G4String sx; 263 G4String sx; 472 G4String str = strS; << 264 for(G4int i=0;i<G4int(str.length());i++) 473 for (G4int i = 0; i < G4int(str.length()); + << 265 { 474 char c = str[i]; << 266 char c = str(i); 475 switch (c) { << 267 switch(c) 476 case '<': << 268 { 477 sx += "<"; << 269 case '<': 478 break; << 270 sx += "<"; break; 479 case '>': << 271 case '>': 480 sx += ">"; << 272 sx += ">"; break; 481 break; << 273 case '&': 482 case '&': << 274 sx += "&"; break; 483 sx += "&"; << 275 default: 484 break; << 276 sx += c; 485 default: << 486 sx += c; << 487 } 277 } 488 } 278 } 489 return sx; 279 return sx; 490 } 280 } 491 281 492 // ------------------------------------------- << 282 void G4UIcommandTree::CreateHTML() 493 void G4UIcommandTree::CreateHTML(const G4Strin << 494 { 283 { 495 G4String ofileName = CreateFileName(pathName 284 G4String ofileName = CreateFileName(pathName); 496 std::ofstream oF(ofileName, std::ios::out); << 285 G4std::ofstream oF(ofileName, G4std::ios::out); 497 286 498 oF << "<html><head><title>Commands in " << M 287 oF << "<html><head><title>Commands in " << ModStr(pathName) << "</title></head>" << G4endl; 499 oF << "<style> \ << 288 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 << 610 if (!command.empty()) { << 611 oF << "<h2>Commands </h2>" << G4endl; << 612 289 613 // resume << 290 if( guidance != NULL ) 614 oF << "<table>" << G4endl; << 291 { 615 for (std::size_t i_thCommand = 0; i_thComm << 292 for(G4int i=0;i<guidance->GetGuidanceEntries();i++) 616 G4UIcommand* cmd = command[i_thCommand]; << 293 { oF << ModStr(guidance->GetGuidanceLine(i)) << "<br>" << G4endl; } 617 oF << "<tr><td><a href=\"#c" << i_thComm << 294 } 618 oF << "</a></td></tr>" << G4endl; << 295 >> 296 oF << "<p><hr><p>" << G4endl; >> 297 >> 298 oF << "<h2>Sub-directories : </h2><dl>" << G4endl; >> 299 for( G4int i_thTree = 0; i_thTree < G4int(tree.size()); i_thTree++ ) >> 300 { >> 301 oF << "<p><br><p><dt><a href=\"" << CreateFileName(tree[i_thTree]->GetPathName()) >> 302 << "\">" << ModStr(tree[i_thTree]->GetPathName()) << "</a>" << G4endl; >> 303 oF << "<p><dd>" << ModStr(tree[i_thTree]->GetTitle()) << G4endl; >> 304 tree[i_thTree]->CreateHTML(); >> 305 } >> 306 >> 307 oF << "</dl><p><hr><p>" << G4endl; >> 308 >> 309 oF << "<h2>Commands : </h2><dl>" << G4endl; >> 310 for( G4int i_thCommand = 0; i_thCommand < G4int(command.size()); i_thCommand++ ) >> 311 { >> 312 G4UIcommand* cmd = command[i_thCommand]; >> 313 oF << "<p><br><p><dt><b>" << ModStr(cmd->GetCommandName()); >> 314 if(cmd->GetParameterEntries()>0) >> 315 { >> 316 for(G4int i_thParam=0;i_thParam<cmd->GetParameterEntries();i_thParam++) >> 317 { oF << " [<i>" << ModStr(cmd->GetParameter(i_thParam)->GetParameterName()) << "</i>]"; } 619 } 318 } 620 oF << "</table>" << G4endl; << 319 oF << "</b>" << G4endl; 621 for (std::size_t i_thCommand = 0; i_thComm << 320 oF << "<p><dd>" << G4endl; 622 G4UIcommand* cmd = command[i_thCommand]; << 321 for(G4int i=0;i<cmd->GetGuidanceEntries();i++) 623 oF << "<h3 id=\"c" << i_thCommand << "\" << 322 { oF << ModStr(cmd->GetGuidanceLine(i)) << "<br>" << G4endl; } 624 if (cmd->GetParameterEntries() > 0) { << 323 if(!(cmd->GetRange()).isNull()) 625 for (G4int i_thParam = 0; i_thParam < << 324 { oF << "<p><dd>Range : " << ModStr(cmd->GetRange()) << G4endl; } 626 oF << " [<i>" << ModStr(cmd->GetPara << 325 G4std::vector<G4ApplicationState>* availabelStateList = cmd->GetStateList(); 627 } << 326 if(availabelStateList->size()==6) 628 } << 327 { oF << "<p><dd>Available at all Geant4 states." << G4endl; } 629 oF << "</h3>" << G4endl; << 328 else 630 oF << "<p>" << G4endl; << 329 { 631 for (G4int i = 0; i < (G4int)cmd->GetGui << 330 oF << "<p><dd>Available Geant4 state(s) : "; 632 oF << ModStr(cmd->GetGuidanceLine(i)) << 331 for(G4int ias=0;ias<G4int(availabelStateList->size());ias++) 633 } << 332 { oF << G4StateManager::GetStateManager()->GetStateString((*availabelStateList)[ias]) << " " << G4endl; } 634 if (!(cmd->GetRange()).empty()) { << 333 } 635 oF << "<p>Range : " << ModStr(cmd->Get << 334 if(cmd->GetParameterEntries()>0) 636 } << 335 { 637 std::vector<G4ApplicationState>* availab << 336 oF << "<p><dd>Parameters<table border=1>" << G4endl; 638 if (availabelStateList->size() == 6) { << 337 for(G4int i_thParam=0;i_thParam<cmd->GetParameterEntries();i_thParam++) 639 oF << "<p>Available at all Geant4 stat << 338 { 640 } << 339 G4UIparameter* prm = cmd->GetParameter(i_thParam); 641 else { << 340 oF << "<tr><td>" << ModStr(prm->GetParameterName()) << G4endl; 642 oF << "<p>Available Geant4 state(s) : << 341 oF << "<td>type " << prm->GetParameterType() << G4endl; 643 for (auto& ias : *availabelStateList) << 342 oF << "<td>"; 644 oF << G4StateManager::GetStateManage << 343 if(prm->IsOmittable()) 645 } << 344 { 646 } << 345 oF << "Omittable : "; 647 if (cmd->GetParameterEntries() > 0) { << 346 if(prm->GetCurrentAsDefault()) 648 oF << "<p>Parameters<table border=1>" << 347 { oF << "current value is used as the default value." << G4endl; } 649 for (G4int i_thParam = 0; i_thParam < << 348 else 650 G4UIparameter* prm = cmd->GetParamet << 349 { 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 } 350 } 671 oF << "</table>" << G4endl; << 351 oF << "<td>"; >> 352 if(!(prm->GetParameterRange()).isNull()) >> 353 { oF << "Parameter range : " << ModStr(prm->GetParameterRange()) << G4endl; } >> 354 else if(!(prm->GetParameterCandidates()).isNull()) >> 355 { oF << "Parameter candidates : " << ModStr(prm->GetParameterCandidates()) << G4endl; } 672 } 356 } >> 357 oF << "</table>" << G4endl; 673 } 358 } >> 359 674 } 360 } 675 oF << "</div></body></html>" << G4endl; << 361 >> 362 oF << "</dl></body></html>" << G4endl; 676 oF.close(); 363 oF.close(); 677 } 364 } 678 365 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 366