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 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 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 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, 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 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)
def update_tab_geometry_hints(self):
'''
copy the WM_NORMAL_HINTS properties of rxvt window to the rxvt tab so it stays within the rxvt resizing requirements
resizing might not be smooth anymore if this is called
'''
rxvt_socket = self.rxvt_socket
display = Xlib.display.Display()
xlib_window = display.create_resource_object('window',
self.plugged.get_xid())
hints = xlib_window.get_wm_normal_hints()
geometry = Gdk.Geometry()
geometry.base_width = hints.base_width
geometry.base_height = hints.base_height
geometry.width_inc = hints.width_inc
geometry.height_inc = hints.height_inc
geom_mask = Gdk.WindowHints(0)
geom_mask |= Gdk.WindowHints.BASE_SIZE
geom_mask |= Gdk.WindowHints.RESIZE_INC
rxvt_socket.get_toplevel().set_geometry_hints(rxvt_socket, geometry,
geom_mask)
def _set_geometry_hints(self, hints):
self._hints = None
if hints is None:
return
h = Gdk.Geometry()
mask = 0
if 'min-width' in hints and 'min-height' in hints:
h.min_width = hints['min-width']
h.min_height = hints['min-height']
mask |= Gdk.WindowHints.MIN_SIZE
if 'max-width' in hints and 'max-height' in hints:
h.max_width = hints['max-width']
h.max_height = hints['max-height']
mask |= Gdk.WindowHints.MAX_SIZE
if 'base-width' in hints and 'base-height' in hints:
h.base_width = hints['base-width']
h.base_height = hints['base-height']
mask |= Gdk.WindowHints.BASE_SIZE
if 'width-inc' in hints and 'height-inc' in hints:
h.width_inc = hints['width-inc']
h.height_inc = hints['height-inc']
mask |= Gdk.WindowHints.RESIZE_INC
if 'min-aspect' in hints and 'max-aspect' in hints:
h.min_aspect = hints['min-aspect']
h.max_aspect = hints['max-aspect']
mask |= Gdk.WindowHints.ASPECT
self.set_geometry_hints(None, h, Gdk.WindowHints(mask))
self._hints = h
def main():
w = Gtk.Window(type=Gtk.WindowType.TOPLEVEL)
w.set_default_size(499, 316)
w.set_title("xterm size hints")
w.connect("delete_event", Gtk.main_quit)
da = Gtk.DrawingArea()
w.add(da)
geom = Gdk.Geometry()
wh = Gdk.WindowHints
geom.min_width = 25
geom.min_height = 17
geom.base_width = 19
geom.base_height = 4
geom.width_inc = 6
geom.height_inc = 13
mask = wh.MIN_SIZE | wh.BASE_SIZE | wh.RESIZE_INC
if sys.platform.startswith("linux"):
geom.max_width = 32767
geom.max_height = 32764
mask |= 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 __init__(self):
super(ImplodeWindow, self).__init__(Gtk.WindowType.TOPLEVEL)
geometry = Gdk.Geometry()
(geometry.min_width, geometry.min_height) = (640, 480)
hints = Gdk.WindowHints(Gdk.WindowHints.MIN_SIZE)
self.set_geometry_hints(None, geometry, hints)
self.set_title("Implode")
self.connect("delete_event", self._delete_event_cb)
toolbar = Gtk.Toolbar()
self._game = implodegame.ImplodeGame()
icon_theme = Gtk.IconTheme()
icon_theme.set_search_path(['icons'])
def set_icon(button, icon):
image = Gtk.Image()
pixbuf = icon_theme.load_icon(icon, geometry.min_height // 10, 0)
image.set_from_pixbuf(pixbuf)
button.set_icon_widget(image)
def add_button(icon, func):
button = Gtk.ToolButton()
set_icon(button, icon)
toolbar.add(button)
def callback(source):
func()
button.connect('clicked', callback)
return button
add_button('new-game', self._game.new_game)
add_button('replay-game', self._game.replay_game)
add_button('edit-undo', self._game.undo)
add_button('edit-redo', self._game.redo)
toolbar.add(Gtk.SeparatorToolItem())
radio_buttons = []
def add_radio_button(icon, level):
if radio_buttons:
button = Gtk.RadioToolButton(group=radio_buttons[0])
else:
button = Gtk.RadioToolButton()
set_icon(button, icon)
radio_buttons.append(button)
toolbar.add(button)
def callback(source):
if source.get_active():
self._game.set_level(level)
self._game.new_game()
button.connect('toggled', callback)
return button
add_radio_button('easy-level', 0)
add_radio_button('medium-level', 1)
add_radio_button('hard-level', 2)
separator = Gtk.SeparatorToolItem()
separator.set_expand(True)
separator.set_draw(False)
toolbar.add(separator)
add_button('toolbar-help', self._help_clicked)
self._stuck_strip = _StuckStrip()
game_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
game_box.pack_start(self._game, True, True, 0)
game_box.pack_end(self._stuck_strip, False, False, 0)
main_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
main_box.pack_start(toolbar, False, True, 0)
main_box.pack_end(game_box, True, True, 0)
self.add(main_box)
# Show everything except the stuck strip.
main_box.show_all()
self._stuck_strip.hide()
self._game.connect('show-stuck', self._show_stuck_cb)
self._stuck_strip.connect('undo-clicked', self._stuck_undo_cb)
game_box.connect('key-press-event', self._key_press_event_cb)
self._game.grab_focus()
self.show()
def main():
PY2 = sys.version_info[0] == 2
if PY2:
import gtk
w = gtk.Window(gtk.WINDOW_TOPLEVEL)
w.set_default_size(499, 316)
w.set_title("xterm size hints")
w.connect("delete_event", gtk.main_quit)
da = gtk.DrawingArea()
w.add(da)
hints = {
"min_width": 25,
"min_height": 17,
"base_width": 19,
"base_height": 4,
"width_inc": 6,
"height_inc": 13,
}
w.set_geometry_hints(None, **hints)
else:
import gi
gi.require_version('Gdk', '3.0')
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk, Gdk
w = Gtk.Window(type=Gtk.WindowType.TOPLEVEL)
w.set_default_size(499, 316)
w.set_title("xterm size hints")
w.connect("delete_event", Gtk.main_quit)
da = gtk.DrawingArea()
w.add(da)
geom = Gdk.Geometry()
wh = Gdk.WindowHints
geom.min_width = 25
geom.min_height = 17
geom.base_width = 19
geom.base_height = 4
geom.width_inc = 6
geom.height_inc = 13
mask = wh.MIN_SIZE | wh.BASE_SIZE | wh.RESIZE_INC
if sys.platform.startswith("linux"):
geom.max_width = 32767
geom.max_height = 32764
mask |= wh.MAX_SIZE
gdk_hints = Gdk.WindowHints(mask)
w.set_geometry_hints(None, geom, gdk_hints)
gtk = Gtk
def configure_event(w, event):
#print("configure_event(%s, %s)" % (w, event))
print("event geometry: %s" %
((event.x, event.y, event.width, event.height), ))
if PY2:
gdkwindow = w.get_window()
x, y = gdkwindow.get_origin()
else:
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.connect("configure_event", configure_event)
w.show_all()
gtk.main()
