Alterar posição do Bmpanel2

zekicarvalho
(usa Debian)

Enviado em 07/01/2018 - 10:19h

Pessoal, ao usar o bmpanel2 a barra nao fica no extremo do lado inferior, ele fica um pouco acima como se esperasse outra barra a baixo dela.
Alguém sabe em que linha do .conf dela eu arrumo isso?
Vou comentar o .conf pra vê se alguem acha

zekicarvalho
(usa Debian)

Enviado em 07/01/2018 - 11:36h

#!/usr/bin/python2.7



import bmpanel2

import gtk, gobject

from gtk import gdk



g_remote = bmpanel2.Bmpanel2Remote()

g_config = bmpanel2.Bmpanel2Config()

g_launch = bmpanel2.Bmpanel2Launchbar(g_config)



#----------------------------------------------------------------------

from threading import Thread



class ThemeDeferredLoader(Thread):

	def __init__(self, view, model, callback):

		Thread.__init__(self)

		self.gui_view = view

		self.gui_model = model

		self.gui_callback = callback



	def run(self):

		view = self.gui_view

		model = self.gui_model



		themes = bmpanel2.Bmpanel2Themes()

		gdk.threads_enter()

		for t in themes.themes:

			name = t.dirname

			if t.name:

				name = t.name

			model.append((name, t, t.path))

		current_theme = g_config.get_theme()

		current_theme_num = 0



		for i in xrange(len(model)):

			if model[i][1].dirname == current_theme:

				current_theme_num = i

				break



		view.set_cursor((current_theme_num,))

		view.scroll_to_cell((current_theme_num,))

		view.get_selection().connect('changed', self.gui_callback)

		view.set_sensitive(True)

		view.set_tooltip_column(2)

		gdk.threads_leave()

#----------------------------------------------------------------------



def reconfigure():

	g_config.save()

	g_remote.reconfigure()



#----------------------------------------------------------------------

# ThemesListbox

#----------------------------------------------------------------------

class ThemesListbox:

	def __init__(self):

		scroll = gtk.ScrolledWindow()

		scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)

		scroll.set_shadow_type(gtk.SHADOW_IN)



		model = gtk.ListStore(gobject.TYPE_STRING,

					gobject.TYPE_PYOBJECT,

					gobject.TYPE_STRING)

		renderer = gtk.CellRendererText()

		column = gtk.TreeViewColumn("Theme", renderer, text=0)

		view = gtk.TreeView(model)

		view.append_column(column)

		view.set_sensitive(False)



		theme_loader = ThemeDeferredLoader(view, model, self.view_cursor_changed)

		theme_loader.start()



		scroll.add(view)

		scroll.set_size_request(200, -1)

		self.widget = scroll



	def view_cursor_changed(self, selection):

		(model, it) = selection.get_selected()

		if not it:

			return

		theme = model.get_value(it, 1)

		g_config.set_theme(theme.dirname)

		reconfigure()



#----------------------------------------------------------------------

# Parameters Table

#----------------------------------------------------------------------

def make_boolean(setter, getter):

	w = gtk.CheckButton()

	w.set_active(getter())

	def changed(checkbox):

		active = checkbox.get_active()

		setter(active)

		reconfigure()

	w.connect('toggled', changed)

	return w



def make_string(setter, getter):

	w = gtk.Entry()

	try:

		w.set_text(getter())

	except:

		pass



	def changed(entry):

		text = entry.get_text()

		setter(text)

		reconfigure()

	w.connect('changed', changed)

	return w



def make_number(setter, getter, mmin, mmax):

	w = gtk.SpinButton()

	w.set_increments(1,5)

	w.set_range(mmin, mmax)

	w.set_value(getter())

	def changed(num):

		n = num.get_value_as_int()

		setter(n)

		reconfigure()

	w.connect('value-changed', changed)

	return w



class ParametersTable:

	def __init__(self):

		table = gtk.Table(1,2)

		table.set_row_spacings(5)



		align = gtk.Alignment(0,0,1,1)

		align.set_padding(0, 5, 0, 0)

		align.add(table)



		frame = gtk.Frame("Parameters")

		frame.set_border_width(5)

		frame.add(align)



		self.widget = frame

		self.table = table



		e = make_string(g_config.set_clock_prog,

				g_config.get_clock_prog)

		self.add_row("Clock program:", e)



		e = make_boolean(g_config.set_task_urgency_hint,

				g_config.get_task_urgency_hint)

		self.add_row("Task urgency hint:", e)



		e = make_number(g_config.set_drag_threshold,

				g_config.get_drag_threshold, 0, 9999)

		self.add_row("Drag threshold:", e)



		e = make_number(g_config.set_task_death_threshold,

				g_config.get_task_death_threshold, 0, 9999)

		self.add_row("Task death threshold:", e)





	def add_row(self, label_text, widget):

		label = gtk.Label(label_text)

		label.set_alignment(0, 0)

		row = self.table.props.n_rows

		self.table.attach(label, 0, 1, row, row+1, gtk.EXPAND | gtk.FILL, 0, 5, 0)

		self.table.attach(widget, 1, 2, row, row+1, gtk.FILL, 0, 5, 0)



#----------------------------------------------------------------------

# IconList

#----------------------------------------------------------------------

class Icon:

	def __init__(self, prog=None, icon=None, pixbuf=None):

		self.prog = prog

		self.icon = icon

		self.pixbuf = pixbuf



	def set(self, prog=None, icon=None, pixbuf=None):

		self.prog = prog

		self.icon = icon

		self.pixbuf = pixbuf





class IconList(gtk.Widget):

	def __init__(self, changed_cb, icon_size = 32):

		gtk.Widget.__init__(self)

		self.icon_size = icon_size

		self.icons = []

		self.active = -1

		self.active_changed = []

		self.changed_cb = changed_cb



	def do_realize(self):

		self.set_flags(self.flags() | gtk.REALIZED)



		self.window = gtk.gdk.Window(

			self.get_parent_window(),

			width = self.allocation.width,

			height = self.allocation.height,

			window_type = gdk.WINDOW_CHILD,

			wclass = gdk.INPUT_OUTPUT,

			event_mask = self.get_events() | gdk.EXPOSURE_MASK | gtk.gdk.BUTTON_PRESS_MASK

		)



		self.window.set_user_data(self)

		self.style.attach(self.window)

		self.style.set_background(self.window, gtk.STATE_NORMAL)

		self.window.move_resize(*self.allocation)



		self.connect('expose-event', self._expose_event)

		self.connect('button-press-event', self._button_press_event)



	def do_unrealize(self):

		self.window.set_user_data(None)



	def do_size_request(self, requisition):

		requisition.height = self.icon_size

		requisition.width = len(self.icons) * self.icon_size



	def do_size_allocate(self, allocation):

		self.allocation = allocation



		if self.flags() & gtk.REALIZED:

			self.window.move_resize(*allocation)



	def _expose_event(self, widget, event):

		gc = self.style.fg_gc[gtk.STATE_NORMAL]

		for i in xrange(len(self.icons)):

			icon = self.icons[i]

			self._draw_icon_centered(icon.pixbuf, self.icon_size * i, i == self.active)



	def _button_press_event(self, widget, event):

		i = event.x / self.icon_size

		if len(self.icons) > i and i >= 0:

			self.active = int(i)

			self._update_gui()



	# draw utils

	def _draw_icon_centered(self, icon, xoff, active=False):

		gc = self.style.bg_gc[gtk.STATE_SELECTED]



		if active:

			self.window.draw_rectangle(gc, True, xoff, 0, self.icon_size, self.icon_size)

		if not icon:

			hs = self.icon_size / 2

			s = (self.icon_size - hs) / 2

			self.window.draw_rectangle(gc, True, xoff+s, s, hs, hs)

		else:

			w = icon.get_width()

			h = icon.get_height()

			x = (self.icon_size - w) / 2

			y = (self.icon_size - h) / 2

			self.window.draw_pixbuf(gc, icon, 0, 0, xoff+x, y, -1, -1)



	def _update_gui(self):

		self.set_size_request(self.icon_size * len(self.icons), self.icon_size)

		if self.flags() & gtk.REALIZED:

			rect = gtk.gdk.Rectangle(0,0,self.allocation[2],self.allocation[3])

			self.window.invalidate_rect(rect, True)



		for cb in self.active_changed:

			cb(self.active)



	# ----------------------------------------------------------------

	def _load_pixbuf_for_icon(self, icon):

		pixbuf = None

		if icon:

			pixbuf = gtk.gdk.pixbuf_new_from_file(icon)

			if pixbuf.get_width() > self.icon_size or pixbuf.get_height() > self.icon_size:

				pixbuf = pixbuf.scale_simple(self.icon_size, self.icon_size, gtk.gdk.INTERP_HYPER)

		return pixbuf



	def _validate_active(self):

		if not len(self.icons):

			self.active = -1

			return

		if self.active < 0:

			self.active = 0

		if self.active >= len(self.icons):

			self.active = len(self.icons)-1



	def insert(self, where_index, prog=None, icon=None):

		assert(where_index >= 0 and where_index < len(self.icons))

		try:

			ic = Icon(prog, icon, self._load_pixbuf_for_icon(icon))

		except:

			return

		self.icons.insert(where_index, ic)

		self._update_gui()



	def remove(self, where_index):

		assert(where_index >= 0 and where_index < len(self.icons))

		commit_change = False

		if self.icons[where_index].icon != None and self.icons[where_index].prog != None:

			commit_change = True

		del self.icons[where_index]

		self._validate_active()

		self._update_gui()

		if commit_change:

			self.changed_cb()



	def change(self, where_index, prog, icon):

		assert(where_index >= 0 and where_index < len(self.icons))

		self.icons[where_index].set(prog, icon, self._load_pixbuf_for_icon(icon))

		if prog != None and icon != None:

			self.changed_cb()

		self._update_gui()



	def move(self, where_index, offset):

		assert(where_index >= 0 and where_index < len(self.icons))

		dest = where_index + offset

		# clamp dest

		if dest < 0:

			dest = 0

		if dest >= len(self.icons):

			dest = len(self.icons)-1



		if dest == where_index:

			return

		if offset > 0:

			dest += 1



		ic = self.icons[where_index]

		self.icons.insert(dest, ic)

		if offset > 0:

			del self.icons[where_index]

		elif offset < 0:

			del self.icons[where_index+1]

		self.active += offset

		# clamp active

		self._validate_active()

		self.changed_cb()

		self._update_gui()



	# utility

	def append(self, prog=None, icon=None):

		try:

			ic = Icon(prog, icon, self._load_pixbuf_for_icon(icon))

		except:

			return

		self.icons.append(ic)

		self._update_gui()



gobject.type_register(IconList)



#----------------------------------------------------------------------



class LaunchbarItem:

	def __init__(self, prog, icon):

		self.prog = prog

		self.icon = icon



class LaunchbarEditor:

	def __init__(self):

		self.items = []

		self.parse_items()

		self.build_gui()



	def build_toolbar(self, iconlist):

		hbox = gtk.HBox()

		vbox = gtk.VBox()

		hbox.pack_start(vbox, False)



		# <- Move left

		but = gtk.Button()

		but.set_focus_on_click(False)

		but.set_relief(gtk.RELIEF_NONE)

		but.set_image(gtk.image_new_from_stock(gtk.STOCK_GO_BACK, gtk.ICON_SIZE_SMALL_TOOLBAR))

		def click(widget):

			if iconlist.active == -1:

				return

			iconlist.move(iconlist.active, -1)

		but.connect('clicked', click)

		vbox.pack_start(but, False)



		# + Add

		but = gtk.Button()

		but.set_focus_on_click(False)

		but.set_relief(gtk.RELIEF_NONE)

		but.set_image(gtk.image_new_from_stock(gtk.STOCK_ADD, gtk.ICON_SIZE_SMALL_TOOLBAR))

		def click(widget):

			if iconlist.active != -1:

				iconlist.insert(iconlist.active)

			else:

				iconlist.append()

		but.connect('clicked', click)

		vbox.pack_start(but, False)



		vbox = gtk.VBox()

		hbox.pack_start(vbox, False)



		# -> Move right

		but = gtk.Button()

		but.set_focus_on_click(False)

		but.set_relief(gtk.RELIEF_NONE)

		but.set_image(gtk.image_new_from_stock(gtk.STOCK_GO_FORWARD, gtk.ICON_SIZE_SMALL_TOOLBAR))

		def click(widget):

			if iconlist.active == -1:

				return

			iconlist.move(iconlist.active, 1)

		but.connect('clicked', click)

		vbox.pack_start(but, False)



		# - Remove

		but = gtk.Button()

		but.set_focus_on_click(False)

		but.set_relief(gtk.RELIEF_NONE)

		but.set_image(gtk.image_new_from_stock(gtk.STOCK_REMOVE, gtk.ICON_SIZE_SMALL_TOOLBAR))

		def click(widget):

			if iconlist.active == -1:

				return

			iconlist.remove(iconlist.active)

		but.connect('clicked', click)

		vbox.pack_start(but, False)



		align = gtk.Alignment(0.5,0.5)

		align.add(hbox)



		return align



	def build_edit(self, iconlist):

		table = gtk.Table(1,2)

		table.set_row_spacings(5)

		def add_row(label_text, widget):

			label = gtk.Label(label_text)

			label.set_alignment(0, 0)

			row = table.props.n_rows

			table.attach(label, 0, 1, row, row+1, gtk.FILL, 0, 5, 0)

			table.attach(widget, 1, 2, row, row+1, gtk.EXPAND | gtk.FILL, 0, 5, 0)



		e1 = gtk.Entry()

		filedialog = gtk.FileChooserDialog("Select an icon")

		filedialog.add_buttons(gtk.STOCK_OK, gtk.RESPONSE_OK,

				gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)

		filefilter = gtk.FileFilter()

		filefilter.add_mime_type("image/png")

		filedialog.set_filter(filefilter)

		e2 = gtk.FileChooserButton(filedialog)



		# preview

		preview = gtk.Image()

		e2.set_preview_widget(preview)

		def update_preview_cb(file_chooser, preview):

			filename = file_chooser.get_preview_filename()

			try:

				pixbuf = gtk.gdk.pixbuf_new_from_file(filename)

				preview.set_from_pixbuf(pixbuf)

				have_preview = True

			except:

				have_preview = False

			file_chooser.set_preview_widget_active(have_preview)

		e2.connect('update-preview', update_preview_cb, preview)

		e1.set_sensitive(False)

		e2.set_sensitive(False)



		# callback for changed event

		def e1_edited(widget):

			text = widget.get_text()

			active = iconlist.active

			if active != -1:

				a = iconlist.icons[active]

				iconlist.change(active, text, a.icon)

		e1.connect('changed', e1_edited)



		# callback for file dialog response event

		def file_dialog_response(dialog, response):

			filename = dialog.get_filename()

			active = iconlist.active

			if response != gtk.RESPONSE_OK:

				if active != -1:

					icon = iconlist.icons[active].icon

					if icon:

						e2.set_filename(iconlist.icons[active].icon)

					else:

						e2.unselect_all()

				return

			if active != -1:

				a = iconlist.icons[active]

				iconlist.change(active, a.prog, filename)

		filedialog.connect('response', file_dialog_response)



		# callback for iconlist

		def active_changed_cb(active):

			e1.handler_block_by_func(e1_edited)

			if active != -1:

				e1.set_sensitive(True)

				e2.set_sensitive(True)

				prog = iconlist.icons[active].prog

				if prog:

					e1.set_text(prog)

				else:

					e1.set_text("")

				icon = iconlist.icons[active].icon

				if icon:

					e2.set_filename(icon)

				else:

					e2.unselect_all()

			else:

				e1.set_text("")

				e2.unselect_all()

				e1.set_sensitive(False)

				e2.set_sensitive(False)

			e1.handler_unblock_by_func(e1_edited)

		iconlist.active_changed.append(active_changed_cb)



		# add widgets to table

		add_row("Program:", e1)

		add_row("Icon:", e2)



		align = gtk.Alignment(0,0,1,1)

		align.set_padding(0, 5, 0, 0)

		align.add(table)



		return align



	def build_gui(self):

		w = IconList(self.save_items)

		for i in self.items:

			w.append(i.prog, i.icon)



		scroll = gtk.ScrolledWindow()

		scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_NEVER)

		scroll.add_with_viewport(w)

		scroll.get_child().set_shadow_type(gtk.SHADOW_NONE)

		def scrollchresize(cont, event):

			adj = cont.get_hadjustment()

			if adj.page_size == adj.upper:

				(width,h) = w.size_request()

				cont.set_size_request(-1, h)

			else:

				cont.set_size_request(-1, -1)

		scroll.connect('size-allocate', scrollchresize)



		hbox = gtk.HBox()

		hbox.pack_start(self.build_edit(w), True)

		hbox.pack_start(gtk.VSeparator(), False)

		hbox.pack_start(self.build_toolbar(w), False)



		vbox = gtk.VBox()

		vbox.pack_start(scroll, False)

		vbox.pack_start(gtk.HSeparator(), False)

		vbox.pack_start(hbox, False)



		frame = gtk.Frame("Launch bar")

		frame.set_border_width(5)

		frame.add(vbox)



		self.iconlist = w

		self.widget = frame



	def parse_items(self):

		for i in g_launch:

			self.items.append(LaunchbarItem(i.prog, i.icon))



	def save_items(self):

		lb = g_config.tree['launchbar']

		children = lb.children[:]

		for i in children:

			g_config.tree.remove_node(i)

		for i in self.iconlist.icons:

			node = bmpanel2.ConfigNode(name="exec", value=i.prog)

			g_config.tree.append_node_as_child(node, lb)

			node2 = bmpanel2.ConfigNode(name="icon", value=i.icon)

			g_config.tree.append_node_as_child(node2, node)

		reconfigure()



gdk.threads_init()



def die(widget, data=None):

	gtk.main_quit()



win = gtk.Window(gtk.WINDOW_TOPLEVEL)

win.set_title("Bmpanel2 Config")

win.connect('destroy', die)



themeslb = ThemesListbox()

paramtbl = ParametersTable()

lbedit = LaunchbarEditor()



hbox = gtk.HBox()

hbox.pack_start(paramtbl.widget, False, True)

hbox.pack_start(themeslb.widget, True, True)



vbox = gtk.VBox()

vbox.pack_start(hbox)

vbox.pack_start(lbedit.widget, False, True)



win.add(vbox)

win.show_all()



if g_remote.started_with_theme:

	d = gtk.MessageDialog(type=gtk.MESSAGE_WARNING, buttons=gtk.BUTTONS_OK)

	d.set_markup("Bmpanel2 was started with <b>--theme</b> parameter. "

		"It means it will not react on theme changes in the config file (via this tool or not).")

	d.run()

	d.destroy()



gtk.main()



 

tava no arquivo /usr/bin/bmpanel2cfg