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)