aboutsummaryrefslogtreecommitdiffstats
path: root/server/src/com/vaadin/ui/ProgressIndicator.java
blob: 6e436169e3223f9d099abd9f1383526bb6d0e00b (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
/*
 * Copyright 2000-2014 Vaadin Ltd.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */

package com.vaadin.ui;

import com.vaadin.data.Property;
import com.vaadin.shared.communication.PushMode;
import com.vaadin.shared.ui.progressindicator.ProgressIndicatorServerRpc;
import com.vaadin.shared.ui.progressindicator.ProgressIndicatorState;

/**
 * A {@link ProgressBar} which polls the server for updates.
 * <p>
 * Polling in this way is generally not recommended since there is no
 * centralized management of when messages are sent to the server. Furthermore,
 * polling might not be needed at all if {@link UI#setPushMode(PushMode)} or
 * {@link UI#setPollInterval(int)} is used.
 * 
 * @author Vaadin Ltd.
 * @since 4
 * @deprecated as of 7.1, use {@link ProgressBar} combined with
 *             {@link UI#setPushMode(PushMode)} or
 *             {@link UI#setPollInterval(int)} instead.
 */
@Deprecated
@SuppressWarnings("serial")
public class ProgressIndicator extends ProgressBar {

    private ProgressIndicatorServerRpc rpc = new ProgressIndicatorServerRpc() {

        @Override
        public void poll() {
            // Nothing to do.
        }
    };

    /**
     * Creates an a new ProgressIndicator.
     */
    public ProgressIndicator() {
        this(0.0f);
    }

    /**
     * Creates a new instance of ProgressIndicator with given state.
     * 
     * @param value
     */
    public ProgressIndicator(float value) {
        super(value);
        registerRpc(rpc);
    }

    /**
     * Creates a new instance of ProgressIndicator with state read from the
     * given datasource.
     * 
     * @param contentSource
     */
    public ProgressIndicator(Property contentSource) {
        super(contentSource);
        registerRpc(rpc);
    }

    @Override
    protected ProgressIndicatorState getState() {
        return (ProgressIndicatorState) super.getState();
    }

    @Override
    protected ProgressIndicatorState getState(boolean markAsDirty) {
        return (ProgressIndicatorState) super.getState(markAsDirty);
    }

    /**
     * Sets the interval that component checks for progress.
     * 
     * @param pollingInterval
     *            the interval in milliseconds.
     */
    public void setPollingInterval(int pollingInterval) {
        getState().pollingInterval = pollingInterval;
    }

    /**
     * Gets the interval that component checks for progress.
     * 
     * @return the interval in milliseconds.
     */
    public int getPollingInterval() {
        return getState(false).pollingInterval;
    }
}
f='#n589'>589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954
<!--
$Id$
============================================================================
                   The Apache Software License, Version 1.1
============================================================================

Copyright (C) 1999-2003 The Apache Software Foundation. All rights reserved.

Redistribution and use in source and binary forms, with or without modifica-
tion, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice,
   this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.

3. The end-user documentation included with the redistribution, if any, must
   include the following acknowledgment: "This product includes software
   developed by the Apache Software Foundation (http://www.apache.org/)."
   Alternately, this acknowledgment may appear in the software itself, if
   and wherever such third-party acknowledgments normally appear.

4. The names "FOP" and "Apache Software Foundation" must not be used to
   endorse or promote products derived from this software without prior
   written permission. For written permission, please contact
   apache@apache.org.

5. Products derived from this software may not be called "Apache", nor may
   "Apache" appear in their name, without prior written permission of the
   Apache Software Foundation.

THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
APACHE SOFTWARE FOUNDATION OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLU-
DING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
============================================================================

This software consists of voluntary contributions made by many individuals
on behalf of the Apache Software Foundation and was originally created by
James Tauber <jtauber@jtauber.com>. For more information on the Apache
Software Foundation, please see <http://www.apache.org/>.
--> 
<xsl:stylesheet version="1.0"
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                xmlns:lxslt="http://xml.apache.org/xslt"
                xmlns:redirect="org.apache.xalan.xslt.extensions.Redirect"
                extension-element-prefixes="redirect">

<xsl:include href="./propinc.xsl"/>

<xsl:output method="text" />

<xsl:template match="extfile">
<!--<xsl:message>Do <xsl:value-of select="@href"/></xsl:message>-->
   <xsl:apply-templates select="document(@href)/*"/>
</xsl:template>

<!-- Content of element is code to calculate the base length -->
<xsl:template match="percent-ok">
  <xsl:text>
    /** Return object used to calculate base Length
     * for percent specifications.
     */
    public PercentBase getPercentBase(final FObj fo, final PropertyList propertyList) {</xsl:text>
  <xsl:choose>
    <xsl:when test="@base">
      <xsl:text>
        return new LengthBase(fo, propertyList, LengthBase.</xsl:text>
        <xsl:value-of select="@base"/><xsl:text>);
</xsl:text>
     </xsl:when>
     <xsl:otherwise>
       <!-- I have no idea what's happening here.  Is this supposed to be
            an anonymous class returning the actual base length?
            -->
       <xsl:text>
        return new LengthBase(fo, propertyList, LengthBase.CUSTOM_BASE) {
     public int getBaseLength() {
      return (</xsl:text>
         <xsl:value-of select="."/>
         <xsl:text>);
          }
  });</xsl:text>
       </xsl:otherwise>
     </xsl:choose>
     <xsl:text>
    }</xsl:text>
</xsl:template>

<!-- Look for "auto" length keyword -->
<xsl:template match="auto-ok">
  <xsl:text>
    protected boolean isAutoLengthAllowed() {
        return true;
    }</xsl:text>
</xsl:template>

<xsl:template match="enumeration">
  <xsl:text>
    public Property checkEnumValues(String value) {</xsl:text>
    <xsl:for-each select="value">
      <xsl:call-template name="enumvals">
        <xsl:with-param name="specvals" select="concat(.,' ')"/>
      </xsl:call-template>
    </xsl:for-each>
    <xsl:text>
        return super.checkEnumValues(value);
    }</xsl:text>
</xsl:template>


<!-- Look for keyword equivalents. Value is the new expression  -->
<xsl:template match="keyword-equiv[1]">
  <xsl:text>
    // Initialize hashtable of keywords
    static HashMap s_htKeywords;
    static {
        s_htKeywords = new HashMap(</xsl:text>
    <xsl:value-of select="count(../keyword-equiv)"/>
    <xsl:text>);</xsl:text>
  <xsl:for-each select="../keyword-equiv">
    <xsl:text>
        s_htKeywords.put("</xsl:text>
      <xsl:value-of select="@match"/>
      <xsl:text>", "</xsl:text>
      <xsl:value-of select="."/>
      <xsl:text>");</xsl:text>
    </xsl:for-each>
    <xsl:text>
    }

    protected String checkValueKeywords(String keyword) {
        String value = (String)s_htKeywords.get(keyword);
        if (value == null) {
            return super.checkValueKeywords(keyword);
        }
        else return value;
    }</xsl:text>
</xsl:template>

<xsl:template match="keyword-equiv[position()>1]"/>

<!-- Generate code to convert from other datatypes to property datatype -->
<xsl:template match='datatype-conversion[1]'>
  <xsl:variable name="propclass">
    <xsl:choose>
      <xsl:when test="../compound">
        <xsl:call-template name="propclass">
          <xsl:with-param name="prop"
            select="../compound/subproperty[@set-by-shorthand]"/>
        </xsl:call-template>
      </xsl:when><xsl:otherwise>
      <xsl:call-template name="propclass">
        <xsl:with-param name="prop" select=".."/>
      </xsl:call-template>
    </xsl:otherwise>
  </xsl:choose>
</xsl:variable>
<xsl:text>

    // See if other value types are acceptable
    protected Property convertPropertyDatatype(
                  Property p, PropertyList propertyList, FObj fo) {</xsl:text>
  <xsl:for-each select="../datatype-conversion">
    <xsl:variable name="dtc">
      <xsl:choose>
        <xsl:when test="@vartype">
          <xsl:value-of select="@vartype"/>
        </xsl:when><xsl:otherwise>
        <xsl:value-of select="@from-type"/>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:variable>
  <xsl:text>
        </xsl:text>
  <xsl:value-of select="$dtc"/>
  <xsl:text> </xsl:text>
  <xsl:value-of select="@varname"/>
  <xsl:text> = p.get</xsl:text>
  <xsl:value-of select="@from-type"/>
  <xsl:text>();
        if (</xsl:text>
      <xsl:value-of select="@varname"/>
      <xsl:text> != null) {
            return new </xsl:text>
      <xsl:value-of select="$propclass"/><xsl:text>(
                    </xsl:text>
        <xsl:value-of select='normalize-space(.)'/><xsl:text>);
        }</xsl:text>
      </xsl:for-each>
      <xsl:text>
        return super.convertPropertyDatatype(p, propertyList, fo);
    }</xsl:text>
</xsl:template>

<xsl:template match="datatype-conversion[position()>1]"/>

<!-- generate getDefaultForXXX for property components -->
<xsl:template match="default[@subproperty]" priority="2">
  <xsl:variable name="spname">
    <xsl:call-template name="makeClassName">
      <xsl:with-param name="propstr" select="@subproperty"/>
    </xsl:call-template>
  </xsl:variable>
  <xsl:text>
    protected String getDefaultFor</xsl:text>
    <xsl:value-of  select='$spname'/>
    <xsl:text>() {
        return "</xsl:text>
    <xsl:value-of  select='.'/>
    <xsl:text>";
    }</xsl:text>
</xsl:template>

<!-- generate default "make" method for non-compound properties -->
<xsl:template match="default[not(../compound)]" priority="1">
  <xsl:if test='not(@contextdep = "true")'>
    <xsl:text>
    private Property m_defaultProp=null;</xsl:text>
  </xsl:if>
  <xsl:text>
    public Property make(PropertyList propertyList) throws FOPException {</xsl:text>
    <xsl:choose>
      <xsl:when test='@contextdep="true"'>
        <xsl:text>
        return make(propertyList, "</xsl:text>
          <xsl:value-of select='.'/>
          <xsl:text>", propertyList.getParentFObj());</xsl:text>
        </xsl:when>
        <xsl:otherwise>
          <xsl:text>
        if (m_defaultProp == null) {
            m_defaultProp=make(propertyList, "</xsl:text>
            <xsl:value-of select='.'/>
            <xsl:text>", propertyList.getParentFObj());
        }
        return m_defaultProp;</xsl:text>
          </xsl:otherwise>
        </xsl:choose>
        <xsl:text>
    }</xsl:text>
</xsl:template>

<xsl:template match="text()"/>

<!-- Ignore properties which reference others. Only for mapping! -->
<xsl:template match="property[@type='ref']"/>

<!-- Only if more explicit rules not matched (ref) -->
<xsl:template match="property">

  <!-- Only create a specific class for those properties not based on
       template (generic) property definitions or which extends a
       generic definition.
       -->
  <xsl:if test='not(use-generic) or count(*)>2'>
    
    <xsl:variable name="eclassname">
      <xsl:choose>
        <xsl:when test="class-name">
          <xsl:value-of select="class-name"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:call-template name="makeClassName">
            <xsl:with-param name="propstr" select="name"/>
          </xsl:call-template>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:variable>

    <xsl:variable name="classname">
      <xsl:value-of select="$eclassname"/>
      <xsl:if test="not(@type='generic')">
        <xsl:text>Maker</xsl:text>
      </xsl:if>
    </xsl:variable>

    <!-- The class of the Property object to be created -->
    <xsl:variable name="propclass">
      <xsl:call-template name="propclass"/>
    </xsl:variable>

    <!-- The superclass for this PropertyMaker -->
    <xsl:variable name="superclass">
      <xsl:choose>
        <xsl:when test="use-generic[@ispropclass='true']">
          <xsl:value-of select="use-generic"/><xsl:text>.Maker</xsl:text>
        </xsl:when>
        <xsl:when test="use-generic">
          <xsl:value-of select="use-generic"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:value-of select="datatype"/><xsl:text>Property.Maker</xsl:text>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:variable>

    <!-- Is this property an Enum or derived from a generic Enum -->
    <xsl:variable name="enumconst">
      <xsl:if test="enumeration/value and not(@type='generic')">
        <xsl:text> implements </xsl:text><xsl:value-of select="$eclassname"/></xsl:if>
    </xsl:variable>

    <redirect:write select="concat($classname, '.java')">
      <xsl:text>package org.apache.fop.fo.properties;
</xsl:text>
      <xsl:if test=".//keyword-equiv or ./name[.='generic-color']">
        <xsl:text>
import java.util.HashMap;</xsl:text>
      </xsl:if>
      <xsl:if test=
          "((./datatype and
              (not (./datatype[.='String' or .='Enum' or .='List'
                      or .='Length' or .='Character' or .='Number'])
                    or (./datatype[.='Length'] and ./percent-ok)
            ) )
            or .//datatype-conversion)
            and ./name[. !='generic-color']">
        <xsl:text>
import org.apache.fop.datatypes.*;</xsl:text>
      </xsl:if>
      <xsl:text>
import org.apache.fop.fo.*;</xsl:text>
      <xsl:if test="not(
                    (./datatype and ./datatype[. ='List'])
                    or ./class-name[.='GenericCondPadding']
                    or ./name[.='generic-boolean'
                              or .='generic-color'])">
        <xsl:text>
import org.apache.fop.apps.FOPException;</xsl:text>
      </xsl:if>
      <xsl:text>

public class </xsl:text>
      <xsl:value-of select="$classname"/>
      <xsl:text> extends </xsl:text>
      <xsl:value-of select="$superclass"/><xsl:value-of select="$enumconst"/>
      <xsl:text> {</xsl:text>

      <!-- If has enumerated values and is a generic class, create a nested
           interface defining the enumeration constants -->
      <xsl:if test=".//enumeration and @type='generic'">
        <xsl:text>
    public interface Enums {</xsl:text>
        <xsl:for-each select="enumeration/value">
          <xsl:text>
        int </xsl:text>
          <xsl:value-of select="@const"/>
          <xsl:text> =  Constants.</xsl:text>
          <xsl:value-of select="@const"/>
          <xsl:text>;</xsl:text>
        </xsl:for-each>
        <xsl:for-each select="compound/subproperty[enumeration]">
          <xsl:variable name="spname">
            <xsl:call-template name="makeClassName">
              <xsl:with-param name="propstr" select="name"/>
            </xsl:call-template>
          </xsl:variable>
          <xsl:text>
        public interface </xsl:text>
          <xsl:value-of select="$spname"/>
          <xsl:text> {</xsl:text>
          <xsl:for-each select="enumeration/value">
            <xsl:text>
            int </xsl:text>
            <xsl:value-of select="@const"/>
            <xsl:text> = Constants.</xsl:text>
            <xsl:value-of select="@const"/>
            <xsl:text>;</xsl:text>
          </xsl:for-each>
          <xsl:text>
        }</xsl:text>
        </xsl:for-each>
        <xsl:text>
    }</xsl:text>
      </xsl:if>


      <!-- Handle enumeration values -->
      <xsl:for-each select="enumeration/value">
        <xsl:text>
    protected final static EnumProperty s_prop</xsl:text>
        <xsl:value-of select="@const"/>
        <xsl:text> = new EnumProperty(</xsl:text>
        <xsl:if test="../../@type='generic'">
          <xsl:text>Enums.</xsl:text>
        </xsl:if>
        <xsl:value-of select="@const"/>
        <xsl:text>);</xsl:text>
      </xsl:for-each>


      <!-- Look for compound properties -->
      <xsl:if test="compound">
        <xsl:variable name="enumclass">
          <xsl:choose>
            <xsl:when test="@type='generic'">
              <xsl:text>Enums</xsl:text>
            </xsl:when>
            <xsl:otherwise>
              <xsl:value-of select="$eclassname"/>
            </xsl:otherwise>
          </xsl:choose>
        </xsl:variable>
        <xsl:for-each select="compound/subproperty">
          <xsl:variable name="spname">
            <xsl:call-template name="makeClassName">
              <xsl:with-param name="propstr" select="name"/>
            </xsl:call-template>
          </xsl:variable>
          <xsl:variable name="sp_superclass">
            <xsl:choose>
              <xsl:when test="use-generic">
                <xsl:value-of select="use-generic"/>
              </xsl:when>
              <xsl:otherwise>
                <xsl:value-of select="datatype"/>
                <xsl:text>Property.Maker</xsl:text>
              </xsl:otherwise>
            </xsl:choose>
          </xsl:variable>
          
          <xsl:choose>
            <xsl:when test='*[local-name(.)!="name" and local-name(.)!="datatype" and local-name(.)!="use-generic" and local-name(.)!="default"]'>
              <xsl:text>
    static private class SP_</xsl:text>
              <xsl:value-of select="$spname"/>
              <xsl:text>Maker extends </xsl:text>
              <xsl:value-of select="$sp_superclass"/>
              <xsl:if test="enumeration">
                <xsl:text> implements </xsl:text>
                <xsl:value-of select="$enumclass"/>
                <xsl:text>.</xsl:text>
                <xsl:value-of select="$spname"/>
              </xsl:if>
              <xsl:text> {
        SP_</xsl:text>
              <xsl:value-of select="$spname"/>
              <xsl:text>Maker(String sPropName) {
            super(sPropName);
        }</xsl:text>
              <xsl:for-each select="enumeration/value">
                <xsl:text>
        protected final static EnumProperty s_prop</xsl:text>
                <xsl:value-of select="@const"/>
                <xsl:text> = new EnumProperty(</xsl:text>
                <xsl:value-of select="@const"/>
                <xsl:text>);</xsl:text>
              </xsl:for-each>

              <xsl:apply-templates
                select="percent-ok|auto-ok|keyword-equiv|
                        datatype-conversion|enumeration"/>
              <xsl:text>
    }

    final private static Property.Maker s_</xsl:text>
              <xsl:value-of select="$spname"/>
              <xsl:text>Maker =
              new SP_</xsl:text><xsl:value-of select="$spname"/>
              <xsl:text>Maker("</xsl:text>
              <xsl:value-of select='../../name'/>
              <xsl:text>.</xsl:text>
              <xsl:value-of select='name'/>
              <xsl:text>");</xsl:text>
            </xsl:when>
            <xsl:otherwise>
              <xsl:text>
    final private static Property.Maker s_</xsl:text>
              <xsl:value-of select="$spname"/>
              <xsl:text>Maker =
              new </xsl:text><xsl:value-of select="$sp_superclass"/>
              <xsl:text>("</xsl:text>
              <xsl:value-of select='../../name'/>
              <xsl:text>.</xsl:text>
              <xsl:value-of select='name'/>
              <xsl:text>");</xsl:text>
            </xsl:otherwise>
          </xsl:choose>
        </xsl:for-each>
      </xsl:if>

      <xsl:text>

    static public Property.Maker maker(String propName) {
        return new </xsl:text>
      <xsl:value-of select="$classname"/>
      <xsl:text>(propName);
    }

    protected </xsl:text>
      <xsl:value-of select="$classname"/>
      <xsl:text>(String name) {
        super(name);</xsl:text>
      <xsl:if test="compound">
        <xsl:text>
        m_shorthandMaker= getSubpropMaker("</xsl:text>
        <xsl:value-of select=
            'compound/subproperty[@set-by-shorthand="true"]/name'/>
        <xsl:text>");</xsl:text>
      </xsl:if>
      <xsl:text>
    }
</xsl:text>

      <xsl:if test="compound">
        <xsl:text>
    Property.Maker m_shorthandMaker;

    public Property checkEnumValues(String value) {
        return m_shorthandMaker.checkEnumValues(value);
    }

    protected boolean isCompoundMaker() {
        return true;
    }

    protected Property.Maker getSubpropMaker(String subprop) {</xsl:text>
        <xsl:for-each select="compound/subproperty">
          <xsl:variable name="spname">
            <xsl:call-template name="makeClassName">
              <xsl:with-param name="propstr" select="name"/>
            </xsl:call-template>
          </xsl:variable>
          <xsl:text>
        if (subprop.equals("</xsl:text>
          <xsl:value-of select='name'/>
          <xsl:text>"))
            return s_</xsl:text>
          <xsl:value-of select="$spname"/>
          <xsl:text>Maker;</xsl:text>
        </xsl:for-each>
        <xsl:text>
        return super.getSubpropMaker(subprop);
    }

    protected Property setSubprop(Property baseProp, String subpropName,
                                  Property subProp) {
        </xsl:text>
        <xsl:value-of select="datatype"/>
        <xsl:text> val = baseProp.get</xsl:text>
        <xsl:value-of select="datatype"/>
        <xsl:text>();
        // Do some type checking???
        // Check if one of our subproperties???
        val.setComponent(subpropName, subProp, false);
        return baseProp;
    }

    public Property getSubpropValue(Property baseProp, String subpropName) {
        </xsl:text>
        <xsl:value-of select="datatype"/>
        <xsl:text> val = baseProp.get</xsl:text>
        <xsl:value-of select="datatype"/>
        <xsl:text>();
        return val.getComponent(subpropName);
    }
</xsl:text>
      <xsl:choose>
        <!-- some subproperty default is context dependent;
             don't cache default! -->
        <xsl:when test='.//default[@contextdep="true"]'>
          <xsl:text>
    public Property make(PropertyList propertyList) throws FOPException {
        return makeCompound(propertyList, propertyList.getParentFObj());
    }</xsl:text>
        </xsl:when>
        <xsl:otherwise>
          <xsl:text>
    private Property m_defaultProp=null;
    public Property make(PropertyList propertyList) throws FOPException {
        if (m_defaultProp == null) {
            m_defaultProp=makeCompound(
                            propertyList, propertyList.getParentFObj());
        }
        return m_defaultProp;
    }</xsl:text>
        </xsl:otherwise>
      </xsl:choose>
      <xsl:text>

    protected Property makeCompound(PropertyList pList, FObj fo) throws FOPException {</xsl:text>
      <xsl:value-of select="datatype"/>
      <xsl:text> p = new </xsl:text>
      <xsl:value-of select="datatype"/>
      <xsl:text>();
        Property subProp;</xsl:text>
      <xsl:for-each select="compound/subproperty/name">
        <xsl:variable name="spname">
          <xsl:call-template name="makeClassName">
            <xsl:with-param name="propstr" select="."/>
          </xsl:call-template>
        </xsl:variable>
        <xsl:text>
       // set default for subprop </xsl:text>
        <xsl:value-of select="."/>
        <xsl:text>
          subProp = getSubpropMaker("</xsl:text>
        <xsl:value-of select='.'/>
        <xsl:text>").make(pList, getDefaultFor</xsl:text>
        <xsl:value-of select='$spname'/>
        <xsl:text>(), fo);
          p.setComponent("</xsl:text>
        <xsl:value-of select='.'/>
        <xsl:text>", subProp, true);</xsl:text>
      </xsl:for-each>
      <xsl:text>
        return new </xsl:text>
      <xsl:value-of select="$propclass"/>
      <xsl:text>(p);
    }
</xsl:text>
      <!-- generate a "getDefaultForXXX" for each subproperty XXX -->
      <xsl:for-each select="compound/subproperty">
        <xsl:variable name="spname">
          <xsl:call-template name="makeClassName">
            <xsl:with-param name="propstr" select="name"/>
          </xsl:call-template>
        </xsl:variable>
        <xsl:text>
        protected String getDefaultFor</xsl:text>
        <xsl:value-of  select='$spname'/>
        <xsl:text>() {</xsl:text>
        <xsl:choose>
          <xsl:when test="default">
            <xsl:text>
            return "</xsl:text>
            <xsl:value-of  select='default'/>
            <xsl:text>";</xsl:text>
          </xsl:when>
          <xsl:when test=
            "use-generic and key('genericref', use-generic)/default">
            <xsl:text>
            return "</xsl:text>
            <xsl:value-of select='key(&apos;genericref&apos;,
                                  use-generic)/default'/>
            <xsl:text>";</xsl:text>
          </xsl:when>
          <xsl:otherwise>
            <xsl:text>
            return "";</xsl:text>
          </xsl:otherwise>
        </xsl:choose>
        <xsl:text>
    }</xsl:text>
      </xsl:for-each>
      <xsl:text>

    /** Set the appropriate components when the "base" property is set. */
    public Property convertProperty(Property p, PropertyList pList,FObj fo)
            throws FOPException {
        if (p instanceof </xsl:text>
      <xsl:value-of select="$propclass"/>
      <xsl:text>) return p;
        if (! (p instanceof EnumProperty)) {
            // delegate to the subprop maker to do conversions
            p = m_shorthandMaker.convertProperty(p,pList,fo);
        }
        if (p != null) {
            Property prop = makeCompound(pList, fo);
      </xsl:text>
      <xsl:value-of select="datatype"/>
      <xsl:text> pval = prop.get</xsl:text>
      <xsl:value-of select="datatype"/>
      <xsl:text>();</xsl:text>
      <xsl:for-each select="compound/subproperty[@set-by-shorthand='true']">
        <xsl:text>
            pval.setComponent("</xsl:text>
        <xsl:value-of select='name'/>
        <xsl:text>", p, false);</xsl:text>
      </xsl:for-each>
      <xsl:text>
            return prop;
        }
        else return null;</xsl:text>
        <!--
             else {
             // throw some kind of exception!
             throw new FOPException("Can't convert value to <xsl:value-of select='$spdt'/> type");
             }
         -->
      <xsl:text>
    }

</xsl:text>
      </xsl:if> <!-- property/compound -->

      <xsl:if test="inherited">
        <xsl:text>
    public boolean isInherited() {
          return </xsl:text>
        <xsl:value-of select="inherited"/>
        <xsl:text>;
    }
</xsl:text>
      </xsl:if>

      <!-- the default implementation returns false -->
      <xsl:if test='inherited/@type="specified"'>
        <xsl:text>
    public boolean inheritsSpecified() {
        return true;
    }
</xsl:text>
      </xsl:if>


      <!-- Currently only works for Enum values -->
      <xsl:if test="derive">
        <xsl:text>
    public Property compute(PropertyList propertyList) {
        Property computedProperty = null;
        Property correspondingProperty = propertyList.get("</xsl:text>
        <xsl:value-of select="derive/@from"/>
        <xsl:text>");
        if (correspondingProperty != null) {
            int correspondingValue = correspondingProperty.getEnum();</xsl:text>
        <xsl:for-each select="derive/if">
          <xsl:text>
            if (correspondingValue == </xsl:text>
          <xsl:value-of select="@match"/>
          <xsl:text>)
                computedProperty = new EnumProperty(</xsl:text>
          <xsl:value-of select="."/>
          <xsl:text>);
            else</xsl:text>
        </xsl:for-each>
        <xsl:text>
                ;
        }
        return computedProperty;
    }
</xsl:text>
      </xsl:if>

      <!-- If any corresponding element at property or subproperty levels -->
      <xsl:if test=".//corresponding">
        <xsl:if test=".//corresponding/@use-if-specified='true'">
          <xsl:text>
    public boolean isCorrespondingForced(PropertyList propertyList) {
        FObj parentFO = propertyList.getParentFObj();
        StringBuffer sbExpr=new StringBuffer();</xsl:text>
          <xsl:for-each select=".//corresponding/propval">
            <xsl:text>
        sbExpr.setLength(0);</xsl:text>
            <xsl:apply-templates select="."/>
            <xsl:text>
        if (propertyList.getExplicit(sbExpr.toString()) != null)
            return true;</xsl:text>
          </xsl:for-each>
          <xsl:text>
        return false;
    }
</xsl:text>
      </xsl:if>
      <xsl:text>

    public Property compute(PropertyList propertyList) throws FOPException {
        FObj parentFO = propertyList.getParentFObj();
        StringBuffer sbExpr=new StringBuffer();
        Property p=null;</xsl:text>
      <xsl:choose>
        <xsl:when test="corresponding/propexpr">
          <xsl:apply-templates select="corresponding/propval"/>
          <xsl:text>
        // Make sure the property is set before calculating it!
        if (propertyList.getExplicitOrShorthand(sbExpr.toString()) == null)
            return p;
        sbExpr.setLength(0);</xsl:text>
          <xsl:apply-templates select="corresponding/propexpr"/>
          <xsl:text>
        p = make(propertyList, sbExpr.toString(), propertyList.getParentFObj());</xsl:text>
        </xsl:when>
        <xsl:otherwise>
          <xsl:apply-templates select="corresponding/propval"/>
          <xsl:text>
        p= propertyList.getExplicitOrShorthand(sbExpr.toString());</xsl:text>
        </xsl:otherwise>
      </xsl:choose>
      <xsl:text>
        if (p != null) {
            p = convertProperty(p, propertyList, parentFO );
        }</xsl:text>
      <xsl:if test="compound">
        <xsl:text>
        else p = makeCompound(propertyList, parentFO);

        Property subprop;</xsl:text>
        <xsl:for-each select="compound/subproperty/corresponding">
          <xsl:text>
        sbExpr.setLength(0);</xsl:text>
          <xsl:choose>
            <xsl:when test="propexpr">
              <xsl:apply-templates select="propexpr"/>
              <xsl:text>
        subprop = getSubpropMaker("</xsl:text>
              <xsl:value-of select='../name'/>
              <xsl:text>").
                  make(propertyList, sbExpr.toString(), parentFO);</xsl:text>
          </xsl:when>
          <xsl:otherwise>
            <xsl:apply-templates select="propval"/>
            <xsl:text>
        subprop = propertyList.getExplicitOrShorthand(sbExpr.toString());</xsl:text>
          </xsl:otherwise>
        </xsl:choose>
        <xsl:text>
        if (subprop != null) {
            setSubprop(p, "</xsl:text>
        <xsl:value-of select='../name'/>
        <xsl:text>", subprop);
        }</xsl:text>
      </xsl:for-each>
    </xsl:if>
    <xsl:text>
        return p;
    }
</xsl:text>
</xsl:if>

<!-- If can be specified by any shorthand property -->
<xsl:if test="shorthand">
  <xsl:text>
    public Property getShorthand(PropertyList propertyList) {
        Property p = null;
        ListProperty listprop;</xsl:text>
  <xsl:for-each select="shorthand">
    <xsl:variable name="shprop" select="."/>
    <xsl:text>
        if (p == null) {
            listprop =
                (ListProperty)propertyList.getExplicit("</xsl:text>
    <xsl:value-of select='$shprop'/>
    <xsl:text>");
            if (listprop != null) {
               // Get a parser for the shorthand to set the individual properties
               ShorthandParser shparser =
                      new </xsl:text>
    <xsl:value-of select="key('shorthandref', $shprop)/datatype-parser"/>
    <xsl:text>(listprop);
               p = shparser.getValueForProperty(
                                        getPropName(), this, propertyList);
            }
        }</xsl:text>
  </xsl:for-each>
  <xsl:text>
        return p;
    }
</xsl:text>
</xsl:if>

<xsl:apply-templates select=
      "percent-ok|auto-ok|default|keyword-equiv|datatype-conversion|
            enumeration|extfile"/>
<xsl:text>
}
</xsl:text>
</redirect:write>
</xsl:if> <!-- need to create a class -->
</xsl:template>

<xsl:template match="corresponding/propexpr/propval">
  <xsl:text>
        sbExpr.append("_fop-property-value(");</xsl:text> <!-- Note: interpreted by property parser -->
  <xsl:apply-templates/>
  <xsl:text>
        sbExpr.append(")");</xsl:text>
</xsl:template>


<xsl:template match="corresponding//text()">
  <xsl:variable name="tval" select='normalize-space(.)'/>
  <xsl:if test="$tval != ''">
    <xsl:text>
        sbExpr.append("</xsl:text>
    <xsl:value-of select='$tval'/>
    <xsl:text>");</xsl:text>
  </xsl:if>
</xsl:template>

<xsl:template match="propval/wmrel2abs">
  <xsl:text>
        sbExpr.append(propertyList.wmRelToAbs(PropertyList.</xsl:text>
  <xsl:value-of select="@dir"/>
  <xsl:text>));</xsl:text>
</xsl:template>

<xsl:template match="propval/parwmrel2abs">
  <xsl:text>
        sbExpr.append(parentFO.properties.wmRelToAbs(PropertyList.</xsl:text>
  <xsl:value-of select="@dir"/>
  <xsl:text>));</xsl:text>
</xsl:template>

<xsl:template match="propval/wmabs2rel">
  <xsl:text>
        sbExpr.append(propertyList.wmAbsToRel(PropertyList.</xsl:text>
  <xsl:value-of select="@dir"/>
  <xsl:text>));</xsl:text>
</xsl:template>

<!-- avoid unwanted output to placeholder file -->
<xsl:template match="localname"/>

<!-- Check that each member of the nodeset dtlist has the same value.
     Print a message if any member of dtlist is different
     from the first member. Return the first member.
 -->
<xsl:template name="check-subprop-datatype">
  <xsl:param name="dtlist"/>
  <xsl:variable name="dt">
    <xsl:value-of select='$dtlist[1]'/>
  </xsl:variable>
  <xsl:for-each select="$dtlist">
    <xsl:if test=". != $dt">
      <xsl:message>
        <xsl:text>Conflict between subproperty datatypes: </xsl:text>
        <xsl:value-of select='.'/> != <xsl:value-of select='$dt'/>
      </xsl:message>
    </xsl:if>
  </xsl:for-each>
  <xsl:value-of select='$dt'/>
</xsl:template>

<!-- If the value of an enumeration constant contains two or more words,
     separated by a blank, map all of these words to the same constant.
-->
<xsl:template name="enumvals">
  <xsl:param name="specvals"/>
  <xsl:if test='string-length($specvals)>0'>
    <xsl:variable name="oneval" select="substring-before($specvals, ' ')"/>
    <xsl:text>
        if (value.equals("</xsl:text>
    <xsl:value-of select="$oneval"/>
    <xsl:text>")) {
            return s_prop</xsl:text>
    <xsl:value-of select="@const"/>
    <xsl:text>;
        }</xsl:text>
    <xsl:call-template name="enumvals">
      <xsl:with-param name="specvals" select="substring-after($specvals, ' ')"/>
    </xsl:call-template>
  </xsl:if>
</xsl:template>

</xsl:stylesheet>