#-------------------------------------------------------------------------------
# demo:
# AFP2web Java SDK demo shell script
#
# Author    : Fa. Maas
# Copyright : (C) 2008-2015 by Maas Holding GmbH
#
# $V100   2008-07-10	Initial Release
# $V101   2009-02-10    Extended Merge functionality and AddUserData functionality
# $V102   2009-02-23    Extended Merge functionality with Scripting Facility
# $V103   2009-04-10    Added PNG input support
# $V104   2009-09-09    Added support for Coded and Non-Coded outputs
#                       Extended support for PDF TO TIFF,JPEG conversions
# $V105   2009-09-25    Extended support for PNG output format
# $V106   2010-07-30    Extended to support LPD and MMD Input
# $V107   2010-11-01    Extended to support "any2html" and "afp2xml" Conversions 
# $V108   2010-11-10    Extended to allow supported conversion for MergeMem API
# $V109   2015-06-05    Modified LD_LIBRARY_PATH setting to export current directory
#                       as first element on list of paths for *NIX OS
# $V110   2015-06-23    - Extended with new AFP2webDocHandler and AFP2webDocWriter Java Samples
#                       - Removed AFP2webMem Java sample
#
#-------------------------------------------------------------------------------

#-------------------------------------------------------------------------------
# Function, Used to fetch the class name
#-------------------------------------------------------------------------------
FETCH_CLASS_NAME(){
    echo
    echo $ALLOWED_CLASS_NAMES
    echo -n "Enter the API Functionality ( Refer doc/index.html for more details ) to test : "
    read CLASSNAME

    #-----Assert the CLASS NAME
    if [ "$CLASSNAME" == "" ]
    then
        CLASSNAME="AFP2web"
        # $V106 Begin
        bStream=false
        # $V106 End
    fi          
    
    #-----------Convert the CLASSNAME into uppercase
    CLASSNAME=`echo $CLASSNAME | tr a-z A-Z`

    #-----Evaluate the CLASS NAME and Compile the Java Source
    if [ "$CLASSNAME" == "AFP2WEB" ]
    then
        CLASSNAME="AFP2web"
	    SOURCE_FILES=javasample/AFP2web.java
        # $V106 Begin
        bStream=false
        # $V106 End
        COMPILE_JAVA_SOURCE
    fi
    
    # $V110 Begin
    if [ "$CLASSNAME" == "AFP2WEBDOCWRITER" ]
    then
        CLASSNAME="AFP2webDocWriter"
        SOURCE_FILES="javasample/CustomDocumentWriter.java javasample/AFP2webDocWriter.java"
        # $V106 Begin
        bStream=false
        # $V106 End
        COMPILE_JAVA_SOURCE
    fi

    if [ "$CLASSNAME" == "AFP2WEBDOCHANDLER" ]
    then
        CLASSNAME="AFP2webDocHandler"
        SOURCE_FILES="javasample/CustomDocumentHandler.java javasample/AFP2webDocHandler.java"
        # $V106 Begin
        bStream=false
        # $V106 End
        COMPILE_JAVA_SOURCE
    fi
    # $V110 End

    if [ "$CLASSNAME" == "AFP2WEBBUFFER" ]
    then
        CLASSNAME="AFP2webBuffer"
        SOURCE_FILES="javasample/AFP2webBuffer.java"
        COMPILE_JAVA_SOURCE
    fi
              
    if [ "$CLASSNAME" == "FILESTREAM" ]
    then
        CLASSNAME=AFP2webFileStream
        SOURCE_FILES="javasample/CustomDocumentWriter.java javasample/AFP2webFileStream.java"
        STREAM_REG_TEST_SAMPLE="samples/insuret.afp#samples/insuret.res#samples/insuret.idx#samples/insuret.fde samples/medform.afp#samples/insuret.res"
        STREAM_SPLIT_TEST_SAMPLE="samples/insuret.afp#samples/insuret.res#samples/insuret.idx#samples/insuret.fde"
        # $V106 Begin
        bStream=true
        # $V106 End
	COMPILE_JAVA_SOURCE   
    fi
    
    if [ "$CLASSNAME" == "FILESTREAMMEM" ]
    then
	CLASSNAME=AFP2webFileStream
        SOURCE_FILES="javasample/CustomDocumentWriter.java javasample/AFP2webFileStream.java"
        STREAM_REG_TEST_SAMPLE="samples/insuret.afp#samples/insuret.res#samples/insuret.idx#samples/insuret.fde samples/medform.afp#samples/insuret.res"
        STREAM_SPLIT_TEST_SAMPLE=samples/insuret.afp#samples/insuret.res#samples/insuret.idx#samples/insuret.fde
        ADD_AFP2WEB_OPTIONS=-mos
        # $V106 Begin
        bStream=true
        # $V106 End
        COMPILE_JAVA_SOURCE   
    fi
    
    if [ "$CLASSNAME" == "BYTESTREAM" ]
    then
        CLASSNAME=AFP2webByteStream
        SOURCE_FILES="javasample/CustomDocumentWriter.java javasample/AFP2webByteStream.java"
        STREAM_REG_TEST_SAMPLE="samples/insuret.afp#samples/insuret.res#samples/insuret.idx#samples/insuret.fde samples/medform.afp#samples/insuret.res"
        STREAM_SPLIT_TEST_SAMPLE=samples/insuret.afp#samples/insuret.res#samples/insuret.idx#samples/insuret.fde
        # $V106 Begin
        bStream=true
        # $V106 End
        COMPILE_JAVA_SOURCE   
    fi
    
    if [ "$CLASSNAME" == "BYTESTREAMMEM" ]
    then
        CLASSNAME=AFP2webByteStream
        SOURCE_FILES="javasample/CustomDocumentWriter.java javasample/AFP2webByteStream.java"
        STREAM_REG_TEST_SAMPLE="samples/insuret.afp#samples/insuret.res#samples/insuret.idx#samples/insuret.fde samples/medform.afp#samples/insuret.res"
        STREAM_SPLIT_TEST_SAMPLE=samples/insuret.afp#samples/insuret.res#samples/insuret.idx#samples/insuret.fde
        ADD_AFP2WEB_OPTIONS=-mos
        # $V106 Begin
        bStream=true
        # $V106 End
        COMPILE_JAVA_SOURCE   
    fi
    
    if [ "$CLASSNAME" == "PRINTUNIQUESYSTEMID" ]
    then
        CLASSNAME=PrintUniqueSystemId
        SOURCE_FILES=javasample/PrintUniqueSystemId.java
        COMPILE_JAVA_SOURCE   
    fi

    if [ "$CLASSNAME" == "PRINTSDKVERSION" ]
    then
        CLASSNAME=PrintSDKVersion
        SOURCE_FILES=javasample/PrintSDKVersion.java
        COMPILE_JAVA_SOURCE   
    fi
        
    # $V101 Begin
    if [ "$CLASSNAME" == "MERGE" ]
    then
        CLASSNAME=AFP2webMerge
        SOURCE_FILES="javasample/CustomDocumentReader.java javasample/AFP2webMerge.java"
        ADD_AFP2WEB_OPTIONS=-of:merge.afp
        ALLOWED_INPUTS="AFP [AFP]"
        SAMPLE="samples/medform.afp samples/insure.afp"
        # $V106 Begin
        ALLOWED_CONVERSIONS="DOCMERGE, SCRIPTINGFACILITY"
        # $V106 End
        COMPILE_JAVA_SOURCE
    fi
    
    if [ "$CLASSNAME" == "MERGEMEM" ]
    then
        CLASSNAME=AFP2webMergeMem
        SOURCE_FILES="javasample/CustomDocumentReader.java javasample/AFP2webMergeMem.java"
        # $V108 Begin
        ALLOWED_INPUTS="AFP, TIFF [AFP]"
        # $V108 End
        COMPILE_JAVA_SOURCE
    fi
    
    if [ "$CLASSNAME" == "ADDUSERDATA" ]
    then
        # $V110 Begin
        CLASSNAME=AFP2webDocWriter
        bAddUserData=true
        SOURCE_FILES="javasample/CustomDocumentWriter.java javasample/AFP2webDocWriter.java"
        # $V110 End
        AFP2WEB_OPTIONS="-q -c -doc_cold"
        ADD_AFP2WEB_OPTIONS=-sp:sfsamples/addUserData.pm
        INPUT=AFP
        OUTPUT=PDF
        OUTPUTTEXT=PDF 
        SAMPLE=samples/insure.afp	
        COMPILE_JAVA_SOURCE
    fi
    # $V101 End

    echo "Invalid Class Name"
    echo "Please Select "
    FETCH_CLASS_NAME
    echo.
}

#-------------------------------------------------------------------------------
# Function, Used to Compile the java source.
#-------------------------------------------------------------------------------
COMPILE_JAVA_SOURCE(){
    echo
    echo "First we Compile the java Source"
    JAVA_COMPILE="$JAVAC $JAVA_COMPILE_OPTIONS $JAVA_EXECUTE_OPTIONS $SOURCE_FILES"
    echo $JAVA_COMPILE
    $JAVA_COMPILE
    if [ $? != 0 ]
    then
        NO_JAVAC
    fi
        
    #------Evaluate the CLASSNAME against the AFP2WebBuffer
    if [ "$CLASSNAME" == "AFP2webBuffer" ]
    then
        FETCH_INPUT_FORMAT
    fi
    
    #------Evaluate the CLASSNAME against the PrintUniqueSystemId and PrintSDKVersion
    if [ "$CLASSNAME" == "PrintUniqueSystemId" ]
    then
        #--- Function Invoked to print the Unique System Id
        PRINT_UNIQUE_SYSTEM_ID   
    fi
    
    if [ "$CLASSNAME" == "PrintSDKVersion" ]
    then
        #---Function Invoked to print SDK Version
        PRINT_SDK_VERSION        
    fi
        
    # $V108 Begin    
    #----Evaluate the CLASSNAME against MERGEMEM
    if [ "$CLASSNAME" == "AFP2webMergeMem" ]
    then
        #--- Function invoked to fetch input format
        FETCH_INPUT_FORMAT
    fi
    # $V108 End
    
    # $V101 Begin
    #---- Assert whether Add User Data process flow
    if [ "$bAddUserData" == "true" ]
    then
	#-----Function invoked to convert with user data added through Scripting Facility
        CALL_AFP2WEB
    fi
    # $V101 End

    #-------Fetch the conversion mode
    FETCH_CONVERSION_MODE
}

#-------------------------------------------------------------------------------
# Function, to Fetch the Conversion Mode
#-------------------------------------------------------------------------------
FETCH_CONVERSION_MODE(){
    # $V102 Begin
    if [ "$CLASSNAME" == "AFP2webMerge" ]
    then
        echo
        echo -n "Enter Conversion Mode DOCMERGE, SCRIPTINGFACILITY [DOCMERGE] : "
        read CONVERTMODE
    fi
    if [ "$CLASSNAME" != "AFP2webMerge" ]
    then
        echo
        echo -n "Enter Conversion Mode ALL, DOCINDEX, SCRIPTINGFACILITY [ALL] : "
        read CONVERTMODE
    fi
    # $V102 End

    #-----Assert the Convert Mode
    if [ "$CONVERTMODE" == "" ]
    then
        CONVERTMODE="ALL"
	# $V102 Begin
        if [ "$CLASSNAME" == "AFP2webMerge" ]
	then
	    CONVERTMODE="DOCMERGE"
	fi
	# $V102 End
    fi
 
    #-----------Convert the CONVERTMODE into uppercase
    CONVERTMODE=`echo $CONVERTMODE | tr a-z A-Z`

    if [ "$CONVERTMODE" == "ALL" ]
    then
        ALLOWED_INPUTS="AFP, PDF, TIFF, JPEG, BMP, GIF, PCX, PNG [AFP]"
	SAMPLE="samples/insure.afp"
        STREAM_SPLIT_TEST_SAMPLE=
        if [ "$STREAM_REG_TEST_SAMPLE" != "" ]
        then
            SAMPLE=$STREAM_REG_TEST_SAMPLE
        fi
        AFP2WEB_OPTIONS="-q -c"
    fi

    if [ "$CONVERTMODE" == "DOCINDEX" ]
    then
        ALLOWED_INPUTS="AFP [AFP]"
        STREAM_SPLIT_TEST_SAMPLE=
        SAMPLE="samples/insure.afp"
        if [ "$STREAM_SPLIT_TEST_SAMPLE" != "" ]
        then
            SAMPLE=$STREAM_SPLIT_SAMPLE
        fi
        AFP2WEB_OPTIONS="-q -c -doc_index"
    fi

    if [ "$CONVERTMODE" == "SCRIPTINGFACILITY" ]
    then
        # $V106 Begin
        ALLOWED_INPUTS="AFP, PDF, LPD, MMD [AFP]"
        # $V106 End
        STREAM_REG_TEST_SAMPLE=
        SAMPLE="samples/insure.afp"
        if [ "$CLASSNAME" == "AFP2webMerge" ]
	    then
	        ALLOWED_INPUTS="AFP [AFP]"
	        SAMPLE="samples/medform.afp samples/insure.afp"
	    fi
	    if [ "$STREAM_SPLIT_TEST_SAMPLE" != "" ]
        then
            SAMPLE=$STREAM_SPLIT_TEST_SAMPLE
        fi
        # $V106 Begin
        if [ "$bStream" == "true" ]
        then
            ALLOWED_INPUTS="AFP, PDF, LPD [AFP]"
        fi
        # $V106 End
        AFP2WEB_OPTIONS="-q -c"
    fi
    
    # $V102 Begin
    if [ "$CONVERTMODE" == "DOCMERGE" ]
    then
        ALLOWED_INPUTS="AFP [AFP]"
	SAMPLE="samples/medform.afp samples/insure.afp"
	AFP2WEB_OPTIONS="-q -c -doc_merge"
    fi
    # $V102 End
    
    # $V106 Begin    
    #---- Assert Conversion mode against allowed conversions
    echo $ALLOWED_CONVERSIONS | grep $CONVERTMODE > /dev/null
    if [ $? -eq 1 ] 
    then  
        #----Function invoking to get display the error message
        CONVERSION_NOT_ALLOWED
    fi
    # $V106 End

    #----Fecth the Input format
    FETCH_INPUT_FORMAT
}

# $V106 Begin
#-------------------------------------------------------------------------------
# Function, Used to display the Error message, when the user gives improper Input format
#-------------------------------------------------------------------------------
CONVERSION_NOT_ALLOWED(){
    echo
    echo $CONVERTMODE is not allowed Conversion
    echo Please Select one input format from $ALLOWED_CONVERSIONS
    #------ Function Invoked to get output format
    FETCH_CONVERSION_MODE
    echo
}
# $V106 End

#-------------------------------------------------------------------------------
# Function, Used to Get the Script File Name
#-------------------------------------------------------------------------------
FETCH_SCRIPT_FILENAME(){
    echo
    # $V107 Begin
    echo -n "Enter Script FileName [$ALLOWED_SF_MODULES] : "
    # $V107 End
    read SCRIPTFILENAME
    #-----Assert the SCRIPTFILENAME
    if [ "$SCRIPTFILENAME" == "" ]
    then
        # $V107 Begin
        case $INPUT in
            "LPD")
                SCRIPTFILENAME="sfsamples/eyecatcher_lpd.pm"
                ;;            
            "MMD")
                SCRIPTFILENAME="sfsamples/eyecatcher_mmd.pm"
                ;;
            *)
                SCRIPTFILENAME=$DEF_SCRIPTFILENAME            
                ;;
        esac
        # $V107 End        
    fi
}

#-------------------------------------------------------------------------------
# Function, Used to Fetch input format
#-------------------------------------------------------------------------------
FETCH_INPUT_FORMAT(){
    echo
    echo -n "ENTER INPUT FORMAT :"$ALLOWED_INPUTS" : "
    read INPUT


    #---- Assert input format
    if [ "$INPUT"  == "" ]
    then 
        INPUT="AFP"
    fi

    #---- Convert the input format into uppercase
  
    INPUT=`echo $INPUT | tr a-z A-Z`

    #---- Evaluate sample filename, allowed output formats,    
    #---- default output format based on given input format
    if [ "$INPUT" == "AFP" ]
    then
        INPUT="AFP"
        DEFAULT_OUTPUT="PDF"
        # $V105 Begin
        ALLOWED_OUTPUTS="AFP,PDF,PDFA,TIFF,JPEG,ASCII,PNG [PDF]"
        # $V105 End
	    # $V102 Begin
        if [ "$CLASSNAME" == "AFP2webMerge" ]
	    then
	        DEFAULT_OUTPUT="AFP"
	        ALLOWED_OUTPUTS="AFP, PDF, TIFF [AFP]"
	    fi
        # $V102 End
        # $V108 Begin
        if [ "$CLASSNAME" == "AFP2webMergeMem" ]
        then
            DEFAULT_OUTPUT="PDF"
	        ALLOWED_OUTPUTS="AFP, PDF [PDF]"
            SAMPLE="samples/medform.afp samples/insure.afp"
        fi
	    # $V108 End
    fi 

    if [ "$INPUT" == "PDF" ] 
    then
        SAMPLE="samples/insure.pdf"
        INPUT="PDF"
        DEFAULT_OUTPUT="AFP"
        # $V105 Begin
        ALLOWED_OUTPUTS="AFP,TIFF,JPEG,PNG [AFP]"
        # $V105 End        
    fi
 
    if [ "$INPUT" == "TIFF" ]
    then 
        SAMPLE="samples/medform.tif"
        INPUT="TIFF"
        # $V105 Begin
        ALLOWED_OUTPUTS="AFP,PDF,TIFF,JPEG,PNG [PDF]"
        # $V105 End
        
        # $V108 Begin
        if [ "$CLASSNAME" == "AFP2webMergeMem" ]
        then
            DEFAULT_OUTPUT="PDF"
	        ALLOWED_OUTPUTS="AFP, PDF [PDF]"
            SAMPLE="samples/medform.tif samples/insure.tif"
        fi
	    # $V108 End
    fi

    if [ "$INPUT" == "JPEG" ]
    then
        SAMPLE="samples/medform.jpg"
        INPUT="JPEG"
        # $V105 Begin
        ALLOWED_OUTPUTS="AFP,PDF,TIFF,JPEG,PNG [PDF]"
        # $V105 End
    fi

    if [ "$INPUT" == "BMP" ]
    then
        SAMPLE="samples/bmpsample.bmp"
        INPUT="BMP"
        # $V105 Begin
        ALLOWED_OUTPUTS="AFP,PDF,TIFF,JPEG,PNG [PDF]"
        # $V105 End
    fi

    if [ "$INPUT" == "GIF" ]
    then 
        SAMPLE="samples/gifsample.gif"
        INPUT="GIF"
        # $V105 Begin
        ALLOWED_OUTPUTS="AFP,PDF,TIFF,JPEG,PNG [PDF]"
        # $V105 End
    fi

    if [ "$INPUT" == "PCX" ] 
    then
        SAMPLE="samples/pcxsample.pcx"
        INPUT="PCX"
        # $V105 Begin
        ALLOWED_OUTPUTS="AFP,PDF,TIFF,JPEG,PNG [PDF]"
        # $V105 End
    fi
    
    # $V103 Begin
    if [ "$INPUT" == "PNG" ] 
    then
        SAMPLE="samples/pngsample.png"
        INPUT="PNG"
        # $V105 Begin
        ALLOWED_OUTPUTS="AFP,PDF,TIFF,JPEG,PNG [PDF]"
        # $V105 End
    fi
    # $V103 End
    
    # $V106 Begin
    if [ "$INPUT" == "LPD" ] 
    then
        SAMPLE="samples/lpdsample.lpd"
        INPUT="LPD"        
        ALLOWED_OUTPUTS="PDF,TIFF,JPEG,PNG,ASCII [PDF]"
        AFP2WEB_OPTIONS="$AFP2WEB_OPTIONS "-lpdin" "-sft:ASA_EBCDIC_FIXED_148""
    fi
    
    if [ "$INPUT" == "MMD" ] 
    then
        SAMPLE="samples/mmdsample.mmd"
        INPUT="MMD"        
        ALLOWED_OUTPUTS="PDF,TIFF,JPEG,PNG,ASCII [PDF]"
        AFP2WEB_OPTIONS="$AFP2WEB_OPTIONS "-mmdin" "-sft:ASA_EBCDIC_FIXED_133" "-fd:f1a2w" "-pd:p1a2w""
    fi
    
    #---- Assert Input format against allowed formats
    echo $ALLOWED_INPUTS | grep $INPUT > /dev/null
    if [ $? -eq 1 ] 
    then  
        #----Function invoking to get display the error message
        INPUT_FORMAT_NOT_ALLOWED
    fi
    
    if [ "$CONVERTMODE" == "SCRIPTINGFACILITY" ]
    then
        # $V107 Begin
        case $INPUT in
            "LPD")
                ALLOWED_SF_MODULES="sfsamples/afp2xml.pm,sfsamples/any2html.pm,sfsamples/eyecatcher_lpd.pm"
                ;;            
            "MMD")
                ALLOWED_SF_MODULES="sfsamples/afp2xml.pm,sfsamples/any2html.pm,sfsamples/eyecatcher_mmd.pm"
                ;;
            *)
                ALLOWED_SF_MODULES=$DEF_SCRIPTFILENAME            
        esac
        # $V107 End
        
        #---- Fetch the script filename
        FETCH_SCRIPT_FILENAME

        #---- Set the Script filename	    
	    AFP2WEB_OPTIONS="$AFP2WEB_OPTIONS "-doc_cold" "-sp:$SCRIPTFILENAME""        
    fi
    # $V106 End
    
    # $V107 Begin
    if [ "$SCRIPTFILENAME" != "afp2web.pm" ]
    then
        SF_MODULE=`echo ${SCRIPTFILENAME:10}`
    else
        SF_MODULE=$SCRIPTFILENAME
    fi
    
    if [ "$SF_MODULE" == "any2html.pm" ]
    then
        DEFAULT_OUTPUT="PNG"
        ALLOWED_OUTPUTS="PNG [PNG]"
    else
        if [ "$INPUT" == "PDF" ]
        then
            SET_OUTPUT_TYPE
        fi
    fi
    # $V107 End
        
    #------ Fetch the Output Format
    FETCH_OUTPUT_FORMAT
}

# $V106 Begin
#-------------------------------------------------------------------------------
# Function, Used to display the Error message, when the user gives improper Input format
#-------------------------------------------------------------------------------
INPUT_FORMAT_NOT_ALLOWED(){
    echo
    echo $INPUT is not allowed for $CLASSNAME API
    echo Please Select one input format from $ALLOWED_INPUTS
    #------ Function Invoked to get output format
    FETCH_INPUT_FORMAT
    echo
}
# $V106 End

#-------------------------------------------------------------------------------
# Function Definition, used to Fetch output format
#-------------------------------------------------------------------------------
FETCH_OUTPUT_FORMAT(){
    echo
    echo -n "ENTER OUTPUT FORMAT :$ALLOWED_OUTPUTS :" 
    read OUTPUT

    #---- Convert the Output format into uppercase
    OUTPUT=`echo $OUTPUT | tr a-z A-Z`

    #---- Assert output format, if not use default (PDF)
    if [ "$OUTPUT" == "" ]
    then
        OUTPUT=$DEFAULT_OUTPUT
        OUTPUTTEXT=$DEFAULT_OUTPUT
    fi

    if [ "$OUTPUT" == "PDFA" ] 
    then
        OUTPUT="PDFA"
        OUTPUTTEXT="PDF/A (Level B)"
        #---- Add "-strict" command line option for PDF/A Output
        AFP2WEB_OPTIONS="$AFP2WEB_OPTIONS -strict"
    fi
    
    if [ "$OUTPUT" == "ASCII" ]
    then  
        OUTPUTTEXT="ASCII"
        OUTPUT="ASCII"

    #---- Special handling for ASCII output
    #     a. Let input sample be insure.afp
    #    SAMPLE=samples/insure.afp
    fi
  
    #---- Make sure OUTPUT & OUTPUTTEXT values are uppercase
    if [ "$OUTPUT" == "PDF" ]
    then
    	OUTPUT="PDF"
 	    OUTPUTTEXT="PDF"
	    # $V102 Begin
        if [ "$CLASSNAME" == "AFP2webMerge" ]
	    then
	        ADD_AFP2WEB_OPTIONS=-of:merge.pdf
	    fi
	    # $V102 Begin
        # $V108 Begin
        if [ "$CLASSNAME" == "AFP2webMergeMem" ]
        then
            OUTPUTTEXT="PDF (merge.pdf)"
            
            #--- Invoke function to call afp2web
            CALL_AFP2WEB
        fi
	    # $V108 End
    fi

    if [ "$OUTPUT" == "TIFF" ]
    then
        OUTPUTTEXT="TIFF"
	OUTPUT="TIFF"
	# $V102 Begin
        if [ "$CLASSNAME" == "AFP2webMerge" ]
	then
	    ADD_AFP2WEB_OPTIONS=-of:merge.tif
	fi
	# $V102 Begin
    fi

    if [ "$OUTPUT" == "AFP" ] 
    then
        OUTPUTTEXT="AFP"
        OUTPUT="AFP"
        # $V108 Begin
        if [ "$CLASSNAME" == "AFP2webMergeMem" ]
        then
            OUTPUTTEXT="AFP (merge.afp)"
            
            #--- Invoke function to call afp2web
            CALL_AFP2WEB
        fi
	    # $V108 End
    fi

    if [ "$OUTPUT" == "JPEG" ]
    then
        OUTPUTTEXT="JPEG"
        OUTPUT="JPEG"
    fi

    if [ "$OUTPUT" == "PNG" ]
    then
        OUTPUTTEXT="PNG"
        OUTPUT="PNG"
    fi
    #---- Assert output format against allowed formats
    echo $ALLOWED_OUTPUTS | grep $OUTPUT > /dev/null
    if [ $? -eq 1 ] 
    then  
    #----Function invoking to get display the error message
      FORMAT_NOT_ALLOWED
    else
    #----Function invoked to fetch the sample filename
       FETCH_SAMPLE_FILENAME
    fi
}

#-------------------------------------------------------------------------------
# Function, Used to display the Error message, when the user gives improper output format
#-------------------------------------------------------------------------------
FORMAT_NOT_ALLOWED(){
    echo
    echo $OUTPUT is not allowed for $INPUT Format
    echo Please Select one output format from $ALLOWED_OUTPUTS
    #------ Function Invoked to get output format
    FETCH_OUTPUT_FORMAT
    echo
}

#-------------------------------------------------------------------------------
# Function to Fetch sample filename
#-------------------------------------------------------------------------------
FETCH_SAMPLE_FILENAME(){
    echo    
    SAMPLETMP=$SAMPLE
    if [ "$INPUT" != "LPD" ] && [ "$INPUT" != "MMD" ]
    then
        echo -n "ENTER SAMPLE FILENAME [ "$SAMPLE" ]:"
        read SAMPLE
    fi
    
    #---Assert the SAMPLE 
    if [ "$SAMPLE" == "" ]
    then
        SAMPLE=$SAMPLETMP
    fi

    if [ "$CLASSNAME" == "AFP2webBuffer" ]
    then
        SAMPLE="samples/medform.afp pdf/medform.pdf"
    fi
    
    #---- Function invoked to execute AFP2web
    CALL_AFP2WEB 
}

#-------------------------------------------------------------------------------
# Function, Used to Build AFP2web Calling string and Call the AFP2web
#-------------------------------------------------------------------------------
CALL_AFP2WEB(){

    #---- Build AFP2web calling string
    AFP2WEB="$JAVA_EXE $JAVA_EXECUTE_OPTIONS $CLASSNAME $AFP2WEB_OPTIONS $ADD_AFP2WEB_OPTIONS "-"$OUTPUT $SAMPLE"

    if [ "$CONVERTMODE" == "DOCINDEX" ]
    then
        echo "Document Index Conversion Sample"
    fi

    if [ "$CONVERTMODE" == "SCRIPTINGFACILITY" ]
    then
        echo "Scripting Facility Conversion Sample"
    fi

    #---- Calling the AFP2web
    echo
    echo 
    echo "Converts $INPUT to $OUTPUT"
    echo "$OUTPUTTEXT Output will be stored in the pdf directory"
    
    # $V101 Begin
    if [ "$bAddUserData" == "true" ]
    then
       echo "User data added through scripting facility are added as .dat files on pdf directory"
    fi   
    # $V101 End

    echo
    echo $AFP2WEB
    $AFP2WEB
    echo AFP2web returned $?
    echo
    END
}

#-------------------------------------------------------------------------------
# Function, Used to Print Unique System ID
#-------------------------------------------------------------------------------
PRINT_UNIQUE_SYSTEM_ID(){
    echo
    echo "Print Unique System Id"
    PRINT="$JAVA_EXE $JAVA_EXECUTE_OPTIONS $CLASSNAME"
    echo $PRINT
    $PRINT
    echo
    echo "Type Enter key to Leave"
    read
    END
}

#-------------------------------------------------------------------------------
# Function, Used to Print SDK Version
#-------------------------------------------------------------------------------
PRINT_SDK_VERSION(){
    echo 
    echo "Prints AFP2web SDK Version"
    echo
    PRINT="$JAVA_EXE $JAVA_EXECUTE_OPTIONS $CLASSNAME"
    echo $PRINT
    $PRINT
    echo 
    echo "Type Enter key to print the AFP2web SDK Version with All Sub Components or Press CTRL+c to stop"
    read
    
    echo
    echo "Prints AFP2web SDK Version with all Sub Components"
    echo
    PRINT="$JAVA_EXE $JAVA_EXECUTE_OPTIONS $CLASSNAME "-all""
    echo $PRINT
    $PRINT
    echo
    echo "Type Enter key to Leave"
    read
    END    
}

# $V104 Begin
#------------------------------------------------------------------------------------
# Function, Used to Fetch Output Type
#------------------------------------------------------------------------------------
SET_OUTPUT_TYPE(){
    echo
    echo -n "NEED CODED OUTPUT? $CODED_OUTPUT_OPTIONS [Yes] :"
    read CODED_OUTPUT

    #---- Convert the Coded Output into uppercase
    CODED_OUTPUT=`echo $CODED_OUTPUT | tr a-z A-Z`
    
    #---- Assert Output Type
    if [ "$CODED_OUTPUT" == "" ]
    then
        CODED_OUTPUT="Yes"
    fi
    
    if [ "$CODED_OUTPUT" == "NO" ]
    then
        AFP2WEB_OPTIONS="$AFP2WEB_OPTIONS -nco"
    fi

    #---- Fetch output format
    FETCH_OUTPUT_FORMAT
}
# $V104 End

#-------------------------------------------------------------------------------
# Function, Used to Display the Error Message for Java Compiler
#-------------------------------------------------------------------------------
NO_JAVAC(){
    echo "Error: Unable to access the java compiler.  Please make sure that Java SDK V1.4.2 or above has been installed."
    echo "If yes, set JAVA_HOME Properly.  Example: JAVA_HOME=/usr/lib/java/bin"
    echo "Type Enter key to Leave....."
    read
    END   
}

#-------------------------------------------------------------------------------
# Function Definition for END
#-------------------------------------------------------------------------------
END(){
 exit
}

clear
echo "*******************************************************************************"
echo "                                AFP2web Demo"              
echo "*******************************************************************************"

#-------------------------------------------------------------------------------
# Declare and Initialize varaibles
#-------------------------------------------------------------------------------
OSNAME=
JAVA_HOME=
JAVAC=
JAVA_EXE=
JAVA_COMPILE=

CONVERTMODE=
# $V107 Begin
DEF_SCRIPTFILENAME=afp2web.pm
# $V107 End

SAMPLE="samples/medform.afp"

INPUT=
# $V106 Begin
ALLOWED_INPUTS="AFP,PDF,TIFF,JPEG,BMP,GIF,PCX,PNG,LPD,MMD [AFP]"
# $V106 End

OUTPUT=
OUTPUTTEXT=
DEFAULT_OUTPUT="PDF"
# $V105 Begin
ALLOWED_OUTPUTS="AFP,PDF,PDFA,TIFF,JPEG,ASCII,PNG [PDF]"
ALLOWED_CONVERSIONS="ALL, DOCINDEX, SCRIPTINGFACILITY"
# $V105 End

# $V104 Begin
CODED_OUTPUT="ON"
CODED_OUTPUT_OPTIONS="Yes, No"
# $V104 End

CLASSNAME=
JAVA_COMPILE_OPTIONS="-d ."
JAVA_EXECUTE_OPTIONS="-classpath .:./a2wjdk43.jar"
SOURCE_FILES=
# $V110 Begin
ALLOWED_CLASS_NAMES="AFP2web, AFP2webDocWriter, AFP2webDocHandler, FileStream, FileStreamMem, ByteStream, ByteStreamMem, PrintUniqueSystemId, PrintSDKVersion, Merge, MergeMem, AddUserData [AFP2web]"
# $V110 End

STREAM_REG_TEST_SAMPLE=
STREAM_SPILIT_TEST_SAMPLE=

AFP2WEB=
AFP2WEB_OPTIONS="-q -c"
ADD_AFP2WEB_OPTIONS=
bAddUserData=false

# $V106 Begin
bStream=false
# $V106 End
# $V107 Begin
ALLOWED_SF_MODULES=$DEF_SCRIPTFILENAME
SF_MODULE=
# $V107 End

#-------------------------------------------------------------------------------
# Set Java HOME and Library Path
#-------------------------------------------------------------------------------
  
OSNAME=`echo $OSTYPE | tr [A-Z] [a-z]`;

case "$OSNAME" in

*aix* | *AIX*)
    #---- Export the Library Path
    export LIBPATH=.:$LIBPATH
    JAVA_HOME="/usr/java14/bin"
    ;;
*)
    #---- Export the Library Path
    # $V109 Begin
    export LD_LIBRARY_PATH=.:$LD_LIBRARY_PATH
    # $V109 End
    JAVA_HOME="/usr/bin"
    ;;
esac

#--- set the Java Compiler and Executable
JAVAC="$JAVA_HOME"/javac""
JAVA_EXE="$JAVA_HOME"/java""

#--------Function Invoked, to fetch the class name
FETCH_CLASS_NAME
