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;
}
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
}
const QGLFormat GLFormat::asQGLFormat() const
{
QGLFormat format;
format.setVersion(m_majorVersion, m_minorVersion);
switch(m_profile)
{
default:
case NoProfile:
format.setProfile(QGLFormat::NoProfile);
break;
case CoreProfile:
format.setProfile(QGLFormat::CoreProfile);
break;
case CompatibilityProfile:
format.setProfile(QGLFormat::CompatibilityProfile);
break;
};
format.setRedBufferSize (m_redBufferSize);
format.setGreenBufferSize (m_greenBufferSize);
format.setBlueBufferSize (m_blueBufferSize);
format.setAlphaBufferSize (m_alphaBufferSize);
format.setDepthBufferSize (m_depthBufferSize);
format.setStencilBufferSize(m_stencilBufferSize);
format.setDoubleBuffer (m_doubleBuffer);
format.setStereo (m_stereo);
format.setSampleBuffers (m_sampleBuffers);
format.setSamples (m_samples);
format.setSwapInterval (m_swapInterval);
return format;
}
BMDOpenGLOutput::BMDOpenGLOutput()
: pDL(NULL), pDLOutput(NULL), pDLVideoFrame(NULL), pFrameBuf(NULL)
{
QGLFormat fmt;
fmt.setRedBufferSize(8);
fmt.setGreenBufferSize(8);
fmt.setBlueBufferSize(8);
fmt.setAlphaBufferSize(8);
fmt.setDepthBufferSize(16);
pContext = new QGLWidget(fmt);
getGLExtensions().ResolveExtensions(pContext->context());
pGLScene = new GLScene();
}
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);
}
// Updates "format" with the parameters of the selected configuration.
void qt_glformat_from_eglconfig(QGLFormat& format, const EGLConfig config)
{
EGLint redSize = 0;
EGLint greenSize = 0;
EGLint blueSize = 0;
EGLint alphaSize = 0;
EGLint depthSize = 0;
EGLint stencilSize = 0;
EGLint sampleCount = 0;
EGLint level = 0;
EGLDisplay display = QEgl::display();
eglGetConfigAttrib(display, config, EGL_RED_SIZE, &redSize);
eglGetConfigAttrib(display, config, EGL_GREEN_SIZE, &greenSize);
eglGetConfigAttrib(display, config, EGL_BLUE_SIZE, &blueSize);
eglGetConfigAttrib(display, config, EGL_ALPHA_SIZE, &alphaSize);
eglGetConfigAttrib(display, config, EGL_DEPTH_SIZE, &depthSize);
eglGetConfigAttrib(display, config, EGL_STENCIL_SIZE, &stencilSize);
eglGetConfigAttrib(display, config, EGL_SAMPLES, &sampleCount);
eglGetConfigAttrib(display, config, EGL_LEVEL, &level);
format.setRedBufferSize(redSize);
format.setGreenBufferSize(greenSize);
format.setBlueBufferSize(blueSize);
format.setAlphaBufferSize(alphaSize);
format.setDepthBufferSize(depthSize);
format.setStencilBufferSize(stencilSize);
format.setSamples(sampleCount);
format.setPlane(level);
format.setDirectRendering(true); // All EGL contexts are direct-rendered
format.setRgba(true); // EGL doesn't support colour index rendering
format.setStereo(false); // EGL doesn't support stereo buffers
format.setAccumBufferSize(0); // EGL doesn't support accululation buffers
format.setDoubleBuffer(true); // We don't support single buffered EGL contexts
// Clear the EGL error state because some of the above may
// have errored out because the attribute is not applicable
// to the surface type. Such errors don't matter.
eglGetError();
}
GLMapView::GLMapView(QWidget *parent): m_time(0), m_dtime(1)
{
QGLFormat glFormat;
glFormat.setRgba(true);
glFormat.setRedBufferSize(8);
glFormat.setGreenBufferSize(8);
glFormat.setBlueBufferSize(8);
glFormat.setAlphaBufferSize(8);
::QGLWidget(glFormat,parent);
waterTriVBO = 0;
waterNormVBO = 0;
waterUvVBO = 0;
objTriVBO = 0;
objNormVBO = 0;
objUvVBO = 0;
znear=10.0;
zfar=1000000.0;
ref=1.0; // Эталон непрозрачности =1
xRot = 0.0;
yRot = 0.5;
R = 1000;
shift = Vector3D(0,0,0);
pos = Vector3D(0,0,0);
xMov = 0.0;
yMov = 0.0;
beginP.setSize( 15.0f );
beginP.setColor( 0.0, 1.0, 0.0 );
endP.setSize( 15.0f );
endP.setColor( 1.0, 1.0, 0.0 );
setMouseTracking( true );
timerFreqFps = new QTimer( this );
connect( timerFreqFps, SIGNAL( timeout() ), this, SLOT( renderFrame() ) );
}
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
}
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;
}