void DirectShowEventLoop::customEvent(QEvent *event)
{
if (event->type() == QEvent::User) {
processEvents();
} else {
QObject::customEvent(event);
}
}
bool DesignerApp::initApplication(QString cmdLine)
{
QLocale::setDefault(QLocale(QLocale::English));
QTextCodec::setCodecForTr(QTextCodec::codecForLocale());
QPixmap pixmap(":/designer/splash.png");
QSplashScreen *splash = new QSplashScreen(pixmap);
splash->show();
splash->showMessage(tr("Loading..."));
processEvents();
writeConfigValue("", "apppath", QtSingleApplication::applicationFilePath());
dbIgame = QSqlDatabase::addDatabase("QMYSQL","igame");
dbIgame.setDatabaseName("MoDeL");
dbIgame.setHostName("localhost");
dbIgame.setUserName("root");
dbIgame.setPassword("lovewin");
dbIgame.open();
DesignerViewMgr::initializeIfNotYet();
DesignerDocMgr::initializeIfNotYet();
DesignerModelMgr::initializeIfNotYet();
DesignerExtensionMgr::initializeIfNotYet();
DesignerMainWnd* mainWnd = DesignerMainWnd::globalCreateNewMainWnd();
setActivationWindow(mainWnd);
QObject::connect(this, SIGNAL(messageReceived(const QString&)), mainWnd, SLOT(instanceMessageReceived(const QString&)));
splash->setWindowFlags(Qt::WindowStaysOnTopHint);
splash->setParent(mainWnd);
splash->show();
QTimer::singleShot(1500, splash, SLOT(close()));
if(cmdLine!="/new")
mainWnd->instanceMessageReceived(cmdLine);
while(splash->isVisible())
{
processEvents();
}
return true;
}
void Game::run()
{
while (mWindow.isOpen())
{
processEvents();
render();
}
}
void Game::run()
{
sf::Clock clock;
sf::Time timeSinceLastUpdate = sf::Time::Zero;
while (mWindow.isOpen())
{
processEvents();
timeSinceLastUpdate += clock.restart();
while (timeSinceLastUpdate > TimePerFrame)
{
timeSinceLastUpdate -= TimePerFrame;
processEvents();
update(TimePerFrame);
}
render();
}
}
void AmCallWatcher::run() {
DBG("starting call watcher.\n");
garbage_collector->start();
while (true) {
waitForEvent();
processEvents();
}
}
/**
* Waits for new OSX event (TODO: thread)
* Virtual
*
* @return RawEvent object
*/
void EventMonitorMac::waitForEvents() {
int i = 10;
while ( events.size() == 0 ) {
// Wait for some event
processEvents();
usleep(75000);
}
}
void TuioDemo::run() {
running=true;
while (running) {
drawObjects();
processEvents();
SDL_Delay(40);
}
}
void run() {
do {
processEvents();
update();
render();
}
while (_window.isOpen());
}
void InputSystem::tick()
{
if (!m_isCapturing) {
return;
}
processEvents();
}
// ============================================================================
ssize_t PacketManager::sendto_Err(int s, void *buf, size_t len, int flags,
const struct sockaddr *to, socklen_t tolen)
{
int nResult = 0;
if (buf == NULL)
{
ERR_PRINT("buf pointer == NULL\n");
exit(1);
}
if (len == 0)
{
ERR_PRINT("len == 0: %u\n", len);
exit(1);
}
if (to == NULL)
{
ERR_PRINT("sockaddr pointer == NULL\n");
exit(1);
}
++m_MsgNo;
uint32_t seqNo = ntohl(*(uint32_t*)(buf));
MSG_PRINT("MSG# %3u SEQ# %3u LEN %4u FLAGS 0x%08X\n", m_MsgNo, seqNo, len, flags);
size_t lenTmp = len;
unsigned char bufTmp[len];
memcpy(bufTmp, buf, lenTmp);
void* pBuf = bufTmp;
nResult = processEvents((void**)&pBuf, &lenTmp, m_MsgNo);
if (nResult < 0)
{
ERR_PRINT("prcoessEvents\n");
return nResult;
}
else if ((nResult == 0) || (nResult == 1))
{
ssize_t lenSent = sendto(s, pBuf, lenTmp, flags, to, tolen);
if (lenSent == (ssize_t)lenTmp)
{
return len;
}
else
{
return lenSent;
}
}
else
{
return len;
}
return -1;
}
int main(int argc, const char** argv)
{
XInitThreads();
s_display = XOpenDisplay(0);
int32_t screen = DefaultScreen(s_display);
int32_t depth = DefaultDepth(s_display, screen);
Visual* visual = DefaultVisual(s_display, screen);
Window root = RootWindow(s_display, screen);
XSetWindowAttributes windowAttrs = { 0 };
windowAttrs.background_pixmap = 0;
windowAttrs.border_pixel = 0;
windowAttrs.event_mask = 0
| ButtonPressMask
| ButtonReleaseMask
| ExposureMask
| KeyPressMask
| KeyReleaseMask
| PointerMotionMask
| StructureNotifyMask
;
int width = 800;
int height = 600;
s_window = XCreateWindow(s_display
, root
, 0, 0
, width, height, 0, depth
, InputOutput
, visual
, CWBorderPixel | CWEventMask
, &windowAttrs
);
// Clear window to black.
XSetWindowAttributes attr = { 0 };
XChangeWindowAttributes(s_display, s_window, CWBackPixel, &attr);
const char* wmDeleteWindowName = "WM_DELETE_WINDOW";
XInternAtoms(s_display, (char**)&wmDeleteWindowName, 1, False, &wmDeleteWindow);
XSetWMProtocols(s_display, s_window, &wmDeleteWindow, 1);
XMapWindow(s_display, s_window);
XStoreName(s_display, s_window, "ProDBG");
bgfx::x11SetDisplayWindow(s_display, s_window);
ProDBG_create((void*)s_window, width, height);
processEvents();
XUnmapWindow(s_display, s_window);
XDestroyWindow(s_display, s_window);
return EXIT_SUCCESS;
}
void MenuServeur::run()
{
while (mWindow.isOpen())
{
// musiccc();
processEvents();
render();
}
}
int Application::main(int argc, char **argv) {
app = new App(argc, argv);
#if !defined(_WIN32)
//Windows port uses 256x256 icon from resource file
app->setWindowIcon(QIcon(":/bsnes.png"));
#endif
initargs(argc, argv); //ensure argv[]s are in UTF-8 format
initPaths(argv[0]);
locateFile(configFilename = "bsnes.cfg", true);
locateFile(styleSheetFilename = "style.qss", false);
string customStylesheet;
if(customStylesheet.readfile(styleSheetFilename) == true) {
app->setStyleSheet((const char*)customStylesheet);
} else {
app->setStyleSheet(defaultStylesheet);
}
config.load(configFilename);
init();
snes.init();
if(argc == 2) {
//if valid file was specified on the command-line, attempt to load it now
utility.loadCartridge(argv[1]);
}
while(terminate == false) {
processEvents();
utility.updateSystemState();
inputManager.refresh();
if(config.input.focusPolicy == Configuration::Input::FocusPolicyPauseEmulation) {
bool inactive = (winMain->window->isActiveWindow() == false);
if(!autopause && inactive) {
autopause = true;
audio.clear();
} else if(autopause && !inactive) {
autopause = false;
}
} else {
autopause = false;
}
if(cartridge.loaded() && !pause && !autopause) {
snes.runtoframe();
} else {
usleep(20 * 1000);
}
supressScreenSaver();
}
config.save(configFilename);
return 0;
}
void run()
{
while (mWindow.isOpen())
{
processEvents();
update();
render();
}
}
void PongGame::run() {
sf::Clock clock;
sf::Time timeSinceLastUpdate = sf::Time::Zero;
while (mainWindow.isOpen()) {
processEvents();
sf::Time elapsedTime = clock.restart();
timeSinceLastUpdate += elapsedTime;
while (timeSinceLastUpdate > timePerFrame) {
timeSinceLastUpdate -= timePerFrame;
processEvents();
// no matter what happens, give the same delta time to the update function
update();
}
updateStatistics(elapsedTime);
render();
}
}
void GameEngine::run(void)
{
sf::Clock clock;
sf::Time lastUpdate = sf::Time::Zero;
while(_mWindow.isOpen())
{
processEvents();
lastUpdate += clock.restart();
while (lastUpdate > _timePerFrame)
{
lastUpdate -= _timePerFrame;
processEvents();
update(_timePerFrame); // A revoir
}
render();
}
}
void Game::run()
{
while (mWindow.isOpen())
{
processEvents();
update(timePerFrame);
render();
}
}
/*!
Enters the main event loop and waits until exit() is called.
Returns the value that was passed to exit().
If \a flags are specified, only events of the types allowed by
the \a flags will be processed.
It is necessary to call this function to start event handling. The
main event loop receives events from the window system and
dispatches these to the application widgets.
Generally speaking, no user interaction can take place before
calling exec(). As a special case, modal widgets like QMessageBox
can be used before calling exec(), because modal widgets
use their own local event loop.
To make your application perform idle processing (i.e. executing a
special function whenever there are no pending events), use a
QTimer with 0 timeout. More sophisticated idle processing schemes
can be achieved using processEvents().
\sa QCoreApplication::quit(), exit(), processEvents()
*/
int QEventLoop::exec(ProcessEventsFlags flags)
{
Q_D(QEventLoop);
//we need to protect from race condition with QThread::exit
QMutexLocker locker(&static_cast<QThreadPrivate *>(QObjectPrivate::get(d->threadData->thread))->mutex);
if (d->threadData->quitNow)
return -1;
if (d->inExec) {
qWarning("QEventLoop::exec: instance %p has already called exec()", this);
return -1;
}
struct LoopReference {
QEventLoopPrivate *d;
QMutexLocker &locker;
bool exceptionCaught;
LoopReference(QEventLoopPrivate *d, QMutexLocker &locker) : d(d), locker(locker), exceptionCaught(true)
{
d->inExec = true;
d->exit.storeRelease(false);
++d->threadData->loopLevel;
d->threadData->eventLoops.push(d->q_func());
locker.unlock();
}
~LoopReference()
{
if (exceptionCaught) {
qWarning("Qt has caught an exception thrown from an event handler. Throwing\n"
"exceptions from an event handler is not supported in Qt.\n"
"You must not let any exception whatsoever propagate through Qt code.\n"
"If that is not possible, in Qt 5 you must at least reimplement\n"
"QCoreApplication::notify() and catch all exceptions there.\n");
}
locker.relock();
QEventLoop *eventLoop = d->threadData->eventLoops.pop();
Q_ASSERT_X(eventLoop == d->q_func(), "QEventLoop::exec()", "internal error");
Q_UNUSED(eventLoop); // --release warning
d->inExec = false;
--d->threadData->loopLevel;
}
};
LoopReference ref(d, locker);
// remove posted quit events when entering a new event loop
QCoreApplication *app = QCoreApplication::instance();
if (app && app->thread() == thread())
QCoreApplication::removePostedEvents(app, QEvent::Quit);
while (!d->exit.loadAcquire())
processEvents(flags | WaitForMoreEvents | EventLoopExec);
ref.exceptionCaught = false;
return d->returnCode.load();
}
void setOpaqueChildren(bool enable)
{
if (opaqueChildren != enable) {
foreach (QWidget *w, children)
w->setAttribute(Qt::WA_OpaquePaintEvent, enable);
opaqueChildren = enable;
processEvents();
}
}
void Tasklet::run() {
platform::setThreadName("'"+name+"' (tasklet)");
isAlive = true;
bool hasError = false;
string errorMsg = "";
try {
// make sure that our GL context is the current context
if(window != NULL) {
window->context->makeCurrent();
}
startup();
if (running) {
double framerate = config.framerate;
double offset = clock.getTime();
while (thread->get_state() == TaskletThread::RUNNING && running) {
processEvents();
if (running) {
update(framerate);
render();
if(waitForEvents) { eventDispatcher->waitForEvents(); }
framerate = clock.getElapsedAndUpdateOffset(offset);
}
}
shutdown();
// unbind GL context
if(window != NULL) {
window->context->clearCurrent();
}
}
}
catch(std::exception& ex)
{
errorMsg = ex.what();
hasError = true;
}
catch (...) {
errorMsg = "<catch all>";
hasError = true;
}
isAlive = false;
dispatchApplicationEvent(TaskletEventPtr(new TaskletEvent(TaskletEvent::DONE(), this)));
if (hasError) {
std::ostringstream os;
os << "Tasklet '"<<name<<"' terminated with error: " <<errorMsg;
throw std::runtime_error(os.str());
}
}
void PipeBase::run()
{
gcTrace("");
while (!isStopped())
{
processEvents();
processLoopback();
}
}
void UGui::processEvents(Drawable* d) {
while (d) {
d->predraw();
eventLock();
d->processEvents();
eventUnlock();
processEvents(d->_children);
d = d->next();
}
}
void Game::run() {
sf::Clock c;
srand(time(0));
while(window.isOpen()) {
float deltaTime = c.restart().asSeconds();
processEvents();
update(deltaTime);
render();
}
}
void pApplication::run() {
if(Application::state.onMain) {
while(!Application::state.quit) {
Application::doMain();
processEvents();
}
} else {
gtk_main();
}
}
bool DirectShowEventLoop::event(QEvent *event)
{
if (event->type() == QEvent::WinEventAct) {
processEvents();
return true;
} else {
return QWinEventNotifier::event(event);
}
}
void pApplication::run() {
if(Application::main) {
while(applicationState.quit == false) {
processEvents();
Application::main();
}
} else {
gtk_main();
}
}
/*!
Process pending events that match \a flags for a maximum of \a
maxTime milliseconds, or until there are no more events to
process, which ever is shorter.
This function is especially useful if you have a long running
operation and want to show its progress without allowing user
input, i.e. by using the \c ExcludeUserInput flag.
NOTE: This function will not process events continuously; it
returns after all available events are processed.
NOTE: Specifying the \c WaitForMore flag makes no sense and will
be ignored.
*/
void QEventLoop::processEvents( ProcessEventsFlags flags, int maxTime )
{
QTime start = QTime::currentTime();
QTime now;
while ( ! d->quitnow && processEvents( flags & ~WaitForMore ) ) {
now = QTime::currentTime();
if ( start.msecsTo( now ) > maxTime )
break;
}
}
/**
* Initializes the LibDS system and instructs the class to close the LibDS
* before the Qt application is closed.
*/
void DriverStation::start()
{
if (!DS_Initialized()) {
DS_Init();
processEvents();
updateElapsedTime();
emit statusChanged (generalStatus());
connect (qApp, SIGNAL (aboutToQuit()), this, SLOT (quitDS()));
}
}
void EventsManager::runMainLoop() {
while (!_doQuit) {
// (Pre)Process all events
processEvents();
_queueProcessed.signal();
// Render a frame
GfxMan.renderScene();
}
}
const Scene::ExitAction PlayModeSelect::run(){
manager.restart();
while (window.isOpen()){
Scene::ExitAction act = processEvents();
if (act != Scene::ExitAction::NoAction){
return act;
}
render();
}
return Scene::ExitAction::Exit;
}
