def on_ok_clicked(self, obj): n = cuni(self.fname.get_text()).strip() if n == '': return if n != self.filter.get_name(): self.uistate.emit( 'filter-name-changed', (self.namespace, cuni(self.filter.get_name()), n)) self.filter.set_name(n) self.filter.set_comment(cuni(self.comment.get_text()).strip()) for f in self.filterdb.get_filters(self.namespace)[:]: if n == f.get_name(): self.filterdb.get_filters(self.namespace).remove(f) break val = self.logical.get_active() # WARNING: must be listed in this order: op = ('and' if val == 0 else 'or' if val == 1 else 'one' if val == 2 else 'sequence') self.logical.set_active(val) self.filter.set_logical_op(op) self.filter.set_invert(self.logical_not.get_active()) self.filterdb.add(self.namespace, self.filter) if self.update: self.update() if self.selection_callback: self.selection_callback(self.filterdb, self.filter.get_name()) self.close()
def write(self, method=print, indent='\t', tabs=''): """ Output function: performs an insertion-order tree traversal and calls supplied method for each item found. :type method: function reference :param method: function to call with each item found :type indent: string :param indenf: string to use for indentation. Default = '\t' (tab) :type tabs: string :param tabs: starting indentation """ if self.indent is None: tabs = '' elif self.indent: tabs += indent if self.inline: # if inline, write all list and method(cuni('%s%s' % (tabs, self))) # nested list elements # else: for item in self[:]: # else write one at a time if isinstance(item, Html): # recurse if nested Html class item.write(method=method, indent=indent, tabs=tabs) else: method(cuni('%s%s' % (tabs, item))) # else write the line
def column_path(self, data): path = data[2] if isinstance(path, UNITYPE): return path try: return cuni(path) except: return cuni(path.encode('iso-8859-1'))
def column_email(self, data): if data[6]: for i in data[6]: url = Url() url.unserialize(i) if url.get_type() == UrlType.EMAIL: return cuni(url.path) return cuni('')
def setUp(self): from gramps.cli.clidbman import CLIDbManager from gramps.gen.config import set as setconfig, get as getconfig from gramps.gen.dbstate import DbState self.newpath = os.path.join( os.path.dirname(__file__), cuni('\u0393\u03c1\u03b1\u03bc\u03c3\u03c0')) self.newtitle = cuni('Gr\u00e4mps T\u00e9st') os.makedirs(self.newpath) self.old_path = getconfig('behavior.database-path') setconfig('behavior.database-path', self.newpath) self.cli = CLIDbManager(DbState())
def build_confirm_text(self): from_text = cuni(self.from_entry.get_text()) to_text = cuni(self.to_entry.get_text()) text = _('The following action is to be performed:\n\n' 'Operation:\t%(title)s\n' 'Replace:\t\t%(src_fname)s\n' 'With:\t\t%(dest_fname)s') % { 'title': self.title.replace('_', ''), 'src_fname': from_text, 'dest_fname': to_text } return text
def _run(self): if not self.prepared: self.prepare() self.set_total(len(self.handle_list)) from_text = cuni(self.from_entry.get_text()) to_text = cuni(self.to_entry.get_text()) for handle in self.handle_list: obj = self.db.get_object_from_handle(handle) new_path = obj.get_path().replace(from_text, to_text) obj.set_path(new_path) self.db.commit_media_object(obj, self.trans) self.update() return True
def year(): """ The year part only """ year = cuni(date.get_year()) count = self.__count_chars("y", 4) if year == "0": return if count == 1: # found 'y' if len(year) == 1: return year elif year[-2] == "0": return year[-1] else: return year[-2:] elif count == 2: # found 'yy' tmp = "0" + year return tmp[-2:] elif count == 3: # found 'yyy' if len(year) > 2: return year else: tmp = "00" + year return tmp[-3:] else: #count == 4 # found 'yyyy' tmp = "000" + year return tmp[-4:]
def get_selection_string(self): try: surname = self.surname_set.get(primary=True) except: surname = "[No primary surname]" return cuni("%s, %s [%s]") % (surname, self.first_name, self.person.gramps_id)
def on_name_changed(self, *obj): """ Called anytime the filename text window changes. Checks to see if the file exists. If it does, the image is loaded into the preview window. """ fname = self.file_text.get_filename() if not fname: return filename = conv_to_unicode(fname) basename = os.path.basename(filename) (root, ext) = os.path.splitext(basename) old_title = cuni(self.description.get_text()) if old_title == '' or old_title == self.temp_name: self.description.set_text(root) self.temp_name = root filename = find_file(filename) if filename: mtype = get_type(filename) if mtype and mtype.startswith("image"): image = scale_image(filename, THUMBSCALE) else: image = find_mime_type_pixbuf(mtype) self.image.set_from_pixbuf(image)
def get_url(self): # /person/3536453463/reference/event/2 ref_by = self.object_type.model_class().objects.get(id=self.object_id) ref_to = self.ref_object return cuni("/%s/%s/reference/%s/%s") % ( ref_by.__class__.__name__.lower(), ref_by.handle, ref_to.__class__.__name__.lower(), self.order)
def write_text(self, text, mark=None, links=False): # Convert to unicode, just in case it's not. Fix of bug 2449. text = cuni(text) LOG.debug("write_text: opened: %d input text: %s" % (self.opened, text)) if self.opened == 0: self.opened = 1 self.text += '{%s ' % self.font_type for i in text: if ord(i) > 127: if ord(i) < 256: self.text += '\\\'%2x' % ord(i) else: # If (uni)code with more than 8 bits: # RTF req valus in decimal, not hex. self.text += '{\\uc1\\u%d\\uc0}' % ord(i) elif i == '\n': self.text += '\n\\par ' elif i == '{' or i == '}' or i == '\\': self.text += '\\%s' % i else: self.text += i if links == True: import re self.text = re.sub(URL_PATTERN, _CLICKABLE, self.text) LOG.debug("write_text, exit: opened: %d saved text: %s" % (self.opened, self.text))
def get_attributes(person, event_handle): """ Return the row number of the person in the census along with a dictionary of attributes. """ attrs = {} order = None for event_ref in person.get_event_ref_list(): if event_ref.ref == event_handle: for attr in event_ref.get_attribute_list(): if cuni(attr.get_type()) == ORDER_ATTR: order = int(attr.get_value()) else: attrs[cuni(attr.get_type())] = attr.get_value() return (order, name_displayer.display_formal(person), attrs)
def apply_filter(self, current_model=None): self.apply_text = cuni(self.filter_text.get_text()) self.filter_button.set_sensitive(False) self.uistate.status_text(_('Updating display...')) self.on_apply_callback() self.filter_text.grab_focus() self.uistate.modify_statusbar(self.dbstate)
def _on_insert_text(self, editable, new, length, position): if self._block_insert: return if not self._mask: UndoableEntry._on_insert_text(self, editable, new, length, position) return new = cuni(new) pos = self.get_position() self.stop_emission('insert-text') text = self.get_text() # Insert one char at a time for c in new: _pos = self._can_insert_at_pos(c, pos) if _pos is None: pos, text = self._insert_at_pos(text, c, pos) else: pos = _pos # Change the text with the new text. self._block_changed = True self._really_delete_text(0, -1) ### mask not used in Gramps, following should work though ##UndoableEntry._on_delete_text(self, editable, 0, -1) self._block_changed = False self._really_insert_text(text, 0)
def citation_src_pinfo(self, data): source_handle = data[COLUMN_SOURCE] try: source = self.db.get_source_from_handle(source_handle) return cuni(source.get_publication_info()) except: return ''
def citation_src_abbr(self, data): source_handle = data[COLUMN_SOURCE] try: source = self.db.get_source_from_handle(source_handle) return cuni(source.get_abbreviation()) except: return ''
def citation_src_id(self, data): source_handle = data[COLUMN_SOURCE] try: source = self.db.get_source_from_handle(source_handle) return cuni(source.gramps_id) except: return ''
def column_description(self, data): descr = data[4] if isinstance(descr, UNITYPE): return descr try: return cuni(descr) except: return conv_to_unicode(descr, 'latin1')
def column_home_url(self, data): if data[6]: for i in data[6]: url = Url() url.unserialize(i) if url.get_type() == UrlType.WEB_HOME: return cuni(url.path) return ""
def column_mime(self, data): mime = data[3] if mime and isinstance(mime, UNITYPE): return mime if mime: return cuni(mime) else: return _('Note')
def column_search_url(self, data): if data[6]: for i in data[6]: url = Url() url.unserialize(i) if url.get_type() == UrlType.WEB_SEARCH: return cuni(url.path) return ''
def _on_change(self, obj): if sys.version_info[0] < 3: self.set_val(cuni(obj.get_text(), 'utf-8')) else: #all is unicode self.set_val(obj.get_text()) if self.changed: self.changed(obj)
def get_value(self): active = self.get_active() if active < 0: return None key = cuni(self.store[active][0]) for paper in paper_sizes: if key == paper.trans_pname: key = paper.get_name() return (self.mapping[key], key)
def column_phone(self, data): try: if data[5]: addr = Address() addr.unserialize(data[5][0]) return addr.get_phone() except: pass return cuni('')
def set_mask(self, mask): """ Set the mask of the Entry. Supported format characters are: - '0' digit - 'L' ascii letter (a-z and A-Z) - '&' alphabet, honors the locale - 'a' alphanumeric, honors the locale - 'A' alphanumeric, honors the locale This is similar to MaskedTextBox: http://msdn2.microsoft.com/en-us/library/system.windows.forms.maskedtextbox.mask(VS.80).aspx Example mask for a ISO-8601 date >>> entry.set_mask('0000-00-00') :param mask: the mask to set """ if not mask: self.modify_font(Pango.FontDescription("sans")) self._mask = mask return # First, reset self._mask_validators = [] self._mask_fields = [] self._current_field = -1 mask = cuni(mask) input_length = len(mask) lenght = 0 pos = 0 field_begin = 0 field_end = 0 while True: if pos >= input_length: break if mask[pos] in INPUT_FORMATS: self._mask_validators += [INPUT_FORMATS[mask[pos]]] field_end += 1 else: self._mask_validators.append(mask[pos]) if field_begin != field_end: self._mask_fields.append((field_begin, field_end)) field_end += 1 field_begin = field_end pos += 1 self._mask_fields.append((field_begin, field_end)) self.modify_font(Pango.FontDescription("monospace")) self._really_delete_text(0, -1) self._insert_mask(0, input_length) self._mask = mask
def filter_name_changed(self, obj): name = cuni(self.fname.get_text()) # Make sure that the name is not empty # and not in the list of existing filters (excluding this one) names = [ filt.get_name() for filt in self.filterdb.get_filters(self.namespace) if filt != self.filter ] self.ok_btn.set_sensitive((len(name) != 0) and (name not in names))
def on_delete_clicked(self, obj): """Deletes the selected style.""" store, node = self.list.selection.get_selected() if not node: return name = cuni(self.list.model.get_value(node, 0)) if name == _('default'): # the default style cannot be removed return self.sheetlist.delete_style_sheet(name) self.redraw()
def column_preview(self, data): """Return a shortend version of the Note's text.""" #data is the encoding in the database, make it a unicode object #for universal work note = cuni(data[Note.POS_TEXT][StyledText.POS_TEXT]) note = " ".join(note.split()) if len(note) > 80: return note[:80] + "..." else: return note
def setUp(self): def dummy_callback(dummy): pass self._tmpdir = tempfile.mkdtemp() self._db = DbBsddb() dbman = CLIDbManager(None) self._filename, title = dbman.create_new_db_cli(title=cuni("Test")) self._db.load(self._filename, dummy_callback, "w")