def display_tab_kolektor(self, x):
"""
Callback gumba za prikaz atba kolektor. Ulazni parametar je boolean (stanje gumba).
Ako je x True:
-stvori objekt kolektor
-dodaj ga u tab widget i spoji signale
Ako je x False:
-zatvori objekt kolektor
-izbrisi objekt kolektor
"""
if x:
uredjaj = self.datastore.get_uredjaj()
konfig = self.datastore.get_konfig()
#koristeni serial portovi?
self.kolektor = Kolektor(uredjaj=uredjaj, konfig=konfig, parent=self, datastore=self.datastore)
#connect signal i slot
self.connect(self.kolektor,
QtCore.SIGNAL('spremi_preuzete_podatke(PyQt_PyObject)'),
self.aktiviraj_ucitane_podatke)
self.connect(self.kolektor,
QtCore.SIGNAL('update_table_view'),
self.tableViewFrejm.update)
self.glavniTabWidget.addTab(self.kolektor, 'Kolektor')
else:
msg = 'Ako ugasite tab za skupljanje podataka, izgubiti cete sve podatke koji nisu spremljeni. Da li zelite ugasiti kolektor?'
title = 'Potvrdi gasenje kolektora'
chk = QtGui.QMessageBox.question(self, title, msg, QtGui.QMessageBox.Ok | QtGui.QMessageBox.No)
if chk == QtGui.QMessageBox.Ok:
ind = self.glavniTabWidget.indexOf(self.kolektor)
self.glavniTabWidget.removeTab(ind)
self.kolektor.close()
self.kolektor = QtGui.QWidget()
else:
self.pushButtonPrikupljanjePodataka.blockSignals(True)
self.pushButtonPrikupljanjePodataka.toggle()
self.pushButtonPrikupljanjePodataka.blockSignals(False)
class Umjeravanje(BASE_UMJERAVANJE, FORM_UMJERAVANJE):
"""
Klasa za 'child' prozor umjeravanja.
"""
redniBroj = 1
def __init__(self, uredjaj=None, generatori=None, dilucije=None, parent=None, postaje=None, cfg=None, datastore=None):
super(BASE_UMJERAVANJE, self).__init__(parent)
self.setupUi(self)
#MDI members ...
self.bezNaslova = True
self.isModified = True
self.workingFolder = os.path.dirname(__file__)
self.kolektor = QtGui.QWidget() #placeholder widget za kolektor preko veze
#podaci za umjeravanje
if datastore==None:
self.datastore = DataStore(uredjaj=uredjaj,
generatori=generatori,
dilucije=dilucije,
postaje=postaje,
cfg=cfg)
else:
self.datastore = datastore
#postavke prozora...
self.labelUredjaj.setText(self.datastore.get_uredjaj().get_serial())
self.labelPostaja.setText(self.datastore.get_izabranaPostaja())
self.init_tabove()
self.setup_connections()
def setup_connections(self):
#update teksta postaje
self.connect(self.tabPostavke,
QtCore.SIGNAL('promjena_postaje(PyQt_PyObject)'),
self.labelPostaja.setText)
### UCITAVANJE PODATAKA ###
self.pushButtonUcitajPodatke.clicked.connect(self.read_data_from_csv)
self.pushButtonPrikupljanjePodataka.clicked.connect(self.display_tab_kolektor)
### REPORT GENERATOR ###
self.pushButtonReport.clicked.connect(self.napravi_report)
### RECALCULATE TRIGGERI ###
self.connect(self.tabPostavke,
QtCore.SIGNAL('recalculate_all_tabs'),
self.recalculate_all_tabs)
self.connect(self.tabPostavke,
QtCore.SIGNAL('recalculate_konverter'),
self.recalculate_tab_konverter)
self.connect(self.tabPostavke,
QtCore.SIGNAL('recalculate_umjeravanja'),
self.recalculate_all_umjeravanja)
self.connect(self.tabPostavke,
QtCore.SIGNAL('promjena_checkOdaziv'),
self.prikazi_tabove_odaziva)
self.connect(self.tabPostavke,
QtCore.SIGNAL('promjena_checkKonverter'),
self.prikazi_tab_konverter)
self.tableViewFrejm.clicked.connect(self.interakcija_sa_tablicom_pojedinih_mjerenja)
### PROMJENA AKTIVNOG TABA ###
self.glavniTabWidget.currentChanged.connect(self.promjena_aktivnog_taba)
### triggeri za save check ###
self.tabPostavke.lineEditCRMSljedivost.textChanged.connect(self.trigger_is_modified)
self.tabPostavke.comboBoxLokacija.currentIndexChanged.connect(self.trigger_is_modified)
self.tabPostavke.comboBoxLokacija.editTextChanged.connect(self.trigger_is_modified)
self.tabPostavke.lineEditVrstaCRM.textChanged.connect(self.trigger_is_modified)
self.tabPostavke.lineEditOznakaIzvjesca.textChanged.connect(self.trigger_is_modified)
self.tabPostavke.lineEditRevizija.textChanged.connect(self.trigger_is_modified)
self.tabPostavke.lineEditBrojObrasca.textChanged.connect(self.trigger_is_modified)
self.tabPostavke.lineEditNorma.textChanged.connect(self.trigger_is_modified)
self.tabPostavke.plainTextEditPuniNazivMetode.textChanged.connect(self.trigger_is_modified)
self.tabPostavke.plainTextEditNapomena.textChanged.connect(self.trigger_is_modified)
self.tabPostavke.lineEditDatumUmjeravanja.textChanged.connect(self.trigger_is_modified)
self.tabPostavke.doubleSpinBoxTemperatura.valueChanged.connect(self.trigger_is_modified)
self.tabPostavke.doubleSpinBoxVlaga.valueChanged.connect(self.trigger_is_modified)
self.tabPostavke.doubleSpinBoxTlak.valueChanged.connect(self.trigger_is_modified)
def scroll_na_indeks(self, indeks):
"""callback za scroll na zadani qmodel indeks"""
try:
self.tableViewFrejm.scrollTo(indeks)
red = indeks.row()
self.tableViewFrejm.selectRow(red)
except Exception as err:
print(str(err))
logging.error(str(err), exc_info=True)
def trigger_is_modified(self, x):
"""callback za promjenu stanja dokumenta"""
self.set_modified(True)
def napravi_report(self):
"""
Izrada PDF reporta umjeravanja.
"""
komponente = self.datastore.get_uredjaj().get_listu_komponenti()
if self.datastore.isNOx:
plin = 'NO'
elif len(komponente) > 1:
plin, ok = QtGui.QInputDialog.getItem(self,
'Izbor komponente za report',
'Komponenta :',
komponente,
editable=False)
if not ok:
return None
else:
plin = komponente[0]
ime = QtGui.QFileDialog.getSaveFileName(parent=self,
caption='Spremi pdf report',
filter = 'pdf file (*.pdf)')
if ime:
report = ReportGenerator()
try:
report.generiraj_report(ime, plin, self)
except Exception as err:
logging.error(str(err), exc_info=True)
msg = "\n".join(['Izvještaj nije uspješno generiran.', str(err)])
QtGui.QMessageBox.information(self, 'Problem', msg)
def get_koristene_serial_portove(self):
"""
Metoda vraca listu koristenih serial portova u aplikaciji. Metoda zanemaruje
trenutno koristeni port u umjeravanju.
"""
setPortova = self.parent().parent().parent().parent().parent().get_aktivne_serial_portove()
setPortova.discard(None)
#moram omoguciti izbor istog seriala koji je koristen u umjeravanju
trenutni = self.get_serial_kolektora()
setPortova.discard(trenutni)
return list(setPortova)
def get_serial_kolektora(self):
"""
Metoda dohvaca koristeni serial port u kolektoru.
"""
try:
return self.kolektor.get_used_serial()
except Exception as err:
logging.error(str(err), exc_info=True)
return None
def display_tab_kolektor(self, x):
"""
Callback gumba za prikaz atba kolektor. Ulazni parametar je boolean (stanje gumba).
Ako je x True:
-stvori objekt kolektor
-dodaj ga u tab widget i spoji signale
Ako je x False:
-zatvori objekt kolektor
-izbrisi objekt kolektor
"""
if x:
uredjaj = self.datastore.get_uredjaj()
konfig = self.datastore.get_konfig()
#koristeni serial portovi?
self.kolektor = Kolektor(uredjaj=uredjaj, konfig=konfig, parent=self, datastore=self.datastore)
#connect signal i slot
self.connect(self.kolektor,
QtCore.SIGNAL('spremi_preuzete_podatke(PyQt_PyObject)'),
self.aktiviraj_ucitane_podatke)
self.connect(self.kolektor,
QtCore.SIGNAL('update_table_view'),
self.tableViewFrejm.update)
self.glavniTabWidget.addTab(self.kolektor, 'Kolektor')
else:
msg = 'Ako ugasite tab za skupljanje podataka, izgubiti cete sve podatke koji nisu spremljeni. Da li zelite ugasiti kolektor?'
title = 'Potvrdi gasenje kolektora'
chk = QtGui.QMessageBox.question(self, title, msg, QtGui.QMessageBox.Ok | QtGui.QMessageBox.No)
if chk == QtGui.QMessageBox.Ok:
ind = self.glavniTabWidget.indexOf(self.kolektor)
self.glavniTabWidget.removeTab(ind)
self.kolektor.close()
self.kolektor = QtGui.QWidget()
else:
self.pushButtonPrikupljanjePodataka.blockSignals(True)
self.pushButtonPrikupljanjePodataka.toggle()
self.pushButtonPrikupljanjePodataka.blockSignals(False)
def tab_isValid(self, tabname):
"""helper metoda za provjeru da li je zadano mjerenje validno"""
if tabname != None and tabname in self.dictTabova:
return True
else:
return False
def prikazi_tab_konverter(self):
check = self.datastore.get_checkKonverter()
if 'konverter' in self.dictTabova:
if check:
self.glavniTabWidget.addTab(self.dictTabova['konverter'], 'konverter')
else:
ind = self.glavniTabWidget.indexOf(self.dictTabova['konverter'])
self.glavniTabWidget.removeTab(ind)
def prikazi_tabove_odaziva(self):
"""toggle tabova odaziv..."""
check = self.datastore.get_checkOdaziv()
if check:
for tab in self.dictTabova:
if tab.endswith('-odaziv'):
self.glavniTabWidget.addTab(self.dictTabova[tab], tab)
else:
for tab in self.dictTabova:
if tab.endswith('-odaziv'):
ind = self.glavniTabWidget.indexOf(self.dictTabova[tab])
self.glavniTabWidget.removeTab(ind)
def recalculate_all_umjeravanja(self):
"""recalculate sve tabove umjeravanja"""
print('RECALCULATE ALL UMJERAVANJA')
for tab in self.dictTabova:
if not tab.endswith('-odaziv') and tab != 'konverter':
self.recalculate_tab(tabname=tab)
def recalculate_all_tabs(self):
"""recalculate sve tabove"""
print('RECALCULATE ALL')
for tab in self.dictTabova:
self.recalculate_tab(tabname=tab)
def recalculate_tab_konverter(self):
print('RECALCULATE KONVERTER')
self.recalculate_tab(tabname='konverter')
@pomocni.activate_wait_spinner
def recalculate_tab(self, tabname=None):
"""recalculate pojedinacni tab"""
self.set_modified(True)
try:
if self.tab_isValid(tabname):
print('recalculating --> {0}'.format(tabname))
if tabname == 'konverter':
tocke = self.datastore.tabData[tabname].get_tocke()
opseg = self.datastore.get_izabraniOpseg()
cnox50 = self.datastore.get_cNOx50()
cnox95 = self.datastore.get_cNOx95()
ecmin = self.datastore.get_uredjaj().get_analitickaMetoda().get_Ec_min()
ecmax = self.datastore.get_uredjaj().get_analitickaMetoda().get_Ec_max()
frejm = self.datastore.tabData[tabname].get_frejm()
if not isinstance(frejm, pd.core.frame.DataFrame):
#nije zadan dataframe
return None
mapa = kalkulator.racunaj_vrijednosti_provjere_konvertera(tocke=tocke,
opseg=opseg,
frejm=frejm,
cnox50=cnox50,
cnox95=cnox95,
ecmin=ecmin,
ecmax=ecmax)
self.dictTabova[tabname].update_rezultat(mapa)
self.datastore.tabData[tabname].set_rezultat(mapa)
elif tabname.endswith('-odaziv'):
self.dictTabova[tabname].update_rezultate()
else:
tocke = self.datastore.tabData[tabname].get_tocke()
linearnost = self.datastore.get_checkLinearnost()
ponovljivost = self.datastore.get_checkPonovljivost()
opseg = self.datastore.get_izabraniOpseg()
cCRM = self.datastore.get_koncentracijaCRM()
sCRM = self.datastore.get_UCRM()
#dilucija
key = self.datastore.get_izabranaDilucija()
dilucija = self.datastore.get_objekt_izabrane_dilucije(key)
uNul = dilucija.get_uNul()
uKal = dilucija.get_uKal()
#data
frejm = self.datastore.tabData[tabname].get_frejm()
if isinstance(frejm, pd.core.frame.DataFrame):
data = list(frejm[tabname])
else:
#nije zadan dataframe
return None
#generator cistog zraka
key = self.datastore.get_izabraniGenerator()
generator = self.datastore.get_objekt_izabranog_generatora(key)
if tabname == 'SO2':
plinMaxC = generator.get_maxSO2()
elif tabname in ['NOx', 'NO', 'NO2']:
plinMaxC = generator.get_maxNOx()
elif tabname == 'CO':
plinMaxC = generator.get_maxCO()
elif tabname == 'O3':
plinMaxC = generator.get_maxO3()
else:
plinMaxC = generator.get_maxBTX()
#metoda
metoda = self.datastore.get_uredjaj().get_analitickaMetoda()
jedinica = metoda.get_jedinica()
srzlimit = metoda.get_Srz()
srslimit = metoda.get_Srs()
rzlimit = metoda.get_rz()
rmaxlimit = metoda.get_rmax()
mapa = kalkulator.racun_umjeravanja(tocke=tocke,
data=data,
linearnost=linearnost,
opseg=opseg,
cCRM=cCRM,
sCRM=sCRM,
uNul=uNul,
uKal=uKal,
plinMaxC=plinMaxC,
ponovljivost=ponovljivost,
jedinica=jedinica,
srzlimit=srzlimit,
srslimit=srslimit,
rzlimit=rzlimit,
rmaxlimit=rmaxlimit)
self.dictTabova[tabname].update_rezultat(mapa)
self.datastore.tabData[tabname].set_rezultat(mapa)
else:
msg = 'recalculate nepostojeceg taba {0}'.format(str(tabname))
logging.warning(msg)
except Exception as err:
logging.error(str(err), exc_info=True)
def aktiviraj_ucitane_podatke(self, mapa):
"""
Spremanje podataka iz prozora u neku instancu otvorenog umjeravanja ili otvaranje novog umjeravanja..
kljucevi mape su:
'podaci':sekundniFrejm
'minutniPodaci':minutniFrejm
'uredjaj':serijski broj uredjaja
"""
minutni = mapa['minutniPodaci']
sekundni = mapa['podaci']
for tab in self.dictTabova:
if tab.endswith('-odaziv'):
#prebaci sekundni frejm sa rise i fall podacima za tab u datastore
model = self.dictTabova[tab].get_model()
komponenta = self.dictTabova[tab].naziv
model.set_slajs(sekundni[komponenta], komponenta)
self.datastore.tabData[tab].set_frejm(model.get_frejm())
self.recalculate_tab(tabname=tab)
else:
#prebaci minutni frejm u datastore
self.datastore.tabData[tab].set_frejm(minutni)
#updejtaj qt model u tab widgetu
model = self.dictTabova[tab].get_model()
model.set_frejm(minutni)
self.recalculate_tab(tabname=tab)
def read_data_from_csv(self):
"""
Ucitavanje sirovih podataka iz csv filea putem wizarda.
redosljed ucitavanja je bitan:
1. clear tabove (ako su razliciti od postojecih tabova)
2. update dokument sa novim podacima
3. create tabove (ako su prethodno izbrisani)
"""
fileWizard = read_file_wizard.CarobnjakZaCitanjeFilea(datastore=self.datastore)
ok = fileWizard.exec_()
if ok:
frejmovi = fileWizard.get_frejmovi()
minutni = frejmovi['minutni'] #za tab umjeravanja i konverter
sekundni = frejmovi['sekundni'] #za tab odaziva
for tab in self.dictTabova:
if tab.endswith('-odaziv'):
#prebaci sekundni frejm sa rise i fall podacima za tab u datastore
model = self.dictTabova[tab].get_model()
komponenta = self.dictTabova[tab].naziv
model.set_slajs(sekundni[komponenta], komponenta)
self.datastore.tabData[tab].set_frejm(model.get_frejm())
self.recalculate_tab(tabname=tab)
else:
#prebaci minutni frejm u datastore
self.datastore.tabData[tab].set_frejm(minutni)
#updejtaj qt model u tab widgetu
model = self.dictTabova[tab].get_model()
model.set_frejm(minutni)
self.recalculate_tab(tabname=tab)
def interakcija_sa_tablicom_pojedinih_mjerenja(self, indeks):
"""interakcija sa tablicom sa podacima"""
try:
widg = self.glavniTabWidget.currentWidget()
mjerenje = widg.plin
x = indeks.row()
if mjerenje == 'postavke':
pass
elif mjerenje.endswith('-odaziv'):
#delegiraj klik widgetu
widg.update_rezultate()
elif mjerenje == 'konverter':
model = self.dictTabova[mjerenje].get_model()
model.set_start(x)
self.datastore.tabData[mjerenje].set_startIndeks(x)
self.recalculate_tab(tabname=mjerenje)
else:
if self.datastore.isNOx:
model = self.dictTabova['NO'].get_model()
model.set_start(x)
self.datastore.tabData['NO'].set_startIndeks(x)
self.recalculate_tab(tabname='NO')
model = self.dictTabova['NOx'].get_model()
model.set_start(x)
self.datastore.tabData['NOx'].set_startIndeks(x)
self.recalculate_tab(tabname='NOx')
else:
model = self.dictTabova[mjerenje].get_model()
model.set_start(x)
self.datastore.tabData[mjerenje].set_startIndeks(x)
self.recalculate_tab(tabname=mjerenje)
except Exception as err:
logging.error(str(err), exc_info=True)
def promjena_aktivnog_taba(self, x):
"""metoda zaduzena za promjenu konteksta prilikom promjene taba. Definira
koji je model aktivan u ljevoj tablici sa podacima."""
try:
nazivTaba = self.glavniTabWidget.currentWidget().plin
if nazivTaba == 'Postavke':
emptyModel = SiroviFrameModel(frejm=pd.DataFrame(),
tocke=self.datastore.init_tockeUmjeravanja(),
start=0)
self.tableViewFrejm.setModel(emptyModel)
self.tableViewFrejm.update()
#exit from method
return None
elif nazivTaba == 'kolektor':
model = self.kolektor.get_model()
self.tableViewFrejm.setModel(model)
self.tableViewFrejm.update()
else:
model = self.dictTabova[nazivTaba].get_model()
self.tableViewFrejm.setModel(model)
self.tableViewFrejm.update()
#display stupaca u modelu
if nazivTaba.endswith('-odaziv'):
self.glavniTabWidget.currentWidget().update_rezultate()
self.tableViewFrejm.resizeColumnToContents(0)
self.tableViewFrejm.resizeColumnToContents(1)
self.tableViewFrejm.horizontalHeader().setStretchLastSection(True)
else:
self.tableViewFrejm.horizontalHeader().setResizeMode(QtGui.QHeaderView.Stretch)
self.tableViewFrejm.update()
except Exception as err:
logging.error(str(err), exc_info=True)
################################################################################
#metode za rad i prikaz umjeravanja
def init_tabove(self):
"""
stvaranje tabova i povezivanje istih...
"""
self.dictTabova = {}
#tab postavke
self.tabPostavke = tab_postavke.TabPostavke(datastore=self.datastore)
self.glavniTabWidget.addTab(self.tabPostavke, 'Postavke')
#ostali tabovi:
for tab in self.datastore.tabData.keys():
if tab.endswith('-odaziv'):
self.dictTabova[tab] = tab_odaziv.TabOdaziv(datastore=self.datastore, plin=tab)
### scroll podataka tab odaziv...###
self.connect(self.dictTabova[tab],
QtCore.SIGNAL('scroll_to_index(PyQt_PyObject)'),
self.scroll_na_indeks)
if self.datastore.get_checkOdaziv():
self.glavniTabWidget.addTab(self.dictTabova[tab], tab)
elif tab == 'konverter':
self.dictTabova[tab] = tab_konverter.TabKonverter(datastore=self.datastore, plin=tab)
if self.datastore.get_checkKonverter():
self.glavniTabWidget.addTab(self.dictTabova[tab], tab)
else:
self.dictTabova[tab] = tab_rezultat.TabRezultat(datastore=self.datastore, plin=tab)
self.glavniTabWidget.addTab(self.dictTabova[tab], tab)
#connectioni za dodavanje, brisanje i editiranje tocaka pojedinog taba
self.connect(self.dictTabova[tab],
QtCore.SIGNAL('panel_dodaj_umjernu_tocku'),
self.dodaj_umjernu_tocku)
self.connect(self.dictTabova[tab],
QtCore.SIGNAL('panel_makni_umjernu_tocku(PyQt_PyObject)'),
self.makni_umjernu_tocku)
self.connect(self.dictTabova[tab],
QtCore.SIGNAL('panel_edit_umjernu_tocku(PyQt_PyObject)'),
self.edit_umjernu_tocku)
def dodaj_umjernu_tocku(self):
"""
Metoda dodaje tocku na popis tocaka za mjerenje(tab). Dodaje je iza vec
definiranih tocaka, ukupno 30 indeksa, prvih 15 zanemarenih, random boja.
"""
try:
tabname = self.glavniTabWidget.currentWidget().plin
frejm = self.datastore.tabData[tabname].get_frejm()
if isinstance(frejm, pd.core.frame.DataFrame):
tocke = copy.deepcopy(self.datastore.tabData[tabname].get_tocke())
ime = "".join(['TOCKA',str(len(tocke)+1)])
indeks = max([max(tocka.indeksi) for tocka in tocke])
start = indeks+15
end = start+15
cref = 0.0
novaTocka = Tocka(ime=ime, start=start, end=end, cref=cref)
tocke.append(novaTocka)
self.datastore.tabData[tabname].set_tocke(tocke)
self.recalculate_tab(tabname=tabname)
except Exception as err:
logging.error(str(err), exc_info=True)
def makni_umjernu_tocku(self, red):
"""
Metoda brise tocku zadanu indeksom (red) sa popisa tocaka za mjerenje.
Metoda mjenja nazive ostalih tocaka radi konzistencije.
"""
try:
tabname = self.glavniTabWidget.currentWidget().plin
frejm = self.datastore.tabData[tabname].get_frejm()
if isinstance(frejm, pd.core.frame.DataFrame):
tocke = copy.deepcopy(self.datastore.tabData[tabname].get_tocke())
tocke.pop(red)
#rename ostale tocke
for i in range(len(tocke)):
tocke[i].ime = "".join(['TOCKA',str(i+1)])
self.datastore.tabData[tabname].set_tocke(tocke)
self.recalculate_tab(tabname=tabname)
except Exception as err:
logging.error(str(err), exc_info=True)
def edit_umjernu_tocku(self, red):
"""
Edit umjerne tocke. Poziva se dijalog za edit parametara.
Ulazni parametar (red) je indeks pod kojim se ta tocka nalazi
u listi tocaka.
"""
try:
tabname = self.glavniTabWidget.currentWidget().plin
tocke = copy.deepcopy(self.datastore.tabData[tabname].get_tocke())
start = self.datastore.tabData[tabname].get_startIndeks()
frejm = self.datastore.tabData[tabname].get_frejm()
if isinstance(frejm, pd.core.frame.DataFrame):
staraTocka = tocke[red]
if staraTocka.crefFaktor == 0.0:
staraTockaIsZero = True
else:
staraTockaIsZero = False
brojZeroTocaka = len([i for i in tocke if i.crefFaktor == 0.0])
#poziv dijaloga za edit
dijalog = dijalog_edit_tocke.EditTockuDijalog(frejm=frejm,
tocke=tocke,
start=start,
indeks=red,
parent=self)
if dijalog.exec_():
novaTocka = dijalog.get_promjenjena_tocka()
if staraTockaIsZero and brojZeroTocaka == 1:
if novaTocka.crefFaktor == 0.0:
tocke[red] = novaTocka
self.datastore.tabData[tabname].set_tocke(tocke)
self.recalculate_tab(tabname=tabname)
else:
QtGui.QMessageBox.information(self, 'Oprez','Mora postojati barem jedna zero tocka. Cref faktor tocke nije promjenjen.')
novaTocka.crefFaktor = 0.0
tocke[red] = novaTocka
self.datastore.tabData[tabname].set_tocke(tocke)
self.recalculate_tab(tabname=tabname)
else:
tocke[red] = novaTocka
self.datastore.tabData[tabname].set_tocke(tocke)
self.recalculate_tab(tabname=tabname)
except Exception as err:
logging.error(str(err), exc_info=True)
################################################################################
#metode za MDI interface
def novi_file(self, folder=None):
"""inicijalizacija novog filea umjeravanja"""
self.bezNaslova = True
if folder:
if os.path.isdir(folder):
self.workingFolder = folder
selectedFilter = "Umjeravanja (*.kal)"
path = QtGui.QFileDialog.getSaveFileName(self, 'Save as', self.workingFolder, selectedFilter)
if path:
fullpath = os.path.normpath(path)
else:
#path nije zadan, koristi default
vrijeme = datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
naziv = 'dokument{0}_{1}.kal'.format(str(Umjeravanje.redniBroj), vrijeme)
Umjeravanje.redniBroj += 1
fullpath = os.path.join(self.workingFolder, naziv)
fullpath = os.path.normpath(fullpath) #normalizacija
self.set_trenutnoImeFilea(fullpath)
self.set_modified(True)
def set_modified(self, x):
"""setter cheka za stanje promjene dokumenta"""
self.isModified = x
if x:
title = " ".join([self.trenutnoImeFilea, '(*)'])
else:
title = self.trenutnoImeFilea
self.setWindowTitle(title)
def get_modified(self):
"""getter cheka za stanje promjene dokumenta"""
return self.isModified
def set_trenutnoImeFilea(self, path):
"""setter patha do filea"""
self.trenutnoImeFilea = path
self.bezNaslova = False
def get_trenutnoImeFilea(self):
"""getter patha do filea"""
return self.trenutnoImeFilea
def load_file(self, path=None):
"""load podataka iz spremljenog filea u objekt"""
QtGui.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)
try:
if path==None:
return False
self.set_full_path_filea(path)
self.recalculate_all_tabs()
QtGui.QApplication.restoreOverrideCursor()
logging.info('Umjeravanje {0} loaded'.format(path))
return True
except Exception as err:
logging.error(str(err), exc_info=True)
QtGui.QApplication.restoreOverrideCursor()
return False
def save(self):
"""save podatke u file"""
if self.bezNaslova:
return self.save_file_as()
else:
return self.save_file(self.trenutnoImeFilea)
def save_file_as(self):
"""save file bez naslova... otvori dijalog za izbor naziva"""
selectedFilter = "Umjeravanja (*.kal)"
path = QtGui.QFileDialog.getSaveFileName(self, 'Save as', self.trenutnoImeFilea, selectedFilter)
if not path:
return False
if not path.endswith('.kal'):
path = "".join([path, '.kal'])
return self.save_file(path)
def save_file(self, path):
"""funkcija za spremanje stanja umjeravanja u file"""
QtGui.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)
try:
with open(path, 'wb') as the_file:
#pickle datastore
data = self.datastore.serialize()
the_file.write(data)
self.set_full_path_filea(path)
QtGui.QApplication.restoreOverrideCursor()
logging.info('Umjeravanje {0} saved'.format(path))
return True
except Exception as err:
logging.error(str(err), exc_info=True)
QtGui.QApplication.restoreOverrideCursor()
QtGui.QMessageBox.warning(self, 'Problem', 'Umjeravanje nije uspjesno spremljeno.\n{0}'.format(str(err)))
return False
def get_filename_from_path(self):
"""funkcija vraca samo naziv trenunog imena filea (bez foldera)"""
x = os.path.split(self.trenutnoImeFilea)
return x[1]
def closeEvent(self, event):
if self.provjeri_status_prije_izlaza():
#propisno ugasi kolektor
self.kolektor.close()
self.kolektor = QtGui.QWidget()
event.accept()
else:
event.ignore()
def provjeri_status_prije_izlaza(self):
"""metoda provjerava da li su promjene spremljene prije gasenja prozora"""
if self.get_modified():
msg = 'Promjene na trenutnom umjeravanju nisu spremljene. Da li zelite spremiti promjene?'
response = QtGui.QMessageBox.warning(self,
'Upozorenje',
msg,
QtGui.QMessageBox.Save | QtGui.QMessageBox.Discard | QtGui.QMessageBox.Cancel)
if response == QtGui.QMessageBox.Save:
return self.save()
elif response == QtGui.QMessageBox.Cancel:
return False
return True
def set_full_path_filea(self, path):
"""metoda postavlja path do filea u objekt. Te mjenja naziv prozora i
status 'spremljenosti' (koristi se prilikom spremanja i loada filea)"""
self.set_trenutnoImeFilea(path)
self.set_modified(False)