Application: gvSIG desktop

import org.gvsig.fmap.dal.store.dbf.utils.DbaseCodepage;

		String charset = storeParameters.getEffectiveEncodingName();	

		if (charset==null) {

			// set a safe encoding in case none has been defined

			charset = "UTF-8";

		}

			myHeader = DbaseFileHeader.createDbaseHeader(featureType, charset);

		// .cpg will be redundant if LDID was already set, but we still

		// want to write it with the hopes of increasing the range of programs

		// that will correctly interpret the charset

		DbaseCodepage cpWriter = new DbaseCodepage(dbfFile);

		cpWriter.write(charset);

import org.gvsig.metadata.MetadataLocator;

import org.gvsig.metadata.MetadataManager;

		updateEncodingDefinition();

		DynObjectValueItem[] values = parametersDefinition.getDynField("Encoding").getAvailableValues();

		MetadataManager metadataManager = MetadataLocator.getMetadataManager();

		DynStruct dynStruct = metadataManager.getDefinition(DBFStoreProvider.METADATA_DEFINITION_NAME);

		DynObjectValueItem[] metadataValues = dynStruct.getDynField("Encoding").getAvailableValues();

		Set<DynObjectValueItem> metadataCharsetSets = new LinkedHashSet<DynObjectValueItem>(160);

		metadataCharsetSets.addAll( Arrays.asList(metadataValues) );

			DynObjectValueItem item = new DynObjectValueItem(value, label);

			charsetSet.add(item);

			metadataCharsetSets.add(item);

		dynStruct.getDynField("Encoding")

			.setAvailableValues(

					(DynObjectValueItem[]) metadataCharsetSets.toArray(

						new DynObjectValueItem[metadataCharsetSets.size()])

			);

import org.gvsig.fmap.dal.DataParameters;

import org.gvsig.fmap.dal.exception.CopyParametersException;

import org.gvsig.fmap.dal.store.dbf.utils.DbaseCodepage;

    // We don't want to persist or show effective encoding in the store parameters dialog

    // But we still need it to properly encode layers when editing!! 

    private String effectiveEncoding = null;

	public String getCPGFileName() {

		return DbaseCodepage.getCpgFileName(getDBFFileName());

	}

	public File getCPGFile() {

		return new File(DbaseCodepage.getCpgFileName(getDBFFileName()));

	}

	/**

	 * The encoding actually used to read/write the dbf

	 * 

	 * @param encoding

	 */

	public String getEffectiveEncodingName() {

		if (effectiveEncoding==null) {

			return getEncodingName();

		}

		return effectiveEncoding.trim();

	}

	/**

	 * The encoding actually used to read/write the dbf

	 * 

	 * @param encoding

	 */

	public Charset getEffectiveEncoding() {

		String name = getEffectiveEncodingName();

		if (name==null) {

			return null;

		}

		return Charset.forName(name);

	}

	/**

	 * The encoding actually used to read/write the dbf

	 * 

	 * @param encoding

	 */

	public void setEffectiveEncoding(String encoding) {

		this.effectiveEncoding = encoding;

    }

	/**

	 * The encoding actually used to read/write the dbf

	 * 

	 * @param encoding

	 */

    public void setEffectiveEncoding(Charset charset) {

    	this.effectiveEncoding = charset.name();

	}

    @Override

    public DataParameters getCopy() {

    	DataParameters copy = super.getCopy();

    	if (copy instanceof DBFStoreParameters) {

    		DBFStoreParameters dbfParams = (DBFStoreParameters) copy;

    		dbfParams.setEffectiveEncoding(this.effectiveEncoding);

    	}

    	return copy;

    }

            return new Integer(this.dbfFile.getCodePageInt());

        // necessary when editing the file

        this.getDBFParameters().setEffectiveEncoding(this.dbfFile.getCharsetName());

        this(afile, chars, false);

    /**

     * @deprecated Use {@link #getCodePageInt()} instead

     */

    @Deprecated

		return (byte) myHeader.getLanguageID();

	}

	public int getCodePageInt() {

	/**

	 * Returns the charset used to read/write this dbf. Maybe different

	 * from the declared in the file if we have forced a different one

	 * 

	 * @return

	 */

	public String getCharsetName() { 

		return chars.name();

		//return myHeader.getCharsetName();

	}

	/**

	 * Returns the charset declared on the dbf file (or the

	 * default one if none is declared)

	 * 

	 * @return

	 */

	public String getOriginalCharsetName() {

		return myHeader.getOriginalCharset();

	}

		return new String(data, chars);

			aux.put(str.getBytes(chars));

		if (myHeader.getLanguageID()==0x00) {

			// read from the .cpg file if ldid is 0x00

			DbaseCodepage cpReader = new DbaseCodepage(file);

			String charsetName = cpReader.read();

			if (charsetName == null) {

				charsetName = "ISO-8859-1"; // for compatibility with old gvSIG files

			}

			charsOriginal = Charset.forName(myHeader.mappingEncoding(charsetName));

		}

		else {

			charsOriginal = Charset.forName(myHeader.mappingEncoding(myHeader.getOriginalCharset()));			

		}

	private int myLanguageID = 0x00;

	/**

	 * Only considered when myLanguageID = 0x00; 

	 */

	private String charset = null;

	private int origLanguageID = 0x00;

	/**

	 * Headers must always be encoded using ASCII/ISO-8859-1, regardless the

	 * encoding of the records

	 */

	private static final Charset headerCharset = Charset.forName("ISO-8859-1");

        // read the language bit (LDID) 

    	origLanguageID  = byteAsUnsigned(in.get());

        if (charsName != null) {

        	// ignore the language bit, use the provided charset name

        	myLanguageID = DbaseCodepage.getLdid(charsName);

        	this.charset = charsName;

		}

        else {

            // use the read the language bit

        	myLanguageID = origLanguageID;

        }

        // FIXME: should field names be always read using ISO8859-1??

            fieldName = new String(buffer, headerCharset);

    /**

     * Returns the value of the unsigned byte as a short

     * Bytes are always signed in Java, so if we are reading a C unsigned byte

     * with value > 128, it will appear as a negative value.

     * 

     * In this case, we need to get the original unsigned value and return it as

     * short or int, as byte will never correctly store the value in Java. 

     * 

     * @return

    private int byteAsUnsigned(byte b) {

    	int i;

    	if (b<0) {

    		i = b & 0xFF;

    	}

    	else {

    		i = b;

    	}

    	return i;

    }

	/**

	 * Gets the Language driver IDs (code page) defined on the file header (or guessed

	 * from the provided charset)

	 * 

	 * Some examples:

	 * 	01h		DOS USA	code page 437

		02h		DOS Multilingual code page 850

		03h		Windows ANSI code page 1252

		04h		Standard Macintosh

		64h		EE MS-DOS code page 852

		65h		Nordic MS-DOS code page 865

		66h		Russian MS-DOS code page 866

		67h		Icelandic MS-DOS

		68h		Kamenicky (Czech) MS-DOS

		69h		Mazovia (Polish) MS-DOS

		6Ah		Greek MS-DOS (437G)

		6Bh		Turkish MS-DOS

		96h		Russian Macintosh

		97h		Eastern European Macintosh

		98h		Greek Macintosh

		C8h		Windows EE	code page 1250

		C9h		Russian Windows

		CAh		Turkish Windows

		CBh		Greek Windows

		See the java equivalences in {@link DbaseCodepage#dbfLdid} & {@link DbaseCodepage#ldidJava} objects.

		See some others here: https://github.com/infused/dbf/blob/master/docs/supported_encodings.csv

	 * @return

	 */

	public int getLanguageID() {

		return createDbaseHeader(featureType, null);

	}

	public static DbaseFileHeader createDbaseHeader(FeatureType featureType, String charsetName)

			throws AttributeFeatureTypeNotSuportedException {

		header.myLanguageID = DbaseCodepage.getLdid(charsetName);

		header.charset = charsetName;

		// write the reserved bytes in the header

		buffer.position(buffer.position() + 17);

		// write the language id

		buffer.put((byte)getLanguageID());

		// write the reserved bytes in the header		

		buffer.position(buffer.position() + 2);

		return getCharsetName(getLanguageID());

	}

	public String getCharsetName(int ldid) {

		if (ldid!=0) {

			// prefer the charset defined by the ldid

			for (int i=0; i<DbaseCodepage.dbfLdid.length; i++) {

				if (DbaseCodepage.dbfLdid[i]==ldid) {

					return DbaseCodepage.ldidJava[i];

				}

			}

		if (charset!=null) {

			// use charset otherwise

			return charset;

		}

		// default

		return "ISO-8859-1";

	public String getOriginalCharset() {

		return getCharsetName(this.origLanguageID);

	}

import java.nio.BufferOverflowException;

import java.util.Arrays;

    private ByteBuffer blank;

    private int blankSize;

    //private Charset charset = Charset.forName("ISO-8859-1");

    private Charset charset;

        this.setCharset(Charset.forName(header.mappingEncoding(header.getCharsetName())));

                encodeField(fad, feature);

    private String fieldString(FeatureAttributeDescriptor attr, Feature feature) throws java.io.UnsupportedEncodingException {

                                        return s;

    private void encodeField(FeatureAttributeDescriptor attr, Feature feature) throws java.io.UnsupportedEncodingException, UnsupportedEncodingException {

        int type = attr.getType();

        int dbfFieldIndex = this.header.getFieldIndex(attr.getName());

        final int fieldLen = header.getFieldLength(dbfFieldIndex);

        String fieldString = "";

        if (DataTypes.BOOLEAN == type) {

            boolean b = feature.getBoolean(attr.getIndex());

            if (b) {

            	safeEncode("T", 1, true); 

            } else {

            	safeEncode("F", 1, true);

            }

        } else

            if (DataTypes.BYTE == type) {

                fieldString = String.valueOf(feature.getByte(attr.getIndex()));

                safeEncode(fieldString, 8, false);

            } else

                if (DataTypes.DATE == type) {

                    Date date = feature.getDate(attr.getIndex());

                    fieldString = formatter.getFieldString(date);

                    safeEncode(fieldString, 8, false);

                } else

                    if (DataTypes.DOUBLE == type) {

                        double d = feature.getDouble(attr.getIndex());

                        fieldString =

                            formatter.getFieldString(fieldLen,

                                header.getFieldDecimalCount(dbfFieldIndex), d);

                        safeEncode(fieldString, fieldLen, false);

                    } else

                        if (DataTypes.FLOAT == type) {

                            float f = feature.getFloat(attr.getIndex());

                            fieldString =

                                formatter.getFieldString(fieldLen,

                                    header.getFieldDecimalCount(dbfFieldIndex),

                                    f);

                            safeEncode(fieldString, fieldLen, false);

                        } else

                            if (DataTypes.INT == type) {

                                int integer = feature.getInt(attr.getIndex());

                                fieldString =

                                    formatter.getFieldString(fieldLen, header

                                        .getFieldDecimalCount(dbfFieldIndex),

                                        integer);

                                safeEncode(fieldString, fieldLen, false);

                            } else

                                if (DataTypes.LONG == type) {

                                    long l = feature.getLong(attr.getIndex());

                                    fieldString =

                                        formatter

                                            .getFieldString(

                                                fieldLen,

                                                header

                                                    .getFieldDecimalCount(dbfFieldIndex),

                                                l);

                                    safeEncode(fieldString, fieldLen, false);

                                } else

                                    if (DataTypes.STRING == type) {

                                        String s =

                                            feature.getString(attr.getIndex());

//                                        System.out.println(fieldLen);

                                        safeEncode(s, fieldLen, true);

                                    }

    }

     * Returns a safely padded (and potentially truncated) string 

     * 

     * This may truncate some record, but it is required to ensure

     * that the field limit is not overflowed when using 

     * variable-length charsets such as UTF-8.

     * @throws UnsupportedEncodingException 

     */

    private void safeEncode(String in, int limit, boolean rightPadding) throws UnsupportedEncodingException {

    	try {

    		byte[] encodedString = in.getBytes(this.charset);

    		if (encodedString.length>limit) {

    			// too long, truncating

    			/*

    			 * The block code bellow is equivalent to this simple code

    			 * fragment:

    		if (rightPadding) {

    			in = in.substring(0, in.length()-1);

    			encodedString = in.getBytes(charset);

    		}

    		else {

    			in.substring(1, in.length());

    			encodedString = in.getBytes(charset);

    		}

    		However, the implemented algorithm has a much better performance

    		for the average and worst cases (when the input string has a lot

    		of multibyte characters), while keeping a good performance

    		for the best case (when all the characters in the input string

    		can be represented as single bytes using the selected charset).

    		The general strategy is to compute the deviation from the

    		required maximum number of bytes (limit) and the actual number

    		of bytes of the encoded String.

    		Then, we use this deviation to estimate the amount of characters

    		to truncate, based on the average factor of bytes per char in the

    		input string.

    		We truncate the string using this approach until the deviation

    		gets stable.

    		Finally, as we should be close enough to the right truncation position,

    		we increment/decrement the truncated string by only 1 character, to

    		ensure we truncate in the exact position. 

    			 */

    			String str = in;

    			int estimatedDiff, deviation;

    			int deviationPrev;

    			double ratio;

    			byte[] encodedChar;

    			int truncatePos = 0;

    			deviation = encodedString.length - limit;

    			deviationPrev = deviation - 1;

    			while(Math.abs(deviation)>Math.abs(deviationPrev) && str.length()>0) {

    				ratio = ((double)encodedString.length) / ((double)str.length());

    				// apply the estimated diff, ensuring it is at least >= 1.0 in absolute value

    				estimatedDiff = Math.max((int)(((double)deviation)/ratio), (int)(Math.signum(deviation)*1));

    				// too long, truncating

    				if (rightPadding) {

    					truncatePos = Math.max(str.length()-estimatedDiff, 0);

    					str = in.substring(0, truncatePos);

    				}

    				else {

    					truncatePos = Math.max(truncatePos + estimatedDiff, 0);

    					str = in.substring(truncatePos);				  

    				}

    				encodedString = str.getBytes(charset);

    				deviationPrev = deviation;

    				deviation = encodedString.length - limit;

    			}

    			// now we are close enough, get the exact position for truncating

    			while (encodedString.length>limit) {

    				// too long, truncating

    				//    				  System.out.println("truncating");

    				if (rightPadding) {

    					str = in.substring(0, str.length()-1);

    				}

    				else {

    					truncatePos = truncatePos + 1;

    					str = in.substring(truncatePos);

    				}

    				encodedString = str.getBytes(charset);

    			}

    			while (encodedString.length<limit && str.length()<in.length()) {

    				// Extend if necessary:

    				// 1 - Get the length in bytes of the next char

    				// 2 - Add the char to the substring if we are still within the limits 

    				//    				  System.out.println("extending");

    				if (rightPadding) {

    					encodedChar = in.substring(str.length(), str.length()+1).getBytes(charset);

    				}

    				else {

    					encodedChar = in.substring(truncatePos-1, truncatePos).getBytes(charset);

    					//    					  System.out.println(encodedChar);

    					//    					  System.out.println(encodedChar.length);

    					//    					  System.out.println(testStrings[i].substring(truncatePos-1, truncatePos));

    				}

    				//    				  System.out.println(testStrings[i].substring(in.length(), in.length()+1));

    				if ((encodedString.length + encodedChar.length)>limit) {

    					// one more char would overflow the limit

    					break;

    				}

    				// too short, extending

    				if (rightPadding) {

    					str = in.substring(0, str.length()+1);

    				}

    				else {

    					truncatePos = truncatePos - 1;

    					str = in.substring(truncatePos);

    				}

    				encodedString = str.getBytes(charset);

    			}

    		}

    		if (rightPadding) {

    			buffer.put(encodedString);

    		}

    		if (encodedString.length<limit) {

    			// too short, padding

    			int i = encodedString.length;

    			while (i<limit) {

    				blank.position(0);

    				buffer.put(blank);

    				i=i+blankSize;

    			}

    			if (i>limit) {

    				// Might happen for instance if charset is UTF16 and the

    				// limit of characters in the field is an odd number

    				throw new UnsupportedEncodingException(new Exception("Impossible to encode this DBF using the selected charset"));

    			}

    		}

    		if (!rightPadding) {

    			buffer.put(encodedString);

    		}

    	}

		catch(BufferOverflowException exc) {

			// Might happen for instance if charset is UTF16 and the

			// limit of characters in the field is an odd number

			throw new UnsupportedEncodingException(exc);

		}

    }

    /**

     * Returns a safely padded (and potentially truncated) string 

     * 

     * This may truncate some record, but it is required to ensure

     * that the field limit is not overflowed when using 

     * variable-length charsets such as UTF-8.

     * 

     * This implementation is not used but it is kept here for reference.

     * It is fully equivalent to the {@link #safeEncode(String, int, boolean)}

     * method and easier to understand, but this implementation is much

     * slower for any multibyte charset (such as UTF-8).

     *  

     * @throws UnsupportedEncodingException 

     */

    private void safeEncodeSlow(String in, int limit, boolean rightPadding) throws UnsupportedEncodingException {

    	try {

    		byte[] encodedString = in.getBytes(this.charset);

    		while (encodedString.length>limit) {

    			// too long, truncating

    			if (rightPadding) {

    				in = in.substring(0, in.length()-1);

    				encodedString = in.getBytes(charset);

    			}

    			else {

    				in.substring(1, in.length());

    				encodedString = in.getBytes(charset);

    			}

    		}

    		if (rightPadding) {

    			buffer.put(encodedString);

    		}

    		if (encodedString.length<limit) {

    			// too short, padding

    			int i = encodedString.length;

    			while (i<limit) {

    				blank.position(0);

    				buffer.put(blank);

    				i=i+blankSize;

    			}

    			if (i>limit) {

    				throw new UnsupportedEncodingException(new Exception("Impossible to encode this DBF using the selected charset"));

    			}

    		}

    		if (!rightPadding) {

    			buffer.put(encodedString);

    		}

    	}

    	catch(BufferOverflowException exc) {

    		// Might happen for instance if charset is UTF16 and the

    		// limit of characters in the field is an odd number

    		throw new UnsupportedEncodingException(exc);

    	}

    }

    /**

    	blank = charset.encode(" ");

    	blankSize = blank.limit();

                        if (shpParams.getCPGFile().exists() && !shpParams.getCPGFile().delete()) {

                            logger.debug("Can't delete cpg file '" + shpParams.getCPGFile() + "'.");

                            throw new IOException("Can't delete cpg '"

                                + FilenameUtils.getBaseName(shpParams.getCPGFileName())

                                + "' file to replace with the new cpg.\nThe new cpg is in temporary file '" + str_base

                                + "'");

                        }

                        FileUtils.moveFile(tmpParams.getCPGFile(), shpParams.getCPGFile());

      <artifactId>org.gvsig.exportto.swing.prov.dbf</artifactId>

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

import org.gvsig.exportto.swing.prov.dbf.ExporttoDBFService;

import org.gvsig.exportto.swing.prov.dbf.panel.ExporttoDBFPanel;

        super(providerServices, featureStore, projection, new ExporttoDBFPanel());

            selectFileOptionPanel, featureStore, projection, ((ExporttoDBFPanel) selectFileOptionPanel).getEncoding());

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

    private String encoding = null;

    	this(fPanel, featureStore, projection, null);

    }

    public ExporttoShapeService(

    		SelectFileOptionPanel fPanel,

    		FeatureStore featureStore,

    		IProjection projection,

    		String encoding) {

        this.encoding = encoding;

        newFeatureStoreParameters.setDynValue("encoding", encoding);