class Ui_GHydraulicsResultDialog(object):
def setupUi(self, GHydraulicsResultDialog):
GHydraulicsResultDialog.setObjectName(_fromUtf8("GHydraulicsResultDialog"))
GHydraulicsResultDialog.resize(640, 480)
self.buttonBox = QDialogButtonBox(GHydraulicsResultDialog)
self.buttonBox.setGeometry(QtCore.QRect(10, 440, 620, 32))
self.buttonBox.setOrientation(QtCore.Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel|QDialogButtonBox.Ok)
self.buttonBox.setObjectName(_fromUtf8("buttonBox"))
self.tabWidget = QTabWidget(GHydraulicsResultDialog)
self.tabWidget.setGeometry(QtCore.QRect(10, 10, 620, 390))
self.tabWidget.setObjectName(_fromUtf8("tabWidget"))
self.tabOutput = QWidget()
self.tabOutput.setObjectName(_fromUtf8("tabOutput"))
self.textOutput = QTextBrowser(self.tabOutput)
self.textOutput.setGeometry(QtCore.QRect(10, 10, 600, 340))
sizePolicy = QSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.textOutput.sizePolicy().hasHeightForWidth())
self.textOutput.setSizePolicy(sizePolicy)
self.textOutput.setObjectName(_fromUtf8("textOutput"))
self.tabWidget.addTab(self.tabOutput, _fromUtf8(""))
self.tabReport = QWidget()
self.tabReport.setObjectName(_fromUtf8("tabReport"))
self.textReport = QTextBrowser(self.tabReport)
self.textReport.setGeometry(QtCore.QRect(10, 10, 600, 340))
sizePolicy = QSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.textReport.sizePolicy().hasHeightForWidth())
self.textReport.setSizePolicy(sizePolicy)
self.textReport.setObjectName(_fromUtf8("textReport"))
self.tabWidget.addTab(self.tabReport, _fromUtf8(""))
self.comboStep = QComboBox(GHydraulicsResultDialog)
self.comboStep.setGeometry(QtCore.QRect(150, 410, 80, 27))
self.comboStep.setObjectName(_fromUtf8("comboStep"))
self.labelStep = QLabel(GHydraulicsResultDialog)
self.labelStep.setGeometry(QtCore.QRect(10, 415, 120, 17))
self.labelStep.setObjectName(_fromUtf8("labelStep"))
self.retranslateUi(GHydraulicsResultDialog)
self.tabWidget.setCurrentIndex(0)
#QtCore.QObject.connect(self.buttonBox, QtCore.SIGNAL(_fromUtf8("accepted()")), GHydraulicsResultDialog.accept)
self.buttonBox.accepted.connect(GHydraulicsResultDialog.accept)
#QtCore.QObject.connect(self.buttonBox, QtCore.SIGNAL(_fromUtf8("rejected()")), GHydraulicsResultDialog.reject)
self.buttonBox.rejected.connect(GHydraulicsResultDialog.reject)
QtCore.QMetaObject.connectSlotsByName(GHydraulicsResultDialog)
def retranslateUi(self, GHydraulicsResultDialog):
GHydraulicsResultDialog.setWindowTitle(_translate("GHydraulicsResultDialog", "EPANET Results", None))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tabOutput), _translate("GHydraulicsResultDialog", "EPANET Output", None))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tabReport), _translate("GHydraulicsResultDialog", "Report", None))
self.labelStep.setText(_translate("GHydraulicsResultDialog", "Load time step", None))
class SupportingDocuments(ComponentUtility):
onUploadDocument = pyqtSignal(list)
def __init__(self,
box,
combobox,
add_documents_btn,
notification_bar,
parent=None):
"""
Handles the supporting documents component loading.
:param box: The layout holding the container widget.
:type box: QVBoxLayout
:param combobox: The combobox loading supporting document types.
:type combobox: QComboBox
:param add_documents_btn: The add supporting document button
:type add_documents_btn: QPushButton
:param notification_bar: The NotificationBar object that displays
notification.
:type notification_bar: Object
:param parent: The container of the widget
:type parent: QDialog or None
"""
ComponentUtility.__init__(self)
self._parent = parent
self.container_box = box
self.doc_type_cbo = combobox
self.notification_bar = notification_bar
self.str_number = 1
self.add_documents_btn = add_documents_btn
self.str_numbers = [1]
self.current_party_count = None
self.init_documents()
def init_documents(self):
"""
Initializes the document type combobox by
populating data.
"""
self.supporting_doc_manager = SourceDocumentManager(
self.social_tenure.supporting_doc, self.str_doc_model,
self._parent)
self.create_doc_tab_populate_combobox()
self.doc_type_cbo.currentIndexChanged.connect(
self.match_doc_combo_to_tab)
self.docs_tab.currentChanged.connect(self.match_doc_tab_to_combo)
def party_count(self, count):
"""
A setter for current_party_count that is used to determined
the number of copies for each supporting document.
:param count: The number of currently added party records.
:type count: Integer
"""
self.current_party_count = count
def create_doc_tab_populate_combobox(self):
"""
Creates the supporting document component widget.
"""
self.doc_tab_data()
self.docs_tab = QTabWidget()
self.docs_tab_index = OrderedDict()
for i, (id, doc) in enumerate(self.doc_types.items()):
self.docs_tab_index[doc] = i
# the tab widget containing the document widget layout
# and the child of the tab.
tab_widget = QWidget()
tab_widget.setObjectName(doc)
# The layout of the tab widget
cont_layout = QVBoxLayout(tab_widget)
cont_layout.setObjectName('widget_layout_{}'.format(doc))
# the scroll area widget inside the tab widget.
scroll_area = QScrollArea(tab_widget)
scroll_area.setFrameShape(QFrame.NoFrame)
scroll_area.setObjectName('tab_scroll_area_{}'.format(doc))
layout_widget = QWidget()
# the widget the is under the scroll area content and
# the widget containing the document widget layout
# This widget is hidden and shown based on the STR number
layout_widget.setObjectName('widget_{}'.format(doc))
doc_widget_layout = QVBoxLayout(layout_widget)
doc_widget_layout.setObjectName('doc_widget_layout_{}'.format(doc))
doc_widget = QWidget()
doc_widget.setObjectName('doc_widget_{}_{}'.format(
doc, self.str_number))
doc_widget_layout.addWidget(doc_widget)
# the layout containing document widget.
### This is the layout that is registered to add uploaded
# supporting documents widgets into.
tab_layout = QVBoxLayout(doc_widget)
tab_layout.setObjectName('layout_{}_{}'.format(
doc, self.str_number))
scroll_area.setWidgetResizable(True)
scroll_area.setWidget(layout_widget)
cont_layout.addWidget(scroll_area)
# Add the tab widget with the document
# type name to create a tab.
self.docs_tab.addTab(tab_widget, doc)
self.container_box.addWidget(self.docs_tab, 1)
if len(self.str_numbers) == 1:
self.doc_type_cbo.addItem(doc, id)
def doc_tab_data(self):
"""
Sets the document types in the social tenure entity.
"""
doc_entity = self.social_tenure. \
supporting_doc.document_type_entity
doc_type_model = entity_model(doc_entity)
docs = doc_type_model()
doc_type_list = docs.queryObject().all()
self.doc_types = [(doc.id, doc.value) for doc in doc_type_list]
self.doc_types = OrderedDict(self.doc_types)
def match_doc_combo_to_tab(self):
"""
Changes the active tab based on the
selected value of document type combobox.
"""
combo_text = self.doc_type_cbo.currentText()
if combo_text is not None and len(combo_text) > 0:
index = self.docs_tab_index[combo_text]
self.docs_tab.setCurrentIndex(index)
def match_doc_tab_to_combo(self):
"""
Changes the document type combobox value based on the
selected tab.
"""
doc_tab_index = self.docs_tab.currentIndex()
self.doc_type_cbo.setCurrentIndex(doc_tab_index)
@staticmethod
def hide_doc_widgets(widget, visibility):
"""
Hides or shows the visibility of the supporting document
container widgets.
:param widget: The widget to which the visibility is set.
:type widget: QWidget
:param visibility: A boolean to show or hide visibility.
True hides widget and False shows it.
:type visibility: Boolean
"""
widget.setHidden(visibility)
def update_container(self, str_number):
"""
Update the current supporting document widget container to be used.
:param str_number: The STR node number
:type str_number: Integer
"""
doc_text = self.doc_type_cbo.currentText()
cbo_index = self.doc_type_cbo.currentIndex()
doc_id = self.doc_type_cbo.itemData(cbo_index)
scroll_area = self.docs_tab.findChild(
QScrollArea, 'tab_scroll_area_{}'.format(doc_text, str_number))
doc_widget = scroll_area.findChild(
QWidget, 'doc_widget_{}_{}'.format(doc_text, str_number))
# If the doc widget doesn't exist create it for new STR instance
if doc_widget is None:
# find the doc_widget layout that contains
# all STR doc widget layouts. Single
# doc_widget_layout is created for each document type.
# But all doc_widgets for each STR instance and
# document types will be added here.
doc_widget_layout = scroll_area.findChild(
QVBoxLayout, 'doc_widget_layout_{}'.format(doc_text))
doc_widget = QWidget()
doc_widget.setObjectName('doc_widget_{}_{}'.format(
doc_text, str_number))
self.hide_all_other_widget(doc_text, str_number)
doc_widget_layout.addWidget(doc_widget)
# Create the layout so that layouts are registered in
# which uploaded document widgets are added.
layout = QVBoxLayout(doc_widget)
layout.setObjectName('layout_{}_{}'.format(doc_text, str_number))
# If the doc widget exists, get the lowest
# layout so that it is registered.
else:
# hide all other widgets
self.hide_all_other_widget(doc_text, str_number)
# show the current doc widget to display
# the document widgets for the current tab.
self.hide_doc_widgets(doc_widget, False)
layout = doc_widget.findChild(
QVBoxLayout, 'layout_{}_{}'.format(doc_text, str_number))
# register layout
self.supporting_doc_manager.registerContainer(layout, doc_id)
def hide_all_other_widget(self, doc_text, str_number):
"""
Hides all other supporting document widget except the current
STR node widget.
:param doc_text: The current document type selected.
:type doc_text: String
:param str_number: The STR node number
:type str_number: Integer
"""
expression = QRegExp('doc_widget*')
# hide all existing widgets in all layouts
for widget in self.docs_tab.findChildren(QWidget, expression):
if widget.objectName() != 'doc_widget_{}_{}'.format(
doc_text, str_number):
self.hide_doc_widgets(widget, True)
def on_upload_document(self):
'''
Slot raised when the user clicks
to upload a supporting document.
'''
document_str = QApplication.translate(
"SupportingDocuments", "Specify the Document File Location")
documents = self.select_file_dialog(document_str)
cbo_index = self.doc_type_cbo.currentIndex()
doc_id = self.doc_type_cbo.itemData(cbo_index)
for doc in documents:
self.supporting_doc_manager.insertDocumentFromFile(
doc, doc_id, self.social_tenure, self.current_party_count)
# Set last path
if len(documents) > 0:
doc = documents[0]
fi = QFileInfo(doc)
dir_path = fi.absolutePath()
set_last_document_path(dir_path)
model_objs = self.supporting_doc_manager.model_objects()
self.onUploadDocument.emit(model_objs)
def select_file_dialog(self, title):
"""
Displays a file dialog for a user to specify a source document
:param title: The title of the file dialog
:type title: String
"""
# Get last path for supporting documents
last_path = last_document_path()
if last_path is None:
last_path = '/home'
files, _ = QFileDialog.getOpenFileNames(
iface.mainWindow(), title, last_path,
"Source Documents (*.jpg *.jpeg *.png *.bmp *.tiff *.svg)")
return files
class InspectionForm(FeatureForm):
def __init__(self, *args, **kwargs):
super(InspectionForm, self).__init__(*args, **kwargs)
self.inspectionforms = []
self.joinkey = 'insp_loc_id'
self.mapkeycolumn = 'mapkey'
self.inspectionformname = 'inspection_data'
self.countcolum = 'number'
def uisetup(self):
"""
Called when the UI is fully constructed. You should connect any signals here.
"""
if self.formconfig['type'] == 'auto':
self.AddInspectionButton = QPushButton()
self.inspectiontabs = QTabWidget()
self.layout().addRow(self.AddInspectionButton)
self.layout().addRow(self.inspectiontabs)
self.AddInspectionButton.pressed.connect(self.create_new_inspection)
def load(self, feature, layers, values):
"""
Called before the form is loaded. This method can be used to do pre checks and halt the loading of the form
if needed.
Calling self.cnacelload("Your message") will stop the opening of the form and show the message to the user.
>>> self.cancelload("Sorry you can't load this form now")
You may alter the values given in the values dict. It will be passed to the form after this method returns.
"""
project = self.form.project
self.inspectionform = project.form_by_name(self.inspectionformname)
inspectionlayer = self.inspectionform.QGISLayer
self.AddInspectionButton.setText("Add {}".format(
self.inspectionform.label))
self.AddInspectionButton.setIcon(QIcon(self.inspectionform.icon))
if not self.is_capturing:
inspections = self.find_inspections(self.feature)
self.load_inspections(inspections, mapkeycolumn=self.mapkeycolumn)
def find_inspections(self, feature):
"""
Override to return the inspections for this form forms feature.
:param feature:
:return:
"""
return []
def load_inspections(self, inspections, mapkeycolumn):
"""
Load the given inspections into the form
:param inspections:
:param mapkeycolumn:
:return:
"""
inspectionlayer = self.inspectionform.QGISLayer
for inspection in inspections:
mapkey = inspection['mapkey']
inspectionfeature = feature_by_key(inspectionlayer, mapkey)
self._add_inspectionform(inspectionfeature,
editing=True,
label=self.inspectionform.label)
def create_new_inspection(self):
"""
Create a new inspection feature and add it to the form
:return:
"""
feature = self.inspectionform.new_feature()
# Give the new feature the key from the parent
feature[self.joinkey] = self.bindingvalues[self.joinkey]
self._add_inspectionform(feature,
editing=False,
label=self.inspectionform.label)
def _add_inspectionform(self, feature, editing=False, label=''):
"""
Add a new inspection form for the given feature.
:param feature: The feature to bind to the form
:param editing: True to set the form into edit mode.
False edit mode will add a new feature on save.
"""
count = len(self.inspectionforms) + 1
# Increase the inspection count for this feature
feature[self.countcolum] = count
# Create a new inspection form widget
featureform = self.inspectionform.create_featureform(feature,
editmode=editing)
featureform.helprequest.connect(self.helprequest.emit)
# Extract the values from the feature
values = self.inspectionform.values_from_feature(feature)
# Bind the values to the feature form
featureform.bindvalues(values)
# Add the tab and set the icon
icon = QIcon(self.inspectionform.icon)
self._add_tab(featureform, "{label} {count}".format(label=label,
count=count), icon)
# If the current count is over the max number of inspections then set the
# button to disabled so we can't add anymore
if count >= self.formconfig.get('maxinspections', 2):
self.AddInspectionButton.setText("Max Inspections")
self.AddInspectionButton.setEnabled(False)
def _add_tab(self, widget, name, icon):
"""
Adds a tab to the tab widget with the given widget, name, and icon.
:param widget: The widget to add to the tab
:param name: The name of the tab
:param icon: The icon of the tab
"""
index = self.inspectiontabs.addTab(widget, name)
self.inspectionforms.append(widget)
self.inspectiontabs.setCurrentIndex(index)
self.inspectiontabs.setTabIcon(index, icon)
def save(self):
"""
Override of the save logic for the feature form
We override the save logic because we are not saving to the property layer but to the
InspectionLocation table
"""
# Save all sub forms
for subform in self.inspectionforms:
subform.save()
class SupportingDocumentsWidget(QWidget):
"""
Widget for managing an entity's supporting documents. It enables listing
of documents grouped by tabs depending on type.
"""
def __init__(self,
entity_supporting_document,
supporting_doc_model_cls,
parent=None):
"""
Class constructor.
:param entity_supporting_document: Object containing information
pertaining to document types, parent entity etc.
:type entity_supporting_document: EntitySupportingDocument
:param supporting_doc_model_cls: Class representing the data model
corresponding to the entity supporting document object.
:type supporting_doc_model_cls: object
:param parent: Parent container widget.
:type parent: QWidget
"""
QWidget.__init__(self, parent)
self._init_gui()
self._entity_supporting_doc = entity_supporting_document
# Container for document type widgets based on lookup id
self._doc_type_widgets = {}
# Init document manager
self.source_document_manager = SourceDocumentManager(
self._entity_supporting_doc, supporting_doc_model_cls, self)
self._load_document_types()
# Connect signals
self._btn_add_document.clicked.connect(
self._on_add_supporting_document)
self._cbo_doc_type.currentIndexChanged.connect(
self.on_doc_type_changed)
self._doc_tab_container.currentChanged.connect(
self.on_tab_doc_type_changed)
def _init_gui(self):
self._gl = QGridLayout(self)
self._label = QLabel(self)
self._label.setText(self.tr('Select document type'))
self._gl.addWidget(self._label, 0, 0, 1, 1)
self._cbo_doc_type = QComboBox(self)
self._gl.addWidget(self._cbo_doc_type, 0, 1, 1, 1)
self._btn_add_document = QPushButton(self)
doc_ico = GuiUtils.get_icon('document.png')
self._btn_add_document.setIcon(doc_ico)
self._btn_add_document.setText(self.tr('Add document...'))
self._btn_add_document.setMaximumWidth(200)
self._gl.addWidget(self._btn_add_document, 0, 2, 1, 1)
self._doc_tab_container = QTabWidget(self)
self._gl.addWidget(self._doc_tab_container, 1, 0, 1, 3)
self.setMinimumHeight(140)
def on_doc_type_changed(self, idx):
"""
Slot raised when the document types changes. The corresponding
widget in the tab container is also selected.
:param idx: Item index in the combobox.
:type idx: int
"""
if idx == -1:
return
self._doc_tab_container.setCurrentIndex(idx)
def on_tab_doc_type_changed(self, idx):
"""
Slot raised when the document types changes. The corresponding
widget in the tab container is also selected.
:param idx: Item index in the tab widget.
:type idx: int
"""
if idx == -1:
return
self._cbo_doc_type.setCurrentIndex(idx)
def current_document_type(self):
"""
:return: Returns the currently selected document type in the combobox.
:rtype: str
"""
return self._cbo_doc_type.currentText()
def current_document_type_id(self):
"""
:return: Returns the primary key/id of the currently selected
document type in the combobox, else -1 if there is not current
item in the combobox
:rtype: int
"""
if not self.current_document_type():
return -1
curr_idx = self._cbo_doc_type.currentIndex()
return self._cbo_doc_type.itemData(curr_idx)
def count(self):
"""
:return: Returns the number of document types supported by this
widget.
:rtype: int
"""
return self._cbo_doc_type.count()
def document_type_containers(self):
"""
:return: Returns a list of document container widgets for all
registered document types.
:rtype: list
"""
return list(self.source_document_manager.containers.values())
def document_type_widget(self, name):
"""
Searches for the document type widget that corresponds to the given
name.
:param name: Name of the document type.
:type name: str
:return: Returns the document widget corresponding to the given type
name.
:rtype: QWidget
"""
idx = self._cbo_doc_type.findText(name)
if idx == -1:
return None
rec_id = self._cbo_doc_type.itemData(idx)
return self._doc_type_widgets.get(rec_id, None)
def _load_document_types(self):
# Load document types in the combobox and tab widget
vl_cls = entity_model(self._entity_supporting_doc.document_type_entity,
entity_only=True)
vl_obj = vl_cls()
res = vl_obj.queryObject().all()
for r in res:
# Add to combo
self._cbo_doc_type.addItem(r.value, r.id)
# Add to tab widget
doc_type_widget = _DocumentTypeContainer(self)
self._doc_tab_container.addTab(doc_type_widget, r.value)
self._doc_type_widgets[r.id] = doc_type_widget
# Register container
self.source_document_manager.registerContainer(
doc_type_widget.container, r.id)
def _on_add_supporting_document(self):
# Slot raised when the user select to add a supporting document
if self.count == 0:
return
select = self.tr('Select')
supporting_docs_str = 'Supporting Documents'
title = '{0} {1} {2}'.format(select, self.current_document_type(),
supporting_docs_str)
filter_str = '{0} (*.jpg *.jpeg *.png *.bmp *.tiff *.svg *.pdf)'.format(
supporting_docs_str)
# Get last path for supporting documents
last_path = last_document_path()
if last_path is None:
last_path = '/home'
else:
dir = QDir(last_path)
if not dir.exists():
last_path = '/home'
source_docs, _ = QFileDialog.getOpenFileNames(self, title, last_path,
filter_str)
doc_type_id = self._cbo_doc_type.itemData(
self._cbo_doc_type.currentIndex())
parent_entity = self._entity_supporting_doc.parent_entity
for doc in source_docs:
self.source_document_manager.insertDocumentFromFile(
doc, doc_type_id, parent_entity)
# Set last path
if len(source_docs) > 0:
doc = source_docs[0]
fi = QFileInfo(doc)
dir_path = fi.absolutePath()
set_last_document_path(dir_path)
class DebuggerWidget(QMainWindow):
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.setWindowTitle("First Aid - Debugger")
self.text_edits = {} # fully expanded path of the file -> associated SourceWidget
self.toolbar = self.addToolBar("General")
self.toolbar.setObjectName("ToolbarGeneral")
self.tab_widget = QTabWidget()
self.tab_widget.setTabsClosable(True)
self.tab_widget.tabCloseRequested.connect(self.on_tab_close_requested)
self.tab_widget.currentChanged.connect(self.on_pos_changed)
self.setCentralWidget(self.tab_widget)
_icon = lambda x: QIcon(os.path.join(os.path.dirname(__file__), "icons", x + ".svg"))
self.action_load = self.toolbar.addAction(_icon("folder-outline"), "Load Python file (Ctrl+O)", self.on_load)
self.action_load.setShortcut("Ctrl+O")
self.action_run = self.toolbar.addAction(_icon("run"), "Run Python file (Ctrl+R)", self.on_run)
self.action_run.setShortcut("Ctrl+R")
self.action_bp = self.toolbar.addAction(_icon("record"), "Toggle breakpoint (F9)", self.on_toggle_breakpoint)
self.action_bp.setShortcut("F9")
self.toolbar.addSeparator()
self.action_continue = self.toolbar.addAction(_icon("play"), "Continue (F5)", self.on_continue)
self.action_continue.setShortcut("F5")
self.action_step_into = self.toolbar.addAction(_icon("debug-step-into"), "Step into (F11)", self.on_step_into)
self.action_step_into.setShortcut("F11")
self.action_step_over = self.toolbar.addAction(_icon("debug-step-over"), "Step over (F10)", self.on_step_over)
self.action_step_over.setShortcut("F10")
self.action_step_out = self.toolbar.addAction(_icon("debug-step-out"), "Step out (Shift+F11)", self.on_step_out)
self.action_step_out.setShortcut("Shift+F11")
self.action_run_to_cursor = self.toolbar.addAction(_icon("cursor-default-outline"), "Run to cursor (Ctrl+F10)",
self.on_run_to_cursor)
self.action_run_to_cursor.setShortcut("Ctrl+F10")
self.vars_view = VariablesView()
self.frames_view = FramesView()
self.dock_frames = QDockWidget("Frames", self)
self.dock_frames.setObjectName("DockFrames")
self.dock_frames.setWidget(self.frames_view)
self.addDockWidget(Qt.BottomDockWidgetArea, self.dock_frames)
self.dock_vars = QDockWidget("Variables", self)
self.dock_vars.setObjectName("DockVariables")
self.dock_vars.setWidget(self.vars_view)
self.addDockWidget(Qt.BottomDockWidgetArea, self.dock_vars)
self.resize(800, 800)
self.debugger = Debugger(self)
self.update_buttons()
settings = QSettings()
self.restoreGeometry(settings.value("/plugins/firstaid/debugger-geometry", b''))
self.restoreState(settings.value("/plugins/firstaid/debugger-windowstate", b''))
filenames = settings.value("/plugins/firstaid/debugger-files", [])
if filenames is None:
filenames = []
# load files from previous session
for filename in filenames:
self.load_file(filename)
if self.tab_widget.count() > 1:
self.tab_widget.setCurrentIndex(0)
# start tracing
self.start_tracing()
def start_tracing(self):
""" called from constructor or when the debugger window is opened again """
sys.settrace(self.debugger.trace_function)
def closeEvent(self, event):
# disable tracing
sys.settrace(None)
settings = QSettings()
settings.setValue("/plugins/firstaid/debugger-geometry", self.saveGeometry())
settings.setValue("/plugins/firstaid/debugger-windowstate", self.saveState())
filenames = list(self.text_edits.keys())
settings.setValue("/plugins/firstaid/debugger-files", filenames)
QMainWindow.closeEvent(self, event)
def load_file(self, filename):
filename = os.path.normpath(os.path.realpath(filename))
if filename in self.text_edits:
self.switch_to_file(filename)
return # already there...
try:
self.text_edits[filename] = SourceWidget(filename)
except IOError:
# TODO: display warning we failed to read the file
return
tab_text = os.path.basename(filename)
self.tab_widget.addTab(self.text_edits[filename], tab_text)
self.tab_widget.setTabToolTip(self.tab_widget.count() - 1, filename)
self.tab_widget.setCurrentWidget(self.text_edits[filename])
self.text_edits[filename].cursorPositionChanged.connect(self.on_pos_changed)
self.on_pos_changed()
def switch_to_file(self, filename):
if filename in self.text_edits:
self.tab_widget.setCurrentWidget(self.text_edits[filename])
def unload_file(self, filename):
for index in range(self.tab_widget.count()):
if self.text_edits[filename] == self.tab_widget.widget(index):
self.tab_widget.removeTab(index)
del self.text_edits[filename]
break
def get_file_name(self, args):
if isinstance(args, tuple):
return args[0]
elif isinstance(args, str):
return args
return ""
def on_load(self):
settings = QSettings()
folder = settings.value("firstaid/lastFolder", '')
args = QFileDialog.getOpenFileName(self, "Load", folder, "Python files (*.py)")
filename = self.get_file_name(args)
if not filename: return
settings.setValue("firstaid/lastFolder", os.path.dirname(filename))
self.load_file(filename)
def on_tab_close_requested(self, index):
self.unload_file(self.tab_widget.widget(index).filename)
def on_pos_changed(self):
if not self.current_text_edit():
self.statusBar().showMessage("[no file]")
return
c = self.current_text_edit().textCursor()
line = c.blockNumber() + 1
col = c.positionInBlock() + 1
self.statusBar().showMessage("%d:%d" % (line, col))
def on_run(self):
globals = None
locals = None
if globals is None:
import __main__
globals = __main__.__dict__
if locals is None:
locals = globals
execfile(self.tab_widget.currentWidget().filename, globals, locals)
def current_text_edit(self):
return self.tab_widget.currentWidget()
def on_toggle_breakpoint(self):
if self.current_text_edit():
self.current_text_edit().toggle_breakpoint()
def update_buttons(self):
active = self.debugger.stopped
self.action_step_into.setEnabled(active)
self.action_step_over.setEnabled(active)
self.action_step_out.setEnabled(active)
self.action_run_to_cursor.setEnabled(active)
self.action_continue.setEnabled(active)
def on_step_into(self):
self.debugger.stepping = True
self.debugger.next_step = None
self.debugger.ev_loop.exit(0)
def on_step_over(self):
self.debugger.stepping = True
self.debugger.next_step = (
'over', self.debugger.current_frame.f_code.co_filename, self.debugger.current_frame.f_lineno)
self.debugger.ev_loop.exit(0)
def on_step_out(self):
self.debugger.stepping = True
self.debugger.next_step = ('out', frame_depth(self.debugger.current_frame))
self.debugger.ev_loop.exit(0)
def on_run_to_cursor(self):
self.debugger.stepping = True
filename = self.tab_widget.currentWidget().filename
line_no = self.tab_widget.currentWidget().textCursor().blockNumber() + 1
self.debugger.next_step = ('at', filename, line_no)
self.debugger.ev_loop.exit(0)
def on_continue(self):
self.debugger.stepping = False
self.current_text_edit().debug_line = -1
self.current_text_edit().update_highlight()
self.vars_view.setVariables({})
self.frames_view.setTraceback(None)
self.debugger.ev_loop.exit(0)