Use record and field properties of widget instead of method arguments

issue8020
review58491002

CHANGELOG

@@ -1,3 +1,4 @@
+* Use record and field properties of widget instead of method arguments
 * Reduce offset when no search result
 * Ensure URL scheme of bus (issue7792)
 * Add drag & drop support on binary widget

tryton/gui/window/view_form/view/form.py

@@ -480,13 +480,12 @@ class ViewForm(View):
         if record:
             for name, widgets in self.widgets.items():
                 if name in record.group.fields:
-                    field = record.group.fields[name]
                     for widget in widgets:
                         if (not focused_widget
                                 or widget.widget.is_focus()
                                 or (isinstance(widget.widget, gtk.Container)
                                     and widget.widget.get_focus_child())):
-                            widget.set_value(record, field)
+                            widget.set_value()
 
     @property
     def selected_records(self):
@@ -534,7 +533,7 @@ class ViewForm(View):
             if field:
                 field.state_set(record)
             for widget in widgets:
-                widget.display(record, field)
+                widget.display()
         for widget in self.state_widgets:
             widget.state_set(record)
         if focused_widget:

tryton/gui/window/view_form/view/form_gtk/binary.py

@@ -195,22 +195,22 @@ class Binary(BinaryMixin, Widget):
         if icon_pos == gtk.ENTRY_ICON_PRIMARY:
             self.open_()
 
-    def display(self, record, field):
-        super(Binary, self).display(record, field)
-        if not field:
+    def display(self):
+        super(Binary, self).display()
+        if not self.field:
             if self.wid_text:
                 self.wid_text.set_text('')
             self.wid_size.set_text('')
             self.but_save_as.hide()
             return False
-        if hasattr(field, 'get_size'):
-            size = field.get_size(record)
+        if hasattr(self.field, 'get_size'):
+            size = self.field.get_size(self.record)
         else:
-            size = len(field.get(record))
+            size = len(self.field.get(self.record))
         self.wid_size.set_text(common.humanize(size or 0))
         reset_position(self.wid_size)
         if self.wid_text:
-            self.wid_text.set_text(self.filename_field.get(record) or '')
+            self.wid_text.set_text(self.filename_field.get(self.record) or '')
             reset_position(self.wid_text)
             if size:
                 icon, tooltip = 'tryton-open', _("Open...")
@@ -227,7 +227,7 @@ class Binary(BinaryMixin, Widget):
         self.update_buttons(bool(size))
         return True
 
-    def set_value(self, record, field):
+    def set_value(self):
         if self.wid_text:
             self.filename_field.set_client(self.record,
                     self.wid_text.get_text() or False)

tryton/gui/window/view_form/view/form_gtk/calendar.py

@@ -62,28 +62,28 @@ class Date(Widget):
     def sig_key_press(self, widget, event):
         self.send_modified()
 
-    def set_value(self, record, field):
-        field.set_client(record, self.get_value())
+    def set_value(self):
+        self.field.set_client(self.record, self.get_value())
 
     def get_value(self):
         return self.entry.props.value
 
-    def set_format(self, record, field):
-        if field and record:
-            format_ = field.date_format(record)
+    def set_format(self):
+        if self.field and self.record:
+            format_ = self.field.date_format(self.record)
         else:
             format_ = common.date_format(
                 self.view.screen.context.get('date_format'))
         self.entry.props.format = format_
 
-    def display(self, record, field):
-        super(Date, self).display(record, field)
-        if field and record:
-            value = field.get_client(record)
+    def display(self):
+        super(Date, self).display()
+        if self.field and self.record:
+            value = self.field.get_client(self.record)
         else:
             value = ''
         self.entry.props.value = value
-        self.set_format(record, field)
+        self.set_format()
 
 
 class Time(Date):
@@ -105,12 +105,12 @@ class Time(Date):
     def real_entry(self):
         return self.entry.get_child()
 
-    def display(self, record, field):
-        super(Time, self).display(record, field)
+    def display(self):
+        super(Time, self).display()
 
-    def set_format(self, record, field):
-        if field and record:
-            format_ = field.time_format(record)
+    def set_format(self):
+        if self.field and self.record:
+            format_ = self.field.time_format(self.record)
         else:
             format_ = '%X'
         self.entry.props.format = format_
@@ -155,10 +155,10 @@ class DateTime(Date):
             elif isinstance(child, gtk.ComboBoxEntry):
                 child.set_sensitive(value)
 
-    def set_format(self, record, field):
-        if field and record:
-            date_format = field.date_format(record)
-            time_format = field.time_format(record)
+    def set_format(self):
+        if self.field and self.record:
+            date_format = self.field.date_format(self.record)
+            time_format = self.field.time_format(self.record)
         else:
             date_format = common.date_format(
                 self.view.screen.context.get('date_format'))

tryton/gui/window/view_form/view/form_gtk/char.py

@@ -83,33 +83,33 @@ class Char(Widget, TranslateMixin, PopdownMixin):
     @property
     def modified(self):
         if self.record and self.field:
-            value = self.get_client_value(self.record, self.field)
+            value = self.get_client_value()
             return value != self.get_value()
         return False
 
-    def set_value(self, record, field):
+    def set_value(self):
         entry = self.entry.get_child() if self.autocomplete else self.entry
         value = entry.get_text() or ''
-        return field.set_client(record, value)
+        return self.field.set_client(self.record, value)
 
     def get_value(self):
         entry = self.entry.get_child() if self.autocomplete else self.entry
         return entry.get_text()
 
-    def get_client_value(self, record, field):
-        if not field:
+    def get_client_value(self):
+        if not self.field:
             value = ''
         else:
-            value = field.get_client(record)
+            value = self.field.get_client(self.record)
         return value
 
-    def display(self, record, field):
-        super(Char, self).display(record, field)
+    def display(self):
+        super(Char, self).display()
         if self.autocomplete:
-            if record:
-                if self.field_name not in record.autocompletion:
-                    record.do_autocomplete(self.field_name)
-                selection = record.autocompletion.get(self.field_name, [])
+            if self.record:
+                if self.field_name not in self.record.autocompletion:
+                    self.record.do_autocomplete(self.field_name)
+                selection = self.record.autocompletion.get(self.field_name, [])
             else:
                 selection = []
             self.set_popdown([(x, x) for x in selection], self.entry)
@@ -119,15 +119,15 @@ class Char(Widget, TranslateMixin, PopdownMixin):
             size_entry = self.entry.get_child()
         else:
             size_entry = self.entry
-        if record:
-            field_size = record.expr_eval(self.attrs.get('size'))
+        if self.record:
+            field_size = self.record.expr_eval(self.attrs.get('size'))
             size_entry.set_width_chars(field_size or -1)
             size_entry.set_max_length(field_size or 0)
         else:
             size_entry.set_width_chars(-1)
             size_entry.set_max_length(0)
 
-        value = self.get_client_value(record, field)
+        value = self.get_client_value()
         if not self.autocomplete:
             self.entry.set_text(value)
             reset_position(self.entry)

tryton/gui/window/view_form/view/form_gtk/checkbox.py

@@ -20,12 +20,12 @@ class CheckBox(Widget):
         # TODO find a better solution to accept focus
         self.widget.set_sensitive(not value)
 
-    def set_value(self, record, field):
-        field.set_client(record, self.widget.get_active())
+    def set_value(self):
+        self.field.set_client(self.record, self.widget.get_active())
 
-    def display(self, record, field):
-        super(CheckBox, self).display(record, field)
-        if not field:
+    def display(self):
+        super(CheckBox, self).display()
+        if not self.field:
             self.widget.set_active(False)
             return False
-        self.widget.set_active(bool(field.get(record)))
+        self.widget.set_active(bool(self.field.get(self.record)))

tryton/gui/window/view_form/view/form_gtk/dictionary.py

@@ -424,10 +424,10 @@ class DictWidget(Widget):
         del self.rows[key]
         if modified:
             self.send_modified()
-            self.set_value(self.record, self.field)
+            self.set_value()
 
-    def set_value(self, record, field):
-        field.set_client(record, self.get_value())
+    def set_value(self):
+        self.field.set_client(self.record, self.get_value())
 
     def get_value(self):
         return dict((key, widget.get_value())
@@ -496,25 +496,25 @@ class DictWidget(Widget):
         self.rows[key] = [label, alignment, remove_but]
         self.buttons[key] = remove_but
 
-    def display(self, record, field):
-        super(DictWidget, self).display(record, field)
+    def display(self):
+        super(DictWidget, self).display()
 
-        if field is None:
+        if self.field is None:
             return
 
-        record_id = record.id if record else None
+        record_id = self.record.id if self.record else None
         if record_id != self._record_id:
             for key in list(self.fields.keys()):
                 self._sig_remove(None, key, modified=False)
             self._record_id = record_id
 
-        value = field.get_client(record) if field else {}
-        new_key_names = set(value.keys()) - set(field.keys)
+        value = self.field.get_client(self.record) if self.field else {}
+        new_key_names = set(value.keys()) - set(self.field.keys)
         if new_key_names:
-            field.add_keys(list(new_key_names), self.record)
+            self.field.add_keys(list(new_key_names), self.record)
         decoder = PYSONDecoder()
         for key, val in sorted(value.items()):
-            if key not in field.keys:
+            if key not in self.field.keys:
                 continue
             if key not in self.fields:
                 self.add_line(key)

tryton/gui/window/view_form/view/form_gtk/float.py

@@ -12,10 +12,10 @@ class Float(Integer):
         super(Float, self).__init__(view, attrs)
         self.entry.connect('key-press-event', self.key_press_event)
 
-    def display(self, record, field):
-        super(Float, self).display(record, field)
-        if field:
-            digits = field.digits(record, factor=self.factor)
+    def display(self):
+        super(Float, self).display()
+        if self.field:
+            digits = self.field.digits(self.record, factor=self.factor)
             if digits:
                 self.entry.set_width_chars(sum(digits))
             else:

tryton/gui/window/view_form/view/form_gtk/image.py

@@ -107,7 +107,7 @@ class Image(BinaryMixin, Widget):
         self.image.set_from_pixbuf(pixbuf)
         return bool(value)
 
-    def display(self, record, field):
-        super(Image, self).display(record, field)
+    def display(self):
+        super(Image, self).display()
         value = self.update_img()
         self.update_buttons(bool(value))

tryton/gui/window/view_form/view/form_gtk/integer.py

@@ -19,15 +19,15 @@ class Integer(Char):
         self.entry.connect('insert_text', self.sig_insert_text)
         self.factor = float(attrs.get('factor', 1))
 
-    def set_value(self, record, field):
-        return field.set_client(record, self.entry.get_text(),
+    def set_value(self):
+        return self.field.set_client(self.record, self.entry.get_text(),
             factor=self.factor)
 
-    def get_client_value(self, record, field):
-        if not field:
+    def get_client_value(self):
+        if not self.field:
             value = ''
         else:
-            value = field.get_client(record, factor=self.factor)
+            value = self.field.get_client(self.record, factor=self.factor)
         return value
 
     def sig_insert_text(self, entry, new_text, new_text_length, position):

tryton/gui/window/view_form/view/form_gtk/many2many.py

@@ -253,21 +253,21 @@ class Many2Many(Widget):
         self._position = signal_data[0]
         self._set_button_sensitive()
 
-    def display(self, record, field):
-        super(Many2Many, self).display(record, field)
-        if field is None:
+    def display(self):
+        super(Many2Many, self).display()
+        if self.field is None:
             self.screen.new_group()
             self.screen.current_record = None
             self.screen.parent = None
             self.screen.display()
             return False
-        new_group = field.get_client(record)
+        new_group = self.field.get_client(self.record)
         if id(self.screen.group) != id(new_group):
             self.screen.group = new_group
         self.screen.display()
         return True
 
-    def set_value(self, record, field):
+    def set_value(self):
         self.screen.current_view.set_value()
         return True
 

tryton/gui/window/view_form/view/form_gtk/many2one.py

@@ -278,9 +278,9 @@ class Many2One(Widget):
     def get_value(self):
         return self.wid_text.get_text()
 
-    def set_value(self, record, field):
-        if field.get_client(record) != self.wid_text.get_text():
-            field.set_client(record, self.value_from_id(None, ''))
+    def set_value(self):
+        if self.field.get_client(self.record) != self.wid_text.get_text():
+            self.field.set_client(self.record, self.value_from_id(None, ''))
             self.set_text('')
 
     def set_text(self, value):
@@ -289,19 +289,19 @@ class Many2One(Widget):
         self.wid_text.set_text(value)
         reset_position(self.wid_text)
 
-    def display(self, record, field):
+    def display(self):
         self.changed = False
-        super(Many2One, self).display(record, field)
+        super(Many2One, self).display()
 
         self._set_button_sensitive()
         self._set_completion()
 
-        if not field:
+        if not self.field:
             self.set_text('')
             self.changed = True
             return False
-        self.set_text(field.get_client(record))
-        if self.has_target(field.get(record)):
+        self.set_text(self.field.get_client(self.record))
+        if self.has_target(self.field.get(self.record)):
             icon1, tooltip1 = 'tryton-open', _('Open the record <F2>')
             icon2, tooltip2 = 'tryton-clear', _('Clear the field <Del>')
         else:

tryton/gui/window/view_form/view/form_gtk/multiselection.py

@@ -66,31 +66,31 @@ class MultiSelection(Widget, SelectionMixin):
         model, paths = self.tree.get_selection().get_selected_rows()
         return [model[path][0] for path in paths]
 
-    def set_value(self, record, field):
-        field.set_client(record, self.get_value())
+    def set_value(self):
+        self.field.set_client(self.record, self.get_value())
 
-    def display(self, record, field):
+    def display(self):
         selection = self.tree.get_selection()
         selection.handler_block_by_func(self.changed)
         try:
             # Remove select_function to allow update,
             # it will be set back in the super call
             selection.set_select_function(lambda *a: True)
-            self.update_selection(record, field)
+            self.update_selection(self.record, self.field)
             self.model.clear()
-            if field is None:
+            if self.field is None:
                 return
             id2path = {}
             for idx, (value, name) in enumerate(self.selection):
                 self.model.append((value, name))
                 id2path[value] = idx
             selection.unselect_all()
-            group = field.get_client(record)
+            group = self.field.get_client(self.record)
             for element in group:
                 if (element not in group.record_removed
                         and element not in group.record_deleted
                         and element.id in id2path):
                     selection.select_path(id2path[element.id])
-            super(MultiSelection, self).display(record, field)
+            super(MultiSelection, self).display()
         finally:
             selection.handler_unblock_by_func(self.changed)

tryton/gui/window/view_form/view/form_gtk/one2many.py

@@ -486,18 +486,18 @@ class One2Many(Widget):
         self.label.set_text(line)
         self._set_button_sensitive()
 
-    def display(self, record, field):
-        super(One2Many, self).display(record, field)
+    def display(self):
+        super(One2Many, self).display()
 
         self._set_button_sensitive()
 
-        if field is None:
+        if self.field is None:
             self.screen.new_group()
             self.screen.current_record = None
             self.screen.parent = None
             self.screen.display()
             return False
-        new_group = field.get_client(record)
+        new_group = self.field.get_client(self.record)
 
         if id(self.screen.group) != id(new_group):
             self.screen.group = new_group
@@ -506,9 +506,9 @@ class One2Many(Widget):
                 self.screen.current_record = None
         domain = []
         size_limit = None
-        if record:
-            domain = field.domain_get(record)
-            size_limit = record.expr_eval(self.attrs.get('size'))
+        if self.record:
+            domain = self.field.domain_get(self.record)
+            size_limit = self.record.expr_eval(self.attrs.get('size'))
         if self._readonly:
             if size_limit is None:
                 size_limit = len(self.screen.group)
@@ -520,11 +520,11 @@ class One2Many(Widget):
         self.screen.display()
         return True
 
-    def set_value(self, record, field):
+    def set_value(self):
         self.screen.current_view.set_value()
         if self.screen.modified():  # TODO check if required
-            record.modified_fields.setdefault(field.name)
-            record.signal('record-modified')
+            self.record.modified_fields.setdefault(self.field.name)
+            self.record.signal('record-modified')
         return True
 
     def _completion_match_selected(self, completion, model, iter_):

tryton/gui/window/view_form/view/form_gtk/progressbar.py

@@ -24,15 +24,15 @@ class ProgressBar(Widget):
             'left_to_right'), gtk.PROGRESS_LEFT_TO_RIGHT)
         self.widget.set_orientation(orientation)
 
-    def display(self, record, field):
-        super(ProgressBar, self).display(record, field)
-        if not field:
+    def display(self):
+        super(ProgressBar, self).display()
+        if not self.field:
             self.widget.set_text('')
             self.widget.set_fraction(0.0)
             return False
-        text = field.get_client(record, factor=100)
+        text = self.field.get_client(self.record, factor=100)
         if text:
             text = _('%s%%') % text
         self.widget.set_text(text)
-        value = field.get(record) or 0.0
+        value = self.field.get(self.record) or 0.0
         self.widget.set_fraction(value)

tryton/gui/window/view_form/view/form_gtk/pyson.py

@@ -24,18 +24,18 @@ class PYSON(Char):
         except Exception:
             return None
 
-    def set_value(self, record, field):
+    def set_value(self):
         # avoid modification because different encoding
         value = self.get_encoded_value()
-        previous = field.get_client(record)
+        previous = self.field.get_client(self.record)
         if (previous
                 and value == self.encoder.encode(
                     self.decoder.decode(previous))):
             value = previous
-        field.set_client(record, value)
+        self.field.set_client(self.record, value)
 
-    def get_client_value(self, record, field):
-        value = super(PYSON, self).get_client_value(record, field)
+    def get_client_value(self):
+        value = super(PYSON, self).get_client_value()
         if value:
             value = repr(self.decoder.decode(value))
         return value

tryton/gui/window/view_form/view/form_gtk/reference.py

@@ -110,22 +110,22 @@ class Reference(Many2One, SelectionMixin, PopdownMixin):
             value = ('', '')
         self.field.set_client(self.record, value)
 
-    def set_value(self, record, field):
+    def set_value(self):
         if not self.get_model():
             value = self.wid_text.get_text()
             if not value:
-                field.set_client(record, None)
+                self.field.set_client(self.record, None)
             else:
-                field.set_client(record, ('', value))
+                self.field.set_client(self.record, ('', value))
                 return
         else:
             try:
-                model, name = field.get_client(record)
+                model, name = self.field.get_client(self.record)
             except (ValueError, TypeError):
                 model, name = self.get_empty_value()
             if (model != self.get_model()
                     or name != self.wid_text.get_text()):
-                field.set_client(record, None)
+                self.field.set_client(self.record, None)
                 self.set_text('')
 
     def set_text(self, value):
@@ -142,7 +142,7 @@ class Reference(Many2One, SelectionMixin, PopdownMixin):
             self.set_popdown_value(self.widget_combo, value)
         self.widget_combo.handler_unblock_by_func(self.sig_changed_combo)
 
-    def display(self, record, field):
-        self.update_selection(record, field)
+    def display(self):
+        self.update_selection(self.record, self.field)
         self.set_popdown(self.selection, self.widget_combo)
-        super(Reference, self).display(record, field)
+        super(Reference, self).display()

tryton/gui/window/view_form/view/form_gtk/richtextbox.py

@@ -125,13 +125,13 @@ class RichTextBox(TextBox):
                 tool = toolbar.get_nth_item(n)
                 tool.set_sensitive(not value)
 
-    def set_value(self, record, field):
+    def set_value(self):
         # avoid modification of not normalized value
         value = self.get_value()
-        prev_value = field.get_client(record) or ''
+        prev_value = self.field.get_client(self.record) or ''
         if value == normalize_markup(prev_value):
             value = prev_value
-        field.set_client(record, value)
+        self.field.set_client(self.record, value)
 
     @property
     def modified(self):

tryton/gui/window/view_form/view/form_gtk/selection.py

@@ -68,22 +68,22 @@ class Selection(Widget, SelectionMixin, PopdownMixin):
             return self.field.get(self.record) != self.get_value()
         return False
 
-    def set_value(self, record, field):
+    def set_value(self):
         value = self.get_value()
         if 'relation' in self.attrs and value:
             value = (value, self.get_popdown_text(self.entry))
-        field.set_client(record, value)
+        self.field.set_client(self.record, value)
 
-    def display(self, record, field):
-        self.update_selection(record, field)
+    def display(self):
+        self.update_selection(self.record, self.field)
         self.set_popdown(self.selection, self.entry)
-        if not field:
+        if not self.field:
             self.entry.set_active(-1)
             # When setting no item GTK doesn't clear the entry
             self.entry.get_child().set_text('')
             return
-        super(Selection, self).display(record, field)
-        value = field.get(record)
+        super(Selection, self).display()
+        value = self.field.get(self.record)
         if isinstance(value, (list, tuple)):
             # Compatibility with Many2One
             value = value[0]

tryton/gui/window/view_form/view/form_gtk/textbox.py

@@ -98,8 +98,8 @@ class TextBox(Widget, TranslateMixin):
     def get_value(self):
         return self.get_buffer(self.textview)
 
-    def set_value(self, record, field):
-        field.set_client(record, self.get_value())
+    def set_value(self):
+        self.field.set_client(self.record, self.get_value())
 
     def set_buffer(self, value, textview):
         buf = textview.get_buffer()
@@ -113,9 +113,9 @@ class TextBox(Widget, TranslateMixin):
         iter_end = buf.get_end_iter()
         return buf.get_text(iter_start, iter_end, False)
 
-    def display(self, record, field):
-        super(TextBox, self).display(record, field)
-        value = field and field.get(record)
+    def display(self):
+        super(TextBox, self).display()
+        value = self.field and self.field.get(self.record)
         if not value:
             value = ''
         self.set_buffer(value, self.textview)

tryton/gui/window/view_form/view/form_gtk/timedelta.py

@@ -29,19 +29,19 @@ class TimeDelta(Widget):
             return self.field.get_client(self.record) != value
         return False
 
-    def set_value(self, record, field):
+    def set_value(self):
         value = self.entry.get_text()
-        return field.set_client(record, value)
+        return self.field.set_client(self.record, value)
 
     def get_value(self):
         return self.entry.get_text()
 
-    def display(self, record, field):
-        super(TimeDelta, self).display(record, field)
-        if not field:
+    def display(self):
+        super(TimeDelta, self).display()
+        if not self.field:
             value = ''
         else:
-            value = field.get_client(record)
+            value = self.field.get_client(self.record)
         self.entry.set_text(value)
         reset_position(self.entry)
 

tryton/gui/window/view_form/view/form_gtk/url.py

@@ -23,13 +23,14 @@ class URL(Char):
         self.widget.pack_start(self.button, expand=False, fill=False)
         self.widget.set_focus_chain([self.entry])
 
-    def display(self, record, field):
-        super(URL, self).display(record, field)
+    def display(self):
+        super(URL, self).display()
         self.set_tooltips()
-        if record and 'icon' in self.attrs:
+        if self.record and 'icon' in self.attrs:
             icon = self.attrs['icon']
-            if icon in record.group.fields:
-                value = record[icon].get_client(record) or 'tryton-public'
+            if icon in self.record.group.fields:
+                value = self.record[icon].get_client(self.record)
+                value = value if value else 'tryton-public'
             else:
                 value = icon
             self.button.set_image(common.IconFactory.get_image(

tryton/gui/window/view_form/view/form_gtk/widget.py

@@ -43,6 +43,7 @@ class Widget(object):
     def field(self):
         if self.record:
             return self.record.group.fields[self.field_name]
+        return None
 
     def destroy(self):
         pass
@@ -101,15 +102,15 @@ class Widget(object):
             return False
         if not self.visible:
             return False
-        self.set_value(self.record, self.field)
+        self.set_value()
 
-    def display(self, record, field):
-        if not field:
+    def display(self):
+        if not self.field:
             self._readonly_set(self.attrs.get('readonly', True))
             self.invisible_set(self.attrs.get('invisible', False))
             self._required_set(False)
             return
-        states = field.get_state_attrs(record)
+        states = self.field.get_state_attrs(self.record)
         readonly = self.attrs.get('readonly', states.get('readonly', False))
         if self.view.screen.readonly:
             readonly = True
@@ -124,7 +125,7 @@ class Widget(object):
         self.invisible_set(self.attrs.get(
                 'invisible', states.get('invisible', False)))
 
-    def set_value(self, record, field):
+    def set_value(self):
         pass