def finish_initializing(self, builder): # pylint: disable=E1002
"""Set up the main window"""
super(UberwriterWindow, self).finish_initializing(builder)
self.AboutDialog = AboutUberwriterDialog
self.UberwriterAdvancedExportDialog = UberwriterAdvancedExportDialog
self.builder = builder
# Code for other initialization actions should be added here.
# Texlive checker
self.texlive_installed = False
self.set_name('UberwriterWindow')
self.title_end = " – UberWriter"
self.set_title("New File" + self.title_end)
# Drag and drop
self.drag_dest_set(Gtk.DestDefaults.ALL, [], Gdk.DragAction.COPY)
self.target_list = Gtk.TargetList.new([])
self.target_list.add_uri_targets(1)
self.target_list.add_text_targets(2)
self.drag_dest_set_target_list(self.target_list)
self.focusmode = False
self.word_count = builder.get_object('word_count')
self.char_count = builder.get_object('char_count')
self.menubar = builder.get_object('menubar1')
# Wire up buttons
self.fullscreen_button = builder.get_object('fullscreen_toggle')
self.focusmode_button = builder.get_object('focus_toggle')
self.preview_button = builder.get_object('preview_toggle')
self.fullscreen_button.set_name('fullscreen_toggle')
self.focusmode_button.set_name('focus_toggle')
self.preview_button.set_name('preview_toggle')
# Setup status bar hide after 3 seconds
self.status_bar = builder.get_object('status_bar_box')
self.status_bar.set_name('status_bar_box')
self.status_bar_visible = True
self.was_motion = True
self.buffer_modified_for_status_bar = False
self.connect("motion-notify-event", self.on_motion_notify)
GObject.timeout_add(3000, self.poll_for_motion)
self.accel_group = Gtk.AccelGroup()
self.add_accel_group(self.accel_group)
# Setup light background
self.TextEditor = TextEditor()
base_leftmargin = 100
self.TextEditor.set_left_margin(base_leftmargin)
self.TextEditor.set_left_margin(40)
self.TextEditor.set_wrap_mode(Gtk.WrapMode.WORD)
self.TextEditor.show()
self.ScrolledWindow = builder.get_object('editor_scrolledwindow')
self.ScrolledWindow.add(self.TextEditor)
# Draw background
self.background_image = helpers.get_media_path('bg_light.png')
self.ScrolledWindow.connect('draw', self.draw_bg)
surface = cairo.ImageSurface.create_from_png(self.background_image)
self.background_pattern = cairo.SurfacePattern(surface)
self.background_pattern.set_extend(cairo.EXTEND_REPEAT)
self.PreviewPane = builder.get_object('preview_scrolledwindow')
pangoFont = Pango.FontDescription("Ubuntu Mono 15px")
# self.scw = builder.get_object('scrolledwindow1')
# self.scw.add(self.sidebar.get_treeview())
# http://nullege.com/codes/show/src%40c%40o%40comix-HEAD%40trunk%40src%40labels.py/31/gtk.Label.set_attributes/python
# ## TODO
# attr_list = Pango.AttrList.new()
# attr_list.insert(Pango.Attribute.LetterSpacing.new(100))
# self.TextEditor.set_attributes(attr_list)
self.TextEditor.modify_font(pangoFont)
self.TextEditor.set_margin_top(38)
self.TextEditor.set_margin_bottom(16)
self.TextEditor.set_pixels_above_lines(4)
self.TextEditor.set_pixels_below_lines(4)
self.TextEditor.set_pixels_inside_wrap(8)
tab_array = Pango.TabArray.new(1, True)
tab_array.set_tab(0, Pango.TabAlign.LEFT, 20)
self.TextEditor.set_tabs(tab_array)
self.TextBuffer = self.TextEditor.get_buffer()
self.TextBuffer.set_text('')
# Init Window height for top/bottom padding
self.window_height = self.get_size()[1]
self.text_change_event = self.TextBuffer.connect('changed', self.text_changed)
self.TextEditor.connect('move-cursor', self.cursor_moved)
# Init file name with None
self.filename = None
self.generate_recent_files_menu(self.builder.get_object('recent'))
self.style_provider = Gtk.CssProvider()
css = open(helpers.get_media_path('style.css'), 'rb')
css_data = css.read()
css.close()
self.style_provider.load_from_data(css_data)
Gtk.StyleContext.add_provider_for_screen(
Gdk.Screen.get_default(), self.style_provider,
Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION
)
# Still needed.
self.fflines = 0
# Markup and Shortcuts for the TextBuffer
self.MarkupBuffer = MarkupBuffer(self, self.TextBuffer, base_leftmargin)
self.MarkupBuffer.markup_buffer()
self.FormatShortcuts = FormatShortcuts(self.TextBuffer, self.TextEditor)
# Scrolling -> Dark or not?
self.textchange = False
self.scroll_count = 0
self.TextBuffer.connect('mark-set', self.mark_set)
self.TextEditor.drag_dest_unset()
# Events to preserve margin. (To be deleted.)
self.TextEditor.connect('delete-from-cursor', self.delete_from_cursor)
self.TextEditor.connect('backspace', self.backspace)
self.TextBuffer.connect('paste-done', self.paste_done)
# self.connect('key-press-event', self.alt_mod)
# Events for Typewriter mode
self.TextBuffer.connect_after('mark-set', self.after_mark_set)
self.TextBuffer.connect_after('changed', self.after_modify_text)
self.TextEditor.connect_after('move-cursor', self.after_cursor_moved)
self.TextEditor.connect_after('insert-at-cursor', self.after_insert_at_cursor)
# Setting up inline preview
self.InlinePreview = UberwriterInlinePreview(self.TextEditor, self.TextBuffer)
# Vertical scrolling
self.vadjustment = self.TextEditor.get_vadjustment()
self.vadjustment.connect('value-changed', self.scrolled)
# Setting up spellcheck
try:
self.SpellChecker = SpellChecker(self.TextEditor,
locale.getdefaultlocale()[0], collapse=False)
self.spellcheck = True
except:
self.SpellChecker = None
self.spellcheck = False
builder.get_object("disable_spellcheck").set_active(False)
if self.spellcheck:
self.SpellChecker.append_filter('[#*]+', SpellChecker.FILTER_WORD)
self.did_change = False
###
# Sidebar initialization test
###
self.paned_window = builder.get_object("main_pained")
self.sidebar_box = builder.get_object("sidebar_box")
self.sidebar = UberwriterSidebar(self)
###
# Search and replace initialization
# Same interface as Sidebar ;)
###
self.searchreplace = UberwriterSearchAndReplace(self)
# Window resize
self.connect("configure-event", self.window_resize)
self.connect("delete-event", self.on_delete_called)
self.load_settings(builder)
def finish_initializing(self, builder): # pylint: disable=E1002
"""Set up the main window"""
super(UberwriterWindow, self).finish_initializing(builder)
self.UberwriterAdvancedExportDialog = UberwriterAdvancedExportDialog
self.builder = builder
self.connect('save-file', self.save_document)
self.connect('save-file-as', self.save_document_as)
self.connect('new-file', self.new_document)
self.connect('open-file', self.open_document)
self.connect('toggle-fullscreen', self.menu_activate_fullscreen)
self.connect('toggle-focusmode', self.menu_activate_focusmode)
#self.connect('toggle-preview', self.menu_activate_preview)
self.connect('toggle-spellcheck', self.toggle_spellcheck)
self.connect('close-window', self.on_mnu_close_activate)
self.connect('toggle-search', self.open_search_and_replace)
self.scroll_adjusted = False
# Code for other initialization actions should be added here.
# Texlive checker
self.texlive_installed = False
self.set_name('UberwriterWindow')
self.use_headerbar = True
if self.use_headerbar == True:
self.hb_container = Gtk.Frame(name='titlebar_container')
self.hb_container.set_shadow_type(Gtk.ShadowType.NONE)
self.hb_revealer = Gtk.Revealer(name='titlebar_revealer')
self.hb = Gtk.HeaderBar()
self.hb_revealer.add(self.hb)
self.hb_revealer.props.transition_duration = 1000
self.hb_revealer.props.transition_type = Gtk.RevealerTransitionType.CROSSFADE
self.hb.props.show_close_button = True
self.hb.get_style_context().add_class("titlebar")
self.hb_container.add(self.hb_revealer)
self.hb_container.show()
self.set_titlebar(self.hb_container)
self.hb_revealer.show()
self.hb_revealer.set_reveal_child(True)
self.hb.show()
bbtn = Gtk.MenuButton()
btn_settings = Gtk.MenuButton()
btn_settings.props.image = Gtk.Image.new_from_icon_name('emblem-system-symbolic', Gtk.IconSize.BUTTON)
self.builder.get_object("menu4").detach()
btn_settings.set_popup(self.builder.get_object("menu4"))
self.builder.get_object("menu1").detach()
bbtn.set_popup(self.builder.get_object("menu1"))
self.hb.pack_start(bbtn)
self.hb.pack_end(btn_settings)
self.hb.show_all()
self.testbits = Gdk.WindowState.MAXIMIZED
#self.connect('draw', self.override_headerbar_background)
self.title_end = " – UberWriter"
self.set_headerbar_title("New File" + self.title_end)
self.focusmode = False
self.word_count = builder.get_object('word_count')
self.char_count = builder.get_object('char_count')
self.menubar = builder.get_object('menubar1')
self.menubar.hide()
# Wire up buttons
self.fullscreen_button = builder.get_object('fullscreen_toggle')
self.fullscreen_menu_button = builder.get_object('mnu_fullscreen')
self.focusmode_button = builder.get_object('focus_toggle')
self.focusmode_menu_button = builder.get_object('mnu_focusmode')
self.preview_button = builder.get_object('preview_toggle')
self.preview_mnu_button = builder.get_object('mnu_preview')
self.fullscreen_button.set_name('fullscreen_toggle')
self.focusmode_button.set_name('focus_toggle')
self.preview_button.set_name('preview_toggle')
# Setup status bar hide after 3 seconds
self.status_bar = builder.get_object('status_bar_box')
self.statusbar_revealer = builder.get_object('status_bar_revealer')
self.status_bar.get_style_context().add_class('status_bar_box')
self.status_bar_visible = True
self.was_motion = True
self.buffer_modified_for_status_bar = False
self.connect("motion-notify-event", self.on_motion_notify)
GObject.timeout_add(3000, self.poll_for_motion)
self.accel_group = Gtk.AccelGroup()
self.add_accel_group(self.accel_group)
# Setup light background
self.TextEditor = TextEditor()
self.TextEditor.set_name('UberwriterEditor')
self.get_style_context().add_class('uberwriter_window')
base_leftmargin = 100
self.TextEditor.set_left_margin(base_leftmargin)
self.TextEditor.set_left_margin(40)
self.TextEditor.set_top_margin(80)
self.TextEditor.props.width_request = 600
self.TextEditor.props.halign = Gtk.Align.CENTER
self.TextEditor.set_vadjustment(builder.get_object('vadjustment1'))
self.TextEditor.set_wrap_mode(Gtk.WrapMode.WORD_CHAR)
self.TextEditor.connect('focus-out-event', self.focus_out)
self.TextEditor.get_style_context().connect('changed', self.style_changed)
# self.TextEditor.install_style_property_parser
self.TextEditor.show()
self.TextEditor.grab_focus()
self.EditorAlignment = builder.get_object('editor_alignment')
self.ScrolledWindow = builder.get_object('editor_scrolledwindow')
self.ScrolledWindow.props.width_request = 600
self.ScrolledWindow.add(self.TextEditor)
self.alignment_padding = 40
self.EditorViewport = builder.get_object('editor_viewport')
self.ScrolledWindow.connect_after("draw", self.draw_gradient)
self.smooth_scroll_starttime = 0
self.smooth_scroll_endtime = 0
self.smooth_scroll_acttarget = 0
self.smooth_scroll_data = {
'target_pos': -1,
'source_pos': -1,
'duration': 0
}
self.smooth_scroll_tickid = -1
self.PreviewPane = builder.get_object('preview_scrolledwindow')
self.TextEditor.set_top_margin(80)
self.TextEditor.set_bottom_margin(16)
self.TextEditor.set_pixels_above_lines(4)
self.TextEditor.set_pixels_below_lines(4)
self.TextEditor.set_pixels_inside_wrap(8)
tab_array = Pango.TabArray.new(1, True)
tab_array.set_tab(0, Pango.TabAlign.LEFT, 20)
self.TextEditor.set_tabs(tab_array)
self.TextBuffer = self.TextEditor.get_buffer()
self.TextBuffer.set_text('')
# Init Window height for top/bottom padding
self.window_height = self.get_size()[1]
self.text_change_event = self.TextBuffer.connect('changed', self.text_changed)
# Init file name with None
self.filename = None
self.generate_recent_files_menu(self.builder.get_object('recent'))
self.style_provider = Gtk.CssProvider()
self.style_provider.load_from_path(helpers.get_media_path('style.css'))
Gtk.StyleContext.add_provider_for_screen(
Gdk.Screen.get_default(), self.style_provider,
Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION
)
# Markup and Shortcuts for the TextBuffer
self.MarkupBuffer = MarkupBuffer(self, self.TextBuffer, base_leftmargin)
self.MarkupBuffer.markup_buffer()
# Scrolling -> Dark or not?
self.textchange = False
self.scroll_count = 0
self.timestamp_last_mouse_motion = 0
self.TextBuffer.connect_after('mark-set', self.mark_set)
# Drag and drop
# self.TextEditor.drag_dest_unset()
# self.TextEditor.drag_dest_set(Gtk.DestDefaults.ALL, [], Gdk.DragAction.COPY)
self.target_list = Gtk.TargetList.new([])
self.target_list.add_uri_targets(1)
self.target_list.add_text_targets(2)
self.TextEditor.drag_dest_set_target_list(self.target_list)
self.TextEditor.connect_after('drag-data-received', self.on_drag_data_received)
def on_drop(widget, *args):
print("drop")
self.TextEditor.connect('drag-drop', on_drop)
self.TextBuffer.connect('paste-done', self.paste_done)
# self.connect('key-press-event', self.alt_mod)
# Events for Typewriter mode
# Setting up inline preview
self.InlinePreview = UberwriterInlinePreview(self.TextEditor, self.TextBuffer)
# Vertical scrolling
self.vadjustment = self.ScrolledWindow.get_vadjustment()
self.vadjustment.connect('value-changed', self.scrolled)
self.spellcheck_button = builder.get_object("disable_spellcheck")
# Setting up spellcheck
self.auto_correct = None
try:
self.SpellChecker = SpellChecker(self.TextEditor,
locale.getdefaultlocale()[0], collapse=False)
if self.auto_correct:
self.auto_correct.set_language(self.SpellChecker.language)
self.SpellChecker.connect_language_change(self.auto_correct.set_language)
self.spellcheck = True
except:
self.SpellChecker = None
self.spellcheck = False
builder.get_object("disable_spellcheck").set_active(False)
if self.spellcheck:
self.SpellChecker.append_filter('[#*]+', SpellChecker.FILTER_WORD)
self.did_change = False
###
# Sidebar initialization test
###
self.paned_window = builder.get_object("main_pained")
self.sidebar_box = builder.get_object("sidebar_box")
self.sidebar = UberwriterSidebar(self)
self.sidebar_box.hide()
###
# Search and replace initialization
# Same interface as Sidebar ;)
###
self.searchreplace = UberwriterSearchAndReplace(self)
# Window resize
self.window_resize(self)
self.connect("configure-event", self.window_resize)
self.connect("delete-event", self.on_delete_called)
self.gtk_settings = Gtk.Settings.get_default()
self.load_settings(builder)
def do_activate(self):
if self.window:
self.window.present()
return
self.window = Gtk.ApplicationWindow(application=self, title="Tryton")
self.window.set_default_size(960, 720)
self.window.maximize()
self.window.set_position(Gtk.WIN_POS_CENTER)
self.window.set_resizable(True)
self.window.set_icon(TRYTON_ICON)
self.window.connect("destroy", self.on_quit)
self.window.connect("delete_event", self.on_quit)
self.header = Gtk.HeaderBar.new()
self.header.set_show_close_button(True)
self.window.set_titlebar(self.header)
self.set_title()
menu = Gtk.Button.new()
menu.set_relief(Gtk.ReliefStyle.NONE)
menu.set_image(
common.IconFactory.get_image('tryton-menu', Gtk.IconSize.BUTTON))
menu.connect('clicked', self.menu_toggle)
self.header.pack_start(menu)
favorite = Gtk.MenuButton.new()
favorite.set_relief(Gtk.ReliefStyle.NONE)
favorite.set_image(
common.IconFactory.get_image('tryton-bookmarks',
Gtk.IconSize.BUTTON))
self.menu_favorite = Gtk.Menu.new()
favorite.set_popup(self.menu_favorite)
favorite.connect('clicked', self.favorite_set)
self.header.pack_start(favorite)
self.set_global_search()
self.header.pack_start(self.global_search_entry)
self.accel_group = Gtk.AccelGroup()
self.window.add_accel_group(self.accel_group)
gtk.accel_map_add_entry('<tryton>/Form/New', gtk.keysyms.N,
gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry('<tryton>/Form/Save', gtk.keysyms.S,
gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry('<tryton>/Form/Duplicate', gtk.keysyms.D,
gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK)
gtk.accel_map_add_entry('<tryton>/Form/Delete', gtk.keysyms.D,
gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry('<tryton>/Form/Next', gtk.keysyms.Page_Down, 0)
gtk.accel_map_add_entry('<tryton>/Form/Previous', gtk.keysyms.Page_Up,
0)
gtk.accel_map_add_entry('<tryton>/Form/Switch View', gtk.keysyms.L,
gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry('<tryton>/Form/Close', gtk.keysyms.W,
gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry('<tryton>/Form/Reload', gtk.keysyms.R,
gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry('<tryton>/Form/Attachments', gtk.keysyms.T,
gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK)
gtk.accel_map_add_entry('<tryton>/Form/Notes', gtk.keysyms.O,
gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK)
gtk.accel_map_add_entry('<tryton>/Form/Relate', gtk.keysyms.R,
gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK)
gtk.accel_map_add_entry('<tryton>/Form/Actions', gtk.keysyms.E,
gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry('<tryton>/Form/Report', gtk.keysyms.P,
gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry('<tryton>/Form/Search', gtk.keysyms.F,
gtk.gdk.CONTROL_MASK)
gtk.accel_map_load(os.path.join(get_config_dir(), 'accel.map'))
self.tooltips = common.Tooltips()
self.vbox = gtk.VBox()
self.window.add(self.vbox)
self.buttons = {}
self.info = gtk.VBox()
self.vbox.pack_start(self.info, expand=False)
if CONFIG['client.check_version']:
common.check_version(self.info)
GLib.timeout_add_seconds(int(CONFIG['download.frequency']),
common.check_version, self.info)
self.pane = gtk.HPaned()
self.vbox.pack_start(self.pane, True, True)
self.pane.set_position(int(CONFIG['menu.pane']))
self.menu_screen = None
self.menu = gtk.VBox()
self.menu.set_vexpand(True)
self.pane.add1(self.menu)
self.notebook = gtk.Notebook()
self.notebook.popup_enable()
self.notebook.set_scrollable(True)
self.notebook.connect_after('switch-page', self._sig_page_changt)
self.pane.add2(self.notebook)
self.window.show_all()
self.pages = []
self.previous_pages = {}
self.current_page = 0
self.last_page = 0
self.dialogs = []
self._global_run = False
self._global_check_timeout_id = None
self._global_update_timeout_id = None
# Register plugins
tryton.plugins.register()
self.set_title() # Adds username/profile while password is asked
try:
common.Login()
except Exception as exception:
if (not isinstance(exception, TrytonError)
or exception.faultCode != 'QueryCanceled'):
common.error(str(exception), traceback.format_exc())
return self.quit()
self.get_preferences()
def __init__(self, filename, ui='transcribe.ui', *args):
builder = Gtk.Builder()
builder.add_from_file(os.path.join(os.path.dirname(__file__), ui))
self.accelerators = Gtk.AccelGroup()
self.window = builder.get_object('window')
self.window.add_accel_group(self.accelerators)
sw = builder.get_object('scrolledwindow')
self.textbuffer = GtkSource.Buffer()
self.lm = GtkSource.LanguageManager()
path = self.lm.get_search_path()
path.insert(0, os.path.join(os.path.dirname(__file__)))
self.lm.set_search_path(path)
self.textbuffer.set_language(self.lm.get_language('transcribe'))
self.sourceview = GtkSource.View.new_with_buffer(self.textbuffer)
self.sourceview.set_wrap_mode(Gtk.WrapMode.WORD_CHAR)
self.sourceview.set_show_line_marks(True)
self.sourceview.set_pixels_below_lines(self.SPACE_BELOW_LINES)
sw.add(self.sourceview)
self.play_button = builder.get_object('play_button')
self.label_time = builder.get_object('label_time')
self.label_duration = builder.get_object('label_duration')
self.audio_slider = builder.get_object('audio_slider')
#self.audio_slider.set_range(0, 100)
self.audio_slider.set_increments(self.AUDIO_STEP, self.AUDIO_PAGE)
box_speed = builder.get_object('box_speed')
self.speed_slider = Gtk.Scale(orientation=Gtk.Orientation.HORIZONTAL)
# self.speed_slider = builder.get_object('speed_slider')
self.speed_slider.set_digits(2)
self.speed_slider.set_range(0.10, 3)
self.speed_slider.set_increments(self.SPEED_STEP, self.SPEED_PAGE)
self.speed_slider.set_value(1.00)
self.speed_slider.add_mark(1.00, Gtk.PositionType.BOTTOM, None)
self.speed_slider.connect('value-changed', self.on_speed_slider_change)
self.speed_slider.connect('grab-focus',
self.on_speed_slider_grab_focus)
box_speed.pack_start(self.speed_slider, True, True, 0)
self.sourceview.connect("event-after", self.on_view_event_after)
self.window.add_events(Gdk.EventType.KEY_PRESS
| Gdk.EventType.KEY_RELEASE)
self.window.connect('key-press-event', self.on_window_key_press)
self.add_accelerator(self.play_button, '<ctrl>p', 'clicked')
self.add_accelerator(self.play_button, '<ctrl>space', 'clicked')
self.add_accelerator(self.play_button, 'F5', 'clicked')
self.add_accelerator(self.speed_slider, '<alt>s', 'grab-focus')
self.add_accelerator(self.audio_slider, '<alt>a', 'grab-focus')
self.add_accelerator(self.sourceview, '<alt>t', 'grab-focus')
builder.connect_signals(self)
title = '%s - %s' % (self.APP_NAME, os.path.basename(filename))
self.window.set_title(title)
self.audio = pipeline.Audio(filename)
self.audio.connect('update-duration', self.on_audio_duration)
self.audio.connect('finished', self.on_audio_finished)
def __init__(self, application):
self.application = application
self.settings = Gio.Settings("com.linuxmint.report")
os.system("mkdir -p %s" % TMP_DIR)
os.system("rm -rf %s/*" % TMP_DIR)
os.system("mkdir -p %s" % UNPACK_DIR)
os.system("cp -R %s/* %s/" % (DATA_DIR, TMP_DIR))
self.cache = apt.Cache()
# Set the Glade file
gladefile = "/usr/share/linuxmint/mintreport/mintreport.ui"
self.builder = Gtk.Builder()
self.builder.set_translation_domain(APP)
self.builder.add_from_file(gladefile)
self.window = self.builder.get_object("main_window")
self.window.set_title(_("System Reports"))
self.window.set_icon_name("mintreport")
self.stack = self.builder.get_object("crash_stack")
self.spinner = self.builder.get_object("crash_spinner")
# Fill in the sysinfo pane
self.load_sysinfo()
self.builder.get_object("button_sysinfo_copy").connect("clicked", self.copy_sysinfo)
self.builder.get_object("button_sysinfo_upload").connect("clicked", self.upload_sysinfo)
# the crashes treeview
self.treeview_crashes = self.builder.get_object("treeview_crashes")
def render_date(column, cell, model, i, *args):
cell.props.text = " ".join([model[i][COL_CRASH_DAY],
model[i][COL_CRASH_DATE],
model[i][COL_CRASH_TIME],
model[i][COL_CRASH_TIMEZONE]])
def sort_by_date(model, a, b, *args):
date_a = datetime.date.from_iso_format(model[a][COL_CRASH_DATE])
date_b = datetime.date.from_iso_format(model[b][COL_CRASH_DATE])
if date_a < date_b:
return -1
elif date_a > date_b:
return 1
time_a = datetime.time.fromisoformat(model[a][COL_CRASH_TIME])
time_b = datetime.time.fromisoformat(model[b][COL_CRASH_TIME])
if time_a < time_b:
return -1
elif time_a > time_b:
return 1
return 0
cell_renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn('', cell_renderer)
column.set_cell_data_func(cell_renderer, render_date)
column.set_resizable(True)
self.treeview_crashes.append_column(column)
column = Gtk.TreeViewColumn("", Gtk.CellRendererText(), text=COL_CRASH_PID)
column.set_sort_column_id(COL_CRASH_PID)
column.set_resizable(True)
self.treeview_crashes.append_column(column)
column = Gtk.TreeViewColumn("", Gtk.CellRendererText(), text=COL_CRASH_EXE)
column.set_sort_column_id(COL_CRASH_EXE)
column.set_resizable(True)
self.treeview_crashes.append_column(column)
self.treeview_crashes.show()
self.model_crashes = Gtk.ListStore(str, str, str, str, str, str, object) # timestamp, pid, exe, object
self.model_sort = self.model_crashes.sort_new_with_model()
self.model_sort.set_sort_func(COL_CRASH_DATE, sort_by_date)
self.treeview_crashes.set_model(self.model_crashes)
self.buffer = GtkSource.Buffer()
self.language_manager = GtkSource.LanguageManager()
style_manager = GtkSource.StyleSchemeManager()
self.buffer.set_style_scheme(style_manager.get_scheme("oblivion"))
self.sourceview = GtkSource.View.new_with_buffer(self.buffer)
self.builder.get_object("scrolledwindow_crash").add(self.sourceview)
self.sourceview.show()
self.treeview_crashes.get_selection().connect("changed", self.on_crash_selected)
self.bugtracker = "https://bugs.launchpad.net/"
self.localfiles_button = self.builder.get_object("button_browse_crash_report")
self.bugtracker_button = self.builder.get_object("button_open_bugtracker")
self.pastebin_button = self.builder.get_object("button_pastebin")
self.localfiles_button.connect("clicked", self.on_button_browse_crash_report_clicked)
self.bugtracker_button.connect("clicked", self.on_button_open_bugtracker_clicked)
self.pastebin_button.connect("clicked", self.on_button_pastebin_clicked)
# the info treeview
self.info_button_box = self.builder.get_object("info_button_box")
self.info_descriptions_box = self.builder.get_object("info_descriptions_box")
self.treeview_info = self.builder.get_object("treeview_info")
renderer = Gtk.CellRendererPixbuf()
column = Gtk.TreeViewColumn("", renderer, icon_name=COL_INFO_ICON)
self.treeview_info.append_column(column)
column = Gtk.TreeViewColumn("", Gtk.CellRendererText(), text=COL_INFO_TITLE)
column.set_sort_column_id(COL_INFO_TITLE)
column.set_resizable(True)
self.treeview_info.append_column(column)
self.treeview_info.show()
self.model_info = Gtk.TreeStore(str, str, object) # icon, name, report
self.model_info.set_sort_column_id(COL_INFO_TITLE, Gtk.SortType.ASCENDING)
self.treeview_info.set_model(self.model_info)
self.treeview_info.get_selection().connect("changed", self.on_info_selected)
if os.path.exists("/usr/bin/coredumpctl"):
self.builder.get_object("crash_internal_stack").set_visible_child_name("page_reports")
self.load_crashes()
else:
self.builder.get_object("crash_internal_stack").set_visible_child_name("page_error")
self.load_info()
accel_group = Gtk.AccelGroup()
self.window.add_accel_group(accel_group)
# Menubar
menubar = self.builder.get_object("menubar")
menu = Gtk.MenuItem.new_with_mnemonic(_("_File"))
menubar.append(menu)
submenu = Gtk.Menu()
menu.set_submenu(submenu)
item = Gtk.ImageMenuItem.new_with_label(_("Refresh"))
image = Gtk.Image.new_from_icon_name("view-refresh-symbolic", Gtk.IconSize.MENU)
item.set_image(image)
item.connect('activate', self.on_menu_refresh)
key, mod = Gtk.accelerator_parse("<Control>R")
item.add_accelerator("activate", accel_group, key, mod, Gtk.AccelFlags.VISIBLE)
submenu.append(item)
item = Gtk.ImageMenuItem.new_with_label(_("Restore ignored reports"))
item.connect('activate', self.on_menu_restore)
submenu.append(item)
submenu.append(Gtk.SeparatorMenuItem())
item = Gtk.ImageMenuItem.new_with_label(_("Quit"))
image = Gtk.Image.new_from_icon_name("application-exit-symbolic", Gtk.IconSize.MENU)
item.set_image(image)
item.connect('activate', self.on_menu_quit)
key, mod = Gtk.accelerator_parse("<Control>Q")
item.add_accelerator("activate", accel_group, key, mod, Gtk.AccelFlags.VISIBLE)
key, mod = Gtk.accelerator_parse("<Control>W")
item.add_accelerator("activate", accel_group, key, mod, Gtk.AccelFlags.VISIBLE)
submenu.append(item)
menubar.show_all()
menu = Gtk.MenuItem.new_with_mnemonic(_("_Help"))
menubar.append(menu)
submenu = Gtk.Menu()
menu.set_submenu(submenu)
item = Gtk.ImageMenuItem()
item.set_image(Gtk.Image.new_from_icon_name("help-about-symbolic", Gtk.IconSize.MENU))
item.set_label(_("About"))
item.connect("activate", self.open_about)
submenu.append(item)
def __init__(self, library):
super(CollectionBrowser, self).__init__(spacing=6)
self.set_orientation(Gtk.Orientation.VERTICAL)
self._register_instance()
if self.__model is None:
self._init_model(library)
sw = ScrolledWindow()
sw.set_shadow_type(Gtk.ShadowType.IN)
self.view = view = CollectionView()
view.set_headers_visible(False)
model_sort = CollectionSortModel(model=self.__model)
model_filter = CollectionFilterModel(child_model=model_sort)
self.__filter = None
self.__bg_filter = background_filter()
model_filter.set_visible_func(self.__parse_query)
view.set_model(model_filter)
def cmpa(a, b):
"""Like cmp but treats values that evaluate to false as inf"""
if not a and b:
return 1
if not b and a:
return -1
return cmp(a, b)
def cmp_rows(model, i1, i2, data):
t1, t2 = model[i1][0], model[i2][0]
pos1 = _ORDERING.get(t1, 0)
pos2 = _ORDERING.get(t2, 0)
if pos1 or pos2:
return cmp(pos1, pos2)
if not isinstance(t1, AlbumNode):
return cmp(util.human_sort_key(t1), util.human_sort_key(t2))
a1, a2 = t1.album, t2.album
return (cmpa(a1.peoplesort, a2.peoplesort)
or cmpa(a1.date, a2.date) or cmpa(a1.sort, a2.sort)
or cmp(a1.key, a2.key))
model_sort.set_sort_func(0, cmp_rows)
model_sort.set_sort_column_id(0, Gtk.SortType.ASCENDING)
column = Gtk.TreeViewColumn("albums")
def cell_data(column, cell, model, iter_, data):
markup = model.get_markup(self.__model.tags, iter_)
cell.markup = markup
cell.set_property('markup', markup)
def get_scaled_cover(item):
if item.scanned:
return item.cover
scale_factor = self.get_scale_factor()
item.scan_cover(scale_factor=scale_factor)
return item.cover
def cell_data_pb(column, cell, model, iter_, data):
album = model.get_album(iter_)
if album is None:
cell.set_property('icon-name', Icons.FOLDER)
else:
item = model.get_value(iter_)
cover = get_scaled_cover(item)
if cover:
cover = add_border_widget(cover, view)
surface = get_surface_for_pixbuf(self, cover)
cell.set_property("surface", surface)
else:
cell.set_property('icon-name', Icons.MEDIA_OPTICAL)
imgrender = Gtk.CellRendererPixbuf()
render = Gtk.CellRendererText()
if view.supports_hints():
render.set_property('ellipsize', Pango.EllipsizeMode.END)
column.pack_start(imgrender, False)
column.pack_start(render, True)
column.set_cell_data_func(render, cell_data)
column.set_cell_data_func(imgrender, cell_data_pb)
view.append_column(column)
sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
sw.add(view)
hbox = Gtk.HBox(spacing=6)
prefs = Gtk.Button()
prefs.add(SymbolicIconImage(Icons.EMBLEM_SYSTEM, Gtk.IconSize.MENU))
prefs.connect('clicked', lambda *x: Preferences(self))
self.accelerators = Gtk.AccelGroup()
tags = self.__model.tags + ["album"]
search = SearchBarBox(completion=AlbumTagCompletion(),
accel_group=self.accelerators,
star=tags)
search.connect('query-changed', self.__update_filter)
connect_obj(search, 'focus-out', lambda w: w.grab_focus(), view)
self.__search = search
hbox.pack_start(search, True, True, 0)
hbox.pack_start(prefs, False, True, 0)
self.pack_start(Align(hbox, left=6, top=6), False, True, 0)
self.pack_start(sw, True, True, 0)
view.get_selection().set_mode(Gtk.SelectionMode.MULTIPLE)
self.__sig = view.get_selection().connect('changed',
self.__selection_changed)
view.connect('row-activated', self.__play)
connect_obj(view, 'popup-menu', self.__popup, view, library)
targets = [("text/x-quodlibet-songs", Gtk.TargetFlags.SAME_APP, 1),
("text/uri-list", 0, 2)]
targets = [Gtk.TargetEntry.new(*t) for t in targets]
view.drag_source_set(Gdk.ModifierType.BUTTON1_MASK, targets,
Gdk.DragAction.COPY)
view.connect("drag-data-get", self.__drag_data_get)
self.connect("destroy", self.__destroy)
self.show_all()
# The developers of the Exaile media player hereby grant permission
# for non-GPL compatible GStreamer and Exaile plugins to be used and
# distributed together with GStreamer and Exaile. This permission is
# above and beyond the permissions granted by the GPL license by which
# Exaile is covered. If you modify this code, you may extend this
# exception to your version of the code, but you are not obligated to
# do so. If you do not wish to do so, delete this exception statement
# from your version.
from gi.repository import Gtk
from xl import common, providers
# Fake accel group so that menuitems can trick GTK into
# showing accelerators in the menus.
FAKEACCELGROUP = Gtk.AccelGroup()
def simple_separator(name, after):
def factory(menu, parent, context):
item = Gtk.SeparatorMenuItem()
return item
item = MenuItem(name, factory, after=after)
item._pos = 'last'
return item
def _get_accel(callback, display_name):
# utility function to get menu information from an xlgui.Accelerator
accelerator = None
def __init__(self):
self.progressbar = get_obj('progressbar')
self.error = Struct({
'message': get_obj('error_message'),
'icon': get_obj('error_icon'),
'bar': get_obj('error_bar')
})
self.error.bar.connect('response',
lambda widget, signal: widget.hide())
self.strings = Struct({
'quit':
get_obj('quit').get_property('secondary-text'),
'preview':
get_obj('preview_label').get_text()
})
self.liststore = get_obj('loaded_photos')
self.liststore.set_sort_column_id(TIMESTAMP, Gtk.SortType.ASCENDING)
cell_string = Gtk.CellRendererText()
cell_thumb = Gtk.CellRendererPixbuf()
cell_thumb.set_property('stock-id', Gtk.STOCK_MISSING_IMAGE)
cell_thumb.set_property('ypad', 6)
cell_thumb.set_property('xpad', 12)
column = Gtk.TreeViewColumn('Photos')
column.pack_start(cell_thumb, False)
column.add_attribute(cell_thumb, 'pixbuf', THUMB)
column.pack_start(cell_string, False)
column.add_attribute(cell_string, 'markup', SUMMARY)
column.set_sizing(Gtk.TreeViewColumnSizing.AUTOSIZE)
get_obj('photos_view').append_column(column)
self.drag = DragController(self.open_files)
self.navigator = NavigationController()
self.search = SearchController()
self.prefs = PreferencesController()
self.labels = LabelController()
self.actors = ActorController()
about = get_obj('about')
about.set_version(REVISION)
about.set_program_name(APPNAME)
about.set_logo(
GdkPixbuf.Pixbuf.new_from_file_at_size(
join(PKG_DATA_DIR, PACKAGE + '.svg'), 192, 192))
click_handlers = {
'open_button': [self.add_files_dialog,
get_obj('open')],
'save_button': [self.save_all_files],
'clear_button': [clear_all_gpx],
'close_button': [self.close_selected_photos],
'revert_button': [self.revert_selected_photos],
'about_button': [lambda b, d: d.run() and d.hide(), about],
'apply_button': [self.apply_selected_photos, map_view],
'select_all_button':
[toggle_selected_photos, self.labels.selection]
}
for button, handler in click_handlers.items():
get_obj(button).connect('clicked', *handler)
accel = Gtk.AccelGroup()
window = get_obj('main')
window.resize(*gst.get('window-size'))
window.connect('delete_event', self.confirm_quit_dialog)
window.add_accel_group(accel)
window.show_all()
# Hide the unused button that appears beside the map source menu.
get_obj('map_source_menu_button').get_child().get_children(
)[0].set_visible(False)
save_size = lambda v, s, size: gst.set_window_size(size())
for prop in ['width', 'height']:
map_view.connect('notify::' + prop, save_size, window.get_size)
accel.connect(Gdk.keyval_from_name('q'), Gdk.ModifierType.CONTROL_MASK,
0, self.confirm_quit_dialog)
self.labels.selection.emit('changed')
clear_all_gpx()
metadata.delta = 0
self.secbutton, self.minbutton = get_obj('seconds'), get_obj('minutes')
for spinbutton in [self.secbutton, self.minbutton]:
spinbutton.connect('value-changed', self.time_offset_changed)
gst.bind('offset-minutes', self.minbutton, 'value')
gst.bind('offset-seconds', self.secbutton, 'value')
gst.bind('left-pane-page', get_obj('photo_camera_gps'), 'page')
get_obj('open').connect('update-preview', self.update_preview,
get_obj('preview_label'),
get_obj('preview_image'))
def __init_window(self):
"""
Add fields for all ui objects we need to access from code.
Initialize everything we can't do from glade like events and other stuff.
"""
log.info("Initialize main window")
self.window = self.window_builder.get_object("app_window")
self.window.set_default_size(1100, 700)
self.window.set_application(self.app)
self.window.show_all()
self.window.present()
self.window.connect("delete-event", self.on_close)
self.window.connect("drag_data_received", self.__on_drag_data_received)
self.window.drag_dest_set(
Gtk.DestDefaults.MOTION | Gtk.DestDefaults.HIGHLIGHT
| Gtk.DestDefaults.DROP,
[Gtk.TargetEntry.new("text/uri-list", 0, 80)], Gdk.DragAction.COPY)
# resizing the progress bar for older gtk versions
if not Gtk.get_minor_version() > 18:
self.window.connect("check-resize", self.__window_resized)
self.author_box = self.window_builder.get_object("author_box")
self.reader_box = self.window_builder.get_object("reader_box")
self.book_box = self.window_builder.get_object("book_box")
self.book_scroller = self.window_builder.get_object("book_scroller")
self.sort_stack = self.window_builder.get_object("sort_stack")
self.sort_stack.connect("notify::visible-child",
self.__on_sort_stack_changed)
self.sort_box = self.window_builder.get_object("sort_box")
self.import_box = self.window_builder.get_object("import_box")
self.position_box = self.window_builder.get_object("position_box")
self.main_stack = self.window_builder.get_object("main_stack")
self.toolbar_revealer = self.window_builder.get_object(
"toolbar_revealer")
self.back_button = self.window_builder.get_object("back_button")
self.back_button.connect("clicked", self.__on_back_clicked)
self.category_toolbar = self.window_builder.get_object(
"category_toolbar")
self.sort_stack_revealer = self.window_builder.get_object(
"sort_stack_revealer")
# This fixes a bug where otherwise expand is
# somehow set to true internally
# but is still showing false in the inspector
self.sort_stack_revealer.props.expand = True
self.sort_stack_revealer.props.expand = False
self.sort_stack_switcher = self.window_builder.get_object(
"sort_stack_switcher")
self.no_media_file_chooser = self.window_builder.get_object(
"no_media_file_chooser")
self.no_media_file_chooser.connect("file-set",
self.__on_no_media_folder_changed)
self.external_switch = self.window_builder.get_object(
"external_switch")
self.auto_scan_switch = self.window_builder.get_object(
"auto_scan_switch")
# some visual stuff
self.category_toolbar_separator = self.window_builder.get_object(
"category_toolbar_separator")
if tools.is_elementary():
self.category_toolbar.set_visible(False)
# get about dialog
self.about_dialog = self.about_builder.get_object("about_dialog")
self.about_dialog.set_transient_for(self.window)
self.about_dialog.connect("delete-event", self.hide_window)
self.about_dialog.set_version(self.version)
# shortcuts
self.accel = Gtk.AccelGroup()
# sorting and filtering
self.author_box.connect("row-selected", self.__on_listbox_changed)
self.reader_box.connect("row-selected", self.__on_listbox_changed)
self.book_box.set_sort_func(self.__sort_books, None, False)
self.book_box.set_filter_func(self.__filter_books, None, False)
try:
about_close_button = self.about_builder.get_object(
"button_box").get_children()[2]
if about_close_button:
about_close_button.connect("clicked",
self.__about_close_clicked)
except Exception as e:
log.info("Not connecting about close button.")
player.add_player_listener(self.__player_changed)
def make_accel(self):
accels = Gtk.AccelGroup()
#accels.connect_by_path("e",self.on_run_clicked)
key, mod = Gtk.accelerator_parse("Return")
accels.connect(key, mod, 0, self.on_accel_return)
def __init__(self, app):
"""Set up the main window"""
super().__init__(application=Gio.Application.get_default(), title="Uberwriter")
self.get_style_context().add_class('uberwriter-window')
# Set UI
builder = Gtk.Builder()
builder.add_from_resource(
"/de/wolfvollprecht/UberWriter/ui/Window.ui")
root = builder.get_object("FullscreenOverlay")
self.connect("delete-event", self.on_delete_called)
self.add(root)
self.set_default_size(1000, 600)
# Preferences
self.settings = Settings.new()
# Headerbars
self.headerbar = headerbars.MainHeaderbar(app)
self.set_titlebar(self.headerbar.hb_container)
self.fs_headerbar = headerbars.FullscreenHeaderbar(builder, app)
self.title_end = " – UberWriter"
self.set_headerbar_title("New File" + self.title_end)
self.timestamp_last_mouse_motion = 0
if self.settings.get_value("poll-motion"):
self.connect("motion-notify-event", self.on_motion_notify)
GObject.timeout_add(3000, self.poll_for_motion)
self.accel_group = Gtk.AccelGroup()
self.add_accel_group(self.accel_group)
self.scrolled_window = builder.get_object('editor_scrolledwindow')
# Setup text editor
self.text_view = TextView(self.settings.get_int("characters-per-line"))
self.text_view.connect('focus-out-event', self.focus_out)
self.text_view.get_buffer().connect('changed', self.on_text_changed)
self.text_view.show()
self.text_view.grab_focus()
self.scrolled_window.add(self.text_view)
# Setup stats counter
self.stats_revealer = builder.get_object('editor_stats_revealer')
self.stats_button = builder.get_object('editor_stats_button')
self.stats_handler = StatsHandler(self.stats_button, self.text_view)
# Setup preview
content = builder.get_object('content')
editor = builder.get_object('editor')
self.preview_handler = PreviewHandler(self, content, editor, self.text_view)
# Setup header/stats bar hide after 3 seconds
self.top_bottom_bars_visible = True
self.was_motion = True
self.buffer_modified_for_status_bar = False
# some people seems to have performance problems with the overlay.
# Let them disable it
self.overlay_id = None
self.toggle_gradient_overlay(self.settings.get_value("gradient-overlay"))
# Init file name with None
self.set_filename()
# Setting up spellcheck
self.auto_correct = None
self.toggle_spellcheck(self.settings.get_value("spellcheck"))
self.did_change = False
###
# Sidebar initialization test
###
self.paned_window = builder.get_object("main_paned")
self.sidebar_box = builder.get_object("sidebar_box")
self.sidebar = Sidebar(self)
self.sidebar_box.hide()
###
# Search and replace initialization
# Same interface as Sidebar ;)
###
self.searchreplace = SearchAndReplace(self, self.text_view, builder)
def __init__(self):
Gtk.ToggleButton.__init__(self)
BaseControl.__init__(self)
QueueAdapter.__init__(self, player.QUEUE)
self.set_focus_on_click(False)
self.set_size_request(200, -1)
box = Gtk.Box()
self.arrow = Gtk.Arrow(Gtk.ArrowType.RIGHT, Gtk.ShadowType.OUT)
box.pack_start(self.arrow, False, True, 0)
self.label = Gtk.Label(label='')
self.label.props.ellipsize = Pango.EllipsizeMode.END
box.pack_start(self.label, True, True, 0)
self.add(box)
self.formatter = TrackFormatter(
settings.get_option('plugin/minimode/track_title_format',
'$tracknumber - $title'))
self.view = PlaylistView(player.QUEUE.current_playlist, player.PLAYER)
self.popup = AttachedWindow(self)
self.popup.set_default_size(
settings.get_option(
'plugin/minimode/'
'playlist_button_popup_width', 350),
settings.get_option(
'plugin/minimode/'
'playlist_button_popup_height', 400),
)
scrollwindow = Gtk.ScrolledWindow()
scrollwindow.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
scrollwindow.set_shadow_type(Gtk.ShadowType.IN)
scrollwindow.add(self.view)
self.popup.add(scrollwindow)
self.popup.connect('show', self.on_popup_show)
self.popup.connect('hide', self.on_popup_hide)
self.popup.connect('configure-event', self.on_popup_configure_event)
accel_group = Gtk.AccelGroup()
key, modifier = Gtk.accelerator_parse('<Primary>J')
accel_group.connect(key, modifier, Gtk.AccelFlags.VISIBLE,
self.on_accelerator_activate)
self.popup.add_accel_group(accel_group)
self.tooltip = TrackToolTip(self, player.PLAYER)
self.tooltip.set_auto_update(True)
if player.PLAYER.current is not None:
self.label.set_text(self.formatter.format(player.PLAYER.current))
self._drag_motion_timeout_id = None
self._drag_leave_timeout_id = None
self.drag_dest_set(
Gtk.DestDefaults.ALL,
self.view.targets,
Gdk.DragAction.COPY | Gdk.DragAction.DEFAULT | Gdk.DragAction.MOVE,
)
self.connect('drag-motion', self.on_drag_motion)
self.connect('drag-leave', self.on_drag_leave)
self.connect('drag-data-received', self.on_drag_data_received)
self.view.connect('drag-motion', self.on_drag_motion)
self.view.connect('drag-leave', self.on_drag_leave)
event.add_ui_callback(self.on_track_tags_changed, 'track_tags_changed')
event.add_ui_callback(self.on_option_set, 'plugin_minimode_option_set')
self.on_option_set('plugin_minimode_option_set', settings,
'plugin/minimode/track_title_format')
def __init__(self, opts):
self.serverIp = opts.serverIp
self.serverPort = opts.serverPort
self.connected = False
self.sock = None
self.done = False
self.useGtk = useGtk
if hasattr(opts, 'userName') and opts.userName is not None:
self.userName = userName
else:
self.userName = os.getenv('USER')
self.recolorDict = {
self.userName: '******',
'WARNING': '#d0a000',
'ERROR': '#e00000'
}
if self.useGtk:
self.window = gtk.Window(type=gtk.WindowType.TOPLEVEL)
self.window.get_settings().set_property('gtk-font-name',
'monospace bold 10')
self.window.set_title("PyChat")
self.window.set_default_size(750, 450)
self.window.connect('destroy', self.doQuit)
# Text Box for viewing
self.textBox = gtk.TextView()
self.textBox.set_wrap_mode(gtk.WrapMode.WORD)
self.textBox.set_editable(False)
self.textBox.set_cursor_visible(False)
self.textBox.set_border_window_size(gtk.TextWindowType.LEFT, 1)
self.textBox.set_border_window_size(gtk.TextWindowType.RIGHT, 1)
self.textBox.set_border_window_size(gtk.TextWindowType.TOP, 1)
self.textBox.set_border_window_size(gtk.TextWindowType.BOTTOM, 1)
# Plot Window for fun
self.doPlotPart = False
if self.doPlotPart:
f = plt.figure()
a = f.add_subplot('111')
a.plot([0, 1, 2, 3], [0, 1, 4, 9], 'bo')
# Widgets must be removed from their parent before they can be added to another container,
# which is done below.
f.canvas.manager.vbox.remove(f.canvas)
self.canvas = f.canvas
print('PA:', self.canvas)
# Text Entry
self.textEntry = gtk.TextView()
self.textEntry.set_wrap_mode(gtk.WrapMode.NONE)
self.textEntry.set_editable(True)
self.textEntry.set_cursor_visible(False)
self.textEntry.set_border_window_size(gtk.TextWindowType.LEFT, 1)
self.textEntry.set_border_window_size(gtk.TextWindowType.RIGHT, 1)
self.textEntry.set_border_window_size(gtk.TextWindowType.TOP, 1)
self.textEntry.set_border_window_size(gtk.TextWindowType.BOTTOM, 1)
self.textEntry.set_tooltip_text(
'Type message here. CTRL+S to submit.')
# Scroll windows to encapsulate text areas
self.scrollWinForTextBox = gtk.ScrolledWindow(expand=True)
self.scrollWinForTextBox.set_policy(gtk.ScrollablePolicy.NATURAL,
gtk.ScrollablePolicy.NATURAL)
self.scrollWinForTextBox.add(self.textBox)
self.scrollWinForTextBox.set_size_request(400, 220)
self.scrollWinForTextEntry = gtk.ScrolledWindow(expand=True)
self.scrollWinForTextEntry.set_policy(gtk.ScrollablePolicy.NATURAL,
gtk.ScrollablePolicy.NATURAL)
self.scrollWinForTextEntry.add(self.textEntry)
self.scrollWinForTextEntry.set_size_request(300, 40)
# Submit button
self.submitButton = gtk.Button(label='submit', expand=False)
self.submitButton.set_size_request(60, 40)
self.submitButton.connect('clicked', self.submitHandler)
accelGroup = gtk.AccelGroup()
key, mod = gtk.accelerator_parse('<Control>s')
self.submitButton.add_accelerator('clicked', accelGroup, key, mod,
gtk.AccelFlags.VISIBLE)
self.submitButton.set_tooltip_text('CTRL+S')
self.howToFormat = 'PANED' # GRID or BOX or PANED
if self.howToFormat == 'GRID':
grid = gtk.Grid(expand=True)
grid.set_row_spacing(2)
grid.set_column_spacing(2)
grid.attach(self.scrollWinForTextBox, 0, 0, 4, 4)
grid.attach(self.scrollWinForTextEntry, 0, 4, 3, 1)
grid.attach(self.submitButton, 3, 4, 1, 1)
self.window.add(grid)
elif self.howToFormat == 'BOX':
vbox = gtk.VBox(homogeneous=False, spacing=5)
if self.doPlotPart:
hbox = gtk.HBox(homogeneous=False, spacing=6)
hbox.pack_start(self.scrollWinForTextBox,
expand=True,
fill=True,
padding=1)
hbox.pack_end(self.canvas,
expand=True,
fill=True,
padding=1)
vbox.pack_start(hbox, expand=True, fill=True, padding=0)
vbox.set_tooltip_text(
'Include "plot: <x sequence> : <y sequence> :" to plot some data.'
)
else:
vbox.pack_start(self.scrollWinForTextBox,
expand=True,
fill=True,
padding=0)
hbox = gtk.HBox(homogeneous=False, spacing=6)
hbox.set_size_request(400, 60)
hbox.pack_start(self.scrollWinForTextEntry,
expand=True,
fill=True,
padding=0)
hbox.pack_end(self.submitButton,
expand=False,
fill=True,
padding=0)
vbox.pack_end(hbox, expand=False, fill=True, padding=0)
self.window.add(vbox)
elif self.howToFormat == 'PANED':
self.vPaned = gtk.Paned(orientation=gtk.Orientation.VERTICAL)
if self.doPlotPart:
hPaned = gtk.Paned()
hPaned.add1(self.scrollWinForTextBox)
hPaned.add2(self.canvas)
self.vPaned.add1(hPaned)
else:
self.vPaned.add1(self.scrollWinForTextBox)
self.hPaned = gtk.Paned()
self.hPaned.add1(self.scrollWinForTextEntry)
self.hPaned.add2(self.submitButton)
self.hPaned.set_position(int(self.window.get_size()[0] * 0.8))
self.vPaned.add2(self.hPaned)
self.vPaned.set_position(int(self.window.get_size()[1] * 0.9))
self.window.add(self.vPaned)
self.window.connect('check-resize', self.resizeCheck)
else:
print('Oops! Wrong howToFormat.', howToFormat)
self.window.add_accel_group(accelGroup)
self.start()
self.window.show_all()
else:
self.root = tk.Tk()
self.root.protocol('WM_DELETE_WINDOW', self.doQuit)
#contentFrame = tk.Frame()
frame = tk.Frame(self.root) #, width=60, height=400)
frame.grid(column=0, row=0, sticky=(tk.N + tk.E + tk.W + tk.S))
frame.rowconfigure(0, weight=5)
frame.rowconfigure(1, weight=1)
frame.columnconfigure(0, weight=10)
frame.columnconfigure(1, weight=1)
frame.columnconfigure(2, weight=2)
frame.columnconfigure(3, weight=1)
tbScrollbar = tk.Scrollbar(frame)
tbScrollbar.grid(column=3,
row=0,
columnspan=1,
rowspan=1,
sticky=(tk.N + tk.W + tk.S))
self.textBox = tk.Text(frame,
width=60,
height=30,
wrap=tk.WORD,
state=tk.DISABLED)
self.textBox.grid(column=0,
row=0,
columnspan=3,
rowspan=1,
sticky=(tk.N + tk.E + tk.W))
self.textBox.config(yscrollcommand=tbScrollbar.set)
tbScrollbar.config(command=self.textBox.yview)
teScrollbar = tk.Scrollbar(frame)
teScrollbar.grid(column=1,
row=1,
columnspan=1,
rowspan=1,
sticky=(tk.N + tk.S + tk.W))
self.textEntry = tk.Text(frame,
width=60,
height=5,
wrap=tk.WORD,
state=tk.NORMAL)
self.textEntry.grid(column=0,
row=1,
columnspan=1,
rowspan=1,
sticky=(tk.E + tk.W))
self.textEntry.config(yscrollcommand=teScrollbar.set)
teScrollbar.config(command=self.textEntry.yview)
self.textEntry.focus()
self.submitButton = tk.Button(frame,
text="submit",
command=self.submitHandler)
self.submitButton.grid(column=2,
row=1,
columnspan=2,
rowspan=1,
sticky=(tk.S + tk.E))
for keyWord, color in self.recolorDict.items():
self.textBox.tag_configure(keyWord,
foreground=color,
background='#dddddd',
lmargin1=50,
lmargin2=50)
frame.pack()
self.start()
def __init__(self, library):
super(AlbumList, self).__init__(spacing=6)
self.set_orientation(Gtk.Orientation.VERTICAL)
self._register_instance()
if self.__model is None:
self._init_model(library)
self._cover_cancel = Gio.Cancellable.new()
sw = ScrolledWindow()
sw.set_shadow_type(Gtk.ShadowType.IN)
self.view = view = AllTreeView()
view.set_headers_visible(False)
model_sort = AlbumSortModel(model=self.__model)
model_filter = AlbumFilterModel(child_model=model_sort)
self.__bg_filter = background_filter()
self.__filter = None
model_filter.set_visible_func(self.__parse_query)
render = Gtk.CellRendererPixbuf()
self.__cover_column = column = Gtk.TreeViewColumn("covers", render)
column.set_visible(config.getboolean("browsers", "album_covers"))
column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
column.set_fixed_width(Album.COVER_SIZE + 12)
render.set_property('height', Album.COVER_SIZE + 8)
render.set_property('width', Album.COVER_SIZE + 8)
def cell_data_pb(column, cell, model, iter_, no_cover):
album = model.get_album(iter_)
if album is None:
surface = None
elif album.cover:
pixbuf = album.cover
pixbuf = add_border_widget(pixbuf, self.view)
surface = get_surface_for_pixbuf(self, pixbuf)
# don't cache, too much state has an effect on the result
self.__last_render_surface = None
else:
surface = no_cover
if self.__last_render_surface == surface:
return
self.__last_render_surface = surface
cell.set_property("surface", surface)
column.set_cell_data_func(render, cell_data_pb, self._no_cover)
view.append_column(column)
render = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("albums", render)
column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
if view.supports_hints():
render.set_property('ellipsize', Pango.EllipsizeMode.END)
def cell_data(column, cell, model, iter_, data):
album = model.get_album(iter_)
if album is None:
text = "<b>%s</b>" % _("All Albums")
text += "\n" + ngettext("%d album", "%d albums",
len(model) - 1) % (len(model) - 1)
markup = text
else:
markup = self.display_pattern % album
if self.__last_render == markup:
return
self.__last_render = markup
cell.markup = markup
cell.set_property('markup', markup)
column.set_cell_data_func(render, cell_data)
view.append_column(column)
view.get_selection().set_mode(Gtk.SelectionMode.MULTIPLE)
view.set_rules_hint(True)
view.set_search_equal_func(self.__search_func, None)
view.set_search_column(0)
view.set_model(model_filter)
sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
sw.add(view)
view.connect('row-activated', self.__play_selection)
self.__sig = view.connect(
'selection-changed',
util.DeferredSignal(self.__update_songs, owner=view))
targets = [("text/x-quodlibet-songs", Gtk.TargetFlags.SAME_APP, 1),
("text/uri-list", 0, 2)]
targets = [Gtk.TargetEntry.new(*t) for t in targets]
view.drag_source_set(Gdk.ModifierType.BUTTON1_MASK, targets,
Gdk.DragAction.COPY)
view.connect("drag-data-get", self.__drag_data_get)
connect_obj(view, 'popup-menu', self.__popup, view, library)
self.accelerators = Gtk.AccelGroup()
search = SearchBarBox(completion=AlbumTagCompletion(),
accel_group=self.accelerators)
search.connect('query-changed', self.__update_filter)
connect_obj(search, 'focus-out', lambda w: w.grab_focus(), view)
self.__search = search
prefs = PreferencesButton(self, model_sort)
search.pack_start(prefs, False, True, 0)
self.pack_start(Align(search, left=6, top=6), False, True, 0)
self.pack_start(sw, True, True, 0)
self.connect("destroy", self.__destroy)
self.enable_row_update(view, sw, self.__cover_column)
self.connect('key-press-event', self.__key_pressed, library.librarian)
self.show_all()
def __init_window(self):
"""
Add fields for all ui objects we need to access from code.
Initialize everything we can't do from glade like events and other stuff.
"""
log.info("Initialize main window")
self.window = self.window_builder.get_object("app_window")
self.window.set_default_size(1100, 700)
self.window.set_application(self.app)
self.window.show_all()
self.window.present()
self.window.connect("delete-event", self.on_close)
self.window.connect("drag_data_received", self.__on_drag_data_received)
self.window.drag_dest_set(Gtk.DestDefaults.MOTION | Gtk.DestDefaults.HIGHLIGHT | Gtk.DestDefaults.DROP,
[Gtk.TargetEntry.new("text/uri-list", 0, 80)], Gdk.DragAction.COPY)
if not Gtk.get_minor_version() > 18:
self.window.connect("check-resize", self.__window_resized)
# hide wip stuff
self.volume_button = self.window_builder.get_object("volume_button")
self.volume_button.set_visible(False)
self.search_button = self.window_builder.get_object("search_button")
self.search_button.set_visible(False)
self.timer_button = self.window_builder.get_object("timer_button")
search_button = self.window_builder.get_object("search_button")
search_popover = self.search_builder.get_object("search_popover")
timer_popover = self.timer_builder.get_object("timer_popover")
self.timer_switch = self.timer_builder.get_object("timer_switch")
self.timer_scale = self.timer_builder.get_object("timer_scale")
self.timer_spinner = self.timer_builder.get_object("timer_spinner")
self.timer_buffer = self.timer_builder.get_object("timer_buffer")
self.cover_img = self.window_builder.get_object("cover_img")
self.throbber = self.window_builder.get_object("spinner")
self.author_box = self.window_builder.get_object("author_box")
self.reader_box = self.window_builder.get_object("reader_box")
self.book_box = self.window_builder.get_object("book_box")
self.book_scroller = self.window_builder.get_object("book_scroller")
self.sort_stack = self.window_builder.get_object("sort_stack")
self.sort_box = self.window_builder.get_object("sort_box")
self.progress_bar = self.window_builder.get_object("progress_bar")
self.update_progress_bar = self.window_builder.get_object("update_progress_bar")
self.import_box = self.window_builder.get_object("import_box")
self.position_box = self.window_builder.get_object("position_box")
self.location_chooser = self.settings_builder.get_object("location_chooser")
self.status_stack = self.window_builder.get_object("status_stack")
self.status_label = self.window_builder.get_object("status_label")
self.play_button = self.window_builder.get_object("play_button")
self.prev_button = self.window_builder.get_object("prev_button")
self.main_stack = self.window_builder.get_object("main_stack")
self.play_img = self.window_builder.get_object("play_img")
self.pause_img = self.window_builder.get_object("pause_img")
self.title_label = self.window_builder.get_object("title_label")
self.subtitle_label = self.window_builder.get_object("subtitle_label")
self.progress_scale = self.window_builder.get_object("progress_scale")
self.current_label = self.window_builder.get_object("current_label")
self.remaining_label = self.window_builder.get_object("remaining_label")
self.author_toggle_button = self.window_builder.get_object("author_toggle_button")
self.reader_toggle_button = self.window_builder.get_object("reader_toggle_button")
self.no_media_file_chooser = self.window_builder.get_object("no_media_file_chooser")
self.timer_image = self.window_builder.get_object("timer_image")
# get settings window
self.settings_window = self.settings_builder.get_object("settings_window")
self.settings_window.set_transient_for(self.window)
self.settings_window.connect("delete-event", self.hide_window)
self.init_db_settings()
# get about dialog
self.about_dialog = self.about_builder.get_object("about_dialog")
self.about_dialog.set_transient_for(self.window)
self.about_dialog.connect("delete-event", self.hide_window)
self.about_dialog.set_version(self.version)
# we need to update the database when the audio book location was changed
folder_chooser = self.settings_builder.get_object("location_chooser")
folder_chooser.connect("file-set", self.__on_folder_changed)
self.no_media_file_chooser.connect("file-set", self.__on_no_media_folder_changed)
# init popovers
search_button.set_popover(search_popover)
self.timer_button.set_popover(timer_popover)
self.timer_switch.connect("notify::active", self.__timer_switch_changed)
# add marks to timer scale
for i in range(0, 181, 15):
self.timer_scale.add_mark(i, Gtk.PositionType.RIGHT, None)
# this is required otherwise the timer will not show "min" on start
self.__init_timer_buffer()
# timer SpinButton text format
self.timer_spinner.connect("value-changed", self.__on_timer_changed)
self.timer_spinner.connect("focus-out-event", self.__on_timer_focus_out)
# init progress scale
self.progress_scale.connect("button-release-event", self.__on_progress_clicked)
self.progress_scale.connect("button-press-event", self.__on_progress_press)
self.progress_scale.connect("value-changed", self.__update_ui_time)
# shortcuts
self.accel = Gtk.AccelGroup()
# sorting and filtering
self.author_box.connect("row-activated", self.__on_listbox_changed)
self.reader_box.connect("row-activated", self.__on_listbox_changed)
self.book_box.set_sort_func(self.__sort_books, None, False)
self.book_box.set_filter_func(self.__filter_books, None, False)
self.book_box.connect("selected-children-changed", self.__on_book_selec_changed)
# button actions
self.play_button.connect("clicked", self.__on_play_pause_clicked)
self.prev_button.connect("clicked", self.__on_rewind_clicked)
self.author_toggle_button.connect("toggled", self.__toggle_author)
self.reader_toggle_button.connect("toggled", self.__toggle_reader)
# menu
menu = self.menu_builder.get_object("app_menu")
self.menu_button = self.window_builder.get_object("menu_button")
# for elementary we add a menu button, else we just set the app menu
if self.is_elementary:
self.menu_button.set_visible(True)
self.menu_button.set_menu_model(menu)
else:
self.menu_button.set_visible(False)
if self.is_elementary:
about_close_button = self.about_builder.get_object("button_box").get_children()[2]
about_close_button.connect("clicked", self.__about_close_clicked)
add_player_listener(self.__player_changed)
def __init__(self, main):
super(MenuBar, self).__init__()
self.main = main
self.uicore = self.main.uicore
agr = Gtk.AccelGroup()
self.main.window.add_accel_group(agr)
actiongroup = Gtk.ActionGroup('MainButton')
# File menu items
newmenu = Gtk.Action('New', None, None, Gtk.STOCK_NEW)
newmenu.connect("activate", self.new_file)
actiongroup.add_action_with_accel(newmenu, '<Control>N')
newmenu.set_accel_group(agr)
newmenu.connect_accelerator()
newmenuitem = newmenu.create_menu_item()
self.append(newmenuitem)
self.manager = Gtk.RecentManager.get_default()
self.recent_menu = Gtk.RecentChooserMenu.new_for_manager(self.manager)
self.recentm = Gtk.MenuItem('Recent targets')
self.recentm.set_submenu(self.recent_menu)
self.recent_menu.connect('item-activated', self.recent_kb)
self.append(self.recentm)
smenu = Gtk.Menu()
savem = Gtk.ImageMenuItem(Gtk.STOCK_SAVE)
savem.get_children()[0].set_label('Save')
savem.set_submenu(smenu)
saves = [
['All', Gtk.STOCK_SAVE_AS, 'all'],
['Disassembly', Gtk.STOCK_SORT_DESCENDING, 'asm'],
['Hexdump', Gtk.STOCK_INDEX, 'hex'],
['Strings', Gtk.STOCK_JUSTIFY_CENTER, 'str'],
]
for save in saves:
savei = Gtk.ImageMenuItem(save[1])
savei.get_children()[0].set_label(save[0])
savei.connect("activate", self._save, save[2])
smenu.append(savei)
self.append(savem)
sep = Gtk.SeparatorMenuItem()
self.append(sep)
tmenu = Gtk.Menu()
themem = Gtk.ImageMenuItem(Gtk.STOCK_SELECT_COLOR)
themem.get_children()[0].set_label('Themes')
themem.set_submenu(tmenu)
themes = ['Classic', 'Cobalt', 'kate', 'Oblivion', 'Tango']
for theme in themes:
themei = Gtk.MenuItem(theme)
themei.connect("activate", self._on_theme_change)
tmenu.append(themei)
self.append(themem)
# View Menu
self.vmenu = Gtk.Menu()
tabsm = Gtk.ImageMenuItem(Gtk.STOCK_PREFERENCES)
tabsm.get_children()[0].set_label('Show tabs')
tabsm.set_submenu(self.vmenu)
self.append(tabsm)
sep = Gtk.SeparatorMenuItem()
self.append(sep)
# Cheatsheet.
cheat = Gtk.Action('Cheat sheet', 'Cheat sheet', None,
Gtk.STOCK_JUSTIFY_FILL)
cheat.connect("activate", self.create_cheatsheet_dialog)
actiongroup.add_action_with_accel(cheat, 'F1')
cheat.set_accel_group(agr)
cheat.connect_accelerator()
cheatitem = cheat.create_menu_item()
self.append(cheatitem)
# Help menu.
helpmenu = Gtk.Action('Help', None, None, Gtk.STOCK_HELP)
helpmenu.connect("activate", self.show_wiki)
actiongroup.add_action_with_accel(helpmenu, '<Control>H')
helpmenu.set_accel_group(agr)
helpmenu.connect_accelerator()
helpmenuitem = helpmenu.create_menu_item()
self.append(helpmenuitem)
# About.
about = Gtk.Action('About', None, None, Gtk.STOCK_ABOUT)
about.connect("activate", self.create_about_dialog)
actiongroup.add_action_with_accel(about, '<Control>A')
about.set_accel_group(agr)
about.connect_accelerator()
aboutitem = about.create_menu_item()
self.append(aboutitem)
sep = Gtk.SeparatorMenuItem()
self.append(sep)
# Quit.
exit = Gtk.Action('Quit', None, None, Gtk.STOCK_QUIT)
exit.connect('activate', self.main.quit)
actiongroup.add_action_with_accel(exit, '<Control>Q')
exit.set_accel_group(agr)
exit.connect_accelerator()
exititem = exit.create_menu_item()
self.append(exititem)
def __init__(self, library, dir=None):
super(ExFalsoWindow, self).__init__(dialog=False)
self.set_title("Ex Falso")
self.set_default_size(750, 475)
self.enable_window_tracking("exfalso")
self.__library = library
hp = ConfigRHPaned("memory", "exfalso_paned_position", 1.0)
hp.set_border_width(0)
hp.set_position(250)
hp.show()
self.add(hp)
vb = Gtk.VBox()
bbox = Gtk.HBox(spacing=6)
def prefs_cb(*args):
window = PreferencesWindow(self)
window.show()
def plugin_window_cb(*args):
window = PluginWindow(self)
window.show()
def about_cb(*args):
about = AboutDialog(self, app)
about.run()
about.destroy()
def update_cb(*args):
d = UpdateDialog(self)
d.run()
d.destroy()
menu = Gtk.Menu()
about_item = MenuItem(_("_About"), Icons.HELP_ABOUT)
about_item.connect("activate", about_cb)
menu.append(about_item)
check_item = MenuItem(_("_Check for Updates…"), Icons.NETWORK_SERVER)
check_item.connect("activate", update_cb)
menu.append(check_item)
menu.append(SeparatorMenuItem())
plugin_item = MenuItem(_("_Plugins"), Icons.SYSTEM_RUN)
plugin_item.connect("activate", plugin_window_cb)
menu.append(plugin_item)
pref_item = MenuItem(_("_Preferences"), Icons.PREFERENCES_SYSTEM)
pref_item.connect("activate", prefs_cb)
menu.append(pref_item)
menu.show_all()
menu_button = MenuButton(SymbolicIconImage(Icons.EMBLEM_SYSTEM,
Gtk.IconSize.BUTTON),
arrow=True,
down=False)
menu_button.set_menu(menu)
bbox.pack_start(menu_button, False, True, 0)
l = Gtk.Label()
l.set_alignment(1.0, 0.5)
l.set_ellipsize(Pango.EllipsizeMode.END)
bbox.pack_start(l, True, True, 0)
self._fs = fs = MainFileSelector()
vb.pack_start(fs, True, True, 0)
vb.pack_start(Align(bbox, border=6), False, True, 0)
vb.show_all()
hp.pack1(vb, resize=True, shrink=False)
nb = qltk.Notebook()
nb.props.scrollable = True
nb.show()
for Page in [EditTags, TagsFromPath, RenameFiles, TrackNumbers]:
page = Page(self, self.__library)
page.show()
nb.append_page(page)
hp.pack2(nb, resize=True, shrink=False)
fs.connect('changed', self.__changed, l)
if dir:
fs.go_to(dir)
connect_destroy(self.__library, 'changed', self.__library_changed, fs)
self.__save = None
connect_obj(self, 'changed', self.set_pending, None)
for c in fs.get_children():
c.get_child().connect('button-press-event',
self.__pre_selection_changed, fs, nb)
c.get_child().connect('focus', self.__pre_selection_changed, fs,
nb)
fs.get_children()[1].get_child().connect('popup-menu',
self.__popup_menu, fs)
self.emit('changed', [])
self.get_child().show()
self.__ag = Gtk.AccelGroup()
key, mod = Gtk.accelerator_parse("<Primary>Q")
self.__ag.connect(key, mod, 0, lambda *x: self.destroy())
self.add_accel_group(self.__ag)
# GtkosxApplication assumes the menu bar is mapped, so add
# it but don't show it.
self._dummy_osx_menu_bar = Gtk.MenuBar()
vb.pack_start(self._dummy_osx_menu_bar, False, False, 0)
def __init__(self, Prototype, values, filename, title):
if self.is_not_unique():
return
super().__init__()
self.Prototype = Prototype
self.current = None
self.filename = filename
self.name = Prototype.NAME or Prototype.__name__
self.input_entries = {}
self.set_border_width(12)
self.set_title(title)
self.set_default_size(self._WIDTH, self._HEIGHT)
self.add(Gtk.HBox(spacing=6))
self.get_child().set_homogeneous(True)
self.accels = Gtk.AccelGroup()
# Set up the model for this widget
self.model = Gtk.ListStore(object)
self._fill_values(values)
# The browser for existing data
self.view = view = RCMHintedTreeView(model=self.model)
view.set_headers_visible(False)
view.set_reorderable(True)
view.set_rules_hint(True)
render = Gtk.CellRendererText()
render.set_padding(3, 6)
render.props.ellipsize = Pango.EllipsizeMode.END
column = Gtk.TreeViewColumn("", render)
column.set_cell_data_func(render, self.__cdf)
view.append_column(column)
sw = Gtk.ScrolledWindow()
sw.set_shadow_type(Gtk.ShadowType.IN)
sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
sw.add(view)
self.get_child().pack_start(sw, True, True, 0)
vbox = Gtk.VBox(spacing=6)
# Input for new ones.
frame = self.__build_input_frame()
vbox.pack_start(frame, False, True, 0)
# Add context menu
menu = Gtk.Menu()
rem = MenuItem(_("_Remove"), Icons.LIST_REMOVE)
keyval, mod = Gtk.accelerator_parse("Delete")
rem.add_accelerator('activate', self.accels, keyval, mod,
Gtk.AccelFlags.VISIBLE)
connect_obj(rem, 'activate', self.__remove, view)
menu.append(rem)
menu.show_all()
view.connect('popup-menu', self.__popup, menu)
view.connect('key-press-event', self.__view_key_press)
connect_obj(self, 'destroy', Gtk.Menu.destroy, menu)
# New and Close buttons
bbox = Gtk.HButtonBox()
self.remove_but = Button(_("_Remove"), Icons.LIST_REMOVE)
self.remove_but.set_sensitive(False)
self.new_but = Button(_("_New"), Icons.DOCUMENT_NEW)
self.new_but.connect('clicked', self._new_item)
bbox.pack_start(self.new_but, True, True, 0)
close = Button(_("_Close"), Icons.WINDOW_CLOSE)
connect_obj(close, 'clicked', qltk.Window.destroy, self)
bbox.pack_start(close, True, True, 0)
vbox.pack_end(bbox, False, True, 0)
self.get_child().pack_start(vbox, True, True, 0)
# Initialise
self.selection = view.get_selection()
self.selection.connect('changed', self.__select)
self.connect('destroy', self.__finish)
self.get_child().show_all()
def __init__(self, builder, settings: "GreeterSettingsCollection"):
Gtk.Dialog.__init__(self, use_header_bar=True)
TranslatableWindow.__init__(self, self)
self.settings = settings
self.listbox = builder.get_object('listbox_add_setting')
for setting in self.settings.additional_settings:
logging.debug("Adding '%s' to additional settings listbox",
setting.id)
self.listbox.add(setting.listboxrow)
self.set_transient_for(self)
self.set_title(_("Additional Settings"))
self.set_default_size(-1, PREFERRED_WIDTH)
sizegroup = Gtk.SizeGroup(Gtk.SizeGroupMode.HORIZONTAL)
accelgroup = Gtk.AccelGroup()
self.add_accel_group(accelgroup)
self.button_cancel = self.add_button(_("Cancel"),
Gtk.ResponseType.CANCEL)
accelgroup.connect(Gdk.KEY_Escape, 0, 0,
self.cb_accelgroup_cancel_activated)
sizegroup.add_widget(self.button_cancel)
self.button_add = self.add_button(_("Add"), Gtk.ResponseType.YES)
Gtk.StyleContext.add_class(self.button_add.get_style_context(),
'suggested-action')
sizegroup.add_widget(self.button_add)
accelgroup.connect(Gdk.KEY_Return, 0, 0,
self.cb_accelgroup_add_activated)
self.button_add.set_visible(False)
self.button_back = Gtk.Button.new_with_label(_("Back"))
self.button_back.set_visible(False)
self.button_back.connect('clicked', self.cb_button_back_clicked, None)
sizegroup.add_widget(self.button_back)
accelgroup.connect(Gdk.KEY_Back, 0, 0,
self.cb_accelgroup_back_activated)
# These key bindings are copied from Firefox, and are the same with
# right-to-left languages.
accelgroup.connect(Gdk.KEY_Left, Gdk.ModifierType.MOD1_MASK, 0,
self.cb_accelgroup_back_activated)
accelgroup.connect(Gdk.KEY_KP_Left, Gdk.ModifierType.MOD1_MASK, 0,
self.cb_accelgroup_back_activated)
self.get_header_bar().pack_end(self.button_back)
self.stack = Gtk.Stack()
self.stack.add_named(self.listbox, "setting-type")
self.listbox.set_valign(Gtk.Align.FILL)
self.listbox.set_vexpand(True)
self.stack.set_visible(True)
# XXX: is SLIDE_LEFT_RIGHT automatically inversed in RTL mode?
self.stack.set_transition_type(
Gtk.StackTransitionType.SLIDE_LEFT_RIGHT)
self.get_content_area().add(self.stack)
# Store translations
self.store_translations(self)
for setting in self.settings.additional_settings:
self.store_translations(setting.box)
def __init__(self, handle, create_jobject=True):
"""Initialise the Activity
handle -- sugar3.activity.activityhandle.ActivityHandle
instance providing the activity id and access to the
presence service which *may* provide sharing for this
application
create_jobject -- boolean
define if it should create a journal object if we are
not resuming
Side effects:
Sets the gdk screen DPI setting (resolution) to the
Sugar screen resolution.
Connects our "destroy" message to our _destroy_cb
method.
Creates a base Gtk.Window within this window.
Creates an ActivityService (self._bus) servicing
this application.
Usage:
If your Activity implements __init__(), it should call
the base class __init()__ before doing Activity specific things.
"""
# Stuff that needs to be done early
icons_path = os.path.join(get_bundle_path(), 'icons')
Gtk.IconTheme.get_default().append_search_path(icons_path)
sugar_theme = 'sugar-72'
if 'SUGAR_SCALING' in os.environ:
if os.environ['SUGAR_SCALING'] == '100':
sugar_theme = 'sugar-100'
# This code can be removed when we grow an xsettings daemon (the GTK+
# init routines will then automatically figure out the font settings)
settings = Gtk.Settings.get_default()
settings.set_property('gtk-theme-name', sugar_theme)
settings.set_property('gtk-icon-theme-name', 'sugar')
settings.set_property('gtk-font-name',
'%s %f' % (style.FONT_FACE, style.FONT_SIZE))
Window.__init__(self)
if 'SUGAR_ACTIVITY_ROOT' in os.environ:
# If this activity runs inside Sugar, we want it to take all the
# screen. Would be better if it was the shell to do this, but we
# haven't found yet a good way to do it there. See #1263.
self.connect('window-state-event', self.__window_state_event_cb)
screen = Gdk.Screen.get_default()
screen.connect('size-changed', self.__screen_size_changed_cb)
self._adapt_window_to_screen()
# process titles will only show 15 characters
# but they get truncated anyway so if more characters
# are supported in the future we will get a better view
# of the processes
proc_title = '%s <%s>' % (get_bundle_name(), handle.activity_id)
util.set_proc_title(proc_title)
self.connect('realize', self.__realize_cb)
self.connect('delete-event', self.__delete_event_cb)
self._active = False
self._active_time = None
self._spent_time = 0
self._activity_id = handle.activity_id
self.shared_activity = None
self._join_id = None
self._updating_jobject = False
self._closing = False
self._quit_requested = False
self._deleting = False
self._max_participants = None
self._invites_queue = []
self._jobject = None
self._read_file_called = False
self._session = _get_session()
self._session.register(self)
self._session.connect('quit-requested',
self.__session_quit_requested_cb)
self._session.connect('quit', self.__session_quit_cb)
accel_group = Gtk.AccelGroup()
self.sugar_accel_group = accel_group
self.add_accel_group(accel_group)
self._bus = ActivityService(self)
self._owns_file = False
share_scope = SCOPE_PRIVATE
if handle.object_id:
self._jobject = datastore.get(handle.object_id)
if 'share-scope' in self._jobject.metadata:
share_scope = self._jobject.metadata['share-scope']
if 'launch-times' in self._jobject.metadata:
self._jobject.metadata['launch-times'] += ', %d' % \
int(time.time())
else:
self._jobject.metadata['launch-times'] = \
str(int(time.time()))
if 'spent-times' in self._jobject.metadata:
self._jobject.metadata['spent-times'] += ', 0'
else:
self._jobject.metadata['spent-times'] = '0'
self.shared_activity = None
self._join_id = None
if handle.object_id is None and create_jobject:
logging.debug('Creating a jobject.')
self._jobject = self._initialize_journal_object()
if handle.invited:
wait_loop = GObject.MainLoop()
self._client_handler = _ClientHandler(
self.get_bundle_id(), partial(self.__got_channel_cb,
wait_loop))
# FIXME: The current API requires that self.shared_activity is set
# before exiting from __init__, so we wait until we have got the
# shared activity. http://bugs.sugarlabs.org/ticket/2168
wait_loop.run()
else:
pservice = presenceservice.get_instance()
mesh_instance = pservice.get_activity(self._activity_id,
warn_if_none=False)
self._set_up_sharing(mesh_instance, share_scope)
if not create_jobject:
self.set_title(get_bundle_name())
return
if self.shared_activity is not None:
self._jobject.metadata['title'] = self.shared_activity.props.name
self._jobject.metadata['icon-color'] = \
self.shared_activity.props.color
else:
self._jobject.metadata.connect('updated',
self.__jobject_updated_cb)
self.set_title(self._jobject.metadata['title'])
def get_widget(self, uri, window):
"""Returns the widgets to display to Caja."""
#Kill old child process
try:
window.nt_lastpid
except AttributeError: #First terminal of the window
window.nt_lastpid = -1
else: #Kill old child
if window.nt_lastpid > 0:
try:
os.kill(window.nt_lastpid, signal.SIGKILL)
except:
pass
finally:
window.nt_lastpid = -1
#Set some variables for new windows
try:
window.nt_termheight
except AttributeError:
window.nt_termheight = -1
try:
window.nt_termhidden
except AttributeError:
window.nt_termhidden = CONF['general_starthidden']
#If it's not a local folder, directory = $HOME
if uri[:7] == "file://":
path = urllib.url2pathname(uri[7:])
else:
path = os.environ.get("HOME")
#Disable for desktop folder
if uri.startswith("x-caja-desktop://"):
return
#White list
if not CONF['folders_showinall'] and \
not match_path(path, CONF['folders_list']):
return
#GUI
gui = Gtk.Builder()
gui.set_translation_domain(__appname__)
gui.add_from_file(TERMINAL_GUI_FILE)
vboxMain = gui.get_object("vboxMain")
#### hboxHidden ####
hboxHidden = gui.get_object("hboxHidden")
if window.nt_termhidden:
hboxHidden.show()
else:
hboxHidden.hide()
btnPref2 = gui.get_object("btnPref2")
btnHide = gui.get_object("btnHide")
btnShow = gui.get_object("btnShow")
#### hboxTerm ####
hboxTerm = gui.get_object("hboxTerm")
if window.nt_termhidden:
hboxTerm.hide()
else:
hboxTerm.show()
btnPref = gui.get_object("btnPref")
sclwinTerm = gui.get_object("sclwinTerm")
#terminal
terminal = Vte.Terminal()
terminal.last_size = window.nt_termheight
self.fork_cmd(window, terminal, sclwinTerm, path)
terminal.show()
sclwinTerm.add(terminal)
#scrollbar
terminal.set_hadjustment(gui.get_object("adjH"))
terminal.set_vadjustment(gui.get_object("adjV"))
if CONF['general_showscrollbar']:
vpolicy = Gtk.PolicyType.ALWAYS
else:
vpolicy = Gtk.PolicyType.NEVER
sclwinTerm.set_policy(
Gtk.PolicyType.NEVER, #Horizontal
vpolicy, #Vertical
)
if window.nt_termheight == -1:
window.nt_termheight = terminal.get_char_height(
) * CONF['general_defheight']
sclwinTerm.set_size_request(-1, window.nt_termheight)
#Apply config on the terminal
self._set_terminal(terminal)
#### evResize ####
evResize = gui.get_object("evResize")
if window.nt_termhidden:
evResize.hide()
else:
evResize.show()
#### Signals ####
#evResize
evResize.connect("enter-notify-event",
self.on_evResize_enter_notify_event, sclwinTerm)
evResize.connect("leave-notify-event",
self.on_evResize_leave_notify_event)
evResize.connect("motion-notify-event",
self.on_evResize_motion_notify_event, sclwinTerm,
terminal, window)
#Button preferences
btnPref.connect("clicked", self.preferences, terminal)
#Button preferences 2
btnPref2.connect("clicked", self.preferences, terminal)
#Button Hide
btnHide.connect(
"clicked",
self.hide,
window,
hboxHidden,
hboxTerm,
evResize,
)
#Button Show
btnShow.connect(
"clicked",
self.show,
window,
hboxHidden,
hboxTerm,
terminal,
evResize,
)
#Terminal
terminal.connect("destroy", self.on_terminal_destroy, window)
terminal.connect("child-exited", self.on_terminal_child_exited)
terminal.connect(
"commit",
self.on_terminal_commit,
window,
sclwinTerm,
path,
)
terminal.connect(
"focus",
self.on_terminal_need_child,
window,
terminal,
sclwinTerm,
path,
)
if Gtk.check_version(3, 0, 0) is None:
terminal.connect(
"draw",
self.on_terminal_need_child,
window,
terminal,
sclwinTerm,
path,
)
else:
terminal.connect(
"expose-event",
self.on_terminal_need_child,
window,
terminal,
sclwinTerm,
path,
)
terminal.connect(
"button-press-event",
self.on_terminal_need_child,
window,
terminal,
sclwinTerm,
path,
)
terminal.connect(
"key-press-event",
self.on_terminal_key_press_event,
window,
sclwinTerm,
path,
)
terminal.connect("key-release-event",
self.on_terminal_key_release_event)
#DnD
try:
# Missing from Gtk-2.0 introspection
terminal.drag_dest_set(
Gtk.DestDefaults.MOTION | Gtk.DestDefaults.HIGHLIGHT
| Gtk.DestDefaults.DROP,
[Gtk.TargetEntry.new('text/uri-list', 0, 80)],
Gdk.DragAction.COPY,
)
terminal.connect("drag_motion", self.on_terminal_drag_motion)
terminal.connect("drag_drop", self.on_terminal_drag_drop)
terminal.connect("drag_data_received",
self.on_terminal_drag_data_received)
except (AttributeError, TypeError):
pass
#### Accel ####
accel_group = Gtk.AccelGroup()
window.add_accel_group(accel_group)
terminal.add_accelerator(
"paste-clipboard",
accel_group,
ord('V'),
Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK,
Gtk.AccelFlags.VISIBLE,
)
terminal.add_accelerator(
"copy-clipboard",
accel_group,
ord('C'),
Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK,
Gtk.AccelFlags.VISIBLE,
)
btnShow.add_accelerator(
"clicked",
accel_group,
ord('T'),
Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK,
Gtk.AccelFlags.VISIBLE,
)
btnHide.add_accelerator(
"clicked",
accel_group,
ord('T'),
Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK,
Gtk.AccelFlags.VISIBLE,
)
#### Return the widgets ####
vboxMain.unparent()
return vboxMain
def do_activate(self):
if self.window:
self.window.present()
return
self.window = Gtk.ApplicationWindow(application=self, title="GNU Health")
self.window.set_default_size(960, 720)
self.window.maximize()
self.window.set_position(Gtk.WindowPosition.CENTER)
self.window.set_resizable(True)
self.window.set_icon(GNUHEALTH_ICON)
self.window.connect("destroy", self.on_quit)
self.window.connect("delete_event", self.on_quit)
self.header = Gtk.HeaderBar.new()
self.header.set_show_close_button(True)
self.window.set_titlebar(self.header)
self.set_title()
menu = Gtk.Button.new()
menu .set_relief(Gtk.ReliefStyle.NONE)
menu.set_image(
common.IconFactory.get_image('tryton-menu', Gtk.IconSize.BUTTON))
menu.connect('clicked', self.menu_toggle)
self.header.pack_start(menu)
favorite = Gtk.MenuButton.new()
favorite.set_relief(Gtk.ReliefStyle.NONE)
favorite.set_image(common.IconFactory.get_image(
'tryton-bookmarks', Gtk.IconSize.BUTTON))
self.menu_favorite = Gtk.Menu.new()
favorite.set_popup(self.menu_favorite)
favorite.connect('clicked', self.favorite_set)
self.header.pack_start(favorite)
self.set_global_search()
self.header.pack_start(self.global_search_entry)
self.accel_group = Gtk.AccelGroup()
self.window.add_accel_group(self.accel_group)
Gtk.AccelMap.add_entry(
'<tryton>/Form/New', Gdk.KEY_N, Gdk.ModifierType.CONTROL_MASK)
Gtk.AccelMap.add_entry(
'<tryton>/Form/Save', Gdk.KEY_S, Gdk.ModifierType.CONTROL_MASK)
Gtk.AccelMap.add_entry(
'<tryton>/Form/Duplicate', Gdk.KEY_D,
Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK)
Gtk.AccelMap.add_entry(
'<tryton>/Form/Delete', Gdk.KEY_D, Gdk.ModifierType.CONTROL_MASK)
Gtk.AccelMap.add_entry(
'<tryton>/Form/Next', Gdk.KEY_Page_Down, 0)
Gtk.AccelMap.add_entry(
'<tryton>/Form/Previous', Gdk.KEY_Page_Up, 0)
Gtk.AccelMap.add_entry(
'<tryton>/Form/Switch View', Gdk.KEY_L,
Gdk.ModifierType.CONTROL_MASK)
Gtk.AccelMap.add_entry(
'<tryton>/Form/Close', Gdk.KEY_W, Gdk.ModifierType.CONTROL_MASK)
Gtk.AccelMap.add_entry(
'<tryton>/Form/Reload', Gdk.KEY_R, Gdk.ModifierType.CONTROL_MASK)
Gtk.AccelMap.add_entry(
'<tryton>/Form/Attachments', Gdk.KEY_T,
Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK)
Gtk.AccelMap.add_entry(
'<tryton>/Form/Notes', Gdk.KEY_O,
Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK)
Gtk.AccelMap.add_entry(
'<tryton>/Form/Relate', Gdk.KEY_R,
Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK)
Gtk.AccelMap.add_entry(
'<tryton>/Form/Actions', Gdk.KEY_E, Gdk.ModifierType.CONTROL_MASK)
Gtk.AccelMap.add_entry(
'<tryton>/Form/Report', Gdk.KEY_P, Gdk.ModifierType.CONTROL_MASK)
Gtk.AccelMap.add_entry(
'<tryton>/Form/Search', Gdk.KEY_F, Gdk.ModifierType.CONTROL_MASK)
Gtk.AccelMap.load(os.path.join(get_config_dir(), 'accel.map'))
self.tooltips = common.Tooltips()
self.vbox = Gtk.VBox()
self.window.add(self.vbox)
self.buttons = {}
self.info = Gtk.VBox()
self.vbox.pack_start(self.info, expand=False, fill=True, padding=0)
self.pane = Gtk.HPaned()
self.vbox.pack_start(self.pane, expand=True, fill=True, padding=0)
self.pane.set_position(int(CONFIG['menu.pane']))
self.menu_screen = None
self.menu = Gtk.VBox()
self.menu.set_vexpand(True)
self.pane.add1(self.menu)
self.notebook = Gtk.Notebook()
self.notebook.popup_enable()
self.notebook.set_scrollable(True)
self.notebook.connect_after('switch-page', self._sig_page_changt)
self.pane.add2(self.notebook)
self.window.show_all()
self.pages = []
self.previous_pages = {}
self.current_page = 0
self.last_page = 0
self.dialogs = []
# Register plugins
tryton.plugins.register()
# GNUHEALTH CLI
self.cli = self.statusbar = self.footer_contents = self.footer = None
self.cli_position = CONFIG['client.cli_position']
self.set_title() # Adds username/profile while password is asked
try:
common.Login()
except Exception as exception:
if (not isinstance(exception, TrytonError)
or exception.faultCode != 'QueryCanceled'):
common.error(exception, traceback.format_exc())
return self.quit()
self.get_preferences()
#GNUHealth Block
#Add connection successful entry to the Activity log
msg = "Connected to GNU Health Server"
self.activity_log_entry(msg, 'info')
# Set the footer
self.init_gnuhealth_env()
def __init__(self, library):
Browser.__init__(self, spacing=6)
self.set_orientation(Gtk.Orientation.VERTICAL)
self.songcontainer = qltk.paned.ConfigRVPaned(
"browsers", "covergrid_pos", 0.4)
if config.getboolean("browsers", "covergrid_wide", False):
self.songcontainer.set_orientation(Gtk.Orientation.HORIZONTAL)
self._register_instance()
if self.__model is None:
self._init_model(library)
self._cover_cancel = Gio.Cancellable()
self.scrollwin = sw = ScrolledWindow()
sw.set_shadow_type(Gtk.ShadowType.IN)
model_sort = AlbumSortModel(model=self.__model)
model_filter = AlbumFilterModel(child_model=model_sort)
self.view = view = IconView(model_filter)
#view.set_item_width(get_cover_size() + 12)
self.view.set_row_spacing(config.getint("browsers", "row_spacing", 6))
self.view.set_column_spacing(config.getint("browsers",
"column_spacing", 6))
self.view.set_item_padding(config.getint("browsers",
"item_padding", 6))
self.view.set_has_tooltip(True)
self.view.connect("query-tooltip", self._show_tooltip)
self.__bg_filter = background_filter()
self.__filter = None
model_filter.set_visible_func(self.__parse_query)
mag = config.getfloat("browsers", "covergrid_magnification", 3.)
self.view.set_item_width(get_cover_size() * mag + 8)
self.__cover = render = Gtk.CellRendererPixbuf()
render.set_property('width', get_cover_size() * mag + 8)
render.set_property('height', get_cover_size() * mag + 8)
view.pack_start(render, False)
def cell_data_pb(view, cell, model, iter_, no_cover):
item = model.get_value(iter_)
if item.album is None:
surface = None
elif item.cover:
pixbuf = item.cover
pixbuf = add_border_widget(pixbuf, self.view)
surface = get_surface_for_pixbuf(self, pixbuf)
# don't cache, too much state has an effect on the result
self.__last_render_surface = None
else:
surface = no_cover
if self.__last_render_surface == surface:
return
self.__last_render_surface = surface
cell.set_property("surface", surface)
view.set_cell_data_func(render, cell_data_pb, self._no_cover)
self.__text_cells = render = Gtk.CellRendererText()
render.set_visible(config.getboolean("browsers", "album_text", True))
render.set_property('alignment', Pango.Alignment.CENTER)
render.set_property('xalign', 0.5)
render.set_property('ellipsize', Pango.EllipsizeMode.END)
view.pack_start(render, False)
def cell_data(view, cell, model, iter_, data):
album = model.get_album(iter_)
if album is None:
text = "<b>%s</b>" % _("All Albums")
text += "\n" + ngettext("%d album", "%d albums",
len(model) - 1) % (len(model) - 1)
markup = text
else:
markup = self.display_pattern % album
if self.__last_render == markup:
return
self.__last_render = markup
cell.markup = markup
cell.set_property('markup', markup)
view.set_cell_data_func(render, cell_data, None)
view.set_selection_mode(Gtk.SelectionMode.MULTIPLE)
sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
sw.add(view)
view.connect('item-activated', self.__play_selection, None)
self.__sig = connect_destroy(
view, 'selection-changed',
util.DeferredSignal(self.__update_songs, owner=self))
targets = [("text/x-quodlibet-songs", Gtk.TargetFlags.SAME_APP, 1),
("text/uri-list", 0, 2)]
targets = [Gtk.TargetEntry.new(*t) for t in targets]
view.drag_source_set(
Gdk.ModifierType.BUTTON1_MASK, targets, Gdk.DragAction.COPY)
view.connect("drag-data-get", self.__drag_data_get) # NOT WORKING
connect_obj(view, 'button-press-event',
self.__rightclick, view, library)
connect_obj(view, 'popup-menu', self.__popup, view, library)
self.accelerators = Gtk.AccelGroup()
search = SearchBarBox(completion=AlbumTagCompletion(),
accel_group=self.accelerators)
search.connect('query-changed', self.__update_filter)
connect_obj(search, 'focus-out', lambda w: w.grab_focus(), view)
self.__search = search
prefs = PreferencesButton(self, model_sort)
search.pack_start(prefs, False, True, 0)
self.pack_start(Align(search, left=6, top=6), False, True, 0)
self.pack_start(sw, True, True, 0)
self.connect("destroy", self.__destroy)
self.enable_row_update(view, sw, self.view)
self.__update_filter()
self.connect('key-press-event', self.__key_pressed, library.librarian)
if app.cover_manager:
connect_destroy(
app.cover_manager, "cover-changed", self._cover_changed)
self.show_all()
def __init__(self, config, application):
"""
:param dict config: The main King Phisher client configuration.
:param application: The application instance to which this window belongs.
:type application: :py:class:`.KingPhisherClientApplication`
"""
assert isinstance(application, Gtk.Application)
super(MainAppWindow, self).__init__(application=application)
self.application = application
self.logger = logging.getLogger('KingPhisher.Client.MainWindow')
self.config = config
"""The main King Phisher client configuration."""
self.set_property('title', 'King Phisher')
vbox = Gtk.Box()
vbox.set_property('orientation', Gtk.Orientation.VERTICAL)
vbox.show()
self.add(vbox)
default_icon_file = find.find_data_file('king-phisher-icon.svg')
if default_icon_file:
icon_pixbuf = GdkPixbuf.Pixbuf.new_from_file(default_icon_file)
self.set_default_icon(icon_pixbuf)
self.accel_group = Gtk.AccelGroup()
self.add_accel_group(self.accel_group)
self.menu_bar = MainMenuBar(application, self)
vbox.pack_start(self.menu_bar.menubar, False, False, 0)
# create notebook and tabs
self.notebook = Gtk.Notebook()
"""The primary :py:class:`Gtk.Notebook` that holds the top level taps of the client GUI."""
self.notebook.connect('switch-page', self.signal_notebook_switch_page)
self.notebook.set_scrollable(True)
vbox.pack_start(self.notebook, True, True, 0)
self.tabs = {}
current_page = self.notebook.get_current_page()
self.last_page_id = current_page
mailer_tab = MailSenderTab(self, self.application)
self.tabs['mailer'] = mailer_tab
self.notebook.insert_page(mailer_tab.box, mailer_tab.label,
current_page + 1)
self.notebook.set_current_page(current_page + 1)
campaign_tab = CampaignViewTab(self, self.application)
campaign_tab.box.show()
self.tabs['campaign'] = campaign_tab
self.notebook.insert_page(campaign_tab.box, campaign_tab.label,
current_page + 2)
self.set_size_request(800, 600)
self.connect('delete-event', self.signal_delete_event)
self.notebook.show()
self.show()
self.rpc = None # needs to be initialized last
"""The :py:class:`.KingPhisherRPCClient` instance."""
self.application.connect('server-connected',
self.signal_kp_server_connected)
self.login_dialog = dialogs.LoginDialog(self.application)
self.login_dialog.dialog.connect('response',
self.signal_login_dialog_response)
self.login_dialog.dialog.show()
def __init__(self, main):
super(MenuBar, self).__init__()
self.main = main
self.gom = self.main.gom
self.uicore = self.main.uicore
agr = Gtk.AccelGroup()
self.main.add_accel_group(agr)
# New KB item
newi = Gtk.ImageMenuItem(Gtk.STOCK_NEW, agr)
#newi.connect("activate", self.new_file)
newi.get_children()[0].set_label('New KB')
key, mod = Gtk.accelerator_parse("<Control>N")
newi.add_accelerator("activate", agr, key,
mod, Gtk.AccelFlags.VISIBLE)
newi.set_sensitive(False)
self.append(newi)
# Save KB item
savei = Gtk.ImageMenuItem(Gtk.STOCK_SAVE)
savei.get_children()[0].set_label('Save')
key, mod = Gtk.accelerator_parse("<Control>S")
savei.add_accelerator("activate", agr, key,
mod, Gtk.AccelFlags.VISIBLE)
savei.connect("activate", self.save_kb)
self.append(savei)
# Load KB item
loadi = Gtk.ImageMenuItem(Gtk.STOCK_OPEN)
loadi.get_children()[0].set_label('Load')
key, mod = Gtk.accelerator_parse("<Control>O")
loadi.add_accelerator("activate", agr, key,
mod, Gtk.AccelFlags.VISIBLE)
loadi.connect("activate", self.load_kb)
self.append(loadi)
# Recent KB items
self.manager = Gtk.RecentManager.get_default()
filter = Gtk.RecentFilter()
filter.add_pattern("*.kb")
recent_menu = Gtk.RecentChooserMenu.new_for_manager(self.manager)
recent_menu.add_filter(filter)
recentm = Gtk.MenuItem('Recent KB')
recentm.set_submenu(recent_menu)
recent_menu.connect('item-activated', self.recent_kb)
self.append(recentm)
# Separator
sep = Gtk.SeparatorMenuItem()
self.append(sep)
# Imports: nmap, host list, w3af and burp...
impi = Gtk.ImageMenuItem(Gtk.STOCK_CONVERT)
#impi.get_children()[0].set_label('Import')
label = impi.get_children()[0]
label.set_markup('<b>Import</b>')
impi.connect('activate', self.import_scan, None)
self.append(impi)
# Host list
imp_hostsi = Gtk.MenuItem('Host list')
imp_hostsi.connect('activate', self.import_scan, 'hosts')
self.append(imp_hostsi)
# Nmap scan
imp_nmapi = Gtk.MenuItem('Nmap XML')
imp_nmapi.connect('activate', self.import_scan, 'nmap')
self.append(imp_nmapi)
# w3af XML
imp_w3afi = Gtk.MenuItem('w3af XML')
imp_w3afi.set_sensitive(False)
self.append(imp_w3afi)
# Burp XML
imp_burpi = Gtk.MenuItem('Burp XML')
imp_burpi.set_sensitive(False)
self.append(imp_burpi)
# Separator
sep = Gtk.SeparatorMenuItem()
self.append(sep)
# Documentation
helpi = Gtk.ImageMenuItem(Gtk.STOCK_HELP, agr)
helpi.get_children()[0].set_label('Documentation')
# key, mod = Gtk.accelerator_parse("<Control>Q")
# helpi.add_accelerator("activate", agr, key,
# mod, Gtk.AccelFlags.VISIBLE)
helpi.connect("activate", self.show_wiki)
self.append(helpi)
# About item
abouti = Gtk.ImageMenuItem(Gtk.STOCK_ABOUT, agr)
abouti.get_children()[0].set_label('About Inguma %s' % glob.version)
key, mod = Gtk.accelerator_parse("<Control>A")
abouti.add_accelerator("activate", agr, key,
mod, Gtk.AccelFlags.VISIBLE)
abouti.connect("activate", self.create_about_dialog)
self.append(abouti)
# Separator
sep = Gtk.SeparatorMenuItem()
self.append(sep)
# Exit item
exit = Gtk.ImageMenuItem(Gtk.STOCK_QUIT, agr)
exit.get_children()[0].set_label('Quit')
key, mod = Gtk.accelerator_parse("<Control>Q")
exit.add_accelerator("activate", agr, key,
mod, Gtk.AccelFlags.VISIBLE)
exit.connect("activate", self.main.menu_quit)
self.append(exit)
def __init__(self, library):
super().__init__(spacing=12)
self.set_orientation(Gtk.Orientation.VERTICAL)
if not self.instances():
self._init(library)
self._register_instance()
self.connect('destroy', self.__destroy)
completion = LibraryTagCompletion(self.__stations)
self.accelerators = Gtk.AccelGroup()
self.__searchbar = search = SearchBarBox(completion=completion,
accel_group=self.accelerators)
search.connect('query-changed', self.__filter_changed)
menu = Gtk.Menu()
new_item = MenuItem(_(u"_New Station…"), Icons.LIST_ADD)
new_item.connect('activate', self.__add)
menu.append(new_item)
update_item = MenuItem(_("_Update Stations"), Icons.VIEW_REFRESH)
update_item.connect('activate', self.__update)
menu.append(update_item)
menu.show_all()
button = MenuButton(SymbolicIconImage(Icons.EMBLEM_SYSTEM,
Gtk.IconSize.MENU),
arrow=True)
button.set_menu(menu)
def focus(widget, *args):
qltk.get_top_parent(widget).songlist.grab_focus()
search.connect('focus-out', focus)
# treeview
scrolled_window = ScrolledWindow()
scrolled_window.show()
scrolled_window.set_shadow_type(Gtk.ShadowType.IN)
self.view = view = AllTreeView()
view.show()
view.set_headers_visible(False)
scrolled_window.set_policy(Gtk.PolicyType.NEVER,
Gtk.PolicyType.AUTOMATIC)
scrolled_window.add(view)
model = Gtk.ListStore(int, str, str, str)
model.append(
row=[self.TYPE_ALL, Icons.FOLDER, "__all",
_("All Stations")])
model.append(row=[self.TYPE_SEP, Icons.FOLDER, "", ""])
# Translators: Favorite radio stations
model.append(
row=[self.TYPE_FAV, Icons.FOLDER, "__fav",
_("Favorites")])
model.append(row=[self.TYPE_SEP, Icons.FOLDER, "", ""])
filters = self.filters
for text, k in sorted([(filters.text(k), k) for k in filters.keys()]):
model.append(row=[self.TYPE_FILTER, Icons.EDIT_FIND, k, text])
model.append(
row=[self.TYPE_NOCAT, Icons.FOLDER, "nocat",
_("No Category")])
def separator(model, iter, data):
return model[iter][self.TYPE] == self.TYPE_SEP
view.set_row_separator_func(separator, None)
def search_func(model, column, key, iter, data):
return key.lower() not in model[iter][column].lower()
view.set_search_column(self.NAME)
view.set_search_equal_func(search_func, None)
column = Gtk.TreeViewColumn("genres")
column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
renderpb = Gtk.CellRendererPixbuf()
renderpb.props.xpad = 3
column.pack_start(renderpb, False)
column.add_attribute(renderpb, "icon-name", self.ICON_NAME)
render = Gtk.CellRendererText()
render.set_property('ellipsize', Pango.EllipsizeMode.END)
view.append_column(column)
column.pack_start(render, True)
column.add_attribute(render, "text", self.NAME)
view.set_model(model)
# selection
selection = view.get_selection()
selection.set_mode(Gtk.SelectionMode.MULTIPLE)
self.__changed_sig = connect_destroy(
selection, 'changed',
util.DeferredSignal(lambda x: self.activate()))
box = Gtk.HBox(spacing=6)
box.pack_start(search, True, True, 0)
box.pack_start(button, False, True, 0)
self._searchbox = Align(box, left=0, right=6, top=6)
self._searchbox.show_all()
def qbar_response(infobar, response_id):
if response_id == infobar.RESPONSE_LOAD:
self.__update()
self.qbar = QuestionBar()
self.qbar.connect("response", qbar_response)
if self._is_library_empty():
self.qbar.show()
pane = qltk.ConfigRHPaned("browsers", "internetradio_pos", 0.4)
pane.show()
pane.pack1(scrolled_window, resize=False, shrink=False)
songbox = Gtk.VBox(spacing=6)
songbox.pack_start(self._searchbox, False, True, 0)
self._songpane_container = Gtk.VBox()
self._songpane_container.show()
songbox.pack_start(self._songpane_container, True, True, 0)
songbox.pack_start(self.qbar, False, True, 0)
songbox.show()
pane.pack2(songbox, resize=True, shrink=False)
self.pack_start(pane, True, True, 0)
self.show()
def __init__(self, oParent, oConfig, sFilterType, sDefaultFilter=None):
super().__init__("Specify Filter", oParent,
Gtk.DialogFlags.DESTROY_WITH_PARENT)
self._oAccelGroup = Gtk.AccelGroup()
self.__oParent = oParent
self.__bWasCancelled = False
self.__oParser = FilterParser.FilterParser()
self.__oConfig = oConfig
self.__sFilterType = sFilterType
self.__oFilter = None
self.__oFilterEditor = FilterEditor(None, self.__sFilterType,
self.__oParser, self)
self.__oFilterEditor.connect_name_changed(self.__name_changed)
self.__sOriginalName = None
self.__sOriginalAST = None
self.set_default_size(700, 550)
self.connect("response", self.__button_response)
self._aDefaultFilters = oConfig.get_default_filters()
# Dialog Buttons
self.add_button("Clear Filter", self.RESPONSE_CLEAR)
self.add_button("Revert Filter", self.RESPONSE_REVERT)
self.add_button("Load", self.RESPONSE_LOAD)
self.add_button("Save", self.RESPONSE_SAVE)
self.add_button("Delete", self.RESPONSE_DELETE)
self.action_area.pack_start(Gtk.VSeparator(), True, True, 0)
self.add_button("_OK", Gtk.ResponseType.OK)
self.add_button("_Cancel", Gtk.ResponseType.CANCEL)
self.vbox.pack_start(self.__oFilterEditor, True, True, 0)
# set initial filter
aDefaultFilters = self.__fetch_filters(True)
aConfigFilters = self.__fetch_filters(False)
if sDefaultFilter:
# Ensure filter isn't broken
# pylint: disable=broad-except
# we do want to catch all exceptions here
try:
oAST = self.__oParser.apply(sDefaultFilter)
except Exception:
# Fall back to usual behaviour
sDefaultFilter = None
if sDefaultFilter:
sName, sFilter = "", sDefaultFilter
oAST = self.__oParser.apply(sFilter)
elif aDefaultFilters:
sName, sFilter = aDefaultFilters[0]
oAST = self.__oParser.apply(sFilter)
elif aConfigFilters:
sName, sFilter = aConfigFilters[0]
oAST = self.__oParser.apply(sFilter)
else:
sName, oAST = "", None
self.__load_filter(sName, oAST)
self.add_accel_group(self._oAccelGroup)
MessageBus.subscribe(MessageBus.Type.CONFIG_MSG, 'replace_filter',
self.replace_filter)
MessageBus.subscribe(MessageBus.Type.CONFIG_MSG, 'add_filter',
self.add_remove_filter)
MessageBus.subscribe(MessageBus.Type.CONFIG_MSG, 'remove_filter',
self.add_remove_filter)
self.show_all()
def on_activate(self, app):
ui_file_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
"app.ui")
appwindow = 'applicationwindow1'
builder = Gtk.Builder()
builder.add_objects_from_file(ui_file_path, [appwindow])
window = builder.get_object(appwindow)
window.set_wmclass ("GNOME Keysign", "GNOME Keysign")
window.set_title("GNOME Keysign")
window.connect("delete-event", self.on_delete_window)
self.headerbar = window.get_titlebar()
self.header_button = builder.get_object("back_refresh_button")
self.header_button.connect('clicked', self.on_header_button_clicked)
self.internet_toggle = builder.get_object("internet_toggle")
self.internet_toggle.connect("toggled", self.on_toggle_clicked)
sw = builder.get_object('stackswitcher1')
# FIXME: I want to be able to press Alt+S and Alt+R respectively
# to switch the stack pages to Send and Receive.
# It's possible when using the Gtk Inspector and modify the
# Switcher's children (ToggleButton and Label) to "use-underscore".
# but it must be possible to do programmatically.
# sw.get_children()
self.stack_switcher = sw
self.send_receive_stack = builder.get_object("send_receive_stack")
self.send_receive_stack.connect('notify::visible-child',
self.on_sr_stack_switch)
## Load Send part
self.send = SendApp()
ss = self.send.stack
p = ss.get_parent()
if p:
p.remove(ss)
ss.connect('notify::visible-child', self.on_send_stack_switch)
ss.connect('map', self.on_send_stack_mapped)
self.send_stack = ss
## End of loading send part
# Load Receive part
try:
self.receive = PswMappingReceiveApp(self.on_presign_mapped)
except NoAvahiDbus as de:
log.info("Probably Avahi needs to be manually started: %s", de)
ui_file_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
"dialog_avahi.ui")
appwindow = 'dialog_avahi'
builder = Gtk.Builder()
builder.add_objects_from_file(ui_file_path, [appwindow])
window.set_wmclass("GNOME Keysign", "GNOME Keysign")
window.set_title("GNOME Keysign")
ok_button = builder.get_object("avahi_ok")
ok_button.connect('clicked', self.on_delete_window)
window = builder.get_object(appwindow)
else:
rs = self.receive.stack
rs.connect('notify::visible-child',
self.on_receive_stack_switch)
scanner = self.receive.scanner
scanner.connect("map", self.on_scanner_mapped)
self.receive_stack = rs
# Hm. Leaving comments for translators does not seem to work
self.send_receive_stack.add_titled(self.send_stack,
"send_stack", _("Send"))
self.send_receive_stack.add_titled(rs,
"receive_stack", _("Receive"))
# These properties must be set after the stacks has been added to the window
# because they require a window element that "receive.ui" file doesn't provide.
accel_group = Gtk.AccelGroup()
window.add_accel_group(accel_group)
self.receive.accept_button.add_accelerator("clicked", accel_group, ord('o'), Gdk.ModifierType.MOD1_MASK,
Gtk.AccelFlags.VISIBLE)
self.receive.accept_button.set_can_default(True)
window.show_all()
self.add_window(window)
def __init__(self, drawing_area, win, uibuilder):
self.log = logging.getLogger('VideoPreviewsController')
self.drawing_area = drawing_area
self.win = win
self.sources = Config.getlist('mix', 'sources')
self.preview_players = {}
self.previews = {}
self.a_btns = {}
self.b_btns = {}
self.current_source = {'a': None, 'b': None}
try:
width = Config.getint('previews', 'width')
self.log.debug('Preview-Width configured to %u', width)
except:
width = 320
self.log.debug('Preview-Width selected as %u', width)
try:
height = Config.getint('previews', 'height')
self.log.debug('Preview-Height configured to %u', height)
except:
height = width * 9 / 16
self.log.debug('Preview-Height calculated to %u', height)
# Accelerators
accelerators = Gtk.AccelGroup()
win.add_accel_group(accelerators)
group_a = None
group_b = None
for idx, source in enumerate(self.sources):
self.log.info('Initializing Video Preview %s', source)
preview = uibuilder.get_check_widget('widget_preview', clone=True)
video = uibuilder.find_widget_recursive(preview, 'video')
video.set_size_request(width, height)
drawing_area.pack_start(preview,
fill=False,
expand=False,
padding=0)
player = VideoDisplay(video, port=13000 + idx)
uibuilder.find_widget_recursive(preview, 'label').set_label(source)
btn_a = uibuilder.find_widget_recursive(preview, 'btn_a')
btn_b = uibuilder.find_widget_recursive(preview, 'btn_b')
btn_a.set_name("%c %u" % ('a', idx))
btn_b.set_name("%c %u" % ('b', idx))
if not group_a:
group_a = btn_a
else:
btn_a.join_group(group_a)
if not group_b:
group_b = btn_b
else:
btn_b.join_group(group_b)
btn_a.connect('toggled', self.btn_toggled)
btn_b.connect('toggled', self.btn_toggled)
key, mod = Gtk.accelerator_parse('%u' % (idx + 1))
btn_a.add_accelerator('activate', accelerators, key, mod,
Gtk.AccelFlags.VISIBLE)
key, mod = Gtk.accelerator_parse('<Ctrl>%u' % (idx + 1))
btn_b.add_accelerator('activate', accelerators, key, mod,
Gtk.AccelFlags.VISIBLE)
btn_fullscreen = uibuilder.find_widget_recursive(
preview, 'btn_fullscreen')
btn_fullscreen.set_name("%c %u" % ('f', idx))
btn_fullscreen.connect('clicked', self.btn_fullscreen_clicked)
self.preview_players[source] = player
self.previews[source] = preview
self.a_btns[source] = btn_a
self.b_btns[source] = btn_b
# connect event-handler and request initial state
Connection.on('video_status', self.on_video_status)
Connection.send('get_video')
def _create_accel_group(self):
self._accel_group = Gtk.AccelGroup()
shortcut = self._gsettings.get_string(GSETTINGS_KEYBINDINGS)
key, mod = Gtk.accelerator_parse(shortcut)
self._accel_group.connect(key, mod, Gtk.AccelFlags.VISIBLE,
self._open_terminal)
