proxychecker2/targets_editor.py at master · helljump/proxychecker2 · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
#!/usr/bin/env python
#-*- coding: UTF-8 -*-

__author__ = "helljump"


import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from PyQt4 import uic
import settings
import logging
import copy


log = logging.getLogger(__name__)


DEFAULT = [
    ["http://www.google.com", u"<title>Google</title>"],
    ["http://www.yandex.ru", u"<title>Яндекс</title>"],
    ["http://market.yandex.ru", u"<title>Яндекс.Маркет"],
]


class TargetsModel(QAbstractTableModel):
    def __init__(self, data, parent):
        QAbstractTableModel.__init__(self)
        self.labels = [u"Адрес", u'Фрагмент страницы']
        self._data = data

    def rowCount(self, parent):
        return len(self._data)

    def columnCount(self, parent):
        return len(self.labels)

    def data(self, index, role):
        if not index.isValid():
            return QVariant()
        elif role != Qt.DisplayRole and role != Qt.EditRole:
            return QVariant()
        row = index.row()
        column = index.column()
        if role == Qt.DisplayRole:
            value = self._data[row][column]
            return QVariant(value)
        if role == Qt.EditRole:
            value = self._data[row][column]
            return QVariant(value)
        return QVariant()

    def headerData(self, section, orientation, role):
        if orientation == Qt.Horizontal and role == Qt.DisplayRole:
            return QVariant(self.labels[section])
        return QVariant()

    def flags(self, index):
        return Qt.ItemIsSelectable | Qt.ItemIsEditable | Qt.ItemIsEnabled

    def setData(self, index, data, role):
        row = index.row()
        column = index.column()
        self._data[row][column] = unicode(data.toString())
        return True

    def sort(self, col, order):
        reverse = order != Qt.AscendingOrder
        self._data.sort(reverse=reverse)
        ifrom = self.createIndex(0, 0)
        ito = self.createIndex(self.rowCount(None), self.columnCount(None))
        self.dataChanged.emit(ifrom, ito)

    def addItem(self, item):
        self.beginInsertRows(QModelIndex(), len(self._data), len(self._data))
        self._data.append(item)
        self.endInsertRows()

    def removeItems(self, indexes):
        if not indexes:
            return False
        f = indexes[-1].row()
        t = indexes[0].row()
        self.beginRemoveRows(QModelIndex(), f, t)
        for ndx in indexes:
            del self._data[ndx.row()]
        self.endRemoveRows()
        return True


class TargetsDialog(QDialog):

    update_targets = pyqtSignal()

    def __init__(self, parent=None):
        super(TargetsDialog, self).__init__(parent)
        uic.loadUi("assets/targets.ui", self)

        params = settings.STORAGE.get(self.__class__.__name__, {})
        if "geometry" in params:
            self.restoreGeometry(params["geometry"])

        egg = copy.deepcopy(DEFAULT)
        m = TargetsModel(settings.STORAGE.get("targets", egg), self)
        self.tableView.setModel(m)
        self.tableView.horizontalHeader().setResizeMode(0, QHeaderView.ResizeToContents)
        self.tableView.addAction(self.actionInsert)
        self.tableView.addAction(self.actionDelete)
        self.tableView.addAction(self.actionReset)

    @pyqtSlot()
    def on_actionDelete_triggered(self):
        log.debug('delete')
        view = self.tableView
        curr = view.currentIndex()
        rows = [ndx for ndx in view.selectedIndexes() if ndx.column() == 0]
        rows.sort(key=QModelIndex.row, reverse=True)
        view.model().removeItems(rows)
        if curr.row() >= len(view.model()._data):
            curr = view.model().createIndex(len(view.model()._data)-1, 0)
        view.setCurrentIndex(curr)
        view.scrollTo(curr)
        self.tableView.model().layoutChanged.emit()

    @pyqtSlot()
    def on_actionInsert_triggered(self):
        log.debug('start')
        self.tableView.model().addItem(['http://', u''])

    @pyqtSlot()
    def on_actionReset_triggered(self):
        log.debug('reset')
        self.tableView.model()._data = copy.deepcopy(DEFAULT)
        self.tableView.model().layoutChanged.emit()

    def accept(self):
        settings.STORAGE['targets'] = self.tableView.model()._data
        self.update_targets.emit()
        self.close()

    def closeEvent(self, event):
        log.debug("close window")
        settings.STORAGE[self.__class__.__name__] = {
            "geometry": self.saveGeometry(),
        }
        event.accept()


if __name__ == '__main__':
    dl = TargetsDialog()
    dl.show()
    sys.exit(qApp.exec_())