def show_screenshot(self, widget, event):
'''
Creates and displays a dialog with the screenshot image
'''
height = Gdk.Screen().get_default().get_height()
width = Gdk.Screen().get_default().get_width()
pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size(
SCREENSHOT_PATH, width * 0.5, height * 0.5)
image = Gtk.Image.new_from_pixbuf(pixbuf)
dialog = KanoDialog(
_("Screenshot"), # noqa: F821
widget=image)
dialog.run()
def css_style(style):
css = Gtk.CssProvider()
css.load_from_data(css_style_dark if style == 1 else css_style_light)
screen = Gdk.Screen()
style_context = Gtk.StyleContext()
style_context.add_provider_for_screen(
screen.get_default(), css, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
def __init__(self):
Gtk.Window.__init__(self, title="ArFedora Terminal")
self.resize(800, 400)
scrolledwindow = Gtk.ScrolledWindow()
self.add(scrolledwindow)
self.terminal = Vte.Terminal()
self.terminal.connect("eof", self.quit_)
self.terminal.set_color_background(
Gdk.RGBA(red=0.180392,
green=0.203922,
blue=0.211765,
alpha=1.000000))
self.terminal.set_color_foreground(
Gdk.RGBA(red=0.988235,
green=0.913725,
blue=0.309804,
alpha=1.000000))
self.terminal.set_allow_hyperlink(True)
vadjustment = self.terminal.get_vadjustment()
scrolledwindow.set_vadjustment(vadjustment)
user_info = pwd.getpwuid(os.geteuid())
self.terminal.spawn_sync(Vte.PtyFlags.DEFAULT, user_info.pw_dir,
[user_info.pw_shell], [],
GLib.SpawnFlags.DO_NOT_REAP_CHILD, None, None)
self.terminal.connect("button-release-event", self.on_button_event)
self.menu = Gtk.Menu()
self.menu.set_screen(Gdk.Screen().get_default())
copytextmenuitem = Gtk.MenuItem("Copy")
pastetextmenuitem = Gtk.MenuItem("Paste")
fontsizemenuitem = Gtk.MenuItem("Font")
cursorshapemenuitem = Gtk.MenuItem("Cursor Shape")
cursorcolormenuitem = Gtk.MenuItem("Cursor Color")
backgroundmenuitem = Gtk.MenuItem("Backgound Color")
foregroundmenuitem = Gtk.MenuItem("Foreground Color")
copytextmenuitem.connect("activate", self.copy_text)
pastetextmenuitem.connect("activate", self.paste_text)
fontsizemenuitem.connect("activate", self.font_change)
cursorshapemenuitem.connect("activate", self.cursor_shape)
cursorcolormenuitem.connect("activate",
self.on_cursor_menuitem_activated)
backgroundmenuitem.connect("activate",
self.on_background_menuitem_activated)
foregroundmenuitem.connect("activate",
self.on_foreground_menuitem_activated)
self.menu.append(copytextmenuitem)
self.menu.append(pastetextmenuitem)
self.menu.append(fontsizemenuitem)
self.menu.append(cursorshapemenuitem)
self.menu.append(cursorcolormenuitem)
self.menu.append(backgroundmenuitem)
self.menu.append(foregroundmenuitem)
scrolledwindow.add(self.terminal)
def usar_estilo(self):
css_provider = Gtk.CssProvider()
css_provider.load_from_path('static/imagens/estilo_calculadora.css')
screen = Gdk.Screen()
style_context = Gtk.StyleContext()
style_context.add_provider_for_screen(
screen.get_default(), css_provider,
Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
def temp1():
global xx, yy, ad
xx += .4
root.move(yy, xx)
if xx >= gdk.Screen().height() / 2 - 150:
glib.timeout_add(1.8, temp3)
return False
return True
def style_application(self, *args):
style = "/home/michael/iq-option/style/class.css"
css_provider = Gtk.CssProvider()
css_provider.load_from_path(style)
screen = Gdk.Screen()
style_context = Gtk.StyleContext()
style_context.add_provider_for_screen(
screen.get_default(), css_provider,
Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
def on_report_chosen(widget, format, path):
self.report_chooser = None
reports.simple(self.facts, start, end, format, path)
if format == ("html"):
webbrowser.open_new("file://%s" % path)
else:
try:
gtk.show_uri(gdk.Screen(), "file://%s" % os.path.split(path)[0], 0)
except:
pass # bug 626656 - no use in capturing this one i think
def _set_custom_css(file):
css_provider = Gtk.CssProvider.new()
css_provider.load_from_path(path=file)
screen = Gdk.Screen()
style_context = Gtk.StyleContext.new()
style_context.add_provider_for_screen(
screen=screen.get_default(),
provider=css_provider,
priority=Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION,
)
def __init__(self):
# Dynamic Resolution Scaling
self.monitor = Gdk.Screen()
self.monitor.connect("size-changed", self.resize)
# Newer versions of pygtk have this method
try:
self.monitor.connect("monitors-changed", self.resize)
except:
pass
# Launch Banner
self.config = self.configure()
self.execute(self.config)
def launch_url (url, ext=""):
if os.name == 'nt':
os.startfile(url)
elif os.name == 'posix':
try:
Gtk.show_uri(Gdk.Screen(),url,0)
except GObject.GError as err:
#print dir(err)
label = _('Unable to open URL')
for reg, msg in [('mailto:',_('Unable to launch mail reader.')),
('http:',_('Unable to open website.')),
('file:',_('Unable to open file.'))]:
if re.match(reg,url.lower()): label = msg
dialog_extras.show_message(
label=label,
sublabel=err.message,
expander=[_('_Details'),
_("There was an error launching the url: %s"%url)]
)
def animation():
global xx, yy, kk
yy = gdk.Screen().width() / 2 - 150
def temp1():
global xx, yy, ad
xx += .4
root.move(yy, xx)
if xx >= gdk.Screen().height() / 2 - 150:
glib.timeout_add(1.8, temp3)
return False
return True
def temp3():
global store1
store1 += .4
root.set_size_request(store1, 0)
if store1 >= 300:
glib.timeout_add(1.8, temp2)
return False
return True
def temp2():
global kk, image2, image, ebox, vbox, plab, elab, store1
kk += .4
root.set_size_request(store1, kk)
if kk >= 20:
image.show()
if kk >= 140:
plab.show()
if kk >= 170:
elab.show()
if kk >= 210:
image2.show()
if kk >= 300:
root.show_all()
return False
return True
glib.timeout_add(1.8, temp1)
def on_darkmode_toggled(self, source_object):
"""Callback for when the menubutton Dark is toggled. """
settings = Gtk.Settings().get_default()
dark = source_object.get_active()
if settings.props.gtk_theme_name == "Adwaita":
if dark:
settings.props.gtk_application_prefer_dark_theme = True
else:
settings.props.gtk_application_prefer_dark_theme = False
else:
# Non-standard theme, use fallback style provider
style_context = self.get_style_context()
screen = Gdk.Screen().get_default()
if dark:
style_context.add_provider_for_screen(
screen, self.dark_fallback_provider, Gtk.STYLE_PROVIDER_PRIORITY_USER)
else:
style_context.remove_provider_for_screen(
screen, self.dark_fallback_provider)
for buf in self.buffers:
buf.update_buffer_default_color()
buf.emit("notifyLevelChanged")
STATE.set_dark(dark)
def __init__(self):
h = Gdk.Screen().height()
w = Gdk.Screen.width()
Gtk.Window.__init__(self, title="Gitmarks")
self.props.resizable = True
self.props.default_width = w / 3
self.props.default_height = h
self.status_bar = Gtk.Statusbar.new()
self.tree_view = None
self.item_list = None
gm_dispatcher = dispatcher.Dispatcher()
ofh = OpenFileHandler(self, self.status_bar, gm_dispatcher)
handlers = [ofh]
gm_dispatcher.load_handlers(handlers)
self.vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=3)
self.hbox = Gtk.Paned(orientation=Gtk.Orientation.HORIZONTAL)
self.add(self.vbox)
hb_factory = widgets.HeaderBar(gm_dispatcher)
header_bar = hb_factory.make_headerbar("Gitmarks")
self.profile_label = hb_factory.get_profile_label()
self.set_titlebar(header_bar)
self.vbox.pack_start(self.hbox, True, True, 0)
self.vbox.pack_end(self.status_bar, False, True, 0)
self.connect("delete-event", Gtk.main_quit)
self.gio_settings = settings.GitmarksSettings().create_gio_settings(
GLib.get_current_dir())
if self.init_settings() is None:
sys.exit(0)
def __init__(self):
Gtk.Window.__init__(self, title="Vte Bash Prompt Generator")
self.maximize()
self.clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
self.current = ""
mainscrolledwindow = Gtk.ScrolledWindow()
self.mainbox = Gtk.HBox(spacing=10)
mainscrolledwindow.add(self.mainbox)
self.tbox = Gtk.VBox(spacing=10)
####################################
self.bg_color = Gdk.RGBA(red=0.180392,
green=0.203922,
blue=0.211765,
alpha=1.000000)
self.fontsize = []
self.cursorshape = [0]
self.cursorcolor = Gdk.RGBA(red=1.000000,
green=1.000000,
blue=1.000000,
alpha=1.000000)
#self.foreground = Gdk.RGBA(red=1.000000, green=1.000000, blue=1.000000, alpha=1.000000)
####################################
self.add(mainscrolledwindow)
fbox1 = Gtk.HBox()
flowbox1 = Gtk.FlowBox()
flowbox1.props.homogeneous = True
flowbox1.set_valign(Gtk.Align.START)
flowbox1.set_max_children_per_line(1)
flowbox1.set_selection_mode(Gtk.SelectionMode.NONE)
fbox1.pack_start(flowbox1, False, False, 0)
self.mainbox.pack_start(fbox1, False, False, 0)
self.mainbox.pack_start(self.tbox, True, True, 0)
fbox2 = Gtk.HBox()
flowbox2 = Gtk.FlowBox()
flowbox2.props.homogeneous = True
flowbox2.set_valign(Gtk.Align.START)
flowbox2.set_max_children_per_line(1)
flowbox2.set_selection_mode(Gtk.SelectionMode.NONE)
fbox2.pack_start(flowbox2, False, False, 0)
self.mainbox.pack_start(fbox2, False, False, 0)
flowbox3 = Gtk.FlowBox()
flowbox3.props.homogeneous = True
flowbox3.set_valign(Gtk.Align.START)
flowbox3.set_max_children_per_line(1)
flowbox3.set_selection_mode(Gtk.SelectionMode.NONE)
fbox1.pack_start(flowbox3, False, False, 0)
flowbox4 = Gtk.FlowBox()
flowbox4.props.homogeneous = True
flowbox4.set_valign(Gtk.Align.START)
flowbox4.set_max_children_per_line(1)
flowbox4.set_selection_mode(Gtk.SelectionMode.NONE)
fbox2.pack_start(flowbox4, False, False, 0)
for k, v in COLORS.items():
b = Gtk.Button(k)
b.connect("clicked", self.color_bg__button_clicked, v)
flowbox1.add(b)
for k, v in BG_COLORS.items():
b = Gtk.Button("bg {}".format(k))
b.connect("clicked", self.color_bg__button_clicked, v)
flowbox2.add(b)
for k, v in OPTIONS1.items():
b = Gtk.Button(k)
b.connect("clicked", self.color_bg__button_clicked, v)
flowbox3.add(b)
for k, v in OPTIONS2.items():
b = Gtk.Button(k)
b.connect("clicked", self.color_bg__button_clicked, v)
flowbox4.add(b)
self.entry = Gtk.Entry()
self.entry.props.placeholder_text = "Enter PS1..."
self.entry_buffer = self.entry.get_buffer()
self.tbox.pack_start(self.entry, False, False, 0)
self.entry.connect("notify::text", self.on_entry_text_changed)
self.entry.props.margin = 10
self.entry.set_icon_from_icon_name(Gtk.EntryIconPosition(0),
"edit-copy")
self.entry.set_icon_from_icon_name(Gtk.EntryIconPosition(1),
"edit-clear")
#self.entry.set_icon_from_gicon(Gtk.EntryIconPosition(1),Gio.ThemedIcon(name="applications-multimedia"))
self.entry.set_icon_tooltip_markup(Gtk.EntryIconPosition(0), "Copy")
self.entry.connect("icon-press", self.on_copy_pressed)
self.menu = Gtk.Menu()
self.menu.set_screen(Gdk.Screen().get_default())
fontsizemenuitem = Gtk.MenuItem("Font")
cursorshapemenuitem = Gtk.MenuItem("Cursor Shape")
cursorcolormenuitem = Gtk.MenuItem("Cursor Color")
backgroundmenuitem = Gtk.MenuItem("Backgound Color")
#foregroundmenuitem = Gtk.MenuItem("Foreground Color")
fontsizemenuitem.connect("activate", self.font_change)
cursorshapemenuitem.connect("activate", self.cursor_shape)
cursorcolormenuitem.connect("activate",
self.on_cursor_menuitem_activated)
backgroundmenuitem.connect("activate",
self.on_background_menuitem_activated)
#foregroundmenuitem.connect("activate", self.on_foreground_menuitem_activated)
self.menu.append(fontsizemenuitem)
self.menu.append(cursorshapemenuitem)
self.menu.append(cursorcolormenuitem)
self.menu.append(backgroundmenuitem)
#self.menu.append(foregroundmenuitem)
self.terminal_gui()
def __init__(self, settings, paths, index):
"""Create the necessary objects and settings.
Args:
settings: Settings from configfiles to use.
paths: Paths received from the parser.
index: Current position in paths.
"""
Gtk.Window.__init__(self)
self.connect('destroy', Gtk.main_quit)
# Own stuff
general = settings["GENERAL"]
self.directory = os.path.expanduser("~/.vimiv")
self.paths = paths
self.index = index
self.set_icon_name("vimiv")
# Sceen and window size
screen = Gdk.Screen()
self.screensize = [screen.width(), screen.height()]
try:
winsize = general["geometry"].split("x")
self.winsize = (int(winsize[0]), int(winsize[1]))
self.resize(self.winsize[0], self.winsize[1])
except:
self.winsize = (800, 600)
self.resize(self.winsize[0], self.winsize[1])
# Generate Window structure
# Grid in which everything gets packed
self.main_grid = Gtk.Grid()
# Other classes
self.keyhandler = KeyHandler(self, settings)
self.commandline = CommandLine(self, settings)
self.tags = TagHandler(self)
self.mark = Mark(self, settings)
self.fileextras = FileExtras(self)
self.statusbar = Statusbar(self, settings)
self.completions = VimivComplete(self)
self.slideshow = Slideshow(self, settings)
self.image = Image(self, settings)
self.library = Library(self, settings)
self.thumbnail = Thumbnail(self, settings)
self.manipulate = Manipulate(self, settings)
self.window = Window(self, settings)
self.information = Information()
Commands(self, settings)
# Pack library, statusbar and manipulate
self.main_grid.attach(self.library.grid, 0, 0, 1, 1)
self.main_grid.attach(self.image.scrolled_win, 1, 0, 1, 1)
self.main_grid.attach(self.manipulate.scrolled_win, 0, 1, 2, 1)
self.main_grid.attach(self.statusbar.bar, 0, 2, 2, 1)
# Overlay contains grid mainly and adds commandline as floating
self.overlay = Gtk.Overlay()
self.overlay.add(self.main_grid)
self.overlay.add_overlay(self.commandline.grid)
self.add(self.overlay)
def on_email(about, mail):
Gtk.show_uri(Gdk.Screen(), "mailto:%s" % mail, 0L)
def on_url(about, link):
Gtk.show_uri(Gdk.Screen(), link, 0L)
from gi.repository import GtkSource
from sugar3 import env
from sugar3.graphics import style
from sugar3.graphics.icon import Icon
from sugar3.graphics.alert import Alert
from sugar3.graphics.alert import TimeoutAlert
from sugar3.graphics.palette import Palette
from sugar3.graphics.palette import ToolInvoker
from sugar3.graphics.toolbutton import ToolButton
from sugar3.graphics.toolbarbox import ToolbarBox
from sugar3.graphics.palettemenu import PaletteMenuBox
from sugar3.graphics.palettemenu import PaletteMenuItem
from sugar3.graphics.toggletoolbutton import ToggleToolButton
screen = Gdk.Screen().get_default()
WIDTH = (screen.get_width() / 6) * 5
HEIGHT = (screen.get_height() / 6) * 5
DEFAULT_FONTS = ['Sans', 'Serif', 'Monospace']
USER_FONTS_FILE_PATH = env.get_profile_path('fonts')
GLOBAL_FONTS_FILE_PATH = '/etc/sugar_fonts'
class FileChooserOpen(Gtk.Window):
__gsignals__ = {'open-file': (GObject.SIGNAL_RUN_FIRST, None, [str])}
def __init__(self, activity, folder=None):
Gtk.Window.__init__(self)
def __init__(self, application):
"""
Initialises the main window
"""
super().__init__(application=application)
self.api = API()
self.store = DataStore()
self.city = None
self.city_tz = "UTC"
self.currentWeather = None
self.forecastWeather = []
self.chartData = []
self.historyWeather = []
self.historyChartData = []
self.LH = 0
self.LW = 0
# Background image
self.overlay = Gtk.Overlay()
self.add(self.overlay)
self.bg = Gtk.Image()
scrollable_wrapper = Gtk.ScrolledWindow()
scrollable_wrapper.add(self.bg)
scrollable_wrapper.set_size_request(DEFAULT_SCREEN_WIDTH,
DEFAULT_SCREEN_HEIGHT)
self.overlay.add(scrollable_wrapper)
# Header
header = Gtk.HeaderBar()
header.set_show_close_button(True)
header.props.title = "Halo"
self.set_titlebar(header)
refresh_btn = Gtk.Button(label=None,
image=Gtk.Image(
icon_name='view-refresh-symbolic',
icon_size=Gtk.IconSize.BUTTON))
refresh_btn.connect("clicked", self.refresh)
# Dropdown menu
menubar = Gtk.MenuBar()
ac_grp = Gtk.AccelGroup()
self.add_accel_group(ac_grp)
menu = Gtk.ImageMenuItem()
menu.set_image(
Gtk.Image(icon_name='view-more-symbolic',
icon_size=Gtk.IconSize.MENU))
menu.set_always_show_image(True)
menu_dropdown = Gtk.Menu()
menu_refresh = Gtk.MenuItem("Refresh", ac_grp)
menu_preference = Gtk.MenuItem("Preference")
menu_city_change = Gtk.MenuItem("Change City")
menu_about = Gtk.MenuItem("About")
menu_exit = Gtk.MenuItem("Exit")
menu_refresh.add_accelerator("activate", ac_grp, ord('R'),
Gdk.ModifierType.CONTROL_MASK,
Gtk.AccelFlags.VISIBLE)
menu_city_change.add_accelerator("activate", ac_grp, ord('C'), 0,
Gtk.AccelFlags.VISIBLE)
menu_refresh.connect('activate', self.refresh)
menu_preference.connect('activate', self.show_preference)
menu_city_change.connect('activate', self.switch_city)
menu_about.connect('activate', self.show_about)
menu_exit.connect('activate', lambda w: application.quit())
menu_dropdown.append(menu_refresh)
menu_dropdown.append(menu_preference)
menu_dropdown.append(menu_city_change)
menu_dropdown.append(menu_about)
menu_dropdown.append(Gtk.SeparatorMenuItem())
menu_dropdown.append(menu_exit)
menu.set_submenu(menu_dropdown)
menubar.append(menu)
header.pack_end(menubar)
header.pack_end(refresh_btn)
# Weather Panel
tm = Gtk.Box(spacing=0)
left = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)
right = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=5)
top = Gtk.Box(spacing=10)
view = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)
left.set_homogeneous(False)
right.set_homogeneous(False)
self.icon = Gtk.Image()
self.place = Gtk.Label()
self.status = Gtk.Label()
self.temperature = Gtk.Label()
self.time = Gtk.Label()
self.t_follow = Gtk.Label()
self.date = Gtk.Label()
self.time.set_alignment(0, 1)
self.t_follow.set_alignment(0, 1)
self.date.set_alignment(0, 0)
self.icon.set_alignment(1, 0)
self.status.set_alignment(1, 0)
self.place.set_alignment(1, 0)
self.temperature.set_alignment(1, 0)
self.time.set_name("time")
self.t_follow.set_name("t_follow")
self.date.set_name("date")
self.status.set_name("status")
self.place.set_name("place")
self.temperature.set_name("temperature")
view.set_name("box")
tm.pack_start(self.time, False, False, 2)
tm.pack_start(self.t_follow, False, False, 2)
left.pack_start(tm, False, False, 0)
left.pack_start(self.date, False, False, 0)
right.pack_start(self.icon, False, False, 0)
right.pack_start(self.status, False, False, 0)
right.pack_start(self.place, False, False, 0)
right.pack_start(self.temperature, False, False, 10)
top.pack_start(left, True, True, 20)
top.pack_start(right, True, True, 20)
# Summary and Trend View
switcher = Gtk.StackSwitcher()
stack_area = Gtk.Stack()
self.forecastArea = SummaryView()
self.historyArea = SummaryView(True)
stack_area.add_titled(self.historyArea.get_view(), "history",
"History")
stack_area.add_titled(self.forecastArea.get_view(), "forecast",
"Forecast")
stack_area.set_transition_type(
Gtk.StackTransitionType.SLIDE_LEFT_RIGHT)
stack_area.set_transition_duration(150)
stack_area.set_homogeneous(True)
switcher.set_name("toggle")
switcher.set_opacity(0.92)
switcher.set_stack(stack_area)
sw_b = Gtk.Box(spacing=10)
sw_b.pack_start(switcher, False, False, 25)
view.pack_start(top, True, True, 10)
view.pack_start(sw_b, False, False, 0)
view.pack_start(stack_area, False, False, 0)
self.overlay.add_overlay(view)
# Styling
screen = Gdk.Screen().get_default()
css_provider = Gtk.CssProvider()
css_provider.load_from_path(BASE + '/style.css')
context = Gtk.StyleContext()
context.add_provider_for_screen(screen, css_provider,
Gtk.STYLE_PROVIDER_PRIORITY_USER)
self.set_default_size(DataStore.get_width(), DataStore.get_height())
self.set_position(Gtk.WindowPosition.CENTER)
self.connect(
'size-allocate', lambda w, rect: GObject.idle_add(
self.win_resize, rect, priority=GLib.PRIORITY_HIGH))
self.set_icon_from_file(BASE + "/assets/halo.svg")
self.show_all()
GObject.timeout_add_seconds(2, self.update_time)
GObject.idle_add(self.refresh)
stack_area.set_visible_child_name("forecast")
def __init__(self, handle):
super(RulerActivity, self).__init__(handle)
self.button_dict = {}
self.callback_dict = {}
self._ready = False
font = 'helvetica 12'
font_bold = 'helvetica bold 12'
#
# We need a canvas
#
self._canvas = MyCanvas()
self.set_canvas(self._canvas)
self._canvas.show()
screen = Gdk.Screen()
width = screen.width()
height = screen.height() - GRID_CELL_SIZE
dpi, self.known_dpi = calc_dpi()
self._canvas.set_dpi(dpi)
# Create instances of our graphics
self._r = show_rulers.ScreenOfRulers(font, font_bold, width, height)
self._gcm = show_grids.ScreenGrid_cm(font, font_bold, width, height)
self._gmm = show_grids.ScreenGrid_mm(font, font_bold, width, height)
self._a90 = show_angles.Angles90(font, font_bold, width, height)
self._a360 = show_angles.Angles360(font, font_bold, width, height)
self._c = show_checkers.ScreenOfCircles(font, font_bold, width, height)
# start with a ruler
self._current = self._r
self._canvas.add_a_ruler(self._current)
# other settings
self._grids_mode = "cm"
self._angles_mode = "90"
#
# We need some toolbars
#
self.max_participants = 1
toolbar_box = ToolbarBox()
# Buttons added to the Activity toolbar
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
self.rulers = radio_factory('ruler',
toolbar_box.toolbar,
self._rulers_cb,
tooltip=_('Ruler'),
group=None)
self.grids = radio_factory('grid-a',
toolbar_box.toolbar,
self._grids_cb,
tooltip=_('Grid'),
group=self.rulers)
self.angles = radio_factory('angles-90',
toolbar_box.toolbar,
self._angles_cb,
tooltip=_('Angles'),
group=self.rulers)
self.checker = radio_factory('checker',
toolbar_box.toolbar,
self._checker_cb,
tooltip=_('Checker'),
group=self.rulers)
self.wrapper = Gtk.ToolItem()
self.wrapper2 = Gtk.ToolItem()
self.wrapper3 = Gtk.ToolItem()
self.custom_unit_entry = Gtk.Entry()
self.txt1 = Gtk.Label()
self.txt1.set_text(_('1 custom unit equals '))
self.txt2 = Gtk.Label()
# TRANS: mm is for Milli Meters
self.txt2.set_text(_(' mm.'))
self.wrapper.add(self.txt1)
self.wrapper2.add(self.custom_unit_entry)
self.wrapper3.add(self.txt2)
self.wrapper.show_all()
self.wrapper2.show_all()
self.wrapper3.show_all()
separator = Gtk.SeparatorToolItem()
separator.props.draw = True
separator.set_expand(False)
separator.show()
toolbar_box.toolbar.insert(separator, -1)
custom_units_toolbox = ToolbarBox()
custom_units_toolbox.toolbar.insert(self.wrapper, -1)
custom_units_toolbox.toolbar.insert(self.wrapper2, -1)
custom_units_toolbox.toolbar.insert(self.wrapper3, -1)
custom_units_toolbox.show()
self.custom_units_button = ToolbarButton(icon_name='view-source',
page=custom_units_toolbox)
toolbar_box.toolbar.insert(self.custom_units_button, -1)
self.custom_unit_entry.connect('changed', self.custom_unit_change_cb)
self.custom_units_button.show()
if not self.known_dpi:
separator = Gtk.SeparatorToolItem()
separator.show()
toolbar_box.toolbar.insert(separator, -1)
dpi = self._canvas.get_dpi()
self._dpi_spin_adj = Gtk.Adjustment(dpi, 72, 200, 2, 32, 0)
self._dpi_spin = Gtk.SpinButton(self._dpi_spin_adj, 0, 0)
self._dpi_spin_id = self._dpi_spin.connect('value-changed',
self._dpi_spin_cb)
self._dpi_spin.set_numeric(True)
self._dpi_spin.show()
self.tool_item_dpi = Gtk.ToolItem()
self.tool_item_dpi.add(self._dpi_spin)
toolbar_box.toolbar.insert(self.tool_item_dpi, -1)
self.tool_item_dpi.show()
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
separator.show()
toolbar_box.toolbar.insert(separator, -1)
# The ever-present Stop Button
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl>Q'
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
self.show_all()
# Restore state if previously saved
self._ready = True
if 'ruler' in self.metadata and \
self.metadata['ruler'] in self.button_dict:
_logger.debug('restoring %s', self.metadata['ruler'])
self.button_dict[self.metadata['ruler']].set_active(True)
self.callback_dict[self.metadata['ruler']]
else:
self._rulers_cb()
self.rulers.set_active(True)
if 'custom_unit' in self.metadata:
self.custom_unit_entry.set_text(self.metadata['custom_unit'])
else: # set the default
self.custom_unit_entry.set_text("25.4")
def init(self):
self.all_category = {}
self.switchcategory = {}
self.sw = Gtk.ScrolledWindow()
self.maincontainer = Gtk.VBox()
self.grid = Gtk.Grid()
self.stack = Gtk.Stack()
self.stack.set_hexpand(True)
self.stack.set_vexpand(True)
self.listbox_ = Gtk.ListBox()
self.grid.attach(self.listbox_, 0, 0, 1, 1)
self.grid.attach(self.stack, 1, 0, 1, 1)
self.maincontainer.add(self.grid)
self.sw.add(self.maincontainer)
self.add(self.sw)
self.loading_all_plugins()
self.listbox_.connect("row-activated", self.on_activated_row)
try:
gi.require_version('Vte', '2.91')
from gi.repository import Vte
tscrolledwindow = Gtk.ScrolledWindow()
self.terminal = Vte.Terminal()
#self.terminal.set_color_background(Gdk.RGBA(red=0.180392, green=0.203922, blue=0.211765, alpha=1.000000))
self.terminal.set_color_foreground(
Gdk.RGBA(red=0.988235,
green=0.913725,
blue=0.309804,
alpha=1.000000))
vadjustment = self.terminal.get_vadjustment()
tscrolledwindow.set_vadjustment(vadjustment)
_pty = Vte.Pty.new_sync(Vte.PtyFlags(0), None)
_pty.child_setup()
self.terminal.set_pty(_pty)
self.terminal.connect("button-release-event", self.on_button_event)
self.menu = Gtk.Menu()
self.menu.set_screen(Gdk.Screen().get_default())
self.copytextmenuitem = Gtk.MenuItem.new_with_label("Copy")
cursorcolormenuitem = Gtk.MenuItem.new_with_label("Cursor Color")
backgroundmenuitem = Gtk.MenuItem.new_with_label("Backgound Color")
foregroundmenuitem = Gtk.MenuItem.new_with_label(
"Foreground Color")
self.copytextmenuitem.connect("activate", self.copy_text)
cursorcolormenuitem.connect("activate",
self.on_cursor_menuitem_activated)
backgroundmenuitem.connect("activate",
self.on_background_menuitem_activated)
foregroundmenuitem.connect("activate",
self.on_foreground_menuitem_activated)
self.menu.append(self.copytextmenuitem)
self.menu.append(cursorcolormenuitem)
self.menu.append(backgroundmenuitem)
self.menu.append(foregroundmenuitem)
self.vte_format = Vte.Format(1)
tscrolledwindow.add(self.terminal)
self.maincontainer.pack_end(tscrolledwindow, True, True, 0)
except Exception as e:
print(e)
self.show_all()
log = logging.getLogger(__name__)
def create_non_gtk_widgets():
sv = GtkSource.View()
sv.destroy()
# Can we do this during install?
def create_user_dirs():
log.info('Ensuring data directories exist.')
# TODO: Loading screen for starting db, creating user dirs etc?
if __name__ == '__main__':
create_user_dirs()
log.info('Bootstrapping gtk resources.')
create_non_gtk_widgets()
css_provider = Gtk.CssProvider()
css_provider.load_from_path('ui/style.css')
Gtk.StyleContext().add_provider_for_screen(
Gdk.Screen().get_default(), css_provider,
Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
MainWindow()
log.info('Starting application.')
Gtk.main()
def __init__(self, message="UNCLASSIFIED", fgcolor="#FFFFFF",
bgcolor="#007A33", font="liberation-sans", size="small",
weight="bold", x=0, y=0, esc=True, opacity=0.75,
sys_info=False):
"""Set up and display the main window
Keyword arguments:
message -- The classification level to display
fgcolor -- Foreground color of the text to display
bgcolor -- Background color of the banner the text is against
font -- Font type to use for the displayed text
size -- Size of font to use for text
weight -- Bold or normal
hres -- Horizontal Screen Resolution (int) [ requires vres ]
vres -- Vertical Screen Resolution (int) [ requires hres ]
opacity -- Opacity of window (float) [0 .. 1, default 0.75]
"""
self.hres = x
self.vres = y
self.css = """window label {
background-color: %s;
}
""" % bgcolor
# Dynamic Resolution Scaling
self.monitor = Gdk.Screen()
self.monitor.connect("size-changed", self.resize)
# Newer versions of pygtk have this method
try:
self.monitor.connect("monitors-changed", self.resize)
except:
pass
# Create Main Window
self.window = Gtk.Window()
self.window.set_position(Gtk.WindowPosition.CENTER)
self.window.connect("hide", self.restore)
self.window.connect("key-press-event", self.keypress)
self.window.set_property('skip-taskbar-hint', True)
self.window.set_property('skip-pager-hint', True)
self.window.set_property('destroy-with-parent', True)
self.window.stick()
self.window.set_decorated(False)
self.window.set_keep_above(True)
self.window.set_app_paintable(True)
# Set the default window size
self.window.set_default_size(int(self.hres), 5)
# Create Main Horizontal Box to Populate
self.hbox = Gtk.HBox()
# Create the Center Vertical Box
self.vbox_center = Gtk.VBox()
self.center_label = Gtk.Label(
"<span font_family='%s' weight='%s' foreground='%s' size='%s'>%s</span>" %
(font, weight, fgcolor, size, message))
self.center_label.set_use_markup(True)
self.center_label.set_justify(Gtk.Justification.CENTER)
self.vbox_center.pack_start(self.center_label, True, True, 0)
# Create the Right-Justified Vertical Box to Populate for hostname
self.vbox_right = Gtk.VBox()
self.host_label = Gtk.Label(
"<span font_family='%s' weight='%s' foreground='%s' size='%s'>%s</span>" %
(font, weight, fgcolor, size, get_host()))
self.host_label.set_use_markup(True)
self.host_label.set_justify(Gtk.Justification.RIGHT)
self.host_label.set_width_chars(20)
# Create the Left-Justified Vertical Box to Populate for user
self.vbox_left = Gtk.VBox()
self.user_label = Gtk.Label(
"<span font_family='%s' weight='%s' foreground='%s' size='%s'>%s</span>" %
(font, weight, fgcolor, size, get_user()))
self.user_label.set_use_markup(True)
self.user_label.set_justify(Gtk.Justification.LEFT)
self.user_label.set_width_chars(20)
# Create the Right-Justified Vertical Box to Populate for ESC message
self.vbox_esc_right = Gtk.VBox()
self.esc_label = Gtk.Label(label="<span font_family='liberation-sans' weight='normal' foreground='%s' size='xx-small'> (ESC to hide temporarily) </span>" %
(fgcolor))
self.esc_label.set_use_markup(True)
self.esc_label.set_justify(Gtk.Justification.RIGHT)
self.esc_label.set_width_chars(20)
# Empty Label for formatting purposes
self.vbox_empty = Gtk.VBox()
self.empty_label = Gtk.Label(
label="<span font_family='liberation-sans' weight='normal'> </span>")
self.empty_label.set_use_markup(True)
self.empty_label.set_width_chars(20)
if not esc:
if not sys_info:
self.hbox.pack_start(self.vbox_center, True, True, 0)
else:
self.vbox_right.pack_start(self.host_label, True, True, 0)
self.vbox_left.pack_start(self.user_label, True, True, 0)
self.hbox.pack_start(self.vbox_right, False, True, 20)
self.hbox.pack_start(self.vbox_center, True, True, 0)
self.hbox.pack_start(self.vbox_left, False, True, 20)
else:
if esc and not sys_info:
self.empty_label.set_justify(Gtk.Justification.LEFT)
self.vbox_empty.pack_start(self.empty_label, True, True, 0)
self.vbox_esc_right.pack_start(self.esc_label, True, True, 0)
self.hbox.pack_start(self.vbox_esc_right, False, True, 0)
self.hbox.pack_start(self.vbox_center, True, True, 0)
self.hbox.pack_start(self.vbox_empty, False, True, 0)
if sys_info:
self.vbox_right.pack_start(self.host_label, True, True, 0)
self.vbox_left.pack_start(self.user_label, True, True, 0)
self.hbox.pack_start(self.vbox_right, False, True, 20)
self.hbox.pack_start(self.vbox_center, True, True, 0)
self.hbox.pack_start(self.vbox_left, False, True, 20)
self.window.add(self.hbox)
self.window.show_all()
self.width, self.height = self.window.get_size()
# load style from file
provider = Gtk.CssProvider()
provider.load_from_data(self.css.encode())
self.apply_css(self.window, provider)
try:
self.window.set_opacity(opacity)
except:
pass
