Beispiel #1
0
class TitleBox(VolumesToolbar):
    __gtype_name__ = 'TitleBox'

    def __init__(self):
        VolumesToolbar.__init__(self)

        label = gtk.Label()
        label.set_markup('<b>%s</b>' % _('Choose an object'))
        label.set_alignment(0, 0.5)
        self._add_widget(label, expand=True)

        self.close_button = ToolButton(icon_name='dialog-cancel')
        self.close_button.set_tooltip(_('Close'))
        self.insert(self.close_button, -1)
        self.close_button.show()

    def _add_widget(self, widget, expand=False):
        tool_item = gtk.ToolItem()
        tool_item.set_expand(expand)

        tool_item.add(widget)
        widget.show()

        self.insert(tool_item, -1)
        tool_item.show()
    def instrument_selected_cb(self, button, instrument):
        ''' Callback for instrument control '''
        logging.debug(instrument)
        if self._tuning_tool is not None:
            self.remove(self._tuning_tool)

        if instrument == _('None'):
            self.activity.wave.instrument = None

            # Remove any previous tuning button
            if hasattr(self, '_tuning_button'):
                self._tuning_button.destroy()

            # Restore the notes, octaves buttons
            if hasattr(self, '_notes_button'):
                self.insert(self._notes_button, 2)
                self.insert(self._octaves_button, 3)
            return

        self.remove(self._notes_button)
        self.remove(self._octaves_button)

        self.activity.wave.instrument = instrument

        # If we are not already in freq. base, switch.
        if not self.activity.wave.get_fft_mode():
            self.activity.timefreq_control()

        # Add a Tuning palette for this instrument
        self._tuning_button = ToolButton('notes')
        self._tuning_button.set_tooltip(instrument)
        self._tuning_button.connect('clicked', self._button_selection_cb)
        self.insert(self._tuning_button, 1)
        self._setup_tuning_palette(instrument)
Beispiel #3
0
    def __init__(self, handle):
        gtk.Toolbar.__init__(self)
        self.handle = handle
        
        #Tytuł pola tekstowego
        self.add_widget(gtk.Label("Id testu: "))

        #Pole tekstowe
        self.test_entry = gtk.Entry()
        self.test_entry.set_size_request(200,25)
        self.test_entry.set_text('709rqd')
        self.add_widget(self.test_entry)

        #Separator
        separator = gtk.SeparatorToolItem()
        separator.set_draw(True)
        separator.set_size_request(50,25)
        self.add_widget(separator)
        
        #Tytuł pola tekstowego
        self.add_widget(gtk.Label("Hasło: "))
        
        #Pole tekstowe
        self.pass_entry = gtk.Entry()
        self.pass_entry.set_size_request(300,25)
#        self.pass_entry.set_text('123123')
        self.add_widget(self.pass_entry)
        
        #Przycisk pobierania
        download_button = ToolButton("download")
        download_button.set_tooltip("Pobierz test")
        download_button.connect("clicked", handle.get_test_bt)
        self.add_widget(download_button)
    def __init__(self, pc):
        gtk.Toolbar.__init__(self)
        self.activity = pc

        # C slider
        self.activity.c_slider = ToolButton("Con")
        self.activity.c_slider.set_tooltip(_('C'))
        self.activity.c_slider.props.sensitive = True
        self.activity.c_slider.connect('clicked', self.activity._c_slider_cb)
        self.insert(self.activity.c_slider, -1)
        self.activity.c_slider.show()

        # A slider
        self.activity.a_slider = ToolButton("Aoff")
        self.activity.a_slider.set_tooltip(_('A'))
        self.activity.a_slider.props.sensitive = True
        self.activity.a_slider.connect('clicked', self.activity._a_slider_cb)
        self.insert(self.activity.a_slider, -1)
        self.activity.a_slider.show()

        # Label for showing status
        self.activity.results_label = gtk.Label("1.0 × 1.0 = 1.0")
        self.activity.results_label.show()
        self.activity.results_toolitem = gtk.ToolItem()
        self.activity.results_toolitem.add(self.activity.results_label)
        self.insert(self.activity.results_toolitem, -1)
        self.activity.results_toolitem.show()
Beispiel #5
0
    def _add_speed_slider(self, toolbar):
        self._speed_stepper_down = ToolButton("speed-down")
        self._speed_stepper_down.set_tooltip(_("Slow down"))
        self._speed_stepper_down.connect("clicked", self._speed_stepper_down_cb)
        self._speed_stepper_down.show()

        self._adjustment = gtk.Adjustment(200, self.LOWER, self.UPPER, 25, 100, 0)
        self._adjustment.connect("value_changed", self._speed_change_cb)
        self._speed_range = gtk.HScale(self._adjustment)
        self._speed_range.set_inverted(True)
        self._speed_range.set_draw_value(False)
        self._speed_range.set_update_policy(gtk.UPDATE_CONTINUOUS)
        self._speed_range.set_size_request(120, 15)
        self._speed_range.show()

        self._speed_stepper_up = ToolButton("speed-up")
        self._speed_stepper_up.set_tooltip(_("Speed up"))
        self._speed_stepper_up.connect("clicked", self._speed_stepper_up_cb)
        self._speed_stepper_up.show()

        self._speed_range_tool = gtk.ToolItem()
        self._speed_range_tool.add(self._speed_range)
        self._speed_range_tool.show()

        toolbar.insert(self._speed_stepper_down, -1)
        toolbar.insert(self._speed_range_tool, -1)
        toolbar.insert(self._speed_stepper_up, -1)
        return
Beispiel #6
0
    def add_frequency_slider(self, toolbar):
        ''' Either on the Sound toolbar or the Main toolbar '''
        self._freq_stepper_up = ToolButton('freq-high')
        self._freq_stepper_up.set_tooltip(_('Zoom out'))
        self._freq_stepper_up.connect('clicked', self._freq_stepper_up_cb)
        self.activity.adjustmentf = gtk.Adjustment(0.5, self.LOWER, self.UPPER,
                                                   0.01, 0.1, 0)
        self.activity.adjustmentf.connect('value_changed', self.cb_page_sizef)
        self._freq_range = gtk.HScale(self.activity.adjustmentf)
        self._freq_range.set_inverted(True)
        self._freq_range.set_draw_value(False)
        self._freq_range.set_update_policy(gtk.UPDATE_CONTINUOUS)
        self._freq_range.set_size_request(120, 15)

        self._freq_stepper_down = ToolButton('freq-low')
        self._freq_stepper_down.set_tooltip(_('Zoom in'))
        self._freq_stepper_down.connect('clicked', self._freq_stepper_down_cb)

        self._freq_range_tool = gtk.ToolItem()
        self._freq_range_tool.add(self._freq_range)

        toolbar.insert(self._freq_stepper_up, -1)
        toolbar.insert(self._freq_range_tool, -1)
        toolbar.insert(self._freq_stepper_down, -1)
        return
Beispiel #7
0
class ReadToolbar(gtk.Toolbar):
    '''
    TODO:
    * the toolbutton's sensitivity depends on context
    '''

    canvas = ReadCanvas

    def __init__(self, activity):        
        gtk.Toolbar.__init__(self)
        self._activity = activity

        self._sendreceive_button = ToolButton('send-and-receive', tooltip=_('Send/receive email'))
        self._sendreceive_button.connect('clicked', self._sendreceive_cb)
        self.insert(self._sendreceive_button, -1)
        self.show_all()
        '''
        self._reply_button = ToolButton('reply', tooltip=_('Write a reply'))
        self._reply_button.connect('clicked', self._reply_msg_cb)
        self.insert(self._reply_button, -1)

        self._forward_button = ToolButton('forward', tooltip=_('Forward this message'))
        self._forward_button.connect('clicked', self._forward_msg_cb)
        self.insert(self._forward_button, -1)
        '''
    def _sendreceive_cb(self, *args):
        sweetmail.mailactivity.run_bgsrt_once(self._activity)
    def _reply_msg_cb(self, *args):
        pass
    
    def _forward_msg_cb(self, *args):
        pass
class TitleBox(VolumesToolbar):
    __gtype_name__ = 'TitleBox'

    def __init__(self):
        VolumesToolbar.__init__(self)

        label = gtk.Label()
        label.set_markup('<b>%s</b>' % _('Choose an object'))
        label.set_alignment(0, 0.5)
        self._add_widget(label, expand=True)

        self.close_button = ToolButton(icon_name='dialog-cancel')
        self.close_button.set_tooltip(_('Close'))
        self.insert(self.close_button, -1)
        self.close_button.show()

    def _add_widget(self, widget, expand=False):
        tool_item = gtk.ToolItem()
        tool_item.set_expand(expand)

        tool_item.add(widget)
        widget.show()

        self.insert(tool_item, -1)
        tool_item.show()
Beispiel #9
0
 def __init__(self, act):
     gtk.Toolbar.__init__(self)
     
     self._activity = act
     
     self._back = ToolButton('go-previous-paired')
     self._back.set_tooltip(_('Back'))
     self._back.props.sensitive = False
     self._back.connect('clicked', self.__go_back_cb)
     self.insert(self._back, -1)
     self._back.show()
     
     self._entry = gtk.Entry()
     self._entry.set_text(self._activity.DEFAULT_FEED_URI)
     self._entry.connect('activate', self.__entry_activate_cb)
     
     entry_item = gtk.ToolItem()
     entry_item.set_expand(True)
     entry_item.add(self._entry)
     self.insert(entry_item, -1)
     self._entry.show()
     
     self._refresh = ToolButton('view-refresh')
     self._refresh.set_tooltip(_('Refresh'))
     self._refresh.connect('clicked', self.__refresh_cb)
     self.insert(self._refresh, -1)
     self._refresh.show()
     
     self._send = ToolButton('activity-journal')
     self._send.set_tooltip(_('Send'))
     self._send.connect('clicked', self.__send_cb)
     self.insert(self._send, -1)
     self._send.show()
    def __init__(self, handle):
        super(Agenda, self).__init__(handle, True)
        tool = ToolbarBox()
        toolbar = tool.toolbar
        activitybtn = ActivityToolbarButton(self)
        self.separator = gtk.SeparatorToolItem()
        self.separator.props.draw = False
        self.separator.set_expand(True)
        stpbtn = StopButton(self)
        self.addbtn = ToolButton('add')
        self.addbtn.connect('clicked', self._show_palette_add_button)
        toolbar.insert(activitybtn, 0)
        toolbar.insert(gtk.SeparatorToolItem(), -1)
        toolbar.insert(self.addbtn, -1)
        toolbar.insert(self.separator, -1)
        toolbar.insert(stpbtn, -1)

        self.canvas = canvas()
        self.toolarea = AddTelephoneArea(self.addbtn, self.canvas)

        self.set_toolbar_box(tool)
        self.set_canvas(self.canvas)
        self.addbtn.set_tooltip(_('Add a new contact'))
        self._create_palette_add_button(self.addbtn)
        self.show_all()
Beispiel #11
0
    def __init__(self):
        gtk.Toolbar.__init__(self)
        self._zoom_out = ToolButton('zoom-out')
        self._zoom_out.set_tooltip(_('Zoom out'))
        self._zoom_out.connect('clicked', self._zoom_out_cb)
        self.insert(self._zoom_out, -1)
        self._zoom_out.props.sensitive = False
        self._zoom_out.show()

        self._zoom_in = ToolButton('zoom-in')
        self._zoom_in.set_tooltip(_('Zoom in'))
        self._zoom_in.connect('clicked', self._zoom_in_cb)
        self.insert(self._zoom_in, -1)
        self._zoom_in.props.sensitive = True
        self._zoom_in.show()

        spacer = gtk.SeparatorToolItem()
        spacer.props.draw = False
        self.insert(spacer, -1)
        spacer.show()

        self._fullscreen = ToolButton('view-fullscreen')
        self._fullscreen.set_tooltip(_('Fullscreen'))
        self._fullscreen.connect('clicked', self._fullscreen_cb)
        self.insert(self._fullscreen, -1)
        self._fullscreen.show()
Beispiel #12
0
class ActivityToolbarXO2XO(gtk.Toolbar):
    def __init__(self, activity, orientation_left=False):
        gtk.Toolbar.__init__(self)

        self._activity = activity
        if orientation_left == False:
            separator = gtk.SeparatorToolItem()
            separator.props.draw = False
            separator.set_expand(True)
            self.insert(separator,-1)
            separator.show()

        self._object_insert = ToolButton('object-insert')
        self.insert(self._object_insert, -1)
        self._object_insert.show()
        self.stop = StopButton(activity)
        self.insert(self.stop, -1)
        self.stop.show()
        self._object_insert.connect('clicked', self.insertImage, activity)

    def insertImage(self, widget, activity):
        self._activity = activity
        chooser = ObjectChooser('Choose image', self._activity,
                                gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT)
        try:
            result = chooser.run()
            if result == gtk.RESPONSE_ACCEPT:
                jobject = chooser.get_selected_object()
                if jobject and jobject.file_path:
                    self._activity.toUploadChosen(jobject.file_path)

        finally:
            chooser.destroy()
            del chooser
    def __init__(self, calc):
        gtk.Toolbar.__init__(self)

        copy_tool = ToolButton('edit-copy')
        copy_tool.set_tooltip(_('Copy'))
        copy_tool.set_accelerator(_('<ctrl>c'))
        copy_tool.connect('clicked', lambda x: calc.text_copy())
        self.insert(copy_tool, -1)

        menu_item = MenuItem(_('Cut'))

        try:
            menu_item.set_accelerator(_('<ctrl>x'))
        except AttributeError:
            pass

        menu_item.connect('activate', lambda x: calc.text_cut())
        menu_item.show()
        copy_tool.get_palette().menu.append(menu_item)

        self.insert(IconToolButton('edit-paste', _('Paste'),
            lambda x: calc.text_paste(),
            alt_html='Paste'), -1)
                        
        self.show_all()
    def __init__(self, pc):
        gtk.Toolbar.__init__(self)
        self.activity = pc

        # Play button
        self.activity.play = ToolButton("media-playback-start")
        self.activity.play.set_tooltip(_('Play'))
        self.activity.play.props.sensitive = True
        self.activity.play.connect('clicked', self.activity._play_cb)
        self.insert(self.activity.play, -1)
        self.activity.play.show()

        # Sound toggle button
        self.activity.sound = ToolButton("speaker-muted-100")
        self.activity.sound.set_tooltip(_('Mute'))
        self.activity.sound.props.sensitive = True
        self.activity.sound.connect('clicked', self.activity._sound_cb)
        self.insert(self.activity.sound, -1)
        self.activity.sound.show()

        separator = gtk.SeparatorToolItem()
        separator.set_draw(True)
        self.insert(separator, -1)
        separator.show()

        # Label for showing play status
        self.activity.level_label = gtk.Label("%s %d" % (_("Level"), 1))
        self.activity.level_label.show()
        self.activity.level_toolitem = gtk.ToolItem()
        self.activity.level_toolitem.add(self.activity.level_label)
        self.insert(self.activity.level_toolitem, -1)
        self.activity.level_toolitem.show()
Beispiel #15
0
    def __init__(self, web_view):
        gobject.GObject.__init__(self)

        self._web_view = web_view

        self._back = ToolButton("go-previous-paired")
        self._back.set_tooltip(_("Back"))
        self._back.props.sensitive = False
        self._back.connect("clicked", self._go_back_cb)
        self.insert(self._back, -1)
        self._back.show()

        self._forward = ToolButton("go-next-paired")
        self._forward.set_tooltip(_("Forward"))
        self._forward.props.sensitive = False
        self._forward.connect("clicked", self._go_forward_cb)
        self.insert(self._forward, -1)
        self._forward.show()

        self._home = ToolButton("go-home")
        self._home.set_tooltip(_("Home"))
        self._home.connect("clicked", self._go_home_cb)
        self.insert(self._home, -1)
        self._home.show()

        progress_listener = self._web_view.progress
        progress_listener.connect("location-changed", self._location_changed_cb)
        progress_listener.connect("loading-stop", self._loading_stop_cb)
	def __init__(self, handle):
		activity.Activity.__init__(self, handle)
		self.toolbox = activity.ActivityToolbox(self)
		activity_toolbar = self.toolbox.get_activity_toolbar()
		activity_toolbar.share.props.visible = False
		activity_toolbar.keep.props.visible = False
		go_up = ToolButton("gtk-go-up")
		go_up.props.tooltip = _("Go Up")
		go_up.show()
		activity_toolbar.insert(go_up, 2)
		refresh = ToolButton("gtk-refresh")
		refresh.props.tooltip = _("Refresh")
		refresh.show()
		activity_toolbar.insert(refresh, 2)
		self.set_toolbox(self.toolbox)
		self.toolbox.show()
		widget = filemanager.Widget()
		go_up.connect("clicked", self.go_up_callback, widget)
		refresh.connect("clicked", self.refresh_callback, widget)
		widget.show()
		current_directory = gio.File(path=os.environ["HOME"])
		widget.set_current_directory(current_directory.get_uri())
		widget.connect("file-menu", self.file_menu)
		widget.connect('current-directory-menu', self.current_directory_menu)
		self.set_canvas(widget)
		self.show()
Beispiel #17
0
    def _add_level_slider(self, toolbar):
        self._level_stepper_down = ToolButton('easy')
        self._level_stepper_down.set_tooltip(_('Easier'))
        self._level_stepper_down.connect('clicked',
                                         self._level_stepper_down_cb)
        self._level_stepper_down.show()

        self._adjustment = gtk.Adjustment(
            1, self.LOWER, self.UPPER, 1, 5, 0)
        self._adjustment.connect('value_changed', self._level_change_cb)
        self._level_range = gtk.HScale(self._adjustment)
        self._level_range.set_draw_value(False)
        self._level_range.set_update_policy(gtk.UPDATE_CONTINUOUS)
        self._level_range.set_size_request(120, 15)
        self._level_range.show()

        self._level_stepper_up = ToolButton('hard')
        self._level_stepper_up.set_tooltip(_('Harder'))
        self._level_stepper_up.connect('clicked', self._level_stepper_up_cb)
        self._level_stepper_up.show()

        self._level_range_tool = gtk.ToolItem()
        self._level_range_tool.add(self._level_range)
        self._level_range_tool.show()

        toolbar.insert(self._level_stepper_down, -1)
        toolbar.insert(self._level_range_tool, -1)
        toolbar.insert(self._level_stepper_up, -1)
        return
 def destroy(self):
     del self._toolbar.bookmarklets[self._name]        
     
     if len(self._toolbar.bookmarklets) == 0:
         self._toolbar.destroy()
         
     ToolButton.destroy(self)
 def __init__(self, activity):
     gtk.Toolbar.__init__(self)
     self.activity = activity
     self._lock = True
     
     # New Button
     new_icon = join(dirname(__file__), 'images', 'game-new.svg')
     new_image = gtk.Image()
     new_image.set_from_file(new_icon)
     self._new_button = ToolButton()
     self._new_button.set_icon_widget(new_image)
     self._new_button.set_tooltip(_('New game'))
     self._new_button.connect('clicked', self._new_game_bt)
     self._add_widget(self._new_button)
     
     # Load Button
     load_icon = join(dirname(__file__), 'images', 'game-load.svg')
     load_image = gtk.Image()
     load_image.set_from_file(load_icon)
     self._load_button = ToolButton()
     self._load_button.set_icon_widget(load_image)
     self._load_button.set_tooltip(_('Load game'))
     self._load_button.connect('clicked', self._load_game)
     self._add_widget(self._load_button)
         
     # Save Button
     save_icon = join(dirname(__file__), 'images', 'game-save.svg')
     save_image = gtk.Image()
     save_image.set_from_file(save_icon)
     self._save_button = ToolButton()
     self._save_button.set_icon_widget(save_image)
     self._save_button.set_tooltip(_('Save game'))
     self._save_button.connect('clicked', self._save_game_bt)
     self._save_button.set_sensitive(False)
     self._add_widget(self._save_button)
 
     # Separator
     separator2 = gtk.SeparatorToolItem()
     separator2.set_draw(True)
     self.insert(separator2, -1)
     
     self._add_widget(gtk.Label(_('Game name') + ': '))
     self.game_name_entry = gtk.Entry()
     self._add_widget(self.game_name_entry) 
     
     self._equal_pairs = gtk.CheckButton(_('Equal pairs'))   
     self._add_widget(self._equal_pairs)
     self._equal_pairs.connect('toggled', self._emit_equal_pairs)
             
     self._grouped_icon1 = join(dirname(__file__), 'images', 'equal_pairs1.svg')
     self._grouped_icon2 = join(dirname(__file__), 'images', 'equal_pairs2.svg')
     self._grouped_image1 = gtk.Image()
     self._grouped_image2 = gtk.Image()
     self._grouped_image1.set_from_file(self._grouped_icon1)
     self._grouped_image2.set_from_file(self._grouped_icon2)
     self._grouped = ToggleToolButton()
     self._grouped.set_icon_widget(self._grouped_image1)
     self._grouped.set_tooltip(_('Click for grouped game'))
     self._grouped.connect('toggled', self._grouped_cb)
     self._add_widget(self._grouped)
Beispiel #20
0
    def __init__(self, activity):
        gtk.Toolbar.__init__(self)

        self._activity = activity

        self._browser = self._activity._web_view

        self.zoomout = ToolButton('zoom-out')
        self.zoomout.set_tooltip(_('Zoom out'))
        self.zoomout.connect('clicked', self.__zoomout_clicked_cb)
        self.insert(self.zoomout, -1)
        self.zoomout.show()

        self.zoomin = ToolButton('zoom-in')
        self.zoomin.set_tooltip(_('Zoom in'))
        self.zoomin.connect('clicked', self.__zoomin_clicked_cb)
        self.insert(self.zoomin, -1)
        self.zoomin.show()

        self.separator = gtk.SeparatorToolItem()
        self.separator.set_draw(True)
        self.insert(self.separator, -1)
        self.separator.show()

        self.fullscreen = ToolButton('view-fullscreen')
        self.fullscreen.set_tooltip(_('Fullscreen'))
        self.fullscreen.connect('clicked', self.__fullscreen_clicked_cb)
        self.insert(self.fullscreen, -1)
        self.fullscreen.show()
Beispiel #21
0
    def add_frequency_slider(self, toolbox):
        """ Either on the Sound toolbar or the Main toolbar """
        self._freq_stepper_up = ToolButton("freq-high")
        self._freq_stepper_up.set_tooltip(_("Zoom out"))
        self._freq_stepper_up.connect("clicked", self._freq_stepper_up_cb)
        self._freq_stepper_up.show()

        self.activity.adjustmentf = gtk.Adjustment(0.5, self.LOWER, self.UPPER, 0.01, 0.1, 0)
        self.activity.adjustmentf.connect("value_changed", self.cb_page_sizef)

        self._freq_range = gtk.HScale(self.activity.adjustmentf)
        self._freq_range.set_inverted(True)
        self._freq_range.set_draw_value(False)
        self._freq_range.set_update_policy(gtk.UPDATE_CONTINUOUS)
        self._freq_range.set_size_request(120, 15)
        self._freq_range.show()

        self._freq_stepper_down = ToolButton("freq-low")
        self._freq_stepper_down.set_tooltip(_("Zoom in"))
        self._freq_stepper_down.connect("clicked", self._freq_stepper_down_cb)
        self._freq_stepper_down.show()

        self._freq_range_tool = gtk.ToolItem()
        self._freq_range_tool.add(self._freq_range)
        self._freq_range_tool.show()

        toolbox.add(self._freq_stepper_up)
        toolbox.add(self._freq_range_tool)
        toolbox.add(self._freq_stepper_down)
        return
    def __init__(self):
        gtk.Toolbar.__init__(self)
        self.back = ToolButton('go-previous')
        self.back.set_tooltip(_('Back'))
        self.back.props.sensitive = False
        palette = self.back.get_palette()
        self.prev_page = MenuItem(text_label=_("Previous page"))
        palette.menu.append(self.prev_page)
        self.prev_page.show_all()
        self.back.connect('clicked', self.go_back_cb)
        self.prev_page.connect('activate', self.go_back_cb)
        self.insert(self.back, -1)
        self.back.show()

        self.forward = ToolButton('go-next')
        self.forward.set_tooltip(_('Forward'))
        self.forward.props.sensitive = False
        palette = self.forward.get_palette()
        self.next_page = MenuItem(text_label=_("Next page"))
        palette.menu.append(self.next_page)
        self.next_page.show_all()
        self.forward.connect('clicked', self.go_forward_cb)
        self.next_page.connect('activate', self.go_forward_cb)
        self.insert(self.forward, -1)
        self.forward.show()

        num_page_item = gtk.ToolItem()

        self._num_page_entry = gtk.Entry()
        self._num_page_entry.set_text('0')
        self._num_page_entry.set_alignment(1)
        self._num_page_entry.connect('insert-text',
                                     self._num_page_entry_insert_text_cb)
        self._num_page_entry.connect('activate',
                                     self._num_page_entry_activate_cb)

        self._num_page_entry.set_width_chars(4)

        num_page_item.add(self._num_page_entry)
        self._num_page_entry.show()

        self.insert(num_page_item, -1)
        num_page_item.show()

        total_page_item = gtk.ToolItem()

        self._total_page_label = gtk.Label()

        label_attributes = pango.AttrList()
        label_attributes.insert(pango.AttrSize(14000, 0, -1))
        label_attributes.insert(
            pango.AttrForeground(65535, 65535, 65535, 0, -1))
        self._total_page_label.set_attributes(label_attributes)

        self._total_page_label.set_text(' / 0')
        total_page_item.add(self._total_page_label)
        self._total_page_label.show()

        self.insert(total_page_item, -1)
        total_page_item.show()
Beispiel #23
0
    def __init__(self):
        activity.EditToolbar.__init__(self)
        separator = gtk.SeparatorToolItem()
        separator.set_draw(False)
        separator.set_expand(True)
        self.insert(separator, -1)
        separator.show()

        search_item = gtk.ToolItem()

        self._search_entry = gtk.Entry()
        self._search_entry.connect('activate', self._search_entry_activate_cb)

        width = int(gtk.gdk.screen_width() / 3)
        self._search_entry.set_size_request(width, -1)

        search_item.add(self._search_entry)
        self._search_entry.show()

        self.insert(search_item, -1)
        search_item.show()

        self._prev = ToolButton('go-previous-paired')
        self._prev.set_tooltip(_('Previous'))
        self._prev.props.sensitive = False
        self._prev.connect('clicked', self._find_prev_cb)
        self.insert(self._prev, -1)
        self._prev.show()

        self._next = ToolButton('go-next-paired')
        self._next.set_tooltip(_('Next'))
        self._next.props.sensitive = False
        self._next.connect('clicked', self._find_next_cb)
        self.insert(self._next, -1)
        self._next.show()
Beispiel #24
0
    def __init__(self):
        gtk.Toolbar.__init__(self)
        self._back = ToolButton('go-previous')
        self._back.set_tooltip(_('Back'))
        self._back.props.sensitive = False
        self._back.connect('clicked', self._go_back_cb)
        self.insert(self._back, -1)
        self._back.show()

        self._forward = ToolButton('go-next')
        self._forward.set_tooltip(_('Forward'))
        self._forward.props.sensitive = False
        self._forward.connect('clicked', self._go_forward_cb)
        self.insert(self._forward, -1)
        self._forward.show()

        num_page_item = gtk.ToolItem()

        self._num_page_entry = gtk.Entry()
        self._num_page_entry.set_text('0')
        self._num_page_entry.set_alignment(1)
        self._num_page_entry.connect('insert-text',
                                     self._num_page_entry_insert_text_cb)
        self._num_page_entry.connect('activate',
                                     self._num_page_entry_activate_cb)

        self._num_page_entry.set_width_chars(4)

        num_page_item.add(self._num_page_entry)
        self._num_page_entry.show()

        self.insert(num_page_item, -1)
        num_page_item.show()

        total_page_item = gtk.ToolItem()

        self._total_page_label = gtk.Label()

        label_attributes = pango.AttrList()
        label_attributes.insert(pango.AttrSize(14000, 0, -1))
        label_attributes.insert(pango.AttrForeground(65535, 65535, 65535, 0, -1))
        self._total_page_label.set_attributes(label_attributes)

        self._total_page_label.set_text(' / 0')
        total_page_item.add(self._total_page_label)
        self._total_page_label.show()

        self.insert(total_page_item, -1)
        total_page_item.show()

        downloaded_item = gtk.ToolItem()
        self._downloaded_label = gtk.Label()
        self._downloaded_label.set_attributes(label_attributes)

        self._downloaded_label.set_text('')
        downloaded_item.add(self._downloaded_label)
        self._downloaded_label.show()

        self.insert(downloaded_item, -1)
        downloaded_item.show()
Beispiel #25
0
    def __init__(self, _parent):
        activity.EditToolbar.__init__(self)

        self._parent = _parent

        self.undo.connect('clicked', self.__undo_cb)
        self.redo.connect('clicked', self.__redo_cb)
        self.copy.connect('clicked', self.__copy_cb)
        self.paste.connect('clicked', self.__paste_cb)

        menu_item = MenuItem(_('Cut'))
        menu_item.connect('activate', self.__cut_cb)
        menu_item.show()
        self.copy.get_palette().menu.append(menu_item)

        self.insert(gtk.SeparatorToolItem(), -1)

        self.erase_button = ToolButton('edit-delete')
        self.erase_button.set_tooltip(_('Erase selected thought(s)'))
        self.erase_button.connect('clicked', self.__delete_cb)
        self.insert(self.erase_button, -1)

        self.show_all()
        self.clipboard = gtk.Clipboard()

        self.copy.child.set_sensitive(False)
        self.paste.child.set_sensitive(False)
        self.erase_button.set_sensitive(False)
Beispiel #26
0
    def __init__(self):
        gtk.Toolbar.__init__(self)

        self._add_separator()

        self._icon = Icon()
        self._add_widget(self._icon)

        self._add_separator()

        self._title = gtk.Label()
        self._add_widget(self._title)

        self._add_separator(True)

        self.cancel_button = ToolButton('dialog-cancel')
        self.cancel_button.set_tooltip(_('Cancel'))
        self.cancel_button.connect('clicked', self.__cancel_button_clicked_cb)
        self.insert(self.cancel_button, -1)
        self.cancel_button.show()

        self.accept_button = ToolButton('dialog-ok')
        self.accept_button.set_tooltip(_('Ok'))
        self.accept_button.connect('clicked', self.__accept_button_clicked_cb)
        self.insert(self.accept_button, -1)
        self.accept_button.show()
Beispiel #27
0
    def _add_speed_slider(self, toolbar):
        self._speed_stepper_down = ToolButton('speed-down')
        self._speed_stepper_down.set_tooltip(_('Slow down'))
        self._speed_stepper_down.connect('clicked',
                                         self._speed_stepper_down_cb)
        self._speed_stepper_down.show()

        self._adjustment = gtk.Adjustment(200, self.LOWER, self.UPPER, 25, 100,
                                          0)
        self._adjustment.connect('value_changed', self._speed_change_cb)
        self._speed_range = gtk.HScale(self._adjustment)
        self._speed_range.set_inverted(True)
        self._speed_range.set_draw_value(False)
        self._speed_range.set_update_policy(gtk.UPDATE_CONTINUOUS)
        self._speed_range.set_size_request(120, 15)
        self._speed_range.show()

        self._speed_stepper_up = ToolButton('speed-up')
        self._speed_stepper_up.set_tooltip(_('Speed up'))
        self._speed_stepper_up.connect('clicked', self._speed_stepper_up_cb)
        self._speed_stepper_up.show()

        self._speed_range_tool = gtk.ToolItem()
        self._speed_range_tool.add(self._speed_range)
        self._speed_range_tool.show()

        toolbar.insert(self._speed_stepper_down, -1)
        toolbar.insert(self._speed_range_tool, -1)
        toolbar.insert(self._speed_stepper_up, -1)
        return
Beispiel #28
0
    def __init__(self):
        gtk.Toolbar.__init__(self)

        self._add_separator()

        tool_item = gtk.ToolItem()
        self.insert(tool_item, -1)
        tool_item.show()
        self._search_entry = iconentry.IconEntry()
        self._search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY,
                                              'system-search')
        self._search_entry.add_clear_button()
        self._search_entry.set_width_chars(25)
        self._search_entry.connect('changed', self.__search_entry_changed_cb)
        tool_item.add(self._search_entry)
        self._search_entry.show()

        self._add_separator(True)

        self.stop = ToolButton(icon_name='dialog-cancel')
        self.stop.set_tooltip(_('Done'))
        self.stop.connect('clicked', self.__stop_clicked_cb)
        self.stop.show()
        self.insert(self.stop, -1)
        self.stop.show()
 def __init__(self):
     gtk.Toolbar.__init__(self)
     self.fullscreen = ToolButton('view-fullscreen')
     self.fullscreen.set_tooltip(_('Fullscreen'))
     self.fullscreen.connect('clicked', self.fullscreen_cb)
     self.insert(self.fullscreen, -1)
     self.fullscreen.show()
    def __init__(self):
        gtk.Toolbar.__init__(self)

        self.undo = ToolButton('edit-undo')
        self.undo.set_tooltip(_('Undo'))
        self.insert(self.undo, -1)
        self.undo.show()

        self.redo = ToolButton('edit-redo')
        self.redo.set_tooltip(_('Redo'))
        self.insert(self.redo, -1)
        self.redo.show()

        self.separator = gtk.SeparatorToolItem()
        self.separator.set_draw(True)
        self.insert(self.separator, -1)
        self.separator.show()

        self.copy = ToolButton('edit-copy')
        self.copy.set_tooltip(_('Copy'))
        self.insert(self.copy, -1)
        self.copy.show()

        self.paste = ToolButton('edit-paste')
        self.paste.set_tooltip(_('Paste'))
        self.insert(self.paste, -1)
        self.paste.show()
Beispiel #31
0
class WriteToolbar(gtk.Toolbar):

    canvas = WriteCanvas

    def __init__(self, activity):        
        gtk.Toolbar.__init__(self)
        self._activity = activity
    
        self._send_button = ToolButton('send-email', tooltip=_('Send email'))
        self._send_button.connect('clicked', self.__send_email_cb)
        self.insert(self._send_button, -1)

        self._attach_button = ToolButton('add-attachment', tooltip=_('Add attachment'))
        self._attach_button.connect('clicked', self.__add_attachment_cb)
        self.insert(self._attach_button, -1)
        
        self.show_all()


    def __send_email_cb(self, *args):
        msg = self._activity.canvas.make_msg()
        if utility.check_online():
            func = self._activity.config.transport_account.send
            args = ([msg], OutboundTracker(self._activity))
            thread.start_new_thread(func, args)
        else:
            self._keep_as_outbound(msg)
        self._activity.toolbox.current_toolbar = 1  # egh

    def __add_attachment_cb(self, *args):
        pass
    def _insert_create_tools(self, create_toolbar):
        # Stop/play button
        self.stop_play_state = True
        self.stop_play = ToolButton('media-playback-stop')
        self.stop_play.set_tooltip(_("Stop"))
        self.stop_play.set_accelerator(_('<ctrl>space'))
        self.stop_play.connect('clicked', self.stop_play_cb)
        create_toolbar.insert(self.stop_play, -1)
        self.stop_play.show()

        separator = gtk.SeparatorToolItem()
        create_toolbar.insert(separator, -1)
        separator.show()

        # Make + add the component buttons
        self.radioList = {}
        firstButton = None
        for c in tools.allTools:
            button = RadioToolButton(named_icon=c.icon)
            if firstButton:
                button.set_group(firstButton)
            else:
                button.set_group(None)
                firstButton = button
            button.set_tooltip(c.toolTip)
            button.set_accelerator(c.toolAccelerator)
            button.connect('clicked', self.radioClicked)
            create_toolbar.insert(button, -1)
            button.show()
            self.radioList[button] = c.name
Beispiel #33
0
    def build_toolbar(self):
        toolbar_box = ToolbarBox()
        self.set_toolbar_box(toolbar_box)
        toolbar_box.show()

        activity_button = ActivityToolbarButton(self)
        toolbar_box.toolbar.insert(activity_button, -1)
        activity_button.show()

        separator1 = gtk.SeparatorToolItem()
        separator1.props.draw = True
        separator1.set_expand(False)
        toolbar_box.toolbar.insert(separator1, -1)
        separator1.show()

        item1 = gtk.ToolItem()
        label1 = gtk.Label()
        label1.set_text(_('Levels') + ' ')
        item1.add(label1)
        toolbar_box.toolbar.insert(item1, -1)

        item2 = gtk.ToolItem()

        levels = (_('Cross'),
            _('Cross 2'),
            #TRANS:'chimney' - the place where you make fire
            _('Hearth'),
            _('Arrow'),
            _('Pyramid'),
            _('Diamond'),
            _('Solitaire'))
        combo = Combo(levels)
        item2.add(combo)
        combo.connect('changed', self.change_combo)
        toolbar_box.toolbar.insert(item2, -1)

        separator2 = gtk.SeparatorToolItem()
        separator2.props.draw = True
        separator2.set_expand(False)
        toolbar_box.toolbar.insert(separator2, -1)
        separator2.show()

        sound_button = ToolButton('speaker-muted-100')
        sound_button.set_tooltip(_('Sound'))
        sound_button.connect('clicked', self.sound_control)
        toolbar_box.toolbar.insert(sound_button, -1)

        separator3 = gtk.SeparatorToolItem()
        separator3.props.draw = False
        separator3.set_expand(True)
        toolbar_box.toolbar.insert(separator3, -1)
        separator3.show()

        stop_button = StopButton(self)
        toolbar_box.toolbar.insert(stop_button, -1)
        stop_button.show()


        self.show_all()
Beispiel #34
0
    def __init__(self):
        gtk.Toolbar.__init__(self)
        self.back = ToolButton('go-previous')
        self.back.set_tooltip(_('Back'))
        self.back.props.sensitive = False
        palette = self.back.get_palette()
        self.prev_page = MenuItem(text_label= _("Previous page"))
        palette.menu.append(self.prev_page) 
        self.prev_page.show_all()        
        self.back.connect('clicked', self.go_back_cb)
        self.prev_page.connect('activate', self.go_back_cb)
        self.insert(self.back, -1)
        self.back.show()

        self.forward = ToolButton('go-next')
        self.forward.set_tooltip(_('Forward'))
        self.forward.props.sensitive = False
        palette = self.forward.get_palette()
        self.next_page = MenuItem(text_label= _("Next page"))
        palette.menu.append(self.next_page) 
        self.next_page.show_all()        
        self.forward.connect('clicked', self.go_forward_cb)
        self.next_page.connect('activate', self.go_forward_cb)
        self.insert(self.forward, -1)
        self.forward.show()

        num_page_item = gtk.ToolItem()

        self._num_page_entry = gtk.Entry()
        self._num_page_entry.set_text('0')
        self._num_page_entry.set_alignment(1)
        self._num_page_entry.connect('insert-text',
                                     self._num_page_entry_insert_text_cb)
        self._num_page_entry.connect('activate',
                                     self._num_page_entry_activate_cb)

        self._num_page_entry.set_width_chars(4)

        num_page_item.add(self._num_page_entry)
        self._num_page_entry.show()

        self.insert(num_page_item, -1)
        num_page_item.show()

        total_page_item = gtk.ToolItem()

        self._total_page_label = gtk.Label()

        label_attributes = pango.AttrList()
        label_attributes.insert(pango.AttrSize(14000, 0, -1))
        label_attributes.insert(pango.AttrForeground(65535, 65535, 65535, 0, -1))
        self._total_page_label.set_attributes(label_attributes)

        self._total_page_label.set_text(' / 0')
        total_page_item.add(self._total_page_label)
        self._total_page_label.show()

        self.insert(total_page_item, -1)
        total_page_item.show()
    def __init__(self, **kwargs):
        ToolButton.__init__(self, **kwargs)
        self.selected_button = None

        if self.props.palette:
            self.__palette_cb(None, None)

        self.connect('notify::palette', self.__palette_cb)
    def __init__(self, library, toolbar):
        self.library = library
        self.activity = library.activity

        self.publish = ToolButton('filesave',
                                  tooltip=_('Publish selected articles'))
        self.publish.connect("clicked", self._publish_clicked_cb)
        toolbar.insert(self.publish, -1)
    def __init__(self, **kwargs):
        ToolButton.__init__(self, **kwargs)
        self.selected_button = None

        if self.props.palette:
            self.__palette_cb(None, None)

        self.connect("notify::palette", self.__palette_cb)
    def __init__(self, handle):
        activity.Activity.__init__(self, handle, True)
        self.toolbar = widgets.ActivityToolbar(self)
        self.buildercanvas = gtk.Builder()
        self.buildercanvas.add_from_file('interfaz.glade')
        self.totl = gtk.EventBox()
        self.totl.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse('#282828'))
        self.box = self.buildercanvas.get_object('vbox1')
        self.totl.add(self.box)
        self.box.set_size_request(gtk.gdk.screen_width(),
                                  gtk.gdk.screen_height() - 55)
        separador = gtk.SeparatorToolItem()
        separador.props.draw = False
        separador.set_expand(True)
        self.img = gtk.Image()
        self.fin = gtk.EventBox()
        p = gtk.gdk.pixbuf_new_from_file_at_size('icons/ceibaljam.svg',
                                                 gtk.gdk.screen_width(),
                                                 gtk.gdk.screen_height() - 55)
        self.fin.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse('#282828'))
        self.fin.add(self.img)
        self.img.set_from_pixbuf(p)
        self.button = ToolButton('document-save')
        self.button.set_tooltip('Guardar al diario')
        self.button.connect('clicked', self.save_xo)
        self.toolbar.insert(separador, 1)
        self.toolbar.insert(self.button, 2)
        self.toolbar.insert(separador, 3)

        l = []
        l.append(self.buildercanvas.get_object('label1'))
        l.append(self.buildercanvas.get_object('label2'))
        l.append(self.buildercanvas.get_object('label3'))
        l.append(self.buildercanvas.get_object('label4'))
        l.append(self.buildercanvas.get_object('label5'))
        l.append(self.buildercanvas.get_object('label6'))
        for x in l:
            x.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse('white'))
            x.show()

        self.f = self.buildercanvas.get_object('label2')
        self.f.modify_font(pango.FontDescription('15'))
        self.icono = self.buildercanvas.get_object('icono')
        self.flash = self.buildercanvas.get_object('flash')
        self.nombre = self.buildercanvas.get_object('nombre')
        self.bundleid = self.buildercanvas.get_object('bundleid')
        self.version = self.buildercanvas.get_object('version')
        self.version.set_value(1)

        self.btn1 = self.buildercanvas.get_object('btn1')
        self.btn2 = self.buildercanvas.get_object('btn2')
        self.btn1.connect('clicked', self.open, True)
        self.btn2.connect('clicked', self.open, False)

        self.set_canvas(self.totl)
        self.set_toolbar_box(self.toolbar)
        self.show_all()
        self.toolbar.share.props.visible = False
Beispiel #39
0
    def __init__(self, activity, **kwargs):
        ToolButton.__init__(self, **kwargs)

        icon = _create_activity_icon(activity.metadata)
        self.set_icon_widget(icon)
        icon.show()

        self.props.tooltip = activity.metadata['title']
        activity.metadata.connect('updated', self.__jobject_updated_cb)
Beispiel #40
0
    def __init__(self, activity, **kwargs):
        ToolButton.__init__(self, **kwargs)

        icon = _create_activity_icon(activity.metadata)
        self.set_icon_widget(icon)
        icon.show()

        self.props.tooltip = activity.metadata['title']
        activity.metadata.connect('updated', self.__jobject_updated_cb)
class NamingToolbar(gtk.Toolbar):
    """ Toolbar of the naming alert
    """

    __gtype_name__ = 'MyNamingToolbar'

    __gsignals__ = {
        'keep-clicked': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])),
    }

    def __init__(self):
        gtk.Toolbar.__init__(self)

        client = gconf.client_get_default()
        color = XoColor(client.get_string('/desktop/sugar/user/color'))
        icon = Icon()
        icon.set_from_icon_name('activity-journal',
                                gtk.ICON_SIZE_LARGE_TOOLBAR)
        icon.props.xo_color = color
        self._add_widget(icon)

        self._add_separator()

        self._title = gtk.Label(_('Describe your activity'))
        self._add_widget(self._title)

        self._add_separator(True)

        self._keep_button = ToolButton('dialog-ok', tooltip=_('Keep'))
        self._keep_button.props.accelerator = '<Ctrl>s'
        self._keep_button.connect('clicked', self.__keep_button_clicked_cb)
        self.insert(self._keep_button, -1)
        self._keep_button.show()

    def _add_separator(self, expand=False):
        separator = gtk.SeparatorToolItem()
        separator.props.draw = False
        if expand:
            separator.set_expand(True)
        else:
            separator.set_size_request(style.DEFAULT_SPACING, -1)
        self.insert(separator, -1)
        separator.show()

    def _add_widget(self, widget, expand=False):
        tool_item = gtk.ToolItem()
        tool_item.set_expand(expand)

        tool_item.add(widget)
        widget.show()

        self.insert(tool_item, -1)
        tool_item.show()

    def __keep_button_clicked_cb(self, widget, data=None):
        self.emit('keep-clicked')
class NamingToolbar(gtk.Toolbar):
    """ Toolbar of the naming alert
    """
    __gtype_name__ = 'SugarNamingToolbar'

    __gsignals__ = {
        'keep-clicked': (gobject.SIGNAL_RUN_FIRST,
                         gobject.TYPE_NONE,
                         ([]))
    }
    def __init__(self):
        gtk.Toolbar.__init__(self)

        client = gconf.client_get_default()
        color = XoColor(client.get_string('/desktop/sugar/user/color'))
        icon = Icon()
        icon.set_from_icon_name('activity-journal', 
                                gtk.ICON_SIZE_LARGE_TOOLBAR)
        icon.props.xo_color = color
        self._add_widget(icon)

        self._add_separator()

        self._title = gtk.Label(_('Name this entry'))
        self._add_widget(self._title)
        
        self._add_separator(True)

        self._keep_button = ToolButton('dialog-ok', tooltip=_('Keep'))
        self._keep_button.props.accelerator = 'Return'
        self._keep_button.connect('clicked', self.__keep_button_clicked_cb)
        self.insert(self._keep_button, -1)
        self._keep_button.show()

    def _add_separator(self, expand=False):
        separator = gtk.SeparatorToolItem()
        separator.props.draw = False
        if expand:
            separator.set_expand(True)
        else:
            separator.set_size_request(style.DEFAULT_SPACING, -1)
        self.insert(separator, -1)
        separator.show()

    def _add_widget(self, widget, expand=False):
        tool_item = gtk.ToolItem()
        tool_item.set_expand(expand)

        tool_item.add(widget)
        widget.show()

        self.insert(tool_item, -1)
        tool_item.show()

    def __keep_button_clicked_cb(self, widget, data=None):
        self.emit('keep-clicked')
Beispiel #43
0
    def __init__(self, activity, abi):
        ToolButton.__init__(self, "document-save")
        self.props.tooltip = _("Export")
        self.props.label = _("Export")

        for i in self._EXPORT_FORMATS:
            menu_item = MenuItem(i["title"])
            menu_item.connect("activate", self.__activate_cb, activity, abi, i)
            self.props.palette.menu.append(menu_item)
            menu_item.show()
Beispiel #44
0
    def __init__(self, page=None, **kwargs):
        ToolButton.__init__(self, **kwargs)

        self.page_widget = None

        self.set_page(page)

        self.connect('clicked',
                     lambda widget: self.set_expanded(not self.is_expanded()))
        self.connect('size-allocate', self.__size_allocate_cb)
    def __init__(self, activity, abi):
        ToolButton.__init__(self, 'document-save')
        self.props.tooltip = _('Export')
        self.props.label = _('Export')

        for i in self._EXPORT_FORMATS:
            menu_item = MenuItem(i['title'])
            menu_item.connect('activate', self.__activate_cb, activity, abi, i)
            self.props.palette.menu.append(menu_item)
            menu_item.show()
    def __init__(self, pc):
        gtk.Toolbar.__init__(self)
        self.activity = pc

        # Ruler
        self.activity.rulers = ToolButton("ruler")
        self.activity.rulers.set_tooltip(_('Ruler'))
        self.activity.rulers.props.sensitive = True
        self.activity.rulers.connect('clicked', self.activity._rulers_cb)
        self.insert(self.activity.rulers, -1)
        self.activity.rulers.show()

        # Grid
        self.activity.grids = ToolButton("grid-a")
        self.activity.grids.set_tooltip(_('Grid'))
        self.activity.grids.props.sensitive = True
        self.activity.grids.connect('clicked', self.activity._grids_cb)
        self.insert(self.activity.grids, -1)
        self.activity.grids.show()

        # Angles
        self.activity.angles = ToolButton("angles-90")
        self.activity.angles.set_tooltip(_('Angles'))
        self.activity.angles.props.sensitive = True
        self.activity.angles.connect('clicked', self.activity._angles_cb)
        self.insert(self.activity.angles, -1)
        self.activity.angles.show()

        # Checker
        self.activity.checker = ToolButton("checker")
        self.activity.checker.set_tooltip(_('Checker'))
        self.activity.checker.props.sensitive = True
        self.activity.checker.connect('clicked', self.activity._checker_cb)
        self.insert(self.activity.checker, -1)
        self.activity.checker.show()

        if not self.activity.known_dpi:
            separator = gtk.SeparatorToolItem()
            separator.set_draw(True)
            self.insert(separator, -1)
            separator.show()

            dpi = self.activity._canvas.get_dpi()
            self.activity._dpi_spin_adj = gtk.Adjustment(
                dpi, 72, 200, 2, 32, 0)
            self.activity._dpi_spin = \
                gtk.SpinButton(self.activity._dpi_spin_adj, 0, 0)
            self.activity._dpi_spin_id = self.activity._dpi_spin.connect(
                'value-changed', self.activity._dpi_spin_cb)
            self.activity._dpi_spin.set_numeric(True)
            self.activity._dpi_spin.show()
            self.activity.tool_item_dpi = gtk.ToolItem()
            self.activity.tool_item_dpi.add(self.activity._dpi_spin)
            self.insert(self.activity.tool_item_dpi, -1)
            self.activity.tool_item_dpi.show()
 def __init__(self, activity):
     gtk.Toolbar.__init__(self)
     self.activity = activity
     self._lock = True
     self.jobject = None
     
     # Reset Button
     restart_icon = join(dirname(__file__), 'images', 'game-restart.svg')
     restart_image = gtk.Image()
     restart_image.set_from_file(restart_icon)
     self._restart_button = ToolButton()
     self._restart_button.set_icon_widget(restart_image)
     self._restart_button.connect('clicked', self._game_reset_cb)
     self._restart_button.set_tooltip(_('Restart Game'))
     self.insert(self._restart_button, -1)
     self._restart_button.show()
     
     # Load Button
     load_icon = join(dirname(__file__), 'images', 'game-load.svg')
     load_image = gtk.Image()
     load_image.set_from_file(load_icon)
     self._load_button = ToolButton()
     self._load_button.set_icon_widget(load_image)
     self._load_button.set_tooltip(_('Load game'))
     self._load_button.connect('clicked', self._load_game)
     self._add_widget(self._load_button)
     
     # Separator
     separator = gtk.SeparatorToolItem()
     separator.set_draw(True)
     self.insert(separator, -1)
     
     # Change size combobox
     self._size_combo = ToolComboBox()
     self._sizes = ['4 X 4', '5 X 5', '6 X 6']
     for i, f in enumerate(self._sizes):
         self._size_combo.combo.append_item(i, f)
     self.size_handle_id = self._size_combo.combo.connect( \
             'changed', self._game_size_cb)
     self._add_widget(self._size_combo)
     self._size_combo.combo.set_active(0)
     
     separator = gtk.SeparatorToolItem()
     separator.set_draw(True)
     self.insert(separator, -1)
     self._lock = False
 
     # Change demo games combobox        
     self._game_combo = ToolComboBox()
     for i, f in enumerate(self.standard_game_names):
         f = _(f)    
         self._game_combo.combo.append_item(i, f)
     self._game_combo.combo.set_active(0)
     self._game_combo.combo.connect('changed', self._game_changed_cb)
     self._add_widget(self._game_combo)
Beispiel #48
0
    def __init__(self, activity, **kwargs):
        gtk.ToolItem.__init__(self)

        description_button = ToolButton('edit-description')
        description_button.show()
        description_button.set_tooltip(_('Description'))
        self._palette = description_button.get_palette()

        description_box = gtk.HBox()
        sw = gtk.ScrolledWindow()
        sw.set_size_request(int(gtk.gdk.screen_width() / 2),
                            2 * style.GRID_CELL_SIZE)
        sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        self._text_view = gtk.TextView()
        self._text_view.set_left_margin(style.DEFAULT_PADDING)
        self._text_view.set_right_margin(style.DEFAULT_PADDING)
        text_buffer = gtk.TextBuffer()
        if 'description' in activity.metadata:
            text_buffer.set_text(activity.metadata['description'])
        self._text_view.set_buffer(text_buffer)
        self._text_view.connect('focus-out-event',
                                self.__description_changed_cb, activity)
        sw.add(self._text_view)
        description_box.pack_start(sw, False, True, 0)
        self._palette.set_content(description_box)
        description_box.show_all()

        self.add(description_button)
        description_button.connect('clicked',
                                   self.__description_button_clicked_cb)

        activity.metadata.connect('updated', self.__jobject_updated_cb)
class ImageToolbar(gtk.Toolbar):
    def __init__(self, toolbox, abiword_canvas, parent):
        gtk.Toolbar.__init__(self)

        self._toolbox = toolbox
        self._abiword_canvas = abiword_canvas
        self._parent = parent

        self._image = ToolButton('insert-image')
        self._image.set_tooltip(_('Insert Image'))
        self._image_id = self._image.connect('clicked', self._image_cb)
        self.insert(self._image, -1)
        self._image.show()

        self._abiword_canvas.connect('image-selected', self._image_selected_cb)

        ####btn salir del barrido del menu item
        self._btn_barrido_menu = ToolButton()
        self._btn_barrido_menu.set_tooltip(_('Salir \nMenú'))
        self._btn_barrido_menu_id = self._btn_barrido_menu.connect(
            'clicked', self._btn_barrido_menu_cb)
        self.insert(self._btn_barrido_menu, -1)
        self._btn_barrido_menu.set_no_show_all(True)

#self._btn_barrido_menu.show() # en realidad mostrar solo si esta barriendo

    def _btn_barrido_menu_cb(self, button):
        if (self._parent.BOTONESxBARRIDO_MENU_ITEM):
            self._parent.BOTONESxBARRIDO_MENU = False
            self._parent.BOTONESxBARRIDO_MENU_ITEM = False
            self._parent.BOTONESxBARRIDO = False  # si le doy True va a ejectuar el escribir porque llama al metodo del eventbox
            #self._parent.chk_activarBarrido_botones_menu.emit("clicked")
            self._parent.chk_activarBarrido_botones.set_active(True)
        ####fin btn salir del barrido del menu item

    def _image_cb(self, button):
        chooser = ObjectChooser(
            _('Choose image'), self._parent,
            gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT)
        try:
            result = chooser.run()
            if result == gtk.RESPONSE_ACCEPT:
                logging.debug('ObjectChooser: %r' %
                              chooser.get_selected_object())
                jobject = chooser.get_selected_object()
                if jobject and jobject.file_path:
                    self._abiword_canvas.insert_image(jobject.file_path, True)
        finally:
            chooser.destroy()
            del chooser

    def _image_selected_cb(self, abi, b):
        if b:
            self._toolbox.set_current_toolbar(TOOLBAR_IMAGE)
            self._abiword_canvas.grab_focus()  # hack: bad toolbox, bad!
Beispiel #50
0
    def build_toolbar(self):
        toolbar_box = ToolbarBox()
        self.set_toolbar_box(toolbar_box)
        toolbar_box.show()

        activity_button = ActivityToolbarButton(self)
        toolbar_box.toolbar.insert(activity_button, -1)
        activity_button.show()

        # Pause/Play button:

        stop_play = ToolButton('media-playback-stop')
        stop_play.set_tooltip(_("Stop"))
        stop_play.set_accelerator(_('<ctrl>space'))
        stop_play.connect('clicked', self._stop_play_cb)
        stop_play.show()

        toolbar_box.toolbar.insert(stop_play, -1)

        # Blank space (separator) and Stop button at the end:

        separator = gtk.SeparatorToolItem()
        separator.props.draw = False
        separator.set_expand(True)
        toolbar_box.toolbar.insert(separator, -1)
        separator.show()

        stop_button = StopButton(self)
        toolbar_box.toolbar.insert(stop_button, -1)
        stop_button.show()
Beispiel #51
0
    def build_resolution_toolbar(self, toolbox):

        resolution_bar = gtk.Toolbar()

        item1 = gtk.ToolItem()
        label1 = gtk.Label()
        label1.set_text(' ' + _('Show size') + ' ')
        item1.add(label1)
        resolution_bar.insert(item1, -1)

        item2 = gtk.ToolItem()
        x_size_spin = gtk.SpinButton()
        x_size_spin.set_range(160, 1200)
        x_size_spin.set_increments(1, 10)
        x_size_spin.props.value = int(self.show_size[0])
        x_size_spin.connect('notify::value', self.x_size_spin_change)
        item2.add(x_size_spin)
        resolution_bar.insert(item2, -1)

        item3 = gtk.ToolItem()
        label3 = gtk.Label()
        label3.set_text(' X ')
        item3.add(label3)
        resolution_bar.insert(item3, -1)

        item4 = gtk.ToolItem()
        y_size_spin = gtk.SpinButton()
        y_size_spin.set_range(120, 900)
        y_size_spin.set_increments(1, 10)
        y_size_spin.props.value = int(self.show_size[1])
        y_size_spin.connect('notify::value', self.y_size_spin_change)
        item4.add(y_size_spin)
        resolution_bar.insert(item4, -1)

        separator1 = gtk.SeparatorToolItem()
        separator1.props.draw = True
        resolution_bar.insert(separator1, -1)

        item5 = gtk.ToolItem()
        label5 = gtk.Label()
        label5.set_text(' ' + _('Show grid'))
        item5.add(label5)
        resolution_bar.insert(item5, -1)

        grid = ToolButton('grid-icon')
        grid.connect('clicked', self.grid_click)
        resolution_bar.insert(grid, -1)

        resolution_bar.show_all()
        resolution_button = ToolbarButton(label=_('Resolution'),
                page=resolution_bar,
                icon_name='camera')
        toolbox.toolbar.insert(resolution_button, -1)
        resolution_button.show()
    def __init__(self, activity):
        gtk.Toolbar.__init__(self)

        self._activity = activity
        self._updating_share = False
        self._focus_out_hid = None

        activity.connect('shared', self.__activity_shared_cb)
        activity.connect('joined', self.__activity_shared_cb)
        activity.connect('notify::max_participants',
                         self.__max_participants_changed_cb)

        if activity.metadata:
            self.title = gtk.Entry()
            self.title.set_size_request(int(gtk.gdk.screen_width() / 3), -1)
            self.title.set_text(activity.metadata['title'])
            self._focus_out_hid = self.title.connect('focus-out-event',
                                                     self.__title_changed_cb)
            self._add_widget(self.title)

            activity.metadata.connect('updated', self.__jobject_updated_cb)

        separator = gtk.SeparatorToolItem()
        separator.props.draw = False
        separator.set_expand(True)
        self.insert(separator, -1)
        separator.show()

        self.share = ToolComboBox(label_text=_('Share with:'))
        self.share.combo.connect('changed', self.__share_changed_cb)
        self.share.combo.append_item(SCOPE_PRIVATE, _('Private'), 'zoom-home')
        self.share.combo.append_item(SCOPE_NEIGHBORHOOD, _('My Neighborhood'),
                                     'zoom-neighborhood')
        self.insert(self.share, -1)
        self.share.show()

        self._update_share()

        self.keep = ToolButton(tooltip=_('Keep'))
        client = gconf.client_get_default()
        color = XoColor(client.get_string('/desktop/sugar/user/color'))
        keep_icon = Icon(icon_name='document-save', xo_color=color)
        self.keep.set_icon_widget(keep_icon)
        keep_icon.show()
        self.keep.props.accelerator = '<Ctrl>S'
        self.keep.connect('clicked', self.__keep_clicked_cb)
        self.insert(self.keep, -1)
        self.keep.show()

        self.stop = ToolButton('activity-stop', tooltip=_('Stop'))
        self.stop.props.accelerator = '<Ctrl>Q'
        self.stop.connect('clicked', self.__stop_clicked_cb)
        self.insert(self.stop, -1)
        self.stop.show()
Beispiel #53
0
    def __init__(self, activity, **kwargs):
        ToolButton.__init__(self, **kwargs)
        self.props.tooltip = _('Keep')
        self.props.accelerator = '<Ctrl>S'

        color = profile.get_color()
        keep_icon = Icon(icon_name='document-save', xo_color=color)
        keep_icon.show()

        self.set_icon_widget(keep_icon)
        self.connect('clicked', self.__keep_button_clicked_cb, activity)
Beispiel #54
0
    def __init__(self, page=None, **kwargs):
        ToolButton.__init__(self, **kwargs)

        self.page_widget = None

        self.set_page(page)

        self.connect('clicked',
                lambda widget: self.set_expanded(not self.is_expanded()))

        self.connect('hierarchy-changed', self.__hierarchy_changed_cb)
    def __init__(self):
        Test.__init__(self)

        toolbar = gtk.Toolbar()

        self._invoker = ToolButton('go-previous')
        toolbar.insert(self._invoker, -1)
        self._invoker.show()

        self.pack_start(toolbar, False)
        toolbar.show()
Beispiel #56
0
    def build_resolution_toolbar(self, toolbox):

        resolution_bar = gtk.Toolbar()

        item1 = gtk.ToolItem()
        label1 = gtk.Label()
        label1.set_text(' ' + _('Show size') + ' ')
        item1.add(label1)
        resolution_bar.insert(item1, -1)

        item2 = gtk.ToolItem()
        x_size_spin = gtk.SpinButton()
        x_size_spin.set_range(160, 1200)
        x_size_spin.set_increments(1, 10)
        x_size_spin.props.value = int(self.show_size[0])
        x_size_spin.connect('notify::value', self.x_size_spin_change)
        item2.add(x_size_spin)
        resolution_bar.insert(item2, -1)

        item3 = gtk.ToolItem()
        label3 = gtk.Label()
        label3.set_text(' X ')
        item3.add(label3)
        resolution_bar.insert(item3, -1)

        item4 = gtk.ToolItem()
        y_size_spin = gtk.SpinButton()
        y_size_spin.set_range(120, 900)
        y_size_spin.set_increments(1, 10)
        y_size_spin.props.value = int(self.show_size[1])
        y_size_spin.connect('notify::value', self.y_size_spin_change)
        item4.add(y_size_spin)
        resolution_bar.insert(item4, -1)

        separator1 = gtk.SeparatorToolItem()
        separator1.props.draw = True
        resolution_bar.insert(separator1, -1)

        item5 = gtk.ToolItem()
        label5 = gtk.Label()
        label5.set_text(' ' + _('Show grid'))
        item5.add(label5)
        resolution_bar.insert(item5, -1)

        grid = ToolButton('grid-icon')
        grid.connect('clicked', self.grid_click)
        resolution_bar.insert(grid, -1)

        resolution_bar.show_all()
        resolution_button = ToolbarButton(label=_('Resolution'),
                                          page=resolution_bar,
                                          icon_name='camera')
        toolbox.toolbar.insert(resolution_button, -1)
        resolution_button.show()
Beispiel #57
0
    def __init__(self, page=None, **kwargs):
        ToolButton.__init__(self, **kwargs)

        self.page_widget = None

        self.set_page(page)

        self.connect('clicked',
                     lambda widget: self.set_expanded(not self.is_expanded()))

        self.connect('hierarchy-changed', self.__hierarchy_changed_cb)
Beispiel #58
0
    def __init__(self, handle):
        gtk.Toolbar.__init__(self)

        self.handle = handle
        self._logger = logging.getLogger("activity-knut")
        self._logger.setLevel(logging.DEBUG)
        # First log handler: outputs to a file
        file_handler = logging.FileHandler("/home/wiktor/code/knut.log")
        file_formatter = logging.Formatter("%(message)s")
        file_handler.setFormatter(file_formatter)
        self._logger.addHandler(file_handler)

        # Tytuł pola tekstowego
        self.add_widget(gtk.Label("Kategoria: "))

        # Pole tekstowe
        self.test_type = ComboBox()
        for id, name in BrowseToolbar.TEST_CATEGORIES.items():
            self.test_type.append_item(id, name)
        self.test_type.set_active(0)
        self.add_widget(self.test_type)

        # Separator
        #        separator = gtk.SeparatorToolItem()
        #        separator.set_draw(True)
        #        separator.set_size_request(50,25)
        #        self.add_widget(separator)

        # Tytuł pola tekstowego
        self.add_widget(gtk.Label(" Szukaj w tytule: "))

        # Pole tekstowe
        self.search_entry = gtk.Entry()
        self.search_entry.set_size_request(100, 25)
        #        self.pass_entry.set_text('123123')
        self.add_widget(self.search_entry)

        # Przycisk pobierania
        download_button = ToolButton("download")
        download_button.set_tooltip("Przeglądaj testy")
        download_button.connect("clicked", self.list_download)
        self.add_widget(download_button)

        separator2 = gtk.SeparatorToolItem()
        separator2.set_draw(True)
        separator2.set_size_request(50, 25)
        self.add_widget(separator2)

        self.add_widget(gtk.Label("Hasło: "))
        self.pass_entry = gtk.Entry()
        self.pass_entry.set_size_request(100, 25)
        #        self.pass_entry.set_text('123123')
        self.add_widget(self.pass_entry)
Beispiel #59
0
    def __init__(self, activity):        
        gtk.Toolbar.__init__(self)
        self._activity = activity
    
        self._send_button = ToolButton('send-email', tooltip=_('Send email'))
        self._send_button.connect('clicked', self.__send_email_cb)
        self.insert(self._send_button, -1)

        self._attach_button = ToolButton('add-attachment', tooltip=_('Add attachment'))
        self._attach_button.connect('clicked', self.__add_attachment_cb)
        self.insert(self._attach_button, -1)
        
        self.show_all()