Mercurial Repositories > eric / file revision

# -*- coding: utf-8 -*-

# Copyright (c) 2009 - 2016 Detlev Offenbach <detlev@die-offenbachs.de>
#

"""
Module implementing a dialog to show all cookies.
"""

from __future__ import unicode_literals

from PyQt5.QtCore import pyqtSlot, Qt, QDateTime, QByteArray, \
    QSortFilterProxyModel
from PyQt5.QtGui import QFont, QFontMetrics
from PyQt5.QtWidgets import QDialog, QTreeWidgetItem

##from .CookieModel import CookieModel
##
from .Ui_CookiesDialog import Ui_CookiesDialog


# TODO: Change dialog to use a QTreeWidget and show cookie data on bottom of dialog
# TODO: Remove CookieModel, CookieDetailsDialog and related files
class CookiesDialog(QDialog, Ui_CookiesDialog):
    """
    Class implementing a dialog to show all cookies.
    """
    DomainRole = Qt.UserRole + 1
    CookieRole = Qt.UserRole + 2
    
    def __init__(self, cookieJar, parent=None):
        """
        Constructor
        
        @param cookieJar reference to the cookie jar (CookieJar)
        @param parent reference to the parent widget (QWidget)
        """
        super(CookiesDialog, self).__init__(parent)
        self.setupUi(self)
        
        self.addButton.setEnabled(False)
        
        self.__cookieJar = cookieJar
        
        self.__domainDict = {}
##        self.__itemDict = {}        # TODO: Maybe get rid of this
        
        for cookie in self.__cookieJar.cookies():
            self.__addCookie(cookie)
    
    def __cookieDomain(self, cookie):
        """
        Private method to extract the cookie domain.
        
        @param cookie cookie to get the domain from
        @type QNetworkCookie
        @return domain of the cookie
        @rtype str
        """
        domain = cookie.domain()
        if domain.startswith("."):
            domain = domain[1:]
        return domain
    
    def __addCookie(self, cookie):
        """
        Private method to add a cookie to the tree.
        
        @param cookie reference to the cookie
        @type QNetworkCookie
        """
        domain = self.__cookieDomain(cookie)
        if domain in self.__domainDict:
            itm = QTreeWidgetItem(self.__domainDict[domain])
        else:
            newParent = QTreeWidgetItem(self.cookiesTree)
            newParent.setText(0, domain)
            newParent.setData(0, self.DomainRole, cookie.domain())
            self.__domainDict[domain] = newParent
            
            itm = QTreeWidgetItem(newParent)
        
        itm.setText(0, cookie.domain())
        itm.setText(1, bytes(cookie.name()).decode())
        itm.setData(0, self.CookieRole, cookie)
        
##        self.__itemDict[itm] = cookie
        
##        self.removeButton.clicked.connect(self.cookiesTable.removeSelected)
##        self.removeAllButton.clicked.connect(self.cookiesTable.removeAll)
##        
##        self.cookiesTable.verticalHeader().hide()
##        model = CookieModel(cookieJar, self)
##        self.__proxyModel = QSortFilterProxyModel(self)
##        self.__proxyModel.setSourceModel(model)
##        self.searchEdit.textChanged.connect(
##            self.__proxyModel.setFilterFixedString)
##        self.cookiesTable.setModel(self.__proxyModel)
##        self.cookiesTable.doubleClicked.connect(self.__showCookieDetails)
##        self.cookiesTable.selectionModel().selectionChanged.connect(
##            self.__tableSelectionChanged)
##        self.cookiesTable.model().modelReset.connect(self.__tableModelReset)
##        
##        fm = QFontMetrics(QFont())
##        height = fm.height() + fm.height() // 3
##        self.cookiesTable.verticalHeader().setDefaultSectionSize(height)
##        self.cookiesTable.verticalHeader().setMinimumSectionSize(-1)
##        for section in range(model.columnCount()):
##            header = self.cookiesTable.horizontalHeader()\
##                .sectionSizeHint(section)
##            if section == 0:
##                header = fm.width("averagebiglonghost.averagedomain.info")
##            elif section == 1:
##                header = fm.width("_session_id")
##            elif section == 4:
##                header = fm.width(
##                    QDateTime.currentDateTime().toString(Qt.LocalDate))
##            buffer = fm.width("mm")
##            header += buffer
##            self.cookiesTable.horizontalHeader().resizeSection(section, header)
##        self.cookiesTable.horizontalHeader().setStretchLastSection(True)
##        self.cookiesTable.model().sort(
##            self.cookiesTable.horizontalHeader().sortIndicatorSection(),
##            Qt.AscendingOrder)
##        
##        self.__detailsDialog = None
##    
##    def __showCookieDetails(self, index):
##        """
##        Private slot to show a dialog with the cookie details.
##        
##        @param index index of the entry to show (QModelIndex)
##        """
##        if not index.isValid():
##            return
##        
##        cookiesTable = self.sender()
##        if cookiesTable is None:
##            return
##        
##        model = cookiesTable.model()
##        row = index.row()
##        
##        domain = model.data(model.index(row, 0))
##        name = model.data(model.index(row, 1))
##        path = model.data(model.index(row, 2))
##        secure = model.data(model.index(row, 3))
##        expires = model.data(model.index(row, 4)).toString("yyyy-MM-dd hh:mm")
##        data = model.data(model.index(row, 5))
##        if data is None:
##            value = ""
##        else:
##            value = bytes(QByteArray.fromPercentEncoding(data)).decode()
##        
##        if self.__detailsDialog is None:
##            from .CookieDetailsDialog import CookieDetailsDialog
##            self.__detailsDialog = CookieDetailsDialog(self)
##        self.__detailsDialog.setData(domain, name, path, secure, expires,
##                                     value)
##        self.__detailsDialog.show()
    
    @pyqtSlot()
    def on_addButton_clicked(self):
        """
        Private slot to add a new exception.
        """
        # TODO: change this
##        selection = self.cookiesTable.selectionModel().selectedRows()
##        if len(selection) == 0:
##            return
##        
##        from .CookiesExceptionsDialog import CookiesExceptionsDialog
##        
##        firstSelected = selection[0]
##        domainSelection = firstSelected.sibling(firstSelected.row(), 0)
##        domain = self.__proxyModel.data(domainSelection, Qt.DisplayRole)
##        dlg = CookiesExceptionsDialog(self.__cookieJar, self)
##        dlg.setDomainName(domain)
##        dlg.exec_()
##    
##    def __tableSelectionChanged(self, selected, deselected):
##        """
##        Private slot to handle a change of selected items.
##        
##        @param selected selected indexes (QItemSelection)
##        @param deselected deselected indexes (QItemSelection)
##        """
##        self.addButton.setEnabled(len(selected.indexes()) > 0)
##    
##    def __tableModelReset(self):
##        """
##        Private slot to handle a reset of the cookies table.
##        """
##        self.addButton.setEnabled(False)
    
    @pyqtSlot()
    def on_removeButton_clicked(self):
        """
        Slot documentation goes here.
        """
        # TODO: not implemented yet
        raise NotImplementedError
    
    @pyqtSlot()
    def on_removeAllButton_clicked(self):
        """
        Slot documentation goes here.
        """
        # TODO: not implemented yet
        raise NotImplementedError
    
    @pyqtSlot(QTreeWidgetItem, QTreeWidgetItem)
    def on_cookiesTree_currentItemChanged(self, current, previous):
        """
        Private slot to handle a change of the current item.
        
        @param current reference to the current item
        @type QTreeWidgetItem
        @param previous reference to the previous current item
        @type QTreeWidgetItem
        """
        self.addButton.setEnabled(current is not None)
        self.removeButton.setEnabled(current is not None)
        
        if current is None:
            return
        
        if not current.text(1):
            # it is a cookie domain entry
            self.domain.setText(self.tr("<no cookie selected>"))
            self.name.setText(self.tr("<no cookie selected>"))
            self.path.setText(self.tr("<no cookie selected>"))
            self.secure.setText(self.tr("<no cookie selected>"))
            self.expiration.setText(self.tr("<no cookie selected>"))
            self.value.setText(self.tr("<no cookie selected>"))
            
            self.removeButton.setText(self.tr("Remove Cookies"))
        else:
            # it is a cookie entry
            cookie = current.data(0, self.CookieRole)
            
            self.domain.setText(cookie.domain())
            self.name.setText(bytes(cookie.name()).decode())
            self.path.setText(cookie.path())
            if cookie.isSecure():
                self.secure.setText(self.tr("Secure connections only"))
            else:
                self.secure.setText(self.tr("All connections"))
            if cookie.isSessionCookie():
                self.expiration.setText(self.tr("Session Cookie"))
            else:
                self.expiration.setText(
                    cookie.expirationDate().toString("yyyy-MM-dd HH:mm:ss"))
            self.value.setText(
                bytes(QByteArray.fromPercentEncoding(cookie.value())).decode())
            
            self.removeButton.setText(self.tr("Remove Cookie"))
    
    @pyqtSlot(str)
    def on_searchEdit_textChanged(self, txt):
        """
        Private slot to search and filter the cookie tree.
        
        @param txt text to search for
        @type str
        """
        if not txt:
            for row in range(self.cookiesTree.topLevelItemCount()):
                self.cookiesTree.topLevelItem(row).setHidden(False)
        else:
            for row in range(self.cookiesTree.topLevelItemCount()):
                text = self.cookiesTree.topLevelItem(row).text(0)
                self.cookiesTree.topLevelItem(row).setHidden(txt not in text)