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)