示例#1
0
def switch_to_detail_page(page_switcher, detail_page, pkg_name):
    log("start switch to detail_page")
    page_switcher.slide_to_page(detail_page, "right")
    # ThreadMethod(detail_page.update_pkg_info, (pkg_name,)).start()
    detail_page.update_pkg_info(pkg_name)
    log("end switch to detail_page")
    global_event.emit("update-current-status-pkg-page", detail_page)
    def button_press(self, column, offset_x, offset_y):
        # init Loading widget
        loading_box = LoadingBox()

        global_event.emit("show-pkg-view", loading_box)

        self.page_box = gtk.VBox()    
            
        self.all_pkg_names = self.data_manager.get_second_category_packages(self.second_category_name)
        self.message_bar = MessageBar(18)
        self.message_bar.set_message(_("%s > %s : %s applications") % (
                get_category_name(self.first_category_name), 
                get_category_name(self.second_category_name), 
                len(self.all_pkg_names),
                ))
        
        self.pkg_icon_view = IconView() 
        self.pkg_icon_view.connect("motion-notify-item", tooltip_aciton)
        if len(self.all_pkg_names) > LOAD_ITEMS_NUMBER:
            self.load_new_items(self.all_pkg_names[:LOAD_ITEMS_NUMBER])
        else:
            self.load_new_items(self.all_pkg_names)

        self.pkg_icon_scrolled_window = ScrolledWindow()
        self.pkg_icon_scrolled_window.connect("vscrollbar-state-changed", self.scrolled_window_vscrollbar_handler)
        self.pkg_icon_scrolled_window.add_child(self.pkg_icon_view)
        self.pkg_icon_view.draw_mask = self.draw_mask
        self.pkg_icon_view.draw_row_mask = self.draw_row_mask
        
        self.page_box.pack_start(self.message_bar, False, False)
        self.page_box.pack_start(self.pkg_icon_scrolled_window, True, True)
        
        global_event.emit("update-current-status-pkg-page", self.pkg_icon_view)
示例#3
0
    def fetch_screenshot(self):
        screenshot_dir = os.path.join(SCREENSHOT_DOWNLOAD_DIR, self.pkg_name)
        screenshot_md5_path = os.path.join(screenshot_dir, "screenshot_md5.txt")
        remote_screenshot_md5_url = "%s/zh_CN/%s/screenshot_md5.txt" % (SCREENSHOT_HOST, self.pkg_name)
        remote_screenshot_zip_url = "%s/zh_CN/%s/screenshot.zip" % (SCREENSHOT_HOST, self.pkg_name)
        try:
            remote_md5 = urllib2.urlopen(remote_screenshot_md5_url).read()
            need_download = False

            if os.path.exists(screenshot_dir):
                if os.path.exists(screenshot_md5_path):
                    local_md5 = read_file(screenshot_md5_path)
                    if remote_md5 != local_md5:
                        need_download = True
                else:
                    need_download = True
            else:
                need_download = True

            if need_download:
                write_file(screenshot_md5_path, remote_md5, True)

                try:
                    urllib.urlretrieve(remote_screenshot_zip_url,
                                       os.path.join(SCREENSHOT_DOWNLOAD_DIR, self.pkg_name, "screenshot.zip")
                                       )
                    global_event.emit("download-screenshot-finish", self.pkg_name)
                except Exception, e:
                    global_logger.logerror("Download screenshot error: %s" % e)
        except Exception, e:
            global_logger.logerror("fetch_screenshot got error: %s" % e)
示例#4
0
    def icon_item_button_press(self, x, y):
        '''
        Handle button-press event.

        This is IconView interface, you should implement it.
        '''
        global_event.emit("switch-to-album-detail-view", self.album_info)
    def click_rank_tab(self, tab_index):
        if self.tab_index != tab_index:
            self.active_flag = False
        elif not self.active_flag:
            self.active_flag = True

            global_event.emit("update-rank-page", self.tab_index)
示例#6
0
def tooltip_aciton(view, item, x, y):
    if item.is_in_name_area(x, y):
        new_cursor_postion = "name"
    else:
        new_cursor_postion = "other"

    global_event.emit("cursor-position-changed", item, new_cursor_postion)
    def status_change(self, pkg, percent, status):
        """Called when the status changed.

        Emits: action-update(status, percent)
        """
        self.time_last_update = time.time()
        global_event.emit("action-update", (self.upgrade_id, self.action_type, int(percent), status))
示例#8
0
    def icon_item_button_press(self, x, y):
        '''
        Handle button-press event.

        This is IconView interface, you should implement it.
        '''
        global_event.emit("switch-to-album-detail-view", self.album_info)
 def handle_pkg_status(self, *reply):
     container_remove_all(self.left_action_box)
     install_status = reply
     if install_status[0][0]:
         if not self.data_manager.get_pkg_desktop_info(self.pkg_name):
             status_label = Label(_("Successfully installed"))
             self.left_action_box.pack_start(status_label)
         else:
             action_button = ImageButton(
                 app_theme.get_pixbuf("button/start_normal.png"),
                 app_theme.get_pixbuf("button/start_hover.png"),
                 app_theme.get_pixbuf("button/start_press.png"),
                 )
             action_button.connect("button-press-event", self.button_press_start_button)
             self.left_action_box.pack_start(action_button)
     else:
         action_button = ImageButton(
             app_theme.get_pixbuf("button/install_normal.png"),
             app_theme.get_pixbuf("button/install_hover.png"),
             app_theme.get_pixbuf("button/install_press.png"),
             )
         action_button.connect("clicked", lambda w: global_event.emit("install-pkg", [self.pkg_name]))
         self.left_action_box.pack_start(action_button)
     self.left_action_box.show_all()
     global_event.emit('update-current-status-pkg-page', self)
 def handle_pkg_status(self, reply, success):
     container_remove_all(self.left_action_box)
     if success:
         install_status = str(reply)
         print install_status
         if install_status == "installed":
             if not self.data_manager.get_pkg_desktop_info(self.pkg_name):
                 status_label = Label(_("Successfully installed"))
                 self.left_action_box.pack_start(status_label)
             else:
                 action_button = ImageButton(
                     app_theme.get_pixbuf("button/start_normal.png"),
                     app_theme.get_pixbuf("button/start_hover.png"),
                     app_theme.get_pixbuf("button/start_press.png"),
                     )
                 action_button.connect("button-press-event", self.button_press_start_button)
                 self.left_action_box.pack_start(action_button)
         elif install_status == "unknown":
             status_label = Label(_("Not found"))
             self.left_action_box.pack_start(status_label)
         else:
             action_button = ImageButton(
                 app_theme.get_pixbuf("button/install_normal.png"),
                 app_theme.get_pixbuf("button/install_hover.png"),
                 app_theme.get_pixbuf("button/install_press.png"),
                 )
             action_button.connect("clicked", lambda w: global_event.emit("install-pkg", [self.pkg_name]))
             self.left_action_box.pack_start(action_button)
         self.left_action_box.show_all()
         global_event.emit('update-current-status-pkg-page', self)
     else:
         global_logger.logerror("get_pkg_installed handle_dbus_error")
         global_logger.logerror(reply)
    def click_rank_tab(self, tab_index):
        if self.tab_index != tab_index:
            self.active_flag = False
        elif not self.active_flag:
            self.active_flag = True

            global_event.emit("update-rank-page", self.tab_index)
示例#12
0
 def button_press_start_button(self, widget, event, desktops):
     pixbuf = app_theme.get_pixbuf("button/start_normal.png").get_pixbuf()
     desktop_infos = self.data_manager.get_pkg_desktop_info(desktops)
     global_event.emit("start-pkg",
                       self.alias_name,
                       desktop_infos,
                       (int(event.x), int(event.y), pixbuf.get_width() / 2, 0))
def tooltip_aciton(view, item, x, y):
    if item.is_in_name_area(x, y):
        new_cursor_postion = "name"
    else:
        new_cursor_postion = "other"

    global_event.emit("cursor-position-changed", item, new_cursor_postion)
示例#14
0
    def icon_item_double_click(self, x, y):
        '''
        Handle double click event.

        This is IconView interface, you should implement it.
        '''
        global_event.emit("switch-to-detail-page", self.info[0])
 def load_new_items(self, pkg_names):
     items = []
     for pkg_name in pkg_names:
         info = self.data_manager.get_item_pkg_info(pkg_name)
         items.append(PkgIconItem(info[0], info[1], info[2], self.data_manager))
     self.pkg_icon_view.add_items(items)
     global_event.emit("show-pkg-view", self.page_box)
 def icon_item_button_press(self, x, y):
     '''
     Handle button-press event.
     
     This is IconView interface, you should implement it.
     '''
     global_event.emit("start-desktop", self.pkg_name, self.desktop_path)
示例#17
0
    def update_home_page(self, data):

        if not data:
            self.check_network_connection()
            return

        slide_infos = sort_for_home_page_data(data['slide'])
        self.slider_switcher = IndexSlideSwitcher(slide_infos)
        self.slider_switcher.connect(
            "motion-notify-index",
            lambda w, i: global_event.emit("set-cursor", gtk.gdk.HAND2))
        self.slider_switcher.connect(
            "button-press-index", lambda w, i: global_event.emit(
                "switch-to-detail-page", slide_infos[i][0]))
        self.slider_switcher.connect(
            "leave-notify-index",
            lambda w, i: global_event.emit("set-cursor", None))

        self.recommend_infos = sort_for_home_page_data(data['recommend'])
        self.tab_switcher = TabSwitcher(
            [_("Recommendations"),
             _("HotApps"),
             _("Download rank")], CATEGORY_ITEM_NAME_SIZE)
        self.tab_switcher_align = gtk.Alignment()
        self.tab_switcher_align.set(0.5, 0.5, 1, 1)
        self.tab_switcher_align.set_padding(10, 0, 0, 9)
        self.tab_switcher_align.add(self.tab_switcher)
        self.tab_switcher_pages_callback = [
            "get_pkg_icon_view_page",
            "get_album_page",
            "get_download_rank_page",
        ]

        self.page_box = gtk.VBox()
        self.box.pack_start(self.slider_switcher, False, False)
        self.box.pack_start(self.tab_switcher_align, False, False)

        self.box_align = gtk.Alignment()
        self.box_align.set(0.5, 0.5, 1, 1)
        self.box_align.set_padding(5, 0, 10, 11)
        self.box_align.add(self.box)

        self.page_box_align = gtk.Alignment()
        self.page_box_align.set(0.5, 0, 1, 1)
        self.page_box_align.add(self.page_box)

        self.background_box.pack_start(self.box_align, False, False)
        self.background_box.pack_start(self.page_box_align)

        self.recommend_scrolled_window.add_child(self.background_box)
        self.switch_page(0)

        self.tab_switcher.connect(
            "tab-switch-start",
            lambda switcher, page_index: self.switch_page(page_index))
        self.tab_switcher.connect(
            "click-current-tab",
            lambda switcher, page_index: self.click_page())
        self.switch_page_view(self.recommend_scrolled_window)
        self.recommend_scrolled_window_initial = True
示例#18
0
 def clean_download_cache_reply(obj, result):
     num, size = result
     if num != 0:
         message = _("You have cleared up %s packages and saved %s of space.") % (num, bit_to_human_str(size))
     else:
         message = _("Your system cache is empty.")
     global_event.emit("show-message", message, 5000)
    def get_pkgs_status(self):
        if self.show_flag:
            infos = self.data_manager.get_download_rank_info(self.pkg_names)

            if len(infos) > 25:
                infos = infos[:25]

            valid_pkg_names = []
            for info in infos:
                valid_pkg_names.append(info[0])

            view = self.view_list[self.current_page_index][1]
            view.clear()
            container_remove_all(self.page_align)

            items = []
            for i in range(len(infos)):
                items.append(PkgIconItem(self.data_manager, *infos[i]))
            view.add_items(items)
            self.page_align.add(self.view_list[self.current_page_index][2])
            global_event.emit("update-current-status-pkg-page", view)
            self.show_all()

            self.show_flag = None
        return True
示例#20
0
 def filter_uninstall_pkg_infos(self, uninstall_pkg_infos):
     pkg_infos = []
     for pkg_info in uninstall_pkg_infos:
         pkg_name, pkg_version = pkg_info
         if self.is_uninstallable_kernel(pkg_name) or \
             self.data_manager.is_pkg_display_in_uninstall_page(pkg_name):
             pkg_infos.append((pkg_name, pkg_version))
     global_event.emit("uninstall-items-filtered", pkg_infos)
 def filter_uninstall_pkg_infos(self, uninstall_pkg_infos):
     pkg_infos = []
     for pkg_info in uninstall_pkg_infos:
         pkg_name, pkg_version = pkg_info
         if self.is_uninstallable_kernel(pkg_name) or \
             self.data_manager.is_pkg_display_in_uninstall_page(pkg_name):
                 pkg_infos.append((pkg_name, pkg_version))
     global_event.emit("uninstall-items-filtered", pkg_infos)
    def error(self, pkg, errormsg):
        """Called when an error happens.

        Emits: action-error()
        """
        global_event.emit("action-error", (pkg, errormsg))
        global_event.emit("action-failed", (pkg, ACTION_UPGRADE, [], str(errormsg)))
        log("error: %s" % errormsg)
示例#23
0
    def expand(self):
        self.is_expand = True

        self.add_child_item()

        if self.redraw_request_callback:
            self.redraw_request_callback(self)
        global_event.emit("category-expand", self)
示例#24
0
    def download_parse_failed(self):
        self.status = self.STATUS_PARSE_DOWNLOAD_FAILED
        self.status_text = _("Dependencies analysis failed")

        if self.redraw_request_callback:
            self.redraw_request_callback(self)

        global_event.emit("request-clear-failed-action", self.pkg_name, ACTION_INSTALL)
 def load_items_reply_handler(self, status, pkg_infos):
     items = []
     for (index, (pkg_name, short_desc, star, alias_name)) in enumerate(pkg_infos):
         if short_desc != None:
             items.append(PkgIconItem(status[index], alias_name, pkg_name, short_desc, star, self.all_desktop_infos[pkg_name]))
     self.pkg_icon_view.add_items(items)
     
     global_event.emit("show-pkg-view", self.page_box)
示例#26
0
 def load_new_items(self, pkg_names):
     items = []
     for pkg_name in pkg_names:
         info = self.data_manager.get_item_pkg_info(pkg_name)
         items.append(
             PkgIconItem(info[0], info[1], info[2], self.data_manager))
     self.pkg_icon_view.add_items(items)
     global_event.emit("show-pkg-view", self.page_box)
 def expand(self):
     self.is_expand = True
     
     self.add_child_item()
         
     if self.redraw_request_callback:
         self.redraw_request_callback(self)
     global_event.emit("category-expand", self)
示例#28
0
 def uninstall_pkg_from_desktop_thread(self, path, purge):
     pkg_name = self.get_pkg_name_from_path(path)
     if pkg_name:
         self.uninstall_pkg(pkg_name, purge)
     else:
         global_event.emit("action-failed",
                           (path, ACTION_UNINSTALL, [],
                            "no package found for path: %s" % path))
    def __init__(self, data_manager):
        # Init.
        gtk.VBox.__init__(self)
        self.data_manager = data_manager

        self.tab_box = gtk.HBox()
        self.tab_box.set_size_request(-1, RANK_TAB_HEIGHT)
        self.tab_box.set_spacing(1)
        self.tab_box_align = gtk.Alignment()
        self.tab_box_align.set(1, 0, 0, 0)
        self.tab_box_align.set_padding(3, 9, 25, 48)
        for (tab_index, tab_name) in enumerate([_("Top 25 weekly"), _("Top 25 monthly"), _("Top 25 totally")]):
            self.tab_box.pack_start(RankTab(tab_index, tab_name, tab_index == 0), False, False)

        self.page_box = gtk.VBox()
        self.page_align = gtk.Alignment()
        self.page_align.set(0.5, 0.5, 1, 1)
        self.page_align.set_padding(0, 0, 15, 15)

        self.week_rank_icon_view = IconView()
        self.week_rank_icon_view_scrlledwindow = ScrolledWindow()
        self.week_rank_icon_view.draw_mask = self.draw_mask

        self.month_rank_icon_view = IconView()
        self.month_rank_icon_view_scrlledwindow = ScrolledWindow()
        self.month_rank_icon_view.draw_mask = self.draw_mask

        self.all_rank_icon_view = IconView()
        self.all_rank_icon_view_scrlledwindow = ScrolledWindow()
        self.all_rank_icon_view.draw_mask = self.draw_mask

        self.week_rank_icon_view_scrlledwindow.add_child(self.week_rank_icon_view)
        self.month_rank_icon_view_scrlledwindow.add_child(self.month_rank_icon_view)
        self.all_rank_icon_view_scrlledwindow.add_child(self.all_rank_icon_view)

        self.tab_box_align.add(self.tab_box)
        self.page_box.pack_start(self.page_align)

        self.pack_start(self.tab_box_align, False, False)
        self.pack_start(self.page_box, True, True)

        self.loading = LoadingBox()

        self.view_list =  [
            ('week', self.week_rank_icon_view, self.week_rank_icon_view_scrlledwindow),
            ('month', self.month_rank_icon_view, self.month_rank_icon_view_scrlledwindow),
            ('all', self.all_rank_icon_view, self.all_rank_icon_view_scrlledwindow)]

        self.pkg_names = []

        self.show_flag = None
        self.all_show_flag = ['week', 'month', 'all']

        global_event.register_event("update-rank-page", self.update_rank_page)

        gtk.timeout_add(300, self.get_pkgs_status)

        global_event.emit("update-rank-page", 0)
 def update_message_bar(self, treeview):
     if len(treeview.visible_items) > 0:
         self.message_bar.set_message(_("%s: %s matched applications") % (' '.join(self.keywords), len(self.all_pkg_names)))
         container_remove_all(self)
         self.pack_start(self.content_box)
         global_event.emit("update-current-status-pkg-page", treeview)
     else:
         container_remove_all(self)
         self.pack_start(self.cute_message_image)
    def update_interface(self):
        """Called periodically to update the interface.

        Emits: action-timeout() [When a timeout happens]
        """
        #print "update_interface >>", self.time_last_update
        apb.InstallProgress.update_interface(self)
        if self.time_last_update + self.INSTALL_TIMEOUT < time.time():
            global_event.emit("action-timeout")
示例#32
0
    def download_parse_failed(self):
        self.status = self.STATUS_PARSE_DOWNLOAD_FAILED
        self.status_text = _("Dependencies analysis failed")

        if self.redraw_request_callback:
            self.redraw_request_callback(self)

        global_event.emit("request-clear-failed-action", self.pkg_name,
                          ACTION_INSTALL)
示例#33
0
 def change_to_nearest_mirror_thread(self, widget):
     from mirror_speed.ip_detect import get_nearest_mirrors
     hostnames = get_nearest_mirrors()
     self.mirror_test_obj = MirrorTest(hostnames)
     hostname = self.mirror_test_obj.run()
     for mirror in self.mirrors_list:
         if mirror.hostname == hostname:
             global_event.emit("mirror-test-finished", mirror)
             break
示例#34
0
 def change_download_save_dir(self, widget):
     local_dir = FolderChooseDialog(False).run()
     if local_dir:
         local_dir = os.path.expanduser(local_dir)
         if local_dir != get_software_download_dir():
             self.dir_entry.set_editable(True)
             self.dir_entry.set_text(local_dir)
             self.dir_entry.set_editable(False)
             set_software_download_dir(local_dir)
             global_event.emit('download-directory-changed')
示例#35
0
 def change_download_save_dir(self, widget):
     local_dir = FolderChooseDialog(False).run()
     if local_dir:
         local_dir = os.path.expanduser(local_dir)
         if local_dir != get_software_download_dir():
             self.dir_entry.set_editable(True)
             self.dir_entry.set_text(local_dir)
             self.dir_entry.set_editable(False)
             set_software_download_dir(local_dir)
             global_event.emit('download-directory-changed')
示例#36
0
    def dist_upgrade(self):
        action_type = ACTION_UPGRADE
        action_id = '%s_%s' % (self.get_unique_id(), action_type)
        self.update_signal([(
            "ready-download-start", (action_id, action_type))])

        dist_upgrade_changes = self.pkg_cache.get_dist_upgrade_changes()
        # detect and prevent the system components from being uninstalled
        pkg_in_white_list = []
        download_pkgs = []
        self.all_upgrade_pkg_names = []
        for pkg in dist_upgrade_changes["delete"]:
            name = pkg.name
            if name in SYS_PKG_WHITE_LIST:
                pkg_in_white_list.append(name)
        if len(pkg_in_white_list) > 0:
            self.update_signal([(
                "remove-pkgs-in-white-list",
                (json.dumps(pkg_in_white_list), action_type))])
            logger.error("found remove system packages: %s" %
                json.dumps(pkg_in_white_list))
        else:
            for status in dist_upgrade_changes:
                for pkg in dist_upgrade_changes[status]:
                    self.all_upgrade_pkg_names.append(pkg.name)
                    if status == "delete" or status == "keep":
                        continue
                    if not parse_pkg.pkg_file_has_exist(pkg):
                        download_pkgs.append(pkg)

            self.update_signal([("ready-download-finish", (action_id, action_type))])
            if len(download_pkgs) == 0:
                global_event.emit("download-finish", action_id, action_type,
                        self.all_upgrade_pkg_names)
            else:
                names = []
                download_urls = []
                download_hash_infos = []
                pkg_sizes = []
                for pkg in download_pkgs:
                    names.append(pkg.name)
                    download_urls.append(pkg.candidate.uri)
                    download_hash_infos.append(pkg.candidate.md5)
                    pkg_sizes.append(pkg.candidate.size)
                self.download_manager.add_download(
                    action_id,
                    action_type,
                    download_urls,
                    download_sizes=pkg_sizes,
                    download_md5s=download_hash_infos,
                    all_task_names=names,
                    all_change_pkgs=self.all_upgrade_pkg_names,
                    file_save_dir=self.download_dir
                    )
示例#37
0
 def update_message_bar(self, treeview):
     if len(treeview.visible_items) > 0:
         self.message_bar.set_message(
                 " ".join(self.keywords) + ": " +
                 _("%s applications searched") % len(self.all_pkg_names))
         container_remove_all(self)
         self.pack_start(self.content_box)
         global_event.emit("update-current-status-pkg-page", treeview)
     else:
         container_remove_all(self)
         self.pack_start(self.cute_message_image)
 def icon_item_button_press(self, x, y):
     '''
     Handle button-press event.
     
     This is IconView interface, you should implement it.
     '''
     try:
         self.desktop_info.launch()
         global_event.emit("show-message", _("%s: request for starting applications sent") % self.desktop_display_name, 5000)
     except:
         logging.error("Launch error: %s" % self.desktop_info)
示例#39
0
    def update_item(self, data):
        items = []
        if data:
            for album_info in data:
                items.append(AlbumSummaryItem(album_info))

            items.sort(key=attrgetter('album_order'), reverse=True)
            self.iconview.add_items(items)
            global_event.emit('switch-to-album-summary-view')
        else:
            global_event.emit('switch-to-network-problem-view')
示例#40
0
    def dist_upgrade(self):
        action_type = ACTION_UPGRADE
        action_id = '%s_%s' % (self.get_unique_id(), action_type)
        self.update_signal([("ready-download-start", (action_id, action_type))
                            ])

        dist_upgrade_changes = self.pkg_cache.get_dist_upgrade_changes()
        # detect and prevent the system components from being uninstalled
        pkg_in_white_list = []
        download_pkgs = []
        self.all_upgrade_pkg_names = []
        for pkg in dist_upgrade_changes["delete"]:
            name = pkg.name
            if name in SYS_PKG_WHITE_LIST:
                pkg_in_white_list.append(name)
        if len(pkg_in_white_list) > 0:
            self.update_signal([("remove-pkgs-in-white-list",
                                 (json.dumps(pkg_in_white_list), action_type))
                                ])
            logger.error("found remove system packages: %s" %
                         json.dumps(pkg_in_white_list))
        else:
            for status in dist_upgrade_changes:
                for pkg in dist_upgrade_changes[status]:
                    self.all_upgrade_pkg_names.append(pkg.name)
                    if status == "delete" or status == "keep":
                        continue
                    if not parse_pkg.pkg_file_has_exist(pkg):
                        download_pkgs.append(pkg)

            self.update_signal([("ready-download-finish", (action_id,
                                                           action_type))])
            if len(download_pkgs) == 0:
                global_event.emit("download-finish", action_id, action_type,
                                  self.all_upgrade_pkg_names)
            else:
                names = []
                download_urls = []
                download_hash_infos = []
                pkg_sizes = []
                for pkg in download_pkgs:
                    names.append(pkg.name)
                    download_urls.append(pkg.candidate.uri)
                    download_hash_infos.append(pkg.candidate.md5)
                    pkg_sizes.append(pkg.candidate.size)
                self.download_manager.add_download(
                    action_id,
                    action_type,
                    download_urls,
                    download_sizes=pkg_sizes,
                    download_md5s=download_hash_infos,
                    all_task_names=names,
                    all_change_pkgs=self.all_upgrade_pkg_names,
                    file_save_dir=self.download_dir)
示例#41
0
    def update_item(self, data):
        items = []
        if data:
            for album_info in data:
                items.append(AlbumSummaryItem(album_info))

            items.sort(key=attrgetter('album_order'), reverse=True)
            self.iconview.add_items(items)
            global_event.emit('switch-to-album-summary-view')
        else:
            global_event.emit('switch-to-network-problem-view')
示例#42
0
    def switch_to_album_detail_view(self, album_info):
        self.in_detail_view = True

        container_remove_all(self)
        container_remove_all(self.album_detail_align)
        album_detail_page = AlbumDetailPage(self.data_manager, album_info)
        self.album_detail_align.add(album_detail_page)

        self.pack_start(self.album_detail_align, True, True)

        self.show_all()
        global_event.emit("update-current-status-pkg-page", album_detail_page.treeview)
示例#43
0
 def run(self):
     url = "%sgame/analytics/?type=star&appid=%s&mark=%s" % (GAME_CENTER_SERVER_ADDRESS, self.appid, self.star)
     try:
         js = urllib2.urlopen(url).read()
         if js:
             js = json.loads(js)
             if js['status'] == 'OK':
                 global_event.emit('set-star-score-success', js)
             else:
                 print "Star error"
                 print js
     except Exception, e:
         print 'SetStarScore Error:', e
 def run(self):
     url = "%sgame/analytics/?type=star&appid=%s&mark=%s" % (GAME_CENTER_SERVER_ADDRESS, self.appid, self.star)
     try:
         js = urllib2.urlopen(url).read()
         if js:
             js = json.loads(js)
             if js['status'] == 'OK':
                 global_event.emit('set-star-score-success', js)
             else:
                 print "Star error"
                 print js
     except Exception, e:
         print 'SetStarScore Error:', e
示例#45
0
    def switch_to_album_detail_view(self, album_info):
        self.in_detail_view = True

        container_remove_all(self)
        container_remove_all(self.album_detail_align)
        album_detail_page = AlbumDetailPage(self.data_manager, album_info)
        self.album_detail_align.add(album_detail_page)

        self.pack_start(self.album_detail_align, True, True)

        self.show_all()
        global_event.emit("update-current-status-pkg-page",
                          album_detail_page.treeview)
    def icon_item_button_press(self, x, y):
        '''
        Handle button-press event.

        This is IconView interface, you should implement it.
        '''
        try:
            self.desktop_info.launch()
            global_event.emit(
                "show-message",
                _("%s: request for starting applications sent") %
                self.desktop_display_name, 5000)
        except:
            logging.error("Launch error: %s" % self.desktop_info)
示例#47
0
 def run(self):
     '''Run'''
     try:
         args = {'n' : self.name, 'm' : self.vote}
         js = urllib2.urlopen(
             "%s/softcenter/v1/mark?%s" % (SERVER_ADDRESS, urllib.urlencode(args)),
             timeout=POST_TIMEOUT
             ).read()
         js = json.loads(js)
         global_event.emit('vote-send-success', (self.name, self.obj, js))
     except Exception, e:
         global_event.emit('vote-send-failed', self.name)
         traceback.print_exc(file=sys.stdout)
         print "SendVote Error: ", e
 def download_json_info(self, appid):
     info_json_url = "%sgame/info/%s" % (GAME_CENTER_SERVER_ADDRESS, appid)
     try:
         js = urllib2.urlopen(info_json_url).read()
         if js:
             info = json.loads(js)
             json.dump(info, open(self.desc_info_path, 'wb'))
             self.finish_fetch_info(info['index_pic_url'])
             global_event.emit('download-app-info-finish', json.dumps(info))
     except Exception, e:
         traceback.print_exc(sys.stdout)
         print "Error msg:", e
         if os.path.exists(self.desc_info_path):
             info = json.load(open(self.desc_info_path))
             global_event.emit('download-app-info-finish', json.dumps(info))
示例#49
0
 def handle_pkg_status(self, status, success):
     if success:
         self.install_status= str(status)
         if self.install_status == "unknown":
             global_event.emit("delete-search-page-items", [self])
         else:
             try:
                 self.desktops = json.loads(self.install_status)
                 self.desktops = self.data_manager.get_pkg_desktop_info(self.desktops)
             except:
                 pass
             self.emit_redraw_request()
     else:
         utils.global_logger.error("%s: get_pkg_installed handle_dbus_error" % self.pkg_name)
         utils.global_logger.error(status)
示例#50
0
class FetchAlbumData(td.Thread):

    def __init__(self, language, status="publish"):
        td.Thread.__init__(self)
        self.language = language
        self.album_data_url = BAIDU_SERVER_ADDRESS + "album/"
        self.data = {
                'hl': language if language != 'zh_HK' else 'zh_TW',
                'status': status_modes.get(status),
                }
        self.setDaemon(True)

    def run(self):
        json_data = None
        try:
            query = urllib.urlencode(self.data)
            request_url = ("%s?%s") % (self.album_data_url, query)
            connection = urllib2.urlopen(
                request_url,
                timeout=POST_TIMEOUT,
            )
            json_data = json.loads(connection.read())
        except Exception, e:
            traceback.print_exc(file=sys.stdout)
            print "Fetch album data failed: %s." % (e)
        global_event.emit("download-album-infos-finish", json_data)
示例#51
0
 def run(self):
     try:
         filename = utils.generate_log_tar()
         o_name, ext = os.path.splitext(filename)
         dt_now = datetime.now()
         folder = dt_now.strftime("/files/%Y/%m/%d/")
         name = "%s_%s%s" % (dt_now.strftime("%Y%m%d%H%M%S"), uuid.uuid4().hex, ext)
         up_path = os.path.join(folder, name)
         bcs_obj = bucket.object(up_path)
         with open(filename) as fp:
             bcs_obj.put(fp.read())
         global_event.emit('upload-error-log-success')
         print "Upload Error Log Success"
     except Exception, e:
         print "Upload Error Log Failed: %s" % e
         global_event.emit("upload-error-log-failed", e)
示例#52
0
class FetchHomeData(td.Thread):

    def __init__(self, language, status="publish"):
        td.Thread.__init__(self)
        self.language = language
        self.home_data_url = BAIDU_SERVER_ADDRESS + "home/"
        self.data = {
                'hl': language if language != 'zh_HK' else 'zh_TW',
                'status': status_modes.get(status),
                }
        self.setDaemon(True)

    def run(self):
        json_data = {}
        query = urllib.urlencode(self.data)
        request_url = ("%s?%s") % (self.home_data_url, query)
        try:
            connection = urllib2.urlopen(
                request_url,
                timeout=POST_TIMEOUT,
            )
            json_data = json.loads(connection.read())
            touch_file(HOME_CACHE_DATA_PATH)
            with open(HOME_CACHE_DATA_PATH, "wb") as fp:
                json.dump(json_data, fp)
        except Exception, e:
            traceback.print_exc(file=sys.stdout)
            print "Fetch home data failed: %s." % (e)
            print "url:", request_url
            if os.path.exists(HOME_CACHE_DATA_PATH):
                with open(HOME_CACHE_DATA_PATH) as fp:
                    json_data = json.load(fp)
        global_event.emit("download-home-infos-finish", json_data)
示例#53
0
    def __init__(self, bus_interface, data_manager):
        '''
        init docs
        '''
        # Init.
        gtk.VBox.__init__(self)
        self.bus_interface = bus_interface
        self.data_manager = data_manager

        self.message_bar = MessageBar(32)
        self.message_box = gtk.HBox()

        self.treeview = TreeView(enable_drag_drop=False)
        self.treeview.set_expand_column(0)
        self.cute_message_image = gtk.VBox()
        self.content_box = gtk.VBox()

        self.pack_start(self.message_box, False, False)
        self.pack_start(self.content_box, True, True)

        self.cute_message_pixbuf = utils.get_common_locale_image_pixbuf(
            "info", "no_download.png")
        self.content_box.pack_start(self.cute_message_image, True, True)

        self.treeview.draw_mask = self.draw_mask

        self.cute_message_image.connect("expose-event",
                                        self.expose_cute_message_image)
        self.treeview.connect("items-change", self.update_message_bar)
        self.treeview.connect(
            "items-change", lambda treeview: global_event.emit(
                "update-install-notify-number",
                self.get_installing_pkgs_number()))
示例#54
0
def cursor_postion_changed(item, new_cursor_postion):
    global cursor_postion
    global timeout_tooltip_action_id
    if new_cursor_postion != cursor_postion and new_cursor_postion == "name":
        if timeout_tooltip_action_id:
            gobject.source_remove(timeout_tooltip_action_id)
            timeout_tooltip_action_id = None
        timeout_tooltip_action_id = gobject.timeout_add(
            1000, timeout_tooltip_action, item)
    elif new_cursor_postion != cursor_postion and new_cursor_postion == 'other':
        if timeout_tooltip_action_id:
            gobject.source_remove(timeout_tooltip_action_id)
            timeout_tooltip_action_id = None
        global_event.emit('hide-pkg-name-tooltip')

    cursor_postion = new_cursor_postion
示例#55
0
def get_upgrade_download_info_with_new_policy(cache, pkg_names):
    cache._depcache.init()
    failed_analyze_pkgs = []
    dependence = []
    try:
        for name in pkg_names:
            new_name, pkg = get_cache_pkg(cache, name)
            if not pkg:
                failed_analyze_pkgs.append(name)
                global_event.emit('parse-download-error', name, ACTION_UPGRADE)
            else:
                if cache.is_pkg_upgradable(new_name):
                    pkg.mark_upgrade()
                elif not cache.is_pkg_installed(new_name):
                    pkg.mark_install()
    except Exception, e:
        global_event.emit('parse-packages-failed', e)
示例#56
0
    def handle_pkg_status(self, reply, success):
        container_remove_all(self.left_action_box)
        if success:
            install_status = str(reply)
            if install_status == "uninstalled":
                action_button = ImageButton(
                    app_theme.get_pixbuf("button/install_normal.png"),
                    app_theme.get_pixbuf("button/install_hover.png"),
                    app_theme.get_pixbuf("button/install_press.png"),
                )
                action_button.connect(
                    "clicked", lambda w: global_event.emit(
                        "install-pkg", [self.pkg_name]))
                self.left_action_box.pack_start(action_button)
            elif install_status == "unknown":
                status_label = Label(_("Not found"))
                self.left_action_box.pack_start(status_label)
            else:
                try:
                    desktops = json.loads(install_status)
                    if not desktops:
                        status_label = Label(_("Successfully installed"))
                        self.left_action_box.pack_start(status_label)
                    else:
                        action_button = ImageButton(
                            app_theme.get_pixbuf("button/start_normal.png"),
                            app_theme.get_pixbuf("button/start_hover.png"),
                            app_theme.get_pixbuf("button/start_press.png"),
                        )
                        action_button.connect(
                            "button-press-event",
                            lambda w, e: self.button_press_start_button(
                                w, e, desktops))
                        self.left_action_box.pack_start(action_button)
                except:
                    logging.error("detail install status: %s = %s" %
                                  (self.pkg_name, install_status))

            self.left_action_box.show_all()
            global_event.emit('update-current-status-pkg-page', self)
        else:
            global_logger.error("get_pkg_installed handle_dbus_error")
            global_logger.error(reply)
    def get_pkgs_status(self):
        if self.show_flag:
            view = self.view_list[self.current_page_index][1]
            view.clear()
            container_remove_all(self.page_align)

            items = []
            pkg_names = self.pkg_names[:25]
            for pkg_name in pkg_names:
                info = self.data_manager.get_item_pkg_info(pkg_name)
                items.append(PkgIconItem(pkg_name, info[1], self.data_manager))

            view.add_items(items)
            self.page_align.add(self.view_list[self.current_page_index][2])
            global_event.emit("update-current-status-pkg-page", view)
            self.show_flag = None
            self.show_all()

        return True
示例#58
0
    def pulse(self, owner):
        """Periodically invoked while the Acquire process is underway.

        Return False if the user asked to cancel the whole Acquire process."""
        apt.progress.base.AcquireProgress.pulse(self, owner)
        self.percent = (((self.current_bytes + self.current_items) * 100.0) /
                        float(self.total_bytes + self.total_items))

        end = ""
        if self.current_cps:
            eta = long(
                float(self.total_bytes - self.current_bytes) /
                self.current_cps)
            end = " %sB/s %s" % (apt_pkg.size_to_str(
                self.current_cps), apt_pkg.time_to_str(eta))

        global_event.emit("update-list-update", self.percent,
                          self.status_message, end)
        return True
示例#59
0
    def motion_notify(self, column, offset_x, offset_y):
        if column == 0:
            if self.is_in_icon_area(column, offset_x, offset_y):
                global_event.emit("set-cursor", gtk.gdk.HAND2)
            elif self.is_in_name_area(column, offset_x, offset_y):
                global_event.emit("set-cursor", gtk.gdk.HAND2)
            else:
                global_event.emit("set-cursor", None)
        else:
            if self.status == self.STATUS_NORMAL:
                if self.is_in_button_area(column, offset_x, offset_y):
                    self.button_status = BUTTON_HOVER

                    if self.redraw_request_callback:
                        self.redraw_request_callback(self)
                elif self.button_status != BUTTON_NORMAL:
                    self.button_status = BUTTON_NORMAL

                    if self.redraw_request_callback:
                        self.redraw_request_callback(self)

                if self.is_in_star_area(column, offset_x, offset_y):
                    global_event.emit("set-cursor", gtk.gdk.HAND2)

                    times = offset_x / STAR_SIZE
                    self.grade_star = times * 2 + 2

                    self.grade_star = min(self.grade_star, 10)
                    self.star_buffer.star_level = self.grade_star

                    if self.redraw_request_callback:
                        self.redraw_request_callback(self)
                else:
                    global_event.emit("set-cursor", None)

                    if self.star_buffer.star_level != self.star_level:
                        self.star_buffer.star_level = self.star_level

                        if self.redraw_request_callback:
                            self.redraw_request_callback(self)