/******************************************************************************
void IFXKeyTrack::Filter(F32 deltatime)

remove track entries too close in time

******************************************************************************/
void IFXKeyTrack::Filter(F32 deltatime)
{
	//I32 original=GetNumberElements();

	IFXListContext basecontext,nextcontext;
	IFXKeyFrame *base,*next;

	ToHead(basecontext);
	while((base=GetCurrent(basecontext)) != NULL)
	{
		nextcontext=basecontext;
		PostIncrement(nextcontext);

		if(IsAtTail(nextcontext))
			break;

		next=GetCurrent(nextcontext);

		if( (next->Time()-base->Time()) < deltatime )
		{
			Delete(next);
		}
		else
		{
			PostIncrement(basecontext);
		}
	}
}

void
ParamListGL::Special(int key, int /*x*/, int /*y*/)
{
    switch(key) {
    case GLUT_KEY_DOWN:
        Increment();
        break;
    case GLUT_KEY_UP:
        Decrement();
        break;
    case GLUT_KEY_RIGHT:
        GetCurrent()->Increment();
        break;
    case GLUT_KEY_LEFT:
        GetCurrent()->Decrement();
        break;
    case GLUT_KEY_HOME:
        GetCurrent()->Reset();
        break;
    case GLUT_KEY_END:
        GetCurrent()->SetPercentage(1.0);
        break;
    }
    glutPostRedisplay();
}

eOSState cMenuBrowseFiles::Info(void)
{
  if (GetCurrent() && !GetCurrent()->IsDir()) {
    cString filename = cString::sprintf("%s/%s", *m_CurrentDir, GetCurrent()->Name());
    return AddSubMenu(new cMetainfoMenu(filename));
  }
  return osContinue;
}

bool LEVELSELECT::addDirectoryListEntry(char* directoryName)
{
    if (strlen(directoryName)+1 > MAX_PATH)
    {
        error("LEVELSELECT::addLevelListEntry", "Parameter directoryName too long. Max length is MAX_PATH (%d).", MAX_PATH);
        return false;
    }

    LEVELDIRECTORY *lastDirectory = GetCurrent()->GetDirectory();
    LEVELDIRECTORY *newDirectory;

    //get last directory
    if (lastDirectory != NULL)
    {
        while (lastDirectory->next != NULL)
        {
            lastDirectory = lastDirectory->next;
        }
    }

    newDirectory = (LEVELDIRECTORY*)malloc(sizeof(LEVELDIRECTORY));
    newDirectory->prev = lastDirectory;
    newDirectory->next = NULL;
    if (lastDirectory != NULL)
    {
        lastDirectory->next = newDirectory;
        newDirectory->index = lastDirectory->index+1;
    }
    else
    {
        newDirectory->index = 0;
    }

    if (strcmp(directoryName, "..")==0)
    {
        strcpy(newDirectory->name, "");
    }
    else
    {
        strcpy(newDirectory->name, directoryName);
    }

    GetCurrent()->GetDirectoryPath(newDirectory->path, newDirectory->name);

    if (GetCurrent()->GetDirectory() == NULL)
        GetCurrent()->currentDirectory = newDirectory;
    return true;
}

void subPageSpells::Del()
{
	School *school = currentSchool;

	if ( school->spells.size() == 1 )
	{
		currentSpell->Clear();
		GetCurrent();
		return;
	}
	spellItr = school->spells.erase(spellItr);
	delete currentSpell;
	currentSpell = *spellItr;

	GetCurrent();
}

void subPageSpells::Next(unsigned int n)
{
	SetCurrent();

	std::vector<Spell*> *pSpells = &currentSchool->spells;

	if ( n > (pSpells->size()-spellNumber) && n!=1 )
	{
		spellItr = pSpells->end();
		spellItr--;
		currentSpell = *spellItr;
		spellNumber = pSpells->size();
		return;
	}

	for ( ; n > 0; n-- )
	{
		spellItr++;
		spellNumber++;
		if ( spellItr == pSpells->end() )
		{
			spellItr = pSpells->begin();
			spellNumber = 1;
		}
		currentSpell = *spellItr;
	}

	GetCurrent();
}

bool
TaskQueue::IsCurrentThreadIn()
{
  bool in = NS_GetCurrentThread() == mRunningThread;
  MOZ_ASSERT(in == (GetCurrent() == this));
  return in;
}

nsresult
TaskQueue::DispatchLocked(already_AddRefed<nsIRunnable> aRunnable,
                               DispatchMode aMode, DispatchFailureHandling aFailureHandling,
                               DispatchReason aReason)
{
  nsCOMPtr<nsIRunnable> r = aRunnable;
  AbstractThread* currentThread;
  if (aReason != TailDispatch && (currentThread = GetCurrent()) && RequiresTailDispatch(currentThread)) {
    currentThread->TailDispatcher().AddTask(this, r.forget(), aFailureHandling);
    return NS_OK;
  }

  mQueueMonitor.AssertCurrentThreadOwns();
  if (mIsFlushing && aMode == AbortIfFlushing) {
    return NS_ERROR_ABORT;
  }
  if (mIsShutdown) {
    return NS_ERROR_FAILURE;
  }
  mTasks.push(r.forget());
  if (mIsRunning) {
    return NS_OK;
  }
  nsRefPtr<nsIRunnable> runner(new Runner(this));
  nsresult rv = mPool->Dispatch(runner.forget(), NS_DISPATCH_NORMAL);
  if (NS_FAILED(rv)) {
    NS_WARNING("Failed to dispatch runnable to run TaskQueue");
    return rv;
  }
  mIsRunning = true;

  return NS_OK;
}

Size DockCont::GetMinSize() const
{
	if (ignoreminsize) return Size(0, 0);
	Size sz = tabbar.GetCount() ? GetCurrent().GetMinSize() : Size(0, 0);
	sz = AddFrameSize(sz);
	return sz;
}

int	CoroutineMgr::Yield(int coid )
{
    Coroutine * cur = GetCurrent();
    if(!cur)
    {
		LOG_FATAL("current co is null !");
        return -1;
    }
	Coroutine * co = Find(coid);
	if(0 == coid)
	{
		//switch to prev
		co = cur->from;
	}
    if(!co)
    {
		LOG_FATAL("current from co is null !");
        return -1;
    }
	if(cur->bState == Coroutine::COROUTINE_STATUS_RUNNING)
	{
		cur->bState = Coroutine::COROUTINE_STATUS_SUSPEND;
	}
	co->bState = Coroutine::COROUTINE_STATUS_RUNNING;
    SetCurrent(co);
	LOG_INFO("co = %d is yield schedule next = %d for = %d",cur->iID,co->iID,coid);
    swapcontext(&(cur->ctx),&(co->ctx));
    return retval;
}

void VirtualHost::UpdateSerializationSizeLimit() {
  const VirtualHost *vh = GetCurrent();
  assert(vh);
  if (vh->m_runtimeOption.serializationSizeLimit != StringData::MaxSize) {
    VariableSerializer::serializationSizeLimit =
      vh->m_runtimeOption.serializationSizeLimit;
  }
}

const vector<string> &VirtualHost::GetAllowedDirectories() {
  const VirtualHost *vh = GetCurrent();
  ASSERT(vh);
  if (!vh->m_runtimeOption.allowedDirectories.empty()) {
    return vh->m_runtimeOption.allowedDirectories;
  }
  return RuntimeOption::AllowedDirectories;
}

void Shader::Unbind()
{
	if(GetCurrent() != nullptr)
	{
		glUseProgram(0);
		SetCurrent(nullptr);
	}
}

void Shader::Bind()
{
	if(GetCurrent() != this)
	{
		glUseProgram(id);
		SetCurrent(this);
	}
}

void FProgress::DrawMeter(CDC& dc, FRect& rcPaint)
{

	//fill the unavailable 
	int nLines = rcPaint.Width() / (gLineDistance + gPenWidth) + 1; 

	int nAvailLines = (int)GetAvail((double)nLines) ;
	int nCurrLines  = (int)GetCurrent((double)nLines);
	
	assert(nAvailLines >= nCurrLines);

	int x = rcPaint.left; 
	int y = rcPaint.top; 

	dc.MoveTo(x, y); 

	int lh = rcPaint.Height() - 0; 
	int mh = lh; 

	int nPenIndex = 2; 
	dc.SelectPen(m_Pens[nPenIndex]); 
	dword dwStyle = GetWindowLong(GWL_STYLE); 

	for (int k = 0; k < nLines; k++)
	{
		if (k == nCurrLines)
		{
			if (k < nAvailLines)
				dc.SelectPen(m_Pens[1]);	
			else
				dc.SelectPen(m_Pens[0]);
			if (dwStyle & PROG_LARGER_CURRENT)
			{
				lh = lh / 2; 
				y += lh / 2; 
				dc.MoveTo(x, y);  
			}
		}
		else if (k == nAvailLines)
		{
			dc.SelectPen(m_Pens[0]); 
		}

		if (dwStyle & PROG_GROWING)
		{
			double dblNow = (double)k / (double)nLines; 
			lh = (int)(mh * dblNow); 
			y = mh - lh; 
			dc.MoveTo(x, y); 
		}

		dc.LineTo(x, y + lh);
		x += gLineDistance; 
		x += gPenWidth;
		dc.MoveTo(x, y); 
	}
}

	void VListWin::SetNoCurrent()
	{
		if ( current == -1 ) { return; }

		current = -1;
		Command( CMD_ITEM_CHANGED, GetCurrent(), this, 0 );

		if ( IsVisible() ) { Invalidate(); }
	}

BOOL CPlayer::Rew(long lSkip)
{
	CAutoLock lock(&m_csecInterface);
	if (m_fOpen == OPEN_NONE)
		return FALSE;

	LONG lTime = GetCurrent();
	lTime -= lSkip;
	return Seek(lTime);
}

	unsigned int Buffer::Read( void* pData, int iSize )
	{
		if ( m_iPos + iSize > m_iSize ) { return 0; }

		if ( iSize == 0 ) { return 0; }

		memcpy( pData, GetCurrent(), iSize );
		m_iPos += iSize;
		return iSize;
	}

 virtual bool IsCurrentThreadIn() override
 {
   // Compare NSPR threads so that this works after shutdown when
   // NS_GetCurrentThread starts returning null.
   PRThread* thread = nullptr;
   mTarget->GetPRThread(&thread);
   bool in = PR_GetCurrentThread() == thread;
   MOZ_ASSERT(in == (GetCurrent() == this));
   return in;
 }

// GetCurrent
Entry *
NameIndexEntryIterator::GetCurrent(uint8 *buffer, size_t *keyLength)
{
	Entry *entry = GetCurrent();
	if (entry) {
		strncpy((char*)buffer, entry->GetName(), kMaxIndexKeyLength);
		*keyLength = strlen(entry->GetName());
	}
	return entry;
}