Ubuntu Software-Center

From RBOSE
Jump to: navigation, search

The Ubuntu Software Center (or Centre) is an easy way to install/remove applications in Ubuntu.

It gives you instant access to thousands of open-source and carefully selected free applications.

[edit] How to disable the purchase/partner channel in Ubuntu 10.10

Since Maverick you can buy apps in the Software Center too. **No comment**

The Purchase channel, like the Ubuntu Partner channel, is shown even if you did not enable such as repository.

Here is a quick tutorial how to get rid of the Purchase and Ubuntu Partner channel (for Software-Center 3.0.7):

(Note: The Partner channel will (still) appear (again), if you added the partner repo)

0. Close your software center, if you have it open.

1. Open a terminal. Applications menu -> Accessories -> Terminal

2. Type (or copy/paste) the following in the terminal:

gksudo gedit /usr/share/software-center/softwarecenter/backend/channel.py

3. Copy the following code and paste it (replace whole code) in the file:

<syntaxhighlight lang="python">

  1. Copyleft (C) 2010 RBOSE
  2. Codekiller:
  3. DNS (RBOSE.org)
  4. (This is just a little "fix" to disable the purchase channel and to disable
  5. the partner channel (it was shown as default, even if the repo was not enabled).)
  6. Copyright (C) 2010 Canonical
  7. Authors:
  8. Gary Lasker
  9. Michael Vogt
  10. This program is free software; you can redistribute it and/or modify it under
  11. the terms of the GNU General Public License as published by the Free Software
  12. Foundation; version 3.
  13. This program is distributed in the hope that it will be useful, but WITHOUT
  14. ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  15. FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
  16. details.
  17. You should have received a copy of the GNU General Public License along with
  18. this program; if not, write to the Free Software Foundation, Inc.,
  19. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

import apt import glib import gettext import logging import string import urlparse import xapian

from aptsources.sourceslist import SourceEntry, SourcesList

from gettext import gettext as _

from softwarecenter.backend import get_install_backend from softwarecenter.distro import get_distro from softwarecenter.view.widgets.animatedimage import AnimatedImage from softwarecenter.utils import * from softwarecenter.enums import *

LOG = logging.getLogger(__name__)

class ChannelsManager(object):

   def __init__(self, db, icons):
       self.db = db
       self.icons = icons
       self.distro = get_distro()
       self.backend = get_install_backend()
       self.backend.connect("channels-changed", 
                            self._remove_no_longer_needed_extra_channels)
       # kick off a background check for changes that may have been made
       # in the channels list
       glib.timeout_add(300, self._check_for_channel_updates_timer)
       # extra channels from e.g. external sources
       self.extra_channels = []
       self._logger = LOG
   # external API
   @property
   def channels(self):
       """
       return a list of SoftwareChannel objects in display order
       according to:
           Distribution, Partners, PPAs alphabetically, 
           Other channels alphabetically, Unknown channel last
       """
       return self._get_channels()
       
   @property
   def channels_installed_only(self):
       """
       return a list of SoftwareChannel objects displaying installed
       packages only in display order according to:
           Distribution, Partners, PPAs alphabetically, 
           Other channels alphabetically, Unknown channel last
       """
       return self._get_channels(installed_only=True)
   def feed_in_private_sources_list_entries(self, entries):
       added = False
       for entry in entries:
           added |= self._feed_in_private_sources_list_entry(entry)
       if added:
           self.backend.emit("channels-changed", True)
   def add_channel(self, name, icon, query):
       """
       create a channel with the name, icon and query specified and append
       it to the set of channels
       return the new channel object
       """
       # print name, icon, query
       channel = SoftwareChannel(self.icons, name, None, None, 
                                 channel_icon=icon,
                                 channel_query=query)
       self.extra_channels.append(channel)
       self.backend.emit("channels-changed", True)
       if channel.installed_only:
           channel._channel_color = '#aea79f'
           channel._channel_image_id = VIEW_PAGE_INSTALLED
       else:
           channel._channel_color = '#0769BC'
           channel._channel_image_id = VIEW_PAGE_AVAILABLE
       return channel
   # internal
   def _feed_in_private_sources_list_entry(self, source_entry):
       """
       this feeds in a private sources.list entry that is
       available to the user (like a private PPA) that may or
       may not be active 
       """
       # FIXME: strip out password and use apt/auth.conf
       potential_new_entry = SourceEntry(source_entry)
       # look if we have it
       sources = SourcesList()
       for source in sources.list:
           if source == potential_new_entry:
               return False
       # need to add it as a not yet enabled channel
       name = human_readable_name_from_ppa_uri(potential_new_entry.uri)
       # FIXME: use something better than uri as name
       private_channel = SoftwareChannel(self.icons, name, None, None,
                                         source_entry=source_entry)
       private_channel.needs_adding = True
       if private_channel in self.extra_channels:
           return False
       # add it
       self.extra_channels.append(private_channel)
       return True
   def _remove_no_longer_needed_extra_channels(self, backend, res):
       """ go over the extra channels and remove no longer needed ones"""
       removed = False
       for channel in self.extra_channels:
           if not channel._source_entry:
               continue
           sources = SourcesList()
           for source in sources.list:
               if source == SourceEntry(channel._source_entry):
                   self.extra_channels.remove(channel)
                   removed = True
       if removed:
           self.backend.emit("channels-changed", True)
   def _check_for_channel_updates_timer(self):
       """
       run a background timer to see if the a-x-i data we have is 
       still fresh or if the cache has changed since
       """
       if not self.db._aptcache.ready:
           return True
       # see if we need a a-x-i update
       if self._check_for_channel_updates():
           # this will trigger a "channels-changed" signal from
           # the backend object once a-x-i is finished
           self._logger.debug("running update_xapian_index")
           self.backend.update_xapian_index()
       return False
   def _check_for_channel_updates(self):
       """ 
       check current set of channel origins in a-x-i and
       compare it to the apt cache to see if 
       anything has changed, 
       
       returns True is a update is needed
       """
       # the operation get_origins can take some time (~60s?)
       cache_origins = self.db._aptcache.get_origins()
       db_origins = set()
       for channel in self.channels:
           origin = channel.get_channel_origin()
           if origin:
               db_origins.add(origin)
       # origins
       self._logger.debug("cache_origins: %s" % cache_origins)
       self._logger.debug("db_origins: %s" % db_origins)
       if cache_origins != db_origins:
           return True
       return False
   
   def _get_channels(self, installed_only=False):
       """
       (internal) implements 'channels()' and 'channels_installed_only()' properties
       """
       distro_channel_name = self.distro.get_distro_channel_name()
       
       # gather the set of software channels and order them
       other_channel_list = []
       for channel_iter in self.db.xapiandb.allterms("XOL"):
           if len(channel_iter.term) == 3:
               continue
           channel_name = channel_iter.term[3:]
           channel_origin = ""
           
           # get origin information for this channel
           m = self.db.xapiandb.postlist_begin(channel_iter.term)
           doc = self.db.xapiandb.get_document(m.get_docid())
           for term_iter in doc.termlist():
               if term_iter.term.startswith("XOO") and len(term_iter.term) > 3: 
                   channel_origin = term_iter.term[3:]
                   break
           self._logger.debug("channel_name: %s" % channel_name)
           self._logger.debug("channel_origin: %s" % channel_origin)
           other_channel_list.append((channel_name, channel_origin))
       
       dist_channel = None
       partner_channel = None
       #for_purchase_channel = None
       new_apps_channel = None
       ppa_channels = []
       other_channels = []
       unknown_channel = []
       local_channel = None
       
       for (channel_name, channel_origin) in other_channel_list:
           if not channel_name:
               unknown_channel.append(SoftwareChannel(self.icons, 
                                                      channel_name,
                                                      channel_origin,
                                                      None,
                                                      installed_only=installed_only))
           elif channel_name == distro_channel_name:
               dist_channel = (SoftwareChannel(self.icons,
                                               distro_channel_name,
                                               channel_origin,
                                               None,
                                               only_packages_without_applications=True,
                                               installed_only=installed_only))
           elif channel_name == "Partner archive":
               partner_channel = SoftwareChannel(self.icons, 
                                                 channel_name,
                                                 channel_origin,
                                                 "partner", 
                                                 only_packages_without_applications=True,
                                                 installed_only=installed_only)
           elif channel_name == "notdownloadable":
               if installed_only:
                   local_channel = SoftwareChannel(self.icons, 
                                                   channel_name,
                                                   None,
                                                   None,
                                                   installed_only=installed_only)
           elif channel_origin and channel_origin.startswith("LP-PPA"):
               if channel_origin == "LP-PPA-app-review-board":
                   new_apps_channel = SoftwareChannel(self.icons, 
                                                      channel_name,
                                                      channel_origin,
                                                      None,
                                                      installed_only=installed_only)
               else:
                   ppa_channels.append(SoftwareChannel(self.icons, 
                                                       channel_name,
                                                       channel_origin,
                                                       None,
                                                       installed_only=installed_only))
           # TODO: detect generic repository source (e.g., Google, Inc.)
           else:
               other_channels.append(SoftwareChannel(self.icons, 
                                                     channel_name,
                                                     channel_origin,
                                                     None,
                                                     installed_only=installed_only))
       # always display the partner channel, even if its source is not enabled                                                       
       #if not partner_channel:
       #    partner_channel = SoftwareChannel(self.icons, 
       #                                      "Partner archive",
       #                                      "Canonical",
       #                                      "partner", 
       #                                      only_packages_without_applications=True,
       #                                      installed_only=installed_only)
       
       # create a "magic" channel to display items available for purchase                                              
       #for_purchase_query = xapian.Query("AH" + AVAILABLE_FOR_PURCHASE_MAGIC_CHANNEL_NAME)
       #for_purchase_channel = SoftwareChannel(self.icons, 
       #                                       "For Purchase", None, None, 
       #                                       channel_icon=None,   # FIXME:  need an icon
       #                                       channel_query=for_purchase_query)
       
       # set them in order
       channels = []
       if dist_channel is not None:
           channels.append(dist_channel)
       if partner_channel is not None:
           channels.append(partner_channel)
       #channels.append(for_purchase_channel)
       if new_apps_channel is not None:
           channels.append(new_apps_channel)
       channels.extend(ppa_channels)
       channels.extend(other_channels)
       channels.extend(unknown_channel)
       channels.extend(self.extra_channels)
       if local_channel is not None:
           channels.append(local_channel)
       for channel in channels:
           if installed_only:
               channel._channel_color = '#aea79f'
               channel._channel_image_id = VIEW_PAGE_INSTALLED
           else:
               channel._channel_color = '#0769BC'
               channel._channel_image_id = VIEW_PAGE_AVAILABLE
       return channels


class SoftwareChannel(object):

   """
   class to represent a software channel
   """
   
   ICON_SIZE = 24
   
   def __init__(self, icons, channel_name, channel_origin, channel_component,
                only_packages_without_applications=False,
                source_entry=None, installed_only=False,
                channel_icon=None, channel_query=None,
                channel_sort_mode=SORT_BY_ALPHABET):
       """
       configure the software channel object based on channel name,
       origin, and component (the latter for detecting the partner
       channel)
       """
       self._channel_name = channel_name
       self._channel_origin = channel_origin
       self._channel_component = channel_component
       self._channel_color = None
       self._channel_image_id = None
       self.only_packages_without_applications = only_packages_without_applications
       self.installed_only = installed_only
       self.icons = icons
       self._channel_sort_mode = channel_sort_mode
       # distro specific stuff
       self.distro = get_distro()
       # configure the channel
       self._channel_display_name = self._get_display_name_for_channel(channel_name, channel_component)
       if channel_icon is None:
           self._channel_icon = self._get_icon_for_channel(channel_name, channel_origin, channel_component)
       else:
           self._channel_icon = channel_icon
       if channel_query is None:
           self._channel_query = self._get_channel_query_for_channel(channel_name, channel_component)
       else:
           self._channel_query = channel_query
       # a sources.list entry attached to the channel (this is currently
       # only used for not-yet-enabled channels)
       self._source_entry = source_entry
       # when the channel needs to be added to the systems sources.list
       self.needs_adding = False
       
   def get_channel_name(self):
       """
       return the channel name as represented in the xapian database
       """
       return self._channel_name
       
   def get_channel_origin(self):
       """
       return the channel origin as represented in the xapian database
       """
       return self._channel_origin
       
   def get_channel_component(self):
       """
       return the channel component as represented in the xapian database
       """
       return self._channel_component
      
   def get_channel_display_name(self):
       """
       return the display name for the corresponding channel for use in the UI
       """
       return self._channel_display_name
       
   def get_channel_icon(self):
       """
       return the icon that corresponds to each channel based
       on the channel name, its origin string or its component
       """
       return self._channel_icon
   def get_channel_query(self):
       """
       return the xapian query to be used with this software channel
       """
       return self._channel_query
       
   def get_channel_sort_mode(self):
       """
       return the sort mode for this software channel
       """
       return self._channel_sort_mode
       
   # TODO:  implement __cmp__ so that sort for channels is encapsulated
   #        here as well
   
   def _get_display_name_for_channel(self, channel_name, channel_component):
       if channel_component == "partner":
           channel_display_name = _("Canonical Partners")
       elif not channel_name:
           channel_display_name = _("Unknown")
       elif channel_name == self.distro.get_distro_channel_name():
           channel_display_name = self.distro.get_distro_channel_description()
       elif channel_name == "For Purchase":
           channel_display_name = _("For Purchase")
       elif channel_name == "Application Review Board PPA":
           channel_display_name = _("Independent")
       elif channel_name == "notdownloadable":
           channel_display_name = _("Other")
       else:
           return channel_name
       return channel_display_name
   
   def _get_icon_for_channel(self, channel_name, channel_origin, channel_component):
       if channel_component == "partner":
           channel_icon = self._get_icon("partner")
       elif not channel_name:
           channel_icon = self._get_icon("unknown-channel")
       elif channel_name == self.distro.get_distro_channel_name():
           channel_icon = self._get_icon("distributor-logo")
       elif channel_name == "Application Review Board PPA":
           channel_icon = self._get_icon("system-users")
       elif channel_name == "For Purchase":
           channel_icon = self._get_icon("emblem-money")
       elif channel_origin and channel_origin.startswith("LP-PPA"):
           channel_icon = self._get_icon("ppa")
       elif channel_name == "notdownloadable":
           channel_icon = self._get_icon("application-default-icon")
       # TODO: add check for generic repository source (e.g., Google, Inc.)
       #       self._get_icon("generic-repository")
       else:
           channel_icon = self._get_icon("unknown-channel")
       return channel_icon
   
   def _get_channel_query_for_channel(self, channel_name, channel_component):
   
       if channel_component == "partner":
           q1 = xapian.Query("XOCpartner")
           q2 = xapian.Query("AH%s-partner" % self.distro.get_codename())
           channel_query = xapian.Query(xapian.Query.OP_OR, q1, q2)
       # show only apps when displaying the new apps archive
       elif channel_name == "Application Review Board PPA":
           channel_query = xapian.Query(xapian.Query.OP_AND, 
                                        xapian.Query("XOL" + channel_name),
                                        xapian.Query("ATapplication"))
       # uncomment the following to limit the distro channel contents to only applications
  1. elif channel_name == self.distro.get_distro_channel_name():
  2. channel_query = xapian.Query(xapian.Query.OP_AND,
  3. xapian.Query("XOL" + channel_name),
  4. xapian.Query("ATapplication"))
       else:
           channel_query = xapian.Query("XOL" + channel_name)
       return channel_query
   def _get_icon(self, icon_name):
       if self.icons.lookup_icon(icon_name, self.ICON_SIZE, 0):
           icon = AnimatedImage(self.icons.load_icon(icon_name, self.ICON_SIZE, 0))
       else:
           # icon not present in theme, probably because running uninstalled
           icon = AnimatedImage(self.icons.load_icon("gtk-missing-image", 
                                                     self.ICON_SIZE, 0))
       return icon
       
   def __str__(self):
       details = []
       details.append("* SoftwareChannel")
       details.append("  get_channel_name(): %s" % self.get_channel_name())
       details.append("  get_channel_origin(): %s" % self.get_channel_origin())
       details.append("  get_channel_component(): %s" % self.get_channel_component())
       details.append("  get_channel_display_name(): %s" % self.get_channel_display_name())
       details.append("  get_channel_icon(): %s" % self.get_channel_icon())
       details.append("  get_channel_query(): %s" % self.get_channel_query())
       details.append("  get_channel_sort_mode(): %s" % self.get_channel_sort_mode())
       details.append("  only_packages_without_applications: %s" % self.only_packages_without_applications)
       details.append("  installed_only: %s" % self.installed_only)
       return '\n'.join(details)
       

if __name__ == "__main__":

   import gtk
   from softwarecenter.enums import *
   icons = gtk.icon_theme_get_default()
   icons.append_search_path(ICON_PATH)
   icons.append_search_path(SOFTWARE_CENTER_ICON_PATH)
   distro = get_distro()
   channel = SoftwareChannel(icons, distro.get_distro_channel_name(), 
                             None, None, only_packages_without_applications=True)
   print channel
   channel = SoftwareChannel(icons, distro.get_distro_channel_name(), None, "partner")
   print channel

</syntaxhighlight>

4. Save the file.

Done, thats all. ;-)

Personal tools
Category Cloud
Projects
About RBOSE