def mimeData(self, indexes):
"""
Public method to return the mime data.
@param indexes list of indexes (QModelIndexList)
@return mime data (QMimeData)
"""
from .XbelWriter import XbelWriter
data = QByteArray()
stream = QDataStream(data, QIODevice.WriteOnly)
urls = []
for index in indexes:
if index.column() != 0 or not index.isValid():
continue
encodedData = QByteArray()
buffer = QBuffer(encodedData)
buffer.open(QIODevice.ReadWrite)
writer = XbelWriter()
parentNode = self.node(index)
writer.write(buffer, parentNode)
stream << encodedData
urls.append(index.data(self.UrlRole))
mdata = QMimeData()
mdata.setData(self.MIMETYPE, data)
mdata.setUrls(urls)
return mdata
def __init__(self, l):
super().__init__()
mimedata = QMimeData()
mimedata.setUrls([QUrl.fromLocalFile(os.path.abspath(fn)) for fn in l])
qdrag = QDrag(self)
qdrag.setMimeData(mimedata)
qdrag.exec(Qt.DropAction.MoveAction)
def mimeData(self, indexes):
"""
Public method to return the mime data.
@param indexes list of indexes (QModelIndexList)
@return mime data (QMimeData)
"""
from .XbelWriter import XbelWriter
data = QByteArray()
stream = QDataStream(data, QIODevice.WriteOnly)
urls = []
for index in indexes:
if index.column() != 0 or not index.isValid():
continue
encodedData = QByteArray()
buffer = QBuffer(encodedData)
buffer.open(QIODevice.ReadWrite)
writer = XbelWriter()
parentNode = self.node(index)
writer.write(buffer, parentNode)
stream << encodedData
urls.append(index.data(self.UrlRole))
mdata = QMimeData()
mdata.setData(self.MIMETYPE, data)
mdata.setUrls(urls)
return mdata
def copy_selected(self, index):
filename = self.model.fileName(index)
filepath = self.model.filePath(index)
data = QMimeData()
url = QUrl.fromLocalFile(filepath)
clipboard = QApplication.clipboard()
data.setUrls([url])
clipboard.setMimeData(data)
def StartDrag(self):
drag = QDrag(self)
data = QMimeData()
data.setText(None)
data.setUrls([QUrl.fromLocalFile(self.imgFile)])
drag.setMimeData(data)
drag.setPixmap(QPixmap(paths['imagePath'] + 'dnd2.png'))
drag.exec_()
def dragFile(widget, filename, icon=None, dropactions=Qt.CopyAction):
"""Starts dragging the given local file from the widget."""
if icon is None or icon.isNull():
icon = QFileIconProvider().icon(QFileInfo(filename))
drag = QDrag(widget)
data = QMimeData()
data.setUrls([QUrl.fromLocalFile(filename)])
drag.setMimeData(data)
drag.setPixmap(icon.pixmap(32))
drag.exec_(dropactions)
def dragFile(widget, filename, icon=None, dropactions=Qt.CopyAction):
"""Starts dragging the given local file from the widget."""
if icon is None or icon.isNull():
icon = QFileIconProvider().icon(QFileInfo(filename))
drag = QDrag(widget)
data = QMimeData()
data.setUrls([QUrl.fromLocalFile(filename)])
drag.setMimeData(data)
drag.setPixmap(icon.pixmap(32))
drag.exec_(dropactions)
def mimeData(self, indexes):
mimedata = QMimeData()
for idx in indexes:
idxPeer = self.index(idx.row(), 1, idx.parent())
if idxPeer.isValid():
peer = self.data(idxPeer, Qt.DisplayRole)
mimedata.setUrls([QUrl('galacteekpeer:{}'.format(peer))])
break
return mimedata
def copyImage(self):
p = os.path.join(os.getcwd(), findImagePage(self.product.imageUrl))
print("copyImage path:", p)
url = QUrl.fromLocalFile(p)
m = QMimeData()
m.setUrls([url])
clipboard = QApplication.clipboard()
clipboard.setMimeData(m)
print("isValid:", url.isValid())
def mimeData(self, indexes):
mimedata = QMimeData()
for idx in indexes:
if not idx.isValid():
continue
nameItem = self.getNameItemFromIdx(idx)
if nameItem:
mimedata.setUrls([nameItem.qIpfsUrl])
break
return mimedata
def mimeData(self, indexes):
"""
Public method to return the mime data.
@param indexes list of indexes (QModelIndexList)
@return mime data (QMimeData)
"""
urls = []
for index in indexes:
url = index.data(HistoryModel.UrlRole)
urls.append(url)
mdata = QMimeData()
mdata.setUrls(urls)
return mdata
def mimeData(self, indexes):
"""
Public method to return the mime data.
@param indexes list of indexes (QModelIndexList)
@return mime data (QMimeData)
"""
mimeData = QMimeData()
urls = []
for index in indexes:
if index.isValid():
itm = self.__manager.downloads()[index.row()]
urls.append(QUrl.fromLocalFile(itm.absoluteFilePath()))
mimeData.setUrls(urls)
return mimeData
def mimeData(self, indexes):
"""
Public method to return the mime data.
@param indexes list of indexes (QModelIndexList)
@return mime data (QMimeData)
"""
mimeData = QMimeData()
urls = []
for index in indexes:
if index.isValid():
itm = self.__manager.downloads()[index.row()]
urls.append(QUrl.fromLocalFile(itm.absoluteFilePath()))
mimeData.setUrls(urls)
return mimeData
def mimeData(self, indexes):
"""
Public method to return the mime data.
@param indexes list of indexes (QModelIndexList)
@return mime data (QMimeData)
"""
urls = []
for index in indexes:
url = index.data(HistoryModel.UrlRole)
urls.append(url)
mdata = QMimeData()
mdata.setUrls(urls)
return mdata
def startDrag(self, mainwin, ev):
d = mainwin.currentDocument()
if not d:
return
url = d.url()
if url.isEmpty():
return
drag = QDrag(mainwin)
data = QMimeData()
data.setUrls([url])
drag.setMimeData(data)
pixmap = mainwin.style().standardPixmap(QStyle.SP_FileIcon, 0, mainwin)
hotspot = QPoint(pixmap.width() - 5, 5)
drag.setPixmap(pixmap)
drag.setHotSpot(hotspot)
drag.start(Qt.LinkAction | Qt.CopyAction)
def mimeData(self, indexes):
mimedata = QMimeData()
urls = []
for idx in indexes:
if not idx.isValid():
continue
nameItem = self.getNameItemFromIdx(idx)
if nameItem:
url = QUrl(nameItem.ipfsPath.ipfsUrl)
urls.append(url)
mimedata.setUrls(urls)
return mimedata
def startDrag(self, mainwin, ev):
d = mainwin.currentDocument()
if not d:
return
url = d.url()
if url.isEmpty():
return
drag = QDrag(mainwin)
data = QMimeData()
data.setUrls([url])
drag.setMimeData(data)
pixmap = mainwin.style().standardPixmap(QStyle.SP_FileIcon, 0, mainwin)
hotspot = QPoint(pixmap.width() - 5, 5)
drag.setPixmap(pixmap)
drag.setHotSpot(hotspot)
drag.start(Qt.LinkAction | Qt.CopyAction)
def mimeData(self, indexes):
mimedata = QMimeData()
urls = []
for idx in indexes:
if not idx.isValid():
continue
eInfo = self.getUnixFSEntryInfoFromIdx(idx)
if eInfo:
url = QUrl(eInfo.ipfsPath.ipfsUrl)
urls.append(url)
mimedata.setUrls(urls)
return mimedata
def test_EditorPane_drop_event():
"""
If there's a drop event associated with files, cause them to be passed into
Mu's existing file loading code.
"""
ep = mu.interface.editor.EditorPane(None, 'baz')
m = mock.MagicMock()
ep.open_file = mock.MagicMock()
ep.open_file.emit = m
data = QMimeData()
data.setUrls([QUrl('file://test/path.py'), QUrl('file://test/path.hex'),
QUrl('file://test/path.txt')])
evt = QDropEvent(QPointF(0, 0), Qt.CopyAction, data,
Qt.LeftButton, Qt.NoModifier)
ep.dropEvent(evt)
# Upstream _load will handle invalid file type (.txt).
assert m.call_count == 3
def test_file_dd_filter_drag_enter_event(qtbot):
widget = QLineEdit()
qtbot.addWidget(widget)
mime = QMimeData()
mime.setUrls([
QUrl("file:///path/to/file"),
])
action = Qt.CopyAction | Qt.MoveAction
point = widget.rect().center()
event = QDragEnterEvent(point, action, mime, Qt.LeftButton, Qt.NoModifier)
event_filter = events.FileDragAndDropFilter()
assert event_filter.eventFilter(widget, event)
assert event.isAccepted()
def test_EditorPane_drop_event():
"""
If there's a drop event associated with files, cause them to be passed into
Mu's existing file loading code.
"""
ep = mu.interface.editor.EditorPane(None, 'baz')
m = mock.MagicMock()
ep.open_file = mock.MagicMock()
ep.open_file.emit = m
data = QMimeData()
data.setUrls([QUrl('file://test/path.py'), QUrl('file://test/path.hex'),
QUrl('file://test/path.txt')])
evt = QDropEvent(QPointF(0, 0), Qt.CopyAction, data,
Qt.LeftButton, Qt.NoModifier)
ep.dropEvent(evt)
# Upstream _load will handle invalid file type (.txt).
assert m.call_count == 3
def updateMimeData(self, hasColor, color, hasHtml, html, hasImage, image,
hasText, text, hasUrls, urls):
# 远程的剪贴板同步到客户端
clipboard = QApplication.clipboard()
clipboard.blockSignals(True)
data = QMimeData()
if hasColor:
data.setColorData(color)
if hasHtml:
data.setHtml(html)
if hasImage:
data.setImageData(image)
if hasText:
data.setText(text)
if hasUrls:
data.setUrls(urls)
clipboard.setMimeData(data)
clipboard.blockSignals(False)
def mimeData(self, indexes):
mimedata = QMimeData()
for idx in indexes:
if not idx.isValid():
continue
nameItem = self.getNameItemFromIdx(idx)
if nameItem:
mimedata.setUrls([nameItem.qIpfsUrl])
# Inventing MIME types
mimedata.setData(
'ipfs/mfs-entry-name',
nameItem.text().encode())
break
return mimedata
def selection_to_mimedata(self,
uri_only=False,
action: Qt.DropActions = None):
mime_data = QMimeData()
fileinfos = self.selected_fileinfos()
urls = [QUrl.fromLocalFile(fi.abspath()) for fi in fileinfos]
mime_data.setUrls(urls)
if not uri_only:
text = "\n".join([fi.abspath() for fi in fileinfos])
mime_data.setText(text)
if action is not None:
gnome_copied_files = make_gnome_copied_files(action, urls)
mime_data.setData("x-special/gnome-copied-files",
gnome_copied_files)
return mime_data
def mousePressEvent(self, ev):
if self.type == 'img_label' and ev.buttons() & Qt.RightButton:
_clipboard = QApplication.clipboard()
if self.alt:
_clipboard.setPixmap(self.alt)
else:
_clipboard.setPixmap(self.pixmap())
try:
w_history = self.parent.parent
_text = "Image copied."
self.worker = MFWorker(w_history.showHint,
args=(_text,
int(CFG.CFG_HINT_SHOW_MS())))
self.worker.start()
except Exception:
pass
pass
elif self.type == 'img_label' and ev.buttons() & Qt.LeftButton:
_pixmap = self.alt if self.alt else self.pixmap()
w_preview = MFImagePreviewer(self, _pixmap)
pass
elif self.type == 'file_label' and ev.buttons() & Qt.RightButton:
_clipboard = QApplication.clipboard()
_mimeData = QMimeData()
_mimeData.setUrls([QUrl.fromLocalFile(str(self.alt))])
_clipboard.setMimeData(_mimeData)
try:
w_history = self.parent.parent
_text = "File <u>%s</u> copied." % self.alt.name
self.worker = MFWorker(w_history.showHint,
args=(_text,
int(CFG.CFG_HINT_SHOW_MS())))
self.worker.start()
except:
pass
pass
elif self.type == 'file_label' and ev.buttons() & Qt.LeftButton:
QDesktopServices.openUrl(QUrl.fromLocalFile(POSIX(
self.alt.parent)))
pass
return super().mousePressEvent(ev)
def mouseMoveEvent(self, evt):
"""
Protected method to handle mouse move events.
@param evt reference to the mouse event (QMouseEvent)
"""
if evt.button() == Qt.LeftButton and \
(evt.pos() - self.__dragStartPos).manhattanLength() > \
QApplication.startDragDistance() and \
self.__browser is not None:
drag = QDrag(self)
mimeData = QMimeData()
title = self.__browser.title()
if title == "":
title = str(self.__browser.url().toEncoded(), encoding="utf-8")
mimeData.setText(title)
mimeData.setUrls([self.__browser.url()])
p = self.pixmap()
if p:
drag.setPixmap(p)
drag.setMimeData(mimeData)
drag.exec_()
def mouseMoveEvent(self, evt):
"""
Protected method to handle mouse move events.
@param evt reference to the mouse event (QMouseEvent)
"""
if evt.button() == Qt.LeftButton and \
(evt.pos() - self.__dragStartPos).manhattanLength() > \
QApplication.startDragDistance() and \
self.__browser is not None:
drag = QDrag(self)
mimeData = QMimeData()
title = self.__browser.title()
if title == "":
title = str(self.__browser.url().toEncoded(), encoding="utf-8")
mimeData.setText(title)
mimeData.setUrls([self.__browser.url()])
p = self.pixmap()
if p:
drag.setPixmap(p)
drag.setMimeData(mimeData)
drag.exec_()
class explore(QWidget):
files = None
icon_size = 120
hidden = False
maxWidth = 1200
scroll_pos_old = 0
scroll_pos = 0
btns = []
#targetType = None
mouse = [0, 0]
collized = []
#Print with hotkey
keyPrint = None
selectBtn = None
anitimer = None
newSelect = 0
select_old = [0]
def __init__(self, parent=None):
super(explore, self).__init__(parent)
self.parent = parent
self.setAcceptDrops(True)
self.init()
def init(self):
sys.modules['explore'] = self
self.core = core()
self.keyPrint = lambda: (print(
self.btns), print(len(self.btns), print('f:', self.files)))
self.history = self.parent.parent().history
self.scroll = QScrollArea(self)
self.window = QWidget(self)
self.window.setAcceptDrops(True)
self.scroll.setWidget(self.window)
self.scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
#self.scroll.verticalScrollBar().valueChanged.connect(self.wh_change)
#self.scroll.verticalScrollBar().sliderMoved.connect(self.scrollMoved)
#self.scroll.mousePressEvent = lambda e: print(e, 'de')
self.scrBar = QScrollBar()
self.scroll.setVerticalScrollBar(self.scrBar)
self.scrBar.valueChanged.connect(self.wh_change)
self.scrBar.sliderMoved.connect(self.scrollMoved)
self.scrBar.wheelEvent = self.wh
self.scrBar.mousePressEvent = self.scrollBarPress
self.scrBar.mouseMoveEvent = self.scrollBarMove
self.scroll.wheelEvent = self.wh
self.anitimer = QTimer()
self.anitimer.setInterval(1000 / 60)
self.anitimer.timeout.connect(self.ani_func)
self.anitimer.start()
self.qrun = qrun(self)
self.app = QApplication([])
hk = sys.modules['scr.hotkey'].hotkey
def setkey(name, func):
key = initKey()
hk.setInitName(hk, name)
key.func = func
hk.add(hk, key)
setkey('redo', lambda: self.redo())
setkey('undo', lambda: self.undo())
setkey('selectall', lambda: self.selectAll())
setkey('deselectall', lambda: self.deselect())
setkey('keyright', lambda: self.keyArrow('right'))
setkey('keyleft', lambda: self.keyArrow('left'))
setkey('keyup', lambda: self.keyArrow('up'))
setkey('keydown', lambda: self.keyArrow('down'))
setkey('ctrlkeyright', lambda: self.keyArrow('right', 1))
setkey('ctrlkeyleft', lambda: self.keyArrow('left', 1))
setkey('ctrlkeyup', lambda: self.keyArrow('up', 1))
setkey('ctrlkeydown', lambda: self.keyArrow('down', 1))
setkey('keyenter', lambda: self.keyEnter())
setkey('keyreturn', lambda: self.keyEnter())
setkey('copy', lambda: self.copyCB())
setkey('paste', lambda: self.pasteCB())
setkey('toggleqrun', lambda: self.qrun.toggle())
setkey('escape', lambda: print('esc explore'))
sys.modules['m'].callbackResize.append(self.res)
self.res()
def copyCB(self): #CLIPBOARD
self.collized = [x for x in self.btns if x.select == True]
self.sourceDir = os.getcwd()
if self.collized:
if self.current_dir[-1] == "/":
self.current_dir = self.current_dir[:-1]
self.mimeData = QMimeData()
self.urls = []
for e in self.collized:
self.urls.append(
QUrl.fromLocalFile(self.current_dir + '/' + e.value))
self.mimeData.setUrls(self.urls)
#--------------------------------
cb = self.app.clipboard()
cb.clear(mode=cb.Clipboard)
self.app.clipboard().setMimeData(self.mimeData, mode=cb.Clipboard)
def pasteCB(self): #CLIPBOARD
print("paste")
print(self.app.clipboard().mimeData().urls())
links = []
mimeurls = self.app.clipboard().mimeData().urls()
for url in mimeurls:
url = QUrl(url)
links.append(url.toLocalFile())
cp = sys.modules['scr.core'].core.copy
cp(sys.modules['scr.core'].core, self.sourceDir, links, os.getcwd())
self.refresh()
pass
def keyEnter(self):
try:
self.selectBtn = self.btns[self.newSelect]
except:
self.selectBtn = self.btns[0]
self.selectFile = os.path.normpath(self.current_dir + '/' +
self.selectBtn.value)
if os.path.isdir(self.selectFile):
self.setDir(self.current_dir + '/' + self.selectBtn.value)
self.history.set(self.current_dir, self.scroll_pos)
else:
self.setDir(self.current_dir + '/' + self.selectBtn.value)
self.lm_menu()
def selectFiles(self):
self.collized = [x.value for x in self.btns if x.select == True]
return self.collized
def keyArrow(self, e, mod=0):
if self.btns:
iconPerRow = int(self.scroll.width() / self.icon_size)
iconPerCol = int(self.scroll.height() / self.icon_size)
selectOn = [x for x in self.btns if x.select == True]
frameTop = self.scroll_pos
frameBottom = self.scroll_pos + iconPerCol * 120
if selectOn:
#select = selectOn[:1][0].value
slo = self.select_old[-1]
#select = self.btns[self.select_old[-1]][0].value
select = self.btns[slo].value
else:
select = self.btns[0].value
for i in range(len(self.btns)):
if select == self.btns[i].value:
if e == 'left':
if i - 1 >= -1:
self.deselect()
if i - 1 == -1:
self.newSelect = 0
else:
self.newSelect = i - 1
b = self.btns[self.newSelect]
b.select = True
b.leaveEvent(QMouseEvent)
elif e == 'right':
if i + 1 < len(self.btns):
self.deselect()
self.newSelect = i + 1
b = self.btns[self.newSelect]
b.select = True
b.leaveEvent(QMouseEvent)
elif e == 'up':
if i - iconPerRow >= 0:
self.deselect()
self.newSelect = i - iconPerRow
b = self.btns[self.newSelect]
b.select = True
b.leaveEvent(QMouseEvent)
elif e == 'down':
if i + iconPerRow < len(self.btns):
self.deselect()
self.newSelect = i + iconPerRow
b = self.btns[self.newSelect]
b.select = True
b.leaveEvent(QMouseEvent)
if mod == 1:
for e in self.select_old:
b = self.btns[e]
b.select = True
b.leaveEvent(QMouseEvent)
self.select_old += [self.newSelect]
else:
self.select_old = [self.newSelect]
print(self.select_old)
######################################################
selectOnLine = int(self.newSelect / iconPerRow)
PosOnSelect = selectOnLine * self.icon_size
if PosOnSelect < frameTop:
self.scroll_pos = PosOnSelect
elif PosOnSelect > frameBottom - 120:
self.scroll_pos = PosOnSelect - 120 * 3
if e == 'enter':
pass
def scrollMoved(self):
#self.targetType = None
pass
def mousePressed(self, e): #НЕ РАБОТАЕТ
self.globalPos = e.globalPos()
def scrollBarPress(self, e):
self.vbar = self.scroll.verticalScrollBar()
frameHeight = self.scroll.height()
current = self.vbar.value()
currentClick = int(self.window.height() * (e.y() / frameHeight))
min = current
max = min + (self.window.height() - self.vbar.maximum())
if not (currentClick > min and currentClick < max):
if currentClick > max:
self.scroll_pos += self.scroll.height()
elif currentClick < min:
self.scroll_pos -= self.scroll.height()
else: #Scroll Btn
self.dragStartScroll = currentClick - min # нужно, чтобы убрать дерганье
super(explore, self).mousePressEvent(e)
def scrollBarMove(self, e):
scrH = self.scroll.height()
wH = self.window.height() #self.vbar.maximum()
pos = e.y() / scrH
try:
self.hardScroll((wH * pos) - self.dragStartScroll)
except:
pass
def wh_change(self, e):
#print(e, self.scroll_pos, self.targetType)
#if self.targetType == None:
#EEEE
#self.scroll_pos = self.scroll_pos_old = e
pass
def wh(self, e):
max = self.scroll.verticalScrollBar().maximum()
#self.targetType = 'wheel'
self.scroll_pos = self.scroll_pos - e.angleDelta().y()
if self.scroll_pos > max:
self.hardScroll(max - 1)
elif self.scroll_pos < 0:
self.hardScroll(0)
def hardScroll(self, e):
self.scroll_pos = self.scroll_pos_old = e
def ani_func(self):
self.scroll_pos_old = self.scroll_pos_old - (
(self.scroll_pos_old - self.scroll_pos) / 4)
self.scroll.verticalScrollBar().setValue(self.scroll_pos_old)
def setSize(self, *size):
h, v = size
print(self.size())
self.window.setFixedWidth(h)
self.setFixedSize(*size)
self.scroll.setFixedSize(h, v - 20)
self.maxWidth = int(self.width() / self.icon_size) * self.icon_size
self.reposition()
def run_c(self, command):
"""Executes a system command."""
def lm_cmd(self):
cmd = self.lb.text() + ' ' + "'" + self.selectFile + "'"
self.cmd_run(cmd)
def rm_cmd(self):
cmd = self.lb.text()
self.cmd_run(cmd)
def cmd_run(self, command):
print(command)
#subprocess.Popen(command, shell=True, stdout=subprocess.PIPE)
pros = QProcess(self)
pros.finished.connect(self.proc_finish)
str = "/bin/sh -c \"" + command + "\""
pros.start(str)
try:
self.mousemenu.close()
except:
pass
#self.scroll.verticalScrollBar().setValue = self.scroll_pos
#update
pass
def proc_finish(self):
self.refresh()
def lm_menu(self):
print(self.selectFile)
self.cmd_run("xdg-open " + self.selectFile)
return
#НУЖНО ЛИ МЕНЮ НА ЛЕВЫЙ КЛИК?
#НАВЕРНОЕ ЛУЧШЕ ОРГАНИЗОВАТЬ ЧЕРЕЗ ПРОБЕЛ
self.mousemenu = QMenu(self)
act = QWidgetAction(self)
self.menuMain = QWidget(self)
self.menuMain.setStyleSheet('background: #111')
#XDG-OPEN
self.btn_open = QPushButton(self.menuMain)
self.btn_open.setStyleSheet(
"background: gray; text-align: left; padding-left: 3px")
self.btn_open.setText("Open")
self.btn_open.setFixedSize(194, 20)
self.btn_open.pressed.connect(
lambda: self.cmd_run("xdg-open " + self.selectFile))
self.btn_open.move(3, 3)
#INPUT CMD
self.lb = QLineEdit(self.menuMain)
self.lb.move(3, 23)
self.lb.setFixedSize(194, 20)
self.lb.setPlaceholderText('cmd')
self.lb.setStyleSheet('background: white')
self.lb.returnPressed.connect(self.lm_cmd)
self.menuMain.setFixedSize(200, 100)
act.setDefaultWidget(self.menuMain)
self.mousemenu.addAction(act)
try:
self.mousemenu.exec_(self.globalPos)
except:
self.mousemenu.exec_([0, 0])
def contextMenuEvent(self, event):
self.mousemenu = QMenu(self)
act = QWidgetAction(self)
self.menuSecond = QWidget(self)
self.menuSecond.setStyleSheet('background: #511')
self.lb = QLineEdit(self.menuSecond)
self.lb.move(3, 3)
self.lb.setFixedSize(194, 20)
self.lb.setPlaceholderText('cmd')
self.lb.setStyleSheet('background: white')
self.lb.returnPressed.connect(self.rm_cmd)
self.menuSecond.setFixedSize(200, 100)
act.setDefaultWidget(self.menuSecond)
self.mousemenu.addAction(act)
self.mousemenu.exec_(self.globalPos)
def btnsClear(self):
if len(self.btns):
for i in self.btns:
i.deleteLater()
del i
del self.btns[:] # че за хрень
def setDir(self, dir):
dir = dir.replace("//", "/")
#dir_enc = self.dFilter.enc(dir)
#dir_dec = self.dFilter.dec(dir_enc)
if os.path.isdir(dir) != True:
if self.selectBtn.select != True:
self.selectBtn.select = True
return
self.btnsClear()
self.current_dir = dir.replace("//", "/")
self.core.sort = 'abs123'
self.files = self.core.read_dir(self.current_dir)
#FILTER DIR
self.parent.parent().address.setText(dir)
os.chdir(dir)
#self.history.set(self.current_dir)
self.cycle = self.tmpL = 0
self.asyncRender()
self.refreshtime = QTimer()
self.refreshtime.timeout.connect(self.refresh)
self.refreshtime.start(1000)
"""
self.ftime = QTimer()
self.ftime.timeout.connect(self.dir_final)
self.ftime.start(1000/60)
"""
sys.modules['m'].setProgramName(sys.modules['appName'] + ' - ' +
os.path.basename(os.getcwd()))
#def dir_final(self):
# self.ftime.deleteLater()
"""
try:
self.btns[0].select = True
self.btns[0].leaveEvent(QMouseEvent)
except:
print("first select btns error")
"""
def redo(self):
link = self.history.get(1)
if link != None:
#self.hardScroll()
self.hardScroll(link[2])
self.setDir(link[1])
def undo(self):
link = self.history.get(-1)
if link != None:
self.hardScroll(link[2])
self.setDir(link[1])
def selectAll(self):
#selectOn = next((x for x in self.btns if x.select == True), None)
selectOn = [x for x in self.btns if x.select == True]
if not len(selectOn) == len(self.btns):
for b in self.btns:
b.selected()
b.leaveEvent(QMouseEvent)
else:
for b in self.btns:
b.unselected()
b.leaveEvent(QMouseEvent)
def deselect(self):
for b in self.btns:
b.unselected()
b.leaveEvent(QMouseEvent)
def asyncRender(self):
self.renderTime = QTimer()
self.renderTime.timeout.connect(self.render)
self.renderTime.start(1000 / 60)
def getTextSplit(self, text):
def width(t):
return label.fontMetrics().boundingRect(t).width()
label = QLabel()
mw = self.icon_size - 15
spl = text.split(' ')
group = ''
for item in spl:
if width(item) > mw:
i = 0
w = 0
letter = ''
while True:
w = w + width(item[i])
if w > mw:
w = 0
letter += ' ' + item[i]
elif item[i] == '-':
w = 0
letter += item[i] + ' '
else:
letter += item[i]
i = i + 1
if i == len(item):
break
group += letter + ' '
else:
group += item + ' '
return group
def rebuild(self):
btns_rebuild = []
for f in self.btns:
try:
f.move(1, 1)
btns_rebuild.append(f)
except:
pass
self.btns = btns_rebuild
def res(self):
print('a', self.window.size(), self.size())
def reposition(self):
if self.btns == None:
self.btns = []
self.rebuild()
#if f.value not in self.files:
# print(f.value)
#self.create_button(f.value)
#123
i = 0
l = 0
for f in self.btns:
count_hoz = int(self.maxWidth / self.icon_size)
x = (self.icon_size * i) % self.maxWidth
y = self.icon_size * l
try:
f.move(x, y)
except:
print('ERROR BTN', f)
if i % count_hoz == count_hoz - 1:
l = l + 1
i = i + 1
#WINDOW SCROLL
m = sys.modules['m']
if self.window.height() <= self.height() - m.addrborder.height():
self.window.setFixedHeight(self.height() - m.addrborder.height())
else:
self.window.setFixedHeight((l + 1) * self.icon_size)
def dir_mod(self):
self.refresh()
def create_button(self, f):
btn = object_file(self.window)
realfile = self.current_dir + '/' + f
#btn.realfile = realfile
if core.type_file(self, realfile) == 'folder':
btn.setIconFromTheme('folder')
else:
ic = iconProvider()
ic = ic.icon(QFileInfo(realfile))
btn.setIcon(ic)
btn.setFileSize(120, 120)
btn.setText(f)
btn.init()
btn.value = f
btn.clicked.connect(self.btn_press)
btn.setTrigger('123')
self.btns.append(btn)
def refresh(self):
dir = self.current_dir
#dir_dec = d.dec(dir)
self.core.sort = 'abs123'
#GET NEW LS`
self.newfiles = self.core.read_dir(dir)
l1 = set(self.files)
l2 = set(self.newfiles)
toDel = l1 - l2
if len(toDel) > 0:
for d in toDel:
for btn in self.btns:
if d == btn.value:
btn.deleteLater()
toAdd = l2 - l1
unique = list(dict.fromkeys(toAdd))
for f in unique:
self.create_button(f)
def btn_text(elem):
return core.nat_keys(self, elem.value)[0]
if self.btns != None:
self.btns.sort(key=btn_text)
self.btns = self.splitFolders(self.btns)
self.files = self.newfiles
self.reposition()
def splitFolders(self, source_files):
if source_files == None:
return
if len(source_files) == 0:
return
folders = []
files = []
if type(source_files[0]) is object_file:
for file in source_files:
realfile = self.current_dir + '/' + file.value
if file.value[0] != '.' or self.hidden != True:
if core.type_file(self, realfile) == 'folder':
folders.append(file)
else:
files.append(file)
else:
for file in source_files:
realfile = self.current_dir + '/' + file
if file[0] != '.' or self.hidden != True:
if core.type_file(self, realfile) == 'folder':
folders.append(file)
else:
files.append(file)
return folders + files
def render(self):
if len(self.files) == 0:
return
i = self.cycle
l = self.tmpL
combine = self.splitFolders(self.files)
cycleAll = int(len(combine) / 50) * 50
try:
float_perc = self.cycle / cycleAll
except ZeroDivisionError:
float_perc = 0
self.parent.parent().setLoadPercent(float_perc * 100)
if int(float_perc) == 1:
self.parent.parent().hideLoader()
for file in range(len(combine)):
file = file + self.cycle
btn = object_file(self.window)
try:
realfile = self.current_dir + '/' + combine[file]
except:
print('733 explore', 'no found file error')
return
btn.realfile = realfile
if core.type_file(self, realfile) == 'folder':
btn.setIconFromTheme('folder')
else:
ic = iconProvider()
ic = ic.icon(QFileInfo(realfile))
btn.setIcon(ic)
btn.setFileSize(120, 120)
btn.setText(combine[file])
btn.init()
x = (self.icon_size * i) % self.maxWidth
y = self.icon_size * l
btn.move(x, y)
count_hoz = int(self.maxWidth / self.icon_size)
if file % count_hoz == count_hoz - 1:
l = l + 1
i = i + 1
btn.value = combine[file]
try:
btn.date = os.path.getctime(realfile)
except:
btn.date = 0
btn.clicked.connect(self.btn_press)
btn.setTrigger(lambda: self.button_trigger)
self.btns.append(btn)
if i % 50 == 0:
self.cycle = i
self.tmpL = l
break
elif file == len(combine) - 1:
self.renderTime = None
self.cycle = -1
break
self.window.setFixedHeight((l + 1) * self.icon_size)
if self.cycle == -1:
return
self.asyncRender()
def collision(self):
iscoll = []
for b in self.btns:
e = {
'x': b.pos().x() + 120,
'y': b.pos().y() + 120,
'w': (b.pos().x() + b.size.width()) - b.size.width(),
'h': (b.pos().y() + b.size.height()) - b.size.height()
}
if (e['x'] > self.select_rect_coll[0] and e['w'] < self.select_rect_coll[2]) \
and (e['y'] > self.select_rect_coll[1] and e['h'] < self.select_rect_coll[3]):
iscoll.append(b)
return iscoll
def mousePressEvent(self, QMouseEvent):
#self.unSelectAll() #Здесь сбивает работу мыши
hover = self.isHoverButton()
if not hover:
self.deselect()
self.press = True
self.globalPos = QMouseEvent.globalPos()
self.windowMouseCoord = self.window.mapFromGlobal(
QMouseEvent.globalPos())
self.selection = QFrame(self.window)
self.selection.setStyleSheet("""
background: rgba(140,200,255,.0);
border-radius: 10px;
border-width: 1px;
border-style: solid;
border-color: rgba(0,0,0,.2);
""")
self.startCoord = QPoint(self.windowMouseCoord)
#if abs(self.startCoord.x()) > 1 and abs(self.startCoord.y()) > 1:
self.selection.setFixedSize(0, 0)
self.selection.move(5, 5)
self.selection.move(self.windowMouseCoord)
self.selection.show()
if self.collized:
self.itemsSelection = True
else:
self.itemsSelection = None
def isHoverButton(self):
for e in self.btns:
try:
if e.hover:
return True
except:
pass
def isHoverButtonSelection(self):
for e in self.collized:
try:
if e.hover:
return True
except:
pass
def mouseMoveEvent(self, QMouseEvent):
hover = self.isHoverButtonSelection()
if self.itemsSelection:
if hover:
self.mimeData = QMimeData()
urls = []
for e in self.collized:
urls.append(
QUrl('file://' + self.current_dir + '/' + e.value))
self.mimeData.setUrls(urls)
self.drag = QDrag(self)
self.drag.setMimeData(self.mimeData)
####################
# ВОТ ЭТО ВАЖНО
#self.drag.exec(Qt.LinkAction)
self.drag.exec(Qt.CopyAction)
if self.press:
pass
else:
for b in self.btns:
b.unselected()
self.select_rect_coll = []
self.collized = []
else: #if self.itemsSelection
if self.btns == None:
return
self.select_rect_coll = [
self.selection.x(),
self.selection.y(),
self.selection.x() + self.selection.width(),
self.selection.y() + self.selection.height()
]
for b in self.btns:
b.unselected()
b.leaveEvent(QMouseEvent)
self.collized = self.collision()
for b in self.collized:
b.selected()
b.leaveEvent(QMouseEvent)
# b.clicked.emit()
self.windowMouseCoord = self.window.mapFromGlobal(
QMouseEvent.globalPos())
self.mouse = [self.windowMouseCoord.x(), self.windowMouseCoord.y()]
self.windowMouseCoord = self.window.mapFromGlobal(
QMouseEvent.globalPos())
movePoint = self.startCoord - self.windowMouseCoord
invertmove = self.startCoord - movePoint
#Drawing selection
if movePoint.x() > 0 and movePoint.y() > 0:
self.selection.setFixedSize(abs(movePoint.x()),
abs(movePoint.y()))
self.selection.move(invertmove)
elif movePoint.x() > 0:
self.selection.setFixedSize(abs(movePoint.x()),
abs(movePoint.y()))
self.selection.move(invertmove.x(), self.startCoord.y())
elif movePoint.y() > 0:
self.selection.setFixedSize(abs(movePoint.x()),
abs(movePoint.y()))
self.selection.move(self.startCoord.x(), invertmove.y())
else:
self.selection.setFixedSize(abs(movePoint.x()),
abs(movePoint.y()))
#############################################################################
def mouseReleaseEvent(self, QMouseEvent):
self.press = False
self.globalPos = QMouseEvent.globalPos()
self.windowMouseCoord = self.window.mapFromGlobal(
QMouseEvent.globalPos())
if self.startCoord == QPoint(self.windowMouseCoord):
self.select_rect_coll = []
self.selection.deleteLater()
pass
def mimeTypes(self):
mimetypes = super().mimeTypes()
mimetypes.append('text/plain')
return mimetypes
def dropEvent(self, event):
#print(event.dropAction() == Qt.CopyAction)
#url = QUrl()
links = []
for url in event.mimeData().urls():
url = QUrl(url)
links.append(url.toLocalFile())
sys.modules['scr.core'].core.copy(sys.modules['scr.core'].core, links,
os.getcwd())
self.refresh()
#path = url.toLocalFile().toLocal8Bit().data()
#if os.path.isfile(path):
# print(path)
#self.refresh()
def dragEnterEvent(self, event):
if event.mimeData().hasUrls():
event.accept()
else:
event.ignore()
def dragMoveEvent(self, Event):
print('drag', Event.pos())
def button_trigger(self, e):
print('WIN', e.value)
def btn_press(self):
self.globalPos = self.sender().globalPos
if self.sender().target == 'None':
try:
self.selectBtn.select = None
except:
print('none target')
pass
if not self.sender().select and self.sender().target == 'icon':
try:
self.selectBtn.select = None
self.selectBtn.btn_update = True
self.selectBtn.update()
except:
pass
self.sender().select = True
self.selectBtn = self.sender()
return
if self.sender() == self.selectBtn and self.sender().target == 'icon':
try:
self.selectBtn.select = None
self.selectBtn.btn_update = True
self.selectBtn.update()
except:
pass
self.selectBtn = self.sender()
self.selectFile = os.path.normpath(self.current_dir + '/' +
self.sender().value)
if os.path.isdir(self.selectFile):
self.setDir(self.current_dir + '/' + self.sender().value)
self.history.set(self.current_dir, self.scroll_pos)
else:
self.setDir(self.current_dir + '/' + self.sender().value)
self.lm_menu()
def mousePressEvent(self, event):
if self._press_key == 1 and event.button() == Qt.LeftButton:
color_dict = {
"version": self._args.info_version_en,
"site": self._args.info_main_site,
"type": "set"
}
color_dict["palettes"] = export_list([
(self._args.sys_color_set, self._args.hm_rule, "", "",
(time.time(), time.time())),
])
color_path = os.sep.join(
(self._args.global_temp_dir.path(),
"DigiPale_Set_{}.dps".format(abs(hash(str(color_dict))))))
with open(color_path, "w", encoding='utf-8') as f:
json.dump(color_dict, f, indent=4)
self._drag_file = True
drag = QDrag(self)
mimedata = QMimeData()
mimedata.setUrls([QUrl.fromLocalFile(color_path)])
drag.setMimeData(mimedata)
pixmap = QPixmap(":/images/images/file_set_128.png")
drag.setPixmap(pixmap)
drag.setHotSpot(QPoint(pixmap.width() / 2, pixmap.height() / 2))
drag.exec_(Qt.CopyAction | Qt.MoveAction)
self._drag_file = False
self._press_key = 0
event.accept()
elif event.button() == Qt.LeftButton:
point = np.array((event.x(), event.y()))
self._backup = self._args.sys_color_set.backup()
if np.linalg.norm(point - self._center) < self._radius:
already_accepted = False
for idx in self._idx_seq[::-1]:
if np.linalg.norm(
point - self._tag_center[idx]) < self._tag_radius:
self._args.sys_activated_idx = idx
self.ps_index_changed.emit(True)
already_accepted = True
event.accept()
# self.update() is completed by
# self._wget_cube_table.ps_color_changed.connect(lambda x: self._wget_wheel.update()) in main.py.
# same below.
break
if already_accepted or self._args.press_move:
self._pressed_in_wheel = True
color = Color(self._backup[self._args.sys_activated_idx],
tp="color",
overflow=self._backup[0].get_overflow())
color.s = np.linalg.norm(point -
self._center) / self._radius
color.h = get_theta_center(self._center, point)
self._args.sys_color_set.modify(
self._args.hm_rule, self._args.sys_activated_idx,
color)
self.ps_color_changed.emit(True)
event.accept()
# self.update() is completed by
# self._wget_cube_table.ps_color_changed.connect(lambda x: self._wget_wheel.update()) in main.py.
# same below.
else:
event.ignore()
elif self._bar_1_box[0] < point[0] < self._bar_1_box[
0] + self._bar_1_box[2] and self._bar_1_box[1] < point[
1] < self._bar_1_box[1] + self._bar_1_box[3]:
if np.linalg.norm(
point - self._cir_1_center
) < self._v_tag_radius or self._args.press_move:
self._pressed_in_bar_1 = True
v = (point[1] - self._bar_1_box[1]) / self._bar_1_box[3]
color = Color(self._backup[self._args.sys_activated_idx],
tp="color",
overflow=self._backup[0].get_overflow())
color.v = v
self._args.sys_color_set.modify(
self._args.hm_rule, self._args.sys_activated_idx,
color)
self.ps_color_changed.emit(True)
event.accept()
else:
event.ignore()
elif self._bar_2_box[0] < point[0] < self._bar_2_box[
0] + self._bar_2_box[2] and self._bar_2_box[1] < point[
1] < self._bar_2_box[1] + self._bar_2_box[3]:
if np.linalg.norm(
point - self._cir_2_center
) < self._v_tag_radius or self._args.press_move:
self._pressed_in_bar_2 = True
v = (point[1] - self._bar_2_box[1]) / self._bar_2_box[3]
color = Color(self._backup[self._args.sys_activated_idx],
tp="color",
overflow=self._backup[0].get_overflow())
color.v = v
self._args.sys_color_set.modify(
self._args.hm_rule, self._args.sys_activated_idx,
color)
self.ps_color_changed.emit(True)
event.accept()
else:
event.ignore()
else:
event.ignore()
else:
event.ignore()
def copyFile(file_path):
data = QMimeData()
url = QUrl.fromLocalFile(file_path)
data.setUrls([url])
QApplication.clipboard().setMimeData(data)
def tempFileMimeData(self):
"""Save the exported image to a temp file and return a QMimeData object for the url."""
data = QMimeData()
data.setUrls([QUrl.fromLocalFile(self.tempFilename())])
return data
def mimeData(self, indexes):
mimedata = QMimeData()
mimedata.setUrls([self.url])
return mimedata
def show_menu(self, clickPos):
index = self.tree.indexAt(clickPos)
selected_path = self.tree.model().filePath(index)
enclosing_dir = self.find_enclosing_dir(selected_path)
menu = QMenu(self)
openAction = menu.addAction("Open")
newFolderAction = menu.addAction("New Folder")
newFileAction = menu.addAction("New File")
copyAction = menu.addAction("Copy")
pasteAction = menu.addAction("Paste")
renameAction = menu.addAction("Rename")
fileInfo = menu.addAction("Properties")
menuPos = QPoint(clickPos.x() + 15, clickPos.y() + 15)
action = menu.exec_(self.mapToGlobal(menuPos))
if action == openAction:
self.open_file(index)
elif action == newFolderAction:
path = self.get_dialog_str("New Folder",
"Enter name for new folder:")
if path:
self.mkdir(os.path.join(enclosing_dir, path))
elif action == newFileAction:
path = self.get_dialog_str("New File", "Enter name for new file:")
if path:
self.touch(os.path.join(enclosing_dir, path))
elif action == renameAction:
path = self.get_dialog_str("Rename File", "Enter new name:")
# Naive validation
if "/" in path:
msg = QMessageBox()
msg.setIcon(QMessageBox.Critical)
msg.setText("Filename cannot contain '/'")
msg.setWindowTitle("Error")
msg.exec_()
return
new_path = os.path.join(enclosing_dir, path)
self.move(selected_path, new_path)
elif action == copyAction:
mime_data = QMimeData()
# TODO: support multiple selections
mime_data.setUrls([QUrl(Path(selected_path).as_uri())])
self.clipboard.setMimeData(mime_data)
elif action == pasteAction:
mime_data = self.clipboard.mimeData()
if not mime_data:
return
if mime_data.hasUrls():
for src_url in mime_data.urls():
self.copy(src_url.path(), enclosing_dir)
def tablewidget_right_menu(self,pos,file_path=None):
item_row = self.tablewidget.currentRow()
file_name = self.tablewidget.item(item_row,0).text()
file_path = self.tablewidget.item(item_row,4).text()
if not file_path:
file_path = os.path.join(self.paths[-1],file_name)
file_path = file_path.replace('\\','/')
# print(file_path)
menu = QMenu(self.tablewidget)
delete = menu.addAction('删除')
copy = menu.addAction('复制')
paste = menu.addAction('粘贴')
openLocalFile = menu.addAction('浏览本地文件')
file_roperty = menu.addAction("属性")
action = menu.exec_(self.tablewidget.mapToGlobal(pos))
if action == delete:
reply = QMessageBox.warning(self.mainwindow, '删除确认', '确认删除吗？', QMessageBox.Yes | QMessageBox.No,
QMessageBox.No)
if os.path.isdir(file_path) and reply == 16384:
# print('delete dir')
shutil.rmtree(file_path)
self.statusBar.showMessage(f'删除 {file_path} 成功！')
self.updateFileTree()
elif not os.path.isdir(file_path) and reply == 16384:
# print('delete file')
os.remove(file_path)
self.statusBar.showMessage("删除 -> %s 成功!" % file_path)
# print(self.paths)
self.updateFileTree()
self.statusBar.showMessage(f'删除 {file_path} 成功!')
elif action == copy:
try:
data = QMimeData()
url = QUrl.fromLocalFile(file_path)
clipboard = QApplication.clipboard()
data.setUrls([url])
clipboard.setMimeData(data)
self.statusBar.showMessage("已复制 -> %s 到剪切板" % file_path)
except Exception as e:
QMessageBox.about(self.mainwindow, '错误', '文件不存在!')
self.statusBar.showMessage("复制 -> %s 出错，文件不存在!" % file_path)
elif action == paste:
data = QApplication.clipboard().mimeData()
source_file_url = data.urls()[0].url()
self.paste_thread = FilePasteThread(source_file_url[8:], file_path)
self.paste_thread.sinOut.connect(self.filePasteComplete)
self.paste_thread.start()
elif action == openLocalFile:
try:
local_path = file_path.replace('/', '\\')
os.system("explorer.exe %s" % os.path.dirname(local_path))
except Exception as e:
QMessageBox.warning(self.mainwindow, '错误', '打开文件不存在!')
elif action == file_roperty:
# print('查看文件属性')
if os.path.isdir(file_path):
file_type = '文件夹'
file_image = '../images/folder_status.png'
_dir = True
else:
_dir = False
if file_path.endswith('.jpg'):
file_type = 'JPG图片文件( *.jpg )'
file_image = '../images/jpg_status.png'
elif file_path.endswith('.html'):
file_type = 'HTML页面文件( *.html )'
file_image = '../images/html_status.png'
elif file_path.endswith('.xlsx'):
file_type = 'XLSX表格文件( *.xlsx )'
file_image = '../images/excel_status.png'
elif file_path.endswith('.png'):
file_type = 'PNG表格文件( *.png )'
file_image = '../images/png_status.png'
else:
file_type = 'Other其他文件类型( *.%s)' % (os.path.splitext(file_path)[1])
file_image = '../images/file_status.png'
if _dir:
'''文件夹大小去要遍历每个子文件夹与文件累加'''
file_size = self.getdirsize(file_path)
# print(file_path)
statinfo = os.stat(file_path)
else:
statinfo = os.stat(file_path)
file_size = statinfo.st_size
file_atime = self.time_format(statinfo.st_atime) # 文件最后访问时间
file_ctime = self.time_format(statinfo.st_ctime) # 文件创建时间
file_mtime = self.time_format(statinfo.st_mtime) # 文件最后修改时间
self.file_status_window = FileStatusWindow()
self.file_status_window.filename = file_path.replace('\\', '/').split('/')[-1]
self.status_main_window = QMainWindow(MainWindow)
self.file_status_window.setupUi(self.status_main_window)
self.file_status_window.lineEdit.setText(self.file_status_window.filename)
self.file_status_window.label_3.setText(file_type)
self.file_status_window.label_5.setText(file_path.replace('/', '\\'))
self.file_status_window.label_9.setText(file_ctime)
self.file_status_window.label_11.setText(file_mtime)
self.file_status_window.label_13.setText(file_atime)
self.file_status_window.label_7.setText(self.approximateSize(file_size))
self.file_status_window.pushButton.clicked.connect(self.fileStatusUse) # 应用按钮click出发函数
self.file_status_window.pushButton_2.clicked.connect(self.fileStatusConfirm)
self.file_status_window.pushButton_3.clicked.connect(self.fileStatusCancel)
pix = QPixmap(file_image)
self.file_status_window.label.setPixmap(pix)
self.status_main_window.show()
