示例#1
0
    QVariant data(const QModelIndex &index, int role) const
    {
        if (!index.isValid())
            return QVariant();

        if (role == Qt::DisplayRole || role == Qt::EditRole)
        {
            int i = alive[index.row()];
            QueuedPlayerMoves::const_iterator mi;
            std::map<int, Game::CharacterState>::const_iterator mi2;
            switch (index.column())
            {
                case Name:
                {
                    // TODO: for sorting return the index as number
                    Game::CharacterID chid(player, i);
                    QString ret = QString::fromStdString(chid.ToString());
                    if (role == Qt::DisplayRole)
                    {
                        if (i == 0)
                            ret = QString::fromUtf8("\u2605") + ret;
                        if (crownHolder == chid)
                            ret += QString::fromUtf8(" \u265B");
                    }
                    return ret;
                }
                case Coins:
                    mi2 = state.characters.find(i);
                    if (mi2 != state.characters.end())
                        return QString::fromStdString(FormatMoney(mi2->second.loot.nAmount));    // TODO: for sorting return as float value
                    return QVariant();
                case Status:
                    if (pending)
                        return tr("Pending");
                    mi = queuedMoves.find(i);
                    if (mi != queuedMoves.end())
                    {
                        if (mi->second.destruct)
                            return tr("Destruct");
                        else
                            return tr("Queued");
                    }
                    else
                    {
                        mi2 = state.characters.find(i);
                        if (mi2 != state.characters.end() && mi2->second.waypoints.empty())
                            return tr("Ready");
                        else
                            return tr("Moving");
                    }
            }
        }
        else if (role == Qt::TextAlignmentRole)
            return QVariant(int(Qt::AlignLeft|Qt::AlignVCenter));

        return QVariant();
    }
void eCableScan::parseSDT()
{
	unsigned long hash = 0;
	ePtr<iDVBChannelList> db;
	ePtr<eDVBResourceManager> res;

	if (m_SDT->getSections().empty()) return;

	eDVBResourceManager::getInstance(res);
	res->getChannelList(db);

	currentScanChannel->getHash(hash);
	eDVBNamespace dvbnamespace(hash & ~0xFFFF);

	eDVBChannelID chid(dvbnamespace, (**m_SDT->getSections().begin()).getTransportStreamId(), (**m_SDT->getSections().begin()).getOriginalNetworkId());

	db->addChannelToList(chid, currentScanChannel);

	std::vector<ServiceDescriptionSection*>::const_iterator i;
	for (i = m_SDT->getSections().begin(); i != m_SDT->getSections().end(); ++i)
	{
		const ServiceDescriptionSection &sdt = **i;
		const ServiceDescriptionList &services = *sdt.getDescriptions();
		for (ServiceDescriptionConstIterator s(services.begin()); s != services.end(); ++s)
		{
			unsigned short service_id = (*s)->getServiceId();
			eServiceReferenceDVB ref;
			ePtr<eDVBService> service = new eDVBService;

			ref.set(chid);
			ref.setServiceID(service_id);

			for (DescriptorConstIterator desc = (*s)->getDescriptors()->begin();
					desc != (*s)->getDescriptors()->end(); ++desc)
			{
				switch ((*desc)->getTag())
				{
				case SERVICE_DESCRIPTOR:
				{
					ServiceDescriptor &d = (ServiceDescriptor&)**desc;
					int servicetype = d.getServiceType();
					ref.setServiceType(servicetype);
					service->m_service_name = convertDVBUTF8(d.getServiceName());
					service->genSortName();
					service->m_provider_name = convertDVBUTF8(d.getServiceProviderName());
					providerNames[service->m_provider_name]++;
					break;
				}
				case CA_IDENTIFIER_DESCRIPTOR:
				{
					CaIdentifierDescriptor &d = (CaIdentifierDescriptor&)**desc;
					const CaSystemIdList &caids = *d.getCaSystemIds();
					for (CaSystemIdList::const_iterator i(caids.begin()); i != caids.end(); ++i)
					{
						service->m_ca.push_front(*i);
					}
					break;
				}
				default:
					break;
				}
			}
			ePtr<eDVBService> dvb_service;
			if (!db->getService(ref, dvb_service))
			{
				dvb_service->m_flags |= service->m_flags;
				if (service->m_ca.size())
					dvb_service->m_ca = service->m_ca;
			}
			else
			{
				db->addService(ref, service);
				service->m_flags |= eDVBService::dxNewFound;
			}
			int logicalchannelid = 0;
			if (hdList)
			{
				std::map<int, int>::const_iterator it = serviceIdToHDChannelId.find(service_id);
				if (it != serviceIdToHDChannelId.end())
				{
					logicalchannelid = it->second;
				}
			}
			if (!logicalchannelid)
			{
				std::map<int, int>::const_iterator it = serviceIdToChannelId.find(service_id);
				if (it != serviceIdToChannelId.end())
				{
					logicalchannelid = it->second;
				}
			}
			if (logicalchannelid)
			{
				switch (ref.getServiceType())
				{
				case 1: /* digital television service */
				case 4: /* nvod reference service (NYI) */
				case 17: /* MPEG-2 HD digital television service */
				case 22: /* advanced codec SD digital television */
				case 24: /* advanced codec SD NVOD reference service (NYI) */
				case 25: /* advanced codec HD digital television */
				case 27: /* advanced codec HD NVOD reference service (NYI) */
				default:
					/* just assume that anything *not* radio is tv */
					numberedServiceRefs[logicalchannelid] = ref;
					break;
				case 2: /* digital radio sound service */
				case 10: /* advanced codec digital radio sound service */
					numberedRadioServiceRefs[logicalchannelid] = ref;
					break;
				}
			}
		}
	}
}
示例#3
0
jlong Java_javax_tv_service_VDRService_getServiceForChannelId(JNIEnv* env, jclass clazz, jint source, jint onid, jint tid, jint sid) {
   tChannelID chid(source, onid, tid, sid);
   return (jlong )Channels.GetByChannelID(chid);
}
示例#4
0
    QVariant data(const QModelIndex &index, int role) const
    {
        if (!index.isValid())
            return QVariant();

        if (role == Qt::DisplayRole || role == Qt::EditRole)
        {
            int i = alive[index.row()];
            QueuedPlayerMoves::const_iterator mi;
            std::map<int, Game::CharacterState>::const_iterator mi2;
            switch (index.column())
            {
                case Name:
                {
                    // TODO: for sorting return the index as number
                    Game::CharacterID chid(player, i);
                    QString ret = QString::fromStdString(chid.ToString());
                    if (role == Qt::DisplayRole)
                    {
                        if (i == 0)
                            ret = QString::fromUtf8("\u2605") + ret;
                        if (crownHolder == chid)
                            ret += QString::fromUtf8(" \u265B");
                    }
                    return ret;
                }
                case Coins:
                    mi2 = state.characters.find(i);
                    if (mi2 != state.characters.end())
                        return QString::fromStdString(FormatMoney(mi2->second.loot.nAmount));    // TODO: for sorting return as float value
                    return QVariant();
                case Status:
                    if (pending) {
                        //return tr("Pending");
                    	mi2 = state.characters.find(i);
                        if (mi2->second.waypoints.empty()) {
                        	QString ret = QString::fromStdString("Pending (");
                        	ret += QString::number(mi2->second.coord.x);
                        	ret += QString::fromStdString(",");
                        	ret += QString::number(mi2->second.coord.y);
                        	ret += QString::fromStdString(")");
                        	return ret;
                        } else {
                        	QString ret = QString::fromStdString("Pending (");
                        	ret += QString::number(mi2->second.coord.x);
                        	ret += QString::fromStdString(",");
                        	ret += QString::number(mi2->second.coord.y);
                        	ret += QString::fromStdString(") - (");
                        	ret += QString::number(mi2->second.waypoints.front().x);
                        	ret += QString::fromStdString(",");
                        	ret += QString::number(mi2->second.waypoints.front().y);
                        	ret += QString::fromStdString(")");
                        	return ret;
                        }
                    }
                    mi = queuedMoves.find(i);
                    if (mi != queuedMoves.end())
                    {
                        if (mi->second.destruct)
                            return tr("Destruct");
                        else
                            return tr("Queued");
                    }
                    else
                    {
                        mi2 = state.characters.find(i);
                        if (mi2 != state.characters.end() && mi2->second.waypoints.empty()) {
                        	QString ret = QString::fromStdString("Ready (");
                        	ret += QString::number(mi2->second.coord.x);
                        	ret += QString::fromStdString(",");
                        	ret += QString::number(mi2->second.coord.y);
                        	ret += QString::fromStdString(")");
                        	return ret;//QString::fromStdString("Ready (")+QString::number(1); //return tr("Ready" + QString::number(1));
                        } else {
                        	QString ret = QString::fromStdString("Moving (");
                        	ret += QString::number(mi2->second.coord.x);
                        	ret += QString::fromStdString(",");
                        	ret += QString::number(mi2->second.coord.y);
                        	ret += QString::fromStdString(") - (");
                        	ret += QString::number(mi2->second.waypoints.front().x);
                        	ret += QString::fromStdString(",");
                        	ret += QString::number(mi2->second.waypoints.front().y);
                        	ret += QString::fromStdString(")");
                        	return ret;
                        }
                    }
                case Time:
                    unsigned val = 0;
                    mi = queuedMoves.find(i);
                    mi2 = state.characters.find(i);
                    const Game::WaypointVector* wp = NULL;
                    if (mi != queuedMoves.end())
                        wp = &mi->second.waypoints;
                    if (mi2 != state.characters.end())
                        val = mi2->second.TimeToDestination(wp);
                    if (val > 0)
                        return QString("%1").arg(val);
                    return "";
            }
        }
        else if (role == Qt::TextAlignmentRole)
            return QVariant(int(Qt::AlignLeft|Qt::AlignVCenter));

        return QVariant();
    }