    001    //$HeadURL: https://svn.wald.intevation.org/svn/deegree/base/branches/2.4_testing/src/org/deegree/graphics/sld/StyleFactory.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     Additional copyright notes:
    010     The basic version of this class was taken from the Geotools2 project
    011     (StyleBuilder.java): Geotools2 - OpenSource mapping toolkit
    012     http://geotools.org
    013     (C) 2002, Geotools Project Managment Committee (PMC)
    014
    015     This library is free software; you can redistribute it and/or modify it under
    016     the terms of the GNU Lesser General Public License as published by the Free
    017     Software Foundation; either version 2.1 of the License, or (at your option)
    018     any later version.
    019     This library is distributed in the hope that it will be useful, but WITHOUT
    020     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    021     FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
    022     details.
    023     You should have received a copy of the GNU Lesser General Public License
    024     along with this library; if not, write to the Free Software Foundation, Inc.,
    025     59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
    026
    027     Contact information:
    028
    029     lat/lon GmbH
    030     Aennchenstr. 19, 53177 Bonn
    031     Germany
    032     http://lat-lon.de/
    033
    034     Department of Geography, University of Bonn
    035     Prof. Dr. Klaus Greve
    036     Postfach 1147, 53001 Bonn
    037     Germany
    038     http://www.geographie.uni-bonn.de/deegree/
    039
    040     e-mail: info@deegree.org
    041    ----------------------------------------------------------------------------*/
    042    package org.deegree.graphics.sld;
    043
    044    import java.awt.Color;
    045    import java.net.MalformedURLException;
    046    import java.net.URL;
    047    import java.util.HashMap;
    048
    049    import org.deegree.framework.util.ColorUtils;
    050    import org.deegree.model.filterencoding.Expression;
    051    import org.deegree.model.filterencoding.Filter;
    052    import org.deegree.ogcbase.PropertyPath;
    053
    054    /**
    055     * An utility class designed to easy creation of style by convinience methods.
    056     *
    057     * @author <a href="mailto:poth@lat-lon.de">Andreas Poth </a>
    058     */
    059    public class StyleFactory {
    060
    061        /**
    062         * creates a <tt>ParameterValueType</tt> instance with a <tt>String</tt> as value
    063         *
    064         * @param value
    065         *            value of the <tt>ParameterValueType</tt>
    066         *
    067         * @return the ParameterValueType created
    068         */
    069        public static ParameterValueType createParameterValueType( String value ) {
    070            return new ParameterValueType( new Object[] { value } );
    071        }
    072
    073        /**
    074         * creates a <tt>ParameterValueType</tt> instance with a <tt>int</tt> as value
    075         *
    076         * @param value
    077         *            value of the <tt>ParameterValueType</tt>
    078         *
    079         * @return the ParameterValueType created
    080         */
    081        public static ParameterValueType createParameterValueType( int value ) {
    082            return new ParameterValueType( new Object[] { "" + value } );
    083        }
    084
    085        /**
    086         * creates a <tt>ParameterValueType</tt> instance with a <tt>String</tt> as value
    087         *
    088         * @param value
    089         *            value of the <tt>ParameterValueType</tt>
    090         *
    091         * @return the ParameterValueType created
    092         */
    093        public static ParameterValueType createParameterValueType( double value ) {
    094            return new ParameterValueType( new Object[] { "" + value } );
    095        }
    096
    097        /**
    098         * creates a <tt>ParameterValueType</tt> instance with an array of <tt>Expression</tt> s as value
    099         *
    100         * @param expressions
    101         *
    102         * @return the the ParameterValueType created
    103         */
    104        public static ParameterValueType createParameterValueType( Expression[] expressions ) {
    105            return new ParameterValueType( expressions );
    106        }
    107
    108        /**
    109         * creates a CssParameter with a name and a value
    110         *
    111         * @param name
    112         *            name of the css parameter
    113         * @param value
    114         *            value of the css parameter
    115         *
    116         * @return the CssParameter created
    117         */
    118        public static CssParameter createCssParameter( String name, String value ) {
    119            ParameterValueType pvt = createParameterValueType( value );
    120            return new CssParameter( name, pvt );
    121        }
    122
    123        /**
    124         * creates a CssParameter with a name and a value
    125         *
    126         * @param name
    127         *            name of the css parameter
    128         * @param value
    129         *            value of the css parameter
    130         *
    131         * @return the CssParameter created
    132         */
    133        public static CssParameter createCssParameter( String name, int value ) {
    134            ParameterValueType pvt = createParameterValueType( value );
    135            return new CssParameter( name, pvt );
    136        }
    137
    138        /**
    139         * creates a CssParameter with a name and a value
    140         *
    141         * @param name
    142         *            name of the css parameter
    143         * @param value
    144         *            value of the css parameter
    145         *
    146         * @return the CssParameter created
    147         */
    148        public static CssParameter createCssParameter( String name, double value ) {
    149            ParameterValueType pvt = createParameterValueType( value );
    150            return new CssParameter( name, pvt );
    151        }
    152
    153        /**
    154         * creates a <tt>GraphicStroke</tt> from a <tt>Graphic</tt> object
    155         *
    156         * @param graphic
    157         *            <tt>Graphic</tt object
    158         *
    159         * @return the GraphicStroke created
    160         */
    161        public static GraphicStroke createGraphicStroke( Graphic graphic ) {
    162            return new GraphicStroke( graphic );
    163        }
    164
    165        /**
    166         * creates a <tt>GraphicFill</tt> from a <tt>Graphic</tt> object
    167         *
    168         * @param graphic
    169         *            <tt>Graphic</tt object
    170         *
    171         * @return the GraphicFill created
    172         */
    173        public static GraphicFill createGraphicFill( Graphic graphic ) {
    174            return new GraphicFill( graphic );
    175        }
    176
    177        /**
    178         * create a default Stroke that black, 1 pixel width, complete opaque, with round linejoin and square line cap
    179         *
    180         * @return the Stroke created
    181         */
    182        public static Stroke createStroke() {
    183            return createStroke( Color.BLACK, 1, "round", "square" );
    184        }
    185
    186        /**
    187         * create a default stroke with the supplied width
    188         *
    189         * @param width
    190         *            the width of the line
    191         *
    192         * @return the stroke created
    193         */
    194        public static Stroke createStroke( double width ) {
    195            return createStroke( Color.BLACK, width );
    196        }
    197
    198        /**
    199         * Create a default stroke with the supplied color
    200         *
    201         * @param color
    202         *            the color of the line
    203         *
    204         * @return the created stroke
    205         */
    206        public static Stroke createStroke( Color color ) {
    207            return createStroke( color, 1 );
    208        }
    209
    210        /**
    211         * create a stroke with the passed width and color
    212         *
    213         * @param color
    214         *            the color of the line
    215         * @param width
    216         *            the width of the line
    217         *
    218         * @return the created stroke
    219         */
    220        public static Stroke createStroke( Color color, double width ) {
    221            return createStroke( color, width, "round", "square" );
    222        }
    223
    224        /**
    225         * create a stroke with color, width, linejoin type and lineCap type.
    226         *
    227         * @param color
    228         *            the color of the line
    229         * @param width
    230         *            the width of the line
    231         * @param lineJoin
    232         *            the type of join to be used at points along the line
    233         * @param lineCap
    234         *            the type of cap to be used at the end of the line
    235         *
    236         * @return the stroke created
    237         */
    238        public static Stroke createStroke( Color color, double width, String lineJoin, String lineCap ) {
    239            return createStroke( color, width, 1, null, lineJoin, lineCap );
    240        }
    241
    242        /**
    243         * create a stroke with color, width, linejoin type and lineCap type.
    244         *
    245         * @param color
    246         *            the color of the line
    247         * @param width
    248         *            the width of the line
    249         * @param opacity
    250         *            the opacity or <I>see throughness </I> of the line, 0 - is transparent, 1 is completely drawn
    251         * @param dashArray
    252         * @param lineJoin
    253         *            the type of join to be used at points along the line
    254         * @param lineCap
    255         *            the type of cap to be used at the end of the line
    256         *
    257         * @return the stroke created
    258         */
    259        public static Stroke createStroke( Color color, double width, double opacity, float[] dashArray, String lineJoin,
    260                                           String lineCap ) {
    261            HashMap<String, Object> cssParams = new HashMap<String, Object>();
    262
    263            CssParameter stroke = createCssParameter( "stroke", ColorUtils.toHexCode( "#", color ) );
    264            cssParams.put( "stroke", stroke );
    265            CssParameter strokeOp = createCssParameter( "stroke-opacity", opacity );
    266            cssParams.put( "stroke-opacity", strokeOp );
    267            CssParameter strokeWi = createCssParameter( "stroke-width", width );
    268            cssParams.put( "stroke-width", strokeWi );
    269            CssParameter strokeLJ = createCssParameter( "stroke-linejoin", lineJoin );
    270            cssParams.put( "stroke-linejoin", strokeLJ );
    271            CssParameter strokeCap = createCssParameter( "stroke-linecap", lineCap );
    272            cssParams.put( "stroke-linecap", strokeCap );
    273
    274            if ( dashArray != null ) {
    275                String s = "";
    276                for ( int i = 0; i < dashArray.length - 1; i++ ) {
    277                    s = s + dashArray[i] + ",";
    278                }
    279                s = s + dashArray[dashArray.length - 1];
    280                CssParameter strokeDash = createCssParameter( "stroke-dasharray", s );
    281                cssParams.put( "stroke-dasharray", strokeDash );
    282            }
    283
    284            return new Stroke( cssParams, null, null );
    285        }
    286
    287        /**
    288         * create a dashed line of color and width
    289         *
    290         * @param color
    291         *            the color of the line
    292         * @param width
    293         *            the width of the line
    294         * @param dashArray
    295         *            an array of floats describing the length of line and spaces
    296         *
    297         * @return the stroke created
    298         */
    299        public static Stroke createStroke( Color color, double width, float[] dashArray ) {
    300            HashMap<String, Object> cssParams = new HashMap<String, Object>();
    301
    302            CssParameter stroke = createCssParameter( "stroke", ColorUtils.toHexCode( "#", color ) );
    303            cssParams.put( "stroke", stroke );
    304            CssParameter strokeOp = createCssParameter( "stroke-opacity", "1" );
    305            cssParams.put( "stroke-opacity", strokeOp );
    306            CssParameter strokeWi = createCssParameter( "stroke-width", width );
    307            cssParams.put( "stroke-width", strokeWi );
    308            CssParameter strokeLJ = createCssParameter( "stroke-linejoin", "mitre" );
    309            cssParams.put( "stroke-linejoin", strokeLJ );
    310            CssParameter strokeCap = createCssParameter( "stroke-linecap", "butt" );
    311            cssParams.put( "stroke-linecap", strokeCap );
    312
    313            if ( dashArray != null ) {
    314                String s = "";
    315                for ( int i = 0; i < dashArray.length - 1; i++ ) {
    316                    s = s + dashArray[i] + ",";
    317                }
    318                s = s + dashArray[dashArray.length - 1];
    319                CssParameter strokeDash = createCssParameter( "stroke-dasharray", s );
    320                cssParams.put( "stroke-dasharray", strokeDash );
    321            }
    322
    323            return new Stroke( cssParams, null, null );
    324        }
    325
    326        /**
    327         * create a stroke with color, width and opacity supplied
    328         *
    329         * @param color
    330         *            the color of the line
    331         * @param width
    332         *            the width of the line
    333         * @param opacity
    334         *            the opacity or <I>see throughness </I> of the line, 0 - is transparent, 1 is completely drawn
    335         *
    336         * @return the stroke created
    337         */
    338        public static Stroke createStroke( Color color, double width, double opacity ) {
    339            return createStroke( color, width, opacity, null, "mitre", "butt" );
    340        }
    341
    342        /**
    343         * create a default fill 50% gray
    344         *
    345         * @return the fill created
    346         */
    347        public static Fill createFill() {
    348            return createFill( Color.GRAY, 1d, null );
    349        }
    350
    351        /**
    352         * create a fill of color
    353         *
    354         * @param color
    355         *            the color of the fill
    356         *
    357         * @return the fill created
    358         */
    359        public static Fill createFill( Color color ) {
    360            return createFill( color, 1d, null );
    361        }
    362
    363        /**
    364         * create a fill with the supplied color and opacity
    365         *
    366         * @param color
    367         *            the color to fill with
    368         * @param opacity
    369         *            the opacity of the fill 0 - transparent, 1 - completly filled
    370         *
    371         * @return the fill created
    372         */
    373        public static Fill createFill( Color color, double opacity ) {
    374            return createFill( color, opacity, null );
    375        }
    376
    377        /**
    378         * create a fill with color and opacity supplied and uses the graphic fill supplied for the fill
    379         *
    380         * @param color
    381         *            the foreground color
    382         * @param opacity
    383         *            the opacity of the fill
    384         * @param fill
    385         *            the graphic object to use to fill the fill
    386         *
    387         * @return the fill created
    388         */
    389        public static Fill createFill( Color color, double opacity, GraphicFill fill ) {
    390            HashMap<String, Object> cssParams = new HashMap<String, Object>();
    391            CssParameter fillCo = createCssParameter( "fill", ColorUtils.toHexCode( "#", color ) );
    392            cssParams.put( "fill", fillCo );
    393            CssParameter fillOp = createCssParameter( "fill-opacity", opacity );
    394            cssParams.put( "fill-opacity", fillOp );
    395            return new Fill( cssParams, fill );
    396        }
    397
    398        /**
    399         * create the named mark
    400         *
    401         * @param wellKnownName
    402         *            the wellknown name of the mark
    403         *
    404         * @return the mark created
    405         */
    406        public static Mark createMark( String wellKnownName ) {
    407            return new Mark( wellKnownName, createStroke(), createFill() );
    408        }
    409
    410        /**
    411         * create the named mark with the colors etc supplied
    412         *
    413         * @param wellKnownName
    414         *            the well known name of the mark
    415         * @param fillColor
    416         *            the color of the mark
    417         * @param borderColor
    418         *            the outline color of the mark
    419         * @param borderWidth
    420         *            the width of the outline
    421         *
    422         * @return the mark created
    423         */
    424        public static Mark createMark( String wellKnownName, Color fillColor, Color borderColor, double borderWidth ) {
    425            Stroke stroke = createStroke( borderColor, borderWidth );
    426            Fill fill = createFill( fillColor );
    427            return new Mark( wellKnownName, stroke, fill );
    428        }
    429
    430        /**
    431         * create a mark with default fill (50% gray) and the supplied outline
    432         *
    433         * @param wellKnownName
    434         *            the well known name of the mark
    435         * @param borderColor
    436         *            the outline color
    437         * @param borderWidth
    438         *            the outline width
    439         *
    440         * @return the mark created
    441         */
    442        public static Mark createMark( String wellKnownName, Color borderColor, double borderWidth ) {
    443            Stroke stroke = createStroke( borderColor, borderWidth );
    444            Fill fill = createFill();
    445            return new Mark( wellKnownName, stroke, fill );
    446        }
    447
    448        /**
    449         * create a mark of the supplied color and a default outline (black)
    450         *
    451         * @param wellKnownName
    452         *            the well known name of the mark
    453         * @param fillColor
    454         *            the color of the mark
    455         *
    456         * @return the created mark
    457         */
    458        public static Mark createMark( String wellKnownName, Color fillColor ) {
    459            Stroke stroke = createStroke();
    460            Fill fill = createFill( fillColor );
    461            return new Mark( wellKnownName, stroke, fill );
    462        }
    463
    464        /**
    465         * create a mark with the supplied fill and stroke
    466         *
    467         * @param wellKnownName
    468         *            the well known name of the mark
    469         * @param fill
    470         *            the fill to use
    471         * @param stroke
    472         *            the stroke to use
    473         *
    474         * @return the mark created
    475         */
    476        public static Mark createMark( String wellKnownName, Fill fill, Stroke stroke ) {
    477            return new Mark( wellKnownName, stroke, fill );
    478        }
    479
    480        /**
    481         * wrapper for stylefactory method
    482         *
    483         * @param uri
    484         *            the uri of the image
    485         * @param format
    486         *            mime type of the image
    487         *
    488         * @return the external graphic
    489         * @throws MalformedURLException
    490         */
    491        public static ExternalGraphic createExternalGraphic( String uri, String format )
    492                                throws MalformedURLException {
    493            return createExternalGraphic( new URL( uri ), format );
    494        }
    495
    496        /**
    497         * wrapper for stylefactory method
    498         *
    499         * @param url
    500         *            the url of the image
    501         * @param format
    502         *            mime type of the image
    503         *
    504         * @return the external graphic
    505         */
    506        public static ExternalGraphic createExternalGraphic( java.net.URL url, String format ) {
    507            return new ExternalGraphic( format, url );
    508        }
    509
    510        /**
    511         * creates a graphic object
    512         *
    513         * @param externalGraphic
    514         *            an external graphic to use if displayable
    515         * @param mark
    516         *            a mark to use
    517         * @param opacity -
    518         *            the opacity of the graphic
    519         * @param size -
    520         *            the size of the graphic
    521         * @param rotation -
    522         *            the rotation from the top of the page of the graphic
    523         *
    524         * @return the graphic created
    525         */
    526        public static Graphic createGraphic( ExternalGraphic externalGraphic, Mark mark, double opacity, double size,
    527                                             double rotation ) {
    528
    529            Object[] mae = null;
    530            if ( externalGraphic != null && mark != null ) {
    531                mae = new Object[] { externalGraphic, mark };
    532            } else if ( externalGraphic != null ) {
    533                mae = new Object[] { externalGraphic };
    534            } else if ( mark != null ) {
    535                mae = new Object[] { mark };
    536            }
    537            ParameterValueType op_pvt = createParameterValueType( opacity );
    538            ParameterValueType sz_pvt = createParameterValueType( size );
    539            ParameterValueType ro_pvt = createParameterValueType( rotation );
    540            return new Graphic( mae, op_pvt, sz_pvt, ro_pvt );
    541        }
    542
    543        /**
    544         * wrapper round Stylefactory Method
    545         *
    546         * @return the default pointplacement
    547         */
    548        public static PointPlacement createPointPlacement() {
    549            return new PointPlacement();
    550        }
    551
    552        /**
    553         * wrapper round Stylefactory Method
    554         *
    555         * @param anchorX -
    556         *            the X coordinate
    557         * @param anchorY -
    558         *            the Y coordinate
    559         * @param rotation -
    560         *            the rotaion of the label
    561         *
    562         * @return the pointplacement created
    563         */
    564        public static PointPlacement createPointPlacement( double anchorX, double anchorY, double rotation ) {
    565            ParameterValueType pvt1 = createParameterValueType( anchorX );
    566            ParameterValueType pvt2 = createParameterValueType( anchorY );
    567            ParameterValueType[] anchorPoint = new ParameterValueType[] { pvt1, pvt2 };
    568            ParameterValueType rot = createParameterValueType( rotation );
    569            return new PointPlacement( anchorPoint, null, rot, false );
    570        }
    571
    572        /**
    573         * wrapper round Stylefactory Method
    574         *
    575         * @param anchorX -
    576         *            the X coordinate
    577         * @param anchorY -
    578         *            the Y coordinate
    579         * @param displacementX -
    580         *            the X distance from the anchor
    581         * @param displacementY -
    582         *            the Y distance from the anchor
    583         * @param rotation -
    584         *            the rotaion of the label
    585         *
    586         * @return the pointplacement created
    587         */
    588        public static PointPlacement createPointPlacement( double anchorX, double anchorY, double displacementX,
    589                                                           double displacementY, double rotation ) {
    590            ParameterValueType pvt1 = createParameterValueType( anchorX );
    591            ParameterValueType pvt2 = createParameterValueType( anchorY );
    592            ParameterValueType[] anchorPoint = new ParameterValueType[] { pvt1, pvt2 };
    593
    594            ParameterValueType pvt3 = createParameterValueType( displacementX );
    595            ParameterValueType pvt4 = createParameterValueType( displacementY );
    596            ParameterValueType[] displacement = new ParameterValueType[] { pvt3, pvt4 };
    597
    598            ParameterValueType rot = createParameterValueType( rotation );
    599            return new PointPlacement( anchorPoint, displacement, rot, false );
    600        }
    601
    602        /**
    603         * @param anchorX -
    604         *            the X coordinate
    605         * @param anchorY -
    606         *            the Y coordinate
    607         * @param displacementX -
    608         *            the X distance from the anchor
    609         * @param displacementY -
    610         *            the Y distance from the anchor
    611         * @param rotation -
    612         *            the rotaion of the label
    613         * @param auto -
    614         *            auto positioning of the label
    615         *
    616         * @return the pointplacement created
    617         */
    618        public static PointPlacement createPointPlacement( double anchorX, double anchorY, double displacementX,
    619                                                           double displacementY, double rotation, boolean auto ) {
    620            ParameterValueType pvt1 = createParameterValueType( anchorX );
    621            ParameterValueType pvt2 = createParameterValueType( anchorY );
    622            ParameterValueType[] anchorPoint = new ParameterValueType[] { pvt1, pvt2 };
    623
    624            ParameterValueType pvt3 = createParameterValueType( displacementX );
    625            ParameterValueType pvt4 = createParameterValueType( displacementY );
    626            ParameterValueType[] displacement = new ParameterValueType[] { pvt3, pvt4 };
    627
    628            ParameterValueType rot = createParameterValueType( rotation );
    629            return new PointPlacement( anchorPoint, displacement, rot, auto );
    630        }
    631
    632        /**
    633         * creates a <tt>LinePlacement</tt> with a user defined distance between the labels and the lines. A positive
    634         * value indicates a position above the line, a negative value indicates a position below. The line width is asumed
    635         * to be 2 pixel and the gap between the labels is set to factor 10 of the label width.
    636         *
    637         * @param offset -
    638         *            the distance between the line and the label
    639         *
    640         * @return the LinePlacement created
    641         */
    642        public static LinePlacement createLinePlacement( double offset ) {
    643
    644            ParameterValueType perpendicularOffset = createParameterValueType( offset );
    645            ParameterValueType lineWidth = createParameterValueType( 2 );
    646            ParameterValueType gap = createParameterValueType( 10 );
    647
    648            return new LinePlacement( perpendicularOffset, lineWidth, gap );
    649        }
    650
    651        /**
    652         * creates a <tt>LinePlacement</tt> with a relative position of the label according to the line the lines. The
    653         * line width is asumed to be 2 pixel and the gap between the labels is set to factor 10 of the label width.
    654         *
    655         * @param position
    656         *            of the label relative to the line
    657         *
    658         * @return the LinePlacement created
    659         */
    660        public static LinePlacement createLinePlacement( String position ) {
    661
    662            ParameterValueType perpendicularOffset = createParameterValueType( position );
    663            ParameterValueType lineWidth = createParameterValueType( 2 );
    664            ParameterValueType gap = createParameterValueType( 10 );
    665
    666            return new LinePlacement( perpendicularOffset, lineWidth, gap );
    667        }
    668
    669        /**
    670         * creates a <tt>LinePlacement</tt> with a user defined distance between the labels and the lines. A positive
    671         * value indicates a position above the line, a negative value indicates a position below.
    672         *
    673         * @param offset -
    674         *            the distance between the line and the label
    675         * @param lineWidth -
    676         *            assumed lineWidth
    677         * @param gap -
    678         *            gap between the labels measured in label width
    679         *
    680         * @return the LinePlacement created
    681         */
    682        public static LinePlacement createLinePlacement( double offset, double lineWidth, int gap ) {
    683
    684            ParameterValueType perpendicularOffset = createParameterValueType( offset );
    685            ParameterValueType lineWidth_ = createParameterValueType( lineWidth );
    686            ParameterValueType gap_ = createParameterValueType( gap );
    687
    688            return new LinePlacement( perpendicularOffset, lineWidth_, gap_ );
    689        }
    690
    691        /**
    692         * creates a <tt>LinePlacement</tt> with a user defined distance between the labels and the lines. A positive
    693         * value indicates a position above the line, a negative value indicates a position below.
    694         *
    695         * @param position -
    696         *            relative position of the label to the line
    697         * @param lineWidth -
    698         *            assumed lineWidth
    699         * @param gap -
    700         *            gap between the labels measured in label width
    701         *
    702         * @return the LinePlacement created
    703         */
    704        public static LinePlacement createLinePlacement( String position, double lineWidth, int gap ) {
    705
    706            ParameterValueType perpendicularOffset = createParameterValueType( position );
    707            ParameterValueType lineWidth_ = createParameterValueType( lineWidth );
    708            ParameterValueType gap_ = createParameterValueType( gap );
    709
    710            return new LinePlacement( perpendicularOffset, lineWidth_, gap_ );
    711        }
    712
    713        /**
    714         * creates a label placement that is orientated on a line
    715         *
    716         * @param linePlacement
    717         *            description of the line where the lable will be orientated on
    718         * @return created LabelPlacement
    719         */
    720        public static LabelPlacement createLabelPlacement( LinePlacement linePlacement ) {
    721            return new LabelPlacement( linePlacement );
    722        }
    723
    724        /**
    725         * creates a label placement that is orientated on a point
    726         *
    727         * @param pointPlacement
    728         *            description of the point where the lable will be orientated on
    729         * @return created LabelPlacement
    730         */
    731        public static LabelPlacement createLabelPlacement( PointPlacement pointPlacement ) {
    732            return new LabelPlacement( pointPlacement );
    733        }
    734
    735        /**
    736         * create a geotools font object from a java font
    737         *
    738         * @param font -
    739         *            the font to be converted
    740         *
    741         * @return - the deegree sld font
    742         */
    743        public static Font createFont( java.awt.Font font ) {
    744            return createFont( font.getFamily(), font.isItalic(), font.isBold(), font.getSize() );
    745        }
    746
    747        /**
    748         * create font of supplied family and size
    749         *
    750         * @param fontFamily -
    751         *            the font family
    752         * @param fontSize -
    753         *            the size of the font in points
    754         *
    755         * @return the font object created
    756         */
    757        public static Font createFont( String fontFamily, double fontSize ) {
    758            return createFont( fontFamily, false, false, fontSize );
    759        }
    760
    761        /**
    762         * create font of supplied family, size and weight/style
    763         *
    764         * @param fontFamily -
    765         *            the font family
    766         * @param italic -
    767         *            should the font be italic?
    768         * @param bold -
    769         *            should the font be bold?
    770         * @param fontSize -
    771         *            the size of the font in points
    772         *
    773         * @return the new font object
    774         */
    775        public static Font createFont( String fontFamily, boolean italic, boolean bold, double fontSize ) {
    776            HashMap<String, CssParameter> cssParams = new HashMap<String, CssParameter>();
    777
    778            cssParams.put( "font-family", createCssParameter( "font-family", fontFamily ) );
    779            cssParams.put( "font-size", createCssParameter( "font-size", "" + fontSize ) );
    780            if ( bold ) {
    781                cssParams.put( "font-weight", createCssParameter( "font-weight", "bold" ) );
    782            } else {
    783                cssParams.put( "font-weight", createCssParameter( "font-weight", "normal" ) );
    784            }
    785            if ( italic ) {
    786                cssParams.put( "font-style", createCssParameter( "font-style", "italic" ) );
    787            } else {
    788                cssParams.put( "font-style", createCssParameter( "font-style", "normal" ) );
    789            }
    790
    791            return new Font( cssParams );
    792        }
    793
    794        /**
    795         * wrapper round StyleFactory method to create default halo
    796         *
    797         * @return the new halo
    798         */
    799        public static Halo createHalo() {
    800            return createHalo( createFill(), createStroke(), -1 );
    801        }
    802
    803        /**
    804         * wrapper round StyleFactory method to create halo
    805         *
    806         * @param color -
    807         *            the color of the halo
    808         * @param radius -
    809         *            the radius of the halo use a value <= 0 for rectangle
    810         *
    811         * @return the new halo
    812         */
    813        public static Halo createHalo( Color color, double radius ) {
    814            return createHalo( createFill( color ), createStroke(), radius );
    815        }
    816
    817        /**
    818         * wrapper round StyleFactory method to create halo
    819         *
    820         * @param fillColor -
    821         *            the fill color of the halo
    822         * @param opacity -
    823         *            the opacity of the halo fill 0 - transparent 1 - solid
    824         * @param strokeColor -
    825         *            the stroke color of the halo
    826         * @param radius -
    827         *            the radius of the halo use a value <= 0 for rectangle
    828         *
    829         * @return the new halo
    830         */
    831        public static Halo createHalo( Color fillColor, double opacity, Color strokeColor, double radius ) {
    832            Fill fill = createFill( fillColor, opacity );
    833            Stroke stroke = createStroke( strokeColor );
    834            return createHalo( fill, stroke, radius );
    835        }
    836
    837        /**
    838         * wrapper round StyleFactory method to create halo
    839         *
    840         * @param fill -
    841         *            the fill of the halo
    842         * @param stroke -
    843         *            the stroke of the halo
    844         * @param radius -
    845         *            the radius of the halo use a value <= 0 for rectangle
    846         *
    847         * @return the new halo
    848         */
    849        public static Halo createHalo( Fill fill, Stroke stroke, double radius ) {
    850            ParameterValueType pvt = null;
    851            if ( radius > 0 ) {
    852                pvt = createParameterValueType( radius );
    853            }
    854            return new Halo( pvt, fill, stroke );
    855        }
    856
    857        /**
    858         * create a default line symboliser
    859         *
    860         * @return the new line symbolizer
    861         */
    862        public static LineSymbolizer createLineSymbolizer() {
    863            return createLineSymbolizer( createStroke( 1 ), null );
    864        }
    865
    866        /**
    867         * create a new line symbolizer
    868         *
    869         * @param width
    870         *            the width of the line
    871         *
    872         * @return the new line symbolizer
    873         */
    874        public static LineSymbolizer createLineSymbolizer( double width ) {
    875            return createLineSymbolizer( createStroke( width ), null );
    876        }
    877
    878        /**
    879         * create a LineSymbolizer
    880         *
    881         * @param color -
    882         *            the color of the line
    883         *
    884         * @return the new line symbolizer
    885         */
    886        public static LineSymbolizer createLineSymbolizer( Color color ) {
    887            return createLineSymbolizer( createStroke( color ), null );
    888        }
    889
    890        /**
    891         * create a LineSymbolizer
    892         *
    893         * @param color -
    894         *            the color of the line
    895         * @param width -
    896         *            the width of the line
    897         *
    898         * @return the new line symbolizer
    899         */
    900        public static LineSymbolizer createLineSymbolizer( Color color, double width ) {
    901            return createLineSymbolizer( createStroke( color, width ), null );
    902        }
    903
    904        /**
    905         * create a LineSymbolizer
    906         *
    907         * @param color -
    908         *            the color of the line
    909         * @param width -
    910         *            the width of the line
    911         * @param geometryPropertyName -
    912         *            the name of the geometry to be drawn
    913         *
    914         * @return the new line symbolizer
    915         */
    916        public static LineSymbolizer createLineSymbolizer( Color color, double width, PropertyPath geometryPropertyName ) {
    917            return createLineSymbolizer( createStroke( color, width ), geometryPropertyName );
    918        }
    919
    920        /**
    921         * create a LineSymbolizer
    922         *
    923         * @param stroke -
    924         *            the stroke to be used to draw the line
    925         *
    926         * @return the new line symbolizer
    927         */
    928        public static LineSymbolizer createLineSymbolizer( Stroke stroke ) {
    929            return createLineSymbolizer( stroke, null );
    930        }
    931
    932        /**
    933         * create a LineSymbolizer
    934         *
    935         * @param stroke -
    936         *            the stroke to be used to draw the line
    937         * @param geometryPropertyName -
    938         *            the name of the geometry to be drawn
    939         *
    940         * @return the new line symbolizer
    941         */
    942        public static LineSymbolizer createLineSymbolizer( Stroke stroke, PropertyPath geometryPropertyName ) {
    943            return createLineSymbolizer( stroke, geometryPropertyName, 0, Double.MAX_VALUE );
    944        }
    945
    946        /**
    947         * create a LineSymbolizer
    948         *
    949         * @param stroke -
    950         *            the stroke to be used to draw the line
    951         * @param geometryPropertyName -
    952         *            the name of the geometry to be drawn
    953         * @param min
    954         *            min scale denominator
    955         * @param max
    956         *            max scale denominator
    957         *
    958         * @return the new line symbolizer
    959         */
    960        public static LineSymbolizer createLineSymbolizer( Stroke stroke, PropertyPath geometryPropertyName, double min,
    961                                                           double max ) {
    962            Geometry geom = null;
    963            if ( geometryPropertyName != null ) {
    964                geom = new Geometry( geometryPropertyName, null );
    965            }
    966            return new LineSymbolizer( stroke, geom, min, max );
    967        }
    968
    969        /**
    970         * create a default polygon symbolizer
    971         *
    972         * @return the new polygon symbolizer
    973         */
    974        public static PolygonSymbolizer createPolygonSymbolizer() {
    975            return createPolygonSymbolizer( createStroke(), createFill() );
    976        }
    977
    978        /**
    979         * create a polygon symbolizer
    980         *
    981         * @param fillColor -
    982         *            the color to fill the polygon
    983         *
    984         * @return the new polygon symbolizer
    985         */
    986        public static PolygonSymbolizer createPolygonSymbolizer( Color fillColor ) {
    987            return createPolygonSymbolizer( createStroke(), createFill( fillColor ) );
    988        }
    989
    990        /**
    991         * create a polygon symbolizer
    992         *
    993         * @param fillColor -
    994         *            the color to fill the polygon
    995         * @param borderColor -
    996         *            the outline color of the polygon
    997         * @param borderWidth -
    998         *            the width of the outline
    999         *
    1000         * @return the new polygon symbolizer
    1001         */
    1002        public static PolygonSymbolizer createPolygonSymbolizer( Color fillColor, Color borderColor, double borderWidth ) {
    1003            return createPolygonSymbolizer( createStroke( borderColor, borderWidth ), createFill( fillColor ) );
    1004        }
    1005
    1006        /**
    1007         * create a polygon symbolizer
    1008         *
    1009         * @param borderColor -
    1010         *            the outline color of the polygon
    1011         * @param borderWidth -
    1012         *            the width of the outline
    1013         *
    1014         * @return the new polygon symbolizer
    1015         */
    1016        public static PolygonSymbolizer createPolygonSymbolizer( Color borderColor, double borderWidth ) {
    1017            Stroke stroke = createStroke( borderColor, borderWidth );
    1018            return createPolygonSymbolizer( stroke, createFill() );
    1019        }
    1020
    1021        /**
    1022         * create a polygon symbolizer
    1023         *
    1024         * @param stroke -
    1025         *            the stroke to use to outline the polygon
    1026         * @param fill -
    1027         *            the fill to use to color the polygon
    1028         *
    1029         * @return the new polygon symbolizer
    1030         */
    1031        public static PolygonSymbolizer createPolygonSymbolizer( Stroke stroke, Fill fill ) {
    1032            return createPolygonSymbolizer( stroke, fill, null );
    1033        }
    1034
    1035        /**
    1036         * create a polygon symbolizer
    1037         *
    1038         * @param stroke -
    1039         *            the stroke to use to outline the polygon
    1040         * @param fill -
    1041         *            the fill to use to color the polygon
    1042         * @param geometryPropertyName -
    1043         *            the name of the geometry to be drawn
    1044         *
    1045         * @return the new polygon symbolizer
    1046         */
    1047        public static PolygonSymbolizer createPolygonSymbolizer( Stroke stroke, Fill fill, PropertyPath geometryPropertyName ) {
    1048            return createPolygonSymbolizer( stroke, fill, geometryPropertyName, 0, Double.MAX_VALUE );
    1049        }
    1050
    1051        /**
    1052         * create a polygon symbolizer
    1053         *
    1054         * @param stroke -
    1055         *            the stroke to use to outline the polygon
    1056         * @param fill -
    1057         *            the fill to use to color the polygon
    1058         * @param geometryPropertyName -
    1059         *            the name of the geometry to be drawn
    1060         * @param min
    1061         *            min scale denominator
    1062         * @param max
    1063         *            max scale denominator
    1064         *
    1065         * @return the new polygon symbolizer
    1066         */
    1067        public static PolygonSymbolizer createPolygonSymbolizer( Stroke stroke, Fill fill,
    1068                                                                 PropertyPath geometryPropertyName, double min, double max ) {
    1069            Geometry geom = null;
    1070            if ( geometryPropertyName != null ) {
    1071                geom = new Geometry( geometryPropertyName, null );
    1072            }
    1073            return new PolygonSymbolizer( fill, stroke, geom, min, max );
    1074        }
    1075
    1076        /**
    1077         * create a default point symbolizer
    1078         *
    1079         * @return the new point symbolizer
    1080         */
    1081        public static PointSymbolizer createPointSymbolizer() {
    1082            Graphic graphic = createGraphic( null, null, 1, 5, 0 );
    1083            return createPointSymbolizer( graphic );
    1084        }
    1085
    1086        /**
    1087         * create a point symbolizer
    1088         *
    1089         * @param graphic -
    1090         *            the graphic object to draw at the point
    1091         *
    1092         * @return the new point symbolizer
    1093         */
    1094        public static PointSymbolizer createPointSymbolizer( Graphic graphic ) {
    1095            return createPointSymbolizer( graphic, null );
    1096        }
    1097
    1098        /**
    1099         * create a point symbolizer
    1100         *
    1101         * @param graphic -
    1102         *            the graphic object to draw at the point
    1103         * @param geometryPropertyName -
    1104         *            the name of the geometry to be drawn
    1105         *
    1106         * @return the new point symbolizer
    1107         */
    1108        public static PointSymbolizer createPointSymbolizer( Graphic graphic, PropertyPath geometryPropertyName ) {
    1109            return createPointSymbolizer( graphic, geometryPropertyName, 0, Double.MAX_VALUE );
    1110        }
    1111
    1112        /**
    1113         * create a point symbolizer
    1114         *
    1115         * @param graphic -
    1116         *            the graphic object to draw at the point
    1117         * @param geometryPropertyName -
    1118         *            the name of the geometry to be drawn
    1119         * @param min
    1120         *            min scale denominator
    1121         * @param max
    1122         *            max scale denominator
    1123         *
    1124         * @return the new point symbolizer
    1125         */
    1126        public static PointSymbolizer createPointSymbolizer( Graphic graphic, PropertyPath geometryPropertyName,
    1127                                                             double min, double max ) {
    1128            Geometry geom = null;
    1129            if ( geometryPropertyName != null ) {
    1130                geom = new Geometry( geometryPropertyName, null );
    1131            }
    1132            return new PointSymbolizer( graphic, geom, min, max );
    1133        }
    1134
    1135        /**
    1136         * create a textsymbolizer
    1137         *
    1138         * @param color
    1139         *            the color of the text
    1140         * @param font
    1141         *            the font to use
    1142         * @param attributeName
    1143         *            the attribute to use for the label
    1144         * @param labelPlacement
    1145         *
    1146         * @return the new textsymbolizer
    1147         *
    1148         */
    1149        public static TextSymbolizer createTextSymbolizer( Color color, Font font, String attributeName,
    1150                                                           LabelPlacement labelPlacement ) {
    1151            ParameterValueType label = createParameterValueType( attributeName );
    1152            Fill fill = createFill( color );
    1153            Halo halo = createHalo();
    1154            return createTextSymbolizer( null, label, font, labelPlacement, halo, fill, 0, Double.MAX_VALUE );
    1155        }
    1156
    1157        /**
    1158         * create a textsymbolizer
    1159         *
    1160         * @param geometryPropertyName
    1161         *            geometry assigned to the TextSymbolizer
    1162         * @param attribute
    1163         *            attribute to draw/print
    1164         * @param labelPlacement
    1165         *            defines the placement of the text
    1166         *
    1167         * @return the new textsymbolizer
    1168         *
    1169         */
    1170        public static TextSymbolizer createTextSymbolizer( PropertyPath geometryPropertyName, String attribute,
    1171                                                           LabelPlacement labelPlacement ) {
    1172            Font font = createFont( java.awt.Font.decode( "Sans Serif" ) );
    1173            return createTextSymbolizer( geometryPropertyName, attribute, font, labelPlacement, createHalo(), createFill(),
    1174                                         0, Double.MAX_VALUE );
    1175        }
    1176
    1177        /**
    1178         * create a textsymbolizer
    1179         *
    1180         * @param geometryPropertyName
    1181         *            geometry assigned to the TextSymbolizer
    1182         * @param attribute
    1183         *            attribute to draw/print
    1184         * @param font
    1185         *            font to use for the text
    1186         * @param labelPlacement
    1187         *            defines the placement of the text
    1188         * @param halo
    1189         *            halo/backgroud of the text
    1190         * @param fill
    1191         *            color, opacity of the text
    1192         * @param min
    1193         *            min scale denominator
    1194         * @param max
    1195         *            max scale denominator
    1196         *
    1197         * @return the new textsymbolizer
    1198         *
    1199         */
    1200        public static TextSymbolizer createTextSymbolizer( PropertyPath geometryPropertyName, String attribute, Font font,
    1201                                                           LabelPlacement labelPlacement, Halo halo, Fill fill, double min,
    1202                                                           double max ) {
    1203            Geometry geom = null;
    1204            if ( geometryPropertyName != null ) {
    1205                geom = new Geometry( geometryPropertyName, null );
    1206            }
    1207            ParameterValueType label = createParameterValueType( attribute );
    1208            return createTextSymbolizer( geom, label, font, labelPlacement, halo, fill, min, max );
    1209        }
    1210
    1211        /**
    1212         * create a textsymbolizer
    1213         *
    1214         * @param geometry
    1215         *            geometry assigned to the TextSymbolizer
    1216         * @param label
    1217         *            attribute to draw/print
    1218         * @param font
    1219         *            font to use for the text
    1220         * @param labelPlacement
    1221         *            defines the placement of the text
    1222         * @param halo
    1223         *            halo/backgroud of the text
    1224         * @param fill
    1225         *            color, opacity of the text
    1226         * @param min
    1227         *            min scale denominator
    1228         * @param max
    1229         *            max scale denominator
    1230         *
    1231         * @return the new textsymbolizer
    1232         *
    1233         */
    1234        public static TextSymbolizer createTextSymbolizer( Geometry geometry, ParameterValueType label, Font font,
    1235                                                           LabelPlacement labelPlacement, Halo halo, Fill fill, double min,
    1236                                                           double max ) {
    1237            return new TextSymbolizer( geometry, label, font, labelPlacement, halo, fill, min, max );
    1238        }
    1239
    1240        /**
    1241         * Throws an UnsupportedOperationException, but should create a textsymbolizer which doesn't change
    1242         *
    1243         * @param color
    1244         *            the color of the text
    1245         * @param font
    1246         *            the font to use
    1247         * @param label
    1248         *            the label to use
    1249         *
    1250         * @return the new textsymbolizer
    1251         */
    1252        public static TextSymbolizer createStaticTextSymbolizer( Color color, Font font, String label ) {
    1253            throw new UnsupportedOperationException( "method createStaticTextSymbolizer is not implemented yet" );
    1254        }
    1255
    1256        /**
    1257         * Throws an UnsupportedOperationException, but should create a textsymbolizer which doesn't change
    1258         *
    1259         * @param color
    1260         *            the color of the text
    1261         * @param fonts
    1262         *            an array of fonts to use from the first to last
    1263         * @param label
    1264         *            the label to use
    1265         *
    1266         * @return the new textsymbolizer
    1267         */
    1268        public static TextSymbolizer createStaticTextSymbolizer( Color color, Font[] fonts, String label ) {
    1269            throw new UnsupportedOperationException( "method createStaticTextSymbolizer is not implemented yet" );
    1270        }
    1271
    1272        /**
    1273         * create a simple styling rule
    1274         *
    1275         * @param symbolizer -
    1276         *            the symbolizer to use
    1277         *
    1278         * @return the new rule
    1279         */
    1280        public static Rule createRule( Symbolizer symbolizer ) {
    1281            return createRule( symbolizer, 0, Double.MAX_VALUE );
    1282        }
    1283
    1284        /**
    1285         * reate a simple styling rule
    1286         *
    1287         * @param symbolizers -
    1288         *            an array of symbolizers to use
    1289         *
    1290         * @return the new rule
    1291         */
    1292        public static Rule createRule( Symbolizer[] symbolizers ) {
    1293            return createRule( symbolizers, 0, Double.MAX_VALUE );
    1294        }
    1295
    1296        /**
    1297         * create a simple styling rule, see the SLD Spec for more details of scaleDenominators
    1298         *
    1299         * @param symbolizer -
    1300         *            the symbolizer to use
    1301         * @param minScaleDenominator -
    1302         *            the minimim scale to draw the feature at
    1303         * @param maxScaleDenominator -
    1304         *            the maximum scale to draw the feature at
    1305         *
    1306         * @return the new rule
    1307         */
    1308        public static Rule createRule( Symbolizer symbolizer, double minScaleDenominator, double maxScaleDenominator ) {
    1309            return createRule( new Symbolizer[] { symbolizer }, minScaleDenominator, maxScaleDenominator );
    1310        }
    1311
    1312        /**
    1313         * create a simple styling rule, see the SLD Spec for more details of scaleDenominators
    1314         *
    1315         * @param symbolizers -
    1316         *            an array of symbolizers to use
    1317         * @param minScaleDenominator -
    1318         *            the minimim scale to draw the feature at
    1319         * @param maxScaleDenominator -
    1320         *            the maximum scale to draw the feature at
    1321         *
    1322         * @return the new rule
    1323         */
    1324        public static Rule createRule( Symbolizer[] symbolizers, double minScaleDenominator, double maxScaleDenominator ) {
    1325            return createRule( symbolizers, "default", "default", "default", minScaleDenominator, maxScaleDenominator );
    1326        }
    1327
    1328        /**
    1329         * create a simple styling rule, see the SLD Spec for more details of scaleDenominators
    1330         *
    1331         * @param symbolizers -
    1332         *            an array of symbolizers to use
    1333         * @param name -
    1334         *            name of the rule
    1335         * @param title -
    1336         *            title of the rule
    1337         * @param abstract_ -
    1338         *            text describing throws rule
    1339         * @param minScaleDenominator -
    1340         *            the minimim scale to draw the feature at
    1341         * @param maxScaleDenominator -
    1342         *            the maximum scale to draw the feature at
    1343         *
    1344         * @return the new rule
    1345         */
    1346        public static Rule createRule( Symbolizer[] symbolizers, String name, String title, String abstract_,
    1347                                       double minScaleDenominator, double maxScaleDenominator ) {
    1348            return createRule( symbolizers, name, title, abstract_, null, null, false, minScaleDenominator,
    1349                               maxScaleDenominator );
    1350        }
    1351
    1352        /**
    1353         * create a complex styling rule, see the SLD Spec for more details of scaleDenominators
    1354         *
    1355         * @param symbolizers -
    1356         *            an array of symbolizers to use
    1357         * @param name -
    1358         *            name of the rule
    1359         * @param title -
    1360         *            title of the rule
    1361         * @param abstract_ -
    1362         *            text describing throws rule
    1363         * @param legendGraphic
    1364         * @param filter -
    1365         *            filter to use with the rule
    1366         * @param elseFilter -
    1367         *            true if the passed is an ElseFilter (see SLD spec)
    1368         * @param minScaleDenominator -
    1369         *            the minimim scale to draw the feature at
    1370         * @param maxScaleDenominator -
    1371         *            the maximum scale to draw the feature at
    1372         *
    1373         * @return the new rule
    1374         */
    1375        public static Rule createRule( Symbolizer[] symbolizers, String name, String title, String abstract_,
    1376                                       LegendGraphic legendGraphic, Filter filter, boolean elseFilter,
    1377                                       double minScaleDenominator, double maxScaleDenominator ) {
    1378            return new Rule( symbolizers, name, title, abstract_, legendGraphic, filter, elseFilter, minScaleDenominator,
    1379                             maxScaleDenominator );
    1380        }
    1381
    1382        /**
    1383         * create a Feature type styler
    1384         *
    1385         * @param symbolizer -
    1386         *            the symbolizer to use
    1387         *
    1388         * @return the new feature type styler
    1389         */
    1390        public static FeatureTypeStyle createFeatureTypeStyle( Symbolizer symbolizer ) {
    1391            return createFeatureTypeStyle( null, symbolizer, 0, Double.MAX_VALUE );
    1392        }
    1393
    1394        /**
    1395         * create a Feature type styler see the SLD Spec for more details of scaleDenominators
    1396         *
    1397         * @param symbolizer -
    1398         *            the symbolizer to use
    1399         * @param minScaleDenominator -
    1400         *            the minimim scale to draw the feature at
    1401         * @param maxScaleDenominator -
    1402         *            the maximum scale to draw the feature at
    1403         *
    1404         * @return the new feature type styler
    1405         */
    1406        public static FeatureTypeStyle createFeatureTypeStyle( Symbolizer symbolizer, double minScaleDenominator,
    1407                                                               double maxScaleDenominator ) {
    1408            return createFeatureTypeStyle( null, symbolizer, minScaleDenominator, maxScaleDenominator );
    1409        }
    1410
    1411        /**
    1412         * create a Feature type styler see the SLD Spec for more details of scaleDenominators
    1413         *
    1414         * @param symbolizers -
    1415         *            an array of symbolizers to use
    1416         * @param minScaleDenominator -
    1417         *            the minimim scale to draw the feature at
    1418         * @param maxScaleDenominator -
    1419         *            the maximum scale to draw the feature at
    1420         *
    1421         * @return the new feature type styler
    1422         */
    1423        public static FeatureTypeStyle createFeatureTypeStyle( Symbolizer[] symbolizers, double minScaleDenominator,
    1424                                                               double maxScaleDenominator ) {
    1425            return createFeatureTypeStyle( null, symbolizers, minScaleDenominator, maxScaleDenominator );
    1426        }
    1427
    1428        /**
    1429         * create a Feature type styler
    1430         *
    1431         * @param featureTypeStyleName -
    1432         *            name for the feature type styler
    1433         * @param symbolizer -
    1434         *            the symbolizer to use
    1435         *
    1436         * @return the new feature type styler
    1437         */
    1438        public static FeatureTypeStyle createFeatureTypeStyle( String featureTypeStyleName, Symbolizer symbolizer ) {
    1439            return createFeatureTypeStyle( featureTypeStyleName, symbolizer, 0, Double.MAX_VALUE );
    1440        }
    1441
    1442        /**
    1443         * create a Feature type styler
    1444         *
    1445         * @param featureTypeStyleName -
    1446         *            name for the feature type styler
    1447         * @param symbolizers -
    1448         *            an array of symbolizers to use
    1449         *
    1450         * @return the new feature type styler
    1451         */
    1452        public static FeatureTypeStyle createFeatureTypeStyle( String featureTypeStyleName, Symbolizer[] symbolizers ) {
    1453            return createFeatureTypeStyle( featureTypeStyleName, symbolizers, 0, Double.MAX_VALUE );
    1454        }
    1455
    1456        /**
    1457         * create a Feature type styler see the SLD Spec for more details of scaleDenominators
    1458         *
    1459         * @param featureTypeStyleName -
    1460         *            name for the feature type styler
    1461         * @param symbolizer -
    1462         *            the symbolizer to use
    1463         * @param minScaleDenominator -
    1464         *            the minimim scale to draw the feature at
    1465         * @param maxScaleDenominator -
    1466         *            the maximum scale to draw the feature at
    1467         *
    1468         * @return the new feature type styler
    1469         */
    1470        public static FeatureTypeStyle createFeatureTypeStyle( String featureTypeStyleName, Symbolizer symbolizer,
    1471                                                               double minScaleDenominator, double maxScaleDenominator ) {
    1472            return createFeatureTypeStyle( featureTypeStyleName, new Symbolizer[] { symbolizer }, minScaleDenominator,
    1473                                           maxScaleDenominator );
    1474        }
    1475
    1476        /**
    1477         * create a Feature type styler see the SLD Spec for more details of scaleDenominators
    1478         *
    1479         * @param featureTypeStyleName -
    1480         *            name for the feature type styler
    1481         * @param symbolizers -
    1482         *            an array of symbolizers to use
    1483         * @param minScaleDenominator -
    1484         *            the minimim scale to draw the feature at
    1485         * @param maxScaleDenominator -
    1486         *            the maximum scale to draw the feature at
    1487         *
    1488         * @return the new feature type styler
    1489         */
    1490        public static FeatureTypeStyle createFeatureTypeStyle( String featureTypeStyleName, Symbolizer[] symbolizers,
    1491                                                               double minScaleDenominator, double maxScaleDenominator ) {
    1492            Rule rule = createRule( symbolizers, minScaleDenominator, maxScaleDenominator );
    1493
    1494            return createFeatureTypeStyle( featureTypeStyleName, rule );
    1495        }
    1496
    1497        /**
    1498         * create a Feature type styler
    1499         *
    1500         * @param rule -
    1501         *            rule contained in the featureTypeStyle
    1502         *
    1503         * @return the new feature type styler
    1504         */
    1505        public static FeatureTypeStyle createFeatureTypeStyle( Rule rule ) {
    1506
    1507            return createFeatureTypeStyle( new Rule[] { rule } );
    1508        }
    1509
    1510        /**
    1511         * create a Feature type styler
    1512         *
    1513         * @param rules -
    1514         *            rules contained in the featureTypeStyle
    1515         *
    1516         * @return the new feature type styler
    1517         */
    1518        public static FeatureTypeStyle createFeatureTypeStyle( Rule[] rules ) {
    1519
    1520            return createFeatureTypeStyle( null, rules );
    1521        }
    1522
    1523        /**
    1524         * create a Feature type styler
    1525         *
    1526         * @param featureTypeStyleName -
    1527         *            name for the feature type styler
    1528         * @param rule -
    1529         *            rule contained in the featureTypeStyle
    1530         *
    1531         * @return the new feature type styler
    1532         */
    1533        public static FeatureTypeStyle createFeatureTypeStyle( String featureTypeStyleName, Rule rule ) {
    1534
    1535            return createFeatureTypeStyle( featureTypeStyleName, new Rule[] { rule } );
    1536        }
    1537
    1538        /**
    1539         * create a Feature type styler
    1540         *
    1541         * @param featureTypeStyleName -
    1542         *            name for the feature type styler
    1543         * @param rules -
    1544         *            rules contained in the featureTypeStyle
    1545         *
    1546         * @return the new feature type styler
    1547         */
    1548        public static FeatureTypeStyle createFeatureTypeStyle( String featureTypeStyleName, Rule[] rules ) {
    1549
    1550            return createFeatureTypeStyle( featureTypeStyleName, null, null, null, rules );
    1551        }
    1552
    1553        /**
    1554         * create a Feature type styler
    1555         *
    1556         * @param featureTypeStyleName -
    1557         *            name for the feature type styler
    1558         * @param featureTypeName -
    1559         *            name of the feature type the Feature type style shall be assigned to
    1560         * @param title -
    1561         *            title of the FeatureTypeStyle
    1562         * @param abstract_ -
    1563         *            text describing the FeatureTypeStyle
    1564         * @param rules -
    1565         *            rules contained in the featureTypeStyle
    1566         *
    1567         * @return the new feature type styler
    1568         */
    1569        public static FeatureTypeStyle createFeatureTypeStyle( String featureTypeStyleName, String title, String abstract_,
    1570                                                               String featureTypeName, Rule[] rules ) {
    1571
    1572            return new FeatureTypeStyle( featureTypeStyleName, title, abstract_, featureTypeName, null, rules );
    1573        }
    1574
    1575        /**
    1576         * create a new style
    1577         *
    1578         * @param symbolizer -
    1579         *            the symbolizer to use
    1580         *
    1581         * @return the new style
    1582         */
    1583        public static AbstractStyle createStyle( Symbolizer symbolizer ) {
    1584            return createStyle( null, symbolizer, 0, Double.MAX_VALUE );
    1585        }
    1586
    1587        /**
    1588         * create a new style with name 'default'
    1589         *
    1590         * @param symbolizer -
    1591         *            the symbolizer to use
    1592         * @param minScaleDenominator -
    1593         *            the minimim scale to draw the feature at
    1594         * @param maxScaleDenominator -
    1595         *            the maximum scale to draw the feature at
    1596         *
    1597         * @return the new style
    1598         */
    1599        public static AbstractStyle createStyle( Symbolizer symbolizer, double minScaleDenominator,
    1600                                                 double maxScaleDenominator ) {
    1601            return createStyle( "default", symbolizer, minScaleDenominator, maxScaleDenominator );
    1602        }
    1603
    1604        /**
    1605         * create a new style
    1606         *
    1607         * @param name -
    1608         *            the name of the style
    1609         * @param symbolizer -
    1610         *            the symbolizer to use
    1611         *
    1612         * @return the new style
    1613         */
    1614        public static AbstractStyle createStyle( String name, Symbolizer symbolizer ) {
    1615            return createStyle( name, symbolizer, 0, Double.MAX_VALUE );
    1616        }
    1617
    1618        /**
    1619         * create a new style
    1620         *
    1621         * @param name -
    1622         *            the name of the style
    1623         * @param symbolizer -
    1624         *            the symbolizer to use
    1625         * @param minScaleDenominator -
    1626         *            the minimim scale to draw the feature at
    1627         * @param maxScaleDenominator -
    1628         *            the maximum scale to draw the feature at
    1629         *
    1630         * @return the new style
    1631         */
    1632        public static AbstractStyle createStyle( String name, Symbolizer symbolizer, double minScaleDenominator,
    1633                                                 double maxScaleDenominator ) {
    1634            // create the feature type style
    1635            FeatureTypeStyle fts = createFeatureTypeStyle( name, symbolizer, minScaleDenominator, maxScaleDenominator );
    1636
    1637            return createStyle( name, null, null, fts );
    1638        }
    1639
    1640        /**
    1641         * create a style
    1642         *
    1643         * @param name -
    1644         *            the name of the style
    1645         * @param featureTypeName -
    1646         *            name of the feature type the Feature type style shall be assigned to
    1647         * @param title -
    1648         *            title of the FeatureTypeStyle
    1649         * @param abstract_ -
    1650         *            text describing the FeatureTypeStyle
    1651         * @param rules -
    1652         *            rules contained in the featureTypeStyle
    1653         *
    1654         * @return the new style
    1655         */
    1656        public static AbstractStyle createStyle( String name, String title, String abstract_, String featureTypeName,
    1657                                                 Rule[] rules ) {
    1658
    1659            FeatureTypeStyle fts = createFeatureTypeStyle( name, title, abstract_, featureTypeName, rules );
    1660            return createStyle( name, null, null, fts );
    1661        }
    1662
    1663        /**
    1664         * create a new style
    1665         *
    1666         * @param name -
    1667         *            the name of the style
    1668         * @param title -
    1669         *            title of the style
    1670         * @param abstract_ -
    1671         *            text describing the style
    1672         * @param featureTypeStyle -
    1673         *            featureTypeStyle
    1674         *
    1675         * @return the new style
    1676         */
    1677        public static AbstractStyle createStyle( String name, String title, String abstract_,
    1678                                                 FeatureTypeStyle featureTypeStyle ) {
    1679            return createStyle( name, title, abstract_, new FeatureTypeStyle[] { featureTypeStyle } );
    1680        }
    1681
    1682        /**
    1683         * create a new style
    1684         *
    1685         * @param name -
    1686         *            the name of the style
    1687         * @param title -
    1688         *            title of the style
    1689         * @param abstract_ -
    1690         *            text describing the style
    1691         * @param featureTypeStyles -
    1692         *            featureTypeStyle
    1693         *
    1694         * @return the new style
    1695         */
    1696        public static AbstractStyle createStyle( String name, String title, String abstract_,
    1697                                                 FeatureTypeStyle[] featureTypeStyles ) {
    1698            return new UserStyle( name, title, abstract_, false, featureTypeStyles );
    1699        }
    1700
    1701        /**
    1702         * creates a style with name 'defaultPoint' for rendering point geometries
    1703         *
    1704         * @param wellKnownName
    1705         *            the well known name of the mark
    1706         * @param fillColor
    1707         *            the color of the mark
    1708         * @param borderColor
    1709         *            the outline color of the mark
    1710         * @param borderWidth
    1711         *            the width of the outline
    1712         * @param opacity -
    1713         *            the opacity of the graphic
    1714         * @param size -
    1715         *            the size of the graphic
    1716         * @param rotation -
    1717         *            the rotation from the top of the page of the graphic
    1718         * @param min -
    1719         *            the minimim scale to draw the feature at
    1720         * @param max -
    1721         *            the maximum scale to draw the feature at
    1722         *
    1723         * @return the style created
    1724         */
    1725        public static AbstractStyle createPointStyle( String wellKnownName, Color fillColor, Color borderColor,
    1726                                                      double borderWidth, double opacity, double size, double rotation,
    1727                                                      double min, double max ) {
    1728            Mark mark = createMark( wellKnownName, fillColor, borderColor, borderWidth );
    1729            Graphic graphic = createGraphic( null, mark, opacity, size, rotation );
    1730            Symbolizer symbolizer = createPointSymbolizer( graphic, null, min, max );
    1731            return createStyle( "defaultPoint", symbolizer );
    1732        }
    1733
    1734        /**
    1735         * creates a style with name 'defaultLine' for rendering line geometries
    1736         *
    1737         * @param color
    1738         *            the line color
    1739         * @param width
    1740         *            the width of the line
    1741         * @param opacity -
    1742         *            the opacity of the line
    1743         * @param min -
    1744         *            the minimim scale to draw the feature at
    1745         * @param max -
    1746         *            the maximum scale to draw the feature at
    1747         *
    1748         * @return the style created
    1749         */
    1750        public static AbstractStyle createLineStyle( Color color, double width, double opacity, double min, double max ) {
    1751            Stroke stroke = createStroke( color, width, opacity );
    1752            Symbolizer symbolizer = createLineSymbolizer( stroke, null, min, max );
    1753            return createStyle( "defaultLine", symbolizer );
    1754        }
    1755
    1756        /**
    1757         * creates a style with name 'defaultPolygon' for rendering polygon geometries
    1758         *
    1759         * @param fillColor -
    1760         *            the fill color of the polygon
    1761         * @param fillOpacity -
    1762         *            the fill opacity of the polygon
    1763         * @param strokeColor -
    1764         *            the line color
    1765         * @param strokeWidth -
    1766         *            the width of the line
    1767         * @param strokeOpacity -
    1768         *            the opacity of the line
    1769         * @param min -
    1770         *            the minimim scale to draw the feature at
    1771         * @param max -
    1772         *            the maximum scale to draw the feature at
    1773         *
    1774         * @return the style created
    1775         */
    1776        public static AbstractStyle createPolygonStyle( Color fillColor, double fillOpacity, Color strokeColor,
    1777                                                        double strokeWidth, double strokeOpacity, double min, double max ) {
    1778            Stroke stroke = createStroke( strokeColor, strokeWidth, strokeOpacity );
    1779            Fill fill = createFill( fillColor, fillOpacity );
    1780            Symbolizer symbolizer = createPolygonSymbolizer( stroke, fill, null, min, max );
    1781            return createStyle( "defaultPolygon", symbolizer );
    1782        }
    1783
    1784        /**
    1785         * Throws an UnsupportedOperationException, but should create a style with name 'defaultPoint' for rendering point
    1786         * geometries. The style contains 1..n rules depending on the value range and the number of steps within it. So it
    1787         * is possible to create a style that creates different rendering depending on the value of one feature attribute.
    1788         * <p>
    1789         * there will be a linear interpolation between colors, size and width of the first and the last rule considering
    1790         * the number of passed steps (rules)
    1791         *
    1792         * @param wellKnownNames -
    1793         *            list of well known names of the mark. the first field will be assigned to the starting rule the last
    1794         *            to the ending rule.
    1795         * @param startFillColor -
    1796         *            the color of the mark of the first rule
    1797         * @param endFillColor -
    1798         *            the color of the mark of the last rule
    1799         * @param startBorderColor -
    1800         *            the outline color of the mark of the first rule
    1801         * @param endBorderColor -
    1802         *            the outline color of the mark of the last rule
    1803         * @param startBorderWidth -
    1804         *            the width of the outline of the first rule
    1805         * @param endBorderWidth -
    1806         *            the width of the outline of the last rule
    1807         * @param opacity -
    1808         *            the opacity of the graphic
    1809         * @param startSize -
    1810         *            the size of the graphic of the first rule
    1811         * @param endSize -
    1812         *            the size of the graphic of the last rule
    1813         * @param rotation -
    1814         *            the rotation from the top of the page of the graphic
    1815         * @param min -
    1816         *            the minimim scale to draw the feature at
    1817         * @param max -
    1818         *            the maximum scale to draw the feature at
    1819         * @param featurePropertyName -
    1820         *            name of the feature property that determines the selection of the rule for drawing
    1821         * @param numberOfSteps -
    1822         *            number of steps used for the interpolation between first and last value. It is identical with the
    1823         *            number of rules that will be created.
    1824         *
    1825         * @return the style created
    1826         */
    1827        public static AbstractStyle createPointStyle( String[] wellKnownNames, Color startFillColor, Color endFillColor,
    1828                                                      Color startBorderColor, Color endBorderColor,
    1829                                                      double startBorderWidth, double endBorderWidth, double opacity,
    1830                                                      double startSize, double endSize, double rotation, double min,
    1831                                                      double max, String featurePropertyName, int numberOfSteps ) {
    1832            throw new UnsupportedOperationException( "method createPointStyle is not implemented yet" );
    1833        }
    1834
    1835        /**
    1836         * Throws an UnsupportedOperationException, but should create a style with name 'defaultLine' for rendering line geometries. The style contains 1..n rules depending on
    1837         * the value range and the number of steps within it. So it is possible to create a style that creates different
    1838         * rendering depending on the value of one feature attribute.
    1839         * <p>
    1840         * there will be a linear interpolation between colors, size and width of the first and the last rule considering
    1841         * the number of passed steps (rules)
    1842         *
    1843         * @param startColor -
    1844         *            the color of the first rule
    1845         * @param endColor -
    1846         *            the color of the last rule
    1847         * @param startWidth -
    1848         *            the width of the line of the first rule
    1849         * @param endWidth -
    1850         *            the width of the line of the last rule
    1851         * @param opacity -
    1852         *            the opacity of the graphic
    1853         * @param min -
    1854         *            the minimim scale to draw the feature at
    1855         * @param max -
    1856         *            the maximum scale to draw the feature at
    1857         * @param featurePropertyName -
    1858         *            name of the feature property that determines the selection of the rule for drawing
    1859         * @param numberOfSteps -
    1860         *            number of steps used for the interpolation between first and last value. It is identical with the
    1861         *            number of rules that will be created.
    1862         *
    1863         * @return the style created
    1864         */
    1865        public static AbstractStyle createLineStyle( Color startColor, Color endColor, double startWidth, double endWidth,
    1866                                                     double opacity, double min, double max, String featurePropertyName,
    1867                                                     int numberOfSteps ) {
    1868            throw new UnsupportedOperationException( "method createLineStyle is not implemented yet" );
    1869        }
    1870
    1871        /**
    1872         * Throws an UnsupportedOperationException, but should create a style with name 'defaultPoint' for rendering point geometries. The style contains 1..n rules depending
    1873         * on the value range and the number of steps within it. So it is possible to create a style that creates different
    1874         * rendering depending on the value of one feature attribute.
    1875         * <p>
    1876         * there will be a linear interpolation between colors, size and width of the first and the last rule considering
    1877         * the number of passed steps (rules)
    1878         *
    1879         * @param startFillColor -
    1880         *            the fill color of the first rule
    1881         * @param endFillColor -
    1882         *            the fill color of the last rule
    1883         * @param fillOpacity -
    1884         *            the opacity of the fill
    1885         * @param startStrokeColor -
    1886         *            the line color of the first rule
    1887         * @param endStrokeColor -
    1888         *            the line color of the last rule
    1889         * @param startStrokeWidth -
    1890         *            the width of the outline of the first rule
    1891         * @param endStrokeWidth -
    1892         *            the width of the outline of the last rule
    1893         * @param strokeOpacity -
    1894         *            the opacity of the outline
    1895         * @param min -
    1896         *            the minimim scale to draw the feature at
    1897         * @param max -
    1898         *            the maximum scale to draw the feature at
    1899         * @param featurePropertyName -
    1900         *            name of the feature property that determines the selection of the rule for drawing
    1901         * @param numberOfSteps -
    1902         *            number of steps used for the interpolation between first and last value. It is identical with the
    1903         *            number of rules that will be created.
    1904         *
    1905         * @return the style created
    1906         */
    1907        public static AbstractStyle createPolygonStyle( Color startFillColor, Color endFillColor, double fillOpacity,
    1908                                                        Color startStrokeColor, Color endStrokeColor,
    1909                                                        double startStrokeWidth, double endStrokeWidth,
    1910                                                        double strokeOpacity, double min, double max,
    1911                                                        String featurePropertyName, int numberOfSteps ) {
    1912            throw new UnsupportedOperationException( "method createPolygonStyle is not implemented yet" );
    1913        }
    1914
    1915        /**
    1916         * create a new default style
    1917         *
    1918         * @return the new style
    1919         */
    1920        public static AbstractStyle createStyle() {
    1921            return null;
    1922        }
    1923
    1924    }