← Back to branch summary

~ubuntu-branches/debian/experimental/spyder/experimental

« back to all changes in this revision

Viewing changes to spyderplugins/widgets/breakpointsgui.py

  • Committer: Package Import Robot
  • Author(s): Picca Frédéric-Emmanuel
  • Date: 2013-01-20 12:19:54 UTC
  • mfrom: (1.1.16)
  • Revision ID: package-import@ubuntu.com-20130120121954-1jt1xa924bshhvh0
Tags: 2.2.0~beta1+dfsg-2
fix typo ipython-qtconsol -> ipython-qtconsole

Show diffs side-by-side

added added

removed removed

Lines of Context:
spyderplugins/widgets/breakpointsgui.py
 
1
# -*- coding: utf-8 -*-
 
2
#
 
3
# Copyright © 2012 Jed Ludlow
 
4
# based loosley on pylintgui.py by Pierre Raybaut
 
5
# Licensed under the terms of the MIT License
 
6
# (see spyderlib/__init__.py for details)
 
7
 
 
8
"""Breakpoint widget"""
 
9
 
 
10
# pylint: disable=C0103
 
11
# pylint: disable=R0903
 
12
# pylint: disable=R0911
 
13
# pylint: disable=R0201
 
14
 
 
15
from __future__ import with_statement
 
16
 
 
17
from spyderlib.qt.QtGui import (QWidget, QTableView, QItemDelegate,
 
18
                                QVBoxLayout)
 
19
from spyderlib.qt.QtCore import (Qt, SIGNAL, QTextCodec,
 
20
                                 QModelIndex, QAbstractTableModel)
 
21
locale_codec = QTextCodec.codecForLocale()
 
22
from spyderlib.qt.compat import to_qvariant
 
23
import sys
 
24
import os.path as osp
 
25
 
 
26
# Local imports
 
27
from spyderlib.baseconfig import get_translation
 
28
from spyderlib.config import CONF
 
29
 
 
30
_ = get_translation("p_breakpoints", dirname="spyderplugins")
 
31
 
 
32
class BreakpointTableModel(QAbstractTableModel):
 
33
    """
 
34
    Table model for breakpoints dictionary
 
35
    
 
36
    """
 
37
    def __init__(self, parent, data):
 
38
        QAbstractTableModel.__init__(self, parent)
 
39
        if data is None:
 
40
            data = {}
 
41
        self._data = None
 
42
        self.breakpoints = None
 
43
        self.set_data(data)    
 
44
    
 
45
    def set_data(self, data):
 
46
        """Set model data"""
 
47
        self._data = data
 
48
        keys = data.keys()
 
49
        self.breakpoints = []
 
50
        for key in keys:
 
51
            bp_list = data[key]
 
52
            if bp_list:
 
53
                for item in data[key]:
 
54
                    self.breakpoints.append((key, item[0], item[1], ""))
 
55
        self.reset()   
 
56
    
 
57
    def rowCount(self, qindex=QModelIndex()):
 
58
        """Array row number"""
 
59
        return len(self.breakpoints)
 
60
    
 
61
    def columnCount(self, qindex=QModelIndex()):
 
62
        """Array column count"""
 
63
        return 4
 
64
 
 
65
    def sort(self, column, order=Qt.DescendingOrder):
 
66
        """Overriding sort method"""
 
67
        if column == 0:
 
68
            self.breakpoints.sort(
 
69
                key=lambda breakpoint: breakpoint[1])
 
70
            self.breakpoints.sort(
 
71
                key=lambda breakpoint: osp.basename(breakpoint[0]))
 
72
        elif column == 1:
 
73
            pass
 
74
        elif column == 2:
 
75
            pass
 
76
        elif column == 3:
 
77
            pass
 
78
        self.reset()
 
79
 
 
80
    def headerData(self, section, orientation, role=Qt.DisplayRole):
 
81
        """Overriding method headerData"""
 
82
        if role != Qt.DisplayRole:
 
83
            return to_qvariant()
 
84
        i_column = int(section)
 
85
        if orientation == Qt.Horizontal:
 
86
            headers = (_("File"), _("Line"), _("Condition"), "")
 
87
            return to_qvariant( headers[i_column] )
 
88
        else:
 
89
            return to_qvariant()
 
90
    
 
91
    def get_value(self, index):
 
92
        """Return current value"""
 
93
        return self.breakpoints[index.row()][index.column()] 
 
94
    
 
95
    def data(self, index, role=Qt.DisplayRole):
 
96
        """Return data at table index"""
 
97
        if not index.isValid():
 
98
            return to_qvariant()
 
99
        if role == Qt.DisplayRole:
 
100
            if index.column() == 0:
 
101
                value = osp.basename(self.get_value(index))
 
102
                return to_qvariant(value)
 
103
            else:
 
104
                value = self.get_value(index)
 
105
                return to_qvariant(value)
 
106
        elif role == Qt.TextAlignmentRole:
 
107
            return to_qvariant(int(Qt.AlignLeft|Qt.AlignVCenter))
 
108
        elif role == Qt.ToolTipRole:
 
109
            if index.column() == 0:
 
110
                value = self.get_value(index)
 
111
                return to_qvariant(value)
 
112
            else:
 
113
                return to_qvariant()
 
114
    
 
115
class BreakpointDelegate(QItemDelegate):
 
116
    def __init__(self, parent=None):
 
117
        QItemDelegate.__init__(self, parent)
 
118
 
 
119
class BreakpointTableView(QTableView):
 
120
    def __init__(self, parent, data):
 
121
        QTableView.__init__(self, parent)
 
122
        self.model = BreakpointTableModel(self, data)
 
123
        self.setModel(self.model)
 
124
        self.delegate = BreakpointDelegate(self)
 
125
        self.setItemDelegate(self.delegate)
 
126
 
 
127
        self.setup_table()
 
128
        
 
129
    def setup_table(self):
 
130
        """Setup table"""
 
131
        self.horizontalHeader().setStretchLastSection(True)
 
132
        self.adjust_columns()
 
133
        self.columnAt(0)
 
134
        # Sorting columns
 
135
        self.setSortingEnabled(False)
 
136
        self.sortByColumn(0, Qt.DescendingOrder)
 
137
    
 
138
    def adjust_columns(self):
 
139
        """Resize three first columns to contents"""
 
140
        for col in range(3):
 
141
            self.resizeColumnToContents(col)    
 
142
    
 
143
    def mouseDoubleClickEvent(self, event):
 
144
        """Reimplement Qt method"""
 
145
        index_clicked = self.indexAt(event.pos())
 
146
        filename = self.model.breakpoints[index_clicked.row()][0]
 
147
        line_number_str = self.model.breakpoints[index_clicked.row()][1]
 
148
        self.parent().emit(SIGNAL("edit_goto(QString,int,QString)"),
 
149
                           filename, int(line_number_str), '')   
 
150
 
 
151
class BreakpointWidget(QWidget):
 
152
    """
 
153
    Breakpoint widget
 
154
    """
 
155
    VERSION = '1.0.0'
 
156
    
 
157
    def __init__(self, parent):
 
158
        QWidget.__init__(self, parent)
 
159
        
 
160
        self.setWindowTitle("Breakpoints")        
 
161
        self.dictwidget = BreakpointTableView(self, 
 
162
                               self._load_all_breakpoints())
 
163
        layout = QVBoxLayout()
 
164
        layout.addWidget(self.dictwidget)
 
165
        self.setLayout(layout)
 
166
    
 
167
    def _load_all_breakpoints(self):
 
168
        bp_dict = CONF.get('run', 'breakpoints', {})
 
169
        for filename in bp_dict.keys():
 
170
            if not osp.isfile(filename):
 
171
                bp_dict.pop(filename)
 
172
        return bp_dict    
 
173
    
 
174
    def get_data(self):
 
175
        pass
 
176
        
 
177
    def set_data(self):
 
178
        bp_dict = self._load_all_breakpoints()
 
179
        self.dictwidget.model.set_data(bp_dict)
 
180
        self.dictwidget.adjust_columns()
 
181
        self.dictwidget.sortByColumn(0, Qt.DescendingOrder)
 
182
 
 
183
def test():
 
184
    """Run breakpoint widget test"""
 
185
    from spyderlib.utils.qthelpers import qapplication
 
186
    app = qapplication()
 
187
    widget = BreakpointWidget(None)
 
188
    widget.show()
 
189
    sys.exit(app.exec_())
 
190
    
 
191
if __name__ == '__main__':
 
192
    test()