← 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/list.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/list.py
30
30
import service
31
31
import locale
32
32
from interface import parser_view
 
33
from widget.model.record import ModelRecord
33
34
 
34
35
class field_record(object):
35
36
    def __init__(self, name):
236
237
        return res
237
238
 
238
239
    def on_iter_children(self, node):
239
 
        res = getattr(node,'children',[])[0]
240
 
        return res
 
240
        res = getattr(node,'children',[])
 
241
        return res and res[0] or []
241
242
 
242
243
    def on_iter_n_children(self, node):
243
244
        return len(getattr(node,'children',[]))
269
270
        self.widget_tree.screen = screen
270
271
        self.reload = False
271
272
        self.children = children
272
 
        self.last_col = None
 
273
        self.changed_col = []
273
274
        self.tree_editable = False
274
275
        self.is_editable = widget.editable
 
276
        self.columns = self.widget_tree.get_columns()
275
277
        if children:
276
278
            hbox = gtk.HBox()
277
279
            self.widget.pack_start(hbox, expand=False, fill=False, padding=2)
283
285
            hbox.show_all()
284
286
 
285
287
        self.display()
286
 
 
287
288
        self.widget_tree.connect('button-press-event', self.__contextual_menu)
288
289
        self.widget_tree.connect_after('row-activated', self.__sig_switch)
289
290
        selection = self.widget_tree.get_selection()
322
323
        data = str(data[0])
323
324
        selection.set(selection.target, 8, data)
324
325
 
325
 
    def group_by_move(self,model_list,get_id,rec_id,field='sequence'):
326
 
        seq_ids = []
327
 
        for x in range(len(model_list.children.lst)):
328
 
            mod =  model_list.children.lst[x]
329
 
            seq_ids += [mod[field].get(mod)]
330
 
 
 
326
    def group_by_move(self, model_list, get_id, rec_id, field='sequence'):
 
327
        seq_ids = map(lambda x: x[field].get(x), model_list.children.lst)
331
328
        set_list = list(set(seq_ids))
332
329
        l = model_list.children.lst
333
330
        if len(seq_ids) != len(set_list):
362
359
        data = eval(selection.data)
363
360
        get_id = data[0]
364
361
        drop_info = treeview.get_dest_row_at_pos(x, y)
 
362
 
365
363
        if drop_info:
366
364
            path, position = drop_info
367
 
            rec_id = path[0]
 
365
            self.source_group_child = []
 
366
            rec_id = model.on_iter_has_child(model.on_get_iter(path)) and path or path[:-1]
368
367
            group_by = self.screen.context.get('group_by',False)
369
368
            if group_by:
370
 
                if data[0]==path[0]:
371
 
                    source_models_list = model.models[data[0]]
 
369
                if data and path and data[:-1] == path[:-1] \
 
370
                            and isinstance(model.on_get_iter(data), ModelRecord):
372
371
                    if position in (gtk.TREE_VIEW_DROP_BEFORE,
373
372
                        gtk.TREE_VIEW_DROP_INTO_OR_BEFORE):
374
 
                        p = path[1]
 
373
                        m_path = path[-1]
375
374
                    else:
376
 
                        if path[1]:
377
 
                            p = path[1] +1
378
 
                        else:
379
 
                            p =0
380
 
                    self.group_by_move(source_models_list, data[1], p)
 
375
                        m_path = path[-1] + 1
 
376
                    source_models_list = model.on_get_iter(path[:-1])
 
377
                    self.group_by_move(source_models_list, data[-1], m_path)
381
378
                else:
382
379
                    source_group = model.on_get_iter(data)
383
 
                    target_group = model.models[rec_id]
384
 
                    if not source_group.list_parent:
385
 
                        source_group_child = source_group.getChildren().lst[:]
 
380
                    target_group = model.on_get_iter(rec_id)
 
381
                    if model.on_iter_has_child(source_group):
 
382
                        def process(parent):
 
383
                            for child in parent.getChildren().lst:
 
384
                                if model.on_iter_has_child(child):
 
385
                                    process(child)
 
386
                                else:
 
387
                                    self.source_group_child.append(child)
 
388
                        process(source_group)
386
389
                    else:
387
 
                        source_group_child = [source_group]
388
 
                    self.screen.current_model = source_group_child[0]
389
 
                    target_domain = filter(lambda x: x[0] == group_by, target_group.children.context.get('__domain',[]))[0]
390
 
                    rpc = RPCProxy(source_group_child[0].resource)
391
 
                    rpc.write(map(lambda x:x.id,source_group_child), {target_domain[0]:target_domain[2]})
392
 
                self.reload = True
393
 
                self.screen.reload()
394
 
                self.expand_row((data[0],))
395
 
                self.expand_row((path[0],))
 
390
                        self.source_group_child = [source_group]
 
391
                    if self.source_group_child:
 
392
                        self.screen.current_model = self.source_group_child[0]
 
393
                        target_domain = filter(lambda x: x[0] in group_by, target_group.children.context.get('__domain',[]))
 
394
                        val = {}
 
395
                        map(lambda x:val.update({x[0]:x[2]}),target_domain)
 
396
                        rpc = RPCProxy(self.source_group_child[0].resource)
 
397
                        rpc.write(map(lambda x:x.id,self.source_group_child),val)
 
398
                        self.reload = True
 
399
                        self.screen.reload()
 
400
                treeview.expand_all()
396
401
            else:
397
402
                idx = path[0]
398
403
                if position in (gtk.TREE_VIEW_DROP_BEFORE,
403
408
                    model.move(data, idx + 1)
404
409
                    rec_id = idx+1
405
410
        context.drop_finish(False, etime)
406
 
        if treeview.sequence and drop_info:
407
 
            self.screen.models.set_sequence(get_id,rec_id,field='sequence')
 
411
        if treeview.sequence and drop_info and not group_by:
 
412
            self.screen.models.set_sequence(get_id, rec_id, field='sequence')
408
413
 
409
414
    def drag_data_delete(self, treeview, context):
410
415
        treeview.emit_stop_by_name('drag-data-delete')
434
439
            if (not path) or not path[0]:
435
440
                return False
436
441
            m = model.models[path[0][0]]
437
 
            if self.screen.context.get('group_by',False):
 
442
            groupby = self.screen.context.get('group_by',False)
 
443
            if groupby:
438
444
                if not len(path[0])> 1: return False
439
 
                m = m.children[path[0][-1]]
 
445
                m = self.store.on_get_iter(path[0])
440
446
            # TODO: add menu cache
441
447
            if event.button == 1:
442
448
                # first click on button
447
453
                    if attrs_check and m['state'].get(m) in path[1].attrs['states'].split(','):
448
454
                        m.get_button_action(self.screen,m.id,path[1].attrs)
449
455
                        self.screen.current_model = m
450
 
                        self.screen.reload()
451
 
                        treeview.screen.reload()
 
456
                    if groupby:
 
457
                        treeview.expand_all()
452
458
 
453
459
            else:
454
460
                # Here it goes for right click
532
538
 
533
539
    def reset(self):
534
540
        pass
535
 
    #
536
 
    # self.widget.set_model(self.store) could be removed if the store
537
 
    # has not changed -> better ergonomy. To test
538
 
    #
 
541
 
 
542
    def set_column_to_default_pos(self, move_col = False, last_grouped_col = False):
 
543
        if last_grouped_col:
 
544
            prev_col = filter(lambda col: col.name == last_grouped_col, \
 
545
                             self.widget_tree.get_columns())[0]
 
546
            self.widget_tree.move_column_after(move_col, prev_col)
 
547
        else:
 
548
            for col in self.columns:
 
549
                if col == self.columns[0]:prev_col = None
 
550
                self.widget_tree.move_column_after(col, prev_col)
 
551
                prev_col = col
 
552
        self.changed_col.remove(move_col)
 
553
 
 
554
    def move_colums(self):
 
555
        if self.screen.context.get('group_by',False):
 
556
            groupby = self.screen.context['group_by']
 
557
            for col in self.columns:
 
558
                if col.name in groupby:
 
559
                    if not col in self.changed_col:
 
560
                        if len(groupby) == 1: base_col = None
 
561
                        else: base_col = self.changed_col[-1]
 
562
                        self.changed_col.append(col)
 
563
                        self.widget_tree.move_column_after(col, base_col)
 
564
                else:
 
565
                    if col in self.changed_col: self.set_column_to_default_pos(col, groupby[-1])
 
566
        else:
 
567
            if self.changed_col: self.set_column_to_default_pos(self.changed_col[-1])
 
568
 
539
569
    def display(self):
540
570
        if self.reload or (not self.widget_tree.get_model()) or self.screen.models<>self.widget_tree.get_model().model_group:
541
571
            if self.screen.context.get('group_by',False):
542
572
                if self.screen.type == 'one2many':
543
573
                    self.screen.domain = [('id','in',self.screen.ids_get())]
544
574
                self.screen.models.models.clear()
545
 
                if self.last_col:
546
 
                    self.widget_tree.move_column_after(self.widget_tree.get_column(0),self.last_col)
547
 
                    self.last_col = None
548
 
                for col in self.widget_tree.get_columns():
549
 
                    if col.name == self.screen.context.get('group_by',False):
550
 
                        pos = self.widget_tree.get_columns().index(col) - 1
551
 
                        if not pos == -1:
552
 
                            self.last_col = self.widget_tree.get_column(pos)
553
 
                        self.widget_tree.move_column_after(col,None) # move groupby column at first position
554
 
            else:
555
 
                if self.last_col:
556
 
                    self.widget_tree.move_column_after(self.widget_tree.get_column(0),self.last_col) # move groupby column back to its original position
557
 
                    self.last_col = None
 
575
            self.move_colums()
558
576
            self.store = AdaptModelGroup(self.screen.models, self.screen.context, self.screen.domain)
559
577
            if self.store:
560
578
                self.widget_tree.set_model(self.store)
662
680
        for col in self.widget_tree.get_columns():
663
681
            value = eval(str(self.widget_tree.cells[col.name].attrs.get('invisible', 'False')),\
664
682
                           {'context':self.screen.context})
665
 
            if col.name == self.screen.context.get('group_by',False):
 
683
            if col.name in self.screen.context.get('group_by',[]):
666
684
                value = False
667
685
            col.set_visible(not value)