001 //$HeadURL: svn+ssh://jwilden@svn.wald.intevation.org/deegree/base/branches/2.5_testing/src/org/deegree/portal/context/XMLFactory.java $
002 /*----------------------------------------------------------------------------
003 This file is part of deegree, http://deegree.org/
004 Copyright (C) 2001-2009 by:
005 Department of Geography, University of Bonn
006 and
007 lat/lon GmbH
008
009 This library is free software; you can redistribute it and/or modify it under
010 the terms of the GNU Lesser General Public License as published by the Free
011 Software Foundation; either version 2.1 of the License, or (at your option)
012 any later version.
013 This library is distributed in the hope that it will be useful, but WITHOUT
014 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
015 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
016 details.
017 You should have received a copy of the GNU Lesser General Public License
018 along with this library; if not, write to the Free Software Foundation, Inc.,
019 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
020
021 Contact information:
022
023 lat/lon GmbH
024 Aennchenstr. 19, 53177 Bonn
025 Germany
026 http://lat-lon.de/
027
028 Department of Geography, University of Bonn
029 Prof. Dr. Klaus Greve
030 Postfach 1147, 53001 Bonn
031 Germany
032 http://www.geographie.uni-bonn.de/deegree/
033
034 e-mail: info@deegree.org
035 ----------------------------------------------------------------------------*/
036
037 package org.deegree.portal.context;
038
039 import java.awt.Rectangle;
040 import java.net.MalformedURLException;
041 import java.net.URI;
042 import java.net.URISyntaxException;
043 import java.net.URL;
044 import java.util.List;
045
046 import javax.xml.parsers.ParserConfigurationException;
047
048 import org.deegree.framework.util.Parameter;
049 import org.deegree.framework.util.ParameterList;
050 import org.deegree.framework.xml.XMLFragment;
051 import org.deegree.framework.xml.XMLTools;
052 import org.deegree.model.metadata.iso19115.CitedResponsibleParty;
053 import org.deegree.model.metadata.iso19115.ContactInfo;
054 import org.deegree.model.spatialschema.Point;
055 import org.deegree.ogcbase.BaseURL;
056 import org.deegree.ogcbase.CommonNamespaces;
057 import org.deegree.ogcbase.ImageURL;
058 import org.deegree.ogcwebservices.OWSUtils;
059 import org.w3c.dom.Attr;
060 import org.w3c.dom.DOMException;
061 import org.w3c.dom.Document;
062 import org.w3c.dom.Element;
063 import org.w3c.dom.Node;
064 import org.w3c.dom.Text;
065
066 /**
067 * This is a factory class to export a <code>ViewContext</code> and a <code>ViewContextCollection</code> as an xml
068 * <code>org.w3c.dom.Document</code>.
069 *
070 *
071 * @version $Revision: 23790 $
072 * @author <a href="mailto:poth@lat-lon.de">Andreas Poth</a>
073 * @author last edited by: $Author: jmays $
074 *
075 * @version $Revision: 23790 $, $Date: 2010-04-23 14:22:04 +0200 (Fr, 23 Apr 2010) $
076 */
077 public class XMLFactory {
078
079 // Import and define constants
080 private static URI OGC_CONTEXT_NS = CommonNamespaces.CNTXTNS;
081
082 private static URI D_CONTEXT_NS = CommonNamespaces.DGCNTXTNS;
083
084 private static URI SLD_NS = CommonNamespaces.SLDNS;
085
086 private static URI XSI_NS = CommonNamespaces.buildNSURI( "http://www.w3.org/2001/XMLSchema-instance" );
087
088 private static URI XLINK_NS = CommonNamespaces.buildNSURI( "http://www.w3.org/1999/xlink" );
089
090 // Common objects
091 protected static javax.xml.parsers.DocumentBuilderFactory factory = null;
092
093 protected static javax.xml.parsers.DocumentBuilder builder = null;
094
095 protected static Document document = null;
096
097 private XMLFactory() {
098 // Forbid instantiation
099 }
100
101 /**
102 * Convenience method for creating a common document builder. Implementation copied from XmlDocument (by tf and ap).
103 *
104 * @throws ParserConfigurationException
105 */
106 protected static void initDocBuilder()
107 throws ParserConfigurationException {
108
109 if ( builder == null ) {
110 if ( factory == null ) {
111 factory = javax.xml.parsers.DocumentBuilderFactory.newInstance();
112 factory.setIgnoringElementContentWhitespace( true );
113 factory.setNamespaceAware( false );
114 factory.setExpandEntityReferences( false );
115 }
116 builder = factory.newDocumentBuilder();
117 }
118
119 }
120
121 /**
122 * Creates a new <code>org.w3c.dom.Document</code> using the internal document builder.
123 *
124 * @return new <code>Document</code> instance
125 * @throws ParserConfigurationException
126 */
127 protected static Document createDocument()
128 throws ParserConfigurationException {
129
130 initDocBuilder();
131
132 return builder.newDocument();
133 }
134
135 /**
136 * Creates a new <code>org.w3c.dom.Element</code>.
137 *
138 * @param namespace
139 * the element namespace
140 * @param elemName
141 * the element name
142 * @return new <code>Element</code> instance
143 */
144 private static Element createElement( URI namespace, String elemName ) {
145
146 return document.createElementNS( namespace == null ? null : namespace.toString(), elemName );
147 }
148
149 /**
150 * Creates a new <code>org.w3c.dom.Attr</code>.
151 *
152 * @param attName
153 * the attribute name
154 * @param value
155 * the attribute value
156 * @return new <code>Attr</code> instance
157 */
158 private static Attr createAttribute( String attName, String value ) {
159
160 Attr attr = document.createAttribute( attName );
161 attr.setValue( value );
162
163 return attr;
164 }
165
166 /**
167 * Creates a new <code>org.w3c.dom.Text</code>. This is the textual content of an element.
168 *
169 * @param text
170 * the attribute name (if <code>null</code>, then context stays empty)
171 * @return new <code>Text</code> instance
172 */
173 private static Text createTextNode( String text ) {
174
175 String t = "";
176 if ( text != null ) {
177 t = text;
178 }
179
180 return document.createTextNode( t );
181 }
182
183 /**
184 * Creates a new <code>org.w3c.dom.Document</code> describing a <code>ViewContext</code>.
185 *
186 * @param viewContext
187 * the <code>ViewContext</code> to be exported
188 * @return the xml dom-representation of the given viewContext.
189 * @throws ParserConfigurationException
190 * if an XML parser couldn't be found
191 */
192 public static XMLFragment export( ViewContext viewContext )
193 throws ParserConfigurationException {
194
195 document = createDocument();
196 // start appending nodes...
197 try {
198 appendViewContext( document, viewContext );
199 } catch ( Exception e ) {
200 e.printStackTrace();
201 throw new ParserConfigurationException( e.getMessage() );
202 }
203
204 XMLFragment xml = null;
205 try {
206 xml = new XMLFragment( document, XMLFragment.DEFAULT_URL );
207 } catch ( MalformedURLException neverHappens ) {
208 neverHappens.printStackTrace();
209 }
210
211 return xml;
212 }
213
214 /**
215 * Creates a new <code>org.w3c.dom.Document</code> describing a <code>ViewContextCollection</code>.
216 *
217 * @param viewContCollec
218 * the <code>ViewContextCollection</code> to be exported
219 * @return the xml dom-representation of the given viewContextCollection.
220 * @throws ParserConfigurationException
221 * if an XML parser couldn't be found
222 *
223 */
224 public static Document export( ViewContextCollection viewContCollec )
225 throws ParserConfigurationException {
226
227 document = createDocument();
228 // start appending nodes...
229 appendViewContextCollection( document, viewContCollec );
230
231 return document;
232 }
233
234 /**
235 * Appends the XML representation of a <code>ViewContext</code> to a <code>Node</code> using the
236 * <code>namespace</code>.
237 *
238 * @param toNode
239 * the <code>Node</code> to append the new element to
240 * @param viewContxt
241 * the <code>ViewContext</code> to be appended as new element
242 * @throws URISyntaxException
243 * @throws DOMException
244 *
245 *
246 */
247 protected static void appendViewContext( Node toNode, ViewContext viewContxt )
248 throws DOMException, URISyntaxException {
249
250 if ( viewContxt != null ) {
251 Element e = createElement( OGC_CONTEXT_NS, "ViewContext" );
252 Element rootNode = (Element) toNode.appendChild( e );
253 XMLTools.appendNSBinding( rootNode, "sld", SLD_NS );
254 XMLTools.appendNSBinding( rootNode, "xlink", XLINK_NS );
255 XMLTools.appendNSBinding( rootNode, "deegree", D_CONTEXT_NS );
256 XMLTools.appendNSBinding( rootNode, "xsi", XSI_NS );
257 // XMLTools.appendNSBinding( rootNode, "", OGC_CONTEXT_NS );
258 XMLTools.appendNSDefaultBinding( rootNode, OGC_CONTEXT_NS );
259
260 // e.setAttributeNode( createAttribute( "xmlns", OGC_CONTEXT_NS.toString() ) );
261 // e.setAttributeNode( createAttribute( "xmlns:sld", ) );
262 // e.setAttributeNode( createAttribute( "xmlns:xlink", .toString() ) );
263 // e.setAttributeNode( createAttribute( "xmlns:deegree", D_CONTEXT_NS.toString() ) );
264 // e.setAttributeNode( createAttribute( "xmlns:", XSI_NS.toString() ) );
265 rootNode.setAttribute( "version", "1.0.0" );
266 rootNode.setAttribute( "id", "viewContext_id" );
267
268 appendGeneral( rootNode, viewContxt.getGeneral() );
269 appendLayerList( rootNode, viewContxt.getLayerList() );
270
271 // toNode.appendChild( e );
272 }
273
274 }
275
276 /**
277 * Appends the XML representation of a <code>General</code> to a <code>Node</code> using the <code>namespace</code>.
278 *
279 * @param toNode
280 * the <code>Node</code> to append the new element to
281 * @param gen
282 * the <code>General</code> to be appended as new element
283 *
284 * contains illegal characters
285 * @throws URISyntaxException
286 * @throws DOMException
287 */
288 protected static void appendGeneral( Node toNode, General gen )
289 throws DOMException, URISyntaxException {
290
291 if ( gen != null ) {
292 Element e = createElement( OGC_CONTEXT_NS, "General" );
293 appendWindow( e, gen.getWindow() );
294 appendBoundingBox( e, gen.getBoundingBox() );
295 appendTitle( e, gen.getTitle() );
296 appendAbstract( e, gen.getAbstract() );
297 appendKeywords( e, gen.getKeywords() );
298 appendDescriptionURL( e, gen.getDescriptionURL() );
299 appendLogoURL( e, gen.getLogoURL() );
300 appendContactInformation( e, gen.getContactInformation() );
301 // append deegree-specific extension
302 appendGeneralExtension( e, gen.getExtension() );
303
304 toNode.appendChild( e );
305 }
306
307 }
308
309 /**
310 * Appends the XML representation of a <code>Rectangle</code> to a <code>Node</code> using the
311 * <code>namespace</code>.
312 * <p/>
313 * Note that the XML representation of a <code>Rectangle</code> is given by a <code><Window></code> element.
314 *
315 * @param toNode
316 * the <code>Node</code> to append the new element to
317 * @param r
318 * the <code>Rectangle</code> to be appended as new element
319 *
320 * contains illegal characters
321 */
322 protected static void appendWindow( Node toNode, Rectangle r ) {
323
324 if ( r != null ) {
325 Element window = createElement( OGC_CONTEXT_NS, "Window" );
326
327 window.setAttribute( "width", String.valueOf( r.width ) );
328 window.setAttribute( "height", String.valueOf( r.height ) );
329
330 toNode.appendChild( window );
331 }
332
333 }
334
335 /**
336 * Appends the XML representation of a <code>GM_Point[]</code> to a <code>Node</code> using the
337 * <code>namespace</code>.
338 * <p/>
339 * Note that the XML representation of a <code>GM_Point[]</code> is given by a <code><BoundingBox></code>
340 * element.
341 *
342 * @param toNode
343 * the <code>Node</code> to append the new element to
344 * @param points
345 * the <code>GM_Point[]</code> to be appended as new element
346 *
347 * contains illegal characters
348 */
349 protected static void appendBoundingBox( Node toNode, Point[] points ) {
350
351 if ( points != null && points.length == 2 ) {
352 Element bbox = createElement( OGC_CONTEXT_NS, "BoundingBox" );
353 String srs = "UNKNOWN_SRS";
354 try {
355 srs = points[0].getCoordinateSystem().getIdentifier();
356 } catch ( Exception e ) {
357 e.printStackTrace();
358 }
359
360 bbox.setAttributeNode( createAttribute( "SRS", srs ) );
361
362 bbox.setAttribute( "minx", String.valueOf( points[0].getX() ) );
363 bbox.setAttribute( "miny", String.valueOf( points[0].getY() ) );
364 bbox.setAttribute( "maxx", String.valueOf( points[1].getX() ) );
365 bbox.setAttribute( "maxy", String.valueOf( points[1].getY() ) );
366
367 toNode.appendChild( bbox );
368
369 }
370
371 }
372
373 /**
374 * Appends the XML representation of a <code>Title</code> to a <code>Node</code> using the <code>namespace</code>.
375 *
376 * @param toNode
377 * the <code>Node</code> to append the new element to
378 * @param title
379 * the <code>String</code> to be appended as new element
380 *
381 * contains illegal characters
382 */
383 protected static void appendTitle( Node toNode, String title ) {
384
385 String t = "";
386 if ( title != null ) {
387 t = title;
388 }
389 Element te = createElement( OGC_CONTEXT_NS, "Title" );
390 te.appendChild( createTextNode( t ) );
391 toNode.appendChild( te );
392
393 }
394
395 /**
396 * Appends the XML representation of an <code>Abstract</code> to a <code>Node</code> using the
397 * <code>namespace</code>.
398 *
399 * @param toNode
400 * the <code>Node</code> to append the new element to
401 * @param abstr
402 * the <code>String</code> to be appended as new element
403 *
404 */
405 protected static void appendAbstract( Node toNode, String abstr ) {
406
407 if ( abstr != null ) {
408 Element te = createElement( OGC_CONTEXT_NS, "Abstract" );
409 te.appendChild( createTextNode( abstr ) );
410 toNode.appendChild( te );
411 }
412
413 }
414
415 /**
416 * Appends the XML representation of an <code>ImageURL</code> to a <code>Node</code> using the
417 * <code>namespace</code>.
418 *
419 * @param toNode
420 * the <code>Node</code> to append the new element to
421 * @param logoURL
422 * the <code>ImageURL</code> to be appended as new element
423 *
424 * contains illegal characters
425 */
426 protected static void appendLogoURL( Node toNode, ImageURL logoURL ) {
427
428 if ( logoURL != null && logoURL.getOnlineResource() != null ) {
429 Element e = createElement( OGC_CONTEXT_NS, "LogoURL" );
430 appendOnlineResource( e, logoURL.getOnlineResource() );
431 toNode.appendChild( e );
432 }
433
434 }
435
436 /**
437 * Appends the XML representation of a keyword list as a <code>String[]</code> to a <code>Node</code> using the
438 * <code>namespace</code>.
439 * <p/>
440 * Note that the keywords are appended to a <code><KeywordList></code> element.
441 *
442 * @param toNode
443 * the <code>Node</code> to append the new element to
444 * @param keywords
445 * the <code>ImageURL</code> to be appended as new element
446 *
447 * contains illegal characters
448 */
449 protected static void appendKeywords( Node toNode, String[] keywords ) {
450
451 if ( keywords != null ) {
452 Element kWordList = createElement( OGC_CONTEXT_NS, "KeywordList" );
453 for ( int i = 0; i < keywords.length; i++ ) {
454 Element kw = createElement( OGC_CONTEXT_NS, "Keyword" );
455 kw.appendChild( createTextNode( keywords[i] ) );
456 kWordList.appendChild( kw );
457 }
458 toNode.appendChild( kWordList );
459 }
460
461 }
462
463 /**
464 * Appends the XML representation of a <code>BaseURL</code>, the <code>DescriptionURL</code>, to a <code>Node</code>
465 * using the <code>namespace</code>.
466 *
467 * @param toNode
468 * the <code>Node</code> to append the new element to
469 * @param bURL
470 * the <code>BaseURL</code> to be appended as new element
471 *
472 * contains illegal characters
473 */
474 protected static void appendDescriptionURL( Node toNode, BaseURL bURL ) {
475
476 if ( bURL != null ) {
477 Element du = createElement( OGC_CONTEXT_NS, "DescriptionURL" );
478 String f = bURL.getFormat();
479 if ( f != null ) {
480 du.setAttribute( "format", f );
481 }
482
483 URL onlineRes = bURL.getOnlineResource();
484 appendOnlineResource( du, onlineRes );
485
486 toNode.appendChild( du );
487 }
488
489 }
490
491 /**
492 * Appends the XML representation of a <code>URL</code> to a <code>Node</code> as a
493 * <code><OnlineResource></code> using the <code>namespace</code>.
494 *
495 * @param toNode
496 * the <code>Node</code> to append the new element to
497 * @param onlineRes
498 * the <code>URL</code> to be appended as new element
499 *
500 * contains illegal characters
501 */
502 protected static void appendOnlineResource( Node toNode, URL onlineRes ) {
503
504 if ( onlineRes != null ) {
505 Element or = createElement( OGC_CONTEXT_NS, "OnlineResource" );
506 or.setAttributeNS( XLINK_NS.toASCIIString(), "xlink:type", "simple" );
507
508 String href = onlineRes.toExternalForm();
509 if ( href != null ) {
510 // according to OGC WMS 1.3 Testsuite a URL to a service operation
511 // via HTTPGet must end with '?' or '&'
512 if ( href.indexOf( '.' ) < 0 ) {
513 href = OWSUtils.validateHTTPGetBaseURL( href );
514 }
515 or.setAttributeNS( XLINK_NS.toASCIIString(), "xlink:href", href );
516 }
517 toNode.appendChild( or );
518 }
519
520 }
521
522 /**
523 * Appends the XML representation of a <code>ContactInformation</code> to a <code>Node</code> using the
524 * <code>namespace</code>.
525 *
526 * @param toNode
527 * the <code>Node</code> to append the new element to
528 * @param respParty
529 */
530 protected static void appendContactInformation( Node toNode, CitedResponsibleParty respParty ) {
531
532 if ( respParty != null ) {
533 Element ci = createElement( OGC_CONTEXT_NS, "ContactInformation" );
534
535 appendContactPersonPrimary( ci, respParty );
536
537 Element pos = createElement( OGC_CONTEXT_NS, "ContactPosition" );
538 pos.appendChild( createTextNode( respParty.getPositionName()[0] ) );
539 ci.appendChild( pos );
540 ContactInfo[] conInf = respParty.getContactInfo();
541
542 if ( conInf != null && conInf.length > 0 ) {
543 appendContactAddress( ci, conInf[0] );
544 if ( conInf[0].getPhone().getVoice() != null && conInf[0].getPhone().getVoice().length > 0 ) {
545 Element e = createElement( OGC_CONTEXT_NS, "ContactVoiceTelephone" );
546 e.appendChild( createTextNode( conInf[0].getPhone().getVoice()[0] ) );
547 ci.appendChild( e );
548 }
549 if ( conInf[0].getAddress().getElectronicMailAddress() != null
550 && conInf[0].getAddress().getElectronicMailAddress().length > 0 ) {
551 Element e = createElement( OGC_CONTEXT_NS, "ContactElectronicMailAddress" );
552 e.appendChild( createTextNode( conInf[0].getAddress().getElectronicMailAddress()[0] ) );
553 ci.appendChild( e );
554 }
555 }
556
557 toNode.appendChild( ci );
558 }
559
560 }
561
562 /**
563 * Appends the XML representation of a <code>ContactPersonPrimary</code> to a <code>Node</code> using the
564 * <code>namespace</code>.
565 *
566 * @param toNode
567 * the <code>Node</code> to append the new element to
568 * @param respParty
569 */
570 protected static void appendContactPersonPrimary( Node toNode, CitedResponsibleParty respParty ) {
571
572 if ( respParty.getIndividualName() != null && respParty.getIndividualName().length > 0 ) {
573 Element cpp = createElement( OGC_CONTEXT_NS, "ContactPersonPrimary" );
574
575 Element p = createElement( OGC_CONTEXT_NS, "ContactPerson" );
576
577 p.appendChild( createTextNode( respParty.getIndividualName()[0] ) );
578 cpp.appendChild( p );
579
580 Element org = createElement( OGC_CONTEXT_NS, "ContactOrganization" );
581 org.appendChild( createTextNode( respParty.getOrganisationName()[0] ) );
582 cpp.appendChild( org );
583
584 toNode.appendChild( cpp );
585 }
586
587 }
588
589 /**
590 * Appends the XML representation of a <code>ContactAddress</code> to a <code>Node</code> using the
591 * <code>namespace</code>.
592 *
593 * @param toNode
594 * the <code>Node</code> to append the new element to
595 * @param ci
596 * the <code>ContactAddress</code> to be appended as new element
597 *
598 */
599 protected static void appendContactAddress( Node toNode, ContactInfo ci ) {
600
601 if ( ci != null ) {
602 Element ca = createElement( OGC_CONTEXT_NS, "ContactAddress" );
603
604 Element e = createElement( OGC_CONTEXT_NS, "AddressType" );
605 e.appendChild( createTextNode( "postal" ) );
606 ca.appendChild( e );
607
608 e = createElement( OGC_CONTEXT_NS, "Address" );
609 e.appendChild( createTextNode( ci.getAddress().getDeliveryPoint()[0] ) );
610 ca.appendChild( e );
611
612 e = createElement( OGC_CONTEXT_NS, "City" );
613 e.appendChild( createTextNode( ci.getAddress().getCity() ) );
614 ca.appendChild( e );
615
616 e = createElement( OGC_CONTEXT_NS, "StateOrProvince" );
617 e.appendChild( createTextNode( ci.getAddress().getAdministrativeArea() ) );
618 ca.appendChild( e );
619
620 e = createElement( OGC_CONTEXT_NS, "PostCode" );
621 e.appendChild( createTextNode( ci.getAddress().getPostalCode() ) );
622 ca.appendChild( e );
623
624 e = createElement( OGC_CONTEXT_NS, "Country" );
625 e.appendChild( createTextNode( ci.getAddress().getCountry() ) );
626 ca.appendChild( e );
627
628 toNode.appendChild( ca );
629 }
630
631 }
632
633 /**
634 * Appends the XML representation of a <code>LayerList</code> to a <code>Node</code> using the
635 * <code>namespace</code>.
636 *
637 * @param toNode
638 * the <code>Node</code> to append the new element to
639 * @param lList
640 * the <code>LayerList</code> to be appended as new element
641 *
642 */
643 protected static void appendLayerList( Node toNode, LayerList lList ) {
644
645 if ( lList != null ) {
646 Element list = createElement( OGC_CONTEXT_NS, "LayerList" );
647
648 Layer[] ls = lList.getLayers();
649 if ( ls != null ) {
650 for ( int i = 0; i < ls.length; i++ ) {
651 appendLayer( list, ls[i] );
652 }
653 }
654 toNode.appendChild( list );
655 }
656
657 }
658
659 /**
660 * Appends the XML representation of a <code>Layer</code> to a <code>Node</code> using the <code>namespace</code>.
661 *
662 * @param toNode
663 * the <code>Node</code> to append the new element to
664 * @param layer
665 * the <code>Layer</code> to be appended as new element
666 *
667 */
668 protected static void appendLayer( Node toNode, Layer layer ) {
669
670 if ( layer != null ) {
671 Element le = createElement( OGC_CONTEXT_NS, "Layer" );
672
673 le.setAttribute( "queryable", stringValue01( layer.isQueryable() ) );
674 le.setAttribute( "hidden", stringValue01( layer.isHidden() ) );
675
676 appendServer( le, layer.getServer() );
677
678 Element n = createElement( OGC_CONTEXT_NS, "Name" );
679 n.appendChild( createTextNode( layer.getName() ) );
680 le.appendChild( n );
681
682 if ( layer.getAbstract() != null ) {
683 n = createElement( OGC_CONTEXT_NS, "Abstract" );
684 n.appendChild( createTextNode( layer.getAbstract() ) );
685 le.appendChild( n );
686 }
687
688 n = createElement( OGC_CONTEXT_NS, "Title" );
689 n.appendChild( createTextNode( layer.getTitle() ) );
690 le.appendChild( n );
691
692 if ( layer.getMetadataURL() != null ) {
693 n = createElement( OGC_CONTEXT_NS, "MetadataURL" );
694 le.appendChild( n );
695 appendOnlineResource( n, layer.getMetadataURL().getOnlineResource() );
696 }
697
698 appendSrs( le, layer.getSrs() );
699 appendFormatList( le, layer.getFormatList() );
700 appendStyleList( le, layer.getStyleList() );
701
702 appendLayerExtension( le, layer.getExtension() );
703
704 toNode.appendChild( le );
705 }
706
707 }
708
709 /**
710 * Appends the XML representation of a <code>Server</code> to a <code>Node</code> using the <code>namespace</code>.
711 *
712 * @param toNode
713 * the <code>Node</code> to append the new element to
714 * @param server
715 * the <code>Server</code> to be appended as new element
716 *
717 */
718 protected static void appendServer( Node toNode, Server server ) {
719
720 if ( server != null ) {
721 Element serv = createElement( OGC_CONTEXT_NS, "Server" );
722
723 if ( server.getService() != null ) {
724 serv.setAttribute( "service", server.getService() );
725 }
726 if ( server.getService() != null ) {
727 serv.setAttribute( "version", server.getVersion() );
728 }
729 if ( server.getService() != null ) {
730 serv.setAttribute( "title", server.getTitle() );
731 }
732
733 appendOnlineResource( serv, server.getOnlineResource() );
734
735 toNode.appendChild( serv );
736 }
737
738 }
739
740 /**
741 * Appends the XML representation of a list of SRSs as a <code>String[]</code> to a <code>Node</code> using the
742 * <code>namespace</code>.
743 *
744 * @param toNode
745 * the <code>Node</code> to append the new element to
746 * @param srsList
747 * the <code>String[]</code> to be appended as new element
748 *
749 */
750 protected static void appendSrs( Node toNode, String[] srsList ) {
751
752 if ( srsList != null ) {
753 StringBuffer sBuf = new StringBuffer( 100 );
754 for ( int i = 0; i < srsList.length; i++ ) {
755 sBuf.append( srsList[i] );
756 if ( i < srsList.length - 1 )
757 sBuf.append( ";" );
758
759 }
760 Element e = createElement( OGC_CONTEXT_NS, "SRS" );
761 e.appendChild( createTextNode( sBuf.toString() ) );
762 toNode.appendChild( e );
763 }
764
765 }
766
767 /**
768 * Appends the XML representation of a list of a <code>FormatList</code> to a <code>Node</code> using the
769 * <code>namespace</code>.
770 *
771 * @param toNode
772 * the <code>Node</code> to append the new element to
773 * @param formatList
774 * the <code>FormatList</code> to be appended as new element
775 *
776 * contains illegal characters
777 */
778 protected static void appendFormatList( Node toNode, FormatList formatList ) {
779
780 if ( formatList != null ) {
781
782 Format[] formats = formatList.getFormats();
783 if ( formats != null ) {
784 Element e = createElement( OGC_CONTEXT_NS, "FormatList" );
785
786 for ( int i = 0; i < formats.length; i++ ) {
787 if ( formats[i] != null ) {
788 Element f = createElement( OGC_CONTEXT_NS, "Format" );
789 f.setAttribute( "current", stringValue01( formats[i].isCurrent() ) );
790 if ( formats[i].getName() != null )
791 f.appendChild( createTextNode( formats[i].getName() ) );
792 e.appendChild( f );
793 }
794 }
795 toNode.appendChild( e );
796 }
797 }
798
799 }
800
801 /**
802 * Appends the XML representation of a list of a <code>StyleList</code> to a <code>Node</code> using the
803 * <code>namespace</code>.
804 *
805 * @param toNode
806 * the <code>Node</code> to append the new element to
807 * @param styleList
808 * the <code>StyleList</code> to be appended as new element
809 *
810 */
811 protected static void appendStyleList( Node toNode, StyleList styleList ) {
812
813 if ( styleList != null ) {
814
815 Style[] styles = styleList.getStyles();
816 if ( styles != null ) {
817 Element e = createElement( OGC_CONTEXT_NS, "StyleList" );
818
819 for ( int i = 0; i < styles.length; i++ ) {
820 if ( styles[i] != null ) {
821 Element s = createElement( OGC_CONTEXT_NS, "Style" );
822 s.setAttribute( "current", stringValue01( styles[i].isCurrent() ) );
823
824 if ( styles[i].getName() != null ) {
825 Element ne = createElement( OGC_CONTEXT_NS, "Name" );
826 ne.appendChild( createTextNode( styles[i].getName() ) );
827 s.appendChild( ne );
828 }
829 if ( styles[i].getTitle() != null ) {
830 Element ne = createElement( OGC_CONTEXT_NS, "Title" );
831 ne.appendChild( createTextNode( styles[i].getTitle() ) );
832 s.appendChild( ne );
833 }
834 if ( styles[i].getAbstract() != null ) {
835 Element ne = createElement( OGC_CONTEXT_NS, "Abstract" );
836 ne.appendChild( createTextNode( styles[i].getAbstract() ) );
837 s.appendChild( ne );
838 }
839 if ( styles[i].getLegendURL() != null && styles[i].getLegendURL().getOnlineResource() != null ) {
840 Element ne = createElement( OGC_CONTEXT_NS, "LegendURL" );
841 ne.setAttribute( "width", String.valueOf( styles[i].getLegendURL().getWidth() ) );
842 ne.setAttribute( "height", String.valueOf( styles[i].getLegendURL().getHeight() ) );
843 ne.setAttribute( "width", String.valueOf( styles[i].getLegendURL().getWidth() ) );
844 appendOnlineResource( ne, styles[i].getLegendURL().getOnlineResource() );
845 s.appendChild( ne );
846 }
847 e.appendChild( s );
848
849 }
850 }
851 toNode.appendChild( e );
852 }
853 }
854
855 }
856
857 /**
858 * Appends the XML representation of a list of a <code>ViewContextCollection</code> to a <code>Node</code> using the
859 * <code>namespace</code>.
860 *
861 * @param toNode
862 * the <code>Node</code> to append the new element to
863 * @param vcc
864 * the <code>ViewContextCollection</code> to be appended as new element
865 *
866 */
867 protected static void appendViewContextCollection( Node toNode, ViewContextCollection vcc ) {
868
869 if ( vcc != null ) {
870 Element e = createElement( OGC_CONTEXT_NS, "ViewContextCollection" );
871 e.setAttributeNode( createAttribute( "xmlns", OGC_CONTEXT_NS.toString() ) );
872 e.setAttributeNode( createAttribute( "xmlns:sld", SLD_NS.toString() ) );
873 e.setAttributeNode( createAttribute( "xmlns:xlink", XLINK_NS.toString() ) );
874 e.setAttributeNode( createAttribute( "xmlns:deegree", D_CONTEXT_NS.toString() ) );
875 e.setAttributeNode( createAttribute( "xmlns:xsi", XSI_NS.toString() ) );
876 e.setAttributeNode( createAttribute( "version", "1.0.0" ) );
877
878 ViewContextReference[] vcrs = vcc.getViewContextReferences();
879 if ( vcrs != null && vcrs.length > 0 ) {
880 for ( int i = 0; i < vcrs.length; i++ ) {
881 if ( vcrs[i] != null ) {
882 appendContextReference( e, vcrs[i] );
883 }
884 }
885 }
886 toNode.appendChild( e );
887 }
888
889 }
890
891 /**
892 * Appends the XML representation of a list of a <code>ViewContextReference</code> to a <code>Node</code> using the
893 * <code>namespace</code>.
894 * <p/>
895 * // TODO implement ID in VCR
896 *
897 * @param toNode
898 * the <code>Node</code> to append the new element to
899 * @param vcr
900 * the <code>ViewContextReference</code> to be appended as new element
901 */
902 protected static void appendContextReference( Node toNode, ViewContextReference vcr ) {
903
904 if ( vcr != null ) {
905 Element e = createElement( OGC_CONTEXT_NS, "ViewContextReference" );
906
907 e.setAttributeNode( createAttribute( "version", "1.0.0" ) );
908
909 String id = vcr.getTitle().replace( ' ', '_' ).toLowerCase();
910 e.setAttributeNode( createAttribute( "id", id ) );
911
912 Element t = createElement( OGC_CONTEXT_NS, "Title" );
913 t.appendChild( createTextNode( vcr.getTitle() ) );
914 e.appendChild( t );
915
916 if ( vcr.getContextURL() != null ) {
917 Element c = createElement( OGC_CONTEXT_NS, "ViewContextURL" );
918 appendOnlineResource( c, vcr.getContextURL() );
919 e.appendChild( c );
920 }
921 toNode.appendChild( e );
922 }
923
924 }
925
926 /**
927 * Creates a String representation ("0" or "1") of a boolean value.
928 *
929 * @param value
930 * the input value
931 * @return "0" or "1" if value is true or false, respectively
932 */
933 private static final String stringValue01( boolean value ) {
934 return value ? "1" : "0";
935 }
936
937 // ***********************************************************************
938 // BEGIN Deegree specific methods
939 // ***********************************************************************
940
941 /**
942 * Appends the XML representation of a list of a <code>GeneralExtension</code> to a <code>Node</code> using the
943 * <code>namespace</code>.
944 *
945 * @param toNode
946 * the <code>Node</code> to append the new element to
947 * @param genExt
948 * the <code>GeneralExtension</code> to be appended as new element
949 * @throws URISyntaxException
950 * @throws DOMException
951 *
952 */
953 protected static void appendGeneralExtension( Node toNode, GeneralExtension genExt )
954 throws DOMException, URISyntaxException {
955
956 if ( genExt != null ) {
957 Element e = createElement( OGC_CONTEXT_NS, "Extension" );
958 Element a = createElement( D_CONTEXT_NS, "deegree:Mode" );
959 a.appendChild( createTextNode( genExt.getMode() ) );
960 e.appendChild( a );
961
962 appendAuthentificationSettings( e, genExt.getAuthentificationSettings() );
963 appendIOSettings( e, genExt.getIOSettings() );
964 appendFrontend( e, genExt.getFrontend() );
965 appendMapParameter( e, genExt.getMapParameter() );
966
967 appendLayerTree( e, genExt.getLayerTreeRoot() );
968
969 appendMapModel( e, genExt.getMapModel() );
970
971 a = createElement( D_CONTEXT_NS, "deegree:XSLT" );
972 // TODO
973 // we should evaluate if it would be a better solution just to store local file name ...
974 a.appendChild( createTextNode( genExt.getXslt().toURI().toASCIIString() ) );
975 e.appendChild( a );
976
977 toNode.appendChild( e );
978 }
979
980 }
981
982 /**
983 * @param e
984 * @param mapModel
985 */
986 private static void appendMapModel( Element e, MapModel mapModel ) {
987 if ( mapModel != null ) {
988 Element mm = createElement( D_CONTEXT_NS, "deegree:MapModel" );
989 e.appendChild( mm );
990 List<LayerGroup> layerGroups = mapModel.getLayerGroups();
991 for ( LayerGroup layerGroup : layerGroups ) {
992 appendLayerGroup( mm, layerGroup );
993 }
994 }
995 }
996
997 /**
998 * @param mm
999 * @param layerGroup
1000 */
1001 private static void appendLayerGroup( Element mm, LayerGroup layerGroup ) {
1002 Element lg = createElement( D_CONTEXT_NS, "deegree:LayerGroup" );
1003 mm.appendChild( lg );
1004 lg.setAttribute( "title", layerGroup.getTitle() );
1005 lg.setAttribute( "identifier", layerGroup.getTitle() );
1006 lg.setAttribute( "hidden", Boolean.toString( layerGroup.isHidden() ) );
1007 lg.setAttribute( "expanded", Boolean.toString( layerGroup.isExpanded() ) );
1008 List<MapModelEntry> mmes = layerGroup.getMapModelEntries();
1009 for ( MapModelEntry mapModelEntry : mmes ) {
1010 if ( mapModelEntry instanceof LayerGroup ) {
1011 appendLayerGroup( lg, (LayerGroup) mapModelEntry );
1012 } else {
1013 appendLayer( lg, (MMLayer) mapModelEntry );
1014 }
1015 }
1016 }
1017
1018 /**
1019 * @param lg
1020 * @param layer
1021 */
1022 private static void appendLayer( Element lg, MMLayer layer ) {
1023 Element lay = createElement( D_CONTEXT_NS, "deegree:Layer" );
1024 lg.appendChild( lay );
1025 lay.setAttribute( "layerId", layer.getIdentifier() );
1026 }
1027
1028 /**
1029 * Appends the XML representation of a <code>LayerTree</code>.
1030 *
1031 * @param e
1032 * the <code>Element</code> to append the new element to
1033 * @param layerTreeRoot
1034 * the root <code>Node</code> of the LayerTree
1035 *
1036 */
1037 protected static void appendLayerTree( Element e, org.deegree.portal.context.Node layerTreeRoot ) {
1038 Element layerTree = createElement( D_CONTEXT_NS, "deegree:LayerTree" );
1039 layerTree.appendChild( getLayerTreeNode( layerTreeRoot ) );
1040 e.appendChild( layerTree );
1041 }
1042
1043 // create LayerTree elements
1044 private static Element getLayerTreeNode( org.deegree.portal.context.Node node ) {
1045 Element n = createElement( D_CONTEXT_NS, "deegree:Node" );
1046 n.setAttributeNode( createAttribute( "id", String.valueOf( node.getId() ) ) );
1047 n.setAttributeNode( createAttribute( "title", node.getTitle() ) );
1048
1049 org.deegree.portal.context.Node[] nodes = node.getNodes();
1050 for ( org.deegree.portal.context.Node childNode : nodes ) {
1051 // ( tree -> recursion )
1052 n.appendChild( getLayerTreeNode( childNode ) );
1053 }
1054 return n;
1055 }
1056
1057 /**
1058 * @param toNode
1059 * @param settings
1060 */
1061 protected static void appendAuthentificationSettings( Node toNode, AuthentificationSettings settings ) {
1062
1063 if ( settings != null ) {
1064 Element e = createElement( D_CONTEXT_NS, "deegree:AuthentificationSettings" );
1065 Element ee = createElement( D_CONTEXT_NS, "deegree:AuthentificationService" );
1066 appendOnlineResource( ee, settings.getAuthentificationURL().getOnlineResource() );
1067 e.appendChild( ee );
1068 toNode.appendChild( e );
1069 }
1070
1071 }
1072
1073 /**
1074 * Appends the XML representation of a list of a <code>IOSettings</code> to a <code>Node</code> using the
1075 * <code>namespace</code>.
1076 *
1077 * @param toNode
1078 * the <code>Node</code> to append the new element to
1079 * @param ioSetts
1080 * the <code>IOSettings</code> to be appended as new element
1081 */
1082 protected static void appendIOSettings( Node toNode, IOSettings ioSetts ) {
1083
1084 if ( ioSetts != null ) {
1085 Element e = createElement( D_CONTEXT_NS, "deegree:IOSettings" );
1086
1087 // TODO: ioSetts.getTempDirectory() , inexistent till now
1088 /*
1089 * if(ioSetts.getRootDirectory() != null ){ Element rd = createElement(namespace,"deegree:TempDirectory");
1090 * rd.appendChild( createTextNode( ioSetts.getRootDirectory() + "temp")); e.appendChild(rd); }
1091 */
1092
1093 appendDirectoryAccess( e, ioSetts.getTempDirectory(), "deegree:TempDirectory" );
1094 // appendDirectoryAccess( e, ioSetts.getDownloadDirectory(), "deegree:TempDirectory" );
1095 appendDirectoryAccess( e, ioSetts.getDownloadDirectory(), "deegree:DownloadDirectory" );
1096 appendDirectoryAccess( e, ioSetts.getSLDDirectory(), "deegree:SLDDirectory" );
1097 appendDirectoryAccess( e, ioSetts.getPrintDirectory(), "deegree:PrintDirectory" );
1098
1099 toNode.appendChild( e );
1100 }
1101
1102 }
1103
1104 /**
1105 * Appends the XML representation of a list of a <code>DirectoryAccess</code> to a <code>Node</code> using the
1106 * <code>namespace</code>.
1107 *
1108 * @param toNode
1109 * the <code>Node</code> to append the new element to
1110 * @param dirAcc
1111 * the <code>DirectoryAccess</code> to be appended as new element
1112 * @param dirName
1113 *
1114 */
1115 protected static void appendDirectoryAccess( Node toNode, DirectoryAccess dirAcc, String dirName ) {
1116
1117 if ( dirAcc != null ) {
1118 Element d = createElement( D_CONTEXT_NS, dirName );
1119 if ( dirAcc.getDirectoryName() != null ) {
1120 Element a = createElement( D_CONTEXT_NS, "deegree:Name" );
1121 a.appendChild( createTextNode( dirAcc.getDirectoryName() ) );
1122 d.appendChild( a );
1123
1124 }
1125 if ( dirAcc.getOnlineResource() != null ) {
1126 Element a = createElement( D_CONTEXT_NS, "deegree:Access" );
1127 appendOnlineResource( a, dirAcc.getOnlineResource() );
1128 d.appendChild( a );
1129 }
1130 toNode.appendChild( d );
1131 }
1132
1133 }
1134
1135 /**
1136 * Appends the XML representation of a list of a <code>Frontend</code> to a <code>Node</code> using the
1137 * <code>namespace</code>.
1138 *
1139 * @param toNode
1140 * the <code>Node</code> to append the new element to
1141 * @param fEnd
1142 * the <code>Frontend</code> to be appended as new element
1143 *
1144 */
1145 protected static void appendFrontend( Node toNode, Frontend fEnd ) {
1146
1147 if ( fEnd != null ) {
1148 Element e = createElement( D_CONTEXT_NS, "deegree:Frontend" );
1149
1150 e.setAttribute( "scope", "JSP" );
1151 if ( fEnd.getController() != null ) {
1152 Element c = createElement( D_CONTEXT_NS, "deegree:Controller" );
1153 c.appendChild( createTextNode( fEnd.getController() ) );
1154 e.appendChild( c );
1155 }
1156 if ( ( (JSPFrontend) fEnd ).getStyle() != null ) {
1157 Element c = createElement( D_CONTEXT_NS, "deegree:Style" );
1158 c.appendChild( createTextNode( ( (JSPFrontend) fEnd ).getStyle() ) );
1159 e.appendChild( c );
1160 }
1161 if ( ( (JSPFrontend) fEnd ).getHeader() != null ) {
1162 Element c = createElement( D_CONTEXT_NS, "deegree:Header" );
1163 c.appendChild( createTextNode( ( (JSPFrontend) fEnd ).getHeader() ) );
1164 e.appendChild( c );
1165 }
1166 if ( ( (JSPFrontend) fEnd ).getFooter() != null ) {
1167 Element c = createElement( D_CONTEXT_NS, "deegree:Footer" );
1168 c.appendChild( createTextNode( ( (JSPFrontend) fEnd ).getFooter() ) );
1169 e.appendChild( c );
1170 }
1171
1172 appendCommonJS( e, ( (JSPFrontend) fEnd ).getCommonJS() );
1173
1174 appendButtons( e, ( (JSPFrontend) fEnd ).getButtons() );
1175
1176 appendGUIArea( e, fEnd.getNorth(), "deegree:North" );
1177 appendGUIArea( e, fEnd.getWest(), "deegree:West" );
1178 appendGUIArea( e, fEnd.getCenter(), "deegree:Center" );
1179 appendGUIArea( e, fEnd.getEast(), "deegree:East" );
1180 appendGUIArea( e, fEnd.getSouth(), "deegree:South" );
1181
1182 toNode.appendChild( e );
1183 }
1184
1185 }
1186
1187 /**
1188 * Appends the XML representation of a list of a <code>String[]</code> to a <code>Node</code> using the
1189 * <code>namespace</code>.
1190 *
1191 * @param toNode
1192 * the <code>Node</code> to append the new element to
1193 * @param commonJS
1194 * the <code>String[]</code> to be appended as new element
1195 *
1196 */
1197 protected static void appendCommonJS( Node toNode, String[] commonJS ) {
1198
1199 if ( commonJS != null ) {
1200 Element c = createElement( D_CONTEXT_NS, "deegree:CommonJS" );
1201
1202 for ( int i = 0; i < commonJS.length; i++ ) {
1203 if ( commonJS[i] != null ) {
1204 Element n = createElement( D_CONTEXT_NS, "deegree:Name" );
1205 n.appendChild( createTextNode( commonJS[i] ) );
1206 c.appendChild( n );
1207 }
1208 }
1209 toNode.appendChild( c );
1210 }
1211
1212 }
1213
1214 /**
1215 * Appends the XML representation of a list of a <code>String</code> to a <code>Node</code> using the
1216 * <code>namespace</code>. // TODO
1217 *
1218 * @param toNode
1219 * the <code>Node</code> to append the new element to
1220 * @param buttons
1221 * the <code>String</code> to be appended as new element
1222 *
1223 */
1224 protected static void appendButtons( Node toNode, String buttons ) {
1225
1226 if ( buttons != null ) {
1227 Element b = createElement( D_CONTEXT_NS, "deegree:Buttons" );
1228 b.appendChild( createTextNode( buttons ) );
1229
1230 toNode.appendChild( b );
1231 }
1232
1233 }
1234
1235 /**
1236 * Appends the XML representation of a list of a <code>GUIArea</code> to a <code>Node</code> using the
1237 * <code>namespace</code>.
1238 *
1239 * @param toNode
1240 * the <code>Node</code> to append the new element to
1241 * @param guiArea
1242 * the <code>GUIArea</code> to be appended as new element
1243 * @param name
1244 *
1245 */
1246 protected static void appendGUIArea( Node toNode, GUIArea guiArea, String name ) {
1247
1248 if ( guiArea != null ) {
1249 Element e = createElement( D_CONTEXT_NS, name );
1250 e.setAttribute( "hidden", String.valueOf( guiArea.isHidden() ) );
1251 if ( guiArea.getWidth() > 0 ) {
1252 e.setAttribute( "width", String.valueOf( guiArea.getWidth() ) );
1253 }
1254 if ( guiArea.getHeight() > 0 ) {
1255 e.setAttribute( "height", String.valueOf( guiArea.getHeight() ) );
1256 }
1257 if ( guiArea.getTop() > -1 ) {
1258 e.setAttribute( "top", String.valueOf( guiArea.getTop() ) );
1259 }
1260 if ( guiArea.getRight() > 0 ) {
1261 e.setAttribute( "right", String.valueOf( guiArea.getRight() ) );
1262 }
1263 if ( guiArea.getLeft() > -1 ) {
1264 e.setAttribute( "left", String.valueOf( guiArea.getLeft() ) );
1265 }
1266 if ( guiArea.getBottom() > 0 ) {
1267 e.setAttribute( "bottom", String.valueOf( guiArea.getBottom() ) );
1268 }
1269 e.setAttribute( "closable", String.valueOf( guiArea.isClosable() ).toLowerCase() );
1270 e.setAttribute( "header", String.valueOf( guiArea.hasHeader() ).toLowerCase() );
1271 e.setAttribute( "overlay", String.valueOf( guiArea.isOverlay() ).toLowerCase() );
1272
1273 Module[] mods = guiArea.getModules();
1274 if ( mods != null ) {
1275 for ( int i = 0; i < mods.length; i++ ) {
1276 if ( mods[i] != null ) {
1277 appendModule( e, mods[i] );
1278 }
1279 }
1280 }
1281
1282 toNode.appendChild( e );
1283 }
1284
1285 }
1286
1287 /**
1288 * Appends the XML representation of a list of a <code>GUIArea</code> to a <code>Node</code> using the
1289 * <code>namespace</code>.
1290 *
1291 * @param toNode
1292 * the <code>Node</code> to append the new element to
1293 * @param mod
1294 *
1295 */
1296 protected static void appendModule( Node toNode, Module mod ) {
1297
1298 if ( mod != null ) {
1299 Element m = createElement( D_CONTEXT_NS, "deegree:Module" );
1300 m.setAttribute( "hidden", String.valueOf( mod.isHidden() ) );
1301
1302 m.setAttribute( "type", mod.getType() );
1303 m.setAttribute( "scrolling", String.valueOf( mod.getScrolling() ) );
1304 if ( mod.getWidth() > 0 ) {
1305 m.setAttribute( "width", String.valueOf( mod.getWidth() ) );
1306 }
1307 if ( mod.getHeight() > 0 ) {
1308 m.setAttribute( "height", String.valueOf( mod.getHeight() ) );
1309 }
1310 if ( mod.getTop() > -1 ) {
1311 m.setAttribute( "top", String.valueOf( mod.getTop() ) );
1312 }
1313 if ( mod.getRight() > 0 ) {
1314 m.setAttribute( "right", String.valueOf( mod.getRight() ) );
1315 }
1316 if ( mod.getLeft() > -1 ) {
1317 m.setAttribute( "left", String.valueOf( mod.getLeft() ) );
1318 }
1319 if ( mod.getBottom() > 0 ) {
1320 m.setAttribute( "bottom", String.valueOf( mod.getBottom() ) );
1321 }
1322 m.setAttribute( "closeable", String.valueOf( mod.isClosable() ).toLowerCase() );
1323 m.setAttribute( "header", String.valueOf( mod.hasHeader() ).toLowerCase() );
1324 m.setAttribute( "overlay", String.valueOf( mod.isOverlay() ).toLowerCase() );
1325 m.setAttribute( "collapsed", String.valueOf( mod.isCollapsed() ).toLowerCase() );
1326
1327 Element n = createElement( D_CONTEXT_NS, "deegree:Name" );
1328 n.appendChild( createTextNode( mod.getName() ) );
1329 m.appendChild( n );
1330
1331 n = createElement( D_CONTEXT_NS, "deegree:Title" );
1332 n.appendChild( createTextNode( mod.getTitle() ) );
1333 m.appendChild( n );
1334
1335 n = createElement( D_CONTEXT_NS, "deegree:Content" );
1336 n.appendChild( createTextNode( mod.getContent() ) );
1337 m.appendChild( n );
1338
1339 appendModuleJSList( m, mod.getModuleJSList() );
1340 appendModuleConfiguration( m, mod.getModuleConfiguration() );
1341 appendParameterList( m, mod.getParameter() );
1342
1343 toNode.appendChild( m );
1344 }
1345
1346 }
1347
1348 /**
1349 * Appends the XML representation of a list of a <code>ModuleConfiguration</code> to a <code>Node</code> using the
1350 * <code>namespace</code>.
1351 *
1352 * @param toNode
1353 * the <code>Node</code> to append the new element to
1354 * @param modConf
1355 * the <code>ModuleConfiguration</code> to be appended as new element
1356 *
1357 */
1358 protected static void appendModuleConfiguration( Node toNode, ModuleConfiguration modConf ) {
1359
1360 if ( modConf != null && modConf.getOnlineResource() != null ) {
1361 Element e = createElement( D_CONTEXT_NS, "deegree:ModuleConfiguration" );
1362 appendOnlineResource( e, modConf.getOnlineResource() );
1363 toNode.appendChild( e );
1364 }
1365
1366 }
1367
1368 /**
1369 * Appends the XML representation of a list of a <code>ParameterList</code> to a <code>Node</code> using the
1370 * <code>namespace</code>.
1371 *
1372 * @param toNode
1373 * the <code>Node</code> to append the new element to
1374 * @param parList
1375 * the <code>ParameterList</code> to be appended as new element
1376 *
1377 */
1378 protected static void appendParameterList( Node toNode, ParameterList parList ) {
1379
1380 if ( parList != null && parList.getParameters().length > 0 ) {
1381
1382 Element e = createElement( D_CONTEXT_NS, "deegree:ParameterList" );
1383
1384 Parameter[] pars = parList.getParameters();
1385 for ( int i = 0; i < pars.length; i++ ) {
1386 if ( pars[i] != null ) {
1387 Element p = createElement( D_CONTEXT_NS, "deegree:Parameter" );
1388
1389 Element n = createElement( D_CONTEXT_NS, "deegree:Name" );
1390 String name = pars[i].getName();
1391 // name = name.substring(0,name.indexOf(':'));
1392 n.appendChild( createTextNode( name ) );
1393 p.appendChild( n );
1394
1395 n = createElement( D_CONTEXT_NS, "deegree:Value" );
1396 n.appendChild( createTextNode( pars[i].getValue().toString() ) );
1397 p.appendChild( n );
1398
1399 e.appendChild( p );
1400 }
1401 }
1402 toNode.appendChild( e );
1403 }
1404
1405 }
1406
1407 /**
1408 * Appends the XML representation of a list of a <code>MapParameter</code> to a <code>Node</code> using the
1409 * <code>namespace</code>.
1410 *
1411 * @param toNode
1412 * the <code>Node</code> to append the new element to
1413 * @param mapPar
1414 * the <code>MapParameter</code> to be appended as new element
1415 *
1416 */
1417 protected static void appendMapParameter( Node toNode, MapParameter mapPar ) {
1418
1419 if ( mapPar != null ) {
1420 Element e = createElement( D_CONTEXT_NS, "deegree:MapParameter" );
1421
1422 Element f = createElement( D_CONTEXT_NS, "deegree:OfferedInfoFormats" );
1423 appendFormats( f, mapPar.getOfferedInfoFormats() );
1424 e.appendChild( f );
1425
1426 appendMapOperationFactors( e, mapPar.getOfferedZoomFactors(), "deegree:OfferedZoomFactor" );
1427 appendMapOperationFactors( e, mapPar.getOfferedPanFactors(), "deegree:OfferedPanFactor" );
1428
1429 Element minScale = createElement( D_CONTEXT_NS, "deegree:MinScale" );
1430 minScale.appendChild( createTextNode( String.valueOf( mapPar.getMinScale() ) ) );
1431 e.appendChild( minScale );
1432
1433 Element maxScale = createElement( D_CONTEXT_NS, "deegree:MaxScale" );
1434 maxScale.appendChild( createTextNode( String.valueOf( mapPar.getMaxScale() ) ) );
1435 e.appendChild( maxScale );
1436
1437 toNode.appendChild( e );
1438 }
1439
1440 }
1441
1442 /**
1443 * Appends the XML representation of a list of a <code>Format[]</code> to a <code>Node</code> using the
1444 * <code>namespace</code>.
1445 *
1446 * @param toNode
1447 * the <code>Node</code> to append the new element to
1448 * @param formats
1449 * the <code>Format[]</code> to be appended as new element
1450 *
1451 */
1452 protected static void appendFormats( Node toNode, Format[] formats ) {
1453
1454 if ( formats != null ) {
1455 for ( int i = 0; i < formats.length; i++ ) {
1456 if ( formats[i] != null ) {
1457 Element f = createElement( D_CONTEXT_NS, "deegree:Format" );
1458
1459 // TODO is current or selected?
1460 if ( formats[i].isCurrent() ) {
1461 f.setAttribute( "selected", String.valueOf( formats[i].isCurrent() ) );
1462 }
1463
1464 f.appendChild( createTextNode( formats[i].getName() ) );
1465 toNode.appendChild( f );
1466 }
1467 }
1468 }
1469
1470 }
1471
1472 /**
1473 * Appends the XML representation of a list of a <code>MapOperationFactor</code> to a <code>Node</code> using the
1474 * <code>namespace</code>.
1475 *
1476 * @param toNode
1477 * the <code>Node</code> to append the new element to
1478 * @param mapOpFac
1479 * the <code>MapOperationFactor</code> to be appended as new element
1480 * @param opName
1481 *
1482 */
1483 protected static void appendMapOperationFactors( Node toNode, MapOperationFactor[] mapOpFac, String opName ) {
1484
1485 if ( mapOpFac != null ) {
1486 for ( int i = 0; i < mapOpFac.length; i++ ) {
1487 if ( mapOpFac[i] != null ) {
1488
1489 Element mof = createElement( D_CONTEXT_NS, opName );
1490 Element f = createElement( D_CONTEXT_NS, "deegree:Factor" );
1491 f.appendChild( createTextNode( String.valueOf( mapOpFac[i].getFactor() ) ) );
1492
1493 if ( mapOpFac[i].isSelected() ) {
1494 f.setAttribute( "selected", String.valueOf( mapOpFac[i].isSelected() ) );
1495 }
1496
1497 // TODO isFree ???
1498
1499 mof.appendChild( f );
1500 toNode.appendChild( mof );
1501 }
1502 }
1503 }
1504
1505 }
1506
1507 /**
1508 * Appends the XML representation of a list of a <code>LayerExtension</code> to a <code>Node</code> using the
1509 * <code>namespace</code>.
1510 *
1511 * @param toNode
1512 * the <code>Node</code> to append the new element to
1513 * @param layExt
1514 * the <code>LayerExtension</code> to be appended as new element
1515 *
1516 */
1517 protected static void appendLayerExtension( Node toNode, LayerExtension layExt ) {
1518
1519 if ( layExt != null ) {
1520 Element e = createElement( OGC_CONTEXT_NS, "Extension" );
1521
1522 appendDataService( e, layExt.getDataService() );
1523
1524 Element g = createElement( D_CONTEXT_NS, "deegree:MasterLayer" );
1525 g.appendChild( createTextNode( String.valueOf( layExt.isMasterLayer() ) ) );
1526 e.appendChild( g );
1527
1528 g = createElement( D_CONTEXT_NS, "deegree:ScaleHint" );
1529 g.setAttribute( "min", "" + layExt.getMinScaleHint() );
1530 g.setAttribute( "max", "" + layExt.getMaxScaleHint() );
1531 e.appendChild( g );
1532
1533 g = createElement( D_CONTEXT_NS, "deegree:parentNodeId" );
1534 g.appendChild( createTextNode( String.valueOf( layExt.getParentNodeId() ) ) );
1535 e.appendChild( g );
1536
1537 g = createElement( D_CONTEXT_NS, "deegree:SelectedForQuery" );
1538 g.appendChild( createTextNode( String.valueOf( layExt.isSelectedForQuery() ) ) );
1539 e.appendChild( g );
1540
1541 if ( layExt.getIdentifier() != null ) {
1542 g = createElement( D_CONTEXT_NS, "deegree:identifier" );
1543 g.appendChild( createTextNode( String.valueOf( layExt.getIdentifier() ) ) );
1544 e.appendChild( g );
1545 }
1546
1547 g = createElement( D_CONTEXT_NS, "deegree:UseAuthentication" );
1548 // System.out.println(layExt.getAuthentication());
1549 if ( layExt.getAuthentication() == LayerExtension.SESSIONID ) {
1550 g.appendChild( createTextNode( "sessionID" ) );
1551 } else if ( layExt.getAuthentication() == LayerExtension.USERPASSWORD ) {
1552 g.appendChild( createTextNode( "user/password" ) );
1553 } else if ( layExt.getAuthentication() == LayerExtension.NONE ) {
1554 g.appendChild( createTextNode( "none" ) );
1555 }
1556 e.appendChild( g );
1557
1558 toNode.appendChild( e );
1559 }
1560
1561 }
1562
1563 /**
1564 * Appends the XML representation of a list of a <code>DataService</code> to a <code>Node</code> using the
1565 * <code>namespace</code>.
1566 *
1567 * @param toNode
1568 * the <code>Node</code> to append the new element to
1569 * @param dataServ
1570 * the <code>DataService</code> to be appended as new element
1571 *
1572 */
1573 protected static void appendDataService( Node toNode, DataService dataServ ) {
1574
1575 if ( dataServ != null ) {
1576 Element e = createElement( D_CONTEXT_NS, "deegree:DataService" );
1577
1578 if ( dataServ.getServer() != null ) {
1579 appendServer( e, dataServ.getServer() );
1580 }
1581 String geoType = dataServ.getGeometryType();
1582 if ( geoType != null ) {
1583 Element g = createElement( D_CONTEXT_NS, "deegree:GeometryType" );
1584 g.appendChild( createTextNode( dataServ.getGeometryType() ) );
1585 e.appendChild( g );
1586 }
1587 String featType = dataServ.getFeatureType();
1588 if ( featType != null ) {
1589 Element g = createElement( D_CONTEXT_NS, "deegree:FeatureType" );
1590 g.appendChild( createTextNode( featType ) );
1591 e.appendChild( g );
1592 }
1593
1594 toNode.appendChild( e );
1595 }
1596
1597 }
1598
1599 /**
1600 * Appends the XML representation of a list of a <code>ParameterList</code> to a <code>Node</code> using the
1601 * <code>namespace</code>.
1602 *
1603 * @param toNode
1604 * the <code>Node</code> to append the new element to
1605 * @param modJSList
1606 * the <code>modJSList</code> to be appended as new element
1607 *
1608 */
1609 protected static void appendModuleJSList( Node toNode, String[] modJSList ) {
1610
1611 if ( modJSList != null && modJSList.length > 0 ) {
1612
1613 for ( int i = 0; i < modJSList.length; i++ ) {
1614 if ( modJSList[i] != null ) {
1615 Element p = createElement( D_CONTEXT_NS, "deegree:ModuleJS" );
1616 p.appendChild( createTextNode( modJSList[i] ) );
1617
1618 toNode.appendChild( p );
1619 }
1620 }
1621 }
1622
1623 }
1624
1625 }