void electromagnetica::draw(){
        //
    
    ofBackground(0);
    
    ofEnableAlphaBlending();
    ofEnableBlendMode(OF_BLENDMODE_SCREEN);
    ofPushMatrix(); //colocamos el canvas en su posicion centrada
    //post.begin();
        ofTranslate((ofGetWidth()-W_WIDTH)/2, 0);
       // drawNoise();
    
        ofNoFill();
        //ofEllipse(W_WIDTH/2, W_WIDTH/2, W_WIDTH, W_WIDTH);
       //
        ofPushMatrix();

            meshParticles.setMode(OF_PRIMITIVE_POINTS);
                meshAux.setMode(OF_PRIMITIVE_POINTS);
            glPointSize(2);
            glEnable(GL_POINT_SMOOTH);	// Para que sean puntos redondos
            ofEnableDepthTest();

            meshParticles.draw();
            meshAux.draw();

            ofDisableDepthTest();
            ofSetColor(255,0,0);
            ofFill();
        if(drawlines) wavesm.draw();

        ofPopMatrix();
        hands.draw();
    
        ofPushMatrix();
            //ofTranslate(200,200);
       // drawEM();
        ofPopMatrix();
    //post.end();
    ofPopMatrix();
  

    ofDisableBlendMode();
    ofDisableAlphaBlending();
    borde.draw();
    if(bdrawDebug)    showDebug();
    
  /*  //wavesm.debugInfo();
    ofPushStyle();
	ofSetColor(255,255,255);
	ofDrawBitmapString("fr: " + ofToString(ofGetFrameRate()), 50, ofGetHeight()-90);
	ofPopStyle();
   
   
*/
}

// =======================================================
int CSaveOptWindow::getValues(COptions *options)
{
  BEGIN;

  // get options
  options->bAskDesc = (newtCheckboxGetValue(m_checkAskDesc) == 'X');
  options->bCheckBeforeSaving = (newtCheckboxGetValue(m_checkCheckBeforeSaving) == 'X');
  options->bOverwrite = (newtCheckboxGetValue(m_checkOverwrite) == 'X');
  options->bSplitWait = (newtCheckboxGetValue(m_checkSplitWait) == 'X');
  
  // get compression level
  if (newtRadioGetCurrent(m_radioCompNone) == m_radioCompNone)
    options->dwCompression = COMPRESS_NONE;
  else if (newtRadioGetCurrent(m_radioCompNone) == m_radioCompGzip)
    options->dwCompression = COMPRESS_GZIP;
  else if (newtRadioGetCurrent(m_radioCompNone) == m_radioCompBzip2)
    options->dwCompression = COMPRESS_BZIP2;
  
  // get finish level
  if (newtRadioGetCurrent(m_radioFinishWait) == m_radioFinishWait)
    options->dwFinish = FINISH_WAIT;
  else if (newtRadioGetCurrent(m_radioFinishWait) == m_radioFinishHalt)
    options->dwFinish = FINISH_HALT;
  else if (newtRadioGetCurrent(m_radioFinishWait) == m_radioFinishReboot)
    options->dwFinish = FINISH_REBOOT;
  else if (newtRadioGetCurrent(m_radioFinishWait) == m_radioFinishQuit)
    options->dwFinish = FINISH_QUIT;
  else if (newtRadioGetCurrent(m_radioFinishWait) == m_radioFinishLast)
    options->dwFinish = FINISH_LAST;
  
  // get split mode
  if (newtRadioGetCurrent(m_radioSplitAuto) == m_radioSplitAuto)
    options->qwSplitSize = 0LL;//options->dwSplitMode = SPLIT_AUTO;
  else if (newtRadioGetCurrent(m_radioSplitAuto) == m_radioSplitSize)
    {	
      //options->dwSplitMode = SPLIT_SIZE;
#ifdef HAVE_ATOLL
      options->qwSplitSize = atoll(newtEntryGetValue(m_editSplitSize)) * 1024 * 1024;
#else
  #ifdef HAVE_STRTOLL
      options->qwSplitSize = strtoll(newtEntryGetValue(m_editSplitSize), 
         NULL, 10) * 1024 * 1024;
  #else
    #error "no function to convert string to long long int"
  #endif // HAVE_STRTOLL
#endif // HAVE_ATOLL
      showDebug(1, "qwSplitSize = %llu\n", options->qwSplitSize);
    }
  /*else if (newtRadioGetCurrent(m_radioSplitNone) == m_radioSplitAuto)
    {
      options->dwSplitMode = SPLIT_AUTO;
      options->dwSplitSize = 0;
    }*/
  
  RETURN_int(0);
}

// =======================================================
void CPartimagedClients::Release(unsigned int client)
{
  pthread_mutex_lock(&mClients);
  showDebug(1, "%d released\n", client);
  shutdown(Clients[client].Sock, SHUT_RDWR);
  Clients[client].Sock = 0;
  Clients[client].Present = false;
  Clients[client].MyPid = 0;
  pthread_mutex_unlock(&mClients);
}

/*
  Properties and methods
*/
HRESULT STDMETHODCALLTYPE QWindowsAccessible::accDoDefaultAction(VARIANT varID)
{
    showDebug(__FUNCTION__, accessible);
    if (!accessible->isValid())
        return E_FAIL;

    AccessibleElement elem(varID.lVal, accessible);
    const bool res = elem.iface ? elem.iface->doAction(DefaultAction, elem.entry, QVariantList()) : false;
    return res ? S_OK : S_FALSE;
}

/*
  Properties and methods
*/
HRESULT STDMETHODCALLTYPE QWindowsAccessible::accDoDefaultAction(VARIANT varID)
{
#ifdef DEBUG_SHOW_ATCLIENT_COMMANDS
    showDebug(__FUNCTION__, accessible);
#endif //DEBUG_SHOW_ATCLIENT_COMMANDS
    if (!accessible->isValid())
        return E_FAIL;

    return accessible->doAction(DefaultAction, varID.lVal, QVariantList()) ? S_OK : S_FALSE;
}

// =======================================================
int CImageDisk::destroySpaceFile() // [Main-Thread]
{
  int nRes;

  showDebug(1, "DESTROY SPACE FILE [%s]\n", m_szSpaceFilename);

  //newtWinMessage("before","b","erase %s", m_szSpaceFilename);
  nRes = unlink(m_szSpaceFilename);
  //newtWinMessage("after","b","erase %s", m_szSpaceFilename);
  return nRes;
}

// =======================================================
unsigned int CPartimagedClients::New()
{
  unsigned int next = 0;
  bool found = false;

  showDebug(1, "create new clients\n");
  pthread_mutex_lock(&mClients);
  while (!found && next < g_uiNbClients)
    {
      if (!Clients[next].Present)
        found = true;
      else
        next++;
    }

  Clients[next].Present = true;
  pthread_mutex_unlock(&mClients);
  showDebug(1, "new clients created : %d\n", next);
  return found ? next : g_uiNbClients;
}

TERMINAL_ACT_INFO* GetNextNameClass::GetName(const FN_STATE_ACT_LIST* period_info,
										TERMINAL_ACT_LIST* act_list,int &current_pos,int time_pos)
{
	FNDWORD k = 0;//
	if (period_info == NULL)
	{
		showWarning("时间表为空，请检查时间表\n");
		return NULL;
	}
	
	if (act_list == NULL)
	{
		showWarning("节目表为空，请检查节目表\n");
		return NULL;
	}
	
	if(period_info->dwSectionCnt == 0)
	{
		showWarning("节目表时段数量为0\n");
		return NULL;
	}
	
	if(time_pos >= (int)period_info->dwSectionCnt && time_pos < 0)
	{
		showWarning("当前时间在时间表时段内越界\n");
		return NULL;
	}

	current_pos = current_pos + 1;
	if(current_pos >= (int)period_info->SectionList[time_pos].dwActCnt)//循环播放
	{
		current_pos=0;
	}
	 showDebug("*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-40\n");
	//获取到一个播放的节目号，还要通过这个号码在节目表中找到具体的节目
	k = period_info->SectionList[time_pos].dwActList[current_pos];

	for(FNDWORD i=0;i<act_list->dwActNum;i++)
	{
	
		if(act_list->ActList[i].sActInfo.dwActID == k)
		{
			act_endtime = period_info->SectionList[time_pos].dwEndTime;
			return &act_list->ActList[i];
		
		}

	}
	
	showWarning("获取节目%u失败，当前时段为%u\n",k,time_pos );
	act_endtime = 0;
	return NULL;
}

// =======================================================
static void catch_sigchild(int signal_number)
{
  int status;
  int iClientPid;

  while( (iClientPid = waitpid (-1, &status, WNOHANG)) > 0)
    {
	  showDebug(1, "Releasing client by pid : %d\n", iClientPid);
      g_Server->ReleaseClientByPid(iClientPid);
      // Save last child exit status in global variable
      child_exit_status = status;
	}
}

// =======================================================
void CImageNet::Connect(COptions * options, char * login, char * passwd,
   char * server, int port)
{
  int nRes;
  lock(__LINE__);
  try { netcl -> Connect(server, port); }
  catch ( CExceptions * excep )
    {
      unlock();
      throw excep;
    }
  nRes = netcl -> SendPass(login, passwd);
  if (nRes)
    {
      unlock();
      showDebug(1, "return from SendPass: failed (%d)\n", nRes);
      THROW(ERR_PASSWD);
    }
  netcl -> Send(options, sizeof(COptions));
  unlock();
  showDebug(9, "return from SendPass: success\n");
}

// =======================================================
void CXfsPart::readBitmap(COptions *options)
{
  BEGIN;

  int nRes;
  DWORD i;
  QWORD j;
  xfs_agf agf;

  // init bitmap -> all blocks marked as used (1)
  m_bitmap.init(m_header.qwBitmapSize+1024);
  for (j=0; j < m_header.qwBlocksCount; j++)
    m_bitmap.setBit(j, true);

  // ---- process allocation groups
  
  // 1. go to the beginning of the disk
  nRes = fseek(m_fDeviceFile, 0, SEEK_SET);
  if (nRes == -1)
    THROW(ERR_ERRNO, errno);

  // 2. loop for each AG of the file system
  for (i=0; i < m_info.dwAgCount; i++)
    {
      nRes = readData(&agf, convertAgToDaddr(i, XFS_AGF_DADDR), sizeof(xfs_agf));
      if (nRes == -1)
	THROW(ERR_ERRNO, errno);

      if (((DWORD)BeToCpu(agf.agf_magicnum)) != XFS_AGF_MAGIC)
	{
	  g_interface -> ErrorReadingSuperblock(errno);
	  THROW(ERR_READING, (DWORD)0, errno);
	}

      showDebug(3, "\n\n== ALLOCATION GROUP %lu ===\nagf_flfirst=%lu\nagf_fllast=%lu\nagf_flcount=%lu\nagf_freeblks=%lu\nagf_longest=%lu\n"
		"agf_roots[0]=%lu and agf_roots[1]=%lu\nagf_levels[0]=%lu and agf_levels[1]=%lu\n", (DWORD)i, 
		(DWORD)BeToCpu(agf.agf_flfirst), (DWORD)BeToCpu(agf.agf_fllast), 
		(DWORD)BeToCpu(agf.agf_flcount), (DWORD)BeToCpu(agf.agf_freeblks), 
		(DWORD)BeToCpu(agf.agf_longest), (DWORD)BeToCpu(agf.agf_roots[0]), 
		(DWORD)BeToCpu(agf.agf_roots[1]), (DWORD)BeToCpu(agf.agf_levels[0]), 
		(DWORD)BeToCpu(agf.agf_levels[1]));

      scanFreelist(&agf);
      scanSbtree(&agf, BeToCpu(agf.agf_roots[XFS_BTNUM_BNO]), BeToCpu(agf.agf_levels[XFS_BTNUM_BNO]));
    }
  
  // fill informations about free/used clusters count
  calculateSpaceFromBitmap();

  RETURN;
}			

// ================================================
CNetServer::~CNetServer()
{
  showDebug(1, "cns detroyed\n");
  delete Clients;
/*
#ifdef HAVE_SSL
  for (unsigned int i = 0; i < nb_clients; i++)
    if (idf_clients[i].ssl)
      SSL_free(idf_clients[i].ssl);
  if (ctx)
    SSL_CTX_free(ctx);
#endif
*/
}

// =======================================================
// may raise ERR_OPENED, ERR_EOF
DWORD CImageDisk::read(void *buf, DWORD dwLength) // [Buffer-Thread]
{
  if (m_bIsOpened == false)
    THROW(ERR_OPENED);

  DWORD dwRes;
  errno = 0;
  
  // ****************************************

  //clearerr(m_fImageFile);
  dwRes = fread(buf, 1, dwLength, m_fImageFile);

  if (dwRes < dwLength)
    {
      showDebug(1, "EOF: dwRes=%lu and dwLength=%lu: MISSING: %lu\n", dwRes, dwLength, dwLength-dwRes);
    }

  m_qwTotal += (QWORD) dwRes; //dwLength;
  showDebug(1, "cid: %ld ; m_qwTotal = %lld\n", dwRes, m_qwTotal);

  return dwRes; // important: must return dwRes even if EOF reached
}

Light::Light(const string &entityName):Entity()
{
	LOG(FORMAT("Loading new entity `%1%` of type `%2%`", entityName % type()));

	mEntityName = entityName;

	// TODO: Load not Error mesh in Light class (get some other mesh type)
	mLight = graphicSystem.getSceneMgr()->createLight("Light:" + entityName);
	mDebugEntity = graphicSystem.getSceneMgr()->createEntity("LightMesh:" + entityName, CONFIG("resorces.LightMesh", string, "Engine/Light.mesh"));
	mNode = graphicSystem.getSceneMgr()->getRootSceneNode()->createChildSceneNode("Node:" + entityName);

	showDebug(true);
    mNode->attachObject(mLight);
}

// =======================================================
QWORD generateIdentificator()
{
  QWORD qwResult;
  int i;
  unsigned char *ptr;

  ptr = (unsigned char *) &qwResult;
  qwResult = time(NULL);
  
  for (i=0; i < (int)sizeof(qwResult); i++)
    ptr[i] ^= getpid();

  showDebug(3, "generateIdentificator() = %llu = %Xh\n", qwResult, qwResult);
  return qwResult;
}

// =======================================================
void CXfsPart::addToHist(DWORD dwAgNo, DWORD dwAgBlockNo, QWORD qwLen)
{
  BEGIN;

  QWORD i;
  QWORD qwBase;

  showDebug(3, "%8d %8d %8llu\n", dwAgNo, dwAgBlockNo, qwLen);
  qwBase = (((QWORD)dwAgNo) * ((QWORD)m_info.dwAgBlocksCount)) + ((QWORD)dwAgBlockNo);

  for (i=0; i < qwLen; i++)
    m_bitmap.setBit(qwBase+i, false);

  RETURN;
}

// =======================================================
void CInterface::showError(signed int nErr, char *szFormat, ...)
{
  va_list args;
  char szText[4096];

  // format text
  va_start(args, szFormat);
  vsnprintf(szText, sizeof(szText), szFormat, args);
  va_end(args);

  showDebug(1, "showError: [%s]\n", szText);

  if (!m_bBatchMode)
    msgBoxCancel(i18n("Error"), "%s", szText);
}