Annotation of modules/damieng/graphical_editor/daxe/lib/src/config.dart, revision 1.1
1.1 ! damieng 1: /*
! 2: This file is part of Daxe.
! 3:
! 4: Daxe is free software: you can redistribute it and/or modify
! 5: it under the terms of the GNU General Public License as published by
! 6: the Free Software Foundation, either version 3 of the License, or
! 7: (at your option) any later version.
! 8:
! 9: Daxe is distributed in the hope that it will be useful,
! 10: but WITHOUT ANY WARRANTY; without even the implied warranty of
! 11: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! 12: GNU General Public License for more details.
! 13:
! 14: You should have received a copy of the GNU General Public License
! 15: along with Daxe. If not, see <http://www.gnu.org/licenses/>.
! 16: */
! 17:
! 18: part of daxe;
! 19:
! 20:
! 21: /**
! 22: * A Jaxe configuration file. Includes many useful methods to use XML schemas.
! 23: */
! 24: class Config {
! 25: static final String _typeAffichageParDefaut = "string";
! 26:
! 27: x.Element _cfgroot; // config file root element
! 28:
! 29: String schemaURL; // schema file URL
! 30:
! 31: String _cfgdir; // config folder URL (in which the config file must be)
! 32:
! 33: HashMap<String, x.Element> _elementDisplayCache; // cache for associations nom -> AFFICHAGE_ELEMENT
! 34: HashMap<x.Element, String> _elementsToNamesCache; // cache for associations element reference -> name
! 35: HashMap<x.Element, String> _elementsTitlesCache; // cache for associations element reference -> title
! 36: HashMap<x.Element, Pattern> _insertCache = null; // cache for regular expressions for insertions
! 37: HashMap<x.Element, Pattern> _validPatternCache = null;
! 38: HashMap<x.Element, HashMap<String, List<String>>> _parametersCache = null;
! 39: List<String> _namespaceCache = null; // namespace list
! 40:
! 41: InterfaceSchema _schema; // all the schema management (validity...)
! 42:
! 43: // nodes for the config file main elements
! 44: x.Element _languageNode;
! 45: x.Element _savingNode;
! 46: x.Element _menusNode;
! 47: x.Element _displayNode;
! 48: x.Element _exportsNode;
! 49: List<x.Element> _listeStrings;
! 50:
! 51:
! 52: // CONSTRUCTORS AND INITIALIZATION
! 53:
! 54: /**
! 55: * Constructor (load must be called afterwards)
! 56: */
! 57: Config() {
! 58: }
! 59:
! 60: /**
! 61: * Load a config file
! 62: *
! 63: * @param cfgFilePath path to the config file
! 64: */
! 65: Future load(final String cfgFilePath) { // throws DaxeException
! 66: Completer completer = new Completer();
! 67: if (cfgFilePath == null) {
! 68: _cfgroot = null;
! 69: return(new Future.error(new DaxeException("Config.load: null path")));
! 70: }
! 71:
! 72: x.DOMParser dp = new x.DOMParser();
! 73: dp.parseFromURL(cfgFilePath).then((x.Document configdoc) {
! 74: String resource;
! 75: if (configdoc.documentElement.nodeName == "CONFIG_JAXE")
! 76: resource = null;
! 77: else
! 78: resource = _getResource(configdoc.documentElement);
! 79:
! 80: _cfgdir = _getParentURL(cfgFilePath);
! 81:
! 82: _cfgroot = configdoc.documentElement;
! 83:
! 84: // AUTRE_CONFIG: ignored
! 85:
! 86: _buildElementDisplayCache();
! 87:
! 88: _elementsTitlesCache = new HashMap<x.Element, String>();
! 89:
! 90: final String noms = schemaName();
! 91: if (noms == null) {
! 92: final x.Element schema_simple = _findElement(_getLanguage(), "SCHEMA_SIMPLE");
! 93: if (schema_simple == null) {
! 94: completer.completeError(new DaxeException("Error: no XML schema is defined in the config file $cfgFilePath"));
! 95: return;
! 96: }
! 97: _schema = new SimpleSchema(schema_simple, _titlesHash());
! 98: schemaURL = null;
! 99: _buildElementsToNamesCache();
! 100: completer.complete();
! 101: return;
! 102: }
! 103:
! 104: if (_cfgdir != null)
! 105: schemaURL = "${_cfgdir}/$noms";
! 106: else
! 107: schemaURL = noms;
! 108: _schema = new DaxeWXS(_titlesHash());
! 109: (_schema as DaxeWXS).load(schemaURL).then((_) {
! 110: _buildElementsToNamesCache();
! 111: completer.complete();
! 112: }, onError: (WXSException ex) {
! 113: completer.completeError(new DaxeException("Error reading schemaURL: $ex"));
! 114: });
! 115: }, onError: (x.DOMException ex) {
! 116: completer.completeError(new DaxeException("Error reading $cfgFilePath: $ex"));
! 117: });
! 118: return(completer.future);
! 119: }
! 120:
! 121: /**
! 122: * Returns the URL of the parent of the given URL (file or directory),
! 123: * or null if the parent directory cannot be found
! 124: */
! 125: static String _getParentURL(final String u) {
! 126: final int index = u.lastIndexOf("/");
! 127: if (index >= 0) {
! 128: return(u.substring(0, index));
! 129: }
! 130: return(null);
! 131: }
! 132:
! 133:
! 134: // METHODS RELATED TO THE CONFIG FILE
! 135:
! 136: /**
! 137: * Returns the name of the first possible root element, or null if none are defined.
! 138: */
! 139: String nameOfFirstRootElement() {
! 140: final x.Element racine = _findElement(_getLanguage(), "RACINE");
! 141: if (racine == null)
! 142: return(null);
! 143: return(racine.getAttribute("element"));
! 144: }
! 145:
! 146: /**
! 147: * Returns the reference to the first possible root element, or null if none are defined.
! 148: */
! 149: x.Element firstRootElement() {
! 150: final String nom = nameOfFirstRootElement();
! 151: return(_schema.elementReferenceByName(nom));
! 152: }
! 153:
! 154: /**
! 155: * Returns the list of names of the possible root elements
! 156: */
! 157: List<String> listOfRoots() {
! 158: final List<String> liste = new List<String>();
! 159: x.Element racine = _findElement(_getLanguage(), "RACINE");
! 160: while (racine != null) {
! 161: liste.add(racine.getAttribute("element"));
! 162: racine = _nextElement(racine, "RACINE");
! 163: }
! 164: return(liste);
! 165: }
! 166:
! 167: /**
! 168: * Returns the list of references to the possible root elements
! 169: */
! 170: List<x.Element> rootElements() {
! 171: // pour éviter une erreur dans le cas d'un schéma définissant un élément global et un élément local
! 172: // sous le même nom mais avec des types différents, on est obligé d'aller d'abord chercher les références
! 173: // des éléments racines en fonction de l'implémentation du schéma, puis de chercher dedans les éléments
! 174: // avec les noms donnés dans la config.
! 175: final List<x.Element> liste = new List<x.Element>();
! 176: final List<x.Element> racinesPossibles = _schema.rootElements();
! 177: x.Element racine = _findElement(_getLanguage(), "RACINE");
! 178: while (racine != null) {
! 179: final String nom = racine.getAttribute("element");
! 180: for (final x.Element ref in racinesPossibles)
! 181: if (nom == _schema.elementName(ref))
! 182: liste.add(ref);
! 183: racine = _nextElement(racine, "RACINE");
! 184: }
! 185: return(liste);
! 186: }
! 187:
! 188: /**
! 189: * Adds the attributes for the namespaces to the root node
! 190: */
! 191: void addNamespaceAttributes(final DaxeNode root) {
! 192: final List<String> espaces = _namespaceList();
! 193: for (final String espace in espaces) {
! 194: if (espace != "") {
! 195: final String prefixe = namespacePrefix(espace);
! 196: String nomatt;
! 197: if (prefixe != null && prefixe != "")
! 198: nomatt = "xmlns:$prefixe";
! 199: else
! 200: nomatt = "xmlns";
! 201: root.setAttributeNS("http://www.w3.org/2000/xmlns/", nomatt, espace);
! 202: }
! 203: }
! 204: final String schemaLocation = getSchemaLocation();
! 205: final String noNamespaceSchemaLocation = getNoNamespaceSchemaLocation();
! 206: if (schemaLocation != null || noNamespaceSchemaLocation != null) {
! 207: root.setAttributeNS("http://www.w3.org/2000/xmlns/", "xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
! 208: if (schemaLocation != null)
! 209: root.setAttributeNS("http://www.w3.org/2001/XMLSchema-instance",
! 210: "xsi:schemaLocation", schemaLocation);
! 211: if (noNamespaceSchemaLocation != null)
! 212: root.setAttributeNS("http://www.w3.org/2001/XMLSchema-instance",
! 213: "xsi:noNamespaceSchemaLocation", noNamespaceSchemaLocation);
! 214: }
! 215: }
! 216:
! 217: /**
! 218: * Returns the name of the schema file as given in the config file
! 219: * (FICHIER_SCHEMA/@nom)
! 220: * Returns null if none is defined
! 221: */
! 222: String schemaName() {
! 223: final x.Element fichierschema = _findElement(_getLanguage(), "FICHIER_SCHEMA");
! 224: if (fichierschema == null)
! 225: return(null);
! 226: String nom = fichierschema.getAttribute("nom");
! 227: if (nom == "")
! 228: nom = null;
! 229: return(nom);
! 230: }
! 231:
! 232: /**
! 233: * Returns the hash table by name of the element displays in the config file
! 234: * (element AFFICHAGE_ELEMENT)
! 235: */
! 236: HashMap<String, x.Element> _buildElementDisplayCache() {
! 237: _elementDisplayCache = new HashMap<String, x.Element>();
! 238: if (_cfgroot == null)
! 239: return(_elementDisplayCache);
! 240: x.Element affel = _findElement(_getNodeDisplay(), "AFFICHAGE_ELEMENT");
! 241: while (affel != null) {
! 242: final String nom = affel.getAttribute("element");
! 243: _elementDisplayCache[nom] = affel;
! 244: affel = _nextElement(affel, "AFFICHAGE_ELEMENT");
! 245: }
! 246: return(_elementDisplayCache);
! 247: }
! 248:
! 249: HashMap<x.Element, String> _getElementsToNamesCache() {
! 250: return(_elementsToNamesCache);
! 251: }
! 252:
! 253: x.Element getElementDisplay(String name) {
! 254: return _elementDisplayCache[name];
! 255: }
! 256:
! 257: /**
! 258: * Builds the hash table of associations schema reference -> element name
! 259: */
! 260: void _buildElementsToNamesCache() {
! 261: _elementsToNamesCache = new HashMap<x.Element, String>();
! 262: if (_cfgroot == null)
! 263: return;
! 264: final List<x.Element> elements = _schema.allElements();
! 265: for (final x.Element ref in elements) {
! 266: final String nom = _schema.elementName(ref);
! 267: if (nom != null)
! 268: _elementsToNamesCache[ref] = nom;
! 269: }
! 270: }
! 271:
! 272: /**
! 273: * Return the name of the resource bundle to use.
! 274: *
! 275: * @return the name of the resource bundle, null if not defined.
! 276: */
! 277: String _getResource(final x.Element root) {
! 278: final x.Element bundle = _findElement(root, "FICHIERTITRES");
! 279: if (bundle == null)
! 280: return(null);
! 281: return(bundle.getAttribute("nom"));
! 282: }
! 283:
! 284: /**
! 285: * Returns the list of export references, depending on the output (HTML or XML)
! 286: */
! 287: List<x.Element> exportsList(final String output) {
! 288: if (_cfgroot == null)
! 289: return(null);
! 290: final List<x.Element> liste = new List<x.Element>();
! 291: x.Element export = _findElement(_getExports(), "EXPORT");
! 292: while (export != null) {
! 293: if (output == export.getAttribute("sortie"))
! 294: liste.add(export);
! 295: export = _nextElement(export, "EXPORT");
! 296: }
! 297: return(liste);
! 298: }
! 299:
! 300: /**
! 301: * Returns an export name based on its reference
! 302: */
! 303: String exportName(final x.Element exportRef) {
! 304: return(exportRef.getAttribute("nom"));
! 305: }
! 306:
! 307: /**
! 308: * Returns the output of an export based on its reference
! 309: */
! 310: String exportOutput(final x.Element exportRef) {
! 311: return(exportRef.getAttribute("sortie"));
! 312: }
! 313:
! 314: /**
! 315: * Returns the character encoding to use for new XML documents
! 316: */
! 317: String getEncoding() {
! 318: final x.Element encodage = _findElement(_getSaving(), "ENCODAGE");
! 319: if (encodage == null)
! 320: return(null);
! 321: return(_dom_elementValue(encodage));
! 322: }
! 323:
! 324: String getPublicId() {
! 325: final x.Element doctype = _findElement(_getSaving(), "DOCTYPE");
! 326: if (doctype != null)
! 327: return doctype.getAttribute("publicId");
! 328:
! 329: return(null);
! 330: }
! 331:
! 332: String getSystemId() {
! 333: final x.Element doctype = _findElement(_getSaving(), "DOCTYPE");
! 334: if (doctype != null)
! 335: return doctype.getAttribute("systemId");
! 336: return(null);
! 337: }
! 338:
! 339: String getSchemaLocation() {
! 340: final x.Element sl = _findElement(_getSaving(), "SCHEMALOCATION");
! 341: if (sl != null) {
! 342: final String schemaLocation = sl.getAttribute("schemaLocation");
! 343: if (schemaLocation != "")
! 344: return(schemaLocation);
! 345: }
! 346: return(null);
! 347: }
! 348:
! 349: String getNoNamespaceSchemaLocation() {
! 350: final x.Element sl = _findElement(_getSaving(), "SCHEMALOCATION");
! 351: if (sl != null) {
! 352: final String noNamespaceSchemaLocation = sl.getAttribute("noNamespaceSchemaLocation");
! 353: if (noNamespaceSchemaLocation != "")
! 354: return(noNamespaceSchemaLocation);
! 355: }
! 356: return(null);
! 357: }
! 358:
! 359: /**
! 360: * Returns a prefix to use for the given namespace, or null if none is found
! 361: */
! 362: String namespacePrefix(final String namespace) {
! 363: if (namespace == "http://www.w3.org/XML/1998/namespace")
! 364: return("xml");
! 365: x.Element pe = _findElement(_getSaving(), "PREFIXE_ESPACE");
! 366: while (pe != null) {
! 367: if (namespace == pe.getAttribute("uri"))
! 368: return(pe.getAttribute("prefixe"));
! 369: pe = _nextElement(pe, "PREFIXE_ESPACE");
! 370: }
! 371: return(_schema.namespacePrefix(namespace));
! 372: }
! 373:
! 374:
! 375: // METHODS FOR THE ELEMENT INSERT MENUS
! 376:
! 377: /**
! 378: * Returns a menu matching the menu definition in the config file.
! 379: *
! 380: * @param doc The Daxe document
! 381: * @param menudef The MENU element in the config file
! 382: */
! 383: Menu _creationMenu(final DaxeDocument doc, final x.Element menudef) {
! 384: final String nomMenu = menudef.getAttribute("nom");
! 385: String titreM = menuTitle(nomMenu);
! 386: final Menu menu = new Menu(titreM);
! 387: String docMenu = menuDocumentation(nomMenu);
! 388: if (docMenu != null) {
! 389: //docMenu = "<html><body>{docMenu.replaceAll('\n', '<br>')}</body></html>";
! 390: menu.toolTipText = docMenu;
! 391: }
! 392: x.Node menunode = menudef.firstChild;
! 393: while (menunode != null) {
! 394: MenuItem item = null;
! 395: final String nodename = menunode.nodeName;
! 396: String shortcut = null;
! 397: if (menunode is x.Element) {
! 398: final String commande = (menunode as x.Element).getAttribute("raccourci");
! 399: if (commande != null && commande != "") {
! 400: shortcut = commande.toUpperCase()[0];
! 401: }
! 402: }
! 403: if (nodename == "MENU_INSERTION") {
! 404: final x.Element insnoeud = menunode as x.Element;
! 405: final String nom = insnoeud.getAttribute("nom");
! 406: final String titre = menuTitle(nom);
! 407: String typeNoeud = insnoeud.getAttribute("type_noeud");
! 408: if (typeNoeud == "")
! 409: typeNoeud = "element";
! 410: x.Element refElement;
! 411: if (typeNoeud == "element") {
! 412: refElement = elementReference(nom);
! 413: if (refElement == null)
! 414: logError("Erreur: MENU_INSERTION: pas de référence pour '$nom' dans le schéma");
! 415: } else
! 416: refElement = null;
! 417: item = new MenuItem(titre, () => doc.insertNewNode(refElement, typeNoeud), shortcut: shortcut, data: refElement);
! 418: menu.add(item);
! 419: String itemdoc = documentation(refElement);
! 420: if (itemdoc != null) {
! 421: //itemdoc = formatDoc(itemdoc);
! 422: item.toolTipText = itemdoc;
! 423: }
! 424: } else if (nodename == "MENU_FONCTION") {
! 425: final x.Element fonction = menunode as x.Element;
! 426: final String classe = fonction.getAttribute("classe");
! 427: final String nom = fonction.getAttribute("nom");
! 428: final String titre = menuTitle(nom);
! 429: item = new MenuItem(titre, () => doc.executeFunction(classe, fonction), shortcut: shortcut);
! 430: menu.add(item);
! 431: String itemdoc = menuDocumentation(nom);
! 432: if (itemdoc != null) {
! 433: //itemdoc = formatDoc(itemdoc);
! 434: item.toolTipText = itemdoc;
! 435: }
! 436: } else if (nodename == "MENU") {
! 437: item = _creationMenu(doc, menunode as x.Element);
! 438: menu.add(item);
! 439: } else if (nodename == "SEPARATEUR")
! 440: menu.addSeparator();
! 441:
! 442: menunode = menunode.nextSibling;
! 443: }
! 444: return(menu);
! 445: }
! 446:
! 447: /**
! 448: * Returns a menubar to insert menus.
! 449: *
! 450: * @param doc The Daxe document
! 451: */
! 452: MenuBar makeMenus(final DaxeDocument doc) {
! 453: final MenuBar mbar = new MenuBar();
! 454:
! 455: final x.Element menus = _getMenus();
! 456: if (menus != null) {
! 457: x.Element menudef = _findElement(menus, "MENU");
! 458: while (menudef != null) {
! 459: final Menu jmenu = _creationMenu(doc, menudef);
! 460: jmenu.parent = mbar;
! 461: mbar.add(jmenu);
! 462: menudef = _nextElement(menudef, "MENU");
! 463: }
! 464: }
! 465: return(mbar);
! 466: }
! 467:
! 468:
! 469: // METHODS RELATED TO THE SCHEMA
! 470:
! 471: InterfaceSchema getSchema() {
! 472: return(_schema);
! 473: }
! 474:
! 475: /**
! 476: * Returns the references for all the elements in the schema
! 477: */
! 478: List<x.Element> allElementsList() {
! 479: final List<x.Element> liste = _schema.allElements();
! 480: return(liste);
! 481: }
! 482:
! 483: bool _elementInSchema(final x.Element elementRef) {
! 484: return(_schema.elementInSchema(elementRef));
! 485: }
! 486:
! 487: /**
! 488: * Returns the name of the element
! 489: */
! 490: String elementName(final x.Element elementRef) {
! 491: return(_elementsToNamesCache[elementRef]);
! 492: }
! 493:
! 494: /**
! 495: * Returns the reference of the first matching element in the schema,
! 496: * based on the element and the reference of its parent
! 497: */
! 498: x.Element getElementRef(final x.Element el, final x.Element parentRef) {
! 499: return(_schema.elementReference(el, parentRef));
! 500: }
! 501:
! 502: /**
! 503: * Returns the reference for the first element with the given name
! 504: */
! 505: x.Element elementReference(final String name) {
! 506: final x.Element el = _schema.elementReferenceByName(localValue(name));
! 507: return(el);
! 508: }
! 509:
! 510: /**
! 511: * Returns the references of the elements with the given name
! 512: */
! 513: List<x.Element> elementReferences(final String name) {
! 514: return(_schema.elementReferencesByName(localValue(name)));
! 515: }
! 516:
! 517: /**
! 518: * Returns the namespace to use for the element,
! 519: * or null the namespace is undefined.
! 520: */
! 521: String elementNamespace(final x.Element elementRef) {
! 522: return(_schema.elementNamespace(elementRef));
! 523: }
! 524:
! 525: /**
! 526: * Returns the prefix to use for a new element with the given reference,
! 527: * or null if no prefix should be used.
! 528: */
! 529: String elementPrefix(final x.Element elementRef) {
! 530: final String espace = elementNamespace(elementRef);
! 531: if (espace == null)
! 532: return(null);
! 533: return(namespacePrefix(espace));
! 534: }
! 535:
! 536: /**
! 537: * Returns the list of possible values for an element.
! 538: * Returns null if there are an infinity of possible values.
! 539: */
! 540: List<String> elementValues(final x.Element elementRef) {
! 541: final List<String> liste = _schema.elementValues(elementRef);
! 542: return(liste);
! 543: }
! 544:
! 545: /**
! 546: * Returns true if the given value is valid for the element
! 547: */
! 548: bool isElementValueValid(final x.Element elementRef, final String value) {
! 549: return(_schema.elementValueIsValid(elementRef, value));
! 550: }
! 551:
! 552: /**
! 553: * Returns the list of all namespaces in the schema
! 554: */
! 555: List<String> _namespaceList() {
! 556: if (_namespaceCache != null)
! 557: return(_namespaceCache);
! 558: final List<String> liste = new List<String>();
! 559: final List<String> espacesSchema = _schema.namespaceList();
! 560: if (espacesSchema != null)
! 561: liste.addAll(espacesSchema);
! 562: _namespaceCache = liste;
! 563: return(liste);
! 564: }
! 565:
! 566: /**
! 567: * Returns a number for the given namespace, starting from 0.
! 568: * A unique number is given for each namespace.
! 569: * Returns -1 if the namespace is not found in the config.
! 570: */
! 571: int namespaceNumber(final String namespace) {
! 572: final List<String> liste = _namespaceList();
! 573: return(liste.indexOf(namespace));
! 574: }
! 575:
! 576: /**
! 577: * Returns true if the namspace is defined in the config
! 578: */
! 579: bool hasNamespace(final String namespace) {
! 580: return(_schema.hasNamespace(namespace));
! 581: }
! 582:
! 583: /**
! 584: * Returns the target namespace for the schema (targetNamespace attribute for WXS)
! 585: */
! 586: String targetNamespace() {
! 587: return(_schema.getTargetNamespace());
! 588: }
! 589:
! 590: /**
! 591: * Returns the references of the elements which are not in the given namespace
! 592: */
! 593: List<x.Element> elementsOutsideNamespace(final String namespace) {
! 594: return(_schema.elementsOutsideNamespace(namespace));
! 595: }
! 596:
! 597: /**
! 598: * Returns the references of the elements which are in the given namespaces
! 599: */
! 600: List<x.Element> elementsWithinNamespaces(final Set<String> namespaces) {
! 601: return(_schema.elementsWithinNamespaces(namespaces));
! 602: }
! 603:
! 604: /**
! 605: * Returns true if the child is required under the parent.
! 606: */
! 607: bool requiredElement(final x.Element parentRef, final x.Element childRef) {
! 608: return(_schema.requiredElement(parentRef, childRef));
! 609: }
! 610:
! 611: /**
! 612: * Returns true if there is a relation parent-child between the 2 elements
! 613: */
! 614: bool isSubElement(final x.Element parentRef, final x.Element childRef) {
! 615: final List<x.Element> children = subElements(parentRef);
! 616: if (children == null)
! 617: return(false);
! 618: return(children.contains(childRef));
! 619: }
! 620:
! 621: /**
! 622: * Returns the first reference in the list that is a child of the parent, or null if none is found.
! 623: */
! 624: x.Element findSubElement(final x.Element parentRef, final List<x.Element> refs) {
! 625: final List<x.Element> children = subElements(parentRef);
! 626: if (children == null)
! 627: return(null);
! 628: for (x.Element ref in refs)
! 629: if (children.contains(ref))
! 630: return(ref);
! 631: return(null);
! 632: }
! 633:
! 634: /**
! 635: * Returns true if the given name matches a possible child for the given parent
! 636: */
! 637: bool isSubElementByName(final x.Element parentRef, String childName) {
! 638: final int inds = childName.indexOf(':');
! 639: if (inds != -1)
! 640: childName = childName.substring(inds+1);
! 641: final List<String> noms = subElementsNames(parentRef);
! 642: return(noms.contains(childName));
! 643: }
! 644:
! 645: /**
! 646: * Returns the references of the given element's children
! 647: */
! 648: List<x.Element> subElements(final x.Element parentRef) {
! 649: return(_schema.subElements(parentRef));
! 650: }
! 651:
! 652: /**
! 653: * Returns the names of the given element's children
! 654: */
! 655: List<String> subElementsNames(final x.Element parentRef) {
! 656: final List<x.Element> listeReferences = subElements(parentRef);
! 657: final List<String> listeNoms = new List<String>();
! 658: for (final x.Element ref in listeReferences) {
! 659: final String nom = _elementsToNamesCache[ref];
! 660: if (!listeNoms.contains(nom))
! 661: listeNoms.add(nom);
! 662: }
! 663: return(listeNoms);
! 664: }
! 665:
! 666: /**
! 667: * Regular expression for a given element
! 668: * @param modevisu True to get a regular expression to display to the user
! 669: * @param modevalid For strict validation instead of checking if an insert is possible
! 670: */
! 671: String _regularExpression(final x.Element parentRef, final bool modevisu, final bool modevalid) {
! 672: return(_schema.regularExpression(parentRef, modevisu, modevalid));
! 673: }
! 674:
! 675: /**
! 676: * Regular expression based on the schema for a given parent element
! 677: */
! 678: String regularExpression(final x.Element parentRef) {
! 679: return(_schema.regularExpression(parentRef, true, false));
! 680: }
! 681:
! 682: /**
! 683: * Returns true if the toInsert element can be inserted under the parent element
! 684: * on the selection defined by the start and end positions
! 685: */
! 686: bool insertIsPossible(DaxeNode parent, final int startOffset, final int endOffset, final x.Element toInsert) {
! 687: if (parent.nodeType == DaxeNode.DOCUMENT_NODE) {
! 688: for (DaxeNode dn in parent.childNodes) {
! 689: if (dn.nodeType == DaxeNode.ELEMENT_NODE)
! 690: return(false);
! 691: }
! 692: return(true);
! 693: }
! 694: assert(parent.nodeType == DaxeNode.ELEMENT_NODE);
! 695: if (_schema is SimpleSchema)
! 696: return(true); // on suppose que le test de sous-élément a déjà été fait
! 697: if (startOffset < 0) {
! 698: logError("Config.insertionPossible: debutSelection < parent.debut");
! 699: return(false);
! 700: }
! 701: if (_schema is DaxeWXS) {
! 702: final List<x.Element> sousElements = new List<x.Element>();
! 703: bool ajoute = false;
! 704: for (DaxeNode dn = parent.firstChild; dn != null; dn = dn.nextSibling) {
! 705: if (dn.nodeType == DaxeNode.ELEMENT_NODE) {
! 706: int offset = parent.offsetOf(dn);
! 707: if (offset < startOffset || offset >= endOffset) {
! 708: if (!ajoute && offset >= endOffset) {
! 709: sousElements.add(toInsert);
! 710: ajoute = true;
! 711: }
! 712: sousElements.add(dn.ref);
! 713: }
! 714: }
! 715: }
! 716: if (!ajoute)
! 717: sousElements.add(toInsert);
! 718: final bool insertionOK = (_schema as DaxeWXS).validElement(parent.ref, sousElements, true);
! 719: return(insertionOK);
! 720: }
! 721: return(false);
! 722: /*
! 723: pb: on ne peut pas tester l'ordre des éléments dans certains cas, par exemple:
! 724: <html>
! 725: <head>
! 726: <xsl:if test='truc'>
! 727: <title>xxx</title>
! 728: </xsl:if>
! 729: <xsl:if test='not(truc)'>
! 730: <title>yyy</title>
! 731: </xsl:if>
! 732: </head>
! 733: </html>
! 734: Ici on autorise deux éléments title sous head alors qu'un seul est normalement autorisé.
! 735: Par contre on peut tester les imbrications (title est autorisé sous head).
! 736: */
! 737: }
! 738:
! 739: /**
! 740: * Returns true if the parent element is valid, considering its attributes,
! 741: * its first level children, its node value, and its parent if there is one.
! 742: */
! 743: bool elementIsValid(final DaxeNode parent) {
! 744: if (parent is DNComment || parent is DNProcessingInstruction || parent is DNCData)
! 745: return(true);
! 746:
! 747: if (parent.ref == null)
! 748: return(false);
! 749:
! 750: if (!attributesAreValid(parent))
! 751: return(false);
! 752:
! 753: if (parent.parent != null && parent.parent.ref != null && !isSubElement(parent.parent.ref, parent.ref))
! 754: return(false);
! 755:
! 756: if (parent.firstChild == null && !isElementValueValid(parent.ref, ''))
! 757: return(false);
! 758: else if (parent.childNodes.length == 1 && parent.firstChild is DNText && parent.firstChild.nodeValue != null &&
! 759: !isElementValueValid(parent.ref, parent.firstChild.nodeValue))
! 760: return(false);
! 761:
! 762: if (_schema is SimpleSchema)
! 763: return(true); // on suppose que le test de sous-balise a déjà été fait
! 764: if (_schema is DaxeWXS) {
! 765: final List<x.Element> sousElements = new List<x.Element>();
! 766: bool avectexte = false;
! 767: for (DaxeNode dn = parent.firstChild; dn != null; dn = dn.nextSibling) {
! 768: if (dn.nodeType == DaxeNode.ELEMENT_NODE && dn.ref != null) {
! 769: sousElements.add(dn.ref);
! 770: } else if (dn.nodeType == DaxeNode.TEXT_NODE) {
! 771: if (dn.nodeValue.trim() != "")
! 772: avectexte = true;
! 773: } else if (dn is DNCData) {
! 774: if (dn.firstChild != null && dn.firstChild.nodeValue.trim() != '')
! 775: avectexte = true;
! 776: }
! 777: }
! 778: if (avectexte && !_schema.canContainText(parent.ref))
! 779: return(false);
! 780: final DaxeWXS sch = _schema as DaxeWXS;
! 781: return(sch.validElement(parent.ref, sousElements, false));
! 782: }
! 783:
! 784: final x.Element refParent = parent.ref;
! 785: final StringBuffer cettexp = new StringBuffer();
! 786: if (_validPatternCache == null)
! 787: _validPatternCache = new HashMap<x.Element, Pattern>();
! 788:
! 789: bool avectexte = false;
! 790: DaxeNode child = parent.firstChild;
! 791: while (child != null) {
! 792: if (child is DNCData) {
! 793: if (child.firstChild != null && child.firstChild.nodeValue.trim() != '')
! 794: avectexte = true;
! 795: } else if (child.nodeType == DaxeNode.ELEMENT_NODE && child is! DNComment && child is! DNProcessingInstruction) {
! 796: cettexp.write(child.localName);
! 797: cettexp.write(",");
! 798: } else if (child.nodeType == DaxeNode.TEXT_NODE) {
! 799: if (child.nodeValue.trim() != '')
! 800: avectexte = true;
! 801: }
! 802: child = child.nextSibling;
! 803: }
! 804: if (avectexte && !_schema.canContainText(refParent))
! 805: return(false);
! 806: RegExp r = _validPatternCache[refParent];
! 807: if (r == null) {
! 808: final String expr = _regularExpression(refParent, false, true);
! 809: if (expr == null || expr == "")
! 810: return(true);
! 811: try {
! 812: r = new RegExp(r"^$expr$");
! 813: } on Exception catch(ex) {
! 814: logError("elementValide(JaxeElement, bool, List<String>) - Malformed Pattern: ^${expr}\$:", ex);
! 815: return(true);
! 816: }
! 817: _validPatternCache[refParent] = r;
! 818: }
! 819:
! 820: final bool matched = r.hasMatch(cettexp.toString());
! 821: return(matched);
! 822: }
! 823:
! 824: /**
! 825: * Returns true if the element attributes are valid and if there is not missing required attribute.
! 826: */
! 827: bool attributesAreValid(final DaxeNode dn) {
! 828: if (dn.nodeType != DaxeNode.ELEMENT_NODE) {
! 829: logError("Config.attributsValides : ce n'est pas un élément: $dn");
! 830: return(false);
! 831: }
! 832: // vérif des attributs qui sont dans le schéma
! 833: final List<x.Element> lattref = elementAttributes(dn.ref);
! 834: List<String> noms = new List<String>(lattref.length);
! 835: List<String> espaces = new List<String>(noms.length);
! 836: for (int i=0; i<lattref.length; i++) {
! 837: final x.Element attref = lattref[i];
! 838: noms[i] = attributeName(attref);
! 839: espaces[i] = attributeNamespace(attref);
! 840: final String valeur = dn.getAttribute(noms[i]);
! 841: if (valeur == null || valeur == '') {
! 842: if (requiredAttribute(dn.ref, attref))
! 843: return(false);
! 844: } else if (!validAttributeValue(attref, valeur))
! 845: return(false);
! 846: }
! 847: // vérif s'il y a des attributs en plus qui ne sont pas dans le schéma
! 848: final List<DaxeAttr> latt = dn.attributes;
! 849: for (int i=0; i<latt.length; i++) {
! 850: DaxeAttr att = latt[i];
! 851: final String prefixe = att.prefix;
! 852: if (prefixe == "xml" || prefixe == "xmlns")
! 853: continue;
! 854: final String nom = att.localName;
! 855: if (prefixe == null && nom == "xmlns")
! 856: continue;
! 857: final String espace = att.namespaceURI;
! 858: if (espace == "http://www.w3.org/2001/XMLSchema-instance")
! 859: continue;
! 860: bool trouve = false;
! 861: for (int j=0; j<noms.length; j++) {
! 862: if (noms[j] == nom && espaces[j] == espace) {
! 863: trouve = true;
! 864: break;
! 865: }
! 866: }
! 867: if (!trouve)
! 868: return(false);
! 869: }
! 870: return(true);
! 871: }
! 872:
! 873: /**
! 874: * Returns the list of possible parent elements for a given element
! 875: */
! 876: List<x.Element> parentElements(final x.Element elementRef) {
! 877: return(_schema.parentElements(elementRef));
! 878: }
! 879:
! 880: /**
! 881: * Returns the list of names for possible parent elements for a given element
! 882: */
! 883: List<String> parentNames(final x.Element elementRef) {
! 884: final List<x.Element> listeReferences = parentElements(elementRef);
! 885: final List<String> listeNoms = new List<String>();
! 886: for (final x.Element ref in listeReferences) {
! 887: final String nom = _elementsToNamesCache[ref];
! 888: if (!listeNoms.contains(nom))
! 889: listeNoms.add(nom);
! 890: }
! 891: return(listeNoms);
! 892: }
! 893:
! 894: /**
! 895: * Returns true if the given element can contain text
! 896: */
! 897: bool canContainText(final x.Element elementRef) {
! 898: if (elementRef == null)
! 899: return(true);
! 900: return(_schema.canContainText(elementRef));
! 901: }
! 902:
! 903: /**
! 904: * Returns the list of possible attributes for a given element.
! 905: */
! 906: List<x.Element> elementAttributes(final x.Element elementRef) {
! 907: return(_schema.elementAttributes(elementRef));
! 908: }
! 909:
! 910: /**
! 911: * Returns the name of an attribute based on its reference.
! 912: */
! 913: String attributeName(final x.Element attributeRef) {
! 914: return(_schema.attributeName(attributeRef));
! 915: }
! 916:
! 917: /**
! 918: * Returns the qualified name of an attribute based on its reference.
! 919: */
! 920: String attributeQualifiedName(final x.Element parentRef, final x.Element attributeRef) {
! 921: String name = _schema.attributeName(attributeRef);
! 922: String namespace = _schema.attributeNamespace(attributeRef);
! 923: if (namespace != null) {
! 924: String prefix = attributePrefix(parentRef, attributeRef);
! 925: if (prefix != null)
! 926: name = "$prefix:$name";
! 927: }
! 928: return(name);
! 929: }
! 930:
! 931: /**
! 932: * Returns an attribute namespace based on its reference, or null if none is defined.
! 933: */
! 934: String attributeNamespace(final x.Element attributeRef) {
! 935: return(_schema.attributeNamespace(attributeRef));
! 936: }
! 937:
! 938: /**
! 939: * Returns the prefix tu use to create an attribute, given the parent element and the attribute reference,
! 940: * or null if no prefix should be used.
! 941: */
! 942: String attributePrefix(final x.Element parent, final x.Element attributeRef) {
! 943: final String espace = attributeNamespace(attributeRef);
! 944: if (espace == null)
! 945: return(null);
! 946: if (espace == "http://www.w3.org/XML/1998/namespace")
! 947: return("xml");
! 948: if (espace == "http://www.w3.org/2000/xmlns/" && attributeName(attributeRef) != "xmlns")
! 949: return("xmlns");
! 950: // on essaye lookupPrefix avec le parent et avec son document
! 951: // (cas d'un élément en cours de création, pas encore inséré dans le document)
! 952: String prefixe = parent.lookupPrefix(espace);
! 953: if (prefixe == null) {
! 954: if (parent.ownerDocument.documentElement != null) // si l'élément racine existe
! 955: prefixe = parent.ownerDocument.lookupPrefix(espace);
! 956: else
! 957: prefixe = namespacePrefix(espace); // on suppose que la racine sera créée avec ajouterAttributsEspaces
! 958: }
! 959: return(prefixe);
! 960: }
! 961:
! 962: /**
! 963: * Returns an attribute namespace based on its full name (including the prefix).
! 964: */
! 965: String attributeNamespaceByName(final String name) {
! 966: return(_schema.attributeNamespaceByName(name));
! 967: }
! 968:
! 969: /**
! 970: * Returns true if the attribute is required for the parent element.
! 971: */
! 972: bool requiredAttribute(final x.Element parentRef, final x.Element attributeRef) {
! 973: return(_schema.attributeIsRequired(parentRef, attributeRef));
! 974: }
! 975:
! 976: /**
! 977: * Returns the list of possible values for an attribute.
! 978: * Returns null if there are an infinity of possible values.
! 979: */
! 980: List<String> attributeValues(final x.Element attributeRef) {
! 981: final List<String> liste = _schema.attributeValues(attributeRef);
! 982: return(liste);
! 983: }
! 984:
! 985: /**
! 986: * Returns an attribute's default value based on its reference.
! 987: */
! 988: String defaultAttributeValue(final x.Element attributeRef) {
! 989: return(_schema.defaultAttributeValue(attributeRef));
! 990: }
! 991:
! 992: /**
! 993: * Returns true if the given String is a valid value for the attribute.
! 994: */
! 995: bool validAttributeValue(final x.Element attributeRef, final String value) {
! 996: return(_schema.attributeIsValid(attributeRef, value));
! 997: }
! 998:
! 999: /**
! 1000: * Returns the local part of an element's name (by removing the prefix).
! 1001: */
! 1002: static String localValue(final String s) {
! 1003: if (s == null)
! 1004: return(null);
! 1005: final int ind = s.indexOf(':');
! 1006: if (ind == -1)
! 1007: return(s);
! 1008: return(s.substring(ind + 1));
! 1009: }
! 1010:
! 1011:
! 1012: // METHODS FOR DISPLAY TYPES
! 1013:
! 1014: /**
! 1015: * Returns a node display type based on the element reference, the node name and the DOM node type.
! 1016: */
! 1017: String nodeDisplayType(final x.Element elementRef, final String name, final int nodeType) {
! 1018: if (nodeType == x.Node.ELEMENT_NODE) {
! 1019: final x.Element affel = getElementDisplay(localValue(name));
! 1020: if (affel == null)
! 1021: return(_typeAffichageParDefaut);
! 1022: return(affel.getAttribute("type"));
! 1023: } else if (nodeType == x.Node.PROCESSING_INSTRUCTION_NODE) {
! 1024: x.Element elplug = _findElement(_getNodeDisplay(), "PLUGIN_INSTRUCTION");
! 1025: while (elplug != null) {
! 1026: if (name != null && name == elplug.getAttribute("cible"))
! 1027: return("plugin");
! 1028: elplug = _nextElement(elplug, "PLUGIN_INSTRUCTION");
! 1029: }
! 1030: return("instruction");
! 1031: } else if (nodeType == x.Node.COMMENT_NODE) {
! 1032: final x.Element elplug = _findElement(_getNodeDisplay(), "PLUGIN_COMMENTAIRE");
! 1033: if (elplug != null)
! 1034: return("plugin");
! 1035: return("commentaire");
! 1036: } else if (nodeType == x.Node.CDATA_SECTION_NODE) {
! 1037: final x.Element elplug = _findElement(_getNodeDisplay(), "PLUGIN_CDATA");
! 1038: if (elplug != null)
! 1039: return("plugin");
! 1040: return("cdata");
! 1041: } else if (nodeType == x.Node.TEXT_NODE) {
! 1042: return("texte");
! 1043: }
! 1044: return(null);
! 1045: }
! 1046:
! 1047: /**
! 1048: * Returns an element display type based on its reference.
! 1049: */
! 1050: String elementDisplayType(final x.Element elementRef) {
! 1051: final x.Element affel = getElementDisplay(elementName(elementRef));
! 1052: if (affel == null)
! 1053: return(_typeAffichageParDefaut);
! 1054: return(affel.getAttribute("type"));
! 1055: }
! 1056:
! 1057: /**
! 1058: * Returns the reference of the first element with the given display type in the config file.
! 1059: */
! 1060: x.Element firstElementWithType(final String displayType) {
! 1061: if (_cfgroot == null)
! 1062: return(null);
! 1063: x.Element affel = _findElement(_getNodeDisplay(), "AFFICHAGE_ELEMENT");
! 1064: while (affel != null) {
! 1065: if (displayType == affel.getAttribute("type"))
! 1066: return(elementReference(affel.getAttribute("element")));
! 1067: affel = _nextElement(affel, "AFFICHAGE_ELEMENT");
! 1068: }
! 1069: return(null);
! 1070: }
! 1071:
! 1072: /**
! 1073: * Returns the references of the elements with the given display type in the config file.
! 1074: */
! 1075: List<x.Element> elementsWithType(final String displayType) {
! 1076: if (_cfgroot == null)
! 1077: return(null);
! 1078: List<x.Element> list = new List<x.Element>();
! 1079: x.Element affel = _findElement(_getNodeDisplay(), "AFFICHAGE_ELEMENT");
! 1080: while (affel != null) {
! 1081: if (displayType == affel.getAttribute("type"))
! 1082: list.addAll(elementReferences(affel.getAttribute("element")));
! 1083: affel = _nextElement(affel, "AFFICHAGE_ELEMENT");
! 1084: }
! 1085: return(list);
! 1086: }
! 1087:
! 1088: /**
! 1089: * Returns the value of an element display parameter.
! 1090: * @param elementRef element reference
! 1091: * @param parameterName parameter name
! 1092: * @param defaultValue default value, used if the parameter is not found
! 1093: */
! 1094: String elementParameterValue(final x.Element elementRef, final String parameterName, final String defaultValue) {
! 1095: return nodeParameterValue(elementRef, "element", null, parameterName, defaultValue);
! 1096: }
! 1097:
! 1098: /**
! 1099: * Returns the value of a node display parameter.
! 1100: * The node type can be used to find display parameters for comments or PIs.
! 1101: */
! 1102: String nodeParameterValue(final x.Element elementRef, final String nodeType,
! 1103: final String name, final String parameterName, final String defaultValue) {
! 1104: final HashMap<String, List<String>> table = getNodeParameters(elementRef, nodeType, name);
! 1105: final List<String> lval = table[parameterName];
! 1106: String valeur;
! 1107: if (lval != null && lval.length > 0)
! 1108: valeur = lval[0];
! 1109: else
! 1110: valeur = defaultValue;
! 1111: return valeur;
! 1112: }
! 1113:
! 1114: /**
! 1115: * Returns a function parameter value.
! 1116: * @param fctdef Element for the function menu in the config file
! 1117: * @param parameterName parameter name
! 1118: * @param defaultValue default value, used if the parameter is not found
! 1119: */
! 1120: String functionParameterValue(final x.Element fctdef, final String parameterName, final String defaultValue) {
! 1121: x.Element parel = _findElement(fctdef, "PARAMETRE");
! 1122: while (parel != null) {
! 1123: final String nom = parel.getAttribute("nom");
! 1124: if (nom == parameterName)
! 1125: return(parel.getAttribute("valeur"));
! 1126: parel = _nextElement(parel, "PARAMETRE");
! 1127: }
! 1128: return(defaultValue);
! 1129: }
! 1130:
! 1131: HashMap<String, List<String>> _buildParameterCache(final x.Element base) {
! 1132: final HashMap<String, List<String>> hashparams = new HashMap<String, List<String>>();
! 1133: x.Element parel = _findElement(base, "PARAMETRE");
! 1134: while (parel != null) {
! 1135: final String nom = parel.getAttribute("nom");
! 1136: final String valeur = parel.getAttribute("valeur");
! 1137: List<String> lval = hashparams[nom];
! 1138: if (lval == null) {
! 1139: lval = new List<String>();
! 1140: lval.add(valeur);
! 1141: hashparams[nom] = lval;
! 1142: } else
! 1143: lval.add(valeur);
! 1144: parel = _nextElement(parel, "PARAMETRE");
! 1145: }
! 1146: _parametersCache[base] = hashparams;
! 1147: return(hashparams);
! 1148: }
! 1149:
! 1150: /**
! 1151: * Returns the table of an element display parameters.
! 1152: */
! 1153: HashMap<String, List<String>> getElementParameters(final x.Element elementRef) {
! 1154: return(getNodeParameters(elementRef, "element", null));
! 1155: }
! 1156:
! 1157: /**
! 1158: * Returns the table of a node display parameters.
! 1159: * The name can be null if nodeType is "element" and elementRef is not null.
! 1160: */
! 1161: HashMap<String, List<String>> getNodeParameters(final x.Element elementRef, final String nodeType, final String name) {
! 1162: x.Element base;
! 1163: if (nodeType == "element")
! 1164: base = getElementDisplay(elementName(elementRef));
! 1165: else if (nodeType == "instruction") {
! 1166: base = null;
! 1167: x.Element elplug = _findElement(_getNodeDisplay(), "PLUGIN_INSTRUCTION");
! 1168: while (elplug != null) {
! 1169: if (name != null && name == elplug.getAttribute("cible")) {
! 1170: base = elplug;
! 1171: break;
! 1172: }
! 1173: elplug = _nextElement(elplug, "PLUGIN_INSTRUCTION");
! 1174: }
! 1175: } else if (nodeType == "commentaire") {
! 1176: final x.Element elplug = _findElement(_getNodeDisplay(), "PLUGIN_COMMENTAIRE");
! 1177: if (elplug == null) {
! 1178: base = null;
! 1179: } else {
! 1180: base = elplug;
! 1181: }
! 1182: } else
! 1183: base = null;
! 1184: if (base == null)
! 1185: return(new HashMap<String, List<String>>());
! 1186: if (_parametersCache == null)
! 1187: _parametersCache = new HashMap<x.Element, HashMap<String, List<String>>>();
! 1188: HashMap<String, List<String>> hashparams = _parametersCache[base];
! 1189: if (hashparams == null)
! 1190: hashparams = _buildParameterCache(base);
! 1191: return(hashparams);
! 1192: }
! 1193:
! 1194: /**
! 1195: * Returns the list of suggested values for a given element.
! 1196: * Returns null if there is no suggestion.
! 1197: */
! 1198: List<String> elementSuggestedValues(final x.Element elementRef) {
! 1199: final Set<String> set = new LinkedHashSet<String>();
! 1200: List<String> schemaSuggestions = _schema.suggestedElementValues(elementRef);
! 1201: if (schemaSuggestions != null)
! 1202: set.addAll(_schema.suggestedElementValues(elementRef));
! 1203: final x.Element affel = getElementDisplay(elementName(elementRef));
! 1204: if (affel != null) {
! 1205: x.Element vs = _findElement(affel, "VALEUR_SUGGEREE");
! 1206: while (vs != null) {
! 1207: final String v = _dom_elementValue(vs);
! 1208: if (v != null)
! 1209: set.add(v);
! 1210: vs = _nextElement(vs, "VALEUR_SUGGEREE");
! 1211: }
! 1212: }
! 1213: if (set.length == 0)
! 1214: return(null);
! 1215: else
! 1216: return(set.toList());
! 1217: }
! 1218:
! 1219: /**
! 1220: * Returns the list of suggested values for an attribute,
! 1221: * based on the parent element reference and the attribute reference.
! 1222: * Returns null if there is no suggestion.
! 1223: */
! 1224: List<String> attributeSuggestedValues(final x.Element parentRef, final x.Element attributeRef) {
! 1225: final Set<String> set = new LinkedHashSet<String>();
! 1226: List<String> schemaSuggestions = _schema.suggestedAttributeValues(attributeRef);
! 1227: if (schemaSuggestions != null)
! 1228: set.addAll(schemaSuggestions);
! 1229: final x.Element affel = getElementDisplay(elementName(parentRef));
! 1230: if (affel != null) {
! 1231: final String nomAtt = attributeName(attributeRef);
! 1232: x.Element aa = _findElement(affel, "AFFICHAGE_ATTRIBUT");
! 1233: while (aa != null) {
! 1234: if (aa.getAttribute("attribut") == nomAtt) {
! 1235: x.Element vs = _findElement(aa, "VALEUR_SUGGEREE");
! 1236: while (vs != null) {
! 1237: final String v = _dom_elementValue(vs);
! 1238: if (v != null)
! 1239: set.add(v);
! 1240: vs = _nextElement(vs, "VALEUR_SUGGEREE");
! 1241: }
! 1242: }
! 1243: aa = _nextElement(aa, "AFFICHAGE_ATTRIBUT");
! 1244: }
! 1245: }
! 1246: if (set.length == 0)
! 1247: return(null);
! 1248: else
! 1249: return(set.toList());
! 1250: }
! 1251:
! 1252:
! 1253: // METHODS FOR THE STRINGS
! 1254:
! 1255: /**
! 1256: * Returns a list of the STRINGS elements in the config file,
! 1257: * ordered by preference based on the user language and country.
! 1258: */
! 1259: List<x.Element> _stringsElements() {
! 1260: final Locale defaut = new Locale();
! 1261: final List<x.Element> liste = new List<x.Element>();
! 1262:
! 1263: final List<x.Element> lstrings = _getStrings();
! 1264: for (final x.Element strings in lstrings) {
! 1265: final String langue = strings.getAttribute("langue");
! 1266: if (langue != "") {
! 1267: Locale strloc;
! 1268: if (strings.getAttribute("pays") == "")
! 1269: strloc = new Locale.l(langue);
! 1270: else
! 1271: strloc = new Locale.lc(langue, strings.getAttribute("pays"));
! 1272: if (defaut == strloc && !liste.contains(strings))
! 1273: liste.add(strings);
! 1274: }
! 1275: }
! 1276: for (final x.Element strings in lstrings) {
! 1277: final String langue = strings.getAttribute("langue");
! 1278: if (langue != "") {
! 1279: final Locale test = new Locale.lc(defaut.language, defaut.country);
! 1280: Locale strloc;
! 1281: if (strings.getAttribute("pays") == "")
! 1282: strloc = new Locale.l(langue);
! 1283: else
! 1284: strloc = new Locale.lc(langue, strings.getAttribute("pays"));
! 1285: if (test == strloc && !liste.contains(strings))
! 1286: liste.add(strings);
! 1287: }
! 1288: }
! 1289: for (final x.Element strings in lstrings) {
! 1290: final String langue = strings.getAttribute("langue");
! 1291: if (langue != "") {
! 1292: final Locale test = new Locale.l(defaut.language);
! 1293: if (test == new Locale.l(langue) && !liste.contains(strings))
! 1294: liste.add(strings);
! 1295: }
! 1296: }
! 1297: for (final x.Element strings in lstrings) {
! 1298: if (!liste.contains(strings))
! 1299: liste.add(strings);
! 1300: }
! 1301: return(liste);
! 1302: }
! 1303:
! 1304: /**
! 1305: * Returns the config description (element DESCRIPTION_CONFIG).
! 1306: */
! 1307: String description() {
! 1308: final List<x.Element> lstrings = _stringsElements();
! 1309: for (final x.Element strings in lstrings) {
! 1310: final x.Element descel = _findElement(strings, "DESCRIPTION_CONFIG");
! 1311: if (descel == null || descel.firstChild == null)
! 1312: break;
! 1313: String desc = _dom_elementValue(descel);
! 1314: return(desc);
! 1315: }
! 1316: return(null);
! 1317: }
! 1318:
! 1319: /**
! 1320: * Returns a menu title based on its name
! 1321: */
! 1322: String menuTitle(final String name) {
! 1323: final List<x.Element> lstrings = _stringsElements();
! 1324: for (final x.Element strings in lstrings) {
! 1325: x.Element sm = _findElementDeep(strings, "STRINGS_MENU");
! 1326: while (sm != null) {
! 1327: if (name == sm.getAttribute("menu")) {
! 1328: final x.Element eltitre = _findElement(sm, "TITRE");
! 1329: if (eltitre != null && eltitre.firstChild != null) {
! 1330: return(_dom_elementValue(eltitre));
! 1331: }
! 1332: break;
! 1333: }
! 1334: sm = _nextElementDeep(strings, sm, "STRINGS_MENU");
! 1335: }
! 1336: }
! 1337: final x.Element refel = elementReference(name);
! 1338: if (refel != null)
! 1339: return(elementTitle(refel));
! 1340: return(name);
! 1341: }
! 1342:
! 1343: /**
! 1344: * Returns a menu documentation based on its name.
! 1345: */
! 1346: String menuDocumentation(final String name) {
! 1347: final List<x.Element> lstrings = _stringsElements();
! 1348: for (final x.Element strings in lstrings) {
! 1349: x.Element sm = _findElementDeep(strings, "STRINGS_MENU");
! 1350: while (sm != null) {
! 1351: if (name == sm.getAttribute("menu")) {
! 1352: final x.Element eldoc = _findElement(sm, "DOCUMENTATION");
! 1353: if (eldoc != null && eldoc.firstChild != null) {
! 1354: return(_dom_elementValue(eldoc));
! 1355: }
! 1356: break;
! 1357: }
! 1358: sm = _nextElementDeep(strings, sm, "STRINGS_MENU");
! 1359: }
! 1360: }
! 1361: return(null);
! 1362: }
! 1363:
! 1364: HashMap<String, String> _titlesHash() {
! 1365: HashMap<String, String> h = new HashMap<String, String>();
! 1366: final List<x.Element> lstrings = _stringsElements();
! 1367: for (final x.Element strings in lstrings) {
! 1368: x.Element sel = _findElement(strings, "STRINGS_ELEMENT");
! 1369: while (sel != null) {
! 1370: String nom = sel.getAttribute("element");
! 1371: if (h[nom] == null) {
! 1372: String titre = nom;
! 1373: final x.Element eltitre = _findElement(sel, "TITRE");
! 1374: if (eltitre != null && eltitre.firstChild != null)
! 1375: titre = _dom_elementValue(eltitre);
! 1376: h[nom] = titre;
! 1377: }
! 1378: sel = _nextElement(sel, "STRINGS_ELEMENT");
! 1379: }
! 1380: }
! 1381: return(h);
! 1382: }
! 1383:
! 1384: /**
! 1385: * Returns an element title based on its reference.
! 1386: */
! 1387: String elementTitle(final x.Element elementRef) {
! 1388: String titre = null;
! 1389: titre = _elementsTitlesCache[elementRef];
! 1390: if (titre != null)
! 1391: return(titre);
! 1392: final String nom = elementName(elementRef);
! 1393: if (nom == null) {
! 1394: logError("Config.elementTitle : no name for $elementRef");
! 1395: return(null);
! 1396: }
! 1397: final List<x.Element> lstrings = _stringsElements();
! 1398: for (final x.Element strings in lstrings) {
! 1399: if (titre == null) {
! 1400: x.Element sel = _findElement(strings, "STRINGS_ELEMENT");
! 1401: while (sel != null) {
! 1402: if (sel.getAttribute("element") == nom) {
! 1403: final x.Element eltitre = _findElement(sel, "TITRE");
! 1404: if (eltitre != null && eltitre.firstChild != null) {
! 1405: titre = _dom_elementValue(eltitre);
! 1406: break;
! 1407: }
! 1408: break;
! 1409: }
! 1410: sel = _nextElement(sel, "STRINGS_ELEMENT");
! 1411: }
! 1412: }
! 1413: }
! 1414: if (titre == null || titre == "")
! 1415: titre = nom;
! 1416: _elementsTitlesCache[elementRef] = titre;
! 1417: return(titre);
! 1418: }
! 1419:
! 1420: /**
! 1421: * Returns an element documentation
! 1422: */
! 1423: String documentation(final x.Element elementRef) {
! 1424: if (elementRef == null)
! 1425: return(null);
! 1426: final String nom = elementName(elementRef);
! 1427: final List<x.Element> lstrings = _stringsElements();
! 1428: for (final x.Element strings in lstrings) {
! 1429: x.Element sel = _findElement(strings, "STRINGS_ELEMENT");
! 1430: while (sel != null) {
! 1431: if (nom == sel.getAttribute("element")) {
! 1432: final x.Element eldoc = _findElement(sel, "DOCUMENTATION");
! 1433: if (eldoc != null && eldoc.firstChild != null)
! 1434: return(_dom_elementValue(eldoc));
! 1435: break;
! 1436: }
! 1437: sel = _nextElement(sel, "STRINGS_ELEMENT");
! 1438: }
! 1439: }
! 1440: return(_schema.elementDocumentation(elementRef));
! 1441: }
! 1442:
! 1443: /**
! 1444: * Formats the documentation in HTML.
! 1445: */
! 1446: static String formatDoc(final String documentation) {
! 1447: String doc = documentation;
! 1448: doc = doc.replaceAll("&", "&");
! 1449: doc = doc.replaceAll("<", "<");
! 1450: doc = doc.replaceAll(">", ">");
! 1451: /*
! 1452: if (doc.length > 100) {
! 1453: int p = 0;
! 1454: for (int i=0; i<doc.length; i++) {
! 1455: if (i-p > 90 && doc[i] == ' ') {
! 1456: doc = "${doc.substring(0, i)}\n${doc.substring(i+1)}";
! 1457: p = i;
! 1458: } else if (doc[i] == '\n')
! 1459: p = i;
! 1460: }
! 1461: }
! 1462: */
! 1463: doc = doc.replaceAll("\n", "<br>");
! 1464: return(doc);
! 1465: }
! 1466:
! 1467: /**
! 1468: * Returns the title for an element value, based on the element reference and the value.
! 1469: */
! 1470: String elementValueTitle(final x.Element elementRef, final String value) {
! 1471: final String nom = elementName(elementRef);
! 1472: final List<x.Element> lstrings = _stringsElements();
! 1473: final String langueSyst = (new Locale()).language;
! 1474: for (final x.Element strings in lstrings) {
! 1475: x.Element sel = _findElement(strings, "STRINGS_ELEMENT");
! 1476: while (sel != null) {
! 1477: if (sel.getAttribute("element") == nom) {
! 1478: x.Element eltitrev = _findElement(sel, "TITRE_VALEUR");
! 1479: while (eltitrev != null) {
! 1480: if (eltitrev.getAttribute("valeur") == value &&
! 1481: eltitrev.firstChild != null)
! 1482: return(_dom_elementValue(eltitrev));
! 1483: eltitrev = _nextElement(eltitrev, "TITRE_VALEUR");
! 1484: }
! 1485: break;
! 1486: }
! 1487: sel = _nextElement(sel, "STRINGS_ELEMENT");
! 1488: }
! 1489: // la langue est trouvée mais il n'y a pas de TITRE_VALEUR correspondant
! 1490: // -> on renvoie la vraie valeur plutôt que de chercher un titre
! 1491: // dans d'autres langues.
! 1492: final String langue = strings.getAttribute("langue");
! 1493: if (langue == langueSyst)
! 1494: return(value);
! 1495: }
! 1496: return(value);
! 1497: }
! 1498:
! 1499: /**
! 1500: * Returns an attribute title based on the parent element reference and the attribute reference.
! 1501: */
! 1502: String attributeTitle(final x.Element parentRef, final x.Element attributeRef) {
! 1503: final String nomEl = elementName(parentRef);
! 1504: final String nomAtt = attributeName(attributeRef);
! 1505: final List<x.Element> lstrings = _stringsElements();
! 1506: for (final x.Element strings in lstrings) {
! 1507: x.Element sel = _findElement(strings, "STRINGS_ELEMENT");
! 1508: while (sel != null) {
! 1509: if (sel.getAttribute("element") == nomEl) {
! 1510: x.Element sat = _findElement(sel, "STRINGS_ATTRIBUT");
! 1511: while (sat != null) {
! 1512: if (sat.getAttribute("attribut") == nomAtt) {
! 1513: final x.Element eltitre = _findElement(sat, "TITRE");
! 1514: if (eltitre != null && eltitre.firstChild != null)
! 1515: return(_dom_elementValue(eltitre));
! 1516: break;
! 1517: }
! 1518: sat = _nextElement(sat, "STRINGS_ATTRIBUT");
! 1519: }
! 1520: }
! 1521: sel = _nextElement(sel, "STRINGS_ELEMENT");
! 1522: }
! 1523: }
! 1524: final String prefixe = attributePrefix(parentRef, attributeRef);
! 1525: if (prefixe != null)
! 1526: return("$prefixe:$nomAtt");
! 1527: return(nomAtt);
! 1528: }
! 1529:
! 1530: /**
! 1531: * Returns the title for an attribute value, based on the parent element reference,
! 1532: * the attribute reference and the value.
! 1533: */
! 1534: String attributeValueTitle(final x.Element parentRef, final x.Element attributeRef, final String value) {
! 1535: final String nomEl = elementName(parentRef);
! 1536: final String nomAtt = attributeName(attributeRef);
! 1537: final List<x.Element> lstrings = _stringsElements();
! 1538: final String langueSyst = (new Locale()).language;
! 1539: for (final x.Element strings in lstrings) {
! 1540: x.Element sel = _findElement(strings, "STRINGS_ELEMENT");
! 1541: while (sel != null) {
! 1542: if (sel.getAttribute("element") == nomEl) {
! 1543: x.Element sat = _findElement(sel, "STRINGS_ATTRIBUT");
! 1544: while (sat != null) {
! 1545: if (sat.getAttribute("attribut") == nomAtt) {
! 1546: x.Element eltitrev = _findElement(sat, "TITRE_VALEUR");
! 1547: while (eltitrev != null) {
! 1548: if (eltitrev.getAttribute("valeur") == value &&
! 1549: eltitrev.firstChild != null)
! 1550: return(_dom_elementValue(eltitrev));
! 1551: eltitrev = _nextElement(eltitrev, "TITRE_VALEUR");
! 1552: }
! 1553: break;
! 1554: }
! 1555: sat = _nextElement(sat, "STRINGS_ATTRIBUT");
! 1556: }
! 1557: }
! 1558: sel = _nextElement(sel, "STRINGS_ELEMENT");
! 1559: }
! 1560: // la langue est trouvée mais il n'y a pas de TITRE_VALEUR correspondant
! 1561: // -> on renvoie la vraie valeur d'attribut plutôt que de chercher un titre
! 1562: // dans d'autres langues.
! 1563: final String langue = strings.getAttribute("langue");
! 1564: if (langue == langueSyst)
! 1565: return(value);
! 1566: }
! 1567: return(value);
! 1568: }
! 1569:
! 1570: /**
! 1571: * Returns an attribute's documentation based on the parent element reference and
! 1572: * the attribute reference.
! 1573: */
! 1574: String attributeDocumentation(final x.Element parentRef, final x.Element attributeRef) {
! 1575: final String nomEl = elementName(parentRef);
! 1576: final String nomAtt = attributeName(attributeRef);
! 1577: final List<x.Element> lstrings = _stringsElements();
! 1578: for (final x.Element strings in lstrings) {
! 1579: x.Element sel = _findElement(strings, "STRINGS_ELEMENT");
! 1580: while (sel != null) {
! 1581: if (sel.getAttribute("element") == nomEl) {
! 1582: x.Element sat = _findElement(sel, "STRINGS_ATTRIBUT");
! 1583: while (sat != null) {
! 1584: if (sat.getAttribute("attribut") == nomAtt) {
! 1585: final x.Element eldoc = _findElement(sat, "DOCUMENTATION");
! 1586: if (eldoc != null &&eldoc.firstChild != null)
! 1587: return(_dom_elementValue(eldoc));
! 1588: break;
! 1589: }
! 1590: sat = _nextElement(sat, "STRINGS_ATTRIBUT");
! 1591: }
! 1592: }
! 1593: sel = _nextElement(sel, "STRINGS_ELEMENT");
! 1594: }
! 1595: }
! 1596: return(_schema.attributeDocumentation(attributeRef));
! 1597: }
! 1598:
! 1599: /**
! 1600: * Returns an export's title based on its reference.
! 1601: */
! 1602: String exportTitle(final x.Element exportRef) {
! 1603: final String nom = exportName(exportRef);
! 1604: final List<x.Element> lstrings = _stringsElements();
! 1605: for (final x.Element strings in lstrings) {
! 1606: x.Element export = _findElement(strings, "STRINGS_EXPORT");
! 1607: while (export != null) {
! 1608: if (nom == export.getAttribute("export")) {
! 1609: final x.Element eltitre = _findElement(export, "TITRE");
! 1610: if (eltitre != null && eltitre.firstChild != null)
! 1611: return(_dom_elementValue(eltitre));
! 1612: break;
! 1613: }
! 1614: export = _nextElement(export, "STRINGS_EXPORT");
! 1615: }
! 1616: }
! 1617: return(nom);
! 1618: }
! 1619:
! 1620: /**
! 1621: * Returns an export's documentation based on its reference.
! 1622: */
! 1623: String exportDocumentation(final x.Element exportRef) {
! 1624: final String nom = exportName(exportRef);
! 1625: final List<x.Element> lstrings = _stringsElements();
! 1626: for (final x.Element strings in lstrings) {
! 1627: x.Element export = _findElement(strings, "STRINGS_EXPORT");
! 1628: while (export != null) {
! 1629: if (nom == export.getAttribute("export")) {
! 1630: final x.Element eldoc = _findElement(export, "DOCUMENTATION");
! 1631: if (eldoc != null && eldoc.firstChild != null)
! 1632: return(_dom_elementValue(eldoc));
! 1633: break;
! 1634: }
! 1635: export = _nextElement(export, "STRINGS_EXPORT");
! 1636: }
! 1637: }
! 1638: return(null);
! 1639: }
! 1640:
! 1641:
! 1642: // TOOLS
! 1643:
! 1644: /**
! 1645: * Returns the value of the first child node, removing leading and trailing whites.
! 1646: * Returns null if there is not child node.
! 1647: */
! 1648: static String _dom_elementValue(final x.Node el) {
! 1649: final x.Node fc = el.firstChild;
! 1650: if (fc == null)
! 1651: return(null);
! 1652: final String v = fc.nodeValue;
! 1653: if (v == null)
! 1654: return(null);
! 1655: return(v.trim());
! 1656: }
! 1657:
! 1658: x.Element _getLanguage() {
! 1659: if (_languageNode == null) {
! 1660: _languageNode = _findElement(_cfgroot, "LANGAGE");
! 1661: }
! 1662: return _languageNode;
! 1663: }
! 1664:
! 1665: x.Element _getSaving() {
! 1666: if (_savingNode == null) {
! 1667: _savingNode = _findElement(_cfgroot, "ENREGISTREMENT");
! 1668: if (_savingNode == null) {
! 1669: _savingNode = _cfgroot.ownerDocument.createElement("ENREGISTREMENT");
! 1670: }
! 1671: }
! 1672: return _savingNode;
! 1673: }
! 1674:
! 1675: x.Element _getMenus() {
! 1676: if (_menusNode == null) {
! 1677: _menusNode = _findElement(_cfgroot, "MENUS");
! 1678: if (_menusNode == null) {
! 1679: _menusNode = _cfgroot.ownerDocument.createElement("MENUS");
! 1680: }
! 1681: }
! 1682: return _menusNode;
! 1683: }
! 1684:
! 1685: x.Element _getNodeDisplay() {
! 1686: if (_displayNode == null) {
! 1687: _displayNode = _findElement(_cfgroot, "AFFICHAGE_NOEUDS");
! 1688: if (_displayNode == null) {
! 1689: _displayNode = _cfgroot.ownerDocument.createElement("AFFICHAGE_NOEUDS");
! 1690: }
! 1691: }
! 1692: return _displayNode;
! 1693: }
! 1694:
! 1695: x.Element _getExports() {
! 1696: if (_exportsNode == null) {
! 1697: _exportsNode = _findElement(_cfgroot, "EXPORTS");
! 1698: if (_exportsNode == null) {
! 1699: _exportsNode = _cfgroot.ownerDocument.createElement("EXPORTS");
! 1700: }
! 1701: }
! 1702: return _exportsNode;
! 1703: }
! 1704:
! 1705: List<x.Element> _getStrings() {
! 1706: if (_listeStrings == null) {
! 1707: _listeStrings = new List<x.Element>();
! 1708: x.Node child = _cfgroot.firstChild;
! 1709: while (child != null) {
! 1710: if (child.nodeType == x.Node.ELEMENT_NODE && child.nodeName == "STRINGS") {
! 1711: _listeStrings.add(child as x.Element);
! 1712: }
! 1713: child = child.nextSibling;
! 1714: }
! 1715: }
! 1716: return _listeStrings;
! 1717: }
! 1718:
! 1719:
! 1720: static x.Element _findElement(final x.Node n, final String name) {
! 1721: final x.Node child = n.firstChild;
! 1722: return _nextNode(child, name);
! 1723: }
! 1724:
! 1725: static x.Element _nextElement(final x.Node n, final String name) {
! 1726: final x.Node child = n.nextSibling;
! 1727: return _nextNode(child, name);
! 1728: }
! 1729:
! 1730: static x.Element _nextNode(x.Node child, final String name) {
! 1731: if (name == null)
! 1732: return null;
! 1733: while (child != null) {
! 1734: if (child.nodeType == x.Node.ELEMENT_NODE && name == child.nodeName) {
! 1735: return child as x.Element;
! 1736: }
! 1737: child = child.nextSibling;
! 1738: }
! 1739: return null;
! 1740: }
! 1741:
! 1742: static x.Element _findElementDeep(final x.Node n, final String name) {
! 1743: return _nextElementDeep(n, n, name);
! 1744: }
! 1745:
! 1746: static x.Element _nextElementDeep(final x.Node parent, final x.Node n, final String name) {
! 1747: x.Node current = n;
! 1748: x.Node next;
! 1749: while (current != null) {
! 1750: if (current.hasChildNodes()) {
! 1751: current = (current.firstChild);
! 1752: } else if (current != parent && null != (next = current.nextSibling)) {
! 1753: current = next;
! 1754: } else {
! 1755: next = null;
! 1756: while (current != parent) {
! 1757:
! 1758: next = current.nextSibling;
! 1759: if (next != null)
! 1760: break;
! 1761: current = current.parentNode;
! 1762: }
! 1763: current = next;
! 1764: }
! 1765: if (current != parent && current != null && current.nodeType == x.Node.ELEMENT_NODE
! 1766: && current.nodeName == name) {
! 1767: return current as x.Element;
! 1768: }
! 1769: }
! 1770: return null;
! 1771: }
! 1772:
! 1773: static void logError(String message, [Exception ex]) {
! 1774: if (ex != null)
! 1775: print("Config: $message: $ex");
! 1776: else
! 1777: print("Config: $message");
! 1778: }
! 1779: }
! 1780:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to config.dart CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [LON-CAPA] / modules / damieng / graphical_editor / daxe / lib / src