← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/mkgmap/oneiric

« back to all changes in this revision

Viewing changes to src/uk/me/parabola/imgfmt/app/typ/TYPFile.java

  • Committer: Bazaar Package Importer
  • Author(s): Francesco Paolo Lovergine, Andreas Putzo, Francesco Paolo Lovergine
  • Date: 2009-07-16 11:10:16 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20090716111016-yycxqya1f26xmti7
Tags: 0.0.0+svn1067-1
[ Andreas Putzo ]
* New upstream snapshot.
* Added ${misc:Depends} among dependencies to fix a lintian warning.
* Bumped debhelper compatibility level to 7.
* Updated long description.
* Updated Homepage in debian/control, debian/copyright, debian/watch.
* Added numerous files from /doc to debian/docs.
* Mentioned Bernhard Heibler in debian/copyright and updated copyright
  year of software and packaging.
* Bumped policy to 3.8.2, without changes.
* Added DM-Upload-Allowed to debian/control.

[ Francesco Paolo Lovergine ]
* Added me as Uploader to avoid possible inappropriate NMU notices.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/uk/me/parabola/imgfmt/app/typ/TYPFile.java
13
13
 * 
14
14
 * Author: Steve Ratcliffe
15
15
 * Create date: 03-Dec-2006
 
16
 * Change: Thomas Lußnig <gps@suche.org>
16
17
 */
17
18
package uk.me.parabola.imgfmt.app.typ;
18
19
 
19
 
import uk.me.parabola.imgfmt.app.BufferedReadStrategy;
20
 
import uk.me.parabola.imgfmt.app.BufferedWriteStrategy;
 
20
import java.io.BufferedReader;
 
21
import java.io.IOException;
 
22
import java.io.StringReader;
 
23
import java.util.Collections;
 
24
import java.util.HashMap;
 
25
import java.util.LinkedList;
 
26
import java.util.List;
 
27
import java.util.Map;
 
28
 
 
29
import uk.me.parabola.imgfmt.app.BufferedImgFileReader;
 
30
import uk.me.parabola.imgfmt.app.BufferedImgFileWriter;
21
31
import uk.me.parabola.imgfmt.app.ImgFile;
 
32
import uk.me.parabola.imgfmt.app.Writeable;
22
33
import uk.me.parabola.imgfmt.fs.ImgChannel;
23
34
import uk.me.parabola.log.Logger;
24
35
 
25
 
import java.io.IOException;
26
 
 
27
36
/**
28
 
 * The TYP file.  I know next to nothing about this file, so the code will be
29
 
 * very experimental for a while and indeed will be mostly to investigate
30
 
 * the file format.
31
 
 * 
32
 
 * @author Steve Ratcliffe
 
37
 * The TYP file.
 
38
 *
 
39
 * @author Thomas Lußnig
33
40
 */
34
41
public class TYPFile extends ImgFile {
35
42
        private static final Logger log = Logger.getLogger(TYPFile.class);
36
43
 
37
44
        private final TYPHeader header = new TYPHeader();
38
45
 
 
46
        private final List<BitmapImage> images = new LinkedList<BitmapImage>();
 
47
        private final List<PointInfo> pointInfo = new LinkedList<PointInfo>();
 
48
        private final List<DrawOrder> drawOrder = new LinkedList<DrawOrder>();
 
49
 
39
50
        public TYPFile(ImgChannel chan, boolean write) {
40
51
                setHeader(header);
41
52
                if (write) {
42
 
                        setWriter(new BufferedWriteStrategy(chan));
 
53
                        setWriter(new BufferedImgFileWriter(chan));
43
54
                        position(TYPHeader.HEADER_LEN);
44
55
                } else {
45
 
                        setReader(new BufferedReadStrategy(chan));
 
56
                        setReader(new BufferedImgFileReader(chan));
46
57
                        header.readHeader(getReader());
47
58
                }
48
59
        }
49
60
 
50
 
        public void sync() throws IOException {
 
61
        public void setCodePage(char code) {
 
62
                header.setCodePage(code);
 
63
        }
 
64
 
 
65
        public void setFamilyId(char code) {
 
66
                header.setFamilyId(code);
 
67
        }
 
68
 
 
69
        public void setProductId(char code) {
 
70
                header.setProductId(code);
 
71
        }
 
72
 
 
73
        public void write() {
 
74
                // HEADER_LEN => 1. Image
 
75
                Collections.sort(images, BitmapImage.comperator());
 
76
 
 
77
                getWriter().position(TYPHeader.HEADER_LEN);
 
78
 
 
79
                int pos = getWriter().position();
 
80
                header.getPointData().setPosition(pos);
 
81
 
 
82
                for (Writeable w : images)
 
83
                        w.write(getWriter());
 
84
                int len = getWriter().position() - pos;
 
85
                header.getPointData().setSize(len);
 
86
 
 
87
                if (len < 0x100)
 
88
                        header.getPointIndex().setItemSize((char) 3);
 
89
                pos = getWriter().position();
 
90
                for (PointInfo w : pointInfo)
 
91
                        w.write(getWriter(), header.getPointData().getSize());
 
92
                header.getPointIndex().setSize(getWriter().position() - pos);
 
93
 
 
94
                pos = getWriter().position();
 
95
                for (Writeable w : drawOrder)
 
96
                        w.write(getWriter());
 
97
                header.getShapeStacking().setSize(getWriter().position() - pos);
 
98
 
 
99
        }
 
100
 
 
101
        public void writePost() {
51
102
                log.debug("syncing TYP file");
52
 
 
 
103
                position(0);
53
104
                getHeader().writeHeader(getWriter());
54
 
 
55
 
                // Sync our writer.
56
 
                getWriter().sync();
57
 
        }
58
 
}
 
 
b'\\ No newline at end of file'
 
105
        }
 
106
 
 
107
        public static BitmapImage parseXpm(int type, int subtype, int day, String xpm) {
 
108
                try {
 
109
                        BufferedReader br = new BufferedReader(new StringReader(xpm));
 
110
                        String[] header = br.readLine().split(" ");
 
111
 
 
112
                        int w = Integer.parseInt(header[0]);
 
113
                        int h = Integer.parseInt(header[1]);
 
114
                        int c = Integer.parseInt(header[2]);
 
115
                        int cpp = Integer.parseInt(header[3]);
 
116
 
 
117
                        Map<String, Rgb> colors = new HashMap<String, Rgb>();
 
118
                        for (int i = 0; i < c; i++) {
 
119
                                String l = br.readLine();
 
120
                                String[] ci = l.split("\t");
 
121
                                int r = Integer.parseInt(ci[1].substring(3, 5), 16);
 
122
                                int g = Integer.parseInt(ci[1].substring(5, 7), 16);
 
123
                                int b = Integer.parseInt(ci[1].substring(7, 9), 16);
 
124
                                colors.put(ci[0], new Rgb(r, g, b, (byte) i));
 
125
                        }
 
126
                        
 
127
                        StringBuffer sb = new StringBuffer();
 
128
                        for (int i = 0; i < h; i++) sb.append(br.readLine());
 
129
                        return new BitmapImage((byte) type, (byte) subtype, (byte) day, w, colors, cpp,
 
130
                                        sb.toString());
 
131
                } catch (IOException e) {
 
132
                        log.error("failed to parse bitmap", e);
 
133
                        return null;
 
134
                }
 
135
        }
 
136
 
 
137
        public void createDrawOrder(byte typ, byte sub) {
 
138
                drawOrder.add(new DrawOrder((char) (typ | sub << 8), (char) 0, (byte) 0));
 
139
        }
 
140
 
 
141
        public List<BitmapImage> getImages() {
 
142
                return images;
 
143
        }
 
144
 
 
145
        public List<PointInfo> getPointInfo() {
 
146
                return pointInfo;
 
147
        }
 
148
 
 
149
        public List<DrawOrder> getDrawOrder() {
 
150
                return drawOrder;
 
151
        }
 
152
}