Exemple #1
0
void wxGL_PMFCanvas::Init() {
	FreezeRender = false;
	this->SetCurrent();
	// === === === Init GL === === === 
	// Initialize OpenGL function table
	vendor = wxString((char*)glGetString(GL_VENDOR), wxConvUTF8);
	renderer = wxString((char*)glGetString(GL_RENDERER), wxConvUTF8);
	version = wxString((char*)glGetString(GL_VERSION), wxConvUTF8);
	/*std::string extensions = (char*)glGetString(GL_EXTENSIONS);
	GLFunctions.LoadFunctionTable();*/

	glClearDepth(1.0f);									// Depth Buffer Setup
	glEnable(GL_DEPTH_TEST);							// Enables Depth Testing
	glDepthFunc(GL_LEQUAL);								// The Type Of Depth Testing To Do
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);	// Really Nice Perspective Calculations
	glShadeModel(GL_SMOOTH);

	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

	glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
	glEnable(GL_NORMALIZE);
	
	glClearColor(0, 0, 0, 1.0f);				// Black Background
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	// Clear Screen And Depth Buffer

	glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
//	glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
	glEnable(GL_COLOR_SUM);

	Reinit(true);
//	gr_debug = new debug_window(wxGetTopLevelParent(parent), GR_DEBUG_WINDOW, "Graphics Debug Output", wxPoint(1024-200,768-150), wxSize(200,150));
}
void CSoundtrackManager::SetGameState (EGameStates iNewState, CSoundType *pTrack)

//	SetGameState
//
//	Sets the current game state and starts playing the given track.

	{
	//	If our state has not changed, then nothing to do

	if (iNewState == m_iGameState
			&& pTrack == m_pNowPlaying)
		return;

	//	Set our state

	m_iGameState = iNewState;

	//	If we're back at program intro then reinit our playlist.

	if (iNewState == stateProgramIntro)
		Reinit();

	//	Play the soundtrack

	Play(pTrack);
	}
Exemple #3
0
//Init
bool Menu::Init (Err *pErr, Config *pConfig, Config *pLanguage,
                 Profiles *pProfiles, sf::RenderWindow *pWindow)
{
    if (!m_Err.SetClass (pErr, L"Menu") ||
        !Render::Init (&m_Err, pWindow))
    {
        return false;
    }
    Err fErr (m_Err, L"Init");
    if (pConfig == NULL || pLanguage == NULL ||
        pProfiles == NULL)
    {
        return fErr.Set (sERR_ARGUMENTS);
    }
    m_pConfig = pConfig;
    m_pLanguage = pLanguage;
    m_pProfiles = pProfiles;

    if (!m_pConfig->Get (sCONF_LEVELDIR, &m_sLevelDir) ||
        !m_pConfig->Get (L"LanguageDir", &m_sLanguageDir))
    {
        return false;
    }
    m_sLevelDir += L"/";
    m_sLanguageDir += L"/";

    m_pCurrentScreen = &m_ScreenMain;

    return Reinit ();
}//Init
Exemple #4
0
int CUstpFtdcMduserApi::HandleMsgFromATF()
{
	char rcvBuf[BUFSIZE] = {0};
	char * pRcvBuf = NULL;
	MsgHead *pMsg = NULL;

	/*======check if is a msg(MSGID_S2C_QUOTE_DISCONNECT) come from ATF======*/
	if(true == m_bLogined)
	{
		pRcvBuf = rcvBuf;
		int iExpectRcvLen = sizeof(MsgHead);
		if(iExpectRcvLen == TcpTimedRecvData(m_fdConnQuoteSvr,pRcvBuf,iExpectRcvLen,50))
		{
			pMsg = (MsgHead *)pRcvBuf;					   
			if(MSGID_S2C_QUOTE_DISCONNECT == ntohs(pMsg->iMsgID))
			{
				g_log.info("Received  MSGID_S2C_QUOTE_DISCONNECT, %dB\n",iExpectRcvLen);
				
				m_FtdcMdSpi_instance->OnFrontDisconnected(0x1001);
				
				Reinit();
				
				SetState(STATUS_QUOTE_INIT);

				return ATF_SUCC;
			}
		}
		
	}
	else
		return ATF_FAIL;

	return ATF_SUCC;
}
Exemple #5
0
bool SnapManager::Snap(Track *currentTrack,
                       double t,
                       bool rightEdge,
                       double *outT,
                       bool *snappedPoint,
                       bool *snappedTime)
{
   // Check to see if we need to reinitialize
   Reinit();

   // First snap to points in mSnapPoints
   *outT = t;
   *snappedPoint = SnapToPoints(currentTrack, t, rightEdge, outT);

   // Now snap to the time grid
   *snappedTime = false;
   if (mSnapToTime)
   {
      if (*snappedPoint)
      {
         // Since mSnapPoints only contains points on the grid, we're done
         *snappedTime = true;
      }
      else
      {
         // Snap time to the grid
         mConverter.ValueToControls(t, GetActiveProject()->GetSnapTo() == SNAP_NEAREST);
         mConverter.ControlsToValue();
         *outT = mConverter.GetValue();
         *snappedTime = true;
      }
   }

   return *snappedPoint || *snappedTime;
}
Exemple #6
0
void wxStringTokenizer::SetString(const wxString& str,
                                  const wxString& delims,
                                  wxStringTokenizerMode mode)
{
    if ( mode == wxTOKEN_DEFAULT )
    {
        // by default, we behave like strtok() if the delimiters are only
        // whitespace characters and as wxTOKEN_RET_EMPTY otherwise (for
        // whitespace delimiters, strtok() behaviour is better because we want
        // to count consecutive spaces as one delimiter)
        const wxChar *p;
        for ( p = delims.c_str(); *p; p++ )
        {
            if ( !wxIsspace(*p) )
                break;
        }

        if ( *p )
        {
            // not whitespace char in delims
            mode = wxTOKEN_RET_EMPTY;
        }
        else
        {
            // only whitespaces
            mode = wxTOKEN_STRTOK;
        }
    }

    m_delims = delims;
    m_mode = mode;

    Reinit(str);
}
Exemple #7
0
/** \fn ChromaKeyOSD::ProcessOSD(OSD*)
 * 
 *  \return true if we need a repaint, false otherwise
 */
bool ChromaKeyOSD::ProcessOSD(OSD *osd)
{
    OSDSurface *osdsurf = NULL;
    if (osd)
        osdsurf = osd->Display();

    int next = (current+1) & 0x1;
    if (!osdsurf && current >= 0)
    {
        Reset();
        return true;
    }
    else if (!osdsurf || (revision == osdsurf->GetRevision()))
        return false;

    // first create a blank frame with the chroma key
    Reinit(next);

    // then blend the OSD onto it
    unsigned char *buf = (unsigned char*) shm_infos[next].shmaddr;
    osdsurf->BlendToARGB(buf, img[next]->bytes_per_line, vf[next].height,
                         false/*blend_to_black*/, 16);

    // then set it as the current OSD image
    revision = osdsurf->GetRevision();
    current  = next;

    return true;
}
Exemple #8
0
SnapManager::SnapManager(const TrackList *tracks,
                         const ZoomInfo *zoomInfo,
                         const TrackClipArray *clipExclusions,
                         const TrackArray *trackExclusions,
                         bool noTimeSnap,
                         int pixelTolerance)
:  mConverter(NumericConverter::TIME)
{
   mTracks = tracks;
   mZoomInfo = zoomInfo;
   mClipExclusions = clipExclusions;
   mTrackExclusions = trackExclusions;
   mPixelTolerance = pixelTolerance;
   mNoTimeSnap = noTimeSnap;

   mProject = GetActiveProject();
   wxASSERT(mProject);

   mSnapTo = 0;
   mRate = 0.0;
   mFormat.Empty();

   // Two time points closer than this are considered the same
   mEpsilon = 1 / 44100.0;

   Reinit();
}
Exemple #9
0
	void AddTorrent::SetFilename (const QString& filename)
	{
		if (filename.isEmpty ())
			return;

		Reinit ();

		XmlSettingsManager::Instance ()->setProperty ("LastTorrentDirectory",
				QFileInfo (filename).absolutePath ());
		Ui_.TorrentFile_->setText (filename);

		ParseBrowsed ();
	}
/*
** SetSimpleMode
** Description:
**		Tell af to use simple mode
*/
void
AirframeClass::SetSimpleMode( int mode )
{
	if ( mode == simpleMode )
		return;

	if(simpleMode != SIMPLE_MODE_OFF && mode == SIMPLE_MODE_OFF) {
		Reinit();
		// MonoPrint("Reinit() Called \n");
	}

	simpleMode = mode;
}
Exemple #11
0
void FinishPatching()
{
	CopyTempPathFiles();

	// Successfully updated!
	g_Patcher_IsUpdating = false;

	Reinit();

	AddStatus( "Update successful!", g_StatusColor );

	g_ShouldLaunchApp = true;
}
Exemple #12
0
void Tiger::Final(byte *hash)
{
	PadLastBlock(56, 0x01);
	CorrectEndianess(data, data, 56);

	data[7] = countLo;

	Transform(digest, data);
	CorrectEndianess(digest, digest, DigestSize());
	memcpy(hash, digest, DigestSize());

	Reinit();		// reinit for next use
}
MLIFont::MLIFont(const string &ttfFilePath, int fontSize, int strokeWidth, bool invertedColors)
    : ttfFilePath(ttfFilePath),
      fontSize(fontSize),
      strokeWidth(strokeWidth),
      cache(CacheSize, new CacheItemHandler(this)),
      invertedColors(invertedColors)
{
    EnsureUIThread();

    pTtfFont = NULL;
    pTtfFontMem = NULL;
    pAccessSemaphore = SDL_CreateSemaphore(1);

    Reinit();
}
Exemple #14
0
// helper function: does real copy
bool wxStringImpl::AssignCopy(size_t nSrcLen,
                              const wxStringCharType *pszSrcData)
{
  if ( nSrcLen == 0 ) {
    Reinit();
  }
  else {
    if ( !AllocBeforeWrite(nSrcLen) ) {
      // allocation failure handled by caller
      return false;
    }
    memcpy(m_pchData, pszSrcData, nSrcLen*sizeof(wxStringCharType));
    GetStringData()->nDataLength = nSrcLen;
    m_pchData[nSrcLen] = wxT('\0');
  }
  return true;
}
Exemple #15
0
	void AddTorrent::on_TorrentBrowse__released ()
	{
		const auto& filename = QFileDialog::getOpenFileName (this,
				tr ("Select torrent file"),
				XmlSettingsManager::Instance ()->property ("LastTorrentDirectory").toString (),
				tr ("Torrents (*.torrent);;All files (*.*)"));
		if (filename.isEmpty ())
			return;

		Reinit ();

		XmlSettingsManager::Instance ()->setProperty ("LastTorrentDirectory",
				QFileInfo (filename).absolutePath ());
		Ui_.TorrentFile_->setText (filename);

		ParseBrowsed ();
	}
Exemple #16
0
void HAVAL::Final (byte *hash)
{
	PadLastBlock(118, 1);	// first byte of padding for HAVAL is 1 instead of 0x80
	CorrectEndianess(data, data, 120);

	data[29] &= 0xffff;
	data[29] |= ((word32)digestSize<<25) | ((word32)pass<<19) | ((word32)VERSION<<16);
	data[30] = countLo;
	data[31] = countHi;

	vTransform(data);
	Tailor(digestSize*8);
	CorrectEndianess(digest, digest, digestSize);
	memcpy(hash, digest, digestSize);

	Reinit();		// reinit for next use
}
MLIFont::MLIFont(const string &fontId, int strokeWidth, bool invertedColors)
    : strokeWidth(strokeWidth),
      cache(CacheSize, new CacheItemHandler(this)),
      invertedColors(invertedColors)
{
    EnsureUIThread();

    this->fontId = fontId;

    pTtfFont = NULL;
    pTtfFontMem = NULL;
    pAccessSemaphore = SDL_CreateSemaphore(1);

    Reinit();

    gpLocalizableContent->AddLocalizableFont(this);
}
Exemple #18
0
// assigns one string to another
wxStringImpl& wxStringImpl::operator=(const wxStringImpl& stringSrc)
{
  wxASSERT( stringSrc.GetStringData()->IsValid() );

  // don't copy string over itself
  if ( m_pchData != stringSrc.m_pchData ) {
    if ( stringSrc.GetStringData()->IsEmpty() ) {
      Reinit();
    }
    else {
      // adjust references
      GetStringData()->Unlock();
      m_pchData = stringSrc.m_pchData;
      GetStringData()->Lock();
    }
  }

  return *this;
}
Exemple #19
0
SnapResults SnapManager::Snap
(Track *currentTrack, double t, bool rightEdge)
{

   SnapResults results;
   // Check to see if we need to reinitialize
   Reinit();

   results.timeSnappedTime = results.outTime = t;
   results.outCoord = mZoomInfo->TimeToPosition(t);

   // First snap to points in mSnapPoints
   results.snappedPoint =
      SnapToPoints(currentTrack, t, rightEdge, &results.outTime);

   if (mSnapToTime) {
      // Find where it would snap time to the grid
      mConverter.ValueToControls(t, GetActiveProject()->GetSnapTo() == SNAP_NEAREST);
      mConverter.ControlsToValue();
      results.timeSnappedTime = mConverter.GetValue();
   }

   results.snappedTime = false;
   if (mSnapToTime)
   {
      if (results.snappedPoint)
      {
         // Since mSnapPoints only contains points on the grid, we're done
         results.snappedTime = true;
      }
      else
      {
         results.outTime = results.timeSnappedTime;
         results.snappedTime = true;
      }
   }

   if (results.Snapped())
      results.outCoord = mZoomInfo->TimeToPosition(results.outTime);

   return results;
}
Exemple #20
0
// helper function: does real copy
bool wxStringImpl::AssignCopy(size_t nSrcLen,
                              const wxStringCharType *pszSrcData)
{
  if ( nSrcLen == 0 ) {
    Reinit();
  }
  else {
    if ( !AllocBeforeWrite(nSrcLen) ) {
      // allocation failure handled by caller
      return false;
    }

    // use memmove() and not memcpy() here as we might be copying from our own
    // buffer in case of assignment such as "s = s.c_str()" (see #11294)
    memmove(m_pchData, pszSrcData, nSrcLen*sizeof(wxStringCharType));

    GetStringData()->nDataLength = nSrcLen;
    m_pchData[nSrcLen] = wxT('\0');
  }
  return true;
}
Exemple #21
0
void wxStringTokenizer::SetString(const wxString& str,
                                  const wxString& delims,
                                  wxStringTokenizerMode mode)
{
    if ( mode == wxTOKEN_DEFAULT )
    {
        // by default, we behave like strtok() if the delimiters are only
        // whitespace characters and as wxTOKEN_RET_EMPTY otherwise (for
        // whitespace delimiters, strtok() behaviour is better because we want
        // to count consecutive spaces as one delimiter)
        wxString::const_iterator p;
        for ( p = delims.begin(); p != delims.end(); ++p )
        {
            if ( !wxIsspace(*p) )
                break;
        }

        if ( p != delims.end() )
        {
            // not whitespace char in delims
            mode = wxTOKEN_RET_EMPTY;
        }
        else
        {
            // only whitespaces
            mode = wxTOKEN_STRTOK;
        }
    }

#if wxUSE_UNICODE // FIXME-UTF8: only wc_str()
    m_delims = delims.wc_str();
#else
    m_delims = delims.mb_str();
#endif
    m_delimsLen = delims.length();

    m_mode = mode;

    Reinit(str);
}
FThinkerIterator::FThinkerIterator (const PClass *type, int statnum, DThinker *prev)
{
	if ((unsigned)statnum > MAX_STATNUM)
	{
		m_Stat = STAT_FIRST_THINKING;
		m_SearchStats = true;
	}
	else
	{
		m_Stat = statnum;
		m_SearchStats = false;
	}
	m_ParentType = type;
	if (prev == NULL || (prev->NextThinker->ObjectFlags & OF_Sentinel))
	{
		Reinit();
	}
	else
	{
		m_CurrThinker = prev->NextThinker;
		m_SearchingFresh = false;
	}
}
Exemple #23
0
void MD5MAC::TruncatedFinal(byte *hash, unsigned int size)
{
	assert(size <= DIGESTSIZE);

	PadLastBlock(56);
	CorrectEndianess(data, data, 56);

	data[14] = countLo;
	data[15] = countHi;

	Transform(digest, data, key+4);

	unsigned i;
	for (i=0; i<4; i++)
		data[i] = key[8+i];
	for (i=0; i<12; i++)
		data[i+4] = T[i] ^ key[8+i%4];
	Transform(digest, data, key+4);

	CorrectEndianess(digest, digest, DIGESTSIZE);
	memcpy(hash, digest, size);

	Reinit();		// reinit for next use
}
Exemple #24
0
int IPCStream::Uninit( )
{
	return Reinit( );
}
 explicit Percent(unsigned max_value, unsigned step = 5) { Reinit(max_value, step); }
Exemple #26
0
bool wxRegExImpl::Compile(const wxString& expr, int flags)
{
    Reinit();

#ifdef WX_NO_REGEX_ADVANCED
#   define FLAVORS wxRE_BASIC
#else
#   define FLAVORS (wxRE_ADVANCED | wxRE_BASIC)
    wxASSERT_MSG( (flags & FLAVORS) != FLAVORS,
                  wxT("incompatible flags in wxRegEx::Compile") );
#endif
    wxASSERT_MSG( !(flags & ~(FLAVORS | wxRE_ICASE | wxRE_NOSUB | wxRE_NEWLINE)),
                  wxT("unrecognized flags in wxRegEx::Compile") );

    // translate our flags to regcomp() ones
    int flagsRE = 0;
    if ( !(flags & wxRE_BASIC) )
    {
#ifndef WX_NO_REGEX_ADVANCED
        if (flags & wxRE_ADVANCED)
            flagsRE |= REG_ADVANCED;
        else
#endif
            flagsRE |= REG_EXTENDED;
    }
    if ( flags & wxRE_ICASE )
        flagsRE |= REG_ICASE;
    if ( flags & wxRE_NOSUB )
        flagsRE |= REG_NOSUB;
    if ( flags & wxRE_NEWLINE )
        flagsRE |= REG_NEWLINE;

    // compile it
#ifdef WXREGEX_USING_BUILTIN
    bool conv = true;
    // FIXME-UTF8: use wc_str() after removing ANSI build
    int errorcode = wx_re_comp(&m_RegEx, expr.c_str(), expr.length(), flagsRE);
#else
    // FIXME-UTF8: this is potentially broken, we shouldn't even try it
    //             and should always use builtin regex library (or PCRE?)
    const wxWX2MBbuf conv = expr.mbc_str();
    int errorcode = conv ? regcomp(&m_RegEx, conv, flagsRE) : REG_BADPAT;
#endif

    if ( errorcode )
    {
        wxLogError(_("Invalid regular expression '%s': %s"),
                   expr.c_str(), GetErrorMsg(errorcode, !conv).c_str());

        m_isCompiled = false;
    }
    else // ok
    {
        // don't allocate the matches array now, but do it later if necessary
        if ( flags & wxRE_NOSUB )
        {
            // we don't need it at all
            m_nMatches = 0;
        }
        else
        {
            // we will alloc the array later (only if really needed) but count
            // the number of sub-expressions in the regex right now

            // there is always one for the whole expression
            m_nMatches = 1;

            // and some more for bracketed subexperessions
            for ( const wxChar *cptr = expr.c_str(); *cptr; cptr++ )
            {
                if ( *cptr == wxT('\\') )
                {
                    // in basic RE syntax groups are inside \(...\)
                    if ( *++cptr == wxT('(') && (flags & wxRE_BASIC) )
                    {
                        m_nMatches++;
                    }
                }
                else if ( *cptr == wxT('(') && !(flags & wxRE_BASIC) )
                {
                    // we know that the previous character is not an unquoted
                    // backslash because it would have been eaten above, so we
                    // have a bare '(' and this indicates a group start for the
                    // extended syntax. '(?' is used for extensions by perl-
                    // like REs (e.g. advanced), and is not valid for POSIX
                    // extended, so ignore them always.
                    if ( cptr[1] != wxT('?') )
                        m_nMatches++;
                }
            }
        }

        m_isCompiled = true;
    }

    return IsValid();
}
void MLIFont::ReloadFontInfo()
{
    Reinit();
}
Exemple #28
0
//ChooseScreen
bool Menu::ChooseScreen (bool *pbQuit)
{
    Err fErr (m_Err, L"ChooseScreen");
    if (pbQuit == NULL)
    {
        return fErr.Set (sERR_ARGUMENTS);
    }
    if (m_pCurrentScreen == NULL)
    {
        return fErr.Set (L"The pointer for the current screen is invalid");
    }

    unsigned int nSelected;
    if (!m_pCurrentScreen->GetSelectId (&nSelected))
    {
        return false;
    }

    switch (nSelected)
    {
        case (eMainButtonStart):
            m_pCurrentScreen = &m_ScreenGame;
            break;
        case (eGameButtonPlay):
            if (!PrepareGameStart ())
            {
                return false;
            }
            *pbQuit = false;
            break;
        case (eMainButtonQuit):
            m_bClose = true;
            break;
        case (eMainButtonSettings):
            m_pCurrentScreen = &m_ScreenSettings;
            break;
        case (eMainButtonProfiles):
            if (!ManageProfileScreens ())
            {
                return false;
            }
            break;
        case (eMainButtonAbout):
            m_pCurrentScreen = &m_ScreenAbout;
            break;
        case (eGameButtonAbort):
        case (eAboutButtonAbort):
        case (eSettingsButtonAbort):
            m_pCurrentScreen = &m_ScreenMain;
            break;
        case (eSettingsButtonOk):
        case (eSettingsButtonAccept):
            {
                if (!ApplySettings () ||
                    !Reinit () ||
                    !m_pConfig->Save ())
                {
                    return false;
                }

                if (nSelected == eSettingsButtonOk)
                {
                    m_pCurrentScreen = &m_ScreenMain;
                }
                break;
            }
        default:
            return fErr.Set (L"The given selectection id is unknown: " +
                             NumToStr (nSelected));
    }

    return true;
}//ChooseScreen