315 lines
8 KiB
C++
315 lines
8 KiB
C++
|
|
|
|
#include "tw/stringtable.h"
|
|
// #include "tw/message.h"
|
|
//#include "tfilepath.h"
|
|
#include "tfilepath_io.h"
|
|
#include "tenv.h"
|
|
//#include "texception.h"
|
|
#include "tsystem.h"
|
|
#include "tstream.h"
|
|
#include "tconvert.h"
|
|
|
|
namespace {
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
class TStringTableImp : public TStringTable {
|
|
public:
|
|
bool m_initialized;
|
|
|
|
std::map<std::string, Item> m_table;
|
|
std::pair<std::string, int> m_defaultFontNameAndSize;
|
|
std::string m_defaultMacFontName;
|
|
|
|
TStringTableImp();
|
|
~TStringTableImp();
|
|
|
|
void init();
|
|
|
|
void load(const TFilePath &);
|
|
|
|
void loadCoded(const TFilePath &);
|
|
void saveCoded(const TFilePath &);
|
|
|
|
const Item *getItem(std::string name) const override;
|
|
std::pair<std::string, int> getDefaultFontNameAndSize() const override {
|
|
return m_defaultFontNameAndSize;
|
|
}
|
|
std::string getDefaultMacFontName() const override;
|
|
};
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
TStringTableImp::TStringTableImp()
|
|
: m_initialized(false)
|
|
, m_defaultFontNameAndSize("", 0)
|
|
, m_defaultMacFontName("") {}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
TStringTableImp::~TStringTableImp() {}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void TStringTableImp::init() {
|
|
if (m_initialized) return;
|
|
|
|
m_initialized = true;
|
|
|
|
TFilePath plainFp = TEnv::getConfigDir() + "current.txt";
|
|
|
|
try {
|
|
load(plainFp);
|
|
} catch (...) {
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
std::string TStringTableImp::getDefaultMacFontName() const {
|
|
return m_defaultMacFontName;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void writeShort(Tofstream &os, int x) {
|
|
os.put(x & 0xff);
|
|
os.put((x >> 8) & 0xff);
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
int readShort(Tifstream &is) {
|
|
char hi = 0, lo = 0;
|
|
is.get(lo);
|
|
is.get(hi);
|
|
return (unsigned char)hi << 8 | (unsigned char)lo;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void writeString(Tofstream &os, std::string s) {
|
|
int len = s.length();
|
|
writeShort(os, len);
|
|
os.write(s.c_str(), len);
|
|
if (len & 0x3) {
|
|
os.write("____", 4 - (len & 0x3));
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
std::string readString(Tifstream &is) {
|
|
int len = readShort(is);
|
|
int len2 = len;
|
|
if (len2 & 0x3) len2 += 4 - (len2 & 0x3);
|
|
char buffer[1204];
|
|
assert(len2 <= (int)(sizeof(buffer)));
|
|
is.read(buffer, len2);
|
|
return std::string(buffer, len);
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void writeStringW(Tofstream &os, std::wstring s) {
|
|
int len = s.length();
|
|
writeShort(os, len);
|
|
os.write(reinterpret_cast<const char *>(s.c_str()), sizeof(wchar_t) * len);
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
std::wstring readStringW(Tifstream &is) {
|
|
int len = readShort(is);
|
|
wchar_t buffer[1204];
|
|
assert(len <= (int)(sizeof(buffer)));
|
|
is.read(reinterpret_cast<char *>(buffer), sizeof(wchar_t) * len);
|
|
return std::wstring(buffer, len);
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
#ifdef MACOSX
|
|
class TMagic // singleton
|
|
{
|
|
public:
|
|
std::string m_magic;
|
|
|
|
private:
|
|
TMagic() : m_magic("stab.001") {}
|
|
|
|
public:
|
|
static TMagic *instance() {
|
|
static TMagic inst;
|
|
;
|
|
return &inst;
|
|
}
|
|
};
|
|
|
|
#else
|
|
const std::string magic = "stab.001";
|
|
#endif
|
|
|
|
void TStringTableImp::loadCoded(const TFilePath &fp) {
|
|
try {
|
|
Tifstream is(fp);
|
|
char buffer[1024];
|
|
|
|
#ifdef MACOSX
|
|
is.read(buffer, TMagic::instance()->m_magic.length());
|
|
#else
|
|
is.read(buffer, magic.length());
|
|
#endif
|
|
|
|
m_defaultFontNameAndSize.first = readString(is);
|
|
m_defaultFontNameAndSize.second = readShort(is);
|
|
int count = readShort(is);
|
|
for (int i = 0; i < count; i++) {
|
|
int m = readShort(is);
|
|
assert(1 <= m && m <= 3);
|
|
std::string id = readString(is);
|
|
Item &item = m_table[id];
|
|
item.m_name = readStringW(is);
|
|
if (m >= 2) {
|
|
item.m_help = readStringW(is);
|
|
if (m == 3) item.m_tip = readStringW(is);
|
|
}
|
|
}
|
|
int check = readShort(is);
|
|
assert(check == 12345);
|
|
// if(check != 12345)
|
|
// throw;
|
|
} catch (...) {
|
|
// TMessage::error("Error reading StringTable file: ", fp);
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
/*
|
|
void TStringTableImp::saveCoded(const TFilePath &fp)
|
|
{
|
|
try {
|
|
Tofstream os(fp);
|
|
|
|
#ifdef MACOSX
|
|
os.write(TMagic::instance()->m_magic.c_str(),
|
|
TMagic::instance()->m_magic.length());
|
|
#else
|
|
os.write(magic.c_str(), magic.length());
|
|
#endif
|
|
writeString(os, m_defaultFontNameAndSize.first);
|
|
writeShort(os, m_defaultFontNameAndSize.second);
|
|
writeShort(os, m_table.size());
|
|
for(std::map<std::string, Item>::iterator it = m_table.begin();
|
|
it != m_table.end(); ++it)
|
|
{
|
|
Item &item = it->second;
|
|
int m = 1;
|
|
if(item.m_tip != L"") m = 3;
|
|
else if(item.m_help != L"") m = 2;
|
|
writeShort(os, m);
|
|
writeString(os, it->first);
|
|
writeStringW(os, item.m_name);
|
|
if(m>=2)
|
|
{
|
|
writeStringW(os, item.m_help);
|
|
if(m==3)
|
|
writeStringW(os, item.m_tip);
|
|
}
|
|
}
|
|
writeShort(os, 12345);
|
|
} catch(...) {
|
|
TMessage::error("Unable to save StringTable file: ", fp);
|
|
}
|
|
}
|
|
*/
|
|
//-------------------------------------------------------------------
|
|
|
|
void TStringTableImp::load(const TFilePath &fp) {
|
|
if (!TFileStatus(fp).doesExist()) throw TException("file not found");
|
|
|
|
TIStream is(fp);
|
|
if (!is) throw TException("can't read string table ");
|
|
|
|
std::string tagName;
|
|
if (!is.matchTag(tagName) || tagName != "stringtable")
|
|
throw TException("not a string table file");
|
|
|
|
while (!is.matchEndTag()) {
|
|
if (!is.matchTag(tagName)) throw TException("expected tag");
|
|
if (tagName == "item") {
|
|
std::string id, name, help, tip;
|
|
is >> id >> name;
|
|
if (!is.matchEndTag()) {
|
|
is >> help;
|
|
if (!is.matchEndTag()) {
|
|
is >> tip;
|
|
if (!is.matchEndTag()) throw TException("Expected end tag");
|
|
}
|
|
}
|
|
Item &item = m_table[id];
|
|
item.m_name = ::to_wstring(name);
|
|
item.m_help = ::to_wstring(help);
|
|
item.m_tip = ::to_wstring(tip);
|
|
} else if (tagName == "defaultFont") {
|
|
std::string fontName;
|
|
int fontSize = 0;
|
|
is >> fontName >> fontSize;
|
|
if (!is.matchEndTag()) throw TException("Expected end tag");
|
|
m_defaultFontNameAndSize = std::make_pair(fontName, fontSize);
|
|
} else if (tagName == "defaultMacFont") {
|
|
std::string macFontName;
|
|
is >> macFontName;
|
|
if (!is.matchEndTag()) throw TException("Expected end tag");
|
|
m_defaultMacFontName = macFontName;
|
|
} else
|
|
throw TException("unexpected tag /" + tagName + "/");
|
|
}
|
|
// m_valid =true;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
const TStringTable::Item *TStringTableImp::getItem(std::string name) const {
|
|
std::map<std::string, Item>::const_iterator it;
|
|
it = m_table.find(name);
|
|
if (it == m_table.end())
|
|
return 0;
|
|
else
|
|
return &(it->second);
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
} // namespace
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
TStringTable::TStringTable() {}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
TStringTable::~TStringTable() {}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
std::wstring TStringTable::translate(std::string name) {
|
|
const TStringTable::Item *item = instance()->getItem(name);
|
|
if (item)
|
|
return item->m_name;
|
|
else
|
|
return ::to_wstring(name);
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
const TStringTable *TStringTable::instance() {
|
|
// may hurt MacOsX
|
|
static TStringTableImp *instance = 0;
|
|
if (!instance) instance = new TStringTableImp;
|
|
|
|
instance->init();
|
|
|
|
return instance;
|
|
}
|