class TabBar(ComboTabBar):
_s_tabMetrics = None
MIMETYPE = 'application/app.tabbar.tab'
@classmethod
def tabMetrics(cls):
if not cls._s_tabMetrics:
cls._s_tabMetrics = TabBarTabMetrics()
return cls._s_tabMetrics
def __init__(self, window, tabWidget):
'''
@param: window BrowserWindow
@param: tabWidget TabWidget
'''
super(TabBar, self).__init__()
self._window = window
self._tabWidget = tabWidget
self._hideTabBarWithOneTab = False
self._showCloseOnInactive = False
self._normalTabWidth = 0
self._activeTabWidth = 0
self._dragStartPosition = QPoint() # QPoint
self._forceHidden = False
self._lastTab = None # QPointer<WebTab>
self.setObjectName('tabbar')
self.setElideMode(Qt.ElideRight)
self.setFocusPolicy(Qt.NoFocus)
self.setTabsCloseable(False)
self.setMouseTracking(True)
self.setDocumentModel(True)
self.setAcceptDrops(True)
self.setDrawBase(False)
self.setMovable(True)
self.currentChanged.connect(self._currentTabChanged)
# ComboTabBar features
self.setUsesScrollButtons(True)
self.setCloseButtonsToolTip(_('Close Tab'))
self.overFlowChanged.connect(self._overflowChanged)
self.tabMetrics().init()
if gVar.app.isPrivate():
privateBrowsing = QLabel(self)
privateBrowsing.setObjectName('private-browsing-icon')
privateBrowsing.setPixmap(
IconProvider.privateBrowsingIcon().pixmap(16))
privateBrowsing.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
privateBrowsing.setFixedWidth(30)
self.addCornerWidget(privateBrowsing, Qt.TopLeftCorner)
def loadSettings(self):
settings = Settings()
settings.beginGroup('Browser-Tabs-Settings')
self._hideTabBarWithOneTab = settings.value('hideTabsWithOneTab',
False)
activateLastTab = settings.value('ActivateLastTabWhenCloseActual',
False)
self._showCloseOnInactive = settings.value('showCloseOnInactiveTabs',
0)
settings.endGroup()
self.setSelectionBehaviorOnRemove(
activateLastTab and QTabBar.SelectPreviousTab
or QTabBar.SelectRightTab)
self.setVisible(not (self.count() <= 1 and self._hideTabBarWithOneTab))
self.setUpLayout()
def tabWidget(self):
return self._tabWidget
# override
def setVisible(self, visible):
if self._forceHidden:
super(TabBar, self).setVisible(False)
return
# Make sure to honor use preference
if visible:
visible = not (self.count() <= 1 and self._hideTabBarWithOneTab)
super(TabBar, self).setVisible(visible)
def setForceHidden(self, hidden):
self._forceHidden = hidden
self.setVisible(not self._forceHidden)
def setTabText(self, index, text):
tabText = text
# Avoid Alt+letter shortcuts
tabText.replace('&', '&&')
tab = self.webTab(index)
if tab and tab.isPinned():
tabText = ''
self.setTabToolTip(index, text)
super(TabBar, self).setTabText(index, tabText)
# override
def wheelEvent(self, event):
if gVar.app.plugins().processWheelEvent(const.ON_TabBar, self, event):
return
super().wheelEvent(event)
# Q_SIGNALS
moveAddTabButton = pyqtSignal(int) # posX
# private Q_SLOTS
def _currentTabChanged(self, index):
if not self.validIndex(index):
return
# Don't hide close buttons when dragging tabs
if self._dragStartPosition.isNull():
self._showCloseButton(index)
if self._lastTab:
self._hideCloseButton(self._lastTab.tabIndex())
QTimer.singleShot(100, self.ensureVisible)
self._lastTab = self.webTab(index)
self._tabWidget.currentTabChanged(index)
def _overflowChanged(self, overflowed):
# Make sure close buttons on inactive tabs are hidden
# This is needed for when leaving fullscreen from non-overflowed to
# overflowed state
if overflowed and self._showCloseOnInactive != 1:
self.setTabsCloseable(False)
self._showCloseButton(self.currentIndex())
#def _closeTabFromButton(self):
# pass
# private:
def _validIndex(self, index):
return index > 0 and index < self.count()
# override
def _tabInserted(self, index):
# Initialize pinned tab metrics
if self.tabMetrics()._pinnedWidth() == -1:
def tabInsertedFunc():
if self.tabMetrics()._pinnedWidth() != -1:
return
w = self.tabButton(0, self.iconButtonPosition())
if w and w.parentWidget():
# QRect
wg = w.parentWidget().geometry()
wr = QStyle.visualRect(self.layoutDirection(), wg,
w.geometry())
self.tabMetrics().setPinnedWidth(
self.iconButtonSize().width() + wr.x() * 2)
self.setUpLayout()
QTimer.singleShot(0, tabInsertedFunc)
# override
def _tabRemoved(self, index):
self._showCloseButton(self.currentIndex())
self.setVisible(not (self.count() <= 1 and self._hideTabBarWithOneTab))
# Make sure to move add tab button to correct position when where are no
# normal tabs
if self.normalTabsCount() == 0:
xForAddTabButton = self.cornerWidth(
Qt.TopLeftCorner) + self._pinTabBarWidth()
if QApplication.layoutDirection() == Qt.RightToLeft:
xForAddTabButton = self.width() - xForAddTabButton
self.moveAddTabButton.emit(xForAddTabButton)
def _hideCloseButton(self, index):
if not self.validIndex(index) or self.tabsCloseable():
return
button = self.tabButton(index, self.closeButtonPosition())
if not isinstance(button, CloseButton):
return
self.setTabButton(index, self.closeButtonPosition(), None)
button.deleteLater()
def _showCloseButton(self, index):
if not self.validIndex(index):
return
# WebTab
webTab = self._tabWidget.widget(index)
button = self.tabButton(index, self.closeButtonPosition())
if button or (webTab and webTab.isPinned()):
return
self.insertCloseButton(index)
def _updatePinnedTabCloseButton(self, index):
if not self.validIndex(index):
return
webTab = self._tabWidget.widget(index)
button = self.tabButton(index, self.closeButtonPosition())
pinned = webTab.isPinned()
if pinned:
if button:
button.hide()
else:
if button:
button.show()
else:
self._showCloseButton(index)
# override
def contextMenuEvent(self, event):
'''
@param: event QContextMenuEvent
'''
if self.isDragInProgress():
return
index = self.tabAt(event.pos())
menu = TabContextMenu(index, self._window)
# Prevent choosing first option with double rightclick
pos = event.globalPos()
p = QPoint(pos.x(), pos.y() + 1)
menu.exec_(p)
# override
def mouseDoubleClickEvent(self, event):
'''
@param: event QMouseEvent
'''
if gVar.app.plugins().processMouseDoubleClick(const.ON_TabBar, self,
event):
return
if event.buttons() == Qt.LeftButton and self.emptyArea(event.pos()):
self._tabWidget.addViewByUrl(QUrl(), const.NT_SelectedTabAtTheEnd,
True)
return
super().mouseDoubleClickEvent(event)
# override
def mousePressEvent(self, event):
'''
@param: event QMouseEvent
'''
super().mousePressEvent(event)
if gVar.app.plugins().processMousePress(const.ON_TabBar, self, event):
return
if event.buttons() == Qt.LeftButton and not self.emptyArea(
event.pos()):
self._dragStartPosition = event.pos()
else:
self._dragStartPosition = QPoint()
# override
def mouseMoveEvent(self, event):
'''
@param: event QMouseEvent
'''
super().mouseMoveEvent(event)
if gVar.app.plugins().processMouseMove(const.ON_TabBar, self, event):
return
if self.count() == 1 and gVar.app.windowCount() == 1:
return
if not self._dragStartPosition.isNull():
offset = 0
eventY = event.pos().y()
if eventY < 0:
offset = abs(eventY)
elif eventY > self.height():
offset = eventY - self.height()
if offset > QApplication.startDragDistance() * 3:
global_ = self.mapToGlobal(self._dragStartPosition)
w = QApplication.widgetAt(global_)
if w:
mouse = QMouseEvent(QEvent.MouseButtonRelease,
w.mapFromGlobal(global_),
Qt.LeftButton, Qt.LeftButton,
event.modifiers())
QApplication.sendEvent(w, mouse)
drag = QDrag(self)
mime = QMimeData()
mime.setData(self.MIMETYPE, b'')
drag.setMimeData(mime)
drag.setPixmap(self.tabPixmap(self.currentIndex()))
if drag.exec_() == Qt.IgnoreAction:
self._tabWidget.detachTabByIndex(self.currentIndex())
return
# override
def mouseReleaseEvent(self, event):
'''
@param: event QMouseEvent
'''
super().mouseReleaseEvent(event)
self._dragStartPosition = QPoint()
if gVar.app.plugins().processMouseRelease(const.ON_TabBar, self,
event):
return
if not self.rect().contains(event.pos()):
return
if event.button() == Qt.MiddleButton:
if self.emptyArea(event.pos()):
self._tabWidget.addViewByUrl(QUrl(),
const.NT_SelectedTabAtTheEnd,
True)
return
id_ = self.tabAt(event.pos())
if id_ != -1:
self._tabWidget.requestCloseTab(id_)
return
_NoAction = 0
_SelectTab = 1
_PrependTab = 2
_AppendTab = 3
@classmethod
def tabDropAction(cls, pos, tabRect, allowSelect):
if not tabRect.contains(pos):
return cls._NoAction
# QPoint
c = tabRect.center()
# QSize
csize = QSize(tabRect.width() * 0.7, tabRect.height() * 0.7)
center = QRect(c.x() - csize.width() // 2,
c.y() - csize.height() // 2, csize.width(),
csize.height())
if allowSelect and center.contains(pos):
return cls._SelectTab
elif pos.x() < c.x():
return cls._PrependTab
else:
return cls._AppendTab
# override
def dragEnterEvent(self, event):
'''
@param: event QDragEnterEvent
'''
# QMimeData
mime = event.mimeData()
if mime.hasText() or mime.hasUrls() or (mime.hasFormat(self.MIMETYPE)
and event.source()):
event.acceptProposedAction()
return
super().dragEnterEvent(event)
# override
def dragMoveEvent(self, event):
'''
@param: event QDragMoveEvent
'''
index = self.tabAt(event.pos())
mime = event.mimeData()
if index == -1:
super().dragMoveEvent(event)
return
dropAction = self.tabDropAction(event.pos(), self.tabRect(index),
not mime.hasFormat(self.MIMETYPE))
if dropAction == self._PrependTab:
self.showDropIndicator(index, self.BeforTab)
elif dropAction == self._AppendTab:
self.showDropIndicator(index, self.AfterTab)
else:
self.clearDropIndicator()
# override
def dragLeaveEvent(self, event):
'''
@param: event QDragLeaveEvent
'''
self.clearDropIndicator()
super().dragLeaveEvent(event)
# override
def dropEvent(self, event): # noqa C901
'''
@param: event QDropEvent
'''
self.clearDropIndicator()
mime = event.mimeData()
if not mime.hasText() and not mime.hasUrls() and not mime.hasFormat(
self.MIMETYPE):
super().dropEvent(event)
return
event.acceptProposedAction()
sourceTabBar = event.source()
if not isinstance(sourceTabBar, TabBar):
sourceTabBar = None
index = self.tabAt(event.pos())
if index == -1:
if mime.hasUrls():
for url in mime.urls():
self._tabWidget.addViewByUrl(url,
const.NT_SelectedTabAtTheEnd)
elif mime.hasText():
self._tabWidget.addViewByReq(
gVar.app.searchEnginesManager(
).searchResultWithDefaultEngine(mime.text()),
const.NT_SelectedNewEmptyTab)
elif mime.hasFormat(self.MIMETYPE) and sourceTabBar:
tab = sourceTabBar.webTab()
if tab:
sourceTabBar._tabWidget.detachTab(tab)
tab.setPinned(False)
self._tabWidget.addViewByTab(tab, const.NT_SelectedTab)
else:
req = LoadRequest()
tab = self._tabWidget.webTab(index)
rect = self.tabRect(index)
# DropAction
action = self.tabDropAction(event.pos(), rect,
not mime.hasFormat(self.MIMETYPE))
if mime.hasUrls():
req = LoadRequest(mime.urls()[0])
elif mime.hasText():
req = gVar.app.searchEnginesManager().searchResult(mime.text())
if action == self._SelectTab:
if req.isValid():
tab.load(req)
elif action in (self._PrependTab, self._AppendTab):
if action == self._PrependTab:
newIndex = index
else:
newIndex = index + 1
if req.isValid():
self._tabWidget.addViewByReqTitle(
req, '', const.NT_SelectedNewEmptyTab, False, newIndex,
index < self.pinnedTabsCount())
elif mime.hasFormat(self.MIMETYPE) and sourceTabBar:
tab = sourceTabBar.webTab()
if tab:
if sourceTabBar == self:
if newIndex > tab.tabIndex():
toIndex = newIndex - 1
else:
toIndex = newIndex
tab.moveTab(toIndex)
else:
sourceTabBar._tabWidget.detachTab(tab)
tab.setPinned(index < self.pinnedTabsCount())
self._tabWidget.insertView(newIndex, tab,
const.NT_SelectedTab)
# override
def tabSizeHint(self, index, fast): # noqa C901
'''
@return: QSize
'''
if not self._window.isVisible():
# Don't calculate it when window is not visible
# It produces invalid size anyway
return QSize(-1, -1)
pinnedTabWidth = self._comboTabBarPixelMetric(
ComboTabBar.PinnedTabWidth)
minTabWidth = self._comboTabBarPixelMetric(
ComboTabBar.NormalTabMinimumWidth)
size = super().tabSizeHint(index)
# The overflowed tabs have same size and we can use this fast method
if fast:
if index >= self.pinnedTabsCount():
size.setWidth(minTabWidth)
else:
size.setWidth(pinnedTabWidth)
return size
webTab = self._tabWidget.widget(index)
tabBar = self
if isinstance(webTab, WebTab) and webTab.isPinned():
size.setWidth(pinnedTabWidth)
else:
availableWidth = self._mainTabBarWidth(
) - self._comboTabBarPixelMetric(self.ExtraReservedWidth)
if availableWidth < 0:
return QSize(-1, -1)
normalTabsCount = super().normalTabsCount()
maxTabWidth = self._comboTabBarPixelMetric(
ComboTabBar.NormalTabMaximumWidth)
if availableWidth >= maxTabWidth * normalTabsCount:
self._normalTabWidth = maxTabWidth
size.setWidth(self._normalTabWidth)
elif normalTabsCount > 0:
minActiveTabWidth = self._comboTabBarPixelMetric(
ComboTabBar.ActiveTabMinimumWidth)
maxWidthForTab = availableWidth // normalTabsCount
if maxWidthForTab < minActiveTabWidth:
if normalTabsCount > 1:
maxWidthForTab = (availableWidth - minActiveTabWidth
) // (normalTabsCount - 1)
else:
maxWidthForTab = 0
tryAdjusting = availableWidth >= (minTabWidth *
normalTabsCount)
if self._showCloseOnInactive != 1 and self.tabsCloseable() and \
availableWidth < (minTabWidth + 25) * normalTabsCount:
# Hiding close buttons to save some space
tabBar.setTabsCloseable(False)
tabBar._showCloseButton(self.currentIndex())
if self._showCloseOnInactive == 1:
# Always showing close buttons
tabBar.setTabsCloseable(True)
tabBar._showCloseButton(self.currentIndex())
if tryAdjusting:
self._normalTabWidth = maxWidthForTab
# Fill any empty space (we've got from rounding) with active tab
if index == self.mainTabBarCurrentIndex():
self._activeTabWidth = availableWidth - maxWidthForTab * (
normalTabsCount - 1)
size.setWidth(self._activeTabWidth)
else:
size.setWidth(self._normalTabWidth)
# Restore close buttons according to preferences
if self._showCloseOnInactive != 2 and not self.tabsCloseable() and \
availableWidth >= (minTabWidth + 25) * normalTabsCount:
tabBar.setTabsCloseable(True)
# Hide close buttons on pinned tabs
for idx in range(self.count()):
tabBar._updatePinnedTabCloseButton(idx)
if index == self.count() - 1:
lastMainActiveTab = self._tabWidget.widget(
self.mainTabBarCurrentIndex())
cornerWidth = self.cornerWidth(Qt.TopLeftCorner)
pinTabBarWidth = self._pinTabBarWidth()
xForAddTabButton = cornerWidth + pinTabBarWidth + \
self.normalTabsCount() * self._normalTabWidth
if isinstance(
lastMainActiveTab,
WebTab) and self._activeTabWidth > self._normalTabWidth:
xForAddTabButton += self._activeTabWidth - self._normalTabWidth
if QApplication.layoutDirection() == Qt.RightToLeft:
xForAddTabButton = self.width() - xForAddTabButton
tabBar.moveAddTabButton.emit(xForAddTabButton)
return size
def _comboTabBarPixelMetric(self, sizeType):
'''
@param: sizeType ComboTabBar::SizeType
'''
if sizeType == self.PinnedTabWidth:
result = self.tabMetrics()._pinnedWidth()
if result > 0: return result
else: return 32
elif sizeType == self.ActiveTabMinimumWidth:
return self.tabMetrics()._activeMinWidth()
elif sizeType == self.NormalTabMinimumWidth:
return self.tabMetrics()._normalMinWidth()
elif sizeType == self.OverflowedTabWidth:
return self.tabMetrics()._overflowedWidth()
elif sizeType == self.NormalTabMaximumWidth:
return self.tabMetrics()._normalMaxWidth()
elif sizeType == self.ExtraReservedWidth:
return self._tabWidget.extraReservedWidth()
return -1
def webTab(self, index=-1):
'''
@return: WebTab
'''
if index == -1:
result = self._tabWidget.widget(self.currentIndex())
else:
result = self._tabWidget.widget(index)
if isinstance(result, WebTab):
return result
else:
return None
class Edicion(edicion[0], edicion[1]):
trigger_comentario = pyqtSignal(str)
trigger_deslock = pyqtSignal(str)
def __init__(self, main):
super().__init__()
self.setupUi(self)
self.pos = [0, 0]
self.main = main
self.comentarios.clicked.connect(self.mostrar_comentarios)
self.comentar.clicked.connect(self.comentar_foto)
self.trigger_comentario.connect(main.cliente.enviar_comentario)
self.trigger_deslock.connect(main.cliente.deslock)
self.veces_click = 0
self.contscroll.hide()
self.vbox = QVBoxLayout(self.contscroll)
self.color.clicked.connect(self.mostrar_colores)
self.selected_color = QColor(110, 20, 50)
self.frame = QFrame(self)
self.frame.setGeometry(110 - 20, 25, 15, 15)
self.frame.setStyleSheet('QWidget {background-color: %s}' %
self.selected_color.name())
self.puede = None
self.recortar.clicked.connect(self.recorte)
self.blur.clicked.connect(self.edit_blur)
self.origin = QPoint()
self.imag = None
self.recortar = []
def edit_blur(self):
self.edicion.mousePressEvent = self.blur_press
def blur_press(self, event):
position = event.pos()
"""acá deberia inicializar los cambios para la edicion"""
def mostrar_comentarios(self):
if self.veces_click % 2 == 0:
self.contscroll.show()
else:
self.contscroll.hide()
self.veces_click += 1
def imagen(self, nombre):
self.imag = nombre
self.edicion.hide()
self.edicion.origin = QPoint()
self.edicion.ruber = QRubberBand(QRubberBand.Rectangle, self.edicion)
self.pixmap4 = QPixmap(nombre).scaled(781, 621)
self.pixmap = self.pixmap4.toImage()
self.edicion.setPixmap(self.pixmap4)
self.edicion.setAlignment(Qt.AlignCenter)
self.edicion.show()
self.show()
def recorte(self):
self.edicion.mouseMoveEvent = self.move_event
self.edicion.mouseReleaseEvent = self.realase_event
self.edicion.mousePressEvent = self.press_event
def move_event(self, event):
if not self.origin.isNull():
self.edicion.ruber.setGeometry(
QRect(self.origin, event.pos()).normalized())
def realase_event(self, event):
if event.button() == Qt.LeftButton:
self.edicion.ruber.hide()
self.recortar.append([event.pos().x(), event.pos().y()])
self.realizar_recorte()
def realizar_recorte(self):
"""obtengo mal los bytes de la imagen que se muestra así que no funciona
bien uwu """
byts, ind_ihdr, ind_idat, ind_iend = leer_imagen(self.imag + '.png')
new_idr = idr(byts, ind_ihdr)
largo, ancho, largo_ihdr, largo_idat, largo_iend = obtner_largos(
byts, ind_ihdr, ind_idat, ind_iend)
matriz = obtener_matriz(byts, largo, ancho, ind_idat, largo_idat)
print(self.recortar)
for i in range(self.recortar[0][0], self.recortar[0][1]):
for j in range(self.recortar[1][0], self.recortar[1][1]):
matriz[i][j] = [255, 255, 255]
m_con0 = agregar_ceros(matriz)
tr = transformar(m_con0)
idat = crear_idat(tr, byts, ind_idat)
foto = byts[0:8] + new_idr + idat + byts[ind_iend - 4:ind_iend + 4 +
largo_iend + 4]
os.remove(self.imag + '.png')
time.sleep(0.5)
with open(self.imag + '.png', 'wb') as fil:
fil.write(foto)
self.imagen(self.imag)
def press_event(self, event):
if event.button() == Qt.LeftButton:
self.recortar.append([event.pos().x(), event.pos().y()])
self.origin = QPoint(event.pos())
self.edicion.ruber.setGeometry(QRect(self.origin, QSize()))
self.edicion.ruber.show()
def pixelSelect(self, event):
position = QPoint(event.pos().x(), event.pos().y())
color = QColor.fromRgb(self.pixmap.pixel(position))
print(color.red(), color.green(), color.blue())
def comentar_foto(self):
fecha_hora = datetime.datetime.now()
fecha = '{}/{}/{}'.format(fecha_hora.day, fecha_hora.month,
fecha_hora.year)
hora = '{}:{}'.format(fecha_hora.hour, fecha_hora.minute)
self.trigger_comentario.emit(fecha + ' ' + hora + ' ' + ' ' +
self.main.cliente.nombre + ' : ' +
self.comentario.text())
self.comentario.setText('')
def comentarr(self, list):
for coment in list:
self.label = QLabel(self.contscroll)
self.label.move(self.pos[0], self.pos[1])
self.label.setText(' ' + coment)
self.vbox.addWidget(self.label)
self.label.show()
self.pos[1] = self.pos[1] + 25
def closeEvent(self, event):
event.accept()
self.main.show()
self.trigger_deslock.emit(self.imag)
self.imag = None
def mostrar_colores(self):
if self.puede:
self.edicion.mousePressEvent = self.pixelSelect
selected_color = QColorDialog.getColor()
matrix = (selected_color.red(), selected_color.green(),
selected_color.blue())
if selected_color.isValid():
self.frame.setStyleSheet('QWidget {background-color: %s}' %
selected_color.name())
