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++;
}
QT_BEGIN_NAMESPACE
/*!
Returns an OpenGL format for the window format specified by \a format.
*/
QGLFormat QGLFormat::fromSurfaceFormat(const QSurfaceFormat &format)
{
QGLFormat retFormat;
if (format.alphaBufferSize() >= 0)
retFormat.setAlphaBufferSize(format.alphaBufferSize());
if (format.blueBufferSize() >= 0)
retFormat.setBlueBufferSize(format.blueBufferSize());
if (format.greenBufferSize() >= 0)
retFormat.setGreenBufferSize(format.greenBufferSize());
if (format.redBufferSize() >= 0)
retFormat.setRedBufferSize(format.redBufferSize());
if (format.depthBufferSize() >= 0)
retFormat.setDepthBufferSize(format.depthBufferSize());
if (format.samples() > 1) {
retFormat.setSampleBuffers(format.samples());
retFormat.setSamples(true);
}
if (format.stencilBufferSize() > 0) {
retFormat.setStencil(true);
retFormat.setStencilBufferSize(format.stencilBufferSize());
}
retFormat.setDoubleBuffer(format.swapBehavior() != QSurfaceFormat::SingleBuffer);
retFormat.setStereo(format.stereo());
return retFormat;
}
ArthurFrame::ArthurFrame(QWidget *parent)
: QWidget(parent)
, m_prefer_image(false)
{
#ifdef QT_OPENGL_SUPPORT
glw = 0;
m_use_opengl = false;
QGLFormat f = QGLFormat::defaultFormat();
f.setSampleBuffers(true);
f.setStencil(true);
f.setAlpha(true);
f.setAlphaBufferSize(8);
QGLFormat::setDefaultFormat(f);
#endif
m_document = 0;
m_show_doc = false;
m_tile = QPixmap(128, 128);
m_tile.fill(Qt::white);
QPainter pt(&m_tile);
QColor color(230, 230, 230);
pt.fillRect(0, 0, 64, 64, color);
pt.fillRect(64, 64, 64, 64, color);
pt.end();
// QPalette pal = palette();
// pal.setBrush(backgroundRole(), m_tile);
// setPalette(pal);
#ifdef Q_WS_X11
QPixmap xRenderPixmap(1, 1);
m_prefer_image = xRenderPixmap.pixmapData()->classId() == QPixmapData::X11Class && !xRenderPixmap.x11PictureHandle();
#endif
}
ArthurFrame::ArthurFrame(QWidget *parent)
: QWidget(parent)
, m_prefer_image(false)
{
#ifdef QT_OPENGL_SUPPORT
std::cout << "Using Open GL" << std::endl;
glw = 0;
m_use_opengl = false;
QGLFormat f = QGLFormat::defaultFormat();
f.setSampleBuffers(true);
f.setStencil(true);
f.setAlpha(true);
f.setAlphaBufferSize(8);
QGLFormat::setDefaultFormat(f);
#endif
m_document = 0;
m_show_doc = false;
m_tile = QPixmap(100, 100);
m_tile.fill(Qt::white);
QPainter pt(&m_tile);
QColor color(240, 240, 240);
pt.fillRect(0, 0, 50, 50, color);
pt.fillRect(50, 50, 50, 50, color);
pt.end();
// QPalette pal = palette();
// pal.setBrush(backgroundRole(), m_tile);
// setPalette(pal);
#ifdef Q_WS_X11
QPixmap xRenderPixmap(1, 1);
m_prefer_image = !xRenderPixmap.x11PictureHandle();
#endif
}
void CQTOpenGLMainWindow::CreateOpenGLWidget(TConfigurationNode& t_tree) {
/* Create user functions */
m_pcUserFunctions = CreateUserFunctions(t_tree);
/* Set up OpenGL features */
QGLFormat cGLFormat = QGLFormat::defaultFormat();
cGLFormat.setSampleBuffers(m_pcToggleAntiAliasingAction->isChecked());
cGLFormat.setStencil(false);
QGLFormat::setDefaultFormat(cGLFormat);
/* Create the widget */
QWidget* pcPlaceHolder = new QWidget(this);
m_pcOpenGLWidget = new CQTOpenGLWidget(pcPlaceHolder, *m_pcUserFunctions);
m_pcOpenGLWidget->setCursor(QCursor(Qt::OpenHandCursor));
m_pcOpenGLWidget->GetCamera().Init(t_tree);
m_pcOpenGLWidget->GetFrameGrabData().Init(t_tree);
m_pcToggleAntiAliasingAction->setChecked(cGLFormat.sampleBuffers());
/* Invert mouse controls? */
bool bInvertMouse;
GetNodeAttributeOrDefault(t_tree, "invert_mouse", bInvertMouse, false);
m_pcOpenGLWidget->SetInvertMouse(bInvertMouse);
/* Set the window as the central widget */
CQTOpenGLLayout* pcQTOpenGLLayout = new CQTOpenGLLayout();
pcQTOpenGLLayout->addWidget(m_pcOpenGLWidget);
pcPlaceHolder->setLayout(pcQTOpenGLLayout);
setCentralWidget(pcPlaceHolder);
}
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;
}
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;
}
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());
}
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
}
/*
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;
}
void OffscreenRenderer::prepareRendering(int w, int h)
{
if((!pbuffer && !glWidget) || width < w || height < h)
{
bool usePBuffer = true;
if(pbuffer)
{
delete pbuffer;
pbuffer = 0;
}
if(glWidget)
{
delete glWidget;
glWidget = 0;
usePBuffer = false;
}
if(framebuffer)
{
glDeleteFramebuffersEXT(1, &framebuffer);
framebuffer = 0;
}
if(renderbuffer)
{
glDeleteRenderbuffersEXT(1, &renderbuffer);
renderbuffer = 0;
}
if(flippingBuffer)
{
delete[] flippingBuffer;
flippingBuffer = 0;
}
QGLFormat format;
format.setStencil(false);
//format.setDoubleBuffer(false);
format.setSwapInterval(0);
if(usePBuffer)
{
#ifdef _WIN32
pbuffer = new QGLPixelBuffer(QSize(w, h), format);
#else
pbuffer = 0;
#endif
}
if(!pbuffer || !pbuffer->isValid())
{
if(pbuffer)
{
delete pbuffer;
pbuffer = 0;
}
// maybe fall back to "onscreen rendering"
if(!glWidget)
{
glWidget = new QGLWidget(format, 0, 0, Qt::WindowStaysOnTopHint);
glWidget->setFixedSize(w, h);
glWidget->makeCurrent();
width = w;
height = h;
graphicsManager->initContext(false);
}
// QGLFramebufferObject didn't work properly... but well, the framebuffer object extension is platform independend anyway
if(GLEW_EXT_framebuffer_object)
{
GLenum status;
glGenFramebuffersEXT(1, &framebuffer);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, framebuffer);
glGenRenderbuffersEXT(1, &renderbuffer);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, renderbuffer);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA8, w, h);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, renderbuffer);
status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if(status != GL_FRAMEBUFFER_COMPLETE_EXT)
{
if(framebuffer)
{
glDeleteFramebuffersEXT(1, &framebuffer);
framebuffer = 0;
}
if(renderbuffer)
{
glDeleteRenderbuffersEXT(1, &renderbuffer);
renderbuffer = 0;
}
}
}
if(framebuffer)
{
TRACE("OffscreenRenderer: using framebuffer object renderer");
}
else
{
TRACE("OffscreenRenderer: using window renderer");
}
determineImagePositionInBuffer(w, h);
}
else
{
TRACE("OffscreenRenderer: yeah, using pixel buffer renderer");
pbuffer->makeCurrent();
const QSize& size(pbuffer->size());
width = size.width();
height = size.height();
ASSERT(width >= w && height >= h);
graphicsManager->initContext(false);
determineImagePositionInBuffer(w, h);
}
}
VERIFY(makeCurrent());
}
int main(int argc, char **argv)
{
#ifdef CONSOLE_APPLICATION
QApplication app(argc, argv, QApplication::Tty);
#else
QApplication app(argc, argv);
#endif
#ifdef DO_QWS_DEBUGGING
qt_show_painter_debug_output = false;
#endif
DeviceType type = WidgetType;
bool checkers_background = true;
QImage::Format imageFormat = QImage::Format_ARGB32_Premultiplied;
QLocale::setDefault(QLocale::c());
QStringList files;
bool interactive = false;
bool printdlg = false;
bool highres = false;
bool show_cmp = false;
int width = 800, height = 800;
bool verboseMode = false;
#ifndef QT_NO_OPENGL
QGLFormat f = QGLFormat::defaultFormat();
f.setSampleBuffers(true);
f.setStencil(true);
f.setAlpha(true);
f.setAlphaBufferSize(8);
QGLFormat::setDefaultFormat(f);
#endif
char *arg;
for (int i=1; i<argc; ++i) {
arg = argv[i];
if (*arg == '-') {
QString option = QString(arg + 1).toLower();
if (option == "widget")
type = WidgetType;
else if (option == "bitmap")
type = BitmapType;
else if (option == "pixmap")
type = PixmapType;
else if (option == "image")
type = ImageType;
else if (option == "imageformat") {
Q_ASSERT_X(i + 1 < argc, "main", "-imageformat must be followed by a value");
QString format = QString(argv[++i]).toLower();
imageFormat = QImage::Format_Invalid;
static const unsigned int formatCount =
sizeof(imageFormats) / sizeof(imageFormats[0]);
for (int ff = 0; ff < formatCount; ++ff) {
if (QLatin1String(imageFormats[ff].name) == format) {
imageFormat = imageFormats[ff].format;
break;
}
}
if (imageFormat == QImage::Format_Invalid) {
printf("Invalid image format. Available formats are:\n");
for (int ff = 0; ff < formatCount; ++ff)
printf("\t%s\n", imageFormats[ff].name);
return -1;
}
} else if (option == "imagemono")
type = ImageMonoType;
else if (option == "imagewidget")
type = ImageWidgetType;
#ifndef QT_NO_OPENGL
else if (option == "opengl")
type = OpenGLType;
else if (option == "pbuffer")
type = OpenGLPBufferType;
#endif
#ifdef USE_CUSTOM_DEVICE
else if (option == "customdevice")
type = CustomDeviceType;
else if (option == "customwidget")
type = CustomWidgetType;
#endif
else if (option == "pdf")
type = PdfType;
else if (option == "ps")
type = PsType;
else if (option == "picture")
type = PictureType;
else if (option == "printer")
type = PrinterType;
else if (option == "highres") {
type = PrinterType;
highres = true;
} else if (option == "printdialog") {
type = PrinterType;
printdlg = true;
}
else if (option == "grab")
type = GrabType;
else if (option == "i")
interactive = true;
else if (option == "v")
verboseMode = true;
else if (option == "commands") {
displayCommands();
return 0;
} else if (option == "w") {
Q_ASSERT_X(i + 1 < argc, "main", "-w must be followed by a value");
width = atoi(argv[++i]);
} else if (option == "h") {
Q_ASSERT_X(i + 1 < argc, "main", "-h must be followed by a value");
height = atoi(argv[++i]);
} else if (option == "cmp") {
show_cmp = true;
} else if (option == "bg-white") {
checkers_background = false;
}
} else {
#if defined (Q_WS_WIN)
QString input = QString::fromLocal8Bit(argv[i]);
if (input.indexOf('*') >= 0) {
QFileInfo info(input);
QDir dir = info.dir();
QFileInfoList infos = dir.entryInfoList(QStringList(info.fileName()));
for (int ii=0; ii<infos.size(); ++ii)
files.append(infos.at(ii).absoluteFilePath());
} else {
files.append(input);
}
#else
files.append(QString(argv[i]));
#endif
}
}
PaintCommands pcmd(QStringList(), 800, 800);
pcmd.setVerboseMode(verboseMode);
pcmd.setType(type);
pcmd.setCheckersBackground(checkers_background);
QWidget *activeWidget = 0;
if (interactive) {
runInteractive();
if (!files.isEmpty())
interactive_widget->load(files.at(0));
} else if (files.isEmpty()) {
printHelp();
return 0;
} else {
for (int j=0; j<files.size(); ++j) {
const QString &fileName = files.at(j);
QStringList content;
QFile file(fileName);
QFileInfo fileinfo(file);
if (file.open(QIODevice::ReadOnly)) {
QTextStream textFile(&file);
QString script = textFile.readAll();
content = script.split("\n", QString::SkipEmptyParts);
} else {
printf("failed to read file: '%s'\n", qPrintable(fileName));
continue;
}
pcmd.setContents(content);
if (show_cmp) {
QString pmFile = QString(files.at(j)).replace(".qps", "_qps") + ".png";
qDebug() << pmFile << QFileInfo(pmFile).exists();
QPixmap pixmap(pmFile);
if (!pixmap.isNull()) {
QLabel *label = createLabel();
label->setWindowTitle("VERIFY: " + pmFile);
label->setPixmap(pixmap);
label->show();
}
}
switch (type) {
case WidgetType:
{
OnScreenWidget<QWidget> *qWidget =
new OnScreenWidget<QWidget>;
qWidget->setVerboseMode(verboseMode);
qWidget->setType(type);
qWidget->setCheckersBackground(checkers_background);
qWidget->m_filename = files.at(j);
qWidget->setWindowTitle(fileinfo.filePath());
qWidget->m_commands = content;
qWidget->resize(width, height);
qWidget->show();
activeWidget = qWidget;
break;
}
case ImageWidgetType:
{
OnScreenWidget<QWidget> *qWidget = new OnScreenWidget<QWidget>;
qWidget->setVerboseMode(verboseMode);
qWidget->setType(type);
qWidget->setCheckersBackground(checkers_background);
qWidget->m_filename = files.at(j);
qWidget->setWindowTitle(fileinfo.filePath());
qWidget->m_commands = content;
qWidget->resize(width, height);
qWidget->show();
activeWidget = qWidget;
break;
}
#ifndef QT_NO_OPENGL
case OpenGLPBufferType:
{
QGLPixelBuffer pbuffer(QSize(width, height));
QPainter pt(&pbuffer);
pcmd.setPainter(&pt);
pcmd.setFilePath(fileinfo.absolutePath());
pcmd.runCommands();
pt.end();
QImage image = pbuffer.toImage();
QLabel *label = createLabel();
label->setPixmap(QPixmap::fromImage(image));
label->resize(label->sizeHint());
label->show();
activeWidget = label;
break;
}
case OpenGLType:
{
OnScreenWidget<QGLWidget> *qGLWidget = new OnScreenWidget<QGLWidget>;
qGLWidget->setVerboseMode(verboseMode);
qGLWidget->setType(type);
qGLWidget->setCheckersBackground(checkers_background);
qGLWidget->m_filename = files.at(j);
qGLWidget->setWindowTitle(fileinfo.filePath());
qGLWidget->m_commands = content;
qGLWidget->resize(width, height);
qGLWidget->show();
activeWidget = qGLWidget;
break;
}
#else
case OpenGLType:
printf("OpenGL type not supported in this Qt build\n");
break;
#endif
#ifdef USE_CUSTOM_DEVICE
case CustomDeviceType:
{
CustomPaintDevice custom(width, height);
QPainter pt;
pt.begin(&custom);
pcmd.setPainter(&pt);
pcmd.setFilePath(fileinfo.absolutePath());
pcmd.runCommands();
pt.end();
QImage *img = custom.image();
if (img) {
QLabel *label = createLabel();
label->setPixmap(QPixmap::fromImage(*img));
label->resize(label->sizeHint());
label->show();
activeWidget = label;
img->save("custom_output_pixmap.png", "PNG");
} else {
custom.save("custom_output_pixmap.png", "PNG");
}
break;
}
case CustomWidgetType:
{
OnScreenWidget<CustomWidget> *cWidget = new OnScreenWidget<CustomWidget>;
cWidget->setVerboseMode(verboseMode);
cWidget->setType(type);
cWidget->setCheckersBackground(checkers_background);
cWidget->m_filename = files.at(j);
cWidget->setWindowTitle(fileinfo.filePath());
cWidget->m_commands = content;
cWidget->resize(width, height);
cWidget->show();
activeWidget = cWidget;
break;
}
#endif
case PixmapType:
{
QPixmap pixmap(width, height);
pixmap.fill(Qt::white);
QPainter pt(&pixmap);
pcmd.setPainter(&pt);
pcmd.setFilePath(fileinfo.absolutePath());
pcmd.runCommands();
pt.end();
pixmap.save("output_pixmap.png", "PNG");
break;
}
case BitmapType:
{
QBitmap bitmap(width, height);
QPainter pt(&bitmap);
pcmd.setPainter(&pt);
pcmd.setFilePath(fileinfo.absolutePath());
pcmd.runCommands();
pt.end();
bitmap.save("output_bitmap.png", "PNG");
QLabel *label = createLabel();
label->setPixmap(bitmap);
label->resize(label->sizeHint());
label->show();
activeWidget = label;
break;
}
case ImageMonoType:
case ImageType:
{
qDebug() << "Creating image";
QImage image(width, height, type == ImageMonoType
? QImage::Format_MonoLSB
: imageFormat);
image.fill(0);
QPainter pt(&image);
pcmd.setPainter(&pt);
pcmd.setFilePath(fileinfo.absolutePath());
pcmd.runCommands();
pt.end();
image.convertToFormat(QImage::Format_ARGB32).save("output_image.png", "PNG");
#ifndef CONSOLE_APPLICATION
QLabel *label = createLabel();
label->setPixmap(QPixmap::fromImage(image));
label->resize(label->sizeHint());
label->show();
activeWidget = label;
#endif
break;
}
case PictureType:
{
QPicture pic;
QPainter pt(&pic);
pcmd.setPainter(&pt);
pcmd.setFilePath(fileinfo.absolutePath());
pcmd.runCommands();
pt.end();
QImage image(width, height, QImage::Format_ARGB32_Premultiplied);
image.fill(0);
pt.begin(&image);
pt.drawPicture(0, 0, pic);
pt.end();
QLabel *label = createLabel();
label->setWindowTitle(fileinfo.absolutePath());
label->setPixmap(QPixmap::fromImage(image));
label->resize(label->sizeHint());
label->show();
activeWidget = label;
break;
}
case PrinterType:
{
PaintCommands pcmd(QStringList(), 800, 800);
pcmd.setVerboseMode(verboseMode);
pcmd.setType(type);
pcmd.setCheckersBackground(checkers_background);
pcmd.setContents(content);
QString file = QString(files.at(j)).replace(".", "_") + ".ps";
QPrinter p(highres ? QPrinter::HighResolution : QPrinter::ScreenResolution);
if (printdlg) {
QPrintDialog printDialog(&p, 0);
if (printDialog.exec() != QDialog::Accepted)
break;
} else {
p.setOutputFileName(file);
}
QPainter pt(&p);
pcmd.setPainter(&pt);
pcmd.setFilePath(fileinfo.absolutePath());
pcmd.runCommands();
pt.end();
if (!printdlg) {
printf("wrote file: %s\n", qPrintable(file));
}
Q_ASSERT(!p.paintingActive());
break;
}
case PsType:
case PdfType:
{
PaintCommands pcmd(QStringList(), 800, 800);
pcmd.setVerboseMode(verboseMode);
pcmd.setType(type);
pcmd.setCheckersBackground(checkers_background);
pcmd.setContents(content);
bool ps = type == PsType;
QPrinter p(highres ? QPrinter::HighResolution : QPrinter::ScreenResolution);
QFileInfo input(files.at(j));
QString file = QString("%1_%2.%3")
.arg(input.baseName())
.arg(input.suffix())
.arg(ps ? "ps" : "pdf");
p.setOutputFormat(ps ? QPrinter::PdfFormat : QPrinter::PostScriptFormat);
p.setOutputFileName(file);
p.setPageSize(QPrinter::A4);
QPainter pt(&p);
pcmd.setPainter(&pt);
pcmd.setFilePath(fileinfo.absolutePath());
pcmd.runCommands();
pt.end();
printf("write file: %s\n", qPrintable(file));
break;
}
case GrabType:
{
QImage image(width, height, QImage::Format_ARGB32_Premultiplied);
image.fill(QColor(Qt::white).rgb());
QPainter pt(&image);
pcmd.setPainter(&pt);
pcmd.setFilePath(fileinfo.absolutePath());
pcmd.runCommands();
pt.end();
QImage image1(width, height, QImage::Format_RGB32);
image1.fill(QColor(Qt::white).rgb());
QPainter pt1(&image1);
pt1.drawImage(QPointF(0, 0), image);
pt1.end();
QString filename = QString(files.at(j)).replace(".qps", "_qps") + ".png";
image1.save(filename, "PNG");
printf("%s grabbed to %s\n", qPrintable(files.at(j)), qPrintable(filename));
break;
}
default:
break;
}
}
}
#ifndef CONSOLE_APPLICATION
if (activeWidget || interactive) {
QObject::connect(&app, SIGNAL(lastWindowClosed()), &app, SLOT(quit()));
app.exec();
}
delete activeWidget;
#endif
return 0;
}
int main(int argc, char *argv[])
{
#ifdef Q_OS_WIN
// Enable standard input/output on Windows Platform for debug
BOOL consoleAttached = ::AttachConsole(ATTACH_PARENT_PROCESS);
if (consoleAttached) {
freopen("CON", "r", stdin);
freopen("CON", "w", stdout);
freopen("CON", "w", stderr);
}
#endif
/*-- "-layout [レイアウト設定ファイル名]" で、必要なモジュールのPageだけのレイアウトで起動することを可能にする --*/
QString argumentLayoutFileName = "";
TFilePath loadScenePath;
if (argc > 1) {
for (int a = 1; a < argc; a++) {
if (QString(argv[a]) == "-layout") {
argumentLayoutFileName = QString(argv[a + 1]);
a++;
} else
loadScenePath = TFilePath(argv[a]);
}
}
QApplication a(argc, argv);
#ifdef Q_OS_WIN
// Since currently OpenToonz does not work with OpenGL of software or angle,
// force Qt to use desktop OpenGL
a.setAttribute(Qt::AA_UseDesktopOpenGL, true);
#endif
// Some Qt objects are destroyed badly withouth a living qApp. So, we must enforce a way to either
// postpone the application destruction until the very end, OR ensure that sensible objects are
// destroyed before.
// Using a static QApplication only worked on Windows, and in any case C++ respects the statics destruction
// order ONLY within the same library. On MAC, it made the app crash on exit o_o. So, nope.
std::auto_ptr<QObject> mainScope(new QObject(&a)); // A QObject destroyed before the qApp is therefore explicitly
mainScope->setObjectName("mainScope"); // provided. It can be accessed by looking in the qApp's children.
#ifdef _WIN32
#ifndef x64
//Store the floating point control word. It will be re-set before Toonz initialization
//has ended.
unsigned int fpWord = 0;
_controlfp_s(&fpWord, 0, 0);
#endif
#endif
#ifdef _WIN32
//At least on windows, Qt's 4.5.2 native windows feature tend to create
//weird flickering effects when dragging panel separators.
a.setAttribute(Qt::AA_DontCreateNativeWidgetSiblings);
#endif
//Set the app's locale for numeric stuff to standard C. This is important for atof() and similar
//calls that are locale-dependant.
setlocale(LC_NUMERIC, "C");
// Set current directory to the bundle/application path - this is needed to have correct relative paths
#ifdef MACOSX
{
QDir appDir(QApplication::applicationDirPath());
appDir.cdUp(), appDir.cdUp(), appDir.cdUp();
bool ret = QDir::setCurrent(appDir.absolutePath());
assert(ret);
}
#endif
// splash screen
QPixmap splashPixmap(":Resources/splash.png");
#ifdef _WIN32
a.setFont(QFont("Arial", 10));
#else
a.setFont(QFont("Helvetica", 10));
#endif
QString offsetStr("\n\n\n\n\n\n\n\n");
TSystem::hasMainLoop(true);
TMessageRepository::instance();
QSplashScreen splash(splashPixmap);
splash.show();
a.processEvents();
splash.showMessage(offsetStr + "Initializing QGLFormat...", Qt::AlignCenter, Qt::white);
a.processEvents();
// OpenGL
QGLFormat fmt;
fmt.setAlpha(true);
fmt.setStencil(true);
QGLFormat::setDefaultFormat(fmt);
#ifdef LINUX
glutInit(&argc, argv);
#endif
splash.showMessage(offsetStr + "Initializing Toonz environment ...", Qt::AlignCenter, Qt::white);
a.processEvents();
//Install run out of contiguous memory callback
TBigMemoryManager::instance()->setRunOutOfContiguousMemoryHandler(&toonzRunOutOfContMemHandler);
// Toonz environment
initToonzEnv();
// Initialize thread components
TThread::init();
TProjectManager *projectManager = TProjectManager::instance();
if (Preferences::instance()->isSVNEnabled()) {
// Read Version Control repositories and add it to project manager as "special" svn project root
VersionControl::instance()->init();
QList<SVNRepository> repositories = VersionControl::instance()->getRepositories();
int count = repositories.size();
for (int i = 0; i < count; i++) {
SVNRepository r = repositories.at(i);
TFilePath localPath(r.m_localPath.toStdWString());
if (!TFileStatus(localPath).doesExist()) {
try {
TSystem::mkDir(localPath);
} catch (TException &e) {
fatalError(QString::fromStdWString(e.getMessage()));
}
}
projectManager->addSVNProjectsRoot(localPath);
}
}
#if defined(MACOSX) && defined(__LP64__)
//Load the shared memory settings
int shmmax = Preferences::instance()->getShmMax();
int shmseg = Preferences::instance()->getShmSeg();
int shmall = Preferences::instance()->getShmAll();
int shmmni = Preferences::instance()->getShmMni();
if (shmall < 0) //Make sure that at least 100 MB of shared memory are available
shmall = (tipc::shm_maxSharedPages() < (100 << 8)) ? (100 << 8) : -1;
tipc::shm_set(shmmax, shmseg, shmall, shmmni);
#endif
// DVDirModel must be instantiated after Version Control initialization...
FolderListenerManager::instance()->addListener(DvDirModel::instance());
splash.showMessage(offsetStr + "Loading Translator ...", Qt::AlignCenter, Qt::white);
a.processEvents();
// Carico la traduzione contenuta in toonz.qm (se � presente)
QString languagePathString = QString::fromStdString(toString(TEnv::getConfigDir() + "loc"));
#ifndef WIN32
//the merge of menu on osx can cause problems with different languages with the Preferences menu
//qt_mac_set_menubar_merge(false);
languagePathString += "/" + Preferences::instance()->getCurrentLanguage();
#else
languagePathString += "\\" + Preferences::instance()->getCurrentLanguage();
#endif
QTranslator translator;
#ifdef LINETEST
translator.load("linetest", languagePathString);
#else
translator.load("toonz", languagePathString);
#endif
// La installo
a.installTranslator(&translator);
// Carico la traduzione contenuta in toonzqt.qm (se e' presente)
QTranslator translator2;
translator2.load("toonzqt", languagePathString);
a.installTranslator(&translator2);
// Carico la traduzione contenuta in tnzcore.qm (se e' presente)
QTranslator tnzcoreTranslator;
tnzcoreTranslator.load("tnzcore", languagePathString);
qApp->installTranslator(&tnzcoreTranslator);
// Carico la traduzione contenuta in toonzlib.qm (se e' presente)
QTranslator toonzlibTranslator;
toonzlibTranslator.load("toonzlib", languagePathString);
qApp->installTranslator(&toonzlibTranslator);
// Carico la traduzione contenuta in colorfx.qm (se e' presente)
QTranslator colorfxTranslator;
colorfxTranslator.load("colorfx", languagePathString);
qApp->installTranslator(&colorfxTranslator);
// Carico la traduzione contenuta in tools.qm
QTranslator toolTranslator;
toolTranslator.load("tnztools", languagePathString);
qApp->installTranslator(&toolTranslator);
// Aggiorno la traduzione delle properties di tutti i tools
TTool::updateToolsPropertiesTranslation();
splash.showMessage(offsetStr + "Loading styles ...", Qt::AlignCenter, Qt::white);
a.processEvents();
// stile
QApplication::setStyle("windows");
IconGenerator::setFilmstripIconSize(Preferences::instance()->getIconSize());
splash.showMessage(offsetStr + "Loading shaders ...", Qt::AlignCenter, Qt::white);
a.processEvents();
loadShaderInterfaces(ToonzFolder::getLibraryFolder() + TFilePath("shaders"));
splash.showMessage(offsetStr + "Initializing Toonz application ...", Qt::AlignCenter, Qt::white);
a.processEvents();
TTool::setApplication(TApp::instance());
TApp::instance()->init();
//iwsw commented out temporarily
#if 0
QStringList monitorNames;
/*-- 接続モニタがPVM-2541の場合のみLUTを読み込む --*/
if (Preferences::instance()->isDoColorCorrectionByUsing3DLutEnabled())
{
/*-- 接続モニタがPVM-2541の場合のみLUTを読み込む --*/
monitorNames = Ghibli3DLutUtil::getMonitorName();
if (monitorNames.contains(QString::fromStdWString(L"PVM-2541")))
/*-- 3DLUTファイルを読み込む --*/
Ghibli3DLutUtil::loadLutFile(Preferences::instance()->get3DLutPath());
}
/*-- 接続モニタをスプラッシュ画面にも表示 --*/
if (!monitorNames.isEmpty())
{
lastUpdateStr += QString("Monitor Name : ");
for (int mn = 0; mn < monitorNames.size(); mn++)
{
if (mn != 0)
lastUpdateStr += QString(", ");
lastUpdateStr += monitorNames.at(mn);
}
lastUpdateStr += QString("\n");
}
#endif
splash.showMessage(offsetStr + "Loading Plugins...", Qt::AlignCenter, Qt::white);
a.processEvents();
/* poll the thread ends:
絶対に必要なわけではないが PluginLoader は中で setup ハンドラが常に固有のスレッドで呼ばれるよう main thread queue の blocking をしているので
processEvents を行う必要がある
*/
while (!PluginLoader::load_entries("")) {
a.processEvents();
}
splash.showMessage(offsetStr + "Creating main window ...", Qt::AlignCenter, Qt::white);
a.processEvents();
/*-- Layoutファイル名をMainWindowのctorに渡す --*/
MainWindow w(argumentLayoutFileName);
splash.showMessage(offsetStr + "Loading style sheet ...", Qt::AlignCenter, Qt::white);
a.processEvents();
// Carico lo styleSheet
QString currentStyle = Preferences::instance()->getCurrentStyleSheet();
a.setStyleSheet(currentStyle);
TApp::instance()->setMainWindow(&w);
w.setWindowTitle(applicationFullName);
splash.showMessage(offsetStr + "Starting main window ...", Qt::AlignCenter, Qt::white);
a.processEvents();
TFilePath fp = ToonzFolder::getModuleFile("mainwindow.ini");
QSettings settings(toQString(fp), QSettings::IniFormat);
w.restoreGeometry(settings.value("MainWindowGeometry").toByteArray());
#ifndef MACOSX
//Workaround for the maximized window case: Qt delivers two resize events, one in the normal geometry, before
//maximizing (why!?), the second afterwards - all inside the following show() call. This makes troublesome for
//the docking system to correctly restore the saved geometry. Fortunately, MainWindow::showEvent(..) gets called
//just between the two, so we can disable the currentRoom layout right before showing and re-enable it after
//the normal resize has happened.
if (w.isMaximized())
w.getCurrentRoom()->layout()->setEnabled(false);
#endif
QRect splashGeometry = splash.geometry();
splash.finish(&w);
a.setQuitOnLastWindowClosed(false);
// a.connect(&a, SIGNAL(lastWindowClosed()), &a, SLOT(quit()));
w.checkForUpdates();
w.show();
//Show floating panels only after the main window has been shown
w.startupFloatingPanels();
CommandManager::instance()->execute(T_Hand);
if (!loadScenePath.isEmpty()) {
splash.showMessage(QString("Loading file '") + loadScenePath.getQString() + "'...", Qt::AlignCenter, Qt::white);
loadScenePath = loadScenePath.withType("tnz");
if (TFileStatus(loadScenePath).doesExist())
IoCmd::loadScene(loadScenePath);
}
QFont *myFont;
std::string family = EnvSoftwareCurrentFont;
myFont = new QFont(QString(family.c_str()));
myFont->setPixelSize(EnvSoftwareCurrentFontSize);
/*-- フォントのBoldの指定 --*/
std::string weight = EnvSoftwareCurrentFontWeight;
if (strcmp(weight.c_str(), "Yes") == 0)
myFont->setBold(true);
else
myFont->setBold(false);
a.setFont(*myFont);
QAction *action = CommandManager::instance()->getAction("MI_OpenTMessage");
if (action)
QObject::connect(TMessageRepository::instance(), SIGNAL(openMessageCenter()), action, SLOT(trigger()));
QObject::connect(
TUndoManager::manager(), SIGNAL(somethingChanged()),
TApp::instance()->getCurrentScene(), SLOT(setDirtyFlag()));
#ifdef _WIN32
#ifndef x64
//On 32-bit architecture, there could be cases in which initialization could alter the
//FPU floating point control word. I've seen this happen when loading some AVI coded (VFAPI),
//where 80-bit internal precision was used instead of the standard 64-bit (much faster and
//sufficient - especially considering that x86 truncates to 64-bit representation anyway).
//IN ANY CASE, revert to the original control word.
//In the x64 case these precision changes simply should not take place up to _controlfp_s
//documentation.
_controlfp_s(0, fpWord, -1);
#endif
#endif
a.installEventFilter(TApp::instance());
int ret = a.exec();
TUndoManager::manager()->reset();
PreviewFxManager::instance()->reset();
#ifdef _WIN32
if (consoleAttached) {
::FreeConsole();
}
#endif
return ret;
}
