MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), m_currentTab(0), m_errorTab(0), m_scriptEnvironment(this)
{
QNetworkProxyFactory::setUseSystemConfiguration(true);
setupUi(this);
ui_projects->hide(); // Disabled for now
/* Turns off updates so all of these things are drawn at once */
setUpdatesEnabled(false);
/* Deletes the tab that QTabWidget starts with by default */
deleteTab(0);
hideErrors();
connect(&m_errorList, SIGNAL(itemDoubleClicked(QListWidgetItem*)), this, SLOT(errorClicked(QListWidgetItem*)));
connect(&m_warningList, SIGNAL(itemDoubleClicked(QListWidgetItem*)), this, SLOT(errorClicked(QListWidgetItem*)));
connect(&m_linkErrorList, SIGNAL(itemDoubleClicked(QListWidgetItem*)), this, SLOT(errorClicked(QListWidgetItem*)));
connect(&m_verboseList, SIGNAL(itemDoubleClicked(QListWidgetItem*)), this, SLOT(errorClicked(QListWidgetItem*)));
initMenus();
setTitle("");
setUpdatesEnabled(true);
}
LorrisProgrammer::LorrisProgrammer()
: WorkTab(), m_logsink(this)
{
m_connectButton = NULL;
ui = NULL;
m_chipStopped = false;
m_overvcc_dialog = NULL;
m_overvcc = 0.0;
m_enable_overvcc = false;
m_overvcc_turnoff = false;
lastVccIndex = 0;
m_progress_dialog = NULL;
m_state = 0;
m_buttons_enabled = false;
m_mode_act_signalmap = new QSignalMapper(this);
connect(m_mode_act_signalmap, SIGNAL(mapped(int)), SLOT(modeSelected(int)));
m_prog_speed_hz = sConfig.get(CFG_QUINT32_SHUPITO_PRG_SPEED);
if(m_prog_speed_hz < 1)
m_prog_speed_hz = 2000000;
initMenus();
setUiType(UI_FULL);
m_timeout_timer.setInterval(TIMEOUT_INTERVAL);
connect(qApp, SIGNAL(focusChanged(QWidget*,QWidget*)), SLOT(focusChanged(QWidget*,QWidget*)));
connect(&m_timeout_timer, SIGNAL(timeout()), SLOT(timeout()));
connectedStatus(false);
}
BtBookshelfWidget::BtBookshelfWidget(QWidget *parent, Qt::WindowFlags flags)
: QWidget(parent, flags)
, m_sourceModel(nullptr)
, m_treeModel(nullptr)
, m_leftCornerWidget(nullptr)
, m_rightCornerWidget(nullptr)
{
// Setup post-filter:
m_postFilterModel = new BtBookshelfFilterModel(this);
// Init widgets and such:
initActions();
initMenus();
initWidgets();
// Connect treeview to model:
m_treeView->setModel(m_postFilterModel);
retranslateUi();
BT_CONNECT(m_nameFilterEdit, SIGNAL(textEdited(QString)),
m_postFilterModel, SLOT(setNameFilterFixedString(QString)));
BT_CONNECT(m_treeView, SIGNAL(contextMenuActivated(QPoint)),
this, SLOT(slotShowContextMenu(QPoint)));
BT_CONNECT(m_treeView,
SIGNAL(moduleContextMenuActivated(CSwordModuleInfo *, QPoint)),
this, SLOT(slotShowItemContextMenu(CSwordModuleInfo *, QPoint)));
}
ShowLog::ShowLog(QWidget *parent, const QString path,
const svn::Revision revisionStart,
const svn::Revision revisionEnd)
: QDialog(0) //don't set parent here! FileSelector is always a top-level window
{
setAttribute(Qt::WA_DeleteOnClose, true);
m_revisionStart = revisionStart;
m_revisionEnd = revisionEnd;
m_revisionBeginShowLog = revisionStart;
m_path = QDir::fromNativeSeparators(path);
m_url = svn::Wc(0).getUrl(path);
m_repos = svn::Wc(0).getRepos(path);
m_repos_path = QString(m_url).remove(m_repos);
setupUi(this);
Config::instance()->restoreWidget(this);
Config::instance()->restoreSplitter(this, splitter);
initLogEntries();
initLogEntriesPath();
initMenus();
this->setWindowTitle(QString(tr("Show Log for %1")).arg(path));
editFilterString->setFocus(Qt::MouseFocusReason);
}
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), m_currentTab(0), m_scriptEnvironment(this)
{
QNetworkProxyFactory::setUseSystemConfiguration(true);
setupUi(this);
m_projectsModel.setProjectManager(&ProjectManager::ref());
ui_projects->setModel(&m_projectsModel);
// ui_projects->hide(); // Disabled for now
/* Turns off updates so all of these things are drawn at once */
setUpdatesEnabled(false);
/* Deletes the tab that QTabWidget starts with by default */
deleteTab(0);
hideErrors();
//connect(ui_projects, SIGNAL(clicked(const QModelIndex&)), SLOT(projectFileClicked(const QModelIndex&)));
connect(ui_projects, SIGNAL(doubleClicked(const QModelIndex&)), SLOT(projectClicked(const QModelIndex&)));
connect(&ProjectManager::ref(), SIGNAL(projectOpened(Project*)), SLOT(projectOpened(Project*)));
connect(&ProjectManager::ref(), SIGNAL(projectClosed(Project*)), SLOT(projectClosed(Project*)));
ui_projectFrame->setVisible(false);
initMenus();
setTitle("");
setUpdatesEnabled(true);
}
void initializeRobot() {
bDisplayDiagnostics=false;
setGyroPos(false);
if (HTSMUXreadPowerStatus(MUX)) { // Multiplexer is off or dead?
nxtDisplayBigStringAt(0,45," MUX ");
nxtDisplayBigStringAt(0,25,"Dead Batt");
PlayImmediateTone(440, 50);
wait1Msec(1500);
eraseDisplay();
fallbackMode=true;
selection[SONAR_MENU]=3;
}
if (SensorRaw[gyro]>=640 || SensorRaw[gyro]<=590) { // Gyro moving or disconnected
nxtDisplayBigStringAt(21,45,"Gyro");
nxtDisplayBigStringAt(15,25,"Error");
nxtDisplayCenteredTextLine(7, "%i", SensorRaw[gyro]);
PlayImmediateTone(440, 50);
wait1Msec(1500);
setGyroEnabled(false);
} else {
wait1Msec(100);
nxtDisplayBigStringAt(15,45,"Wait...");
HTGYROstartCal(gyro);
PlaySound(soundBeepBeep);
setGyroEnabled(true);
}
eraseDisplay();
setClamp(true);
initMenus();
return;
}
void init()
{
glClearColor(1.0,.6,0,0); //background del display naranja
initMenus();
gameState = 0;
currentIndex = 0;
showInstructions = false;
glutTimerFunc(0,sound,0);//timer de la musica
}
ZoneViewerWindow::ZoneViewerWindow(RenderContext *renderCtx, QWidget *parent) : QMainWindow(parent)
{
m_scene = new ZoneScene(renderCtx);
m_renderCtx = renderCtx;
setWindowTitle("EQuilibre Zone Viewer");
m_viewport = new SceneViewport(m_scene, renderCtx);
setCentralWidget(m_viewport);
initMenus();
}
MainWindow::MainWindow()
{
textArea = new TextArea;
//textArea->is
windowTitle="Text Editor";
setWindowIcon(QIcon(":/images/app.png"));
setCentralWidget(textArea);
documentModified=false;
initMenus();
initToolBars();
//initContext();
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int
main(int argc, char** argv)
{
numParticles = 1024;
uint gridDim = 64;
numIterations = 1;
cutGetCmdLineArgumenti( argc, (const char**) argv, "n", (int *) &numParticles);
cutGetCmdLineArgumenti( argc, (const char**) argv, "grid", (int *) &gridDim);
gridSize.x = gridSize.y = gridSize.z = gridDim;
printf("grid: %d x %d x %d = %d cells\n", gridSize.x, gridSize.y, gridSize.z, gridSize.x*gridSize.y*gridSize.z);
bool benchmark = !cutCheckCmdLineFlag(argc, (const char**) argv, "noqatest") != 0;
cutGetCmdLineArgumenti( argc, (const char**) argv, "i", &numIterations);
cudaInit(argc, argv);
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutInitWindowSize(640, 480);
glutCreateWindow("CUDA particles");
initGL();
init(numParticles, gridSize);
initParams();
initMenus();
if (benchmark)
{
if (numIterations <= 0)
numIterations = 300;
runBenchmark(numIterations);
}
else
{
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutKeyboardFunc(key);
glutSpecialFunc(special);
glutIdleFunc(idle);
glutMainLoop();
}
if (psystem)
delete psystem;
cudaThreadExit();
return 0;
}
/**
* @brief 생성자
* @param parent 부모 위젯
*/
Puzzle::Puzzle(QWidget *parent)
: QMainWindow(parent)
, _emptyPiece(0)
, _shuffle(false)
, _tryCount(0)
{
initMenus(); // 메뉴 초기화
initWidgets(); // 위젯 초기화
initConnections(); // 시그널과 슬롯 연결
newPuzzle(); // 새 퍼즐
}
/**
* @brief TimeTable::TimeTable 생성자
* @param parent 부모 위젯
*/
TimeTable::TimeTable(QWidget *parent)
: QMainWindow(parent)
, _tableRows(0)
, _tableCols(0)
, _timeTable(0)
, _named(false)
{
initMenus(); // 메뉴 초기화
initWidgets(); // 위젯 초기화
// newTimeTable() 을 나중에 이벤트 루프에서 호출
QMetaObject::invokeMethod(this, "newTimeTable", Qt::QueuedConnection);
}
void
runGraphicsTest(int argc, char** argv)
{
printf("MarchingCubes ");
if (g_bFBODisplay) printf("[w/ FBO] ");
if (g_bOpenGLQA) printf("[Readback Comparisons] ");
printf("\n");
if ( cutCheckCmdLineFlag(argc, (const char **)argv, "device")) {
printf("[%s]\n", argv[0]);
printf(" Does not explicitly support -device=n in OpenGL mode\n");
printf(" To use -device=n, the sample must be running w/o OpenGL\n\n");
printf(" > %s -device=n -qatest\n", argv[0]);
printf("exiting...\n");
exit(0);
}
// First initialize OpenGL context, so we can properly set the GL for CUDA.
// This is necessary in order to achieve optimal performance with OpenGL/CUDA interop.
if(CUTFalse == initGL(&argc, argv)) {
return;
}
cudaGLSetGLDevice( cutGetMaxGflopsDeviceId() );
// register callbacks
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutIdleFunc(idle);
glutReshapeFunc(reshape);
initMenus();
// Initialize CUDA buffers for Marching Cubes
initMC(argc, argv);
cutilCheckError( cutCreateTimer( &timer));
if (g_bOpenGLQA) {
g_CheckRender = new CheckBackBuffer(window_width, window_height, 4);
g_CheckRender->setPixelFormat(GL_RGBA);
g_CheckRender->setExecPath(argv[0]);
g_CheckRender->EnableQAReadback(true);
}
// start rendering mainloop
glutMainLoop();
cudaThreadExit();
}
CantorWorksheetView::CantorWorksheetView(CantorWorksheet* worksheet) : QWidget(),
m_worksheet(worksheet) {
QHBoxLayout* layout = new QHBoxLayout(this);
layout->setContentsMargins(0, 0, 0, 0);
part = worksheet->part();
if (part) {
layout->addWidget(part->widget());
initActions();
initMenus();
connect(m_worksheet, SIGNAL(requestProjectContextMenu(QMenu*)), this, SLOT(createContextMenu(QMenu*)));
connect(m_worksheet, SIGNAL(statusChanged(Cantor::Session::Status)), this, SLOT(statusChanged(Cantor::Session::Status)));
}
}
void initGL(int *argc, char **argv)
{
// initialize GLUT callback functions
glutInit(argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_ALPHA | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowSize(width, height);
glutCreateWindow("CUDA bicubic texture filtering");
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutReshapeFunc(reshape);
glutTimerFunc(REFRESH_DELAY, timerEvent, 0);
#if defined (__APPLE__) || defined(MACOSX)
atexit(cleanup);
#else
glutCloseFunc(cleanup);
#endif
initMenus();
glewInit();
if (!glewIsSupported("GL_VERSION_2_0 "
"GL_ARB_pixel_buffer_object "
))
{
fprintf(stderr, "Required OpenGL extensions are missing.");
exit(EXIT_FAILURE);
}
#if USE_BUFFER_TEX
if (!glewIsSupported("GL_EXT_texture_buffer_object"))
{
fprintf(stderr, "OpenGL extension: GL_EXT_texture_buffer_object missing.\n");
exit(EXIT_FAILURE);
}
if (!glewIsSupported("GL_NV_gpu_program4"))
{
fprintf(stderr, "OpenGL extension: GL_NV_gpu_program4 missing.\n");
exit(EXIT_FAILURE);
}
#endif
}
VLCMainwindow::VLCMainwindow() {
vlcPlayer = NULL;
this->setWindowTitle("RTSP player");
/* Init libVLC */
if((vlcObject = libvlc_new(0,NULL)) == NULL) {
printf("Could not init libVLC");
exit(1);
}
/* Display libVLC version */
printf("libVLC version: %s\n",libvlc_get_version());
/* Interface initialisation */
initMenus();
initComponents();
}
/**
@param parent parent QWidget of this window
*/
QETTitleBlockTemplateEditor::QETTitleBlockTemplateEditor(QWidget *parent) :
QETMainWindow(parent),
opened_from_file_(false),
read_only_(false),
duplicate_(false),
tb_template_(0),
logo_manager_(0)
{
setWindowIcon(QET::Icons::QETLogo);
setAttribute(Qt::WA_DeleteOnClose);
initWidgets();
initActions();
initMenus();
initToolbars();
readSettings();
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int
main(int argc, char** argv)
{
// numParticles = 65536*2;
// numParticles = 65536;
// numParticles = 32768;
// numParticles = 8192;
// numParticles = 4096;
numParticles = 2048;
// numParticles = 1024;
// numParticles = 256;
// numParticles = 32;
// numParticles = 2;
uint gridDim = 64;
numIterations = 0;
gridSize.x = gridSize.y = gridSize.z = gridDim;
printf("grid: %d x %d x %d = %d cells\n", gridSize.x, gridSize.y, gridSize.z, gridSize.x*gridSize.y*gridSize.z);
cudaInit(argc, argv);
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutInitWindowSize(640, 480);
glutCreateWindow("CUDA particles");
initGL();
init(numParticles, gridSize);
initParams();
initMenus();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutKeyboardFunc(key);
glutSpecialFunc(special);
glutIdleFunc(idle);
glutMainLoop();
if (psystem)
delete psystem;
return 0;
}
int main(int argc, char* argv[])
{
Initial();
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB|GLUT_DEPTH );
glutInitWindowPosition(0,0);
glutInitWindowSize(WINDOW_WIDTH,WINDOW_HEIGHT);
glutCreateWindow("Hücresel Otomatlar Trafik Simülasyonu(CPU)");
glutReshapeFunc(ChangeSize);
glutTimerFunc(WAIT,waitAndRedraw,1);
glutDisplayFunc(RenderScene);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);
initMenus();
SetupRC();
glutMainLoop();
return 0;
}
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
{
activeDocument_ = 0L;
newcnt_ = 1;
// set up the main window
init();
initGui();
initActions();
initMenus();
initToolBars();
initConnections();
Config *cfg = Application::self()->config();
QByteArray state = cfg->state();
QByteArray geometry = cfg->geometry();
if (!state.isEmpty())
restoreState(state);
if (!geometry.isEmpty())
restoreGeometry(geometry);
// to make sure that there is no open models.
activeDocumentChanged(-1);
emit actionEnabled(false);
// parse cmd line args
QStringList args = qApp->arguments();
for (int i = 1; i < args.size(); ++i) {
const QString &arg = args[i];
if (!arg.startsWith("-"))
openFile(arg);
}
setStatusMessage(tr("Ready..."));
}
void setup(){
// A visual Queue that the System is in
// Setup Mode.
// Pin 14 -> LED ON
digitalWrite(SetupLED, HIGH);
// ----- PRELIMINARY PROCEDURES ------
// -> init serial Connection to LCD
initLCD();
LCDprintln("***** Starting Up *****");
delay(100);
LCDprintln(" [OK] ");
// ----- SPLASH SCREEN PROCEDURES ------
// -> splash Screen
// -> ask for connections
// -> Store USB?
#ifdef MEGA
toggleSplashScreen();
delay(1000);
askForConnectionTypes();
askToStoreData();
#endif
// ----- DEBUG STARTUP PROCEDURES ------
#ifdef DEBUG
toggleSplashScreen();
delay(1000);
LCDprintln("***** DEBUG MODE *****");
startDebugSequence();
#endif
// ----- PINS // INT // ISR PROCEDURES ------
// -> init buttons
// -> init LED pins
// -> init Digital pins
// -> init Sensors
// -> attach interrupts
#ifdef MEGA
initbuttons();
#else
LCDprintln("In DEBUG mode no input required");
#endif
#ifdef MEGA
initLEDPins();
initDigitalPins();
initSensors();
#else
LCDprintln("No need for inputs random numbers\n
sent to the PC/XBee.");
#endif
attachInterrupts();
// ----- COMMS STARTUP PROCEDURES ------
// -> init Keyboard
// -> init serial Connection to XBee
// -> init serial Connection to PC
#ifdef XBeeConnected
initXbee();
LCDdisplayConnectedIcon(Connection);
#endif
#ifdef USBConnected
initUSB();
LCDdisplayConnectedIcon(Connection);
#endif
#ifdef StoreUSB
initVDIP();
LCDdisplayConnectedIcon(Connection);
printHeaders();
#endif
// ----- MEM. & MENUS STARTUP PROCEDURES ------
// -> init EEPROM
// -> +1 to session ID
// -> Verify Version ID
// -> init Menu System
// -> Startup
initEEPROM();
initMenus();
// A visual Queue that the System is now past
// the Setup Mode.
// Pin 14 -> LED OFF
digitalWrite(SetupLED, LOW);
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int
main(int argc, char **argv)
{
printf("%s Starting...\n\n", sSDKsample);
numParticles = NUM_PARTICLES;
maxNumParticles = MAX_NUM_PARTICLES;
uint gridDim = GRID_SIZE;
numIterations = 0;
printf("Surely I can get this far\n");
if (argc > 1)
{
if (checkCmdLineFlag(argc, (const char **) argv, "n"))
{
numParticles = getCmdLineArgumentInt(argc, (const char **)argv, "n");
}
if (checkCmdLineFlag(argc, (const char **) argv, "grid"))
{
gridDim = getCmdLineArgumentInt(argc, (const char **) argv, "grid");
}
if (checkCmdLineFlag(argc, (const char **)argv, "file"))
{
getCmdLineArgumentString(argc, (const char **)argv, "file", &g_refFile);
fpsLimit = frameCheckNumber;
numIterations = 1;
}
}
//*******************************************************
// RMK Hard code for cylindrical coords (y=theta=1)
// DomainSize
//char Zfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-nothot/ZVert.txt";
//char Rfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-nothot/RVert.txt";
//char Zfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-nothot-big/ZVert.txt";
//char Rfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-nothot-big/RVert.txt";
//char Zfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-big/ZVert.txt";
//char Rfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-big/RVert.txt";
//char Zfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-nothot-big-refine/ZVert.txt";
//char Rfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-nothot-big-refine/RVert.txt";
char Zfile[] = "/home/rkeedy/CFD/BuoyantStrumJet85-big-refine-lighter/ZVert.txt";
char Rfile[] = "/home/rkeedy/CFD/BuoyantStrumJet85-big-refine-lighter/RVert.txt";
//char Zfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet62-big-refine-lighter/ZVert.txt";
//char Rfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet62-big-refine-lighter/RVert.txt";
//char Zfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-big-refine/ZVert.txt";
//char Rfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-big-refine/RVert.txt";
//char Zfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet63-big-refine/ZVert.txt";
//char Rfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet63-big-refine/RVert.txt";
numVelNodes.x = filecount(Rfile); //-1;
numVelNodes.z = filecount(Zfile); //-1;
numVelNodes.y = 1;
numCells.x = 80; //47; //24; //29;
numCells.y = 1;
numCells.z = 160; //188; //95; //88;
numParticles = numCells.x*numCells.z*20; //avgnumparticles = 40
srand( time( NULL ) );
//numParticles = numCells.x*numCells.z*40;
printf("vel grid: %d x %d x %d = %d cells\n", numVelNodes.x, numVelNodes.y, numVelNodes.z, numVelNodes.x*numVelNodes.y*numVelNodes.z);
printf(" grid: %d x %d x %d = %d cells\n", numCells.x, numCells.y, numCells.z, numCells.x*numCells.y*numCells.z);
//printf("vel grid: %d x %d x %d = %d cells\n", gridSize.x, gridSize.y, gridSize.z, gridSize.x*gridSize.y*gridSize.z);
bool benchmark = checkCmdLineFlag(argc, (const char **) argv, "benchmark") != 0;
if (checkCmdLineFlag(argc, (const char **) argv, "i"))
{
numIterations = getCmdLineArgumentInt(argc, (const char **) argv, "i");
}
if (g_refFile)
{
cudaInit(argc, argv);
}
else
{
if (checkCmdLineFlag(argc, (const char **)argv, "device"))
{
printf("[%s]\n", argv[0]);
printf(" Does not explicitly support -device=n in OpenGL mode\n");
printf(" To use -device=n, the sample must be running w/o OpenGL\n\n");
printf(" > %s -device=n -file=<*.bin>\n", argv[0]);
printf("exiting...\n");
exit(EXIT_SUCCESS);
}
initGL(&argc, argv);
cudaGLInit(argc, argv);
}
// Moved code snippet to CellSystem
//initCellSystem(gridSize);
// now moved to particlesystem
printf("Begin initialization\n");
//initParticleSystem(numParticles, gridSize, g_refFile==NULL);
initParticleSystem(maxNumParticles, numParticles, numVelNodes, numCells, g_refFile==NULL);
//printf("Finished with initParticleSystem, %d\n",g_refFile==NULL);
//cin.ignore();
initParams();
printf("Finished with initialization\n");
if (!g_refFile)
{
initMenus();
}
if (benchmark || g_refFile)
{
if (numIterations <= 0)
{
numIterations = 300;
}
runBenchmark(numIterations, argv[0]);
}
else
{
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutKeyboardFunc(key);
glutSpecialFunc(special);
glutIdleFunc(idle);
atexit(cleanup);
glutMainLoop();
}
if (psystem)
{
delete psystem;
}
cudaDeviceReset();
exit(g_TotalErrors > 0 ? EXIT_FAILURE : EXIT_SUCCESS);
}
Window::Window()
: m_toolbar(0),
m_fullscreen(true),
m_typewriter_sounds(true),
m_auto_save(true),
m_save_positions(true),
m_goal_type(0),
m_time_goal(0),
m_wordcount_goal(0),
m_current_time(0),
m_current_wordcount(0)
{
setAcceptDrops(true);
setAttribute(Qt::WA_DeleteOnClose);
setContextMenuPolicy(Qt::NoContextMenu);
setWindowIcon(QIcon(":/focuswriter.png"));
// Set up icons
if (QIcon::themeName().isEmpty()) {
QIcon::setThemeName("hicolor");
setIconSize(QSize(22,22));
}
// Create window contents first so they stack behind documents
menuBar();
m_toolbar = new QToolBar(this);
m_toolbar->setFloatable(false);
m_toolbar->setMovable(false);
addToolBar(m_toolbar);
QWidget* contents = new QWidget(this);
setCentralWidget(contents);
// Create documents
m_documents = new Stack(this);
m_sessions = new SessionManager(this);
m_timers = new TimerManager(m_documents, this);
m_load_screen = new LoadScreen(this);
connect(m_documents, SIGNAL(footerVisible(bool)), m_timers->display(), SLOT(setVisible(bool)));
connect(m_documents, SIGNAL(formattingEnabled(bool)), this, SLOT(setFormattingEnabled(bool)));
connect(m_documents, SIGNAL(updateFormatActions()), this, SLOT(updateFormatActions()));
connect(m_documents, SIGNAL(updateFormatAlignmentActions()), this, SLOT(updateFormatAlignmentActions()));
connect(m_documents, SIGNAL(updateFormatHeadingActions()), this, SLOT(updateFormatHeadingActions()));
connect(m_sessions, SIGNAL(themeChanged(Theme)), m_documents, SLOT(themeSelected(Theme)));
// Set up menubar and toolbar
initMenus();
// Set up details
m_footer = new QWidget(contents);
QWidget* details = new QWidget(m_footer);
m_wordcount_label = new QLabel(tr("Words: 0"), details);
m_page_label = new QLabel(tr("Pages: 0"), details);
m_paragraph_label = new QLabel(tr("Paragraphs: 0"), details);
m_character_label = new QLabel(tr("Characters: 0"), details);
m_progress_label = new QLabel(tr("0% of daily goal"), details);
m_clock_label = new QLabel(details);
updateClock();
// Set up clock
m_clock_timer = new QTimer(this);
m_clock_timer->setInterval(60000);
connect(m_clock_timer, SIGNAL(timeout()), this, SLOT(updateClock()));
connect(m_clock_timer, SIGNAL(timeout()), m_timers, SLOT(saveTimers()));
int delay = (60 - QTime::currentTime().second()) * 1000;
QTimer::singleShot(delay, m_clock_timer, SLOT(start()));
QTimer::singleShot(delay, this, SLOT(updateClock()));
// Set up tabs
m_tabs = new QTabBar(m_footer);
m_tabs->setShape(QTabBar::RoundedSouth);
m_tabs->setDocumentMode(true);
m_tabs->setExpanding(false);
m_tabs->setMovable(true);
m_tabs->setTabsClosable(true);
m_tabs->setUsesScrollButtons(true);
connect(m_tabs, SIGNAL(currentChanged(int)), this, SLOT(tabClicked(int)));
connect(m_tabs, SIGNAL(tabCloseRequested(int)), this, SLOT(tabClosed(int)));
connect(m_tabs, SIGNAL(tabMoved(int, int)), this, SLOT(tabMoved(int, int)));
new QShortcut(QKeySequence::NextChild, this, SLOT(nextDocument()));
new QShortcut(QKeySequence::PreviousChild, this, SLOT(previousDocument()));
// Lay out details
QHBoxLayout* clock_layout = new QHBoxLayout;
clock_layout->setMargin(0);
clock_layout->setSpacing(6);
clock_layout->addWidget(m_timers->display(), 0, Qt::AlignCenter);
clock_layout->addWidget(m_clock_label);
QHBoxLayout* details_layout = new QHBoxLayout(details);
details_layout->setSpacing(25);
details_layout->setMargin(6);
details_layout->addWidget(m_wordcount_label);
details_layout->addWidget(m_page_label);
details_layout->addWidget(m_paragraph_label);
details_layout->addWidget(m_character_label);
details_layout->addStretch();
details_layout->addWidget(m_progress_label);
details_layout->addStretch();
details_layout->addLayout(clock_layout);
// Lay out footer
QVBoxLayout* footer_layout = new QVBoxLayout(m_footer);
footer_layout->setSpacing(0);
footer_layout->setMargin(0);
footer_layout->addWidget(details);
footer_layout->addWidget(m_tabs);
// Lay out window
QVBoxLayout* layout = new QVBoxLayout(contents);
layout->setSpacing(0);
layout->setMargin(0);
layout->addStretch();
layout->addWidget(m_footer);
// Load current daily progress
QSettings settings;
if (settings.value("Progress/Date").toDate() != QDate::currentDate()) {
settings.remove("Progress");
}
settings.setValue("Progress/Date", QDate::currentDate().toString(Qt::ISODate));
m_current_wordcount = settings.value("Progress/Words", 0).toInt();
m_current_time = settings.value("Progress/Time", 0).toInt();
updateProgress();
// Load settings
Preferences preferences;
loadPreferences(preferences);
m_documents->themeSelected(settings.value("ThemeManager/Theme").toString());
// Restore window geometry
setMinimumSize(640, 480);
resize(800, 600);
restoreGeometry(settings.value("Window/Geometry").toByteArray());
m_fullscreen = !settings.value("Window/Fullscreen", true).toBool();
toggleFullscreen();
m_actions["Fullscreen"]->setChecked(m_fullscreen);
show();
// Update themes
m_load_screen->setText(tr("Loading themes"));
Theme::copyBackgrounds();
// Load sounds
m_load_screen->setText(tr("Loading sounds"));
m_key_sound = new Sound("keyany.wav", this);
m_enter_key_sound = new Sound("keyenter.wav", this);
// Update margin
m_tabs->blockSignals(true);
m_tabs->addTab(tr("Untitled"));
updateMargin();
m_tabs->removeTab(0);
m_tabs->blockSignals(false);
// Open previous documents
QString session = settings.value("SessionManager/Session").toString();
QStringList files = QApplication::arguments().mid(1);
if (!files.isEmpty()) {
session.clear();
settings.setValue("Save/Current", files);
settings.setValue("Save/Positions", QStringList());
settings.setValue("Save/Active", 0);
}
m_sessions->setCurrent(session);
}
extern "C" void qteapp_init(
MIDPMainWindowCreateProc mainWindowCreateProc) {
//edit by sookie
//char display_buf[64];
int qtArgc = 1;
#ifdef FV_USE_QT4
char* argv[7];
#else
char* argv[5];
#endif
// The argv[0] which will go into Ui::initialize
// *MUST* match the one in Qtopia env. (i.e. the name
// inside .desktop file), otherwise the icon will
// NOT show up in task bar when run. [QPE just
// match the name of this and append .png. that's why]
argv[0] = "usertest";
//#if ENABLE_QWS
argv[1] = "-qws";
qtArgc++;
//#endif /* ENABLE_QWS */
argv[2] = "-nomouse";
qtArgc++;
#ifdef FV_USE_QT4
argv[3] = "-geometry";
#else
argv[3] = "-bg";
#endif
qtArgc++;
#ifdef FV_USE_QT4
argv[4] = "640x530";
#else
argv[4] = "white";
#endif
qtArgc++;
#ifdef FV_USE_QT4
argv[5] = "-display";
qtArgc++;
if((argv[6]=getenv("jvm_display"))==NULL){
argv[6] = "linuxfb:/dev/fb0";
}
printf("======jvm_display is %s\n",argv[6]);
//argv[6] = "linuxfb:/dev/fb1";
qtArgc++;
#else
#endif
qapp = new QApplication(qtArgc, argv);
#ifdef FV_USE_QT4
QWSServer::setBackground(QBrush(Qt::transparent));
#else
#endif
// The constructor of MIDPMainWindow sets mscreen.
MainWindow = mainWindowCreateProc(NULL, NULL);
// IMPL_NOTE:this should move to MainWindow or MScreen
initMenus();
#ifdef FV_USE_QT4
#else
qapp->setMainWidget(MainWindow);
#endif
MainWindow->showMaximized();
mscreen = MainWindow->getMScreen();
mscreen->init();
//edit by sookie
//MainWindow->setGeometry(MainWindow->x(), MainWindow->y(),MainWindow->width(),MainWindow->height());
MainWindow->setGeometry(40,23,640,530);
//MainWindow->setBackgroundColor( Qt::white );
//MainWindow->setWFlags(MainWindow->getWFlags()|Qt::WStyle_Customize|Qt::WStyle_NoBorder);
}
static Bool initCitadel(void)
{
if (!read_cfg_messages())
{
#ifdef WINCIT
char Buffer[128];
sprintf(Buffer, getmsg(188), getmsg(671));
MessageBox(NULL, Buffer, NULL, MB_ICONSTOP | MB_OK);
#else
printf(getmsg(188), getmsg(671));
#endif
return (FALSE);
}
checkfiles();
initExtDrivers();
get_os();
cfg.battr = 0xff;
setscreen();
logo(TRUE); // no go for debug version; td32 go crash crash
init_internal_sound();
// some mouse initialization technology!!!!
initMouseHandler();
hideCounter = 1;
if (time(NULL) < 700000000L)
{
#ifdef WINCIT
MessageBox(NULL, getcfgmsg(119), NULL, MB_ICONSTOP | MB_OK);
#else
doccr();
doccr();
cPrintf(getcfgmsg(119));
doccr();
#endif
dump_cfg_messages();
return (FALSE);
}
static char prompt[92];
static char citadel[92];
char *envprompt;
char *citprompt;
envprompt = getenv(getcfgmsg(120));
citprompt = getenv(getcfgmsg(121));
if (citprompt)
{
sprintf(prompt, getcfgmsg(122), citprompt);
}
else if (envprompt)
{
sprintf(prompt, getcfgmsg(123), envprompt);
}
else
{
strcpy(prompt, getcfgmsg(124));
}
putenv(prompt);
sprintf(citadel, getcfgmsg(125), programName, version);
putenv(citadel);
#ifndef WINCIT
OC.whichIO = CONSOLE;
OC.SetOutFlag(OUTOK);
OC.Echo = BOTH;
OC.setio();
#endif
VerifyHeap(1);
// If we aren't reconfiguring, load the tables...
if (!reconfig)
{
// Start by reading ETC.TAB
getcwd(etcpath, 64);
FILE *fd;
if ((fd = fopen(etcTab, FO_RB)) != NULL)
{
if (filelength(fileno(fd)) != (long) sizeof(config) ||
fread(&cfg, 1, sizeof(config), fd) != (long) sizeof(config))
{
memset(&cfg, 0, sizeof(cfg));
reconfig = TRUE;
}
fclose(fd);
unlink(etcTab);
// If ETC.TAB could be loaded, load the rest
if (!reconfig)
{
changedir(cfg.homepath);
allocateTables();
if (!LogTab.Load() || !MessageDat.LoadTable() || !RoomTab.Load())
{
reconfig = TRUE;
}
Cron.ReadTable(WC_TWpn);
}
}
else
{
if (!batchmode)
{
#ifdef WINCIT
MessageBox(NULL, "No ETC.TAB.", NULL, MB_ICONSTOP | MB_OK);
#else
doccr();
discardable *d;
if ((d = readData(6)) != NULL)
{
int i;
for (i = 0; ((char **) d->next->aux)[i][0] != '#'; i++)
{
cPrintf(pcts, ((char **) d->next->aux)[i]);
doccr();
}
doccr();
discardData(d);
}
else
{
cOutOfMemory(28);
}
DeinitializeTimer();
critical(FALSE);
#endif
exit(1);
}
reconfig = TRUE;
}
}
if (reconfig)
{
cfg.attr = 7;
#ifndef WINCIT
pause(200);
cls(SCROLL_SAVE);
cCPrintf(getcfgmsg(126));
doccr();
#endif
if (!configcit())
{
#ifdef WINCIT
MessageBox(NULL, getcfgmsg(127), NULL, MB_ICONSTOP | MB_OK);
#else
doccr();
doccr();
cPrintf(getcfgmsg(127));
doccr();
#endif
dump_cfg_messages();
return (FALSE);
}
#ifndef WINCIT
setdefaultTerm(TT_ANSI);
CurrentUser->SetWidth(80);
#endif
Cron.ReadCronCit(WC_TWpn);
}
else
{
#ifndef WINCIT
if (!CreateScrollBackBuffer())
{
cPrintf(getcfgmsg(60));
doccr();
}
#endif
if (readconfigcit) // forced to read in config.cit
{
if (!readconfig(NULL, 1))
{
#ifdef WINCIT
MessageBox(NULL, getcfgmsg(129), NULL, MB_ICONSTOP | MB_OK);
#else
doccr();
doccr();
cPrintf(getcfgmsg(129));
doccr();
#endif
dump_cfg_messages();
return (FALSE);
}
}
}
VerifyHeap(1);
makeBorders();
readBordersDat();
if (cmd_nobells)
{
cfg.noBells = 2;
}
if (cmd_nochat)
{
cfg.noChat = TRUE;
}
if (cmd_mdata != CERROR)
{
cfg.mdata = cmd_mdata;
}
if (*cfg.f6pass)
{
if (SameString(cfg.f6pass, getmsg(670)))
{
ConsoleLock.LockF6();
}
else
{
ConsoleLock.Lock();
}
}
#ifndef WINCIT
if (cfg.ovrEms)
{
if (_OvrInitEms(0, 0, 0))
{
cPrintf(getcfgmsg(130));
doccr();
pause(200);
}
}
if (cfg.ovrExt)
{
if (_OvrInitExt(0, 0))
{
cPrintf(getcfgmsg(131));
doccr();
pause(200);
}
}
CommPort->Init();
setscreen();
#endif
logo(TRUE); // no go for debug version; td32 go crash crash
#ifndef WINCIT
StatusLine.Update(WC_TWp);
#endif
if (cfg.msgpath[(strlen(cfg.msgpath) - 1)] == '\\')
{
cfg.msgpath[(strlen(cfg.msgpath) - 1)] = '\0';
}
// move to home path
changedir(cfg.homepath);
char FileName[128];
ReIndexFileInfo(); // keep fileinfo.dat nice and pretty
// open message file
if (!MessageDat.OpenMessageFile(cfg.msgpath))
{
illegal(getmsg(78), MessageDat.GetFilename());
}
// Then room file
sprintf(FileName, sbs, cfg.homepath, roomDat);
openFile(FileName, &RoomFile);
citOpen(cfg.trapfile, CO_A, &TrapFile);
initMenus();
dump_cfg_messages();
if(!read_tr_messages())
{
errorDisp(getmsg(172));
}
else
{
#ifdef WINCIT
trap(T_SYSOP, "", gettrmsg(37));
#else
trap(T_SYSOP, gettrmsg(37));
#endif
dump_tr_messages();
}
read_cfg_messages(); // uh-oh!
if (!GroupData.Load())
{
return (FALSE);
}
if (!HallData.Load())
{
return (FALSE);
}
getRoomPos();
if (cfg.accounting)
{
ReadGrpdataCit(WC_TWpn);
}
ReadExternalCit(WC_TWpn);
ReadProtocolCit(WC_TWpn);
ReadMdmresltCit(WC_TWpn);
ReadCommandsCit(WC_TWpn);
#ifndef WINCIT
ReadMCICit(FALSE);
CurrentRoom->Load(LOBBY);
thisRoom = LOBBY;
checkdir();
if (!slv_door)
{
CITWINDOW *w = CitWindowsMsg(NULL, getmsg(19));
Initport();
Initport();
if (w)
{
destroyCitWindow(w, FALSE);
}
}
else
{
CommPort->Enable();
}
OC.whichIO = MODEM;
OC.setio();
#endif
// record when we put system up
time(&uptimestamp);
#ifndef WINCIT
setdefaultconfig(FALSE);
Talley->Fill();
#endif
logo(FALSE);
VerifyHeap(1);
dump_cfg_messages();
compactMemory(1);
return (TRUE);
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int
main(int argc, char **argv)
{
#if defined(__linux__)
setenv ("DISPLAY", ":0", 0);
#endif
printf("%s Starting...\n\n", sSDKsample);
printf("NOTE: The CUDA Samples are not meant for performance measurements. Results may vary when GPU Boost is enabled.\n\n");
numParticles = NUM_PARTICLES;
uint gridDim = GRID_SIZE;
numIterations = 0;
if (argc > 1)
{
if (checkCmdLineFlag(argc, (const char **) argv, "n"))
{
numParticles = getCmdLineArgumentInt(argc, (const char **)argv, "n");
}
if (checkCmdLineFlag(argc, (const char **) argv, "grid"))
{
gridDim = getCmdLineArgumentInt(argc, (const char **) argv, "grid");
}
if (checkCmdLineFlag(argc, (const char **)argv, "file"))
{
getCmdLineArgumentString(argc, (const char **)argv, "file", &g_refFile);
fpsLimit = frameCheckNumber;
numIterations = 1;
}
}
gridSize.x = gridSize.y = gridSize.z = gridDim;
printf("grid: %d x %d x %d = %d cells\n", gridSize.x, gridSize.y, gridSize.z, gridSize.x*gridSize.y*gridSize.z);
printf("particles: %d\n", numParticles);
bool benchmark = checkCmdLineFlag(argc, (const char **) argv, "benchmark") != 0;
if (checkCmdLineFlag(argc, (const char **) argv, "i"))
{
numIterations = getCmdLineArgumentInt(argc, (const char **) argv, "i");
}
if (g_refFile)
{
cudaInit(argc, argv);
}
else
{
if (checkCmdLineFlag(argc, (const char **)argv, "device"))
{
printf("[%s]\n", argv[0]);
printf(" Does not explicitly support -device=n in OpenGL mode\n");
printf(" To use -device=n, the sample must be running w/o OpenGL\n\n");
printf(" > %s -device=n -file=<*.bin>\n", argv[0]);
printf("exiting...\n");
exit(EXIT_SUCCESS);
}
initGL(&argc, argv);
cudaGLInit(argc, argv);
}
initParticleSystem(numParticles, gridSize, g_refFile==NULL);
initParams();
if (!g_refFile)
{
initMenus();
}
if (benchmark || g_refFile)
{
if (numIterations <= 0)
{
numIterations = 300;
}
runBenchmark(numIterations, argv[0]);
}
else
{
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutKeyboardFunc(key);
glutSpecialFunc(special);
glutIdleFunc(idle);
glutCloseFunc(cleanup);
glutMainLoop();
}
if (psystem)
{
delete psystem;
}
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits
cudaDeviceReset();
exit(g_TotalErrors > 0 ? EXIT_FAILURE : EXIT_SUCCESS);
}
BtBookshelfDockWidget::BtBookshelfDockWidget(QWidget *parent, Qt::WindowFlags f)
: QDockWidget(parent, f)
{
BT_ASSERT(!m_instance);
m_instance = this;
setObjectName("BookshelfDock");
// Setup actions and menus:
initMenus();
// Setup tree model:
m_treeModel = new BtBookshelfTreeModel(groupingOrderKey, this);
// Get backend model:
BtBookshelfModel *bookshelfModel = CSwordBackend::instance()->model();
// Setup bookshelf widgets:
m_bookshelfWidget = new BtBookshelfWidget(this);
m_bookshelfWidget->setTreeModel(m_treeModel);
m_bookshelfWidget->setSourceModel(bookshelfModel);
m_bookshelfWidget->setItemContextMenu(m_itemContextMenu);
m_bookshelfWidget->treeView()->setMouseTracking(true); // required for moduleHovered
/// \bug The correct grouping action is not selected on startup.
// Setup welcome widgets:
m_welcomeWidget = new QWidget(this);
QVBoxLayout *welcomeLayout = new QVBoxLayout;
m_installLabel = new QLabel(this);
m_installLabel->setWordWrap(true);
m_installLabel->setAlignment(Qt::AlignHCenter | Qt::AlignBottom);
welcomeLayout->addWidget(m_installLabel, 0, Qt::AlignHCenter | Qt::AlignBottom);
m_installButton = new QPushButton(this);
welcomeLayout->addWidget(m_installButton, 0, Qt::AlignHCenter | Qt::AlignTop);
m_welcomeWidget->setLayout(welcomeLayout);
// Setup stacked widget:
m_stackedWidget = new QStackedWidget(this);
m_stackedWidget->addWidget(m_bookshelfWidget);
m_stackedWidget->addWidget(m_welcomeWidget);
m_stackedWidget->setCurrentWidget(bookshelfModel->moduleList().empty()
? m_welcomeWidget
: m_bookshelfWidget);
setWidget(m_stackedWidget);
// Connect signals:
BT_CONNECT(m_bookshelfWidget->treeView(),
SIGNAL(moduleActivated(CSwordModuleInfo *)),
this, SLOT(slotModuleActivated(CSwordModuleInfo *)));
BT_CONNECT(m_bookshelfWidget->treeView(),
SIGNAL(moduleHovered(CSwordModuleInfo *)),
this, SIGNAL(moduleHovered(CSwordModuleInfo *)));
BT_CONNECT(m_treeModel, SIGNAL(moduleChecked(CSwordModuleInfo *, bool)),
this, SLOT(slotModuleChecked(CSwordModuleInfo *, bool)));
BT_CONNECT(m_treeModel,
SIGNAL(groupingOrderChanged(BtBookshelfTreeModel::Grouping)),
this,
SLOT(slotGroupingOrderChanged(
BtBookshelfTreeModel::Grouping const &)));
BT_CONNECT(m_bookshelfWidget->showHideAction(), SIGNAL(toggled(bool)),
m_treeModel, SLOT(setCheckable(bool)));
BT_CONNECT(bookshelfModel,
SIGNAL(rowsInserted(QModelIndex const &, int, int)),
this, SLOT(slotModulesChanged()));
BT_CONNECT(bookshelfModel,
SIGNAL(rowsRemoved(QModelIndex const &, int, int)),
this, SLOT(slotModulesChanged()));
BT_CONNECT(m_installButton, SIGNAL(clicked()),
BibleTime::instance(), SLOT(slotBookshelfWizard()));
retranslateUi();
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int
main(int argc, char** argv)
{
int retVal = 0;
retVal = xnInit( argc, argv );
printf("[ %s ]\n", sSDKsample);
if (argc > 1) {
cutGetCmdLineArgumenti( argc, (const char**) argv, "n", (int *) &numParticles);
if (cutCheckCmdLineFlag(argc, (const char **)argv, "qatest") ||
cutCheckCmdLineFlag(argc, (const char **)argv, "noprompt")
)
{
g_bQAReadback = true;
}
if (cutCheckCmdLineFlag(argc, (const char **)argv, "glverify"))
{
g_bQAGLVerify = true;
}
}
if (g_bQAReadback) {
// For Automated testing, we do not use OpenGL/CUDA interop
if ( cutCheckCmdLineFlag(argc, (const char **)argv, "device")) {
cutilDeviceInit (argc, argv);
} else {
cudaSetDevice (cutGetMaxGflopsDeviceId() );
}
g_CheckRender = new CheckBackBuffer(winWidth, winHeight, 4, false);
g_CheckRender->setPixelFormat(GL_RGBA);
g_CheckRender->setExecPath(argv[0]);
g_CheckRender->EnableQAReadback(true);
// This code path is used for Automated Testing
initParticles(numParticles, false, false);
initParams();
if (emitterOn) {
runEmitter();
}
SimParams ¶ms = psystem->getParams();
params.cursorPos = make_float3(cursorPosLag.x, cursorPosLag.y, cursorPosLag.z);
psystem->step(timestep);
float4 *pos = NULL, *vel = NULL;
int g_TotalErrors = 0;
psystem->dumpBin(&pos, &vel);
g_CheckRender->dumpBin(pos, numParticles*sizeof(float4), "smokeParticles_pos.bin");
g_CheckRender->dumpBin(vel, numParticles*sizeof(float4), "smokeParticles_vel.bin");
if (!g_CheckRender->compareBin2BinFloat("smokeParticles_pos.bin", sRefBin[0], numParticles*sizeof(float4), MAX_EPSILON_ERROR, THRESHOLD))
g_TotalErrors++;
if (!g_CheckRender->compareBin2BinFloat("smokeParticles_vel.bin", sRefBin[1], numParticles*sizeof(float4), MAX_EPSILON_ERROR, THRESHOLD))
g_TotalErrors++;
delete psystem;
delete g_CheckRender;
printf("%s\n", (g_TotalErrors > 0) ? "FAILED" : "PASSED");
cudaThreadExit();
} else {
// Normal smokeParticles rendering path
// 1st initialize OpenGL context, so we can properly set the GL for CUDA.
// This is needed to achieve optimal performance with OpenGL/CUDA interop.
initGL( &argc, argv );
if ( cutCheckCmdLineFlag(argc, (const char **)argv, "device")) {
cutilGLDeviceInit (argc, argv);
} else {
cudaGLSetGLDevice (cutGetMaxGflopsDeviceId() );
}
if (g_bQAGLVerify) {
g_CheckRender = new CheckBackBuffer(winWidth, winHeight, 4);
g_CheckRender->setPixelFormat(GL_RGBA);
g_CheckRender->setExecPath(argv[0]);
g_CheckRender->EnableQAReadback(true);
}
// This is the normal code path for SmokeParticles
initParticles(numParticles, true, true);
initParams();
initMenus();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutKeyboardFunc(key);
glutKeyboardUpFunc(keyUp);
glutSpecialFunc(special);
glutIdleFunc(idle);
glutMainLoop();
}
cutilExit(argc, argv);
return retVal;
}
int main(int argc, char *argv[])
{
uiInitOptions o;
int i;
const char *err;
uiWindow *w;
uiBox *page2, *page3, *page4, *page5;
uiBox *page6, *page7, *page8, *page9, *page10;
uiBox *page11, *page12, *page13;
uiTab *page14;
uiBox *page15;
uiBox *page16;
uiTab *outerTab;
uiTab *innerTab;
int nomenus = 0;
int startspaced = 0;
int steps = 0;
newhbox = uiNewHorizontalBox;
newvbox = uiNewVerticalBox;
memset(&o, 0, sizeof (uiInitOptions));
for (i = 1; i < argc; i++)
if (strcmp(argv[i], "nomenus") == 0)
nomenus = 1;
else if (strcmp(argv[i], "startspaced") == 0)
startspaced = 1;
else if (strcmp(argv[i], "swaphv") == 0) {
newhbox = uiNewVerticalBox;
newvbox = uiNewHorizontalBox;
} else if (strcmp(argv[i], "steps") == 0)
steps = 1;
else {
fprintf(stderr, "%s: unrecognized option %s\n", argv[0], argv[i]);
return 1;
}
err = uiInit(&o);
if (err != NULL) {
fprintf(stderr, "error initializing ui: %s\n", err);
uiFreeInitError(err);
return 1;
}
if (!nomenus)
initMenus();
w = newWindow("Main Window", 320, 240, 1);
uiWindowOnClosing(w, onClosing, NULL);
printf("main window %p\n", (void *) w);
uiOnShouldQuit(onShouldQuit, w);
mainBox = newHorizontalBox();
uiWindowSetChild(w, uiControl(mainBox));
outerTab = newTab();
uiBoxAppend(mainBox, uiControl(outerTab), 1);
mainTab = newTab();
uiTabAppend(outerTab, "Pages 1-5", uiControl(mainTab));
// page 1 uses page 2's uiGroup
page2 = makePage2();
makePage1(w);
uiTabAppend(mainTab, "Page 1", uiControl(page1));
uiTabAppend(mainTab, "Page 2", uiControl(page2));
uiTabAppend(mainTab, "Empty Page", uiControl(uiNewHorizontalBox()));
page3 = makePage3();
uiTabAppend(mainTab, "Page 3", uiControl(page3));
page4 = makePage4();
uiTabAppend(mainTab, "Page 4", uiControl(page4));
page5 = makePage5(w);
uiTabAppend(mainTab, "Page 5", uiControl(page5));
innerTab = newTab();
uiTabAppend(outerTab, "Pages 6-10", uiControl(innerTab));
page6 = makePage6();
uiTabAppend(innerTab, "Page 6", uiControl(page6));
page7 = makePage7();
uiTabAppend(innerTab, "Page 7", uiControl(page7));
/* page8 = makePage8();
uiTabAppend(innerTab, "Page 8", uiControl(page8));
page9 = makePage9();
uiTabAppend(innerTab, "Page 9", uiControl(page9));
page10 = makePage10();
uiTabAppend(innerTab, "Page 10", uiControl(page10));
*/
innerTab = newTab();
uiTabAppend(outerTab, "Pages 11-15", uiControl(innerTab));
// page11 = makePage11();
// uiTabAppend(innerTab, "Page 11", uiControl(page11));
page12 = makePage12();
uiTabAppend(innerTab, "Page 12", uiControl(page12));
page13 = makePage13();
uiTabAppend(innerTab, "Page 13", uiControl(page13));
page14 = makePage14();
uiTabAppend(innerTab, "Page 14", uiControl(page14));
page15 = makePage15(w);
uiTabAppend(innerTab, "Page 15", uiControl(page15));
innerTab = newTab();
uiTabAppend(outerTab, "Pages 16-?", uiControl(innerTab));
page16 = makePage16();
uiTabAppend(innerTab, "Page 16", uiControl(page16));
if (startspaced)
setSpaced(1);
uiControlShow(uiControl(w));
if (!steps)
uiMain();
else {
uiMainSteps();
while (uiMainStep(1))
;
}
printf("after uiMain()\n");
freePage16();
uiUninit();
printf("after uiUninit()\n");
return 0;
}
int main(int argc, char *argv[])
{
uiInitOptions o;
int i;
const char *err;
uiWindow *w;
uiBox *page2, *page3, *page4, *page5;
int nomenus = 0;
int startspaced = 0;
newhbox = uiNewHorizontalBox;
newvbox = uiNewVerticalBox;
memset(&o, 0, sizeof (uiInitOptions));
for (i = 1; i < argc; i++)
if (strcmp(argv[i], "nomenus") == 0)
nomenus = 1;
else if (strcmp(argv[i], "startspaced") == 0)
startspaced = 1;
else if (strcmp(argv[i], "swaphv") == 0) {
newhbox = uiNewVerticalBox;
newvbox = uiNewHorizontalBox;
} else {
fprintf(stderr, "%s: unrecognized option %s\n", argv[0], argv[i]);
return 1;
}
err = uiInit(&o);
if (err != NULL) {
fprintf(stderr, "error initializing ui: %s\n", err);
uiFreeInitError(err);
return 1;
}
if (!nomenus)
initMenus();
w = newWindow("Main Window", 320, 240, 1);
uiWindowOnClosing(w, onClosing, NULL);
printf("main window %p\n", w);
uiOnShouldQuit(onShouldQuit, w);
mainBox = newHorizontalBox();
uiWindowSetChild(w, uiControl(mainBox));
mainTab = newTab();
uiBoxAppend(mainBox, uiControl(mainTab), 1);
// page 1 uses page 2's uiGroup
page2 = makePage2();
makePage1(w);
uiTabAppend(mainTab, "Page 1", uiControl(page1));
uiTabAppend(mainTab, "Page 2", uiControl(page2));
uiTabAppend(mainTab, "Empty Page", uiControl(uiNewHorizontalBox()));
page3 = makePage3();
uiTabAppend(mainTab, "Page 3", uiControl(page3));
page4 = makePage4();
uiTabAppend(mainTab, "Page 4", uiControl(page4));
page5 = makePage5();
uiTabAppend(mainTab, "Page 5", uiControl(page5));
if (startspaced)
setSpaced(1);
uiControlShow(uiControl(w));
uiMain();
printf("after uiMain()\n");
uiUninit();
printf("after uiUninit()\n");
return 0;
}
