class ComboSearchFilter(SearchFilter):
"""
- a label
- a combo with a set of predefined item to select from
"""
__gtype_name__ = 'ComboSearchFilter'
def __init__(self, label='', values=None):
"""
Create a new ComboSearchFilter object.
@param name: name of the search filter
@param values: items to put in the combo, see
L{kiwi.ui.widgets.combo.ProxyComboBox.prefill}
"""
SearchFilter.__init__(self, label=label)
label = gtk.Label(label)
self.pack_start(label, False, False)
label.show()
self.title_label = label
self.combo = ProxyComboBox()
if values:
self.combo.prefill(values)
self.combo.connect('content-changed', self._on_combo__content_changed)
self.pack_start(self.combo, False, False, 6)
self.combo.show()
#
# SearchFilter
#
def get_state(self):
return NumberQueryState(filter=self,
value=self.combo.get_selected_data())
def get_title_label(self):
return self.title_label
def get_mode_combo(self):
return self.combo
#
# Public API
#
def select(self, data):
"""
selects an item in the combo
@param data: what to select
"""
self.combo.select(data)
#
# Callbacks
#
def _on_combo__content_changed(self, mode):
self.emit('changed')
def _add_options(self, attr, pos):
combo = ProxyComboBox()
label = gtk.Label(attr.attribute.description)
# This dictionary is populated with the purpose of tests
self._widgets[attr.attribute.description] = combo
self.attr_table.attach(label, 0, 1, pos, pos + 1, 0, 0, 0, 0)
self.attr_table.attach(combo, 1, 2, pos, pos + 1, 0, gtk.EXPAND | gtk.FILL, 0, 0)
self.attr_table.show_all()
self._fill_options(combo, attr)
combo.connect('changed', self._on_combo_selection__changed)
def _add_options(self, attr, pos):
combo = ProxyComboBox()
label = gtk.Label(attr.attribute.description)
# This dictionary is populated with the purpose of tests
self._widgets[attr.attribute.description] = combo
self.attr_table.attach(label, 0, 1, pos, pos + 1, 0, 0, 0, 0)
self.attr_table.attach(combo, 1, 2, pos, pos + 1, 0, gtk.EXPAND | gtk.FILL, 0, 0)
self.attr_table.show_all()
self._fill_options(combo, attr)
combo.connect('changed', self._on_combo_selection__changed)
class Editor(Gtk.HBox):
"""Base class for field editors
Subclasses must define a list of operations and a datatype
"""
operations = []
data_type = None
def __init__(self, store, field, other_fields):
"""
:param store: a storm store if its needed
:param field: the field that is being edited
:param other_fields: other fields available for math operations
"""
assert len(self.operations)
self._store = store
self._other_fields = other_fields
self._oper = None
self._field = field
super(Editor, self).__init__(spacing=6)
self.operations_combo = ProxyComboBox()
self.pack_start(self.operations_combo, True, True, 0)
self.operations_combo.connect('changed', self._on_operation_changed)
for oper in self.operations:
self.operations_combo.append_item(oper.label, oper)
self.operations_combo.select(self.operations[0])
self.show_all()
def set_field(self, field):
assert field.data_type == self.data_type
self._field = field
self._oper.set_field(field)
def _on_operation_changed(self, combo):
if self._oper is not None:
# Remove previous operation
self.remove(self._oper)
self._oper = combo.get_selected()(self._store, self._field,
self._other_fields)
self.pack_start(self._oper, True, True, 0)
def apply_operation(self, item):
return self._oper.apply_operation(item)
class Editor(Gtk.HBox):
"""Base class for field editors
Subclasses must define a list of operations and a datatype
"""
operations = []
data_type = None
def __init__(self, store, field, other_fields):
"""
:param store: a storm store if its needed
:param field: the field that is being edited
:param other_fields: other fields available for math operations
"""
assert len(self.operations)
self._store = store
self._other_fields = other_fields
self._oper = None
self._field = field
super(Editor, self).__init__(spacing=6)
self.operations_combo = ProxyComboBox()
self.pack_start(self.operations_combo, True, True, 0)
self.operations_combo.connect('changed', self._on_operation_changed)
for oper in self.operations:
self.operations_combo.append_item(oper.label, oper)
self.operations_combo.select(self.operations[0])
self.show_all()
def set_field(self, field):
assert field.data_type == self.data_type
self._field = field
self._oper.set_field(field)
def _on_operation_changed(self, combo):
if self._oper is not None:
# Remove previous operation
self.remove(self._oper)
self._oper = combo.get_selected()(self._store, self._field,
self._other_fields)
self.pack_start(self._oper, True, True, 0)
def apply_operation(self, item):
return self._oper.apply_operation(item)
def _add_options(self, attr, pos):
combo = ProxyComboBox()
label = Gtk.Label(label=attr.attribute.description + u':')
label.set_alignment(xalign=1, yalign=0.5)
# This dictionary is populated with the purpose of tests
self._widgets[attr.attribute.description] = combo
# Use 3 labels per row
row_pos = pos / 3
col_pos = 2 * (pos % 3)
self.attr_table.attach(label, col_pos, col_pos + 1, row_pos, row_pos + 1,
Gtk.AttachOptions.EXPAND | Gtk.AttachOptions.FILL, 0, 0, 0)
self.attr_table.attach(combo, col_pos + 1, col_pos + 2, row_pos, row_pos + 1,
Gtk.AttachOptions.EXPAND | Gtk.AttachOptions.FILL, 0, 0, 0)
self.attr_table.show_all()
self._fill_options(combo, attr)
combo.connect('changed', self._on_combo_selection__changed)
class ComboSearchFilter(SearchFilter):
"""
- a label
- a combo with a set of predefined item to select from
"""
__gtype_name__ = 'ComboSearchFilter'
def __init__(self, label='', values=None):
"""
Create a new ComboSearchFilter object.
:param label: label of the search filter
:param values: items to put in the combo, see
:class:`kiwi.ui.widgets.combo.ProxyComboBox.prefill`
"""
self._block_updates = False
SearchFilter.__init__(self, label=label)
label = gtk.Label(label)
self.pack_start(label, False, False)
label.show()
self.title_label = label
self.combo = ProxyComboBox()
if values:
self.update_values(values)
self.combo.connect('content-changed', self._on_combo__content_changed)
self.pack_start(self.combo, False, False, 6)
self.combo.show()
#
# SearchFilter
#
def get_state(self):
value = self.combo.get_selected_data()
state = NumberQueryState(filter=self, value=value)
if hasattr(value, 'id'):
state.value_id = value.id
return state
def set_state(self, value, value_id=None):
if value_id is not None:
for item in self.combo.get_model_items().values():
if item is None:
continue
if item.id == value_id:
value = item
break
self.select(value)
def update_values(self, values):
self._block_updates = True
self.combo.prefill(values)
self._block_updates = False
def get_title_label(self):
return self.title_label
def get_mode_combo(self):
return self.combo
def get_description(self):
desc = ''
data = self.combo.get_selected_data()
if data is not None:
desc += self.combo.get_selected_label()
return '%s %s' % (
self.title_label.get_text(),
desc,
)
#
# Public API
#
def select(self, data):
"""
selects an item in the combo
:param data: what to select
"""
self.combo.select(data)
#
# Callbacks
#
def _on_combo__content_changed(self, mode):
if not self._block_updates:
self.emit('changed')
class MassEditorWidget(Gtk.HBox):
_editors = {
currency: DecimalEditor,
Decimal: DecimalEditor,
str: UnicodeEditor,
datetime.date: DateEditor,
object: ObjectEditor,
}
def __init__(self, store, fields, results):
self._store = store
self._editor = None
self._fields = fields
self._results = results
super(MassEditorWidget, self).__init__(spacing=6)
self._setup_widgets()
def _filter_fields(self, data_type):
return [f for f in self._fields if f.data_type == data_type]
def _setup_editor(self, field):
# Reuse editor if its possible (not when data_type is an object, since
# that requires changing the reference values)
if (self._editor and field.data_type is not object and
self._editor.data_type == field.data_type):
self._editor.set_field(field)
return
if self._editor:
self.editor_placeholder.remove(self._editor)
other_fields = self._filter_fields(field.data_type)
klass = self._editors[field.data_type]
self._editor = klass(self._store, field, other_fields)
self.editor_placeholder.add(self._editor)
def _setup_widgets(self):
label = Gtk.Label(label=_('Update'))
self.pack_start(label, False, False, 0)
self.field_combo = ProxyComboBox()
self.field_combo.connect('changed', self._on_field_combo__changed)
self.pack_start(self.field_combo, False, False, 0)
self.editor_placeholder = Gtk.EventBox()
self.pack_start(self.editor_placeholder, False, False, 0)
self.apply_button = Gtk.Button(stock=Gtk.STOCK_APPLY)
self.apply_button.connect('clicked', self._on_apply_button__clicked)
self.pack_start(self.apply_button, False, False, 0)
for field in self._fields:
# Don't let the user edit unique fields for now
if field.unique or field.read_only:
continue
self.field_combo.append_item(field.label, field)
self.field_combo.select_item_by_position(0)
def _apply(self):
marker('Updating values')
for i in self._results:
self._editor.apply_operation(i)
self._results.refresh(i)
marker('Done updating values')
#
# Public API
#
def get_changed_objects(self):
"""Returns a set of all the changed objects"""
objs = set()
for field in self._fields:
objs.update(field.new_values.keys())
return objs
#
# BaseEditorSlave
#
def confirm(self, dialog):
marker('Saving data')
objs = self.get_changed_objects()
total = len(objs)
for i, obj in enumerate(objs):
for field in self._fields:
field.save_value(obj)
yield i, total
# Flush soon, so that any errors triggered by database constraints
# pop up.
self._store.flush()
marker('Done saving data')
#
# Callbacks
#
def _on_field_combo__changed(self, combo):
self._setup_editor(combo.get_selected())
def _on_apply_button__clicked(self, button):
self._apply()
class MassEditorWidget(Gtk.HBox):
_editors = {
currency: DecimalEditor,
Decimal: DecimalEditor,
str: UnicodeEditor,
datetime.date: DateEditor,
object: ObjectEditor,
}
def __init__(self, store, fields, results):
self._store = store
self._editor = None
self._fields = fields
self._results = results
super(MassEditorWidget, self).__init__(spacing=6)
self._setup_widgets()
def _filter_fields(self, data_type):
return [f for f in self._fields if f.data_type == data_type]
def _setup_editor(self, field):
# Reuse editor if its possible (not when data_type is an object, since
# that requires changing the reference values)
if (self._editor and field.data_type is not object
and self._editor.data_type == field.data_type):
self._editor.set_field(field)
return
if self._editor:
self.editor_placeholder.remove(self._editor)
other_fields = self._filter_fields(field.data_type)
klass = self._editors[field.data_type]
self._editor = klass(self._store, field, other_fields)
self.editor_placeholder.add(self._editor)
def _setup_widgets(self):
label = Gtk.Label(label=_('Update'))
self.pack_start(label, False, False, 0)
self.field_combo = ProxyComboBox()
self.field_combo.connect('changed', self._on_field_combo__changed)
self.pack_start(self.field_combo, False, False, 0)
self.editor_placeholder = Gtk.EventBox()
self.pack_start(self.editor_placeholder, False, False, 0)
self.apply_button = Gtk.Button(stock=Gtk.STOCK_APPLY)
self.apply_button.connect('clicked', self._on_apply_button__clicked)
self.pack_start(self.apply_button, False, False, 0)
for field in self._fields:
# Don't let the user edit unique fields for now
if field.unique or field.read_only:
continue
self.field_combo.append_item(field.label, field)
self.field_combo.select_item_by_position(0)
def _apply(self):
marker('Updating values')
for i in self._results:
self._editor.apply_operation(i)
self._results.refresh(i)
marker('Done updating values')
#
# Public API
#
def get_changed_objects(self):
"""Returns a set of all the changed objects"""
objs = set()
for field in self._fields:
objs.update(field.new_values.keys())
return objs
#
# BaseEditorSlave
#
def confirm(self, dialog):
marker('Saving data')
objs = self.get_changed_objects()
total = len(objs)
for i, obj in enumerate(objs):
for field in self._fields:
field.save_value(obj)
yield i, total
# Flush soon, so that any errors triggered by database constraints
# pop up.
self._store.flush()
marker('Done saving data')
#
# Callbacks
#
def _on_field_combo__changed(self, combo):
self._setup_editor(combo.get_selected())
def _on_apply_button__clicked(self, button):
self._apply()
class ComboSearchFilter(SearchFilter):
"""
- a label
- a combo with a set of predefined item to select from
"""
__gtype_name__ = 'ComboSearchFilter'
def __init__(self, label='', values=None):
"""
Create a new ComboSearchFilter object.
:param label: label of the search filter
:param values: items to put in the combo, see
:class:`kiwi.ui.widgets.combo.ProxyComboBox.prefill`
"""
self._block_updates = False
SearchFilter.__init__(self, label=label)
label = gtk.Label(label)
self.pack_start(label, False, False)
label.show()
self.title_label = label
self.combo = ProxyComboBox()
if values:
self.update_values(values)
self.combo.connect('content-changed', self._on_combo__content_changed)
self.pack_start(self.combo, False, False, 6)
self.combo.show()
#
# SearchFilter
#
def get_state(self):
value = self.combo.get_selected_data()
state = NumberQueryState(filter=self,
value=value)
if hasattr(value, 'id'):
state.value_id = value.id
return state
def set_state(self, value, value_id=None):
if value_id is not None:
for item in self.combo.get_model_items().values():
if item is None:
continue
if item.id == value_id:
value = item
break
self.select(value)
def update_values(self, values):
self._block_updates = True
self.combo.prefill(values)
self._block_updates = False
def get_title_label(self):
return self.title_label
def get_mode_combo(self):
return self.combo
def get_description(self):
desc = ''
data = self.combo.get_selected_data()
if data is not None:
desc += self.combo.get_selected_label()
return '%s %s' % (self.title_label.get_text(), desc,)
#
# Public API
#
def select(self, data):
"""
selects an item in the combo
:param data: what to select
"""
self.combo.select(data)
#
# Callbacks
#
def _on_combo__content_changed(self, mode):
if not self._block_updates:
self.emit('changed')
class ChartDialog(gtk.Window):
def __init__(self):
self._js_data = None
self._js_options = None
self._current = None
gtk.Window.__init__(self)
self.set_size_request(800, 480)
self.vbox = gtk.VBox()
self.add(self.vbox)
self.vbox.show()
hbox = gtk.HBox()
self.vbox.pack_start(hbox, False, False, 6)
hbox.show()
label = gtk.Label('Period:')
hbox.pack_start(label, False, False, 6)
label.show()
self.chart_type = ProxyComboBox()
self.chart_type.connect(
'content-changed',
self._on_chart_type__content_changed)
hbox.pack_start(self.chart_type, False, False, 6)
self.chart_type.show()
self.period_values = ProxyComboBox()
self.period_values.connect(
'content-changed',
self._on_period_values__content_changed)
hbox.pack_start(self.period_values, False, False, 6)
self.period_values.show()
self._view = WebView()
self._view.get_view().connect(
'load-finished',
self._on_view__document_load_finished)
self.vbox.pack_start(self._view, True, True)
self.results = ObjectList()
self.results.connect(
'row-activated',
self._on_results__row_activated)
self.vbox.pack_start(self.results, True, True)
self._setup_daemon()
@api.async
def _setup_daemon(self):
daemon = yield start_daemon()
self._daemon_uri = daemon.base_uri
proxy = daemon.get_client()
yield proxy.callRemote('start_webservice')
self.chart_type.prefill([
('Year', 'YearlyPayments'),
('Month', 'MonthlyPayments'),
('Day', 'DailyPayments'),
])
@api.async
def _invoke_chart(self, chart_type_name, **report_kwargs):
def _get_chart_url(**kwargs):
params = []
for key, value in kwargs.items():
params.append(key + '=' + str(value))
return '%s/web/chart.json?%s' % (
self._daemon_uri, '&'.join(params))
url = _get_chart_url(type=chart_type_name, **report_kwargs)
page = yield getPage(url)
data = json.loads(page)
api.asyncReturn(data)
def _render_chart(self, chart_class, response):
self._render_javascript(chart_class, response)
self._render_objectlist(chart_class, response)
def _render_javascript(self, chart_class, response):
ticks = [item['short_title'] for item in response['items']]
self._js_data = response['data']
options = {}
options['description'] = response['description']
options['series'] = [dict(label=c['title']) for c in chart_class.columns][1:]
options['xaxis_ticks'] = ticks
self._js_options = options
self._view.load_uri('%s/web/static/chart.html' % (
self._daemon_uri,))
def _render_objectlist(self, chart_class, response):
columns = []
for kwargs in chart_class.columns:
kwargs = kwargs.copy()
name = kwargs.pop('name')
columns.append(Column(name, **kwargs))
self.results.set_columns(columns)
items = []
for item in response['items']:
settable = Settable(**item)
settable.chart_class = chart_class
items.append(settable)
self.results.add_list(items, clear=True)
self.results.show()
def _load_finished(self):
self._view.js_function_call(
"plot", self._js_data, self._js_options)
@api.async
def _show_one(self, chart_type_name, start, end):
chart_class = get_chart_class(chart_type_name)
report_kwargs = dict(start=start.strftime('%Y-%m-%d'),
end=end.strftime('%Y-%m-%d'))
# Get chart datab
response = yield self._invoke_chart(chart_type_name, **report_kwargs)
self._render_chart(chart_class, response)
def _update_period_values(self):
chart_type_name = self.chart_type.get_selected()
chart_class = get_chart_class(chart_type_name)
values = chart_class.get_combo_labels()
self.period_values.prefill(values)
#
# Callbacks
#
def _on_view__document_load_finished(self, view, frame):
self._load_finished()
def _on_chart_type__content_changed(self, combo):
self._update_period_values()
def _on_period_values__content_changed(self, combo):
kind = self.chart_type.get_selected()
value = self.period_values.get_selected()
if not value:
return
start, end = value
if self._current == (kind, start, end):
return
self._show_one(kind, start, end)
self._current = kind, start, end
def _on_results__row_activated(self, results, item):
chart_type_name = item.chart_class.__name__
if chart_type_name == 'YearlyPayments':
start = localdate(item.year, 1, 1).date()
end = localdate(item.year, 12, 31).date()
chart_type_name = 'MonthlyPayments'
elif chart_type_name == 'MonthlyPayments':
start = localdate(item.year, item.month, 1).date()
end = start + relativedelta(days=31)
chart_type_name = 'DailyPayments'
else:
return
self._show_one(chart_type_name, start, end)
class DateSearchFilter(SearchFilter):
"""
A filter which helps you to search by a date interval.
Can be customized through add_option.
"""
__gtype_name__ = 'DateSearchFilter'
class Type(enum):
(USER_DAY, USER_INTERVAL) = range(100, 102)
def __init__(self, label=''):
"""
Create a new DateSearchFilter object.
:param label: name of the search filter
"""
self._options = {}
SearchFilter.__init__(self, label=label)
self.title_label = Gtk.Label(label=label)
self.pack_start(self.title_label, False, False, 0)
self.title_label.show()
self.mode = ProxyComboBox()
self.mode.connect('content-changed', self._on_mode__content_changed)
self.pack_start(self.mode, False, False, 6)
self.mode.show()
self.from_label = Gtk.Label(label=_("From:"))
self.pack_start(self.from_label, False, False, 0)
self.from_label.show()
self.start_date = ProxyDateEntry()
self._start_changed_id = self.start_date.connect(
'content-changed', self._on_start_date__changed)
self.pack_start(self.start_date, False, False, 6)
self.start_date.show()
self.to_label = Gtk.Label(label=_("To:"))
self.pack_start(self.to_label, False, False, 0)
self.to_label.show()
self.end_date = ProxyDateEntry()
self._end_changed_id = self.end_date.connect(
'content-changed', self._on_end_date__changed)
self.pack_start(self.end_date, False, False, 6)
self.end_date.show()
self.add_custom_options()
for option in (Any, Today, Yesterday, LastWeek, LastMonth):
self.add_option(option)
self.mode.select_item_by_position(0)
#
# SearchFilter
#
def get_state(self):
start = self.start_date.get_date()
end = self.end_date.get_date()
if start == end:
return DateQueryState(filter=self, date=start)
return DateIntervalQueryState(filter=self, start=start, end=end)
def set_state(self, start, end=None):
self.start_date.set_date(start)
if end is not None:
self.end_date.set_date(end)
def get_title_label(self):
return self.title_label
def get_mode_combo(self):
return self.mode
def get_description(self):
desc = ''
start_date = self.start_date.get_date()
end_date = self.end_date.get_date()
if start_date:
if end_date and start_date != end_date:
desc += ' %s %s %s %s' % (
_(u'from'),
start_date.strftime('%x'),
_(u'to'),
end_date.strftime('%x'),
)
else:
desc += start_date.strftime('%x')
if desc:
return '%s %s' % (
self.get_title_label().get_text(),
desc,
)
#
# Public API
#
def clear_options(self):
"""
Removes all previously added options
"""
self._options = {}
self.mode.clear()
def add_option(self, option_type, position=-2):
"""
Adds a date option
:param option_type: option to add
:type option_type: a :class:`DateSearchOption` subclass
"""
option = option_type()
num = len(self.mode) + position
self.mode.insert_item(num, option.name, option_type)
self._options[option_type] = option
def add_option_fixed(self, name, date, position=-2):
"""
Adds a fixed option, eg one for which date is not
possible to modify.
:param name: name of the option
:param date: fixed data
:param position: position to add the option at
"""
option_type = type('', (FixedDateSearchOption, ),
dict(name=name, date=date))
self.add_option(option_type, position=position)
def add_option_fixed_interval(self, name, start, end, position=-2):
"""
Adds a fixed option interval, eg one for which the dates are not
possible to modify.
:param name: name of the option
:param start: start of the fixed interval
:param end: end of the fixed interval
:param position: position to add the option at
"""
option_type = type('', (FixedIntervalSearchOption, ),
dict(name=name, start=start, end=end))
self.add_option(option_type, position=position)
def add_custom_options(self):
"""Adds the custom options 'Custom day' and 'Custom interval' which
let the user define its own interval dates.
"""
pos = len(self.mode) + 1
for name, option_type in [
(_('Custom day'), DateSearchFilter.Type.USER_DAY),
(_('Custom interval'), DateSearchFilter.Type.USER_INTERVAL)
]:
self.mode.insert_item(pos, name, option_type)
pos += 1
def get_start_date(self):
"""
Get the start date.
:returns: start date
:rtype: datetime.date or None
"""
return self.start_date.get_date()
def get_end_date(self):
"""
Get the end date.
:returns: end date
:rtype: datetime.date or None
"""
return self.end_date.get_date()
def set_use_date_entries(self, use_date_entries):
"""
Toggles the visibility of the user selectable date entries
:param use_date_entries:
"""
self.from_label.props.visible = use_date_entries
self.to_label.props.visible = use_date_entries
self.start_date.props.visible = use_date_entries
self.end_date.props.visible = use_date_entries
def select(self, data=None, position=None):
"""
selects an item in the combo
Data or position can be sent in. If nothing
is sent in the first item will be selected, if any
:param data: data to select
:param position: position of data to select
"""
if data is not None and position is not None:
raise TypeError("You can't send in both data and position")
if data is None and position is None:
position = 0
if position is not None:
if len(self.mode):
self.mode.select_item_by_position(position)
elif data:
self.mode.select(data)
#
# Private
#
def _update_dates(self):
# This is called when we change mode
date_type = self.mode.get_selected_data()
if date_type is None:
return
# If we switch to a user selectable day, make sure that
# both dates are set to today
if date_type == DateSearchFilter.Type.USER_DAY:
today = datetime.date.today()
self.start_date.set_date(today)
self.end_date.set_date(today)
# And for user interval, set start to today and to tomorrow
elif date_type == DateSearchFilter.Type.USER_INTERVAL:
today = datetime.date.today()
self.start_date.set_date(today)
self.end_date.set_date(today + datetime.timedelta(days=1))
# Finally for pre-defined ones let the DateSearchOption decide what the
# values are going to be, these dates are not user editable so
# we don't need to do any checking.
else:
option = self._options.get(date_type)
assert option, (date_type, self._options)
start_date, end_date = option.get_interval()
self.start_date.set_date(start_date)
self.end_date.set_date(end_date)
def _update_sensitivity(self):
date_type = self.mode.get_selected_data()
enabled = date_type == DateSearchFilter.Type.USER_INTERVAL
self.to_label.set_sensitive(enabled)
self.end_date.set_sensitive(enabled)
enabled = (date_type == DateSearchFilter.Type.USER_INTERVAL
or date_type == DateSearchFilter.Type.USER_DAY)
self.from_label.set_sensitive(enabled)
self.start_date.set_sensitive(enabled)
def _internal_set_start_date(self, date):
self.start_date.handler_block(self._start_changed_id)
self.start_date.set_date(date)
self.start_date.handler_unblock(self._start_changed_id)
def _internal_set_end_date(self, date):
self.end_date.handler_block(self._end_changed_id)
self.end_date.set_date(date)
self.end_date.handler_unblock(self._end_changed_id)
def _restore_date_validation(self):
self.start_date.set_valid()
self.end_date.set_valid()
#
# Callbacks
#
def _on_mode__content_changed(self, mode):
self._update_dates()
self._update_sensitivity()
self._restore_date_validation()
self.emit('changed')
def _on_start_date__changed(self, start_date):
date_type = self.mode.get_selected_data()
start = start_date.get_date()
# For user days, just make sure that the date entries
# always are in sync
if date_type == DateSearchFilter.Type.USER_DAY:
if start is None:
self.start_date.set_invalid(_(u'Invalid date'))
else:
self.start_date.set_valid()
self._internal_set_end_date(start)
# Make sure that we cannot select a start date after
# the end date, be nice and increase the end date if
# the start date happen to be the same
elif date_type == DateSearchFilter.Type.USER_INTERVAL:
end = self.end_date.get_date()
if start is None:
self.start_date.set_invalid(_(u'Invalid date'))
return
if end and start >= end:
self._internal_set_end_date(start + datetime.timedelta(days=1))
self.start_date.set_valid()
def _on_end_date__changed(self, end_date):
date_type = self.mode.get_selected_data()
# We don't need to do anything for user day, since
# this the end date widget is disabled
if date_type == DateSearchFilter.Type.USER_DAY:
pass
# Make sure that we cannot select an end date before
# the start date, be nice and decrease the start date if
# the end date happen to be the same
elif date_type == DateSearchFilter.Type.USER_INTERVAL:
start = self.start_date.get_date()
end = end_date.get_date()
if end is None:
self.end_date.set_invalid(_(u'Invalid date'))
else:
self.end_date.set_valid()
if start and end and end <= start:
self._internal_set_start_date(end - datetime.timedelta(days=1))
class DateSearchFilter(SearchFilter):
"""
A filter which helps you to search by a date interval.
Can be customized through add_option.
"""
__gtype_name__ = 'DateSearchFilter'
class Type(enum):
(USER_DAY,
USER_INTERVAL) = range(100, 102)
def __init__(self, label=''):
"""
Create a new DateSearchFilter object.
@param label: name of the search filter
"""
self._options = {}
SearchFilter.__init__(self, label=label)
self.title_label = gtk.Label(label)
self.pack_start(self.title_label, False, False)
self.title_label.show()
self.mode = ProxyComboBox()
self.mode.connect(
'content-changed',
self._on_mode__content_changed)
self.pack_start(self.mode, False, False, 6)
self.mode.show()
self.from_label = gtk.Label(_("From:"))
self.pack_start(self.from_label, False, False)
self.from_label.show()
self.start_date = ProxyDateEntry()
self._start_changed_id = self.start_date.connect(
'content-changed', self._on_start_date__changed)
self.pack_start(self.start_date, False, False, 6)
self.start_date.show()
self.to_label = gtk.Label(_("To:"))
self.pack_start(self.to_label, False, False)
self.to_label.show()
self.end_date = ProxyDateEntry()
self._end_changed_id = self.end_date.connect(
'content-changed', self._on_end_date__changed)
self.pack_start(self.end_date, False, False, 6)
self.end_date.show()
self.add_custom_options()
for option in (Any, Today, Yesterday, LastWeek, LastMonth):
self.add_option(option)
self.mode.select_item_by_position(0)
#
# SearchFilter
#
def get_state(self):
start = self.start_date.get_date()
end = self.end_date.get_date()
if start == end:
return DateQueryState(filter=self, date=start)
return DateIntervalQueryState(filter=self, start=start, end=end)
def get_title_label(self):
return self.title_label
def get_mode_combo(self):
return self.mode
def get_description(self):
desc = ''
start_date = self.start_date.get_date()
end_date = self.end_date.get_date()
if start_date:
if end_date and start_date != end_date:
desc += ' %s %s %s %s' % (_(u'from'), start_date.strftime('%x'),
_(u'to'), end_date.strftime('%x'),)
else:
desc += start_date.strftime('%x')
if desc:
return '%s %s' % (self.get_title_label().get_text(), desc,)
#
# Public API
#
def clear_options(self):
"""
Removes all previously added options
"""
self._options = {}
self.mode.clear()
def add_option(self, option_type, position=-2):
"""
Adds a date option
@param option_type: option to add
@type option_type: a L{DateSearchOption} subclass
"""
option = option_type()
num = len(self.mode) + position
self.mode.insert_item(num, option.name, option_type)
self._options[option_type] = option
def add_option_fixed(self, name, date, position=-2):
"""
Adds a fixed option, eg one for which date is not
possible to modify.
@param name: name of the option
@param date: fixed data
@param position: position to add the option at
"""
option_type = type('', (FixedDateSearchOption,),
dict(name=name, date=date))
self.add_option(option_type, position=position)
def add_option_fixed_interval(self, name, start, end, position=-2):
"""
Adds a fixed option interval, eg one for which the dates are not
possible to modify.
@param name: name of the option
@param start: start of the fixed interval
@param end: end of the fixed interval
@param position: position to add the option at
"""
option_type = type('', (FixedIntervalSearchOption,),
dict(name=name, start=start, end=end))
self.add_option(option_type, position=position)
def add_custom_options(self):
"""Adds the custom options 'Custom day' and 'Custom interval' which
let the user define its own interval dates.
"""
pos = len(self.mode) + 1
for name, option_type in [
(_('Custom day'), DateSearchFilter.Type.USER_DAY),
(_('Custom interval'), DateSearchFilter.Type.USER_INTERVAL)]:
self.mode.insert_item(pos, name, option_type)
pos += 1
def get_start_date(self):
"""
Get the start date.
@returns: start date
@rtype: datetime.date or None
"""
return self.start_date.get_date()
def get_end_date(self):
"""
Get the end date.
@returns: end date
@rtype: datetime.date or None
"""
return self.end_date.get_date()
def set_use_date_entries(self, use_date_entries):
"""
Toggles the visibility of the user selectable date entries
@param use_date_entries:
"""
self.from_label.props.visible = use_date_entries
self.to_label.props.visible = use_date_entries
self.start_date.props.visible = use_date_entries
self.end_date.props.visible = use_date_entries
def select(self, data=None, position=None):
"""
selects an item in the combo
Data or position can be sent in. If nothing
is sent in the first item will be selected, if any
@param data: data to select
@param position: position of data to select
"""
if data is not None and position is not None:
raise TypeError("You can't send in both data and position")
if data is None and position is None:
position = 0
if position is not None:
if len(self.mode):
self.mode.select_item_by_position(position)
elif data:
self.mode.select(data)
#
# Private
#
def _update_dates(self):
# This is called when we change mode
date_type = self.mode.get_selected_data()
if date_type is None:
return
# If we switch to a user selectable day, make sure that
# both dates are set to today
if date_type == DateSearchFilter.Type.USER_DAY:
today = datetime.date.today()
self.start_date.set_date(today)
self.end_date.set_date(today)
# And for user interval, set start to today and to tomorrow
elif date_type == DateSearchFilter.Type.USER_INTERVAL:
today = datetime.date.today()
self.start_date.set_date(today)
self.end_date.set_date(today + datetime.timedelta(days=1))
# Finally for pre-defined ones let the DateSearchOption decide what the
# values are going to be, these dates are not user editable so
# we don't need to do any checking.
else:
option = self._options.get(date_type)
assert option, (date_type, self._options)
start_date, end_date = option.get_interval()
self.start_date.set_date(start_date)
self.end_date.set_date(end_date)
def _update_sensitivity(self):
date_type = self.mode.get_selected_data()
enabled = date_type == DateSearchFilter.Type.USER_INTERVAL
self.to_label.set_sensitive(enabled)
self.end_date.set_sensitive(enabled)
enabled = (date_type == DateSearchFilter.Type.USER_INTERVAL or
date_type == DateSearchFilter.Type.USER_DAY)
self.from_label.set_sensitive(enabled)
self.start_date.set_sensitive(enabled)
def _internal_set_start_date(self, date):
self.start_date.handler_block(self._start_changed_id)
self.start_date.set_date(date)
self.start_date.handler_unblock(self._start_changed_id)
def _internal_set_end_date(self, date):
self.end_date.handler_block(self._end_changed_id)
self.end_date.set_date(date)
self.end_date.handler_unblock(self._end_changed_id)
def _restore_date_validation(self):
self.start_date.set_valid()
self.end_date.set_valid()
#
# Callbacks
#
def _on_mode__content_changed(self, mode):
self._update_dates()
self._update_sensitivity()
self._restore_date_validation()
self.emit('changed')
def _on_start_date__changed(self, start_date):
date_type = self.mode.get_selected_data()
start = start_date.get_date()
# For user days, just make sure that the date entries
# always are in sync
if date_type == DateSearchFilter.Type.USER_DAY:
if start is None:
self.start_date.set_invalid(_(u'Invalid date'))
else:
self.start_date.set_valid()
self._internal_set_end_date(start)
# Make sure that we cannot select a start date after
# the end date, be nice and increase the end date if
# the start date happen to be the same
elif date_type == DateSearchFilter.Type.USER_INTERVAL:
end = self.end_date.get_date()
if start is None:
self.start_date.set_invalid(_(u'Invalid date'))
return
if end and start >= end:
self._internal_set_end_date(start + datetime.timedelta(days=1))
self.start_date.set_valid()
def _on_end_date__changed(self, end_date):
date_type = self.mode.get_selected_data()
# We don't need to do anything for user day, since
# this the end date widget is disabled
if date_type == DateSearchFilter.Type.USER_DAY:
pass
# Make sure that we cannot select an end date before
# the start date, be nice and decrease the start date if
# the end date happen to be the same
elif date_type == DateSearchFilter.Type.USER_INTERVAL:
start = self.start_date.get_date()
end = end_date.get_date()
if end is None:
self.end_date.set_invalid(_(u'Invalid date'))
else:
self.end_date.set_valid()
if start and end and end <= start:
self._internal_set_start_date(end - datetime.timedelta(days=1))
class AccountEditor(BaseEditor):
""" Account Editor """
gladefile = "AccountEditor"
proxy_widgets = ['description', 'code']
model_type = Account
model_name = _('Account')
def __init__(self, store, model=None, parent_account=None):
self._last_account_type = None
self._bank_number = -1
self._bank_widgets = []
self._bank_option_widgets = []
self._option_fields = {}
self._test_button = None
self.existing = model is not None
self.parent_account = parent_account
self.bank_model = _TemporaryBankAccount()
BaseEditor.__init__(self, store, model)
action_area = self.main_dialog.action_area
action_area.set_layout(gtk.BUTTONBOX_END)
action_area.pack_start(self._test_button, expand=False, fill=False)
action_area.set_child_secondary(self._test_button, True)
self._test_button.show()
#
# BaseEditor hooks
#
def create_model(self, store):
return Account(description=u"",
account_type=Account.TYPE_CASH,
store=store)
def _setup_widgets(self):
self._test_button = gtk.Button(_("Print a test bill"))
self._test_button.connect('clicked',
self._on_test_button__clicked)
self.parent_accounts = AccountTree(with_code=False, create_mode=True)
self.parent_accounts.connect('selection-changed',
self._on_parent_accounts__selection_changed)
self.tree_box.pack_start(self.parent_accounts)
self.tree_box.reorder_child(self.parent_accounts, 0)
if self.model == sysparam(self.store).IMBALANCE_ACCOUNT:
self.account_type.set_sensitive(False)
self.account_type.prefill(Account.account_type_descriptions)
account_type = self.model.account_type
self.parent_accounts.insert_initial(self.store,
edited_account=self.model)
if self.parent_account:
account = self.parent_accounts.get_account_by_id(
self.parent_account.id)
self.parent_accounts.select(account)
if not self.existing:
account_type = account.account_type
self.account_type.select(account_type)
self.parent_accounts.show()
def setup_proxies(self):
self._setup_widgets()
self.add_proxy(self.model, AccountEditor.proxy_widgets)
def validate_confirm(self):
if not self.model.description:
return False
account = self.parent_accounts.get_selected()
if not account:
return True
return account.selectable
def on_confirm(self):
new_parent = self.parent_accounts.get_selected()
if new_parent:
new_parent = new_parent.account
if new_parent != self.model:
self.model.parent = new_parent
self.model.account_type = self.account_type.get_selected()
self._save_bank()
def refresh_ok(self, value):
BaseEditor.refresh_ok(self, value)
account_type = self.account_type.get_selected()
if account_type != Account.TYPE_BANK:
value = False
self._test_button.set_sensitive(value)
# Private
def _save_bank(self):
bank_account = self.model.bank
if not bank_account:
bank_account = BankAccount(account=self.model,
store=self.store)
# FIXME: Who sets this to a str?
bank_account.bank_account = unicode(self.bank_model.bank_account)
bank_account.bank_branch = unicode(self.bank_model.bank_branch)
if self._bank_number is not None:
bank_account.bank_number = self.bank_model.bank_number
self._save_bank_bill_options(bank_account)
def _save_bank_bill_options(self, bank_account):
for option, entry in self._option_fields.items():
value = unicode(entry.get_text())
bill_option = self.store.find(BillOption,
bank_account=bank_account,
option=option).one()
if bill_option is None:
bill_option = BillOption(store=self.store,
bank_account=bank_account,
option=option,
value=value)
bill_option.value = value
def _add_widget(self, label, widget, options=False):
n_rows = self.table.props.n_rows
l = gtk.Label()
l.set_markup(label)
l.props.xalign = 1.0
self.table.resize(n_rows + 1, 2)
self.table.attach(
l, 0, 1, n_rows, n_rows + 1,
gtk.FILL, 0, 0, 0)
self.table.attach(
widget, 1, 2, n_rows, n_rows + 1,
gtk.EXPAND | gtk.FILL, 0, 0, 0)
if options:
self._bank_option_widgets.extend([l, widget])
else:
self._bank_widgets.extend([l, widget])
l.show()
return l
def _update_bank_type(self):
self._remove_bank_option_widgets()
bank_number = self.bank_type.get_selected()
bank_info = None
if bank_number:
bank_info = get_bank_info_by_number(bank_number)
self.bank_number = ProxyEntry()
self.bank_number.props.data_type = int
self.bank_number.set_sensitive(False)
bank_number_lbl = self._add_widget(api.escape(_("Number:")),
self.bank_number, options=True)
self.bank_branch = ProxyEntry()
self.bank_branch.connect('validate', self._on_bank_branch__validate,
bank_info)
self.bank_branch.props.data_type = 'str'
self.bank_branch.props.mandatory = True
self.bank_branch.model_attribute = "bank_branch"
bank_branch_lbl = self._add_widget(api.escape(_("Agency:")),
self.bank_branch, options=True)
if bank_number is not None:
bank_branch_lbl.show()
self.bank_branch.show()
else:
bank_branch_lbl.hide()
self.bank_account = ProxyEntry()
self.bank_account.connect('validate', self._on_bank_account__validate,
bank_info)
self._add_widget(api.escape(_("Account:")),
self.bank_account, options=True)
self.bank_account.model_attribute = "bank_account"
self.bank_account.props.data_type = 'str'
if bank_number is not None:
self.bank_account.props.mandatory = True
self.bank_account.show()
attributes = ['bank_account', 'bank_branch',
'bank_number']
if bank_number is not None:
bank_number_lbl.show()
self.bank_number.show()
self.bank_model.bank_number = bank_number
for i, option in enumerate(bank_info.get_extra_options()):
name = 'option' + str(i)
entry = ProxyEntry()
entry.model_attribute = name
setattr(self, name, entry)
# Set the model attr too so it can be validated
setattr(self.bank_model, name, u'')
entry.props.data_type = 'str'
entry.connect('validate', self._on_bank_option__validate,
bank_info, option)
self._add_widget("<i>%s</i>:" % (api.escape(option.capitalize()), ),
entry, options=True)
entry.show()
self._option_fields[option] = entry
attributes.append(entry.model_attribute)
else:
bank_number_lbl.hide()
self.bank_proxy = self.add_proxy(
self.bank_model, attributes)
self._fill_bank_account()
def _fill_bank_account(self):
if not self.model.bank:
return
self.bank_model.bank_branch = self.model.bank.bank_branch.encode('utf-8')
self.bank_model.bank_account = self.model.bank.bank_account.encode('utf-8')
self.bank_proxy.update('bank_branch')
self.bank_proxy.update('bank_account')
bill_options = list(self.store.find(BillOption,
bank_account=self.model.bank))
for bill_option in bill_options:
if bill_option.option is None:
continue
field_entry = self._option_fields.get(bill_option.option)
if field_entry:
field_entry.set_text(bill_option.value)
def _update_account_type(self, account_type):
if not self.account_type.get_sensitive():
return
if account_type != Account.TYPE_BANK:
self._remove_bank_widgets()
self._remove_bank_option_widgets()
self.code.set_sensitive(True)
return
self.code.set_sensitive(False)
self.bank_type = ProxyComboBox()
self._add_widget(api.escape(_("Bank:")), self.bank_type)
self.bank_type.connect('content-changed',
self._on_bank_type__content_changed)
self.bank_type.show()
banks = [(_('Generic'), None)]
banks.extend([(b.description,
b.bank_number) for b in get_all_banks()])
self.bank_type.prefill(banks)
if self.model.bank:
try:
self.bank_type.select(self.model.bank.bank_number)
except KeyError:
self.bank_type.select(None)
self._update_bank_type()
def _remove_bank_widgets(self):
for widget in self._bank_widgets:
widget.get_parent().remove(widget)
widget.destroy()
self.table.resize(5, 2)
self._bank_widgets = []
def _remove_bank_option_widgets(self):
for widget in self._bank_option_widgets:
widget.get_parent().remove(widget)
widget.destroy()
self.table.resize(5 + len(self._bank_widgets) / 2, 2)
self._bank_option_widgets = []
self._option_fields = {}
def _print_test_bill(self):
try:
bank_info = get_bank_info_by_number(self.bank_model.bank_number)
except NotImplementedError:
info(_("This bank does not support printing of bills"))
return
kwargs = dict(
valor_documento=12345.67,
data_vencimento=datetime.date.today(),
data_documento=datetime.date.today(),
data_processamento=datetime.date.today(),
nosso_numero=u'624533',
numero_documento=u'1138',
sacado=[_(u"Drawee"), _(u"Address"), _(u"Details")],
cedente=_(u"Supplier"),
demonstrativo=[_(u"Demonstration")],
instrucoes=[_(u"Instructions")],
agencia=self.bank_model.bank_branch,
conta=self.bank_model.bank_account,
)
for opt in self.bank_model.options:
kwargs[opt.option] = opt.value
data = bank_info(**kwargs)
print_report(BillTestReport, data)
# Callbacks
def _on_parent_accounts__selection_changed(self, objectlist, account):
self.force_validation()
def on_description__activate(self, entry):
if self.validate_confirm():
self.confirm()
def on_description__validate(self, entry, text):
if not text:
return ValidationError(_("Account description cannot be empty"))
def on_account_type__content_changed(self, account_type):
account_type = account_type.get_selected()
if self._last_account_type == account_type:
return
self._update_account_type(account_type)
self._last_account_type = account_type
def _on_bank_type__content_changed(self, bank_type):
bank_number = bank_type.get_selected()
if self._bank_number == bank_number:
return
self._update_bank_type()
self._bank_number = bank_number
def _on_bank_branch__validate(self, entry, value, bank_info):
if bank_info:
try:
bank_info.validate_field(value)
except BoletoException, e:
return ValidationError(str(e))
class ChartDialog(gtk.Window):
def __init__(self):
self._js_data = None
self._js_options = None
self._current = None
gtk.Window.__init__(self)
self.set_size_request(800, 480)
self.vbox = gtk.VBox()
self.add(self.vbox)
self.vbox.show()
hbox = gtk.HBox()
self.vbox.pack_start(hbox, False, False, 6)
hbox.show()
label = gtk.Label('Period:')
hbox.pack_start(label, False, False, 6)
label.show()
self.chart_type = ProxyComboBox()
self.chart_type.connect('content-changed',
self._on_chart_type__content_changed)
hbox.pack_start(self.chart_type, False, False, 6)
self.chart_type.show()
self.period_values = ProxyComboBox()
self.period_values.connect('content-changed',
self._on_period_values__content_changed)
hbox.pack_start(self.period_values, False, False, 6)
self.period_values.show()
self._view = WebView()
self._view.get_view().connect('load-finished',
self._on_view__document_load_finished)
self.vbox.pack_start(self._view, True, True)
self.results = ObjectList()
self.results.connect('row-activated', self._on_results__row_activated)
self.vbox.pack_start(self.results, True, True)
self._setup_daemon()
@api. async
def _setup_daemon(self):
daemon = yield start_daemon()
self._daemon_uri = daemon.base_uri
proxy = daemon.get_client()
yield proxy.callRemote('start_webservice')
self.chart_type.prefill([
('Year', 'YearlyPayments'),
('Month', 'MonthlyPayments'),
('Day', 'DailyPayments'),
])
@api. async
def _invoke_chart(self, chart_type_name, **report_kwargs):
def _get_chart_url(**kwargs):
params = []
for key, value in kwargs.items():
params.append(key + '=' + str(value))
return '%s/web/chart.json?%s' % (self._daemon_uri,
'&'.join(params))
url = _get_chart_url(type=chart_type_name, **report_kwargs)
page = yield getPage(url)
data = json.loads(page)
api.asyncReturn(data)
def _render_chart(self, chart_class, response):
self._render_javascript(chart_class, response)
self._render_objectlist(chart_class, response)
def _render_javascript(self, chart_class, response):
ticks = [item['short_title'] for item in response['items']]
self._js_data = response['data']
options = {}
options['description'] = response['description']
options['series'] = [
dict(label=c['title']) for c in chart_class.columns
][1:]
options['xaxis_ticks'] = ticks
self._js_options = options
self._view.load_uri('%s/web/static/chart.html' % (self._daemon_uri, ))
def _render_objectlist(self, chart_class, response):
columns = []
for kwargs in chart_class.columns:
kwargs = kwargs.copy()
name = kwargs.pop('name')
columns.append(Column(name, **kwargs))
self.results.set_columns(columns)
items = []
for item in response['items']:
settable = Settable(**item)
settable.chart_class = chart_class
items.append(settable)
self.results.add_list(items, clear=True)
self.results.show()
def _load_finished(self):
self._view.js_function_call("plot", self._js_data, self._js_options)
@api. async
def _show_one(self, chart_type_name, start, end):
chart_class = get_chart_class(chart_type_name)
report_kwargs = dict(start=start.strftime('%Y-%m-%d'),
end=end.strftime('%Y-%m-%d'))
# Get chart datab
response = yield self._invoke_chart(chart_type_name, **report_kwargs)
self._render_chart(chart_class, response)
def _update_period_values(self):
chart_type_name = self.chart_type.get_selected()
chart_class = get_chart_class(chart_type_name)
values = chart_class.get_combo_labels()
self.period_values.prefill(values)
#
# Callbacks
#
def _on_view__document_load_finished(self, view, frame):
self._load_finished()
def _on_chart_type__content_changed(self, combo):
self._update_period_values()
def _on_period_values__content_changed(self, combo):
kind = self.chart_type.get_selected()
value = self.period_values.get_selected()
if not value:
return
start, end = value
if self._current == (kind, start, end):
return
self._show_one(kind, start, end)
self._current = kind, start, end
def _on_results__row_activated(self, results, item):
chart_type_name = item.chart_class.__name__
if chart_type_name == 'YearlyPayments':
start = localdate(item.year, 1, 1).date()
end = localdate(item.year, 12, 31).date()
chart_type_name = 'MonthlyPayments'
elif chart_type_name == 'MonthlyPayments':
start = localdate(item.year, item.month, 1).date()
end = start + relativedelta(days=31)
chart_type_name = 'DailyPayments'
else:
return
self._show_one(chart_type_name, start, end)
class StringSearchFilter(SearchFilter):
"""
Contains:
- a label
- an entry
:ivar entry: the entry
:ivar label: the label
"""
def __init__(self, label, chars=0, container=None):
"""
Create a new StringSearchFilter object.
:param label: label of the search filter
:param chars: maximum number of chars used by the search entry
"""
self._container = container
SearchFilter.__init__(self, label=label)
self.title_label = gtk.Label(label)
self.pack_start(self.title_label, False, False)
self.title_label.show()
self._options = {}
self.mode = ProxyComboBox()
self.mode.connect('content-changed', self._on_mode__content_changed)
self.pack_start(self.mode, False, False, 6)
self.entry = HintedEntry()
self.entry.set_hint(_("Search"))
self.entry.show_hint()
self.entry.props.secondary_icon_sensitive = False
data = environ.get_resource_string('stoq', 'pixmaps',
'stoq-funnel-16x16.png')
image = pixbuf_from_string(data)
self.entry.set_icon_from_pixbuf(gtk.ENTRY_ICON_PRIMARY,
image)
self.entry.set_icon_tooltip_text(gtk.ENTRY_ICON_PRIMARY,
_("Add a filter"))
self.entry.set_icon_from_stock(gtk.ENTRY_ICON_SECONDARY,
gtk.STOCK_CLEAR)
self.entry.set_icon_tooltip_text(gtk.ENTRY_ICON_SECONDARY,
_("Clear the search"))
self.entry.connect("icon-release", self._on_entry__icon_release)
self.entry.connect('activate', self._on_entry__activate)
self.entry.connect('changed', self._on_entry__changed)
if chars:
self.entry.set_width_chars(chars)
self.pack_start(self.entry, False, False, 6)
self.entry.show()
for option in (ContainsAll, ContainsExactly, DoesNotContain):
self._add_option(option)
self.mode.select_item_by_position(0)
def _add_option(self, option_type, position=-2):
option = option_type()
num = abs(position)
self.mode.insert_item(num, option.name, option_type)
self._options[option_type] = option
#
# Callbacks
#
def _on_mode__content_changed(self, combo):
self.emit('changed')
def _on_entry__activate(self, entry):
self.emit('changed')
def _on_entry__changed(self, entry):
entry.props.secondary_icon_sensitive = bool(entry.get_text())
def _position_filter_menu(self, data):
window = self.entry.get_icon_window(gtk.ENTRY_ICON_PRIMARY)
x, y = window.get_origin()
y += window.get_size()[1]
border = self.entry.style_get_property('progress-border')
if border is not None:
y += border.bottom
return (x, y, True)
def _on_entry__icon_release(self, entry, icon_pos, event):
if icon_pos == gtk.ENTRY_ICON_SECONDARY:
entry.set_text("")
entry.grab_focus()
self.emit('changed')
elif icon_pos == gtk.ENTRY_ICON_PRIMARY:
# We don't need create popup filters if haven't search columns.
if (not self._container or not hasattr(self._container, 'menu') or
not self._container.menu):
return
self._container.menu.popup(None, None,
self._position_filter_menu, 0, event.time)
#
# SearchFilter
#
def get_state(self):
option = self.mode.get_selected_data()
return StringQueryState(filter=self,
text=unicode(self.entry.get_text()),
mode=option and option.mode)
def set_state(self, text, mode=None):
self.entry.set_text(text)
if mode is not None:
self.mode.select_item_by_position(mode)
def get_title_label(self):
return self.title_label
def get_mode_combo(self):
return self.mode
def get_description(self):
desc = self.entry.get_text()
if desc:
mode = self.mode.get_selected_label()
return '%s %s "%s"' % (self.title_label.get_text(), mode, desc,)
#
# Public API
#
def enable_advanced(self):
# Do not show the funnel icon if its an advanced filter
self.entry.set_icon_from_pixbuf(gtk.ENTRY_ICON_PRIMARY, None)
self.mode.show()
def set_label(self, label):
self.title_label.set_text(label)
class ComboSearchFilter(SearchFilter):
"""
- a label
- a combo with a set of predefined item to select from
"""
__gtype_name__ = 'ComboSearchFilter'
def __init__(self, label='', values=None):
"""
Create a new ComboSearchFilter object.
:param label: label of the search filter
:param values: items to put in the combo, see
:class:`kiwi.ui.widgets.combo.ProxyComboBox.prefill`
"""
self._block_updates = False
SearchFilter.__init__(self, label=label)
label = gtk.Label(label)
self.pack_start(label, False, False)
label.show()
self.title_label = label
# We create the mode, but it will only be added to this box when
# enable_advanced is called
self.mode = ProxyComboBox()
self.mode.connect('content-changed', self._on_mode__content_changed)
for option in (ComboEquals, ComboDifferent):
self.add_option(option)
self.mode.select_item_by_position(0)
self.combo = ProxyComboBox()
if values:
self.update_values(values)
self.combo.connect('content-changed', self._on_combo__content_changed)
self.pack_start(self.combo, False, False, 6)
self.combo.show()
#
# SearchFilter
#
def get_state(self):
value = self.combo.get_selected_data()
mode = self.mode.get_selected_data()
state = NumberQueryState(filter=self, value=value, mode=mode.mode)
if hasattr(value, 'id'):
state.value_id = value.id
return state
def set_state(self, value, value_id=None, mode=None):
if mode is None:
mode = NumberQueryState.EQUALS
if value_id is not None:
for item in self.combo.get_model_items().values():
if item is None:
continue
if item.id == value_id:
value = item
break
self.select(value)
def update_values(self, values):
self._block_updates = True
self.combo.prefill(values)
self._block_updates = False
def get_title_label(self):
return self.title_label
def get_mode_combo(self):
return self.combo
def get_description(self):
desc = ''
data = self.combo.get_selected_data()
if data is not None:
desc += self.combo.get_selected_label()
return '%s %s' % (self.title_label.get_text(), desc,)
#
# Public API
#
def add_option(self, option_type, position=0):
"""
Adds an option
:param option_type: option to add
:type option_type: a :class:`ComboSearchOption` subclass
"""
option = option_type()
num = len(self.mode) + position
self.mode.insert_item(num, option.name, option_type)
def select(self, data):
"""
selects an item in the combo
:param data: what to select
"""
self.combo.select(data)
def enable_advanced(self):
self.pack_start(self.mode, False, False, 6)
self.reorder_child(self.mode, 1)
self.mode.show()
#
# Callbacks
#
def _on_mode__content_changed(self, combo):
if not self._block_updates:
self.emit('changed')
def _on_combo__content_changed(self, mode):
if not self._block_updates:
self.emit('changed')
class StringSearchFilter(SearchFilter):
"""
Contains:
- a label
- an entry
:ivar entry: the entry
:ivar label: the label
"""
def __init__(self, label, chars=0, container=None):
"""
Create a new StringSearchFilter object.
:param label: label of the search filter
:param chars: maximum number of chars used by the search entry
"""
self._container = container
SearchFilter.__init__(self, label=label)
self.title_label = gtk.Label(label)
self.pack_start(self.title_label, False, False)
self.title_label.show()
self._options = {}
self.mode = ProxyComboBox()
self.mode.connect('content-changed', self._on_mode__content_changed)
self.pack_start(self.mode, False, False, 6)
self.entry = HintedEntry()
self.entry.set_hint(_("Search"))
self.entry.show_hint()
self.entry.props.secondary_icon_sensitive = False
self.entry.set_icon_from_stock(gtk.ENTRY_ICON_PRIMARY, gtk.STOCK_FIND)
self.entry.set_icon_from_stock(gtk.ENTRY_ICON_SECONDARY,
gtk.STOCK_CLEAR)
self.entry.set_icon_tooltip_text(gtk.ENTRY_ICON_SECONDARY,
_("Clear the search"))
self.entry.connect("icon-release", self._on_entry__icon_release)
self.entry.connect('activate', self._on_entry__activate)
self.entry.connect('changed', self._on_entry__changed)
if chars:
self.entry.set_width_chars(chars)
self.pack_start(self.entry, False, False, 6)
self.entry.show()
for option in (ContainsAll, ContainsExactly, DoesNotContain):
self._add_option(option)
self.mode.select_item_by_position(0)
def _add_option(self, option_type, position=-2):
option = option_type()
num = abs(position)
self.mode.insert_item(num, option.name, option_type)
self._options[option_type] = option
#
# Callbacks
#
def _on_mode__content_changed(self, combo):
self.emit('changed')
def _on_entry__activate(self, entry):
self.emit('changed')
def _on_entry__changed(self, entry):
entry.props.secondary_icon_sensitive = bool(entry.get_text())
def _position_filter_menu(self, data):
window = self.entry.get_icon_window(gtk.ENTRY_ICON_PRIMARY)
x, y = window.get_origin()
y += window.get_size()[1]
border = self.entry.style_get_property('progress-border')
if border is not None:
y += border.bottom
return (x, y, True)
def _on_entry__icon_release(self, entry, icon_pos, event):
if icon_pos == gtk.ENTRY_ICON_SECONDARY:
entry.set_text("")
entry.grab_focus()
self.emit('changed')
elif icon_pos == gtk.ENTRY_ICON_PRIMARY:
# We don't need create popup filters if haven't search columns.
if (not self._container or not hasattr(self._container, 'menu')
or not self._container.menu):
return
self._container.menu.popup(None, None, self._position_filter_menu,
0, event.time)
#
# SearchFilter
#
def get_state(self):
option = self.mode.get_selected_data()
return StringQueryState(filter=self,
text=self.entry.get_text(),
mode=option and option.mode)
def set_state(self, text, mode=None):
self.entry.set_text(text)
if mode is not None:
self.mode.select_item_by_position(mode)
def get_title_label(self):
return self.title_label
def get_mode_combo(self):
return self.mode
def get_description(self):
desc = self.entry.get_text()
if desc:
mode = self.mode.get_selected_label()
return '%s %s "%s"' % (
self.title_label.get_text(),
mode,
desc,
)
#
# Public API
#
def enable_advanced(self):
self.mode.show()
def set_label(self, label):
self.title_label.set_text(label)
class StringSearchFilter(SearchFilter):
"""
Contains:
- a label
- an entry
:ivar entry: the entry
:ivar label: the label
"""
__gtype_name__ = 'StringSearchFilter'
def __init__(self, label, chars=0, container=None):
"""
Create a new StringSearchFilter object.
:param label: label of the search filter
:param chars: maximum number of chars used by the search entry
"""
self._container = container
SearchFilter.__init__(self, label=label)
self.title_label = Gtk.Label(label=label)
self.pack_start(self.title_label, False, False, 0)
self.title_label.show()
self._options = {}
self.mode = ProxyComboBox()
self.mode.connect('content-changed', self._on_mode__content_changed)
self.pack_start(self.mode, False, False, 6)
self.entry = Gtk.Entry()
self.entry.set_placeholder_text(_("Search"))
self.entry.props.secondary_icon_sensitive = False
data = environ.get_resource_string('stoq', 'pixmaps',
'stoq-funnel-16x16.png')
image = pixbuf_from_string(data)
self.entry.set_icon_from_pixbuf(Gtk.EntryIconPosition.PRIMARY, image)
self.entry.set_icon_tooltip_text(Gtk.EntryIconPosition.PRIMARY,
_("Add a filter"))
self.entry.set_icon_from_stock(Gtk.EntryIconPosition.SECONDARY,
Gtk.STOCK_CLEAR)
self.entry.set_icon_tooltip_text(Gtk.EntryIconPosition.SECONDARY,
_("Clear the search"))
self.entry.connect("icon-release", self._on_entry__icon_release)
self.entry.connect('activate', self._on_entry__activate)
self.entry.connect('changed', self._on_entry__changed)
if chars:
self.entry.set_width_chars(chars)
self.pack_start(self.entry, False, False, 6)
self.entry.show()
for option in [
ContainsAll, ContainsExactly, IdenticalTo, DoesNotContain
]:
self._add_option(option)
self.mode.select_item_by_position(0)
def _add_option(self, option_type):
option = option_type()
self.mode.append_item(option.name, option_type)
self._options[option_type] = option
#
# Callbacks
#
def _on_mode__content_changed(self, combo):
self.emit('changed')
def _on_entry__activate(self, entry):
self.emit('changed')
def _on_entry__changed(self, entry):
entry.props.secondary_icon_sensitive = bool(entry.get_text())
def _position_filter_menu(self, data):
window = self.entry.get_icon_window(Gtk.EntryIconPosition.PRIMARY)
x, y = window.get_origin()
y += window.get_size()[1]
border = self.entry.style_get_property('progress-border')
if border is not None:
y += border.bottom
return (x, y, True)
def _on_entry__icon_release(self, entry, icon_pos, event):
if icon_pos == Gtk.EntryIconPosition.SECONDARY:
entry.set_text("")
entry.grab_focus()
self.emit('changed')
elif icon_pos == Gtk.EntryIconPosition.PRIMARY:
# We don't need create popup filters if haven't search columns.
if (not self._container or not hasattr(self._container, 'menu')
or not self._container.menu):
return
self._container.menu.popup(None, None, None,
self._position_filter_menu, 0,
event.time)
#
# SearchFilter
#
def get_state(self):
option = self.mode.get_selected_data()
return StringQueryState(filter=self,
text=str(self.entry.get_text()),
mode=option and option.mode)
def set_state(self, text, mode=None):
self.entry.set_text(text)
if mode is not None:
self.mode.select_item_by_position(mode)
def get_title_label(self):
return self.title_label
def get_mode_combo(self):
return self.mode
def get_description(self):
desc = self.entry.get_text()
if desc:
mode = self.mode.get_selected_label()
return '%s %s "%s"' % (
self.title_label.get_text(),
mode,
desc,
)
#
# Public API
#
def enable_advanced(self):
# Do not show the funnel icon if its an advanced filter
self.entry.set_icon_from_pixbuf(Gtk.EntryIconPosition.PRIMARY, None)
self.mode.show()
def set_label(self, label):
self.title_label.set_text(label)
class AccountEditor(BaseEditor):
""" Account Editor """
gladefile = "AccountEditor"
proxy_widgets = ['description', 'code']
model_type = Account
model_name = _('Account')
def __init__(self, store, model=None, parent_account=None):
self._last_account_type = None
self._bank_number = -1
self._bank_widgets = []
self._bank_option_widgets = []
self._option_fields = {}
self._test_button = None
self.existing = model is not None
self.parent_account = parent_account
self.bank_model = _TemporaryBankAccount()
BaseEditor.__init__(self, store, model)
action_area = self.main_dialog.action_area
action_area.set_layout(Gtk.ButtonBoxStyle.END)
action_area.pack_start(self._test_button, False, False, 0)
action_area.set_child_secondary(self._test_button, True)
self._test_button.show()
#
# BaseEditor hooks
#
def create_model(self, store):
return Account(description=u"",
account_type=Account.TYPE_CASH,
store=store)
def _setup_widgets(self):
self._test_button = Gtk.Button(_("Print a test bill"))
self._test_button.connect('clicked', self._on_test_button__clicked)
self.parent_accounts = AccountTree(with_code=False, create_mode=True)
self.parent_accounts.connect(
'selection-changed', self._on_parent_accounts__selection_changed)
self.tree_box.pack_start(self.parent_accounts, True, True, 0)
self.tree_box.reorder_child(self.parent_accounts, 0)
if sysparam.compare_object('IMBALANCE_ACCOUNT', self.model):
self.account_type.set_sensitive(False)
self.account_type.prefill(Account.account_type_descriptions)
account_type = self.model.account_type
self.parent_accounts.insert_initial(self.store,
edited_account=self.model)
if self.parent_account:
account = self.parent_accounts.get_account_by_id(
self.parent_account.id)
self.parent_accounts.select(account)
if not self.existing:
account_type = account.account_type
self.account_type.select(account_type)
self.parent_accounts.show()
def setup_proxies(self):
self._setup_widgets()
self.add_proxy(self.model, AccountEditor.proxy_widgets)
def validate_confirm(self):
if not self.model.description:
return False
account = self.parent_accounts.get_selected()
if not account:
return True
return account.selectable
def on_confirm(self):
new_parent = self.parent_accounts.get_selected()
if new_parent:
new_parent = new_parent.account
if new_parent != self.model:
self.model.parent = new_parent
self.model.account_type = self.account_type.get_selected()
self._save_bank()
def refresh_ok(self, value):
BaseEditor.refresh_ok(self, value)
account_type = self.account_type.get_selected()
if account_type != Account.TYPE_BANK:
value = False
self._test_button.set_sensitive(value)
# Private
def _save_bank(self):
bank_account = self.model.bank
if not bank_account:
bank_account = BankAccount(account=self.model, store=self.store)
# FIXME: Who sets this to a str?
bank_account.bank_account = unicode(self.bank_model.bank_account)
bank_account.bank_branch = unicode(self.bank_model.bank_branch)
if self._bank_number is not None:
bank_account.bank_number = self.bank_model.bank_number
self._save_bank_bill_options(bank_account)
def _save_bank_bill_options(self, bank_account):
for option, entry in self._option_fields.items():
value = unicode(entry.get_text())
bill_option = self.store.find(BillOption,
bank_account=bank_account,
option=option).one()
if bill_option is None:
bill_option = BillOption(store=self.store,
bank_account=bank_account,
option=option,
value=value)
bill_option.value = value
def _add_widget(self, label, widget, options=False):
n_rows = self.table.props.n_rows
l = Gtk.Label()
l.set_markup(label)
l.props.xalign = 1.0
self.table.resize(n_rows + 1, 2)
self.table.attach(l, 0, 1, n_rows, n_rows + 1, Gtk.AttachOptions.FILL,
0, 0, 0)
self.table.attach(widget, 1, 2, n_rows, n_rows + 1,
Gtk.AttachOptions.EXPAND | Gtk.AttachOptions.FILL, 0,
0, 0)
if options:
self._bank_option_widgets.extend([l, widget])
else:
self._bank_widgets.extend([l, widget])
l.show()
return l
def _update_bank_type(self):
self._remove_bank_option_widgets()
bank_number = self.bank_type.get_selected()
bank_info = None
if bank_number:
bank_info = get_bank_info_by_number(bank_number)
self.bank_number = ProxyEntry()
self.bank_number.props.data_type = int
self.bank_number.set_sensitive(False)
bank_number_lbl = self._add_widget(api.escape(_("Number:")),
self.bank_number,
options=True)
self.bank_branch = ProxyEntry()
self.bank_branch.connect('validate', self._on_bank_branch__validate,
bank_info)
self.bank_branch.props.data_type = 'str'
self.bank_branch.props.mandatory = True
self.bank_branch.model_attribute = "bank_branch"
bank_branch_lbl = self._add_widget(api.escape(_("Agency:")),
self.bank_branch,
options=True)
if bank_number is not None:
bank_branch_lbl.show()
self.bank_branch.show()
else:
bank_branch_lbl.hide()
self.bank_account = ProxyEntry()
self.bank_account.connect('validate', self._on_bank_account__validate,
bank_info)
self._add_widget(api.escape(_("Account:")),
self.bank_account,
options=True)
self.bank_account.model_attribute = "bank_account"
self.bank_account.props.data_type = 'str'
if bank_number is not None:
self.bank_account.props.mandatory = True
self.bank_account.show()
attributes = ['bank_account', 'bank_branch', 'bank_number']
if bank_number is not None:
bank_number_lbl.show()
self.bank_number.show()
self.bank_model.bank_number = bank_number
for i, option in enumerate(bank_info.get_extra_options()):
name = 'option' + str(i)
entry = ProxyEntry()
entry.model_attribute = name
setattr(self, name, entry)
# Set the model attr too so it can be validated
setattr(self.bank_model, name, u'')
entry.props.data_type = 'str'
entry.connect('validate', self._on_bank_option__validate,
bank_info, option)
name = option.replace('_', ' ').capitalize()
self._add_widget("<i>%s</i>:" % api.escape(name),
entry,
options=True)
entry.show()
self._option_fields[option] = entry
attributes.append(entry.model_attribute)
else:
bank_number_lbl.hide()
self.bank_proxy = self.add_proxy(self.bank_model, attributes)
self._fill_bank_account()
def _fill_bank_account(self):
if not self.model.bank:
return
self.bank_model.bank_branch = self.model.bank.bank_branch.encode(
'utf-8')
self.bank_model.bank_account = self.model.bank.bank_account.encode(
'utf-8')
self.bank_proxy.update('bank_branch')
self.bank_proxy.update('bank_account')
bill_options = list(
self.store.find(BillOption, bank_account=self.model.bank))
for bill_option in bill_options:
if bill_option.option is None:
continue
field_entry = self._option_fields.get(bill_option.option)
if field_entry:
field_entry.set_text(bill_option.value)
def _update_account_type(self, account_type):
if not self.account_type.get_sensitive():
return
if account_type != Account.TYPE_BANK:
self._remove_bank_widgets()
self._remove_bank_option_widgets()
self.code.set_sensitive(True)
return
self.code.set_sensitive(False)
self.bank_type = ProxyComboBox()
self._add_widget(api.escape(_("Bank:")), self.bank_type)
self.bank_type.connect('content-changed',
self._on_bank_type__content_changed)
self.bank_type.show()
banks = [(_('Generic'), None)]
banks.extend([(b.description, b.bank_number) for b in get_all_banks()])
self.bank_type.prefill(banks)
if self.model.bank:
try:
self.bank_type.select(self.model.bank.bank_number)
except KeyError:
self.bank_type.select(None)
self._update_bank_type()
def _remove_bank_widgets(self):
for widget in self._bank_widgets:
widget.get_parent().remove(widget)
widget.destroy()
self.table.resize(5, 2)
self._bank_widgets = []
def _remove_bank_option_widgets(self):
for widget in self._bank_option_widgets:
widget.get_parent().remove(widget)
widget.destroy()
self.table.resize(5 + len(self._bank_widgets) / 2, 2)
self._bank_option_widgets = []
self._option_fields = {}
def _print_test_bill(self):
try:
bank_info = get_bank_info_by_number(self.bank_model.bank_number)
except NotImplementedError:
info(_("This bank does not support printing of bills"))
return
kwargs = dict(
valor_documento=12345.67,
data_vencimento=datetime.date.today(),
data_documento=datetime.date.today(),
data_processamento=datetime.date.today(),
nosso_numero=u'24533',
numero_documento=u'1138',
sacado=[_(u"Drawee"), _(u"Address"),
_(u"Details")],
cedente=[_(u"Supplier"),
_(u"Address"),
_(u"Details"), ("CNPJ")],
demonstrativo=[_(u"Demonstration")],
instrucoes=[_(u"Instructions")],
agencia=self.bank_model.bank_branch,
conta=self.bank_model.bank_account,
)
for opt in self.bank_model.options:
kwargs[opt.option] = opt.value
data = bank_info(**kwargs)
print_report(BillTestReport, data)
# Callbacks
def _on_parent_accounts__selection_changed(self, objectlist, account):
self.force_validation()
def on_description__activate(self, entry):
if self.validate_confirm():
self.confirm()
def on_description__validate(self, entry, text):
if not text:
return ValidationError(_("Account description cannot be empty"))
def on_account_type__content_changed(self, account_type):
account_type = account_type.get_selected()
if self._last_account_type == account_type:
return
self._update_account_type(account_type)
self._last_account_type = account_type
def _on_bank_type__content_changed(self, bank_type):
bank_number = bank_type.get_selected()
if self._bank_number == bank_number:
return
self._update_bank_type()
self._bank_number = bank_number
def _on_bank_branch__validate(self, entry, value, bank_info):
if bank_info:
try:
bank_info.validate_field(value)
except BoletoException as e:
return ValidationError(str(e))
def _on_bank_account__validate(self, entry, value, bank_info):
if bank_info:
try:
bank_info.validate_field(value)
except BoletoException as e:
return ValidationError(str(e))
def _on_bank_option__validate(self, entry, value, bank_info, option):
try:
bank_info.validate_option(option, value)
except BoletoException as e:
return ValidationError(str(e))
self.bank_model.set_option(option, value)
def _on_test_button__clicked(self, button):
self._print_test_bill()
class NumberSearchFilter(SearchFilter):
"""
A filter which helps you to search by a number interval.
"""
__gtype_name__ = 'NumberSearchFilter'
def __init__(self, label=''):
"""
@param label: name of the search filter
"""
self._options = {}
SearchFilter.__init__(self, label=label)
self.title_label = gtk.Label(label)
self.title_label.set_alignment(1.0, 0.5)
self.pack_start(self.title_label, False, False)
self.title_label.show()
self.mode = ProxyComboBox()
self.mode.connect('content-changed', self._on_mode__content_changed)
self.pack_start(self.mode, False, False, 6)
self.mode.show()
self.start = gtk.SpinButton(climb_rate=1.0)
self.start.get_adjustment().step_increment = 1.0
self.start.set_range(-sys.maxint-1, sys.maxint)
self.pack_start(self.start, False, False, 6)
self.start.show()
self.and_label = gtk.Label(_("And"))
self.pack_start(self.and_label, False, False)
self.and_label.show()
self.end = gtk.SpinButton(climb_rate=1.0)
self.end.get_adjustment().step_increment = 1.0
self.end.set_range(-sys.maxint-1, sys.maxint)
self.pack_start(self.end, False, False, 6)
self.end.show()
for option in (LowerThan, EqualsTo, GreaterThan, Between):
self.add_option(option)
self.mode.select_item_by_position(0)
#
# Private
#
def _update_visibility(self):
option = self.mode.get_selected_data()
numbers = option.numbers
if numbers == 0:
self.start.hide()
self.and_label.hide()
self.end.hide()
elif numbers == 1:
self.start.show()
self.and_label.hide()
self.end.hide()
elif numbers == 2:
self.start.show()
self.and_label.show()
self.end.show()
#
# Callbacks
#
def _on_mode__content_changed(self, combo):
self._update_visibility()
#
# SearchFilter
#
def get_state(self):
start_value = self.start.get_value_as_int()
end_value = self.end.get_value_as_int()
option = self.mode.get_selected_data()
start, end = option().get_interval(start_value, end_value)
return NumberIntervalQueryState(filter=self, start=start, end=end)
def get_title_label(self):
return self.title_label
def get_mode_combo(self):
return self.mode
#
# Public API
#
def add_option(self, option_type, position=-2):
"""
Adds a date option
@param option_type: option to add
@type option_type: a L{NumberSearchOption} subclass
"""
option = option_type()
num = len(self.mode) + position
self.mode.insert_item(num, option.name, option_type)
self._options[option_type] = option
class ComboSearchFilter(SearchFilter):
"""
- a label
- a combo with a set of predefined item to select from
"""
__gtype_name__ = 'ComboSearchFilter'
def __init__(self, label='', values=None):
"""
Create a new ComboSearchFilter object.
@param name: name of the search filter
@param values: items to put in the combo, see
L{kiwi.ui.widgets.combo.ProxyComboBox.prefill}
"""
SearchFilter.__init__(self, label=label)
label = gtk.Label(label)
self.pack_start(label, False, False)
label.show()
self.title_label = label
self.combo = ProxyComboBox()
if values:
self.combo.prefill(values)
self.combo.connect('content-changed', self._on_combo__content_changed)
self.pack_start(self.combo, False, False, 6)
self.combo.show()
#
# SearchFilter
#
def get_state(self):
return NumberQueryState(filter=self,
value=self.combo.get_selected_data())
def get_title_label(self):
return self.title_label
def get_mode_combo(self):
return self.combo
def get_description(self):
desc = ''
data = self.combo.get_selected_data()
if data is not None:
desc += self.combo.get_selected_label()
return '%s %s' % (self.title_label.get_text(), desc,)
#
# Public API
#
def select(self, data):
"""
selects an item in the combo
@param data: what to select
"""
self.combo.select(data)
#
# Callbacks
#
def _on_combo__content_changed(self, mode):
self.emit('changed')
class StringSearchFilter(SearchFilter):
"""
Contains:
- a label
- an entry
:ivar entry: the entry
:ivar label: the label
"""
__gtype_name__ = 'StringSearchFilter'
def __init__(self, label, chars=0, container=None):
"""
Create a new StringSearchFilter object.
:param label: label of the search filter
:param chars: maximum number of chars used by the search entry
"""
self._container = container
SearchFilter.__init__(self, label=label)
self.title_label = Gtk.Label(label=label)
self.pack_start(self.title_label, False, False, 0)
self.title_label.show()
self._options = {}
self.mode = ProxyComboBox()
self.mode.connect('content-changed', self._on_mode__content_changed)
self.pack_start(self.mode, False, False, 6)
self.entry = Gtk.Entry()
self.entry.set_placeholder_text(_("Search"))
self.entry.props.secondary_icon_sensitive = False
self.entry.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY,
'fa-filter-symbolic')
self.entry.set_icon_tooltip_text(Gtk.EntryIconPosition.PRIMARY,
_("Add a filter"))
self.entry.set_icon_from_icon_name(Gtk.EntryIconPosition.SECONDARY,
'edit-clear-symbolic')
self.entry.set_icon_tooltip_text(Gtk.EntryIconPosition.SECONDARY,
_("Clear the search"))
self.entry.connect("icon-release", self._on_entry__icon_release)
self.entry.connect('activate', self._on_entry__activate)
self.entry.connect('changed', self._on_entry__changed)
if chars:
self.entry.set_width_chars(chars)
self.pack_start(self.entry, False, False, 6)
self.entry.show()
# Default filter will be only contains all. When advanced filter is enabled it will add
# other options
self._add_option(ContainsAll)
self.mode.select_item_by_position(0)
def _add_option(self, option_type):
option = option_type()
self.mode.append_item(option.name, option_type)
self._options[option_type] = option
#
# Callbacks
#
def _on_mode__content_changed(self, combo):
self.emit('changed')
def _on_entry__activate(self, entry):
self.emit('changed')
def _on_entry__changed(self, entry):
entry.props.secondary_icon_sensitive = bool(entry.get_text())
def _position_filter_menu(self, data):
window = self.entry.get_icon_window(Gtk.EntryIconPosition.PRIMARY)
x, y = window.get_origin()
y += window.get_size()[1]
border = self.entry.style_get_property('progress-border')
if border is not None:
y += border.bottom
return (x, y, True)
def _on_entry__icon_release(self, entry, icon_pos, event):
if icon_pos == Gtk.EntryIconPosition.SECONDARY:
entry.set_text("")
entry.grab_focus()
self.emit('changed')
elif icon_pos == Gtk.EntryIconPosition.PRIMARY:
# We don't need create popup filters if haven't search columns.
if (not self._container or not hasattr(self._container, 'menu') or
not self._container.menu):
return
self._container.menu.popup(None, None, None,
self._position_filter_menu, 0, event.time)
#
# SearchFilter
#
def get_state(self):
option = self.mode.get_selected_data()
return StringQueryState(filter=self,
text=str(self.entry.get_text()),
mode=option and option.mode)
def set_state(self, text, mode=None):
self.entry.set_text(text)
for i in self.mode.get_model_items().values():
if i.mode == mode:
self.mode.select_item_by_data(i)
break
def get_title_label(self):
return self.title_label
def get_mode_combo(self):
return self.mode
def get_description(self):
desc = self.entry.get_text()
if desc:
mode = self.mode.get_selected_label()
return '%s %s "%s"' % (self.title_label.get_text(), mode, desc,)
#
# Public API
#
def enable_advanced(self):
# Do not show the funnel icon if its an advanced filter
self.entry.set_icon_from_pixbuf(Gtk.EntryIconPosition.PRIMARY, None)
for option in [ContainsExactly, IdenticalTo, DoesNotContain]:
self._add_option(option)
self.mode.show()
def set_label(self, label):
self.title_label.set_text(label)
class ComboSearchFilter(SearchFilter):
"""
- a label
- a combo with a set of predefined item to select from
"""
__gtype_name__ = 'ComboSearchFilter'
def __init__(self, label='', values=None):
"""
Create a new ComboSearchFilter object.
:param label: label of the search filter
:param values: items to put in the combo, see
:class:`kiwi.ui.widgets.combo.ProxyComboBox.prefill`
"""
self._block_updates = False
SearchFilter.__init__(self, label=label)
label = Gtk.Label(label=label)
self.pack_start(label, False, False, 0)
label.show()
self.title_label = label
# We create the mode, but it will only be added to this box when
# enable_advanced is called
self.mode = ProxyComboBox()
self.mode.connect('content-changed', self._on_mode__content_changed)
for option in (ComboEquals, ComboDifferent):
self.add_option(option)
self.mode.select_item_by_position(0)
self.combo = ProxyComboBox()
if values:
self.update_values(values)
self.combo.connect('content-changed', self._on_combo__content_changed)
self.pack_start(self.combo, False, False, 6)
self.combo.show()
#
# SearchFilter
#
def get_state(self):
value = self.combo.get_selected_data()
mode = self.mode.get_selected_data()
state = NumberQueryState(filter=self, value=value, mode=mode.mode)
if hasattr(value, 'id'):
state.value_id = value.id
return state
def set_state(self, value, value_id=None, mode=None):
if mode is None:
mode = NumberQueryState.EQUALS
if value_id is not None:
for item in self.combo.get_model_items().values():
if item is None:
continue
# Filter can come as a string or as a FilterItem object
item_id = item if isinstance(item, str) else item.id
if item_id == value_id:
value = item
break
self.select(value)
def update_values(self, values):
self._block_updates = True
self.combo.prefill(values)
self._block_updates = False
def get_title_label(self):
return self.title_label
def get_mode_combo(self):
return self.combo
def get_description(self):
desc = ''
data = self.combo.get_selected_data()
if data is not None:
desc += self.combo.get_selected_label()
return '%s %s' % (
self.title_label.get_text(),
desc,
)
#
# Public API
#
def add_option(self, option_type, position=0):
"""
Adds an option
:param option_type: option to add
:type option_type: a :class:`ComboSearchOption` subclass
"""
option = option_type()
num = len(self.mode) + position
self.mode.insert_item(num, option.name, option_type)
def select(self, data):
"""
selects an item in the combo
:param data: what to select
"""
self.combo.select(data)
def enable_advanced(self):
self.pack_start(self.mode, False, False, 6)
self.reorder_child(self.mode, 1)
self.mode.show()
#
# Callbacks
#
def _on_mode__content_changed(self, combo):
if not self._block_updates:
self.emit('changed')
def _on_combo__content_changed(self, mode):
if not self._block_updates:
self.emit('changed')
class StringSearchFilter(SearchFilter):
"""
- a label
- an entry
@ivar entry: the entry
@ivar label: the label
"""
def __init__(self, label, chars=0):
"""
Create a new StringSearchFilter object.
@param label: label of the search filter
@param chars: maximum number of chars used by the search entry
"""
SearchFilter.__init__(self, label=label)
self.title_label = gtk.Label(label)
self.pack_start(self.title_label, False, False)
self.title_label.show()
self._options = {}
self.mode = ProxyComboBox()
self.mode.connect('content-changed', self._on_mode__content_changed)
self.pack_start(self.mode, False, False, 6)
self.entry = gtk.Entry()
self.entry.connect('activate', self._on_entry__activate)
if chars:
self.entry.set_width_chars(chars)
self.pack_start(self.entry, False, False, 6)
self.entry.show()
for option in (Contains, DoesNotContain):
self._add_option(option)
self.mode.select_item_by_position(0)
def _add_option(self, option_type, position=-2):
option = option_type()
num = len(self.mode) + position
self.mode.insert_item(num, option.name, option_type)
self._options[option_type] = option
#
# Callbacks
#
def _on_mode__content_changed(self, combo):
self.emit('changed')
def _on_entry__activate(self, entry):
self.emit('changed')
#
# SearchFilter
#
def get_state(self):
option = self.mode.get_selected_data()
return StringQueryState(filter=self,
text=self.entry.get_text(),
mode=option.mode)
def get_title_label(self):
return self.title_label
def get_mode_combo(self):
return self.mode
def get_description(self):
desc = self.entry.get_text()
if desc:
mode = self.mode.get_selected_label()
return '%s %s "%s"' % (self.title_label.get_text(), mode, desc,)
#
# Public API
#
def enable_advaced(self):
self.mode.show()
def set_label(self, label):
self.title_label.set_text(label)
class NumberSearchFilter(SearchFilter):
"""
A filter which helps you to search by a number interval.
"""
__gtype_name__ = 'NumberSearchFilter'
def __init__(self, label=''):
"""
Create a new NumberSearchFilter object.
:param label: name of the search filter
"""
self._options = {}
SearchFilter.__init__(self, label=label)
self.title_label = Gtk.Label(label=label)
self.title_label.set_alignment(1.0, 0.5)
self.pack_start(self.title_label, False, False, 0)
self.title_label.show()
self.mode = ProxyComboBox()
self.mode.connect('content-changed', self._on_mode__content_changed)
self.pack_start(self.mode, False, False, 6)
self.mode.show()
self.start = Gtk.SpinButton(climb_rate=1.0)
self.start.get_adjustment().step_increment = 1.0
self.start.set_range(-MAX_INT - 1, MAX_INT)
self.pack_start(self.start, False, False, 6)
self.start.show()
self.start.connect_after('activate', self._on_entry__activate)
self.and_label = Gtk.Label(label=_("And"))
self.pack_start(self.and_label, False, False, 0)
self.and_label.show()
self.end = Gtk.SpinButton(climb_rate=1.0)
self.end.get_adjustment().step_increment = 1.0
self.end.set_range(-MAX_INT - 1, MAX_INT)
self.pack_start(self.end, False, False, 6)
self.end.show()
self.end.connect_after('activate', self._on_entry__activate)
for option in (LowerThan, EqualsTo, GreaterThan, Between):
self.add_option(option)
self.mode.select_item_by_position(0)
def set_digits(self, digits):
"""
Number of decimal place to be displayed
:param digits: number of decimal places
"""
self.start.set_digits(digits)
self.end.set_digits(digits)
#
# Private
#
def _update_visibility(self):
option = self.mode.get_selected_data()
numbers = option.numbers
if numbers == 0:
self.start.hide()
self.and_label.hide()
self.end.hide()
elif numbers == 1:
self.start.show()
self.and_label.hide()
self.end.hide()
elif numbers == 2:
self.start.show()
self.and_label.show()
self.end.show()
#
# Callbacks
#
def _on_entry__activate(self, entry):
self.emit('changed')
def _on_mode__content_changed(self, combo):
self._update_visibility()
self.emit('changed')
#
# SearchFilter
#
def get_state(self):
# Using Decimals for better precision.
start_value = Decimal("%.2f" % self.start.get_value())
end_value = Decimal("%.2f" % self.end.get_value())
option = self.mode.get_selected_data()
start, end = option().get_interval(start_value, end_value)
return NumberIntervalQueryState(filter=self, start=start, end=end)
def set_state(self, start, end):
self.start.set_value(start)
self.end.set_value(end)
def get_title_label(self):
return self.title_label
def get_mode_combo(self):
return self.mode
def get_description(self):
desc = ''
option = self.mode.get_selected_data()
if option is not None:
desc += option.name
if option.numbers > 0:
start = self.start.get_value_as_int()
if option.numbers == 1:
desc += ' %d' % start
elif option.numbers == 2:
end = self.end.get_value_as_int()
desc += ' %d %s %d' % (
start,
self.and_label.get_text(),
end,
)
if desc:
return '%s %s' % (self.get_title_label().get_text(), desc)
#
# Public API
#
def add_option(self, option_type, position=-2):
"""
Adds a date option
:param option_type: option to add
:type option_type: a :class:`NumberSearchOption` subclass
"""
option = option_type()
num = len(self.mode) + position
self.mode.insert_item(num, option.name, option_type)
self._options[option_type] = option
class NumberSearchFilter(SearchFilter):
"""
A filter which helps you to search by a number interval.
"""
__gtype_name__ = 'NumberSearchFilter'
def __init__(self, label=''):
"""
Create a new NumberSearchFilter object.
@param label: name of the search filter
"""
self._options = {}
SearchFilter.__init__(self, label=label)
self.title_label = gtk.Label(label)
self.title_label.set_alignment(1.0, 0.5)
self.pack_start(self.title_label, False, False)
self.title_label.show()
self.mode = ProxyComboBox()
self.mode.connect('content-changed', self._on_mode__content_changed)
self.pack_start(self.mode, False, False, 6)
self.mode.show()
self.start = gtk.SpinButton(climb_rate=1.0)
self.start.get_adjustment().step_increment = 1.0
self.start.set_range(-sys.maxint-1, sys.maxint)
self.pack_start(self.start, False, False, 6)
self.start.show()
self.start.connect_after('activate', self._on_entry__activate)
self.and_label = gtk.Label(_("And"))
self.pack_start(self.and_label, False, False)
self.and_label.show()
self.end = gtk.SpinButton(climb_rate=1.0)
self.end.get_adjustment().step_increment = 1.0
self.end.set_range(-sys.maxint-1, sys.maxint)
self.pack_start(self.end, False, False, 6)
self.end.show()
self.end.connect_after('activate', self._on_entry__activate)
for option in (LowerThan, EqualsTo, GreaterThan, Between):
self.add_option(option)
self.mode.select_item_by_position(0)
def set_digits(self, digits):
"""
Number of decimal place to be displayed
@param digits: number of decimal places
"""
self.start.set_digits(digits)
self.end.set_digits(digits)
#
# Private
#
def _update_visibility(self):
option = self.mode.get_selected_data()
numbers = option.numbers
if numbers == 0:
self.start.hide()
self.and_label.hide()
self.end.hide()
elif numbers == 1:
self.start.show()
self.and_label.hide()
self.end.hide()
elif numbers == 2:
self.start.show()
self.and_label.show()
self.end.show()
#
# Callbacks
#
def _on_entry__activate(self, entry):
self.emit('changed')
def _on_mode__content_changed(self, combo):
self._update_visibility()
self.emit('changed')
#
# SearchFilter
#
def get_state(self):
# Using Decimals for better precision.
start_value = Decimal("%.2f" % self.start.get_value())
end_value = Decimal("%.2f" % self.end.get_value())
option = self.mode.get_selected_data()
start, end = option().get_interval(start_value, end_value)
return NumberIntervalQueryState(filter=self, start=start, end=end)
def get_title_label(self):
return self.title_label
def get_mode_combo(self):
return self.mode
def get_description(self):
desc = ''
option = self.mode.get_selected_data()
if option is not None:
desc += option.name
if option.numbers > 0:
start = self.start.get_value_as_int()
if option.numbers == 1:
desc += ' %d' % start
elif option.numbers == 2:
end = self.end.get_value_as_int()
desc += ' %d %s %d' % (start, self.and_label.get_text(), end,)
if desc:
return '%s %s' % (self.get_title_label().get_text(), desc)
#
# Public API
#
def add_option(self, option_type, position=-2):
"""
Adds a date option
@param option_type: option to add
@type option_type: a L{NumberSearchOption} subclass
"""
option = option_type()
num = len(self.mode) + position
self.mode.insert_item(num, option.name, option_type)
self._options[option_type] = option
