class ClassesModel(xobjects.XStandardItemModel):
sigLoaded = pyqtSignal()
def __init__(self, parent=None):
super(xobjects.XStandardItemModel, self).__init__(parent)
self.set_header(0, "Class")
self.make_root()
def make_root(self):
items = self.make_blank_row()
items[0].set("All", ico=Ico.Folder)
self.appendRow(items)
return items
def load_classes(self, classes):
rootItem = self.item(0, 0)
for r in classes:
citems = self.make_blank_row()
citems[0].set(r)
rootItem.appendRow(citems)
self.sigLoaded.emit()
class GroupsModel(xobjects.XStandardItemModel):
sigClasses = pyqtSignal(list)
def __init__(self, parent=None):
xobjects.XStandardItemModel.__init__(self, parent)
self.set_header(CG.code, "Group")
self.set_header(CG.description, "Description")
self.set_header(CG.cls, "Class")
#self.set_header(CG.x_id, "xid")
self.set_header(CG.search, "Search")
def load_data(self, groups):
classes = []
for group_code in groups.keys():
rec = groups[group_code]
items = self.make_blank_row()
items[CG.code].set(rec['group_code'],
bold=True,
ico=Ico.AgsGroup,
font="monospace")
items[CG.description].set(rec['group_description'])
items[CG.search].set(rec['group_code'] + rec['group_description'])
items[CG.cls].set(rec['class'])
self.appendRow(items)
if not rec['class'] in classes:
classes.append(rec['class'])
G.Ags.modelHeadings.append_headings(rec)
G.Ags.modelNotes.append_notes(group_code, rec['notes'])
self.sigClasses.emit(classes)
def get_group(self, code):
items = self.findItems(code, Qt.MatchExactly, CG.code)
#print "GET+", code
ridx = items[0].index().row()
return dict(group_code=self.item(ridx, CG.code).s(),
group_description=self.item(ridx, CG.description).s(),
cls=self.item(ridx, CG.cls).s())
def get_words(self):
lst = []
for ridx in range(0, self.rowCount()):
lst.append(
dict(type=AGS_TYPE.group,
description=self.item(ridx, CG.description).s(),
code=self.item(ridx, CG.code).s()))
return lst
class ExamplesWidget(QtGui.QWidget):
sigFileSelected = pyqtSignal(object)
def __init__(self, parent):
QtGui.QWidget.__init__(self, parent)
self.debug = False
self.setMinimumWidth(300)
self.mainLayout = QtGui.QVBoxLayout()
self.mainLayout.setSpacing(0)
self.mainLayout.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.mainLayout)
#=============================
## Set up tree
self.tree = QtGui.QTreeWidget()
self.mainLayout.addWidget(self.tree, 30)
self.tree.setRootIsDecorated(False)
self.tree.header().setStretchLastSection(True)
self.tree.header().hide()
hi = self.tree.headerItem()
hi.setText(C_EG.file_name, "Example")
self.tree.itemClicked.connect(self.on_tree_item_clicked)
self.load_files_list()
def load_files_list(self, sub_dir=None):
files_list, err = ags4.examples_list()
if err:
pass #TODO
self.tree.clear()
for fd in files_list:
file_name = fd["file_name"]
item = QtGui.QTreeWidgetItem()
item.setText(C_EG.file_name, file_name)
item.setIcon(C_EG.file_name, Ico.icon(Ico.Ags4))
f = item.font(C_EG.file_name)
f.setBold(True)
item.setFont(C_EG.file_name, f)
self.tree.addTopLevelItem(item)
def on_tree_item_clicked(self, item, col):
file_name = str(item.text(C_EG.file_name))
self.sigFileSelected.emit(file_name)
class ExpPathBrowseWidget(QtGui.QWidget):
"""The SourceViewWidget info which in row 0 """
sigOpenFile = pyqtSignal(str)
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.debug = False
self.setObjectName("ExcelBrowserWidget")
self.mainLayout = QtGui.QVBoxLayout()
self.mainLayout.setSpacing(0)
self.mainLayout.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.mainLayout)
self.toolbar = QtGui.QToolBar()
self.mainLayout.addWidget(self.toolbar, 0)
tbg = xwidgets.ToolBarGroup(title="Selected Dir")
self.toolbar.addWidget(tbg)
buttSel = xwidgets.XToolButton(text="Select")
self.toolbar.addWidget(buttSel)
self.txtPath = QtGui.QLineEdit()
tbg.addWidget(self.txtPath)
if G.args.dev:
self.txtPath.setText("/home/ogt/gstl_examples/35579")
self.tree = QtGui.QTreeView()
self.mainLayout.addWidget(self.tree, 30)
self.dirModel = QtGui.QFileSystemModel()
self.dirModel.setRootPath(self.txtPath.text())
self.dirModel.setNameFilters(["*.xlsx"])
self.tree.setModel(self.dirModel)
self.tree.setRootIndex(self.dirModel.index(self.txtPath.text()))
#print self.txtPath.text()
if G.args.dev:
ed = os.path.join(str(self.txtPath.text()), "ATTS")
self.tree.expand(self.dirModel.index(ed))
self.tree.setColumnWidth(0, 400)
self.tree.doubleClicked.connect(self.on_tree_double_clicked)
def on_tree_double_clicked(self, midx):
filename = str(self.dirModel.filePath(midx))
self.sigOpenFile.emit(filename)
class HelpPageView(QtGui.QWidget):
sigPageLinkClicked = pyqtSignal(str)
def __init__(self, parent=None, page=None):
QtGui.QWidget.__init__(self, parent)
self.debug = False
self.page = None
lay = QtGui.QVBoxLayout()
lay.setSpacing(0)
lay.setContentsMargins(0, 0, 0, 0)
self.setLayout(lay)
self.webView = QtWebKit.QWebView()
lay.addWidget(self.webView, 2)
if self.debug:
page = self.webView.page()
page.settings().setAttribute(
QtWebKit.QWebSettings.DeveloperExtrasEnabled, True)
# elf.webView.settings().globalSettings().setAttribute(QtWebKit.QWebSettings.DeveloperExtrasEnabled, True)
self.webInspector = QtWebKit.QWebInspector(self)
self.webInspector.setPage(page)
lay.addWidget(self.webInspector, 3)
self.webView.page().setLinkDelegationPolicy(
QtWebKit.QWebPage.DelegateAllLinks)
self.webView.linkClicked.connect(self.on_link_clicked)
def set_data(self, page, html):
self.page = page
base_url = QtCore.QUrl.fromLocalFile(DOCS_PATH + "/")
# bu.setScheme("file")
# print " > out stuff=", base_url.toString(), base_url.isValid()
self.webView.setHtml(html, base_url)
def on_link_clicked(self, url):
page = str(url.path())[1:]
# print url, page, type(page)
self.sigPageLinkClicked.emit(page)
class OGTProjectSummaryWidget( QtGui.QMainWindow ):
sigUpdated = pyqtSignal(object)
def __init__( self, parent=None):
QtGui.QMainWindow.__init__( self, parent )
self.debug = False
self.file_path = None
self.doc = None
self.docProject = QtGui.QDockWidget()
self.docProject.setWindowTitle("Project")
self.docProject.setFeatures(QtGui.QDockWidget.DockWidgetMovable)
self.docProject.setAllowedAreas(Qt.LeftDockWidgetArea|Qt.RightDockWidgetArea)
self.addDockWidget(Qt.LeftDockWidgetArea, self.docProject)
self.lblProjectPlace = QtGui.QLabel()
self.lblProjectPlace.setText("project placeholder")
self.docProject.setWidget(self.lblProjectPlace)
class GroupsListWidget(QtGui.QWidget):
sigFileSelected = pyqtSignal(object)
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.debug = False
self.setMinimumWidth(300)
self.mainLayout = xwidgets.vlayout()
self.setLayout(self.mainLayout)
#=============================
## Set up tree
self.tree = QtGui.QTreeView()
self.mainLayout.addWidget(self.tree)
self.tree.setMinimumWidth(300)
self.tree.setRootIsDecorated(False)
self.tree.header().setStretchLastSection(True)
self.model = GroupListModel()
self.tree.setModel(self.model)
"""
hi = self.tree.headerItem()
hi.setText(CP.group_code, "Group")
hi.setText(CP.group_description, "Description")
hi.setText(CP.node, "Rows")
hi.setTextAlignment(CP.node, Qt.AlignRight)
self.tree.itemDoubleClicked.connect(self.on_tree_double_clicked)
"""
#self.tree.setColumnWidth(CP.node, 40)
#self.tree.setColumnWidth(CP.group_code, 70)
#self.load_projects()
def set_document(self, ogtDoc):
self.model.set_document(ogtDoc)
def load_projects(self, sub_dir=None):
return
files_list, err = ags4.examples_list()
if err:
pass #TODO
self.tree.clear()
for fd in files_list:
file_name = fd["file_name"]
item = QtGui.QTreeWidgetItem()
item.setText(C_EG.file_name, file_name)
item.setIcon(C_EG.file_name, Ico.icon(Ico.Ags4))
f = item.font(C_EG.file_name)
f.setBold(True)
item.setFont(C_EG.file_name, f)
self.tree.addTopLevelItem(item)
def on_tree_item_clicked(self, item, col):
file_name = str(item.text(C_EG.file_name))
self.sigFileSelected.emit(file_name)
class OGTDocumentWidget(QtGui.QWidget):
sigUpdated = pyqtSignal(object)
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.debug = False
self.file_path = None
self.doc = None
self.mainLayout = QtGui.QVBoxLayout()
self.mainLayout.setSpacing(0)
self.mainLayout.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.mainLayout)
self.tabBar = QtGui.QTabBar()
self.mainLayout.addWidget(self.tabBar)
self.stackWidget = QtGui.QStackedWidget()
self.mainLayout.addWidget(self.stackWidget)
self.tabBar.currentChanged.connect(self.on_tab_changed)
def init(self):
#self.fetch()
pass
def fetch(self, example=None):
"""Send request to server"""
url = "/ags/4/parse"
params = None
if example:
params = dict(example=example)
G.server.get(origin=self, url=url, params=params)
def load_reply(self, xreply):
"""Got a reply from server.."""
#print self, xreply
if xreply.origin != self:
return
if not "document" in xreply.data:
return # SHould not happen
# loop the groups and add the tabs,...
for dic in xreply.data["document"]["groups"]:
widget = self.load_group(dic)
def load_ags4_file(self, file_path):
self.file_path = None
doc = ags4.AGS4Document()
err = doc.load_from_file(file_path)
print "err=", err
self.load_document(doc)
def load_document(self, doc):
self.doc = doc
data = doc.to_dict(edit_mode=True)
for gkey in data['groups']:
self.load_group(data['groups'].get(gkey))
def load_group(self, group_dic):
widget = ogtgui_group.OGTGroupWidget(self)
self.tabBar.addTab(Ico.icon(Ico.Group), group_dic['group_code'])
self.stackWidget.addWidget(widget)
widget.load_group(group_dic)
#self.tabBar.setCurrentIndex(self.tabBar.count() - 1)
return widget
def on_tab_changed(self, idx):
# TODO check is theres an edit. ebore tab change maybe
#print "idx", idx
self.stackWidget.setCurrentIndex(idx)
class AGS4GroupsBrowser(QtGui.QWidget):
"""The left panel with the classes, filter and groups table underneath"""
sigGroupSelected = pyqtSignal(object)
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.debug = False
self.setObjectName("AGS4GroupsBrowser")
self.proxy = QtGui.QSortFilterProxyModel()
self.proxy.setSourceModel(G.ags.modelGroups)
self.proxy.setFilterCaseSensitivity(QtCore.Qt.CaseInsensitive)
##===============================================
self.mainLayout = QtGui.QVBoxLayout()
self.mainLayout.setSpacing(0)
self.mainLayout.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.mainLayout)
self.splitter = QtGui.QSplitter(self)
self.splitter.setObjectName(self.objectName() + "groups_splitter")
self.mainLayout.addWidget(self.splitter)
##############################################################################
leftWidget = QtGui.QWidget()
leftLayout = xwidgets.vlayout()
leftWidget.setLayout(leftLayout)
self.splitter.addWidget(leftWidget)
self.tabFilter = QtGui.QTabWidget()
leftLayout.addWidget(self.tabFilter)
##================================
## Filter
grpFilter = xwidgets.GroupGridBox()
mmm = 5
grpFilter.setContentsMargins(mmm, mmm, mmm, mmm)
# grpFilter.grid.setSpacing(5)
# grpFilter.setFixedWidth(150)
self.tabFilter.addTab(grpFilter, "Filter")
# filter combo
self.buttGroupFilter = QtGui.QButtonGroup()
self.buttGroupFilter.setExclusive(True)
#self.comboSearchFor = QtGui.QComboBox()
#grpFilter.addWidget(self.comboSearchFor)
for ridx, s in enumerate(["Code", "Description",
"Code + Description"]):
rad = QtGui.QRadioButton()
rad.setText(s)
grpFilter.grid.addWidget(rad, ridx, 0, 1, 2)
self.buttGroupFilter.addButton(rad, 3 if ridx == 2 else ridx)
self.buttGroupFilter.button(0).setChecked(True)
self.buttGroupFilter.buttonClicked.connect(self.on_filter_col)
#self.comboSearchFor.addItem("Code", CG.code)
#self.comboSearchFor.addItem("Description", CG.description)
#self.comboSearchFor.addItem("Code + Description", CG.search)
#self.comboSearchFor.setMaximumWidth(150)
# clear button
self.buttClear = xwidgets.ClearButton(self,
callback=self.on_clear_filter)
grpFilter.grid.addWidget(self.buttClear, 3, 0)
## filter text
self.txtFilter = QtGui.QLineEdit()
self.txtFilter.setMaximumWidth(100)
grpFilter.grid.addWidget(self.txtFilter, 3, 1)
self.txtFilter.textChanged.connect(self.on_txt_changed)
grpFilter.grid.addWidget(QtGui.QLabel(), 4, 2)
#grpFilter.layout.addStretch(3)
grpFilter.grid.setColumnStretch(0, 0)
grpFilter.grid.setColumnStretch(1, 10)
##================================
## Classification Tree
topLayout = QtGui.QVBoxLayout()
leftLayout.addLayout(topLayout, 0)
self.treeClass = QtGui.QTreeView()
self.tabFilter.addTab(self.treeClass, "By classification")
self.treeClass.setModel(G.ags.modelClasses)
self.treeClass.setRootIsDecorated(False)
self.treeClass.setExpandsOnDoubleClick(False)
self.treeClass.setFixedHeight(220)
self.treeClass.selectionModel().selectionChanged.connect(
self.on_class_tree_selected)
##== Groups Tree
self.treeGroups = QtGui.QTreeView()
leftLayout.addWidget(self.treeGroups, 10)
self.treeGroups.setModel(self.proxy)
self.treeGroups.setUniformRowHeights(True)
self.treeGroups.setRootIsDecorated(False)
self.treeGroups.setAlternatingRowColors(True)
self.treeGroups.header().setStretchLastSection(True)
self.treeGroups.setColumnHidden(CG.search, True)
self.treeGroups.setColumnWidth(CG.code, 120)
self.treeGroups.setColumnWidth(CG.description, 250)
self.treeGroups.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.treeGroups.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
self.treeGroups.setSortingEnabled(True)
self.treeGroups.sortByColumn(CG.code)
self.treeGroups.selectionModel().selectionChanged.connect(
self.on_groups_tree_selected)
self.agsGroupViewWidget = AGS4GroupViewWidget(self)
self.splitter.addWidget(self.agsGroupViewWidget)
self.splitter.setStretchFactor(0, 2)
self.splitter.setStretchFactor(1, 5)
G.settings.restore_splitter(self.splitter)
self.splitter.splitterMoved.connect(self.on_splitter_moved)
#self.statusBar = QtGui.QStatusBar()
#self.mainLayout.addWidget(self.statusBar, 0)
##############################################################################
rightWidget = QtGui.QWidget()
rightLayout = xwidgets.vlayout()
rightWidget.setLayout(rightLayout)
self.splitter.addWidget(rightWidget)
#self.agsHeadingDetailWidget = AGS4HeadingDetailWidget()
#rightLayout.addWidget(self.agsHeadingDetailWidget)
#self.init_setup()
G.ags.sigLoaded.connect(self.on_loaded)
self.txtFilter.setText("DETL")
def on_splitter_moved(self, i, pos):
G.settings.save_splitter(self.splitter)
def set_focus(self):
self.txtFilter.setFocus()
def init(self):
print "init", selfs
def on_proxy_changed(self, tl, br):
print "changes", tl, bsr
#=========================================
def on_groups_tree_selected(self, sel=None, desel=None):
if not self.treeGroups.selectionModel().hasSelection():
self.agsGroupViewWidget.set_group(None)
self.sigGroupSelected.emit(None)
return
tIdx = self.proxy.mapToSource(sel.indexes()[0])
grp_dic = self.proxy.sourceModel().rec_from_midx(tIdx)
self.agsGroupViewWidget.set_group(grp_dic)
self.sigGroupSelected.emit(grp_dic)
def on_filter_col(self, idx):
self.update_filter()
self.txtFilter.setFocus()
def on_txt_changed(self, x):
self.update_filter()
def update_filter(self):
self.treeClass.blockSignals(True)
self.treeClass.clearSelection()
self.treeClass.blockSignals(False)
cidx = self.buttGroupFilter.checkedId()
self.proxy.setFilterKeyColumn(cidx)
txt = str(self.txtFilter.text()).strip()
if "_" in txt:
grp_code, _ = txt.split("_")
else:
grp_code = txt
self.proxy.setFilterFixedString(grp_code)
if self.proxy.rowCount() == 1:
# TODO
# #self.tree.selectionModel().select(self.proxy.index(0,0))
pass
def on_clear_filter(self):
self.txtFilter.setText("")
self.txtFilter.setFocus()
def on_class_tree_selected(self, selected, deselected):
if not self.treeClass.selectionModel().hasSelection():
self.txtFilter.setFocus()
#self.on_group_tree_selected()
return
self.proxy.setFilterKeyColumn(CG.cls)
item = self.treeClass.model().itemFromIndex(selected.indexes()[0])
if item.text() == "All":
self.proxy.setFilterFixedString("")
else:
self.proxy.setFilterFixedString(item.text())
self.txtFilter.setFocus()
def init_load(self):
pass
def on_loaded(self):
## expand first row
self.treeClass.setExpanded(self.treeClass.model().item(0, 0).index(),
True)
self.treeClass.sortByColumn(0, Qt.AscendingOrder)
## set sort orders
self.treeGroups.sortByColumn(CG.code, Qt.AscendingOrder)
self.treeGroups.resizeColumnToContents(CG.code)
class AGS4GroupNotesWidget(QtGui.QWidget):
sigWordClicked = pyqtSignal(str)
def __init__(self, parent, mode=None):
QtGui.QWidget.__init__(self, parent)
self.mainLayout = QtGui.QVBoxLayout()
self.mainLayout.setSpacing(0)
self.mainLayout.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.mainLayout)
##==============================
scrollArea = QtGui.QScrollArea()
scrollArea.setWidgetResizable(True)
self.mainLayout.addWidget(scrollArea, 100)
self.scrollWidget = QtGui.QWidget()
scrollArea.setWidget(self.scrollWidget)
self.scrollLayout = QtGui.QVBoxLayout()
self.scrollLayout.setContentsMargins(0, 0, 0, 0)
self.scrollLayout.setSpacing(0)
self.scrollWidget.setLayout(self.scrollLayout)
def clear(self):
"""Removes all entries"""
## pain.. all this s***e just to nuke a list
self.setUpdatesEnabled(False)
while self.scrollLayout.count() > 0:
vari = self.scrollLayout.itemAt(0)
w = vari.widget()
if w:
self.scrollLayout.removeWidget(w)
w.setParent(None)
w = None
else:
self.scrollLayout.removeItem(vari)
self.setUpdatesEnabled(True)
self.update()
def set_group(self, grp):
self.clear()
if grp == None:
return
notes = grp.get("notes")
if notes == None:
return
self.setUpdatesEnabled(False)
lookup = ags4.AGS4.words
for note in notes:
w = widget = QtGui.QLabel()
words = note.split(" ")
res = []
for word in words:
#print word
if word in lookup:
res.append("<a href='#%s-%s'>%s</a>" %
(lookup[word]['type'], word, word))
else:
res.append(word)
widget.setText(" ".join(res))
widget.setTextFormat(QtCore.Qt.RichText)
widget.setWordWrap(True)
widget.setMargin(0)
sty = "background-color: #EEF1F8; padding: 2px; margin:0; border-bottom:1px solid #dddddd;"
widget.setStyleSheet(sty)
widget.setAlignment(QtCore.Qt.AlignTop)
self.scrollLayout.addWidget(w, 0)
#self.connect(widget, QtCore.SIGNAL("linkHovered(const QString)"), self.on_link_hover)
widget.linkActivated.connect(self.on_link_activated)
#if len(notes) < 4:
self.scrollLayout.addStretch(10)
self.setUpdatesEnabled(True)
def on_link_activated(self, lnkq):
lnk = str(lnkq)
parts = lnk[1:].split("-", 1)
print "act", lnk, parts, type(parts[1])
self.sigWordClicked.emit(parts[1])
class TableHeaderWidget(QtGui.QWidget):
"""The HEADER info in tableWidget """
sigGoto = pyqtSignal(str)
def __init__(self, parent=None, ogtDoc=None):
QtGui.QWidget.__init__(self, parent)
self.ogtDoc = ogtDoc
self.ogtHeading = None
self.debug = False
self.mainLayout = QtGui.QGridLayout()
self.mainLayout.setSpacing(0)
self.mainLayout.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.mainLayout)
row = 0
## So splits up tthe header into parts..
#self.headerWidget = QtGui.QWidget()
self.headerGridLay = QtGui.QHBoxLayout()
#self.headerWidget.setLayout(self.headerGridLay)
self.mainLayout.addLayout(self.headerGridLay, row, 0, 1, 3)
self.lblHeadCode = xwidgets.XLabel("-", bold=True)
self.headerGridLay.addWidget(self.lblHeadCode, 10)
#self.buttGroup = xwidgets.XToolButton(self, text="group")
#self.headerGridLay.addWidget(self.buttGroup)
self.buttHeadCode = xwidgets.XToolButton(self,
ico=Ico.BulletDown,
bold=True,
popup=True,
menu=True)
self.buttHeadCode.setToolButtonStyle(Qt.ToolButtonIconOnly)
self.headerGridLay.addWidget(self.buttHeadCode, 0)
self.buttHeadCode.menu().addAction("Open Group TODO")
self.buttHeadCode.menu().addAction("Select another heading TODO")
#sp = self.buttHeadCode.sizePolicy()
#sp.setHorizontalPolicy(QtGui.QSizePolicy.Expanding)
#self.buttHeadCode.setSizePolicy(sp)
sty = "background-color: #dddddd; color: black; padding: 3px; font-size: 8pt;"
# description
row += 1
self.lblHeadDescription = QtGui.QLabel()
self.lblHeadDescription.setStyleSheet(sty)
self.lblHeadDescription.setFixedHeight(60)
self.lblHeadDescription.setWordWrap(True)
self.lblHeadDescription.setAlignment(Qt.AlignTop | Qt.AlignLeft)
self.mainLayout.addWidget(self.lblHeadDescription, row, 0, 1, 3)
# unit
row += 1
lbl = xwidgets.XLabel("Unit:", align=Qt.AlignRight, style=sty)
self.mainLayout.addWidget(lbl, row, 0)
self.lblUnit = xwidgets.XLabel("-",
bold=True,
style=sty + "color: #000099;")
self.mainLayout.addWidget(self.lblUnit, row, 1, 1, 2)
# Type
row += 1
lbl = xwidgets.XLabel("Type:", align=Qt.AlignRight, style=sty)
self.mainLayout.addWidget(lbl, row, 0)
self.lblType = xwidgets.XLabel("-",
bold=True,
style=sty + "color: #000099;")
self.mainLayout.addWidget(self.lblType, row, 1)
self.buttLink = QtGui.QToolButton()
#self.buttLink.setAutoRaise(True)
self.buttLink.setText("Goto")
self.mainLayout.addWidget(self.buttLink, row, 2)
self.buttLink.setVisible(False)
self.buttLink.clicked.connect(self.on_goto)
self.mainLayout.setColumnStretch(0, 1)
self.mainLayout.setColumnStretch(1, 5)
def set_link(self, state):
self.buttLink.setVisible(state)
def set_heading(self, ogtHeading):
self.ogtHeading = ogtHeading
descr = self.ogtHeading.head_description
t = "-" if descr == None else descr
para = '<p style="line-height: 80%">' + t + '</p>'
self.lblHeadDescription.setText(para)
self.lblHeadCode.setText(ogtHeading.head_code)
self.lblUnit.setText(self.ogtHeading.unit_label)
#typ = "<a href="""
self.lblType.setText(self.ogtHeading.type_label)
#self.lblType.setToolTip(hrec['type'])
typ = ags4.AGS4.type(self.ogtHeading.type)
if typ:
self.lblType.setToolTip(typ['description'])
else:
self.lblType.setToolTip(self.ogtHeading.type_label)
def on_goto(self):
self.sigGoto.emit(self.ogtHeading.head_code)
class AGS4_GroupNotesTable(QtGui.QWidget):
sigLoaded = pyqtSignal(int, object)
def __init__(self, parent, mode=None):
QtGui.QWidget.__init__(self, parent)
self.debug = True
self.cache = None
self.mainLayout = QtGui.QVBoxLayout()
self.mainLayout.setSpacing(0)
self.mainLayout.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.mainLayout)
##==============================
scrollArea = QtGui.QScrollArea()
scrollArea.setWidgetResizable(True)
self.mainLayout.addWidget(scrollArea, 100)
self.scrollWidget = QtGui.QWidget()
#self.mainLayout.addWidget(self.noticesListWidget, 100)
scrollArea.setWidget(self.scrollWidget)
self.scrollLayout = QtGui.QVBoxLayout()
self.scrollLayout.setContentsMargins(0, 0, 0, 0)
self.scrollLayout.setSpacing(0)
self.scrollWidget.setLayout(self.scrollLayout)
def clear(self):
"""Removes all QLabel entries"""
## pain.. all this s***e just to nuke a list
self.setUpdatesEnabled(False)
while self.scrollLayout.count() > 0:
vari = self.scrollLayout.itemAt(0)
w = vari.widget()
if w:
self.scrollLayout.removeWidget(w)
w.setParent(None)
w = None
else:
self.scrollLayout.removeItem(vari)
self.setUpdatesEnabled(True)
self.update()
def load_notes(self, group_code):
"""Loads group notes
:param group_code: The four character group code
"""
lookup = G.Ags.get_words()
self.clear()
notes = G.Ags.get_notes(group_code)
#print notes
if notes == None:
return
self.setUpdatesEnabled(False)
for note in notes:
w = widget = QtGui.QLabel()
words = note.split(" ")
res = []
for word in words:
#print word
if word in lookup:
res.append("<a href='#%s-%s'>%s</a>" %
(lookup[word]['type'], word, word))
else:
res.append(word)
widget.setText(" ".join(res))
widget.setTextFormat(QtCore.Qt.RichText)
widget.setWordWrap(True)
widget.setMargin(0)
widget.setStyleSheet(
"background-color: #C3F6A9; padding: 2px; margin: 0; border-bottom:1px solid #dddddd;"
)
widget.setAlignment(QtCore.Qt.AlignTop)
self.scrollLayout.addWidget(w, 0)
self.connect(widget, QtCore.SIGNAL("linkHovered(const QString)"),
self.on_link_hover)
#if len(notes) < 4:
self.scrollLayout.addStretch(10)
self.setUpdatesEnabled(True)
self.sigLoaded.emit(len(notes), self)
#self.emit(QtCore.SIGNAL("loaded"), len(notes), self)
def on_link_hover(self, lnk):
#print "link=", lnk
#self.statusBar.showMessage(lnk)
print "TODO"
def on_tree_context_menu(self, point):
if not self.tree.selectionModel().hasSelection():
return
class GroupDataTableWidget(QtGui.QWidget):
sigGoto = pyqtSignal(str)
def __init__(self, parent):
QtGui.QWidget.__init__(self, parent)
self.debug = False
self.ogtGroup = None
self.mainLayout = xwidgets.vlayout()
self.setLayout(self.mainLayout)
#== Headings
self.tableHeadings = QtGui.QTableView()
self.mainLayout.addWidget(self.tableHeadings, 0)
self.headingsModel = GroupHeadingsModel(self)
self.tableHeadings.setModel(self.headingsModel)
self.tableHeadings.horizontalHeader().hide()
self.tableHeadings.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.tableHeadings.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
#== Data
self.tableData = QtGui.QTableView()
self.mainLayout.addWidget(self.tableData, 200)
self.dataModel = GroupDataModel(self)
self.tableData.setModel(self.dataModel)
self.tableData.horizontalHeader().hide()
self.tableData.horizontalScrollBar().valueChanged.connect(
self.on_table_data_h_scroll)
HEADER_HEIGHT = 120
self.tableHeadings.setRowHeight(1, 60)
self.tableHeadings.setFixedHeight(HEADER_HEIGHT + 30)
#self.headCodeDelegeate = HeadCodeDelegate()
#self.tableHeadings.setItemDelegateForRow(0, self.headCodeDelegeate)
#HeadCodeWidget
self.headingsModel.dataChanged.connect(self.on_header_data_changed)
def on_header_data_changed(self, tl, tr):
print "on_header_data_changed", tl, tr
dssdsa()
def update_headings(self):
for cidx in range(0, self.headingsModel.columnCount()):
idx = self.headingsModel.index(0, cidx)
widget = self.tableHeadings.indexWidget(idx)
if widget == None:
widget = HeadCodeWidget()
self.tableHeadings.setIndexWidget(idx, widget)
widget.set_head_code(self.headingsModel.data(idx, Qt.DisplayRole))
def on_table_data_h_scroll(self, x):
self.tableHeadings.horizontalScrollBar().setValue(x)
def deadon_tree_sched_v_scroll(self, x):
self.treeSamples.verticalScrollBar().setValue(x)
def set_group(self, ogtGroup):
self.ogtGroup = ogtGroup
#self.headingsModel =
self.headingsModel.set_group(self.ogtGroup)
#self.dataModel =
self.dataModel.set_group(self.ogtGroup)
# Init table, first row = 0 is headings (cos we cant embed widgets in a header on pyqt4)
# headings = self.ogtGroup.headings()
#self.tableHeadings.setRowCount(1)
#self.tableHeadings.setColumnCount(self.ogtGroup.headings_count)
return
# v_labels = QtCore.QStringList() # vertical labels
## Populate header
HEADER_HEIGHT = 120
for cidx, heading in enumerate(self.ogtGroup.headings_list()):
hitem = xwidgets.XTableWidgetItem()
hitem.set(heading.head_code, bold=True)
self.tableHeadings.setHorizontalHeaderItem(cidx, hitem)
header_widget = TableHeaderWidget(ogtDoc=self.ogtGroup.ogtDoc)
header_widget.set_heading(heading)
self.tableHeadings.setCellWidget(0, cidx, header_widget)
header_widget.sigGoto.connect(self.on_goto)
self.tableHeadings.setVerticalHeaderLabels([""])
self.tableHeadings.setRowHeight(0, HEADER_HEIGHT)
self.tableHeadings.setFixedHeight(HEADER_HEIGHT + 30)
v_labels = QtCore.QStringList()
# Load the data
return
for ridx, row in enumerate(self.ogtGroup.data):
# self.tableData.setRowCount( self.tableData.rowCount() + 1)
v_labels.append(str(ridx + 1))
for cidx, heading in enumerate(self.ogtGroup.headings_list()):
# item = QtGui.QTableWidgetItem()
# item.setText(row[heading.head_code])
# self.tableData.setItem(ridx + 1, cidx, item)
if heading.type == "PA":
# Combo dropdown
self.tableData.setItemDelegateForColumn(
cidx,
ags4_widgets.PickListComboDelegate(self, heading))
# item.setBackgroundColor(QtGui.QColor("#FFFDBF"))
if heading.type in ["2DP"]:
# Number editor
# item.setTextAlignment(Qt.AlignRight|Qt.AlignVCenter)
self.tableData.setItemDelegateForColumn(
cidx, ags4_widgets.NumberEditDelegate(self, heading))
if heading.type == "ID":
if self.ogtGroup.group_code == heading.head_code.split(
"_")[0]:
# in same group as heading, so highlight the ID
pass # item.setBackgroundColor(QtGui.QColor("#FFF96C"))
else:
# Dropdown for ID
optts = self.ogtGroup.parentDoc.get_column_data(
heading.head_code)
self.tableData.setItemDelegateForColumn(
cidx,
ags4_widgets.IDComboDelegate(self,
heading,
options=optts))
# self.tableData.cellWidget(0, cidx).set_link(True)
# item.setBackgroundColor(QtGui.QColor("#FFFDBF"))
self.tableData.setRowHeight(ridx + 1, 25)
# resize columns, with max_width
col_width = 200
# self.tableHeadings.resizeColumnsToContents()
for cidx in range(0, self.tableHeadings.columnCount()):
self.tableHeadings.setColumnWidth(cidx, 120)
if self.tableHeadings.columnWidth(cidx) > col_width:
self.tableHeadings.setColumnWidth(cidx, col_width)
self.tableData.setColumnWidth(cidx,
self.tableHeadings.columnWidth(cidx))
self.tableHeadings.verticalHeader().setFixedWidth(
self.tableData.verticalHeader().width())
def on_goto(self, code):
self.sigGoto.emit(code)
class AGS4_GroupViewWidget(QtGui.QWidget):
"""The GroupView contains the vertically the Group Label at top, headings and notes"""
sigHeadCodeSelected = pyqtSignal(object)
def __init__(self, parent, mode=None):
QtGui.QWidget.__init__(self, parent)
self.debug = True
self.cache = None
self.group_by = "none"
self.mainLayout = QtGui.QVBoxLayout()
self.mainLayout.setSpacing(0)
self.mainLayout.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.mainLayout)
self.toolbar = xwidgets.hlayout()
self.mainLayout.addLayout(self.toolbar, 0)
self.icoLabel = xwidgets.IconLabel(self, ico=Ico.AgsGroup)
self.icoLabel.setStyleSheet("background-color: white; color: #444444;")
self.toolbar.addWidget(self.icoLabel)
self.lblGroupCode = QtGui.QLabel(" ")
self.lblGroupCode.setStyleSheet(
"background-color: white; color: %s; font-weight: bold; font-family: monospace; padding: 3px;"
% AGS_COLORS.group)
self.toolbar.addWidget(self.lblGroupCode, 1)
self.lblGroupCode.setFixedWidth(50)
self.lblDescription = QtGui.QLabel(" ")
self.lblDescription.setStyleSheet(
"background-color: white; color: #444444;")
self.toolbar.addWidget(self.lblDescription, 3)
self.mainLayout.addSpacing(10)
#self.tabWidget = QtGui.QTabWidget()
#self.mainLayout.addWidget(self.tabWidget)
#self.lblHeadings = Widgets.Label(text="Headings")
#self.mainLayout.addWidget(self.lblHeadings, 0)
self.agsHeadingsTable = AGS4_HeadingsTable(self)
self.mainLayout.addWidget(self.agsHeadingsTable, 10)
#self.tabWidget.addTab(self.agsHeadingsTable, dIco.icon(dIco.AgsField), "Headings")
#self.lblNotes = Widgets.Label(text="Notes")
#self.mainLayout.addWidget(self.lblNotes, 0)
self.agsGroupNotesTable = AGS4_GroupNotesTable(self)
self.agsGroupNotesTable.setFixedHeight(200)
self.mainLayout.addWidget(self.agsGroupNotesTable)
#self.tabWidget.addTab(self.agsGroupNotesTable, dIco.icon(dIco.AgsNotes), "Notes")
#self.connect(self.agsGroupNotesTable, QtCore.SIGNAL("loaded"), self.on_notes_loaded)
self.agsHeadingsTable.sigHeadCodeSelected.connect(self.on_head_code)
def on_head_code(self, head_code):
self.sigHeadCodeSelected.emit(head_code)
def on_notes_loaded(self, c):
self.tabWidget.setTabText(1, "Notes - %s" % (c if c > 0 else "None"))
def clear(self):
self.lblGroupCode.setText("")
self.lblDescription.setText("")
self.agsGroupNotesTable.clear()
def load_group(self, group_code):
if group_code == None:
self.agsHeadingsTable.filter_headings()
return
g = G.Ags.get_group(group_code)
#print group_code, g
self.lblGroupCode.setText(g['group_code'])
self.lblDescription.setText(g['group_description'])
if False:
self.tabWidget.setTabText(0, "Headings - %s" % len(g['headings']))
if len(g['notes']) == 0:
s = "None"
else:
s = len(g['notes'])
self.tabWidget.setTabText(1, "Notes - %s" % s)
self.agsHeadingsTable.filter_headings(g['group_code'])
self.agsGroupNotesTable.load_notes(g['group_code'])
class AGS4_HeadingsTable(QtGui.QWidget):
sigHeadCodeSelected = pyqtSignal(object)
"""A row has been selected or delelected
:return: HeadCode or `None`
"""
def __init__(self, parent):
QtGui.QWidget.__init__(self, parent)
self.debug = True
self.cache = None
self.proxy = QtGui.QSortFilterProxyModel()
self.proxy.setSourceModel(G.Ags.modelHeadings)
self.proxy.setFilterCaseSensitivity(QtCore.Qt.CaseInsensitive)
self.proxy.setFilterKeyColumn(CH.group_code)
self.proxy.setFilterFixedString(SHOW_NONE)
self.group_code = None
self.mainLayout = QtGui.QVBoxLayout()
self.mainLayout.setSpacing(0)
self.mainLayout.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.mainLayout)
##===============================================================
self.tree = QtGui.QTreeView()
self.mainLayout.addWidget(self.tree)
self.tree.setUniformRowHeights(True)
self.tree.setRootIsDecorated(False)
self.tree.setAlternatingRowColors(True)
self.tree.setSortingEnabled(False)
self.tree.setModel(self.proxy)
for c in [CH.example, CH.group_code, CH.sort]:
pass #self.tree.setColumnHidden(c, True)
self.tree.setColumnWidth(CH.head_code, 100)
self.tree.setColumnWidth(CH.unit, 50)
self.tree.setColumnWidth(CH.status, 40)
self.tree.setColumnWidth(CH.data_type, 50)
self.tree.header().setStretchLastSection(True)
self.tree.setSortingEnabled(True)
self.tree.selectionModel().selectionChanged.connect(
self.on_tree_selected)
#self.statusBar = StatusBar(self, True)
#self.mainLayout.addWidget(self.statusBar, 0)
#self.statusBar.hide()
def filter_headings(self, gc=None):
self.group_code = SHOW_NONE if gc == None else gc
self.proxy.setFilterFixedString(self.group_code)
#=========================================
def on_tree_selected(self, sel, desel):
if not self.tree.selectionModel().hasSelection():
self.sigHeadCodeSelected.emit(None)
return
selidx = sel.indexes()[0]
srcidx = self.proxy.mapToSource(selidx)
model = self.proxy.sourceModel()
tIdx = model.index(srcidx.row(), CH.head_code, srcidx.parent())
item = model.itemFromIndex(tIdx)
head_code = str(item.text())
self.sigHeadCodeSelected.emit(head_code)
def on_tree_context_menu(self, point):
if not self.tree.selectionModel().hasSelection():
return
def deadon_butt_pop(self, butt):
code = str(butt.property("code").toString())
p = self.mapFromGlobal(QtGui.QCursor.pos())
#print p
p = QtGui.QCursor.pos()
d = ags.AgsAbbrevPopDialog.AgsAbbrevPopDialog(self, abrev_code=code)
d.move(p.x() - 50, 100)
d.exec_()
class ServerConnection(QtCore.QObject):
"""
HTTP Client
"""
TIMEOUT = 3000 #30000
response = pyqtSignal(object) # XReply
def __init__(self, parent=None, server=None):
QtCore.QObject.__init__(self, parent)
self.debug = False
self.callbacks = {}
self.netManager = QtNetwork.QNetworkAccessManager(self)
## Initialise cookies
self.cookieJar = QtNetwork.QNetworkCookieJar()
self.netManager.setCookieJar(self.cookieJar)
self.netManager.finished.connect(self.on_request_finished)
#self.netMan.error.connect(self._on_server_read_error)
def get(self,
origin=None,
url=None,
params=None,
tag=None,
cb=None,
widget=None,
debug=False,
spinner=True):
self.debug = False
srv = G.settings.current_server()
if srv == None:
print("NO Server in dServer.fetch()")
return
url = QtCore.QUrl("%s/ajax%s" % (srv.url, url))
#q = QtCore.QUrlQuery()
if params:
for k, v in params.items():
url.addQueryItem(str(k), str(v))
request = QtNetwork.QNetworkRequest()
request.setUrl(url)
request.setOriginatingObject(origin)
request.setPriority(QtNetwork.QNetworkRequest.HighPriority)
if tag:
request.setAttribute(ATTR_ID, tag)
#self.load_cookies() TODO
if spinner:
pass #self.spin(True)
if G.args.dev:
print("# --- GET: tag=%s, %s" % (tag, url.toString()))
#self.trigger_reply( request, SERVER_STATUS.REQUESTING, SERVER_FLAG.WAIT )
## creat own accoutn bundle and senf
#req = Request(url)
##req.timeout.connect(self.on_timeout)
##self.requests.append(req)
#req.reply = self.netManager.get( request )
reply = self.netManager.get(request)
def on_request_finished(self, qreply):
"""Server Request has finished, so parse and check for errors"""
#self.spin(False)
reply = XReply(qreply=qreply)
reply.tag = qreply.request().attribute(ATTR_ID)
reply.origin = qreply.request().originatingObject()
## Things not OK
if reply.http_code != 200:
reply.error = "HTTP Error: %s" % reply.http_code
qreply.deleteLater()
self.response.emit(reply)
return
if qreply.error():
print(
"ERROR", qreply.error(),
qreply.attribute(
QtNetwork.QNetworkReply.HttpStatusCodeAttribute))
catchme_todo
qreply.deleteLater()
return
## Save Cookies - TODO
"""
cookies = self.netManager.cookieJar().allCookies()
#print "-------- REC COOKIES----------------_"
G.settings.beginGroup( "cookies" )
for cookie in cookies:
G.settings.setValue( "%s" % str( cookie.name() ), str( cookie.value() ) )
#print "SAVE", cookie.name(), cookie.value()
G.settings.endGroup()
"""
## Decode json
# make it py/str/ascii for now (need to catch non ascii soon and utf-8 everywhere)
# TODO catch non unicode
contents = str(qreply.readAll().data())
#print("contents=", contents)
try:
reply.data = json.loads(contents)
# Always expect a dict or list so add error
if isinstance(reply.data, dict) or isinstance(reply.data, list):
pass # ok
else:
reply.error = "Does nto seem to be json"
qreply.deleteLater()
self.response.emit(reply)
return
except ValueError as e:
reply.error = "Not Valid json %s" % str(e)
qreply.deleteLater()
self.response.emit(reply)
return
except TypeError as e:
reply.error = "Not Valid json %s" % str(e)
qreply.deleteLater()
self.response.emit(reply)
return
## json is decoded and works
print "should now get here"
if self.debug:
print(" data keys: %s" % " ".join(sorted(resp.data.keys())))
qreply.deleteLater()
class Ags4Object(QtCore.QObject):
sigLoaded = pyqtSignal()
def __init__( self, parent=None):
super(QtCore.QObject, self).__init__(parent)
#self.modelNotes = NotesModel()
self.modelUnits = UnitsModel(self)
self.modelTypes = DataTypesModel(self)
self.modelClasses = ClassesModel(self)
self.modelGroups = GroupsModel(self)
self.modelHeadings = HeadingsModel(self)
#self.modelAbbrevClasses = ClassesModel(self)
#self.modelAbbrevs = AbbrevsModel(self)
self.modelAbbrItems = AbbrevItemsModel(self)
#self.modelGroups.sigClasses.connect(self.modelClasses.load_classes)
#self.connect(self.modelAbbrevs, QtCore.SIGNAL("classes"), self.modelAbbrevClasses.load_classes)
def init_load(self):
err = ags4.AGS4.initialise()
if err:
panicssss
self.load()
def load(self):
#self.modelAbbrItems.load_data(ags4.AGS4.abbrs())
self.modelClasses.set_ags4dd(ags4.AGS4)
self.modelGroups.set_ags4dd(ags4.AGS4)
self.modelUnits.set_ags4dd(ags4.AGS4)
self.modelTypes.set_ags4dd(ags4.AGS4)
#self.modelNotes.init_words()
self.sigLoaded.emit()
def get_group(self, code):
return self.modelGroups.get_group(code)
def deadget_abbrev(self, head_code):
return self.modelAbbrevItems.get_abbrev(head_code)
def has_abbrev(self, head_code):
"""Check `head_code` exists
:param head_code:
"""
return self.modelAbbrevItems.has_abbrev(head_code)
#
def deadget_words(self):
return self.modelNotes.get_words()
def get_notes(self, group_code):
return self.modelNotes.get_notes(group_code)
def get_heading(self, head_code):
return self.modelHeadings.get_heading(head_code)
def get_picklist(self, abbrev):
#print self.modelAbbrevItems.get_picklist(abbrev)
return self.modelAbbrevItems.get_picklist(abbrev)
"""
class OGTProjectWidget( QtGui.QWidget ):
sigUpdated = pyqtSignal(object)
def __init__( self, parent=None):
QtGui.QWidget.__init__( self, parent )
self.debug = False
self.ogtDoc = None
self.mainLayout = xwidgets.vlayout()
self.setLayout(self.mainLayout)
self.topLay = xwidgets.hlayout()
self.mainLayout.addLayout(self.topLay)
self.lblHeader = QtGui.QLabel()
self.lblHeader.setStyleSheet("background-color: green; color: white; font-size: 14pt; padding: 3px 5px;")
self.topLay.addWidget(self.lblHeader, 100)
self.buttExport = QtGui.QToolButton()
self.buttExport.setText("Export..")
self.buttExport.setIcon(Ico.icon(Ico.Export))
self.buttExport.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
self.buttExport.setPopupMode(QtGui.QToolButton.InstantPopup)
self.topLay.addWidget(self.buttExport)
menu = QtGui.QMenu()
self.buttExport.setMenu(menu)
for a in FORMATS:
menu.addAction("%s - TODO" % a)
self.mainLayout.addSpacing(5)
self.tabBar = QtGui.QTabBar()
f = self.tabBar.font()
f.setBold(True)
self.tabBar.setFont(f)
self.mainLayout.addWidget(self.tabBar)
self.stackWidget = QtGui.QStackedWidget()
self.mainLayout.addWidget(self.stackWidget)
## add tables tab
self.tabBar.addTab(Ico.icon(Ico.Groups), "Tables")
self.ogtDocWidget = ogtgui_doc.OGTDocumentWidget()
self.stackWidget.addWidget(self.ogtDocWidget)
self.tabBar.addTab(Ico.icon(Ico.Schedule), "Schedule")
self.ogtScheduleWidget = ogtgui_widgets.OGTScheduleWidget()
self.stackWidget.addWidget(self.ogtScheduleWidget)
## add Sources tab
self.tabBar.addTab(Ico.icon(Ico.Source), "Source")
self.ogtSourceViewWidget = ogtgui_widgets.OGTSourceViewWidget()
self.stackWidget.addWidget(self.ogtSourceViewWidget)
self.tabBar.addTab(Ico.icon(Ico.Project), "Summary")
self.ogtProjSummaryWidget = OGTProjectSummaryWidget()
self.stackWidget.addWidget(self.ogtProjSummaryWidget)
self.tabBar.currentChanged.connect(self.on_tab_changed)
#self.tabBar.setCurrentIndex(1)
def init(self):
pass
def on_tab_changed(self, idx):
self.stackWidget.setCurrentIndex(idx)
def load_ags4_file(self, file_path):
#self.file_path = None
"""
self.doc, err = ogt_doc.OGTDocument()
err = self.doc.load_from_ags4_file(file_path)
#print "err=", err
"""
self.ogtDoc, err = ogt_doc.create_doc_from_ags4_file(file_path)
proj = self.ogtDoc.proj_dict()
print "proj=", proj
self.lblHeader.setText(proj['PROJ_NAME'])
self.ogtDocWidget.load_document(self.ogtDoc)
self.ogtScheduleWidget.load_document(self.ogtDoc)
self.ogtSourceViewWidget.load_document(self.ogtDoc)
class ExamplesWidget(QtGui.QWidget):
sigLoadFile = pyqtSignal(object)
def __init__(self, parent):
QtGui.QWidget.__init__(self, parent)
self.debug = False
self.mainLayout = QtGui.QVBoxLayout()
self.mainLayout.setSpacing(0)
self.mainLayout.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.mainLayout)
self.tabBar = QtGui.QTabBar()
self.mainLayout.addWidget(self.tabBar, 0)
self.tabBar.currentChanged.connect(self.on_tab_changed)
#=============================
## Set up tree
self.tree = QtGui.QTreeWidget()
self.mainLayout.addWidget(self.tree, 30)
self.tree.setRootIsDecorated(False)
self.tree.header().setStretchLastSection(True)
self.tree.header().hide()
hi = self.tree.headerItem()
hi.setText(C_EG.file_path, "full path")
hi.setText(C_EG.file_name, "Example")
self.tree.setColumnHidden(C_EG.file_path, True)
self.tree.itemDoubleClicked.connect(self.on_tree_double_clicked)
def load(self):
## nuke any tabs existing
self.tabBar.blockSignals(True)
for i in range(0, self.tabBar.count()):
self.tabBar.removeTab(i)
dirs, err = utils.get_example_dirs()
if err:
# todo warn
return
for d in dirs:
nidx = self.tabBar.addTab(Ico.icon(Ico.Folder), d)
self.tabBar.setTabData(nidx, d)
self.tabBar.blockSignals(False)
self.on_tab_changed(0)
def list_files(self, sub_dir):
files_list, err = utils.list_examples(sub_dir)
if err:
pass #TODO
self.tree.clear()
for file_name in files_list:
item = QtGui.QTreeWidgetItem()
item.setText(C_EG.file_path, file_name)
item.setText(C_EG.file_name, os.path.basename(file_name))
item.setIcon(C_EG.file_name, Ico.icon(Ico.Ags4))
f = item.font(C_EG.file_name)
f.setBold(True)
item.setFont(C_EG.file_name, f)
self.tree.addTopLevelItem(item)
def on_tree_double_clicked(self, item, col):
file_path = str(item.text(C_EG.file_path))
self.sigLoadFile.emit(file_path)
def on_tab_changed(self, idx):
sub_dir = str(self.tabBar.tabData(idx).toString())
self.list_files(sub_dir)
class OGTErrorsWidget(QtGui.QWidget):
sigGotoSource = pyqtSignal(int, int)
sigErrorsFilter = pyqtSignal(bool, bool)
def __init__(self, parent=None, mode=None):
QtGui.QWidget.__init__(self, parent)
self.debug = False
self.mode = mode
if self.mode == None:
freak_out()
self.mainLayout = QtGui.QVBoxLayout()
self.mainLayout.setSpacing(0)
self.mainLayout.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.mainLayout)
self.toolBar = QtGui.QToolBar()
self.mainLayout.addWidget(self.toolBar)
self.buttGroupFilters = QtGui.QButtonGroup(self)
self.buttGroupFilters.setExclusive(False)
self.buttWarnings = xwidgets.XToolButton(text="Show Warnings",
checkable=True,
checked=True)
self.buttGroupFilters.addButton(self.buttWarnings)
self.buttErrors = xwidgets.XToolButton(text="Show Errors",
checkable=True,
checked=True)
self.buttGroupFilters.addButton(self.buttErrors)
self.buttGroupFilters.buttonClicked.connect(self.on_update_filter)
self.toolBar.addWidget(self.buttWarnings)
self.toolBar.addWidget(self.buttErrors)
#=============================
## Set up tree
self.tree = QtGui.QTreeView()
self.mainLayout.addWidget(self.tree, 30)
self.model = ErrorsListModel(mode=self.mode)
self.tree.setModel(self.model)
self.tree.setRootIsDecorated(False)
self.tree.header().setStretchLastSection(True)
#self.tree.setSortingEnabled(True)
"""
hi = self.tree.headerItem()
hi.setText(C_ERR.err, "Type")
hi.setText(C_ERR.lidx, "Line")
hi.setText(C_ERR.cidx, "Col")
hi.setText(C_ERR.rule, "Rule")
hi.setText(C_ERR.highlight, "Rule")
hi.setText(C_ERR.descr, "Description")
hi.setText(C_ERR.search, "search")
"""
self.tree.setColumnHidden(C_ERR.err, True)
self.tree.setColumnHidden(C_ERR.search, True)
self.tree.setColumnWidth(C_ERR.lidx, 30)
self.tree.setColumnWidth(C_ERR.cidx, 30)
self.tree.setColumnWidth(C_ERR.rule, 50)
self.tree.setColumnWidth(C_ERR.highlight, 8)
#self.tree.itemClicked.connect(self.on_tree_item_clicked)
def clear(self):
print "clear", self #self.tree.clear()
def set_group(self, ogtGroup):
self.model.set_group(ogtGroup)
def load_document(self, ogtDoc):
print "load_codument", self
#self.model.load_document(ogtDoc)
return
errrs = ogtDoc.get_errors_list()
if len(errrs) == 0:
item = xwidgets.XTreeWidgetItem()
item.set(C_ERR.descr, "Yipee! no errors :-)", bg="#D5FF71")
item.setFirstColumnSpanned(True)
self.tree.addTopLevelItem(item)
return
for er in errrs:
item = xwidgets.XTreeWidgetItem()
item.set(C_ERR.err, "1" if er.type else "0")
item.set(C_ERR.descr, er.message, bg=er.bg)
item.set(C_ERR.lidx, er.line_no, align=Qt.AlignCenter)
item.set(C_ERR.cidx, er.column_no, align=Qt.AlignCenter)
item.set(C_ERR.rule,
"-" if er.rule == None else er.rule,
align=Qt.AlignCenter)
item.set(C_ERR.search, "%s-%s" % (er.lidx, er.cidx))
self.tree.addTopLevelItem(item)
self.on_show_warnings(sig=False)
self.on_show_errors(sig=False)
def on_tree_item_clicked(self, item, col):
lidx = item.i(C_ERR.lidx) - 1
cidx = item.i(C_ERR.cidx) - 1
if lidx == None and cidx == None:
return
self.sigGotoSource.emit(lidx, cidx)
def select_items(self, ridx, cidx):
#print "select_items", ridx, cidx
self.tree.blockSignals(True)
# clear selection and hightlight colors
self.tree.clearSelection()
root = self.tree.invisibleRootItem()
for i in range(0, root.childCount()):
root.child(i).set_bg(C_ERR.highlight, "white")
if ridx != None and cidx != None:
# search and hightlight row/col if any
search = "%s-%s" % (ridx, cidx)
items = self.tree.findItems(search, Qt.MatchExactly, C_ERR.search)
if len(items) > 0:
for item in items:
item.set_bg(C_ERR.highlight, "purple")
self.tree.blockSignals(False)
def on_update_filter(self):
self.on_show_warnings()
self.on_show_errors()
self.emit_filters_sig()
def on_show_warnings(self, sig=True):
return
hidden = self.buttWarnings.isChecked() == False
root = self.tree.invisibleRootItem()
self.tree.setUpdatesEnabled(False)
for ridx in range(0, root.childCount()):
if str(root.child(ridx).text(C_ERR.err)) == "0":
root.child(ridx).setHidden(hidden)
self.tree.setUpdatesEnabled(True)
if sig:
self.emit_filters_sig()
def on_show_errors(self, sig=True):
return
hidden = self.buttErrors.isChecked() == False
root = self.tree.invisibleRootItem()
self.tree.setUpdatesEnabled(False)
for ridx in range(0, root.childCount()):
if str(root.child(ridx).text(C_ERR.err)) == "1":
root.child(ridx).setHidden(hidden)
self.tree.setUpdatesEnabled(True)
if sig:
self.emit_filters_sig()
def emit_filters_sig(self):
self.sigErrorsFilter.emit(self.buttWarnings.isChecked(),
self.buttErrors.isChecked())
def get_error_filters(self):
return self.buttWarnings.isChecked(), self.buttErrors.isChecked()
class GroupWidget(QtGui.QWidget):
sigGoto = pyqtSignal(str)
def __init__(self, parent=None, ogtGroup=None):
QtGui.QWidget.__init__(self, parent)
self.debug = False
self.ogtGroup = None
self.mainLayout = xwidgets.vlayout()
self.setLayout(self.mainLayout)
## titles and toolbar at top =========
m = 3
topLay = xwidgets.hlayout(margin=m)
self.mainLayout.addLayout(topLay, 0)
# View Mode
self.tbgView = xwidgets.ToolBarGroup(
title="View",
is_group=True,
toggle_icons=True,
toggle_callback=self.on_view_change)
topLay.addWidget(self.tbgView)
self.tbgView.addButton(text="Data", idx=0, checkable=True)
self.tbgView.addButton(text="Source",
idx=1,
checkable=True,
checked=True)
# description
sty = "background-color: #333333; color: #dddddd; padding: 2px;"
self.lblGroupDescription = QtGui.QLabel()
self.lblGroupDescription.setStyleSheet(sty + "")
topLay.addWidget(self.lblGroupDescription, 100)
# The AGS group data
self.buttGroupCode = xwidgets.XToolButton(text="-",
ico=Ico.Ags4,
bold=True,
width=80,
tooltip="View AGS data Dict")
#self.buttGroupCode.setStyleSheet( "font-weight: bold;")
topLay.addWidget(self.buttGroupCode, 0)
self.buttGroupCode.clicked.connect(self.on_butt_group_code)
# mid splitter with stack widget
self.splitter = QtGui.QSplitter()
self.mainLayout.addWidget(self.splitter)
#self.stackWidget = QtGui.QStackedWidget()
#self.splitter.addWidget(self.stackWidget)
# Left LAyout
if True:
self.leftWidget = QtGui.QWidget()
self.leftLay = xwidgets.vlayout()
self.leftWidget.setLayout(self.leftLay)
self.splitter.addWidget(self.leftWidget)
self.groupDataTableWidget = GroupDataTableWidget(self)
self.leftLay.addWidget(self.groupDataTableWidget)
self.groupSourceTableWidget = GroupSourceGridTableWidget(self)
self.leftLay.addWidget(self.groupSourceTableWidget)
# Right LAyout
self.rightWidget = QtGui.QWidget()
self.rightLay = xwidgets.vlayout()
self.rightWidget.setLayout(self.rightLay)
self.splitter.addWidget(self.rightWidget)
self.errorsWidget = ogtgui_widgets.OGTErrorsWidget(
mode=ogtgui_widgets.VIEW_ERR_MODE.group)
self.rightLay.addWidget(self.errorsWidget, 1)
self.headersListWidget = HeadersListWidget()
self.headersListWidget.setMinimumWidth(300)
self.rightLay.addWidget(self.headersListWidget, 1)
self.splitter.setStretchFactor(0, 10)
self.splitter.setStretchFactor(1, 4)
#self.splitter.setStretchFactor(0, 10)
#self.splitter.setStretchFactor(1, 0)
if ogtGroup:
self.set_group(ogtGroup)
self.groupSourceTableWidget.model.layoutChanged.connect(
self.on_data_changed)
self.groupDataTableWidget.headingsModel.layoutChanged.connect(
self.on_data_changed)
self.groupDataTableWidget.dataModel.layoutChanged.connect(
self.on_data_changed)
self.on_view_change(self.tbgView.get_id())
#self.groupDataTableWidget.headingsModel.dataChanged.connect(self.on_headings_data_changed)
self.on_data_changed()
def on_headings_data_changed(self):
print "on_headings_data_changed"
def on_data_changed(self):
print "on_data_changed", self, self.sender()
for model in [
self.groupSourceTableWidget.model,
self.groupDataTableWidget.headingsModel,
self.groupDataTableWidget.dataModel
]:
if model == self.sender():
print "ignore", model
else:
model.modelReset.emit()
self.headersListWidget.model.layoutChanged.emit()
self.errorsWidget.model.layoutChanged.emit()
self.groupDataTableWidget.update_headings()
def set_group(self, ogtGroup):
self.ogtGroup = ogtGroup
## Set the labels
self.buttGroupCode.setText(self.ogtGroup.group_code)
descr = None
if ogtGroup.data_dict():
descr = self.ogtGroup.group_description
self.lblGroupDescription.setText("-" if descr == None else descr)
# load into widgets
self.groupDataTableWidget.set_group(ogtGroup)
self.groupSourceTableWidget.set_group(ogtGroup)
self.headersListWidget.set_group(ogtGroup)
self.errorsWidget.set_group(ogtGroup)
return
def on_goto(self, code):
self.sigGoto.emit(code)
def on_butt_group_code(self):
d = ags4_widgets.AGS4GroupViewDialog(
group_code=self.ogtGroup.group_code)
d.exec_()
def on_view_change(self, idx):
return
self.stackWidget.setCurrentIndex(idx)
class OGTProjectSummaryWidget(QtGui.QMainWindow):
sigGoto = pyqtSignal(object)
sigGotoSource = pyqtSignal(int, int)
def __init__(self, parent=None):
QtGui.QMainWindow.__init__(self, parent)
self.debug = False
self.file_path = None
self.ogtDoc = None
self.dockProject = QtGui.QDockWidget()
self.dockProject.setWindowTitle("Project")
self.dockProject.setFeatures(QtGui.QDockWidget.DockWidgetMovable)
self.dockProject.setAllowedAreas(Qt.LeftDockWidgetArea
| Qt.RightDockWidgetArea)
self.addDockWidget(Qt.LeftDockWidgetArea, self.dockProject)
self.lblProjectPlace = QtGui.QLabel()
self.lblProjectPlace.setText("project placeholder")
self.dockProject.setWidget(self.lblProjectPlace)
## Errors
self.dockGroups = QtGui.QDockWidget()
self.dockGroups.setWindowTitle("Groups")
self.dockGroups.setFeatures(QtGui.QDockWidget.DockWidgetMovable)
self.dockGroups.setAllowedAreas(Qt.LeftDockWidgetArea
| Qt.RightDockWidgetArea)
self.addDockWidget(Qt.RightDockWidgetArea, self.dockGroups)
self.groupsListWidget = ogtgui_groups.GroupsListWidget()
self.dockGroups.setWidget(self.groupsListWidget)
#self.tree.setMinimumWidth(300)
#self.tree.setRootIsDecorated(False)
#self.tree.header().setStretchLastSection(True)
#self.setCentralWidget(self.tree)
#self.model = GroupListModel()
#self.tree.setModel(self.model)
"""
hi = self.tree.headerItem()
hi.setText(CP.group_code, "Group")
hi.setText(CP.group_description, "Description")
hi.setText(CP.node, "Rows")
hi.setTextAlignment(CP.node, Qt.AlignRight)
self.tree.itemDoubleClicked.connect(self.on_tree_double_clicked)
"""
#self.tree.setColumnWidth(CP.node, 40)
#self.tree.setColumnWidth(CP.group_code, 70)
centralWidget = QtGui.QWidget()
centralLay = xwidgets.vlayout()
centralWidget.setLayout(centralLay)
self.setCentralWidget(centralWidget)
lbl = QtGui.QLabel()
lbl.setText("Errors and Warnings")
lbl.setStyleSheet(
"font-weight: bold; padding: 3px; background-color: #eeeeee;")
centralLay.addWidget(lbl)
self.errorsWidget = ogtgui_widgets.OGTErrorsWidget(
mode=ogtgui_widgets.VIEW_ERR_MODE.group)
centralLay.addWidget(self.errorsWidget)
self.errorsWidget.sigGotoSource.connect(self.on_goto_source)
def clear(self):
self.errorsWidget.clear()
self.tree.clear()
def load_document(self, ogtDoc):
# self.model = OGTProjectsModel()
#self.model.load_document(ogtDoc)
self.ogtDoc = ogtDoc
self.groupsListWidget.set_document(self.ogtDoc)
#self.errorsWidget.load_document(self.ogtDoc)
return
for g in self.ogtDoc.groups_list:
#print "===", g.group_description
item = xwidgets.XTreeWidgetItem()
item.set(CP.group_code, g.group_code, bold=True, ico=Ico.AgsGroup)
item.set(CP.group_description, g.group_description)
item.set(CP.node, str(g.data_rows_count()), align=Qt.AlignRight)
#self.tree.addTopLevelItem(item)
def on_tree_double_clicked(self, item, cidx):
print "dbk", item, cidx
item = self.tree.currentItem()
if item == None:
return
self.sigGoto.emit(item.text(CP.group_code))
def on_goto_source(self, lidx, cidx):
self.sigGotoSource.emit(lidx, cidx)
class AgsObject(QtCore.QObject):
sigLoaded = pyqtSignal()
def __init__(self, parent=None):
super(QtCore.QObject, self).__init__(parent)
self.modelNotes = NotesModel()
self.modelUnits = UnitsModel(self)
self.modelClasses = ClassesModel(self)
self.modelGroups = GroupsModel(self)
self.modelHeadings = HeadingsModel(self)
#self.modelAbbrevClasses = ClassesModel(self)
#self.modelAbbrevs = AbbrevsModel(self)
self.modelAbbrItems = AbbrevItemsModel(self)
self.modelGroups.sigClasses.connect(self.modelClasses.load_classes)
#self.connect(self.modelAbbrevs, QtCore.SIGNAL("classes"), self.modelAbbrevClasses.load_classes)
def load(self):
all, err = ogt.ags4.all()
print err
print "all=", all.keys()
self.modelAbbrItems.load_data(all['abbrs'])
groups, err = ogt.ags4.groups()
#print groups.keys()
self.modelGroups.load_data(groups)
self.modelNotes.init_words()
self.sigLoaded.emit()
def get_group(self, code):
return self.modelGroups.get_group(code)
def deadget_abbrev(self, head_code):
return self.modelAbbrevItems.get_abbrev(head_code)
def has_abbrev(self, head_code):
"""Check `head_code` exists
:param head_code:
"""
return self.modelAbbrevItems.has_abbrev(head_code)
#
def get_words(self):
return self.modelNotes.get_words()
def get_notes(self, group_code):
return self.modelNotes.get_notes(group_code)
def get_heading(self, head_code):
return self.modelHeadings.get_heading(head_code)
def get_picklist(self, abbrev):
#print self.modelAbbrevItems.get_picklist(abbrev)
return self.modelAbbrevItems.get_picklist(abbrev)
"""
class AGS4HeadingsTable(QtGui.QWidget):
sigHeadingSelected = pyqtSignal(object)
def __init__(self, parent):
QtGui.QWidget.__init__(self, parent)
self.mainLayout = QtGui.QVBoxLayout()
self.mainLayout.setSpacing(0)
self.mainLayout.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.mainLayout)
##===============================================================
self.tree = QtGui.QTreeView()
self.mainLayout.addWidget(self.tree)
self.tree.setUniformRowHeights(True)
self.tree.setRootIsDecorated(False)
self.tree.setAlternatingRowColors(True)
self.model = HeadingsModel()
self.tree.setModel(self.model)
CH = HeadingsModel.CH
self.tree.setColumnWidth(CH.strip, 3)
self.tree.setColumnWidth(CH.head_code, 100)
self.tree.setColumnWidth(CH.description, 250)
self.tree.setColumnWidth(CH.unit, 50)
self.tree.setColumnWidth(CH.status, 40)
self.tree.setColumnWidth(CH.data_type, 50)
self.tree.setColumnWidth(CH.sort_order, 20)
self.tree.header().setStretchLastSection(True)
self.tree.setSortingEnabled(False)
self.tree.setContextMenuPolicy(Qt.CustomContextMenu)
self.tree.customContextMenuRequested.connect(self.on_tree_context_menu)
self.tree.selectionModel().selectionChanged.connect(
self.on_tree_selected)
self.popMenu = QtGui.QMenu()
self.actOpenGroup = self.popMenu.addAction(Ico.icon(Ico.AgsGroup),
"CODEEEEE",
self.on_act_open_group)
def on_tree_context_menu(self, qPoint):
idx = self.tree.indexAt(qPoint)
rec = self.model.rec_from_midx(idx)
gc = rec['head_code'].split("_")[0]
self.actOpenGroup.setDisabled(gc == self.model.grpDD['group_code'])
self.actOpenGroup.setText("Open: %s" % gc)
self.popMenu.exec_(self.tree.mapToGlobal(qPoint))
def on_act_open_group(self):
selidx = self.tree.selectionModel().selectedIndexes()
rec = self.model.rec_from_midx(selidx[0])
hc = rec.get("head_code")
gc = hc.split("_")[0]
d = AGS4GroupViewDialog(self, group_code=gc, head_code=hc)
d.exec_()
def set_group(self, grp):
self.model.set_group(grp)
def on_tree_selected(self, sel, desel):
if not self.tree.selectionModel().hasSelection():
self.sigHeadingSelected.emit(None)
return
rec = self.model.rec_from_midx(sel.indexes()[0])
self.sigHeadingSelected.emit(rec)
def deadon_tree_context_menu(self, point):
if not self.tree.selectionModel().hasSelection():
return
def deadon_butt_pop(self, butt):
code = str(butt.property("code").toString())
p = self.mapFromGlobal(QtGui.QCursor.pos())
#print p
p = QtGui.QCursor.pos()
d = ags.AgsAbbrevPopDialog.AgsAbbrevPopDialog(self, abrev_code=code)
d.move(p.x() - 50, 100)
d.exec_()
def select_heading(self, head_code):
midx = self.model.get_heading_index(head_code)
if midx != None:
self.tree.selectionModel().setCurrentIndex(
midx, QtGui.QItemSelectionModel.SelectCurrent
| QtGui.QItemSelectionModel.Rows)
class AGS4_GroupsBrowser(QtGui.QWidget):
sigCodeSelected = pyqtSignal(object)
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.debug = True
self.proxy = QtGui.QSortFilterProxyModel()
self.proxy.setSourceModel(G.Ags.modelGroups)
self.proxy.setFilterCaseSensitivity(QtCore.Qt.CaseInsensitive)
##===============================================
self.mainLayout = QtGui.QVBoxLayout()
self.mainLayout.setSpacing(0)
self.mainLayout.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.mainLayout)
self.splitter = QtGui.QSplitter()
self.mainLayout.addWidget(self.splitter)
##############################################################################
leftWidget = QtGui.QWidget()
leftLayout = xwidgets.vlayout()
leftWidget.setLayout(leftLayout)
self.splitter.addWidget(leftWidget)
##================================
## Classification
topLayout = QtGui.QHBoxLayout()
leftLayout.addLayout(topLayout, 0)
self.treeClass = QtGui.QTreeView()
topLayout.addWidget(self.treeClass, 3)
self.treeClass.setModel(G.Ags.modelClasses)
self.treeClass.setRootIsDecorated(False)
self.treeClass.setExpandsOnDoubleClick(False)
self.treeClass.setFixedHeight(250)
self.treeClass.selectionModel().selectionChanged.connect(
self.on_class_selection)
##================================
## Filter Widget
rLay = QtGui.QVBoxLayout()
topLayout.addLayout(rLay)
grpFilter = xwidgets.GroupGridBox("Filter by")
#mmm = 20
#grpFilter.setContentsMargins(mmm,mmm,mmm,mmm)
grpFilter.grid.setSpacing(5)
grpFilter.setFixedWidth(150)
rLay.addWidget(grpFilter, 1)
## Buttons
self.buttGrp = QtGui.QButtonGroup()
self.buttGrp.setExclusive(True)
self.connect(self.buttGrp, QtCore.SIGNAL("buttonClicked(int)"),
self.on_filter_col)
row = 0
self.buttFilterCode = QtGui.QRadioButton()
grpFilter.grid.addWidget(self.buttFilterCode, row, 1)
self.buttFilterCode.setText("Code")
self.buttGrp.addButton(self.buttFilterCode, CG.code)
row += 1
self.buttFilterDesc = QtGui.QRadioButton()
grpFilter.grid.addWidget(self.buttFilterDesc, row, 1)
self.buttFilterDesc.setText("Description")
self.buttGrp.addButton(self.buttFilterDesc, CG.description)
row += 1
self.buttFilterAll = QtGui.QRadioButton()
grpFilter.grid.addWidget(self.buttFilterAll, row, 1)
self.buttFilterAll.setText("Both")
self.buttFilterAll.setChecked(True)
self.buttGrp.addButton(self.buttFilterAll, CG.search)
row += 1
self.buttClear = xwidgets.ClearButton(self,
callback=self.on_clear_filter)
grpFilter.grid.addWidget(self.buttClear, row, 0)
self.txtCode = QtGui.QLineEdit()
self.txtCode.setMaximumWidth(100)
grpFilter.grid.addWidget(self.txtCode, row, 1)
self.txtCode.textChanged.connect(self.on_txt_changed)
grpFilter.grid.setColumnStretch(0, 0)
grpFilter.grid.setColumnStretch(1, 10)
rLay.addStretch(1)
##===============================================
self.tree = QtGui.QTreeView()
leftLayout.addWidget(self.tree, 10)
self.tree.setUniformRowHeights(True)
self.tree.setRootIsDecorated(False)
self.tree.setAlternatingRowColors(True)
self.tree.setSortingEnabled(True)
self.tree.setModel(self.proxy)
self.tree.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
self.tree.header().setStretchLastSection(True)
self.tree.setColumnHidden(CG.search, True)
self.tree.setColumnHidden(CG.x_id, True)
#self.tree.setColumnHidden(C.abbrev_id, True)
self.tree.setColumnWidth(CG.code, 120)
self.tree.setColumnWidth(CG.description, 250)
#self.tree.setColumnWidth(CG.cls, 150)
self.tree.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.tree.selectionModel().selectionChanged.connect(
self.on_tree_selected)
self.tree.sortByColumn(CG.code)
self.agsGroupViewWidget = AGS4_GroupViewWidget(self)
self.splitter.addWidget(self.agsGroupViewWidget)
self.splitter.setStretchFactor(0, 2)
self.splitter.setStretchFactor(1, 5)
#self.statusBar = StatusBar(self, False)
#self.mainLayout.addWidget(self.statusBar, 0)
##############################################################################
rightWidget = QtGui.QWidget()
rightLayout = xwidgets.vlayout()
rightWidget.setLayout(rightLayout)
self.splitter.addWidget(rightWidget)
self.agsHeadingDetailWidget = AGS4_HeadingDetailWidget()
rightLayout.addWidget(self.agsHeadingDetailWidget)
#self.init_setup()
G.Ags.sigLoaded.connect(self.on_loaded)
self.agsGroupViewWidget.sigHeadCodeSelected.connect(
self.agsHeadingDetailWidget.load_heading)
def init(self):
pass
#=========================================
def on_tree_selected(self, sel, desel):
if not self.tree.selectionModel().hasSelection():
self.sigCodeSelected.emit(None)
return
selidx = sel.indexes()[0]
srcidx = self.proxy.mapToSource(selidx)
model = self.proxy.sourceModel()
tIdx = model.index(srcidx.row(), CG.code, srcidx.parent())
item = model.itemFromIndex(tIdx)
group_code = str(item.text())
self.agsGroupViewWidget.load_group(group_code)
self.sigCodeSelected.emit(group_code)
def on_filter_col(self, idx):
self.update_filter()
self.txtCode.setFocus()
def on_txt_changed(self, x):
self.update_filter()
def update_filter(self):
#print "update_filter", self.tabWidget.currentIndex(), self
self.treeClass.blockSignals(True)
self.treeClass.clearSelection()
self.treeClass.blockSignals(False)
self.proxy.setFilterKeyColumn(self.buttGrp.checkedId())
self.proxy.setFilterFixedString(self.txtCode.text())
def on_clear_filter(self):
self.txtCode.setText("")
self.txtCode.setFocus()
def on_class_selection(self, selected, deselected):
if not self.treeClass.selectionModel().hasSelection():
return
self.proxy.setFilterKeyColumn(CG.cls)
item = self.treeClass.model().itemFromIndex(selected.indexes()[0])
if item.text() == "All":
self.proxy.setFilterFixedString("")
else:
self.proxy.setFilterFixedString(item.text())
def deadon_tree_context_menu(self, point):
if not self.tree.selectionModel().hasSelection():
return #
def init(self):
pass
def on_loaded(self):
# expand first row, set sort orders
self.treeClass.setExpanded(self.treeClass.model().item(0, 0).index(),
True)
self.treeClass.sortByColumn(0, Qt.AscendingOrder)
self.tree.sortByColumn(CG.code, Qt.AscendingOrder)
self.tree.resizeColumnToContents(CG.code)
class OGTDocumentWidget( QtGui.QWidget ):
sigUpdated = pyqtSignal(object)
def __init__( self, parent=None):
QtGui.QWidget.__init__( self, parent )
self.debug = False
self.file_path = None
self.doc = None
self.mainLayout = QtGui.QVBoxLayout()
self.mainLayout.setSpacing(0)
self.mainLayout.setContentsMargins(0,0,0,0)
self.setLayout(self.mainLayout)
self.tabBar = QtGui.QTabBar()
self.mainLayout.addWidget(self.tabBar)
self.stackWidget = QtGui.QStackedWidget()
self.mainLayout.addWidget(self.stackWidget)
self.tabBar.currentChanged.connect(self.on_tab_changed)
def init_load(self):
#self.fetch()
pass
# def fetch(self, example=None):
# """Send request to server"""
# url = "/ags/4/parse"
# params = None
#
# if example:
# params = dict(example=example)
#
# G.server.get(origin=self, url=url, params=params)
#
#
#
# def load_reply(self, xreply):
# """Got a reply from server.."""
# #print self, xreply
#
# if xreply.origin != self:
# return
#
# if not "document" in xreply.data:
# return # SHould not happen
#
# # loop the groups and add the tabs,...
# for dic in xreply.data["document"]["groups"]:
#
# widget = self.load_group(dic)
# def deadload_ags4_file(self, file_path):
#
# self.file_path = None
#
# doc = ogt_doc.OGTDocument()
# #doc.opts.edit_mode = True
# err = doc.load_ags4_file(file_path)
#
#
# self.load_document(doc)
def clear(self):
while self.tabBar.count() > 0:
self.tabBar.removeTab(0)
while self.stackWidget.count() > 0:
self.stackWidget.removeWidget(self.stackWidget.widget(0))
def load_document(self, ogtdoc):
self.ogtDoc = ogtdoc
#print "doc=", self.ogtDoc
#data = doc.to_dict()
for grpOb in self.ogtDoc.groups_list:
#print "here", grpOb
self.load_group( grpOb )
self.tabBar.setCurrentIndex(1)
def load_group(self, ogtGroup):
#print "load_group", ogtGrp, self
widget = ogtgui_group.GroupWidget(self, ogtGroup=ogtGroup)
idx = self.tabBar.addTab( "%s - %s " % (ogtGroup.group_code, ogtGroup.data_rows_count()) )
if ogtGroup.data_dict():
descr = ogtGroup.group_description
self.tabBar.setTabToolTip(idx, "-" if descr == None else descr)
if False:
print "---------"
print "star", ogtGroup.group_start_lidx
print "hidx", ogtGroup.headings_idx
print "uidx", ogtGroup.units_idx
print "tidx", ogtGroup.types_idx
print "didx", ogtGroup.data_start_idx
self.stackWidget.addWidget(widget)
#widget.set_group(ogtGrp)
widget.sigGoto.connect(self.on_goto)
return widget
def select_group(self, group_code):
for i in range(0, self.stackWidget.count()):
if self.stackWidget.widget(i).ogtGroup.group_code == group_code:
self.tabBar.setCurrentIndex(i)
return
def on_tab_changed(self, idx):
# TODO check is theres an edit. ebore tab change maybe
#print "idx", idx
self.stackWidget.setCurrentIndex(idx)
def on_goto(self, code):
grp_code = code.split("_")[0]
for idx in range(0, self.stackWidget.count()):
if self.stackWidget.widget(idx).ogtGroup.group_code == grp_code:
self.tabBar.setCurrentIndex(idx)
#self.stackWidget.widget(idx).select_heading(code)
return
class AGS4GroupViewWidget(QtGui.QWidget):
"""The GroupView contains the vertically the Group Label at top, headings and notes"""
sigHeadingSelected = pyqtSignal(object)
def __init__(self, parent=None, mode=None):
QtGui.QWidget.__init__(self, parent)
self.group_code = None
self.mainLayout = QtGui.QVBoxLayout()
self.mainLayout.setSpacing(0)
self.mainLayout.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.mainLayout)
self.toolbar = xwidgets.hlayout()
self.mainLayout.addLayout(self.toolbar, 0)
self.icoLabel = xwidgets.IconLabel(self, ico=Ico.AgsGroup)
self.icoLabel.setStyleSheet("background-color: white; color: #444444;")
self.toolbar.addWidget(self.icoLabel)
self.lblGroupCode = QtGui.QLabel(" ")
self.lblGroupCode.setStyleSheet(
"background-color: white; color: %s; font-weight: bold; font-family: monospace; padding: 3px;"
% AGS4_COLORS.group)
self.toolbar.addWidget(self.lblGroupCode, 1)
self.lblGroupCode.setFixedWidth(50)
self.lblDescription = QtGui.QLabel(" ")
self.lblDescription.setStyleSheet(
"background-color: white; color: #444444;")
self.toolbar.addWidget(self.lblDescription, 3)
self.mainLayout.addSpacing(10)
## Headings Table
self.agsHeadingsTable = AGS4HeadingsTable(self)
self.mainLayout.addWidget(self.agsHeadingsTable, 10)
##== Bottom Splitter
self.splitBott = QtGui.QSplitter()
self.splitBott.setObjectName("ags_group_view_notes_picklist")
self.mainLayout.addWidget(self.splitBott)
## Notes
self.agsGroupNotesWidget = AGS4GroupNotesWidget(self)
self.agsGroupNotesWidget.setFixedHeight(200)
self.splitBott.addWidget(self.agsGroupNotesWidget)
## Abbrs Picklist
self.agsAbbrevsWidget = AGS4AbbrevsWidget()
self.splitBott.addWidget(self.agsAbbrevsWidget)
## setup splitter
self.splitBott.setStretchFactor(0, 1)
self.splitBott.setStretchFactor(1, 1)
G.settings.restore_splitter(self.splitBott)
self.splitBott.splitterMoved.connect(self.on_splitter_bott_moved)
self.agsHeadingsTable.sigHeadingSelected.connect(
self.on_heading_selection_changed)
self.agsGroupNotesWidget.sigWordClicked.connect(self.on_word_clicked)
def on_word_clicked(self, code):
code = str(code) # WTF!, its a QString not str as sent !
rec = ags4.AGS4.words.get(code)
if rec:
if rec['type'] == "heading":
# its a heading, so select it if its in within this group eg SAMP_ID is almost everywhere
found = self.agsHeadingsTable.select_heading(code)
if not found:
# so its not in this group, so open other group
parts = code.split("_")
d = AGS4GroupViewDialog(group_code=parts[0],
head_code=code)
d.exec_()
if rec['type'] == "group":
if code != self.group_code:
# Dialog only if its not this group
d = AGS4GroupViewDialog(group_code=self.group_code)
d.exec_()
def on_splitter_bott_moved(self):
G.settings.save_splitter(self.splitBott)
def on_heading_selection_changed(self, head_code):
self.sigHeadingSelected.emit(head_code)
self.agsAbbrevsWidget.set_heading(head_code)
def select_heading(self, head_code):
self.agsHeadingsTable.select_heading(head_code)
def clear(self):
self.lblGroupCode.setText("")
self.lblDescription.setText("")
self.agsGroupNotesTable.clear()
self.agsAbbrevsWidget.clear()
def set_group(self, grp):
## load subwidgets, even if grp==None
self.agsHeadingsTable.set_group(grp)
self.agsGroupNotesWidget.set_group(grp)
if grp == None:
self.group_code = None
self.lblGroupCode.setText("")
self.lblDescription.setText("")
return
self.group_code = grp['group_code']
self.lblGroupCode.setText(grp['group_code'])
self.lblDescription.setText(grp['group_description'])
class OGTProjectWidget(QtGui.QWidget):
sigUpdated = pyqtSignal(object)
def __init__(self, parent=None, empty=False):
QtGui.QWidget.__init__(self, parent)
self.debug = False
self.ogtDoc = None
if empty:
self.ogtDoc = ogt_doc.OGTDocument()
self.mainLayout = xwidgets.vlayout()
self.setLayout(self.mainLayout)
##====== Top Bar ===
self.topLay = xwidgets.hlayout()
self.mainLayout.addLayout(self.topLay)
## Header Label
self.lblHeader = QtGui.QLabel()
self.lblHeader.setStyleSheet(
"background-color: #444444; color: #dddddd; font-size: 14pt; padding: 3px 5px;"
)
self.topLay.addWidget(self.lblHeader, 100)
## Add button
self.buttActAdd = xwidgets.XToolButton(text="Add..",
ico=Ico.Add,
menu=True,
popup=True)
self.topLay.addWidget(self.buttActAdd)
## Import button
self.buttImport = xwidgets.XToolButton(text="Import",
ico=Ico.Import,
menu=True,
popup=True)
self.topLay.addWidget(self.buttImport)
self.buttImport.menu().addAction("Add default PROJ, UNIT, etc groups",
self.on_add_default_groups)
## Export button
self.buttExport = xwidgets.XToolButton(text="Export",
ico=Ico.Export,
menu=True,
popup=True)
self.topLay.addWidget(self.buttExport)
for a in FORMATS:
self.buttExport.menu().addAction("%s - TODO" % a)
## Reload button
self.buttReload = xwidgets.XToolButton(text="Reload",
ico=Ico.Refresh,
popup=True,
callback=self.on_reload)
self.topLay.addWidget(self.buttReload)
self.mainLayout.addSpacing(5)
##========= Content ===============
## tabar + Stack
self.tabBar = QtGui.QTabBar()
f = self.tabBar.font()
f.setBold(True)
self.tabBar.setFont(f)
self.mainLayout.addWidget(self.tabBar)
self.stackWidget = XStackedWidget() #QtGui.QStackedWidget()
self.mainLayout.addWidget(self.stackWidget)
## Summary Tab
self.tabBar.addTab(Ico.icon(Ico.Summary), "Summary")
self.ogtProjSummaryWidget = OGTProjectSummaryWidget()
self.stackWidget.addWidget(self.ogtProjSummaryWidget,
"Project Summary")
self.ogtProjSummaryWidget.sigGoto.connect(self.on_goto)
self.ogtProjSummaryWidget.sigGotoSource.connect(self.on_goto_source)
## Groups Tab
self.tabBar.addTab(Ico.icon(Ico.Groups), "Groups")
self.ogtDocWidget = ogtgui_doc.OGTDocumentWidget()
nidx = self.stackWidget.addWidget(self.ogtDocWidget, "Groups")
chk = QtGui.QCheckBox()
chk.setText("Show Data Count")
self.stackWidget.addHeaderWidget(nidx, chk)
## Schedule Tab
self.tabBar.addTab(Ico.icon(Ico.Schedule), "Schedule")
self.ogtScheduleWidget = ogtgui_widgets.OGTScheduleWidget()
self.stackWidget.addWidget(self.ogtScheduleWidget, "Schedule")
## Source tab
self.tabBar.addTab(Ico.icon(Ico.Source), "Source")
self.ogtSourceViewWidget = ogtgui_widgets.OGTSourceViewWidget()
self.stackWidget.addWidget(self.ogtSourceViewWidget, "Sources")
if False:
self.tabBar.addTab(Ico.icon(Ico.Map), "Map")
self.mapOverviewWidget = map_widgets.MapOverviewWidget()
self.stackWidget.addWidget(self.mapOverviewWidget)
self.tabBar.currentChanged.connect(self.on_tab_changed)
if G.args.dev:
self.tabBar.setCurrentIndex(1)
pass
def init_load(self):
pass
def on_tab_changed(self, idx):
self.stackWidget.setCurrentIndex(idx)
def on_reload(self):
fp = self.ogtDoc.source_file_path
self.ogtSourceViewWidget.clear()
self.ogtDocWidget.clear()
self.ogtScheduleWidget.clear()
self.ogtProjSummaryWidget.clear()
self.ogtDoc = None
self.load_ags4_file(fp)
def load_ags4_string(self, contents, file_name):
self.ogtDoc, err = ogt_doc.create_doc_from_ags4_string(
contents, file_name)
self.load_document()
#proj = self.ogtDoc.proj_dict()
#self.lblHeader.setText(proj['PROJ_NAME'])
#self.ogtDocWidget.load_document(self.ogtDoc)
#self.ogtScheduleWidget.load_document(self.ogtDoc)
#self.ogtSourceViewWidget.load_document(self.ogtDoc)
def load_ags4_file(self, file_path):
#self.file_path = None
"""
self.doc, err = ogt_doc.OGTDocument()
err = self.doc.load_from_ags4_file(file_path)
"""
self.ogtDoc, err = ogt_doc.create_doc_from_ags4_file(file_path)
self.load_document()
def load_document(self):
proj = None #self.ogtDoc.proj_dict()
print "proj=", proj, self
if proj:
self.lblHeader.setText(proj['PROJ_NAME'])
self.ogtDocWidget.load_document(self.ogtDoc)
self.ogtProjSummaryWidget.load_document(self.ogtDoc)
return
self.ogtScheduleWidget.load_document(self.ogtDoc)
self.ogtSourceViewWidget.load_document(self.ogtDoc)
## HACK
QtCore.QTimer.singleShot(4000, self.do_map_after)
def do_map_after(self):
self.mapOverviewWidget.load_document(self.ogtDoc)
def on_goto(self, code):
self.ogtDocWidget.select_group(code)
idx = self.stackWidget.indexOf(self.ogtDocWidget)
self.tabBar.setCurrentIndex(idx)
def on_goto_source(self, lidx, cidx):
self.ogtSourceViewWidget.select_cell(lidx, cidx)
idx = self.stackWidget.indexOf(self.ogtSourceViewWidget)
self.tabBar.setCurrentIndex(idx)
def on_add_default_groups(self):
for g in ogt_doc.GROUPS_REQUIRED:
self.ogtDoc.add_group(g)
