Merge branch 'origin/master' into Weblate.

Currently translated at 100.0% (342 of 342 strings)

Translation: GPXSee/Translations
Translate-URL: https://hosted.weblate.org/projects/gpxsee/translations/fr/

.appveyor.yml

@@ -1,4 +1,4 @@
-version: 7.9.{build}
+version: 7.10.{build}
 configuration: Release
 platform: Any CPU
 environment:

gpxsee.pro

@@ -3,7 +3,7 @@ unix:!macx {
 } else {
     TARGET = GPXSee
 }
-VERSION = 7.9
+VERSION = 7.10
 
 QT += core \
     gui \
@@ -180,7 +180,8 @@ HEADERS += src/common/config.h \
     src/map/IMG/netfile.h \
     src/GUI/limitedcombobox.h \
     src/GUI/pathtickitem.h \
-    src/map/IMG/textitem.h
+    src/map/IMG/textitem.h \
+    src/map/IMG/label.h
 SOURCES += src/main.cpp \
     src/common/coordinates.cpp \
     src/common/rectc.cpp \

lang/gpxsee_fr.ts

@@ -1055,7 +1055,7 @@
     <message>
         <location filename="../src/GUI/optionsdialog.cpp" line="168"/>
         <source>Palette shift:</source>
-        <translation>Décalage de palette :</translation>
+        <translation>Incrément de palette :</translation>
     </message>
     <message>
         <location filename="../src/GUI/optionsdialog.cpp" line="112"/>

pkg/gpxsee.nsi

@@ -7,7 +7,7 @@
 ; The name of the installer
 Name "GPXSee"
 ; Program version
-!define VERSION "7.9"
+!define VERSION "7.10"
 
 ; The file to write
 OutFile "GPXSee-${VERSION}.exe"

pkg/gpxsee64.nsi

@@ -7,7 +7,7 @@
 ; The name of the installer
 Name "GPXSee"
 ; Program version
-!define VERSION "7.9"
+!define VERSION "7.10"
 
 ; The file to write
 OutFile "GPXSee-${VERSION}_x64.exe"

src/GUI/graphview.cpp

@@ -75,8 +75,7 @@ GraphView::~GraphView()
 	delete _grid;
 	delete _message;
 
-	for (int i = 0; i < _graphs.count(); i++)
-		delete _graphs[i];
+	qDeleteAll(_graphs);
 }
 
 void GraphView::createXLabel()
@@ -380,9 +379,7 @@ void GraphView::clear()
 	_slider->clear();
 	_info->clear();
 
-	for (int i = 0; i < _graphs.count(); i++)
-		delete _graphs[i];
-
+	qDeleteAll(_graphs);
 	_graphs.clear();
 	_visible.clear();
 	_palette.reset();

src/GUI/gui.cpp

@@ -885,8 +885,7 @@ void GUI::closePOIFiles()
 {
 	_poiFilesMenu->clear();
 
-	for (int i = 0; i < _poiFilesActions.count(); i++)
-		delete _poiFilesActions[i];
+	qDeleteAll(_poiFilesActions);
 	_poiFilesActions.clear();
 
 	_poi->clear();

src/GUI/pathitem.cpp

@@ -141,6 +141,10 @@ void PathItem::setColor(const QColor &color)
 		return;
 
 	_pen.setColor(color);
+
+	for (int i = 0; i < _ticks.size(); i++)
+		_ticks[i]->setColor(color);
+
 	update();
 }
 
@@ -317,8 +321,7 @@ unsigned PathItem::tickSize() const
 
 void PathItem::updateTicks()
 {
-	for (int i = 0; i < _ticks.size(); i++)
-		delete _ticks[i];
+	qDeleteAll(_ticks);
 	_ticks.clear();
 
 	if (!_showTicks)

src/data/track.cpp

@@ -99,8 +99,11 @@ Track::Track(const TrackData &data) : _data(data), _pause(0)
 			if (sd.at(j).timestamp() >= sd.at(j-1).timestamp())
 				dt = sd.at(j-1).timestamp().msecsTo(
 				  sd.at(j).timestamp()) / 1000.0;
-			else
-				dt = NAN;
+			else {
+				qWarning("%s: %s: time skew detected", qPrintable(_data.name()),
+				  qPrintable(sd.at(j).timestamp().toString(Qt::ISODate)));
+				dt = 0;
+			}
 			seg.time.append(seg.time.last() + dt);
 
 			if (dt < 1e-3) {

src/map/IMG/img.cpp

@@ -5,6 +5,8 @@
 #include "img.h"
 
 
+#define CACHE_SIZE 8388608 /* 8MB */
+
 #define CHECK(condition) \
 	if (!(condition)) { \
 		_errorString = "Invalid/corrupted IMG file"; \
@@ -25,19 +27,8 @@ struct CTX
 	QList<IMG::Point> *points;
 };
 
-#ifndef QT_NO_DEBUG
-static QDebug operator<<(QDebug dbg, const QMap<QString, VectorTile*> &map)
-{
-	dbg.nospace() << "TileMap(";
-	for (QMap<QString, VectorTile*>::const_iterator it = map.constBegin();
-	  it != map.constEnd(); ++it)
-		dbg << "(" << it.key() << ", " << *(*it) << ")";
-	dbg << ")";
-	return dbg.space();
-}
-#endif // QT_NO_DEBUG
-
-IMG::IMG(const QString &fileName) : _file(fileName), _valid(false)
+IMG::IMG(const QString &fileName)
+  : _file(fileName), _typ(0), _style(0), _valid(false)
 {
 	if (!_file.open(QFile::ReadOnly)) {
 		_errorString = _file.errorString();
@@ -62,6 +53,7 @@ IMG::IMG(const QString &fileName) : _file(fileName), _valid(false)
 	QByteArray nba(QByteArray(d1, sizeof(d1)) + QByteArray(d2, sizeof(d2)));
 	_name = QString(nba).trimmed();
 	_blockSize = 1 << (e1 + e2);
+	_blockCache.setMaxCost(CACHE_SIZE / _blockSize);
 
 	// Read the FAT table
 	quint8 flag;
@@ -84,7 +76,7 @@ IMG::IMG(const QString &fileName) : _file(fileName), _valid(false)
 
 
 	QMap<QString, VectorTile*> tileMap;
-	QMap<QString, SubFile*> TYPMap;
+	QString typFile;
 
 	// Read FAT blocks describing the IMG sub-files
 	for (int i = 0; i < cnt; i++) {
@@ -120,14 +112,15 @@ IMG::IMG(const QString &fileName) : _file(fileName), _valid(false)
 				file->addBlock(block);
 			}
 		} else if (tt == SubFile::TYP) {
-			SubFile *typ;
-			QMap<QString, SubFile*>::iterator it = TYPMap.find(fn);
-			if (it == TYPMap.end()) {
-				typ = new SubFile(this, size);
-				TYPMap.insert(fn, typ);
-			} else
-				typ = *it;
+			SubFile *typ = 0;
+			if (typFile.isNull()) {
+				_typ = new SubFile(this, size);
+				typ = _typ;
+				typFile = fn;
+			} else if (fn == typFile)
+				typ = _typ;
 
+			if (typ) {
 				_file.seek(offset + 0x20);
 				for (int i = 0; i < 240; i++) {
 					CHECK(readValue(block));
@@ -136,12 +129,12 @@ IMG::IMG(const QString &fileName) : _file(fileName), _valid(false)
 					typ->addBlock(block);
 				}
 			}
+		}
 
 		offset += 512;
 	}
 
 	// Create tile tree
-	QSet<int> bits;
 	for (QMap<QString, VectorTile*>::iterator it = tileMap.begin();
 	  it != tileMap.end(); ++it) {
 		CHECK((*it)->init());
@@ -154,27 +147,6 @@ IMG::IMG(const QString &fileName) : _file(fileName), _valid(false)
 		_tileTree.Insert(min, max, *it);
 
 		_bounds |= (*it)->bounds();
-
-		for (int i = 0; i < (*it)->bits().count(); i++)
-			bits.insert((*it)->bits().at(i));
-	}
-	_bits = bits.toList();
-	qSort(_bits);
-
-	// Read TYP file if any
-	if (!TYPMap.isEmpty()) {
-		if (TYPMap.size() > 1)
-			qWarning("%s: Multiple TYP files, using %s",
-			  qPrintable(_file.fileName()), qPrintable(TYPMap.keys().first()));
-		SubFile *typ = TYPMap.values().first();
-		_style = Style(typ);
-		qDeleteAll(TYPMap);
-	} else {
-		QFile typFile(ProgramPaths::typFile());
-		if (typFile.exists()) {
-			SubFile typ(&typFile);
-			_style = Style(&typ);
-		}
 	}
 
 	_valid = true;
@@ -185,6 +157,37 @@ IMG::~IMG()
 	TileTree::Iterator it;
 	for (_tileTree.GetFirst(it); !_tileTree.IsNull(it); _tileTree.GetNext(it))
 		delete _tileTree.GetAt(it);
+
+	delete _typ;
+	delete _style;
+}
+
+void IMG::load()
+{
+	Q_ASSERT(!_style);
+
+	if (_typ && _typ->isValid())
+		_style = new Style(_typ);
+	else {
+		QFile typFile(ProgramPaths::typFile());
+		if (typFile.exists()) {
+			SubFile typ(&typFile);
+			_style = new Style(&typ);
+		} else
+			_style = new Style();
+	}
+}
+
+void IMG::clear()
+{
+	TileTree::Iterator it;
+	for (_tileTree.GetFirst(it); !_tileTree.IsNull(it); _tileTree.GetNext(it))
+		_tileTree.GetAt(it)->clear();
+
+	delete _style;
+	_style = 0;
+
+	_blockCache.clear();
 }
 
 static bool cb(VectorTile *tile, void *context)
@@ -195,17 +198,9 @@ static bool cb(VectorTile *tile, void *context)
 }
 
 void IMG::objects(const RectC &rect, int bits, QList<Poly> *polygons,
-  QList<Poly> *lines, QList<Point> *points) const
+  QList<Poly> *lines, QList<Point> *points)
 {
-	int mb = _bits.first();
-	for (int i = 0; i < _bits.size(); i++) {
-		if (_bits.at(i) > bits)
-			break;
-		else
-			mb = _bits.at(i);
-	}
-
-	CTX ctx(rect, mb, polygons, lines, points);
+	CTX ctx(rect, bits, polygons, lines, points);
 	double min[2], max[2];
 
 	min[0] = rect.left();

src/map/IMG/img.h

@@ -10,6 +10,7 @@
 #include "common/rectc.h"
 #include "common/range.h"
 #include "style.h"
+#include "label.h"
 
 class VectorTile;
 class SubFile;
@@ -23,7 +24,7 @@ public:
 		   ll2xy() the points in the IMG class as this can not be done in
 		   parallel. */
 		QVector<QPointF> points;
-		QString label;
+		Label label;
 		quint32 type;
 
 		bool operator<(const Poly &other) const
@@ -34,25 +35,29 @@ public:
 		Point() : id(0) {}
 
 		Coordinates coordinates;
-		QString label;
+		Label label;
 		quint32 type;
 		bool poi;
 		quint64 id;
 
 		bool operator<(const Point &other) const
-		  {return id > other.id;}
+		  {return id < other.id;}
 	};
 
 
 	IMG(const QString &fileName);
 	~IMG();
 
+	void load();
+	void clear();
+
+	QString fileName() const {return _file.fileName();}
 	const QString &name() const {return _name;}
 	const RectC &bounds() const {return _bounds;}
-	Range zooms() const {return Range(_bits.first(), _bits.last());}
+
 	void objects(const RectC &rect, int bits, QList<Poly> *polygons,
-	  QList<Poly> *lines, QList<Point> *points) const;
-	const Style &style() const {return _style;}
+	  QList<Poly> *lines, QList<Point> *points);
+	const Style *style() const {return _style;}
 
 	bool isValid() const {return _valid;}
 	const QString &errorString() const {return _errorString;}
@@ -62,23 +67,22 @@ private:
 
 	typedef RTree<VectorTile*, double, 2> TileTree;
 
-	QString fileName() const {return _file.fileName();}
 	int blockSize() const {return _blockSize;}
 	bool readBlock(int blockNum, QByteArray &data);
 	qint64 read(char *data, qint64 maxSize);
 	template<class T> bool readValue(T &val);
+	bool init();
 
 	QFile _file;
 	quint8 _key;
 	int _blockSize;
 	QCache<int, QByteArray> _blockCache;
 
-	TileTree _tileTree;
-
 	QString _name;
 	RectC _bounds;
-	QList<int> _bits;
-	Style _style;
+	TileTree _tileTree;
+	SubFile *_typ;
+	Style *_style;
 
 	bool _valid;
 	QString _errorString;

src/map/IMG/label.h

@@ -0,0 +1,74 @@
+#ifndef LABEL_H
+#define LABEL_H
+
+#include <QString>
+#include <QDebug>
+
+class Label {
+public:
+	class Shield
+	{
+	public:
+		enum Type {
+			None,
+			USInterstate,
+			USShield,
+			USRound,
+			Hbox,
+			Box,
+			Oval
+		};
+
+		Shield() : _type(None) {}
+		Shield(Type type, const QString &name) : _type(type), _text(name) {}
+
+		Type type() const {return _type;}
+		const QString &text() const {return _text;}
+		bool isValid() const {return _type > None && !_text.isEmpty();}
+
+		bool operator==(const Shield &other) const
+		  {return _type == other._type && _text == other._text;}
+
+	private:
+		Type _type;
+		QString _text;
+	};
+
+	Label() {}
+	Label(const QString &text, const Shield &shield = Shield())
+	  : _text(text), _shield(shield) {}
+
+	const Shield &shield() const {return _shield;}
+	const QString &text() const {return _text;}
+	bool isValid() const {return _shield.isValid() || !_text.isEmpty();}
+
+	void setText(const QString &text) {_text = text;}
+
+private:
+	QString _text;
+	Shield _shield;
+};
+
+inline uint qHash(const Label::Shield &shield)
+{
+	return qHash(shield.text()) ^ shield.type();
+}
+
+#ifndef QT_NO_DEBUG
+inline QDebug operator<<(QDebug dbg, const Label::Shield &shield)
+{
+	dbg.nospace() << "Shield(" << shield.type() << ", " << shield.text() << ")";
+	return dbg.space();
+}
+
+inline QDebug operator<<(QDebug dbg, const Label &label)
+{
+	dbg.nospace() << "Label(";
+	if (label.shield().isValid())
+		dbg << label.shield() << ", ";
+	dbg << label.text() << ")";
+	return dbg.space();
+}
+#endif // QT_NO_DEBUG
+
+#endif // LABEL_H

src/map/IMG/lblfile.cpp

@@ -7,7 +7,7 @@ static quint8 NORMAL_CHARS[] = {
 	' ', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
 	'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
 	'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
-	'X', 'Y', 'Z',  '~', '~', '~', '~', '~',
+	'X', 'Y', 'Z',  '~', '~', '~', ' ', ' ',
 	'0', '1', '2', '3', '4', '5', '6', '7',
 	'8', '9', '~', '~', '~', '~', '~', '~'
 };
@@ -48,6 +48,7 @@ static QString capitalize(const QString &str)
 	return ret;
 }
 
+
 bool LBLFile::init()
 {
 	Handle hdl;
@@ -73,45 +74,48 @@ bool LBLFile::init()
 	return true;
 }
 
-QString LBLFile::label6b(Handle &hdl, quint32 offset) const
+Label LBLFile::label6b(Handle &hdl, quint32 offset) const
 {
-	QByteArray result;
+	Label::Shield::Type shieldType = Label::Shield::None;
+	QByteArray label, shieldLabel;
+	QByteArray *bap = &label;
 	Charset curCharSet = Normal;
 	quint8 b1, b2, b3;
 
 	if (!seek(hdl, offset))
-		return QString();
+		return Label();
 
 	while (true) {
 		if (!(readByte(hdl, b1) && readByte(hdl, b2) && readByte(hdl, b3)))
-			return QString();
+			return Label();
 
 		int c[]= {b1>>2, (b1&0x3)<<4|b2>>4, (b2&0xF)<<2|b3>>6, b3&0x3F};
 
 		for (int cpt = 0; cpt < 4; cpt++) {
-			if (c[cpt] > 0x2F)
-				return QString::fromLatin1(result);
+			if (c[cpt] > 0x2f || (curCharSet == Normal && c[cpt] == 0x1d))
+				return Label(capitalize(QString::fromLatin1(label)),
+				  Label::Shield(shieldType, shieldLabel));
 			switch (curCharSet) {
 				case Normal:
 					if (c[cpt] == 0x1c)
 						curCharSet = Symbol;
 					else if (c[cpt] == 0x1b)
 						curCharSet = Special;
-					else if(c[cpt] == 0x1d)
-						result.append('|');
-					else if (c[cpt] == 0x1f)
-						result.append(' ');
-					else if (c[cpt] == 0x1e)
-						result.append(' ');
+					else if (c[cpt] >= 0x2a && c[cpt] <= 0x2f) {
+						shieldType = (Label::Shield::Type)(c[cpt] - 0x29);
+						bap = &shieldLabel;
+					} else if (bap == &shieldLabel
+					  && NORMAL_CHARS[c[cpt]] == ' ')
+						bap = &label;
 					else
-						result.append(NORMAL_CHARS[c[cpt]]);
+						bap->append(NORMAL_CHARS[c[cpt]]);
 					break;
 				case Symbol:
-					result.append(SYMBOL_CHARS[c[cpt]]);
+					bap->append(SYMBOL_CHARS[c[cpt]]);
 					curCharSet = Normal;
 					break;
 				case Special:
-					result.append(SPECIAL_CHARS[c[cpt]]);
+					bap->append(SPECIAL_CHARS[c[cpt]]);
 					curCharSet = Normal;
 					break;
 			}
@@ -119,40 +123,51 @@ QString LBLFile::label6b(Handle &hdl, quint32 offset) const
 	}
 }
 
-QString LBLFile::label8b(Handle &hdl, quint32 offset) const
+Label LBLFile::label8b(Handle &hdl, quint32 offset) const
 {
-	QByteArray result;
+	Label::Shield::Type shieldType = Label::Shield::None;
+	QByteArray label, shieldLabel;
+	QByteArray *bap = &label;
 	quint8 c;
 
 	if (!seek(hdl, offset))
-		return QString();
+		return Label();
 
 	while (true) {
 		if (!readByte(hdl, c))
-			return QString();
-		if (!c)
+			return Label();
+		if (!c || c == 0x1d)
 			break;
 
-		if (c >= 0x1B && c <= 0x1F)
-			result.append(' ');
-		else if (c > 0x07)
-			result.append(c);
+		if ((c >= 0x1e && c <= 0x1f)) {
+			if (bap == &shieldLabel)
+				bap = &label;
+			else
+				bap->append(' ');
+		} else if (c <= 0x07) {
+			shieldType = (Label::Shield::Type)c;
+			bap = &shieldLabel;
+		} else if (bap == &shieldLabel && QChar(c).isSpace()) {
+			bap = &label;
+		} else
+			bap->append(c);
 	}
 
-	return _codec ? _codec->toUnicode(result) : QString::fromLatin1(result);
+	return Label(capitalize(_codec ? _codec->toUnicode(label)
+	  : QString::fromLatin1(label)), Label::Shield(shieldType, _codec
+	  ? _codec->toUnicode(shieldLabel) : QString::fromLatin1(shieldLabel)));
 }
 
-QString LBLFile::label(Handle &hdl, quint32 offset, bool poi)
+Label LBLFile::label(Handle &hdl, quint32 offset, bool poi)
 {
-	if (!_init) {
-		if (!(_init = init()))
+	if (!_size && !init())
 		return QString();
-	}
 
 	quint32 labelOffset;
 	if (poi) {
 		quint32 poiOffset;
-		if (!(seek(hdl, _poiOffset + offset) && readUInt24(hdl, poiOffset)))
+		if (!(seek(hdl, _poiOffset + offset) && readUInt24(hdl, poiOffset)
+		  && (poiOffset & 0x3FFFFF)))
 			return QString();
 		labelOffset = _offset + (poiOffset & 0x3FFFFF) * _multiplier;
 	} else
@@ -163,11 +178,11 @@ QString LBLFile::label(Handle &hdl, quint32 offset, bool poi)
 
 	switch (_encoding) {
 		case 6:
-			return capitalize(label6b(hdl, labelOffset));
+			return label6b(hdl, labelOffset);
 		case 9:
 		case 10:
-			return capitalize(label8b(hdl, labelOffset));
+			return label8b(hdl, labelOffset);
 		default:
-			return QString();
+			return Label();
 	}
 }

src/map/IMG/lblfile.h

@@ -2,21 +2,24 @@
 #define LBLFILE_H
 
 #include "subfile.h"
+#include "label.h"
 
 class QTextCodec;
 
 class LBLFile : public SubFile
 {
 public:
-	LBLFile(IMG *img, quint32 size) : SubFile(img, size), _init(false) {}
+	LBLFile(IMG *img, quint32 size)
+	  : SubFile(img, size), _offset(0), _size(0), _poiOffset(0), _poiSize(0),
+	  _multiplier(0), _encoding(0), _codec(0) {}
 
-	QString label(Handle &hdl, quint32 offset, bool poi = false);
+	Label label(Handle &hdl, quint32 offset, bool poi = false);
 
 private:
 	bool init();
 
-	QString label6b(Handle &hdl, quint32 offset) const;
-	QString label8b(Handle &hdl, quint32 offset) const;
+	Label label6b(Handle &hdl, quint32 offset) const;
+	Label label8b(Handle &hdl, quint32 offset) const;
 
 	quint32 _offset;
 	quint32 _size;
@@ -25,8 +28,6 @@ private:
 	quint8 _multiplier;
 	quint8 _encoding;
 	QTextCodec *_codec;
-
-	bool _init;
 };
 
 #endif // LBLFILE_H

src/map/IMG/rgnfile.cpp

@@ -205,7 +205,8 @@ bool RGNFile::polyObjects(const RectC &rect, Handle &hdl, const SubDiv *subdiv,
 		if (lbl && (labelPtr & 0x3FFFFF)) {
 			if (labelPtr & 0x800000) {
 				quint32 lblOff;
-				if (net && net->lblOffset(netHdl, labelPtr & 0x3FFFFF, lblOff))
+				if (net && net->lblOffset(netHdl, labelPtr & 0x3FFFFF, lblOff)
+				  && lblOff)
 					poly.label = lbl->label(lblHdl, lblOff);
 			} else
 				poly.label = lbl->label(lblHdl, labelPtr & 0x3FFFFF);
@@ -289,7 +290,7 @@ bool RGNFile::extPolyObjects(const RectC &rect, Handle &hdl,
 		if (subtype & 0x20) {
 			if (!readUInt24(hdl, labelPtr))
 				return false;
-			if (lbl)
+			if (lbl && (labelPtr & 0x3FFFFF))
 				poly.label = lbl->label(lblHdl, labelPtr & 0x3FFFFF);
 		}
 
@@ -403,10 +404,8 @@ void RGNFile::objects(const RectC &rect, const SubDiv *subdiv, LBLFile *lbl,
 {
 	Handle rgnHdl, lblHdl, netHdl;
 
-	if (!_init) {
-		if (!(_init = init()))
+	if (!_size && !init())
 		return;
-	}
 
 	QVector<RGNFile::Segment> seg(segments(rgnHdl, subdiv));
 	for (int i = 0; i < seg.size(); i++) {
@@ -437,10 +436,8 @@ void RGNFile::extObjects(const RectC &rect, const SubDiv *subdiv, LBLFile *lbl,
 {
 	Handle rgnHdl, lblHdl;
 
-	if (!_init) {
-		if (!(_init = init()))
+	if (!_size && !init())
 		return;
-	}
 
 	if (polygons && subdiv->polygonsOffset() != subdiv->polygonsEnd()) {
 		quint32 start = _polygonsOffset + subdiv->polygonsOffset();

src/map/IMG/rgnfile.h

@@ -11,7 +11,10 @@ class NETFile;
 class RGNFile : public SubFile
 {
 public:
-	RGNFile(IMG *img, quint32 size) : SubFile(img, size), _init(false) {}
+	RGNFile(IMG *img, quint32 size)
+	  : SubFile(img, size), _offset(0), _size(0), _polygonsOffset(0),
+	  _polygonsSize(), _linesOffset(), _linesSize(), _pointsOffset(),
+	  _pointsSize() {}
 
 	void objects(const RectC &rect, const SubDiv *subdiv, LBLFile *lbl,
 	  NETFile *net, QList<IMG::Poly> *polygons, QList<IMG::Poly> *lines,
@@ -96,8 +99,6 @@ private:
 	quint32 _linesSize;
 	quint32 _pointsOffset;
 	quint32 _pointsSize;
-
-	bool _init;
 };
 
 #ifndef QT_NO_DEBUG

src/map/IMG/style.cpp

@@ -148,8 +148,14 @@ void Style::defaultLineStyle()
 	_lines[TYPE(0x29)].setTextFontSize(Style::None);
 }
 
-void Style::defaultPOIStyle()
+void Style::defaultPointStyle()
 {
+	// Cities
+	_points[TYPE(0x01)].setTextFontSize(Style::Large);
+	_points[TYPE(0x02)].setTextFontSize(Style::Large);
+	_points[TYPE(0x03)].setTextFontSize(Style::Large);
+
+	// POI
 	_points[0x2a00] = Point(QImage(":/restaurant-11.png"));
 	_points[0x2a01] = Point(QImage(":/restaurant-11.png"));
 	_points[0x2a02] = Point(QImage(":/restaurant-noodle-11.png"));
@@ -380,6 +386,9 @@ bool Style::itemInfo(SubFile *file, SubFile::Handle &hdl,
 bool Style::parsePolygons(SubFile *file, SubFile::Handle &hdl,
   const Section &section)
 {
+	if (!section.arrayItemSize)
+		return section.arraySize ? false : true;
+
 	for (quint32 i = 0; i < section.arraySize / section.arrayItemSize; i++) {
 		if (!file->seek(hdl, section.arrayOffset + i * section.arrayItemSize))
 			return false;
@@ -493,6 +502,9 @@ bool Style::parsePolygons(SubFile *file, SubFile::Handle &hdl,
 bool Style::parseLines(SubFile *file, SubFile::Handle &hdl,
   const Section &section)
 {
+	if (!section.arrayItemSize)
+		return section.arraySize ? false : true;
+
 	for (quint32 i = 0; i < section.arraySize / section.arrayItemSize; i++) {
 		if (!file->seek(hdl, section.arrayOffset + i * section.arrayItemSize))
 			return false;
@@ -774,6 +786,9 @@ static bool readColorTable(SubFile *file, SubFile::Handle &hdl, QImage& img,
 bool Style::parsePoints(SubFile *file, SubFile::Handle &hdl,
   const Section &section)
 {
+	if (!section.arrayItemSize)
+		return section.arraySize ? false : true;
+
 	for (quint32 i = 0; i < section.arraySize / section.arrayItemSize; i++) {
 		if (!file->seek(hdl, section.arrayOffset + i * section.arrayItemSize))
 			return false;
@@ -849,6 +864,9 @@ bool Style::parseDrawOrder(SubFile *file, SubFile::Handle &hdl,
 {
 	QList<quint32> drawOrder;
 
+	if (!order.arrayItemSize)
+		return order.arraySize ? false : true;
+
 	if (!file->seek(hdl, order.arrayOffset))
 		return false;
 
@@ -922,7 +940,7 @@ Style::Style(SubFile *typ)
 {
 	defaultLineStyle();
 	defaultPolygonStyle();
-	defaultPOIStyle();
+	defaultPointStyle();
 
 	if (typ && typ->isValid())
 		parseTYPFile(typ);
@@ -968,6 +986,11 @@ bool Style::isSummit(quint32 type)
 	return (type == 0x6616);
 }
 
+bool Style::isMajorRoad(quint32 type)
+{
+	return (type <= TYPE(0x04));
+}
+
 Style::POIClass Style::poiClass(quint32 type)
 {
 	if ((type >= 0x2a00 && type < 0x2b00) || type == 0x2c0a || type == 0x2d02)

src/map/IMG/style.h

@@ -106,6 +106,7 @@ public:
 	static bool isContourLine(quint32 type);
 	static bool isSpot(quint32 type);
 	static bool isSummit(quint32 type);
+	static bool isMajorRoad(quint32 type);
 	static POIClass poiClass(quint32 type);
 
 private:
@@ -137,7 +138,7 @@ private:
 	  const Section &section, ItemInfo &info);
 	void defaultPolygonStyle();
 	void defaultLineStyle();
-	void defaultPOIStyle();
+	void defaultPointStyle();
 
 	QMap<quint32, Line> _lines;
 	QMap<quint32, Polygon> _polygons;

src/map/IMG/textpointitem.cpp

@@ -7,29 +7,48 @@
 
 #define FLAGS (Qt::AlignCenter | Qt::TextWordWrap | Qt::TextDontClip)
 #define MAX_TEXT_WIDTH 8
+#define MIN_BOX_WIDTH 2
+
+
+static void expand(QRect &rect, int width)
+{
+	rect.adjust(-(width/2 - rect.width()/2), 0, width/2 - rect.width()/2, 0);
+}
 
 TextPointItem::TextPointItem(const QPoint &point, const QString *text,
-  const QFont *font, const QImage *img, const QColor *color)
-  : _text(text), _font(font), _img(img), _color(color)
+  const QFont *font, const QImage *img, const QColor *color,
+  const QColor *bgColor) : _text(text), _font(font), _img(img), _color(color),
+  _bgColor(bgColor)
 {
-	QRect iconRect;
-
 	if (text) {
 		QFontMetrics fm(*font);
 		int limit = font->pixelSize() * MAX_TEXT_WIDTH;
 		_textRect = fm.boundingRect(QRect(0, 0, limit, 0), FLAGS, *text);
 		_textRect.adjust(0, 0, 1, 1);
 	}
-	if (img) {
-		iconRect = QRect(QPoint(point.x() - img->width()/2, point.y()
-		  - img->height()/2), img->size());
-		_textRect.moveTopLeft(QPoint(point.x() + img->width(), point.y()
+
+	if (_bgColor && _textRect.width() < font->pixelSize() * MIN_BOX_WIDTH)
+		expand(_textRect, font->pixelSize() * MIN_BOX_WIDTH);
+
+	setPos(point);
+}
+
+void TextPointItem::setPos(const QPoint &point)
+{
+	QPainterPath shape;
+	QRect iconRect;
+
+	if (_img) {
+		iconRect = QRect(QPoint(point.x() - _img->width()/2, point.y()
+		  - _img->height()/2), _img->size());
+		_textRect.moveTopLeft(QPoint(point.x() + _img->width(), point.y()
 		  - _textRect.height()/2));
 	} else
 		_textRect.moveCenter(point);
 
 	_rect = _textRect | iconRect;
-	_shape.addRect(_rect);
+	shape.addRect(_rect);
+	_shape = shape;
 }
 
 void TextPointItem::paint(QPainter *painter) const
@@ -54,6 +73,13 @@ void TextPointItem::paint(QPainter *painter) const
 		painter->drawImage(_textRect.x() - 1, _textRect.y(), img);
 		painter->drawImage(_textRect.x() + 1, _textRect.y(), img);
 
+
+		if (_bgColor) {
+			painter->setPen(*_color);
+			painter->setBrush(*_bgColor);
+			painter->drawRect(_textRect);
+			painter->setBrush(Qt::NoBrush);
+		}
 		if (_color) {
 			painter->setFont(*_font);
 			painter->setPen(*_color);

src/map/IMG/textpointitem.h

@@ -16,7 +16,7 @@ class TextPointItem : public TextItem
 public:
 	TextPointItem() : _text(0), _font(0), _img(0) {}
 	TextPointItem(const QPoint &point, const QString *text, const QFont *font,
-	  const QImage *img, const QColor *color);
+	  const QImage *img, const QColor *color, const QColor *bgColor = 0);
 
 	bool isValid() const {return !_rect.isEmpty();}
 
@@ -24,11 +24,13 @@ public:
 	QPainterPath shape() const {return _shape;}
 	void paint(QPainter *painter) const;
 
+	void setPos(const QPoint &point);
+
 private:
 	const QString *_text;
 	const QFont *_font;
 	const QImage *_img;
-	const QColor *_color;
+	const QColor *_color, *_bgColor;
 	QRect _rect, _textRect;
 	QPainterPath _shape;
 };

src/map/IMG/trefile.cpp

@@ -9,16 +9,6 @@ struct MapLevel {
 	quint16 subdivs;
 };
 
-#ifndef QT_NO_DEBUG
-static QDebug operator<<(QDebug dbg, const MapLevel &ml)
-{
-	bool inherited = ml.level & 0x80 ? true : false;
-	dbg.nospace() << "MapLevel(" << (ml.level & 0x7F) << ", " << inherited
-	  << ", " << ml.bits << ", " << ml.subdivs << ")";
-	return dbg.space();
-}
-#endif // QT_NO_DEBUG
-
 static void unlock(quint8 *dst, const quint8 *src, quint32 size, quint32 key)
 {
 	static const unsigned char shuf[] = {
@@ -50,29 +40,12 @@ static void unlock(quint8 *dst, const quint8 *src, quint32 size, quint32 key)
 
 TREFile::~TREFile()
 {
-	SubDivTree::Iterator jt;
-
-	for (QMap<int, SubDivTree*>::iterator it = _subdivs.begin();
-	  it != _subdivs.end(); ++it) {
-		SubDivTree *tree = *it;
-		for (tree->GetFirst(jt); !tree->IsNull(jt); tree->GetNext(jt))
-			delete tree->GetAt(jt);
-	}
-
-	for (QMap<int, SubDivTree*>::iterator it = _subdivs.begin();
-	  it != _subdivs.end(); ++it)
-		delete *it;
+	clear();
 }
 
 bool TREFile::init()
 {
 	Handle hdl;
-	quint8 locked;
-	quint16 hdrLen;
-
-	if (!(isValid() && seek(hdl, 0) && readUInt16(hdl, hdrLen)
-	  && seek(hdl, 0x0D) && readByte(hdl, locked)))
-		return false;
 
 	// Tile bounds
 	qint32 north, east, south, west;
@@ -82,9 +55,23 @@ bool TREFile::init()
 	_bounds = RectC(Coordinates(toWGS84(west), toWGS84(north)),
 	  Coordinates(toWGS84(east), toWGS84(south)));
 
+	return true;
+}
+
+bool TREFile::load()
+{
+	Handle hdl;
+	quint8 locked;
+	quint16 hdrLen;
+
+	if (!(seek(hdl, 0) && readUInt16(hdl, hdrLen)
+	  && seek(hdl, 0x0D) && readByte(hdl, locked)))
+		return false;
+
 	quint32 levelsOffset, levelsSize, subdivOffset, subdivSize;
-	if (!(readUInt32(hdl, levelsOffset) && readUInt32(hdl, levelsSize)
-	  && readUInt32(hdl, subdivOffset) && readUInt32(hdl, subdivSize)))
+	if (!(seek(hdl, 0x21) && readUInt32(hdl, levelsOffset)
+	  && readUInt32(hdl, levelsSize) && readUInt32(hdl, subdivOffset)
+	  && readUInt32(hdl, subdivSize)))
 		return false;
 
 	quint32 extOffset, extSize = 0;
@@ -199,9 +186,44 @@ bool TREFile::init()
 		}
 	}
 
+	_levels = _subdivs.keys();
+
 	return true;
 }
 
+void TREFile::clear()
+{
+	SubDivTree::Iterator jt;
+
+	for (QMap<int, SubDivTree*>::iterator it = _subdivs.begin();
+	  it != _subdivs.end(); ++it) {
+		SubDivTree *tree = *it;
+		for (tree->GetFirst(jt); !tree->IsNull(jt); tree->GetNext(jt))
+			delete tree->GetAt(jt);
+	}
+
+	qDeleteAll(_subdivs);
+
+	_subdivs.clear();
+	_levels.clear();
+}
+
+int TREFile::level(int bits)
+{
+	if (_levels.isEmpty() && !load())
+		return -1;
+
+	int l = _levels.first();
+	for (int i = 0; i < _levels.size(); i++) {
+		if (_levels.at(i) > bits)
+			break;
+		else
+			l = _levels.at(i);
+	}
+
+	return l;
+}
+
 static bool cb(SubDiv *subdiv, void *context)
 {
 	QList<SubDiv*> *list = (QList<SubDiv*>*)context;
@@ -209,9 +231,10 @@ static bool cb(SubDiv *subdiv, void *context)
 	return true;
 }
 
-QList<SubDiv*> TREFile::subdivs(const RectC &rect, int bits) const
+QList<SubDiv*> TREFile::subdivs(const RectC &rect, int bits)
 {
 	QList<SubDiv*> list;
+	SubDivTree *tree = _subdivs.value(level(bits));
 	double min[2], max[2];
 
 	min[0] = rect.left();
@@ -219,7 +242,8 @@ QList<SubDiv*> TREFile::subdivs(const RectC &rect, int bits) const
 	max[0] = rect.right();
 	max[1] = rect.top();
 
-	_subdivs.value(bits)->Search(min, max, cb, &list);
+	if (tree)
+		tree->Search(min, max, cb, &list);
 
 	return list;
 }

src/map/IMG/trefile.h

@@ -17,20 +17,22 @@ public:
 	~TREFile();
 
 	bool init();
+	void clear();
 
 	const RectC &bounds() const {return _bounds;}
-	const QList<int> bits() const {return _subdivs.keys();}
-
-	QList<SubDiv*> subdivs(const RectC &rect, int bits) const;
+	QList<SubDiv*> subdivs(const RectC &rect, int bits);
 
 private:
 	typedef RTree<SubDiv*, double, 2> SubDivTree;
 
+	bool load();
+	int level(int bits);
 	bool parsePoly(Handle hdl, quint32 pos, const QMap<int, int> &level2bits,
 	  QMap<quint32, int> &map);
 	bool parsePoints(Handle hdl, quint32 pos, const QMap<int, int> &level2bits);
 
 	RectC _bounds;
+	QList<int> _levels;
 	QMap<int, SubDivTree*> _subdivs;
 };
 

src/map/IMG/vectortile.cpp

@@ -38,7 +38,8 @@ SubFile *VectorTile::addFile(IMG *img, SubFile::Type type, quint32 size)
 
 bool VectorTile::init()
 {
-	if (!(_tre && _tre->init() && _rgn && _rgn->isValid()))
+	if (!(_tre && _tre->isValid() && _tre->init() && _rgn
+	  && _rgn->isValid()))
 		return false;
 	if (_lbl && !_lbl->isValid())
 		return false;

src/map/IMG/vectortile.h

@@ -14,9 +14,9 @@ public:
 	~VectorTile() {delete _tre; delete _rgn; delete _lbl; delete _net;}
 
 	bool init();
+	void clear() {_tre->clear();}
 
 	const RectC &bounds() const {return _tre->bounds();}
-	const QList<int> bits() const {return _tre->bits();}
 
 	SubFile *file(SubFile::Type type);
 	SubFile *addFile(IMG *img, SubFile::Type type, quint32 size);

src/map/imgmap.cpp

@@ -18,12 +18,6 @@
 
 #define TILE_SIZE   256
 #define TEXT_EXTENT 256
-
-#define LARGE_FONT_SIZE   14
-#define NORMAL_FONT_SIZE  12
-#define SMALL_FONT_SIZE   10
-#define POI_FONT_SIZE      9
-
 #define LINE_TEXT_MIN_ZOOM   22
 
 class RasterTile
@@ -74,12 +68,17 @@ private:
 };
 
 
-static void convertUnits(QString &str)
+static QColor shieldColor(Qt::white);
+static QColor shieldBgColor1("#dd3e3e");
+static QColor shieldBgColor2("#379947");
+static QColor shieldBgColor3("#4a7fc1");
+
+
+static QString convertUnits(const QString &str)
 {
 	bool ok;
 	int number = str.toInt(&ok);
-	if (ok)
-		str = QString::number(qRound(number * 0.3048));
+	return ok ? QString::number(qRound(number * 0.3048)) : str;
 }
 
 static int minPOIZoom(Style::POIClass cl)
@@ -103,28 +102,88 @@ static int minPOIZoom(Style::POIClass cl)
 	}
 }
 
+static QFont font(int pixelSize)
+{
+	QFont f;
+	f.setPixelSize(pixelSize);
+	return f;
+}
+
+/* The fonts must be initialized on first usage (after the QGuiApplication
+   instance is created) */
+#define FONT(name, size) \
+static const QFont *name() \
+{ \
+	static QFont f = font(size); \
+	return &f; \
+}
+
+FONT(largeFont, 16)
+FONT(normalFont, 14)
+FONT(smallFont, 12)
+FONT(poiFont, 10)
+
+static const QColor *shieldBgColor(Label::Shield::Type type)
+{
+	switch (type) {
+		case Label::Shield::USInterstate:
+		case Label::Shield::Hbox:
+			return &shieldBgColor1;
+		case Label::Shield::USShield:
+		case Label::Shield::Box:
+			return &shieldBgColor2;
+		case Label::Shield::USRound:
+		case Label::Shield::Oval:
+			return &shieldBgColor3;
+		default:
+			return 0;
+	}
+}
+
+static int minShieldZoom(Label::Shield::Type type)
+{
+	switch (type) {
+		case Label::Shield::USInterstate:
+		case Label::Shield::Hbox:
+			return 18;
+		case Label::Shield::USShield:
+		case Label::Shield::Box:
+			return 19;
+		case Label::Shield::USRound:
+		case Label::Shield::Oval:
+			return 20;
+		default:
+			return INT_MAX;
+	}
+}
+
+
 IMGMap::IMGMap(const QString &fileName, QObject *parent)
-  : Map(parent), _fileName(fileName), _img(fileName),
-  _projection(PCS::pcs(3857)), _valid(false)
+  : Map(parent), _img(fileName), _projection(PCS::pcs(3857)), _valid(false)
 {
 	if (!_img.isValid()) {
 		_errorString = _img.errorString();
 		return;
 	}
 
-	_zooms = Range(_img.zooms().min() - 1, 28);
+	_zooms = Range(12, 28);
 	_zoom = _zooms.min();
 
 	updateTransform();
 
-	_largeFont.setPixelSize(LARGE_FONT_SIZE);
-	_normalFont.setPixelSize(NORMAL_FONT_SIZE);
-	_smallFont.setPixelSize(SMALL_FONT_SIZE);
-	_poiFont.setPixelSize(POI_FONT_SIZE);
-
 	_valid = true;
 }
 
+void IMGMap::load()
+{
+	_img.load();
+}
+
+void IMGMap::unload()
+{
+	_img.clear();
+}
+
 QRectF IMGMap::bounds()
 {
 	RectD prect(_img.bounds(), _projection);
@@ -199,12 +258,12 @@ Coordinates IMGMap::xy2ll(const QPointF &p)
 
 void IMGMap::drawPolygons(QPainter *painter, const QList<IMG::Poly> &polygons)
 {
-	for (int n = 0; n < _img.style().drawOrder().size(); n++) {
+	for (int n = 0; n < _img.style()->drawOrder().size(); n++) {
 		for (int i = 0; i < polygons.size(); i++) {
 			const IMG::Poly &poly = polygons.at(i);
-			if (poly.type != _img.style().drawOrder().at(n))
+			if (poly.type != _img.style()->drawOrder().at(n))
 				continue;
-			const Style::Polygon &style = _img.style().polygon(poly.type);
+			const Style::Polygon &style = _img.style()->polygon(poly.type);
 
 			painter->setPen(style.pen());
 			painter->setBrush(style.brush());
@@ -219,7 +278,7 @@ void IMGMap::drawLines(QPainter *painter, const QList<IMG::Poly> &lines)
 
 	for (int i = 0; i < lines.size(); i++) {
 		const IMG::Poly &poly = lines.at(i);
-		const Style::Line &style = _img.style().line(poly.type);
+		const Style::Line &style = _img.style()->line(poly.type);
 
 		if (style.background() == Qt::NoPen)
 			continue;
@@ -230,7 +289,7 @@ void IMGMap::drawLines(QPainter *painter, const QList<IMG::Poly> &lines)
 
 	for (int i = 0; i < lines.size(); i++) {
 		const IMG::Poly &poly = lines.at(i);
-		const Style::Line &style = _img.style().line(poly.type);
+		const Style::Line &style = _img.style()->line(poly.type);
 
 		if (!style.img().isNull())
 			BitmapLine::draw(painter, poly.points, style.img());
@@ -262,6 +321,8 @@ void IMGMap::processPolygons(QList<IMG::Poly> &polygons)
 void IMGMap::processLines(QList<IMG::Poly> &lines, const QPoint &tile,
   QList<TextItem*> &textItems)
 {
+	QRect tileRect(tile, QSize(TILE_SIZE, TILE_SIZE));
+
 	qStableSort(lines);
 
 	for (int i = 0; i < lines.size(); i++) {
@@ -272,42 +333,88 @@ void IMGMap::processLines(QList<IMG::Poly> &lines, const QPoint &tile,
 		}
 	}
 
-	if (_zoom < LINE_TEXT_MIN_ZOOM)
-		return;
-
+	if (_zoom >= LINE_TEXT_MIN_ZOOM) {
 		for (int i = 0; i < lines.size(); i++) {
 			IMG::Poly &poly = lines[i];
-		const Style::Line &style = _img.style().line(poly.type);
+			const Style::Line &style = _img.style()->line(poly.type);
 
 			if (style.img().isNull() && style.foreground() == Qt::NoPen)
 				continue;
-		if (poly.label.isEmpty() || style.textFontSize() == Style::None)
+			if (poly.label.text().isEmpty()
+			  || style.textFontSize() == Style::None)
 				continue;
 
 			if (Style::isContourLine(poly.type))
-			convertUnits(poly.label);
+				poly.label.setText(convertUnits(poly.label.text()));
 
 			const QFont *font;
 			switch (style.textFontSize()) {
 				case Style::Large:
-				font = &_largeFont;
+					font = largeFont();
 					break;
-			case Style::Small:
-				font = &_smallFont;
+				case Style::Normal:
+					font = normalFont();
 					break;
 				default:
-				font = &_normalFont;
+					font = smallFont();
 			}
 			const QColor *color = style.textColor().isValid()
 			  ? &style.textColor() : 0;
 
-		TextPathItem *item = new TextPathItem(poly.points, &poly.label,
-		  QRect(tile, QSize(TILE_SIZE, TILE_SIZE)), font, color);
+			TextPathItem *item = new TextPathItem(poly.points,
+			  &poly.label.text(), tileRect, font, color);
 			if (item->isValid() && !item->collides(textItems))
 				textItems.append(item);
 			else
 				delete item;
 		}
+	}
+
+
+	for (int type = 1; type < 7; type++) {
+		if (minShieldZoom((Label::Shield::Type)type) > _zoom)
+			continue;
+
+		QSet<Label::Shield> shields;
+
+		for (int i = 0; i < lines.size(); i++) {
+			const IMG::Poly &poly = lines.at(i);
+			const Label::Shield &shield = poly.label.shield();
+			if (shield.type() != type || !Style::isMajorRoad(poly.type))
+				continue;
+
+			if (poly.label.shield().isValid() && !shields.contains(shield)) {
+				bool valid = false;
+				int idx = poly.points.size()/2, inc = 0, sign = 1;
+
+				TextPointItem *item = new TextPointItem(
+				  poly.points.at(idx).toPoint(), &shield.text(), poiFont(),
+				  0, &shieldColor, shieldBgColor(shield.type()));
+
+				while (1) {
+					if (!item->collides(textItems)
+					  && tileRect.contains(item->boundingRect().toRect())) {
+						valid = true;
+						break;
+					}
+					inc++;
+					sign = (sign < 0) ? 1 : -1;
+					idx += inc * sign;
+
+					if (!(idx >= 0 && idx < poly.points.size()))
+						break;
+
+					item->setPos(poly.points.at(idx).toPoint());
+				}
+
+				if (valid) {
+					textItems.append(item);
+					shields.insert(shield);
+				} else
+					delete item;
+			}
+		}
+	}
 }
 
 void IMGMap::processPoints(QList<IMG::Point> &points,
@@ -318,32 +425,33 @@ void IMGMap::processPoints(QList<IMG::Point> &points,
 	for (int i = 0; i < points.size(); i++) {
 		IMG::Point &point = points[i];
 
-		const Style::Point &style = _img.style().point(point.type);
+		const Style::Point &style = _img.style()->point(point.type);
 
 		if (point.poi && _zoom < minPOIZoom(Style::poiClass(point.type)))
 			continue;
 
-		const QString *label = point.label.isEmpty() ? 0 : &(point.label);
+		const QString *label = point.label.text().isEmpty()
+		  ? 0 : &(point.label.text());
 		const QImage *img = style.img().isNull() ? 0 : &style.img();
 		const QFont *font = 0;
 		if (point.poi) {
 			if (style.textFontSize() == Style::None)
 				label = 0;
 			else
-				font = &_poiFont;
+				font = poiFont();
 		} else {
 			switch (style.textFontSize()) {
 				case Style::None:
 					label = 0;
 					break;
-				case Style::Normal:
-					font = &_normalFont;
-					break;
 				case Style::Small:
-					font = &_smallFont;
+					font = smallFont();
+					break;
+				case Style::Large:
+					font = largeFont();
 					break;
 				default:
-					font = &_largeFont;
+					font = normalFont();
 			}
 		}
 		const QColor *color = style.textColor().isValid()
@@ -353,10 +461,10 @@ void IMGMap::processPoints(QList<IMG::Point> &points,
 			continue;
 
 		if (Style::isSpot(point.type))
-			convertUnits(point.label);
-		if (Style::isSummit(point.type) && !point.label.isEmpty()) {
-			QStringList list = point.label.split(" ");
-			convertUnits(list.last());
+			point.label.setText(convertUnits(point.label.text()));
+		if (Style::isSummit(point.type) && !point.label.text().isEmpty()) {
+			QStringList list = point.label.text().split(" ");
+			list.last() = convertUnits(list.last());
 			point.label = list.join(" ");
 		}
 
@@ -390,7 +498,7 @@ void IMGMap::draw(QPainter *painter, const QRectF &rect, Flags flags)
 		for (int j = 0; j < height; j++) {
 			QPixmap pm;
 			QPoint ttl(tl.x() + i * TILE_SIZE, tl.y() + j * TILE_SIZE);
-			QString key = _fileName + "-" + QString::number(_zoom) + "_"
+			QString key = _img.fileName() + "-" + QString::number(_zoom) + "_"
 			  + QString::number(ttl.x()) + "_" + QString::number(ttl.y());
 			if (QPixmapCache::find(key, pm))
 				painter->drawPixmap(ttl, pm);

src/map/imgmap.h

@@ -34,6 +34,9 @@ public:
 
 	void setProjection(const Projection &projection);
 
+	void load();
+	void unload();
+
 	bool isValid() const {return _valid;}
 	QString errorString() const {return _errorString;}
 
@@ -51,15 +54,12 @@ private:
 	  QList<TextItem*> &textItems);
 	void processPoints(QList<IMG::Point> &points, QList<TextItem*> &textItems);
 
-	QString _fileName;
 	IMG _img;
 	int _zoom;
 	Range _zooms;
 	Projection _projection;
 	Transform _transform;
 
-	QFont _largeFont, _normalFont, _smallFont, _poiFont;
-
 	bool _valid;
 	QString _errorString;
 };