def __init__(self, widget): gobject.GObject.__init__(self) self._widget = widget self._start_color = None self._background_timeout_id = -1 self._countdown_timeout_id = -1 self._log = Logger('fade') self._done = False
# """ Common routines used by other parts of the ui test framework. """ import re import gobject import gtk import time from gtk import gdk from kiwi.utils import gsignal from kiwi.log import Logger log = Logger('common') try: from gtk.gdk import event_handler_set event_handler_set # pyflakes except ImportError: try: from kiwi._kiwi import event_handler_set event_handler_set # pyflakes except ImportError: event_handler_set = None def find_in_tree(gobj, *columnValuePairs): retval = []
""" from stoqdrivers.printers.fiscal import FiscalPrinter from stoqdrivers.translation import stoqdrivers_gettext from stoqdrivers.exceptions import ( CommandParametersError, ) from kiwi.log import Logger from decimal import Decimal import json import re import os import ConfigParser from stoqdrivers.printers.bematech.MP25 import * from datetime import datetime _ = stoqdrivers_gettext log = Logger('fiscalv') class ParameterChecker(): def invoice(self, info): """ Check if invoice dictionary has proper indexs """ invoice_fields = ['customer', 'items', 'payments'] for cf in invoice_fields: if not info.has_key(cf): raise CommandParametersError( _('Invoice "%s" not specified' % (cf))) return True def customer(self, info):
from stoqdrivers.enum import PaymentMethodType, TaxType, UnitType from stoqdrivers.exceptions import ( PrinterError, CloseCouponError, PendingReadX, CommandError, CouponOpenError, CommandParametersError, CouponNotOpenError, ReduceZError, HardwareFailure, DriverError, OutofPaperError, PendingReduceZ, InvalidState, CancelItemError, AlreadyTotalized) from stoqdrivers.interfaces import ICouponPrinter from stoqdrivers.serialbase import SerialBase from stoqdrivers.printers.capabilities import Capability from stoqdrivers.printers.base import BaseDriverConstants from stoqdrivers.translation import stoqdrivers_gettext _ = stoqdrivers_gettext log = Logger('stoqdrivers.sweda') class IFS9000IConstants(BaseDriverConstants): _constants = { # Page 4-12, two decimals UnitType.WEIGHT: '!', UnitType.METERS: '@', UnitType.LITERS: ')', UnitType.EMPTY: '^', PaymentMethodType.MONEY: '01', PaymentMethodType.CHECK: '01' } _tax_constants = [ # Page 4-8
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 # USA # # Author(s): Johan Dahlin <*****@*****.**> # from gaxml.parser import GAXParser from kiwi.log import Logger log = Logger('gaxmlparser') class GAXMLWidgetTree(object): def __init__(self, view, gladefile, domain=None): self._view = view self._gladefile = gladefile self._parser = GAXParser() self._parser.parse_file(gladefile) self._widgets = [o.get_name() for o in self._parser.get_objects()] self._attach_widgets() def _attach_widgets(self): # Attach widgets in the widgetlist to the view specified, so # widgets = [label1, button1] -> view.label1, view.button1 for w in self._widgets: widget = self._parser.get_object(name=w)
Generic base class implementation for all devices. """ import gobject from kiwi.log import Logger from stoqdrivers.configparser import StoqdriversConfig from stoqdrivers.enum import DeviceType from stoqdrivers.exceptions import CriticalError, ConfigError from stoqdrivers.translation import stoqdrivers_gettext from stoqdrivers.serialbase import SerialPort _ = stoqdrivers_gettext log = Logger('stoqdrivers.basedev') class BaseDevice: """ Base class for all device interfaces, responsible for instantiate the device driver itself based on the brand and model specified or in the configuration file. """ typename_translate_dict = { DeviceType.PRINTER: "Printer", DeviceType.SCALE: "Scale", DeviceType.BARCODE_READER: "Barcode Reader", } # Subclasses must define these attributes device_dirname = None required_interfaces = None
"""Widget for displaying a list of objects""" import gtk from gtk import gdk, keysyms from kiwi.component import implements from kiwi.interfaces import IEasyCombo from kiwi.enums import ComboColumn, ComboMode from kiwi.log import Logger from kiwi.ui.entry import KiwiEntry from kiwi.ui.entrycompletion import KiwiEntryCompletion from kiwi.utils import gsignal, type_register from kiwi.ui.cellrenderer import ComboDetailsCellRenderer log = Logger('kiwi.ui.combo') class _ComboEntryPopup(gtk.Window): gsignal('text-selected', str) def __init__(self, comboentry): gtk.Window.__init__(self, gtk.WINDOW_POPUP) self.add_events(gdk.BUTTON_PRESS_MASK) self.connect('key-press-event', self._on__key_press_event) self.connect('button-press-event', self._on__button_press_event) self._comboentry = comboentry # Number of visible rows in the popup window, sensible # default value from other toolkits self._visible_rows = 10 self._initial_text = None
"""The accessor module offers two important front-end functions: kgetattr and ksetattr. These functions allow retrieving attribute values from objects much in the same way as getattr/setattr allow, but with two important differences: - They follow a dot hierarchy to retrieve or modify any value reachable from the object. - They cache the method used to access a certain attribute and reuse it the next time the value is retrieved. """ import string import types from kiwi.log import Logger log = Logger('kiwi.accessor') def get_default_getter(model, attr_name, cache): """Obtains from model a callable through which attr_name can be retrieved. This callable is an accessor named get_foo, where foo is the value of attr_name, or getattr(model, foo) if the accessor does not exist. If the callable exists, it is returned; if getattr() is to be used a tuple in the format (model, attr_name) is returned.""" func = getattr(model, "get_%s" % attr_name, None) if callable(func): log.info('kgetattr based get_%s method is deprecated, ' 'replace it with a property' % attr_name) return func else:
HyperLink ObjectList ObjectTree ProxyLabel ProxyComboEntry ProxyComboBox ProxyCheckButton ProxyColorButton ProxyRadioButton ProxyEntry ProxyDateEntry ProxySpinButton ProxyTextView ProxyButton log = Logger('builderloader') class BuilderWidgetTree: def __init__(self, view, gladefile, domain=None): self._view = view self._gladefile = gladefile self._builder = gtk.Builder() self._builder.add_from_file(gladefile) if domain is not None: self._builder.set_translation_domain(domain) self._attach_widgets() def _attach_widgets(self): # Attach widgets in the widgetlist to the view specified, so
from kiwi.argcheck import number, percent from kiwi.currency import currency from kiwi.log import Logger from stoqdrivers.exceptions import (CloseCouponError, PaymentAdditionError, AlreadyTotalized, InvalidValue) from stoqdrivers.enum import PaymentMethodType, TaxType, UnitType from stoqdrivers.printers.base import BasePrinter from stoqdrivers.printers.capabilities import capcheck from stoqdrivers.utils import encode_text from stoqdrivers.translation import stoqdrivers_gettext _ = stoqdrivers_gettext log = Logger('stoqdrivers.fiscalprinter') # # Extra data types to argcheck # class taxcode(number): @classmethod def value_check(cls, name, value): if value not in (TaxType.NONE, TaxType.ICMS, TaxType.SUBSTITUTION, TaxType.EXEMPTION): raise ValueError("%s must be one of TaxType.* constants" % name) class unit(number): @classmethod def value_check(cls, name, value):
FIRST_COMMAND_ID = 0x81 RETRIES_BEFORE_TIMEOUT = 5 # When cancel the last coupon. This values are used to define the coupon type. FISCAL_COUPON = '1' NON_FISCAL_COUPON = '24' # Coupons status CLOSED_COUPON = '0000' OPENED_FISCAL_COUPON = '0001' OPENED_NON_FISCAL_COUPON = '1000' _ = stoqdrivers_gettext log = Logger('stoqdrivers.epson') class Reply(object): # # Printer flags # error_codes = { '0101': (CommandError(_("Invalid command for current state."))), '0102': (CommandError(_("Invalid command for current document."))), '0203': (CommandError(_("Excess fields"))), '0204': (CommandError(_("Missing fields"))), '0205': (CommandParametersError(_("Field not optional."))), '0206': (CommandParametersError(_("Invalid alphanumeric field."))),
import errno import gettext import imp import locale import os import sys from kiwi.log import Logger from kiwi.python import namedAny __all__ = [ 'Application', 'Library', 'app', 'environ', 'require_gazpacho', 'is_gazpacho_required' ] log = Logger('environ') EnvironmentError = EnvironmentError # From http://tinyurl.com/77ukj def _is_frozen(): "Helper function to check if we're frozen in a py2exe'd file" return (hasattr(sys, "frozen") or # new py2exe hasattr(sys, "importers") # old py2exe or imp.is_frozen("__main__")) # tools/freeze class Environment: """Environment control
import re import string import gobject import gtk from gtk import gdk from kiwi.environ import environ from kiwi.interfaces import IValidatableProxyWidget from kiwi.log import Logger from kiwi.python import namedAny from kiwi.utils import gsignal, type_register from kiwi.ui.gadgets import quit_if_last from kiwi.ui.proxy import Proxy log = Logger('kiwi.view') _non_interactive = ( gtk.Label, gtk.Alignment, gtk.AccelLabel, gtk.Arrow, gtk.EventBox, gtk.Fixed, gtk.Frame, gtk.HBox, gtk.HButtonBox, gtk.HPaned, gtk.HSeparator, gtk.Layout, gtk.Progress,
# License along with this library; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 # USA # # Author(s): Christian Reis <*****@*****.**> # Johan Dahlin <*****@*****.**> # """Holds the models part of the Kiwi Framework""" import os import pickle from kiwi import ValueUnset from kiwi.log import Logger log = Logger('model') # # A model that implements half of an observer pattern; when its # attributes are changed, it notifies any proxies of the change. # class Model: """ The Model is a mixin to be used by domain classes when attached to Proxies. It also provides autonotification of changes to the attached proxies. Note that if using setters, a specific call to notify_proxies() may be necessary; see the doc for __setattr__.""" def __init__(self): self.ensure_init()
## ## Author(s): Johan Dahlin <*****@*****.**> ## Henrique Romano <*****@*****.**> ## from kiwi.log import Logger from serial import Serial, EIGHTBITS, PARITY_NONE, STOPBITS_ONE from zope.interface import implements from stoqdrivers.interfaces import ISerialPort from stoqdrivers.exceptions import DriverError from stoqdrivers.translation import stoqdrivers_gettext _ = stoqdrivers_gettext log = Logger('stoqdrivers.serial') class VirtualPort: implements(ISerialPort) def getDSR(self): return True def setDTR(self, value): pass def write(self, data): pass def read(self, n_bytes=1):
""" Daruma FS2100 driver """ import operator from decimal import Decimal import time from stoqdrivers.printers.base import BaseDriverConstants from stoqdrivers.printers.daruma.FS345 import FS345, CMD_GET_TAX_CODES from stoqdrivers.enum import UnitType, TaxType from stoqdrivers.exceptions import DriverError from kiwi.log import Logger log = Logger('stoqdrivers.daruma') ENQ = 05 ACK = 06 LF = 10 CR = 13 ESC = 27 FS = 28 GS = 29 FF = 255 CMD_ADD_ITEM = 201 class FS2100Constants(BaseDriverConstants): _constants = {
from stoqdrivers.serialbase import SerialBase from stoqdrivers.exceptions import (DriverError, OutofPaperError, PrinterError, CommandError, CouponOpenError, HardwareFailure, PrinterOfflineError, PaymentAdditionError, ItemAdditionError, CancelItemError, CouponTotalizeError, CouponNotOpenError) from stoqdrivers.interfaces import ICouponPrinter from stoqdrivers.printers.capabilities import Capability from stoqdrivers.printers.base import BaseDriverConstants from stoqdrivers.enum import TaxType, UnitType from stoqdrivers.translation import stoqdrivers_gettext _ = stoqdrivers_gettext log = Logger('stoqdrivers.bematech.MP25') CASH_IN_TYPE = "SU" CASH_OUT_TYPE = "SA" # The comment after the commands are comparing the MP25 command with MP20. CMD_COUPON_OPEN = 0 # MP25 aceita 2 parametros opcionais a mais CMD_CLOSE_TILL = 5 CMD_REDUCE_Z = 5 CMD_READ_X = 6 CMD_ADD_TAX = 7 CMD_READ_MEMORY = 8 CMD_COUPON_CANCEL = 14 # MP25 aceita 3 parametros opicionais CMD_STATUS = 19 CMD_ADD_VOUCHER = 25
from gobject import add_emission_hook add_emission_hook # pyflakes # XXX needed for add_emission_hook('delete-event'), something is not # initialized correctly. gtk.Window().destroy() except ImportError: try: from kiwi._kiwi import add_emission_hook add_emission_hook # pyflakes except ImportError: add_emission_hook = None _events = [] log = Logger('recorder') def register_event_type(event_type): """ Add an event type to a list of event types. @param event_type: a L{Event} subclass """ if event_type in _events: raise AssertionError("event %s already registered" % event_type) _events.append(event_type) def get_event_types(): """
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details. # # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. ################################################################################ from stoqdrivers.printers.fiscal import FiscalPrinter from stoqdrivers.printers import base from stoqdrivers.exceptions import DriverError from stoqdrivers.translation import stoqdrivers_gettext _ = stoqdrivers_gettext from kiwi.log import Logger log = Logger('fiscalex') class FiscalPrinterEx(FiscalPrinter): def get_supported_printers(self): printers = base.get_supported_printers() for brand in printers: for i in range(0, len(printers[brand])): printers[brand][i] = str(printers[brand][i]).split(".")[3] return printers def get_supported_printers(self): return base.get_supported_printers() def set_payment_methods(self, payment_methods): log.info('set_payment_methods()')
from kiwi.ui.widgets.combo import ProxyComboEntry, ProxyComboBox, \ ProxyComboBoxEntry from kiwi.ui.widgets.entry import ProxyDateEntry, ProxyEntry from kiwi.ui.widgets.label import ProxyLabel from kiwi.ui.widgets.radiobutton import ProxyRadioButton from kiwi.ui.widgets.scale import ProxyHScale, ProxyVScale from kiwi.ui.widgets.spinbutton import ProxySpinButton from kiwi.ui.widgets.textview import ProxyTextView # Backwards compatibility + pyflakes from kiwi.ui.widgets.combobox import ComboBox, ComboBoxEntry from kiwi.ui.widgets.list import List HyperLink _ = lambda m: gettext.dgettext('kiwi', m) log = Logger('gazpacholoader') class Builder(ObjectBuilder): def find_resource(self, filename): return environ.find_resource("pixmaps", filename) class GazpachoWidgetTree: """Example class of GladeAdaptor that uses Gazpacho loader to load the glade files """ def __init__(self, view, gladefile, domain=None): self._view = view self._gladefile = gladefile self._showwarning = warnings.showwarning
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 # USA # # Author(s): Johan Dahlin <*****@*****.**> # from gtk.glade import XML from kiwi.log import Logger log = Logger('libgladeloader') class LibgladeWidgetTree(XML): def __init__(self, view, gladefile, domain=None): self._view = view self._gladefile = gladefile XML.__init__(self, gladefile, domain) self._widgets = [w.get_name() for w in self.get_widget_prefix('')] self._attach_widgets() def _attach_widgets(self): # Attach widgets in the widgetlist to the view specified, so # widgets = [label1, button1] -> view.label1, view.button1 for w in self._widgets: widget = XML.get_widget(self, w)
import gettext import gobject import gtk from gtk import gdk from kiwi import ValueUnset from kiwi.component import implements from kiwi.datatypes import ValidationError, converter, BaseConverter from kiwi.environ import environ from kiwi.interfaces import IProxyWidget, IValidatableProxyWidget from kiwi.log import Logger from kiwi.ui.gadgets import FadeOut log = Logger('widget proxy') _ = lambda m: gettext.dgettext('kiwi', m) class _PixbufConverter(BaseConverter): type = gdk.Pixbuf name = 'Pixbuf' def as_string(self, value, format='png'): if value is ValueUnset: return '' buffer = [] value.save_to_callback(buffer.append, format) string = ''.join(buffer) return string
Runner - executes recorded scripts """ import doctest import os import sys import time from StringIO import StringIO import gobject from gtk import gdk from kiwi.log import Logger from kiwi.ui.test.common import WidgetIntrospecter log = Logger('kiwi.ui.test.player') class NotReadyYet(Exception): pass class MissingWidget(KeyError): pass class MagicWindowWrapper(object): def __init__(self, window, ns): self.window = window self.ns = ns
""" import gobject import gtk from kiwi import ValueUnset from kiwi.accessor import kgetattr, ksetattr, clear_attr_cache from kiwi.datatypes import converter from kiwi.decorators import deprecated from kiwi.interfaces import IProxyWidget, IValidatableProxyWidget from kiwi.log import Logger class ProxyError(Exception): pass log = Logger('proxy') def block_widget(widget): """Blocks the signal handler of the 'content-changed' signal on widget""" connection_id = widget.get_data('content-changed-id') if connection_id: widget.handler_block(connection_id) def unblock_widget(widget): """Unblocks the signal handler of the 'content-changed' signal on widget""" connection_id = widget.get_data('content-changed-id') if connection_id: widget.handler_unblock(connection_id) def _get_widget_data_type(widget): data_type = widget.get_property('data-type')