Пример #1
0
   def __init__(self, parent=None):
      super().__init__(parent)   #调用父类构造函数,创建窗体
      self.ui=Ui_MainWindow()    #创建UI对象
      self.ui.setupUi(self)      #构造UI界面

      self.setWindowTitle("Demo14_5, 三维数据绘图")
      self.__colormap=mpl.cm.seismic  #当前colormap
      self.__iniUI()    #初始化界面

      mpl.rcParams['font.sans-serif']=['SimHei']  #黑体
      mpl.rcParams['font.size']=10   
##  黑体:SimHei 宋体:SimSun 新宋体:NSimSun 仿宋:FangSong  楷体:KaiTi 
      mpl.rcParams['axes.unicode_minus'] =False    #减号unicode编码

      self.__colorbar=None   #colorbar对象
      self.__generateData()  #生成数据
      self.__iniFigure()     #绘图

      self.ui.widgetPlot.figure.canvas.setCursor(Qt.CrossCursor)
      self.ui.widgetPlot.figure.canvas.mpl_connect("motion_notify_event",self.do_canvas_mouseMove)
      self.ui.widgetPlot.figure.canvas.mpl_connect("pick_event",self.do_canvas_pick)
      
      self.on_combo3D_type_currentIndexChanged(0)  #3D曲线
      self.on_combo2D_type_currentIndexChanged(0)  #2D曲线
      self.ui.widgetPlot.figure.subplots_adjust(left=0.05,
               bottom=0.26, right=0.97, top=0.92, wspace=0.28)
Пример #2
0
 def __init__(self, parent=None):
     super().__init__(parent)  #调用父类构造函数,创建窗体
     self.ui = Ui_MainWindow()  #创建Ui对象
     self.ui.setupUi(self)  #构造UI
     self.LabPath = QLabel(self)
     self.ui.statusBar.addWidget(self.LabPath)
     self.__buildModelView()
Пример #3
0
   def __init__(self, parent=None):
      super().__init__(parent)    #调用父类构造函数,创建窗体
      self.ui=Ui_MainWindow()     #创建UI对象
      self.ui.setupUi(self)       #构造UI界面

      self.ui.progBar_Max.setMaximum(256)
      self.ui.progBar_Min.setMaximum(256)
      self.ui.progBar_Diff.setMaximum(256)

      self.ui.sliderVolumn.setMaximum(100)
      self.ui.sliderVolumn.setValue(100)

      self.ui.comboDevices.clear()
      self.__deviceList=QAudioDeviceInfo.availableDevices(QAudio.AudioInput) #音频输入设备列表
      for i in range(len(self.__deviceList)):
         device=self.__deviceList[i]    #QAudioDeviceInfo类
         self.ui.comboDevices.addItem(device.deviceName())

##      self.__deviceInfo =None   #当前设备信息,QAudioDeviceInfo
      self.audioDevice=None       #音频输入设备,QAudioInput
      self.BUFFER_SIZE=4000

      self.ioDevice=None      #第1种读取方法,内建的IODevice

##      self.externalReader=None        #第2种读取方法,外建的IODevice

      self.recordFile=QFile()      #第3种读取方法,使用QFile直接写入文件

      if len(self.__deviceList)>0:
         self.ui.comboDevices.setCurrentIndex(0) #触发comboDevices的信号currentIndexChanged()
##         self.__deviceInfo =deviceList[0]
      else:
         self.ui.actStart.setEnabled(False)
         self.ui.actDeviceTest.setEnabled(False)
         self.ui.groupBoxDevice.setTitle("支持的音频输入设置(无设备)")
Пример #4
0
    def __init__(self, parent=None):
        super().__init__(parent)  #调用父类构造函数,创建窗体
        self.ui = Ui_MainWindow()  #创建UI对象
        self.ui.setupUi(self)  #构造UI界面

        self.setWindowTitle("Demo8_4, 自定义界面组件")
        pass
Пример #5
0
 def __init__(self):
     QtWidgets.QMainWindow.__init__(self)
     self.ui = Ui_MainWindow()
     self.ui.setupUi(self)
     self.movie = DrawableMovieLabel()
     self.ui.horizontalLayout_2.addWidget(self.movie)
     self.ui.pushButton_browse.clicked.connect(self.openFile)
     self.ui.pushButton_start.clicked.connect(self.start_stop)
     self.ui.pushButton_remove.clicked.connect(self.removeTrack)
     self.ui.pushButton_save_annotation.clicked.connect(
             self.save_annotations)
     self.ui.pushButton_browse_annotaion.clicked.connect(
             self.open_annotations)
     self.ui.pushButton_next.clicked.connect(self.movie.nextFrame)
     self.ui.pushButton_previous.clicked.connect(self.movie.prviousFrame)
     self.ui.listView.setModel(self.movie.model)
     self.ui.listView.setEditTriggers(
             QtWidgets.QAbstractItemView.DoubleClicked)
     self.ui.horizontalSlider.setMinimum(0)
     self.ui.horizontalSlider.setMaximum(100)
     self.ui.horizontalSlider.valueChanged.connect(self.movie.seekToPercent)
     self.movie.progress.connect(self.ui.horizontalSlider.setValue)
     self.timer = QtCore.QTimer(self)
     self.timer.timeout.connect(self.autoSave)
     self.timer.start(60*1000)
     self.ui.pushButton_kafkaConnect.clicked.connect(self.connectKafka)
Пример #6
0
	def __init__(self, parent=None):
		super(MainWindow, self).__init__(parent)
		self.ui = Ui_MainWindow()
		self.ui.setupUi(self)
		#
		self.ui.actionInterval.triggered.connect(self.onCaptureInterval)
		self.ui.actionStart.triggered.connect(self.onCaptureStart)
		self.ui.actionStop.triggered.connect(self.onCaptureStop)
		self.ui.actionReset.triggered.connect(self.onResetCapture)
		self.ui.actionQuit.triggered.connect(self.close)
		#
		self.arpPackets = list()
		self.ethPackets = list()
		#
		self.arpEntropies = list()
		self.ethEntropies = list()
		#
		self.sniffer = Sniffer()
		self.sniffer.packetCaptured.connect(self.onPacketCaptured)
		self.sniffer.timeout.connect(self.onSniffTimeout)
		self.thread = QThread()
		self.sniffer.moveToThread(self.thread)
		self.thread.started.connect(self.sniffer.sniff)
		self.sniffer.finished.connect(self.thread.quit)
		self.sniffer.finished.connect(self.onCaptureStop)
		#
		self.packets = 0
		#
		self.maxArpEntropy = [0, -1]
		self.maxEthEntropy = [0, -1]
		#
		self.ethEntropyThread = QThread()
		self.ethEntropy = EtherEntropy()
		self.ethEntropyThread.started.connect(self.ethEntropy.entropy)
		self.ethEntropy.resultReady.connect(self.onEthEntropyReady)
		self.ethEntropy.resultReady.connect(self.ethEntropyThread.quit)
		#
		self.arpEntropyThread = QThread()
		self.arpEntropy = ArpEntropy()
		self.arpEntropyThread.started.connect(self.arpEntropy.entropy)
		self.arpEntropy.resultReady.connect(self.onArpEntropyReady)
		self.arpEntropy.resultReady.connect(self.arpEntropyThread.quit)
		#
		self.timer = QTimer(self)
		self.timer.timeout.connect(self.onCountDown)
		self.timer.start(ONE_SECOND)
		#
		self.entropyTimer = QTimer(self)
		self.entropyTimer.timeout.connect(self.updateEntropy)
		#
		self.timer2 = QTimer(self)
		self.timer2.timeout.connect(self.updateStatics)
		self.timer2.start(MILLIS_200)
		#
		self.ui.actionSaveCapture.triggered.connect(self.saveCapture)
		self.ui.actionSaveEntropy.triggered.connect(self.saveEntropy)
		#
		self.ui.statusbar.showMessage("Ready")
		#
		self.ui.progressBar.hide()
Пример #7
0
    def __init__(self, parent=None):
        super().__init__(parent)  #调用父类构造函数,创建窗体
        self.ui = Ui_MainWindow()  #创建UI对象
        self.ui.setupUi(self)  #构造UI界面

        self.ui.groupBox.setEnabled(False)
        self.ui.actSaveALL.setEnabled(False)
        self.ui.actReadALL.setEnabled(False)

        self.__testFileName = ""
        self.__typeSize = {
            "char": 1,
            "bool": 1,
            "int8": 1,
            "uint8": 1,
            "int16": 2,
            "uint16": 2,
            "int32": 4,
            "uint32": 4,
            "int64": 8,
            "uint64": 8,
            "int": 4,
            "uint": 4,
            "float": 4,
            "single": 4,
            "double": 8
        }
Пример #8
0
    def __init__(self, parent=None):
        super().__init__(parent)  #调用父类构造函数,创建窗体
        self.ui = Ui_MainWindow()  #创建UI对象
        self.ui.setupUi(self)  #构造UI界面

        self.setWindowTitle("Demo13_1, Q3DBars和QBar3DSeries绘制三维柱状图")
        pass
Пример #9
0
    def __init__(self, parent=None):
        super().__init__(parent)  #调用父类构造函数,创建窗体
        self.ui = Ui_MainWindow()  #创建UI对象
        self.ui.setupUi(self)  #构造UI界面

        self.setWindowTitle("Demo12_6, 蜡烛图、日期时间坐标轴")
        pass
Пример #10
0
    def __init__(self, parent=None):
        super().__init__(parent)  #调用父类构造函数,创建窗体
        self.ui = Ui_MainWindow()  #创建UI对象
        self.ui.setupUi(self)  #构造UI界面

        self.setWindowTitle("Demo13_4, Q3DSurface和QSurface3DSeries绘制三维地形图")
        pass
Пример #11
0
    def __init__(self, parent=None, dbFilename='None'):
        super().__init__(parent)  # Call the parent class. Create window.
        self.ui = Ui_MainWindow()  # Create UI object
        self.ui.setupUi(self)  # Create UI interface

        self.ui.tabWidget.setVisible(True)
        self.setCentralWidget(self.ui.tabWidget)

        # tableView setting
        self.ui.tableView.setSelectionBehavior(QAbstractItemView.SelectItems)
        self.ui.tableView.setSelectionMode(QAbstractItemView.SingleSelection)
        self.ui.tableView.setAlternatingRowColors(True)
        self.ui.tableView.verticalHeader().setDefaultSectionSize(44)
        self.ui.tableView.horizontalHeader().setDefaultSectionSize(70)
        self.ui.tableView.setSortingEnabled(True)

        # Initialize chart
        self.__iniPieChart()  # Initialize pie chart
        self.__iniStackedBar()  # Stacked bar

        mpl.rcParams['font.sans-serif'] = ['Calibri']
        mpl.rcParams['font.size'] = 8

        # Choose the SQLITE database drive
        self.DB = QSqlDatabase.addDatabase("QSQLITE")
        self.DB.setDatabaseName(dbFilename)  # Set the name of database
        if self.DB.open():  # Open database
            self.__openTable()  # Open tables
        else:
            QMessageBox.warning(self, "Warning",
                                "Failed to open the database.")
Пример #12
0
    def __init__(self, parent=None):
        super().__init__(parent)  #调用父类构造函数,创建窗体
        self.ui = Ui_MainWindow()  #创建UI对象
        self.ui.setupUi(self)  #构造UI界面

        self.__dlgSetHeaders = None
        self.setCentralWidget(self.ui.tableView)

        ##构建状态栏
        self.LabCellPos = QLabel("当前单元格:", self)
        self.LabCellPos.setMinimumWidth(180)
        self.ui.statusBar.addWidget(self.LabCellPos)

        self.LabCellText = QLabel("单元格内容:", self)
        self.LabCellText.setMinimumWidth(200)
        self.ui.statusBar.addWidget(self.LabCellText)

        ##构建Item Model/View
        self.itemModel = QStandardItemModel(10, 5, self)  #数据模型,10行5列
        self.selectionModel = QItemSelectionModel(self.itemModel)  #Item选择模型
        self.selectionModel.currentChanged.connect(self.do_currentChanged)

        ##为tableView设置数据模型
        self.ui.tableView.setModel(self.itemModel)  #设置数据模型
        self.ui.tableView.setSelectionModel(self.selectionModel)  #设置选择模型
Пример #13
0
    def __init__(self, parent=None):
        super().__init__(parent)  #调用父类构造函数,创建窗体
        self.ui = Ui_MainWindow()  #创建UI对象
        self.ui.setupUi(self)  #构造UI界面

        self.setCentralWidget(self.ui.splitter)
        pass
Пример #14
0
class CustomMainWindow(QMainWindow):
    def __init__(self):
        QMainWindow.__init__(self)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        self.isShiftPressed = False
        self.model = Model()
        self.generator = Generator()

        self.ui.showArea.setReadOnly(True)
        self.ui.sendButton.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_Q))

        self.connect(self.ui.sendButton, QtCore.SIGNAL('clicked()'), self.onSendButtonClicked)
        self.connect(self.model, QtCore.SIGNAL('messageAdded(QString)'), self.onMessageAdded)

    def onSendButtonClicked(self):
        question = self.ui.inputArea.toPlainText()
        if question:
            message = Message(question, u"Станислав")
            self.ui.inputArea.clear()
            self.model.addMessage(message)

            answer = self.generator.getAnswer(question)
            self.model.addMessage(Message(answer, u"Катерина"))

    def onMessageAdded(self, message):
        self.ui.showArea.append(message + "\n")
Пример #15
0
    def __init__(self, parent=None):
        super().__init__(parent)  #调用父类构造函数,创建窗体
        self.ui = Ui_MainWindow()  #创建UI对象
        self.ui.setupUi(self)  #构造UI界面
        self.setCentralWidget(self.ui.splitter)

        self.__ColCount = 6  #列数=6
        self.itemModel = QStandardItemModel(5, self.__ColCount,
                                            self)  # 数据模型,10行6列

        self.selectionModel = QItemSelectionModel(self.itemModel)  #Item选择模型
        self.selectionModel.currentChanged.connect(self.do_curChanged)

        self.__lastColumnTitle = "测井取样"
        self.__lastColumnFlags = (Qt.ItemIsSelectable
                                  | Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)

        ##tableView设置
        self.ui.tableView.setModel(self.itemModel)  #设置数据模型
        self.ui.tableView.setSelectionModel(self.selectionModel)  #设置选择模型

        oneOrMore = QAbstractItemView.ExtendedSelection
        self.ui.tableView.setSelectionMode(oneOrMore)  #可多选

        itemOrRow = QAbstractItemView.SelectItems
        self.ui.tableView.setSelectionBehavior(itemOrRow)  #单元格选择

        self.ui.tableView.verticalHeader().setDefaultSectionSize(22)  #缺省行高
        self.ui.tableView.setAlternatingRowColors(True)  #交替行颜色

        self.ui.tableView.setEnabled(False)  #先禁用tableView
        self.__buildStatusBar()
Пример #16
0
    def __init__(self, parent=None):
        super().__init__(parent)  #调用父类构造函数,创建窗体
        self.ui = Ui_MainWindow()  #创建UI对象
        self.ui.setupUi(self)  #构造UI界面

        self.setWindowTitle("Demo14_2, 绘图主要对象的操作")
        mplStyle.use("classic")  #使用样式,必须在绘图之前调用,修改字体后才可显示汉字

        mpl.rcParams['font.sans-serif'] = ['KaiTi',
                                           'SimHei']  #显示汉字为 楷体, 汉字不支持 粗体,斜体等设置
        mpl.rcParams['font.size'] = 12
        ##  Windows自带的一些字体
        ##  黑体:SimHei 宋体:SimSun 新宋体:NSimSun 仿宋:FangSong  楷体:KaiTi
        mpl.rcParams['axes.unicode_minus'] = False  #减号unicode编码

        self.__fig = None  #Figue对象
        self.__curAxes = None  #当前操作的Axes,为了方便单独用变量
        self.__curLine = None  #当前操作的曲线

        self.__createFigure()  #创建Figure和FigureCanvas对象,初始化界面
        self.__drawFig2X1()  #绘图

        axesList = self.__fig.axes  #子图列表
        for one in axesList:  #添加到工具栏上的下拉列表框里
            self.__comboAxes.addItem(one.get_label())

        legendLocs = [
            'best', 'upper right', 'upper left', 'lower left', 'lower right',
            'right', 'center left', 'center right', 'lower center',
            'upper center', 'center'
        ]  #图例位置
        self.ui.combo_LegendLoc.addItems(legendLocs)  #添加选项

        styleList = mplStyle.available  #可用样式列表,字符串列表
        self.ui.comboFig_Style.addItems(styleList)
Пример #17
0
class QmyMainWindow(QMainWindow):
    def __init__(self, parent=None):
        super().__init__(parent)  #调用父类构造函数,创建窗体
        self.ui = Ui_MainWindow()  #创建UI对象
        self.ui.setupUi(self)  #构造UI界面

        self.__buildModelView()

##  ==============自定义功能函数============

    def __buildModelView(self):  ##构造Model/View 系统
        self.model = QFileSystemModel(self)
        self.model.setRootPath(QDir.currentPath())

        self.ui.treeView.setModel(self.model)  #设置数据模型
        self.ui.listView.setModel(self.model)
        self.ui.tableView.setModel(self.model)

        self.ui.treeView.clicked.connect(self.ui.listView.setRootIndex)
        self.ui.treeView.clicked.connect(self.ui.tableView.setRootIndex)

##  ==========由connectSlotsByName() 自动连接的槽函数==================

    def on_treeView_clicked(self, index):  ##treeView单击
        self.ui.chkBox_IsDir.setChecked(self.model.isDir(index))  #是否是目录

        self.ui.LabPath.setText(self.model.filePath(index))  #目录名
        self.ui.LabType.setText(self.model.type(index))  #节点类型
        self.ui.LabFileName.setText(self.model.fileName(index))  #文件名

        fileSize = self.model.size(index) / 1024
        if (fileSize < 1024):
            self.ui.LabFileSize.setText("%d KB" % fileSize)
        else:
            self.ui.LabFileSize.setText("%.2f MB" % (fileSize / 1024.0))
Пример #18
0
    def __init__(self, parent=None):
        super().__init__(parent)  #调用父类构造函数,创建窗体
        self.ui = Ui_MainWindow()  #创建UI对象
        self.ui.setupUi(self)  #构造UI界面

        self.setWindowTitle("Demo12_7, QAreaSeries绘制填充图")
        pass
Пример #19
0
class QmyMainWindow(QMainWindow):
    def __init__(self, parent=None):
        super().__init__(parent)  #调用父类构造函数,创建窗体
        self.ui = Ui_MainWindow()  #创建UI对象
        self.ui.setupUi(self)  #构造UI界面

        self.setWindowTitle("Demo8_4, 自定义界面组件")
        self.ui.slider.setRange(0, 100)
        self.ui.LabInfo.setMaximumHeight(20)
        self.ui.battery.powerLevelChanged.connect(self.do_battery_changed)
        self.ui.slider.setValue(60)

##  ==============自定义功能函数========================

##  ==============event处理函数==========================

##  ==========由connectSlotsByName()自动连接的槽函数============

    def on_slider_valueChanged(self, value):
        self.ui.battery.setPowerLevel(value)

##  =============自定义槽函数===============================

    def do_battery_changed(self, power):
        powStr = "当前电量:%d %%" % power
        self.ui.LabInfo.setText(powStr)
Пример #20
0
class QmyMainWindow(QMainWindow):
    def __init__(self, parent=None):
        super().__init__(parent)  #调用父类构造函数,创建窗体
        self.ui = Ui_MainWindow()  #创建UI对象
        self.ui.setupUi(self)  #构造UI界面

        self.setCentralWidget(self.ui.splitter)
        pass

##  ================自定义功能函数============================

    def __setActionsForButton(self):  ##为界面上的ToolButton按钮设置Actions
        pass

    def __createSelectionPopMenu(self):  ##创建ToolButton的下拉菜单
        pass

##  =========connectSlotsByName() 自动连接的槽函数===========

    @pyqtSlot()  ##初始化列表
    def on_actList_Ini_triggered(self):
        pass

    @pyqtSlot()  ##插入一项
    def on_actList_Insert_triggered(self):
        pass

    @pyqtSlot()  ##添加一项
    def on_actList_Append_triggered(self):
        pass

    @pyqtSlot()  ##删除当前项
    def on_actList_Delete_triggered(self):
        pass

    @pyqtSlot()  ##清空列表
    def on_actList_Clear_triggered(self):
        pass

    @pyqtSlot()
    def on_actSel_ALL_triggered(self):  ##全选
        pass

    @pyqtSlot()
    def on_actSel_None_triggered(self):  ##全不选
        pass

    @pyqtSlot()
    def on_actSel_Invs_triggered(self):  ##反选
        pass

    @pyqtSlot(bool)
    def on_chkBoxList_Editable_clicked(self, checked):  ##改变可编辑状态
        pass

    def on_listWidget_currentItemChanged(self, current, previous):  ##当前项切换变化
        pass

    def on_listWidget_customContextMenuRequested(self, pos):  ##右键快捷菜单
        pass
Пример #21
0
    def __init__(self, parent=None):
        super().__init__(parent)  #调用父类构造函数,创建窗体
        self.ui = Ui_MainWindow()  #创建UI对象
        self.ui.setupUi(self)  #构造UI界面

        self.setWindowTitle("Demo12_5,饼图和各种柱状图")

        self.ui.tableView.setAlternatingRowColors(True)
        self.ui.treeWidget.setAlternatingRowColors(True)
        self.setStyleSheet("QTreeWidget, QTableView{"
                           "alternate-background-color:rgb(170, 241, 190)}")

        self.__studCount = 10  #学生人数
        self.ui.spinCount.setValue(self.__studCount)

        self.dataModel = QStandardItemModel(self)  #数据模型
        self.ui.tableView.setModel(self.dataModel)  #设置数据模型
        self.dataModel.itemChanged.connect(self.do_calcuAverage)  #自动计算平均分

        self.__generateData()  #初始化数据
        self.__surveyData()  #数据统计

        self.__iniBarChart()  #柱状图初始化
        self.__iniStackedBar()  #堆积图初始化
        self.__iniPercentBar()  #百分比图初始化
        self.__iniPieChart()  #饼图初始化
Пример #22
0
class QmyMainWindow(QMainWindow): 

   def __init__(self, parent=None):
      super().__init__(parent)   #调用父类构造函数,创建窗体
      self.ui=Ui_MainWindow()    #创建UI对象
      self.ui.setupUi(self)      #构造UI界面

      self.setCentralWidget(self.ui.tableView)
      pass


##  ==============自定义功能函数============
   def __getFieldNames(self):  ##获取所有字段名称
      pass
   
   
   def __openTable(self):   ##打开数据表
      pass

        
##  ==========由connectSlotsByName() 自动连接的槽函数==================        
   @pyqtSlot()
   def on_actOpenDB_triggered(self):
      pass


   @pyqtSlot()    ##保存修改
   def on_actSubmit_triggered(self):   
      pass


   @pyqtSlot()    ##取消修改
   def on_actRevert_triggered(self): 
      pass


   @pyqtSlot()    ##添加记录
   def on_actRecAppend_triggered(self):
      pass


   @pyqtSlot()    ##插入记录
   def on_actRecInsert_triggered(self):
      pass


   @pyqtSlot()    ##删除记录
   def on_actRecDelete_triggered(self):
      pass
   

   @pyqtSlot()    ##显示字段列表
   def on_actFields_triggered(self):
      pass
      
      
##  =============自定义槽函数===============================        
   def do_currentChanged(self,current,previous):   ##更新actPost和actCancel 的状态
      pass
Пример #23
0
    def __init__(self, parent=None):
        super().__init__(parent)  #调用父类构造函数,创建窗体
        self.ui = Ui_MainWindow()  #创建UI对象
        self.ui.setupUi(self)  #构造UI界面

        self.setWindowTitle(
            "Demo12_3, QScatterSeries、QSplineSeries、自定义QChartView")
        pass
Пример #24
0
    def __init__(self, parent=None):
        super().__init__(parent)  #调用父类构造函数,创建窗体
        self.ui = Ui_MainWindow()  #创建UI对象
        self.ui.setupUi(self)  #构造UI界面

        self.setCentralWidget(self.ui.mdiArea)  #填充满工作区
        ##      self.setWindowState(Qt.WindowMaximized) #窗口最大化显示
        self.ui.mainToolBar.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
Пример #25
0
    def __init__(self, parent=None):
        super().__init__(parent)  #调用父类构造函数,创建窗体
        self.ui = Ui_MainWindow()  #创建UI对象
        self.ui.setupUi(self)  #构造UI界面

        self.setWindowTitle("Demo14_4, 几种常见二维图表")
        self.setCentralWidget(self.ui.tabWidget)
        pass
Пример #26
0
class QmyMainWindow(QMainWindow):
    def __init__(self, parent=None):
        super().__init__(parent)  #调用父类构造函数,创建窗体
        self.ui = Ui_MainWindow()  #创建UI对象
        self.ui.setupUi(self)  #构造UI界面
        self.setCentralWidget(self.ui.textEdit)
        pass

##  ============自定义功能函数================================

    def __buildUI(self):  ##窗体上动态添加组件
        pass

##  ===========由connectSlotsByName() 自动连接的槽函数=====================

    @pyqtSlot(bool)  ##设置粗体
    def on_actFont_Bold_triggered(self, checked):
        pass

    @pyqtSlot(bool)  ##设置斜体
    def on_actFont_Italic_triggered(self, checked):
        pass

    @pyqtSlot(bool)  ##设置下划线
    def on_actFont_UnderLine_triggered(self, checked):
        pass

    def on_textEdit_copyAvailable(self, avi):  ##文本框内容可copy
        pass

    def on_textEdit_selectionChanged(self):  ##文本选择内容发生变化
        pass

    def on_textEdit_customContextMenuRequested(self, pos):  ##标准右键菜单
        pass

    @pyqtSlot(bool)  ##设置工具栏按钮样式
    def on_actSys_ToggleText_triggered(self, checked):
        pass

    def on_actFile_New_triggered(self):  ##新建文件,不实现具体功能
        pass

    def on_actFile_Open_triggered(self):  ##打开文件,不实现具体功能
        pass

    def on_actFile_Save_triggered(self):  ##保存文件,不实现具体功能
        pass

##  =============自定义槽函数===============================

    @pyqtSlot(int)  ##设置字体大小,关联 __spinFontSize
    def do_fontSize_Changed(self, fontSize):
        pass

    @pyqtSlot(str)  ##选择字体名称,关联__comboFontName
    def do_fontName_Changed(self, fontName):
        pass
Пример #27
0
    def __init__(self, parent=None):
        super().__init__(parent)  #调用父类构造函数,创建窗体
        self.ui = Ui_MainWindow()  #创建UI对象
        self.ui.setupUi(self)  #构造UI界面

        self.ui.toolBox.setCurrentIndex(0)
        self.fileWatcher = QFileSystemWatcher()
        self.fileWatcher.directoryChanged.connect(self.do_directoryChanged)
        self.fileWatcher.fileChanged.connect(self.do_fileChanged)
class MainWindow(QMainWindow):
    def __init__(self):
        super(MainWindow, self).__init__()
        self.__ui = Ui_MainWindow()
        self.__ui.setupUi(self)
        self.__ui.pushButton.clicked.connect(self.click_agregar)

    def click_agregar(self):
        self.__ui.pushButton.setText("Guardado")
Пример #29
0
	def __init__(self,parent=None):
		super().__init__(parent)#调用父类构造函数,创建窗体
		self.ui = Ui_MainWindow()#创建Ui对象
		self.ui.setupUi(self)#构造UI

		self.__buildUI()
		self.__spinFontSize.valueChanged[int].connect(self.do_fontSize_Changed)
		self.__comboFontName.currentIndexChanged[str].connect(self.do_fontName_Changed)
		self.setCentralWidget(self.ui.textEdit)
Пример #30
0
   def __init__(self, parent=None):
      super().__init__(parent)    # 调用父类构造函数,创建窗体
      self.ui=Ui_MainWindow()     # 创建UI对象
      self.ui.setupUi(self)       # 构造UI界面

      self.setWindowTitle("Demo12_8, 极坐标图")
      
      self.__iniChart()  # 创建self.chart
      self.__drawRose()
Пример #31
0
    def __init__(self):
        super(MainWindow, self).__init__()
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        # Set default settings if first launch
        if self.settings.value('firstLaunch', True, type=bool):
            self.settings.setValue('ZIP', self.DEFAULT_ZIP)
            self.settings.setValue('fullscreen', True)
            self.settings.setValue('rotateCamera', False)
            self.settings.setValue('firstLaunch', False)

            categories = [
                'Dry Goods', 'Meat', 'Veggies', 'Fruit', 'Dairy', 'Prepared',
                'Other'
            ]
            self.settings.setValue('categories', categories)

            locations = ['Pantry', 'Fridge', 'Freezer']
            self.settings.setValue('locations', locations)

            self.settings.setValue('hideCursor', False)

        for category in self.settings.value('categories', type=list):
            self.ui.categoryComboBox.addItem(category)
            self.ui.categoriesListWidget.addItem(category)

        for location in self.settings.value('locations', type=list):
            self.ui.locationComboBox.addItem(location)
            self.ui.locationsListWidget.addItem(location)

        self.ui.sidLineEdit.setText(self.settings.value('sid', type=str))
        self.ui.authLineEdit.setText(self.settings.value('authToken',
                                                         type=str))
        self.ui.fromNumberLineEdit.setText(
            self.settings.value('fromNumber', type=str))
        self.ui.toNumberLineEdit.setText(
            self.settings.value('toNumber', type=str))

        self.ui.fullscreenOffButton.setChecked(
            not self.settings.value('fullscreen', type=bool))
        self.ui.rotateCameraOnButton.setChecked(
            self.settings.value('rotateCamera', type=bool))
        self.ui.zipEdit.setText(self.settings.value('ZIP'))
        self.ui.hideCursorOnButton.setChecked(
            self.settings.value('hideCursor', type=bool))

        self.setup_database()

        self.setup_table()

        self.setup_clock()

        self.setup_weather()

        self.setup_connections()
Пример #32
0
    def __init__(self):
        QMainWindow.__init__(self)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        self.isShiftPressed = False
        self.model = Model()
        self.generator = Generator()

        self.ui.showArea.setReadOnly(True)
        self.ui.sendButton.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_Q))

        self.connect(self.ui.sendButton, QtCore.SIGNAL('clicked()'), self.onSendButtonClicked)
        self.connect(self.model, QtCore.SIGNAL('messageAdded(QString)'), self.onMessageAdded)
Пример #33
0
 def __init__ ( self ) : 
   #
   QtGui.QMainWindow.__init__ ( self )
   
   # This is always the same
   self.ui = Ui_MainWindow ()
   self.ui.setupUi ( self )
   self.setupMenuBar ()
   self.setupPanels ()
   
   self.setWindowTitle ( "meShaderEd (" + app_renderer.getCurrentPresetName() + ")")
   
   self.activeNodeList = None
   self.workArea = None # current work area
   self.onNew () # create new document 
   
   grid_enabled = getDefaultValue( app_settings, 'WorkArea', 'grid_enabled' )
   grid_snap = getDefaultValue ( app_settings, 'WorkArea', 'grid_snap' )
   grid_size = int( getDefaultValue ( app_settings, 'WorkArea', 'grid_size' )  )
   reverse_flow = getDefaultValue ( app_settings, 'WorkArea', 'reverse_flow' )
   straight_links = getDefaultValue ( app_settings, 'WorkArea', 'straight_links' )
 
   #self.ui.workArea.gridSize = grid_size
   #self.ui.workArea.gridSnap = grid_snap
   self.workArea.drawGrid = grid_enabled
   #self.ui.workArea.reverseFlow = reverse_flow 
   #self.ui.workArea.straightLinks = straight_links
   
   self.ui.actionShowGrid.setChecked( grid_enabled )
   self.ui.actionSnapGrid.setChecked( grid_snap )
   self.ui.actionReverseFlow.setChecked( reverse_flow )
   self.ui.actionStraightLinks.setChecked( straight_links )
  
   self.ui.nodeList_ctl.setLibrary ( app_global_vars[ 'NodesPath' ] )
   self.ui.project_ctl.setLibrary ( app_global_vars[ 'ProjectNetworks' ] )
   
   QtCore.QObject.connect ( self.ui.nodeList_ctl.ui.nodeList, QtCore.SIGNAL( "setActiveNodeList" ), self.setActiveNodeList )
   QtCore.QObject.connect ( self.ui.project_ctl.ui.nodeList, QtCore.SIGNAL( "setActiveNodeList" ), self.setActiveNodeList )
   
   QtCore.QObject.connect ( self.ui.tabs, QtCore.SIGNAL( "currentChanged(int)" ), self.onTabSelected )
   QtCore.QObject.connect ( self.ui.tabs, QtCore.SIGNAL( "tabCloseRequested(int)" ), self.onTabCloseRequested )
   
   QtCore.QObject.connect ( self.ui.nodeParam_ctl, QtCore.SIGNAL( "nodeLabelChanged" ), self.onNodeLabelChanged  )
Пример #34
0
 def __init__(self, parent=None):
     QMainWindow.__init__(self, parent)
     self.ui = Ui_MainWindow()
     self.ui.setupUi(self)
     self.setWindowTitle("PLessc - lessc not defined")
     # Connect the function with the signal
     self.ui.inputChoose.clicked.connect(self.openInputDialog)
     self.ui.outputChoose.clicked.connect(self.openOutputDialog)
     self.ui.setBoth.pressed.connect(self.setBoth)
     self.ui.setStandard.pressed.connect(self.setStandard)
     self.ui.optionIE.stateChanged.connect(self.setOptionIE)
     self.ui.optionSourceMap.stateChanged.connect(self.setOptionSourceMap)
     self.ui.setMinify.stateChanged.connect(self.setMinify)
     self.ui.inputEdit.pressed.connect(self.openEditor)
     self.ui.outputLog.clicked.connect(self.openLog)
     self.ui.lint.clicked.connect(self.lintLog)
     self.ui.compile.clicked.connect(self.compileIt)
     self.ui.menuInfo.triggered.connect(self.openInfo)
     self.ui.menuSetting.triggered.connect(self.openSetDialog)
     self.proc.finished.connect(self.checkLog)
     self.less_version.finished.connect(self.updateTitle)
     signal.signal(signal.SIGINT, signal.SIG_DFL)
     # hide log
     self.ui.log.hide()
     # check lessc version
     self.loadVersion()
     # Check the setting for load the path of the file
     if self.settings.value("input_file") != -1:
         self.input_less = self.settings.value("input_file")
     else:
         self.input_less = "/"
     if self.settings.value("output_file") != -1:
         self.output_css = self.settings.value("output_file")
     else:
         self.output_css = "/"
     self.ui.inputFile.setText(self.input_less)
     self.ui.outputFile.setText(self.output_css)
     # Check the setting for the minify mode for the css file
     if self.settings.value("min") == "False":
         self.option["minify"] = " "
         self.settings.setValue("min", "False")
         self.ui.setMinify.setChecked(False)
     else:
         self.option["minify"] = "-x"
         self.settings.setValue("min", "True")
         self.ui.setMinify.setChecked(True)
     # Check for the export of the file
     if self.settings.value("both_or_standard") == "False":
         self.settings.setValue("both_or_standard", "False")
         self.ui.setStandard.toggle()
     else:
         self.settings.setValue("both_or_standard", "True")
         self.ui.setBoth.toggle()
     # Auto compile option
     if self.settings.value("auto_compile") == "False":
         self.ui.autoCompile.setChecked(False)
     else:
         self.ui.autoCompile.setChecked(True)
     # Add the function for the autocompile after the load of the setting
     self.ui.autoCompile.stateChanged.connect(self.autoCompile)
     self.autoCompile()
     # Setting for export the css for old IE version
     if self.settings.value("option_IE") == "False":
         self.ui.optionIE.setChecked(False)
         self.option["ie"] = " "
     else:
         self.ui.optionIE.setChecked(True)
         self.option["ie"] = "--no-ie-compat"
     # Setting for enable Sourcemap
     if self.settings.value("option_SourceMap") == "False":
         self.ui.optionSourceMap.setChecked(False)
         self.option["sourcemap"] = " "
     else:
         self.ui.optionSourceMap.setChecked(True)
         self.option["sourcemap"] = "--source-map"
     # Resize the window for hide the space of log
     self.resize(505, 220)
     # Load History
     self.loadHistory()
     self.show()
Пример #35
0
class MainWindow(QtModule.QMainWindow):
    #
    # __init__
    #
    def __init__(self):
        #
        QtModule.QMainWindow.__init__(self)

        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
        #
        # setup WhatsThis help action
        #
        self.ui.actionHelpMode = QtModule.QWhatsThis.createAction()
        self.ui.actionHelpMode.setToolTip('Enter "WhatsThis" help mode')
        self.ui.menuHelp.addAction(self.ui.actionHelpMode)
        self.ui.toolBar.addSeparator()
        self.ui.toolBar.addAction(self.ui.actionHelpMode)

        self.clipboard = QtModule.QApplication.clipboard()

        if usePyQt4:
            self.recentProjects = app_settings.value("RecentProjects").toStringList()
            self.recentNetworks = app_settings.value("RecentNetworks").toStringList()
        else:
            self.recentProjects = []
            self.recentNetworks = []

            recentProjects = app_settings.value("RecentProjects")
            if recentProjects is not None:
                if isinstance(recentProjects, list):
                    for proj in recentProjects:
                        self.recentProjects.append(proj)
                else:
                    self.recentProjects.append(recentProjects)

            recentNetworks = app_settings.value("RecentNetworks")
            if recentNetworks is not None:
                if isinstance(recentNetworks, list):
                    for network in recentNetworks:
                        self.recentNetworks.append(network)
                else:
                    self.recentNetworks.append(recentNetworks)

        print "* recentProjects =", self.recentProjects
        print "* recentNetworks =", self.recentNetworks

        print "* ProjectPath =", app_global_vars["ProjectPath"]

        self.addRecentProject(app_global_vars["ProjectPath"])

        self.setupMenuBar()
        self.setupPanels()

        self.activeNodeList = None
        self.workArea = None  # current work area
        self.onNew()  # create new document

        grid_enabled = getDefaultValue(app_settings, "WorkArea", "grid_enabled")
        grid_snap = getDefaultValue(app_settings, "WorkArea", "grid_snap")
        grid_size = int(getDefaultValue(app_settings, "WorkArea", "grid_size"))
        reverse_flow = getDefaultValue(app_settings, "WorkArea", "reverse_flow")
        straight_links = getDefaultValue(app_settings, "WorkArea", "straight_links")

        # self.ui.workArea.gridSize = grid_size
        # self.ui.workArea.gridSnap = grid_snap
        self.workArea.drawGrid = grid_enabled
        # self.ui.workArea.reverseFlow = reverse_flow
        # self.ui.workArea.straightLinks = straight_links

        self.ui.actionShowGrid.setChecked(grid_enabled)
        self.ui.actionSnapGrid.setChecked(grid_snap)
        self.ui.actionReverseFlow.setChecked(reverse_flow)
        self.ui.actionStraightLinks.setChecked(straight_links)

        self.ui.nodeList_ctl.setLibrary(app_global_vars["NodesPath"])
        self.ui.project_ctl.setLibrary(app_global_vars["ProjectNetworks"])

        # self.ui.dockNodes.setWindowTitle ( 'Library: %s' % app_global_vars [ 'NodesPath' ] )
        # self.ui.dockProject.setWindowTitle ( 'Project: %s' % app_global_vars [ 'ProjectNetworks' ] )

        self.connectSignals()

        self.setupActions()
        self.setupWindowTitle()
        #
        # connectSignals
        #

    def connectSignals(self):
        #
        if usePyQt4:
            QtCore.QObject.connect(self.ui.actionHelpMode, QtCore.SIGNAL("toggled(bool)"), self.onHelpMode)
            QtCore.QObject.connect(
                self.ui.nodeList_ctl.ui.nodeList, QtCore.SIGNAL("setActiveNodeList"), self.setActiveNodeList
            )
            QtCore.QObject.connect(
                self.ui.project_ctl.ui.nodeList, QtCore.SIGNAL("setActiveNodeList"), self.setActiveNodeList
            )

            QtCore.QObject.connect(self.ui.tabs, QtCore.SIGNAL("currentChanged(int)"), self.onTabSelected)
            QtCore.QObject.connect(self.ui.tabs, QtCore.SIGNAL("tabCloseRequested(int)"), self.onTabCloseRequested)

            QtCore.QObject.connect(
                self.ui.nodeParam_ctl, QtCore.SIGNAL("nodeLabelChangedSignal"), self.onNodeLabelChanged
            )
            QtCore.QObject.connect(
                self.ui.nodeParam_ctl, QtCore.SIGNAL("nodeParamChangedSignal"), self.onNodeParamChanged
            )
        else:
            self.ui.actionHelpMode.toggled.connect(self.onHelpMode)

            self.ui.nodeList_ctl.ui.nodeList.setActiveNodeList.connect(self.setActiveNodeList)
            self.ui.project_ctl.ui.nodeList.setActiveNodeList.connect(self.setActiveNodeList)

            self.ui.tabs.currentChanged.connect(self.onTabSelected)
            self.ui.tabs.tabCloseRequested.connect(self.onTabCloseRequested)

            self.ui.nodeParam_ctl.nodeLabelChangedSignal.connect(self.onNodeLabelChanged)
            self.ui.nodeParam_ctl.nodeParamChangedSignal.connect(self.onNodeParamChanged)

            #
            # connectWorkAreaSignals
            #

    def connectWorkAreaSignals(self):
        #
        if usePyQt4:
            if self.workArea != None:
                if self.activeNodeList != None:
                    QtCore.QObject.connect(self.activeNodeList, QtCore.SIGNAL("addNode"), self.workArea.insertNodeNet)
                QtCore.QObject.connect(self.workArea, QtCore.SIGNAL("selectNodes"), self.onSelectGfxNodes)
                QtCore.QObject.connect(
                    self.workArea, QtCore.SIGNAL("nodeConnectionChanged"), self.onGfxNodeParamChanged
                )
                QtCore.QObject.connect(self.workArea, QtCore.SIGNAL("gfxNodeAdded"), self.onAddGfxNode)
                QtCore.QObject.connect(self.workArea, QtCore.SIGNAL("gfxNodeRemoved"), self.onRemoveGfxNode)
                # QtCore.QObject.connect ( self.workArea, QtCore.SIGNAL ( 'editGfxNode' ), self.editGfxNode )
                QtCore.QObject.connect(self.workArea.scene(), QtCore.SIGNAL("nodeUpdated"), self.updateNodeParamView)
                QtCore.QObject.connect(
                    self.workArea.scene(), QtCore.SIGNAL("gfxNodeParamChanged"), self.onGfxNodeParamChanged
                )
        else:
            if self.workArea != None:
                if self.activeNodeList != None:
                    self.activeNodeList.addNode.connect(self.workArea.insertNodeNet)
                self.workArea.selectNodes.connect(self.onSelectGfxNodes)
                self.workArea.nodeConnectionChanged.connect(self.onGfxNodeParamChanged)
                self.workArea.gfxNodeAdded.connect(self.onAddGfxNode)
                self.workArea.gfxNodeRemoved.connect(self.onRemoveGfxNode)
                # self.workArea.editGfxNode.connect ( self.editGfxNode )
                self.workArea.scene().nodeUpdated.connect(self.updateNodeParamView)
                self.workArea.scene().gfxNodeParamChanged.connect(self.onGfxNodeParamChanged)
                #
                # disconnectWorkAreaSignals
                #

    def disconnectWorkAreaSignals(self):
        #
        if usePyQt4:
            if self.workArea != None:
                if self.activeNodeList != None:
                    QtCore.QObject.disconnect(
                        self.activeNodeList, QtCore.SIGNAL("addNode"), self.workArea.insertNodeNet
                    )
                QtCore.QObject.disconnect(self.workArea, QtCore.SIGNAL("selectNodes"), self.onSelectGfxNodes)
                QtCore.QObject.disconnect(
                    self.workArea, QtCore.SIGNAL("nodeConnectionChanged"), self.onGfxNodeParamChanged
                )
                QtCore.QObject.disconnect(self.workArea, QtCore.SIGNAL("gfxNodeAdded"), self.onAddGfxNode)
                QtCore.QObject.disconnect(self.workArea, QtCore.SIGNAL("gfxNodeRemoved"), self.onRemoveGfxNode)
                # QtCore.QObject.disconnect ( self.workArea, QtCore.SIGNAL ( 'editGfxNode' ), self.editGfxNode )
                QtCore.QObject.disconnect(self.workArea.scene(), QtCore.SIGNAL("nodeUpdated"), self.updateNodeParamView)
                QtCore.QObject.disconnect(
                    self.workArea.scene(), QtCore.SIGNAL("gfxNodeParamChanged"), self.onGfxNodeParamChanged
                )
        else:
            if self.workArea != None:
                if self.activeNodeList != None:
                    self.activeNodeList.addNode.disconnect(self.workArea.insertNodeNet)
                self.workArea.selectNodes.disconnect(self.onSelectGfxNodes)
                self.workArea.nodeConnectionChanged.disconnect(self.onGfxNodeParamChanged)
                self.workArea.gfxNodeAdded.disconnect(self.onAddGfxNode)
                self.workArea.gfxNodeRemoved.disconnect(self.onRemoveGfxNode)
                # self.workArea.editGfxNode.disconnect ( self.editGfxNode )
                self.workArea.scene().nodeUpdated.disconnect(self.updateNodeParamView)
                self.workArea.scene().gfxNodeParamChanged.disconnect(self.onGfxNodeParamChanged)
                #
                # setupWindowTitle
                #

    def setupWindowTitle(self):
        #
        self.setWindowTitle(
            "meShaderEd %s (%s) %s"
            % (
                app_global_vars["version"],
                app_global_vars["RendererPreset"].getCurrentPresetName(),
                app_global_vars["ProjectPath"],
            )
        )
        self.ui.dockNodes.setToolTip(app_global_vars["NodesPath"])
        self.ui.dockNodes.setStatusTip(app_global_vars["NodesPath"])
        self.ui.dockProject.setToolTip(app_global_vars["ProjectNetworks"])
        self.ui.dockProject.setStatusTip(app_global_vars["ProjectNetworks"])
        #
        # setupMenuBar
        #

    def setupMenuBar(self):
        # override font for menu from Designer's settings to system default
        import sys

        font = QtGui.QFont()
        if sys.platform == "win32":
            # Runing on windows, override font sizes from Designer to default
            font.setPointSize(8)
        elif sys.platform == "darwin":
            font.setPointSize(10)

        self.ui.menubar.setFont(font)
        self.ui.menuFile.setFont(font)
        self.ui.menuEdit.setFont(font)
        self.ui.menuCommand.setFont(font)
        self.ui.menuWindow.setFont(font)
        self.ui.menuHelp.setFont(font)

        self.buildRecentProjectsMenu()
        self.buildRecentNetworksMenu()
        #
        # buildRecentProjectsMenu
        #

    def buildRecentProjectsMenu(self):
        #
        print ">> buildRecentProjectsMenu ..."
        if usePyQt4:
            # self.recentProjects = app_settings.value ( 'RecentProjects' ).toStringList ()
            print ">> self.recentProjects:", self.recentProjects
            self.ui.menuRecent_Projects.clear()
            if len(self.recentProjects):
                icon = QtGui.QIcon.fromTheme("folder", QtGui.QIcon(":/file_icons/resources/open.png"))
                # QtGui.QIcon ( ':/file_icons/resources/recentFile.png' ) 'folder'
                for i, fname in enumerate(self.recentProjects):
                    # QtCore.QFileInfo ( fname ).fileName ()
                    action = QtModule.QAction(icon, "&%d %s" % (i + 1, fname), self)
                    action.setData(QtCore.QVariant(fname))
                    self.connect(action, QtCore.SIGNAL("triggered()"), self.onOpenRecentProject)
                    self.ui.menuRecent_Projects.addAction(action)
        else:
            # self.recentProjects = app_settings.value ( 'RecentProjects' )
            print ">> self.recentProjects:", self.recentProjects
            self.ui.menuRecent_Projects.clear()
            if len(self.recentProjects):
                icon = QtGui.QIcon.fromTheme("folder", QtGui.QIcon(":/file_icons/resources/open.png"))
                # QtGui.QIcon ( ':/file_icons/resources/recentFile.png' ) 'folder'
                for i, fname in enumerate(self.recentProjects):
                    # QtCore.QFileInfo ( fname ).fileName ()
                    action = QtModule.QAction(icon, "&%d %s" % (i + 1, fname), self)
                    action.setData(fname)
                    action.triggered.connect(self.onOpenRecentProject)
                    self.ui.menuRecent_Projects.addAction(action)
                #
                # buildRecentNetworksMenu
                #

    def buildRecentNetworksMenu(self):
        #
        if usePyQt4:
            # self.recentNetworks = app_settings.value ( 'RecentNetworks' ).toStringList ()
            self.ui.menuRecent_Networks.clear()
            if len(self.recentNetworks):
                for i, fname in enumerate(self.recentNetworks):
                    icon = QtGui.QIcon.fromTheme("document-new", QtGui.QIcon(":/file_icons/resources/new.png"))
                    # QtCore.QFileInfo ( fname ).fileName ()
                    action = QtModule.QAction(icon, "&%d %s" % (i + 1, fname), self)
                    action.setData(QtCore.QVariant(fname))
                    self.connect(action, QtCore.SIGNAL("triggered()"), self.onOpenRecentNetwork)
                    self.ui.menuRecent_Networks.addAction(action)
        else:
            # self.recentNetworks = app_settings.value ( 'RecentNetworks' )
            self.ui.menuRecent_Networks.clear()
            if len(self.recentNetworks):
                for i, fname in enumerate(self.recentNetworks):
                    icon = QtGui.QIcon.fromTheme("document-new", QtGui.QIcon(":/file_icons/resources/new.png"))
                    # QtCore.QFileInfo ( fname ).fileName ()
                    action = QtModule.QAction(icon, "&%d %s" % (i + 1, fname), self)
                    action.setData(fname)
                    action.triggered.connect(self.onOpenRecentNetwork)
                    self.ui.menuRecent_Networks.addAction(action)
                #
                # setupPanels
                #

    def setupPanels(self):
        #
        self.tabifyDockWidget(self.ui.dockNodes, self.ui.dockProject)

        # self.tabifyDockWidget ( self.ui.dockPreview, self.ui.dockGeom  )
        self.tabifyDockWidget(self.ui.dockParam, self.ui.dockSwatch)

        # temporary hide unused panels
        # self.removeDockWidget ( self.ui.dockGeom )
        # self.removeDockWidget ( self.ui.dockSwatch )
        # self.ui.dockGeom.hide ()
        self.ui.dockSwatch.hide()

        self.ui.dockNodes.raise_()
        self.ui.dockPreview.raise_()
        self.ui.dockParam.raise_()

        # self.addDockWidget ( QtCore.Qt.DockWidgetArea ( 2 ), self.ui.dockParam )
        # self.ui.dockParam.show ()
        #
        # addRecentProject
        #

    def addRecentProject(self, project):
        #
        print ">> addRecentProject ", project
        if project is not None:
            if usePyQt4:
                recent_projects_max = getDefaultValue(app_settings, "", "recent_projects_max")
                if project not in self.recentProjects:
                    self.recentProjects.prepend(QtCore.QString(project))
                while self.recentProjects.count() > recent_projects_max:
                    self.recentProjects.takeLast()
                recentProjects = QtCore.QVariant(self.recentProjects) if self.recentProjects else QtCore.QVariant()
                app_settings.setValue("RecentProjects", recentProjects)
            else:
                recent_projects_max = getDefaultValue(app_settings, "", "recent_projects_max")
                if project not in self.recentProjects:
                    self.recentProjects.insert(0, project)
                    while len(self.recentProjects) > recent_projects_max:
                        self.recentProjects.pop()
                    app_settings.setValue("RecentProjects", self.recentProjects)
                    print "* project added recentProjects =", self.recentProjects
            print "* recentProjects =", self.recentProjects
            #
            # addRecentNetwork
            #

    def addRecentNetwork(self, network):
        #
        if network is not None:
            if usePyQt4:
                recent_networks_max = getDefaultValue(app_settings, "", "recent_networks_max")
                if network not in self.recentNetworks:
                    self.recentNetworks.prepend(QtCore.QString(network))
                while self.recentNetworks.count() > recent_networks_max:
                    self.recentNetworks.takeLast()
                recentNetworks = QtCore.QVariant(self.recentNetworks) if self.recentNetworks else QtCore.QVariant()
                app_settings.setValue("RecentNetworks", recentNetworks)
            else:
                recent_networks_max = getDefaultValue(app_settings, "", "recent_networks_max")
                if network not in self.recentNetworks:
                    self.recentNetworks.insert(0, network)
                while len(self.recentNetworks) > recent_networks_max:
                    self.recentNetworks.pop()
                app_settings.setValue("RecentNetworks", self.recentNetworks)
                #
                # setupActions
                #

    def setupActions(self):
        #
        # if DEBUG_MODE : print '>> MainWindow.setupActions'
        import sys

        numNodes = 0
        numSelectedNodes = 0
        numSelectedLinks = 0
        # selectedNodeType = None
        # selectedNodeFormat = None
        isShader = False
        isCode = False
        if self.workArea is not None:
            numNodes = len(self.workArea.getAllGfxNodes())
            numSelectedNodes = len(self.workArea.selectedNodes)
            numSelectedLinks = len(self.workArea.selectedLinks)
            if numSelectedNodes == 1:
                selectedNode = self.getSelectedNode().node
                selectedNodeType = selectedNode.type
                selectedNodeFormat = selectedNode.format
                if selectedNodeFormat in ["rsl", "rib"]:
                    isCode = True
                    if selectedNode.thisIs() == "rsl_shader_node":
                        isShader = True
        enableForPaste = False

        if self.clipboard.ownsClipboard() or (sys.platform == "darwin"):
            if DEBUG_MODE:
                print "** self.clipboard.ownsClipboard"
            data = self.clipboard.mimeData()
            if data is not None:
                if data.hasText():
                    enableForPaste = True

        self.ui.actionExportShader.setEnabled(isShader)
        self.ui.actionCompileShader.setEnabled(isShader)
        self.ui.actionViewComputedCode.setEnabled(isCode)
        self.ui.actionSaveSelected.setEnabled(numSelectedNodes > 0)
        self.ui.actionSelectAll.setEnabled(numNodes > 0)
        self.ui.actionSelectAbove.setEnabled(numSelectedNodes == 1)
        self.ui.actionSelectBelow.setEnabled(numSelectedNodes == 1)
        self.ui.actionDuplicate.setEnabled(numSelectedNodes > 0)
        self.ui.actionDuplicateWithLinks.setEnabled(numSelectedNodes > 0)
        self.ui.actionDelete.setEnabled((numSelectedNodes > 0) or (numSelectedLinks > 0))
        self.ui.actionCut.setEnabled(numSelectedNodes > 0)
        self.ui.actionCopy.setEnabled(numSelectedNodes > 0)
        self.ui.actionPaste.setEnabled(enableForPaste)
        self.ui.actionFitAll.setEnabled(numNodes > 0)
        self.ui.actionFitSelected.setEnabled(numSelectedNodes > 0)
        #
        # onProjectSetup
        #

    def onProjectSetup(self):
        #
        if DEBUG_MODE:
            print ">> MainWindow.onProjectSetup"
        projectSetupDlg = ProjectSetup(app_settings)
        projectSetupDlg.exec_()
        self.ui.project_ctl.setLibrary(app_global_vars["ProjectNetworks"])
        createDefaultProject(app_settings)
        self.setupWindowTitle()
        self.addRecentProject(app_global_vars["ProjectPath"])
        self.buildRecentProjectsMenu()
        #
        # onSettingsSetup
        #

    def onSettingsSetup(self):
        #
        if DEBUG_MODE:
            print ">> MainWindow.onSettingsSetup"
        settingsSetupDlg = SettingsSetup(app_settings)
        settingsSetupDlg.exec_()
        self.ui.nodeList_ctl.setLibrary(app_global_vars["NodesPath"])
        #
        # onRenderSettings
        #

    def onRenderSettings(self):
        #
        if DEBUG_MODE:
            print (">> MainWindow::onRenderSettings")
        import copy

        self.RendererPreset = copy.deepcopy(app_global_vars["RendererPreset"])
        if DEBUG_MODE:
            print (":: self.RendererPreset.getCurrentPresetName = %s" % self.RendererPreset.getCurrentPresetName())
        renderSettingsDlg = meRendererSetup(self.RendererPreset)
        if usePyQt4:
            QtCore.QObject.connect(renderSettingsDlg, QtCore.SIGNAL("presetChanged"), self.onRenderPresetChanged)
            QtCore.QObject.connect(renderSettingsDlg, QtCore.SIGNAL("savePreset"), self.onRenderPresetSave)
        else:
            renderSettingsDlg.presetChanged.connect(self.onRenderPresetChanged)
            renderSettingsDlg.savePreset.connect(self.onRenderPresetSave)
        renderSettingsDlg.exec_()
        #
        # onRenderPresetChanged
        #

    def onRenderPresetChanged(self):
        #
        if DEBUG_MODE:
            print (">> MainWindow::onRenderPresetChanged preset = %s" % self.RendererPreset.getCurrentPresetName())
        app_settings.setValue("defRenderer", self.RendererPreset.getCurrentPresetName())

        app_global_vars["RendererName"] = self.RendererPreset.currentPreset.RendererName
        app_global_vars["RendererFlags"] = self.RendererPreset.currentPreset.RendererFlags
        app_global_vars["ShaderCompiler"] = self.RendererPreset.currentPreset.ShaderCompiler
        app_global_vars["ShaderDefines"] = self.RendererPreset.currentPreset.ShaderDefines
        app_global_vars["ShaderInfo"] = self.RendererPreset.currentPreset.ShaderInfo
        app_global_vars["SLO"] = self.RendererPreset.currentPreset.ShaderExt
        app_global_vars["TextureMake"] = self.RendererPreset.currentPreset.TextureMake
        app_global_vars["TextureInfo"] = self.RendererPreset.currentPreset.TextureInfo
        app_global_vars["TextureViewer"] = self.RendererPreset.currentPreset.TextureViewer
        app_global_vars["TEX"] = self.RendererPreset.currentPreset.TextureExt
        app_global_vars["RendererPreset"] = self.RendererPreset
        self.setupWindowTitle()
        #
        # onRenderPresetSave
        #

    def onRenderPresetSave(self):
        #
        if DEBUG_MODE:
            print (">> MainWindow::onRenderPresetSave  preset = %s" % self.RendererPreset.getCurrentPresetName())
        self.RendererPreset.saveSettings()
        app_global_vars["RendererPreset"] = self.RendererPreset
        #
        # onShowGrid
        #

    def onShowGrid(self, check):
        #
        self.workArea.drawGrid = bool(check)
        app_settings.beginGroup("WorkArea")
        app_settings.setValue("grid_enabled", bool(check))
        app_settings.endGroup()
        self.workArea.resetCachedContent()
        # self.ui.workArea.update()
        #
        # onSnapGrid
        #

    def onSnapGrid(self, check):
        #
        self.workArea.gridSnap = bool(check)
        app_settings.beginGroup("WorkArea")
        app_settings.setValue("grid_snap", bool(check))
        app_settings.endGroup()
        #
        # onReverseFlow
        #

    def onReverseFlow(self, check):
        #
        self.workArea.reverseFlow = bool(check)
        app_settings.beginGroup("WorkArea")
        app_settings.setValue("reverse_flow", bool(check))
        app_settings.endGroup()
        # self.ui.workArea.resetCachedContent()
        #
        # onStraightLinks
        #

    def onStraightLinks(self, check):
        #
        self.workArea.straightLinks = bool(check)
        app_settings.beginGroup("WorkArea")
        app_settings.setValue("straight_links", bool(check))
        app_settings.endGroup()
        self.workArea.resetCachedContent()
        self.workArea.adjustLinks()
        #
        # setActiveNodeList
        #

    def setActiveNodeList(self, nodeList):
        #
        if DEBUG_MODE:
            print (">> MainWindow.setActiveNodeList")
        if usePyQt4:
            if self.activeNodeList != None:
                QtCore.QObject.disconnect(self.activeNodeList, QtCore.SIGNAL("addNode"), self.workArea.insertNodeNet)
            self.activeNodeList = nodeList
            QtCore.QObject.connect(self.activeNodeList, QtCore.SIGNAL("addNode"), self.workArea.insertNodeNet)
        else:
            if self.activeNodeList != None:
                self.activeNodeList.addNode.disconnect(self.workArea.insertNodeNet)
            self.activeNodeList = nodeList
            self.activeNodeList.addNode.connect(self.workArea.insertNodeNet)
            #
            # onGetNode
            #
            # Called by WorkArea after drag&drop event
            # Here we choose selected nodeList panel (Library or Project)
            # for processing node request
            #

    def onGetNode(self, itemFilename, pos):
        #
        if self.activeNodeList != None:
            self.activeNodeList.onGetNode(itemFilename, pos)
        #
        # onAddGfxNode
        #

    def onAddGfxNode(self, gfxNode):
        #
        # print ">> MainWindow: onAddGfxNode = %s" % gfxNode.node.label
        if gfxNode.node.format == "image":
            if gfxNode.node.thisIs() == "image_render_node":
                self.ui.imageView_ctl.addViewer(gfxNode)

                #
                # onRemoveGfxNode
                #

    def onRemoveGfxNode(self, gfxNode):
        #
        if DEBUG_MODE:
            print (">> MainWindow.onRemoveGfxNode = %s" % gfxNode.node.label)
        if gfxNode.node.format == "image":
            if gfxNode.node.thisIs() == "image_render_node":
                self.ui.imageView_ctl.removeViewer(gfxNode)
                #
                # getSelectedNode
                #

    def getSelectedNode(self):
        return self.workArea.selectedNodes[0]

    #
    # onRenderPreview
    #
    def onRenderPreview(self):
        print ">> MainWindow.onRenderPreview (not implemented yet...)"

    #
    # onShowSwatch
    #
    def onShowSwatch(self):
        print ">> MainWindow.onShowSwatch (not implemented yet...)"

    #
    # onHideSwatch
    #
    def onHideSwatch(self):
        print ">> MainWindow.onHideSwatch (not implemented yet...)"

    #
    # onCreateNode
    #
    def onCreateNode(self):
        print ">> MainWindow.onCreateNode (not implemented yet...)"

    #
    # onExportShader
    #
    def onExportShader(self):
        #
        if DEBUG_MODE:
            print ">> MainWindow.onExportShader"
        gfxNode = self.getSelectedNode()
        exportShaderDlg = ExportShaderDialog(gfxNode.node)
        exportShaderDlg.exec_()
        if exportShaderDlg.ui.chk_save_changes.isChecked():
            if DEBUG_MODE:
                print ">> MainWindow.exportShaderDlg save changes"
            gfxNode.updateGfxNode(removeLinks=False)
            self.workArea.updateBelow(gfxNode)
            self.updateNodeParamView()
            self.workArea.scene().update()
            #
            # onViewComputedCode
            #

    def onViewComputedCode(self):
        ViewComputedCodeDialog(self.getSelectedNode().node).exec_()

    #
    # onEditNode
    #
    def onEditNode(self):
        #
        if DEBUG_MODE:
            print ">> MainWindow.onEditNode"

        gfxNode = self.getSelectedNode()
        editNode = gfxNode.node.copy()

        dupNodeNet = NodeNetwork("duplicate")
        dupNodeNet.addNode(editNode)
        #
        # copy input links to new node
        #
        if DEBUG_MODE:
            print "** duplicate input links ..."
        for link in gfxNode.node.getInputLinks():
            newLink = link.copy()
            newParam = editNode.getInputParamByName(link.dstParam.name)
            newLink.setDst(editNode, newParam)
            dupNodeNet.addLink(newLink)

            newLink.printInfo()
            #
            # copy output links to new node
            #
        if DEBUG_MODE:
            print "** duplicate output links ..."
        for link in gfxNode.node.getOutputLinks():
            newLink = link.copy()
            newParam = editNode.getOutputParamByName(link.srcParam.name)
            newLink.setSrc(editNode, newParam)
            dupNodeNet.addLink(newLink)

            newLink.printInfo()

        nodeEditDlg = NodeEditorDialog(editNode)

        if nodeEditDlg.exec_() == QtModule.QDialog.Accepted:
            #
            if DEBUG_MODE:
                print ">> MainWindow.nodeEditDlg Accepted"
            #
            # remove original node with links
            (inputLinksToRemove, outputLinksToRemove) = self.workArea.nodeNet.removeNode(gfxNode.node)

            for link in inputLinksToRemove:
                self.workArea.nodeNet.removeLink(link)
            for link in outputLinksToRemove:
                self.workArea.nodeNet.removeLink(link)

            # add duplicate network to current node net
            self.workArea.nodeNet.add(dupNodeNet)

            if gfxNode.node.label != editNode.label:
                self.ui.imageView_ctl.onNodeLabelChanged(gfxNode, editNode.label)

                # set new node to gfxNode.node
            gfxNode.node = editNode
            gfxNode.updateGfxNode()
            for link in editNode.getInputLinks():
                self.workArea.addGfxLink(link)
            for link in editNode.getOutputLinks():
                self.workArea.addGfxLink(link)
            self.updateNodeParamView()
            self.workArea.scene().update()

        else:
            # remove duplicate node network
            dupNodeNet.clear()
            #
            # onDelete
            #

    def onDelete(self):
        #
        selected = self.workArea.scene().selectedItems()
        if len(selected):
            self.workArea.removeSelected()
        else:
            self.ui.imageView_ctl.removeAllViewers()
            self.workArea.clear()
            #
            # onSelectAll
            #

    def onSelectAll(self):
        self.workArea.selectAllNodes()

    #
    # onSelectAbove
    #
    def onSelectAbove(self):
        self.workArea.selectAbove(self.getSelectedNode())

    #
    # onSelectBelow
    #
    def onSelectBelow(self):
        self.workArea.selectBelow(self.getSelectedNode())

    #
    # onCopy
    #
    def onCopy(self):
        if DEBUG_MODE:
            print (">> MainWindow.onCopy")
        self.workArea.copyNodes(self.clipboard, cutNodes=False)
        self.setupActions()
        #
        # onCut
        #

    def onCut(self):
        if DEBUG_MODE:
            print (">> MainWindow.onCut")
        self.workArea.copyNodes(self.clipboard, cutNodes=True)
        self.setupActions()
        #
        # onPaste
        #

    def onPaste(self):
        if DEBUG_MODE:
            print (">> MainWindow.onPaste")
        self.workArea.pasteNodes(self.clipboard)
        #
        # onDuplicate
        #

    def onDuplicate(self):
        self.workArea.duplicateNodes(preserveLinks=False)

    #
    # onDuplicateWithLinks
    #
    def onDuplicateWithLinks(self):
        self.workArea.duplicateNodes(preserveLinks=True)

    #
    # onSelectGfxNodes
    #
    def onSelectGfxNodes(self, gfxNodes=[], gfxLinks=[]):
        #
        self.setupActions()
        self.workArea.inspectedNode = None
        if len(gfxNodes) == 1:
            gfxNode = gfxNodes[0]
            self.workArea.inspectedNode = gfxNode
            if gfxNode.node.format == "image":
                if gfxNode.node.thisIs() == "image_render_node":
                    self.ui.imageView_ctl.selectViewer(gfxNode)
        self.ui.nodeParam_ctl.setNode(self.workArea.inspectedNode)
        #
        # onNodeLabelChanged
        #

    def onNodeLabelChanged(self, gfxNode, newLabel):
        #
        self.workArea.nodeNet.renameNodeLabel(gfxNode.node, newLabel)
        gfxNode.updateNodeLabel()
        self.ui.imageView_ctl.onNodeLabelChanged(gfxNode, newLabel)
        self.workArea.scene().update()
        #
        # onNodeParamChanged
        #

    def onNodeParamChanged(self, gfxNode, param):
        #
        if DEBUG_MODE:
            print (">> MainWindow.onNodeParamChanged")
        # from WorkArea we have GfxNode in signal nodeConnectionChanged
        # hence need to update nodeParam_ctl
        if isinstance(gfxNode, GfxNote):
            if DEBUG_MODE:
                print ("* update GfxNote")
            gfxNode.updateGfxNode()
            self.workArea.scene().update()
        elif isinstance(gfxNode, GfxSwatchNode):
            if DEBUG_MODE:
                print ("* update GfxSwatchNode")
            gfxNode.setupSwatchParams()
            gfxNode.setupGeometry()
            gfxNode.adjustLinks()
            self.workArea.scene().update()
        elif isinstance(gfxNode, GfxNode):
            if DEBUG_MODE:
                print ("* update GfxNode")
            gfxNode.updateGfxNode(removeLinks=False)
            self.updateNodeParamView(gfxNode, param)

        if self.ui.imageView_ctl.autoUpdate():
            self.ui.imageView_ctl.updateViewer()
            #
            # onGxNodeParamChanged
            #

    def onGfxNodeParamChanged(self, gfxNode, param=None):
        #
        if DEBUG_MODE:
            print (">> MainWindow.onGxNodeParamChanged")

        # from WorkArea we have GfxNode in signal nodeConnectionChanged
        # hence need to update nodeParam_ctl
        if isinstance(gfxNode, GfxNode) or isinstance(gfxNode, GfxSwatchNode):
            # if DEBUG_MODE : print "* update nodeView"
            # gfxNode.updateInputParams ()
            self.updateNodeParamView(gfxNode, param)
            self.workArea.scene().update()

        if self.ui.imageView_ctl.autoUpdate():
            self.ui.imageView_ctl.updateViewer()
            #
            # updateNodeParamView
            #

    def updateNodeParamView(self, gfxNode=None, param=None):
        #
        if DEBUG_MODE:
            print (">> MainWindow.updateNodeParamView")
        if gfxNode is not None:
            print ('** gfxNode = "%s"' % gfxNode.node.label)
            if param is not None:
                print ('** param = "%s"' % param.name)
                print ("** No update")
                return
        print ("** Update all parameters")
        self.ui.nodeParam_ctl.disconnectParamSignals()
        self.ui.nodeParam_ctl.connectParamSignals()
        self.ui.nodeParam_ctl.updateGui()
        #
        # onFitAll
        #

    def onFitAll(self):
        self.workArea.fitGfxNodesInView(self.workArea.getAllGfxNodes())

    #
    # onFitSelected
    #
    def onFitSelected(self):
        self.workArea.fitGfxNodesInView(self.workArea.selectedNodes)

    #
    # onZoomReset
    #
    def onZoomReset(self):
        self.workArea.resetZoom()

    #
    # onNewParamView
    #
    def onNewParamView(self):
        print ">> MainWindow.onNewParamView (not implemented yet...)"

    #
    # onTabSelected
    #
    def onTabSelected(self, idx):
        #
        if DEBUG_MODE:
            print ">> MainWindow.onTabSelected (%d)" % idx
        self.disconnectWorkAreaSignals()
        self.ui.imageView_ctl.removeAllViewers()
        self.workArea = self.ui.tabs.currentWidget()

        # setup imageView menu for image nodes in new tab
        imageNodes = self.workArea.getGfxNodesByFormat("image")
        for gfxNode in imageNodes:
            if gfxNode.node.thisIs() == "image_render_node":
                self.ui.imageView_ctl.addViewer(gfxNode)

        self.connectWorkAreaSignals()
        self.ui.nodeParam_ctl.setNode(self.workArea.inspectedNode)
        self.workArea.adjustLinks()
        #
        # onTabCloseRequested
        #

    def onTabCloseRequested(self, idx):
        #
        if DEBUG_MODE:
            print ">> MainWindow: onTabCloseRequested (%d)" % idx
        if self.ui.tabs.count() > 1:
            self.workArea.nodeNet.clear()
            self.ui.tabs.removeTab(idx)
            #
            # onNew
            #
            # @QtCore.pyqtSlot ()

    def onNew(self, foo_param=None, tabName="untitled"):
        #
        def tabNameExists(self, name):
            ret = False
            for i in range(0, self.ui.tabs.count()):
                if name == str(self.ui.tabs.tabText(i)):
                    ret = True
                    break
            return ret
            #

        newName = tabName
        if DEBUG_MODE:
            print "->  self.ui.tabs.count() = %d " % self.ui.tabs.count()

        if self.workArea != None:
            if DEBUG_MODE:
                print "->  create new WorkArea widget"
            # set unique new name
            name = newName
            i = 0
            while True:
                if tabNameExists(self, name):
                    name = newName + str(i)
                    i += 1
                    continue
                else:
                    break

            newName = name
            workArea = WorkArea()  # create new WorkArea instance
            newTab = self.ui.tabs.addTab(workArea, newName)
        else:
            if DEBUG_MODE:
                print "->  use initial WorkArea widget"
            workArea = self.ui.workArea  # use initial WorkArea widget
            self.workArea = workArea
            self.connectWorkAreaSignals()

        nodeNet = NodeNetwork(newName)
        workArea.setNodeNetwork(nodeNet)

        self.ui.tabs.setTabText(self.ui.tabs.indexOf(workArea), newName)
        self.ui.tabs.setCurrentIndex(self.ui.tabs.indexOf(workArea))
        #
        # onOpen
        #

    def onOpen(self):
        #
        if DEBUG_MODE:
            print ">> MainWindow.onOpen"
        #
        curDir = app_global_vars["ProjectNetworks"]
        typeFilter = "Shader networks *.xml;;All files *.*;;"
        if usePyQt4:
            filename = str(QtGui.QFileDialog.getOpenFileName(self, "Open file", curDir, typeFilter))
        else:
            (filename, filter) = QtModule.QFileDialog.getOpenFileName(self, "Open file", curDir, typeFilter)
        if filename != "":
            if self.openNetwork(filename):
                self.addRecentNetwork(normPath(filename))
                self.buildRecentNetworksMenu()
                #
                # openNetwork
                #

    def openNetwork(self, filename):
        #
        import os

        ret = True
        if DEBUG_MODE:
            print "-> open file %s" % filename
        if QtCore.QFile.exists(filename):
            (name, ext) = os.path.splitext(os.path.basename(filename))

            self.ui.imageView_ctl.removeAllViewers()

            self.workArea.clear()
            self.workArea.nodeNet.name = name
            self.workArea.nodeNet.fileName = ""
            self.ui.tabs.setTabText(self.ui.tabs.indexOf(self.workArea), name)

            self.workArea.openNodeNet(normPath(filename))
        else:
            print "ERROR! filename %s doesn't exist" % filename
            ret = False
        return ret
        #
        # onOpenRecentNetwork
        #

    def onOpenRecentNetwork(self):
        #
        action = self.sender()
        if isinstance(action, QtModule.QAction):
            if usePyQt4:
                network = unicode(action.data().toString())
            else:
                network = action.data()
            if network is not None:
                if DEBUG_MODE:
                    print ">> onOpenRecentNetwork : %s" % network
                if not self.openNetwork(network):
                    if usePyQt4:
                        self.recentNetworks.removeAll(network)
                    else:
                        self.recentNetworks.remove(network)
                #
                # onOpenRecentProject
                #

    def onOpenRecentProject(self):
        #
        action = self.sender()
        if isinstance(action, QtModule.QAction):
            if usePyQt4:
                project = unicode(action.data().toString())
            else:
                project = action.data()
            if project is not None:
                print ">> onOpenRecentProject : %s" % project
                project_filename = getDefaultValue(app_settings, "", "project_filename")
                if openDefaultProject(app_settings, app_global_vars, project, project_filename):
                    # very strange... app_settings doesn't update inside meCommon.openDefaultProject...
                    # though app_global_vars does
                    # have to duplicate this action here...
                    app_settings.setValue("project", app_global_vars["ProjectPath"])
                    app_settings.setValue("project_shaders", app_global_vars["ProjectShaders"])
                    app_settings.setValue("project_textures", app_global_vars["ProjectTextures"])
                    app_settings.setValue("shader_networks", app_global_vars["ProjectNetworks"])
                    app_settings.setValue("shader_sources", app_global_vars["ProjectSources"])

                    self.ui.project_ctl.setLibrary(app_global_vars["ProjectNetworks"])
                    self.setupWindowTitle()
                else:
                    print "ERROR! project %s doesn't exist" % project
                    if usePyQt4:
                        self.recentProjects.removeAll(network)
                    else:
                        self.recentProjects.remove(network)
                #
                # onImport
                #

    def onImport(self):
        #
        if DEBUG_MODE:
            print ">> MainWindow.onImport"
        #
        curDir = app_global_vars["ProjectNetworks"]
        typeFilter = "Shader networks *.xml;;All files *.*;;"

        if usePyQt4:
            filename = str(QtModule.QFileDialog.getOpenFileName(self, "Import file", curDir, typeFilter))
        else:
            (filename, filter) = QtModule.QFileDialog.getOpenFileName(self, "Import file", curDir, typeFilter)
        if filename != "":
            if DEBUG_MODE:
                print "-> import file %s" % filename
            self.workArea.insertNodeNet(normPath(filename))
            #
            # onSaveSelected
            #

    def onSaveSelected(self):
        #
        import os

        if DEBUG_MODE:
            print ">> MainWindow.onSaveSelected"
        singleNode = len(self.workArea.selectedNodes) == 1
        curDir = app_global_vars["ProjectNetworks"]
        saveName = os.path.join(curDir, self.workArea.nodeNet.name + ".xml")
        typeFilter = "Shader networks *.xml;;All files *.*;;"

        if usePyQt4:
            filename = str(QtModule.QFileDialog.getSaveFileName(self, "Save file as", saveName, typeFilter))
        else:
            (filename, filter) = QtModule.QFileDialog.getSaveFileName(self, "Save file as", saveName, typeFilter)
        if filename != "":
            if DEBUG_MODE:
                print "-> save file As %s" % filename
            (name, ext) = os.path.splitext(os.path.basename(filename))
            if singleNode:
                # save single node
                print "*** save as single Node"
                gfxNode = self.getSelectedNode()
                saveNode = gfxNode.node.copy()
                saveNode.name = name
                saveNode.master = normPath(filename)
                saveNode.save()
            else:
                # save selected as network
                print "*** save as nodenet"
                saveNodeNet = self.workArea.nodeNetFromSelected(name)
                saveNodeNet.fileName = normPath(filename)
                saveNodeNet.save()
                #
                # onSave
                #

    def onSave(self):
        #
        if DEBUG_MODE:
            print ">> MainWindow.onSave"
        # if file is new -- use onSaveAs function
        #
        curDir = app_global_vars["ProjectNetworks"]
        if self.workArea.nodeNet.fileName == "":
            self.onSaveAs()
        else:
            if DEBUG_MODE:
                print "-> save file %s" % self.workArea.nodeNet.fileName
            self.workArea.nodeNet.save()
            #
            # onSaveAs
            #

    def onSaveAs(self):
        #
        if DEBUG_MODE:
            print ">> MainWindow.onSaveAs"
        #
        import os

        curDir = app_global_vars["ProjectNetworks"]
        saveName = os.path.join(curDir, self.workArea.nodeNet.name + ".xml")
        typeFilter = "Shader networks *.xml;;All files *.*;;"
        if usePyQt4:
            filename = str(QtModule.QFileDialog.getSaveFileName(self, "Save file as", saveName, typeFilter))
        else:
            (filename, filter) = QtModule.QFileDialog.getSaveFileName(self, "Save file as", saveName, typeFilter)
        if filename != "":
            if DEBUG_MODE:
                print "-> save file As %s" % filename
            (name, ext) = os.path.splitext(os.path.basename(filename))
            self.workArea.nodeNet.fileName = normPath(filename)
            self.workArea.nodeNet.name = name
            self.ui.tabs.setTabText(self.ui.tabs.indexOf(self.workArea), name)
            self.workArea.nodeNet.save()
            self.addRecentNetwork(normPath(filename))
            self.buildRecentNetworksMenu()
            self.ui.project_ctl.onReload()
            #
            # onHelpNode
            #

    def onHelpMode(self, showWhatsThis):
        #
        # if showWhatsThis :
        QtModule.QWhatsThis.enterWhatsThisMode()
        # else :
        #  QtGui.QWhatsThis.leaveWhatsThisMode ()
        #
        # onCompileShader
        #

    def onCompileShader(self):
        #
        if DEBUG_MODE:
            print ">> MainWindow.onCompileShader"
        pass
Пример #36
0
	def __init__ ( self ) :
		#
		QtModule.QMainWindow.__init__ ( self )

		self.ui = Ui_MainWindow ()
		self.ui.setupUi ( self )
		#
		# setup WhatsThis help action
		#
		self.ui.actionHelpMode = QtModule.QWhatsThis.createAction ( )
		self.ui.actionHelpMode.setToolTip ( 'Enter "WhatsThis" help mode' )
		self.ui.menuHelp.addAction ( self.ui.actionHelpMode )
		self.ui.toolBar.addSeparator()
		self.ui.toolBar.addAction ( self.ui.actionHelpMode )
		
		self.clipboard = QtModule.QApplication.clipboard ()

		if usePyQt4 :
			self.recentProjects = app_settings.value ( 'RecentProjects' ).toStringList ()
			self.recentNetworks = app_settings.value ( 'RecentNetworks' ).toStringList ()
		else :
			self.recentProjects = []
			self.recentNetworks = []
			
			recentProjects = app_settings.value ( 'RecentProjects' )
			if recentProjects is not None :
				if isinstance ( recentProjects, list ) :
					for proj in recentProjects :
						self.recentProjects.append ( proj )	
				else :
					self.recentProjects.append ( recentProjects )
			
			recentNetworks = app_settings.value ( 'RecentNetworks' )
			if recentNetworks is not None :
				if isinstance ( recentNetworks, list ) :
					for network in recentNetworks :
						self.recentNetworks.append ( network )	
				else :
					self.recentNetworks.append ( recentNetworks )
			
		print '* recentProjects =', self.recentProjects
		print '* recentNetworks =', self.recentNetworks
		
		print '* ProjectPath =', app_global_vars [ 'ProjectPath' ]
			
		self.addRecentProject ( app_global_vars [ 'ProjectPath' ] )

		self.setupMenuBar ()
		self.setupPanels ()

		self.activeNodeList = None
		self.workArea = None # current work area
		self.onNew () # create new document

		grid_enabled = getDefaultValue ( app_settings, 'WorkArea', 'grid_enabled' )
		grid_snap = getDefaultValue ( app_settings, 'WorkArea', 'grid_snap' )
		grid_size = int ( getDefaultValue ( app_settings, 'WorkArea', 'grid_size' )  )
		reverse_flow = getDefaultValue ( app_settings, 'WorkArea', 'reverse_flow' )
		straight_links = getDefaultValue ( app_settings, 'WorkArea', 'straight_links' )

		#self.ui.workArea.gridSize = grid_size
		#self.ui.workArea.gridSnap = grid_snap
		self.workArea.drawGrid = grid_enabled
		#self.ui.workArea.reverseFlow = reverse_flow
		#self.ui.workArea.straightLinks = straight_links

		self.ui.actionShowGrid.setChecked ( grid_enabled )
		self.ui.actionSnapGrid.setChecked ( grid_snap )
		self.ui.actionReverseFlow.setChecked ( reverse_flow )
		self.ui.actionStraightLinks.setChecked ( straight_links )

		self.ui.nodeList_ctl.setLibrary ( app_global_vars [ 'NodesPath' ] )
		self.ui.project_ctl.setLibrary ( app_global_vars [ 'ProjectNetworks' ] )

		#self.ui.dockNodes.setWindowTitle ( 'Library: %s' % app_global_vars [ 'NodesPath' ] )
		#self.ui.dockProject.setWindowTitle ( 'Project: %s' % app_global_vars [ 'ProjectNetworks' ] )

		self.connectSignals ()
		
		self.setupActions ()
		self.setupWindowTitle ()
Пример #37
0
class MainWindow ( QtGui.QMainWindow ) :
  #
  # __init__
  #
  def __init__ ( self ) :
    #
    QtGui.QMainWindow.__init__ ( self )

    self.ui = Ui_MainWindow ()
    self.ui.setupUi ( self )
    #
    # setup WhatsThis help action
    #
    self.ui.actionHelpMode = QtGui.QWhatsThis.createAction ( )
    self.ui.actionHelpMode.setToolTip ( 'Enter "WhatsThis" help mode' )
    self.ui.menuHelp.addAction ( self.ui.actionHelpMode )
    self.ui.toolBar.addSeparator()
    self.ui.toolBar.addAction ( self.ui.actionHelpMode )
    QtCore.QObject.connect ( self.ui.actionHelpMode, QtCore.SIGNAL ( 'toggled(bool)' ), self.onHelpMode )
    
    self.clipboard = QtGui.QApplication.clipboard ()

    self.recentProjects = app_settings.value ( 'RecentProjects' ).toStringList ()
    self.recentNetworks = app_settings.value ( 'RecentNetworks' ).toStringList ()

    self.addRecentProject ( app_global_vars [ 'ProjectPath' ] )

    self.setupMenuBar ()
    self.setupPanels ()

    self.activeNodeList = None
    self.workArea = None # current work area
    self.onNew () # create new document

    grid_enabled = getDefaultValue ( app_settings, 'WorkArea', 'grid_enabled' )
    grid_snap = getDefaultValue ( app_settings, 'WorkArea', 'grid_snap' )
    grid_size = int ( getDefaultValue ( app_settings, 'WorkArea', 'grid_size' )  )
    reverse_flow = getDefaultValue ( app_settings, 'WorkArea', 'reverse_flow' )
    straight_links = getDefaultValue ( app_settings, 'WorkArea', 'straight_links' )

    #self.ui.workArea.gridSize = grid_size
    #self.ui.workArea.gridSnap = grid_snap
    self.workArea.drawGrid = grid_enabled
    #self.ui.workArea.reverseFlow = reverse_flow
    #self.ui.workArea.straightLinks = straight_links

    self.ui.actionShowGrid.setChecked ( grid_enabled )
    self.ui.actionSnapGrid.setChecked ( grid_snap )
    self.ui.actionReverseFlow.setChecked ( reverse_flow )
    self.ui.actionStraightLinks.setChecked ( straight_links )

    self.ui.nodeList_ctl.setLibrary ( app_global_vars [ 'NodesPath' ] )
    self.ui.project_ctl.setLibrary ( app_global_vars [ 'ProjectNetworks' ] )

    #self.ui.dockNodes.setWindowTitle ( 'Library: %s' % app_global_vars [ 'NodesPath' ] )
    #self.ui.dockProject.setWindowTitle ( 'Project: %s' % app_global_vars [ 'ProjectNetworks' ] )

    QtCore.QObject.connect ( self.ui.nodeList_ctl.ui.nodeList, QtCore.SIGNAL ( 'setActiveNodeList' ), self.setActiveNodeList )
    QtCore.QObject.connect ( self.ui.project_ctl.ui.nodeList, QtCore.SIGNAL ( 'setActiveNodeList' ), self.setActiveNodeList )

    QtCore.QObject.connect ( self.ui.tabs, QtCore.SIGNAL ( 'currentChanged(int)' ), self.onTabSelected )
    QtCore.QObject.connect ( self.ui.tabs, QtCore.SIGNAL ( 'tabCloseRequested(int)' ), self.onTabCloseRequested )

    QtCore.QObject.connect ( self.ui.nodeParam_ctl, QtCore.SIGNAL ( 'nodeLabelChanged' ), self.onNodeLabelChanged  )
    QtCore.QObject.connect ( self.ui.nodeParam_ctl, QtCore.SIGNAL ( 'nodeParamChanged' ), self.onNodeParamChanged  )

    self.setupActions ()
    self.setupWindowTitle ()
  #
  # connectWorkAreaSignals
  #
  def connectWorkAreaSignals ( self ) :
    #
    if self.workArea != None :
      if self.activeNodeList != None :
        QtCore.QObject.connect ( self.activeNodeList, QtCore.SIGNAL ( 'addNode' ), self.workArea.insertNodeNet  )
      QtCore.QObject.connect ( self.workArea, QtCore.SIGNAL ( 'selectNodes' ), self.onSelectGfxNodes  )
      QtCore.QObject.connect ( self.workArea, QtCore.SIGNAL ( 'nodeConnectionChanged' ), self.onGfxNodeParamChanged  )
      QtCore.QObject.connect ( self.workArea, QtCore.SIGNAL ( 'gfxNodeAdded' ), self.onAddGfxNode )
      QtCore.QObject.connect ( self.workArea, QtCore.SIGNAL ( 'gfxNodeRemoved' ), self.onRemoveGfxNode )
      #QtCore.QObject.connect ( self.workArea, QtCore.SIGNAL ( 'editGfxNode' ), self.editGfxNode )
      QtCore.QObject.connect ( self.workArea.scene(), QtCore.SIGNAL ( 'nodeUpdated' ), self.updateNodeParamView )
      QtCore.QObject.connect ( self.workArea.scene(), QtCore.SIGNAL ( 'gfxNodeParamChanged' ), self.onGfxNodeParamChanged  )
  #
  # disconnectWorkAreaSignals
  #
  def disconnectWorkAreaSignals ( self ) :
    #
    if self.workArea != None :
      if self.activeNodeList != None :
        QtCore.QObject.disconnect ( self.activeNodeList, QtCore.SIGNAL ( 'addNode' ), self.workArea.insertNodeNet  )
      QtCore.QObject.disconnect ( self.workArea, QtCore.SIGNAL ( 'selectNodes' ), self.onSelectGfxNodes  )
      QtCore.QObject.disconnect ( self.workArea, QtCore.SIGNAL ( 'nodeConnectionChanged' ), self.onGfxNodeParamChanged  )
      QtCore.QObject.disconnect ( self.workArea, QtCore.SIGNAL ( 'gfxNodeAdded' ), self.onAddGfxNode )
      QtCore.QObject.disconnect ( self.workArea, QtCore.SIGNAL ( 'gfxNodeRemoved' ), self.onRemoveGfxNode )
      #QtCore.QObject.disconnect ( self.workArea, QtCore.SIGNAL ( 'editGfxNode' ), self.editGfxNode )
      QtCore.QObject.disconnect ( self.workArea.scene(), QtCore.SIGNAL ( 'nodeUpdated' ), self.updateNodeParamView )
      QtCore.QObject.disconnect ( self.workArea.scene(), QtCore.SIGNAL ( 'gfxNodeParamChanged' ), self.onGfxNodeParamChanged  )
  #
  #
  #
  def setupWindowTitle ( self ) :
    #
    self.setWindowTitle ( 'meShaderEd %s (%s) %s' % ( app_global_vars [ 'version' ], app_renderer.getCurrentPresetName(), app_global_vars [ 'ProjectPath' ]  ) )
    self.ui.dockNodes.setToolTip ( app_global_vars [ 'NodesPath' ] )
    self.ui.dockNodes.setStatusTip ( app_global_vars [ 'NodesPath' ] )
    self.ui.dockProject.setToolTip ( app_global_vars [ 'ProjectNetworks' ] )
    self.ui.dockProject.setStatusTip ( app_global_vars [ 'ProjectNetworks' ] )
  #
  # setupMenuBar
  #
  def setupMenuBar ( self ) :
    # override font for menu from Designer's settings to system default
    font = QtGui.QFont ()
    if ( sys.platform == 'win32' ):
      # Runing on windows, override font sizes from Designer to default
      font.setPointSize ( 8 )
    elif ( sys.platform == 'darwin' ):
      font.setPointSize ( 10 )

    self.ui.menubar.setFont ( font )
    self.ui.menuFile.setFont ( font )
    self.ui.menuEdit.setFont ( font )
    self.ui.menuCommand.setFont ( font )
    self.ui.menuWindow.setFont ( font )
    self.ui.menuHelp.setFont ( font )

    self.buildRecentProjectsMenu ()
    self.buildRecentNetworksMenu ()
  #
  # buildRecentProjectsMenu
  #
  def buildRecentProjectsMenu ( self ) :
    #self.recentProjects = app_settings.value ( 'RecentProjects' ).toStringList ()
    #self.recentNetworks = app_settings.value ( 'RecentNetworks' ).toStringList ()
    self.ui.menuRecent_Projects.clear ()

    if len ( self.recentProjects ) :
      icon =  QtGui.QIcon.fromTheme ( 'folder', QtGui.QIcon ( ':/file_icons/resources/open.png' ) )
      # QtGui.QIcon ( ':/file_icons/resources/recentFile.png' ) 'folder'
      for i, fname in enumerate ( self.recentProjects ) :
        # QtCore.QFileInfo ( fname ).fileName ()
        action = QtGui.QAction ( icon, '&%d %s' % ( i + 1, fname ), self )
        action.setData ( QtCore.QVariant ( fname ) )
        self.connect ( action, QtCore.SIGNAL ( 'triggered()' ), self.onOpenRecentProject )
        self.ui.menuRecent_Projects.addAction ( action )
  #
  # buildRecentNetworksMenu
  #
  def buildRecentNetworksMenu ( self ) :
    #
    self.ui.menuRecent_Networks.clear ()

    if len ( self.recentNetworks ) :
      for i, fname in enumerate ( self.recentNetworks ) :
        icon =  QtGui.QIcon.fromTheme ( 'document-new', QtGui.QIcon ( ':/file_icons/resources/new.png' ) )
        # QtCore.QFileInfo ( fname ).fileName ()
        action = QtGui.QAction ( icon, '&%d %s' % ( i + 1, fname ), self )
        action.setData ( QtCore.QVariant ( fname ) )
        self.connect ( action, QtCore.SIGNAL ( 'triggered()' ), self.onOpenRecentNetwork )
        self.ui.menuRecent_Networks.addAction ( action )
  #
  # setupPanels
  #
  def setupPanels ( self ) :
    #
    self.tabifyDockWidget ( self.ui.dockNodes, self.ui.dockProject )

    self.tabifyDockWidget ( self.ui.dockPreview, self.ui.dockGeom  )
    self.tabifyDockWidget ( self.ui.dockParam, self.ui.dockSwatch )

    # temporary hide unused panels
    #self.removeDockWidget ( self.ui.dockGeom )
    #self.removeDockWidget ( self.ui.dockSwatch )
    self.ui.dockGeom.hide ()
    self.ui.dockSwatch.hide ()

    self.ui.dockNodes.raise_ ()
    self.ui.dockPreview.raise_ ()
    self.ui.dockParam.raise_ ()

    #self.addDockWidget ( QtCore.Qt.DockWidgetArea ( 2 ), self.ui.dockParam )
    #self.ui.dockParam.show ()
  #
  # addRecentProject
  #
  def addRecentProject ( self, project ) :
    #
    if project is not None :
      recent_projects_max = getDefaultValue ( app_settings, '', 'recent_projects_max' )

      if not self.recentProjects.contains ( project ) :
        self.recentProjects.prepend ( QtCore.QString ( project ) )

      while self.recentProjects.count () > recent_projects_max :
        self.recentProjects.takeLast ()

      recentProjects = QtCore.QVariant ( self.recentProjects ) if self.recentProjects else QtCore.QVariant ()
      app_settings.setValue ( 'RecentProjects', recentProjects )
  #
  # addRecentNetwork
  #
  def addRecentNetwork ( self, network ) :
    #
    if network is not None :
      recent_networks_max = getDefaultValue ( app_settings, '', 'recent_networks_max' )

      if not self.recentNetworks.contains ( network ) :
        self.recentNetworks.prepend ( QtCore.QString ( network ) )

      while self.recentNetworks.count () > recent_networks_max :
        self.recentNetworks.takeLast ()

      recentNetworks = QtCore.QVariant ( self.recentNetworks ) if self.recentNetworks else QtCore.QVariant ()
      app_settings.setValue ( 'RecentNetworks', recentNetworks )
  #
  # setupActions
  #
  def setupActions ( self ) :
    #
    #if DEBUG_MODE : print '>> MainWindow.setupActions'
    numNodes = 0
    numSelectedNodes = 0
    numSelectedLinks = 0
    selectedNodeType = None
    if self.workArea is not None :
      numNodes = len ( self.workArea.getAllGfxNodes () )
      numSelectedNodes = len ( self.workArea.selectedNodes )
      numSelectedLinks = len ( self.workArea.selectedLinks )
      if numSelectedNodes == 1 :
        selectedNodeType = self.getSelectedNode ().node.type
    enableForPaste = False

    if self.clipboard.ownsClipboard () or (sys.platform == 'darwin'):
      if DEBUG_MODE : print '** self.clipboard.ownsClipboard'
      data = self.clipboard.mimeData ()
      if data is not None :
        if data.hasText () :
          enableForPaste = True
          
    self.ui.actionExportShader.setEnabled ( selectedNodeType in VALID_RSL_SHADER_TYPES )
    self.ui.actionViewComputedCode.setEnabled ( selectedNodeType in VALID_RSL_NODE_TYPES or selectedNodeType in VALID_RIB_NODE_TYPES )
    self.ui.actionSaveSelected.setEnabled ( numSelectedNodes > 0 )
    self.ui.actionSelectAll.setEnabled ( numNodes > 0 )
    self.ui.actionSelectAbove.setEnabled ( numSelectedNodes == 1 )
    self.ui.actionSelectBelow.setEnabled ( numSelectedNodes == 1 )
    self.ui.actionDuplicate.setEnabled ( numSelectedNodes > 0 )
    self.ui.actionDuplicateWithLinks.setEnabled ( numSelectedNodes > 0 )
    self.ui.actionDelete.setEnabled ( ( numSelectedNodes > 0 ) or ( numSelectedLinks > 0 ) )
    self.ui.actionCut.setEnabled ( numSelectedNodes > 0 )
    self.ui.actionCopy.setEnabled ( numSelectedNodes > 0 )
    self.ui.actionPaste.setEnabled ( enableForPaste )
    self.ui.actionFitAll.setEnabled ( numNodes > 0 )
    self.ui.actionFitSelected.setEnabled ( numSelectedNodes > 0 )
  #
  # onProjectSetup
  #
  def onProjectSetup ( self ) :
    #
    if DEBUG_MODE : print ">> MainWindow.onProjectSetup"
    projectSetupDlg = ProjectSetup ( app_settings )
    projectSetupDlg.exec_()
    self.ui.project_ctl.setLibrary ( app_global_vars [ 'ProjectNetworks' ] )
    createDefaultProject ( app_settings )
    self.setupWindowTitle ()
    self.addRecentProject ( app_global_vars [ 'ProjectPath' ] )
    self.buildRecentProjectsMenu ()
  #
  # onSettingsSetup
  #
  def onSettingsSetup ( self ) :
    #
    if DEBUG_MODE : print '>> MainWindow.onSettingsSetup'
    settingsSetupDlg = SettingsSetup ( app_settings )
    settingsSetupDlg.exec_()
    self.ui.nodeList_ctl.setLibrary ( app_global_vars [ 'NodesPath' ] )
  #
  # onRenderSettings
  #
  def onRenderSettings ( self ) :
    #
    if DEBUG_MODE : print '>> MainWindow.onRenderSettings'
    renderSettingsDlg = meRendererSetup ( app_renderer )
    QtCore.QObject.connect ( renderSettingsDlg, QtCore.SIGNAL ( 'presetChanged' ), self.onRenderPresetChanged )
    QtCore.QObject.connect ( renderSettingsDlg, QtCore.SIGNAL ( 'savePreset' ), self.onRenderSavePreset )
    renderSettingsDlg.exec_ ()
  #
  # onRenderPresetChanged
  #
  def onRenderPresetChanged ( self ) :
    #
    presetName = app_renderer.getCurrentPresetName ()
    if DEBUG_MODE : print '>> MainWindow.onRenderPresetChanged preset = %s' % presetName
    #self.setWindowTitle ( 'meShaderEd %s (%s) %s' % ( app_global_vars [ 'version' ], presetName, app_global_vars [ 'ProjectNetworks' ] ) )
    app_settings.setValue ( 'defRenderer', presetName )

    app_global_vars [ 'RendererPreset' ] = presetName
    app_global_vars [ 'Renderer' ]       = app_renderer.getCurrentValue ( 'renderer', 'name' )
    app_global_vars [ 'RendererFlags' ]  = app_renderer.getCurrentValue ( 'renderer', 'flags' )
    app_global_vars [ 'ShaderCompiler' ] = app_renderer.getCurrentValue ( 'shader', 'compiler' )
    app_global_vars [ 'ShaderDefines' ]  = app_renderer.getCurrentValue ( 'shader', 'defines' )
    app_global_vars [ 'ShaderInfo' ]     = app_renderer.getCurrentValue ( 'shader', 'sloinfo' )
    app_global_vars [ 'TEX' ]            = app_renderer.getCurrentValue ( 'texture', 'extension' )
    app_global_vars [ 'SLO' ]            = app_renderer.getCurrentValue ( 'shader', 'extension' )
    app_global_vars [ 'TexMake' ]        = app_renderer.getCurrentValue ( 'texture', 'texmake' )
    self.setupWindowTitle ()
  #
  # onRenderSavePreset
  #
  def onRenderSavePreset ( self ) :
    #
    if DEBUG_MODE : print '>> MainWindow.onRenderSavePreset  preset = %s' % app_renderer.getCurrentPresetName()
    app_renderer.saveSettings ()
  #
  # onShowGrid
  #
  def onShowGrid ( self, check ) :
    #
    self.workArea.drawGrid = bool ( check )
    app_settings.beginGroup ( 'WorkArea' )
    app_settings.setValue ( 'grid_enabled', bool ( check ) )
    app_settings.endGroup ()

    self.workArea.resetCachedContent ()
    #self.ui.workArea.update()
  #
  # onSnapGrid
  #
  def onSnapGrid ( self, check ) :
    #
    self.workArea.gridSnap = bool ( check )
    app_settings.beginGroup ( 'WorkArea' )
    app_settings.setValue ( 'grid_snap', bool ( check ) )
    app_settings.endGroup ()
  #
  # onReverseFlow
  #
  def onReverseFlow ( self, check ) :
    #
    self.workArea.reverseFlow = bool ( check )
    app_settings.beginGroup ( 'WorkArea' )
    app_settings.setValue ( 'reverse_flow', bool ( check ) )
    app_settings.endGroup ()

    #self.ui.workArea.resetCachedContent()
  #
  # onStraightLinks
  #
  def onStraightLinks ( self, check ) :
    #
    self.workArea.straightLinks = bool ( check )
    app_settings.beginGroup ( 'WorkArea' )
    app_settings.setValue ( 'straight_links', bool ( check ) )
    app_settings.endGroup ()
    self.workArea.resetCachedContent ()
    self.workArea.adjustLinks ()
  #
  # setActiveNodeList
  #
  def setActiveNodeList ( self, nodeList ) :
    #
    if DEBUG_MODE : print '>> MainWindow.setActiveNodeList'
    if self.activeNodeList != None :
      QtCore.QObject.disconnect ( self.activeNodeList, QtCore.SIGNAL ( 'addNode' ), self.workArea.insertNodeNet  )
    self.activeNodeList = nodeList
    QtCore.QObject.connect ( self.activeNodeList, QtCore.SIGNAL ( 'addNode' ), self.workArea.insertNodeNet  )
  #
  # onGetNode
  #
  # Called by WorkArea after drag&drop event
  # Here we choose selected nodeList panel (Library or Project)
  # for processing node request
  #
  def onGetNode ( self, itemFilename, pos ) :
    #
    if self.activeNodeList != None : self.activeNodeList.onGetNode ( itemFilename, pos )
  #
  # onAddGfxNode
  #
  def onAddGfxNode ( self, gfxNode ) :
    #
    #print ">> MainWindow: onAddGfxNode = %s" % gfxNode.node.label
    if gfxNode.node.type == 'image' : self.ui.imageView_ctl.addViewer ( gfxNode )

      #if self.ui.nodeParam_ctl.receivers( QtCore.SIGNAL( 'onNodeParamChanged(QObject,QObject)' ) ) == 0 :
      #  QtCore.QObject.connect( self.ui.nodeParam_ctl, QtCore.SIGNAL( 'onNodeParamChanged(QObject,QObject)' ), self.ui.imageView_ctl.onNodeParamChanged )
      #else :
      #  print ">> MainWindow: nodeParam_ctl onNodeParamChanged already connected to imageView_ctl"
  #
  # onRemoveGfxNode
  #
  def onRemoveGfxNode ( self, gfxNode ) :
    #
    if DEBUG_MODE : print '>> MainWindow.onRemoveGfxNode = %s' % gfxNode.node.label
    if gfxNode.node.type == 'image' :
      self.ui.imageView_ctl.removeViewer ( gfxNode )
      #QtCore.QObject.disconnect ( self.ui.nodeParam_ctl, QtCore.SIGNAL ( 'onNodeParamChanged(QObject,QObject)' ), self.ui.imageView_ctl.onNodeParamChanged )
  #
  # getSelectedNode
  #
  def getSelectedNode ( self ) : return self.workArea.selectedNodes [0]
  #
  # onRenderPreview
  #
  def onRenderPreview ( self ) : print ">> MainWindow.onRenderPreview (not implemented yet...)"
  #
  # onShowSwatch
  #
  def onShowSwatch ( self ) : print ">> MainWindow.onShowSwatch (not implemented yet...)"
  #
  # onHideSwatch
  #
  def onHideSwatch ( self ) : print ">> MainWindow.onHideSwatch (not implemented yet...)"
  #
  # onCreateNode
  #
  def onCreateNode ( self ) : print ">> MainWindow.onCreateNode (not implemented yet...)"
  #
  # onExportShader
  #
  def onExportShader ( self ) : 
    #
    if DEBUG_MODE : print ">> MainWindow.onExportShader"
    gfxNode = self.getSelectedNode ()
    exportShaderDlg = ExportShaderDialog ( gfxNode.node )
    exportShaderDlg.exec_ ()
    if exportShaderDlg.ui.chk_save_changes.isChecked () :
      if DEBUG_MODE : print '>> MainWindow.exportShaderDlg save changes'
      gfxNode.updateGfxNode ( removeLinks = False )
      self.workArea.updateBelow ( gfxNode )
      self.updateNodeParamView ()
      self.workArea.scene().update ()
  #
  # onViewComputedCode
  #
  def onViewComputedCode ( self ) : ViewComputedCodeDialog ( self.getSelectedNode ().node ).exec_ ()
    
  #
  # onEditNode
  #
  def onEditNode ( self ) : 
    #
    if DEBUG_MODE : print ">> MainWindow.onEditNode"

    gfxNode = self.getSelectedNode ()
    editNode = gfxNode.node.copy ()

    dupNodeNet = NodeNetwork ( 'duplicate' )
    dupNodeNet.addNode ( editNode )
    #
    # copy input links to new node
    #
    if DEBUG_MODE : print '** duplicate input links ...'
    for link in gfxNode.node.getInputLinks () :
      newLink = link.copy ()
      newParam = editNode.getInputParamByName ( link.dstParam.name )
      newLink.setDst ( editNode, newParam )
      dupNodeNet.addLink ( newLink )

      newLink.printInfo ()
    #
    # copy output links to new node
    #
    if DEBUG_MODE : print '** duplicate output links ...'
    for link in gfxNode.node.getOutputLinks () :
      newLink = link.copy ()
      newParam = editNode.getOutputParamByName ( link.srcParam.name )
      newLink.setSrc ( editNode, newParam )
      dupNodeNet.addLink ( newLink )

      newLink.printInfo ()

    nodeEditDlg = NodeEditorDialog ( editNode )

    if nodeEditDlg.exec_ () == QtGui.QDialog.Accepted :
      #
      if DEBUG_MODE : print '>> MainWindow.nodeEditDlg Accepted'
      #
      # remove original node with links
      ( inputLinksToRemove, outputLinksToRemove ) = self.workArea.nodeNet.removeNode ( gfxNode.node )

      for link in inputLinksToRemove  : self.workArea.nodeNet.removeLink ( link  )
      for link in outputLinksToRemove : self.workArea.nodeNet.removeLink ( link  )

      # add duplicate network to current node net
      self.workArea.nodeNet.add ( dupNodeNet )

      if gfxNode.node.label != editNode.label :
        self.ui.imageView_ctl.onNodeLabelChanged ( gfxNode, editNode.label )

      # set new node to gfxNode.node
      gfxNode.node = editNode
      gfxNode.updateGfxNode ()
      for link in editNode.getInputLinks ()  : self.workArea.addGfxLink ( link  )
      for link in editNode.getOutputLinks () : self.workArea.addGfxLink ( link  )
      self.updateNodeParamView ()
      self.workArea.scene().update ()

    else :
      # remove duplicate node network
      dupNodeNet.clear ()
  #
  # onDelete
  #
  def onDelete ( self ) :
    #
    selected = self.workArea.scene ().selectedItems ()
    if len ( selected ) :
      self.workArea.removeSelected ()
    else :
      self.ui.imageView_ctl.removeAllViewers ()
      self.workArea.clear()
  #
  # onSelectAll
  #
  def onSelectAll ( self ) : self.workArea.selectAllNodes ()
  #
  # onSelectAbove
  #
  def onSelectAbove ( self ) : self.workArea.selectAbove ( self.getSelectedNode () )
  #
  # onSelectBelow
  #
  def onSelectBelow ( self ) : self.workArea.selectBelow ( self.getSelectedNode () )
  #
  # onCopy
  #
  def onCopy ( self ) :
    if DEBUG_MODE : print '>> MainWindow.onCopy'
    self.workArea.copyNodes ( self.clipboard, cutNodes = False )
    self.setupActions ()
  #
  # onCut
  #
  def onCut ( self ) :
     if DEBUG_MODE : print '>> MainWindow.onCut'
     self.workArea.copyNodes ( self.clipboard, cutNodes = True )
     self.setupActions ()
  #
  # onPaste
  #
  def onPaste ( self ) :
    if DEBUG_MODE : print '>> MainWindow.onPaste'
    self.workArea.pasteNodes ( self.clipboard )
  #
  # onDuplicate
  #
  def onDuplicate ( self ) : self.workArea.duplicateNodes ( preserveLinks = False )
  #
  # onDuplicateWithLinks
  #
  def onDuplicateWithLinks ( self ) : self.workArea.duplicateNodes ( preserveLinks = True )
  #
  # onSelectGfxNodes
  #
  def onSelectGfxNodes ( self, gfxNodes = [], gfxLinks = [] ) :
    #
    self.setupActions ()
    self.workArea.inspectedNode = None
    if len ( gfxNodes ) == 1 : self.workArea.inspectedNode = gfxNodes[ 0 ]

    self.ui.nodeParam_ctl.setNode ( self.workArea.inspectedNode )
  #
  # onNodeLabelChanged
  #
  def onNodeLabelChanged ( self, gfxNode, newLabel ) :
    #
    self.workArea.nodeNet.renameNodeLabel ( gfxNode.node, newLabel )
    gfxNode.updateNodeLabel ()
    self.ui.imageView_ctl.onNodeLabelChanged ( gfxNode, newLabel )
    self.workArea.scene ().update ()
  #
  # onNodeParamChanged
  #
  def onNodeParamChanged ( self, gfxNode, param ) :
    #
    if DEBUG_MODE : print ">> MainWindow.onNodeParamChanged"
    #param.shaderParam = not gfxNode.node.isInputParamLinked ( param )

    # from WorkArea we have GfxNode in signal nodeConnectionChanged
    # hence need to update nodeParam_ctl
    if isinstance ( gfxNode, GfxNote ) :
      #if DEBUG_MODE : print "* update GfxNote"
      gfxNode.updateGfxNode ()
      #node.update ()
      self.workArea.scene ().update ()
    elif isinstance ( gfxNode, GfxSwatchNode ) :
      if DEBUG_MODE : print "* update GfxSwatchNode"
      gfxNode.setupSwatchParams ()
      gfxNode.setupGeometry ()
      gfxNode.adjustLinks ()
      self.workArea.scene ().update ()
    elif isinstance ( gfxNode, GfxNode ) :
      if DEBUG_MODE : print "* update GfxNode"
      gfxNode.updateGfxNode ( removeLinks = False )
      self.updateNodeParamView ()

    if self.ui.imageView_ctl.autoUpdate () : self.ui.imageView_ctl.updateViewer()
  #
  # onGxNodeParamChanged
  #
  def onGfxNodeParamChanged ( self, gfxNode, param = None ) :
    #
    if DEBUG_MODE : print ">> MainWindow.onGxNodeParamChanged" 
    
    # from WorkArea we have GfxNode in signal nodeConnectionChanged
    # hence need to update nodeParam_ctl
    if isinstance ( gfxNode, GfxNode ) or isinstance ( gfxNode, GfxSwatchNode ) :
      #if DEBUG_MODE : print "* update nodeView"
      # gfxNode.updateInputParams ()
      self.updateNodeParamView ()
      self.workArea.scene ().update ()

    if self.ui.imageView_ctl.autoUpdate () : self.ui.imageView_ctl.updateViewer()
  #
  # updateNodeParamView
  #
  def updateNodeParamView ( self, gfxNode = None ) :
    #
    if DEBUG_MODE : 
      print '>> MainWindow.updateNodeParamView'
      if gfxNode is not None :
        print '** gfxNode = "%s"' % gfxNode.node.label
    self.ui.nodeParam_ctl.disconnectParamSignals ()
    self.ui.nodeParam_ctl.connectParamSignals ()
    self.ui.nodeParam_ctl.updateGui ()
  #
  # onFitAll
  #
  def onFitAll ( self ) : self.workArea.fitGfxNodesInView ( self.workArea.getAllGfxNodes () )
  #
  # onFitSelected
  #
  def onFitSelected ( self ) : self.workArea.fitGfxNodesInView ( self.workArea.selectedNodes )
  #
  # onZoomReset
  #
  def onZoomReset ( self ) : self.workArea.resetZoom ()
  #
  # onNewParamView
  #
  def onNewParamView ( self ) : print ">> MainWindow.onNewParamView (not implemented yet...)"
  #
  # onTabSelected
  #
  def onTabSelected ( self, idx ) :
    #
    if DEBUG_MODE : print '>> MainWindow.onTabSelected (%d)' % idx
    self.disconnectWorkAreaSignals ()
    self.ui.imageView_ctl.removeAllViewers ()
    self.workArea = self.ui.tabs.currentWidget ()

    imageNodes = self.workArea.getGfxNodesByType ( 'image' )
    # setup imageView menu for image nodes in new tab
    for gfxNode in imageNodes : self.ui.imageView_ctl.addViewer ( gfxNode )

    self.connectWorkAreaSignals ()
    self.ui.nodeParam_ctl.setNode ( self.workArea.inspectedNode )
    self.workArea.adjustLinks ()
  #
  # onTabCloseRequested
  #
  def onTabCloseRequested ( self, idx ) :
    #
    if DEBUG_MODE : print '>> MainWindow: onTabCloseRequested (%d)' % idx
    if self.ui.tabs.count () > 1 :
      self.workArea.nodeNet.clear ()
      self.ui.tabs.removeTab ( idx )
  #
  # onNew
  #
  def onNew ( self, tabName = 'untitled' ) :
    #
    def tabNameExists ( self, name ) :
      ret = False
      for i in range ( 0, self.ui.tabs.count () ) :
        if name == str ( self.ui.tabs.tabText ( i ) ):
          ret = True
          break
      return ret

    newName = tabName
    if DEBUG_MODE : print '->  self.ui.tabs.count() = %d ' % self.ui.tabs.count ()

    if self.workArea != None :
      if DEBUG_MODE : print '->  create new WorkArea widget'
      # set unique new name
      name = newName
      i = 0
      while True :
        if tabNameExists ( self, name ) :
          name = newName + str ( i )
          i += 1
          continue
        else :
          break
      newName = name
      workArea = WorkArea ()  # create new WorkArea instance
      newTab = self.ui.tabs.addTab ( workArea, newName )
    else :
      if DEBUG_MODE : print '->  use initial WorkArea widget'
      workArea = self.ui.workArea # use initial WorkArea widget
      self.workArea = workArea
      self.connectWorkAreaSignals ()

    nodeNet = NodeNetwork ( newName )
    workArea.setNodeNetwork ( nodeNet )

    self.ui.tabs.setTabText ( self.ui.tabs.indexOf ( workArea ), newName )
    self.ui.tabs.setCurrentIndex ( self.ui.tabs.indexOf ( workArea ) )
  #
  # onOpen
  #
  def onOpen ( self ) :
    #
    if DEBUG_MODE : print ">> MainWindow.onOpen"
    #
    curDir = app_global_vars [ 'ProjectNetworks' ]
    typeFilter = 'Shader networks *.xml;;All files *.*;;'

    filename = str ( QtGui.QFileDialog.getOpenFileName ( self, "Open file", curDir, typeFilter ) )
    if filename != '' :
      if self.openNetwork ( filename ) :
        self.addRecentNetwork ( normPath ( filename ) )
        self.buildRecentNetworksMenu ()
  #
  # openNetwork
  #
  def openNetwork ( self, filename ) :
    #
    ret = True
    if DEBUG_MODE : print "-> open file %s" %  filename
    if QtCore.QFile.exists ( filename ) :
      ( name, ext ) = os.path.splitext ( os.path.basename ( filename ) )

      self.ui.imageView_ctl.removeAllViewers ()

      self.workArea.clear ()
      self.workArea.nodeNet.name = name
      self.workArea.nodeNet.fileName = ''
      self.ui.tabs.setTabText ( self.ui.tabs.indexOf ( self.workArea ), name )

      self.workArea.openNodeNet ( normPath ( filename ) )
    else :
      print "ERROR! filename %s doesn't exist" %  filename
      ret = False
    return ret
  #
  # onOpenRecentNetwork
  #
  def onOpenRecentNetwork ( self ) :
    #
    action = self.sender ()
    if isinstance ( action, QtGui.QAction ):
      network = unicode ( action.data ().toString () )
      if network is not None :
        if DEBUG_MODE : print '>> onOpenRecentNetwork : %s' % network
        if not self.openNetwork ( network ) :
          # TODO!!! remove network from rescentNetworks
          pass
  #
  # onOpenRecentProject
  #
  def onOpenRecentProject ( self ) :
    #
    action = self.sender ()
    if isinstance ( action, QtGui.QAction ):
      project = unicode ( action.data ().toString () )
      if project is not None :
        print '>> onOpenRecentProject : %s' % project
        if openDefaultProject ( app_settings, app_global_vars, project ) :
          # very strange... app_settings doesn't update inside meCommon.openDefaultProject...
          # though app_global_vars does
          # have to duplicate this action here...
          app_settings.setValue ( 'project', app_global_vars [ 'ProjectPath' ] )
          app_settings.setValue ( 'project_shaders', app_global_vars [ 'ProjectShaders' ] )
          app_settings.setValue ( 'project_textures', app_global_vars [ 'ProjectTextures' ] )
          app_settings.setValue ( 'shader_networks', app_global_vars [ 'ProjectNetworks' ] )
          app_settings.setValue ( 'shader_sources', app_global_vars [ 'ProjectSources' ] )

          self.ui.project_ctl.setLibrary ( app_global_vars [ 'ProjectNetworks' ] )
          self.setupWindowTitle ()
        else :
          print "ERROR! project %s doesn't exist" %  project
          # TODO!!! remove project from rescentProjects
  #
  # onImport
  #
  def onImport ( self ) :
    #
    if DEBUG_MODE : print ">> MainWindow.onImport"
    #
    curDir = app_global_vars [ 'ProjectNetworks' ]
    typeFilter = 'Shader networks *.xml;;All files *.*;;'

    filename = str ( QtGui.QFileDialog.getOpenFileName ( self, "Import file", curDir, typeFilter ) )
    if filename != '' :
      if DEBUG_MODE : print "-> import file %s" %  filename
      self.workArea.insertNodeNet ( normPath ( filename ) )
  #
  # onSaveSelected
  #
  def onSaveSelected ( self ) :  
    #
    if DEBUG_MODE : print ">> MainWindow.onSaveSelected"
    singleNode = ( len ( self.workArea.selectedNodes ) == 1 )
    curDir = app_global_vars [ 'ProjectNetworks' ]
    saveName = os.path.join ( curDir, self.workArea.nodeNet.name + '.xml' )
    typeFilter = 'Shader networks *.xml;;All files *.*;;'

    filename = str( QtGui.QFileDialog.getSaveFileName ( self, "Save file as", saveName, typeFilter ) )
    if filename != '' :
      if DEBUG_MODE : print '-> save file As %s' % filename
      ( name, ext ) = os.path.splitext ( os.path.basename ( filename ) )
      if singleNode :
      # save single node
        print '*** save as single Node'
        gfxNode =  self.getSelectedNode ()
        saveNode = gfxNode.node.copy ()
        saveNode.name = name
        saveNode.master = normPath ( filename )
        saveNode.save ()
      else :
      # save selected as network
        print '*** save as nodenet'
        saveNodeNet = self.workArea.nodeNetFromSelected ( name )
        saveNodeNet.fileName = normPath ( filename ) 
        saveNodeNet.save ()
  #
  # onSave
  #
  def onSave ( self ) :
    #
    if DEBUG_MODE : print ">> MainWindow.onSave"
    # if file is new -- use onSaveAs function
    #
    curDir = app_global_vars [ 'ProjectNetworks' ]
    if self.workArea.nodeNet.fileName == '' :
      self.onSaveAs ()
    else :
      if DEBUG_MODE : print '-> save file %s' % self.workArea.nodeNet.fileName
      self.workArea.nodeNet.save ()
  
  #
  # onSaveAs
  #
  def onSaveAs ( self ) :
    #
    if DEBUG_MODE : print ">> MainWindow.onSaveAs"
    #
    curDir = app_global_vars [ 'ProjectNetworks' ]
    saveName = os.path.join ( curDir, self.workArea.nodeNet.name + '.xml' )
    typeFilter = 'Shader networks *.xml;;All files *.*;;'

    filename = str( QtGui.QFileDialog.getSaveFileName ( self, "Save file as", saveName, typeFilter ) )
    if filename != '' :
      if DEBUG_MODE : print '-> save file As %s' % filename
      ( name, ext ) = os.path.splitext ( os.path.basename ( filename ) )
      self.workArea.nodeNet.fileName = normPath ( filename )
      self.workArea.nodeNet.name = name
      self.ui.tabs.setTabText ( self.ui.tabs.indexOf ( self.workArea ), name )
      self.workArea.nodeNet.save ()
      self.addRecentNetwork ( normPath ( filename ) )
      self.buildRecentNetworksMenu ()
      self.ui.project_ctl.onReload ()
  #
  # onHelpNode
  #
  def onHelpMode ( self, showWhatsThis ) :
    #
    #if showWhatsThis :
    QtGui.QWhatsThis.enterWhatsThisMode ()
Пример #38
0
  def __init__ ( self ) :
    #
    QtGui.QMainWindow.__init__ ( self )

    self.ui = Ui_MainWindow ()
    self.ui.setupUi ( self )
    #
    # setup WhatsThis help action
    #
    self.ui.actionHelpMode = QtGui.QWhatsThis.createAction ( )
    self.ui.actionHelpMode.setToolTip ( 'Enter "WhatsThis" help mode' )
    self.ui.menuHelp.addAction ( self.ui.actionHelpMode )
    self.ui.toolBar.addSeparator()
    self.ui.toolBar.addAction ( self.ui.actionHelpMode )
    QtCore.QObject.connect ( self.ui.actionHelpMode, QtCore.SIGNAL ( 'toggled(bool)' ), self.onHelpMode )
    
    self.clipboard = QtGui.QApplication.clipboard ()

    self.recentProjects = app_settings.value ( 'RecentProjects' ).toStringList ()
    self.recentNetworks = app_settings.value ( 'RecentNetworks' ).toStringList ()

    self.addRecentProject ( app_global_vars [ 'ProjectPath' ] )

    self.setupMenuBar ()
    self.setupPanels ()

    self.activeNodeList = None
    self.workArea = None # current work area
    self.onNew () # create new document

    grid_enabled = getDefaultValue ( app_settings, 'WorkArea', 'grid_enabled' )
    grid_snap = getDefaultValue ( app_settings, 'WorkArea', 'grid_snap' )
    grid_size = int ( getDefaultValue ( app_settings, 'WorkArea', 'grid_size' )  )
    reverse_flow = getDefaultValue ( app_settings, 'WorkArea', 'reverse_flow' )
    straight_links = getDefaultValue ( app_settings, 'WorkArea', 'straight_links' )

    #self.ui.workArea.gridSize = grid_size
    #self.ui.workArea.gridSnap = grid_snap
    self.workArea.drawGrid = grid_enabled
    #self.ui.workArea.reverseFlow = reverse_flow
    #self.ui.workArea.straightLinks = straight_links

    self.ui.actionShowGrid.setChecked ( grid_enabled )
    self.ui.actionSnapGrid.setChecked ( grid_snap )
    self.ui.actionReverseFlow.setChecked ( reverse_flow )
    self.ui.actionStraightLinks.setChecked ( straight_links )

    self.ui.nodeList_ctl.setLibrary ( app_global_vars [ 'NodesPath' ] )
    self.ui.project_ctl.setLibrary ( app_global_vars [ 'ProjectNetworks' ] )

    #self.ui.dockNodes.setWindowTitle ( 'Library: %s' % app_global_vars [ 'NodesPath' ] )
    #self.ui.dockProject.setWindowTitle ( 'Project: %s' % app_global_vars [ 'ProjectNetworks' ] )

    QtCore.QObject.connect ( self.ui.nodeList_ctl.ui.nodeList, QtCore.SIGNAL ( 'setActiveNodeList' ), self.setActiveNodeList )
    QtCore.QObject.connect ( self.ui.project_ctl.ui.nodeList, QtCore.SIGNAL ( 'setActiveNodeList' ), self.setActiveNodeList )

    QtCore.QObject.connect ( self.ui.tabs, QtCore.SIGNAL ( 'currentChanged(int)' ), self.onTabSelected )
    QtCore.QObject.connect ( self.ui.tabs, QtCore.SIGNAL ( 'tabCloseRequested(int)' ), self.onTabCloseRequested )

    QtCore.QObject.connect ( self.ui.nodeParam_ctl, QtCore.SIGNAL ( 'nodeLabelChanged' ), self.onNodeLabelChanged  )
    QtCore.QObject.connect ( self.ui.nodeParam_ctl, QtCore.SIGNAL ( 'nodeParamChanged' ), self.onNodeParamChanged  )

    self.setupActions ()
    self.setupWindowTitle ()
Пример #39
0
class MainWindow(QtGui.QMainWindow):
    """ Class of Main Window (top)
    """
    def __init__(self, parent=None):
        """ Initialization and set up
        """
        # Base class
        QtGui.QMainWindow.__init__(self,parent)

        # UI Window (from Qt Designer)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        # Make UI scrollable
        self._scrollbars = MantidQt.API.WidgetScrollbarDecorator(self)
        self._scrollbars.setEnabled(True) # Must follow after setupUi(self)!

        # Mantid configuration
        self._instrument = str(self.ui.comboBox_instrument.currentText())
        # config = ConfigService.Instance()
        # self._instrument = config["default.instrument"]

        # Event handling definitions
        # Top
        self.connect(self.ui.pushButton_setExp, QtCore.SIGNAL('clicked()'),
                     self.do_set_experiment)

        # Tab 'Data Access'
        self.connect(self.ui.pushButton_applySetup, QtCore.SIGNAL('clicked()'),
                     self.do_apply_setup)
        self.connect(self.ui.pushButton_browseLocalDataDir, QtCore.SIGNAL('clicked()'),
                     self.do_browse_local_spice_data)
        self.connect(self.ui.pushButton_testURLs, QtCore.SIGNAL('clicked()'),
                     self.do_test_url)
        self.connect(self.ui.pushButton_ListScans, QtCore.SIGNAL('clicked()'),
                     self.do_list_scans)
        self.connect(self.ui.pushButton_downloadExpData, QtCore.SIGNAL('clicked()'),
                     self.do_download_spice_data)
        self.connect(self.ui.comboBox_mode, QtCore.SIGNAL('currentIndexChanged(int)'),
                     self.change_data_access_mode)

        # Tab 'View Raw Data'
        self.connect(self.ui.pushButton_setScanInfo, QtCore.SIGNAL('clicked()'),
                     self.do_load_scan_info)
        self.connect(self.ui.pushButton_plotRawPt, QtCore.SIGNAL('clicked()'),
                     self.do_plot_pt_raw)
        self.connect(self.ui.pushButton_prevPtNumber, QtCore.SIGNAL('clicked()'),
                     self.do_plot_prev_pt_raw)
        self.connect(self.ui.pushButton_nextPtNumber, QtCore.SIGNAL('clicked()'),
                     self.do_plot_next_pt_raw)
        self.connect(self.ui.pushButton_showPtList, QtCore.SIGNAL('clicked()'),
                     self.show_scan_pt_list)
        self.connect(self.ui.pushButton_usePt4UB, QtCore.SIGNAL('clicked()'),
                     self.do_add_peak_to_find)

        # Tab 'calculate ub matrix'
        self.connect(self.ui.pushButton_findPeak, QtCore.SIGNAL('clicked()'),
                     self.do_find_peak)
        self.connect(self.ui.pushButton_addPeakToCalUB, QtCore.SIGNAL('clicked()'),
                     self.do_add_ub_peak)
        self.connect(self.ui.pushButton_calUB, QtCore.SIGNAL('clicked()'),
                     self.do_cal_ub_matrix)
        self.connect(self.ui.pushButton_acceptUB, QtCore.SIGNAL('clicked()'),
                     self.doAcceptCalUB)
        self.connect(self.ui.pushButton_indexUBPeaks, QtCore.SIGNAL('clicked()'),
                     self.do_index_ub_peaks)
        self.connect(self.ui.pushButton_deleteUBPeak, QtCore.SIGNAL('clicked()'),
                     self.do_del_ub_peaks)
        self.connect(self.ui.pushButton_clearUBPeakTable, QtCore.SIGNAL('clicked()'),
                     self.do_clear_ub_peaks)
        self.connect(self.ui.pushButton_resetPeakHKLs, QtCore.SIGNAL('clicked()'),
                     self.do_reset_ub_peaks_hkl)

        # Tab 'Slice View'
        self.connect(self.ui.pushButton_setUBSliceView, QtCore.SIGNAL('clicked()'),
                     self.do_set_ub_sv)
        self.connect(self.ui.pushButton_process4SliceView, QtCore.SIGNAL('clicked()'),
                     self.do_merge_scans)

        # Tab 'Advanced'
        self.connect(self.ui.pushButton_useDefaultDir, QtCore.SIGNAL('clicked()'),
                     self.do_setup_dir_default)
        self.connect(self.ui.pushButton_browseLocalCache, QtCore.SIGNAL('clicked()'),
                     self.do_browse_local_cache_dir)
        self.connect(self.ui.pushButton_browseWorkDir, QtCore.SIGNAL('clicked()'),
                     self.do_browse_working_dir)
        self.connect(self.ui.comboBox_instrument, QtCore.SIGNAL('currentIndexChanged(int)'),
                     self.change_instrument_name)

        # Refine UB matrix
        self.connect(self.ui.pushButton_addToRefine, QtCore.SIGNAL('clicked()'),
                     self.do_refine_ub)
        self.connect(self.ui.pushButton_addAllRefineUB, QtCore.SIGNAL('clicked()'),
                     self.do_refine_ub)
        self.connect(self.ui.pushButton_acceptRefinedUB, QtCore.SIGNAL('clicked()'),
                     self.do_refine_ub)
        self.connect(self.ui.pushButton_resetRefinedUB, QtCore.SIGNAL('clicked()'),
                     self.do_refine_ub)

        # Tab 'Integrate Peaks'
        self.connect(self.ui.pushButton_integratePeak, QtCore.SIGNAL('clicked()'),
                     self.do_integrate_peaks)

        # Menu
        self.connect(self.ui.actionExit, QtCore.SIGNAL('triggered()'),
                     self.menu_quit)

        self.connect(self.ui.actionSave_Session, QtCore.SIGNAL('triggered()'),
                     self.save_current_session)
        self.connect(self.ui.actionLoad_Session, QtCore.SIGNAL('triggered()'),
                     self.load_session)

        # Event handling for tab 'refine ub matrix'
        self.connect(self.ui.pushButton_addToRefine, QtCore.SIGNAL('clicked()'),
                     self.doAddScanPtToRefineUB)

        # Validator ... (NEXT)

        # Declaration of class variable
        # some configuration
        self._homeSrcDir = os.getcwd()
        self._homeDir = os.getcwd()

        # Control
        self._myControl = r4c.CWSCDReductionControl(self._instrument)
        self._allowDownload = True
        self._dataAccessMode = 'Download'

        # Initial setup
        self.ui.tabWidget.setCurrentIndex(0)
        self.ui.tabWidget.setTabEnabled(4, False)
        self.ui.tabWidget.setTabEnabled(5, False)
        self._init_ub_table()
        self.ui.radioButton_ubFromTab1.setChecked(True)

        # Tab 'Access'
        self.ui.lineEdit_url.setText('http://neutron.ornl.gov/user_data/hb3a/')
        self.ui.comboBox_mode.setCurrentIndex(0)
        self.ui.lineEdit_localSpiceDir.setEnabled(True)
        self.ui.pushButton_browseLocalDataDir.setEnabled(True)

        return

    def do_integrate_peaks(self):
        """

        :return:
        """
        raise RuntimeError('ASAP')

    def do_refine_ub(self):
        """

        :return:
        """
        raise RuntimeError('Next Release')

    def _init_ub_table(self):
        """ DOC
        :return:
        """
        # UB-peak table
        # NOTE: have to call this because pyqt set column and row to 0 after __init__
        #       thus a 2-step initialization has to been adopted
        self.ui.tableWidget_peaksCalUB.setup()

        self.ui.tableWidget_ubMatrix.setup()
        self.ui.tableWidget_ubSiceView.setup()
        self.ui.tableWidget_refinedUB.setup()

        self.ui.tableWidget_sliceViewProgress.setup()

        return

    def change_data_access_mode(self):
        """ Change data access mode between downloading from server and local
        Event handling methods
        :return:
        """
        new_mode = str(self.ui.comboBox_mode.currentText())
        self._dataAccessMode = new_mode

        if new_mode.startswith('Local') is True:
            self.ui.lineEdit_localSpiceDir.setEnabled(True)
            self.ui.pushButton_browseLocalDataDir.setEnabled(True)
            self.ui.lineEdit_url.setEnabled(False)
            self.ui.lineEdit_localSrcDir.setEnabled(False)
            self.ui.pushButton_browseLocalCache.setEnabled(False)
            self._allowDownload = False
        else:
            self.ui.lineEdit_localSpiceDir.setEnabled(False)
            self.ui.pushButton_browseLocalDataDir.setEnabled(False)
            self.ui.lineEdit_url.setEnabled(True)
            self.ui.lineEdit_localSrcDir.setEnabled(True)
            self.ui.pushButton_browseLocalCache.setEnabled(True)
            self._allowDownload = True

        return

    def change_instrument_name(self):
        """ Handing the event as the instrument name is changed
        :return:
        """
        new_instrument = str(self.ui.comboBox_instrument.currentText())
        self.pop_one_button_dialog('Change of instrument during data processing is dangerous.')
        status, error_message = self._myControl.set_instrument_name(new_instrument)
        if status is False:
            self.pop_one_button_dialog(error_message)

        return

    def do_add_ub_peak(self):
        """ Add current to ub peaks
        :return:
        """
        # Add peak
        status, int_list = gutil.parse_integers_editors([self.ui.lineEdit_exp,
                                                         self.ui.lineEdit_scanNumber,
                                                         self.ui.lineEdit_ptNumber])
        if status is False:
            self.pop_one_button_dialog(int_list)
        exp_no, scan_no, pt_no = int_list

        # Get HKL from GUI
        status, float_list = gutil.parse_float_editors([self.ui.lineEdit_H,
                                                        self.ui.lineEdit_K,
                                                        self.ui.lineEdit_L])
        if status is False:
            err_msg = float_list
            self.pop_one_button_dialog(err_msg)
            return
        h, k, l = float_list

        status, peak_info_obj = self._myControl.get_peak_info(exp_no, scan_no, pt_no)
        if status is False:
            error_message = peak_info_obj
            self.pop_one_button_dialog(error_message)
            return
        assert isinstance(peak_info_obj, r4c.PeakInfo)

        if self.ui.checkBox_roundHKLInt.isChecked():
            h = math.copysign(1, h)*int(abs(h)+0.5)
            k = math.copysign(1, k)*int(abs(k)+0.5)
            l = math.copysign(1, l)*int(abs(l)+0.5)
        peak_info_obj.set_user_hkl(h, k, l)
        self.set_ub_peak_table(peak_info_obj)

        # Clear
        self.ui.lineEdit_scanNumber.setText('')
        self.ui.lineEdit_ptNumber.setText('')

        self.ui.lineEdit_sampleQx.setText('')
        self.ui.lineEdit_sampleQy.setText('')
        self.ui.lineEdit_sampleQz.setText('')

        self.ui.lineEdit_H.setText('')
        self.ui.lineEdit_K.setText('')
        self.ui.lineEdit_L.setText('')

        return

    def doAcceptCalUB(self):
        """ Accept the calculated UB matrix
        """
        raise RuntimeError('ASAP')
        return

    def doAddScanPtToRefineUB(self):
        """ Add scan/pt numbers to the list of data points for refining ub matrix

        And the added scan number and pt numbers will be reflected in the (left sidebar)

        """
        raise RuntimeError("ASAP")

    def do_add_peak_to_find(self):
        """
        Add the scan/pt to the next
        :return:
        """
        scan_no = self.ui.lineEdit_run.text()
        pt_no = self.ui.lineEdit_rawDataPtNo.text()

        self.ui.lineEdit_scanNumber.setText(scan_no)
        self.ui.lineEdit_ptNumber.setText(pt_no)

        self.ui.tabWidget.setCurrentIndex(2)

    def do_browse_local_cache_dir(self):
        """ Browse local cache directory
        :return:
        """
        local_cache_dir = str(QtGui.QFileDialog.getExistingDirectory(self,
                                                                     'Get Local Cache Directory',
                                                                     self._homeSrcDir))

        # Set local directory to control
        status, error_message = self._myControl.set_local_data_dir(local_cache_dir)
        if status is False:
            self.pop_one_button_dialog(error_message)
            return

        # Synchronize to local data/spice directory and local cache directory
        if str(self.ui.lineEdit_localSpiceDir.text()) != '':
            prev_dir = str(self.ui.lineEdit_localSrcDir.text())
            self.pop_one_button_dialog('Local data directory was set up as %s' %
                                       prev_dir)
        self.ui.lineEdit_localSrcDir.setText(local_cache_dir)
        self.ui.lineEdit_localSpiceDir.setText(local_cache_dir)

        return

    def do_browse_local_spice_data(self):
        """ Browse local source SPICE data directory
        """
        src_spice_dir = str(QtGui.QFileDialog.getExistingDirectory(self, 'Get Directory',
                                                                   self._homeSrcDir))
        # Set local data directory to controller
        status, error_message = self._myControl.set_local_data_dir(src_spice_dir)
        if status is False:
            self.pop_one_button_dialog(error_message)
            return

        self._homeSrcDir = src_spice_dir
        self.ui.lineEdit_localSpiceDir.setText(src_spice_dir)

        return

    def do_browse_working_dir(self):
        """
        Browse and set up working directory
        :return:
        """
        work_dir = str(QtGui.QFileDialog.getExistingDirectory(self, 'Get Working Directory', self._homeDir))
        status, error_message = self._myControl.set_working_directory(work_dir)
        if status is False:
            self.pop_one_button_dialog(error_message)
        else:
            self.ui.lineEdit_workDir.setText(work_dir)

        return

    def do_cal_ub_matrix(self):
        """ Calculate UB matrix by 2 or 3 reflections
        """
        # Get reflections
        num_rows = self.ui.tableWidget_peaksCalUB.rowCount()
        peak_info_list = list()
        status, exp_number = gutil.parse_integers_editors(self.ui.lineEdit_exp)
        for i_row in xrange(num_rows):
            if self.ui.tableWidget_peaksCalUB.is_selected(i_row) is True:
                scan_num, pt_num = self.ui.tableWidget_peaksCalUB.get_exp_info(i_row)
                status, peak_info = self._myControl.get_peak_info(exp_number, scan_num, pt_num)
                peak_info.set_peak_ws_hkl_from_user()
                if status is False:
                    self.pop_one_button_dialog(peak_info)
                    return
                assert isinstance(peak_info, r4c.PeakInfo)
                peak_info_list.append(peak_info)
        # END-FOR

        # Get lattice
        status, ret_obj = self._get_lattice_parameters()
        if status is True:
            a, b, c, alpha, beta, gamma = ret_obj
        else:
            err_msg = ret_obj
            self.pop_one_button_dialog(err_msg)
            return

        # Calculate UB matrix
        status, ub_matrix = self._myControl.calculate_ub_matrix(peak_info_list, a, b, c,
                                                                alpha, beta, gamma)

        # Deal with result
        if status is True:
            self._show_ub_matrix(ub_matrix)
        else:
            err_msg = ub_matrix
            self.pop_one_button_dialog(err_msg)

        return

    def do_clear_ub_peaks(self):
        """
        Clear all peaks in UB-Peak table
        :return:
        """
        self.ui.tableWidget_peaksCalUB.clear()

        return

    def do_del_ub_peaks(self):
        """
        Delete a peak in UB-Peak table
        :return:
        """
        # Find out the lines to get deleted
        row_num_list = self.ui.tableWidget_peaksCalUB.get_selected_rows()
        print '[DB] Row %s are selected' % str(row_num_list)

        # Delete
        self.ui.tableWidget_peaksCalUB.delete_rows(row_num_list)

        return

    def do_download_spice_data(self):
        """ Download SPICE data
        :return:
        """
        # Check scans to download
        scan_list_str = str(self.ui.lineEdit_downloadScans.text())
        if len(scan_list_str) > 0:
            # user specifies scans to download
            valid, scan_list = fcutil.parse_int_array(scan_list_str)
            if valid is False:
                error_message = scan_list
                self.pop_one_button_dialog(error_message)
        else:
            # Get all scans
            status, ret_obj = gutil.parse_integers_editors([self.ui.lineEdit_exp])
            if status is False:
                self.pop_one_button_dialog(ret_obj)
                return
            exp_no = ret_obj
            assert isinstance(exp_no, int)
            server_url = str(self.ui.lineEdit_url.text())
            scan_list = fcutil.get_scans_list(server_url, exp_no, return_list=True)
        self.pop_one_button_dialog('Going to download scans %s.' % str(scan_list))

        # Check location
        destination_dir = str(self.ui.lineEdit_localSrcDir.text())
        status, error_message = self._myControl.set_local_data_dir(destination_dir)
        if status is False:
            self.pop_one_button_dialog(error_message)
        else:
            self.pop_one_button_dialog('Spice files will be downloaded to %s.' % destination_dir)

        # Set up myControl for downloading data
        exp_no = int(self.ui.lineEdit_exp.text())
        self._myControl.set_exp_number(exp_no)

        server_url = str(self.ui.lineEdit_url.text())
        status, error_message = self._myControl.set_server_url(server_url)
        if status is False:
            self.pop_one_button_dialog(error_message)
            return

        # Download
        self._myControl.download_data_set(scan_list)

        return

    def do_find_peak(self):
        """ Find peak in a given scan/pt and record it
        """
        # Get experiment, scan and pt
        status, ret_obj = gutil.parse_integers_editors([self.ui.lineEdit_exp,
                                                        self.ui.lineEdit_scanNumber,
                                                        self.ui.lineEdit_ptNumber])
        if status is True:
            exp_no, scan_no, pt_no = ret_obj
        else:
            self.pop_one_button_dialog(ret_obj)
            return

        # Find peak
        status, err_msg = self._myControl.find_peak(exp_no, scan_no, pt_no)
        if status is False:
            self.pop_one_button_dialog(ret_obj)
            return
        if self.ui.checkBox_loadHKLfromFile.isChecked() is True:
            # This is the first time that in the workflow to get HKL from MD workspace
            status, err_msg = self._myControl.set_hkl_to_peak(exp_no, scan_no, pt_no)
            if status is False:
                self.pop_one_button_dialog('Unable to locate peak info due to %s.' % err_msg)

        # Set up correct values to table tableWidget_peaksCalUB
        self._myControl.add_peak_info(exp_no, scan_no, pt_no)
        status, peak_info = self._myControl.get_peak_info(exp_no, scan_no, pt_no)
        if status is False:
            err_msg = peak_info
            raise KeyError(err_msg)
        assert isinstance(peak_info, r4c.PeakInfo)

        # Set the HKL value from PeakInfo directly
        # BAD PROGRAMMING! THERE ARE TOO MANY WAYS TO ACCESS STORED HKL
        h, k, l = peak_info.get_peak_ws_hkl()
        self.ui.lineEdit_H.setText('%.2f' % h)
        self.ui.lineEdit_K.setText('%.2f' % k)
        self.ui.lineEdit_L.setText('%.2f' % l)

        q_sample = peak_info.getQSample()
        self.ui.lineEdit_sampleQx.setText('%.5E' % q_sample[0])
        self.ui.lineEdit_sampleQy.setText('%.5E' % q_sample[1])
        self.ui.lineEdit_sampleQz.setText('%.5E' % q_sample[2])

        # self.set_ub_peak_table(peak_info)

        return

    def do_index_ub_peaks(self):
        """ Index the peaks in the UB matrix peak table
        :return:
        """
        # Get UB matrix
        ub_matrix = self.ui.tableWidget_ubMatrix.get_matrix()
        print '[DB] Get UB matrix ', ub_matrix

        # Do it for each peak
        num_peaks = self.ui.tableWidget_peaksCalUB.rowCount()
        err_msg = ''
        for i_peak in xrange(num_peaks):
            scan_no, pt_no = self.ui.tableWidget_peaksCalUB.get_exp_info(i_peak)
            status, ret_obj = self._myControl.index_peak(ub_matrix, scan_number=scan_no,
                                                         pt_number=pt_no)
            if status is True:
                new_hkl = ret_obj[0]
                error = ret_obj[1]
                self.ui.tableWidget_peaksCalUB.set_hkl(i_peak, new_hkl, error)
            else:
                err_msg += ret_obj + '\n'
        # END-FOR

        if len(err_msg) > 0:
            self.pop_one_button_dialog(err_msg)

        return

    def do_list_scans(self):
        """ List all scans available
        :return:
        """
        # Experiment number
        exp_no = int(self.ui.lineEdit_exp.text())

        access_mode = str(self.ui.comboBox_mode.currentText())
        if access_mode == 'Local':
            spice_dir = str(self.ui.lineEdit_localSpiceDir.text())
            message = fcutil.get_scans_list_local_disk(spice_dir, exp_no)
        else:
            url = str(self.ui.lineEdit_url.text())
            message = fcutil.get_scans_list(url, exp_no)

        self.pop_one_button_dialog(message)

        return

    def do_load_scan_info(self):
        """ Load SIICE's scan file
        :return:
        """
        # Get scan number
        status, ret_obj = gutil.parse_integers_editors([self.ui.lineEdit_run])
        if status is True:
            scan_no = ret_obj[0]
        else:
            err_msg = ret_obj
            self.pop_one_button_dialog('Unable to get scan number in raw data tab due to %s.' % err_msg)
            return

        status, err_msg = self._myControl.load_spice_scan_file(exp_no=None, scan_no=scan_no)
        if status is False:
            self.pop_one_button_dialog(err_msg)

        return

    def do_plot_pt_raw(self):
        """ Plot the Pt.
        """
        # Get measurement pt and the file number
        status, ret_obj = gutil.parse_integers_editors([self.ui.lineEdit_exp,
                                                        self.ui.lineEdit_run,
                                                        self.ui.lineEdit_rawDataPtNo])
        if status is True:
            exp_no = ret_obj[0]
            scan_no = ret_obj[1]
            pt_no = ret_obj[2]
        else:
            self.pop_one_button_dialog(ret_obj)
            return

        # Call to plot 2D
        self._plot_raw_xml_2d(exp_no, scan_no, pt_no)

        return

    def do_plot_prev_pt_raw(self):
        """ Plot the Pt.
        """
        # Get measurement pt and the file number
        status, ret_obj = gutil.parse_integers_editors([self.ui.lineEdit_exp,
                                                        self.ui.lineEdit_run,
                                                        self.ui.lineEdit_rawDataPtNo])
        if status is True:
            exp_no = ret_obj[0]
            scan_no = ret_obj[1]
            pt_no = ret_obj[2]
        else:
            self.pop_one_button_dialog(ret_obj)
            return

        # Previous one
        pt_no -= 1
        if pt_no <= 0:
            self.pop_one_button_dialog('Pt. = 1 is the first one.')
            return
        else:
            self.ui.lineEdit_rawDataPtNo.setText('%d' % pt_no)

        # Plot
        self._plot_raw_xml_2d(exp_no, scan_no, pt_no)

        return

    def do_plot_next_pt_raw(self):
        """ Plot the Pt.
        """
        # Get measurement pt and the file number
        status, ret_obj = gutil.parse_integers_editors([self.ui.lineEdit_exp,
                                                        self.ui.lineEdit_run,
                                                        self.ui.lineEdit_rawDataPtNo])
        if status is True:
            exp_no = ret_obj[0]
            scan_no = ret_obj[1]
            pt_no = ret_obj[2]
        else:
            self.pop_one_button_dialog(ret_obj)
            return

        # Previous one
        pt_no += 1
        # get last Pt. number
        status, last_pt_no = self._myControl.get_pt_numbers(exp_no, scan_no)
        if status is False:
            error_message = last_pt_no
            self.pop_one_button_dialog('Unable to access Spice table for scan %d. Reason" %s.' % (
                scan_no, error_message))
        if pt_no > last_pt_no:
            self.pop_one_button_dialog('Pt. = %d is the last one of scan %d.' % (pt_no, scan_no))
            return
        else:
            self.ui.lineEdit_rawDataPtNo.setText('%d' % pt_no)

        # Plot
        self._plot_raw_xml_2d(exp_no, scan_no, pt_no)

        return

    def do_merge_scans(self):
        """ Process data for slicing view
        :return:
        """
        # Get UB matrix
        ub_matrix = self.ui.tableWidget_ubSiceView.get_matrix()
        self._myControl.set_ub_matrix(exp_number=None, ub_matrix=ub_matrix)

        # Get list of scans
        scan_list = gutil.parse_integer_list(str(self.ui.lineEdit_listScansSliceView.text()))
        if len(scan_list) == 0:
            self.pop_one_button_dialog('Scan list is empty.')

        # Set table
        self.ui.tableWidget_sliceViewProgress.append_scans(scans=scan_list)

        # Warning
        self.pop_one_button_dialog('Data processing is long. Be patient!')

        # Process
        base_name = str(self.ui.lineEdit_baseMergeMDName.text())
        scan_list.sort()
        frame = str(self.ui.comboBox_mergeScanFrame.currentText())
        for scan_no in scan_list:
            # Download/check SPICE file
            self._myControl.download_spice_file(None, scan_no, over_write=False)

            # Get some information
            status, pt_list = self._myControl.get_pt_numbers(None, scan_no, load_spice_scan=True)
            if status is False:
                err_msg = pt_list
                self.pop_one_button_dialog('Failed to get Pt. number: %s' % err_msg)
                return
            else:
                # Set information to table
                err_msg = self.ui.tableWidget_sliceViewProgress.set_scan_pt(scan_no, pt_list)
                if len(err_msg) > 0:
                    self.pop_one_button_dialog(err_msg)

            out_ws_name = base_name + '%04d' % scan_no
            self.ui.tableWidget_sliceViewProgress.set_scan_pt(scan_no, 'In Processing')
            try:
                ret_tup = self._myControl.merge_pts_in_scan(exp_no=None, scan_no=scan_no,
                                                            target_ws_name=out_ws_name,
                                                            target_frame=frame)
                merge_status = 'Done'
                merged_name = ret_tup[0]
                group_name = ret_tup[1]
            except RuntimeError as e:
                merge_status = 'Failed. Reason: %s' % str(e)
                merged_name = ''
                group_name = ''
            finally:
                self.ui.tableWidget_sliceViewProgress.set_status(scan_no, merge_status)
                self.ui.tableWidget_sliceViewProgress.set_ws_names(scan_no, merged_name, group_name)

            # Sleep for a while
            time.sleep(0.1)
        # END-FOR

        return

    def do_reset_ub_peaks_hkl(self):
        """
        Reset user specified HKL value to peak table
        :return:
        """
        num_rows = self.ui.tableWidget_peaksCalUB.rowCount()
        for i_row in xrange(num_rows):
            print '[DB] Update row %d' % (i_row)
            scan, pt = self.ui.tableWidget_peaksCalUB.get_scan_pt(i_row)
            status, peak_info = self._myControl.get_peak_info(None, scan, pt)
            if status is False:
                error_message = peak_info
                raise RuntimeError(error_message)
            h, k, l = peak_info.get_user_hkl()
            self.ui.tableWidget_peaksCalUB.update_hkl(i_row, h, k, l)
        # END-FOR

        return

    def do_set_experiment(self):
        """ Set experiment
        :return:
        """
        status, ret_obj = gutil.parse_integers_editors([self.ui.lineEdit_exp])
        if status is True:
            exp_number = ret_obj[0]
            curr_exp_number = self._myControl.get_experiment()
            if curr_exp_number is not None and exp_number != curr_exp_number:
                self.pop_one_button_dialog('Changing experiment to %d.  Clean previous experiment %d\'s result'
                                           ' in Mantid manually.' % (exp_number, curr_exp_number))
            self._myControl.set_exp_number(exp_number)
            self.ui.lineEdit_exp.setStyleSheet('color: black')
        else:
            err_msg = ret_obj
            self.pop_one_button_dialog('Unable to set experiment as %s' % err_msg)
            self.ui.lineEdit_exp.setStyleSheet('color: red')

        self.ui.tabWidget.setCurrentIndex(0)

        return

    def do_set_ub_sv(self):
        """ Set UB matrix in Slice view
        :return:
        """
        if self.ui.radioButton_ubFromTab1.isChecked():
            self.ui.tableWidget_ubSiceView.set_from_matrix(self.ui.tableWidget_ubMatrix.get_matrix())
        elif self.ui.radioButton_ubFromTab3.isChecked():
            self.ui.tableWidget_ubSiceView.set_from_matrix(self.ui.tableWidget_refinedUB.get_matrix())
        elif self.ui.radioButton_ubFromList.isChecked():
            status, ret_obj = gutil.parse_float_array(str(self.ui.plainTextEdit_ubInput.toPlainText()))
            if status is False:
                self.pop_one_button_dialog(ret_obj)
            elif len(ret_obj) != 9:
                self.pop_one_button_dialog('Requiring 9 floats for UB matrix.  Only %d are given.' % len(ret_obj))
            else:
                self.ui.tableWidget_ubSiceView.set_from_list(ret_obj)
        else:
            self.pop_one_button_dialog('None is selected to set UB matrix.')

        return

    def do_setup_dir_default(self):
        """
        Set up default directory for storing data and working
        :return:
        """
        home_dir = os.path.expanduser('~')

        # Data cache directory
        data_cache_dir = os.path.join(home_dir, 'Temp/HB3ATest')
        self.ui.lineEdit_localSpiceDir.setText(data_cache_dir)
        self.ui.lineEdit_localSrcDir.setText(data_cache_dir)

        work_dir = os.path.join(data_cache_dir, 'Workspace')
        self.ui.lineEdit_workDir.setText(work_dir)

        return

    def do_apply_setup(self):
        """
        Apply set up ...
        :return:
        """
        # Local data directory
        local_data_dir = str(self.ui.lineEdit_localSpiceDir.text())
        if os.path.exists(local_data_dir) is False:
            try:
                os.mkdir(local_data_dir)
            except OSError as os_error:
                self.pop_one_button_dialog('Unable to create local data directory %s due to %s.' % (
                    local_data_dir, str(os_error)))
                self.ui.lineEdit_localSpiceDir.setStyleSheet("color: red;")
                return
            else:
                self.ui.lineEdit_localSpiceDir.setStyleSheet("color: black;")
        # END-IF

        # Working directory
        working_dir = str(self.ui.lineEdit_workDir.text())
        if os.path.exists(working_dir) is False:
            try:
                os.mkdir(working_dir)
            except OSError as os_error:
                self.pop_one_button_dialog('Unable to create working directory %s due to %s.' % (
                    working_dir, str(os_error)))
                self.ui.lineEdit_workDir.setStyleSheet("color: red;")
                return
            else:
                self.ui.lineEdit_workDir.setStyleSheet("color: black;")
        # END-IF

        # Server URL
        data_server = str(self.ui.lineEdit_url.text())
        url_is_good = self.do_test_url()
        if url_is_good is False:
            self.ui.lineEdit_url.setStyleSheet("color: red;")
            return
        else:
            self.ui.lineEdit_url.setStyleSheet("color: black;")

        # Set to control
        self._myControl.set_local_data_dir(local_data_dir)
        self._myControl.set_working_directory(working_dir)
        self._myControl.set_server_url(data_server)

        return

    def do_test_url(self):
        """ Test whether the root URL provided specified is good
        """
        url = str(self.ui.lineEdit_url.text())

        url_is_good, err_msg = fcutil.check_url(url)
        if url_is_good is True:
            self.pop_one_button_dialog("URL %s is valid." % url)
        else:
            self.pop_one_button_dialog(err_msg)

        return url_is_good

    def pop_one_button_dialog(self, message):
        """ Pop up a one-button dialog
        :param message:
        :return:
        """
        assert isinstance(message, str)
        QtGui.QMessageBox.information(self, '4-circle Data Reduction', message)

        return

    def save_current_session(self, filename=None):
        """ Save current session/value setup to
        :return:
        """
        # Set up dictionary
        save_dict = dict()

        # Setup
        save_dict['lineEdit_localSpiceDir'] = str(self.ui.lineEdit_localSpiceDir.text())
        save_dict['lineEdit_url'] = str(self.ui.lineEdit_url.text())
        save_dict['lineEdit_workDir']= str(self.ui.lineEdit_workDir.text())

        # Experiment
        save_dict['lineEdit_exp'] = str(self.ui.lineEdit_exp.text())
        save_dict['lineEdit_scanNumber'] = self.ui.lineEdit_scanNumber.text()
        save_dict['lineEdit_ptNumber'] = str(self.ui.lineEdit_ptNumber.text())

        # Lattice
        save_dict['lineEdit_a'] = str(self.ui.lineEdit_a.text())
        save_dict['lineEdit_b'] = str(self.ui.lineEdit_b.text())
        save_dict['lineEdit_c'] = str(self.ui.lineEdit_c.text())
        save_dict['lineEdit_alpha'] = str(self.ui.lineEdit_alpha.text())
        save_dict['lineEdit_beta'] = str(self.ui.lineEdit_beta.text())
        save_dict['lineEdit_gamma'] = str(self.ui.lineEdit_gamma.text())

        # Merge scan
        save_dict['plainTextEdit_ubInput'] = str(self.ui.plainTextEdit_ubInput.toPlainText())
        save_dict['lineEdit_listScansSliceView'] = str(self.ui.lineEdit_listScansSliceView.text())
        save_dict['lineEdit_baseMergeMDName'] = str(self.ui.lineEdit_baseMergeMDName.text())

        # Save to csv file
        if filename is None:
            filename = 'session_backup.csv'
        ofile = open(filename, 'w')
        writer = csv.writer(ofile)
        for key, value in save_dict.items():
            writer.writerow([key, value])
        ofile.close()

        return

    def load_session(self, filename=None):
        """
        To load a session, i.e., read it back:
        :param filename:
        :return:
        """
        if filename is None:
            filename = 'session_backup.csv'

        in_file = open(filename, 'r')
        reader = csv.reader(in_file)
        my_dict = dict(x for x in reader)

        # ...
        for key, value in my_dict.items():
            if key.startswith('lineEdit') is True:
                self.ui.__getattribute__(key).setText(value)
            elif key.startswith('plainText') is True:
                self.ui.__getattribute__(key).setPlainText(value)
            elif key.startswith('comboBox') is True:
                self.ui.__getattribute__(key).setCurrentIndex(int(value))
            else:
                self.pop_one_button_dialog('Error! Widget name %s is not supported' % key)
        # END-FOR

        # ...
        self._myControl.set_local_data_dir(str(self.ui.lineEdit_localSpiceDir.text()))

        return

    def menu_quit(self):
        """

        :return:
        """
        self.close()

    def show_scan_pt_list(self):
        """ Show the range of Pt. in a scan
        :return:
        """
        # Get parameters
        status, inp_list = gutil.parse_integers_editors([self.ui.lineEdit_exp, self.ui.lineEdit_run])
        if status is False:
            self.pop_one_button_dialog(inp_list)
            return
        else:
            exp_no = inp_list[0]
            scan_no = inp_list[1]

        status, ret_obj = self._myControl.get_pt_numbers(exp_no, scan_no)

        # Form message
        if status is False:
            # Failed to get Pt. list
            error_message = ret_obj
            self.pop_one_button_dialog(error_message)
        else:
            # Form message
            pt_list = sorted(ret_obj)
            num_pts = len(pt_list)
            info = 'Exp %d Scan %d has %d Pt. ranging from %d to %d.\n' % (exp_no, scan_no, num_pts,
                                                                           pt_list[0], pt_list[-1])
            num_miss_pt = pt_list[-1] - pt_list[0] + 1 - num_pts
            if num_miss_pt > 0:
                info += 'There are %d Pt. skipped.\n' % num_miss_pt

            self.pop_one_button_dialog(info)

        return

    def set_ub_peak_table(self, peakinfo):
        """
        DOC
        :param peak_info:
        :return:
        """
        assert isinstance(peakinfo, r4c.PeakInfo)

        # Get data
        exp_number, scan_number, pt_number = peakinfo.getExpInfo()
        h, k, l = peakinfo.get_user_hkl()
        q_sample = peakinfo.getQSample()
        m1 = self._myControl.get_sample_log_value(exp_number, scan_number, pt_number, '_m1')

        # Set to table
        status, err_msg = self.ui.tableWidget_peaksCalUB.append_row(
            [scan_number, pt_number, h, k, l, q_sample[0], q_sample[1], q_sample[2], False, m1, ''])
        if status is False:
            self.pop_one_button_dialog(err_msg)

        return

    def _get_lattice_parameters(self):
        """
        Get lattice parameters from GUI
        :return: (Boolean, Object).  True, 6-tuple as a, b, c, alpha, beta, gamm
                                     False: error message
        """
        status, ret_list = gutil.parse_float_editors([self.ui.lineEdit_a,
                                                      self.ui.lineEdit_b,
                                                      self.ui.lineEdit_c,
                                                      self.ui.lineEdit_alpha,
                                                      self.ui.lineEdit_beta,
                                                      self.ui.lineEdit_gamma])
        if status is False:
            err_msg = ret_list
            err_msg = 'Unable to parse unit cell due to %s' % err_msg
            return False, err_msg

        a, b, c, alpha, beta, gamma = ret_list

        return True, (a, b, c, alpha, beta, gamma)

    def _plot_raw_xml_2d(self, exp_no, scan_no, pt_no):
        """ Plot raw workspace from XML file for a measurement/pt.
        """
        # Check and load SPICE table file
        does_exist = self._myControl.does_spice_loaded(exp_no, scan_no)
        if does_exist is False:
            # Download data
            status, error_message = self._myControl.download_spice_file(exp_no, scan_no, over_write=False)
            if status is True:
                status, error_message = self._myControl.load_spice_scan_file(exp_no, scan_no)
                if status is False and self._allowDownload is False:
                    self.pop_one_button_dialog(error_message)
                    return
            else:
                self.pop_one_button_dialog(error_message)
                return
        # END-IF(does_exist)

        # Load Data for Pt's xml file
        does_exist = self._myControl.does_raw_loaded(exp_no, scan_no, pt_no)

        if does_exist is False:
            # Check whether needs to download
            status, error_message = self._myControl.download_spice_xml_file(scan_no, pt_no, exp_no=exp_no)
            if status is False:
                self.pop_one_button_dialog(error_message)
                return
            # Load SPICE xml file
            status, error_message = self._myControl.load_spice_xml_file(exp_no, scan_no, pt_no)
            if status is False:
                self.pop_one_button_dialog(error_message)
                return

        # Convert a list of vector to 2D numpy array for imshow()
        # Get data and plot
        raw_det_data = self._myControl.get_raw_detector_counts(exp_no, scan_no, pt_no)
        self.ui.graphicsView.clear_canvas()
        self.ui.graphicsView.add_plot_2d(raw_det_data, x_min=0, x_max=256, y_min=0, y_max=256,
                                         hold_prev_image=False)

        return

    def _show_ub_matrix(self, ubmatrix):
        """ Show UB matrix
        :param ubmatrix:
        :return:
        """
        assert ubmatrix.shape == (3, 3)

        self.ui.tableWidget_ubMatrix.set_from_matrix(ubmatrix)

        return
Пример #40
0
    def __init__(self, parent=None):
        """ Initialization and set up
        """
        # Base class
        QtGui.QMainWindow.__init__(self,parent)

        # UI Window (from Qt Designer)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        # Make UI scrollable
        self._scrollbars = MantidQt.API.WidgetScrollbarDecorator(self)
        self._scrollbars.setEnabled(True) # Must follow after setupUi(self)!

        # Mantid configuration
        self._instrument = str(self.ui.comboBox_instrument.currentText())
        # config = ConfigService.Instance()
        # self._instrument = config["default.instrument"]

        # Event handling definitions
        # Top
        self.connect(self.ui.pushButton_setExp, QtCore.SIGNAL('clicked()'),
                     self.do_set_experiment)

        # Tab 'Data Access'
        self.connect(self.ui.pushButton_applySetup, QtCore.SIGNAL('clicked()'),
                     self.do_apply_setup)
        self.connect(self.ui.pushButton_browseLocalDataDir, QtCore.SIGNAL('clicked()'),
                     self.do_browse_local_spice_data)
        self.connect(self.ui.pushButton_testURLs, QtCore.SIGNAL('clicked()'),
                     self.do_test_url)
        self.connect(self.ui.pushButton_ListScans, QtCore.SIGNAL('clicked()'),
                     self.do_list_scans)
        self.connect(self.ui.pushButton_downloadExpData, QtCore.SIGNAL('clicked()'),
                     self.do_download_spice_data)
        self.connect(self.ui.comboBox_mode, QtCore.SIGNAL('currentIndexChanged(int)'),
                     self.change_data_access_mode)

        # Tab 'View Raw Data'
        self.connect(self.ui.pushButton_setScanInfo, QtCore.SIGNAL('clicked()'),
                     self.do_load_scan_info)
        self.connect(self.ui.pushButton_plotRawPt, QtCore.SIGNAL('clicked()'),
                     self.do_plot_pt_raw)
        self.connect(self.ui.pushButton_prevPtNumber, QtCore.SIGNAL('clicked()'),
                     self.do_plot_prev_pt_raw)
        self.connect(self.ui.pushButton_nextPtNumber, QtCore.SIGNAL('clicked()'),
                     self.do_plot_next_pt_raw)
        self.connect(self.ui.pushButton_showPtList, QtCore.SIGNAL('clicked()'),
                     self.show_scan_pt_list)
        self.connect(self.ui.pushButton_usePt4UB, QtCore.SIGNAL('clicked()'),
                     self.do_add_peak_to_find)

        # Tab 'calculate ub matrix'
        self.connect(self.ui.pushButton_findPeak, QtCore.SIGNAL('clicked()'),
                     self.do_find_peak)
        self.connect(self.ui.pushButton_addPeakToCalUB, QtCore.SIGNAL('clicked()'),
                     self.do_add_ub_peak)
        self.connect(self.ui.pushButton_calUB, QtCore.SIGNAL('clicked()'),
                     self.do_cal_ub_matrix)
        self.connect(self.ui.pushButton_acceptUB, QtCore.SIGNAL('clicked()'),
                     self.doAcceptCalUB)
        self.connect(self.ui.pushButton_indexUBPeaks, QtCore.SIGNAL('clicked()'),
                     self.do_index_ub_peaks)
        self.connect(self.ui.pushButton_deleteUBPeak, QtCore.SIGNAL('clicked()'),
                     self.do_del_ub_peaks)
        self.connect(self.ui.pushButton_clearUBPeakTable, QtCore.SIGNAL('clicked()'),
                     self.do_clear_ub_peaks)
        self.connect(self.ui.pushButton_resetPeakHKLs, QtCore.SIGNAL('clicked()'),
                     self.do_reset_ub_peaks_hkl)

        # Tab 'Slice View'
        self.connect(self.ui.pushButton_setUBSliceView, QtCore.SIGNAL('clicked()'),
                     self.do_set_ub_sv)
        self.connect(self.ui.pushButton_process4SliceView, QtCore.SIGNAL('clicked()'),
                     self.do_merge_scans)

        # Tab 'Advanced'
        self.connect(self.ui.pushButton_useDefaultDir, QtCore.SIGNAL('clicked()'),
                     self.do_setup_dir_default)
        self.connect(self.ui.pushButton_browseLocalCache, QtCore.SIGNAL('clicked()'),
                     self.do_browse_local_cache_dir)
        self.connect(self.ui.pushButton_browseWorkDir, QtCore.SIGNAL('clicked()'),
                     self.do_browse_working_dir)
        self.connect(self.ui.comboBox_instrument, QtCore.SIGNAL('currentIndexChanged(int)'),
                     self.change_instrument_name)

        # Refine UB matrix
        self.connect(self.ui.pushButton_addToRefine, QtCore.SIGNAL('clicked()'),
                     self.do_refine_ub)
        self.connect(self.ui.pushButton_addAllRefineUB, QtCore.SIGNAL('clicked()'),
                     self.do_refine_ub)
        self.connect(self.ui.pushButton_acceptRefinedUB, QtCore.SIGNAL('clicked()'),
                     self.do_refine_ub)
        self.connect(self.ui.pushButton_resetRefinedUB, QtCore.SIGNAL('clicked()'),
                     self.do_refine_ub)

        # Tab 'Integrate Peaks'
        self.connect(self.ui.pushButton_integratePeak, QtCore.SIGNAL('clicked()'),
                     self.do_integrate_peaks)

        # Menu
        self.connect(self.ui.actionExit, QtCore.SIGNAL('triggered()'),
                     self.menu_quit)

        self.connect(self.ui.actionSave_Session, QtCore.SIGNAL('triggered()'),
                     self.save_current_session)
        self.connect(self.ui.actionLoad_Session, QtCore.SIGNAL('triggered()'),
                     self.load_session)

        # Event handling for tab 'refine ub matrix'
        self.connect(self.ui.pushButton_addToRefine, QtCore.SIGNAL('clicked()'),
                     self.doAddScanPtToRefineUB)

        # Validator ... (NEXT)

        # Declaration of class variable
        # some configuration
        self._homeSrcDir = os.getcwd()
        self._homeDir = os.getcwd()

        # Control
        self._myControl = r4c.CWSCDReductionControl(self._instrument)
        self._allowDownload = True
        self._dataAccessMode = 'Download'

        # Initial setup
        self.ui.tabWidget.setCurrentIndex(0)
        self.ui.tabWidget.setTabEnabled(4, False)
        self.ui.tabWidget.setTabEnabled(5, False)
        self._init_ub_table()
        self.ui.radioButton_ubFromTab1.setChecked(True)

        # Tab 'Access'
        self.ui.lineEdit_url.setText('http://neutron.ornl.gov/user_data/hb3a/')
        self.ui.comboBox_mode.setCurrentIndex(0)
        self.ui.lineEdit_localSpiceDir.setEnabled(True)
        self.ui.pushButton_browseLocalDataDir.setEnabled(True)

        return
Пример #41
0
class MainWindow(QMainWindow, Ui_MainWindow):

    # var initialization
    settings = QSettings("Mte90", "Plessc")
    settings.setFallbacksEnabled(False)
    history = QSettings("Mte90", "Plessc_History")
    history.setFallbacksEnabled(False)
    version = "v 1.1"
    input_less = ""
    output_css = ""
    mysize = ""
    history_field = {}
    history_field["input"] = []
    history_field["output"] = []
    option = {}
    proc = QProcess()
    less_version = QProcess()
    watcher = QFileSystemWatcher()

    def __init__(self, parent=None):
        QMainWindow.__init__(self, parent)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
        self.setWindowTitle("PLessc - lessc not defined")
        # Connect the function with the signal
        self.ui.inputChoose.clicked.connect(self.openInputDialog)
        self.ui.outputChoose.clicked.connect(self.openOutputDialog)
        self.ui.setBoth.pressed.connect(self.setBoth)
        self.ui.setStandard.pressed.connect(self.setStandard)
        self.ui.optionIE.stateChanged.connect(self.setOptionIE)
        self.ui.optionSourceMap.stateChanged.connect(self.setOptionSourceMap)
        self.ui.setMinify.stateChanged.connect(self.setMinify)
        self.ui.inputEdit.pressed.connect(self.openEditor)
        self.ui.outputLog.clicked.connect(self.openLog)
        self.ui.lint.clicked.connect(self.lintLog)
        self.ui.compile.clicked.connect(self.compileIt)
        self.ui.menuInfo.triggered.connect(self.openInfo)
        self.ui.menuSetting.triggered.connect(self.openSetDialog)
        self.proc.finished.connect(self.checkLog)
        self.less_version.finished.connect(self.updateTitle)
        signal.signal(signal.SIGINT, signal.SIG_DFL)
        # hide log
        self.ui.log.hide()
        # check lessc version
        self.loadVersion()
        # Check the setting for load the path of the file
        if self.settings.value("input_file") != -1:
            self.input_less = self.settings.value("input_file")
        else:
            self.input_less = "/"
        if self.settings.value("output_file") != -1:
            self.output_css = self.settings.value("output_file")
        else:
            self.output_css = "/"
        self.ui.inputFile.setText(self.input_less)
        self.ui.outputFile.setText(self.output_css)
        # Check the setting for the minify mode for the css file
        if self.settings.value("min") == "False":
            self.option["minify"] = " "
            self.settings.setValue("min", "False")
            self.ui.setMinify.setChecked(False)
        else:
            self.option["minify"] = "-x"
            self.settings.setValue("min", "True")
            self.ui.setMinify.setChecked(True)
        # Check for the export of the file
        if self.settings.value("both_or_standard") == "False":
            self.settings.setValue("both_or_standard", "False")
            self.ui.setStandard.toggle()
        else:
            self.settings.setValue("both_or_standard", "True")
            self.ui.setBoth.toggle()
        # Auto compile option
        if self.settings.value("auto_compile") == "False":
            self.ui.autoCompile.setChecked(False)
        else:
            self.ui.autoCompile.setChecked(True)
        # Add the function for the autocompile after the load of the setting
        self.ui.autoCompile.stateChanged.connect(self.autoCompile)
        self.autoCompile()
        # Setting for export the css for old IE version
        if self.settings.value("option_IE") == "False":
            self.ui.optionIE.setChecked(False)
            self.option["ie"] = " "
        else:
            self.ui.optionIE.setChecked(True)
            self.option["ie"] = "--no-ie-compat"
        # Setting for enable Sourcemap
        if self.settings.value("option_SourceMap") == "False":
            self.ui.optionSourceMap.setChecked(False)
            self.option["sourcemap"] = " "
        else:
            self.ui.optionSourceMap.setChecked(True)
            self.option["sourcemap"] = "--source-map"
        # Resize the window for hide the space of log
        self.resize(505, 220)
        # Load History
        self.loadHistory()
        self.show()

    def loadHistory(self):
        # load history
        if str(self.history.value("input")) != "None":
            self.history_field["input"] = str(self.history.value("input")).split(";")
        if str(self.history.value("output")) != "None":
            self.history_field["output"] = str(self.history.value("output")).split(";")
        completer_input = QCompleter(self.history_field["input"], self.ui.inputFile)
        self.ui.inputFile.setCompleter(completer_input)
        completer_output = QCompleter(self.history_field["output"], self.ui.outputFile)
        self.ui.outputFile.setCompleter(completer_output)
        self.ui.inputFile.editingFinished.connect(self.setInputFile)
        self.ui.outputFile.editingFinished.connect(self.setOutputFile)

    def addHistory(self, field, text):
        # add the path in the history if not exist
        if text not in self.history_field[field]:
            self.history_field[field].append(text)
            self.history.setValue(field, ";".join(self.history_field[field]))

    # Function for open a dialog for choose the input less file
    def openInputDialog(self):
        self.input_less = QFileDialog.getOpenFileName(
            self, "Choose less file", self.ui.inputFile.text(), "LESS file (*.less)"
        )
        if self.input_less != "":
            self.ui.inputFile.setText(self.input_less)

    # Function for open a dialog for choose the output css file
    def openOutputDialog(self):
        self.output_css = QFileDialog.getSaveFileName(
            self, "Set css file", self.ui.outputFile.text(), "CSS file (*.css)"
        )
        if self.output_css != "":
            self.ui.outputFile.setText(self.output_css)

    # Save the input file in the setting
    def setInputFile(self):
        self.settings.setValue("input_file", self.ui.inputFile.text())
        self.addHistory("input", self.ui.inputFile.text())

    # Save the output file in the setting
    def setOutputFile(self):
        self.settings.setValue("output_file", self.ui.outputFile.text())
        self.addHistory("output", self.ui.outputFile.text())

    # Save the output export of the css
    def setBoth(self):
        self.settings.setValue("both_or_standard", "True")

    # Save the output export of the css
    def setStandard(self):
        self.settings.setValue("both_or_standard", "False")

    # Check autoCompile and enable the watching of the input less file
    def autoCompile(self):
        # If not checked
        if self.ui.autoCompile.isChecked() == False:
            self.settings.setValue("auto_compile", "False")
            # If previosuly was enabled the option this disable the watch of the file
            try:
                self.watcher.fileChanged.disconnect()
            except (RuntimeError, TypeError, NameError):
                pass
        else:
            self.settings.setValue("auto_compile", "True")
            # Clean the path added to file watching for fix a problem with Qt4
            self.watcher.removePath(self.settings.value("input_file"))
            # Re add of the path
            self.watcher.addPath(self.settings.value("input_file"))
            self.watcher.fileChanged.connect(self.compileIt)

    # Save the Ie Setting
    def setOptionIE(self):
        if self.ui.optionIE.isChecked() == False:
            self.settings.setValue("option_IE", "False")
            self.option["ie"] = ""
        else:
            self.settings.setValue("option_IE", "True")
            self.option["ie"] = "--no-ie-compat"

    # Save the SourceMap
    def setOptionSourceMap(self):
        if self.ui.optionSourceMap.isChecked() == False:
            self.settings.setValue("option_SourceMap", "False")
            self.option["sourcemap"] = " "
        else:
            self.settings.setValue("option_SourceMap", "True")
            self.option["sourcemap"] = "--source-map"

    # Save the minify setting
    def setMinify(self):
        if self.ui.setMinify.isChecked() == False:
            self.option["minify"] = " "
            self.settings.setValue("min", "False")
        else:
            self.option["minify"] = "-x"
            self.settings.setValue("min", "True")

    # Compile the less file
    def compileIt(self):
        QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
        if os.path.isfile(self.settings.value("input_file")):
            self.ui.log.setHtml("")
            self.ui.info.setText("Compiling...")
            if self.settings.value("both_or_standard") == "True":
                # if both save method True
                name = os.path.splitext(self.settings.value("output_file"))[0]
                name += ".min.css"
                complete = str(
                    self.settings.value("less_path")
                    + self.optionString()
                    + '"'
                    + self.settings.value("input_file")
                    + '" "'
                    + name
                    + '"'
                )
                command = str(
                    self.settings.value("less_path")
                    + self.optionString("minify")
                    + ' --verbose "'
                    + self.settings.value("input_file")
                    + '" "'
                    + self.settings.value("output_file")
                    + '"'
                )
                # Compile the min.css
                os.system(complete)
                self.proc.closeWriteChannel()
                # Compile a standard css
                self.proc.start(command)
                self.proc.waitForFinished()
                self.proc.closeWriteChannel()
                if os.path.isfile(name):
                    self.ui.info.setText(
                        "File Min Output: <b>"
                        + self.sizeof_fmt(name)
                        + "</b> | File Standard: <b>"
                        + self.sizeof_fmt(self.settings.value("output_file"))
                        + "</b> | "
                        + datetime.datetime.now().strftime("%d-%m-%Y %H:%M:%S")
                    )
                else:
                    QMessageBox.critical(self.window(), "Output File not exist", "The output file choosen not exist!")
            else:
                # if standard = 0 False
                command = str(
                    self.settings.value("less_path")
                    + self.optionString()
                    + ' --verbose "'
                    + self.settings.value("input_file")
                    + '" "'
                    + self.settings.value("output_file")
                    + '"'
                )
                self.proc.closeWriteChannel()
                self.proc.start(command)
                self.proc.waitForFinished()
                self.proc.closeWriteChannel()
                if os.path.isfile(self.settings.value("output_file")):
                    self.ui.info.setText(
                        "File Output: <b>"
                        + self.sizeof_fmt(self.settings.value("output_file"))
                        + "</b>"
                        + " | "
                        + datetime.datetime.now().strftime("%d-%m-%Y %H:%M:%S")
                    )
                else:
                    QMessageBox.critical(self.window(), "Output File not exist", "The output file choosen not exist!")
            QApplication.restoreOverrideCursor()
        else:
            QMessageBox.critical(self.window(), "Input File not exist", "The input file choosen not exist!")
        print(command)
        # Clean the path added to file watching for fix a problem with Qt4
        self.watcher.removePath(self.settings.value("input_file"))
        # Readd the path
        self.watcher.addPath(self.settings.value("input_file"))

    # Open all the less file in the folder onf the input file
    def openEditor(self):
        open_file = self.settings.value("input_file")
        # get all file less and open on the editor if this option are set
        if self.settings.value("less_folder") == "True":
            list_file = ""
            path_less = os.path.split(str(open_file))[0]
            for root, dirs, files in os.walk(path_less):
                files.sort()
                for name in files:
                    filename = os.path.join(root, name)
                    if filename.endswith(".less"):
                        list_file = list_file + '"' + filename + '" '
            open_file = list_file
        os.system(str(self.settings.value("editor_path") + " " + open_file))

    # Show the log
    def openLog(self):
        if self.ui.log.isVisible() == True:
            self.resize(531, 239)
            self.ui.log.hide()
        else:
            self.resize(531, 459)
            self.ui.log.show()

    def openSetDialog(self):
        # i need to explain this??
        window = QDialog()
        ui = SettingDialog()
        ui.setupUi(window)
        if ui.exec_() == 1:
            self.loadVersion()

    def openInfo(self):
        QMessageBox.about(
            self.window(),
            "About Plessc",
            "<p align='center'>Plessc "
            + self.version
            + " <br><br>By <a href='http://www.mte90.net'><b>Mte90</b></a><br><br>GUI in Python and Qt4 for compile less file<br><br>Tested with lessc 1.7.x of LESS.JS<br><br><small>If other compilers use the same parameters i think that works else some monkeys do it for you</small><br><br>License: GPL 3</p>",
        )

    # http://stackoverflow.com/questions/1094841/reusable-library-to-get-human-readable-version-of-file-size
    def sizeof_fmt(self, file_):
        num = os.path.getsize(str(file_))
        for x in ["bytes", "KB", "MB", "GB", "TB"]:
            if num < 1024.0:
                return str("%3.1f %s") % (num, x)
            num /= 1024.0

    # Clean the output of lessc
    def replace_all(self, text):
        # remove the shellcode/ANSI of the color of the text
        text = text.replace("[39m", "<br>").replace("[31m", "").replace("[22m", "").replace("[0m", "").replace("1b", "")
        text = (
            text.replace("[90m", "")
            .replace("[27m", "")
            .replace("[7m", "")
            .replace("[1m", "")
            .replace("b''", "")
            .replace("\n\n", "")
            .replace("b'", "")
        )
        text = text.replace("\\x", "").replace("\\n\\n'", "").replace("\\n", "")

        return text.lstrip()

    # Execeute the lint and show it in the log area
    def lintLog(self):
        self.proc.closeWriteChannel()
        QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
        self.proc.start(str(self.settings.value("less_path") + ' --lint "' + self.settings.value("input_file") + '"'))
        self.openLog()
        self.proc.closeWriteChannel()
        QApplication.restoreOverrideCursor()

    # Check the content of log
    def checkLog(self):
        stdout = str(self.proc.readAllStandardOutput())
        check = stdout.strip()
        # If the log not exmpty and length > of 3 print
        if check is not None and len(check) > 3:
            output = self.replace_all(stdout)
            if not output.startswith("lessc: wrote "):
                self.ui.log.setHtml(self.replace_all(stdout))
                self.openLog()
        else:
            self.ui.log.setHtml("OK!")

    # Execute the load of lessc version
    def loadVersion(self):
        self.less_version.closeWriteChannel()
        self.setWindowTitle("PLessc - lessc not defined")
        self.less_version.start(self.settings.value("less_path"), ["--version"])

    # Update the title with less version
    def updateTitle(self):
        stdout = str(self.less_version.readAllStandardOutput())
        self.setWindowTitle("PLessc - " + self.replace_all(stdout.rstrip("'")))

    # Concate all the settings for lessc for use it in the command
    def optionString(self, remove=[]):
        # remove the parameter
        if remove != []:
            del self.option[remove]
        string = " ".join("{}".format(val) for key, val in self.option.items())
        return " " + string + " "
Пример #42
0
class MainWindow ( QtGui.QMainWindow ):
  #
  #
  def __init__ ( self ) : 
    #
    QtGui.QMainWindow.__init__ ( self )
    
    # This is always the same
    self.ui = Ui_MainWindow ()
    self.ui.setupUi ( self )
    self.setupMenuBar ()
    self.setupPanels ()
    
    self.setWindowTitle ( "meShaderEd (" + app_renderer.getCurrentPresetName() + ")")
    
    self.activeNodeList = None
    self.workArea = None # current work area
    self.onNew () # create new document 
    
    grid_enabled = getDefaultValue( app_settings, 'WorkArea', 'grid_enabled' )
    grid_snap = getDefaultValue ( app_settings, 'WorkArea', 'grid_snap' )
    grid_size = int( getDefaultValue ( app_settings, 'WorkArea', 'grid_size' )  )
    reverse_flow = getDefaultValue ( app_settings, 'WorkArea', 'reverse_flow' )
    straight_links = getDefaultValue ( app_settings, 'WorkArea', 'straight_links' )
  
    #self.ui.workArea.gridSize = grid_size
    #self.ui.workArea.gridSnap = grid_snap
    self.workArea.drawGrid = grid_enabled
    #self.ui.workArea.reverseFlow = reverse_flow 
    #self.ui.workArea.straightLinks = straight_links
    
    self.ui.actionShowGrid.setChecked( grid_enabled )
    self.ui.actionSnapGrid.setChecked( grid_snap )
    self.ui.actionReverseFlow.setChecked( reverse_flow )
    self.ui.actionStraightLinks.setChecked( straight_links )
   
    self.ui.nodeList_ctl.setLibrary ( app_global_vars[ 'NodesPath' ] )
    self.ui.project_ctl.setLibrary ( app_global_vars[ 'ProjectNetworks' ] )
    
    QtCore.QObject.connect ( self.ui.nodeList_ctl.ui.nodeList, QtCore.SIGNAL( "setActiveNodeList" ), self.setActiveNodeList )
    QtCore.QObject.connect ( self.ui.project_ctl.ui.nodeList, QtCore.SIGNAL( "setActiveNodeList" ), self.setActiveNodeList )
    
    QtCore.QObject.connect ( self.ui.tabs, QtCore.SIGNAL( "currentChanged(int)" ), self.onTabSelected )
    QtCore.QObject.connect ( self.ui.tabs, QtCore.SIGNAL( "tabCloseRequested(int)" ), self.onTabCloseRequested )
    
    QtCore.QObject.connect ( self.ui.nodeParam_ctl, QtCore.SIGNAL( "nodeLabelChanged" ), self.onNodeLabelChanged  )
  #
  #
  def connectWorkAreaSignals ( self ) :
    if self.workArea != None :
      if self.activeNodeList != None :
        QtCore.QObject.connect ( self.activeNodeList, QtCore.SIGNAL( "addNode" ), self.workArea.insertNodeNet  ) 
      QtCore.QObject.connect ( self.workArea, QtCore.SIGNAL( "selectNodes" ), self.onSelectGfxNodes  )
      QtCore.QObject.connect ( self.workArea, QtCore.SIGNAL( "nodeParamChanged" ), self.onNodeParamChanged  )
      QtCore.QObject.connect ( self.workArea, QtCore.SIGNAL( "gfxNodeAdded" ), self.onAddGfxNode )
      QtCore.QObject.connect ( self.workArea, QtCore.SIGNAL( "gfxNodeRemoved" ), self.onRemoveGfxNode )
  #
  #
  def disconnectWorkAreaSignals ( self ) :
    if self.workArea != None : 
      if self.activeNodeList != None :
        QtCore.QObject.disconnect ( self.activeNodeList, QtCore.SIGNAL( "addNode" ), self.workArea.insertNodeNet  )
      QtCore.QObject.disconnect ( self.workArea, QtCore.SIGNAL( "selectNodes" ), self.onSelectGfxNodes  )
      QtCore.QObject.disconnect ( self.workArea, QtCore.SIGNAL( "nodeParamChanged" ), self.onNodeParamChanged  )
      QtCore.QObject.disconnect ( self.workArea, QtCore.SIGNAL( "gfxNodeAdded" ), self.onAddGfxNode )
      QtCore.QObject.disconnect ( self.workArea, QtCore.SIGNAL( "gfxNodeRemoved" ), self.onRemoveGfxNode )  
  #
  #
  def setupMenuBar ( self ) :
    # override font for menu from Designer's settings to system default
    font = QtGui.QFont ()
    if ( sys.platform == 'win32' ):
      # Runing on windows, override font sizes from Designer to default 
      font.setPointSize ( 8 )   
    elif ( sys.platform == 'darwin' ):
      font.setPointSize ( 10 )
    
    self.ui.menubar.setFont ( font )
    self.ui.menuFile.setFont ( font )
    self.ui.menuEdit.setFont ( font )
    self.ui.menuCommand.setFont ( font )
    self.ui.menuWindow.setFont ( font )
    self.ui.menuHelp.setFont ( font )
  #
  #
  def setupPanels ( self ) :
        
    self.tabifyDockWidget ( self.ui.dockGeom, self.ui.dockPreview ) 
    self.tabifyDockWidget ( self.ui.dockProject, self.ui.dockNodes ) 
    
    self.removeDockWidget ( self.ui.dockParam )
    self.addDockWidget ( QtCore.Qt.DockWidgetArea(2), self.ui.dockParam )
    self.ui.dockParam.show ()
    
  #
  #
  def onProjectSetup ( self ):

    print ">> MainWindow: onProjectSetup" 
    projectSetupDlg = ProjectSetup ( app_settings )
    projectSetupDlg.exec_()
    self.ui.project_ctl.setLibrary ( app_global_vars[ 'ProjectNetworks' ] )
  #
  #
  def onSettingsSetup ( self ):

    print ">> MainWindow: onSettingsSetup" 
    settingsSetupDlg = SettingsSetup ( app_settings )
    settingsSetupDlg.exec_()
    self.ui.nodeList_ctl.setLibrary ( app_global_vars[ 'NodesPath' ] )
  #
  #
  def onRenderSettings ( self ):

    print ">> MainWindow: onRenderSettings" 
    renderSettingsDlg = meRendererSetup ( app_renderer )
    QtCore.QObject.connect( renderSettingsDlg, QtCore.SIGNAL("presetChanged"), self.onRenderPresetChanged )
    QtCore.QObject.connect( renderSettingsDlg, QtCore.SIGNAL("savePreset"), self.onRenderSavePreset )
    renderSettingsDlg.exec_()
  #
  #
  def onRenderPresetChanged ( self ):
    #
    presetName = app_renderer.getCurrentPresetName()
    print ">> MainWindow: onRenderPresetChanged preset = %s" % presetName 
    self.setWindowTitle ( "meShaderEd (" + presetName + ")")
    app_settings.setValue ( 'defRenderer', presetName )
    
    app_global_vars[ 'Renderer' ] = app_renderer.getCurrentValue( 'renderer', 'name' )
    app_global_vars[ 'RendererFlags' ] = app_renderer.getCurrentValue( 'renderer', 'flags' ) 
    app_global_vars[ 'ShaderCompiler' ] = app_renderer.getCurrentValue( 'shader', 'compiler' ) 
    app_global_vars[ 'ShaderDefines' ] = app_renderer.getCurrentValue( 'shader', 'defines' ) 
    app_global_vars[ 'TEX' ] = app_renderer.getCurrentValue( 'texture', 'extension' )
    app_global_vars[ 'SLO' ] = app_renderer.getCurrentValue( 'shader', 'extension' )
  #
  #
  def onRenderSavePreset ( self ):
    #
    print ">> MainWindow: onRenderSavePreset  preset = %s" % app_renderer.getCurrentPresetName()
    app_renderer.saveSettings ()
  #
  #
  def onShowGrid ( self, check ):
    #
    print ">> MainWindow: onShowGrid = %d" % check
    self.workArea.drawGrid = bool( check ) 
    app_settings.beginGroup ( 'WorkArea' )
    app_settings.setValue ( 'grid_enabled', bool( check ) )
    app_settings.endGroup ()
      
    self.workArea.resetCachedContent()
    #self.ui.workArea.update()
  #
  #
  def onSnapGrid ( self, check ):
    #
    print ">> MainWindow: onSnapGrid = %d" % check
    self.workArea.gridSnap = bool( check ) 
    app_settings.beginGroup ( 'WorkArea' )
    app_settings.setValue ( 'grid_snap', bool( check ) )
    app_settings.endGroup ()
      
    #self.ui.workArea.resetCachedContent()
  #
  #
  def onReverseFlow ( self, check ):
    #
    print ">> MainWindow: onReverseFlow = %d" % check   
    self.workArea.reverseFlow = bool( check ) 
    app_settings.beginGroup ( 'WorkArea' )
    app_settings.setValue ( 'reverse_flow', bool( check ) )
    app_settings.endGroup ()
      
    #self.ui.workArea.resetCachedContent()
  #
  #
  def onStraightLinks ( self, check ):
    #
    print ">> MainWindow: onStraightLinks = %d" % check 
    self.workArea.straightLinks = bool( check ) 
    app_settings.beginGroup ( 'WorkArea' )
    app_settings.setValue ( 'straight_links', bool( check ) )
    app_settings.endGroup ()
    self.workArea.resetCachedContent () 
  #
  #
  def setActiveNodeList ( self, nodeList ) :
    print '>> MainWindow: setActiveNodeList'
    if self.activeNodeList != None :
      QtCore.QObject.disconnect ( self.activeNodeList, QtCore.SIGNAL( "addNode" ), self.workArea.insertNodeNet  )  
    self.activeNodeList = nodeList  
    QtCore.QObject.connect ( self.activeNodeList, QtCore.SIGNAL( "addNode" ), self.workArea.insertNodeNet  )
  #
  # Called by WorkArea after drag&drop event
  # Here we choose selected nodeList panel (Libray or Project)
  # for processing node request
  def onGetNode ( self, itemFilename, pos ):
    if self.activeNodeList != None :
      self.activeNodeList.onGetNode ( itemFilename, pos ) 
  #
  #
  def onAddGfxNode ( self, gfxNode ):
    #
    #print ">> MainWindow: onAddGfxNode = %s" % gfxNode.node.label
    if gfxNode.node.type == 'image' :
      
      self.ui.imageView_ctl.addViewer ( gfxNode )
      
      #if self.ui.nodeParam_ctl.receivers( QtCore.SIGNAL( 'onNodeParamChanged(QObject,QObject)' ) ) == 0 :
      #  QtCore.QObject.connect( self.ui.nodeParam_ctl, QtCore.SIGNAL( 'onNodeParamChanged(QObject,QObject)' ), self.ui.imageView_ctl.onNodeParamChanged ) 
      #else :
      #  print ">> MainWindow: nodeParam_ctl onNodeParamChanged already connected to imageView_ctl" 
  #
  #
  def onRemoveGfxNode ( self, gfxNode ):
    #
    print ">> MainWindow: onRemoveGfxNode = %s" % gfxNode.node.label
    if gfxNode.node.type == 'image' :
      self.ui.imageView_ctl.removeViewer ( gfxNode )
      #QtCore.QObject.disconnect ( self.ui.nodeParam_ctl, QtCore.SIGNAL( 'onNodeParamChanged(QObject,QObject)' ), self.ui.imageView_ctl.onNodeParamChanged ) 
  #
  #
  def onDelete ( self ):
    #
    print ">> MainWindow: onDelete"
    
    selected = self.workArea.scene().selectedItems()
    if len ( selected ) :
      self.workArea.removeSelected()
    else :
      self.ui.imageView_ctl.removeAllViewers ()
      self.workArea.clear()  
      
  #
  #
  def onSelectGfxNodes ( self, gfxNodes = [], gfxLinks = [] ):
    #
    #print ">> MainWindow: onSelectGfxNodes"
    self.workArea.inspectedNode = None  
    if len( gfxNodes ) == 1 :
      self.workArea.inspectedNode = gfxNodes[ 0 ]
      
    self.ui.nodeParam_ctl.setNode ( self.workArea.inspectedNode )
  #
  #
  def onNodeLabelChanged ( self, gfxNode, newLabel ) :

    self.workArea.nodeNet.renameNodeLabel ( gfxNode.node, newLabel )
    gfxNode.updateNodeLabel()
    self.ui.imageView_ctl.onNodeLabelChanged ( gfxNode, newLabel )
    self.workArea.scene().update()
  #
  #
  def onNodeParamChanged ( self, gfxNode, param ) :
    #param.shaderParam = not gfxNode.node.isInputParamLinked ( param )
    gfxNode.updateInputParams ()
    self.ui.nodeParam_ctl.updateGui ()
  #
  #
  def onFitAll ( self ) :    
    print ">> MainWindow: onFitAll"
  #
  #
  def onFitSelected ( self ) :    
    print ">> MainWindow: onFitSelected"
  #
  #
  def onZoomReset ( self ) :    
    print ">> MainWindow: onZoomReset"
  #
  #
  def onNewParamView ( self ) :    
    print ">> MainWindow: onNewParamView"
  #
  #
  def onTabSelected ( self, idx ) :
    #
    print '>> MainWindow: onTabSelected (%d)' % idx 
    self.disconnectWorkAreaSignals () 
    
    self.ui.imageView_ctl.removeAllViewers ()
        
    self.workArea = self.ui.tabs.currentWidget ()
    
    imageNodes = self.workArea.getGfxNodesByType ( 'image' )
    # setup imageView menu for image nodes in new tab 
    for gfxNode in imageNodes :
      self.ui.imageView_ctl.addViewer ( gfxNode )
    
    self.connectWorkAreaSignals ()
    self.ui.nodeParam_ctl.setNode ( self.workArea.inspectedNode )
  #
  #
  def onTabCloseRequested ( self, idx ) :
    #
    print '>> MainWindow: onTabCloseRequested (%d)' % idx 
    if self.ui.tabs.count() > 1 :
      self.workArea.nodeNet.clear()
      self.ui.tabs.removeTab ( idx )
  #
  #
  def onNew ( self, tabName = 'untitled' ):
    #
    def tabNameExists ( self, name ):
      ret = False
      for i in range ( 0, self.ui.tabs.count() ) :
        if name == str ( self.ui.tabs.tabText ( i ) ):
          ret = True
          break
      return ret 
    
    newName = tabName
    print '->  self.ui.tabs.count() = %d ' % self.ui.tabs.count()
    
    if self.workArea != None :
      print '->  create new WorkArea widget'
      # set unique new name
      name = newName
      i = 0
      while True :
        if tabNameExists ( self, name ) :
          name = newName + str ( i )
          i += 1
          continue
        else :
          break
      newName = name
      workArea = WorkArea ()  # create new WorkArea instance
      newTab = self.ui.tabs.addTab ( workArea, newName )
    else :
      print '->  use initial WorkArea widget'
      workArea = self.ui.workArea # use initial WorkArea widget
      self.workArea = workArea
      self.connectWorkAreaSignals () 
    
    nodeNet = NodeNetwork ( newName )
    workArea.setNodeNetwork ( nodeNet )
    
    self.ui.tabs.setTabText ( self.ui.tabs.indexOf( workArea ), newName )
    self.ui.tabs.setCurrentIndex ( self.ui.tabs.indexOf( workArea ) ) 
  #
  #
  def onOpen ( self ):
    print ">> MainWindow: onOpen"
    #
    curDir = app_global_vars[ 'ProjectNetworks' ]
    typeFilter = 'Shader networks *.xml;;All files *.*;;'
    
    filename = str( QtGui.QFileDialog.getOpenFileName( self, "Open file", curDir, typeFilter ) )
    if filename != '' : 
      print "-> open file %s" %  filename 
      ( name, ext ) = os.path.splitext( os.path.basename( filename ) )
      
      self.ui.imageView_ctl.removeAllViewers ()

      self.workArea.clear ()
      self.workArea.nodeNet.name = name
      self.workArea.nodeNet.fileName = ''
      self.ui.tabs.setTabText ( self.ui.tabs.indexOf( self.workArea ), name )
      
      self.workArea.openNodeNet ( normPath ( filename ) ) 
  #
  #
  def onImport ( self ):
    print ">> MainWindow: onImport"  
    # 
    curDir = app_global_vars[ 'ProjectNetworks' ]
    typeFilter = 'Shader networks *.xml;;All files *.*;;'
    
    filename = str( QtGui.QFileDialog.getOpenFileName( self, "Import file", curDir, typeFilter ) )
    if filename != '' : 
      print "-> import file %s" %  filename 
      self.workArea.insertNodeNet ( normPath ( filename ) ) 
  #
  #
  def onSave ( self ):
    print ">> MainWindow: onSave"
    # if file is new -- use onSaveAs function
    #
    curDir = app_global_vars[ 'ProjectNetworks' ]
    if self.workArea.nodeNet.fileName == '' :
      self.onSaveAs () 
    else :
      print '-> save file %s' % self.workArea.nodeNet.fileName 
      self.workArea.nodeNet.save ()
  #
  #
  def onSaveAs ( self ):
    print ">> MainWindow: onSaveAs"
    #
    curDir = app_global_vars[ 'ProjectNetworks' ]
    saveName = os.path.join ( curDir, self.workArea.nodeNet.name + '.xml' )
    typeFilter = 'Shader networks *.xml;;All files *.*;;'

    filename = str( QtGui.QFileDialog.getSaveFileName ( self, "Save file as", saveName, typeFilter ) )
    if filename != '' :
      print '-> save file As %s' % filename
      ( name, ext ) = os.path.splitext( os.path.basename( filename ) )
      self.workArea.nodeNet.fileName = normPath ( filename )
      self.workArea.nodeNet.name = name
      self.ui.tabs.setTabText ( self.ui.tabs.indexOf( self.workArea ), name )
      
      self.workArea.nodeNet.save ()
      self.ui.project_ctl.onReload()