~ubuntu-branches/ubuntu/natty/pymca/natty : revision 4

1

#!/usr/bin/env python

2

__revision__ = "$Revision: 2.02 $"

3

#/*##########################################################################

4

5

#

6

# This file is part of the PyMCA X-ray Fluorescence Toolkit developed at

7

# the ESRF by the Beamline Instrumentation Software Support (BLISS) group.

8

#

9

# This toolkit is free software; you can redistribute it and/or modify it

10

# under the terms of the GNU General Public License as published by the Free

11

# Software Foundation; either version 2 of the License, or (at your option)

12

# any later version.

13

#

14

# PyMCA is distributed in the hope that it will be useful, but WITHOUT ANY

15

# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

16

# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more

17

# details.

18

#

19

# You should have received a copy of the GNU General Public License along with

20

# PyMCA; if not, write to the Free Software Foundation, Inc., 59 Temple Place,

21

# Suite 330, Boston, MA 02111-1307, USA.

22

#

23

# PyMCA follows the dual licensing model of Trolltech's Qt and Riverbank's PyQt

24

# and cannot be used as a free plugin for a non-free program.

25

#

26

# Please contact the ESRF industrial unit (industry@esrf.fr) if this license

27

# is a problem for you.

28

#############################################################################*/

29

import sys, getopt, string

30

nativeFileDialogs = None

31

if __name__ == '__main__':

32

options = '-f'

33

longoptions = ['spec=','shm=','debug=', 'qt=', 'nativefiledialogs=']

34

try:

35

opts, args = getopt.getopt(

36

sys.argv[1:],

37

options,

38

longoptions)

39

except getopt.error,msg:

40

print msg

41

sys.exit(1)

42

43

keywords={}

44

debugreport = 0

45

qtversion = '4'

46

for opt, arg in opts:

47

if opt in ('--spec'):

48

keywords['spec'] = arg

49

elif opt in ('--shm'):

50

keywords['shm'] = arg

51

elif opt in ('--debug'):

52

debugreport = 1

53

elif opt in ('-f'):

54

keywords['fresh'] = 1

55

elif opt in ('--qt'):

56

qtversion = arg

57

elif opt in ('--nativefiledialogs'):

58

if int(arg):

59

nativeFileDialogs = True

60

else:

61

nativeFileDialogs = False

62

if qtversion == '3':

63

import qt

64

65

import PyMcaMdi

66

from PyMcaMdi import qt

67

68

QTVERSION = qt.qVersion()

69

70

from PyMca_Icons import IconDict

71

from PyMca_help import HelpDict

72

import os

73

__version__ = "4.4.0"

74

if (QTVERSION < '4.0.0') and ((sys.platform == 'darwin') or (QTVERSION < '3.0.0')):

75

class SplashScreen(qt.QWidget):

76

def __init__(self,parent=None,name="SplashScreen",

77

fl=qt.Qt.WStyle_Customize | qt.Qt.WDestructiveClose,

78

pixmap = None):

79

qt.QWidget.__init__(self,parent,name,fl)

80

self.setCaption("PyMCA %s" % __version__)

81

layout = qt.QVBoxLayout(self)

82

layout.setAutoAdd(1)

83

label = qt.QLabel(self)

84

if pixmap is not None:label.setPixmap(pixmap)

85

else:label.setText("Hello")

86

self.bottomText = qt.QLabel(self)

87

88

def message(self, text):

89

font = self.bottomText.font()

90

font.setBold(True)

91

self.bottomText.setFont(font)

92

self.bottomText.setText(text)

93

self.bottomText.show()

94

self.show()

95

self.raiseW()

96

97

if __name__ == "__main__":

98

app = qt.QApplication(sys.argv)

99

if qt.qVersion >= '3.0.0':

100

strlist = qt.QStyleFactory.keys()

101

if sys.platform == "win32":

102

for item in strlist:

103

text = str(item)

104

if text == "WindowsXP":

105

style = qt.QStyleFactory.create(item)

106

app.setStyle(style)

107

break

108

if 1 or QTVERSION < '4.0.0':

109

winpalette = qt.QPalette(qt.QColor(230,240,249),qt.QColor(238,234,238))

110

app.setPalette(winpalette)

111

else:

112

palette = app.palette()

113

role = qt.QPalette.Window #this is the background

114

palette.setColor(role, qt.QColor(238,234,238))

115

app.setPalette(palette)

116

117

mpath = os.path.dirname(PyMcaMdi.__file__)

118

if mpath[-3:] == "exe":

119

mpath = os.path.dirname(mpath)

120

if QTVERSION < '4.0.0':

121

qt.QMimeSourceFactory.defaultFactory().addFilePath(mpath)

122

if (sys.platform == 'darwin') or (qt.qVersion() < '3.0.0'):

123

pixmap = qt.QPixmap('PyMcaSplashImage.png')

124

splash = SplashScreen(pixmap=pixmap)

125

splash.message( 'PyMCA version %s\n' % __version__)

126

else:

127

pixmap = qt.QPixmap.fromMimeSource('PyMcaSplashImage.png')

128

splash = qt.QSplashScreen(pixmap)

129

splash.show()

130

font = splash.font()

131

font.setBold(True)

132

splash.setFont(font)

133

splash.message( 'PyMCA %s' % __version__,

134

qt.Qt.AlignLeft|qt.Qt.AlignBottom,

135

qt.Qt.white)

136

else:

137

fname = os.path.join(mpath,'PyMcaSplashImage.png')

138

if not os.path.exists(fname):

139

while len(mpath) > 3:

140

fname = os.path.join(mpath,'PyMcaSplashImage.png')

141

if not os.path.exists(fname):

142

mpath = os.path.dirname(mpath)

143

else:

144

break

145

if os.path.exists(fname):

146

pixmap = qt.QPixmap(qt.QString(fname))

147

splash = qt.QSplashScreen(pixmap)

148

else:

149

splash = qt.QSplashScreen()

150

splash.show()

151

import ChangeLog

152

font = splash.font()

153

font.setBold(1)

154

splash.setFont(font)

155

splash.showMessage( 'PyMCA %s' % __version__,

156

qt.Qt.AlignLeft|qt.Qt.AlignBottom,

157

qt.Qt.white)

158

if sys.platform == "darwin":

159

qt.qApp.processEvents()

160

161

import McaWindow

162

import ScanWindow

163

OBJECT3D = False

164

if QTVERSION > '4.0.0':

165

import PyMcaImageWindow

166

try:

167

#This is to make sure it is properly frozen

168

#and that Object3D is fully supported

169

import OpenGL.GL

170

import PyQt4.QtOpenGL

171

#import Object3D.SceneGLWindow as SceneGLWindow

172

import PyMcaGLWindow as SceneGLWindow

173

OBJECT3D = True

174

except:

175

OBJECT3D = False

176

import QDispatcher

177

import ElementsInfo

178

import PeakIdentifier

179

import PyMcaBatch

180

###########import Fit2Spec

181

import Mca2Edf

182

STACK = False

183

if QTVERSION > '4.0.0':

184

try:

185

import QEDFStackWidget

186

STACK = True

187

except:

188

STACK = False

189

import PyMcaPostBatch

190

import RGBCorrelator

191

import MaterialEditor

192

193

import ConfigDict

194

import PyMcaDirs

195

196

XIA_CORRECT = False

197

if QTVERSION > '4.3.0':

198

try:

199

import XiaCorrect

200

XIA_CORRECT = True

201

except:

202

pass

203

204

DEBUG = 0

205

SOURCESLIST = QDispatcher.QDataSource.source_types.keys()

206

207

"""

208

209

SOURCES = {"SpecFile":{'widget':SpecFileSelector.SpecFileSelector,'data':SpecFileLayer.SpecFileLayer},

210

"EdfFile":{'widget':EdfFileSelector.EdfFileSelector,'data':EdfFileLayer.EdfFileLayer}}

211

212

SOURCESLIST = ["SpecFile","EdfFile"]

213

214

if (sys.platform != 'win32') and (sys.platform != 'darwin'):

215

import MySPSSelector as SPSSelector

216

SOURCES["SPS"] = {'widget':SPSSelector.SPSSelector,'data':SPSLayer.SPSLayer}

217

SOURCESLIST.append("SPS")

218

"""

219

220

class PyMca(PyMcaMdi.PyMca):

221

def __init__(self, parent=None, name="PyMca", fl=None,**kw):

222

if QTVERSION < '4.0.0':

223

if fl is None:qt.Qt.WDestructiveClose

224

PyMcaMdi.PyMca.__init__(self, parent, name, fl)

225

self.setCaption(name)

226

self.setIcon(qt.QPixmap(IconDict['gioconda16']))

227

self.menuBar().setIcon(qt.QPixmap(IconDict['gioconda16']))

228

else:

229

if fl is None: fl = qt.Qt.WA_DeleteOnClose

230

PyMcaMdi.PyMca.__init__(self, parent, name, fl)

231

maxheight = qt.QDesktopWidget().height()

232

if maxheight < 799:

233

self.setMinimumHeight(int(0.8*maxheight))

234

self.setMaximumHeight(int(0.9*maxheight))

235

self.setWindowTitle(name)

236

self.setWindowIcon(qt.QIcon(qt.QPixmap(IconDict['gioconda16'])))

237

self.changeLog = None

238

239

self._widgetDict = {}

240

self.initSourceBrowser()

241

self.initSource()

242

243

self.elementsInfo= None

244

self.attenuationTool = None

245

self.identifier = None

246

self.__batch = None

247

self.__mca2Edf = None

248

self.__fit2Spec = None

249

self.__correlator = None

250

self.__imagingTool = None

251

if QTVERSION < '4.0.0':

252

self.openMenu = qt.QPopupMenu()

253

self.openMenu.insertItem("PyMca Configuration",0)

254

self.openMenu.insertItem("Data Source",1)

255

self.connect(self.openMenu,qt.SIGNAL('activated(int)'),self.openSource)

256

else:

257

self.openMenu = qt.QMenu()

258

self.openMenu.addAction("PyMca Configuration", self.openSource)

259

self.openMenu.addAction("Data Source",

260

self.sourceWidget.sourceSelector._openFileSlot)

261

#self.connect(self.openMenu,qt.SIGNAL('activated(int)'),self.openSource)

262

263

if QTVERSION > '4.0.0':

264

self.__useTabWidget = True

265

else:

266

self.__useTabWidget = False

267

268

if not self.__useTabWidget:

269

self.mcawindow = McaWindow.McaWidget(self.mdi)

270

self.scanwindow = ScanWindow.ScanWindow(self.mdi)

271

self.imageWindowDict = None

272

self.connectDispatcher(self.mcawindow, self.sourceWidget)

273

self.connectDispatcher(self.scanwindow, self.sourceWidget)

274

if QTVERSION < '4.0.0':

275

pass

276

else:

277

self.mdi.addWindow(self.mcawindow)

278

self.mdi.addWindow(self.scanwindow)

279

#self.scanwindow.showMaximized()

280

#self.mcawindow.showMaximized()

281

else:

282

if QTVERSION < '4.0.0':

283

self.mainTabWidget = qt.QTabWidget(self.mdi)

284

self.mainTabWidget.setCaption("Main Window")

285

self.mcawindow = McaWindow.McaWidget()

286

self.scanwindow = ScanWindow.ScanWindow()

287

self.mainTabWidget.addTab(self.mcawindow, "MCA")

288

self.mainTabWidget.addTab(self.scanwindow, "SCAN")

289

#self.mdi.addWindow(self.mainTabWidget)

290

self.mainTabWidget.showMaximized()

291

if False:

292

self.connectDispatcher(self.mcawindow, self.sourceWidget)

293

self.connectDispatcher(self.scanwindow, self.sourceWidget)

294

else:

295

self.imageWindowDict = {}

296

self.imageWindowCorrelator = None

297

self.connect(self.sourceWidget,

298

qt.PYSIGNAL("addSelection"),

299

self.dispatcherAddSelectionSlot)

300

self.connect(self.sourceWidget,

301

qt.PYSIGNAL("removeSelection"),

302

self.dispatcherRemoveSelectionSlot)

303

self.connect(self.sourceWidget,

304

qt.PYSIGNAL("replaceSelection"),

305

self.dispatcherReplaceSelectionSlot)

306

self.connect(self.mainTabWidget,

307

qt.SIGNAL("currentChanged(QWidget*)"),

308

self.currentTabIndexChanged)

309

else:

310

self.mainTabWidget = qt.QTabWidget(self.mdi)

311

self.mainTabWidget.setWindowTitle("Main Window")

312

self.mcawindow = McaWindow.McaWidget()

313

self.scanwindow = ScanWindow.ScanWindow()

314

if OBJECT3D:

315

self.glWindow = SceneGLWindow.SceneGLWindow()

316

self.mainTabWidget.addTab(self.mcawindow, "MCA")

317

self.mainTabWidget.addTab(self.scanwindow, "SCAN")

318

if OBJECT3D:

319

self.mainTabWidget.addTab(self.glWindow, "OpenGL")

320

self.mdi.addWindow(self.mainTabWidget)

321

#print "Markus patch"

322

#self.mainTabWidget.show()

323

#print "end Markus patch"

324

self.mainTabWidget.showMaximized()

325

if False:

326

self.connectDispatcher(self.mcawindow, self.sourceWidget)

327

self.connectDispatcher(self.scanwindow, self.sourceWidget)

328

else:

329

self.imageWindowDict = {}

330

self.imageWindowCorrelator = None

331

self.connect(self.sourceWidget,

332

qt.SIGNAL("addSelection"),

333

self.dispatcherAddSelectionSlot)

334

self.connect(self.sourceWidget,

335

qt.SIGNAL("removeSelection"),

336

self.dispatcherRemoveSelectionSlot)

337

self.connect(self.sourceWidget,

338

qt.SIGNAL("replaceSelection"),

339

self.dispatcherReplaceSelectionSlot)

340

self.connect(self.mainTabWidget,

341

qt.SIGNAL("currentChanged(int)"),

342

self.currentTabIndexChanged)

343

344

345

if QTVERSION < '4.0.0':

346

self.connect(self.sourceWidget,

347

qt.PYSIGNAL("otherSignals"),

348

self.dispatcherOtherSignalsSlot)

349

else:

350

self.connect(self.sourceWidget,

351

qt.SIGNAL("otherSignals"),

352

self.dispatcherOtherSignalsSlot)

353

if 0:

354

if QTVERSION < '4.0.0':

355

self.connect(self.mcawindow,qt.PYSIGNAL('McaWindowSignal'),

356

self.__McaWindowSignal)

357

else:

358

self.connect(self.mcawindow,qt.SIGNAL('McaWindowSignal'),

359

self.__McaWindowSignal)

360

if kw.has_key('shm'):

361

if len(kw['shm']) >= 8:

362

if kw['shm'][0:8] in ['MCA_DATA', 'XIA_DATA']:

363

self.mcawindow.showMaximized()

364

self.toggleSource()

365

else:

366

self.mcawindow.showMaximized()

367

currentConfigDict = ConfigDict.ConfigDict()

368

defaultFileName = self.__getDefaultSettingsFile()

369

self.configDir = os.path.dirname(defaultFileName)

370

if not kw.has_key('fresh'):

371

if os.path.exists(defaultFileName):

372

currentConfigDict.read(defaultFileName)

373

self.setConfig(currentConfigDict)

374

if kw.has_key('spec') and kw.has_key('shm'):

375

if len(kw['shm']) >= 8:

376

#if kw['shm'][0:8] in ['MCA_DATA', 'XIA_DATA']:

377

if kw['shm'][0:8] in ['MCA_DATA']:

378

#self.mcawindow.showMaximized()

379

self.toggleSource()

380

self._startupSelection(source=kw['spec'],

381

selection=kw['shm'])

382

else:

383

self._startupSelection(source=kw['spec'],

384

selection=None)

385

else:

386

self._startupSelection(source=kw['spec'],

387

selection=None)

388

389

def connectDispatcher(self, viewer, dispatcher = None):

390

#I could connect sourceWidget to myself and then

391

#pass the selections to the active window!!

392

#That will be made in a next iteration I guess

393

if dispatcher is None: dispatcher = self.sourceWidget

394

if QTVERSION < '4.0.0':

395

self.connect(dispatcher, qt.PYSIGNAL("addSelection"),

396

viewer._addSelection)

397

self.connect(dispatcher, qt.PYSIGNAL("removeSelection"),

398

viewer._removeSelection)

399

self.connect(dispatcher, qt.PYSIGNAL("replaceSelection"),

400

viewer._replaceSelection)

401

else:

402

self.connect(dispatcher, qt.SIGNAL("addSelection"),

403

viewer._addSelection)

404

self.connect(dispatcher, qt.SIGNAL("removeSelection"),

405

viewer._removeSelection)

406

self.connect(dispatcher, qt.SIGNAL("replaceSelection"),

407

viewer._replaceSelection)

408

409

def currentTabIndexChanged(self, index):

410

if QTVERSION < '4.0.0':

411

#is not an index but a widget

412

index = self.mainTabWidget.indexOf(index)

413

legend = str(self.mainTabWidget.label(index))

414

else:

415

legend = str(self.mainTabWidget.tabText(index))

416

for key in self.imageWindowDict.keys():

417

if key == legend:value = True

418

else: value = False

419

self.imageWindowDict[key].setPlotEnabled(value)

420

421

def _is2DSelection(self, ddict):

422

if ddict.has_key('imageselection'):

423

if ddict['imageselection']:

424

return True

425

return False

426

427

def _is3DSelection(self, ddict):

428

if self._is2DSelection(ddict):

429

return False

430

431

if ddict.has_key('selection'):

432

if ddict['selection'] is None:

433

return False

434

if ddict['selection'].has_key('selectiontype'):

435

if ddict['selection']['selectiontype'] == '3D':

436

return True

437

438

if ddict['selection'].has_key('x'):

439

if ddict['selection']['x'] is not None:

440

if len(ddict['selection']['x']) > 1:

441

return True

442

return False

443

444

def dispatcherAddSelectionSlot(self, ddict):

445

if self.__useTabWidget:

446

if self.mainTabWidget.isHidden():

447

#make sure it is visible in case of being closed

448

self.mainTabWidget.show()

449

if DEBUG:

450

return self._dispatcherAddSelectionSlot(ddict)

451

try:

452

return self._dispatcherAddSelectionSlot(ddict)

453

except:

454

msg = qt.QMessageBox(self)

455

msg.setIcon(qt.QMessageBox.Critical)

456

msg.setText("Error: %s" % sys.exc_info()[1])

457

if QTVERSION < '4.0.0':

458

msg.exec_loop()

459

else:

460

msg.exec_()

461

462

def _dispatcherAddSelectionSlot(self, ddict):

463

if DEBUG:

464

print "self.dispatcherAddSelectionSlot(ddict), ddict = ",ddict

465

466

toadd = False

467

if self._is2DSelection(ddict):

468

if QTVERSION < '4.0.0':

469

if DEBUG:

470

print "For the time being, no Qt3 support"

471

return

472

if self.imageWindowCorrelator is None:

473

self.imageWindowCorrelator = RGBCorrelator.RGBCorrelator()

474

#toadd = True

475

title = "ImageWindow RGB Correlator"

476

self.imageWindowCorrelator.setWindowTitle(title)

477

legend = ddict['legend']

478

if legend not in self.imageWindowDict.keys():

479

imageWindow = PyMcaImageWindow.PyMcaImageWindow(name = legend,

480

correlator = self.imageWindowCorrelator)

481

self.imageWindowDict[legend] = imageWindow

482

if QTVERSION > '4.0.0':

483

self.connect(imageWindow, qt.SIGNAL("addImageClicked"),

484

self.imageWindowCorrelator.addImageSlot)

485

self.connect(imageWindow, qt.SIGNAL("removeImageClicked"),

486

self.imageWindowCorrelator.removeImageSlot)

487

self.connect(imageWindow, qt.SIGNAL("replaceImageClicked"),

488

self.imageWindowCorrelator.replaceImageSlot)

489

self.mainTabWidget.addTab(imageWindow, legend)

490

if toadd:

491

self.mainTabWidget.addTab(self.imageWindowCorrelator,

492

"RGB Correlator")

493

self.imageWindowDict[legend].setPlotEnabled(False)

494

self.imageWindowDict[legend]._addSelection(ddict)

495

if QTVERSION < '4.0.0':

496

self.mainTabWidget.setCurrentPage(self.mainTab.indexOf(imageWindow))

497

else:

498

self.mainTabWidget.setCurrentWidget(imageWindow)

499

#self.imageWindowDict[legend].setPlotEnabled(True)

500

return

501

if self.mainTabWidget.indexOf(self.imageWindowDict[legend]) < 0:

502

self.mainTabWidget.addTab(self.imageWindowDict[legend],

503

legend)

504

self.imageWindowDict[legend].setPlotEnabled(False)

505

self.imageWindowDict[legend]._addSelection(ddict)

506

if QTVERSION < '4.0.0':

507

self.mainTabWidget.setCurrentPage(self.mainTab.indexOf\

508

(self.imageWindowDict[legend]))

509

else:

510

self.mainTabWidget.setCurrentWidget(self.imageWindowDict\

511

[legend])

512

else:

513

self.imageWindowDict[legend]._addSelection(ddict)

514

else:

515

if OBJECT3D:

516

if ddict['dataobject'].info['selectiontype'] == "1D":

517

self.mcawindow._addSelection(ddict)

518

self.scanwindow._addSelection(ddict)

519

else:

520

self.mainTabWidget.setCurrentWidget(self.glWindow)

521

self.glWindow._addSelection(ddict)

522

else:

523

self.mcawindow._addSelection(ddict)

524

self.scanwindow._addSelection(ddict)

525

526

def dispatcherRemoveSelectionSlot(self, ddict):

527

try:

528

return self._dispatcherRemoveSelectionSlot(ddict)

529

except:

530

msg = qt.QMessageBox(self)

531

msg.setIcon(qt.QMessageBox.Critical)

532

msg.setText("Error: %s" % sys.exc_info()[1])

533

if QTVERSION < '4.0.0':

534

msg.exec_loop()

535

else:

536

msg.exec_()

537

538

539

def _dispatcherRemoveSelectionSlot(self, ddict):

540

if DEBUG:

541

print "self.dispatcherRemoveSelectionSlot(ddict), ddict = ",ddict

542

543

if self._is2DSelection(ddict):

544

if QTVERSION < '4.0.0':

545

if DEBUG:

546

print "For the time being, no Qt3 support"

547

return

548

legend = ddict['legend']

549

if legend in self.imageWindowDict.keys():

550

index = self.mainTabWidget.indexOf(self.imageWindowDict[legend])

551

self.mainTabWidget.removeTab(index)

552

self.imageWindowDict[legend]._removeSelection(ddict)

553

elif self._is3DSelection(ddict):

554

self.glWindow._removeSelection(ddict)

555

else:

556

self.mcawindow._removeSelection(ddict)

557

self.scanwindow._removeSelection(ddict)

558

559

def dispatcherReplaceSelectionSlot(self, ddict):

560

try:

561

return self._dispatcherReplaceSelectionSlot(ddict)

562

except:

563

msg = qt.QMessageBox(self)

564

msg.setIcon(qt.QMessageBox.Critical)

565

msg.setText("Error: %s" % sys.exc_info()[1])

566

if QTVERSION < '4.0.0':

567

msg.exec_loop()

568

else:

569

msg.exec_()

570

571

def _dispatcherReplaceSelectionSlot(self, ddict):

572

if DEBUG:

573

print "self.dispatcherReplaceSelectionSlot(ddict), ddict = ",ddict

574

if self._is2DSelection(ddict):

575

if QTVERSION < '4.0.0':

576

if DEBUG:

577

print "For the time being, no Qt3 support"

578

return

579

legend = ddict['legend']

580

for key in self.imageWindowDict.keys():

581

index = self.mainTabWidget.indexOf(self.imageWindowDict[key])

582

if key == legend:continue

583

if index >= 0:

584

self.mainTabWidget.removeTab(index)

585

self.imageWindowDict[key]._removeSelection(ddict)

586

self.imageWindowDict[key].setPlotEnabled(False)

587

self.dispatcherAddSelectionSlot(ddict)

588

index = self.mainTabWidget.indexOf(self.imageWindowDict[key])

589

if index != self.mainTabWidget.currentIndex():

590

if QTVERSION < '4.0.0':

591

self.mainTabWidget.setCurrentPage(index)

592

else:

593

self.mainTabWidget.setCurrentWidget(self.imageWindowDict[legend])

594

elif self._is3DSelection(ddict):

595

self.glWindow._replaceSelection(ddict)

596

else:

597

self.mcawindow._replaceSelection(ddict)

598

self.scanwindow._replaceSelection(ddict)

599

600

def dispatcherOtherSignalsSlot(self, ddict):

601

if DEBUG:print "self.dispatcherOtherSignalsSlot(ddict), ddict = ",ddict

602

if not self.__useTabWidget:return

603

if ddict['event'] == "SelectionTypeChanged":

604

if QTVERSION < '4.0.0':

605

if ddict['SelectionType'].upper() == "COUNTERS":

606

index = self.mainTabWidget.indexOf(self.scanwindow)

607

self.mainTabWidget.setCurrentPage(index)

608

return

609

for i in range(self.mainTabWidget.count()):

610

if str(self.mainTabWidget.label(i)) == \

611

ddict['SelectionType']:

612

self.mainTabWidget.setCurrentPage(i)

613

else:

614

if ddict['SelectionType'].upper() == "COUNTERS":

615

self.mainTabWidget.setCurrentWidget(self.scanwindow)

616

return

617

for i in range(self.mainTabWidget.count()):

618

if str(self.mainTabWidget.tabText(i)) == \

619

ddict['SelectionType']:

620

self.mainTabWidget.setCurrentIndex(i)

621

return

622

if ddict['event'] == "SourceTypeChanged":

623

pass

624

return

625

if DEBUG:print "Unhandled dict"

626

627

def setConfig(self, configDict):

628

if configDict.has_key('PyMca'): self.__configurePyMca(configDict['PyMca'])

629

if configDict.has_key('ROI'): self.__configureRoi(configDict['ROI'])

630

if configDict.has_key('Elements'): self.__configureElements(configDict['Elements'])

631

if configDict.has_key('Fit'): self.__configureFit(configDict['Fit'])

632

if configDict.has_key('SimpleFit'):self.__configureSimpleFit(configDict['SimpleFit'])

633

634

def getConfig(self):

635

d = {}

636

d['PyMca'] = {}

637

d['PyMca']['VERSION'] = __version__

638

d['PyMca']['ConfigDir'] = self.configDir

639

d['PyMca']['nativeFileDialogs'] = PyMcaDirs.nativeFileDialogs

640

641

#geometry

642

d['PyMca']['Geometry'] ={}

643

r = self.geometry()

644

d['PyMca']['Geometry']['MainWindow'] = [r.x(), r.y(), r.width(), r.height()]

645

r = self.splitter.sizes()

646

d['PyMca']['Geometry']['Splitter'] = r

647

r = self.mcawindow.geometry()

648

d['PyMca']['Geometry']['McaWindow'] = [r.x(), r.y(), r.width(), r.height()]

649

r = self.mcawindow.graph.geometry()

650

d['PyMca']['Geometry']['McaGraph'] = [r.x(), r.y(), r.width(), r.height()]

651

#sources

652

d['PyMca']['Sources'] = {}

653

d['PyMca']['Sources']['lastFileFilter'] = self.sourceWidget.sourceSelector.lastFileFilter

654

for source in SOURCESLIST:

655

d['PyMca'][source] = {}

656

if self.sourceWidget.sourceSelector.lastInputDir is not None:

657

d['PyMca'][source]['lastInputDir'] = self.sourceWidget.sourceSelector.lastInputDir

658

try:

659

PyMcaDirs.inputDir = self.sourceWidget.sourceSelector.lastInputDir

660

except ValueError:

661

pass

662

else:

663

d['PyMca'][source]['lastInputDir'] = "None"

664

if source == "SpecFile":

665

d['PyMca'][source]['SourceName'] = []

666

for key in self.sourceWidget.sourceList:

667

if key.sourceType == source:

668

d['PyMca'][source]['SourceName'].append(key.sourceName)

669

elif source == "EdfFile":

670

d['PyMca'][source]['SourceName'] = []

671

for key in self.sourceWidget.sourceList:

672

if key.sourceType == source:

673

d['PyMca'][source]['SourceName'].append(key.sourceName)

674

#if key == "EDF Stack":

675

# d['PyMca'][source]['SourceName'].append(self.sourceWidget.selectorWidget[source]._edfstack)

676

#else:

677

# d['PyMca'][source]['SourceName'].append(self.sourceWidget.selectorWidget[source].mapComboName[key])

678

elif source == "HDF5":

679

d['PyMca'][source]['SourceName'] = []

680

for key in self.sourceWidget.sourceList:

681

if key.sourceType == source:

682

d['PyMca'][source]['SourceName'].append(key.sourceName)

683

selectorWidget = self.sourceWidget.selectorWidget[source]

684

if hasattr(selectorWidget,'setWidgetConfiguration'):

685

d['PyMca'][source]['WidgetConfiguration'] = selectorWidget.getWidgetConfiguration()

686

687

#d['PyMca'][source]['Selection'] = self.sourceWidget[source].getSelection()

688

#ROIs

689

d['ROI']={}

690

roilist, roidict = self.mcawindow.roiwidget.getroilistanddict()

691

d['ROI']['roilist'] = roilist

692

d['ROI']['roidict'] = {}

693

d['ROI']['roidict'].update(roidict)

694

695

#fit related

696

d['Elements'] = {}

697

d['Elements']['Material'] = {}

698

d['Elements']['Material'].update(ElementsInfo.Elements.Material)

699

d['Fit'] = {}

700

if self.mcawindow.advancedfit.configDir is not None:

701

d['Fit'] ['ConfigDir'] = self.mcawindow.advancedfit.configDir * 1

702

d['Fit'] ['Configuration'] = {}

703

d['Fit'] ['Configuration'].update(self.mcawindow.advancedfit.mcafit.configure())

704

d['Fit'] ['Information'] = {}

705

d['Fit'] ['Information'].update(self.mcawindow.advancedfit.info)

706

d['Fit'] ['LastFit'] = {}

707

d['Fit'] ['LastFit']['hidden'] = self.mcawindow.advancedfit.isHidden()

708

d['Fit'] ['LastFit']['xdata0'] = self.mcawindow.advancedfit.mcafit.xdata0

709

d['Fit'] ['LastFit']['ydata0'] = self.mcawindow.advancedfit.mcafit.ydata0

710

d['Fit'] ['LastFit']['sigmay0']= self.mcawindow.advancedfit.mcafit.sigmay0

711

d['Fit'] ['LastFit']['fitdone']= self.mcawindow.advancedfit._fitdone()

712

#d['Fit'] ['LastFit']['fitdone']= 1

713

#d['Fit'] ['LastFit']['xmin'] = self.mcawindow.advancedfit.mcafit.sigma0

714

#d['Fit'] ['LastFit']['xmax'] = self.mcawindow.advancedfit.mcafit.sigma0

715

return d

716

717

def saveConfig(self, config, filename = None):

718

d = ConfigDict.ConfigDict()

719

d.update(config)

720

if filename is None:

721

filename = self.__getDefaultSettingsFile()

722

d.write(filename)

723

724

def __configurePyMca(self, dict):

725

if dict.has_key('ConfigDir'):

726

self.configDir = dict['ConfigDir']

727

728

if dict.has_key('Geometry'):

729

r = qt.QRect(*dict['Geometry']['MainWindow'])

730

self.setGeometry(r)

731

key = 'Splitter'

732

if key in dict['Geometry'].keys():

733

self.splitter.setSizes(dict['Geometry'][key])

734

key = 'McaWindow'

735

if key in dict['Geometry'].keys():

736

r = qt.QRect(*dict['Geometry']['McaWindow'])

737

self.mcawindow.setGeometry(r)

738

key = 'McaGraph'

739

if key in dict['Geometry'].keys():

740

r = qt.QRect(*dict['Geometry']['McaGraph'])

741

self.mcawindow.graph.setGeometry(r)

742

self.show()

743

qt.qApp.processEvents()

744

qt.qApp.postEvent(self, qt.QResizeEvent(qt.QSize(dict['Geometry']['MainWindow'][2]+1,

745

dict['Geometry']['MainWindow'][3]+1),

746

qt.QSize(dict['Geometry']['MainWindow'][2],

747

dict['Geometry']['MainWindow'][3])))

748

self.mcawindow.showMaximized()

749

750

PyMcaDirs.nativeFileDialogs = dict.get('nativeFileDialogs', True)

751

752

if dict.has_key('Sources'):

753

if dict['Sources'].has_key('lastFileFilter'):

754

self.sourceWidget.sourceSelector.lastFileFilter = dict['Sources']['lastFileFilter']

755

for source in SOURCESLIST:

756

if dict.has_key(source):

757

if dict[source].has_key('lastInputDir'):

758

if dict[source] ['lastInputDir'] != "None":

759

self.sourceWidget.sourceSelector.lastInputDir = dict[source] ['lastInputDir']

760

try:

761

PyMcaDirs.inputDir = dict[source] ['lastInputDir']

762

except ValueError:

763

pass

764

if dict[source].has_key('SourceName'):

765

if type(dict[source]['SourceName']) != type([]):

766

dict[source]['SourceName'] = [dict[source]['SourceName'] * 1]

767

for SourceName in dict[source]['SourceName']:

768

if len(SourceName):

769

try:

770

if not os.path.exists(SourceName): continue

771

self.sourceWidget.sourceSelector.openFile(SourceName, justloaded =1)

772

continue

773

#This event is not needed

774

ndict = {}

775

ndict["event"] = "NewSourceSelected"

776

ndict["sourcelist"] = [SourceName]

777

self.sourceWidget._sourceSelectorSlot(ndict)

778

continue

779

if source == "EdfFile":

780

self.sourceWidget.selectorWidget[source].openFile(SourceName, justloaded=1)

781

else:

782

self.sourceWidget.selectorWidget[source].openFile(SourceName)

783

except:

784

msg = qt.QMessageBox(self)

785

msg.setIcon(qt.QMessageBox.Critical)

786

msg.setText("Error: %s\n opening file %s" % (sys.exc_info()[1],SourceName ))

787

if QTVERSION < '4.0.0':

788

msg.exec_loop()

789

else:

790

msg.exec_()

791

792

if dict[source].has_key('WidgetConfiguration'):

793

selectorWidget = self.sourceWidget.selectorWidget[source]

794

if hasattr(selectorWidget,'setWidgetConfiguration'):

795

try:

796

selectorWidget.setWidgetConfiguration(dict[source]['WidgetConfiguration'])

797

except:

798

msg = qt.QMessageBox(self)

799

msg.setIcon(qt.QMessageBox.Critical)

800

msg.setText("Error: %s\n configuring %s widget" % (sys.exc_info()[1], source ))

801

if QTVERSION < '4.0.0':

802

msg.exec_loop()

803

else:

804

msg.exec_()

805

"""

806

if dict[source].has_key('Selection'):

807

if type(dict[source]['Selection']) != type([]):

808

dict[source]['Selection'] = [dict[source]['Selection']]

809

if source == "EdfFile":

810

self.sourceWidget[source].setSelected(dict[source]['Selection'])

811

"""

812

813

814

def __configureRoi(self, dict):

815

if dict.has_key('roidict'):

816

if dict.has_key('roilist'):

817

roilist = dict['roilist']

818

if type(roilist) != type([]):

819

roilist=[roilist]

820

roidict = dict['roidict']

821

self.mcawindow.roiwidget.fillfromroidict(roilist=roilist,

822

roidict=roidict)

823

824

825

def __configureElements(self, dict):

826

if dict.has_key('Material'):

827

ElementsInfo.Elements.Material.update(dict['Material'])

828

829

def __configureFit(self, d):

830

if d.has_key('Configuration'):

831

self.mcawindow.advancedfit.mcafit.configure(d['Configuration'])

832

if not self.mcawindow.advancedfit.isHidden():

833

self.mcawindow.advancedfit._updateTop()

834

if d.has_key('ConfigDir'):

835

self.mcawindow.advancedfit.configDir = d['ConfigDir'] * 1

836

if False and d.has_key('LastFit'):

837

if (d['LastFit']['ydata0'] != None) and \

838

(d['LastFit']['ydata0'] != 'None'):

839

self.mcawindow.advancedfit.setdata(x=d['LastFit']['xdata0'],

840

y=d['LastFit']['ydata0'],

841

sigmay=d['LastFit']['sigmay0'],

842

**d['Information'])

843

if d['LastFit']['hidden'] == 'False':

844

self.mcawindow.advancedfit.show()

845

self.mcawindow.advancedfit.raiseW()

846

if d['LastFit']['fitdone']:

847

try:

848

self.mcawindow.advancedfit.fit()

849

except:

850

pass

851

else:

852

print "hidden"

853

854

def __configureSimpleFit(self, dict):

855

pass

856

857

def initMenuBar(self):

858

if self.options["MenuFile"]:

859

if QTVERSION < '4.0.0':

860

self.menuFile= qt.QPopupMenu(self.menuBar())

861

idx= self.menuFile.insertItem(self.Icons["fileopen"], qt.QString("&Open"), self.onOpen, qt.Qt.CTRL+qt.Qt.Key_O)

862

self.menuFile.setWhatsThis(idx, HelpDict["fileopen"])

863

idx= self.menuFile.insertItem(self.Icons["filesave"], "&Save as", self.onSaveAs, qt.Qt.CTRL+qt.Qt.Key_S)

864

self.menuFile.setWhatsThis(idx, HelpDict["filesave"])

865

self.menuFile.insertItem("Save &Defaults", self.onSave)

866

self.menuFile.insertSeparator()

867

idx= self.menuFile.insertItem(self.Icons["fileprint"], "&Print", self.onPrint, qt.Qt.CTRL+qt.Qt.Key_P)

868

self.menuFile.setWhatsThis(idx, HelpDict["fileprint"])

869

self.menuFile.insertSeparator()

870

self.menuFile.insertItem("&Quit", qt.qApp, qt.SLOT("closeAllWindows()"), qt.Qt.CTRL+qt.Qt.Key_Q)

871

self.menuBar().insertItem('&File',self.menuFile)

872

self.onInitMenuBar(self.menuBar())

873

874

else:

875

#build the actions

876

#fileopen

877

self.actionOpen = qt.QAction(self)

878

self.actionOpen.setText(qt.QString("&Open"))

879

self.actionOpen.setIcon(self.Icons["fileopen"])

880

self.actionOpen.setShortcut(qt.Qt.CTRL+qt.Qt.Key_O)

881

self.connect(self.actionOpen, qt.SIGNAL("triggered(bool)"),

882

self.onOpen)

883

#filesaveas

884

self.actionSaveAs = qt.QAction(self)

885

self.actionSaveAs.setText(qt.QString("&Save"))

886

self.actionSaveAs.setIcon(self.Icons["filesave"])

887

self.actionSaveAs.setShortcut(qt.Qt.CTRL+qt.Qt.Key_S)

888

self.connect(self.actionSaveAs, qt.SIGNAL("triggered(bool)"),

889

self.onSaveAs)

890

891

#filesave

892

self.actionSave = qt.QAction(self)

893

self.actionSave.setText(qt.QString("Save &Default Settings"))

894

#self.actionSave.setIcon(self.Icons["filesave"])

895

#self.actionSave.setShortcut(qt.Qt.CTRL+qt.Qt.Key_S)

896

self.connect(self.actionSave, qt.SIGNAL("triggered(bool)"),

897

self.onSave)

898

#fileprint

899

self.actionPrint = qt.QAction(self)

900

self.actionPrint.setText(qt.QString("&Print"))

901

self.actionPrint.setIcon(self.Icons["fileprint"])

902

self.actionPrint.setShortcut(qt.Qt.CTRL+qt.Qt.Key_P)

903

self.connect(self.actionPrint, qt.SIGNAL("triggered(bool)"),

904

self.onPrint)

905

906

#filequit

907

self.actionQuit = qt.QAction(self)

908

self.actionQuit.setText(qt.QString("&Quit"))

909

#self.actionQuit.setIcon(self.Icons["fileprint"])

910

self.actionQuit.setShortcut(qt.Qt.CTRL+qt.Qt.Key_Q)

911

qt.QObject.connect(self.actionQuit,

912

qt.SIGNAL("triggered(bool)"),

913

qt.qApp,

914

qt.SLOT("closeAllWindows()"))

915

916

#self.menubar = qt.QMenuBar(self)

917

self.menuFile= qt.QMenu(self.menuBar())

918

self.menuFile.addAction(self.actionOpen)

919

self.menuFile.addAction(self.actionSaveAs)

920

self.menuFile.addAction(self.actionSave)

921

self.menuFile.addSeparator()

922

self.menuFile.addAction(self.actionPrint)

923

self.menuFile.addSeparator()

924

self.menuFile.addAction(self.actionQuit)

925

self.menuBar().addMenu(self.menuFile)

926

self.menuFile.setTitle("&File")

927

self.onInitMenuBar(self.menuBar())

928

929

if self.options["MenuTools"]:

930

if QTVERSION < '4.0.0':

931

self.menuTools= qt.QPopupMenu()

932

self.menuTools.setCheckable(1)

933

self.connect(self.menuTools, qt.SIGNAL("aboutToShow()"), self.menuToolsAboutToShow)

934

self.menuBar().insertItem("&Tools", self.menuTools)

935

else:

936

self.menuTools= qt.QMenu()

937

#self.menuTools.setCheckable(1)

938

self.connect(self.menuTools, qt.SIGNAL("aboutToShow()"),

939

self.menuToolsAboutToShow)

940

self.menuTools.setTitle("&Tools")

941

self.menuBar().addMenu(self.menuTools)

942

943

if self.options["MenuWindow"]:

944

if QTVERSION < '4.0.0':

945

self.menuWindow= qt.QPopupMenu()

946

self.menuWindow.setCheckable(1)

947

self.connect(self.menuWindow, qt.SIGNAL("aboutToShow()"), self.menuWindowAboutToShow)

948

self.menuBar().insertItem("&Window", self.menuWindow)

949

else:

950

self.menuWindow= qt.QMenu()

951

#self.menuWindow.setCheckable(1)

952

self.connect(self.menuWindow, qt.SIGNAL("aboutToShow()"), self.menuWindowAboutToShow)

953

self.menuWindow.setTitle("&Window")

954

self.menuBar().addMenu(self.menuWindow)

955

956

if self.options["MenuHelp"]:

957

if QTVERSION < '4.0.0':

958

self.menuHelp= qt.QPopupMenu(self)

959

self.menuHelp.insertItem("&Menu", self.onMenuHelp)

960

self.menuHelp.insertItem("&Data Display HOWTOs", self.onDisplayHowto)

961

self.menuHelp.insertItem("MCA &HOWTOs",self.onMcaHowto)

962

self.menuHelp.insertSeparator()

963

self.menuHelp.insertItem("&About", self.onAbout)

964

self.menuHelp.insertItem("About &Qt",self.onAboutQt)

965

self.menuBar().insertSeparator()

966

self.menuBar().insertItem("&Help", self.menuHelp)

967

self.menuBrowser = None

968

self.displayBrowser = None

969

self.mcaBrowser = None

970

else:

971

self.menuHelp= qt.QMenu(self)

972

self.menuHelp.addAction("&Menu", self.onMenuHelp)

973

self.menuHelp.addAction("&Data Display HOWTOs", self.onDisplayHowto)

974

self.menuHelp.addAction("MCA &HOWTOs",self.onMcaHowto)

975

self.menuHelp.addSeparator()

976

self.menuHelp.addAction("&About", self.onAbout)

977

self.menuHelp.addAction("Changes", self.onChanges)

978

self.menuHelp.addAction("About &Qt",self.onAboutQt)

979

self.menuBar().addSeparator()

980

self.menuHelp.setTitle("&Help")

981

self.menuBar().addMenu(self.menuHelp)

982

self.menuBrowser = None

983

self.displayBrowser = None

984

self.mcaBrowser = None

985

986

987

def initSourceBrowser(self):

988

self.sourceFrame = qt.QWidget(self.splitter)

989

if QTVERSION < '4.0.0':

990

self.splitter.moveToFirst(self.sourceFrame)

991

else:

992

self.splitter.insertWidget(0, self.sourceFrame)

993

self.sourceFrame.setWindowTitle("Source Selector")

994

self.sourceFrame.setWindowIcon(self.windowIcon())

995

#self.splitter.setResizeMode(self.sourceFrame,qt.QSplitter.KeepSize)

996

self.sourceFrameLayout = qt.QVBoxLayout(self.sourceFrame)

997

self.sourceFrameLayout.setMargin(0)

998

self.sourceFrameLayout.setSpacing(0)

999

#layout.setAutoAdd(1)

1000

1001

sourceToolbar = qt.QWidget(self.sourceFrame)

1002

layout1 = qt.QHBoxLayout(sourceToolbar)

1003

#self.line1 = qt.QFrame(sourceToolbar,"line1")

1004

self.line1 = Line(sourceToolbar)

1005

self.line1.setFrameShape(qt.QFrame.HLine)

1006

self.line1.setFrameShadow(qt.QFrame.Sunken)

1007

self.line1.setFrameShape(qt.QFrame.HLine)

1008

layout1.addWidget(self.line1)

1009

#self.closelabel = qt.QLabel(sourceToolbar)

1010

self.closelabel = PixmapLabel(sourceToolbar)

1011

self.closelabel.setPixmap(qt.QPixmap(IconDict['close']))

1012

layout1.addWidget(self.closelabel)

1013

self.closelabel.setSizePolicy(qt.QSizePolicy(qt.QSizePolicy.Fixed, qt.QSizePolicy.Fixed))

1014

#self.sourceBrowserTab=qt.QTabWidget(self.sourceFrame)

1015

1016

self.sourceFrameLayout.addWidget(sourceToolbar)

1017

1018

if QTVERSION < '4.0.0':

1019

#connections

1020

self.connect(self.line1,qt.PYSIGNAL("LineDoubleClickEvent"),self.sourceReparent)

1021

self.connect(self.closelabel,qt.PYSIGNAL("PixmapLabelMousePressEvent"),self.toggleSource)

1022

1023

#tips

1024

qt.QToolTip.add(self.line1,"DoubleClick toggles floating window mode")

1025

qt.QToolTip.add(self.closelabel,"Hides Source Area")

1026

else:

1027

#connections

1028

self.connect(self.line1,qt.SIGNAL("LineDoubleClickEvent"),self.sourceReparent)

1029

self.connect(self.closelabel,qt.SIGNAL("PixmapLabelMousePressEvent"),self.toggleSource)

1030

1031

#tips

1032

self.line1.setToolTip("DoubleClick toggles floating window mode")

1033

self.closelabel.setToolTip("Hides Source Area")

1034

1035

def sourceReparent(self,ddict = None):

1036

if self.sourceFrame.parent() is not None:

1037

if QTVERSION < '4.0.0':

1038

self.sourceFrame.reparent(None,self.cursor().pos(),1)

1039

self.splitter.moveToFirst(self.sourceFrame)

1040

else:

1041

self.sourceFrame.setParent(None)

1042

self.sourceFrame.move(self.cursor().pos())

1043

self.sourceFrame.show()

1044

else:

1045

if QTVERSION < '4.0.0':

1046

self.sourceFrame.reparent(self.splitter,qt.QPoint(),1)

1047

self.splitter.moveToFirst(self.sourceFrame)

1048

else:

1049

try:

1050

self.splitter.insertWidget(0, self.sourceFrame)

1051

except:

1052

self.sourceFrame.setParent(self.splitter)

1053

1054

def initSource(self):

1055

self.sourceWidget = QDispatcher.QDispatcher(self.sourceFrame)

1056

self.sourceFrameLayout.addWidget(self.sourceWidget)

1057

1058

def _startupSelection(self, source, selection):

1059

self.sourceWidget.sourceSelector.openSource(source)

1060

if selection is None:return

1061

1062

if len(selection) >= 8:

1063

if selection[0:8] == "MCA_DATA":

1064

ddict= {}

1065

ddict['event'] = "addSelection"

1066

ddict['SourceName'] = source

1067

ddict['Key'] = selection

1068

ddict["selection"] = {'cols': {'y': [1], 'x': [0]}}

1069

ddict["legend"] = ddict['SourceName'] + ' %s.c.1' %selection

1070

ddict["SourceType"] = 'SPS'

1071

self.sourceWidget._addSelectionSlot([ddict])

1072

if QTVERSION < '4.0.0':

1073

self.mcawindow.control.calbox.setCurrentItem(2)

1074

else:

1075

self.mcawindow.control.calbox.setCurrentIndex(2)

1076

self.mcawindow.calibration = self.mcawindow.calboxoptions[2]

1077

self.mcawindow.control._calboxactivated("Internal")

1078

else:

1079

return

1080

"""

1081

elif selection == "XIA_DATA":

1082

ddict= {}

1083

ddict['event'] = "addSelection"

1084

ddict['SourceName'] = "armando5"

1085

ddict['Key'] = selection

1086

ddict["selection"] = {'rows': {'y': [1], 'x': [0]}}

1087

ddict["legend"] = ddict['SourceName'] + ' XIA_DATA.c.1'

1088

ddict["SourceType"] = 'SPS'

1089

self.sourceWidget._addSelectionSlot([ddict])

1090

"""

1091

1092

def menuToolsAboutToShow(self):

1093

if DEBUG:

1094

print "menu ToolsAboutToShow"

1095

self.menuTools.clear()

1096

if QTVERSION < '4.0.0':

1097

if self.sourceFrame.isHidden():

1098

self.menuTools.insertItem("Show Source",self.toggleSource)

1099

else:

1100

self.menuTools.insertItem("Hide Source",self.toggleSource)

1101

#self.menuTools.insertItem("Choose Font",self.fontdialog)

1102

self.menuTools.insertItem("Elements Info",self.__elementsInfo)

1103

self.menuTools.insertItem("Identify Peaks",self.__peakIdentifier)

1104

self.menuTools.insertItem("Batch Fitting",self.__batchFitting)

1105

self.menuTools.insertItem("Convert Mca to Edf",self.__mca2EdfConversion)

1106

#self.menuTools.insertItem("Fit to Specfile",self.__fit2SpecConversion)

1107

if STACK:

1108

self.menuTools.insertItem("ROI Imaging",self.__roiImaging)

1109

else:

1110

if self.sourceFrame.isHidden():

1111

self.menuTools.addAction("Show Source",self.toggleSource)

1112

else:

1113

self.menuTools.addAction("Hide Source",self.toggleSource)

1114

self.menuTools.addAction("Elements Info",self.__elementsInfo)

1115

self.menuTools.addAction("Material Transmission",self.__attTool)

1116

self.menuTools.addAction("Identify Peaks",self.__peakIdentifier)

1117

self.menuTools.addAction("Batch Fitting",self.__batchFitting)

1118

self.menuTools.addAction("Convert Mca to Edf",self.__mca2EdfConversion)

1119

#self.menuTools.addAction("Fit to Specfile",self.__fit2SpecConversion)

1120

self.menuTools.addAction("RGB Correlator",self.__rgbCorrelator)

1121

if STACK:

1122

self.menuTools.addAction("ROI Imaging",self.__roiImaging)

1123

if XIA_CORRECT:

1124

self.menuTools.addAction("XIA Correct",

1125

self.__xiaCorrect)

1126

if DEBUG:"print Fit to Specfile missing"

1127

def fontdialog(self):

1128

fontd = qt.QFontDialog.getFont(self)

1129

if fontd[1]:

1130

qt.qApp.setFont(fontd[0],1)

1131

1132

1133

def toggleSource(self,**kw):

1134

if DEBUG:

1135

print "toggleSource called"

1136

if self.sourceFrame.isHidden():

1137

self.sourceFrame.show()

1138

if QTVERSION < '4.0.0': self.sourceFrame.raiseW()

1139

else:self.sourceFrame.raise_()

1140

else:

1141

self.sourceFrame.hide()

1142

1143

def __elementsInfo(self):

1144

if self.elementsInfo is None:self.elementsInfo=ElementsInfo.ElementsInfo(None,"Elements Info")

1145

if self.elementsInfo.isHidden():

1146

self.elementsInfo.show()

1147

if QTVERSION < '4.0.0': self.elementsInfo.raiseW()

1148

else:self.elementsInfo.raise_()

1149

1150

def __attTool(self):

1151

if self.attenuationTool is None:

1152

self.attenuationTool = MaterialEditor.MaterialEditor(toolmode=True)

1153

if self.attenuationTool.isHidden():

1154

self.attenuationTool.show()

1155

self.attenuationTool.raise_()

1156

1157

def __peakIdentifier(self):

1158

if self.identifier is None:

1159

self.identifier=PeakIdentifier.PeakIdentifier(energy=5.9,

1160

useviewer=1)

1161

self.identifier.myslot()

1162

if self.identifier.isHidden():

1163

self.identifier.show()

1164

if QTVERSION < '4.0.0': self.identifier.raiseW()

1165

else:self.identifier.raise_()

1166

1167

def __batchFitting(self):

1168

if self.__batch is None:self.__batch = PyMcaBatch.McaBatchGUI(fl=0,actions=1)

1169

if self.__batch.isHidden():self.__batch.show()

1170

if QTVERSION < '4.0.0': self.__batch.raiseW()

1171

else: self.__batch.raise_()

1172

1173

def __mca2EdfConversion(self):

1174

if self.__mca2Edf is None:self.__mca2Edf = Mca2Edf.Mca2EdfGUI(fl=0,actions=1)

1175

if self.__mca2Edf.isHidden():self.__mca2Edf.show()

1176

if QTVERSION < '4.0.0': self.__mca2Edf.raiseW()

1177

else:self.__mca2Edf.raise_()

1178

1179

def __fit2SpecConversion(self):

1180

if self.__fit2Spec is None:self.__fit2Spec = Fit2Spec.Fit2SpecGUI(fl=0,actions=1)

1181

if self.__fit2Spec.isHidden():self.__fit2Spec.show()

1182

if QTVERSION < '4.0.0': self.__fit2Spec.raiseW()

1183

else:self.__fit2Spec.raise_()

1184

1185

def __rgbCorrelator(self):

1186

if self.__correlator is None:self.__correlator = []

1187

fileTypeList = ["Batch Result Files (*dat)",

1188

"EDF Files (*edf)",

1189

"EDF Files (*ccd)",

1190

"All Files (*)"]

1191

message = "Open ONE Batch result .dat file or SEVERAL EDF files"

1192

filelist = self.__getStackOfFiles(fileTypeList, message)

1193

if not(len(filelist)): return

1194

filelist.sort()

1195

self.sourceWidget.sourceSelector.lastInputDir = os.path.dirname(filelist[0])

1196

PyMcaDirs.inputDir = os.path.dirname(filelist[0])

1197

self.__correlator.append(PyMcaPostBatch.PyMcaPostBatch())

1198

for correlator in self.__correlator:

1199

if correlator.isHidden():

1200

correlator.show()

1201

correlator.raise_()

1202

self.connect(self.__correlator[-1],

1203

qt.SIGNAL("RGBCorrelatorSignal"),

1204

self._deleteCorrelator)

1205

1206

if len(filelist) == 1:

1207

correlator.addBatchDatFile(filelist[0])

1208

else:

1209

correlator.addFileList(filelist)

1210

1211

def _deleteCorrelator(self, ddict):

1212

n = len(self.__correlator)

1213

if ddict['event'] == "RGBCorrelatorClosed":

1214

for i in range(n):

1215

if id(self.__correlator[i]) == ddict["id"]:

1216

self.__correlator[i].deleteLater()

1217

del self.__correlator[i]

1218

break

1219

1220

def __getStackOfFiles(self, typelist, message = "", getfilter=False):

1221

wdir = PyMcaDirs.inputDir

1222

fileTypeList = typelist

1223

filterused = None

1224

if QTVERSION < '4.0.0':

1225

filetypes = ""

1226

for filetype in fileTypeList:

1227

filetypes += filetype+"\n"

1228

filelist = qt.QFileDialog.getOpenFileNames(filetypes,

1229

wdir,

1230

self,

1231

message,

1232

message)

1233

if not len(filelist):

1234

if getfilter:

1235

return [], filterused

1236

else:

1237

return []

1238

else:

1239

if PyMcaDirs.nativeFileDialogs:

1240

filetypes = ""

1241

for filetype in fileTypeList:

1242

filetypes += filetype+"\n"

1243

filelist = qt.QFileDialog.getOpenFileNames(self,

1244

message,

1245

wdir,

1246

filetypes)

1247

if not len(filelist):

1248

if getfilter:

1249

return [], filterused

1250

else:

1251

return []

1252

else:

1253

sample = str(filelist[0])

1254

for filetype in fileTypeList:

1255

ftype = filetype.replace("(", "").replace(")","")

1256

extensions = ftype.split()[2:]

1257

for extension in extensions:

1258

if sample.endswith(extension[-3:]):

1259

filterused = filetype

1260

break

1261

else:

1262

fdialog = qt.QFileDialog(self)

1263

fdialog.setModal(True)

1264

fdialog.setWindowTitle(message)

1265

strlist = qt.QStringList()

1266

for filetype in fileTypeList:

1267

strlist.append(filetype.replace("(","").replace(")",""))

1268

fdialog.setFilters(strlist)

1269

fdialog.setFileMode(fdialog.ExistingFiles)

1270

fdialog.setDirectory(wdir)

1271

if QTVERSION > '4.3.0':

1272

history = fdialog.history()

1273

if len(history) > 6:

1274

fdialog.setHistory(history[-6:])

1275

ret = fdialog.exec_()

1276

if ret == qt.QDialog.Accepted:

1277

filelist = fdialog.selectedFiles()

1278

if getfilter:

1279

filterused = str(fdialog.selectedFilter())

1280

fdialog.close()

1281

del fdialog

1282

else:

1283

fdialog.close()

1284

del fdialog

1285

if getfilter:

1286

return [], filterused

1287

else:

1288

return []

1289

filelist = map(str, filelist)

1290

if getfilter:

1291

return filelist, filterused

1292

else:

1293

return filelist

1294

1295

1296

def __roiImaging(self):

1297

if self.__imagingTool is None:

1298

fileTypeList = ["EDF Files (*edf)",

1299

"EDF Files (*ccd)",

1300

"Specfile Files (*mca)",

1301

"Specfile Files (*dat)",

1302

"OMNIC Files (*map)",

1303

"HDF5 Files (*.nxs *.hdf *.h5)",

1304

"AIFIRA Files (*DAT)",

1305

"SupaVisio Files (*pige *pixe *rbs)",

1306

"All Files (*)"]

1307

if 'h5py' not in sys.modules:

1308

idx = fileTypeList.index("HDF5 Files (*.nxs *.hdf *.h5)")

1309

del fileTypeList[idx]

1310

message = "Open ONE indexed stack or SEVERAL files"

1311

filelist, filefilter = self.__getStackOfFiles(fileTypeList,

1312

message,

1313

getfilter=True)

1314

if not(len(filelist)): return

1315

filelist.sort()

1316

self.sourceWidget.sourceSelector.lastInputDir = os.path.dirname(filelist[0])

1317

PyMcaDirs.inputDir = os.path.dirname(filelist[0])

1318

"""

1319

if QTVERSION > '4.0.0':

1320

rgbWidget = PyMcaPostBatch.RGBCorrelator.RGBCorrelator(self.mdi)

1321

rgbWidget.setWindowTitle("ROI Imaging RGB Correlator")

1322

self.mdi.addWindow(rgbWidget)

1323

rgbWidget.show()

1324

else:

1325

rgbWidget = None

1326

"""

1327

rgbWidget = None

1328

try:

1329

widget = QEDFStackWidget.QEDFStackWidget(mcawidget=self.mcawindow,

1330

rgbwidget=rgbWidget,

1331

master=True)

1332

widget.notifyCloseEventToWidget(self)

1333

self.__imagingTool = id(widget)

1334

self._widgetDict[self.__imagingTool] = widget

1335

omnicfile = False

1336

luciafile = False

1337

supavisio = False

1338

aifirafile = False

1339

hdf5file = False

1340

if len(filelist) == 1:

1341

f = open(filelist[0])

1342

line = f.read(10)

1343

f.close()

1344

if line[0]=="\n":

1345

line = line[1:]

1346

if line.startswith('Spectral'):

1347

omnicfile = True

1348

elif line.startswith('#\tDate:'):

1349

luciafile = True

1350

elif "AIFIRA" == filefilter.split()[0].upper():

1351

aifirafile = True

1352

elif "HDF5" == filefilter.split()[0].upper():

1353

hdf5file = True

1354

elif "SupaVisio" == filefilter.split()[0]:

1355

supavisio = True

1356

elif filelist[0][-4:].upper() in ["PIGE", "PIGE"]:

1357

supavisio = True

1358

elif filelist[0][-3:].upper() in ["RBS"]:

1359

supavisio = True

1360

try:

1361

if omnicfile:

1362

widget.setStack(QEDFStackWidget.OmnicMap.OmnicMap(filelist[0]))

1363

elif luciafile:

1364

widget.setStack(QEDFStackWidget.LuciaMap.LuciaMap(filelist[0]))

1365

elif aifirafile:

1366

stack = QEDFStackWidget.AifiraMap.AifiraMap(filelist[0])

1367

masterStack = QEDFStackWidget.DataObject.DataObject()

1368

masterStack.info = QEDFStackWidget.copy.deepcopy(stack.info)

1369

masterStack.data = stack.data[:,:,0:1024]

1370

masterStack.info['Dim_2'] = int(masterStack.info['Dim_2'] / 2)

1371

1372

slaveStack = QEDFStackWidget.DataObject.DataObject()

1373

slaveStack.info = QEDFStackWidget.copy.deepcopy(stack.info)

1374

slaveStack.data = stack.data[:,:, 1024:]

1375

slaveStack.info['Dim_2'] = int(slaveStack.info['Dim_2'] / 2)

1376

widget.setStack(masterStack)

1377

widget.slave = QEDFStackWidget.QEDFStackWidget(rgbwidget=widget.rgbWidget,

1378

master=False)

1379

widget.slave.setStack(slaveStack)

1380

widget.connectSlave(widget.slave)

1381

widget._resetSelection()

1382

widget.loadStackButton.hide()

1383

widget.slave.show()

1384

elif supavisio:

1385

widget.setStack(QEDFStackWidget.SupaVisioMap.SupaVisioMap(filelist[0]))

1386

elif hdf5file:

1387

widget.setStack(QEDFStackWidget.QHDF5Stack1D.QHDF5Stack1D(filelist))

1388

else:

1389

widget.setStack(QEDFStackWidget.QStack(filelist))

1390

except:

1391

widget.setStack(QEDFStackWidget.QSpecFileStack(filelist))

1392

widget.show()

1393

except IOError:

1394

widget = None

1395

del self._widgetDict[self.__imagingTool]

1396

self.__imagingTool = None

1397

msg = qt.QMessageBox(self)

1398

msg.setIcon(qt.QMessageBox.Critical)

1399

msg.setText("Input Output Error: %s" % (sys.exc_info()[1]))

1400

if QTVERSION < '4.0.0':

1401

msg.exec_loop()

1402

else:

1403

msg.exec_()

1404

return

1405

except:

1406

widget = None

1407

del self._widgetDict[self.__imagingTool]

1408

self.__imagingTool = None

1409

msg = qt.QMessageBox(self)

1410

msg.setIcon(qt.QMessageBox.Critical)

1411

print "Error info = ",sys.exc_info()

1412

msg.setText("Unexpected Error: %s" % (sys.exc_info()[1]))

1413

if QTVERSION < '4.0.0':

1414

msg.exec_loop()

1415

else:

1416

msg.exec_()

1417

return

1418

else:

1419

widget = self._widgetDict[self.__imagingTool]

1420

if widget.isHidden():

1421

widget.show()

1422

widget.raise_()

1423

1424

1425

def customEvent(self, event):

1426

if hasattr(event, 'dict'):

1427

ddict = event.dict

1428

if ddict.has_key('event'):

1429

if ddict['event'] == "closeEventSignal":

1430

if self._widgetDict.has_key(ddict['id']):

1431

if ddict['id'] == self.__imagingTool:

1432

self.__imagingTool = None

1433

del self._widgetDict[ddict['id']]

1434

1435

def __xiaCorrect(self):

1436

XiaCorrect.mainGUI(qt.qApp)

1437

1438

def onOpen(self):

1439

if QTVERSION < '4.0.0':

1440

self.openMenu.exec_loop(self.cursor().pos())

1441

else:

1442

self.openMenu.exec_(self.cursor().pos())

1443

1444

def onSave(self):

1445

self._saveAs()

1446

1447

def onSaveAs(self):

1448

if QTVERSION < '4.0.0':

1449

return self._onSaveAs()

1450

index = self.mainTabWidget.currentIndex()

1451

text = str(self.mainTabWidget.tabText(index))

1452

self.saveMenu = qt.QMenu()

1453

self.saveMenu.addAction("PyMca Configuration", self._onSaveAs)

1454

if text.upper() == 'MCA':

1455

self.saveMenu.addAction("Active Mca",

1456

self.mcawindow._saveIconSignal)

1457

elif text.upper() == 'SCAN':

1458

self.saveMenu.addAction("Active Scan",

1459

self.scanwindow._saveIconSignal)

1460

elif text in self.imageWindowDict.keys():

1461

self.saveMenu.addAction("Active Image",

1462

self.imageWindowDict[text].graphWidget._saveIconSignal)

1463

self.saveMenu.exec_(self.cursor().pos())

1464

1465

def _onSaveAs(self):

1466

cwd = os.getcwd()

1467

if QTVERSION < '4.0.0':

1468

outfile = qt.QFileDialog(self,"Output File Selection",1)

1469

outfile.setFilters('PyMca *.ini')

1470

outfile.setMode(outfile.AnyFile)

1471

else:

1472

outfile = qt.QFileDialog(self)

1473

outfile.setFilter('PyMca *.ini')

1474

outfile.setFileMode(outfile.AnyFile)

1475

outfile.setAcceptMode(qt.QFileDialog.AcceptSave)

1476

1477

if os.path.exists(self.configDir):cwd =self.configDir

1478

if QTVERSION < '4.0.0': outfile.setDir(cwd)

1479

else: outfile.setDirectory(cwd)

1480

if QTVERSION < '4.0.0':ret = outfile.exec_loop()

1481

else:ret = outfile.exec_()

1482

if ret:

1483

filterused = str(outfile.selectedFilter()).split()

1484

extension = ".ini"

1485

if QTVERSION < '4.0.0':

1486

outdir=str(outfile.selectedFile())

1487

else:

1488

outdir=str(outfile.selectedFiles()[0])

1489

try:

1490

outputDir = os.path.dirname(outdir)

1491

except:

1492

outputDir = "."

1493

try:

1494

outputFile = os.path.basename(outdir)

1495

except:

1496

outputFile = "PyMca.ini"

1497

outfile.close()

1498

del outfile

1499

else:

1500

outfile.close()

1501

del outfile

1502

return

1503

#always overwrite for the time being

1504

if len(outputFile) < len(extension[:]):

1505

outputFile += extension[:]

1506

elif outputFile[-4:] != extension[:]:

1507

outputFile += extension[:]

1508

filename = os.path.join(outputDir, outputFile)

1509

if os.path.exists(filename):

1510

try:

1511

os.remove(filename)

1512

except IOError:

1513

msg = qt.QMessageBox(self)

1514

msg.setIcon(qt.QMessageBox.Critical)

1515

msg.setText("Input Output Error: %s" % (sys.exc_info()[1]))

1516

if QTVERSION < '4.0.0':

1517

msg.exec_loop()

1518

else:

1519

msg.exec_()

1520

return

1521

try:

1522

self._saveAs(filename)

1523

self.configDir = outputDir

1524

except:

1525

msg = qt.QMessageBox(self)

1526

msg.setIcon(qt.QMessageBox.Critical)

1527

msg.setText("Error Saving Configuration: %s" % (sys.exc_info()[1]))

1528

if QTVERSION < '4.0.0':

1529

msg.exec_loop()

1530

else:

1531

msg.exec_()

1532

return

1533

1534

def _saveAs(self, filename=None):

1535

if filename is None:filename = self.__getDefaultSettingsFile()

1536

self.saveConfig(self.getConfig(), filename)

1537

1538

def __getDefaultSettingsFile(self):

1539

filename = "PyMca.ini"

1540

if sys.platform == 'win32':

1541

home = os.getenv('USERPROFILE')

1542

try:

1543

l = len(home)

1544

directory = os.path.join(home,"My Documents")

1545

except:

1546

home = '\\'

1547

directory = '\\'

1548

#print home

1549

#print directory

1550

if os.path.isdir('%s' % directory):

1551

directory = os.path.join(directory,"PyMca")

1552

else:

1553

#print "My Documents is not there"

1554

directory = os.path.join(home,"PyMca")

1555

if not os.path.exists('%s' % directory):

1556

#print "PyMca directory not present"

1557

os.mkdir('%s' % directory)

1558

#print filename

1559

finalfile = os.path.join(directory, filename)

1560

#print finalfile

1561

else:

1562

home = os.getenv('HOME')

1563

directory = os.path.join(home,"PyMca")

1564

if not os.path.exists('%s' % directory):

1565

os.mkdir('%s' % directory)

1566

finalfile = os.path.join(directory, filename)

1567

return finalfile

1568

1569

def openSource(self,index=0):

1570

if DEBUG:

1571

print "index = ",index

1572

if index <= 0:

1573

if QTVERSION < '4.0.0':

1574

outfile = qt.QFileDialog(self,"Select PyMca Configuration File",1)

1575

if os.path.exists(self.configDir):

1576

outfile.setDir(self.configDir)

1577

outfile.setFilters('PyMca *.ini')

1578

outfile.setMode(outfile.ExistingFile)

1579

ret = outfile.exec_loop()

1580

else:

1581

outfile = qt.QFileDialog(self)

1582

outfile.setWindowTitle("Select PyMca Configuration File")

1583

if os.path.exists(self.configDir):

1584

outfile.setDirectory(self.configDir)

1585

outfile.setFilters(['PyMca *.ini'])

1586

outfile.setFileMode(outfile.ExistingFile)

1587

ret = outfile.exec_()

1588

if ret:

1589

if QTVERSION < '4.0.0':filename=str(outfile.selectedFile())

1590

else:filename=str(outfile.selectedFiles()[0])

1591

outfile.close()

1592

del outfile

1593

else:

1594

outfile.close()

1595

del outfile

1596

return

1597

currentConfigDict = ConfigDict.ConfigDict()

1598

self.configDir = os.path.dirname(filename)

1599

currentConfigDict.read(filename)

1600

self.setConfig(currentConfigDict)

1601

return

1602

else:

1603

index -= 1

1604

source = SOURCESLIST[index]

1605

if self.sourceFrame.isHidden():

1606

self.sourceFrame.show()

1607

if QTVERSION < '4.0.0':self.sourceFrame.raiseW()

1608

else:self.sourceFrame.raise_()

1609

self.sourceBrowserTab.showPage(self.sourceWidget[source])

1610

qt.qApp.processEvents()

1611

self.sourceWidget[source].openFile()

1612

1613

def onMenuHelp(self):

1614

if self.menuBrowser is None:

1615

self.menuBrowser= qt.QTextBrowser()

1616

if QTVERSION < '4.0.0':

1617

self.menuBrowser.setCaption(qt.QString("Main Menu Help"))

1618

else:

1619

self.menuBrowser.setWindowTitle(qt.QString("Main Menu Help"))

1620

dir=os.path.dirname(PyMcaMdi.__file__)

1621

if not os.path.exists(os.path.join(dir,"HTML","Menu.html")):

1622

dir = os.path.dirname(dir)

1623

if QTVERSION < '4.0.0':

1624

self.menuBrowser.mimeSourceFactory().addFilePath(qt.QString(dir+"/HTML"))

1625

self.menuBrowser.setSource(qt.QString("Menu.html"))

1626

else:

1627

self.menuBrowser.setSearchPaths([os.path.join(dir,"HTML")])

1628

self.menuBrowser.setSource(qt.QUrl(qt.QString("Menu.html")))

1629

self.menuBrowser.show()

1630

if self.menuBrowser.isHidden():self.menuBrowser.show()

1631

if QTVERSION < '4.0.0': self.menuBrowser.raiseW()

1632

else: self.menuBrowser.raise_()

1633

1634

def onDisplayHowto(self):

1635

if self.displayBrowser is None:

1636

self.displayBrowser= qt.QTextBrowser()

1637

if QTVERSION < '4.0.0':

1638

self.displayBrowser.setCaption(qt.QString("Data Display HOWTO"))

1639

else:

1640

self.displayBrowser.setWindowTitle(qt.QString("Data Display HOWTO"))

1641

dir=os.path.dirname(PyMcaMdi.__file__)

1642

if not os.path.exists(os.path.join(dir,"HTML","Display-HOWTO.html")):

1643

dir = os.path.dirname(dir)

1644

if QTVERSION < '4.0.0':

1645

self.displayBrowser.mimeSourceFactory().addFilePath(qt.QString(dir+"/HTML"))

1646

self.displayBrowser.setSource(qt.QString("Display-HOWTO.html"))

1647

else:

1648

self.displayBrowser.setSearchPaths([os.path.join(dir,"HTML")])

1649

self.displayBrowser.setSource(qt.QUrl(qt.QString("Display-HOWTO.html")))

1650

self.displayBrowser.show()

1651

if self.displayBrowser.isHidden():self.displayBrowser.show()

1652

if QTVERSION < '4.0.0':self.displayBrowser.raiseW()

1653

else:self.displayBrowser.raise_()

1654

1655

def onMcaHowto(self):

1656

if self.mcaBrowser is None:

1657

self.mcaBrowser= MyQTextBrowser()

1658

if QTVERSION < '4.0.0':

1659

self.mcaBrowser.setCaption(qt.QString("MCA HOWTO"))

1660

else:

1661

self.mcaBrowser.setWindowTitle(qt.QString("MCA HOWTO"))

1662

dir=os.path.dirname(PyMcaMdi.__file__)

1663

if not os.path.exists(dir+"/HTML"+"/MCA-HOWTO.html"):

1664

dir = os.path.dirname(dir)

1665

if QTVERSION < '4.0.0':

1666

self.mcaBrowser.mimeSourceFactory().addFilePath(qt.QString(dir+"/HTML"))

1667

self.mcaBrowser.setSource(qt.QString("MCA-HOWTO.html"))

1668

else:

1669

self.mcaBrowser.setSearchPaths([os.path.join(dir,"HTML")])

1670

self.mcaBrowser.setSource(qt.QUrl(qt.QString("MCA-HOWTO.html")))

1671

#f = open(os.path.join(dir,"HTML","MCA-HOWTO.html"))

1672

#self.mcaBrowser.setHtml(f.read())

1673

#f.close()

1674

self.mcaBrowser.show()

1675

if self.mcaBrowser.isHidden():self.mcaBrowser.show()

1676

if QTVERSION < '4.0.0':self.mcaBrowser.raiseW()

1677

else:self.mcaBrowser.raise_()

1678

1679

def onAbout(self):

1680

qt.QMessageBox.about(self, "PyMca",

1681

"PyMca Application\nVersion: "+__version__)

1682

#self.onDebug()

1683

1684

def onChanges(self):

1685

if self.changeLog is None:

1686

self.changeLog = qt.QTextEdit()

1687

self.changeLog.setCursor(self.cursor())

1688

self.changeLog.setWindowTitle("PyMCA %s Changes" % __version__)

1689

self.changeLog.setWindowIcon(qt.QIcon(qt.QPixmap(IconDict['gioconda16'])))

1690

mpath = os.path.dirname(PyMcaMdi.__file__)

1691

fname = os.path.join(mpath,'changelog.txt')

1692

if not os.path.exists(fname):

1693

while len(mpath) > 3:

1694

fname = os.path.join(mpath,'changelog.txt')

1695

#print "looking for ", fname

1696

if not os.path.exists(fname):

1697

mpath = os.path.dirname(mpath)

1698

else:

1699

break

1700

if os.path.exists(fname):

1701

self.log = ChangeLog.ChangeLog(textfile='changelog.txt')

1702

self.changeLog.setDocument(self.log)

1703

self.changeLog.setMinimumWidth(500)

1704

else:

1705

self.log = ChangeLog.ChangeLog()

1706

self.log.setPlainText('Cannot find file changelog.txt')

1707

self.changeLog.show()

1708

1709

def onDebug(self):

1710

print "Module name = ","PyMca",__revision__.replace("$","")

1711

print "Module name = ","PyQt ",qt.PYQT_VERSION_STR

1712

for module in sys.modules.values():

1713

try:

1714

if 'Revision' in module.__revision__:

1715

if module.__name__ != "__main__":

1716

print "Module name = ",module.__name__,module.__revision__.replace("$","")

1717

except:

1718

pass

1719

1720

def onPrint(self):

1721

if DEBUG:

1722

print "onPrint called"

1723

if self.scanwindow.hasFocus():

1724

self.scanwindow.graph.printps()

1725

else:

1726

self.mcawindow.show()

1727

if QTVERSION < '4.0.0':self.mcawindow.raiseW()

1728

else:self.mcawindow.raise_()

1729

self.mcawindow.graph.printps()

1730

1731

def __McaWindowSignal(self,dict):

1732

if dict['event'] == 'NewScanCurve':

1733

if self.mcawindow.scanwindow.isHidden():

1734

self.mcawindow.scanwindow.show()

1735

self.mcawindow.scanwindow.setFocus()

1736

1737

if 0:

1738

1739

#

1740

# GraphWindow operations

1741

#

1742

def openGraph(self,name="MCA Graph"):

1743

"""

1744

Creates a new GraphWindow on the MDI

1745

"""

1746

self.setFollowActiveWindow(0)

1747

1748

#name= self.__getNewGraphName()

1749

if name == "MCA Graph":

1750

graph= McaWindow.McaWindow(self.mdi, name=name)

1751

self.connect(graph, qt.SIGNAL("windowClosed()"), self.closeGraph)

1752

graph.show()

1753

1754

if len(self.mdi.windowList())==1:

1755

graph.showMaximized()

1756

else: self.windowTile()

1757

1758

self.setFollowActiveWindow(1)

1759

1760

def getActiveGraph(self):

1761

"""

1762

Return active GraphWindow instance or a new one

1763

"""

1764

graph= self.mdi.activeWindow()

1765

if graph is None:

1766

graph= self.openGraph()

1767

return graph

1768

1769

def getGraph(self, name):

1770

"""

1771

Return GraphWindow instance indexed by name

1772

Or None if not found

1773

"""

1774

for graph in self.mdi.windowList():

1775

if str(graph.caption())==name:

1776

return graph

1777

return None

1778

1779

def closeGraph(self, name):

1780

"""

1781

Called after a graph is closed

1782

"""

1783

print "closeGraph", name

1784

1785

def __getGraphNames(self):

1786

return [ str(window.caption()) for window in self.mdi.windowList() ]

1787

1788

1789

def __getNewGraphName(self):

1790

names= self.__getGraphNames()

1791

idx= 0

1792

while "Graph %d"%idx in names:

1793

idx += 1

1794

return "Graph %d"%(idx)

1795

1796

class MyQTextBrowser(qt.QTextBrowser):

1797

def setSource(self,name):

1798

if name == qt.QString("./PyMCA.html"):

1799

if sys.platform == 'win32':

1800

dir=os.path.dirname(PyMcaMdi.__file__)

1801

if not os.path.exists(dir+"/HTML"+"/PyMCA.html"):

1802

dir = os.path.dirname(dir)

1803

cmd = dir+"/HTML/PyMCA.pdf"

1804

os.system('"%s"' % cmd)

1805

return

1806

try:

1807

self.report.show()

1808

except:

1809

self.report = qt.QTextBrowser()

1810

self.report.setCaption(qt.QString("PyMca Report"))

1811

self.report.mimeSourceFactory().addFilePath(qt.QString(os.path.dirname(PyMcaMdi.__file__)+"/HTML"))

1812

self.report.mimeSourceFactory().addFilePath(qt.QString(os.path.dirname(PyMcaMdi.__file__)+"/HTML/PyMCA_files"))

1813

self.report.setSource(name)

1814

if self.report.isHidden():self.report.show()

1815

self.report.raiseW()

1816

else:

1817

qt.QTextBrowser.setSource(self,name)

1818

1819

class Line(qt.QFrame):

1820

def mouseDoubleClickEvent(self,event):

1821

if DEBUG:

1822

print "Double Click Event"

1823

ddict={}

1824

ddict['event']="DoubleClick"

1825

ddict['data'] = event

1826

if QTVERSION < '4.0.0':

1827

self.emit(qt.PYSIGNAL("LineDoubleClickEvent"),(ddict,))

1828

else:

1829

self.emit(qt.SIGNAL("LineDoubleClickEvent"),(ddict))

1830

1831

class PixmapLabel(qt.QLabel):

1832

def mousePressEvent(self,event):

1833

if DEBUG:

1834

print "Mouse Press Event"

1835

ddict={}

1836

ddict['event']="MousePress"

1837

ddict['data'] = event

1838

if QTVERSION < '4.0.0':

1839

self.emit(qt.PYSIGNAL("PixmapLabelMousePressEvent"),(ddict,))

1840

else:

1841

self.emit(qt.SIGNAL("PixmapLabelMousePressEvent"),(ddict))

1842

1843

if __name__ == '__main__':

1844

PROFILING = 0

1845

if PROFILING:

1846

import profile

1847

import pstats

1848

demo = PyMca(**keywords)

1849

if nativeFileDialogs is not None:

1850

PyMcaDirs.nativeFileDialogs = nativeFileDialogs

1851

if debugreport:demo.onDebug()

1852

qt.QObject.connect(app, qt.SIGNAL("lastWindowClosed()"),

1853

app,qt.SLOT("quit()"))

1854

if QTVERSION < '4.0.0':

1855

app.setMainWidget(demo)

1856

demo.show()

1857

# --- close waiting widget

1858

splash.close()

1859

if PROFILING:

1860

profile.run('sys.exit(app.exec_loop())',"test")

1861

p=pstats.Stats("test")

1862

p.strip_dirs().sort_stats(-1).print_stats()

1863

else:

1864

app.exec_loop()

1865

else:

1866

splash.finish(demo)

1867

demo.show()

1868

if PROFILING:

1869

profile.run('sys.exit(app.exec_())',"test")

1870

p=pstats.Stats("test")

1871

p.strip_dirs().sort_stats(-1).print_stats()

1872

else:

1873

sys.exit(app.exec_())

1874