← Back to branch summary

~ubuntu-branches/ubuntu/vivid/blueman/vivid-proposed

« back to all changes in this revision

Viewing changes to blueman/gui/GenericList.py

  • Committer: Package Import Robot
  • Author(s): Artur Rona
  • Date: 2014-12-24 18:33:36 UTC
  • mfrom: (2.3.8 sid)
  • Revision ID: package-import@ubuntu.com-20141224183336-cyb82ot0y8tz8flq
Tags: 1.99~alpha1-1ubuntu1
* Merge from Debian unstable.  Remaining changes:
  - debian/patches/01_dont_autostart_lxde.patch:
    + Don't autostart the applet in LXDE.
  - debian/patches/03_filemanager_fix.patch:
    + Add support for more filemanagers.
* debian/patches/02_dont_crash_on_non-bluetooth_card.patch:
  - Dropped, no longer applicable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
blueman/gui/GenericList.py
1
 
# Copyright (C) 2008 Valmantas Paliksa <walmis at balticum-tv dot lt>
2
 
# Copyright (C) 2008 Tadas Dailyda <tadas at dailyda dot com>
3
 
#
4
 
# Licensed under the GNU General Public License Version 3
5
 
#
6
 
# This program is free software: you can redistribute it and/or modify
7
 
# it under the terms of the GNU General Public License as published by
8
 
# the Free Software Foundation, either version 3 of the License, or
9
 
# (at your option) any later version.
10
 
#
11
 
# This program is distributed in the hope that it will be useful,
12
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
# GNU General Public License for more details.
15
 
#
16
 
# You should have received a copy of the GNU General Public License
17
 
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
18
 
# 
19
 
import gtk
20
 
 
21
 
 
22
 
class GenericList(gtk.TreeView):
23
 
 
24
 
        def __init__(self, data):
25
 
                gtk.TreeView.__init__(self)
26
 
                self.selection = self.get_selection()
27
 
                self._load(data)
28
 
                
29
 
                
30
 
 
31
 
        def _load(self, data):
32
 
                
33
 
                self.ids = {}
34
 
                self.columns = {}
35
 
                
36
 
 
37
 
                types = []
38
 
                for i in range(len(data)):
39
 
                        types.append(data[i][1])
40
 
                        
41
 
                types = tuple(types)
42
 
                
43
 
                self.liststore = gtk.ListStore(*types)
44
 
                self.set_model(self.liststore)
45
 
                column = None
46
 
                for i in range(len(data)):
47
 
 
48
 
                        self.ids[data[i][0]] = i
49
 
                        
50
 
                        
51
 
                        if len(data[i]) == 5 or len(data[i]) == 6:
52
 
 
53
 
                                column = gtk.TreeViewColumn(data[i][4])
54
 
                                
55
 
                                column.pack_start(data[i][2])
56
 
                                column.set_attributes(data[i][2], **data[i][3])                         
57
 
                                
58
 
                                
59
 
                                if len(data[i]) == 6:
60
 
                                        column.set_properties(**data[i][5])
61
 
                                
62
 
                                self.columns[data[i][0]] = column
63
 
                                self.append_column(column)
64
 
                                
65
 
 
66
 
    
67
 
        def selected(self):
68
 
                (model, iter) = self.selection.get_selected()
69
 
               
70
 
                return iter
71
 
 
72
 
                        
73
 
    
74
 
        def delete(self, id):
75
 
                if type(id) == gtk.TreeIter:
76
 
                        iter = id
77
 
                else:
78
 
                        iter = self.get_iter(id)
79
 
                
80
 
                if iter == None:
81
 
                        return False
82
 
                if self.liststore.iter_is_valid(iter):
83
 
                        self.liststore.remove(iter)
84
 
                        return True
85
 
                else:
86
 
                        return False
87
 
                        
88
 
        
89
 
        def _add(self, **columns):
90
 
                ids_len = len(self.ids)
91
 
                cols_len = len(columns)
92
 
                
93
 
                items = {}
94
 
                for k, v in self.ids.iteritems():
95
 
                        items[v] = None
96
 
        
97
 
                
98
 
                for k, v in columns.iteritems():
99
 
                        if k in self.ids:
100
 
                                items[self.ids[k]] = v
101
 
                        else:
102
 
                                raise Exception, "Invalid key %s" % k
103
 
                                
104
 
                return items.values()
105
 
                
106
 
        def append(self, **columns):
107
 
                vals = self._add(**columns)
108
 
                return self.liststore.append(vals)
109
 
        
110
 
        def prepend(self, **columns):
111
 
                vals = self._add(**columns)
112
 
                return self.liststore.prepend(vals)
113
 
                
114
 
        def get_conditional(self, **cols):
115
 
                ret = []
116
 
                matches = 0
117
 
                for i in range(len(self.liststore)):
118
 
                        row = self.get(i)
119
 
                        for k, v in cols.iteritems():
120
 
                                if row[k] == v:
121
 
                                        matches += 1
122
 
                                        
123
 
                        if matches == len(cols):
124
 
                                ret.append(i)
125
 
                                
126
 
                        matches = 0
127
 
 
128
 
                return ret
129
 
                
130
 
                
131
 
        def set(self, id, **cols):
132
 
                if type(id) == gtk.TreeIter:
133
 
                        iter = id
134
 
                else:
135
 
                        iter = self.get_iter(id)
136
 
                
137
 
                if iter != None:
138
 
                        for k, v in cols.iteritems():
139
 
                                self.liststore.set(iter, self.ids[k], v)
140
 
                        return True
141
 
                else:
142
 
                        return False
143
 
 
144
 
        
145
 
        
146
 
        def get(self, id, *items):
147
 
                ret = {}
148
 
 
149
 
                if id != None:
150
 
                        if type(id) == gtk.TreeIter:
151
 
                                iter = id
152
 
                        else:
153
 
                                iter = self.get_iter(id)
154
 
                        if len(items) == 0:
155
 
                                for k, v in self.ids.iteritems():
156
 
                                        ret[k] = self.liststore.get(iter, v)[0]
157
 
                        else:
158
 
                                for i in range(len(items)):
159
 
                                        if items[i] in self.ids:
160
 
                                                ret[items[i]] = self.liststore.get(iter, self.ids[items[i]])[0]
161
 
                else:
162
 
                        return False
163
 
 
164
 
        
165
 
                return ret
166
 
 
167
 
                
168
 
        
169
 
        def get_iter(self, path):
170
 
                if path == None:
171
 
                        return None
172
 
                
173
 
                try:
174
 
                        return self.liststore.get_iter(path)
175
 
                except:
176
 
                        return None
177
 
                        
178
 
        def clear(self):
179
 
                self.liststore.clear()
180
 
                
181
 
        def compare(self, iter_a, iter_b):
182
 
                if iter_a != None and iter_b != None:
183
 
                        return self.get_model().get_path(iter_a) == self.get_model().get_path(iter_b)
184
 
                else:
185
 
                        return False
186
 
 
 
1
from gi.repository import Gtk
 
2
from gi.repository import GObject
 
3
 
 
4
 
 
5
# noinspection PyAttributeOutsideInit
 
6
class GenericList(Gtk.TreeView):
 
7
    def __init__(self, data):
 
8
        GObject.GObject.__init__(self)
 
9
        self.selection = self.get_selection()
 
10
        self._load(data)
 
11
 
 
12
    def _load(self, data):
 
13
        self.ids = {}
 
14
        self.columns = {}
 
15
 
 
16
        types = []
 
17
        for i in range(len(data)):
 
18
            types.append(data[i][1])
 
19
 
 
20
        types = tuple(types)
 
21
 
 
22
        self.liststore = Gtk.ListStore(*types)
 
23
        self.set_model(self.liststore)
 
24
 
 
25
        for i in range(len(data)):
 
26
 
 
27
            self.ids[data[i][0]] = i
 
28
 
 
29
            if len(data[i]) == 5 or len(data[i]) == 6:
 
30
 
 
31
                column = Gtk.TreeViewColumn(data[i][4])
 
32
 
 
33
                column.pack_start(data[i][2], True)
 
34
                column.set_attributes(data[i][2], **data[i][3])
 
35
 
 
36
                if len(data[i]) == 6:
 
37
                    column.set_properties(**data[i][5])
 
38
 
 
39
                self.columns[data[i][0]] = column
 
40
                self.append_column(column)
 
41
 
 
42
    def selected(self):
 
43
        (model, iter) = self.selection.get_selected()
 
44
 
 
45
        return iter
 
46
 
 
47
    def delete(self, id):
 
48
        if type(id) == Gtk.TreeIter:
 
49
            iter = id
 
50
        else:
 
51
            iter = self.get_iter(id)
 
52
 
 
53
        if iter is None:
 
54
            return False
 
55
        if self.liststore.iter_is_valid(iter):
 
56
            self.liststore.remove(iter)
 
57
            return True
 
58
        else:
 
59
            return False
 
60
 
 
61
    def _add(self, **columns):
 
62
        items = {}
 
63
        for k, v in self.ids.items():
 
64
            items[v] = None
 
65
 
 
66
        for k, v in columns.items():
 
67
            if k in self.ids:
 
68
                items[self.ids[k]] = v
 
69
            else:
 
70
                raise Exception("Invalid key %s" % k)
 
71
 
 
72
        return items.values()
 
73
 
 
74
    def append(self, **columns):
 
75
        vals = self._add(**columns)
 
76
        return self.liststore.append(vals)
 
77
 
 
78
    def prepend(self, **columns):
 
79
        vals = self._add(**columns)
 
80
        return self.liststore.prepend(vals)
 
81
 
 
82
    def get_conditional(self, **cols):
 
83
        ret = []
 
84
        matches = 0
 
85
        for i in range(len(self.liststore)):
 
86
            row = self.get(i)
 
87
            for k, v in cols.items():
 
88
                if row[k] == v:
 
89
                    matches += 1
 
90
 
 
91
            if matches == len(cols):
 
92
                ret.append(i)
 
93
 
 
94
            matches = 0
 
95
 
 
96
        return ret
 
97
 
 
98
    def set(self, id, **cols):
 
99
        if type(id) == Gtk.TreeIter:
 
100
            iter = id
 
101
        else:
 
102
            iter = self.get_iter(id)
 
103
 
 
104
        if iter is not None:
 
105
            for k, v in cols.items():
 
106
                self.liststore.set(iter, self.ids[k], v)
 
107
            return True
 
108
        else:
 
109
            return False
 
110
 
 
111
    def get(self, id, *items):
 
112
        ret = {}
 
113
 
 
114
        if id is not None:
 
115
            if type(id) == Gtk.TreeIter:
 
116
                iter = id
 
117
            else:
 
118
                iter = self.get_iter(id)
 
119
            if len(items) == 0:
 
120
                for k, v in self.ids.items():
 
121
                    ret[k] = self.liststore.get(iter, v)[0]
 
122
            else:
 
123
                for i in range(len(items)):
 
124
                    if items[i] in self.ids:
 
125
                        ret[items[i]] = self.liststore.get(iter, self.ids[items[i]])[0]
 
126
        else:
 
127
            return False
 
128
 
 
129
        return ret
 
130
 
 
131
    def get_iter(self, path):
 
132
        if path is None:
 
133
            return None
 
134
 
 
135
        try:
 
136
            return self.liststore.get_iter(path)
 
137
        except:
 
138
            return None
 
139
 
 
140
    def clear(self):
 
141
        self.liststore.clear()
 
142
 
 
143
    def compare(self, iter_a, iter_b):
 
144
        if iter_a is not None and iter_b is not None:
 
145
            return self.get_model().get_path(iter_a) == self.get_model().get_path(iter_b)
 
146
        else:
 
147
            return False