""" qtgui/screenshot.py: CCP4MG Molecular Graphics Program Copyright (C) 2001-2008 University of York, CCLRC Copyright (C) 2009-2011 University of York Copyright (C) 2012 STFC This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License version 3, modified in accordance with the provisions of the license to address the requirements of UK law. You should have received a copy of the modified GNU Lesser General Public License along with this library. If not, copies may be downloaded from http://www.ccp4.ac.uk/ccp4license.php This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. """ from PyQt4 import QtGui,QtCore,QtOpenGL from global_definitions import * import sys,os import guiUtils,mgWidgets,MGSimpleDialog import time PREFERENCES = None def saveFile(im,filename): useTiff = False if hasattr(filename,"endswith") and (filename.endswith("tiff") or filename.endswith("tif") or filename.endswith("TIFF") or filename.endswith("TIF")): useTiff = True elif hasattr(filename,"endsWith") and (filename.endsWith("tiff") or filename.endsWith("tif") or filename.endsWith("TIFF") or filename.endsWith("TIF")): useTiff = True if useTiff: print "Compressing tiff" writer = QtGui.QImageWriter(filename) writer.setCompression(1) writer.write(im) else: im.save(filename) #------------------------------------------------------------------- def makeScreenshot(filename='',size=[], hideWindows=1,render_quality=1,clear_labels=0, stereo=0,stereo_angle=6.0,transparent=0,scaleFonts=1, stereo_sep=0.1,stereo_mode='rotation',scaleImages=1, dpi=300,use_pbuffer=False,scalebartext=0,scaleLines=0,**kw): #------------------------------------------------------------------- import tempfile,os,shutil print "screenshot.makeScreenshot",size; sys.stdout.flush() rv = 0 t1=time.time() ''' def handleScreenShotGUI(self): cprim.RenderQuality.SetRenderQuality(1) self.glWidget.SetRenderMode(self.glWidget.IMMEDIATE) self.glWidget.updateGL() iinfo = self.glWidget.screenshot() iinfo.write(output_name) cprim.RenderQuality.SetRenderQuality(0) self.glWidget.SetRenderMode(self.glWidget.DISPLAYLISTS) self.glWidget.updateGL() FILEVIEWER().open(output_name) ''' if stereo: root,ext = os.path.splitext(filename) filn_left = root+'_left'+ext filn_right = root+'_right'+ext if os.path.exists(filn_left): os.remove(filn_left) if os.path.exists(filn_right): os.remove(filn_right) if os.path.exists(filn_left) or os.path.exists(filn_right): return (1,'Intermediate file\n '+filn_left+ \ '\nor'+filn_right+'\nexists'+ \ '\nPlease remove or give alternative file name') glWidget = MAINWINDOW().glWidget r,g,b = glWidget.getBackground() a = glWidget.getBackgroundAlpha() if transparent: if QtOpenGL.QGLFramebufferObject.hasOpenGLFramebufferObjects(): glWidget.setBackground(0,0,0,0) glWidget.fogcolour = QtGui.QColor(r,g,b,a) else: glWidget.setBackground(r,g,b,0) else: glWidget.setBackground(r,g,b,255) # Close all possible obscuring widgets if hideWindows: MAINWINDOW().hideWindows() if render_quality: import cprim,rebuild cprim.RenderQuality.SetRenderQuality(1) rebuild.Rebuild() # Make the screenshot! glWidget.makeCurrent() if size: current_size = glWidget.size() if scaleFonts: current_fontScaling = glWidget.getFontScaling() glWidget.setFontScaling(glWidget.getFontScaling()*float(size[1])/glWidget.size().height()) if not use_pbuffer: glWidget.resize(size[0],size[1]) if stereo: # We are just using rotation stereo here, even if graphics window uses shear. # I guess we should use *option* of shear here too. import pygl_coord oldExtraMatrix = glWidget.getExtraMatrix() glWidget.setExtraMatrix(None) oldExtraQuat = glWidget.extra_quat glWidget.extra_quat = pygl_coord.Quat(0.0,0.0,0.0,0) if stereo_mode == "rotation": if not use_pbuffer: # left image glWidget.setRotation(0.0,stereo_angle*0.5 ,0.0 ) glWidget.updateGL() iinfo = glWidget.screenshot() iinfo.write(str(filn_left)) # right image glWidget.setRotation(0.0,-stereo_angle,0.0 ) glWidget.updateGL() iinfo = glWidget.screenshot() iinfo.write(str(filn_right)) # back to original position glWidget.setRotation(0.0,stereo_angle*0.5 ,0.0 ) glWidget.setExtraMatrix(oldExtraMatrix) glWidget.extra_quat = oldExtraQuat else: glWidget.setRotation(0.0,stereo_angle*0.5 ,0.0 ) glWidget.updateGL() imleft = glWidget.screenshot_pbuffer(size=QtCore.QSize(size[0],size[1]),scalebartext=scalebartext,scaleLines=scaleLines) glWidget.setRotation(0.0,-stereo_angle ,0.0 ) glWidget.updateGL() imright = glWidget.screenshot_pbuffer(size=QtCore.QSize(size[0],size[1]),scalebartext=scalebartext,scaleLines=scaleLines) glWidget.setRotation(0.0,stereo_angle*0.5 ,0.0 ) glWidget.setExtraMatrix(oldExtraMatrix) glWidget.extra_quat = oldExtraQuat if stereo_mode == "shear": if not use_pbuffer: shear_plus = pygl_coord.matrix(4,4,[1,0,0,0, 0,1,0,0, stereo_sep,0,1,0, 0,0,0,1]) shear_minus = pygl_coord.matrix(4,4,[1,0,0,0, 0,1,0,0, -stereo_sep,0,1,0, 0,0,0,1]) matp = shear_plus.to_dp() matm = shear_minus.to_dp() # left image glWidget.setExtraMatrix(matp) glWidget.updateGL() iinfo = glWidget.screenshot() iinfo.write(str(filn_left)) # right image glWidget.setExtraMatrix(matm) glWidget.updateGL() iinfo = glWidget.screenshot() iinfo.write(str(filn_right)) # back to original position glWidget.setExtraMatrix(oldExtraMatrix) if not use_pbuffer: rv = merge_image_files(filn_left,filn_right,filename,dpi) else: rv = merge_image_files("junk","junk",filename,dpi,im1=imleft,im2=imright) else: if len(MAINWINDOW().glWidgets) == 1: glWidget.updateGL() if not use_pbuffer: iinfo = glWidget.screenshot() if hasattr(iinfo,"write"): f = tempfile.mkstemp(".png") tmpnam = f[1] os.close(f[0]) iinfo.write(tmpnam) im1 = QtGui.QImage(tmpnam) else: im1 = iinfo else: #print size im1 = glWidget.screenshot_pbuffer(size=QtCore.QSize(size[0],size[1]),scalebartext=scalebartext,scaleLines=scaleLines) print "Time for get screenshot",time.time()-t1; sys.stdout.flush() print im1.size(), str(filename) im1.setDotsPerMeterX(int(dpi*1000./25.4)) im1.setDotsPerMeterY(int(dpi*1000./25.4)) saveFile(im1,QtCore.QString.fromUtf8(filename)) print "Time for save",time.time()-t1; sys.stdout.flush() else: images = [] bgcolour = glWidget.getBackground() if transparent: col = QtGui.QColor(bgcolour[0],bgcolour[1],bgcolour[2],0) else: col = QtGui.QColor(bgcolour[0],bgcolour[1],bgcolour[2],255) sys.stdout.flush() for widget in MAINWINDOW().glWidgets: widget.makeCurrent() if not use_pbuffer: iinfo = widget.screenshot() f = tempfile.mkstemp(".png") tmpnam = f[1] os.close(f[0]) iinfo.write(tmpnam) im = QtGui.QImage(tmpnam) else: im = widget.screenshot_pbuffer(size=QtCore.QSize(size[0],size[1]),scalebartext=scalebartext,scaleLines=scaleLines) if size: widget.resize(current_size.width(),current_size.height()) if scaleFonts: widget.setFontScaling(current_fontScaling) if QtOpenGL.QGLFramebufferObject.hasOpenGLFramebufferObjects(): widget.setBackground(r,g,b,a) widget.fogcolour = None images.append(im) if len(images)==2: pixmap = QtGui.QPixmap(images[0].width()+images[1].width(),images[0].height()) painter = QtGui.QPainter() painter.begin(pixmap) painter.drawImage(0,0,images[0]) painter.drawImage(images[0].width(),0,images[1]) painter.end() image = pixmap.toImage() image.setDotsPerMeterX(int(dpi*1000./25.4)) image.setDotsPerMeterY(int(dpi*1000./25.4)) saveFile(image,QtCore.QString.fromUtf8(filename)) elif len(images)==3: pixmap = QtGui.QPixmap(images[0].width()+images[1].width(),images[0].height()+images[2].height()) pixmap.fill(col) painter = QtGui.QPainter() painter.begin(pixmap) painter.drawImage(0,0,images[0]) painter.drawImage(images[0].width(),0,images[1]) painter.drawImage(0,images[0].height(),images[2]) painter.end() image = pixmap.toImage() image.setDotsPerMeterX(int(dpi*1000./25.4)) image.setDotsPerMeterY(int(dpi*1000./25.4)) saveFile(image,QtCore.QString.fromUtf8(filename)) if size: glWidget.resize(current_size.width(),current_size.height()) if scaleFonts: glWidget.setFontScaling(current_fontScaling) if render_quality: cprim.RenderQuality.SetRenderQuality(0) rebuild.Rebuild() if QtOpenGL.QGLFramebufferObject.hasOpenGLFramebufferObjects(): glWidget.setBackground(r,g,b,a) glWidget.fogcolour = None glWidget.updateGL() if hideWindows: MAINWINDOW().hideWindows(open=1) print "Finish time",time.time()-t1; sys.stdout.flush() if rv: return rv else: return (0,unicode(filename,'utf-8')) #--------------------------------------------------------------------------- def merge_image_files(filn_left,filn_right,filename,dpi=None,im1=None,im2=None): #--------------------------------------------------------------------------- if not im1: im1 = QtGui.QImage(QtCore.QString.fromUtf8(filn_left)) if not im2: im2 = QtGui.QImage(QtCore.QString.fromUtf8(filn_right)) pix = QtGui.QPixmap(im1.width()+im2.width(),max(im1.height(),im2.height())) pix.fill(QtGui.QColor(0,0,0,0)) painter = QtGui.QPainter(pix) painter.drawImage(0,0,im1) painter.drawImage(im1.width(),0,im2) painter.end() im1 = pix.toImage() if dpi: im1.setDotsPerMeterX(int(dpi*1000./25.4)) im1.setDotsPerMeterY(int(dpi*1000./25.4)) saveFile(im1,QtCore.QString.fromUtf8(filename)) return [0,unicode(filename,'utf-8')] #--------------------------------------------------------------------------- def makePDF(printer=None,fitMode='scale',render_quality=1): #--------------------------------------------------------------------------- #print 'makePDF',printer,fitMode,str(printer.outputFileName()) if not printer: return [1,'No printer info in screenshot.makePDF'] if sys.platform == "win32": return [1,'makePDF does not currently work on Windows'] import tempfile,os qimage_list = [] if render_quality: import cprim,rebuild cprim.RenderQuality.SetRenderQuality(1) rebuild.Rebuild() for glWidget in MAINWINDOW().glWidgets: glWidget.updateGL() # Get screen dump(s) as QImage # Save as a png and then load as a QImage for glWidget in MAINWINDOW().glWidgets: iinfo = glWidget.screenshot() f = tempfile.mkstemp(".png") iinfo.writepng(f[0]) qimage_list.append(QtGui.QImage(f[1])) if render_quality: cprim.RenderQuality.SetRenderQuality(0) rebuild.Rebuild() for glWidget in MAINWINDOW().glWidgets: glWidget.updateGL() # Make it fit actual_width = 0 for qimage in qimage_list: actual_width = actual_width + qimage.width() actual_height = qimage_list[0].height() #print 'makePDF actual_width',len(qimage_list),actual_width,actual_height,'printer',printer.width() if fitMode == 'scale': if actual_width > printer.width(): scale = float(printer.width())/float(actual_width) #print 'makePDF scaling width',scale for ii in range(len(qimage_list)): req_width = int(float(qimage_list[ii].width())*scale) qimage_list[ii] = qimage_list[ii].scaledToWidth(req_width,QtCore.Qt.SmoothTransformation) if actual_height > printer.height(): req_height = printer.height() for ii in range(len(qimage_list)): qimage_list[ii] = qimage_list[ii].scaledToHeight(req_height,QtCore.Qt.SmoothTransformation) else: pass ''' if actual_width > printer.width() or actual_height > printer.height(): centre_px = printer.width()/2 centre_ix = qimage.width()/2 x = centre_ix - centre_px centre_py = printer.height()/2 centre_iy = qimage.height()/2 y = centre_iy - centre_py qimage = qimage.copy(x,y,printer.width(),printer.height()) ''' # Output the image painter = QtGui.QPainter() painter.begin(printer) xx = 0 for qimage in qimage_list: painter.drawImage(xx,0,qimage) xx = xx + int(qimage.width()) painter.end() return [0,str(printer.outputFileName())] class screenShotOptions(QtGui.QWidget): def setStereoPrefsEnabled(self,clicked=None): if not self.stereo.isChecked(): self.stereo_angle.setEnabled(False) self.stereo_sep.setEnabled(False) self.stereo_mode_shear.setEnabled(False) self.stereo_mode_rot.setEnabled(False) return else: self.stereo_mode_shear.setEnabled(True) self.stereo_mode_rot.setEnabled(True) if self.stereo_mode_shear.isChecked(): self.stereo_angle.setEnabled(False) self.stereo_sep.setEnabled(True) else: self.stereo_angle.setEnabled(True) self.stereo_sep.setEnabled(False) def __init__(self,parent=None): QtGui.QWidget.__init__(self,parent) layout = QtGui.QGridLayout() layout.setSpacing(2) layout.setContentsMargins(2,2,2,2) size_frame = QtGui.QFrame(self) size_frame.setFrameStyle(QtGui.QFrame.Box) size_layout = QtGui.QVBoxLayout() style_frame = QtGui.QFrame(self) style_frame.setFrameStyle(QtGui.QFrame.Box) style_layout = QtGui.QVBoxLayout() review_frame = QtGui.QFrame(self) review_frame.setFrameStyle(QtGui.QFrame.Box) review_layout = QtGui.QVBoxLayout() # Validator needed if use QLineEdit #self.validator = QtGui.QIntValidator(self) size_group = QtGui.QButtonGroup(self) self.size_window = QtGui.QRadioButton(self.tr('Display window size x'),self) size_group.addButton(self.size_window) label0 = QtGui.QLabel(self.tr('Output image size')) self.magnification = QtGui.QDoubleSpinBox(self) self.magnification.setRange(0.2,4.0) self.magnification.setSingleStep(0.2) self.size_defined = QtGui.QRadioButton(self.tr('Width (in pixels)'),self) self.scaleFonts = QtGui.QCheckBox(self.tr('Scale font sizes'),self) self.scaleLines = QtGui.QCheckBox(self.tr('Scale line widths'),self) self.scaleImages = QtGui.QCheckBox(self.tr('Scale image sizes'),self) size_group.addButton(self.size_defined) self.dpi_defined = QtGui.QRadioButton(self.tr('Use dpi'),self) size_group.addButton(self.dpi_defined) self.heightWidget = QtGui.QSpinBox(self) self.heightWidget.setRange(0,5000) #self.heightWidget.setValidator(self.validator) label = QtGui.QLabel('height') self.widthWidget = QtGui.QSpinBox(self) self.widthWidget.setRange(0,5000) #self.widthWidget.setValidator(self.validator) self.transparent = QtGui.QCheckBox(self.tr('Transparent background')) self.scalebartext = QtGui.QCheckBox(self.tr('Output text on scale bar')) self.stereo = QtGui.QCheckBox(self.tr('Stereo image')) stereo_group = QtGui.QButtonGroup(self) self.stereo_mode_shear = QtGui.QRadioButton(self.tr('Shear stereo with separation'),self) self.stereo_mode_rot = QtGui.QRadioButton(self.tr('Rotation stereo with angle'),self) stereo_group.addButton(self.stereo_mode_shear) stereo_group.addButton(self.stereo_mode_rot) self.connect(self.stereo,QtCore.SIGNAL("clicked (bool)"),self.setStereoPrefsEnabled) self.connect(self.stereo_mode_shear,QtCore.SIGNAL("clicked (bool)"),self.setStereoPrefsEnabled) self.connect(self.stereo_mode_rot,QtCore.SIGNAL("clicked (bool)"),self.setStereoPrefsEnabled) self.stereo_angle = QtGui.QDoubleSpinBox(self) self.stereo_angle.setRange(-20.0,20.0) self.stereo_angle.setSingleStep(1.0) self.stereo_sep = QtGui.QDoubleSpinBox(self) self.stereo_sep.setRange(-2.0,2.0) self.stereo_sep.setSingleStep(0.1) self.save_status = QtGui.QCheckBox(self.tr('Save status file')) self.save_status.setChecked(1) self.preview = QtGui.QCheckBox(self.tr('View output')) self.preview.setChecked(1) self.width_dpi_inches = QtGui.QDoubleSpinBox(self) self.height_dpi_inches = QtGui.QDoubleSpinBox(self) self.dpi_spin = QtGui.QSpinBox(self) self.dpi_spin.setMaximum(6000) self.dpi_spin.setValue(300) width_dpi_label = QtGui.QLabel(" width (in)") height_dpi_label = QtGui.QLabel(" height") self.width_dpi_inches.setValue(6.0) self.height_dpi_inches.setValue(4.0) size_layout.addWidget(label0) layout0 = QtGui.QHBoxLayout() layout0.addWidget(self.size_window) layout0.addWidget(self.magnification) layout0.addStretch() size_layout.addLayout(layout0) layout1 = QtGui.QHBoxLayout() layout1.addWidget(self.size_defined) layout1.addWidget(self.widthWidget) layout1.addWidget(label) layout1.addWidget(self.heightWidget) layout1.addStretch() size_layout.addLayout(layout1) self.keepLayout = QtGui.QHBoxLayout() self.keepAspect = QtGui.QCheckBox(self.tr('Keep graphics window aspect'),self) self.keepLayout.addSpacing(10) self.keepLayout.addWidget(self.keepAspect) layout2 = QtGui.QHBoxLayout() layout2.addWidget(self.dpi_defined) layout2.addWidget(self.dpi_spin) layout2.addWidget(width_dpi_label) layout2.addWidget(self.width_dpi_inches) layout2.addWidget(height_dpi_label) layout2.addWidget(self.height_dpi_inches) layout2.addStretch() size_layout.addSpacing(10) size_layout.addLayout(layout2) size_layout.addLayout(self.keepLayout) size_layout.addWidget(self.scaleFonts) size_layout.addWidget(self.scaleLines) size_layout.addWidget(self.scaleImages) size_frame.setLayout(size_layout) size_layout.addStretch() self.connect(self.widthWidget,QtCore.SIGNAL("valueChanged(int)"),self.checkHeight) self.connect(self.heightWidget,QtCore.SIGNAL("valueChanged(int)"),self.checkWidth) self.connect(self.width_dpi_inches,QtCore.SIGNAL("valueChanged(double)"),self.checkHeightDPI) self.connect(self.height_dpi_inches,QtCore.SIGNAL("valueChanged(double)"),self.checkWidthDPI) style_layout.addWidget(self.transparent) style_layout.addWidget(self.stereo) line_layout = QtGui.QHBoxLayout() line_layout.addWidget(self.stereo_mode_shear) line_layout.addWidget(self.stereo_sep) style_layout.addLayout(line_layout) line_layout = QtGui.QHBoxLayout() line_layout.addWidget(self.stereo_mode_rot) line_layout.addWidget(self.stereo_angle) style_layout.addLayout(line_layout) style_layout.addWidget(self.scalebartext) style_frame.setLayout(style_layout) style_layout.addStretch() review_layout.addWidget(self.save_status) review_layout.addWidget(self.preview) review_layout.addStretch() review_frame.setLayout(review_layout) layout.addWidget(size_frame,0,0,1,1) layout.addWidget(style_frame,0,1,1,1) layout.addWidget(review_frame,0,2,1,1) self.setLayout(layout) self.connect(MAINWINDOW().glWidget,QtCore.SIGNAL("SizeChanged"),self.glSizeChanged) self.connect(self.keepAspect,QtCore.SIGNAL("stateChanged(int)"),self.keepAspectChanged) #------------------------------------------------------------------- def keepAspectChanged(self,state): #------------------------------------------------------------------- self.checkHeight(int(self.widthWidget.value())) self.checkHeightDPI(int(self.width_dpi_inches.value())) #------------------------------------------------------------------- def glSizeChanged(self,size): #------------------------------------------------------------------- self.checkHeight(int(self.widthWidget.value())) self.checkHeightDPI(int(self.width_dpi_inches.value())) #------------------------------------------------------------------- def checkHeight(self,val): #------------------------------------------------------------------- if not self.keepAspect.isChecked(): return current_size = MAINWINDOW().glWidget.size() self.heightWidget.blockSignals(True) self.heightWidget.setValue(int(val*float(current_size.height())/current_size.width())) self.heightWidget.blockSignals(False) #------------------------------------------------------------------- def checkWidth(self,val): #------------------------------------------------------------------- if not self.keepAspect.isChecked(): return current_size = MAINWINDOW().glWidget.size() self.widthWidget.blockSignals(True) self.widthWidget.setValue(int(val*float(current_size.width())/current_size.height())) self.widthWidget.blockSignals(False) #------------------------------------------------------------------- def checkHeightDPI(self,val): #------------------------------------------------------------------- if not self.keepAspect.isChecked(): return current_size = MAINWINDOW().glWidget.size() self.height_dpi_inches.blockSignals(True) self.height_dpi_inches.setValue(float(val*float(current_size.height())/current_size.width())) self.height_dpi_inches.blockSignals(False) #------------------------------------------------------------------- def checkWidthDPI(self,val): #------------------------------------------------------------------- if not self.keepAspect.isChecked(): return current_size = MAINWINDOW().glWidget.size() self.width_dpi_inches.blockSignals(True) self.width_dpi_inches.setValue(float(val*float(current_size.width())/current_size.height())) self.width_dpi_inches.blockSignals(False) #------------------------------------------------------------------- def setParams(self,params={},**kw): #------------------------------------------------------------------- params.update(kw) #print "screenshotOptions.setParams",params if params.get('scaleFonts',''): self.scaleFonts.setChecked(params['scaleFonts']) if params.get('scaleImages',''): self.scaleImages.setChecked(params['scaleImages']) if params.get('scaleLines',''): self.scaleLines.setChecked(params['scaleLines']) if params.get('keepAspect',''): self.keepAspect.setChecked(params['keepAspect']) if params.get('size_mode',''): if params['size_mode'] == 'defined': self.size_defined.setChecked(1) elif params['size_mode'] == 'window': self.size_window.setChecked(1) elif params['size_mode'] == 'dpi_defined': self.dpi_defined.setChecked(1) if params.get('stereo_mode',''): if params['stereo_mode'] == 'shear': self.stereo_mode_shear.setChecked(1) elif params['stereo_mode'] == 'rotation': self.stereo_mode_rot.setChecked(1) for key in ['magnification','stereo_angle','stereo_sep','dpi_spin','width_dpi_inches','height_dpi_inches']: if params.get(key,''): getattr(self,key).setValue(params[key]) for key in ['height','width']: if params.get(key,''): getattr(self,key+'Widget').setValue(params[key]) for key in ['transparent','stereo','preview','save_status','scalebartext']: if params.get(key,-1)>=0: getattr(self,key).setChecked(params[key]) self.setStereoPrefsEnabled() #------------------------------------------------------------------- def getParams(self): #------------------------------------------------------------------- pars = {} for key in ['magnification','stereo_angle','stereo_sep','dpi_spin','width_dpi_inches','height_dpi_inches']: pars[key] = getattr(self,key).value() for key in ['height','width']: pars[key] = getattr(self,key+'Widget').value() for key in ['transparent','stereo','preview','save_status','scalebartext']: pars[key] = getattr(self,key).isChecked() if getattr(self,'size_defined').isChecked(): pars['size_mode'] = 'defined' elif getattr(self,'size_window').isChecked(): pars['size_mode'] = 'window' elif getattr(self,'dpi_defined').isChecked(): pars['size_mode'] = 'dpi_defined' if getattr(self,'stereo_mode_shear').isChecked(): pars['stereo_mode'] = 'shear' elif getattr(self,'stereo_mode_rot').isChecked(): pars['stereo_mode'] = 'rotation' if getattr(self,'scaleFonts').isChecked(): pars['scaleFonts'] = 1 else: pars['scaleFonts'] = 0 if getattr(self,'scaleImages').isChecked(): pars['scaleImages'] = 1 else: pars['scaleImages'] = 0 if getattr(self,'scaleLines').isChecked(): pars['scaleLines'] = 1 else: pars['scaleLines'] = 0 if getattr(self,'keepAspect').isChecked(): pars['keepAspect'] = 1 else: pars['keepAspect'] = 0 #print "screenshot getParams",pars return pars #------------------------------------------------------------------- #------------------------------------------------------------------- #------------------------------------------------------------------- class screenShotGUI(QtGui.QDialog): #------------------------------------------------------------------- #------------------------------------------------------------------- #------------------------------------------------------------------- saved_params = { 'size_mode' :'window', 'stereo_mode' :'rotation', 'width' : 600, 'height' : 600, 'magnification' : 1, 'transparent' : 0, 'scalebartext' : 1, 'stereo' : 0, 'scaleFonts' : 1, 'scaleImages' : 1, 'scaleLines' : 1, 'keepAspect' : 0, 'stereo_angle' : 6.0, 'stereo_sep' : 0.1, 'filetype' : 'png', 'save_status' : 1 } #------------------------------------------------------------------- def setParams(self,params={},**kw): #------------------------------------------------------------------- self.optionsWidget.setParams(params) # ?kw? #------------------------------------------------------------------- def getParams(self): #------------------------------------------------------------------- return self.optionsWidget.getParams() #------------------------------------------------------------------- def __init__(self,parent=None): #------------------------------------------------------------------- QtGui.QDialog.__init__(self,parent) self.draw() self.setParams(self.saved_params) #if self.fileDialog.exec_(): self.handleSelection() def draw(self): self.setWindowTitle(self.tr('Save screenshot to image file')) layout = QtGui.QVBoxLayout() layout.setSpacing(2) layout.setContentsMargins(2,2,2,2) label = QtGui.QLabel(' Note that the Render tool (on the File menu) will produce better quality pictures than this screenshot',self) font = QtGui.QFont() font.setItalic(1) label.setFont(font) layout.addWidget(label) self.optionsWidget = screenShotOptions() self.optionsWidget.widthWidget.setMaximum(8192) self.optionsWidget.heightWidget.setMaximum(8192) self.optionsWidget.scaleImages.setEnabled(False) layout.addWidget(self.optionsWidget) import mgWidgets file = mgWidgets.MGFileDialog(self) self.fileDialog = file.getFileDialog() self.fileDialog.setFileMode(QtGui.QFileDialog.AnyFile) self.fileDialog.setAcceptMode(QtGui.QFileDialog.AcceptSave) self.fileDialog.setConfirmOverwrite(False) filter_list = [] formats = QtGui.QImageWriter.supportedImageFormats() # We use ccp4mg's image handling stuff for now. Maybe for ever? #import image_info #formats = image_info.image_info.GetSupportedWriteFormats() for format in formats: if str(format).upper()!=str(format): filter = [str(format).upper()+" files (*."+str(format)+")",str(format)] if (str(format).upper() == 'PNG' and sys.platform!='win32') or \ (str(format).upper() == 'BMP' and sys.platform=='win32') : filter_list.insert(0,filter) else: filter_list.append(filter) self.fileDialog.setNameFilters(filter_list) self.connect(self.fileDialog, QtCore.SIGNAL('rejected()'),self.close) self.connect(self, QtCore.SIGNAL('rejected()'),self.close) """ children = self.fileDialog.findChildren(QtGui.QPushButton,"") for child in children: if child.text() == self.tr("&Save"): self.connect(child, QtCore.SIGNAL('pressed()'),self.saveFile) """ self.connect(self.fileDialog, QtCore.SIGNAL('fileSelected(const QString&)'),self.saveFile) layout.addWidget(file) self.setLayout(layout) #------------------------------------------------------------------- def saveFile(self): #------------------------------------------------------------------- # ? resize image size = [] w = getattr(self.optionsWidget,'size_defined') if w and w.isChecked(): for item in ['width','height']: w = getattr(self.optionsWidget,item+'Widget') if w: size.append(int(w.value())) # ? Magnified image w = getattr(self.optionsWidget,'size_window') if w and w.isChecked(): magnification = float(getattr(self.optionsWidget,'magnification').value()) current_size = MAINWINDOW().glWidget.size() size = [int(current_size.width()*magnification),int(current_size.height()*magnification)] w = getattr(self.optionsWidget,'dpi_defined') if w and w.isChecked(): w = getattr(self.optionsWidget,'dpi_spin') if w: dpi = w.value() for item in ['width','height']: w = getattr(self.optionsWidget,item+'_dpi_inches') if w: size.append(int(w.value()*dpi)) if len(size)<2: size = [] file = self.fileDialog.selectedFiles() if not file: return file = str(file[0].toUtf8()) w = getattr(self.optionsWidget,'save_status') if w and w.isChecked(): #HISTORY().save_status(filename=file+'.pkl') MAINWINDOW().saveStatusFile(file=file+'.pkl') if getattr(self.optionsWidget,'stereo_mode_shear').isChecked(): stereo_mode = 'shear' elif getattr(self.optionsWidget,'stereo_mode_rot').isChecked(): stereo_mode = 'rotation' dpi=300 if getattr(self.optionsWidget,'dpi_defined').isChecked(): dpi = self.optionsWidget.dpi_spin.value() t1 = time.time() #MAINWINDOW().glWidget.makeCurrent() if QtOpenGL.QGLFramebufferObject.hasOpenGLFramebufferObjects(): print "Using FBOs" rv = makeScreenshot(file,size=size,stereo=int(self.optionsWidget.stereo.isChecked()), stereo_angle=self.optionsWidget.stereo_angle.value(),transparent=self.optionsWidget.transparent.isChecked(),scaleFonts=self.optionsWidget.scaleFonts.isChecked(),stereo_sep=self.optionsWidget.stereo_sep.value(),stereo_mode=stereo_mode,scaleImages=self.optionsWidget.scaleImages.isChecked(),dpi=dpi,use_pbuffer=True,scalebartext=self.optionsWidget.scalebartext.isChecked(),scaleLines=self.optionsWidget.scaleLines.isChecked()) else: rv = makeScreenshot(file,size=size,stereo=int(self.optionsWidget.stereo.isChecked()), stereo_angle=self.optionsWidget.stereo_angle.value(),transparent=self.optionsWidget.transparent.isChecked(),scaleFonts=self.optionsWidget.scaleFonts.isChecked(),stereo_sep=self.optionsWidget.stereo_sep.value(),stereo_mode=stereo_mode,scaleImages=self.optionsWidget.scaleImages.isChecked(),dpi=dpi,scalebartext=self.optionsWidget.scalebartext.isChecked(),scaleLines=self.optionsWidget.scaleLines.isChecked()) print "time to get screenshot",time.time()-t1; sys.stdout.flush() if rv[0]: QtGui.QMessageBox.warning(self,'Screenshot',file+'\n'+rv[1]) else: # Show image in file viewer if self.optionsWidget.preview.isChecked(): FILEVIEWER().open(rv[1]) print "time to preview",time.time()-t1; sys.stdout.flush() self.close() #------------------------------------------------------------------- def handleSelection(self,fileList): #------------------------------------------------------------------- #print "handleSelection fileList",fileList if len(fileList)<=0: return self.saved_params.update(self.getParams()) #------------------------------------------------------------------- def close(self): #------------------------------------------------------------------- self.saved_params.update(self.getParams()) QtGui.QDialog.close(self) #------------------------------------------------------------------------- def create_screenshot_preferences(): #------------------------------------------------------------------------- import services antialias = 1 if ['win32','darwin'].count(sys.platform): offscreen = 0 else: offscreen = 1 return services.ParamsManager ( name='screenshot_preferences', title='Screenshots', help = 'images.html#screenshots', gui =['offscreen','antialias'], \ default = { 'offscreen' : offscreen, 'antialias' : antialias }, definition = { 'offscreen' : dict(type=int,label='Create image offscreen (offscreen buffer)',style='checkbox'), 'antialias' : dict(type=int,label='Smooth edges (antialias) output',style='checkbox') } )