def __init__(self,
content="",
font_name="monospace",
font_size=10,
wrap=False,
set_statusbar_msg=None):
self.content = "\n" * 11 + content # Dirty offset for the logo
self.layout = None
self.font_name = font_name
self.font_size = font_size
self.wrap = wrap
self._linesppage = 0
self._current_line = 0
self.operation = gtk.PrintOperation()
self.operation.set_unit(gtk.UNIT_MM)
# Setting paper size as A4
paper_size = gtk.PaperSize(gtk.PAPER_NAME_A4)
setup = gtk.PageSetup()
setup.set_paper_size(paper_size)
self.operation.set_default_page_setup(setup)
self.operation.connect("begin_print", self.begin_print)
self.operation.connect("draw_page", self.draw_page)
if set_statusbar_msg is not None:
self.operation.connect("status-changed", status_cb,
set_statusbar_msg)
def __init__(self, unit=gtk.UNIT_MM, size=gtk.PAPER_NAME_A4,
orientation=gtk.PAGE_ORIENTATION_PORTRAIT):
"""
Parameters
----------
unit : gtk unit constant
size : gtk paper name constant
orientation : gtk page orientation constant
see http://www.pygtk.org/pygtk2reference/gtk-constants.html
for available constantes
"""
self.op = None
self.page_setup = gtk.PageSetup()
self.page_setup.set_orientation(orientation)
self.page_setup.set_paper_size(gtk.PaperSize(size))
self.unit = unit
self.w = self.page_setup.get_paper_size().get_width(unit)
self.h = self.page_setup.get_paper_size().get_height(unit)
# Workaround:
# Variable `self.error` keeps track of exceptions raised during print
# operation in the methods `PDF._paginate()` or `PDF._draw_page()`. To
# catch the exceptions, the calls of these methods are encapsulated
# within `PDF.__paginate()` or `PDF.__draw_page()`, where this variable
# is set to the exception and the print operation is canceled via
# `op.cancel()`.
# The reason for this is that exceptions thrown during the run of the
# print operation are caught internally and can not be handled further.
# This leads to fatal uncaught exception error.
self.error = None
def get_print_operation(self):
"""Return a Print Operation"""
print_operation = gtk.PrintOperation()
print_operation.set_show_progress(True)
if self.page_setup is None: self.page_setup = gtk.PageSetup()
if self.settings is None: self.settings = gtk.PrintSettings()
print_operation.set_default_page_setup(self.page_setup)
print_operation.set_print_settings(self.settings)
return print_operation
def get_page_setup(self):
if not self.__page_setup:
self.__page_setup = gtk.PageSetup()
try:
filename = self.__get_page_setup_filename()
self.__page_setup.load_file(filename)
except glib.GError:
pass
return self.__page_setup
def on_print_clicked(self, widget):
printop = gtk.PrintOperation()
page_setup = gtk.PageSetup()
page_setup.set_paper_size(gtk.PaperSize(gtk.PAPER_NAME_A4))
printop.set_default_page_setup(page_setup)
order_products = OrderProduct.find_all_not_yet_ordered_on(
self.calendardate())
self.printer = OrderProductPrinter(order_products)
n_pages = self.printer.calc_n_pages()
printop.set_n_pages(n_pages)
printop.connect("draw_page", self.print_ordered_products)
printop.run(gtk.PRINT_OPERATION_ACTION_PRINT_DIALOG)
def render(self):
# FIXME: This is an specific fix for boleto printing in landscape
# orientation. We should find a better fix for it or simply remove
# PrintOperationPoppler when migrating the last reports using
# reportlab to weasyprint
if getattr(self._report, 'print_as_landscape', False):
default_page_setup = gtk.PageSetup()
default_page_setup.set_orientation(gtk.PAGE_ORIENTATION_LANDSCAPE)
self.set_default_page_setup(default_page_setup)
self._report.save()
uri = gio.File(path=self._report.filename).get_uri()
self._document = poppler.document_new_from_file(uri, password="")
def _load_settings(self):
self.config_dir = get_application_dir('stoq')
settings = gtk.PrintSettings()
filename = os.path.join(self.config_dir, self.print_settings_name)
if os.path.exists(filename):
settings.load_file(filename)
self.set_print_settings(settings)
default_page_setup = gtk.PageSetup()
default_page_setup.set_orientation(gtk.PAGE_ORIENTATION_PORTRAIT)
filename = os.path.join(self.config_dir, self.page_setup_name)
if os.path.exists(filename):
default_page_setup.load_file(filename)
self.set_default_page_setup(default_page_setup)
def doPrint(self,
printer,
wikiDocument,
wordList,
printType,
addopt,
doPreview=False):
"""
To print with webkit we load the pages into a temporary frame
that contains a WKHtmlWindow and use webkits print function.
The frame does not need to be shown as a preview is builtin
"""
self.setContext(printer, wikiDocument, wordList, printType, addopt)
if self.checkWebkit():
import gtk
htpath = self._buildHtml()
frame = None
try:
# Get page setup dialog data (wxPython) and translate to pyGTK
psddata = self.printer.getPageSetupDialogData()
tl = psddata.GetMarginTopLeft()
br = psddata.GetMarginBottomRight()
print_op = gtk.PrintOperation()
page_setup = gtk.PageSetup()
page_setup.set_top_margin(tl.y, gtk.UNIT_MM)
page_setup.set_left_margin(tl.x, gtk.UNIT_MM)
page_setup.set_right_margin(br.x, gtk.UNIT_MM)
page_setup.set_bottom_margin(br.y, gtk.UNIT_MM)
print_op.set_default_page_setup(page_setup)
frame = WKPrintFrame(htpath)
if doPreview:
opCode = gtk.PRINT_OPERATION_ACTION_PREVIEW
frame.print_full(print_op, opCode)
return False
else:
opCode = gtk.PRINT_OPERATION_ACTION_PRINT_DIALOG
result = frame.print_full(print_op, opCode)
return result in (gtk.PRINT_OPERATION_RESULT_APPLY,
gtk.PRINT_OPERATION_RESULT_IN_PROGRESS)
finally:
if frame:
frame.Destroy()
self._freeHtml()
def do_print(self):
print_op = gtk.PrintOperation()
# Page size and orientation
# FIXME: sizes other than letter do not work
print "paper size:", self.papersize
paper_size = gtk.PaperSize(gtk.PAPER_NAME_LETTER)
if self.papersize[0] > self.papersize[1]:
print " landscape"
paper_size.set_size(self.papersize[1], self.papersize[0],
gtk.UNIT_POINTS)
orientation = gtk.PAGE_ORIENTATION_LANDSCAPE
else:
print " portrait"
paper_size.set_size(self.papersize[0], self.papersize[1],
gtk.UNIT_POINTS)
orientation = gtk.PAGE_ORIENTATION_PORTRAIT
print "is_custom:", paper_size.is_custom()
page_setup = gtk.PageSetup()
page_setup.set_paper_size_and_default_margins(paper_size)
page_setup.set_orientation(orientation)
print_op.set_default_page_setup(page_setup)
#if self.print_settings is not None:
# print_op.set_print_settings(self.print_settings)
print_op.set_show_progress(False) # appears late
print_op.set_use_full_page(True)
print_op.set_embed_page_setup(True)
print_op.connect('draw_page', self.draw_page)
print_op.set_n_pages(1)
result = print_op.run(gtk.PRINT_OPERATION_ACTION_PRINT_DIALOG,
self.main_window)
print "Printing result:", result
if self.map_failure:
return self.map_failure
elif result == gtk.PRINT_OPERATION_RESULT_ERROR:
return print_op.get_error()
#elif result == gtk.PRINT_OPERATION_RESULT_APPLY:
# self.print_settings = print_op.get_print_settings()
# return None
else:
return None
def __init__(self, content, cols_width, heading=None):
# self.lines_per_page = 24
self.cell_margin = 4
self.line = 2 #the thinest possible width of lines.
self.row_height = 2 * (config.contentfont + self.cell_margin)
self.header_height = 0
self.heading_height = 35
self.operation = gtk.PrintOperation()
settings = gtk.PrintSettings()
paper_size = gtk.paper_size_new_from_ppd(config.paper_ppd,
config.paper_name,
config.paper_width,
config.paper_height)
self.page_setup = gtk.PageSetup()
self.page_setup.set_paper_size(paper_size)
self.page_setup.set_orientation(config.paper_orientation)
# self.page_setup = gtk.print_run_page_setup_dialog(None, self.page_setup, settings)
self.page_setup.set_top_margin(config.topmargin, gtk.UNIT_POINTS)
self.page_setup.set_bottom_margin(config.botmargin, gtk.UNIT_POINTS)
self.page_setup.set_right_margin(config.rightmargin, gtk.UNIT_POINTS)
self.page_setup.set_left_margin(config.leftmargin, gtk.UNIT_POINTS)
self.operation.set_default_page_setup(self.page_setup)
self.operation.set_unit(gtk.UNIT_POINTS)
self.content = content
tablewidth = self.page_setup.get_page_width(gtk.UNIT_POINTS)
tablewidth -= (len(cols_width) *
(self.line + self.cell_margin)) + self.line + (
config.rightmargin + config.leftmargin)
self.cols_width = []
for percent in cols_width:
self.cols_width.append(math.floor((percent * tablewidth) / 100))
# self.cols_width = cols_width
self.heading = heading
self.operation.connect("begin_print", self.beginPrint)
self.operation.connect("draw-page", self.printPage)
self.type = 0
self.title = ""
self.fields = {}
def __begin_print_cb(self, operation, context, data=None):
settings = operation.get_print_settings()
pixbuf = self._get_view_image()
rect = self.output.get_allocation()
paper_size = gtk.paper_size_new_custom("custom", "custom",
pixel_to_mm(rect.width),
pixel_to_mm(rect.height),
gtk.UNIT_MM)
settings.set_paper_size(paper_size)
page_setup = gtk.PageSetup()
page_setup.set_top_margin(0, gtk.UNIT_POINTS)
page_setup.set_bottom_margin(0, gtk.UNIT_POINTS)
page_setup.set_left_margin(0, gtk.UNIT_POINTS)
page_setup.set_right_margin(0, gtk.UNIT_POINTS)
operation.set_default_page_setup(page_setup)
settings.set_orientation
operation.set_n_pages(1)
def set_document(self, filename, operation, context):
if not filename.startswith('file'):
filename = 'file://' + os.path.realpath(filename)
self.d = poppler.document_new_from_file(filename, None)
operation.set_n_pages(self.d.get_n_pages())
# Assume all pages are same
page = self.d.get_page(0)
w, h = page.get_size()
if w > h:
w, h = h, w
ori = gtk.PAGE_ORIENTATION_LANDSCAPE
else:
ori = gtk.PAGE_ORIENTATION_PORTRAIT
page_setup = gtk.PageSetup()
page_setup.set_orientation(ori)
size = int(round(w)), int(round(h))
gtk_size = rl2gtk_papersizes.get(size, None)
if gtk_size:
ps = gtk.PaperSize(gtk_size)
else:
ps = gtk.paper_size_new_custom('', '', w, h, gtk.UNIT_POINTS)
page_setup.set_paper_size(ps)
operation.set_default_page_setup(page_setup)
def __init__(self):
gtk.Window.__init__(self)
self.set_size_request(640, 480)
self.set_default_size(1366, 768)
#self.set_default_size(800, 600)
self.winstate = 0
self.maximize()
self.connect("delete-event", self.quit)
self.bindings = gtk.AccelGroup()
self.add_accel_group(self.bindings)
self.setup = gtk.PageSetup()
self.settings = gtk.PrintSettings()
self.filename = None
self.update_title()
icon = gtk.gdk.pixbuf_new_from_file(
os.path.join(os.path.dirname(__file__), "..", "images",
"canvas-logo.png"))
self.set_icon(icon)
vbox = gtk.VBox()
self.add(vbox)
self.menu = MenuBar(self)
vbox.pack_start(self.menu, False, False)
self.menu.append_menu("_" + _("File"))
self.menu.append_item(gtk.STOCK_NEW, "new", "<Control>N")
self.menu.append_item(gtk.STOCK_OPEN, "open", "<Control>O")
self.menu.append_item(gtk.STOCK_SAVE, "save", "<Control>S")
self.menu.append_item(gtk.STOCK_SAVE_AS, "save-as",
"<Control><Shift>S")
self.menu.append_separator()
self.menu.append_item(gtk.STOCK_PAGE_SETUP, "page-setup")
self.menu.append_item(gtk.STOCK_PRINT_PREVIEW, "print-preview",
"<Control><Shift>P")
self.menu.append_item(gtk.STOCK_PRINT, "print", "<Control>P")
self.menu.append_separator()
self.menu.append_menu("_" + _("Document"), True)
self.menu.append_item(SET_BACKGROUND, "set-background")
self.menu.ascend()
self.menu.append_separator()
self.menu.append_menu("_" + _("Export"), True)
self.menu.append_item(EXPORT_TO_PDF, "export-to-pdf")
self.menu.ascend()
self.menu.append_separator()
self.menu.append_item(gtk.STOCK_QUIT, "quit", "<Control>Q")
self.menu.append_menu("_" + _("Edit"))
self.menu.append_item(gtk.STOCK_UNDO, "undo", "<Control>Z")
self.menu.append_item(gtk.STOCK_REDO, "redo", "<Control>Y")
self.menu.append_separator()
self.menu.append_item(gtk.STOCK_COPY, "copy", "<Control>C")
self.menu.append_item(gtk.STOCK_CUT, "cut", "<Control>X")
self.menu.append_item(gtk.STOCK_PASTE, "paste", "<Control>V")
self.menu.append_separator()
self.menu.append_item(gtk.STOCK_DELETE, "delete", "Delete")
self.menu.append_separator()
self.menu.append_item(gtk.STOCK_SELECT_ALL, "select-all", "<Control>A")
self.menu.append_menu("_" + _("View"))
self.menu.append_toggle(MARGINS_ENABLED, "margins")
self.menu.append_toggle(GRID, "grid")
self.menu.append_toggle(GUIDES, "guides")
self.menu.append_toggle(SNAP_ENABLED, "snap")
self.menu.append_toggle(_("Z-Order hint"), "hints", toggled=False)
self.menu.append_separator()
self.menu.append_toggle(gtk.STOCK_PROPERTIES, "properties")
self.menu.append_toggle(_("Menubar"), "menubar")
self.menu.append_toggle(_("Statusbar"), "statusbar")
self.menu.append_menu("_" + _("Insert"))
self.menu.append_item(LINE, "line")
self.menu.append_item(ARC, "arc")
self.menu.append_item(CURVE, "curve")
self.menu.append_item(CONNECTOR, "connector")
self.menu.append_menu(BOX, "box", True)
self.menu.append_item(BOX, "box")
self.menu.append_item(SPLIT_HORIZONTALLY, "split-horizontally")
self.menu.append_item(SPLIT_VERTICALLY, "split-vertically")
self.menu.append_item(REMOVE_SPLIT, "remove-split")
self.menu.ascend()
self.menu.append_item(ROUNDED_BOX, "rounded-box")
self.menu.append_item(TEXT, "text")
self.menu.append_item(TABLE, "table")
self.menu.append_item(CHART, "chart")
self.menu.append_item(BARCODE, "barcode")
self.menu.append_item(IMAGE, "image")
self.menu.append_menu("_" + _("Format"))
self.menu.append_item(gtk.STOCK_SELECT_FONT, "select-font")
self.menu.append_separator()
self.menu.append_item(gtk.STOCK_SELECT_COLOR, "select-color")
self.menu.append_menu("_" + _("Tools"))
self.menu.append_item(GROUP, "group", "<Control>G")
self.menu.append_item(UNGROUP, "ungroup", "<Control><Shift>G")
self.menu.append_separator()
self.menu.append_item(BRING_TO_FRONT, "bring-to-front",
"<Control>plus")
self.menu.append_item(BRING_TO_BACK, "bring-to-back", "<Control>minus")
self.menu.append_separator()
self.menu.append_menu("_" + _("Zoom"), True)
self.menu.append_item(gtk.STOCK_ZOOM_FIT, "zoom-fit", "<Control>0")
self.menu.append_item(gtk.STOCK_ZOOM_100, "zoom-100", "<Control>1")
self.menu.append_item(gtk.STOCK_ZOOM_IN, "zoom-in",
"<Control><Shift>plus")
self.menu.append_item(gtk.STOCK_ZOOM_OUT, "zoom-out",
"<Control><Shift>minus")
self.menu.ascend()
self.menu.append_separator()
self.menu.append_menu("_" + _("Objects alignment"), True)
self.menu.append_item(ALIGN_OBJECTS_NORTHWEST,
"align-objects-northwest")
self.menu.append_item(ALIGN_OBJECTS_NORTH, "align-objects-north")
self.menu.append_item(ALIGN_OBJECTS_NORTHEAST,
"align-objects-northeast")
self.menu.append_item(ALIGN_OBJECTS_SOUTHWEST,
"align-objects-southwest")
self.menu.append_item(ALIGN_OBJECTS_SOUTH, "align-objects-south")
self.menu.append_item(ALIGN_OBJECTS_SOUTHEAST,
"align-objects-southeast")
self.menu.append_item(ALIGN_OBJECTS_WEST, "align-objects-west")
self.menu.append_item(ALIGN_OBJECTS_CENTER_BOTH,
"align-objects-center-both")
self.menu.append_item(ALIGN_OBJECTS_EAST, "align-objects-east")
self.menu.append_item(ALIGN_OBJECTS_CENTER_HORIZONTAL,
"align-objects-center-horizontal")
self.menu.append_item(ALIGN_OBJECTS_CENTER_VERTICAL,
"align-objects-center-vertical")
self.menu.ascend()
self.menu.append_menu("_" + _("Paper alignment"), True)
self.menu.append_item(ALIGN_PAPER_NORTHWEST, "align-paper-northwest")
self.menu.append_item(ALIGN_PAPER_NORTH, "align-paper-north")
self.menu.append_item(ALIGN_PAPER_NORTHEAST, "align-paper-northeast")
self.menu.append_item(ALIGN_PAPER_SOUTHWEST, "align-paper-southwest")
self.menu.append_item(ALIGN_PAPER_SOUTH, "align-paper-south")
self.menu.append_item(ALIGN_PAPER_SOUTHEAST, "align-paper-southeast")
self.menu.append_item(ALIGN_PAPER_WEST, "align-paper-west")
self.menu.append_item(ALIGN_PAPER_CENTER_BOTH,
"align-paper-center-both")
self.menu.append_item(ALIGN_PAPER_EAST, "align-paper-east")
self.menu.append_item(ALIGN_PAPER_CENTER_HORIZONTAL,
"align-paper-center-horizontal")
self.menu.append_item(ALIGN_PAPER_CENTER_VERTICAL,
"align-paper-center-vertical")
self.menu.ascend()
self.menu.append_menu("_" + _("Window"))
self.menu.append_item(gtk.STOCK_FULLSCREEN, "fullscreen", "<Control>F")
self.menu.append_menu("_" + _("Help"), right=True)
self.menu.append_item(gtk.STOCK_HELP, "help", "F1")
self.menu.append_separator()
self.menu.append_item(gtk.STOCK_ABOUT, "about")
self.menu.show_all()
htoolbar = Toolbar(HORIZONTAL)
vbox.pack_start(htoolbar, False, False)
htoolbar.append(gtk.STOCK_NEW, "new")
htoolbar.append(gtk.STOCK_OPEN, "open")
htoolbar.append(gtk.STOCK_SAVE, "save")
htoolbar.append_separator()
htoolbar.append(gtk.STOCK_PRINT, "print")
htoolbar.append_separator()
htoolbar.append(gtk.STOCK_UNDO, "undo")
htoolbar.append(gtk.STOCK_REDO, "redo")
htoolbar.append_separator()
htoolbar.append(gtk.STOCK_CUT, "cut")
htoolbar.append(gtk.STOCK_COPY, "copy")
htoolbar.append(gtk.STOCK_PASTE, "paste")
htoolbar.append_separator()
htoolbar.append(gtk.STOCK_DELETE, "delete")
htoolbar.append_separator()
htoolbar.append_with_submenu(LINE_STYLE_CONTINUOUS,
"line-style-continuous")
htoolbar.append_to_submenu(LINE_STYLE_POINT_DASH,
"line-style-point-dash")
htoolbar.append_to_submenu(LINE_STYLE_POINT, "line-style-point")
htoolbar.append_to_submenu(LINE_STYLE_DASH, "line-style-dash")
htoolbar.append_separator()
htoolbar.append_with_submenu(gtk.STOCK_ZOOM_FIT, "zoom-fit")
htoolbar.append_to_submenu(gtk.STOCK_ZOOM_100, "zoom-100")
htoolbar.append_to_submenu(gtk.STOCK_ZOOM_IN, "zoom-in")
htoolbar.append_to_submenu(gtk.STOCK_ZOOM_OUT, "zoom-out")
htoolbar.append_separator()
htoolbar.append_toggle(MARGINS_ENABLED, "margins")
htoolbar.append_toggle(GRID, "grid")
htoolbar.append_toggle(GUIDES, "guides")
htoolbar.append_toggle(SNAP_ENABLED, "snap")
htoolbar.append_separator()
htoolbar.append(EXPORT_TO_PDF, "export-to-pdf")
htoolbar.append_separator()
htoolbar.append_toggle(GROUP, "group")
htoolbar.append_separator()
htoolbar.append(BRING_TO_FRONT, "bring-to-front")
htoolbar.append(BRING_TO_BACK, "bring-to-back")
htoolbar.append_separator()
htoolbar.append_with_submenu(ALIGN_OBJECTS_CENTER_BOTH,
"align-object-center-both")
htoolbar.append_to_submenu(ALIGN_OBJECTS_NORTHWEST,
"align-object-northwest")
htoolbar.append_to_submenu(ALIGN_OBJECTS_NORTH, "align-object-north")
htoolbar.append_to_submenu(ALIGN_OBJECTS_SOUTHWEST,
"align-object-southwest")
htoolbar.append_to_submenu(ALIGN_OBJECTS_NORTHEAST,
"align-object-northeast")
htoolbar.append_to_submenu(ALIGN_OBJECTS_SOUTH, "align-object-south")
htoolbar.append_to_submenu(ALIGN_OBJECTS_SOUTHEAST,
"align-object-southeast")
htoolbar.append_to_submenu(ALIGN_OBJECTS_WEST, "align-object-west")
htoolbar.append_to_submenu(ALIGN_OBJECTS_EAST, "align-object-east")
htoolbar.append_to_submenu(ALIGN_OBJECTS_CENTER_HORIZONTAL,
"align-object-center-horizontal")
htoolbar.append_to_submenu(ALIGN_OBJECTS_CENTER_VERTICAL,
"align-object-center-vertical")
htoolbar.append_with_submenu(ALIGN_PAPER_CENTER_BOTH,
"align-paper-center-both")
htoolbar.append_to_submenu(ALIGN_PAPER_NORTHWEST,
"align-paper-northwest")
htoolbar.append_to_submenu(ALIGN_PAPER_NORTH, "align-paper-north")
htoolbar.append_to_submenu(ALIGN_PAPER_SOUTHWEST,
"align-paper-southwest")
htoolbar.append_to_submenu(ALIGN_PAPER_NORTHEAST,
"align-paper-northeast")
htoolbar.append_to_submenu(ALIGN_PAPER_SOUTH, "align-paper-south")
htoolbar.append_to_submenu(ALIGN_PAPER_SOUTHEAST,
"align-paper-southeast")
htoolbar.append_to_submenu(ALIGN_PAPER_WEST, "align-paper-west")
htoolbar.append_to_submenu(ALIGN_PAPER_EAST, "align-paper-east")
htoolbar.append_to_submenu(ALIGN_PAPER_CENTER_HORIZONTAL,
"align-paper-center-horizontal")
htoolbar.append_to_submenu(ALIGN_PAPER_CENTER_VERTICAL,
"align-paper-center-vertical")
htoolbar.append_separator()
htoolbar.append(gtk.STOCK_HELP, "help")
hbox = gtk.HBox()
vbox.add(hbox)
vtoolbar = Toolbar()
vtoolbar.set_style(gtk.TOOLBAR_ICONS)
hbox.pack_start(vtoolbar, False, False)
vtoolbar.append(LINE, "line")
vtoolbar.append(ARC, "arc")
vtoolbar.append(CURVE, "curve")
vtoolbar.append(CONNECTOR, "connector")
vtoolbar.append_with_submenu(BOX, "box")
vtoolbar.append_to_submenu(SPLIT_HORIZONTALLY, "split-horizontally")
vtoolbar.append_to_submenu(SPLIT_VERTICALLY, "split-vertically")
vtoolbar.append_to_submenu(REMOVE_SPLIT, "remove-split")
vtoolbar.append(ROUNDED_BOX, "rounded-box")
vtoolbar.append(TEXT, "text")
vtoolbar.append(BARCODE, "barcode")
vtoolbar.append(TABLE, "table")
vtoolbar.append(CHART, "chart")
vtoolbar.append(IMAGE, "image")
notebook = gtk.Notebook()
notebook.set_show_tabs(True)
notebook.set_show_border(False)
#notebook.set_tab_pos(gtk.POS_LEFT)
notebook.set_tab_pos(gtk.POS_RIGHT)
hbox.add(notebook)
self.status = Statusbar()
self.id = self.status.get_context_id(_("Edit mode"))
vbox.pack_start(self.status, False, False)
label = gtk.Label(_("Design view"))
label.set_angle(90)
self.editor = Editor(self)
self.editor.set_paper()
notebook.append_page(self.editor, label)
label = gtk.Label(_("XML view"))
label.set_angle(90)
def get_source_view():
source = gtk.ScrolledWindow()
source.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
view = gtk.TextView()
self.code = gtk.TextBuffer()
view.set_buffer(self.code)
source.add(view)
return source
if '--source-editor-test' in sys.argv:
while True:
try:
from ui.code_editor import SourcePad
except:
source = get_source_view()
break
source = SourcePad(self)
self.code = source.buffer
source.set_language("xml")
break
else:
source = get_source_view()
notebook.append_page(source, label)
self.menu.connect("new", self.new)
self.menu.connect("open", self.open)
self.menu.connect("save", self.save)
self.menu.connect("save-as", self.save_as)
self.menu.connect("page-setup", self.page_setup)
self.menu.connect("export-to-pdf", self.export_to_pdf)
self.menu.connect("set-background", self.set_background)
self.menu.connect("quit", self.quit)
self.menu.connect("cut", self.editor.canvas.cut)
self.menu.connect("copy", self.editor.canvas.copy)
self.menu.connect("paste", self.editor.canvas.paste)
self.menu.connect("delete", self.editor.canvas.delete)
self.menu.connect("select-all", self.editor.canvas.select_all)
self.menu.connect("margins", self.editor.canvas.toggle_margins)
self.menu.connect("grid", self.editor.canvas.toggle_grid)
self.menu.connect("guides", self.editor.canvas.toggle_guides)
self.menu.connect("snap", self.editor.canvas.toggle_snap)
self.menu.connect("hints", self.editor.canvas.toggle_hints)
self.menu.connect("properties", self.editor.toggle_properties)
self.menu.connect("menubar", self.toggle_menubar)
self.menu.connect("statusbar", self.toggle_statusbar)
self.menu.connect("bring-to-front", self.editor.canvas.bring_to_front)
self.menu.connect("bring-to-back", self.editor.canvas.bring_to_back)
self.menu.connect("align-paper-center-horizontal",
self.editor.canvas.paper_center_horizontal)
self.menu.connect("line", self.create, "Line")
self.menu.connect("curve", self.create, "Curve")
self.menu.connect("connector", self.create, "Connector")
self.menu.connect("box", self.create, "Box")
self.menu.connect("rounded-box", self.create, "Rounded")
self.menu.connect("text", self.create, "Text")
self.menu.connect("barcode", self.create, "BarCode")
self.menu.connect("table", self.create, "Table")
self.menu.connect("image", self.create, "Image")
self.menu.connect("chart", self.create, "Chart")
self.menu.connect("fullscreen", self.fullscreen)
self.menu.connect("about", self.about)
self.menu.connect("help", self.help)
self.menu.connect("split-horizontally",
self.editor.canvas.split_horizontally)
self.menu.connect("split-vertically",
self.editor.canvas.split_vertically)
self.menu.connect("remove-split", self.editor.canvas.remove_split)
htoolbar.connect("new", self.new)
htoolbar.connect("open", self.open)
htoolbar.connect("save", self.save)
htoolbar.connect("snap", self.editor.canvas.toggle_snap)
htoolbar.connect("grid", self.editor.canvas.toggle_grid)
htoolbar.connect("guides", self.editor.canvas.toggle_guides)
htoolbar.connect("margins", self.editor.canvas.toggle_margins)
htoolbar.connect("cut", self.editor.canvas.cut)
htoolbar.connect("copy", self.editor.canvas.copy)
htoolbar.connect("paste", self.editor.canvas.paste)
htoolbar.connect("delete", self.editor.canvas.delete)
htoolbar.connect("bring-to-front", self.editor.canvas.bring_to_front)
htoolbar.connect("bring-to-back", self.editor.canvas.bring_to_back)
htoolbar.connect("export-to-pdf", self.export_to_pdf)
htoolbar.connect("help", self.help)
vtoolbar.connect("line", self.create, "Line")
vtoolbar.connect("arc", self.create, "Arc")
vtoolbar.connect("curve", self.create, "Curve")
vtoolbar.connect("connector", self.create, "Connector")
vtoolbar.connect("box", self.create, "Box")
vtoolbar.connect("rounded-box", self.create, "Rounded")
vtoolbar.connect("text", self.create, "Text")
vtoolbar.connect("barcode", self.create, "BarCode")
vtoolbar.connect("table", self.create, "Table")
vtoolbar.connect("image", self.create, "Image")
vtoolbar.connect("chart", self.create, "Chart")
vtoolbar.connect("split-horizontally",
self.editor.canvas.split_horizontally)
vtoolbar.connect("split-vertically",
self.editor.canvas.split_vertically)
vtoolbar.connect("remove-split", self.editor.canvas.remove_split)
notebook.connect("switch-page", self.switch)
self.connect("key-press-event", self.key_press)
def __init__(self):
"""initialise a new puzzle"""
#Set the environment variables and default display settings
self.local_path = os.path.realpath(os.path.dirname(sys.argv[0]))
self.gladefile = os.path.join(self.local_path, 'assets',
"findthatword.glade")
self.show_title = True
self.show_grid = True
self.show_words = True
self.show_solution = True
#Initialise the Glade GUI environment
self.widget_tree = gtk.glade.XML(self.gladefile, "MainWindow")
self.widget_tree.signal_autoconnect(self)
self.main_window = self.widget_tree.get_widget("MainWindow")
#Draw the icon. Unofortunately, not all operating systems can accept SVGs
if os.name == 'posix':
icon_file = os.path.join(self.local_path, 'assets',
"ftw_small.svg")
self.main_window.set_icon_from_file(icon_file)
else:
icon_file = os.path.join(self.local_path, 'assets' "ftw_small.ico")
self.main_window.set_icon_from_file(icon_file)
#Disable printing support on Windows - the GTK page setup dialogue doesn't
#work so the printed puzzle is incorrectly scaled to the page
if os.name == 'nt' or os.name == 'ce':
self.widget_tree.get_widget("PrintIcon").hide()
self.widget_tree.get_widget("FilePageSetupMenuItem").hide()
self.widget_tree.get_widget("FilePrintMenuItem").hide()
self.widget_tree.get_widget("separatormenuitem2").hide()
#Setup the Recent Files menu if the modules are available
recent_widget = self.widget_tree.get_widget("FileRecentMenuItem")
if RECENT_CHOOSER:
recent_manager = gtk.recent_manager_get_default()
recent_chooser = gtk.RecentChooserMenu(recent_manager)
recent_filter = gtk.RecentFilter()
recent_filter.add_pattern("*.ftw")
recent_chooser.add_filter(recent_filter)
recent_chooser.set_show_not_found(False)
recent_chooser.connect("item-activated",
self.on_RecentChooser_activate)
recent_widget.set_submenu(recent_chooser)
else:
recent_widget.hide()
#Create a permanent reference to frequently used widgets
self.new_word_entry_widget = self.widget_tree.get_widget(
"NewWordEntry")
self.new_description_entry_widget = self.widget_tree.get_widget(
"NewDescriptionEntry")
self.words_view_widget = self.widget_tree.get_widget("WordsView")
#Initialise the WordsView widget
for i in range(0, 2):
column = gtk.TreeViewColumn("Word", gtk.CellRendererText(), text=i)
column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
self.words_view_widget.append_column(column)
column.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE)
self.words_list = gtk.ListStore(gobject.TYPE_STRING,
gobject.TYPE_STRING)
self.words_view_widget.set_model(self.words_list)
self.words_view_widget_selection = self.words_view_widget.get_selection(
)
#Manually connect signals where Glade provides no options
self.widget_tree.get_widget("NarrativeEntry").get_buffer().connect(
"changed", self.on_NarrativeWidget_changed)
self.words_view_widget_selection.connect(
'changed', self.on_WordsListWidgetSelection_changed)
#Initialise print settings
self.print_settings = None
self.print_settings = gtk.PrintSettings()
self.page_setup = gtk.PageSetup()
#Create and display a new puzzle
self.dirty = False
#Let's celelebrate being Welsh
if datetime.date.today().month == 3 and datetime.date.today().day == 1:
self.st_davids_day = True
else:
self.st_davids_day = False
self.new_puzzle()
#Find the name of a file passed on the command line
if len(sys.argv) >= 2:
self.load_file(sys.argv[len(sys.argv) - 1], "Filename")
def paperstyle_to_pagesetup(paper_style):
"""Convert a PaperStyle instance into a gtk.PageSetup instance.
@param paper_style: Gramps paper style object to convert
@param type: PaperStyle
@return: page_setup
@rtype: gtk.PageSetup
"""
# paper size names according to 'PWG Candidate Standard 5101.1-2002'
# ftp://ftp.pwg.org/pub/pwg/candidates/cs-pwgmsn10-20020226-5101.1.pdf
gramps_to_gtk = {
"Letter": "na_letter",
"Legal": "na_legal",
"A0": "iso_a0",
"A1": "iso_a1",
"A2": "iso_a2",
"A3": "iso_a3",
"A4": "iso_a4",
"A5": "iso_a5",
"B0": "iso_b0",
"B1": "iso_b1",
"B2": "iso_b2",
"B3": "iso_b3",
"B4": "iso_b4",
"B5": "iso_b5",
"B6": "iso_b6",
"B": "na_ledger",
"C": "na_c",
"D": "na_d",
"E": "na_e",
}
# First set the paper size
gramps_paper_size = paper_style.get_size()
gramps_paper_name = gramps_paper_size.get_name()
# All sizes not included in the translation table (even if a standard size)
# are handled as custom format, because we are not intelligent enough.
if gramps_paper_name in gramps_to_gtk:
paper_size = gtk.PaperSize(gramps_to_gtk[gramps_paper_name])
log.debug("Selected paper size: %s" % gramps_to_gtk[gramps_paper_name])
else:
if paper_style.get_orientation() == PAPER_PORTRAIT:
paper_width = gramps_paper_size.get_width() * 10
paper_height = gramps_paper_size.get_height() * 10
else:
paper_width = gramps_paper_size.get_height() * 10
paper_height = gramps_paper_size.get_width() * 10
paper_size = gtk.paper_size_new_custom("custom", "Custom Size",
paper_width, paper_height,
gtk.UNIT_MM)
log.debug("Selected paper size: (%f,%f)" % (paper_width, paper_height))
page_setup = gtk.PageSetup()
page_setup.set_paper_size(paper_size)
# Set paper orientation
if paper_style.get_orientation() == PAPER_PORTRAIT:
page_setup.set_orientation(gtk.PAGE_ORIENTATION_PORTRAIT)
else:
page_setup.set_orientation(gtk.PAGE_ORIENTATION_LANDSCAPE)
# Set paper margins
page_setup.set_top_margin(paper_style.get_top_margin() * 10, gtk.UNIT_MM)
page_setup.set_bottom_margin(paper_style.get_bottom_margin() * 10,
gtk.UNIT_MM)
page_setup.set_left_margin(paper_style.get_left_margin() * 10, gtk.UNIT_MM)
page_setup.set_right_margin(paper_style.get_right_margin() * 10,
gtk.UNIT_MM)
return page_setup
def gtk_default_page_setup():
pset = gtk.PageSetup()
pset.set_paper_size(gtk.PaperSize())
return pset
def __init__(self):
gobject.GObject.__init__(self)
self.builder = get_builder("setting")
self.window = self.builder.get_object("window1")
self.filechooser = self.builder.get_object("filechooser")
self.filename = self.builder.get_object("filename")
self.treeview = self.builder.get_object("databases-table")
self.treeview.set_direction(gtk.TEXT_DIR_LTR)
self.liststore = gtk.ListStore(gobject.TYPE_BOOLEAN, str, str)
if gtk.widget_get_default_direction() == gtk.TEXT_DIR_RTL :
halign = 1
else:
halign = 0
crtoggle = gtk.CellRendererToggle()
crtoggle.set_radio(True)
# crtoggle.set_activatable(True)
crtoggle.connect('toggled', self.changeCurrentDb, 0)
column = gtk.TreeViewColumn(_("Current"), crtoggle, active=0)
column.set_alignment(halign)
column.set_spacing(5)
column.set_resizable(True)
self.treeview.append_column(column)
column = gtk.TreeViewColumn(_("Name"), gtk.CellRendererText(), text=1)
column.set_alignment(halign)
column.set_spacing(5)
column.set_resizable(True)
self.treeview.append_column(column)
column = gtk.TreeViewColumn(_("Path"), gtk.CellRendererText(), text=2)
column.set_alignment(halign)
column.set_spacing(5)
column.set_resizable(True)
self.treeview.append_column(column)
self.treeview.set_model(self.liststore)
i = 0
for dbpath in config.dblist:
if i == config.currentdb - 1:
self.active_iter = self.liststore.append((True, config.dbnames[i], dbpath))
else:
self.liststore.append((False, config.dbnames[i], dbpath))
i += 1
# self.olddb = self.builder.get_object("olddb")
# self.newdb = self.builder.get_object("newdb")
self.infolabel = self.builder.get_object("infolabel")
self.infolabel.set_text(config.db.dbfile)
self.langlist = self.builder.get_object("language")
comboInsertItems(self.langlist, config.langlist)
self.langlist.set_active(config.localelist.index(config.locale))
self.dateformat = self.builder.get_object("dateformat")
comboInsertItems(self.dateformat, config.datetypes)
self.dateformat.set_active(config.datetype)
self.delimiter = self.builder.get_object("delimiter")
comboInsertItems(self.delimiter, config.datedelims)
self.delimiter.set_active(config.datedelim)
self.dateorder = self.builder.get_object("dateorder")
comboInsertItems(self.dateorder, [])
for order in config.dateorders:
self.dateorder.append_text(order[0] + " - " + order[1] + " - " + order[2])
self.dateorder.set_active(config.dateorder)
self.uselatin = self.builder.get_object("uselatin")
if config.digittype == 0:
self.uselatin.set_active(True)
else:
self.uselatin.set_active(False)
self.repair_atstart = self.builder.get_object("repair_atstart")
self.repair_atstart.set_active(config.repair_atstart)
self.builder.get_object("topmargin").set_value(config.topmargin)
self.builder.get_object("botmargin").set_value(config.botmargin)
self.builder.get_object("rightmargin").set_value(config.rightmargin)
self.builder.get_object("leftmargin").set_value(config.leftmargin)
self.builder.get_object("namefont").set_value(config.namefont)
self.builder.get_object("headerfont").set_value(config.headerfont)
self.builder.get_object("contentfont").set_value(config.contentfont)
self.builder.get_object("footerfont").set_value(config.footerfont)
paper_size = gtk.paper_size_new_from_ppd(config.paper_ppd, config.paper_name, config.paper_width, config.paper_height)
self.page_setup = gtk.PageSetup()
self.page_setup.set_paper_size(paper_size)
self.page_setup.set_orientation(config.paper_orientation)
self.builder.get_object("papersize").set_text(config.paper_name)
self.window.show_all()
self.builder.connect_signals(self)
