Example #1
0
Period & Period::at(const QDateTime &dt, const PeriodType *t)
{
	type = t;
	if(type)
	{
		setFrom(dt);
		Duration dur = dt % type->base;
		uint np = type->parts.size();
		if(np)
		{
			for(part = 0; part < np - 1; part++) if(type->parts[part + 1] > dur) break;
			if(type->parts[part] > dur) { changePart(-1); return *this; }
		}
	}
	changePart(0);
	return *this;
}
Example #2
0
bool KonqView::ensureViewSupports( const QString &mimeType,
                                   bool forceAutoEmbed )
{
    if (supportsMimeType(mimeType)) {
        // could be more specific, let's store it so that OpenUrlArguments::mimeType is correct
        // testcase: http://acid3.acidtests.org/svg.xml should be opened as image/svg+xml
        m_serviceType = mimeType;
        return true;
    }
    return changePart(mimeType, QString(), forceAutoEmbed);
}
Example #3
0
void ChangePartManager::onResLoad(ModelNode* pNode)
{
	if( 0 == pNode) //不可能
	{
		throw std::string("ChangePartManager::onResLoad:: empty ModelNode");
		return;
	}

	m_bLoaded = true;
	m_pModelNode = pNode;

	//设置身体颜色
	m_pModelNode->setGlobalDiffuse(m_vBodyColor);

	//执行换装命令
	ulong curBody = getCurrentBody();
	if( curBody == EEntityPart_Armor )//普通装备
	{
		changePart(m_CurrentPart[EEntityPart_Armet]);
		changePart(m_CurrentPart[EEntityPart_Weapon]);
	}
	else if( curBody == EEntityPart_Suit_Armor)
	{
		changePart(m_CurrentPart[EEntityPart_Suit_Armet]);
		changePart(m_CurrentPart[EEntityPart_Weapon]);
	}
	else
	{
		//no thing to do
	}

	//链接外部
	ChangePartCallBackContext context;
	context.pNode = m_pModelNode;
	m_pCallBack->onChangePart(context);
}
Example #4
0
File: undo.cpp Project: faesong/oom
void Song::doRedo2()
{
    Undo& u = redoList->back();
    for (iUndoOp i = u.begin(); i != u.end(); ++i)
    {
        switch (i->type)
        {
        case UndoOp::AddTrack:
            insertTrack2(i->oTrack, i->trackno);
            // Added by T356.
            chainTrackParts(i->oTrack, true);

            updateFlags |= SC_TRACK_INSERTED;
            break;
        case UndoOp::DeleteTrack:
            removeTrack2(i->oTrack);
            updateFlags |= SC_TRACK_REMOVED;
            break;
        case UndoOp::ModifyTrack:
        {
            // Unchain the track parts, but don't touch the ref counts.
            unchainTrackParts(i->nTrack, false);

            //Track* track = i->nTrack->clone();
            Track* track = i->nTrack->clone(false);

            *(i->nTrack) = *(i->oTrack);

            // Prevent delete i->oTrack from crashing.
            switch (i->oTrack->type())
            {
            case Track::AUDIO_OUTPUT:
            {
                AudioOutput* ao = (AudioOutput*) i->oTrack;
                for (int ch = 0; ch < ao->channels(); ++ch)
                    ao->setJackPort(ch, 0);
            }
            break;
            case Track::AUDIO_INPUT:
            {
                AudioInput* ai = (AudioInput*) i->oTrack;
                for (int ch = 0; ch < ai->channels(); ++ch)
                    ai->setJackPort(ch, 0);
            }
            break;
            default:
                break;
            }
            if (!i->oTrack->isMidiTrack())
                ((AudioTrack*) i->oTrack)->clearEfxList();

            delete i->oTrack;
            i->oTrack = track;

            // Chain the track parts, but don't touch the ref counts.
            chainTrackParts(i->nTrack, false);

            // Connect and register ports.
            switch (i->nTrack->type())
            {
            case Track::AUDIO_OUTPUT:
            {
                AudioOutput* ao = (AudioOutput*) i->nTrack;
                ao->setName(ao->name());
            }
            break;
            case Track::AUDIO_INPUT:
            {
                AudioInput* ai = (AudioInput*) i->nTrack;
                ai->setName(ai->name());
            }
            break;
            default:
                break;
            }

            // Update solo states, since the user may have changed soloing on other tracks.
            updateSoloStates();

            updateFlags |= SC_TRACK_MODIFIED;
        }
        break;

        /*
        // Prevent delete i->oTrack from crashing.
        switch(i->oTrack->type())
        {
        	  case Track::AUDIO_OUTPUT:
        			  {
        			  AudioOutput* ao = (AudioOutput*)i->oTrack;
        			  for(int ch = 0; ch < ao->channels(); ++ch)
        				ao->setJackPort(ch, 0);
        			  }
        			break;
        	  case Track::AUDIO_INPUT:
        			  {
        			  AudioInput* ai = (AudioInput*)i->oTrack;
        			  for(int ch = 0; ch < ai->channels(); ++ch)
        				ai->setJackPort(ch, 0);
        			  }
        			break;
        	  default:
        			break;
        }
        if(!i->oTrack->isMidiTrack())
          ((AudioTrack*)i->oTrack)->clearEfxList();

        //delete i->oTrack;
        //i->oTrack = track;

        // Remove the track. removeTrack2 takes care of unchaining the old track.
        removeTrack2(i->oTrack);

        // Connect and register ports.
        switch(i->nTrack->type())
        {
          case Track::AUDIO_OUTPUT:
        	  {
        	  AudioOutput* ao = (AudioOutput*)i->nTrack;
        	  ao->setName(ao->name());
        	  }
        	break;
          case Track::AUDIO_INPUT:
        	  {
        	  AudioInput* ai = (AudioInput*)i->nTrack;
        	  ai->setName(ai->name());
        	  }
        	break;
          default:
        	break;
        }

        // Insert the new track.
        insertTrack2(i->nTrack, i->trackno);
        // Chain the new track parts. (removeTrack2, above, takes care of unchaining the old track).
        chainTrackParts(i->nTrack, true);

        // Update solo states, since the user may have changed soloing on other tracks.
        updateSoloStates();

        updateFlags |= SC_TRACK_MODIFIED;
        }
        break;
         */

        case UndoOp::SwapTrack:
        {
            Track* track = _tracks[i->a];
            _tracks[i->a] = _tracks[i->b];
            _tracks[i->b] = track;
            updateFlags |= SC_TRACK_MODIFIED;
        }
        break;
        case UndoOp::AddPart:
            addPart(i->oPart);
            updateFlags |= SC_PART_INSERTED;
            i->oPart->events()->incARef(1);
            //i->oPart->chainClone();
            chainClone(i->oPart);
            break;
        case UndoOp::DeletePart:
            removePart(i->oPart);
            updateFlags |= SC_PART_REMOVED;
            i->oPart->events()->incARef(-1);
            //i->oPart->unchainClone();
            unchainClone(i->oPart);
            break;
        case UndoOp::ModifyPart:
            if (i->doCtrls)
                removePortCtrlEvents(i->nPart, i->doClones);
            changePart(i->nPart, i->oPart);
            i->oPart->events()->incARef(1);
            i->nPart->events()->incARef(-1);
            //i->nPart->replaceClone(i->oPart);
            replaceClone(i->nPart, i->oPart);
            if (i->doCtrls)
                addPortCtrlEvents(i->oPart, i->doClones);
            updateFlags |= SC_PART_MODIFIED;
            break;
        case UndoOp::AddEvent:
            addEvent(i->nEvent, i->part);
            if (i->doCtrls)
                addPortCtrlEvents(i->nEvent, i->part, i->doClones);
            updateFlags |= SC_EVENT_INSERTED;
            break;
        case UndoOp::DeleteEvent:
            if (i->doCtrls)
                removePortCtrlEvents(i->nEvent, i->part, i->doClones);
            deleteEvent(i->nEvent, i->part);
            updateFlags |= SC_EVENT_REMOVED;
            break;
        case UndoOp::ModifyEvent:
            if (i->doCtrls)
                removePortCtrlEvents(i->nEvent, i->part, i->doClones);
            changeEvent(i->nEvent, i->oEvent, i->part);
            if (i->doCtrls)
                addPortCtrlEvents(i->oEvent, i->part, i->doClones);
            updateFlags |= SC_EVENT_MODIFIED;
            break;
        case UndoOp::AddTempo:
            //printf("doRedo2: UndoOp::AddTempo. adding tempo at: %d with tempo=%d\n", i->a, i->b);
            tempomap.addTempo(i->a, i->b);
            updateFlags |= SC_TEMPO;
            break;
        case UndoOp::DeleteTempo:
            //printf("doRedo2: UndoOp::DeleteTempo. deleting tempo at: %d with tempo=%d\n", i->a, i->b);
            tempomap.delTempo(i->a);
            updateFlags |= SC_TEMPO;
            break;
        case UndoOp::AddSig:
            ///sigmap.add(i->a, i->b, i->c);
            AL::sigmap.add(i->a, AL::TimeSignature(i->b, i->c));
            updateFlags |= SC_SIG;
            break;
        case UndoOp::DeleteSig:
            ///sigmap.del(i->a);
            AL::sigmap.del(i->a);
            updateFlags |= SC_SIG;
            break;
        case UndoOp::ModifyClip:
        case UndoOp::ModifyMarker:
            break;
        }
    }
}