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")
