← Back to branch summary

~openerp-dev/openobject-client/trunk-dev-client_merge_rev1222

« back to all changes in this revision

Viewing changes to bin/widget/view/form_gtk/many2many.py

  • Committer: Stephane Wirtel
  • Date: 2010-04-01 11:59:28 UTC
  • mfrom: (1202.1.20 trunk-dev-client)
  • Revision ID: stephane@openerp.com-20100401115928-n7usfuaypq97173h
[MERGE] lp:~openerp-dev/openobject-client/trunk-dev-client 

revno: 1222
revision-id: nch@tinyerp.com-20100401071511-btkyuld52qd3004h
parent: nch@tinyerp.com-20100401065749-ukknmty6qrdunjqw
committer: nch@tinyerp.com
branch nick: trunk-dev-client
timestamp: Thu 2010-04-01 12:45:11 +0530
message:
  [IMP,REF]:Columns move in multilevel group by

Show diffs side-by-side

added added

removed removed

Lines of Context:
bin/widget/view/form_gtk/many2many.py
33
33
import interface
34
34
import service
35
35
import rpc
36
 
 
 
36
from pager import pager
37
37
from modules.gui.window.win_search import win_search
38
38
from widget.view.form_gtk.many2one import dialog
39
39
 
64
64
        self.wid_but_remove.connect('clicked', self._sig_remove)
65
65
        hb.pack_start(self.wid_but_remove, expand=False, fill=False)
66
66
 
 
67
        hb.pack_start(gtk.VSeparator(), expand=False, fill=True)
 
68
        # Previous Page
 
69
        tooltips = gtk.Tooltips()
 
70
        self.eb_prev_page = gtk.EventBox()
 
71
        tooltips.set_tip(self.eb_prev_page, _('Previous Page'))
 
72
        self.eb_prev_page.set_events(gtk.gdk.BUTTON_PRESS)
 
73
        self.eb_prev_page.connect('button_press_event', self._sig_prev_page)
 
74
        img_first = gtk.Image()
 
75
        img_first.set_from_stock('gtk-goto-first', gtk.ICON_SIZE_MENU)
 
76
        img_first.set_alignment(0.5, 0.5)
 
77
        self.eb_prev_page.add(img_first)
 
78
        hb.pack_start(self.eb_prev_page, expand=False, fill=False)
 
79
 
 
80
        # Previous Record
 
81
        self.eb_pre = gtk.EventBox()
 
82
        tooltips.set_tip(self.eb_pre, _('Previous Record'))
 
83
        self.eb_pre.set_events(gtk.gdk.BUTTON_PRESS)
 
84
        self.eb_pre.connect('button_press_event', self._sig_previous)
 
85
        img_pre = gtk.Image()
 
86
        img_pre.set_from_stock('gtk-go-back', gtk.ICON_SIZE_MENU)
 
87
        img_pre.set_alignment(0.5, 0.5)
 
88
        self.eb_pre.add(img_pre)
 
89
        hb.pack_start(self.eb_pre, expand=False, fill=False)
 
90
 
 
91
        self.label = gtk.Label('(0,0)')
 
92
        hb.pack_start(self.label, expand=False, fill=False)
 
93
 
 
94
        # Next Record
 
95
        self.eb_next = gtk.EventBox()
 
96
        tooltips.set_tip(self.eb_next, _('Next Record'))
 
97
        self.eb_next.set_events(gtk.gdk.BUTTON_PRESS)
 
98
        self.eb_next.connect('button_press_event', self._sig_next)
 
99
        img_next = gtk.Image()
 
100
        img_next.set_from_stock('gtk-go-forward', gtk.ICON_SIZE_MENU)
 
101
        img_next.set_alignment(0.5, 0.5)
 
102
        self.eb_next.add(img_next)
 
103
        hb.pack_start(self.eb_next, expand=False, fill=False)
 
104
 
 
105
        # Next Page
 
106
        self.eb_next_page = gtk.EventBox()
 
107
        tooltips.set_tip(self.eb_next_page, _('Next Page'))
 
108
        self.eb_next_page.set_events(gtk.gdk.BUTTON_PRESS)
 
109
        self.eb_next_page.connect('button_press_event', self._sig_next_page)
 
110
        img_last = gtk.Image()
 
111
        img_last.set_from_stock('gtk-goto-last', gtk.ICON_SIZE_MENU)
 
112
        img_last.set_alignment(0.5, 0.5)
 
113
        self.eb_next_page.add(img_last)
 
114
        hb.pack_start(self.eb_next_page, expand=False, fill=False)
 
115
 
 
116
        hb.pack_start(gtk.VSeparator(), expand=False, fill=True)
 
117
 
 
118
        # LIMIT COMBO
 
119
        self.cb = gtk.combo_box_new_text()
 
120
        for limit in ['20','40','80','100']:
 
121
            self.cb.append_text(limit)
 
122
        self.cb.set_active(0)
 
123
        tooltips.set_tip(self.cb, _('Choose Limit'))
 
124
        self.cb.connect('changed', self.limit_changed)
 
125
        hb.pack_start(self.cb, expand=False, fill=False)
 
126
 
67
127
        self.widget.pack_start(hb, expand=False, fill=False)
68
128
        self.widget.pack_start(gtk.HSeparator(), expand=False, fill=True)
69
129
 
73
133
        scroll.set_shadow_type(gtk.SHADOW_NONE)
74
134
 
75
135
        self.screen = Screen(attrs['relation'], view_type=['tree'],
76
 
                views_preload=attrs.get('views', {}),row_activate=self.row_activate)
 
136
                views_preload=attrs.get('views', {}),row_activate=self.row_activate, limit=20)
 
137
        self.screen.signal_connect(self, 'record-message', self._sig_label)
77
138
        self.screen.type = 'many2many'
78
139
        scroll.add_with_viewport(self.screen.widget)
79
140
        self.widget.pack_start(scroll, expand=True, fill=True)
80
141
 
81
 
#        self.old = None
82
 
        self.avail_ids = set()
83
 
 
84
 
    def check_exist(self):
85
 
        if not len(self.screen.models.models):
86
 
            self.avail_ids.clear()
87
 
        else:
88
 
            for i in self.screen.models.models:
89
 
                self.avail_ids.add(i.id)
 
142
        self.pager = pager(object=self, relation=attrs['relation'], screen=self.screen)
 
143
        self.model = None
 
144
        self.model_field = None
 
145
        self.name = attrs['name']
90
146
 
91
147
    def row_activate(self, screen):
92
148
        gui_window = service.LocalService('gui.window')
94
150
        dia = dialog(screen.name, id=screen.id_get(), attrs=self.attrs, domain=domain, window=screen.window,context=screen.context,target=False, view_type=['form'])
95
151
        if dia.dia.get_has_separator():
96
152
            dia.dia.set_has_separator(False)
97
 
        dia.run()
 
153
        ok, value = dia.run()
 
154
        if ok:
 
155
            screen.current_model.validate_set()
 
156
            screen.current_view.set_value()
98
157
        dia.destroy()
99
158
 
100
159
    def destroy(self):
103
162
        del self.widget
104
163
 
105
164
    def _menu_sig_default(self, obj):
106
 
        res = rpc.session.rpc_exec_auth('/object', 'execute', self.attrs['model'], 'default_get', [self.attrs['name']])
107
 
        self.value = res.get(self.attrs['name'], False)
 
165
        res = rpc.session.rpc_exec_auth('/object', 'execute', self.attrs['model'], 'default_get', [self.name])
 
166
        self.value = res.get(self.name, False)
108
167
 
109
168
    def _sig_add(self, *args):
110
 
        flag=False
111
 
        newids=[]
112
169
        domain = self._view.modelfield.domain_get(self._view.model)
113
170
        context = self._view.modelfield.context_get(self._view.model)
114
171
 
115
172
        ids = rpc.session.rpc_exec_auth('/object', 'execute', self.attrs['relation'], 'name_search', self.wid_text.get_text(), domain, 'ilike', context)
116
173
        ids = map(lambda x: x[0], ids)
117
 
        self.check_exist()
118
 
#        if len(ids)<>1:
119
174
        win = win_search(self.attrs['relation'], sel_multi=True, ids=ids, context=context, domain=domain, parent=self._window)
120
175
        ids = win.go()
121
176
 
122
 
        if ids == None:
123
 
            ids=[]
124
 
        if len(self.avail_ids) and len(ids):
125
 
            for i in ids:
126
 
                if i not in self.avail_ids:
127
 
                    newids.append(i)
128
 
                    flag=True
129
 
            if flag==True:
130
 
                ids=newids
131
 
            else:
132
 
                ids=[]
133
 
        self.screen.load(ids)
134
 
        for i in ids:
135
 
            self.avail_ids.add(i)
136
 
        self.screen.display()
 
177
        if ids == None: ids = []
 
178
        if self.name in self.model.m2m_cache:
 
179
            self.model.m2m_cache[self.name] = list(set(self.model.m2m_cache[self.name] + ids))
 
180
        else:
 
181
            self.model.m2m_cache[self.name] = ids
 
182
        self.model.is_m2m_modified = True
137
183
        self.wid_text.set_text('')
138
184
        self._focus_out()
 
185
        self.pager.reset_pager()
 
186
        self.pager.search_count()
139
187
 
140
188
    def _sig_remove(self, *args):
141
 
        rem_id=[]
142
 
        self.check_exist()
143
 
        rem_id=self.screen.current_view.sel_ids_get()
144
 
        for i in rem_id:
145
 
            self.avail_ids.remove(i)
146
 
        self.screen.remove()
147
 
        self.screen.display()
148
 
        self._focus_out()
 
189
        rem_id = self.screen.current_view.sel_ids_get()
 
190
        if rem_id:
 
191
            [self.model.m2m_cache[self.name].remove(id) \
 
192
                 for id in rem_id if id in self.model.m2m_cache[self.name]]
 
193
            self.model.is_m2m_modified = True
 
194
            self.screen.remove()
 
195
            self.screen.display()
 
196
            self._focus_out()
 
197
            self.pager.reset_pager()
 
198
            self.pager.search_count()
149
199
 
150
200
    def _sig_activate(self, *args):
151
201
        self._sig_add()
156
206
        self.wid_but_remove.set_sensitive(not ro)
157
207
        self.wid_but_add.set_sensitive(not ro)
158
208
 
 
209
    def limit_changed(self,*args):
 
210
        self.pager.limit_changed()
 
211
 
 
212
 
 
213
    def _sig_prev_page(self, *args):
 
214
        self.pager.prev_page()
 
215
 
 
216
    def _sig_next_page(self, *args):
 
217
        self.pager.next_page()
 
218
 
 
219
    def _sig_next(self, *args):
 
220
        _, event = args
 
221
        if event.type == gtk.gdk.BUTTON_PRESS:
 
222
            self.pager.next_record()
 
223
 
 
224
 
 
225
    def _sig_previous(self, *args):
 
226
        _, event = args
 
227
        if event.type == gtk.gdk.BUTTON_PRESS:
 
228
            self.pager.prev_record()
 
229
 
 
230
    def _sig_label(self, screen, signal_data):
 
231
        name = '_'
 
232
        if signal_data[0] >= 0:
 
233
            name = str(signal_data[0] + 1)
 
234
        line = '(%s/%s of %s)' % (name, signal_data[1], signal_data[2])
 
235
        self.label.set_text(line)
 
236
 
159
237
    def display(self, model, model_field):
 
238
        self.model = model
 
239
        self.model_field = model_field
160
240
        super(many2many, self).display(model, model_field)
161
241
        ids = []
162
242
        if model_field:
163
243
            ids = model_field.get_client(model)
164
 
#        if ids<>self.old:
165
244
        self.screen.clear()
166
245
        self.screen.load(ids)
167
 
#        self.old = ids
168
 
        self.avail_ids.clear()
169
246
        self.screen.display()
 
247
        if self.screen.models.models:
 
248
            self.screen.current_models = self.screen.models.models[0]
 
249
        if model and model.id:
 
250
            self.pager.search_count()
 
251
            self.pager.set_sensitivity()
 
252
            self.screen.current_view.set_cursor()
170
253
        return True
171
254
 
172
255
    def set_value(self, model, model_field):
173
 
        model_field.set_client(model, [x.id for x in self.screen.models.models])
 
256
        if self.name in model.m2m_cache:
 
257
            model_field.set_client(model, model.m2m_cache[self.name])
174
258
 
175
259
    def grab_focus(self):
176
260
        return self.wid_text.grab_focus()