mirror of
https://github.com/tumic0/GPXSee.git
synced 2024-11-24 03:35:53 +01:00
Code cleanup
This commit is contained in:
parent
80dbb99091
commit
1385482689
@ -113,6 +113,7 @@ HEADERS += src/common/config.h \
|
||||
src/GUI/timezoneinfo.h \
|
||||
src/GUI/passwordedit.h \
|
||||
src/data/twonavparser.h \
|
||||
src/map/IMG/section.h \
|
||||
src/map/proj/polyconic.h \
|
||||
src/map/proj/webmercator.h \
|
||||
src/map/proj/transversemercator.h \
|
||||
|
||||
@ -5,7 +5,7 @@ using namespace IMG;
|
||||
|
||||
bool HuffmanBuffer::load(const RGNFile *rgn, SubFile::Handle &rgnHdl)
|
||||
{
|
||||
quint32 recordSize, recordOffset = rgn->dictOffset();
|
||||
quint32 recordSize, recordOffset = rgn->dict().offset;
|
||||
|
||||
for (int i = 0; i <= _id; i++) {
|
||||
if (!rgn->seek(rgnHdl, recordOffset))
|
||||
@ -13,7 +13,7 @@ bool HuffmanBuffer::load(const RGNFile *rgn, SubFile::Handle &rgnHdl)
|
||||
if (!rgn->readVUInt32(rgnHdl, recordSize))
|
||||
return false;
|
||||
recordOffset = rgn->pos(rgnHdl) + recordSize;
|
||||
if (recordOffset > rgn->dictOffset() + rgn->dictSize())
|
||||
if (recordOffset > rgn->dict().offset + rgn->dict().size)
|
||||
return false;
|
||||
};
|
||||
|
||||
|
||||
@ -77,11 +77,11 @@ bool LBLFile::load(Handle &hdl, const RGNFile *rgn, Handle &rgnHdl)
|
||||
quint16 hdrLen, codepage;
|
||||
|
||||
if (!(seek(hdl, _gmpOffset) && readUInt16(hdl, hdrLen)
|
||||
&& seek(hdl, _gmpOffset + 0x15) && readUInt32(hdl, _offset)
|
||||
&& readUInt32(hdl, _size) && readByte(hdl, &_multiplier)
|
||||
&& seek(hdl, _gmpOffset + 0x15) && readUInt32(hdl, _base.offset)
|
||||
&& readUInt32(hdl, _base.size) && readByte(hdl, &_shift)
|
||||
&& readByte(hdl, &_encoding) && seek(hdl, _gmpOffset + 0x57)
|
||||
&& readUInt32(hdl, _poiOffset) && readUInt32(hdl, _poiSize)
|
||||
&& readByte(hdl, &_poiMultiplier) && seek(hdl, _gmpOffset + 0xAA)
|
||||
&& readUInt32(hdl, _poi.offset) && readUInt32(hdl, _poi.size)
|
||||
&& readByte(hdl, &_poiShift) && seek(hdl, _gmpOffset + 0xAA)
|
||||
&& readUInt16(hdl, codepage)))
|
||||
return false;
|
||||
|
||||
@ -107,8 +107,8 @@ bool LBLFile::load(Handle &hdl, const RGNFile *rgn, Handle &rgnHdl)
|
||||
quint32 offset, recordSize, size, flags;
|
||||
if (!(seek(hdl, _gmpOffset + 0x184) && readUInt32(hdl, offset)
|
||||
&& readUInt32(hdl, size) && readUInt16(hdl, recordSize)
|
||||
&& readUInt32(hdl, flags) && readUInt32(hdl, _imgOffset)
|
||||
&& readUInt32(hdl, _imgSize)))
|
||||
&& readUInt32(hdl, flags) && readUInt32(hdl, _img.offset)
|
||||
&& readUInt32(hdl, _img.size)))
|
||||
return false;
|
||||
|
||||
if (size && recordSize)
|
||||
@ -278,7 +278,7 @@ Label LBLFile::labelHuffman(Handle &hdl, const SubFile *file, Handle &fileHdl,
|
||||
for (int i = 0; i < str.size(); i++) {
|
||||
quint32 val = _table[str.at(i)];
|
||||
if (val) {
|
||||
quint32 off = _offset + ((val & 0x7fffff) << _multiplier);
|
||||
quint32 off = _base.offset + ((val & 0x7fffff) << _shift);
|
||||
if (!seek(hdl, off))
|
||||
return Label();
|
||||
|
||||
@ -287,7 +287,8 @@ Label LBLFile::labelHuffman(Handle &hdl, const SubFile *file, Handle &fileHdl,
|
||||
else if (str2.size())
|
||||
str2.append(' ');
|
||||
|
||||
if (!_huffmanText->decode(this, hdl, _offset + _size - off, str2))
|
||||
if (!_huffmanText->decode(this, hdl, _base.offset + _base.size - off,
|
||||
str2))
|
||||
return Label();
|
||||
} else {
|
||||
if (str.at(i) == 7) {
|
||||
@ -309,21 +310,21 @@ Label LBLFile::label(Handle &hdl, quint32 offset, bool poi, bool capitalize,
|
||||
quint32 labelOffset;
|
||||
if (poi) {
|
||||
quint32 poiOffset;
|
||||
if (!(_poiSize >= (offset << _poiMultiplier)
|
||||
&& seek(hdl, _poiOffset + (offset << _poiMultiplier))
|
||||
if (!(_poi.size >= (offset << _poiShift)
|
||||
&& seek(hdl, _poi.offset + (offset << _poiShift))
|
||||
&& readUInt24(hdl, poiOffset) && (poiOffset & 0x3FFFFF)))
|
||||
return Label();
|
||||
labelOffset = _offset + ((poiOffset & 0x3FFFFF) << _multiplier);
|
||||
labelOffset = _base.offset + ((poiOffset & 0x3FFFFF) << _shift);
|
||||
} else
|
||||
labelOffset = _offset + (offset << _multiplier);
|
||||
labelOffset = _base.offset + (offset << _shift);
|
||||
|
||||
if (labelOffset > _offset + _size)
|
||||
if (labelOffset > _base.offset + _base.size)
|
||||
return Label();
|
||||
if (!seek(hdl, labelOffset))
|
||||
return Label();
|
||||
|
||||
return label(hdl, this, hdl, _offset + _size - labelOffset, capitalize,
|
||||
convert);
|
||||
return label(hdl, this, hdl, _base.offset + _base.size - labelOffset,
|
||||
capitalize, convert);
|
||||
}
|
||||
|
||||
Label LBLFile::label(Handle &hdl, const SubFile *file, Handle &fileHdl,
|
||||
@ -348,7 +349,7 @@ bool LBLFile::loadRasterTable(Handle &hdl, quint32 offset, quint32 size,
|
||||
quint32 prev, cur;
|
||||
|
||||
_imgCount = size / recordSize;
|
||||
_imgOffsetIdSize = byteSize(_imgCount - 1);
|
||||
_imgIdSize = byteSize(_imgCount - 1);
|
||||
_rasters = new Image[_imgCount];
|
||||
|
||||
if (!(seek(hdl, offset) && readVUInt32(hdl, recordSize, prev)))
|
||||
@ -365,7 +366,7 @@ bool LBLFile::loadRasterTable(Handle &hdl, quint32 offset, quint32 size,
|
||||
}
|
||||
|
||||
_rasters[_imgCount-1].offset = prev;
|
||||
_rasters[_imgCount-1].size = _imgSize - prev;
|
||||
_rasters[_imgCount-1].size = _img.size - prev;
|
||||
|
||||
return true;
|
||||
}
|
||||
@ -377,7 +378,7 @@ QPixmap LBLFile::image(Handle &hdl, quint32 id) const
|
||||
if (id >= _imgCount)
|
||||
return pm;
|
||||
|
||||
if (!seek(hdl, _imgOffset + _rasters[id].offset))
|
||||
if (!seek(hdl, _img.offset + _rasters[id].offset))
|
||||
return pm;
|
||||
QByteArray ba;
|
||||
ba.resize(_rasters[id].size);
|
||||
|
||||
@ -3,6 +3,7 @@
|
||||
|
||||
#include <QPixmap>
|
||||
#include "common/textcodec.h"
|
||||
#include "section.h"
|
||||
#include "subfile.h"
|
||||
#include "label.h"
|
||||
|
||||
@ -15,17 +16,14 @@ class LBLFile : public SubFile
|
||||
{
|
||||
public:
|
||||
LBLFile(const IMGData *img)
|
||||
: SubFile(img), _huffmanText(0), _table(0), _rasters(0), _offset(0),
|
||||
_size(0), _poiOffset(0), _poiSize(0), _imgOffsetIdSize(0),
|
||||
_poiMultiplier(0), _multiplier(0), _encoding(0) {}
|
||||
: SubFile(img), _huffmanText(0), _table(0), _rasters(0), _imgIdSize(0),
|
||||
_poiShift(0), _shift(0), _encoding(0) {}
|
||||
LBLFile(const QString *path)
|
||||
: SubFile(path), _huffmanText(0), _table(0), _rasters(0), _offset(0),
|
||||
_size(0), _poiOffset(0), _poiSize(0), _imgOffsetIdSize(0),
|
||||
_poiMultiplier(0), _multiplier(0), _encoding(0) {}
|
||||
LBLFile(const SubFile *gmp, quint32 offset) : SubFile(gmp, offset),
|
||||
_huffmanText(0), _table(0), _rasters(0), _offset(0), _size(0),
|
||||
_poiOffset(0), _poiSize(0), _imgOffsetIdSize(0), _poiMultiplier(0),
|
||||
_multiplier(0), _encoding(0) {}
|
||||
: SubFile(path), _huffmanText(0), _table(0), _rasters(0), _imgIdSize(0),
|
||||
_poiShift(0), _shift(0), _encoding(0) {}
|
||||
LBLFile(const SubFile *gmp, quint32 offset)
|
||||
: SubFile(gmp, offset), _huffmanText(0), _table(0), _rasters(0),
|
||||
_imgIdSize(0), _poiShift(0), _shift(0), _encoding(0) {}
|
||||
~LBLFile();
|
||||
|
||||
bool load(Handle &hdl, const RGNFile *rgn, Handle &rgnHdl);
|
||||
@ -36,7 +34,7 @@ public:
|
||||
Label label(Handle &hdl, const SubFile *file, Handle &fileHdl,
|
||||
quint32 size, bool capitalize = true, bool convert = false) const;
|
||||
|
||||
quint8 imageIdSize() const {return _imgOffsetIdSize;}
|
||||
quint8 imageIdSize() const {return _imgIdSize;}
|
||||
QPixmap image(Handle &hdl, quint32 id) const;
|
||||
|
||||
private:
|
||||
@ -60,16 +58,11 @@ private:
|
||||
quint32 *_table;
|
||||
Image *_rasters;
|
||||
TextCodec _codec;
|
||||
quint32 _offset;
|
||||
quint32 _size;
|
||||
quint32 _poiOffset;
|
||||
quint32 _poiSize;
|
||||
quint32 _imgOffset;
|
||||
quint32 _imgSize;
|
||||
Section _base, _poi, _img;
|
||||
quint32 _imgCount;
|
||||
quint8 _imgOffsetIdSize;
|
||||
quint8 _poiMultiplier;
|
||||
quint8 _multiplier;
|
||||
quint8 _imgIdSize;
|
||||
quint8 _poiShift;
|
||||
quint8 _shift;
|
||||
quint8 _encoding;
|
||||
};
|
||||
|
||||
|
||||
@ -330,7 +330,7 @@ bool NETFile::linkLabel(Handle &hdl, quint32 offset,
|
||||
{
|
||||
if (!seek(hdl, offset))
|
||||
return false;
|
||||
BitStream1 bs(*this, hdl, _linksSize - (offset - _linksOffset));
|
||||
BitStream1 bs(*this, hdl, _links.size - (offset - _links.offset));
|
||||
|
||||
quint32 flags, labelPtr;
|
||||
if (!bs.read(8, flags))
|
||||
@ -351,20 +351,20 @@ bool NETFile::load(Handle &hdl, const RGNFile *rgn, Handle &rgnHdl)
|
||||
quint16 hdrLen;
|
||||
|
||||
if (!(seek(hdl, _gmpOffset) && readUInt16(hdl, hdrLen)
|
||||
&& seek(hdl, _gmpOffset + 0x15) && readUInt32(hdl, _offset)
|
||||
&& readUInt32(hdl, _size) && readByte(hdl, &_shift)))
|
||||
&& seek(hdl, _gmpOffset + 0x15) && readUInt32(hdl, _base.offset)
|
||||
&& readUInt32(hdl, _base.size) && readByte(hdl, &_netShift)))
|
||||
return false;
|
||||
|
||||
if (hdrLen >= 0x4C) {
|
||||
quint32 info;
|
||||
if (!(seek(hdl, _gmpOffset + 0x37) && readUInt32(hdl, info)))
|
||||
return false;
|
||||
if (!(seek(hdl, _gmpOffset + 0x43) && readUInt32(hdl, _linksOffset)
|
||||
&& readUInt32(hdl, _linksSize) && readByte(hdl, &_linksShift)))
|
||||
if (!(seek(hdl, _gmpOffset + 0x43) && readUInt32(hdl, _links.offset)
|
||||
&& readUInt32(hdl, _links.size) && readByte(hdl, &_linksShift)))
|
||||
return false;
|
||||
|
||||
quint8 tableId = ((info >> 2) & 0x0F);
|
||||
if (_linksSize && (!rgn->huffmanTable() || rgn->huffmanTable()->id()
|
||||
if (_links.size && (!rgn->huffmanTable() || rgn->huffmanTable()->id()
|
||||
!= tableId)) {
|
||||
_huffmanTable = new HuffmanTable(tableId);
|
||||
if (!_huffmanTable->load(rgn, rgnHdl))
|
||||
@ -401,12 +401,12 @@ bool NETFile::link(const SubDiv *subdiv, quint32 shift, Handle &hdl,
|
||||
if (!nod->linkInfo(nodHdl, blockInfo, linkId, linkInfo))
|
||||
return false;
|
||||
|
||||
quint32 linkOffset = _linksOffset + (linkInfo.linkOffset << _linksShift);
|
||||
if (linkOffset > _linksOffset + _linksSize)
|
||||
quint32 linkOffset = _links.offset + (linkInfo.linkOffset << _linksShift);
|
||||
if (linkOffset > _links.offset + _links.size)
|
||||
return false;
|
||||
if (!seek(hdl, linkOffset))
|
||||
return false;
|
||||
BitStream4R bs(*this, hdl, linkOffset - _linksOffset);
|
||||
BitStream4R bs(*this, hdl, linkOffset - _links.offset);
|
||||
QVector<quint16> ca;
|
||||
quint16 mask = 0;
|
||||
quint32 size;
|
||||
@ -484,7 +484,7 @@ bool NETFile::link(const SubDiv *subdiv, quint32 shift, Handle &hdl,
|
||||
|
||||
bool NETFile::lblOffset(Handle &hdl, quint32 netOffset, quint32 &lblOffset) const
|
||||
{
|
||||
if (!(seek(hdl, _offset + (netOffset << _shift))
|
||||
if (!(seek(hdl, _base.offset + (netOffset << _netShift))
|
||||
&& readUInt24(hdl, lblOffset)))
|
||||
return false;
|
||||
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
#ifndef IMG_NETFILE_H
|
||||
#define IMG_NETFILE_H
|
||||
|
||||
#include "section.h"
|
||||
#include "subfile.h"
|
||||
#include "nodfile.h"
|
||||
|
||||
@ -15,15 +16,13 @@ class BitStream4R;
|
||||
class NETFile : public SubFile
|
||||
{
|
||||
public:
|
||||
NETFile(const IMGData *img) : SubFile(img), _huffmanTable(0), _tp(0),
|
||||
_offset(0), _size(0), _linksOffset(0), _linksSize(0), _shift(0),
|
||||
NETFile(const IMGData *img)
|
||||
: SubFile(img), _huffmanTable(0), _tp(0), _netShift(0), _linksShift(0) {}
|
||||
NETFile(const QString *path)
|
||||
: SubFile(path), _huffmanTable(0), _tp(0), _netShift(0), _linksShift(0) {}
|
||||
NETFile(const SubFile *gmp, quint32 offset)
|
||||
: SubFile(gmp, offset), _huffmanTable(0), _tp(0), _netShift(0),
|
||||
_linksShift(0) {}
|
||||
NETFile(const QString *path) : SubFile(path), _huffmanTable(0), _tp(0),
|
||||
_offset(0), _size(0), _linksOffset(0), _linksSize(0), _shift(0),
|
||||
_linksShift(0) {}
|
||||
NETFile(const SubFile *gmp, quint32 offset) : SubFile(gmp, offset),
|
||||
_huffmanTable(0), _tp(0), _offset(0), _size(0), _linksOffset(0),
|
||||
_linksSize(0), _shift(0), _linksShift(0) {}
|
||||
~NETFile();
|
||||
|
||||
bool load(Handle &hdl, const RGNFile *rgn, Handle &rgnHdl);
|
||||
@ -34,7 +33,7 @@ public:
|
||||
const NODFile *nod, Handle &nodHdl2, Handle &nodHdl, const LBLFile *lbl,
|
||||
Handle &lblHdl, const NODFile::BlockInfo &blockInfo, quint8 linkId,
|
||||
quint8 lineId, QList<MapData::Poly> *lines) const;
|
||||
bool hasLinks() const {return (_linksSize > 0);}
|
||||
bool hasLinks() const {return (_links.size > 0);}
|
||||
|
||||
private:
|
||||
bool linkLabel(Handle &hdl, quint32 offset, const LBLFile *lbl,
|
||||
@ -47,8 +46,8 @@ private:
|
||||
|
||||
HuffmanTable *_huffmanTable;
|
||||
const HuffmanTable *_tp;
|
||||
quint32 _offset, _size, _linksOffset, _linksSize;
|
||||
quint8 _shift, _linksShift;
|
||||
Section _base, _links;
|
||||
quint8 _netShift, _linksShift;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
@ -96,15 +96,15 @@ bool NODFile::load(Handle &hdl)
|
||||
&& readByte(hdl, &_blockShift) && readByte(hdl, &_nodeShift)))
|
||||
return false;
|
||||
|
||||
if (!(seek(hdl, _gmpOffset + 0x67) && readUInt32(hdl, _blockOffset)
|
||||
&& readUInt32(hdl, _blockSize) && readUInt16(hdl, _blockRecordSize)
|
||||
&& readUInt32(hdl, _indexOffset) && readUInt32(hdl, _indexSize)
|
||||
if (!(seek(hdl, _gmpOffset + 0x67) && readUInt32(hdl, _block.offset)
|
||||
&& readUInt32(hdl, _block.size) && readUInt16(hdl, _blockRecordSize)
|
||||
&& readUInt32(hdl, _index.offset) && readUInt32(hdl, _index.size)
|
||||
&& readUInt16(hdl, _indexRecordSize) && readUInt32(hdl, _indexFlags)))
|
||||
return false;
|
||||
|
||||
if (!_indexRecordSize || _indexSize < _indexRecordSize)
|
||||
if (!_indexRecordSize || _index.size < _indexRecordSize)
|
||||
return false;
|
||||
quint32 indexCount = _indexSize / _indexRecordSize;
|
||||
quint32 indexCount = _index.size / _indexRecordSize;
|
||||
_indexIdSize = byteSize(indexCount - 1);
|
||||
}
|
||||
|
||||
@ -116,7 +116,7 @@ bool NODFile::readBlock(Handle &hdl, quint32 blockOffset,
|
||||
{
|
||||
blockInfo.offset = blockOffset;
|
||||
|
||||
return (seek(hdl, blockInfo.offset + _blockOffset)
|
||||
return (seek(hdl, blockInfo.offset + _block.offset)
|
||||
&& readUInt16(hdl, blockInfo.hdr.flags)
|
||||
&& readUInt32(hdl, blockInfo.hdr.nodeLonBase)
|
||||
&& readUInt32(hdl, blockInfo.hdr.nodeLatBase)
|
||||
@ -130,10 +130,10 @@ bool NODFile::readBlock(Handle &hdl, quint32 blockOffset,
|
||||
bool NODFile::blockInfo(Handle &hdl, quint32 blockId, BlockInfo &blockInfo) const
|
||||
{
|
||||
quint32 blockOffset;
|
||||
quint32 offset = _indexRecordSize * blockId + _indexOffset;
|
||||
quint32 offset = _indexRecordSize * blockId + _index.offset;
|
||||
quint32 offsetSize = (_indexFlags & 3) + 1;
|
||||
|
||||
if (offset > _indexOffset + _indexSize)
|
||||
if (offset > _index.offset + _index.size)
|
||||
return false;
|
||||
if (!(seek(hdl, offset) && readVUInt32(hdl, offsetSize, blockOffset)))
|
||||
return false;
|
||||
@ -147,19 +147,19 @@ bool NODFile::linkInfo(Handle &hdl, const BlockInfo &blockInfo, quint32 linkId,
|
||||
if (linkId >= blockInfo.hdr.linksCount)
|
||||
return false;
|
||||
|
||||
quint32 infoOffset = _blockOffset + blockInfo.offset + blockInfo.hdr.size()
|
||||
quint32 infoOffset = _block.offset + blockInfo.offset + blockInfo.hdr.size()
|
||||
+ ((blockInfo.hdr.linkInfoSize * linkId) >> 3);
|
||||
quint32 s1 = ((blockInfo.hdr.flags >> 2) & 0x1f) + 8;
|
||||
quint32 s2 = (blockInfo.hdr.flags >> 7) & 0xf;
|
||||
quint32 skip = (blockInfo.hdr.linkInfoSize * linkId) & 7;
|
||||
|
||||
if (infoOffset > _blockOffset + _blockSize || infoOffset < blockInfo.offset)
|
||||
if (infoOffset > _block.offset + _block.size || infoOffset < blockInfo.offset)
|
||||
return false;
|
||||
if (!seek(hdl, infoOffset))
|
||||
return false;
|
||||
|
||||
quint32 padding;
|
||||
BitStream1 bs(*this, hdl, _blockOffset + _blockSize - infoOffset);
|
||||
BitStream1 bs(*this, hdl, _block.offset + _block.size - infoOffset);
|
||||
if (!(bs.read(skip, padding) && bs.read(0xc, linkInfo.flags)))
|
||||
return false;
|
||||
|
||||
@ -183,13 +183,13 @@ bool NODFile::linkInfo(Handle &hdl, const BlockInfo &blockInfo, quint32 linkId,
|
||||
bool NODFile::nodeInfo(Handle &hdl, const BlockInfo &blockInfo,
|
||||
quint32 nodeOffset, NodeInfo &nodeInfo) const
|
||||
{
|
||||
quint32 infoOffset = (nodeOffset << _nodeShift) + _blockOffset;
|
||||
if (infoOffset > _blockOffset + _blockSize || infoOffset < blockInfo.offset)
|
||||
quint32 infoOffset = (nodeOffset << _nodeShift) + _block.offset;
|
||||
if (infoOffset > _block.offset + _block.size || infoOffset < blockInfo.offset)
|
||||
return false;
|
||||
if (!seek(hdl, infoOffset))
|
||||
return false;
|
||||
|
||||
BitStream1 bs(*this, hdl, _blockOffset + _blockSize - infoOffset);
|
||||
BitStream1 bs(*this, hdl, _block.offset + _block.size - infoOffset);
|
||||
|
||||
if (!bs.read(8, nodeInfo.flags))
|
||||
return false;
|
||||
@ -234,7 +234,7 @@ bool NODFile::nodeOffset(Handle &hdl, const BlockInfo &blockInfo,
|
||||
if (nodeId >= blockInfo.hdr.nodesCount)
|
||||
return false;
|
||||
|
||||
quint32 offset = _blockOffset + blockInfo.offset + blockInfo.hdr.size()
|
||||
quint32 offset = _block.offset + blockInfo.offset + blockInfo.hdr.size()
|
||||
+ bs(blockInfo.hdr.linksCount * blockInfo.hdr.linkInfoSize)
|
||||
+ nodeId * 3;
|
||||
|
||||
@ -245,12 +245,12 @@ bool NODFile::nodeBlock(Handle &hdl, quint32 nodeOffset,
|
||||
BlockInfo &blockInfo) const
|
||||
{
|
||||
int low = 0;
|
||||
int high = _indexSize / _indexRecordSize - 1;
|
||||
int high = _index.size / _indexRecordSize - 1;
|
||||
quint32 offsetSize = (_indexFlags & 3) + 1;
|
||||
|
||||
while (low <= high) {
|
||||
int m = ((low + high) / 2);
|
||||
quint32 offset = _indexRecordSize * m + _indexOffset;
|
||||
quint32 offset = _indexRecordSize * m + _index.offset;
|
||||
quint32 blockOffset, prevBlockOffset;
|
||||
|
||||
if (m > 0) {
|
||||
@ -282,11 +282,11 @@ bool NODFile::nodeBlock(Handle &hdl, quint32 nodeOffset,
|
||||
|
||||
bool NODFile::absAdjInfo(Handle &hdl, AdjacencyInfo &adj) const
|
||||
{
|
||||
quint32 infoOffset = (adj.nodeOffset << _nodeShift) + _blockOffset
|
||||
quint32 infoOffset = (adj.nodeOffset << _nodeShift) + _block.offset
|
||||
+ adj.nodeInfo.bytes;
|
||||
if (!seek(hdl, infoOffset))
|
||||
return false;
|
||||
BitStream1 bs(*this, hdl, _blockOffset + _blockSize - infoOffset);
|
||||
BitStream1 bs(*this, hdl, _block.offset + _block.size - infoOffset);
|
||||
|
||||
quint8 linkId = adj.blockInfo.hdr.linksCount;
|
||||
quint32 m2p = 2;
|
||||
@ -386,12 +386,12 @@ bool NODFile::absAdjInfo(Handle &hdl, AdjacencyInfo &adj) const
|
||||
|
||||
bool NODFile::relAdjInfo(Handle &hdl, AdjacencyInfo &adj) const
|
||||
{
|
||||
quint32 infoOffset = (adj.nodeOffset << _nodeShift) + _blockOffset
|
||||
quint32 infoOffset = (adj.nodeOffset << _nodeShift) + _block.offset
|
||||
+ adj.nodeInfo.bytes;
|
||||
if (!seek(hdl, infoOffset))
|
||||
return false;
|
||||
|
||||
BitStream1 bs(*this, hdl, _blockOffset + _blockSize - infoOffset);
|
||||
BitStream1 bs(*this, hdl, _block.offset + _block.size - infoOffset);
|
||||
|
||||
quint32 linkId = adj.blockInfo.hdr.linksCount;
|
||||
quint32 skip = 8;
|
||||
@ -485,8 +485,7 @@ int NODFile::nextNode(Handle &hdl, AdjacencyInfo &adjInfo) const
|
||||
if (adjInfo.nodeOffset == 0xFFFFFFFF)
|
||||
return 1;
|
||||
|
||||
if (!nodeInfo(hdl, adjInfo.blockInfo, adjInfo.nodeOffset,
|
||||
adjInfo.nodeInfo))
|
||||
if (!nodeInfo(hdl, adjInfo.blockInfo, adjInfo.nodeOffset, adjInfo.nodeInfo))
|
||||
return -1;
|
||||
if (!adjacencyInfo(hdl, adjInfo))
|
||||
return -1;
|
||||
@ -497,7 +496,7 @@ int NODFile::nextNode(Handle &hdl, AdjacencyInfo &adjInfo) const
|
||||
bool NODFile::linkType(Handle &hdl, const BlockInfo &blockInfo, quint8 linkId,
|
||||
quint32 &type) const
|
||||
{
|
||||
quint32 offset = _blockOffset + blockInfo.offset + blockInfo.hdr.size()
|
||||
quint32 offset = _block.offset + blockInfo.offset + blockInfo.hdr.size()
|
||||
+ bs(blockInfo.hdr.linksCount * blockInfo.hdr.linkInfoSize)
|
||||
+ blockInfo.hdr.nodesCount * 3;
|
||||
int low = 0;
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
#ifndef IMG_NODFILE_H
|
||||
#define IMG_NODFILE_H
|
||||
|
||||
#include "section.h"
|
||||
#include "subfile.h"
|
||||
|
||||
namespace IMG {
|
||||
@ -59,16 +60,15 @@ public:
|
||||
bool eog;
|
||||
};
|
||||
|
||||
NODFile(const IMGData *img) : SubFile(img), _indexOffset(0), _indexSize(0),
|
||||
_indexFlags(0), _blockOffset(0), _blockSize(0), _indexRecordSize(0),
|
||||
NODFile(const IMGData *img)
|
||||
: SubFile(img), _indexFlags(0), _indexRecordSize(0), _blockRecordSize(0),
|
||||
_blockShift(0), _nodeShift(0), _indexIdSize(0) {}
|
||||
NODFile(const QString *path)
|
||||
: SubFile(path), _indexFlags(0), _indexRecordSize(0), _blockRecordSize(0),
|
||||
_blockShift(0), _nodeShift(0), _indexIdSize(0) {}
|
||||
NODFile(const SubFile *gmp, quint32 offset)
|
||||
: SubFile(gmp, offset), _indexFlags(0), _indexRecordSize(0),
|
||||
_blockRecordSize(0), _blockShift(0), _nodeShift(0), _indexIdSize(0) {}
|
||||
NODFile(const QString *path) : SubFile(path), _indexOffset(0), _indexSize(0),
|
||||
_indexFlags(0), _blockOffset(0), _blockSize(0), _indexRecordSize(0),
|
||||
_blockRecordSize(0), _blockShift(0), _nodeShift(0), _indexIdSize(0) {}
|
||||
NODFile(const SubFile *gmp, quint32 offset) : SubFile(gmp, offset),
|
||||
_indexOffset(0), _indexSize(0), _indexFlags(0), _blockOffset(0),
|
||||
_blockSize(0), _indexRecordSize(0), _blockRecordSize(0), _blockShift(0),
|
||||
_nodeShift(0), _indexIdSize(0) {}
|
||||
|
||||
bool load(Handle &hdl);
|
||||
|
||||
@ -95,8 +95,8 @@ private:
|
||||
bool nodeBlock(Handle &hdl, quint32 nodeOffset, BlockInfo &blockInfo) const;
|
||||
bool readBlock(Handle &hdl, quint32 blockOffset, BlockInfo &blockInfo) const;
|
||||
|
||||
quint32 _flags, _indexOffset, _indexSize, _indexFlags, _blockOffset,
|
||||
_blockSize;
|
||||
Section _block, _index;
|
||||
quint32 _flags, _indexFlags;
|
||||
quint16 _indexRecordSize, _blockRecordSize;
|
||||
quint8 _blockShift, _nodeShift, _indexIdSize;
|
||||
};
|
||||
|
||||
@ -136,22 +136,22 @@ bool RGNFile::load(Handle &hdl)
|
||||
quint16 hdrLen;
|
||||
|
||||
if (!(seek(hdl, _gmpOffset) && readUInt16(hdl, hdrLen)
|
||||
&& seek(hdl, _gmpOffset + 0x15) && readUInt32(hdl, _offset)
|
||||
&& readUInt32(hdl, _size)))
|
||||
&& seek(hdl, _gmpOffset + 0x15) && readUInt32(hdl, _base.offset)
|
||||
&& readUInt32(hdl, _base.size)))
|
||||
return false;
|
||||
|
||||
if (hdrLen >= 0x68) {
|
||||
if (!(readUInt32(hdl, _polygonsOffset) && readUInt32(hdl, _polygonsSize)
|
||||
if (!(readUInt32(hdl, _polygons.offset) && readUInt32(hdl, _polygons.size)
|
||||
&& seek(hdl, _gmpOffset + 0x29) && readUInt32(hdl, _polygonsGblFlags)
|
||||
&& readUInt32(hdl, _polygonsLclFlags[0])
|
||||
&& readUInt32(hdl, _polygonsLclFlags[1])
|
||||
&& readUInt32(hdl, _polygonsLclFlags[2])
|
||||
&& readUInt32(hdl, _linesOffset) && readUInt32(hdl, _linesSize)
|
||||
&& readUInt32(hdl, _lines.offset) && readUInt32(hdl, _lines.size)
|
||||
&& seek(hdl, _gmpOffset + 0x45) && readUInt32(hdl, _linesGblFlags)
|
||||
&& readUInt32(hdl, _linesLclFlags[0])
|
||||
&& readUInt32(hdl, _linesLclFlags[1])
|
||||
&& readUInt32(hdl, _linesLclFlags[2])
|
||||
&& readUInt32(hdl, _pointsOffset) && readUInt32(hdl, _pointsSize)
|
||||
&& readUInt32(hdl, _points.offset) && readUInt32(hdl, _points.size)
|
||||
&& seek(hdl, _gmpOffset + 0x61) && readUInt32(hdl, _pointsGblFlags)
|
||||
&& readUInt32(hdl, _pointsLclFlags[0])
|
||||
&& readUInt32(hdl, _pointsLclFlags[1])
|
||||
@ -161,11 +161,11 @@ bool RGNFile::load(Handle &hdl)
|
||||
|
||||
if (hdrLen >= 0x7D) {
|
||||
quint32 info;
|
||||
if (!(seek(hdl, _gmpOffset + 0x71) && readUInt32(hdl, _dictOffset)
|
||||
&& readUInt32(hdl, _dictSize) && readUInt32(hdl, info)))
|
||||
if (!(seek(hdl, _gmpOffset + 0x71) && readUInt32(hdl, _dict.offset)
|
||||
&& readUInt32(hdl, _dict.size) && readUInt32(hdl, info)))
|
||||
return false;
|
||||
|
||||
if (_dictSize && _dictOffset && (info & 0x1E)) {
|
||||
if (_dict.size && _dict.offset && (info & 0x1E)) {
|
||||
_huffmanTable = new HuffmanTable(((info >> 1) & 0xF) - 1);
|
||||
if (!_huffmanTable->load(this, hdl))
|
||||
return false;
|
||||
@ -556,7 +556,7 @@ bool RGNFile::segments(Handle &hdl, SubDiv *subdiv, SubDiv::Segment seg[5]) cons
|
||||
if (subdiv->offset() == subdiv->end() || !(subdiv->objects() & 0x1F))
|
||||
return true;
|
||||
|
||||
quint32 offset = _offset + subdiv->offset();
|
||||
quint32 offset = _base.offset + subdiv->offset();
|
||||
if (!seek(hdl, offset))
|
||||
return false;
|
||||
|
||||
@ -585,7 +585,7 @@ bool RGNFile::segments(Handle &hdl, SubDiv *subdiv, SubDiv::Segment seg[5]) cons
|
||||
}
|
||||
|
||||
seg[lt] = SubDiv::Segment(ls,
|
||||
subdiv->end() ? _offset + subdiv->end() : _offset + _size);
|
||||
subdiv->end() ? _base.offset + subdiv->end() : _base.offset + _base.size);
|
||||
|
||||
return true;
|
||||
}
|
||||
@ -598,24 +598,24 @@ bool RGNFile::subdivInit(Handle &hdl, SubDiv *subdiv) const
|
||||
return false;
|
||||
|
||||
if (subdiv->extPointsOffset() != subdiv->extPointsEnd()) {
|
||||
quint32 start = _pointsOffset + subdiv->extPointsOffset();
|
||||
quint32 start = _points.offset + subdiv->extPointsOffset();
|
||||
quint32 end = subdiv->extPointsEnd()
|
||||
? _pointsOffset + subdiv->extPointsEnd()
|
||||
: _pointsOffset + _pointsSize;
|
||||
? _points.offset + subdiv->extPointsEnd()
|
||||
: _points.offset + _points.size;
|
||||
extPoints = SubDiv::Segment(start, end);
|
||||
}
|
||||
if (subdiv->extPolygonsOffset() != subdiv->extPolygonsEnd()) {
|
||||
quint32 start = _polygonsOffset + subdiv->extPolygonsOffset();
|
||||
quint32 start = _polygons.offset + subdiv->extPolygonsOffset();
|
||||
quint32 end = subdiv->extPolygonsEnd()
|
||||
? _polygonsOffset + subdiv->extPolygonsEnd()
|
||||
: _polygonsOffset + _polygonsSize;
|
||||
? _polygons.offset + subdiv->extPolygonsEnd()
|
||||
: _polygons.offset + _polygons.size;
|
||||
extPolygons = SubDiv::Segment(start, end);
|
||||
}
|
||||
if (subdiv->extLinesOffset() != subdiv->extLinesEnd()) {
|
||||
quint32 start = _linesOffset + subdiv->extLinesOffset();
|
||||
quint32 start = _lines.offset + subdiv->extLinesOffset();
|
||||
quint32 end = subdiv->extLinesEnd()
|
||||
? _linesOffset + subdiv->extLinesEnd()
|
||||
: _linesOffset + _linesSize;
|
||||
? _lines.offset + subdiv->extLinesEnd()
|
||||
: _lines.offset + _lines.size;
|
||||
extLines = SubDiv::Segment(start, end);
|
||||
}
|
||||
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
#ifndef IMG_RGNFILE_H
|
||||
#define IMG_RGNFILE_H
|
||||
|
||||
#include "section.h"
|
||||
#include "subfile.h"
|
||||
#include "subdiv.h"
|
||||
|
||||
@ -22,18 +23,10 @@ public:
|
||||
RoadReference
|
||||
};
|
||||
|
||||
RGNFile(const IMGData *img)
|
||||
: SubFile(img), _huffmanTable(0), _offset(0), _size(0), _polygonsOffset(0),
|
||||
_polygonsSize(0), _linesOffset(0), _linesSize(0), _pointsOffset(0),
|
||||
_pointsSize(0) {}
|
||||
RGNFile(const QString *path)
|
||||
: SubFile(path), _huffmanTable(0), _offset(0), _size(0), _polygonsOffset(0),
|
||||
_polygonsSize(0), _linesOffset(0), _linesSize(0), _pointsOffset(0),
|
||||
_pointsSize(0) {}
|
||||
RGNFile(const SubFile *gmp, quint32 offset) : SubFile(gmp, offset),
|
||||
_huffmanTable(0), _offset(0), _size(0), _polygonsOffset(0),
|
||||
_polygonsSize(0), _linesOffset(0), _linesSize(0), _pointsOffset(0),
|
||||
_pointsSize(0) {}
|
||||
RGNFile(const IMGData *img) : SubFile(img), _huffmanTable(0) {}
|
||||
RGNFile(const QString *path) : SubFile(path), _huffmanTable(0) {}
|
||||
RGNFile(const SubFile *gmp, quint32 offset)
|
||||
: SubFile(gmp, offset), _huffmanTable(0) {}
|
||||
~RGNFile();
|
||||
|
||||
void clear();
|
||||
@ -57,8 +50,7 @@ public:
|
||||
bool subdivInit(Handle &hdl, SubDiv *subdiv) const;
|
||||
|
||||
const HuffmanTable *huffmanTable() const {return _huffmanTable;}
|
||||
quint32 dictOffset() const {return _dictOffset;}
|
||||
quint32 dictSize() const {return _dictSize;}
|
||||
const Section &dict() const {return _dict;}
|
||||
|
||||
private:
|
||||
bool segments(Handle &hdl, SubDiv *subdiv, SubDiv::Segment seg[5]) const;
|
||||
@ -68,24 +60,9 @@ private:
|
||||
bool skipGblFields(Handle &hdl, quint32 flags) const;
|
||||
|
||||
HuffmanTable *_huffmanTable;
|
||||
|
||||
quint32 _offset;
|
||||
quint32 _size;
|
||||
quint32 _dictOffset;
|
||||
quint32 _dictSize;
|
||||
|
||||
quint32 _polygonsOffset;
|
||||
quint32 _polygonsSize;
|
||||
quint32 _polygonsLclFlags[3];
|
||||
quint32 _polygonsGblFlags;
|
||||
quint32 _linesOffset;
|
||||
quint32 _linesSize;
|
||||
quint32 _linesLclFlags[3];
|
||||
quint32 _linesGblFlags;
|
||||
quint32 _pointsOffset;
|
||||
quint32 _pointsSize;
|
||||
quint32 _pointsLclFlags[3];
|
||||
quint32 _pointsGblFlags;
|
||||
Section _base, _dict, _polygons, _lines, _points;
|
||||
quint32 _polygonsGblFlags, _linesGblFlags, _pointsGblFlags;
|
||||
quint32 _polygonsLclFlags[3], _linesLclFlags[3], _pointsLclFlags[3];
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
17
src/map/IMG/section.h
Normal file
17
src/map/IMG/section.h
Normal file
@ -0,0 +1,17 @@
|
||||
#ifndef SECTION_H
|
||||
#define SECTION_H
|
||||
|
||||
#include <QtGlobal>
|
||||
|
||||
namespace IMG {
|
||||
|
||||
struct Section {
|
||||
quint32 offset;
|
||||
quint32 size;
|
||||
|
||||
Section() : offset(0), size(0) {}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif // SECTION_H
|
||||
@ -52,8 +52,11 @@ TREFile::~TREFile()
|
||||
bool TREFile::init()
|
||||
{
|
||||
Handle hdl(this);
|
||||
quint8 locked;
|
||||
quint8 locked, levels[64];
|
||||
quint16 hdrLen;
|
||||
qint32 north, east, south, west;
|
||||
quint32 levelsCount;
|
||||
Section levelSec;
|
||||
|
||||
|
||||
if (!(seek(hdl, _gmpOffset) && readUInt16(hdl, hdrLen)
|
||||
@ -61,7 +64,6 @@ bool TREFile::init()
|
||||
return false;
|
||||
|
||||
// Tile bounds
|
||||
qint32 north, east, south, west;
|
||||
if (!(seek(hdl, _gmpOffset + 0x15) && readInt24(hdl, north)
|
||||
&& readInt24(hdl, east) && readInt24(hdl, south) && readInt24(hdl, west)))
|
||||
return false;
|
||||
@ -71,39 +73,35 @@ bool TREFile::init()
|
||||
return false;
|
||||
|
||||
// Levels & subdivs info
|
||||
quint32 levelsOffset, levelsSize, subdivSize;
|
||||
if (!(readUInt32(hdl, levelsOffset) && readUInt32(hdl, levelsSize)
|
||||
&& readUInt32(hdl, _subdivOffset) && readUInt32(hdl, subdivSize)))
|
||||
if (!(readUInt32(hdl, levelSec.offset) && readUInt32(hdl, levelSec.size)
|
||||
&& readUInt32(hdl, _subdivSec.offset) && readUInt32(hdl, _subdivSec.size)))
|
||||
return false;
|
||||
|
||||
if (hdrLen > 0x9A) {
|
||||
// Extended objects (TRE7) info
|
||||
if (!(seek(hdl, _gmpOffset + 0x7C) && readUInt32(hdl, _extended.offset)
|
||||
&& readUInt32(hdl, _extended.size)
|
||||
&& readUInt16(hdl, _extended.itemSize) && readUInt32(hdl, _flags)))
|
||||
if (hdrLen > 0x9A) {
|
||||
if (!(seek(hdl, _gmpOffset + 0x7C) && readUInt32(hdl, _extSec.offset)
|
||||
&& readUInt32(hdl, _extSec.size) && readUInt16(hdl, _extItemSize)
|
||||
&& readUInt32(hdl, _flags)))
|
||||
return false;
|
||||
} else {
|
||||
_extended.offset = 0;
|
||||
_extended.size = 0;
|
||||
_extended.itemSize = 0;
|
||||
_flags = 0;
|
||||
}
|
||||
|
||||
// Tile levels
|
||||
quint8 levels[64];
|
||||
if (levelsSize > 64 || !(seek(hdl, levelsOffset)
|
||||
&& read(hdl, (char*)levels, levelsSize)))
|
||||
if (levelSec.size > 64)
|
||||
return false;
|
||||
if (!(seek(hdl, levelSec.offset) && read(hdl, (char*)levels, levelSec.size)))
|
||||
return false;
|
||||
|
||||
if (locked) {
|
||||
quint32 key;
|
||||
if (hdrLen < 0xAE || !(seek(hdl, _gmpOffset + 0xAA)
|
||||
&& readUInt32(hdl, key)))
|
||||
|
||||
if (hdrLen < 0xAE)
|
||||
return false;
|
||||
demangle(levels, levelsSize, key);
|
||||
if (!(seek(hdl, _gmpOffset + 0xAA) && readUInt32(hdl, key)))
|
||||
return false;
|
||||
demangle(levels, levelSec.size, key);
|
||||
}
|
||||
|
||||
quint32 levelsCount = levelsSize / 4;
|
||||
levelsCount = levelSec.size / 4;
|
||||
_levels = QVector<MapLevel>(levelsCount);
|
||||
|
||||
for (quint32 i = 0; i < levelsCount; i++) {
|
||||
@ -166,14 +164,13 @@ bool TREFile::load(int idx)
|
||||
SubDivTree *tree = new SubDivTree();
|
||||
const MapLevel &level = _levels.at(idx);
|
||||
|
||||
|
||||
_subdivs.insert(level.bits, tree);
|
||||
|
||||
quint32 skip = 0;
|
||||
for (int i = 0; i < idx; i++)
|
||||
skip += _levels.at(i).subdivs;
|
||||
|
||||
if (!seek(hdl, _subdivOffset + skip * 16))
|
||||
if (!seek(hdl, _subdivSec.offset + skip * 16))
|
||||
return false;
|
||||
|
||||
for (int j = 0; j < level.subdivs; j++) {
|
||||
@ -229,16 +226,16 @@ bool TREFile::load(int idx)
|
||||
|
||||
|
||||
// Objects with extended types (TRE7)
|
||||
if (_extended.size && _extended.itemSize) {
|
||||
if (_extSec.size && _extItemSize) {
|
||||
quint32 totalSubdivs = 0;
|
||||
for (int i = 0; i < _levels.size(); i++)
|
||||
totalSubdivs += _levels.at(i).subdivs;
|
||||
quint32 extendedSubdivs = _extended.size / _extended.itemSize;
|
||||
quint32 extendedSubdivs = _extSec.size / _extItemSize;
|
||||
quint32 diff = totalSubdivs - extendedSubdivs + 1;
|
||||
if (skip < diff)
|
||||
return true;
|
||||
|
||||
if (!seek(hdl, _extended.offset + (skip - diff) * _extended.itemSize))
|
||||
if (!seek(hdl, _extSec.offset + (skip - diff) * _extItemSize))
|
||||
goto error;
|
||||
|
||||
quint32 polygons, lines, points;
|
||||
@ -251,7 +248,7 @@ bool TREFile::load(int idx)
|
||||
if (i)
|
||||
sl.at(i-1)->setExtEnds(polygons, lines, points);
|
||||
|
||||
if (!seek(hdl, pos(hdl) + _extended.itemSize - rb))
|
||||
if (!seek(hdl, pos(hdl) + _extItemSize - rb))
|
||||
goto error;
|
||||
}
|
||||
|
||||
@ -333,3 +330,13 @@ QList<SubDiv*> TREFile::subdivs(const RectC &rect, int bits, bool baseMap)
|
||||
|
||||
return list;
|
||||
}
|
||||
|
||||
#ifndef QT_NO_DEBUG
|
||||
QDebug IMG::operator<<(QDebug dbg, const TREFile::MapLevel &level)
|
||||
{
|
||||
dbg.nospace() << "MapLevel(" << level.level << "," << level.bits << ", "
|
||||
<< level.subdivs << ")";
|
||||
|
||||
return dbg.space();
|
||||
}
|
||||
#endif // QT_NO_DEBUG
|
||||
|
||||
@ -6,6 +6,7 @@
|
||||
#include <QRect>
|
||||
#include "common/rectc.h"
|
||||
#include "common/rtree.h"
|
||||
#include "section.h"
|
||||
#include "subfile.h"
|
||||
|
||||
namespace IMG {
|
||||
@ -15,9 +16,12 @@ class SubDiv;
|
||||
class TREFile : public SubFile
|
||||
{
|
||||
public:
|
||||
TREFile(const IMGData *img) : SubFile(img) {}
|
||||
TREFile(const QString *path) : SubFile(path) {}
|
||||
TREFile(const SubFile *gmp, quint32 offset) : SubFile(gmp, offset) {}
|
||||
TREFile(const IMGData *img)
|
||||
: SubFile(img), _flags(0), _extItemSize(0) {}
|
||||
TREFile(const QString *path)
|
||||
: SubFile(path), _flags(0), _extItemSize(0) {}
|
||||
TREFile(const SubFile *gmp, quint32 offset)
|
||||
: SubFile(gmp, offset), _flags(0), _extItemSize(0) {}
|
||||
~TREFile();
|
||||
|
||||
bool init();
|
||||
@ -37,15 +41,10 @@ private:
|
||||
quint8 bits;
|
||||
quint16 subdivs;
|
||||
};
|
||||
struct Extended {
|
||||
quint32 offset;
|
||||
quint32 size;
|
||||
quint16 itemSize;
|
||||
|
||||
Extended() : offset(0), size(0), itemSize(0) {}
|
||||
};
|
||||
typedef RTree<SubDiv*, double, 2> SubDivTree;
|
||||
|
||||
friend QDebug operator<<(QDebug dbg, const MapLevel &level);
|
||||
|
||||
bool load(int idx);
|
||||
int level(int bits, bool baseMap);
|
||||
int readExtEntry(Handle &hdl, quint32 &polygons, quint32 &lines,
|
||||
@ -53,15 +52,18 @@ private:
|
||||
|
||||
RectC _bounds;
|
||||
QVector<MapLevel> _levels;
|
||||
quint32 _subdivOffset;
|
||||
Extended _extended;
|
||||
int _firstLevel;
|
||||
Section _subdivSec, _extSec;
|
||||
quint32 _flags;
|
||||
quint16 _extItemSize;
|
||||
int _firstLevel;
|
||||
bool _isBaseMap;
|
||||
|
||||
QMap<int, SubDivTree*> _subdivs;
|
||||
};
|
||||
|
||||
#ifndef QT_NO_DEBUG
|
||||
QDebug operator<<(QDebug dbg, const TREFile::MapLevel &level);
|
||||
#endif // QT_NO_DEBUG
|
||||
}
|
||||
|
||||
#endif // IMG_TREFILE_H
|
||||
|
||||
Loading…
Reference in New Issue
Block a user