def __init__(self, context_model=None, parent=None):
        """Create a context table."""
        super(ContextTableWidget, self).__init__(self.default_row_count,
                                                 2, parent)
        ContextViewMixin.__init__(self, context_model)

        self.diff_mode = False
        self.diff_context_model = None
        self.diff_from_source = False
        self._show_effective_request = False
        self._current_variant = None

        self.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
        self.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)

        hh = self.horizontalHeader()
        hh.setDefaultSectionSize(12 * self.fontMetrics().height())

        vh = self.verticalHeader()
        vh.setResizeMode(QtGui.QHeaderView.ResizeToContents)
        vh.setVisible(False)

        self.delegate = CellDelegate(self)
        self.setItemDelegate(self.delegate)
        self.setShowGrid(False)

        self.currentCellChanged.connect(self._currentCellChanged)
        self.itemSelectionChanged.connect(self._itemSelectionChanged)
        self.refresh()

    def __init__(self, context_model=None, parent=None, lock_package=False,
                 package_selectable_callback=None):
        super(BrowsePackageWidget, self).__init__(parent)
        ContextViewMixin.__init__(self, context_model)

        self.edit = PackageLineEdit(context_model, family_only=True)
        if lock_package:
            self.edit.hide()

        self.versions_table = PackageVersionsTable(context_model,
                                                   callback=package_selectable_callback)
        self.package_tab = PackageTabWidget(versions_tab=False)

        splitter = ConfiguredSplitter(app.config, "layout/splitter/browse_package")
        splitter.setOrientation(QtCore.Qt.Vertical)
        splitter.addWidget(self.versions_table)
        splitter.addWidget(self.package_tab)
        if not splitter.apply_saved_layout():
            splitter.setStretchFactor(0, 2)
            splitter.setStretchFactor(1, 1)

        layout = QtGui.QVBoxLayout()
        layout.addWidget(self.edit)
        layout.addWidget(splitter)
        self.setLayout(layout)

        self.edit.focusOutViaKeyPress.connect(self._set_package_name)
        self.versions_table.itemSelectionChanged.connect(self._set_package)

    def __init__(self, context_model=None, parent=None, family_only=False,
                 read_only=False):
        super(PackageLineEdit, self).__init__(parent)
        ContextViewMixin.__init__(self, context_model)
        self.read_only = read_only
        self.family_only = family_only
        self.default_style = None

        pal = self.palette()
        self.normal_font = self.font()
        self.placeholder_font = self.font()
        self.placeholder_font.setItalic(True)
        self.normal_text_color = pal.color(QtGui.QPalette.Text)
        self.placeholder_text_color = pal.color(QtGui.QPalette.Disabled,
                                                QtGui.QPalette.Text)
        if not self.read_only:
            self.setPlaceholderText("enter package")
            self._update_font()

        self.completer = QtGui.QCompleter(self)
        self.completer.setCompletionMode(QtGui.QCompleter.PopupCompletion)
        self.completions = QtGui.QStringListModel(self.completer)
        self.completer.setModel(self.completions)
        self.setCompleter(self.completer)

        self.textEdited.connect(self._textEdited)
        self.textChanged.connect(self._textChanged)

    def __init__(self, context_model, variant, reference_variant=None,
                 hide_locks=False, read_only=False, parent=None):
        super(VariantCellWidget, self).__init__(parent)
        ContextViewMixin.__init__(self, context_model)

        self.variant = variant
        self.reference_variant = reference_variant
        self.stale = False
        self.lock_status = None
        self.lock_icon = None
        self.hide_locks = hide_locks
        self.read_only = read_only
        self.icons = []  # 3-tuples: widget, name, tooltip

        qname = self.variant.qualified_package_name
        self.label = QtGui.QLabel(qname)
        desc = "%[email protected]%s" % (qname, self.variant.wrapped.location)
        self.label.setToolTip(desc)

        self.depends_icon = get_icon_widget("depends", "dependent package")
        self.depends_icon.hide()
        create_pane([self.label, self.depends_icon, None],
                    True, compact=True, parent_widget=self)

        self.refresh()

    def __init__(self, context_model=None, parent=None):
        super(ContextResolveTimeLabel, self).__init__(parent)
        ContextViewMixin.__init__(self, context_model)

        self.timer = QtCore.QTimer(self)
        self.timer.setInterval(60 * 1000)
        self.timer.timeout.connect(self.refresh)
        self.refresh()

    def __init__(self, context_model=None, versions_tab=False, parent=None):
        super(PackageTabWidget, self).__init__(parent)
        ContextViewMixin.__init__(self, context_model)
        self.variant = None
        self.tabs = {}

        self.summary_widget = VariantSummaryWidget()
        self.tools_widget = VariantToolsList(self.context_model)
        self.variants_widget = VariantsList()
        self.changelog_edit = VariantChangelogEdit()
        self.details_widget = VariantDetailsWidget(self.context_model)
        self.help_widget = VariantHelpWidget(self.context_model)

        if versions_tab:
            self.versions_widget = VariantVersionsWidget(self.context_model)
        else:
            self.versions_widget = None

        n = 0
        icon = get_icon("package", as_qicon=True)
        self.addTab(self.summary_widget, icon, "package summary")
        self.tabs["summary"] = dict(index=n, lazy=False)
        n += 1

        if self.versions_widget:
            icon = get_icon("versions", as_qicon=True)
            self.addTab(self.versions_widget, icon, "versions")
            self.tabs["versions"] = dict(index=n, lazy=True)
            n += 1

        icon = get_icon("variant", as_qicon=True)
        self.addTab(self.variants_widget, icon, "variants")
        self.tabs["variants"] = dict(index=n, lazy=False)
        n += 1

        icon = get_icon("tools", as_qicon=True)
        self.addTab(self.tools_widget, icon, "tools")
        self.tabs["tools"] = dict(index=n, lazy=False)
        n += 1

        icon = get_icon("changelog", as_qicon=True)
        self.addTab(self.changelog_edit, icon, "changelog")
        self.tabs["changelog"] = dict(index=n, lazy=True)
        n += 1

        icon = get_icon("help", as_qicon=True)
        self.addTab(self.help_widget, icon, "help")
        self.tabs["help"] = dict(index=n, lazy=True)
        n += 1

        icon = get_icon("info", as_qicon=True)
        self.addTab(self.details_widget, icon, "details")
        self.tabs["info"] = dict(index=n, lazy=False)

        self.currentChanged.connect(self._tabChanged)
        self.setEnabled(False)

    def __init__(self, context=None, parent=None):
        super(ContextSubWindow, self).__init__(parent)
        context_model = ContextModel(context)
        ContextViewMixin.__init__(self, context_model)
        config_key = "layout/window/context_manager"
        StoreSizeMixin.__init__(self, app.config, config_key)
        self.setAttribute(QtCore.Qt.WA_DeleteOnClose, True)

        widget = ContextManagerWidget(context_model)
        widget.diffModeChanged.connect(self._diffModeChanged)
        self.setWidget(widget)
        self._update_window_title()

    def __init__(self, context_model=None, parent=None):
        super(BrowsePackagePane, self).__init__(parent)
        ContextViewMixin.__init__(self, context_model)

        self.browse = BrowsePackageWidget(self.context_model)
        self.settings = ContextSettingsWidget(self.context_model,
                                              attributes=("packages_path",))

        icon = get_icon("package", as_qicon=True)
        self.addTab(self.browse, icon, "packages")
        icon = get_icon("cog", as_qicon=True)
        self.addTab(self.settings, icon, "settings")

    def __init__(self, context_model=None, parent=None):
        super(VariantDetailsWidget, self).__init__(parent)
        ContextViewMixin.__init__(self, context_model)
        self.variant = None

        self.edit = StreamableTextEdit()
        self.edit.setStyleSheet("font: 9pt 'Courier'")
        self.view_graph_btn = ViewGraphButton(context_model)
        self._update_graph_btn_visibility()
        btn_pane = create_pane([None, self.view_graph_btn], True, compact=True)

        create_pane([self.edit, btn_pane], False, compact=True, parent_widget=self)
        self.clear()

    def __init__(self, context_model=None, reference_variant=None,
                 in_window=False, parent=None):
        """
        Args:
            reference_variant (`Variant`): Used to show the difference between
                two variants.
            in_window (bool): If True, the 'view changelogs' option turns
                into a checkbox, dropping the 'View in window' option.
        """
        super(VariantVersionsWidget, self).__init__(parent)
        ContextViewMixin.__init__(self, context_model)

        self.in_window = in_window
        self.variant = None
        self.reference_variant = reference_variant
        self.pending_changelog_packages = None

        self.label = QtGui.QLabel()
        self.changelog_edit = ChangelogEdit()
        self.table = VariantVersionsTable(self.context_model,
                                          reference_variant=reference_variant)

        self.tab = QtGui.QTabWidget()
        self.tab.addTab(self.table, "list view")
        self.tab.addTab(self.changelog_edit, "changelogs")
        self.tab.currentChanged.connect(self._tabIndexChanged)

        buttons = [None]
        if self.in_window:
            close_btn = QtGui.QPushButton("Close")
            buttons.append(close_btn)
            close_btn.clicked.connect(self._close_window)
        else:
            browse_versions_btn = QtGui.QPushButton("Browse Versions...")
            browse_versions_btn.clicked.connect(self._browseVersions)
            buttons.append(browse_versions_btn)

            window_btn = QtGui.QPushButton("View In Window...")
            window_btn.clicked.connect(self._view_changelogs_window)
            buttons.append(window_btn)

        btn_pane = create_pane(buttons, True, compact=not self.in_window)
        pane = create_pane([self.label, self.tab, btn_pane], False, compact=True)

        self.set_main_widget(pane)
        self.set_loader_swap_delay(300)
        self.clear()

    def __init__(self, context_model=None, parent=None):
        super(ViewGraphButton, self).__init__(parent)
        ContextViewMixin.__init__(self, context_model)

        # If not None, prunes the graph to this package
        self.package_name = None

        menu = QtGui.QMenu()
        self.action_1 = add_menu_action(menu, "View Resolve Graph...", self._view_resolve_graph, "graph")
        self.action_2 = add_menu_action(menu, "View Dependency Graph...", self._view_dependency_graph)

        self.setPopupMode(QtGui.QToolButton.MenuButtonPopup)
        self.setToolButtonStyle(QtCore.Qt.ToolButtonTextBesideIcon)
        self.setDefaultAction(self.action_1)
        self.setMenu(menu)

        self.refresh()

    def __init__(self, context_model=None, parent=None):
        super(VariantToolsList, self).__init__(0, 1, parent)
        ContextViewMixin.__init__(self, context_model)

        self.variant = None
        self.tool_widgets = {}

        self.setGridStyle(QtCore.Qt.DotLine)
        self.setFocusPolicy(QtCore.Qt.NoFocus)
        self.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
        self.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)

        hh = self.horizontalHeader()
        hh.setStretchLastSection(True)
        hh.setVisible(False)
        vh = self.verticalHeader()
        vh.setVisible(False)

    def __init__(self, context_model=None, parent=None):
        super(ContextToolsWidget, self).__init__(parent)
        ContextViewMixin.__init__(self, context_model)

        self.tool_widgets = {}
        self.package_icon = get_icon("package", as_qicon=True)

        h = self.header()
        h.stretchLastSection()
        h.setResizeMode(QtGui.QHeaderView.Fixed)
        h.setVisible(False)

        self.setColumnCount(2)
        self.setFocusPolicy(QtCore.Qt.NoFocus)

        app.process_tracker.instanceCountChanged.connect(self._instanceCountChanged)

        self.refresh()

    def __init__(self, context_model=None, read_only=False, parent=None):
        super(PackageSelectWidget, self).__init__(parent)
        ContextViewMixin.__init__(self, context_model)

        self.edit = PackageLineEdit(self.context_model, read_only=read_only, parent=self)
        self.edit.setStyleSheet("QLineEdit { border : 0px;}")
        self.btn = IconButton("package", "browse packages")
        self.btn.hide()

        create_pane([(self.edit, 1), self.btn, 2], True, compact=True, compact_spacing=0, parent_widget=self)

        if read_only:
            self.edit.setReadOnly(True)
            update_font(self.edit, italic=True)
        else:
            self.edit.focusIn.connect(self._focusIn)
            self.edit.focusOut.connect(self._focusOut)
            self.edit.focusOutViaKeyPress.connect(self._focusOutViaKeyPress)
            self.edit.textChanged.connect(self._textChanged)
            self.btn.clicked.connect(self._browse_package)

    def __init__(self, context_model=None, parent=None):
        super(VariantHelpWidget, self).__init__(parent)
        ContextViewMixin.__init__(self, context_model)
        self.variant = None
        self.help_1 = None
        self.help_2 = None

        self.table_1 = self._create_table()
        self.table_2 = self._create_table()

        self.tab = QtGui.QTabWidget()
        self.tab.addTab(self.table_1, "latest help")
        self.tab.addTab(self.table_2, "help")

        self.no_help_label = QtGui.QLabel("No help found.")
        self.no_help_label.setAlignment(QtCore.Qt.AlignCenter)
        pane = create_pane([self.no_help_label, self.tab], False, compact=True)

        self.set_main_widget(pane)
        self.set_loader_swap_delay(300)
        self.clear()

    def __init__(self, context_model=None, attributes=None, parent=None):
        """
        Args:
            attributes (list of str): Select only certain settings to expose. If
                None, all settings are exposed.
        """
        super(ContextSettingsWidget, self).__init__(parent)
        ContextViewMixin.__init__(self, context_model)

        self.schema_keys = set(self.schema_dict.iterkeys())
        if attributes:
            self.schema_keys &= set(attributes)
            assert self.schema_keys

        schema_dict = dict((k, v) for k, v in self.schema_dict.iteritems()
                           if k in self.schema_keys)
        self.schema = Schema(schema_dict)

        self.edit = QtGui.QTextEdit()
        self.edit.setStyleSheet("font: 9pt 'Courier'")
        self.default_btn = QtGui.QPushButton("Set To Defaults")
        self.discard_btn = QtGui.QPushButton("Discard Changes...")
        self.apply_btn = QtGui.QPushButton("Apply")
        self.discard_btn.setEnabled(False)
        self.apply_btn.setEnabled(False)
        btn_pane = create_pane([None, self.default_btn, self.discard_btn,
                                self.apply_btn], True)

        layout = QtGui.QVBoxLayout()
        layout.addWidget(self.edit)
        layout.addWidget(btn_pane)
        self.setLayout(layout)

        self.apply_btn.clicked.connect(self.apply_changes)
        self.default_btn.clicked.connect(self.set_defaults)
        self.discard_btn.clicked.connect(partial(self.discard_changes, True))
        self.edit.textChanged.connect(self._settingsChanged)

        self._update_text()

    def __init__(self, context_model=None, parent=None):
        super(ContextDetailsWidget, self).__init__(parent)
        ContextViewMixin.__init__(self, context_model)
        self.code_pending = True

        self.overview_edit = StreamableTextEdit()
        self.overview_edit.setStyleSheet("font: 9pt 'Courier'")

        self.graph_btn = ViewGraphButton(context_model)
        btn_pane = create_pane([None, self.graph_btn], True)
        overview_pane = create_pane([self.overview_edit, btn_pane], False)

        self.code_edit = SearchableTextEdit()
        self.code_edit.setStyleSheet("font: 9pt 'Courier'")

        self.code_combo = QtGui.QComboBox()
        # strip out 'sh' and 'csh', they only differ from bash and tcsh in shell
        # startup behaviour, which is irrelevant here
        code_types = set(get_shell_types()) - set([system.shell, "sh", "csh"])
        code_types = [system.shell] + sorted(code_types) + ["python dict"]
        for code_type in code_types:
            self.code_combo.addItem(code_type)

        label = QtGui.QLabel("Format:")
        btn_pane = create_pane([None, label, self.code_combo], True)
        code_pane = create_pane([self.code_edit, btn_pane], False)

        self.environ_widget = ContextEnvironWidget()

        self.addTab(overview_pane, "overview")
        self.addTab(code_pane, "shell code")
        self.addTab(self.environ_widget, "environment")

        self.code_combo.currentIndexChanged.connect(self._update_code)
        self.currentChanged.connect(self._currentTabChanged)

        self.refresh()

    def __init__(self, context_model=None, parent=None, callback=None):
        """
        Args:
            callback (callable): If supplied, this will be called and passed
            a `Package` for each package in the versions list. If the callable
            returns False, that package will be disabled for selection.
        """
        super(PackageVersionsTable, self).__init__(0, 2, parent)
        ContextViewMixin.__init__(self, context_model)

        self.package_name = None
        self.callback = callback
        self.packages = {}

        self.setGridStyle(QtCore.Qt.DotLine)
        self.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
        self.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
        self.setVerticalScrollMode(QtGui.QAbstractItemView.ScrollPerPixel)

        hh = self.horizontalHeader()
        hh.setStretchLastSection(True)
        vh = self.verticalHeader()
        vh.setResizeMode(QtGui.QHeaderView.ResizeToContents)
        self.clear()

    def __init__(self, context_model=None, reference_variant=None, parent=None):
        super(VariantVersionsTable, self).__init__(0, 2, parent)
        ContextViewMixin.__init__(self, context_model)

        self.variant = None
        self.reference_variant = reference_variant
        self.allow_selection = False
        self.num_versions = -1
        self.version_index = -1
        self.reference_version_index = -1

        self.setWordWrap(False)
        self.setGridStyle(QtCore.Qt.DotLine)
        self.setFocusPolicy(QtCore.Qt.NoFocus)
        self.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
        self.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
        self.setVerticalScrollMode(QtGui.QAbstractItemView.ScrollPerPixel)

        hh = self.horizontalHeader()
        hh.setVisible(False)
        vh = self.verticalHeader()
        vh.setResizeMode(QtGui.QHeaderView.ResizeToContents)

        self.clear()

    def __init__(self, context_model=None, parent=None):
        super(ContextManagerWidget, self).__init__(parent)
        ContextViewMixin.__init__(self, context_model)

        # widgets
        self.popup = None
        self.context_table = ContextTableWidget(self.context_model)
        self.show_effective_request_checkbox = QtGui.QCheckBox("show effective request")

        resolve_time_label = ContextResolveTimeLabel(self.context_model)

        self.time_lock_tbtn = QtGui.QToolButton()
        icon = get_icon("time_lock", as_qicon=True)
        self.time_lock_tbtn.setIcon(icon)

        self.find_tbtn = QtGui.QToolButton()
        self.find_tbtn.setToolTip("find resolved package")
        icon = get_icon("find", as_qicon=True)
        self.find_tbtn.setIcon(icon)

        self.shell_tbtn = QtGui.QToolButton()
        self.shell_tbtn.setToolTip("open shell")
        icon = get_icon("terminal", as_qicon=True)
        self.shell_tbtn.setIcon(icon)

        self.diff_tbtn = QtGui.QToolButton()
        self.diff_tbtn.setToolTip("enter diff mode")
        self.diff_tbtn.setPopupMode(QtGui.QToolButton.MenuButtonPopup)
        self.diff_menu = QtGui.QMenu()
        self.diff_action = add_menu_action(
            self.diff_menu, "Diff Against Current",
            self._diff_with_last_resolve, "diff")
        self.diff_to_disk_action = add_menu_action(
            self.diff_menu, "Diff Against Disk",
            self._diff_with_disk, "diff_to_disk")
        self.diff_to_other_action = add_menu_action(
            self.diff_menu, "Diff Against Other...",
            self._diff_with_other, "diff_to_other")
        self.diff_tbtn.setMenu(self.diff_menu)
        self.diff_tbtn.setDefaultAction(self.diff_action)

        self.undiff_tbtn = QtGui.QToolButton()
        self.undiff_tbtn.setToolTip("leave diff mode")
        icon = get_icon("diff", as_qicon=True)
        self.undiff_tbtn.setIcon(icon)
        self.undiff_tbtn.setCheckable(True)

        self.lock_tbtn = QtGui.QToolButton()
        self.lock_tbtn.setToolTip("locking")
        icon = get_icon("no_lock", as_qicon=True)
        self.lock_tbtn.setIcon(icon)
        self.lock_tbtn.setPopupMode(QtGui.QToolButton.InstantPopup)
        menu = QtGui.QMenu()
        for lock_type in PatchLock:
            fn = partial(self._set_lock_type, lock_type)
            add_menu_action(menu, lock_type.description, fn, lock_type.name)
        menu.addSeparator()
        add_menu_action(menu, "Remove Explicit Locks", self._removeExplicitLocks)
        self.lock_tbtn.setMenu(menu)

        self.revert_tbtn = QtGui.QToolButton()
        self.revert_tbtn.setToolTip("revert")
        icon = get_icon("revert", as_qicon=True)
        self.revert_tbtn.setIcon(icon)
        self.revert_tbtn.setPopupMode(QtGui.QToolButton.InstantPopup)

        self.revert_menu = QtGui.QMenu()
        self.revert_action = add_menu_action(
            self.revert_menu, "Revert To Last Resolve...",
            self._revert_to_last_resolve, "revert")
        self.revert_diff_action = add_menu_action(
            self.revert_menu, "Revert To Reference...",
            self._revert_to_diff, "revert_to_diff")
        self.revert_disk_action = add_menu_action(
            self.revert_menu, "Revert To Disk...",
            self._revert_to_disk, "revert_to_disk")
        self.revert_tbtn.setMenu(self.revert_menu)

        resolve_tbtn = QtGui.QToolButton()
        resolve_tbtn.setPopupMode(QtGui.QToolButton.MenuButtonPopup)
        menu = QtGui.QMenu()
        default_resolve_action = add_menu_action(menu, "Resolve", self._resolve, "resolve")
        add_menu_action(menu, "Advanced Resolve...",
                        partial(self._resolve, advanced=True), "advanced_resolve")
        resolve_tbtn.setDefaultAction(default_resolve_action)
        resolve_tbtn.setMenu(menu)

        toolbar = QtGui.QToolBar()
        toolbar.addWidget(resolve_time_label)
        self.time_lock_tbtn_action = toolbar.addWidget(self.time_lock_tbtn)
        toolbar.addSeparator()
        toolbar.addWidget(self.find_tbtn)
        toolbar.addWidget(self.shell_tbtn)
        self.diff_tbtn_action = toolbar.addWidget(self.diff_tbtn)
        self.undiff_tbtn_action = toolbar.addWidget(self.undiff_tbtn)
        toolbar.addWidget(self.lock_tbtn)
        toolbar.addWidget(self.revert_tbtn)
        toolbar.addWidget(resolve_tbtn)
        self.time_lock_tbtn_action.setVisible(False)
        self.undiff_tbtn_action.setVisible(False)
#.........这里部分代码省略.........