//////////////////////////////////////////////////// // Locks onto a specific client port (for session tracking) void EQPacket::lockOnClient(in_port_t serverPort, in_port_t clientPort) { m_serverPort = serverPort; m_clientPort = clientPort; if (!m_playbackPackets) { if (m_mac.length() == 17) { m_packetCapture->setFilter(m_device, m_mac, m_realtime, MAC_ADDRESS_TYPE, 0, m_clientPort); emit filterChanged(); seqInfo("EQPacket: SEQStart detected, pcap filter: EQ Client %s, Client port %d", (const char*)m_mac, m_clientPort); } else { m_packetCapture->setFilter(m_device, m_ip, m_realtime, IP_ADDRESS_TYPE, 0, m_clientPort); emit filterChanged(); seqInfo("EQPacket: SEQStart detected, pcap filter: EQ Client %s, Client port %d", (const char*)m_ip, m_clientPort); } } emit clientPortLatched(m_clientPort); }
void SpellShell::spellMessage(QString &str) { QString spell = str.right(str.length() - 7); // drop 'Spell: ' bool b = false; // Your xxx has worn off. // Your target resisted the xxx spell. // Your spell fizzles. seqInfo("*** spellMessage *** %s", spell.latin1()); if (spell.left(25) == QString("Your target resisted the ")) { spell = spell.right(spell.length() - 25); spell = spell.left(spell.length() - 7); seqInfo("RESIST: '%s'", spell.latin1()); b = true; } else if (spell.right(20) == QString(" spell has worn off.")) { spell = spell.right(spell.length() - 5); spell = spell.left(spell.length() - 20); seqInfo("WORE OFF: '%s'", spell.latin1()); b = true; } if (b) { // Can't really tell which spell/target, so just delete the last one for(QValueList<SpellItem*>::Iterator it = m_spellList.begin(); it != m_spellList.end(); it++) { if ((*it)->spellName() == spell) { (*it)->setDuration(0); break; } } } }
/////////////////////////////////////////// // Monitor for packets on the specified device void EQPacket::monitorDevice(const QString& dev) { // set the device to use m_device = dev; // make sure we aren't playing back packets if (m_playbackPackets != PLAYBACK_OFF) return; // stop the current packet capture m_packetCapture->stop(); // setup for capture on new device if (!m_ip.isEmpty()) { struct hostent *he; struct in_addr ia; /* Substitute "special" IP which is interpreted to set up a different filter for picking up new sessions */ if (m_ip == "auto") inet_aton (AUTOMATIC_CLIENT_IP, &ia); else if (inet_aton (m_ip, &ia) == 0) { he = gethostbyname(m_ip); if (!he) seqFatal("Invalid address; %s", (const char*)m_ip); memcpy (&ia, he->h_addr_list[0], he->h_length); } m_client_addr = ia.s_addr; m_ip = inet_ntoa(ia); if (m_ip == AUTOMATIC_CLIENT_IP) { m_detectingClient = true; seqInfo("Listening for first client seen."); } else { m_detectingClient = false; seqInfo("Listening for client: %s", (const char*)m_ip); } } resetEQPacket(); // restart packet capture if (m_mac.length() == 17) m_packetCapture->start(m_device, m_mac, m_realtime, MAC_ADDRESS_TYPE ); else m_packetCapture->start(m_device, m_ip, m_realtime, IP_ADDRESS_TYPE ); emit filterChanged(); }
void EQPacketTypeDB::list(void) const { seqInfo("EQPacketTypeDB contains %d types (in %d buckets)", m_typeSizeDict.count(), m_typeSizeDict.size()); QAsciiDictIterator<size_t> it(m_typeSizeDict); while (it.current()) { seqInfo("\t%s = %d", it.currentKey(), *(it.current())); ++it; } }
void EQPacketOPCodeDB::list(void) const { m_opcodes.statistics(); seqInfo("EQPacketOPCodeDB contains %d opcodes (in %d buckets)", m_opcodes.count(), m_opcodes.size()); EQPacketOPCode* current; EQPacketPayload* currentPayload; // iterate over all the opcodes QIntDictIterator<EQPacketOPCode> it(m_opcodes); while ((current = it.current()) != NULL) { fprintf(stderr, "\tkey=%04lx opcode=%04x", it.currentKey(), current->opcode()); if (!current->name().isNull()) fprintf(stderr, " name='%s'", current->name().latin1()); if (current->implicitLen()) fprintf(stderr, " implicitlen='%d'", current->implicitLen()); if (!current->updated().isNull()) fprintf(stderr, " updated='%s'", current->updated().latin1()); fputc('\n', stderr); QStringList comments = current->comments(); fprintf(stderr, "\t\t%d comment(s)\n", comments.count()); for (QStringList::Iterator cit = comments.begin(); cit != comments.end(); ++cit) fprintf(stderr, "\t\t\t'%s'\n", (*cit).latin1()); fprintf(stderr, "\t\t%d payload(s)\n", current->count()); QPtrListIterator<EQPacketPayload> pit(*current); while ((currentPayload = pit.current()) != 0) { seqInfo("\t\t\tdir=%d typename=%s size=%d sizechecktype=%d", currentPayload->dir(), (const char*)currentPayload->typeName(), currentPayload->typeSize(), currentPayload->sizeCheckType()); ++pit; } ++it; } }
void GuildMgr::readGuildList() { QFile guildsfile(guildsFileName); m_guildMap.clear(); if (guildsfile.open(IO_ReadOnly)) { worldGuildListStruct tmp; if (guildsfile.size() != sizeof(tmp.guilds)) { seqWarn("GuildMgr: Guildsfile not loaded, expected size %d got %ld", sizeof(worldGuildListStruct), guildsfile.size()); return; } struct guildListStruct gl; while (!guildsfile.atEnd()) { guildsfile.readBlock(reinterpret_cast<char*>(&gl), sizeof(gl)); // Commented out until verified that this needs to actually be // removed. -- Ratt // if (strlen(gl.guildName) > 0) m_guildMap.push_back(QString::fromUtf8(gl.guildName)); } guildsfile.close(); seqInfo("GuildMgr: Guildsfile loaded"); } else seqWarn("GuildMgr: Could not load guildsfile, %s", (const char*)guildsFileName); }
std::vector<READ> vecStrToReadObjs(const VecStr & strs, const std::string & stubName){ std::vector<READ> ans; for(const auto & strPos : iter::range(strs.size())){ ans.emplace_back(READ(seqInfo(stubName + "." + leftPadNumStr(strPos, strs.size()), strs[strPos]))); } return ans; }
void SpellShell::timeout() { SpellItem* spell; QValueList<SpellItem*>::Iterator it = m_spellList.begin(); while (it != m_spellList.end()) { spell = *it; int d = spell->duration() - pSEQPrefs->getPrefInt("SpellTimer", "SpellList", 6); if (d > -6) { spell->setDuration(d); emit changeSpell(spell); it++; } else { seqInfo("SpellItem '%s' finished.", (*it)->spellName().latin1()); if (m_lastPlayerSpell == spell) m_lastPlayerSpell = 0; emit delSpell(spell); it = m_spellList.remove(it); delete spell; } } if (m_spellList.count() == 0) m_timer->stop(); }
void ZoneMgr::restoreZoneState(void) { QString fileName = showeq_params->saveRestoreBaseFilename + "Zone.dat"; QFile keyFile(fileName); if (keyFile.open(IO_ReadOnly)) { QDataStream d(&keyFile); // check the magic string uint32_t magicTest; d >> magicTest; if (magicTest != *magic) { seqWarn("Failure loading %s: Bad magic string!", (const char*)fileName); return; } d >> m_longZoneName; d >> m_shortZoneName; seqInfo("Restored Zone: %s (%s)!", (const char*)m_shortZoneName, (const char*)m_longZoneName); }
//////////////////////////////////////////////////// // Handle zone2client stream closing void EQPacket::closeStream(uint32_t sessionId, EQStreamID streamId) { // If this is the zone server session closing, reset the pcap filter to // a non-exclusive form if ((streamId == zone2client || streamId == client2zone) && (m_playbackPackets == PLAYBACK_OFF || m_playbackPackets == PLAYBACK_FORMAT_TCPDUMP)) { m_packetCapture->setFilter(m_device, m_ip, m_realtime, IP_ADDRESS_TYPE, 0, 0); emit filterChanged(); } // Pass the close onto the streams m_client2WorldStream->close(sessionId, streamId, m_session_tracking); m_world2ClientStream->close(sessionId, streamId, m_session_tracking); m_client2ZoneStream->close(sessionId, streamId, m_session_tracking); m_zone2ClientStream->close(sessionId, streamId, m_session_tracking); // If we just closed the zone server session, unlatch the client port if (streamId == zone2client || streamId == client2zone) { m_clientPort = 0; m_serverPort = 0; emit clientPortLatched(m_clientPort); seqInfo("EQPacket: SessionDisconnect detected, awaiting next zone session, pcap filter: EQ Client %s", (const char*)m_ip); } }
void SpawnListWindow3::doubleClicked(const QModelIndex& index) { const Item* item = m_spawnModel->item(index); if (item != NULL) { seqInfo("%s", (const char*)m_spawnModel->filterString(item)); } }
void GuildMgr::listGuildInfo() { for (unsigned int i = 0; i < m_guildMap.size(); i++) { if (m_guildMap[i]) seqInfo("%d\t%s", i, (const char*)m_guildMap[i]); } }
void Filters::list(void) const { FilterMap::const_iterator it; seqInfo("Filters from file '%s':", (const char*)m_file); // iterate over the filters for (it = m_filters.begin(); it != m_filters.end(); it++) { // print the header seqInfo("Filter Type '%s':", (const char*)m_types.name(it->first)); // list off the actual filters it->second->listFilters(); } }
static std::vector<readObject> createCondensedObjects(std::vector<T> reads) { std::vector<readObject> ans; readVec::allSetCondensedSeq(reads); for (const auto& read : reads) { ans.emplace_back(readObject(seqInfo(read.seqBase_.name_, read.condensedSeq, read.condensedSeqQual))); } return ans; }
void Filter::listFilters(void) { FilterItem *re; #ifdef DEBUG_FILTER // seqDebug("Filter::listFilters"); #endif FilterListIterator it(m_filterItems); for (re = it.toFirst(); re != NULL; re = ++it) { if (re->minLevel() || re->maxLevel()) seqInfo("\t'%s' (%d, %d)", (const char*)re->name().utf8(), re->minLevel(), re->maxLevel()); else seqInfo("\t'%s'", (const char*)re->name().utf8()); } }
//////////////////////////////////////////////////// // Locks onto a specific client port (for session tracking) void EQPacket::lockOnClient(in_port_t serverPort, in_port_t clientPort) { m_serverPort = serverPort; m_clientPort = clientPort; if (m_playbackPackets == PLAYBACK_OFF || m_playbackPackets == PLAYBACK_FORMAT_TCPDUMP) { if (m_mac.length() == 17) { m_packetCapture->setFilter(m_device, m_mac, m_realtime, MAC_ADDRESS_TYPE, 0, m_clientPort); emit filterChanged(); } else { m_packetCapture->setFilter(m_device, m_ip, m_realtime, IP_ADDRESS_TYPE, 0, m_clientPort); emit filterChanged(); } } // Wanted this message even if we're running on playback... if (m_mac.length() == 17) { seqInfo("EQPacket: SessionRequest detected, pcap filter: EQ Client %s, Client port %d. Server port %d", (const char*)m_mac, m_clientPort, m_serverPort); } else { seqInfo("EQPacket: SessionRequest detected, pcap filter: EQ Client %s, Client port %d. Server port %d", (const char*)m_ip, m_clientPort, m_serverPort); } emit clientPortLatched(m_clientPort); }
std::vector<baseReadObject> alignToSeq(const std::vector<READ>& reads, const REF& reference, aligner& alignObj, bool local, bool usingQuality) { std::vector<baseReadObject> output; output.emplace_back(baseReadObject(reference)); for (const auto& read : reads) { alignObj.alignCache(reference, read, local); output.emplace_back(baseReadObject(seqInfo( read.seqBase_.name_ + "_score:" + std::to_string(alignObj.parts_.score_), alignObj.alignObjectB_.seqBase_.seq_, alignObj.alignObjectB_.seqBase_.qual_))); } return output; }
void ExperienceWindow::calculateZEM(long xp_gained, int mob_level) { float gbonus=1.00; int penalty; int myLevel = m_player->level(); int group_ag; gbonus = m_group->groupBonus(); group_ag = m_group->totalLevels(); if (m_group->groupSize()) { seqInfo("MY Level: %d GroupTot: %d BONUS :%d", myLevel, group_ag, gbonus * 100); } // WAR and ROG are at 10 since thier EXP is not scaled to compensate // for thier bonus switch (m_player->classVal()) { case 1 : penalty = 10; break; // WAR case 2 : penalty = 10; break; // CLR case 3 : penalty = 14; break; // PAL case 4 : penalty = 14; break; // RNG case 5 : penalty = 14; break; // SHD case 6 : penalty = 10; break; // DRU case 7 : penalty = 12; break; // MNK case 8 : penalty = 14; break; // BRD case 9 : penalty = 10; break; // ROG case 10: penalty = 10; break; // SHM case 11: penalty = 11; break; // NEC case 12: penalty = 11; break; // MAG case 13: penalty = 11; break; // ENC default: /* why are we here? */ penalty = 10; break; } unsigned char ZEM = (unsigned char) ((float)xp_gained*((float)((float)group_ag/(float)myLevel)*(float)((float)1.0/(float)gbonus))*((float)1/(float)(mob_level*mob_level))*((float)10/(float)penalty)); seqInfo("xpgained: %ld group_ag: %d myLevel: %d gbonus: %d mob_level: %d penalty: %d ", xp_gained, group_ag, myLevel, gbonus, mob_level, penalty); seqInfo("ZEM - ZEM - ZEM ===== %d ", ZEM); }
/////////////////////////////////////////////////////////////// // Process a session disconnect if it is for us void EQPacketStream::close(uint32_t sessionId, EQStreamID /*streamId*/, uint8_t sessionTracking) { if (sessionId == m_sessionId) { // Close is for us reset(); setSessionTracking(sessionTracking); #ifdef PACKET_SESSION_DIAG seqInfo("EQPacket: SessionDisconnected received on stream %s (%d). Closing session %u on stream %s (%d).", EQStreamStr[streamId], streamId, sessionId, EQStreamStr[m_streamid], m_streamid); #endif } }
//////////////////////////////////////////////////// // Handle zone2client stream closing void EQPacket::closeStream() { // reseting the pcap filter to a non-exclusive form allows us to beat // the race condition between timer and processing the zoneServerInfo if(!m_playbackPackets) { m_packetCapture->setFilter(m_device, m_ip, m_realtime, IP_ADDRESS_TYPE, 0, 0); emit filterChanged(); } seqInfo("EQPacket: SEQClosing detected, awaiting next zone session, pcap filter: EQ Client %s", (const char*)m_ip); // we'll be waiting for a new SEQStart for ALL streams // it seems we only ever see a proper closing sequence from the zone server // so reset all packet sequence caches resetEQPacket(); }
/////////////////////////////////////////// // Set the IP address of the client to monitor void EQPacket::monitorIPClient(const QString& ip) { m_ip = ip; struct in_addr ia; inet_aton (m_ip, &ia); m_client_addr = ia.s_addr; emit clientChanged(m_client_addr); resetEQPacket(); seqInfo("Listening for IP client: %s", (const char*)m_ip); if (!m_playbackPackets) { m_packetCapture->setFilter(m_device, m_ip, m_realtime, IP_ADDRESS_TYPE, 0, 0); emit filterChanged(); } }
void CategoryMgr::reloadCategories(void) { clearCategories(); m_changed = false; QString section = "CategoryMgr"; int i = 0; QString prefBaseName; QString tempStr; for(i = 1; i <= tMaxNumCategories; i++) { prefBaseName.sprintf("Category%d_", i); // attempt to pull a button title from the preferences tempStr = prefBaseName + "Name"; if (pSEQPrefs->isPreference(tempStr, section)) { QString name = pSEQPrefs->getPrefString(tempStr, section); QString filter = pSEQPrefs->getPrefString(prefBaseName + "Filter", section); QColor color = pSEQPrefs->getPrefColor(prefBaseName + "Color", section, QColor("black")); tempStr = prefBaseName + "FilterOut"; QString filterout; if (pSEQPrefs->isPreference(tempStr, section)) filterout = pSEQPrefs->getPrefString(tempStr, section); //seqDebug("%d: Got '%s' '%s' '%s'", i, name, filter, color); if (!name.isEmpty() && !filter.isEmpty()) { Category* newcat = new Category(name, filter, filterout, color); m_categories.append(newcat); } } } // signal that the categories have been loaded emit loadedCategories(); seqInfo("Categories Reloaded"); }
/////////////////////////////////////////// // Monitor the next client seen void EQPacket::monitorNextClient() { m_detectingClient = true; m_ip = AUTOMATIC_CLIENT_IP; struct in_addr ia; inet_aton (m_ip, &ia); m_client_addr = ia.s_addr; emit clientChanged(m_client_addr); resetEQPacket(); seqInfo("Listening for next client seen. (you must zone for this to work!)"); if (!m_playbackPackets) { m_packetCapture->setFilter(m_device, NULL, m_realtime, DEFAULT_ADDRESS_TYPE, 0, 0); emit filterChanged(); } }
/////////////////////////////////////////// // Set the MAC address of the client to monitor void EQPacket::monitorMACClient(const QString& mac) { m_mac = mac; m_detectingClient = true; struct in_addr ia; inet_aton (AUTOMATIC_CLIENT_IP, &ia); m_client_addr = ia.s_addr; emit clientChanged(m_client_addr); resetEQPacket(); seqInfo("Listening for MAC client: %s", (const char*)m_mac); if (!m_playbackPackets) { m_packetCapture->setFilter(m_device, m_ip, m_realtime, IP_ADDRESS_TYPE, 0, 0); emit filterChanged(); } }
void GuildMgr::readGuildList() { QFile guildsfile(guildsFileName); m_guildMap.clear(); if (guildsfile.open(QIODevice::ReadOnly)) { while (!guildsfile.atEnd()) { char szGuildName[64] = {0}; guildsfile.readBlock(szGuildName, sizeof(szGuildName)); // seqDebug("GuildMgr::readGuildList - read guild '%s'", szGuildName); m_guildMap.push_back(QString::fromUtf8(szGuildName)); } guildsfile.close(); seqInfo("GuildMgr: Guildsfile loaded"); } else seqWarn("GuildMgr: Could not load guildsfile, %s", (const char*)guildsFileName); }
void GuildMgr::writeGuildList(const worldGuildListStruct* gls, size_t len) { QFile guildsfile(guildsFileName); if (guildsfile.exists()) { if (!guildsfile.remove()) { seqWarn("GuildMgr: Could not remove old %s, unable to replace with server data!" , guildsFileName.latin1()); return; } } if(!guildsfile.open(IO_WriteOnly)) seqWarn("GuildMgr: Could not open %s for writing, unable to replace with server data!", guildsFileName.latin1()); QDataStream guildDataStream(&guildsfile); guildDataStream.writeRawBytes((char *)gls->guilds, sizeof(gls->guilds)); guildsfile.close(); seqInfo("GuildMgr: New guildsfile written"); }
void SpawnShell::newSpawn(const spawnStruct& s) { #ifdef SPAWNSHELL_DIAG seqDebug("SpawnShell::newSpawn(spawnStruct *(name='%s'))", s.name); #endif // if this is the SPAWN_SELF it's the player if (s.NPC == SPAWN_SELF) return; // not the player, so check if it's a recently deleted spawn for (int i =0; i < m_cntDeadSpawnIDs; i++) { if ((m_deadSpawnID[i] != 0) && (m_deadSpawnID[i] == s.spawnId)) { // found a match, remove it from the deleted spawn list m_deadSpawnID[i] = 0; // let the user know what's going on seqInfo("%s(%d) has already been removed from the zone before we processed it.", s.name, s.spawnId); // and stop the attempt to add the spawn. return; } } Item* item = m_spawns.find(s.spawnId); if (item != NULL) { Spawn* spawn = (Spawn*)item; spawn->update(&s); updateFilterFlags(spawn); updateRuntimeFilterFlags(spawn); item->updateLastChanged(); if (spawn->guildID() < MAX_GUILDS) spawn->setGuildTag(m_guildMgr->guildIdToName(spawn->guildID())); else spawn->setGuildTag(""); if (!showeq_params->fast_machine) item->setDistanceToPlayer(m_player->calcDist2DInt(*item)); else item->setDistanceToPlayer(m_player->calcDist(*item)); emit changeItem(item, tSpawnChangedALL); } else { item = new Spawn(&s); Spawn* spawn = (Spawn*)item; updateFilterFlags(spawn); updateRuntimeFilterFlags(spawn); m_spawns.insert(s.spawnId, item); if (spawn->guildID() < MAX_GUILDS) spawn->setGuildTag(m_guildMgr->guildIdToName(spawn->guildID())); else spawn->setGuildTag(""); if (!showeq_params->fast_machine) item->setDistanceToPlayer(m_player->calcDist2DInt(*item)); else item->setDistanceToPlayer(m_player->calcDist(*item)); emit addItem(item); // send notification of new spawn count emit numSpawns(m_spawns.count()); } }
void SpawnMonitor::loadSpawnPoints() { QString fileName; fileName = m_zoneName + ".sp"; QFileInfo fileInfo = m_dataLocMgr->findExistingFile("spawnpoints", fileName, false); if (!fileInfo.exists()) { seqWarn("Can't find spawn point file %s", (const char*)fileInfo.absFilePath()); return; } fileName = fileInfo.absFilePath(); QFile spFile(fileName); if (!spFile.open(IO_ReadOnly)) { seqWarn( "Can't open spawn point file %s", (const char*)fileName ); return; } QTextStream input( &spFile ); int16_t x, y, z; unsigned long diffTime; uint32_t count; QString name; while (!input.atEnd()) { input >> x; input >> y; input >> z; input >> diffTime; input >> count; name = input.readLine(); name = name.stripWhiteSpace(); EQPoint loc(x, y, z); SpawnPoint* p = new SpawnPoint( 0, loc, name, diffTime, count ); if (p) { QString key = p->key(); if (!m_points.find(key)) { m_points.insert(key, p); emit newSpawnPoint(p); } else { seqWarn("Warning: spawn point key already in use!"); delete p; } } } seqInfo("Loaded spawn points: %s", (const char*)fileName); m_modified = false; }
void SpawnMonitor::saveSpawnPoints() { // only save if modified if (!m_modified) return; if ( !m_zoneName.length() ) { seqWarn("Zone name not set in 'SpawnMonitor::saveSpawnPoints'!" ); return; } QString fileName; fileName = m_zoneName + ".sp"; QFileInfo fileInfo = m_dataLocMgr->findWriteFile("spawnpoints", fileName, false); fileName = fileInfo.absFilePath(); QString newName = fileName + ".new"; QFile spFile( newName ); if (!spFile.open(IO_WriteOnly)) { seqWarn("Failed to open %s for writing", (const char*)newName); return; } QTextStream output(&spFile); QAsciiDictIterator<SpawnPoint> it( m_points ); SpawnPoint* sp; while ((sp = it.current())) { ++it; output << sp->x() << " " << sp->y() << " " << sp->z() << " " << (unsigned long)sp->diffTime() << " " << sp->count() << " " << sp->name() << '\n'; } spFile.close(); QFileInfo fi( spFile ); QFile old( fileName ); QDir dir( fi.dir() ); QString backupName = fileName + ".bak"; if (old.exists()) { if (dir.rename( fileName, backupName)) { if (!dir.rename( newName, fileName)) seqWarn( "Failed to rename %s to %s", (const char*)newName, (const char*)fileName); } } else { if (!dir.rename(newName, fileName)) seqWarn("Failed to rename %s to %s", (const char*)newName, (const char*)fileName); } m_modified = false; seqInfo("Saved spawn points: %s", (const char*)fileName); }
bool EQStr::load(const QString& fileName) { // clear out any existing contents m_messageStrings.clear(); // create a QFile on the file QFile formatFile(fileName); // open the file read only if (!formatFile.open(IO_ReadOnly)) { seqWarn("EQStr: Failed to open '%s'", fileName.latin1()); return false; } // allocate a QCString large enough to hold the entire file QCString textData(formatFile.size() + 1); // read in the entire file formatFile.readBlock(textData.data(), textData.size()); // construct a regex to deal with either style line termination QRegExp lineTerm("[\r\n]{1,2}"); // split the data into lines at the line termination QStringList lines = QStringList::split(lineTerm, QString::fromUtf8(textData), false); // start iterating over the lines QStringList::Iterator it = lines.begin(); // first is the magic id string QString magicString = (*it++); int spc; uint32_t formatId; QString formatString; uint32_t maxFormatId = 0; // next skip over the count, etc... it++; // now iterate over the format lines for (; it != lines.end(); ++it) { // find the beginning space spc = (*it).find(' '); // convert the beginnign of the string to a ULong formatId = (*it).left(spc).toULong(); if (formatId > maxFormatId) maxFormatId = formatId; // insert the format string into the dictionary. m_messageStrings.insert(formatId, new QString((*it).mid(spc+1))); } // note that strings are loaded m_loaded = true; seqInfo("Loaded %d message strings from '%s' maxFormat=%d", m_messageStrings.count(), fileName.latin1(), maxFormatId); return true; }