def __init__(self):
hildon.Program.__init__(self)
self.window = hildon.Window()
self.window.connect("delete-event", gtk.main_quit)
self.add_window(self.window)
# Osso stuff
self.osso_c = osso.Context("osso_test_mime_icons", "0.0.1", False)
self.mime = osso.Mime(self.osso_c)
# Remaining widgets
vbox = gtk.VBox()
self.entry = gtk.Entry()
vbox.pack_start(self.entry, expand=False, fill=True)
self.button = gtk.Button("Ok")
self.button.connect("clicked", self.button_cb)
vbox.pack_start(self.button, expand=False, fill=True)
scroll = gtk.ScrolledWindow()
vbox.pack_start(scroll)
self.model = gtk.ListStore(gtk.gdk.Pixbuf, str)
self.iconview = gtk.IconView(self.model)
self.iconview.set_pixbuf_column(0)
self.iconview.set_text_column(1)
self.iconview.set_margin(12)
self.iconview.set_item_width(125)
scroll.add(self.iconview)
self.window.add(vbox)
self.window.show_all()
def __init__(self, edit_dialog):
gtk.ScrolledWindow.__init__(self)
self._edit_dialog = edit_dialog
self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
# The ListStore layout is (thumbnail, basename, full path).
self._liststore = gtk.ListStore(gtk.gdk.Pixbuf, str, str)
self._iconview = gtk.IconView(self._liststore)
self._iconview.set_pixbuf_column(0)
self._iconview.set_tooltip_column(1)
self._iconview.set_reorderable(True)
self._iconview.set_selection_mode(gtk.SELECTION_MULTIPLE)
self._iconview.connect('button_press_event', self._button_press)
self._iconview.connect('key_press_event', self._key_press)
self._iconview.connect_after('drag_begin', self._drag_begin)
self.add(self._iconview)
self._ui_manager = gtk.UIManager()
ui_description = """
<ui>
<popup name="Popup">
<menuitem action="remove" />
</popup>
</ui>
"""
self._ui_manager.add_ui_from_string(ui_description)
actiongroup = gtk.ActionGroup('comix-edit-archive-image-area')
actiongroup.add_actions([
('remove', gtk.STOCK_REMOVE, _('Remove from archive'), None, None,
self._remove_pages)])
self._ui_manager.insert_action_group(actiongroup, 0)
def _create_store(self, widget=None):
if self._sample_window is None:
self._sample_box = gtk.EventBox()
self._sample_window = gtk.ScrolledWindow()
self._sample_window.set_policy(gtk.POLICY_NEVER,
gtk.POLICY_AUTOMATIC)
width = gtk.gdk.screen_width() / 2
height = gtk.gdk.screen_height() / 2
self._sample_window.set_size_request(width, height)
self._sample_window.show()
store = gtk.ListStore(gtk.gdk.Pixbuf, str)
icon_view = gtk.IconView()
icon_view.set_model(store)
icon_view.set_selection_mode(gtk.SELECTION_SINGLE)
icon_view.connect('selection-changed', self._sample_selected,
store)
icon_view.set_pixbuf_column(0)
icon_view.grab_focus()
self._sample_window.add_with_viewport(icon_view)
icon_view.show()
self._fill_samples_list(store)
width = gtk.gdk.screen_width() / 4
height = gtk.gdk.screen_height() / 4
self._sample_box.add(self._sample_window)
self.fixed.put(self._sample_box, width, height)
self._sample_window.show()
self._sample_box.show()
def __init__(self, label, path_list, avatar_chooser):
gtk.HBox.__init__(self)
self.set_spacing(4)
self.chooser = avatar_chooser
self.model = gtk.ListStore(gtk.gdk.Pixbuf, str)
self.iconview = gtk.IconView(self.model)
self.iconview.enable_model_drag_dest([('text/uri-list', 0, 0)],
gtk.gdk.ACTION_DEFAULT
| gtk.gdk.ACTION_COPY)
self.iconview.connect("drag-data-received", self._drag_data_received)
self.iconview.set_pixbuf_column(0)
self.iconview.connect("item-activated", self._on_icon_activated)
self.iconview.connect("button_press_event", self.pop_up)
self.label = gtk.Label(label)
self.scroll = gtk.ScrolledWindow()
self.scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self.scroll.set_shadow_type(gtk.SHADOW_IN)
self.scroll.add(self.iconview)
self.pack_start(self.scroll, True, True)
self.stop = False
# Start a new thread to fill the iconview with images from path_list
thread.start_new_thread(self.fill, (path_list, ))
def __init__(self):
super(PicasaInfoPage, self).__init__()
self.label = _('Images')
self._disabled = False
self.gd_client = gdata.photos.service.PhotosService()
#self.set_policy(gtk.POLICY_ALWAYS, gtk.POLICY_ALWAYS)
self.iconview = gtk.IconView()
# TODO: we set the columns here because for some reason the
# combination of paned windows, notebooks and scrollbars seems
# to screw up the icon view automatic row/column handling so
# that if you make the infobox larger then the images seem to
# move between rows ok but if you make it smaller it doesn't
self.iconview.set_columns(1)
self.iconview.set_pixbuf_column(0)
self.vbox.pack_start(self.iconview)
self._current_row = None
def on_clicked(*args):
d = PicasaSettingsDialog()
if d.run():
self.update(self._current_row)
self.status_box = StatusBox(on_clicked)
self.vbox.pack_start(self.status_box)
self.show_status_box()
def build_icon_view(self):
self.clean_main_view()
for category in self.items_visible_by_categories:
frame = Gtk.Frame(label=category)
self.content_ui_vbox.add(frame)
hbox = Gtk.HBox()
frame.add(hbox)
#Impossible to add a custom structure in liststore ...
liststore = Gtk.ListStore(Gtk.gdk.Pixbuf, str, str)
iconview = Gtk.IconView(liststore)
iconview.set_pixbuf_column(0)
iconview.set_text_column(1)
#GTK2 Specific => Force width to avoid too much spacing
iconview.set_item_width(self.icon_view_icons_size * 4)
iconview.set_columns(self.icon_view_columns)
iconview.set_selection_mode(Gtk.SELECTION_SINGLE)
#GTK2 spcific => enable single selection click
iconview.connect("selection_changed",
self.on_icon_view_selection_changed)
logging.debug("build_UI: get_item_width = %s" %
iconview.get_item_width())
logging.debug("build_UI: get_spacing = %s" %
iconview.get_spacing())
logging.debug("build_UI: get_row_spacing = %s" %
iconview.get_row_spacing())
logging.debug("build_UI: get_column_spacing = %s" %
iconview.get_column_spacing())
logging.debug("build_UI: get_margin = %s" % iconview.get_margin())
logging.debug("build_UI: get_item_padding = %s" %
iconview.get_item_padding())
logging.debug("build_UI: item orientation = %s" %
iconview.get_item_orientation())
if (self.icon_force_size == True):
icon_lookup_flags = Gtk.ICON_LOOKUP_FORCE_SVG
else:
icon_lookup_flags = Gtk.ICON_LOOKUP_USE_BUILTIN
self.define_icon_type_with_gtk_theme()
for i in self.items_visible_by_categories[category]:
if (i.icon_type == "fix"):
pixbuf = Gtk.gdk.pixbuf_new_from_file(i.icon)
elif (i.icon_type == "themed"):
pixbuf = self.theme.load_icon(i.icon,
self.icon_view_icons_size,
icon_lookup_flags)
else:
pixbuf = self.theme.load_icon(self.icon_fallback,
self.icon_view_icons_size,
icon_lookup_flags)
liststore.append([pixbuf, i.name, i.path])
hbox.add(iconview)
def __init__(self, instance):
gtk.VBox.__init__(self)
self.set_border_width(5)
self.app = instance
# model
self.storemodel = gtk.ListStore(str, str, object)
self.scrollwin = gtk.ScrolledWindow()
self.scrollwin.set_policy(gtk.POLICY_NEVER,
gtk.POLICY_AUTOMATIC)
self.pack_start(self.scrollwin)
self.iconview = gtk.IconView(self.storemodel)
self.treeview = gtk.TreeView(self.storemodel)
namecol = gtk.TreeViewColumn(_("Name"))
self.treeview.append_column(namecol)
namecell = gtk.CellRendererText()
namecol.pack_start(namecell)
namecol.add_attribute(namecell, "text", COL_NAME)
namecol = gtk.TreeViewColumn(_("Description"))
self.treeview.append_column(namecol)
namecell = gtk.CellRendererText()
namecell.set_property("ellipsize", pango.ELLIPSIZE_END)
namecol.pack_start(namecell)
namecol.add_attribute(namecell, "text", COL_DESCRIPTION)
self.scrollwin.add(self.treeview)
self._fillUpModel()
def add_box(self, box):
'''
Add a new box to the panels on the right
'''
print 'Add box %s' % box.get_resource()
model = gtk.ListStore(gobject.TYPE_STRING, gtk.gdk.Pixbuf)
iconview = gtk.IconView(model)
iconview.set_text_column(0)
iconview.set_pixbuf_column(1)
iconview.set_reorderable(True)
iconview.enable_model_drag_source(gtk.gdk.BUTTON1_MASK,
self.DND_TARGET, gtk.gdk.ACTION_MOVE)
iconview.enable_model_drag_dest(self.DND_TARGET, gtk.gdk.ACTION_MOVE)
iconview.drag_dest_add_image_targets()
iconview.connect("drag_data_get", self.drag_cb)
iconview.connect("drag_data_received", self.drop_cb)
scrollable = gtk.ScrolledWindow()
scrollable.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
scrollable.add(iconview)
scrollable.show_all()
hbox = gtk.HBox()
hbox.pack_start(
gtk.image_new_from_stock(gtk.STOCK_DIRECTORY,
gtk.ICON_SIZE_BUTTON), False, False, 10)
#hbox.pack_end(gtk.Label(name), True, True, 10)
hbox.show_all()
self.boxes.append_page(scrollable, hbox)
self.model_to_box[model] = box
self.box_to_model[box] = model
def __build_window(self):
"""Build up the widget"""
self.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_POPUP_MENU)
vbox = gtk.VBox()
self.add(vbox)
# icon list
scld_win = gtk.ScrolledWindow()
scld_win.set_policy(gtk.POLICY_NEVER, gtk.POLICY_ALWAYS)
scld_win.set_shadow_type(gtk.SHADOW_ETCHED_IN)
vbox.pack_start(scld_win, expand=True, fill=True)
self.symbol_iv = gtk.IconView()
self.symbol_iv.set_pixbuf_column(0)
self.symbol_iv.set_property("columns", 7)
self.symbol_iv.set_property("item-width", 32)
# IconView size:
# --------------
# it seems that with the above parameters, a row width is about:
# item_count * (32px (item) + 6px (dflt padding) + 2px (spacing?)) \
# + 2*6px (dflt widget margin)
# The same goes for row height, but being right for this value is less
# important due to the vertical scrollbar.
# The IcVw size should fit the width of 7 cols and height of ~4 lines.
self.symbol_iv.set_size_request(40 * 7 + 12, 38 * 4)
scld_win.add(self.symbol_iv)
# icon remove button
img = gtk.Image()
img.set_from_stock(gtk.STOCK_REMOVE, gtk.ICON_SIZE_BUTTON)
self.remove_bt = gtk.Button()
self.remove_bt.set_image(img)
self.remove_bt.set_label(_("Remove selected icon"))
vbox.pack_start(self.remove_bt, fill=False, expand=False)
# set the callbacks
self.symbol_iv.connect("selection-changed", self.on_selection_changed)
self.remove_bt.connect("clicked", self.on_remove_bt_clicked)
def __init__(self, ui, plugin, pageview):
Dialog.__init__(
self,
ui,
_('Insert Symbol'), # T: Dialog title
button=(_('_Insert'), 'gtk-ok'), # T: Button label
defaultwindowsize=(350, 400))
self.plugin = plugin
self.pageview = pageview
if not plugin.symbols:
plugin.load_file()
self.textentry = InputEntry()
self.vbox.pack_start(self.textentry, False)
# TODO make this iconview single-click
model = gtk.ListStore(str, str) # text, shortcut
self.iconview = gtk.IconView(model)
self.iconview.set_text_column(0)
self.iconview.set_column_spacing(0)
self.iconview.set_row_spacing(0)
if gtk.gtk_version >= (2, 12, 0):
self.iconview.set_property('has-tooltip', True)
self.iconview.connect('query-tooltip', self.on_query_tooltip)
self.iconview.connect('item-activated', self.on_activated)
self.vbox.add(ScrolledWindow(self.iconview))
button = gtk.Button(stock=gtk.STOCK_EDIT)
button.connect('clicked', self.on_edit)
self.action_area.add(button)
self.action_area.reorder_child(button, 0)
self.load_symbols()
def __init__(self):
super(PyAppWidgetIconView, self).__init__()
self.set_title("- Icon view -")
self.set_size_request(650, 400)
#self.set_border_width(2)
self.set_position(gtk.WIN_POS_CENTER)
self.connect("destroy", gtk.main_quit)
self.col_path = 0
self.col_pixbuf = 1
self.col_is_directory = 2
self.current_directory = "/"
vbox = gtk.VBox(False, 0)
toolbar = gtk.Toolbar()
vbox.pack_start(toolbar, False, False, 0)
self.upButton = gtk.ToolButton(gtk.STOCK_GO_UP)
self.upButton.set_is_important(True)
self.upButton.set_sensitive(False)
toolbar.insert(self.upButton, -1)
homeButton = gtk.ToolButton(gtk.STOCK_HOME)
homeButton.set_is_important(True)
toolbar.insert(homeButton, -1)
self.fileIcon = self.get_icon(gtk.STOCK_FILE)
self.dirIcon = self.get_icon(gtk.STOCK_DIRECTORY)
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
vbox.pack_start(sw, True, True, 0)
self.store = self.create_store()
self.fill_store()
iconView = gtk.IconView(self.store)
iconView.set_selection_mode(gtk.SELECTION_MULTIPLE)
self.upButton.connect("clicked", self.on_up_clicked)
homeButton.connect("clicked", self.on_home_clicked)
iconView.set_text_column(self.col_path)
iconView.set_pixbuf_column(self.col_pixbuf)
iconView.connect("item-activated", self.on_item_activated)
sw.add(iconView)
iconView.grab_focus()
self.add(vbox)
self.show_all()
def __init__(self, gladexml, emerald_dict):
## load buttons and attach signals
self.emerald_dict = emerald_dict
self.emerald_addbtn = gladexml.get_widget("emerald_addbtn")
self.emerald_applybtn = gladexml.get_widget("emerald_applybtn")
self.emerald_delbtn = gladexml.get_widget("emerald_delbtn")
self.statbar = gladexml.get_widget("statusbar")
dic = {
"on_emerald_addbtn_clicked": self.on_emerald_addbtn_clicked,
"on_emerald_applybtn_clicked": self.apply_emerald_theme,
"on_emerald_delbtn_clicked": self.on_emerald_delbtn_clicked,
}
gladexml.signal_autoconnect(dic)
## for threads
self.progress_box = gladexml.get_widget("progress_box")
self.progress_text = gladexml.get_widget("progress_box_text")
self.main_progressbar = gladexml.get_widget("main_progressbar")
## setup the liststore model
self.model = gtk.ListStore(str, gtk.gdk.Pixbuf, str, str, str, str,
str, str)
## setup the iconview
self.emerald_iconview = gtk.IconView(model=self.model)
self.emerald_iconview.set_pixbuf_column(1)
self.emerald_iconview.set_text_column(0)
self.emerald_iconview.set_item_width(225)
self.emerald_iconview.set_selection_mode('single')
self.emerald_iconview.set_reorderable(1)
## iconview signal
self.emerald_iconview.connect('selection_changed', self.get_model)
self.emerald_iconview.connect('button-press-event',
self.check_double_click)
self.emerald_gest_info = gladexml.get_widget("emerald_gest_info")
self.emerald_gest_viewer = gladexml.get_widget("emerald_gest_viewer")
self.emerald_dret_label = gladexml.get_widget("emerald_dret_label")
self.emerald_applybtn = gladexml.get_widget("emerald_applybtn")
self.emerald_addbtn = gladexml.get_widget("emerald_addbtn")
self.emerald_delbtn = gladexml.get_widget("emerald_delbtn")
self.decoration_page_img = gladexml.get_widget("decoration_page_img")
self.decoration_page_desc = gladexml.get_widget("decoration_page_desc")
self.decoration_page_img.set_from_file(config.img_path +
"//decoration.png")
self.decoration_page_desc.set_text(
_("Window decoration :\nManage and install your metacity/emerald themes"
))
self.emerald_gest_info.set_text(_("Available themes list"))
## add the iconview
self.emerald_gest_viewer.add(self.emerald_iconview)
self.list_emerald_themes()
def make_view(self,data,single=False):
self.view = gtk.IconView(self.init_data(data))
if not single:
self.view.set_selection_mode(gtk.SELECTION_MULTIPLE)
else:
self.view.set_selection_mode(gtk.SELECTION_SINGLE)
self.view.set_text_column(0)
self.view.set_pixbuf_column(1)
self.view.show_all()
return self.view
def iconview(col=None, space=None, margin=None, itemw=None, selmode=None):
tmpiv = gtk.IconView()
if col:
tmpiv.set_columns(col)
if space:
tmpiv.set_spacing(space)
if margin:
tmpiv.set_margin(margin)
if itemw:
tmpiv.set_item_width(itemw)
if selmode:
tmpiv.set_selection_mode(selmode)
return tmpiv
def __init__(self, dbstate, uistate, track, media_list, update=None):
self.iconlist = gtk.IconView()
ButtonTab.__init__(self, dbstate, uistate, track, _('_Gallery'), True)
DbGUIElement.__init__(self, dbstate.db)
self.track_ref_for_deletion("iconlist")
self.media_list = media_list
self.callman.register_handles(
{'media': [mref.ref for mref in self.media_list]})
self.update = update
self._set_dnd()
self.rebuild()
self.show_all()
def __init__(self, library):
gtk.ScrolledWindow.__init__(self)
self._library = library
self._stop_update = False
self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self._liststore = gtk.ListStore(gtk.gdk.Pixbuf, int) # (Cover, ID).
self._iconview = gtk.IconView(self._liststore)
self._iconview.set_pixbuf_column(0)
self._iconview.connect('item_activated', self._book_activated)
self._iconview.connect('selection_changed', self._selection_changed)
self._iconview.connect_after('drag_begin', self._drag_begin)
self._iconview.connect('drag_data_get', self._drag_data_get)
self._iconview.connect('drag_data_received', self._drag_data_received)
self._iconview.connect('button_press_event', self._button_press)
self._iconview.connect('key_press_event', self._key_press)
self._iconview.modify_base(gtk.STATE_NORMAL, gtk.gdk.Color()) # Black.
self._iconview.enable_model_drag_source(
0, [('book', gtk.TARGET_SAME_APP, _DRAG_BOOK_ID)],
gtk.gdk.ACTION_MOVE)
self._iconview.drag_dest_set(gtk.DEST_DEFAULT_ALL,
[('text/uri-list', 0, _DRAG_EXTERNAL_ID)],
gtk.gdk.ACTION_COPY | gtk.gdk.ACTION_MOVE)
self._iconview.set_selection_mode(gtk.SELECTION_MULTIPLE)
self.add(self._iconview)
self._ui_manager = gtk.UIManager()
ui_description = """
<ui>
<popup name="Popup">
<menuitem action="open" />
<separator />
<menuitem action="remove from collection" />
<menuitem action="remove from library" />
</popup>
</ui>
"""
self._ui_manager.add_ui_from_string(ui_description)
actiongroup = gtk.ActionGroup('comix-library-book-area')
actiongroup.add_actions([('open', gtk.STOCK_OPEN, _('Open'), None,
None, self.open_selected_book),
('remove from collection', gtk.STOCK_REMOVE,
_('Remove from this collection'), None, None,
self._remove_books_from_collection),
('remove from library', gtk.STOCK_DELETE,
_('Remove from the library...'), None, None,
self._remove_books_from_library)])
self._ui_manager.insert_action_group(actiongroup, 0)
def __init__(self):
""" Constructor """
HIGHBox.__init__(self)
self.scroll = HIGScrolledWindow()
self._box = HIGHBox()
self._icons_list = []
self._tabstruct = TabStruct()
self.__current = [0]
self.__model = gtk.ListStore(str, gtk.gdk.Pixbuf)
#self.__model = gtk.ListStore(str, HIGHBox)
self.__pixmap_d = Path.pixmaps_dir
self.__icon = gtk.IconView()
self.__icon.set_model(self.__model)
self.__icon.set_text_column(0)
self.__icon.set_pixbuf_column(1)
self.__icon.set_orientation(gtk.ORIENTATION_VERTICAL)
self.__icon.set_selection_mode(gtk.SELECTION_SINGLE)
# Change background color -- FIXME
#self.__icon.set_name("icon tabs")
#gtk.rc_parse_string(
#"""
#style "iconview"
#{
#bg[PRELIGHT] = { 0.75, 3, 1 }
#}
#class 'GtkIconView' style 'iconview'
#""")
map = self.__icon.get_colormap()
colour = map.alloc_color("#FFF9E9") # light red
style = self.__icon.get_style().copy()
style.base[gtk.STATE_NORMAL] = colour
self.__icon.set_style(style)
#self.cellpb = gtk.CellRendererPixbuf()
#self.cellpb.set_property('cell-background', 'yellow')
#self.__icon.pack_start(self.cellpb, False)
#self.__icon.set_attributes(self.cellpb, pixbuf=0)
self.pack_start(self.scroll, True, True)
self.scroll.add(self.__icon)
def __init__(self,gladexml,gstyle_obj):
## load buttons and attach signals
self.gstyle_obj = gstyle_obj
self.mouse_dict = self.gstyle_obj.mouse_dict
self.mouse_scroll = gladexml.get_widget("mouse_scroll")
self.mouse_gest_label = gladexml.get_widget("mouse_gest_label")
self.mouse_gest_label.set_text(_("Installed mouse themes list"))
self.mouse_gest_colorbtn = gladexml.get_widget("mouse_gest_colorbtn")
self.mouse_gest_welcomentry = gladexml.get_widget("mouse_gest_welcomentry")
self.mouse_page_img = gladexml.get_widget("mouse_page_img")
self.mouse_page_img.set_from_file("%s/mouse.png" % config.img_path)
self.mouse_page_desc = gladexml.get_widget("mouse_page_desc")
self.mouse_page_desc.set_text(_("\nmouse themes : \nOrganize your mouse themes...\n"))
self.mouse_gest_applybtn = gladexml.get_widget('mouse_gest_applybtn')
self.mouse_gest_delbtn = gladexml.get_widget('mouse_gest_delbtn')
self.statbar = gladexml.get_widget("statusbar")
dic = {"on_mouse_addbtn_clicked" : self.action_add,
"on_mouse_applybtn_clicked" : self.action_apply,
"on_mouse_delbtn_clicked" : self.action_del,
}
gladexml.signal_autoconnect(dic)
## gui
self.model = gtk.ListStore(str,gtk.gdk.Pixbuf,str,str,str,str,str,str)
self.mouse_iconview = gtk.IconView(model=self.model)
# Setup GtkIconView
self.mouse_iconview.set_pixbuf_column(1)
self.mouse_iconview.set_text_column(0)
## options
self.mouse_iconview.set_columns(0)
self.mouse_iconview.set_selection_mode('single')
self.mouse_iconview.set_reorderable(1)
self.mouse_iconview.set_item_width(150);
self.mouse_iconview.connect('selection_changed',self.get_model)
self.mouse_iconview.connect('button-press-event',self.check_double_click)
self.mouse_scroll.add(self.mouse_iconview)
self.list_mouse_themes()
def __init__(self):
# create the window
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window = window
window.set_title('Lite Control Panel')
window.connect("destroy", self.destroy)
window.set_border_width(3)
window.set_position(gtk.WIN_POS_CENTER_ALWAYS)
# we make the icons
it = gtk.icon_theme_get_default()
gtk.window_set_default_icon(
it.load_icon("gtk-preferences", 48, gtk.ICON_LOOKUP_FORCE_SVG))
window.resize(740, 400)
self.liststore = gtk.ListStore(gtk.gdk.Pixbuf, str, str)
self.iv = gtk.IconView(self.liststore)
self.iv.set_pixbuf_column(0)
self.iv.set_text_column(1)
self.iv.set_events(self.iv.get_events() | gtk.gdk.BUTTON_PRESS_MASK)
self.iv.connect("button-press-event", self.valtamaction)
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.add(self.iv)
window.add(sw)
first = True
for line in zoose_icons:
if first:
first = False
continue
try:
if '/' in line[1]:
pixbuf = gtk.gdk.pixbuf_new_from_file(line[1])
else:
pixbuf = it.load_icon(line[1], 48,
gtk.ICON_LOOKUP_FORCE_SVG)
except:
pixbuf = it.load_icon('gtk-stop', 48,
gtk.ICON_LOOKUP_FORCE_SVG)
namen = (line[0])
self.liststore.append([pixbuf, namen, line[2]])
window.show_all()
def __init__(self):
"""Initialize."""
super(SlaveIconView, self).__init__()
from saplib import saputils
self.icon_view = gtk.IconView()
self.icon_view.show()
self.add(self.icon_view)
self.model = gtk.ListStore(Pixbuf, str)
self.slave_dict = {}
self.icon_view.set_pixbuf_column(0)
self.icon_view.enable_model_drag_source(gtk.gdk.BUTTON1_MASK, \
[], \
gtk.gdk.ACTION_COPY)
self.icon_view.connect("drag-data-get", self.on_drag_data_get)
self.icon_view.connect("drag-begin", self.on_drag_begin)
self.icon_view.connect("selection-changed", self.on_item_change)
self.slave_icon_selected_callback = None
def _setup_boxes(self, actions):
tscroll = gtk.ScrolledWindow()
tscroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
tscroll.set_shadow_type(gtk.SHADOW_ETCHED_IN)
self.iconview = gtk.IconView()
self._model = gtk.ListStore(gtk.gdk.Pixbuf, object)
self.iconview.set_model(self._model)
self.iconview.set_pixbuf_column(0)
self.iconview.set_selection_mode(gtk.SELECTION_SINGLE)
self.iconview.connect("item-activated", self.__on_dp_dblclick)
self.iconview.connect("button-press-event", self.__on_dp_click)
tscroll.add(self.iconview)
dpsbox = gtk.VBox()
dpsbox.pack_start(tscroll)
buttonbox = gtk.VBox(False)
buttonbox.set_size_request(100, 450)
currentdp = gtk.Image()
buttonbox.pack_start(currentdp, False)
cancel_button = gtk.Button('Cancel', gtk.STOCK_CANCEL)
cancel_button.connect('clicked', lambda button: self.destroy())
ok_button = gtk.Button('Ok', gtk.STOCK_OK)
ok_button.connect('clicked', self._dp_chosen)
buttonbox.pack_start(ok_button, False)
buttonbox.pack_start(cancel_button, False)
for name, cb in actions:
button = gtk.Button(name)
def callback(cb):
return lambda button: cb()
button.connect('clicked', callback(cb))
buttonbox.pack_start(button, False)
hbox = gtk.HBox()
hbox.pack_start(dpsbox)
hbox.pack_start(buttonbox, False)
self.add(hbox)
def create_gui(self):
model = gtk.ListStore(str, gtk.gdk.Pixbuf)
self.locations = os.listdir(self.context)
for location in self.locations:
if location is None:
continue
pixbuf = self.load_icon(self.context + location)
model.append([location[:10], pixbuf])
self.icon_view = gtk.IconView(model)
self.icon_view.set_text_column(0)
self.icon_view.set_pixbuf_column(1)
self.icon_view.set_orientation(gtk.ORIENTATION_VERTICAL)
self.icon_view.set_selection_mode(gtk.SELECTION_SINGLE)
self.icon_view.connect('item-activated', self.item_activate, model)
self.icon_view.set_columns(4)
self.icon_view.set_item_width(-1)
self.icon_view.set_size_request(-1, -1)
self.content_box = gtk.HBox(False)
self.content_box.pack_start(self.icon_view, fill=True, expand=False)
self.vbox.pack_start(self.content_box)
self.show_all()
def __init__(self, label, path_list, on_remove_cb, on_accept_cb,
iconv_type, on_drag_data_accepted):
gtk.HBox.__init__(self)
self.set_spacing(4)
self.on_remove_cb = on_remove_cb
self.on_accept_cb = on_accept_cb
self.on_drag_data_accepted = on_drag_data_accepted
self.iconv_type = iconv_type
self.model = gtk.ListStore(gtk.gdk.Pixbuf, str)
self.iconview = gtk.IconView(self.model)
if not check_gtk3():
target = ('text/uri-list', 0, 0)
else:
#FIXME: this is not working in gtk3
target = gtk.TargetEntry.new('text/uri-list', 0, 0)
self.iconview.enable_model_drag_dest([target], gtk.gdk.ACTION_DEFAULT
| gtk.gdk.ACTION_COPY)
self.iconview.connect("drag-data-received", self._drag_data_received)
self.iconview.set_pixbuf_column(0)
self.iconview.connect("item-activated", self._on_icon_activated)
self.iconview.connect("button_press_event", self.pop_up)
self.label = gtk.Label(label)
self.scroll = gtk.ScrolledWindow()
self.scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self.scroll.set_shadow_type(gtk.SHADOW_IN)
self.scroll.add(self.iconview)
self.pack_start(self.scroll, True, True)
self.stop = False
# Start a new thread to fill the iconview with images from path_list
thread.start_new_thread(self.fill, (path_list, ))
def __init__(self, pen, guid, title, pages, builder):
self.guid = guid
self.title = title
self.pen = pen
self.pages = pages
self.is_rendered = False
self.status_bar = builder.get_object('statusbar1')
self.progress_bar = builder.get_object('progressbar1')
self.builder = builder
ls = gtk.ListStore(str, gtk.gdk.Pixbuf, str, str)
self.ls = ls
# XXX: cleanup temp dir
self.tmpdir = tempfile.mkdtemp()
self.work_queue = []
self.work_queue_lock = threading.Lock()
self.work_queue_sem = threading.Semaphore(0)
args = tuple()
self.thread = thread.start_new_thread(self.worker_thread, args)
iv = gtk.IconView(ls)
iv.connect('item-activated', self.page_activated)
iv.connect('button-press-event', self.page_popup)
iv.modify_base(gtk.STATE_NORMAL, gtk.gdk.Color("gray"))
iv.set_text_column(0)
iv.set_pixbuf_column(1)
iv.show()
sw = gtk.ScrolledWindow()
sw.props.hscrollbar_policy = "never"
sw.add(iv)
sw.show()
self.contents = sw
def __init__(self):
super(IconFileSelection, self).__init__()
# set some default values'
self.icon_size = 48
self.start_dir = os.path.expanduser('/')
self.cur_dir = self.start_dir
self.user_dir = os.path.expanduser('~')
self.jump_to_dir = os.path.expanduser('/tmp')
self.filetypes = ("ngc,py")
self.sortorder = _FOLDERFIRST
# This will hold the path we will return
self.path = ""
self.button_state = {}
self.old_button_state = {}
# Make the GUI and connect signals
vbox = gtk.VBox(False, 0)
self.buttonbox = gtk.HButtonBox()
self.buttonbox.set_layout(gtk.BUTTONBOX_EDGE)
self.buttonbox.set_property("homogeneous", True)
vbox.pack_end(self.buttonbox, False, False, 0)
self.btn_home = gtk.Button()
self.btn_home.set_size_request(56, 56)
image = gtk.Image()
image.set_from_stock(gtk.STOCK_HOME, gtk.ICON_SIZE_LARGE_TOOLBAR)
self.btn_home.set_image(image)
self.btn_home.set_tooltip_text(_("Move to your home directory"))
self.buttonbox.add(self.btn_home)
self.btn_dir_up = gtk.Button();
self.btn_dir_up.set_size_request(56, 56)
image = gtk.Image()
image.set_from_stock(gtk.STOCK_GOTO_TOP, gtk.ICON_SIZE_LARGE_TOOLBAR)
self.btn_dir_up.set_image(image)
self.btn_dir_up.set_tooltip_text(_("Move to parent directory"))
self.buttonbox.add(self.btn_dir_up)
self.btn_sel_prev = gtk.Button()
self.btn_sel_prev.set_size_request(56, 56)
image = gtk.Image()
image.set_from_stock(gtk.STOCK_GO_BACK, gtk.ICON_SIZE_LARGE_TOOLBAR)
self.btn_sel_prev.set_image(image)
self.btn_sel_prev.set_tooltip_text(_("Select the previous file"))
self.buttonbox.add(self.btn_sel_prev)
self.btn_sel_next = gtk.Button()
self.btn_sel_next.set_size_request(56, 56)
image = gtk.Image()
image.set_from_stock(gtk.STOCK_GO_FORWARD, gtk.ICON_SIZE_LARGE_TOOLBAR)
self.btn_sel_next.set_image(image)
self.btn_sel_next.set_tooltip_text(_("Select the next file"))
self.buttonbox.add(self.btn_sel_next)
# ToDo : Find out how to move one line down or up
# self.btn_go_down = gtk.Button()
# self.btn_go_down.set_size_request(56,56)
# image = gtk.Image()
# image.set_from_stock(gtk.STOCK_GO_DOWN,48)
# self.btn_go_down.set_image(image)
# self.buttonbox.add(self.btn_go_down)
#
# self.btn_go_up = gtk.Button()
# self.btn_go_up.set_size_request(56,56)
# image = gtk.Image()
# image.set_from_stock(gtk.STOCK_GO_UP,48)
# self.btn_go_up.set_image(image)
# self.buttonbox.add(self.btn_go_up)
# ToDo : End
self.btn_jump_to = gtk.Button()
self.btn_jump_to.set_size_request(56, 56)
image = gtk.Image()
image.set_from_stock(gtk.STOCK_JUMP_TO, gtk.ICON_SIZE_LARGE_TOOLBAR)
self.btn_jump_to.set_image(image)
self.btn_jump_to.set_tooltip_text(_("Jump to user defined directory"))
self.buttonbox.add(self.btn_jump_to)
self.btn_select = gtk.Button()
self.btn_select.set_size_request(56, 56)
image = gtk.Image()
image.set_from_stock(gtk.STOCK_OK, gtk.ICON_SIZE_LARGE_TOOLBAR)
self.btn_select.set_image(image)
self.btn_select.set_tooltip_text(_("select the highlighted file and return the path"))
self.buttonbox.add(self.btn_select)
self.btn_exit = gtk.Button()
self.btn_exit.set_size_request(56, 56)
image = gtk.Image()
image.set_from_stock(gtk.STOCK_STOP, gtk.ICON_SIZE_LARGE_TOOLBAR)
self.btn_exit.set_image(image)
self.btn_exit.set_tooltip_text(_("Close without returning a file path"))
self.buttonbox.add(self.btn_exit)
self.dirIcon = self._get_icon("folder")
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
vbox.pack_start(sw, True, True, 0)
self.file_label = gtk.Label("File Label")
vbox.pack_start(self.file_label, False, True, 0)
self.store = self._create_store()
self.iconView = gtk.IconView(self.store)
self.iconView.set_selection_mode(gtk.SELECTION_SINGLE)
self.iconView.set_text_column(COL_PATH)
self.iconView.set_pixbuf_column(COL_PIXBUF)
sw.add(self.iconView)
self.iconView.grab_focus()
self.model = self.iconView.get_model()
self.btn_dir_up.connect("clicked", self.on_btn_dir_up_clicked)
self.btn_home.connect("clicked", self.on_btn_home_clicked)
self.btn_sel_next.connect("clicked", self.on_btn_sel_next_clicked)
self.btn_sel_prev.connect("clicked", self.on_btn_sel_prev_clicked)
# self.btn_go_down.connect("clicked", self.on_btn_go_down_clicked)
# self.btn_go_up.connect("clicked", self.on_btn_go_up_clicked)
self.btn_jump_to.connect("clicked", self.on_btn_jump_to_clicked)
self.btn_select.connect("clicked", self.on_btn_select_clicked)
self.btn_exit.connect("clicked", self.on_btn_exit_clicked)
# will be emitted, when a icon has been activated, so we keep track of the path
self.iconView.connect("item-activated", self._on_item_activated)
# will be emitted, when a icon is activated and the ENTER key has been pressed
self.iconView.connect("activate-cursor-item", self._on_activate_cursor_item)
# will be emmited if the selection has changed, this happens also if the user clicks ones on an icon
self.iconView.connect("selection-changed", self._on_selection_changed)
# will be emitted, when the widget is destroyed
self.connect("destroy", gtk.main_quit)
self.add(vbox)
self.show_all()
# To use the the events, we have to unmask them
self.iconView.add_events(gtk.gdk.BUTTON_PRESS_MASK)
self.iconView.connect("button_press_event", self._button_press)
self._fill_store()
self._init_button_state()
class LebayApp(object):
def app_kill(self):
output = commands.getoutput("ps -A -o pid,cmd | grep "+APP)
out = output.split('\n')[0]
pid = out.split(' ')[1]
os.kill(int(pid.strip()),signal.SIGHUP)
def app_run(self):
os.system(APP+" 1>/dev/null &")
def app_status(self):
output = commands.getoutput("ps -A -o cmd | grep -x "+APP)
return output == APP
def auto_start(self, widget):
status = widget.get_active()
if status:
before = "X-GNOME-Autostart-enabled=false"
after = "X-GNOME-Autostart-enabled=true"
if not self.app_status():
self.app_run()
else:
before = "X-GNOME-Autostart-enabled=true"
after = "X-GNOME-Autostart-enabled=false"
if not self.exists(DAEMONFILE):
os.system("cp %s %s" % (DAEMONMASTER, DAEMONFILE))
fout = open(DAEMONFILE, "a")
fout.write(after)
fout.close()
if self.app_status():
self.app_kill()
if self.exists(DAEMONFILE):
file = open(DAEMONFILE, "r")
text = file.read()
file.close()
file = open(DAEMONFILE, "w")
file.write(text.replace(before,after))
file.close()
def auto_status(self):
if self.exists(DAEMONFILE):
lastLine = file(DAEMONFILE, "r").readlines()[-1]
textValue = lastLine.split("=")
if textValue[1].strip() == 'true':
if not self.app_status():
self.app_run()
return True
else:
if self.app_status():
self.app_kill()
return False
else:
if not self.app_status():
self.app_run()
return True
def browse_image(self, widget):
if gtk.pygtk_version < (2,3,90):
print "PyGtk 2.3.90 or later required for this example"
raise SystemExit
dialog = gtk.FileChooserDialog("Open..",
None,
gtk.FILE_CHOOSER_ACTION_OPEN,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_OPEN, gtk.RESPONSE_OK))
dialog.set_default_response(gtk.RESPONSE_OK)
filter = gtk.FileFilter()
filter.set_name("Images")
filter.add_mime_type("image/png")
filter.add_pattern("*.png")
dialog.add_filter(filter)
response = dialog.run()
if response == gtk.RESPONSE_OK:
self.teks.set_text(dialog.get_filename())
self.preview.set_from_pixbuf(self.thum_image(dialog.get_filename(),320))
parm = self.activeWall.split(".")
self.client.set_string("/apps/blankon-desktop/context/"+parm[0]+"/themes/"+self.theme+"/"+parm[1], dialog.get_filename())
dialog.destroy()
def change_pos(self, widget, data):
widget.set_sensitive(False)
self.activePos.set_sensitive(True)
self.activePos = widget
parm = data.split(".")
wall = self.client.get_string("/apps/blankon-desktop/context/"+parm[0]+"/themes/"+self.theme+"/"+parm[1])
self.preview.set_from_pixbuf(self.thum_image(wall,320))
self.teks.set_text(wall)
self.activeWall = data
def create_store(self):
store = gtk.ListStore(str, gtk.gdk.Pixbuf, bool)
store.set_sort_column_id(COL_PATH, gtk.SORT_ASCENDING)
return store
def change_theme(self, widget):
item = widget.get_cursor()
model = widget.get_model()
path = model[item[0]][COL_PATH]
self.theme = path
parm = self.activeWall.split(".")
wall = self.client.get_string("/apps/blankon-desktop/context/"+parm[0]+"/themes/"+self.theme+"/"+parm[1])
self.teks.set_text(wall)
self.preview.set_from_pixbuf(self.thum_image(wall,320))
self.client.set_string("/apps/blankon-desktop/context/time/theme", path)
#os.system("blankon-contextual-desktop-update")
def exists(self, filename):
try:
f = open(filename)
f.close()
return True
except:
return False
def fill_store(self):
self.store.clear()
if THEMEDIR is None:
return
for fl in os.listdir(THEMEDIR):
if not fl[0] == '.':
if os.path.isdir(os.path.join(THEMEDIR, fl)):
self.store.append([fl, self.thum_image(THEMEDIR+fl+"/time/dawn.png",180), True])
def default_key(self, widget):
parm = self.activeWall.split(".")
defaultWall = THEMEDIR+self.theme+"/"+parm[0]+"/"+parm[1]+".png"
self.client.set_string("/apps/blankon-desktop/context/"+parm[0]+"/themes/"+self.theme+"/"+parm[1], defaultWall)
self.preview.set_from_pixbuf(self.thum_image(defaultWall,320))
self.teks.set_text(defaultWall)
def thum_image(self, dir, width):
thum = gtk.gdk.pixbuf_new_from_file(dir)
if thum.get_width() < width:
return thum
else:
return gtk.gdk.pixbuf_new_from_file_at_size(dir,width,-1)
def __init__(self):
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.set_resizable(False)
window.set_size_request(480,500) #ukuran window
window.set_border_width(10) #padding
window.set_position(gtk.WIN_POS_CENTER) #posisi window
window.set_title("Lebay") #judul
window.connect("delete_event", gtk.main_quit)
try:
window.set_icon_from_file("lebay.png") #icon
except Exception, e:
print e.message
sys.exit(1)
self.client = gconf.client_get_default()
self.theme = self.client.get_string("/apps/blankon-desktop/context/time/theme")
themeFirst = self.client.get_string("/apps/blankon-desktop/context/time/themes/"+self.theme+"/dawn")
self.store = self.create_store()
self.fill_store()
mainTable = gtk.Table(3,2,False)
mainTable.set_row_spacings(5)
tab = gtk.Notebook()
tab.set_tab_pos(gtk.POS_TOP)
mainTable.attach(tab,0,2,0,1)
#halaman tema
themeView = gtk.IconView(self.store)
themeView.set_size_request(430,400)
themeView.set_selection_mode(gtk.SELECTION_MULTIPLE)
themeView.set_text_column(COL_PATH)
themeView.set_pixbuf_column(COL_PIXBUF)
themeView.connect("selection-changed", self.change_theme)
themeScroll = gtk.ScrolledWindow()
themeScroll.set_shadow_type(gtk.SHADOW_ETCHED_IN)
themeScroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
themeScroll.add(themeView)
themeTable = gtk.Table()
themeTable = gtk.Table(1,1,False)
themeTable.set_border_width(10)
themeTable.attach(themeScroll,0,1,0,1)
label = gtk.Label("Theme") #judul tab
tab.append_page(themeTable, label)
#halaman latar
wallTable = gtk.Table(16,3,False)
wallTable.set_border_width(10)
wallTable.set_col_spacings(10)
self.preview = gtk.Image()
self.preview.set_size_request(320,-1)
self.preview.set_from_pixbuf(self.thum_image(themeFirst,320))
wallTable.attach(self.preview,1,3,0,14)
self.teks = gtk.Entry()
self.teks.set_text(themeFirst)
wallTable.attach(self.teks,1,3,14,15)
defaultButton = gtk.Button("_Default")
defaultButton.connect("clicked", self.default_key)
wallTable.attach(defaultButton,1,2,15,16)
browseButton = gtk.Button("_Browse")
browseButton.connect("clicked", self.browse_image)
wallTable.attach(browseButton,2,3,15,16)
waktu = gtk.Label("Time")
wallTable.attach(waktu,0,1,0,1)
dawn = gtk.Button("Dawn")
dawn.set_sensitive(False)
dawn.connect("clicked", self.change_pos, "time.dawn")
wallTable.attach(dawn,0,1,1,2)
morning = gtk.Button("Morning")
morning.connect("clicked", self.change_pos, "time.morning")
wallTable.attach(morning,0,1,2,3)
noon = gtk.Button("Noon")
noon.connect("clicked", self.change_pos, "time.noon")
wallTable.attach(noon,0,1,3,4)
afternoon = gtk.Button("Afternoon")
afternoon.connect("clicked", self.change_pos, "time.afternoon")
wallTable.attach(afternoon,0,1,4,5)
evening = gtk.Button("Evening")
evening.connect("clicked", self.change_pos, "time.evening")
wallTable.attach(evening,0,1,5,6)
midnight = gtk.Button("Midnight")
midnight.connect("clicked", self.change_pos, "time.midnight")
wallTable.attach(midnight,0,1,6,7)
waktu = gtk.Label()
wallTable.attach(waktu,0,1,7,8)
waktu = gtk.Label("Weather")
wallTable.attach(waktu,0,1,8,9)
cloud = gtk.Button("Cloud")
cloud.connect("clicked", self.change_pos, "weather.cloud")
wallTable.attach(cloud,0,1,9,10)
fog = gtk.Button("Fog")
fog.connect("clicked", self.change_pos, "weather.fog")
wallTable.attach(fog,0,1,10,11)
rain = gtk.Button("Rain")
rain.connect("clicked", self.change_pos, "weather.rain")
wallTable.attach(rain,0,1,11,12)
snow = gtk.Button("Snow")
snow.connect("clicked", self.change_pos, "weather.snow")
wallTable.attach(snow,0,1,12,13)
strom = gtk.Button("Strom")
strom.connect("clicked", self.change_pos, "weather.storm")
wallTable.attach(strom,0,1,13,14)
sun = gtk.Button("Sun")
sun.connect("clicked", self.change_pos, "weather.sun")
wallTable.attach(sun,0,1,14,15)
suncloud = gtk.Button("Suncloud")
suncloud.connect("clicked", self.change_pos, "weather.suncloud")
wallTable.attach(suncloud,0,1,15,16)
label = gtk.Label("Wallpaper")
tab.insert_page(wallTable,label)
aktif = gtk.CheckButton("_Activate BlankOn Contextual Desktop")
aktif.set_active(self.auto_status())
aktif.connect("toggled", self.auto_start)
mainTable.attach(aktif,0,1,1,2)
halign = gtk.Alignment(1, 0, 0, 0)
tutup = gtk.Button(stock='gtk-close')
tutup.set_size_request(70, 30)
tutup.connect("clicked", gtk.main_quit)
halign.add(tutup)
mainTable.attach(halign,1,2,1,2)
window.add(mainTable)
window.show_all()
self.activePos = dawn
self.activeWall = "time.dawn"
def __init__(self, instance, uiman):
gtk.VBox.__init__(self)
Loggable.__init__(self)
self.app = instance
self.settings = instance.settings
# Store
# icon, infotext, objectfactory, uri, length
self.storemodel = gtk.ListStore(gtk.gdk.Pixbuf, gtk.gdk.Pixbuf, str,
object, str, str, str, str)
# Scrolled Windows
self.treeview_scrollwin = gtk.ScrolledWindow()
self.treeview_scrollwin.set_policy(gtk.POLICY_NEVER,
gtk.POLICY_AUTOMATIC)
self.treeview_scrollwin.set_shadow_type(gtk.SHADOW_ETCHED_IN)
self.iconview_scrollwin = gtk.ScrolledWindow()
self.iconview_scrollwin.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.iconview_scrollwin.set_shadow_type(gtk.SHADOW_ETCHED_IN)
# Popup Menu
self.popup = gtk.Menu()
self.popup_importitem = gtk.ImageMenuItem(_("Import clips..."))
image = gtk.Image()
image.set_from_stock(gtk.STOCK_ADD, gtk.ICON_SIZE_MENU)
self.popup_importitem.set_image(image)
self.popup_remitem = gtk.ImageMenuItem(_("Remove Clip"))
image = gtk.Image()
image.set_from_stock(gtk.STOCK_REMOVE, gtk.ICON_SIZE_MENU)
self.popup_remitem.set_image(image)
self.popup_playmenuitem = gtk.MenuItem(_("Play Clip"))
self.popup_importitem.connect("activate", self._importButtonClickedCb)
self.popup_remitem.connect("activate", self._removeButtonClickedCb)
self.popup_playmenuitem.connect("activate", self._playButtonClickedCb)
self.popup_importitem.show()
self.popup_remitem.show()
self.popup_playmenuitem.show()
self.popup.append(self.popup_importitem)
self.popup.append(self.popup_remitem)
self.popup.append(self.popup_playmenuitem)
# import sources dialogbox
self._importDialog = None
# TreeView
# Displays icon, name, type, length
self.treeview = gtk.TreeView(self.storemodel)
self.treeview_scrollwin.add(self.treeview)
self.treeview.connect("button-press-event",
self._treeViewButtonPressEventCb)
self.treeview.connect("row-activated", self._rowActivatedCb)
self.treeview.set_property("rules_hint", True)
self.treeview.set_headers_visible(False)
self.treeview.set_property("search_column", COL_SEARCH_TEXT)
tsel = self.treeview.get_selection()
tsel.set_mode(gtk.SELECTION_MULTIPLE)
tsel.connect("changed", self._viewSelectionChangedCb)
pixbufcol = gtk.TreeViewColumn(_("Icon"))
pixbufcol.set_expand(False)
pixbufcol.set_spacing(5)
self.treeview.append_column(pixbufcol)
pixcell = gtk.CellRendererPixbuf()
pixcell.props.xpad = 6
pixbufcol.pack_start(pixcell)
pixbufcol.add_attribute(pixcell, 'pixbuf', COL_ICON)
namecol = gtk.TreeViewColumn(_("Information"))
self.treeview.append_column(namecol)
namecol.set_expand(True)
namecol.set_spacing(5)
namecol.set_sizing(gtk.TREE_VIEW_COLUMN_GROW_ONLY)
namecol.set_min_width(150)
txtcell = gtk.CellRendererText()
txtcell.set_property("ellipsize", pango.ELLIPSIZE_END)
namecol.pack_start(txtcell)
namecol.add_attribute(txtcell, "markup", COL_INFOTEXT)
namecol = gtk.TreeViewColumn(_("Duration"))
namecol.set_expand(False)
self.treeview.append_column(namecol)
txtcell = gtk.CellRendererText()
txtcell.set_property("yalign", 0.0)
namecol.pack_start(txtcell)
namecol.add_attribute(txtcell, "markup", COL_LENGTH)
# IconView
self.iconview = gtk.IconView(self.storemodel)
self.iconview_scrollwin.add(self.iconview)
self.iconview.connect("button-press-event",
self._iconViewButtonPressEventCb)
self.iconview.connect("selection-changed",
self._viewSelectionChangedCb)
self.iconview.set_orientation(gtk.ORIENTATION_VERTICAL)
self.iconview.set_text_column(COL_SHORT_TEXT)
self.iconview.set_pixbuf_column(COL_ICON_LARGE)
self.iconview.set_selection_mode(gtk.SELECTION_MULTIPLE)
self.iconview.set_item_width(106)
# Explanatory message InfoBar
infobar = gtk.InfoBar()
txtlabel = gtk.Label()
txtlabel.set_padding(PADDING, PADDING)
txtlabel.set_line_wrap(True)
txtlabel.set_line_wrap_mode(pango.WRAP_WORD)
txtlabel.set_justify(gtk.JUSTIFY_CENTER)
txtlabel.set_markup(
_("<span>Import your clips by dragging them here or "
"by using the buttons above.</span>"))
infobar.add(txtlabel)
self.infobar = infobar
self.txtlabel = txtlabel
self.infostub = InfoStub()
self.infostub.connect("remove-me", self._removeInfoStub)
# Connect to project. We must remove and reset the callbacks when
# changing project.
self.project_signals = SignalGroup()
self.app.connect("new-project-created", self._newProjectCreatedCb)
self.app.connect("new-project-loaded", self._newProjectLoadedCb)
self.app.connect("new-project-failed", self._newProjectFailedCb)
# default pixbufs
self.audiofilepixbuf = self._getIcon("audio-x-generic",
"pitivi-sound.png")
self.videofilepixbuf = self._getIcon("video-x-generic",
"pitivi-video.png")
# Drag and Drop
self.drag_dest_set(gtk.DEST_DEFAULT_DROP | gtk.DEST_DEFAULT_MOTION,
[dnd.URI_TUPLE, dnd.FILE_TUPLE],
gtk.gdk.ACTION_COPY)
self.connect("drag_data_received", self._dndDataReceivedCb)
self.treeview.drag_source_set(0, [], gtk.gdk.ACTION_COPY)
self.treeview.connect("motion-notify-event",
self._treeViewMotionNotifyEventCb)
self.treeview.connect("button-release-event",
self._treeViewButtonReleaseCb)
self.treeview.connect("drag_begin", self._dndDragBeginCb)
self.treeview.connect("drag_data_get", self._dndDataGetCb)
self.iconview.drag_source_set(0, [], gtk.gdk.ACTION_COPY)
self.iconview.connect("motion-notify-event",
self._iconViewMotionNotifyEventCb)
self.iconview.connect("button-release-event",
self._iconViewButtonReleaseCb)
self.iconview.connect("drag_begin", self._dndDragBeginCb)
self.iconview.connect("drag_data_get", self._dndDataGetCb)
# Hack so that the views have the same method as self
self.treeview.getSelectedItems = self.getSelectedItems
# Error dialog box
self.errorDialogBox = None
# always available
actions = (
("ImportSources", gtk.STOCK_ADD, _("_Import clips..."), None,
_("Import clips to use"), self._importSourcesCb),
("ImportSourcesFolder", gtk.STOCK_ADD,
_("Import _folder of clips..."), None,
_("Import folder of clips to use"), self._importSourcesFolderCb),
)
# only available when selection is non-empty
selection_actions = (
("RemoveSources", gtk.STOCK_DELETE, _("_Remove from project"),
"<Control>Delete", None, self._removeSourcesCb),
("InsertEnd", gtk.STOCK_COPY, _("Insert at _end of timeline"),
"Insert", None, self._insertEndCb),
)
actiongroup = gtk.ActionGroup("sourcelistpermanent")
actiongroup.add_actions(actions)
actiongroup.get_action("ImportSources").props.is_important = True
uiman.insert_action_group(actiongroup, 0)
self.selection_actions = gtk.ActionGroup("sourcelistselection")
self.selection_actions.add_actions(selection_actions)
self.selection_actions.set_sensitive(False)
uiman.insert_action_group(self.selection_actions, 0)
uiman.add_ui_from_string(ui)
# clip view menu items
view_menu_item = uiman.get_widget('/MainMenuBar/View')
view_menu = view_menu_item.get_submenu()
seperator = gtk.SeparatorMenuItem()
self.treeview_menuitem = gtk.RadioMenuItem(None,
"Show Clips as a List")
self.iconview_menuitem = gtk.RadioMenuItem(self.treeview_menuitem,
"Show Clips as Icons")
# update menu items with current clip view before we connect to item
# signals
if self.settings.lastClipView == SHOW_TREEVIEW:
self.treeview_menuitem.set_active(True)
self.iconview_menuitem.set_active(False)
else:
self.treeview_menuitem.set_active(False)
self.iconview_menuitem.set_active(True)
# we only need to connect to one menu item because we get a signal
# from each radio item in the group
self.treeview_menuitem.connect("toggled",
self._treeViewMenuItemToggledCb)
view_menu.append(seperator)
view_menu.append(self.treeview_menuitem)
view_menu.append(self.iconview_menuitem)
self.treeview_menuitem.show()
self.iconview_menuitem.show()
seperator.show()
# add all child widgets
self.pack_start(self.infobar, expand=False, fill=False)
self.pack_start(self.iconview_scrollwin)
self.pack_start(self.treeview_scrollwin)
# display the help text
self.clip_view = self.settings.lastClipView
self._displayClipView()
class MovieGridView(View):
media = 'movies'
layout = 'grid'
view = gtk.IconView()
prefs = prefs_manager.PrefsManager()
def create_view(self):
self.view.set_selection_mode(gtk.SELECTION_MULTIPLE)
style = self.view.get_style().copy()
grey = gtk.gdk.Color('#4F4F4F')
style.base[gtk.STATE_NORMAL] = grey
self.view.set_style(style)
self.view.set_model(self.movie_list)
self.view.set_pixbuf_column(0)
self.view.set_text_column(1)
self.view.set_tooltip_column(2)
def load_library(self):
"""Loads the movie library into the current ListStore."""
lib_manager = library_manager.MovieGridManager()
library = lib_manager.load_library()
if self.movie_list.get_iter_root():
self.movie_list.clear()
for movie in library:
self.movie_list.append(movie)
self.movie_list.set_sort_column_id(1, gtk.SORT_ASCENDING)
def on_view_button_press(self, iconview, event):
"""IconView button press signal
Checks for right click and pops up a menu
"""
if event.button == 3:
path = iconview.get_path_at_pos(int(event.x), int(event.y))
if not path:
return False
if path not in iconview.get_selected_items():
iconview.unselect_all()
iconview.select_path(path[0])
if len(iconview.get_selected_items()) > 1:
self.multiple_select_context_menu.popup(
None, None, None, event.button, event.time)
else:
self.single_select_context_menu.popup(None, None, None,
event.button, event.time)
return True
def on_item_activated(self, iconview, path):
if len(iconview.get_selected_items()) > 1:
return False
#gobject.threads_init()
path_column = 1 + [prop['name']
for prop in movie_list_columns].index('path')
movie_path = self.movie_list[path][path_column]
process = Popen(['vlc', movie_path], stdout=PIPE, stderr=PIPE)
process_func = lambda: process.communicate()
play_thread = threading.Thread(target=process_func)
play_thread.start()
return True
def on_edit_item_click(self, menu_item, data=None):
"""Edit Item clicked signal.
Gets the currently selected item and then opens a
MovieTagger instance to edit the data.
"""
path_column = 1 + [prop['name']
for prop in movie_list_columns].index('path')
selected_items = self.view.get_selected_items()
if selected_items:
path = self.movie_list[selected_items[0]][path_column]
selected_movie = library_manager.MovieLibraryManager.get_item_from_library(
path)
movie_tagger.MovieTagger(selected_movie)
return True
else:
return False
def __init__(self):
super(MovieGridView, self).__init__()
self.view.connect('button-press-event', self.on_view_button_press)
self.view.connect('item-activated', self.on_item_activated)
self.single_edit_info_item.connect('activate', self.on_edit_item_click)
list_types = [param['type'] for param in movie_grid_columns]
self.movie_list = gtk.ListStore(gtk.gdk.Pixbuf, str, *list_types)
self.create_view()
self.load_library()
def __init__(self):
if os.name == "nt" :
self.winux = PdfShuffler_Windows_code()
else :
self.winux = PdfShuffler_Linux_code()
# Create the temporary directory
self.tmp_dir = tempfile.mkdtemp("pdfshuffler")
self.selection_start = 0
os.chmod(self.tmp_dir, 0700)
icon_theme = gtk.icon_theme_get_default()
try:
gtk.window_set_default_icon(icon_theme.load_icon("pdfshuffler", 64, 0))
except:
print(_("Can't load icon. Application is not installed correctly."))
# Import the user interface file, trying different possible locations
ui_path = '/usr/share/pdfbooklet/data/pdfshuffler_g.glade'
if not os.path.exists(ui_path):
ui_path = '/usr/local/share/pdfbooklet/data/pdfshuffler_g.glade'
if not os.path.exists(ui_path): # Windows standard path
ui_path = './data/pdfshuffler_g.glade'
if not os.path.exists(ui_path):
parent_dir = os.path.dirname( \
os.path.dirname(os.path.realpath(__file__)))
ui_path = os.path.join(parent_dir, 'data', 'pdfshuffler_g.glade')
if not os.path.exists(ui_path):
head, tail = os.path.split(parent_dir)
while tail != 'lib' and tail != '':
head, tail = os.path.split(head)
if tail == 'lib':
ui_path = os.path.join(head, 'share', 'pdfbooklet', \
'data/pdfshuffler_g.glade')
self.uiXML = gtk.Builder()
self.uiXML.add_from_file(ui_path)
self.uiXML.connect_signals(self)
# Create the main window, and attach delete_event signal to terminating
# the application
self.window = self.uiXML.get_object('main_window')
self.window.set_title(APPNAME)
self.window.set_border_width(0)
self.window.move(self.prefs['window x'], self.prefs['window y'])
self.window.set_default_size(self.prefs['window width'],
self.prefs['window height'])
self.window.connect('delete_event', self.close_application)
# Create a scrolled window to hold the thumbnails-container
self.sw = self.uiXML.get_object('scrolledwindow')
self.sw.drag_dest_set(gtk.DEST_DEFAULT_MOTION |
gtk.DEST_DEFAULT_HIGHLIGHT |
gtk.DEST_DEFAULT_DROP |
gtk.DEST_DEFAULT_MOTION,
self.TARGETS_SW,
gtk.gdk.ACTION_COPY |
gtk.gdk.ACTION_MOVE)
self.sw.connect('drag_data_received', self.sw_dnd_received_data)
self.sw.connect('button_press_event', self.sw_button_press_event)
self.sw.connect('scroll_event', self.sw_scroll_event)
# Create an alignment to keep the thumbnails center-aligned
align = gtk.Alignment(0.5, 0.5, 0, 0)
self.sw.add_with_viewport(align)
# Create ListStore model and IconView
self.model = gtk.ListStore(str, # 0.Text descriptor
gobject.TYPE_PYOBJECT,
# 1.Cached page image
int, # 2.Document number
int, # 3.Page number
float, # 4.Scale
str, # 5.Document filename
int, # 6.Rotation angle
float, # 7.Crop left
float, # 8.Crop right
float, # 9.Crop top
float, # 10.Crop bottom
int, # 11.Page width
int, # 12.Page height
float) # 13.Resampling factor
self.zoom_set(self.prefs['initial zoom level'])
self.iv_col_width = self.prefs['initial thumbnail size']
self.iconview = gtk.IconView(self.model)
self.iconview.set_item_width(self.iv_col_width + 12)
self.cellthmb = CellRendererImage()
self.iconview.pack_start(self.cellthmb, False)
self.iconview.set_attributes(self.cellthmb, image=1,
scale=4, rotation=6, cropL=7, cropR=8, cropT=9, cropB=10,
width=11, height=12, resample=13)
self.celltxt = gtk.CellRendererText()
self.celltxt.set_property('width', self.iv_col_width)
self.celltxt.set_property('wrap-width', self.iv_col_width)
self.celltxt.set_property('alignment', pango.ALIGN_CENTER)
self.iconview.pack_start(self.celltxt, False)
self.iconview.set_attributes(self.celltxt, text=0)
self.iconview.set_selection_mode(gtk.SELECTION_MULTIPLE)
self.iconview.enable_model_drag_source(gtk.gdk.BUTTON1_MASK,
self.TARGETS_IV,
gtk.gdk.ACTION_COPY |
gtk.gdk.ACTION_MOVE)
self.iconview.enable_model_drag_dest(self.TARGETS_IV,
gtk.gdk.ACTION_DEFAULT)
self.iconview.connect('drag_begin', self.iv_drag_begin)
self.iconview.connect('drag_data_get', self.iv_dnd_get_data)
self.iconview.connect('drag_data_received', self.iv_dnd_received_data)
self.iconview.connect('drag_data_delete', self.iv_dnd_data_delete)
self.iconview.connect('drag_motion', self.iv_dnd_motion)
self.iconview.connect('drag_leave', self.iv_dnd_leave_end)
self.iconview.connect('drag_end', self.iv_dnd_leave_end)
self.iconview.connect('button_press_event', self.iv_button_press_event)
align.add(self.iconview)
# Progress bar
self.progress_bar = self.uiXML.get_object('progressbar')
self.progress_bar_timeout_id = 0
# Define window callback function and show window
self.window.connect('size_allocate', self.on_window_size_request) # resize
self.window.connect('key_press_event', self.on_keypress_event ) # keypress
self.window.show_all()
self.progress_bar.hide_all()
# Change iconview color background
style = self.sw.get_style().copy()
for state in (gtk.STATE_NORMAL, gtk.STATE_PRELIGHT, gtk.STATE_ACTIVE):
style.base[state] = style.bg[gtk.STATE_NORMAL]
self.iconview.set_style(style)
# Creating the popup menu
## self.popup = gtk.Menu()
## popup_rotate_right = gtk.ImageMenuItem(_('_Rotate Right'))
## popup_rotate_left = gtk.ImageMenuItem(_('Rotate _Left'))
## popup_crop = gtk.MenuItem(_('C_rop...'))
## popup_delete = gtk.ImageMenuItem(gtk.STOCK_DELETE)
## popup_rotate_right.connect('activate', self.rotate_page_right)
## popup_rotate_left.connect('activate', self.rotate_page_left)
## popup_crop.connect('activate', self.crop_page_dialog)
## popup_delete.connect('activate', self.clear_selected)
## popup_rotate_right.show()
## popup_rotate_left.show()
## popup_crop.show()
## popup_delete.show()
## self.popup.append(popup_rotate_right)
## self.popup.append(popup_rotate_left)
## self.popup.append(popup_crop)
## self.popup.append(popup_delete)
self.popup = self.uiXML.get_object('contextmenu1')
# Initializing variables
self.export_directory = self.winux.home_dir()
self.import_directory = self.export_directory
self.nfile = 0
self.iv_auto_scroll_direction = 0
self.iv_auto_scroll_timer = None
self.pdfqueue = []
gobject.type_register(PDF_Renderer)
gobject.signal_new('update_thumbnail', PDF_Renderer,
gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
[gobject.TYPE_INT, gobject.TYPE_PYOBJECT,
gobject.TYPE_FLOAT])
self.rendering_thread = 0
self.set_unsaved(False)
# Importing documents passed as command line arguments
for filename in sys.argv[1:]:
self.add_pdf_pages(filename)
class LaTeXSymbolMapView(SideView):
"""
"""
__log = getLogger("LaTeXSymbolMapView")
label = "Symbols"
icon = gtk.STOCK_INDEX
scope = View.SCOPE_WINDOW
def init(self, context):
self.__log.debug("init")
self.__context = context
self.__preferences = Preferences()
scrolled = gtk.ScrolledWindow()
scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled.set_shadow_type(gtk.SHADOW_NONE)
self.__box = gtk.VBox()
scrolled.add_with_viewport(self.__box)
self.add(scrolled)
self.show_all()
self.__load_collection(SymbolCollection())
def __load_collection(self, collection):
self.__expanded_groups = set(self.__preferences.get("ExpandedSymbolGroups", "").split(","))
for group in collection.groups:
self.__add_group(group)
def __add_group(self, group):
model = gtk.ListStore(gtk.gdk.Pixbuf, str, object) # icon, tooltip, Template
for symbol in group.symbols:
try:
model.append([gtk.gdk.pixbuf_new_from_file(symbol.icon), str(symbol.template), symbol.template])
except GError, s:
print s
view = gtk.IconView(model)
view.set_pixbuf_column(0)
view.set_selection_mode(gtk.SELECTION_SINGLE)
view.connect("selection-changed", self.__on_symbol_selected)
view.set_item_width(-1)
view.set_spacing(0)
view.set_column_spacing(0)
view.set_row_spacing(0)
view.set_columns(-1)
view.set_text_column(-1)
view.set_tooltip_column(1) # this requires PyGTK 2.12
view.show()
expander = gtk.Expander(group.label)
expander.add(view)
expander.show_all()
if group.label in self.__expanded_groups:
expander.set_expanded(True)
expander.connect("notify::expanded", self.__on_group_expanded, group.label)
self.__box.pack_start(expander, False)
