MythRenderOpenGL* MythRenderOpenGL::Create(const QString &painter, QPaintDevice* device) { QGLFormat format; format.setDepth(false); #if defined(Q_WS_MAC) format.setSwapInterval(1); #endif #ifdef USING_OPENGLES if (device) return new MythRenderOpenGL2ES(format, device); return new MythRenderOpenGL2ES(format); #else if (painter.contains("opengl2")) { if (device) return new MythRenderOpenGL2(format, device); return new MythRenderOpenGL2(format); } if (device) return new MythRenderOpenGL1(format, device); return new MythRenderOpenGL1(format); #endif }
QT_BEGIN_NAMESPACE QGLFormat QGLFormat::fromPlatformWindowFormat(const QPlatformWindowFormat &format) { QGLFormat retFormat; retFormat.setAccum(format.accum()); if (format.accumBufferSize() >= 0) retFormat.setAccumBufferSize(format.accumBufferSize()); retFormat.setAlpha(format.alpha()); if (format.alphaBufferSize() >= 0) retFormat.setAlphaBufferSize(format.alphaBufferSize()); if (format.blueBufferSize() >= 0) retFormat.setBlueBufferSize(format.blueBufferSize()); retFormat.setDepth(format.depth()); if (format.depthBufferSize() >= 0) retFormat.setDepthBufferSize(format.depthBufferSize()); retFormat.setDirectRendering(format.directRendering()); retFormat.setDoubleBuffer(format.doubleBuffer()); if (format.greenBufferSize() >= 0) retFormat.setGreenBufferSize(format.greenBufferSize()); if (format.redBufferSize() >= 0) retFormat.setRedBufferSize(format.redBufferSize()); retFormat.setRgba(format.rgba()); retFormat.setSampleBuffers(format.sampleBuffers()); retFormat.setSamples(format.sampleBuffers()); retFormat.setStencil(format.stencil()); if (format.stencilBufferSize() >= 0) retFormat.setStencilBufferSize(format.stencilBufferSize()); retFormat.setStereo(format.stereo()); retFormat.setSwapInterval(format.swapInterval()); return retFormat; }
/*===========================================================================*/ void ScreenBase::create() { KVS_ASSERT( m_id == -1 ); // Initialize display mode. QGLFormat f = QGLFormat::defaultFormat(); f.setDoubleBuffer( displayFormat().doubleBuffer() ); f.setRgba( displayFormat().colorBuffer() ); f.setDepth( displayFormat().depthBuffer() ); f.setAccum( displayFormat().accumulationBuffer() ); f.setStencil( displayFormat().stencilBuffer() ); f.setStereo( displayFormat().stereoBuffer() ); f.setSampleBuffers( displayFormat().multisampleBuffer() ); f.setAlpha( displayFormat().alphaChannel() ); QGLFormat::setDefaultFormat( f ); // Set screen geometry. QWidget::setGeometry( BaseClass::x(), BaseClass::y(), BaseClass::width(), BaseClass::height() ); QGLWidget::makeCurrent(); // Initialize GLEW. GLenum result = glewInit(); if ( result != GLEW_OK ) { const GLubyte* message = glewGetErrorString( result ); kvsMessageError( "GLEW initialization failed: %s.", message ); } // Create window. static int counter = 0; m_id = counter++; }
void *QGLContext::chooseVisual() { static int bufDepths[] = { 8, 4, 2, 1 }; // Try 16, 12 also? //todo: if pixmap, also make sure that vi->depth == pixmap->depth void* vis = 0; int i = 0; bool fail = FALSE; QGLFormat fmt = format(); bool tryDouble = !fmt.doubleBuffer(); // Some GL impl's only have double bool triedDouble = FALSE; while( !fail && !( vis = tryVisual( fmt, bufDepths[i] ) ) ) { if ( !fmt.rgba() && bufDepths[i] > 1 ) { i++; continue; } if ( tryDouble ) { fmt.setDoubleBuffer( TRUE ); tryDouble = FALSE; triedDouble = TRUE; continue; } else if ( triedDouble ) { fmt.setDoubleBuffer( FALSE ); triedDouble = FALSE; } if ( fmt.stereo() ) { fmt.setStereo( FALSE ); continue; } if ( fmt.accum() ) { fmt.setAccum( FALSE ); continue; } if ( fmt.stencil() ) { fmt.setStencil( FALSE ); continue; } if ( fmt.alpha() ) { fmt.setAlpha( FALSE ); continue; } if ( fmt.depth() ) { fmt.setDepth( FALSE ); continue; } if ( fmt.doubleBuffer() ) { fmt.setDoubleBuffer( FALSE ); continue; } fail = TRUE; } glFormat = fmt; return vis; }
QGLFormat QtCanvas::getQGLFormat(const Buffers buffers) { QGLFormat format = QGLFormat(); format.setAlpha(buffers & GLCanvas::ALPHA_BUFFER); format.setDepth(buffers & GLCanvas::DEPTH_BUFFER); format.setDoubleBuffer(buffers & GLCanvas::DOUBLE_BUFFER); format.setStencil(buffers & GLCanvas::STENCIL_BUFFER); format.setAccum(buffers & GLCanvas::ACCUM_BUFFER); format.setStereo(buffers & GLCanvas::STEREO_VIEWING); format.setSampleBuffers(buffers & GLCanvas::MULTISAMPLING); return format; }
void XyzWindow::CreateXYZView() { QFrame *XyFrame; QFrame *XzFrame; QFrame *ZyFrame; QWidget *centralWidget; centralWidget = new QWidget(this); QPalette palette; palette.setColor(QPalette::Background , QColor(/*200,200,200*/167, 210, 200)); centralWidget->setAutoFillBackground(true); centralWidget->setPalette(palette); XzFrame = new QFrame(centralWidget); XzFrame->setGeometry(QRect(mXorigin1,mYorigin1 , mx+2*FRAM_BORDER , mz+2*FRAM_BORDER)); XzFrame->setFrameShape(QFrame::StyledPanel); XzFrame->setFrameShadow(QFrame::Raised); ZyFrame = new QFrame(centralWidget); ZyFrame->setGeometry(QRect(mXorigin2 , mYorigin2 , mz+2*FRAM_BORDER ,my+2*FRAM_BORDER)); ZyFrame->setFrameShape(QFrame::StyledPanel); ZyFrame->setFrameShadow(QFrame::Raised); XyFrame = new QFrame(centralWidget); XyFrame->setGeometry(QRect(mXorigin1 , mYorigin2 , mx+2*FRAM_BORDER ,my+2*FRAM_BORDER)); XyFrame->setFrameShape(QFrame::StyledPanel); XyFrame->setFrameShadow(QFrame::Raised); palette.setColor(QPalette::Background , QColor(255,0,0)); XzFrame->setAutoFillBackground(true); XzFrame->setPalette(palette); ZyFrame->setAutoFillBackground(true); ZyFrame->setPalette(palette); XyFrame->setAutoFillBackground(true); XyFrame->setPalette(palette); setCentralWidget(centralWidget); QGLFormat glFormat; glFormat.setRgba(true); glFormat.setDoubleBuffer(true); glFormat.setDepth(true); mXY_GLw = new XyzGL(glFormat , XY_VIEW , XyFrame , this); mXY_GLw->setGeometry(FRAM_BORDER , FRAM_BORDER,mx,my); mXY_GLw->setAttribute(Qt::WA_DeleteOnClose); mXZ_GLw = new XyzGL(glFormat , XZ_VIEW , XzFrame , this); mXZ_GLw->setGeometry(FRAM_BORDER , FRAM_BORDER , mx ,mz); mXZ_GLw->setAttribute(Qt::WA_DeleteOnClose); mYZ_GLw = new XyzGL(glFormat , ZY_VIEW , ZyFrame , this); mYZ_GLw->setGeometry(FRAM_BORDER , FRAM_BORDER ,mz ,my); mYZ_GLw->setAttribute(Qt::WA_DeleteOnClose); }
static QGLFormat& getDesiredGLFormat() { // Specify an OpenGL 3.3 format using the Core profile. // That is, no old-school fixed pipeline functionality static QGLFormat glFormat; static std::once_flag once; std::call_once(once, [] { glFormat.setVersion(4, 1); glFormat.setProfile(QGLFormat::CoreProfile); // Requires >=Qt-4.8.0 glFormat.setSampleBuffers(false); glFormat.setDepth(false); glFormat.setStencil(false); }); return glFormat; }
bool VideoOutputOpenGL::SetupContext(void) { QMutexLocker locker(&gl_context_lock); if (gl_context) { VERBOSE(VB_PLAYBACK, LOC + QString("Re-using context")); return true; } MythMainWindow* win = MythMainWindow::getMainWindow(); if (!win) { VERBOSE(VB_IMPORTANT, LOC_ERR + "Failed to get MythMainWindow"); return false; } //gl_context = dynamic_cast<MythRenderOpenGL*>(win->GetRenderDevice()); if (gl_context) { gl_context->UpRef(); VERBOSE(VB_PLAYBACK, LOC + "Using main UI render context"); return true; } QGLFormat fmt; fmt.setDepth(false); QGLWidget *device = (QGLWidget*)QWidget::find(gl_parent_win); if (!device) { VERBOSE(VB_IMPORTANT, LOC_ERR + "Failed to cast parent to QGLWidget"); return false; } gl_context = MythRenderOpenGL::Create(fmt, device); if (gl_context && gl_context->create()) { gl_context->Init(); VERBOSE(VB_GENERAL, LOC + QString("Created MythRenderOpenGL device.")); return true; } VERBOSE(VB_IMPORTANT, LOC_ERR + "Failed to create MythRenderOpenGL device."); if (gl_context) gl_context->DownRef(); gl_context = NULL; return false; }
int main(int argc, char **argv) { QGLFormat fmt; fmt.setRgba(true); fmt.setAlpha(true); fmt.setDepth(true); fmt.setDoubleBuffer(true); QGLFormat::setDefaultFormat(fmt); QApplication app(argc, argv); MainWindow window; window.showMaximized(); for (int i = 1; i < argc; i++) window.objectSet()->loadFile(argv[i]); return app.exec(); }
void MapView::setUseOpenGL(bool useOpenGL) { #ifndef QT_NO_OPENGL if (useOpenGL && QGLFormat::hasOpenGL()) { if (!qobject_cast<QGLWidget*>(viewport())) { QGLFormat format = QGLFormat::defaultFormat(); format.setDepth(false); // No need for a depth buffer format.setSampleBuffers(true); // Enable anti-aliasing setViewport(new QGLWidget(format)); } } else { if (qobject_cast<QGLWidget*>(viewport())) setViewport(0); } QWidget *v = viewport(); v->setAttribute(Qt::WA_StaticContents); v->setMouseTracking(true); #endif }
void ConfigManager::Initialize() { QGLFormat glf = QGLFormat::defaultFormat(); glf.setRedBufferSize(8); glf.setGreenBufferSize(8); glf.setBlueBufferSize(8); glf.setAlphaBufferSize(8); glf.setSampleBuffers(true); glf.setSamples(8); glf.setDepth(true); glf.setDepthBufferSize(24); glf.setVersion(3, 3); glf.setProfile(QGLFormat::CompatibilityProfile); glf.setSwapInterval(1); QGLFormat::setDefaultFormat(glf); input_state_ = InputState::SELECT; snap_to_grid_ = true; grid_minor_color_ = QColor(175, 175, 175); grid_major_color_ = QColor(75, 75, 75); }
void MapView::setUseOpenGL(bool useOpenGL) { #ifndef QT_NO_OPENGL #if QT_VERSION >= 0x050400 if (useOpenGL) { if (!qobject_cast<QOpenGLWidget*>(viewport())) { QSurfaceFormat format = QSurfaceFormat::defaultFormat(); format.setDepthBufferSize(0); // No need for a depth buffer format.setSamples(4); // Enable anti-aliasing QOpenGLWidget *openGLWidget = new QOpenGLWidget(this); openGLWidget->setFormat(format); setViewport(openGLWidget); } } else { if (qobject_cast<QOpenGLWidget*>(viewport())) setViewport(nullptr); } #else if (useOpenGL && QGLFormat::hasOpenGL()) { if (!qobject_cast<QGLWidget*>(viewport())) { QGLFormat format = QGLFormat::defaultFormat(); format.setDepth(false); // No need for a depth buffer format.setSampleBuffers(true); // Enable anti-aliasing setViewport(new QGLWidget(format)); } } else { if (qobject_cast<QGLWidget*>(viewport())) setViewport(nullptr); } #endif QWidget *v = viewport(); if (mMode == StaticContents) v->setAttribute(Qt::WA_StaticContents); v->setMouseTracking(true); #else Q_UNUSED(useOpenGL) #endif }
void GridsPlugin::initDockWidget() { // create and add doc widget _dock_widget = new QDockWidget(QObject::tr("Grid Viewer")); _dock_widget->setAllowedAreas(Qt::RightDockWidgetArea); _dock_widget->setObjectName("gridViewerDock"); QGLFormat format; format.setVersion(2, 1); format.setDoubleBuffer(true); format.setDepth(true); format.setRgba(true); format.setAlpha(false); format.setAccum(false); format.setStencil(false); format.setStereo(false); format.setDirectRendering(true); format.setOverlay(false); _viewer = new GridViewer(format); _viewer->setMinimumSize(250, 0); _viewer->setObjectName("gridViewer"); QVBoxLayout *layout = new QVBoxLayout(); layout->addWidget(_viewer); QWidget *widget = new QWidget(); widget->setLayout(layout); _dock_widget->setWidget(widget); NeuroGui::MainWindow::instance()->addDockWidget(Qt::RightDockWidgetArea, _dock_widget); // add to view menu NeuroGui::MainWindow::instance()->toolBarsMenu()->addAction(_dock_widget->toggleViewAction()); }
void System::initializeGL() { // We will destroy and rebuild it with the chosen OpenGL format in the end, but we need to have a valid current OpenGL // context for calling some of the methods below. //sharedWidget = new QGLWidget; //sharedWidget->makeCurrent(); struct _GLVersion { unsigned int majorVer; unsigned int minorVer; }; // Array of all the OpenGL versions that gtatools-gui might work with. We will try to build a context with the first entry // in this array, and if that fails, we go on trying the next one and so on. _GLVersion glVersionsToTry[] = { { 4, 3 }, { 4, 2 }, { 4, 1 }, { 4, 0 }, { 3, 3 }, { 3, 2 }, { 3, 1 }, { 3, 0 } }; QGLFormat::OpenGLVersionFlags vflags = QGLFormat::openGLVersionFlags(); QGLFormat defaultGlFormat; defaultGlFormat.setDoubleBuffer(true); defaultGlFormat.setDirectRendering(true); defaultGlFormat.setDepth(true); defaultGlFormat.setAlpha(true); // NOTE: This line is VERY important. GLEW (tested with version 1.11) does not work with OpenGL 3.2+ Core Contexts, // apparently because it calls glGetString(GL_EXTENSIONS), which is deprecated and therefore returns an error on the // Core profile, which makes GLEW fail at basically everything. // This issue is described in http://www.opengl.org/wiki/OpenGL_Loading_Library. Quote: // // "GLEW has a problem with core contexts. It calls glGetString(GL_EXTENSIONS), which causes GL_INVALID_ENUM on GL // 3.2+ core context as soon as glewInit() is called. It also doesn't fetch the function pointers. The solution // is for GLEW to use glGetStringi instead. The current version of GLEW is 1.10.0 but they still haven't corrected // it. The only fix is to use glewExperimental for now" // // Instead of using glewExperimental, we simply use the compatibility profile (which is probably a good idea in general, // god knows how many "deprecated" (-> compatibility!) features I use in libgta that might fail with a core context... defaultGlFormat.setProfile(QGLFormat::CompatibilityProfile); int majorVer = 0; int minorVer = 0; bool foundMatching = false; for (size_t i = 0 ; i < sizeof(glVersionsToTry)/sizeof(_GLVersion) ; i++) { _GLVersion ver = glVersionsToTry[i]; defaultGlFormat.setVersion(ver.majorVer, ver.minorVer); sharedWidget = new QGLWidget(defaultGlFormat); sharedWidget->makeCurrent(); majorVer = sharedWidget->format().majorVersion(); minorVer = sharedWidget->format().minorVersion(); if (majorVer > ver.majorVer || (majorVer == ver.majorVer && minorVer >= ver.minorVer)) { foundMatching = true; break; } else { delete sharedWidget; } } if (!foundMatching) { fprintf(stderr, "ERROR: OpenGL >= 3.0 seems to be unsupported on the system. gtatools-gui will need at least OpenGL " "3.0 to work correctly!\n"); } printf("Using OpenGL version %d.%d\n", majorVer, minorVer); QGLFormat::setDefaultFormat(defaultGlFormat); }
QGLGraphicsSystem::QGLGraphicsSystem(bool useX11GL) : QGraphicsSystem(), m_useX11GL(useX11GL) { #if defined(Q_WS_X11) && !defined(QT_OPENGL_ES) // only override the system defaults if the user hasn't already // picked a visual if (X11->visual == 0 && X11->visual_id == -1 && X11->visual_class == -1) { // find a double buffered, RGBA visual that supports OpenGL // and set that as the default visual for windows in Qt int i = 0; int spec[16]; spec[i++] = GLX_RGBA; spec[i++] = GLX_DOUBLEBUFFER; if (!qgetenv("QT_GL_SWAPBUFFER_PRESERVE").isNull()) { spec[i++] = GLX_DEPTH_SIZE; spec[i++] = 8; spec[i++] = GLX_STENCIL_SIZE; spec[i++] = 8; spec[i++] = GLX_SAMPLE_BUFFERS_ARB; spec[i++] = 1; spec[i++] = GLX_SAMPLES_ARB; spec[i++] = 4; } spec[i++] = XNone; XVisualInfo *vi = glXChooseVisual(X11->display, X11->defaultScreen, spec); if (vi) { X11->visual_id = vi->visualid; X11->visual_class = vi->c_class; QGLFormat format; int res; glXGetConfig(X11->display, vi, GLX_LEVEL, &res); format.setPlane(res); glXGetConfig(X11->display, vi, GLX_DOUBLEBUFFER, &res); format.setDoubleBuffer(res); glXGetConfig(X11->display, vi, GLX_DEPTH_SIZE, &res); format.setDepth(res); if (format.depth()) format.setDepthBufferSize(res); glXGetConfig(X11->display, vi, GLX_RGBA, &res); format.setRgba(res); glXGetConfig(X11->display, vi, GLX_RED_SIZE, &res); format.setRedBufferSize(res); glXGetConfig(X11->display, vi, GLX_GREEN_SIZE, &res); format.setGreenBufferSize(res); glXGetConfig(X11->display, vi, GLX_BLUE_SIZE, &res); format.setBlueBufferSize(res); glXGetConfig(X11->display, vi, GLX_ALPHA_SIZE, &res); format.setAlpha(res); if (format.alpha()) format.setAlphaBufferSize(res); glXGetConfig(X11->display, vi, GLX_ACCUM_RED_SIZE, &res); format.setAccum(res); if (format.accum()) format.setAccumBufferSize(res); glXGetConfig(X11->display, vi, GLX_STENCIL_SIZE, &res); format.setStencil(res); if (format.stencil()) format.setStencilBufferSize(res); glXGetConfig(X11->display, vi, GLX_STEREO, &res); format.setStereo(res); glXGetConfig(X11->display, vi, GLX_SAMPLE_BUFFERS_ARB, &res); format.setSampleBuffers(res); if (format.sampleBuffers()) { glXGetConfig(X11->display, vi, GLX_SAMPLES_ARB, &res); format.setSamples(res); } QGLWindowSurface::surfaceFormat = format; XFree(vi); printf("using visual class %x, id %x\n", X11->visual_class, X11->visual_id); } } #elif defined(Q_WS_WIN) QGLWindowSurface::surfaceFormat.setDoubleBuffer(true); qt_win_owndc_required = true; #endif }
WaveformWidgetFactory::WaveformWidgetFactory() : m_type(WaveformWidgetType::Count_WaveformwidgetType), m_config(0), m_skipRender(false), m_frameRate(30), m_defaultZoom(3), m_zoomSync(false), m_overviewNormalized(false), m_openGLAvailable(false), m_openGLShaderAvailable(false), m_vsyncThread(NULL), m_frameCnt(0), m_actualFrameRate(0) { m_visualGain[All] = 1.5; m_visualGain[Low] = 1.0; m_visualGain[Mid] = 1.0; m_visualGain[High] = 1.0; if (QGLFormat::hasOpenGL()) { QGLFormat glFormat; glFormat.setDirectRendering(true); glFormat.setDoubleBuffer(true); glFormat.setDepth(false); // Disable waiting for vertical Sync // This can be enabled when using a single Threads for each QGLContext // Setting 1 causes QGLContext::swapBuffer to sleep until the next VSync #if defined(__APPLE__) // On OS X, syncing to vsync has good performance FPS-wise and // eliminates tearing. glFormat.setSwapInterval(1); #else // Otherwise, turn VSync off because it could cause horrible FPS on // Linux. // TODO(XXX): Make this configurable. // TOOD(XXX): What should we do on Windows? glFormat.setSwapInterval(0); #endif glFormat.setRgba(true); QGLFormat::setDefaultFormat(glFormat); QGLFormat::OpenGLVersionFlags version = QGLFormat::openGLVersionFlags(); int majorVersion = 0; int minorVersion = 0; if (version == QGLFormat::OpenGL_Version_None) { m_openGLVersion = "None"; } else if (version & QGLFormat::OpenGL_Version_3_0) { majorVersion = 3; } else if (version & QGLFormat::OpenGL_Version_2_1) { majorVersion = 2; minorVersion = 1; } else if (version & QGLFormat::OpenGL_Version_2_0) { majorVersion = 2; minorVersion = 0; } else if (version & QGLFormat::OpenGL_Version_1_5) { majorVersion = 1; minorVersion = 5; } else if (version & QGLFormat::OpenGL_Version_1_4) { majorVersion = 1; minorVersion = 4; } else if (version & QGLFormat::OpenGL_Version_1_3) { majorVersion = 1; minorVersion = 3; } else if (version & QGLFormat::OpenGL_Version_1_2) { majorVersion = 1; minorVersion = 2; } else if (version & QGLFormat::OpenGL_Version_1_1) { majorVersion = 1; minorVersion = 1; } if (majorVersion != 0) { m_openGLVersion = QString::number(majorVersion) + "." + QString::number(minorVersion); } m_openGLAvailable = true; QGLWidget* glWidget = new QGLWidget(); // create paint device // QGLShaderProgram::hasOpenGLShaderPrograms(); valgind error m_openGLShaderAvailable = QGLShaderProgram::hasOpenGLShaderPrograms(glWidget->context()); delete glWidget; } evaluateWidgets(); m_time.start(); }
CubeWidget::CubeWidget(const QString &name, int pos) : ModuleWidget(name, pos) { m_active = false; m_varsCount = 0; m_cube = Kernel::instance()->getCube(); // OpenGL format QGLFormat fmt; fmt.setDepth(true); fmt.setAlpha(true); // drawer m_drawer = new CubeGLDrawer(fmt); m_gm = GUIManager::instance(); // changing one term in drawer connect(m_drawer, SIGNAL(cubeChanged(int, OutputValue &)), m_gm, SLOT(setTerm(int, OutputValue &))); // minimizing formula from drawer connect(m_drawer, SIGNAL(minRequested()), m_gm, SLOT(minimizeFormula())); // creating new formula connect(m_gm, SIGNAL(formulaChanged()), m_drawer, SLOT(reloadCube())); connect(m_gm, SIGNAL(formulaChanged()), this, SLOT(updateData())); connect(m_gm, SIGNAL(minimalFormulaChanged()), this, SLOT(updateData())); connect(m_gm, SIGNAL(minimalFormulaChanged()), m_drawer, SLOT(reloadCube())); // request for minimizing cube connect(m_gm, SIGNAL(formulaMinimized()), m_drawer, SLOT(minimizeCube())); // request for invalidating cube connect(m_gm, SIGNAL(formulaInvalidated()), m_drawer, SLOT(invalidateCube())); connect(m_gm, SIGNAL(formulaInvalidated()), this, SLOT(invalidateData())); // formula representation changed connect(m_gm, SIGNAL(repreChanged(bool)), this, SLOT(setRepre(bool))); // setting drawer activity connect(this, SIGNAL(activated(bool)), m_drawer, SLOT(setActivity(bool))); QHBoxLayout *glLayout = new QHBoxLayout; glLayout->setMargin(0); glLayout->addWidget(m_drawer); BorderWidget *borderWidget = new BorderWidget; borderWidget->setLayout(glLayout); BorderWidget *error1Widget = new BorderWidget(tr("No logic function for Cube.")); BorderWidget *error2Widget = new BorderWidget(tr("Too many variables (max 3 variables).")); m_stack = new QStackedLayout; m_stack->addWidget(borderWidget); m_stack->addWidget(error1Widget); m_stack->addWidget(error2Widget); m_stack->setCurrentIndex(1); // terms m_termsModel = new TermsModel; m_termsView = new QTableView; m_termsView->setModel(m_termsModel); m_termsView->setShowGrid(false); m_termsView->horizontalHeader()->hide(); m_termsView->setMaximumWidth(SIDEBAR_SIZE); m_mintermsStr = tr("Minterms"); m_maxtermsStr = tr("Maxterms"); m_termsLabel = new QLabel(m_gm->isSoP()? m_mintermsStr: m_maxtermsStr); m_termsLabel->setContentsMargins(3, 5, 5, 0); m_termsLabel->setBuddy(m_termsView); // covers m_coversModel = new CoversModel; m_coversView = new QTableView; m_coversView->setModel(m_coversModel); m_coversView->setShowGrid(false); m_coversView->horizontalHeader()->hide(); m_coversView->verticalHeader()->hide(); m_coversView->setMaximumWidth(SIDEBAR_SIZE); m_coversCheckBox = new QCheckBox(tr("Show covers")); m_coversCheckBox->setChecked(Constants::CUBE_COVERS_DEFAULT); m_drawer->showCovers(Constants::CUBE_COVERS_DEFAULT); connect(m_coversCheckBox, SIGNAL(toggled(bool)), this, SLOT(enableCovers(bool))); connect(m_coversCheckBox, SIGNAL(toggled(bool)), m_drawer, SLOT(showCovers(bool))); connect(m_drawer, SIGNAL(showingCoversChanged(bool)), m_coversCheckBox, SLOT(setChecked(bool))); connect(m_termsView->selectionModel(), SIGNAL(selectionChanged(QItemSelection, QItemSelection)), this, SLOT(selectTerms(QItemSelection, QItemSelection))); connect(m_coversView->selectionModel(), SIGNAL(selectionChanged(QItemSelection, QItemSelection)), this, SLOT(selectCovers(QItemSelection, QItemSelection))); #if CUBE_TEXTURES // covers tour m_tourPos = -1; QGroupBox *tourGroupBox = new QGroupBox(tr("Covers tour")); m_tourStartStr = tr("Start tour"); m_tourStopStr = tr("Stop tour"); m_tourBtn = new QPushButton(m_tourStartStr); m_tourBtn->setEnabled(false); m_tourPrevBtn = new QPushButton(tr("Prev")); m_tourPrevBtn->setEnabled(false); m_tourNextBtn = new QPushButton(tr("Next")); m_tourNextBtn->setEnabled(false); QHBoxLayout *tourShiftLayout = new QHBoxLayout; tourShiftLayout->setMargin(0); tourShiftLayout->addWidget(m_tourPrevBtn); tourShiftLayout->addWidget(m_tourNextBtn); QVBoxLayout *tourMainLayout = new QVBoxLayout; tourMainLayout->setMargin(0); tourMainLayout->addWidget(m_tourBtn); tourMainLayout->addLayout(tourShiftLayout); tourGroupBox->setLayout(tourMainLayout); // tour connections with drawer connect(m_tourBtn, SIGNAL(clicked()), m_drawer, SLOT(toggleMin())); connect(m_tourNextBtn, SIGNAL(clicked()), m_drawer, SLOT(nextMin())); connect(m_tourPrevBtn, SIGNAL(clicked()), m_drawer, SLOT(prevMin())); connect(m_drawer, SIGNAL(minStarted(int)), this, SLOT(startTour(int))); connect(m_drawer, SIGNAL(minStopped()), this, SLOT(stopTour())); connect(m_drawer, SIGNAL(minShifted(int)), this, SLOT(shiftTour(int))); #endif // espresso EspressoWidget *espressoWidget = new EspressoWidget(CubeGLDrawer::MAX_N); QVBoxLayout *sideLayout = new QVBoxLayout; sideLayout->addWidget(m_termsLabel); sideLayout->addWidget(m_termsView); sideLayout->addWidget(m_coversCheckBox); sideLayout->addWidget(m_coversView); #if CUBE_TEXTURES sideLayout->addWidget(tourGroupBox); #endif sideLayout->addWidget(espressoWidget); sideLayout->setStretchFactor(m_termsView, 5); sideLayout->setStretchFactor(m_coversView, 3); QHBoxLayout *mainLayout = new QHBoxLayout; mainLayout->setMargin(0); //mainLayout->addWidget(borderWidget); mainLayout->addLayout(m_stack); mainLayout->addLayout(sideLayout); setLayout(mainLayout); setFocusPolicy(Qt::StrongFocus); }
int main(int argc, char *argv[]) { int i; const char *resPath = 0; char override_base_file[MAX_STR_LEN] = ""; int override_local_port = 0; char override_remote_host[MAX_STR_LEN] = ""; int override_remote_port = 0; char configfile[MAX_STR_LEN] = "mume.ini"; int default_local_port = 3000; int default_remote_port = 4242; int mud_emulation = 0; #ifdef Q_OS_MACX CFURLRef pluginRef = CFBundleCopyBundleURL(CFBundleGetMainBundle()); CFStringRef macPath = CFURLCopyFileSystemPath(pluginRef, kCFURLPOSIXPathStyle); const char *appPath = CFStringGetCStringPtr(macPath, CFStringGetSystemEncoding()); resPath = (char *)malloc(strlen(appPath)+25); strcpy(resPath, appPath); strcat(resPath, "/Contents/Resources/"); char default_base_file[MAX_STR_LEN] = "mume.pmf"; char default_remote_host[MAX_STR_LEN] = ""; strcpy(configfile, "configs/default.conf"); CFRelease(pluginRef); CFRelease(macPath); #else resPath = ""; char default_base_file[MAX_STR_LEN] = "mume.pmf"; char default_remote_host[MAX_STR_LEN] = "129.241.210.221"; #endif QApplication::setColorSpec( QApplication::CustomColor ); QApplication app( argc, argv ); QPixmap pixmap("images/logo.png"); QSplashScreen *splash = new QSplashScreen(pixmap); splash->show(); splash->showMessage("Loading configuration and database..."); for (i=1; i < argc; i++) { if ((strcmp(argv[i], "--config") == 0) || ( strcmp(argv[i], "-c") == 0)) { if (i == argc) { printf("Too few arguments. Missing config file name.\r\n"); print_usage(); exit(1); } i++; strcpy(configfile, argv[i]); resPath = ""; // obviously the user has an own config file - including the path } if ((strcmp(argv[i], "--emulate") == 0) || ( strcmp(argv[i], "-e") == 0)) { printf("Pandora: Starting in MUD emulation mode.\r\n"); mud_emulation = 1; } if ((strcmp(argv[i], "--base") == 0) || ( strcmp(argv[i], "-b") == 0)) { if (i == argc) { printf("Too few arguments. Missing database.\r\n"); print_usage(); exit(1); } i++; strcpy(override_base_file, argv[i]); // overriding the database file is possible even with default config file } if ((strcmp(argv[i], "--hostname") == 0) || ( strcmp(argv[i], "-hn") == 0)) { if (i == argc) { printf("Too few arguments. Wrong hostname given.\r\n"); print_usage(); exit(1); } i++; strcpy(override_remote_host, argv[i]); } if ((strcmp(argv[i], "--localport") == 0) || ( strcmp(argv[i], "-lp") == 0)) { if (i == argc) { printf("Too few arguments. Missing localport.\r\n"); print_usage(); exit(1); } i++; override_local_port = atoi(argv[i]); } if ((strcmp(argv[i], "--remoteport") == 0) || ( strcmp(argv[i], "-rp") == 0)) { if (i == argc) { printf("Too few arguments. Missing targetport.\r\n"); print_usage(); exit(1); } i++; override_remote_port = atoi(argv[i]); } if ((strcmp(argv[i], "--help") == 0) || ( strcmp(argv[i], "-h") == 0)) { print_usage(); exit(1); } } /* set analyzer engine defaults */ //engine_init(); splash->showMessage(QString("Loading the configuration ") + configfile); conf = new Cconfigurator(); conf->loadConfig(resPath, configfile); print_debug(DEBUG_SYSTEM, "starting up..."); if (override_base_file[0] != 0) { conf->setBaseFile(override_base_file); } else if ( conf->getBaseFile() == "") { conf->setBaseFile(default_base_file); } print_debug(DEBUG_SYSTEM, "Using database file : %s.", (const char*) conf->getBaseFile() ); if (override_remote_host[0] != 0) { conf->setRemoteHost(override_remote_host); } else if ( conf->getRemoteHost().isEmpty() ) { conf->setRemoteHost(default_remote_host); } print_debug(DEBUG_SYSTEM, "Using target hostname : %s.", (const char*) conf->getRemoteHost() ); if (override_local_port != 0) { conf->setLocalPort(override_local_port); } else if ( conf->getLocalPort() == 0) { conf->setLocalPort(default_local_port); } print_debug(DEBUG_SYSTEM, "Using local port : %i.", conf->getLocalPort()); if (override_remote_port != 0) { conf->setRemotePort(override_remote_port); } else if (conf->getRemotePort() == 0) { conf->setRemotePort(default_remote_port); } print_debug(DEBUG_SYSTEM, "Using target port : %i.", conf->getRemotePort()); conf->setConfigModified( false ); splash->showMessage("Starting Analyzer and Proxy..."); engine = new CEngine(new CRoomManager()); proxy = new Proxy(); /* special init for the mud emulation */ if (mud_emulation) { print_debug(DEBUG_SYSTEM, "Starting in MUD emulation mode..."); engine->initEmulationMode(); } proxy->setMudEmulation( mud_emulation ); print_debug(DEBUG_SYSTEM, "Starting renderer ...\n"); if ( !QGLFormat::hasOpenGL() ) { qWarning( "This system has no OpenGL support. Quiting." ); return -1; } QRect rect = app.desktop()->availableGeometry(-1); if (conf->getWindowRect().x() == 0 || conf->getWindowRect().x() >= rect.width() || conf->getWindowRect().y() >= rect.height() ) { print_debug(DEBUG_SYSTEM && DEBUG_INTERFACE, "Autosettings for window size and position"); int x, y, height, width; x = rect.width() / 3 * 2; y = 0; height = rect.height() / 3; width = rect.width() - x; conf->setWindowRect( x, y, width, height); } QGLFormat f = QGLFormat::defaultFormat(); f.setDoubleBuffer( true ); f.setDirectRendering( true ); f.setRgba( true ); f.setDepth( true ); f.setAlpha( true ); if (conf->getMultisampling()) f.setSampleBuffers( true ); //f.setSamples(4); QGLFormat::setDefaultFormat( f ); renderer_window = new CMainWindow; renderer_window->show(); splash->finish(renderer_window); delete splash; proxy->start(); QObject::connect(proxy, SIGNAL(startEngine()), engine, SLOT(slotRunEngine()), Qt::QueuedConnection ); QObject::connect(proxy, SIGNAL(startRenderer()), renderer_window->renderer, SLOT(display()), Qt::QueuedConnection); // this will be done via mainwindow itself //userland_parser->parse_user_input_line("mload"); return app.exec(); }
/* See qgl.cpp for qdoc comment. */ void *QGLContext::chooseVisual() { Q_D(QGLContext); static const int bufDepths[] = { 8, 4, 2, 1 }; // Try 16, 12 also? //todo: if pixmap, also make sure that vi->depth == pixmap->depth void* vis = 0; int i = 0; bool fail = false; QGLFormat fmt = format(); bool tryDouble = !fmt.doubleBuffer(); // Some GL impl's only have double bool triedDouble = false; bool triedSample = false; if (fmt.sampleBuffers()) fmt.setSampleBuffers(QGLExtensions::glExtensions & QGLExtensions::SampleBuffers); while(!fail && !(vis = tryVisual(fmt, bufDepths[i]))) { if (!fmt.rgba() && bufDepths[i] > 1) { i++; continue; } if (tryDouble) { fmt.setDoubleBuffer(true); tryDouble = false; triedDouble = true; continue; } else if (triedDouble) { fmt.setDoubleBuffer(false); triedDouble = false; } if (!triedSample && fmt.sampleBuffers()) { fmt.setSampleBuffers(false); triedSample = true; continue; } if (fmt.stereo()) { fmt.setStereo(false); continue; } if (fmt.accum()) { fmt.setAccum(false); continue; } if (fmt.stencil()) { fmt.setStencil(false); continue; } if (fmt.alpha()) { fmt.setAlpha(false); continue; } if (fmt.depth()) { fmt.setDepth(false); continue; } if (fmt.doubleBuffer()) { fmt.setDoubleBuffer(false); continue; } fail = true; } d->glFormat = fmt; return vis; }
TumblerWindow::TumblerWindow(TumblerStruct *xtum, bool rgba, bool doubleBuffer, bool enableDepth, QWidget * parent, const char * name, Qt::WindowFlags f) : QMainWindow(parent, f) { int j; QString str; mTum = xtum; setAttribute(Qt::WA_DeleteOnClose); setAttribute(Qt::WA_AlwaysShowToolTips); if (firstTime) utilFileListsToIcons(fileList, icons, MAX_XTUM_TOGGLES); firstTime = 0; // Make central vbox and top frame containing an hboxlayout QWidget *central = new QWidget(this); setCentralWidget(central); QVBoxLayout *cenlay = new QVBoxLayout(central); cenlay->setContentsMargins(0,0,0,0); cenlay->setSpacing(0); QFrame * topFrame = new QFrame(central); cenlay->addWidget(topFrame); topFrame->setFrameStyle(QFrame::Raised | QFrame::StyledPanel); QHBoxLayout *topLayout = new QHBoxLayout(topFrame); topLayout->setContentsMargins(2,2,2,2); topLayout->setSpacing(3); QVBoxLayout *topVBox = diaVBoxLayout(topLayout); topVBox->setSpacing(4); QHBoxLayout *topHBox = diaHBoxLayout(topVBox); topHBox->setContentsMargins(0,0,0,0); topHBox->setSpacing(3); // Add the toolbar widgets // Zoom spin box // If you try to make a spin box narrower, it makes the arrows tiny mZoomBox = (QSpinBox *)diaLabeledSpin(0, 1., XTUM_MAX_ZOOM, 1., "Zoom", topFrame, topHBox); mZoomBox->setValue(xtum->zoom); connect(mZoomBox, SIGNAL(valueChanged(int)), this, SLOT(zoomChanged(int))); mZoomBox->setToolTip("Change zoom of display"); // Make the 2 toggle buttons and their signal mapper QSignalMapper *toggleMapper = new QSignalMapper(topFrame); connect(toggleMapper, SIGNAL(mapped(int)), this, SLOT(toggleClicked(int))); for (j = 0; j < 2; j++) { utilSetupToggleButton(topFrame, NULL, topHBox, toggleMapper, icons, toggleTips, mToggleButs, mToggleStates, j); connect(mToggleButs[j], SIGNAL(clicked()), toggleMapper, SLOT(map())); } // Help button mHelpButton = diaPushButton("Help", topFrame, topHBox); connect(mHelpButton, SIGNAL(clicked()), this, SLOT(help())); setFontDependentWidths(); topHBox->addStretch(); // Make second row for size spin boxes, and signal map them QHBoxLayout *botHBox = diaHBoxLayout(topVBox); botHBox->setContentsMargins(0,0,0,0); botHBox->setSpacing(3); QSignalMapper *sizeMapper = new QSignalMapper(topFrame); connect(sizeMapper, SIGNAL(mapped(int)), this, SLOT(sizeChanged(int))); // Make the spin boxes for (j = 0; j < 3; j++) { str = xyzLabels[j]; mSizeBoxes[j] = (QSpinBox *)diaLabeledSpin(0, XTUM_SIZE_MIN, XTUM_SIZE_MAX, XTUM_SIZE_INC, LATIN1(str), topFrame, botHBox); mSizeBoxes[j]->setValue(XTUM_SIZE_INI); sizeMapper->setMapping(mSizeBoxes[j], j); connect(mSizeBoxes[j], SIGNAL(valueChanged(int)), sizeMapper, SLOT(map())); mSizeBoxes[j]->setToolTip("Change size of box in " + str); } // Spacer for the second row botHBox->addStretch(); // Add a vertical line QFrame *vertLine = new QFrame(topFrame); vertLine->setFrameStyle(QFrame::Sunken | QFrame::VLine); topLayout->addWidget(vertLine); // Threshold sliders mSliders = new MultiSlider(topFrame, 2, sliderLabels); topLayout->addLayout(mSliders->getLayout()); connect(mSliders, SIGNAL(sliderChanged(int, int, bool)), this, SLOT(thresholdChanged(int, int, bool))); mSliders->setValue(0, xtum->minval); mSliders->setValue(1, xtum->maxval); mSliders->getSlider(0)->setToolTip( "Level below which pixels will be set to black"); mSliders->getSlider(1)->setToolTip( "Level above which pixels will be set to white"); QGLFormat glFormat; glFormat.setRgba(rgba); glFormat.setDoubleBuffer(doubleBuffer); glFormat.setDepth(enableDepth); mGLw = new TumblerGL(xtum, glFormat, central); cenlay->addWidget(mGLw); cenlay->setStretchFactor(mGLw, 1); resize(XTUM_WIDTH, XTUM_HEIGHT); setFocusPolicy(Qt::StrongFocus); }