C++ Xml::s2方法代码示例

static QPair<int, QString> readMidiPortPreset(Xml& xml)/*{{{*/
{
    int id = 0;
    QString sysex;

    for (;;)
    {
        Xml::Token token = xml.parse();
        QString tag = xml.s1();
        switch (token)
        {
            case Xml::TagStart:
                xml.unknown("midiPreset");
                break;
            case Xml::Attribut:
                if (tag == "id")
                    id = xml.s2().toInt();
                else if (tag == "sysex")
                {
                    sysex = xml.s2();
                }
                break;
            case Xml::TagEnd:
                return qMakePair(id, sysex);
            default:
                break;
        }
    }
}/*}}}*/

void PosLen::read(Xml& xml, const char* name)
{
    sn = -1;
    for (;;)
    {
        Xml::Token token = xml.parse();
        const QString& tag = xml.s1();
        switch (token)
        {
        case Xml::Error:
        case Xml::End:
            return;

        case Xml::TagStart:
            xml.unknown(name);
            break;

        case Xml::Attribut:
            if (tag == "tick")
            {
                setType(TICKS);
                setTick(xml.s2().toInt());
            }
            else if (tag == "sample")
            {
                setType(FRAMES);
                setFrame(xml.s2().toInt());
            }
            else if (tag == "len")
            {
                int n = xml.s2().toInt();
                switch (type())
                {
                case TICKS:
                    setLenTick(n);
                    break;
                case FRAMES:
                    setLenFrame(n);
                    break;
                }
            }
            else
                xml.unknown(name);
            break;

        case Xml::TagEnd:
            if (tag == name)
                return;
        default:
            break;
        }
    }
}

QColor readColor(Xml& xml)
{
    int val, r = 0, g = 0, b = 0;

    for (;;)
    {
        Xml::Token token = xml.parse();
        if (token != Xml::Attribut)
            break;
        QString tag = xml.s1();
        switch (token)
        {
            case Xml::Attribut:
                val = xml.s2().toInt();
                if (tag == "r")
                    r = val;
                else if (tag == "g")
                    g = val;
                else if (tag == "b")
                    b = val;
                break;
            default:
                break;
        }
    }

    return QColor(r, g, b);
}

int SigEvent::read(Xml& xml)
{
	int at = 0;
	for (;;)
	{
		Xml::Token token = xml.parse();
		const QString& tag = xml.s1();
		switch (token)
		{
			case Xml::Error:
			case Xml::End:
				return 0;
			case Xml::TagStart:
				if (tag == "tick")
					tick = xml.parseInt();
				else if (tag == "nom")
					z = xml.parseInt();
				else if (tag == "denom")
					n = xml.parseInt();
				else
					xml.unknown("SigEvent");
				break;
			case Xml::Attribut:
				if (tag == "at")
					at = xml.s2().toInt();
				break;
			case Xml::TagEnd:
				if (tag == "sig")
					return at;
			default:
				break;
		}
	}
	return 0;
}

void PatchGroup::read(Xml& xml)
      {
      for (;;) {
            Xml::Token token = xml.parse();
            const QString& tag = xml.s1();
            switch (token) {
                  case Xml::Error:
                  case Xml::End:
                        return;
                  case Xml::TagStart:
                        if (tag == "Patch") {
                              Patch* patch = new Patch;
                              patch->read(xml);
                              patches.push_back(patch);
                              }
                        else
                              xml.unknown("PatchGroup");
                        break;
                  case Xml::Attribut:
                        if (tag == "name")
                              name = xml.s2();
                        break;
                  case Xml::TagEnd:
                        if (tag == "PatchGroup")
                              return;
                  default:
                        break;
                  }
            }
      }

int TEvent::read(Xml& xml)
{
	int at = 0;
	for (;;)
	{
		Xml::Token token = xml.parse();
		const QString& tag = xml.s1();
		switch (token)
		{
			case Xml::Error:
			case Xml::End:
				return 0;
			case Xml::TagStart:
				if (tag == "tick")
					tick = xml.parseInt();
				else if (tag == "val")
					tempo = xml.parseInt();
				else
					xml.unknown("TEvent");
				break;
			case Xml::Attribut:
				if (tag == "at")
					at = xml.s2().toInt();
				break;
			case Xml::TagEnd:
				if (tag == "tempo")
				{
					return at;
				}
			default:
				break;
		}
	}
	return 0;
}

static void readPortChannel(Xml& xml, int midiPort)
{
    int idx = 0; //torbenh
    for (;;)
    {
        Xml::Token token = xml.parse();
        if (token == Xml::Error || token == Xml::End)
            break;
        QString tag = xml.s1();
        switch (token)
        {
            case Xml::TagStart:
                if (tag == "controller")
                {
                    readController(xml, midiPort, idx);
                }
                else
                    xml.skip(tag);
                break;
            case Xml::Attribut:
                if (tag == "idx")
                    idx = xml.s2().toInt();
                break;
            case Xml::TagEnd:
                if (tag == "channel")
                    return;
            default:
                break;
        }
    }
}

void AudioTrack::readAuxSend(Xml& xml)
{
	qint64 idx;
	double val;
	bool pre = true;
	for (;;)
	{
		Xml::Token token = xml.parse();
		const QString& tag = xml.s1();
		switch (token)
		{
			case Xml::Error:
			case Xml::End:
				return;
			case Xml::Attribut:
			{
				if (tag == "idx")
				{//Backwards compatible
					idx = xml.s2().toLongLong();
					gUpdateAuxes = true;
				}
				else if(tag == "trackId")
				{//New style trackId based
					idx = xml.s2().toLongLong();
				}
				else if(tag == "pre")
				{
					pre = xml.s2().toInt();
				}
				break;
			}
			case Xml::Text:
				val = tag.toDouble();
				break;
			case Xml::TagEnd:
				if (xml.s1() == "auxSend")
				{
					AuxInfo info(pre, val);
					_auxSend[idx] = info;
					return;
				}
			default:
				break;
		}
	}
}

void MidiEventBase::read(Xml& xml)
{
	setType(Note);
	a = 0;
	b = 0;
	c = 0;

	int dataLen = 0;
	for (;;)
	{
		Xml::Token token = xml.parse();
		const QString& tag = xml.s1();
		switch (token)
		{
			case Xml::Error:
			case Xml::End:
				return;
			case Xml::TagStart:
				xml.unknown("Event");
				break;
			case Xml::Text:
			{
				QByteArray ba = tag.toLatin1();
				const char*s = ba.constData();
				edata.data = new unsigned char[dataLen];
				edata.dataLen = dataLen;
				unsigned char* d = edata.data;
				for (int i = 0; i < dataLen; ++i)
				{
					char* endp;
					*d++ = strtol(s, &endp, 16);
					s = endp;
				}
			}
				break;
			case Xml::Attribut:
				if (tag == "tick")
					setTick(xml.s2().toInt());
				else if (tag == "type")
					setType(EventType(xml.s2().toInt()));
				else if (tag == "len")
					setLenTick(xml.s2().toInt());
				else if (tag == "a")
					a = xml.s2().toInt();
				else if (tag == "b")
					b = xml.s2().toInt();
				else if (tag == "c")
					c = xml.s2().toInt();
				else if (tag == "datalen")
					dataLen = xml.s2().toInt();
				break;
			case Xml::TagEnd:
				if (tag == "event")
					return;
			default:
				break;
		}
	}
}

patch_collection_t MidiInstrument::readDrummapsEntryPatchCollection(Xml& xml)
{
  int first_prog=0, last_prog=256;   // this means:
  int first_lbank=0, last_lbank=256; // "does not matter"
  int first_hbank=0, last_hbank=256;

  for (;;)
  {
    Xml::Token token = xml.parse();
    const QString& tag = xml.s1();
    switch (token)
    {
      case Xml::Error:
      case Xml::End:
        return patch_collection_t(-1,-1,-1,-1,-1,-1); // an invalid collection

      case Xml::TagStart:
        xml.unknown("MidiInstrument::readDrummapsEntryPatchCollection");
        break;

      case Xml::Attribut:
        if (tag == "prog")
          parse_range(xml.s2(), &first_prog, &last_prog);
        else if (tag == "lbank")
          parse_range(xml.s2(), &first_lbank, &last_lbank);
        else if (tag == "hbank")
          parse_range(xml.s2(), &first_hbank, &last_hbank);
        break;

      case Xml::TagEnd:
        if (tag == "patch_collection")
          return patch_collection_t(first_prog, last_prog, first_lbank, last_lbank, first_hbank, last_hbank);

      default:
        break;
    }
  }

  printf("ERROR: THIS CANNOT HAPPEN: exited infinite loop in MidiInstrument::readDrummapsEntryPatchCollection()!\n"
         "                           not returning anything. expect undefined behaviour or even crashes.\n");
}

void KeyMap::read(Xml& xml)/*{{{*/
{
    program = -1;
    pname = "";
    comment = "";
    key = -1;
    hasProgram = false;
    for (;;)
    {
        Xml::Token token = xml.parse();
        const QString& tag = xml.s1();
        switch (token)
        {
            case Xml::Error:
            case Xml::End:
                return;
            case Xml::TagStart:
                xml.unknown("KeyMap");
                break;
            case Xml::Attribut:
                if (tag == "comment")
                    comment = xml.s2();
                else if (tag == "program")
                    program = xml.s2().toInt();
                else if (tag == "key")
                    key = xml.s2().toInt();
                else if (tag == "pname")
                    pname = xml.s2();
                else if(tag == "hasProgram")
                    hasProgram = (bool)xml.s2().toInt();
                break;
            case Xml::TagEnd:
                if (tag == "KeyMap")
                    return;
            default:
                break;
        }
    }
}/*}}}*/

void readGlobalInput(Xml& xml)/*{{{*/
{
    QString name;
    int type;
    for (;;)
    {
        Xml::Token token = xml.parse();
        const QString& tag = xml.s1();
        switch (token)
        {
            case Xml::Error:
            case Xml::End:
                return;
            case Xml::TagStart:
                break;
            case Xml::Attribut:
                if(tag == "deviceType")
                {
                    type = xml.s2().toInt();
                }
                else if(tag == "deviceName")
                {
                    name = xml.s2();
                }
                break;
            case Xml::TagEnd:
                if(tag == "globalInput")
                {
                    if(debugMsg)
                        qDebug("readGlobalInput: Adding My Input to list: Type: %d, Name: %s", type,  name.toUtf8().constData());
                    gInputList.append(qMakePair(type, name));
                    return;
                }
            default:
                break;
        }
    }
}/*}}}*/

void MidiInstrument::readMidiState(Xml& xml)
{
  // A kludge to support old midistates by wrapping them in the proper header.
  _tmpMidiStateVersion = 1;    // Assume old (unmarked) first version 1.
  for (;;)
  {
    Xml::Token token = xml.parse();
    const QString tag = xml.s1();
    switch (token)
    {
          case Xml::Error:
          case Xml::End:
                return;
          case Xml::TagStart:
                if (tag == "event")
                {
                  Event e(Note);
                  e.read(xml);
                  _midiState->add(e);
                }
                else
                xml.unknown("midistate");
                break;
          case Xml::Attribut:
                if(tag == "version")
                  _tmpMidiStateVersion = xml.s2().toInt();
                else
                  xml.unknown("MidiInstrument");
                break;
          case Xml::TagEnd:
                if(tag == "midistate")
                  return;
          default:
                break;
    }
  }
}

QRect readGeometry(Xml& xml, const QString& name)
{
    QRect r(0, 0, 50, 50);
    int val;

    for (;;)
    {
        Xml::Token token = xml.parse();
        if (token == Xml::Error || token == Xml::End)
            break;
        QString tag = xml.s1();
        switch (token)
        {
            case Xml::TagStart:
                xml.parse1();
                break;
            case Xml::Attribut:
                val = xml.s2().toInt();
                if (tag == "x")
                    r.setX(val);
                else if (tag == "y")
                    r.setY(val);
                else if (tag == "w")
                    r.setWidth(val);
                else if (tag == "h")
                    r.setHeight(val);
                break;
            case Xml::TagEnd:
                if (tag == name)
                    return r;
            default:
                break;
        }
    }
    return r;
}

static void readController(Xml& xml, int midiPort, int channel)
{
    int id = 0;
    int val = CTRL_VAL_UNKNOWN;

    for (;;)
    {
        Xml::Token token = xml.parse();
        QString tag = xml.s1();
        switch (token)
        {
            case Xml::TagStart:
                if (tag == "val")
                    val = xml.parseInt();
                else
                    xml.skip(tag);
                break;
            case Xml::Attribut:
                if (tag == "id")
                    id = xml.s2().toInt();
                break;
            case Xml::TagEnd:
                if (tag == "controller")
                {
                    MidiPort* port = &midiPorts[midiPort];
                    //port->addManagedController(channel, id);
                    val = port->limitValToInstrCtlRange(id, val);
                    // The value here will actually be sent to the device LATER, in MidiPort::setMidiDevice()
                    port->setHwCtrlState(channel, id, val);
                    return;
                }
            default:
                return;
        }
    }
}