Subversion Repositories mkgmap

/*
 * Copyright (C) 2011.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 3 or
 * version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 */
package uk.me.parabola.imgfmt.app.typ;

import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.CharsetEncoder;
import java.util.ArrayList;
import java.util.List;

import uk.me.parabola.imgfmt.app.ImgFileWriter;

/**
 * Base routines and data used by points, lines and polygons.
 *
 * If fact they are all very similar, so there is very little extra in the
 * subclasses apart from the write routine.
 *
 * @author Steve Ratcliffe
 */
public abstract class TypElement implements Comparable<TypElement> {
        private int type;
        private int subType;

        protected final List<TypLabel> labels = new ArrayList<TypLabel>();

        protected Xpm xpm;

        protected int fontStyle;
        protected Rgb dayFontColour;
        protected Rgb nightFontColour;

        protected int offset;

        public void setType(int type) {
                this.type = type;
        }

        public void setSubType(int subType) {
                this.subType = subType;
        }

        public int getType() {
                return type;
        }

        /**
         * We sort these by type.
         * Only the index needs to be sorted (probably) but we don't create the index separately.
         *
         * @param o The other object to compare against.
         * @return The usual -1, 0, 1 for the other object being less than, equal, greater than than this.
         */
        public int compareTo(TypElement o) {
                int t1 = getTypeForFile();
                int t2 = o.getTypeForFile();
                if (t1 == t2)
                        return 0;
                else if (t1 < t2)
                        return -1;
                else
                        return 1;
        }

        /**
         * Get the type in the format required for writing in the typ file sections.
         */
        public int getTypeForFile() {
                return (type << 5) | (subType & 0x1f);
        }

        public void addLabel(String text) {
                labels.add(new TypLabel(text));
        }

        public void setXpm(Xpm xpm) {
                this.xpm = xpm;
        }

        public void setFontStyle(int font) {
                this.fontStyle = font;
        }

        public void setDayFontColor(String value) {
                dayFontColour = new Rgb(value);
        }

        public void setNightCustomColor(String value) {
                nightFontColour = new Rgb(value);
        }

        public abstract void write(ImgFileWriter writer, CharsetEncoder encoder);

        public int getOffset() {
                return offset;
        }

        /**
         * Does this element have two colour bitmaps, with possible automatic night colours. For lines and polygons.
         *
         * Overridden for points and icons.
         */
        public boolean simpleBitmap() {
                return true;
        }

        /**
         * Make the label block separately as we need its length before we write it out properly.
         *
         * @param encoder For encoding the strings as bytes.
         * @return A byte buffer with position set to the length of the block.
         */
        protected ByteBuffer makeLabelBlock(CharsetEncoder encoder) {
                ByteBuffer out = ByteBuffer.allocate(256 * labels.size());
                for (TypLabel tl : labels) {
                        out.put((byte) tl.getLang());
                        CharBuffer cb = CharBuffer.wrap(tl.getText());
                        try {
                                ByteBuffer buffer = encoder.encode(cb);
                                out.put(buffer);
                        } catch (CharacterCodingException ignore) {
                                String name = encoder.charset().name();
                                //System.out.println("cs " + name);
                                throw new TypLabelException(name);
                        }
                        out.put((byte) 0);
                }

                return out;
        }

        /**
         * Write the label block, this is the same for all element types.
         * @param encoder To properly encode the labels.
         */
        protected void writeLabelBlock(ImgFileWriter writer, CharsetEncoder encoder) {
                ByteBuffer out = makeLabelBlock(encoder);

                int len = out.position();

                // The length is encoded as a variable length integer with the length indicated by a suffix.
                len = (len << 1) + 1;
                int mask = ~0xff;
                while ((len & mask) != 0) {
                        mask <<= 8;
                        len <<= 1;
                }

                // write out the length, I'm assuming that it will be 1 or 2 bytes
                if (len > 0xff)
                        writer.putChar((char) len);
                else
                        writer.put((byte) len);

                // Prepare and write buffer
                out.flip();
                writer.put(out);
        }

        /**
         * Write out extended font information, colour and size.
         *
         * This is the same for each element type.
         */
        protected void writeExtendedFontInfo(ImgFileWriter writer) {
                byte fontExt = (byte) fontStyle;
                if (dayFontColour != null)
                        fontExt |= 0x8;

                if (nightFontColour != null)
                        fontExt |= 0x10;

                writer.put(fontExt);

                if (dayFontColour != null)
                        dayFontColour.write(writer, (byte) 0x10);

                if (nightFontColour != null)
                        nightFontColour.write(writer, (byte) 0x10);
        }

        /**
         * Write out an image. The width and height are written separately, because they are not
         * repeated for the night image.
         *
         * @param xpm Either the day or night XPM.
         */
        protected void writeImage(ImgFileWriter writer, Xpm xpm) {
                ColourInfo colourInfo = xpm.getColourInfo();

                writer.put((byte) colourInfo.getNumberOfSColoursForCM());
                writer.put((byte) colourInfo.getColourMode());

                colourInfo.write(writer);
                xpm.writeImage(writer);
        }
}