def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._bridge = None
self.available_bridges = {}
self.selected_bridge = None
self.connect('prepare', self._on_prepare)
self.set_position(Gtk.WindowPosition.CENTER)
geometry = Gdk.Geometry()
geometry.min_height = 450
geometry.min_width = 500
self.set_geometry_hints(None, geometry, Gdk.WindowHints.MIN_SIZE)
builder = Gtk.Builder()
builder.add_from_resource(get_resource_path('ui/setup.ui'))
builder.connect_signals(self)
self.search_page = builder.get_object('search-page')
self.append_page(self.search_page)
self.set_page_title(self.search_page, 'Discover Bridge(s)')
self.set_page_type(self.search_page, Gtk.AssistantPageType.INTRO)
self.results_list = builder.get_object('results-list')
self.results_page = builder.get_object('results-page')
self.append_page(self.results_page)
self.set_page_title(self.results_page, 'Select Bridge')
self.set_page_type(self.results_page, Gtk.AssistantPageType.CONTENT)
self.link_button_page = builder.get_object('link-button-page')
self.append_page(self.link_button_page)
self.set_page_title(self.link_button_page, 'Establish Connection')
self.set_page_type(self.link_button_page, Gtk.AssistantPageType.CUSTOM)
def post_initialisations(self):
b = Gdk.Geometry()
b.min_aspect = b.max_aspect = 1.
b.min_width = b.min_height = 33
c = Gdk.WindowHints(Gdk.WindowHints.POS | Gdk.WindowHints.USER_POS
| Gdk.WindowHints.USER_SIZE
| Gdk.WindowHints.ASPECT
| Gdk.WindowHints.MIN_SIZE)
self.set_geometry_hints(self, b, c)
self.gridMain = Gtk.Grid()
self.gridMain.set_row_homogeneous(True)
self.gridMain.set_column_homogeneous(True)
self.gridMain.set_row_spacing(3)
self.gridMain.set_column_spacing(3)
for rowcounter in range(3):
for colcounter in range(3):
num = colcounter * 3 + rowcounter + 1
label = Gtk.Label(self.thelist[num])
label.id = 'l' + str(num)
eb = Gtk.EventBox()
eb.add(label)
self.set_object_attr(eb, 'background', 'gray')
self.set_object_attr(eb, 'color', 'white')
eb.connect('button-press-event',
self.on_any_eb_button_press_event)
self.gridMain.attach(eb, rowcounter + 1, colcounter + 1, 1, 1)
self.enumobjects.append(label)
self.add(self.gridMain)
def set_main_window_size(self, column_number=None):
if column_number is None:
column_number = self.gio_settings.get_int("min-column-number")
default_height = 450
default_width = 340
min_width = 340
proceed = True
if column_number == 1:
default_width = min_width = 360
elif column_number == 2:
default_width = min_width = 600
elif column_number == 3:
default_width = min_width = 800
elif column_number == 4:
default_width = min_width = 958
elif column_number == 5:
default_width = 1100
min_width = 958
# elif column_number > 5:
# proceed = False
if proceed:
self.resize(default_width, default_height)
self.set_size_request(min_width, default_height)
geometry = Gdk.Geometry()
setattr(geometry, 'min_height', default_height)
setattr(geometry, 'min_width', min_width)
self.set_geometry_hints(None, geometry, Gdk.WindowHints.MIN_SIZE)
def __init__(self, animation, compiler, parent):
Gtk.Dialog.__init__(self,
transient_for=parent,
title="Generating images...",
modal=True,
destroy_with_parent=True)
self.add_buttons(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL)
hig.MessagePopper.__init__(self)
self.lbl_image = Gtk.Label(label="Current image progress")
self.vbox.pack_start(self.lbl_image, True, True, 0)
self.pbar_image = Gtk.ProgressBar()
self.vbox.pack_start(self.pbar_image, True, True, 0)
self.lbl_overall = Gtk.Label(label="Overall progress")
self.vbox.pack_start(self.lbl_overall, True, True, 0)
self.pbar_overall = Gtk.ProgressBar()
self.vbox.pack_start(self.pbar_overall, True, True, 0)
geometry = Gdk.Geometry()
geometry.min_aspect = 3.5
geometry.max_aspect = 3.5
self.set_geometry_hints(None, geometry, Gdk.WindowHints.ASPECT)
self.anim = animation
# -------------loads compiler----------------------------
self.compiler = compiler
def __init__(self, parent):
Gtk.Window.__init__(self, title=_("Cache Refresh"))
self.set_transient_for(parent)
self.set_position(Gtk.WindowPosition.CENTER)
self.set_border_width(16)
self.set_modal(True)
self.set_deletable(False)
self.set_default_size(300, 75)
geometry = Gdk.Geometry()
geometry.min_width = 210
geometry.min_height = 60
geometry.max_width = 800
geometry.max_height = 260
self.set_geometry_hints(None, geometry, Gdk.WindowHints.MIN_SIZE)
self.set_geometry_hints(None, geometry, Gdk.WindowHints.MAX_SIZE)
self.box = Gtk.Box(spacing=6, orientation=Gtk.Orientation.VERTICAL)
self.add(self.box)
self.label = Gtk.Label(xalign=0)
self.label.set_markup("<b><big>{}</big></b>".format(
_("Refreshing software cache")))
self.box.pack_start(self.label, False, False, 0)
# create a progress bar
self.progressbar = Gtk.ProgressBar()
self.box.pack_start(self.progressbar, True, True, 0)
def update_geometry(self):
"""
Override BaseWindow.update_geometry() - the Stage should always be the
GdkScreen size, unless status.InteractiveDebug is True
"""
if status.InteractiveDebug:
monitor_n = status.screen.get_primary_monitor()
self.rect = status.screen.get_monitor_geometry(monitor_n)
else:
self.rect = status.screen.get_screen_geometry()
if status.Debug:
print(
"Stage.update_geometry - new backdrop position: %d, %d new size: %d x %d"
%
(self.rect.x, self.rect.y, self.rect.width, self.rect.height))
hints = Gdk.Geometry()
hints.min_width = self.rect.width
hints.min_height = self.rect.height
hints.max_width = self.rect.width
hints.max_height = self.rect.height
hints.base_width = self.rect.width
hints.base_height = self.rect.height
self.set_geometry_hints(
self, hints, Gdk.WindowHints.MIN_SIZE | Gdk.WindowHints.MAX_SIZE
| Gdk.WindowHints.BASE_SIZE)
def main():
w = Gtk.Window(type=Gtk.WindowType.TOPLEVEL)
w.set_default_size(-1, -1)
w.set_title("eclipse size hints")
w.connect("delete_event", Gtk.main_quit)
da = Gtk.DrawingArea()
w.add(da)
geom = Gdk.Geometry()
wh = Gdk.WindowHints
geom.min_width = 862
geom.min_height = 385
geom.max_width = 862
geom.max_height = 385
mask = wh.MIN_SIZE | wh.MAX_SIZE
gdk_hints = Gdk.WindowHints(mask)
w.set_geometry_hints(da, geom, gdk_hints)
#da.connect("click", show)
def configure_event(w, event):
#print("configure_event(%s, %s)" % (w, event))
print("event geometry: %s" %
((event.x, event.y, event.width, event.height), ))
gdkwindow = da.get_window()
x, y = gdkwindow.get_origin()[1:]
w, h = w.get_size()
print("drawing area geometry: %s" % ((x, y, w, h), ))
w.show_all()
w.connect("configure_event", configure_event)
Gtk.main()
def make_win(title="Test Geometry Hints",
min_width=-1,
min_height=-1,
max_width=-1,
max_height=-1,
base_width=-1,
base_height=-1,
width_inc=-1,
height_inc=-1):
window = Gtk.Window(title=title)
window.connect("delete_event", Gtk.main_quit)
geom = Gdk.Geometry()
geom.base_width = base_width
geom.base_height = base_height
geom.width_inc = width_inc
geom.height_inc = height_inc
geom.min_width = min_width
geom.min_height = min_height
geom.max_width = max_width
geom.max_height = max_height
mask = 0
if base_width > 0 or base_height > 0:
mask |= Gdk.WindowHints.BASE_SIZE
if width_inc > 0 or height_inc > 0:
mask |= Gdk.WindowHints.RESIZE_INC
if min_width > 0 or min_height > 0:
mask |= Gdk.WindowHints.MIN_SIZE
if max_width > 0 or max_height > 0:
mask |= Gdk.WindowHints.MAX_SIZE
window.set_geometry_hints(None, geom, Gdk.WindowHints(mask))
window.show_all()
fixup_window_style(window)
def set_geometry(self):
""" Sets Cnchi window geometry """
self.set_position(Gtk.WindowPosition.CENTER)
self.set_resizable(False)
self.set_size_request(self._main_window_width,
self._main_window_height)
self.set_default_size(self._main_window_width,
self._main_window_height)
geom = Gdk.Geometry()
geom.min_width = self._main_window_width
geom.min_height = self._main_window_height
geom.max_width = self._main_window_width
geom.max_height = self._main_window_height
geom.base_width = self._main_window_width
geom.base_height = self._main_window_height
geom.width_inc = 0
geom.height_inc = 0
hints = (Gdk.WindowHints.MIN_SIZE |
Gdk.WindowHints.MAX_SIZE |
Gdk.WindowHints.BASE_SIZE |
Gdk.WindowHints.RESIZE_INC)
self.set_geometry_hints(None, geom, hints)
def _create():
window = Gtk.Window()
window.set_title(NAME)
window.set_role('status-window')
# window.set_type_hint(Gdk.WindowTypeHint.UTILITY)
# window.set_skip_taskbar_hint(True)
# window.set_skip_pager_hint(True)
window.connect('delete-event', _hide)
vbox = _create_window_layout()
window.add(vbox)
geometry = Gdk.Geometry()
geometry.min_width = 600
geometry.min_height = 320
geometry.max_width = 1000
geometry.max_height = 600
window.set_geometry_hints(
vbox, geometry, Gdk.WindowHints.MIN_SIZE | Gdk.WindowHints.MAX_SIZE)
window.set_position(Gtk.WindowPosition.CENTER)
style = window.get_style_context()
style.add_class('solaar')
return window
def _cb_realize_event(self, user_data):
""" Gdk window created """
# Disable maximize function (LP #859288)
# unity: no effect, but double click on top bar unhides anyway
# unity-2d: works and avoids the bug
self.get_window().set_functions(Gdk.WMFunction.RESIZE | \
Gdk.WMFunction.MOVE | \
Gdk.WMFunction.MINIMIZE | \
Gdk.WMFunction.CLOSE)
set_unity_property(self)
if not config.xid_mode: # not when embedding
ord = self.is_override_redirect_mode()
if ord:
self.get_window().set_override_redirect(True)
self._override_redirect = ord
self.update_taskbar_hint()
self.restore_window_rect(startup=True)
# set min window size for unity MT grab handles
geom = Gdk.Geometry()
geom.min_width, geom.min_height = \
self.keyboard_widget.get_min_window_size()
self.set_geometry_hints(self, geom, Gdk.WindowHints.MIN_SIZE)
def input_box(frame,
title="Input Box",
message="",
default_text="",
modal=True,
option=False,
optionmessage="",
optionvalue=False,
droplist=[]):
win = EntryDialog(frame,
message,
default_text,
option=option,
optionmessage=optionmessage,
optionvalue=optionvalue,
droplist=droplist)
win.set_title(title)
win.set_icon(frame.images["n"])
hints_geometry = Gdk.Geometry()
hints_geometry.min_width = 300
win.set_geometry_hints(None, hints_geometry,
Gdk.WindowHints(Gdk.WindowHints.MIN_SIZE))
win.show()
gtk.main()
return win.ret
def __init__(self):
self.log = logging.getLogger("shairport-display")
self.format = logging.Formatter('%(asctime)s - [%(levelname)s] - %(message)s', "%Y-%m-%d %H:%M:%S")
self.handler = logging.StreamHandler(stream=sys.stdout)
self.handler.setFormatter(self.format)
self.handler.setLevel(logging.DEBUG)
self.log.addHandler(self.handler)
self.log.setLevel(logging.DEBUG)
self.log.info("Starting application")
self.properties_changed = None
self._setup_loop()
self._setup_bus()
self._setup_signals()
self.length = 0
self.fraction = 0.0
self.duration = 500 # miliseconds
self.timer = None
self.builder = Gtk.Builder()
self.builder.add_from_file(os.path.dirname(os.path.realpath(__file__)) + "/shairport-display.glade")
self.window = self.builder.get_object("Window")
geometry = Gdk.Geometry()
geometry.min_width = 800
geometry.max_width = 800
geometry.min_height = 480
geometry.max_height = 480
hints = Gdk.WindowHints(Gdk.WindowHints.MAX_SIZE | Gdk.WindowHints.MIN_SIZE)
self.window.set_geometry_hints(None, geometry, hints)
self.Art = self.builder.get_object("CoverArt")
self.Title = self.builder.get_object("Title")
self.Artist = self.builder.get_object("Artist")
self.Album = self.builder.get_object("Album")
self.Elapsed = self.builder.get_object("Elapsed")
self.Remaining = self.builder.get_object("Remaining")
self.ProgressBar = self.builder.get_object("ProgressBar")
self.window.show_all()
self.window.fullscreen()
self._clear_display()
self._initialize_display()
self.window.connect("destroy", self.quit)
self.window.connect("key-press-event", self._on_win_key_press_event)
self.window.connect("window-state-event", self._on_window_state_event)
def __init__(self, app, pref_dialog, customised_item):
Gtk.Dialog.__init__(self, use_header_bar=True, flags=Gtk.DialogFlags.MODAL)
self.app = app
self.preferences = pref_dialog
self.customised_item = customised_item
self.set_title(_("Set Shortcut"))
# Set a minimum size.
self.set_size_request(500, 300)
# Set a maximum size.
geometry = Gdk.Geometry()
geometry.max_width = self.get_size_request()[0]
geometry.max_height = -1
self.set_geometry_hints(None, geometry, Gdk.WindowHints.MAX_SIZE)
self.set_transient_for(self.preferences)
self.get_titlebar().set_decoration_layout('close:')
self.add_events(Gdk.EventMask.KEY_PRESS_MASK)
self.conflicting_action = None
# Setup the widgets used in the dialog.
self.apply_button = self.add_button(_("Apply"), Gtk.ResponseType.OK)
self.apply_button.get_style_context()\
.add_class(Gtk.STYLE_CLASS_SUGGESTED_ACTION)
self.apply_button.set_tooltip_text(_("Apply the accelerator to this"
" shortcut."))
self.apply_button.hide()
self.replace_button = self.add_button(_("Replace"), Gtk.ResponseType.OK)
self.replace_button.get_style_context().\
add_class(Gtk.STYLE_CLASS_SUGGESTED_ACTION)
self.replace_button.set_tooltip_text(_("Remove this accelerator from where "
"it was used previously and set it for "
"this shortcut."))
self.replace_button.hide()
prompt_label = Gtk.Label()
prompt_label.set_markup(
_("Enter new shortcut for <b>%s</b>, or press Esc to cancel.")
% customised_item.title)
prompt_label.props.wrap = True
prompt_label.props.margin_bottom = PADDING * 3
prompt_label.show()
self.accelerator_label = Gtk.Label()
self.accelerator_label.props.margin_bottom = PADDING
self.invalid_label = Gtk.Label()
self.invalid_label.set_text(
_("The accelerator you are trying to set might interfere with typing."
" Try using Control, Shift or Alt with some other key, please."))
self.invalid_label.props.wrap = True
self.conflict_label = Gtk.Label()
self.conflict_label.props.wrap = True
content_area = self.get_content_area()
content_area.props.margin = PADDING * 3
content_area.add(prompt_label)
content_area.add(self.accelerator_label)
content_area.add(self.conflict_label)
content_area.add(self.invalid_label)
def assemble_window(self):
# Default size
window_size = Settings.get_default().window_size
self.set_default_size(window_size[0], window_size[1])
# Min size
geom = Gdk.Geometry()
geom.min_width = 360
geom.min_height = 288
self.set_geometry_hints(None, geom, Gdk.WindowHints.MIN_SIZE)
# Titlebar
self.titlebar = self.builder.get_object('titlebar')
self.headerbar = self.builder.get_object('headerbar')
self.left_button = self.builder.get_object('left_button')
self.left_button.connect('clicked', self.on_left_button_clicked, None)
self.builder.get_object('fullscreen_button').connect(
'clicked', self.toggle_fullscreen, None)
self.set_titlebar(self.titlebar)
# Fisrt start grid
self.first_start_grid = self.builder.get_object('first_start_grid')
pix = Pixbuf.new_from_resource_at_scale(
'/info/febvre/Komikku/images/logo.png', 256, 256, True)
self.builder.get_object('app_logo').set_from_pixbuf(pix)
# Init pages
self.library = Library(self)
self.card = Card(self)
self.reader = Reader(self)
# Window
self.connect('check-resize', self.on_resize)
self.connect('delete-event', self.on_application_quit)
self.connect('key-press-event', self.on_key_press_event)
self.connect('window-state-event', self.on_window_state_event)
# Custom CSS
screen = Gdk.Screen.get_default()
css_provider = Gtk.CssProvider()
css_provider_resource = Gio.File.new_for_uri(
'resource:///info/febvre/Komikku/css/style.css')
css_provider.load_from_file(css_provider_resource)
context = Gtk.StyleContext()
context.add_provider_for_screen(screen, css_provider,
Gtk.STYLE_PROVIDER_PRIORITY_USER)
if Gio.Application.get_default().development_mode is True:
self.get_style_context().add_class('devel')
# Theme (light or dark)
self.init_theme()
self.library.show()
def _udpate_geometry_hints(self):
geometry = Gdk.Geometry()
geometry.max_width = _C_INT_MAX
if self._notebook.get_visible():
geometry.max_height = _C_INT_MAX
else:
geometry.max_height = -1
self.set_geometry_hints(None, geometry, Gdk.WindowHints.MAX_SIZE)
def __init__(self, run_callback):
self.run_callback = run_callback
Gtk.Window.__init__(self, title="LaTexText (GTK3)")
gh = Gdk.Geometry()
gh.max_height = 120
gh.max_width = 700
self.set_geometry_hints(None, gh, Gdk.WindowHints.MAX_SIZE)
self.set_hexpand(True)
self.set_size_request(400, gh.max_height)
self.set_keep_above(True)
def __init__(self, org_directories):
self.window = Gtk.Window()
self.window.set_wmclass("traycalendar", "TrayCalendar")
self.window.set_resizable(False)
self.window.set_decorated(False)
self.window.set_gravity(Gdk.Gravity.STATIC)
window_width = 300
# Set the window geometry.
geometry = Gdk.Geometry()
geometry.min_width = window_width
geometry.max_width = window_width
geometry.base_width = window_width
self.window.set_geometry_hints(
None, geometry, Gdk.WindowHints.MIN_SIZE | Gdk.WindowHints.MAX_SIZE
| Gdk.WindowHints.BASE_SIZE)
# Create the listview for the calendar events.
list_model = Gtk.ListStore(str)
list_view = Gtk.TreeView(list_model)
list_column = Gtk.TreeViewColumn("Events",
Gtk.CellRendererText(),
text=0)
list_column.set_fixed_width(window_width)
list_view.append_column(list_column)
# Create the calendar widget.
calendar = Gtk.Calendar()
self.calendar_events = scan_org_for_events(org_directories)
calendar.connect('month-changed', self.mark_calendar_events)
calendar.connect('day-selected', self.display_event_list, list_model)
self.mark_calendar_events(calendar)
self.display_event_list(calendar, list_model)
close_button = Gtk.Button("Close")
close_button.connect('clicked', lambda event: self.window.destroy())
vbox = Gtk.VBox()
vbox.add(close_button)
vbox.add(calendar)
vbox.add(list_view)
self.window.add(vbox)
rootwin = self.window.get_screen().get_root_window()
# get_pointer is deprecated but using Gdk.Device.get_position
# is not viable here: we have no access to the pointing device.
screen, x, y, mask = rootwin.get_pointer()
x -= window_width
# Show the window right beside the cursor.
self.window.move(x, y)
self.window.show_all()
def _on_set_aspect_ratio(self, manager, result):
val = result.get_js_value()
if val.is_undefined():
raise ValueError('needs ratio argument')
if not val.is_number():
raise ValueError('ratio arg should be number')
hint = Gdk.Geometry()
hint.min_aspect = hint.max_aspect = val.to_double()
self.set_geometry_hints(None, hint, Gdk.WindowHints.ASPECT)
def main():
window = Gtk.Window(Gtk.WindowType.TOPLEVEL)
window.set_size_request(300, 200)
window.connect("delete_event", Gtk.main_quit)
window.show_all()
geom = Gdk.Geometry()
geom.max_width = 600
geom.max_height = 400
hints = Gdk.WindowHints.MAX_SIZE
window.set_geometry_hints(window, geom, hints)
Gtk.main()
return 0
def set_rough_geometry_hints(self):
"""Walk all the terminals along the top and left edges to fake up how
many columns/rows we sort of have"""
if self.ismaximised == True:
return
if not hasattr(self, 'cached_maker'):
self.cached_maker = Factory()
maker = self.cached_maker
if maker.isinstance(self.get_child(), 'Notebook'):
dbg("We don't currently support geometry hinting with tabs")
return
terminals = self.get_visible_terminals()
column_sum = 0
row_sum = 0
for terminal in terminals:
rect = terminal.get_allocation()
if rect.x == 0:
cols, rows = terminal.get_size()
row_sum = row_sum + rows
if rect.y == 0:
cols, rows = terminal.get_size()
column_sum = column_sum + cols
if column_sum == 0 or row_sum == 0:
dbg('column_sum=%s,row_sum=%s. No terminals found in >=1 axis' %
(column_sum, row_sum))
return
# FIXME: I don't think we should just use whatever font size info is on
# the last terminal we inspected. Looking up the default profile font
# size and calculating its character sizes would be rather expensive
# though.
font_width, font_height = terminal.get_font_size()
total_font_width = font_width * column_sum
total_font_height = font_height * row_sum
win_width, win_height = self.get_size()
extra_width = win_width - total_font_width
extra_height = win_height - total_font_height
dbg('setting geometry hints: (ewidth:%s)(eheight:%s),\
(fwidth:%s)(fheight:%s)' %
(extra_width, extra_height, font_width, font_height))
geometry = Gdk.Geometry()
geometry.base_width = extra_width
geometry.base_height = extra_height
geometry.width_inc = font_width
geometry.height_inc = font_height
self.set_geometry_hints(
self, geometry,
Gdk.WindowHints.BASE_SIZE | Gdk.WindowHints.RESIZE_INC)
def _create_window(self, window_name):
style_provider = Gtk.CssProvider()
style_provider.load_from_data(self.CSS.encode("utf-8"))
self._window = Gtk.Window(title=window_name)
context = self._window.get_style_context()
context.add_provider(style_provider, Gtk.STYLE_PROVIDER_PRIORITY_USER)
box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
top_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
swindow = Gtk.ScrolledWindow()
swindow.set_size_request(KEY_WIDTH * 14, WHITE_KEY_LENGTH)
swindow.set_hexpand(True)
swindow.set_vexpand(False)
swindow.set_policy(Gtk.PolicyType.ALWAYS, Gtk.PolicyType.NEVER)
swindow.set_overlay_scrolling(False)
self._window.set_default_size(KEY_WIDTH * 14, WHITE_KEY_LENGTH)
viewport = Gtk.Viewport()
button = Gtk.RadioButton.new_with_label(None, label="1")
self._ch_buttons = [button] + [
Gtk.RadioButton.new_with_label_from_widget(button, str(i))
for i in range(2, 17)
]
for button in self._ch_buttons:
button.props.draw_indicator = False
context = button.get_style_context()
context.add_class("channel-button")
context.add_provider(style_provider,
Gtk.STYLE_PROVIDER_PRIORITY_USER)
top_box.add(button)
self._kb_canvas = Gtk.DrawingArea()
self._kb_canvas.set_size_request(KEY_WIDTH * 75, WHITE_KEY_LENGTH)
box.add(top_box)
box.add(swindow)
swindow.add(viewport)
viewport.add(self._kb_canvas)
self._window.add(box)
size = self._window.get_size()
hints = Gdk.Geometry()
hints.min_width = size.width
hints.max_width = size.width - KEY_WIDTH * 14 + KEY_WIDTH * 75
hints.min_height = size.height
hints.max_height = size.height
self._window.set_geometry_hints(
self._window, hints, Gdk.WindowHints.MIN_SIZE
| Gdk.WindowHints.MAX_SIZE)
self._kb_canvas.connect("draw", self._draw_keyboard)
vadj = swindow.get_hadjustment()
vadj.connect("changed", self._configure_scrolling)
self._kb_canvas.add_events(Gdk.EventMask.BUTTON_PRESS_MASK
| Gdk.EventMask.BUTTON_RELEASE_MASK
| Gdk.EventMask.LEAVE_NOTIFY_MASK
| Gdk.EventMask.POINTER_MOTION_MASK)
def __init__(self, title=None, **kwargs):
super().__init__(type=Gtk.WindowType.TOPLEVEL)
self.set_title(title or "")
add_close_accel(self, self.delete_event)
self.connect("delete_event", self.delete_event)
icon = get_icon_pixbuf("windows.png")
if icon:
self.set_icon(icon)
if kwargs.pop("headerbar", False):
hb = Gtk.HeaderBar()
hb.set_show_close_button(True)
hb.props.title = "HeaderBar example"
self.set_titlebar(hb)
da = Gtk.DrawingArea()
self.add(da)
def configure_event(_widget, event):
self.set_title(title or "%ix%i" % (event.width, event.height))
da.connect("configure-event", configure_event)
geom = Gdk.Geometry()
for attr in (
"min_width",
"min_height",
"max_width",
"max_height",
"base_width",
"base_height",
"width_inc",
"height_inc",
):
v = kwargs.pop(attr, -1)
setattr(geom, attr, v)
value = 0
if geom.min_width >= 0 or geom.min_height >= 0:
value |= Gdk.WindowHints.MIN_SIZE
if geom.max_width >= 0 or geom.max_height >= 0:
value |= Gdk.WindowHints.MAX_SIZE
if geom.base_width >= 0 or geom.base_height >= 0:
value |= Gdk.WindowHints.BASE_SIZE
if geom.width_inc >= 0 or geom.height_inc >= 0:
value |= Gdk.WindowHints.RESIZE_INC
hints = Gdk.WindowHints(value)
width = kwargs.pop("width", -1)
height = kwargs.pop("height", -1)
self.set_default_size(width, height)
self.set_geometry_hints(da, geom, hints)
self.show_all()
def _adapt_window_to_screen(self):
screen = Gdk.Screen.get_default()
geometry = Gdk.Geometry()
geometry.max_width = geometry.base_width = geometry.min_width = \
screen.get_width()
geometry.max_height = geometry.base_height = geometry.min_height = \
screen.get_height()
geometry.width_inc = geometry.height_inc = geometry.min_aspect = \
geometry.max_aspect = 1
hints = Gdk.WindowHints(Gdk.WindowHints.ASPECT
| Gdk.WindowHints.BASE_SIZE
| Gdk.WindowHints.MAX_SIZE
| Gdk.WindowHints.MIN_SIZE)
self.set_geometry_hints(None, geometry, hints)
def apply_geometry_hints(self, hints):
""" we convert the hints as a dict into a gdk.Geometry + gdk.WindowHints """
wh = Gdk.WindowHints
name_to_hint = {
"maximum-size": wh.MAX_SIZE,
"max_width": wh.MAX_SIZE,
"max_height": wh.MAX_SIZE,
"minimum-size": wh.MIN_SIZE,
"min_width": wh.MIN_SIZE,
"min_height": wh.MIN_SIZE,
"base-size": wh.BASE_SIZE,
"base_width": wh.BASE_SIZE,
"base_height": wh.BASE_SIZE,
"increment": wh.RESIZE_INC,
"width_inc": wh.RESIZE_INC,
"height_inc": wh.RESIZE_INC,
"min_aspect_ratio": wh.ASPECT,
"max_aspect_ratio": wh.ASPECT,
}
#these fields can be copied directly to the gdk.Geometry as ints:
INT_FIELDS = [
"min_width", "min_height", "max_width", "max_height", "base_width",
"base_height", "width_inc", "height_inc"
]
ASPECT_FIELDS = {
"min_aspect_ratio": "min_aspect",
"max_aspect_ratio": "max_aspect",
}
geom = Gdk.Geometry()
mask = 0
for k, v in hints.items():
k = bytestostr(k)
if k in INT_FIELDS:
if k.find("width") >= 0:
v = self._client.sx(v)
elif k.find("height") >= 0:
v = self._client.sy(v)
elif k.find("size") >= 0:
v = self._client.sp(v)
setattr(geom, k, int(v))
mask |= int(name_to_hint.get(k, 0))
elif k in ASPECT_FIELDS:
field = ASPECT_FIELDS.get(k)
setattr(geom, field, float(v))
mask |= int(name_to_hint.get(k, 0))
gdk_hints = Gdk.WindowHints(mask)
metalog("apply_geometry_hints(%s) geometry=%s, hints=%s", hints, geom,
gdk_hints)
self.set_geometry_hints(None, geom, gdk_hints)
def set_geometry(self):
self.set_position(Gtk.WindowPosition.CENTER)
self.set_resizable(False)
self.set_size_request(MAIN_WINDOW_WIDTH, MAIN_WINDOW_HEIGHT)
self.set_default_size(MAIN_WINDOW_WIDTH, MAIN_WINDOW_HEIGHT)
geom = Gdk.Geometry()
geom.min_width = MAIN_WINDOW_WIDTH
geom.min_height = MAIN_WINDOW_HEIGHT
geom.max_width = MAIN_WINDOW_WIDTH
geom.max_height = MAIN_WINDOW_HEIGHT
geom.base_width = MAIN_WINDOW_WIDTH
geom.base_height = MAIN_WINDOW_HEIGHT
hints = Gdk.WindowHints.MIN_SIZE | Gdk.WindowHints.MAX_SIZE | Gdk.WindowHints.BASE_SIZE
self.set_geometry_hints(None, geom, hints)
def __init__(self):
window = Gtk.Window()
window.set_title(_('Solaar Rule Editor'))
window.connect('delete-event', self._closing)
vbox = Gtk.VBox()
self.top_panel, self.view = self._create_top_panel()
for col in self._create_view_columns():
self.view.append_column(col)
vbox.pack_start(self.top_panel, True, True, 0)
self.dirty = False # if dirty, there are pending changes to be saved
self.type_ui = {}
self.update_ui = {}
self.bottom_panel = self._create_bottom_panel()
self.ui = defaultdict(lambda: UnsupportedRuleComponentUI(self.bottom_panel))
self.ui.update({ # one instance per type
rc_class: rc_ui_class(self.bottom_panel, on_update=self.on_update)
for rc_class, rc_ui_class in COMPONENT_UI.items()
})
bottom_box = Gtk.ScrolledWindow()
bottom_box.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.NEVER)
bottom_box.add(self.bottom_panel)
vbox.pack_start(bottom_box, True, True, 0)
self.model = self._create_model()
self.view.set_model(self.model)
self.view.expand_all()
window.add(vbox)
geometry = Gdk.Geometry()
geometry.min_width = 800
geometry.min_height = 800
window.set_geometry_hints(None, geometry, Gdk.WindowHints.MIN_SIZE)
window.set_position(Gtk.WindowPosition.CENTER)
window.show_all()
window.connect('delete-event', lambda w, e: w.hide_on_delete() or True)
style = window.get_style_context()
style.add_class('solaar')
self.window = window
self._editing_component = None
def apply_geometry_hints(self, hints):
""" we convert the hints as a dict into a gdk.Geometry + gdk.WindowHints """
wh = Gdk.WindowHints
name_to_hint = {
"max_width": wh.MAX_SIZE,
"max_height": wh.MAX_SIZE,
"min_width": wh.MIN_SIZE,
"min_height": wh.MIN_SIZE,
"base_width": wh.BASE_SIZE,
"base_height": wh.BASE_SIZE,
"width_inc": wh.RESIZE_INC,
"height_inc": wh.RESIZE_INC,
"min_aspect_ratio": wh.ASPECT,
"max_aspect_ratio": wh.ASPECT,
}
#these fields can be copied directly to the gdk.Geometry as ints:
INT_FIELDS = [
"min_width", "min_height", "max_width", "max_height", "base_width",
"base_height", "width_inc", "height_inc"
]
ASPECT_FIELDS = {
"min_aspect_ratio": "min_aspect",
"max_aspect_ratio": "max_aspect",
}
thints = typedict(hints)
if self.drawing_area:
#apply min size to the drawing_area:
#(for CSD mode, ie: headerbar)
minw = thints.intget("min_width", 0)
minh = thints.intget("min_width", 0)
self.drawing_area.set_size_request(minw, minh)
geom = Gdk.Geometry()
mask = 0
for k, v in hints.items():
k = bytestostr(k)
if k in INT_FIELDS:
setattr(geom, k, v)
mask |= int(name_to_hint.get(k, 0))
elif k in ASPECT_FIELDS:
field = ASPECT_FIELDS.get(k)
setattr(geom, field, float(v))
mask |= int(name_to_hint.get(k, 0))
gdk_hints = Gdk.WindowHints(mask)
geomlog("apply_geometry_hints(%s) geometry=%s, hints=%s", hints, geom,
gdk_hints)
self.set_geometry_hints(self.drawing_area, geom, gdk_hints)
def set_geometry_hints(self,
geometry_widget=None,
min_width=-1,
min_height=-1,
max_width=-1,
max_height=-1,
base_width=-1,
base_height=-1,
width_inc=-1,
height_inc=-1,
min_aspect=-1.0,
max_aspect=-1.0):
geometry = Gdk.Geometry()
geom_mask = Gdk.WindowHints(0)
if min_width >= 0 or min_height >= 0:
geometry.min_width = max(min_width, 0)
geometry.min_height = max(min_height, 0)
geom_mask |= Gdk.WindowHints.MIN_SIZE
if max_width >= 0 or max_height >= 0:
geometry.max_width = max(max_width, 0)
geometry.max_height = max(max_height, 0)
geom_mask |= Gdk.WindowHints.MAX_SIZE
if base_width >= 0 or base_height >= 0:
geometry.base_width = max(base_width, 0)
geometry.base_height = max(base_height, 0)
geom_mask |= Gdk.WindowHints.BASE_SIZE
if width_inc >= 0 or height_inc >= 0:
geometry.width_inc = max(width_inc, 0)
geometry.height_inc = max(height_inc, 0)
geom_mask |= Gdk.WindowHints.RESIZE_INC
if min_aspect >= 0.0 or max_aspect >= 0.0:
if min_aspect <= 0.0 or max_aspect <= 0.0:
raise TypeError("aspect ratios must be positive")
geometry.min_aspect = min_aspect
geometry.max_aspect = max_aspect
geom_mask |= Gdk.WindowHints.ASPECT
return orig_set_geometry_hints(self, geometry_widget, geometry,
geom_mask)
def __screen_size_changed_cb(self, screen):
screen = Gdk.Screen.get_default()
n = screen.get_number()
rect = screen.get_monitor_geometry(n)
geometry = Gdk.Geometry()
geometry.max_width = geometry.base_width = geometry.min_width = \
rect.width
geometry.max_height = geometry.base_height = geometry.min_height = \
rect.height
geometry.width_inc = geometry.height_inc = geometry.min_aspect = \
geometry.max_aspect = 1
hints = Gdk.WindowHints(Gdk.WindowHints.ASPECT
| Gdk.WindowHints.BASE_SIZE
| Gdk.WindowHints.MAX_SIZE
| Gdk.WindowHints.MIN_SIZE)
workarea = screen.get_monitor_workarea(n)
self.move(workarea.x, workarea.y)
self.set_geometry_hints(None, geometry, hints)
