class App(QWidget):
def __init__(self):
super().__init__()
self.title = 'PyQt5 file system view'
self.left = 100
self.top = 100
self.width = 1140
self.height = 480
self.initUI()
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.model = QFileSystemModel()
self.model.setRootPath(QDir.rootPath())
self.tree = QTreeView()
self.tree.setModel(self.model)
self.tree.setRootIndex(self.model.index(config['rgb_img_path']))
self.tree.setAnimated(False)
self.tree.setIndentation(20)
self.tree.setSortingEnabled(True)
self.tree.setWindowTitle("Dir View")
self.tree.resize(640, 480)
self.tree.doubleClicked.connect(self.plot)
windowLayout = QVBoxLayout()
windowLayout.addWidget(self.tree)
self.setLayout(windowLayout)
self.m = PlotCanvas(self, width=5, height=4)
self.m.move(640, 0)
self.show()
def plot(self, signal):
file_path = self.tree.model().filePath(signal)
sample_id = re.search(r'\d+', file_path.split('/')[-1]).group()
self.m.plot(str(sample_id))
class App(QWidget):
def __init__(self):
super().__init__()
self.title = 'PyQt5 file system view - pythonspot.com'
self.left = 100
self.top = 100
self.width = 940
self.height = 480
self.initUI()
time.sleep(5)
#self.hideUI()
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.model = QFileSystemModel()
self.model.setRootPath('')
self.tree = QTreeView()
self.tree.setModel(self.model)
self.tree.setAnimated(True)
self.tree.setIndentation(20)
self.tree.setSortingEnabled(True)
self.tree.setWindowTitle("Dir View")
self.tree.resize(1280, 960)
windowLayout = QVBoxLayout()
windowLayout.addWidget(self.tree)
self.setLayout(windowLayout)
self.show()
def hideUI(self):
self.hide()
class App(QWidget):
def __init__(self):
super().__init__()
self.title = 'PyQt5 file system view - pythonspot.com'
self.left = 10
self.top = 10
self.width = 640
self.height = 480
self.initUI()
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.model = QFileSystemModel()
r_inx = self.model.setRootPath(".")
self.tree = QTreeView()
self.tree.setModel(self.model)
self.tree.setAnimated(False)
self.tree.setIndentation(15)
self.tree.setSortingEnabled(True)
self.tree.setWindowTitle("Dir View")
self.tree.resize(640, 480)
windowLayout = QVBoxLayout()
windowLayout.addWidget(self.tree)
self.setLayout(windowLayout)
print(self.model.rootPath())
print(self.model.filePath(self.model.parent(r_inx)))
index_temp = self.model.index(0, 0, QModelIndex())
print(self.model.fileName(index_temp))
self.show()
class App(QWidget):
def __init__(self):
super().__init__()
self.title = "PyQt5 file system view - pythonspot.com"
self.left = 100
self.top = 300
self.width = 640
self.height = 480
self.initUI()
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.model = QFileSystemModel()
self.model.setRootPath("C:\\")
self.tree = QTreeView()
self.tree.setModel(self.model)
self.tree.setAnimated(False)
self.tree.setIndentation(20)
self.tree.setSortingEnabled(True)
self.tree.setWindowTitle("Dir View")
self.tree.resize(640, 480)
windowLayout = QVBoxLayout()
windowLayout.addWidget(self.tree)
self.setLayout(windowLayout)
self.show()
class App(QWidget):
def __init__(self):
super().__init__()
self.title = 'Android File Transfer'
self.left = 20
self.top = 30
self.width = 640
self.height = 480
self.initUI()
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.model = QFileSystemModel()
self.model.setRootPath('/Volumes/RV/')
self.tree = QTreeView()
self.tree.clicked.connect(self.onClicked)
self.tree.setModel(self.model)
self.tree.setAnimated(False)
self.tree.setIndentation(20)
self.tree.setSortingEnabled(True)
self.tree.setWindowTitle("Dir View")
self.tree.resize(640, 480)
windowLayout = QVBoxLayout()
windowLayout.addWidget(self.tree)
self.setLayout(windowLayout)
def onClicked(self, index):
path = self.sender().model().filePath(index)
print(path)
class DirViewer(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.fileModel = QFileSystemModel()
self.fileModel.setRootPath('')
self.treeView = QTreeView()
self.treeView.setModel(self.fileModel)
self.treeView.setIndentation(10)
self.treeView.setSortingEnabled(True)
self.treeView.setWindowTitle("Dir Viewer")
self.treeView.resize(700, 300)
vbox = QVBoxLayout()
vbox.addWidget(self.treeView)
self.setLayout(vbox)
self.setGeometry(300, 300, 700, 300)
self.setWindowTitle("Dir Viewer")
self.show()
class FilesHierarchyViewer(QWidget):
def __init__(self):
# super().__init__()
super(FilesHierarchyViewer, self).__init__()
self.title = 'File system viewer'
self.left = 0
self.top = 0
self.width = 640
self.height = 480
self.initUI()
def initUI(self):
self.setWindowTitle(self.title)
# self.setGeometry(self.left, self.top, self.width, self.height)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.model = QFileSystemModel()
self.model.setRootPath(glb.DIRECTORY_VIEWER_ROOT_PATH)
print(glb.DIRECTORY_VIEWER_ROOT_PATH)
self.tree = QTreeView()
self.tree.setModel(self.model)
self.tree.setAnimated(False)
self.tree.setIndentation(20)
self.tree.setSortingEnabled(True)
self.tree.setWindowTitle("Dir View")
self.tree.resize(640, 480)
windowLayout = QVBoxLayout()
windowLayout.addWidget(self.tree)
self.setLayout(windowLayout)
self.show()
class MyGridFilesWidget(QWidget):
def __init__(self, parent):
super(QWidget, self).__init__(parent)
start_dir = QStringListModel()
start_dir = 'C:/ROBOCZY'
self.model = QFileSystemModel()
self.model.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot
| QDir.AllEntries)
self.model.setNameFilters()
self.model.setNameFilterDisables(0)
#self.model.setRootPath(start_dir)
#self.model.setRootPath(start_dir)
self.tree = QTreeView()
self.tree.setRootIndex(self.model.index(start_dir))
self.tree.setModel(self.model)
self.tree.setAnimated(False)
self.tree.setIndentation(20)
self.tree.setSortingEnabled(True)
self.tree.setWindowTitle("Dir View")
self.tree.resize(640, 480)
windowLayout = QVBoxLayout()
windowLayout.addWidget(self.tree)
self.setLayout(windowLayout)
def main(args):
app = QApplication (args)
view = QTreeView()
view.setModel(StorageModel(view))
view.resize(640, 480)
view.setSelectionBehavior(QAbstractItemView.SelectRows)
for column in range(view.model().columnCount()):
view.resizeColumnToContents(column)
view.show()
return app.exec_()
class Manager(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.setWindowTitle('File Manager')
self.setGeometry(100, 500, 1000, 600)
self.shown = QFileSystemModel()
self.shown.setRootPath('')
self.tree = QTreeView()
self.tree.setModel(self.shown)
self.tree.setIndentation(20)
self.tree.setSortingEnabled(True)
self.tree.setWindowTitle('Directory View')
self.tree.resize(1000, 600)
window_layout = QVBoxLayout()
window_layout.addWidget(self.tree)
self.setLayout(window_layout)
def text_editor_eval(self):
def insert_text():
file_name = fd.askopenfilename()
with open(file_name) as file:
txt = file.read()
text.insert(1.0, txt)
def extract_text():
file_name = fd.asksaveasfilename(filetypes=(("TXT files", "*.txt"),
("HTML files",
"*.html;*.htm"),
("All files", "*.*")))
with open(file_name, mode='w') as file:
txt = text.get(1.0, END)
file.write(txt)
root = Tk()
text = Text(width=50, height=25)
text.grid(columnspan=2)
b1 = Button(text='Open', command=insert_text)
b1.grid(row=1, sticky=E)
b2 = Button(text='Save', command=extract_text)
b2.grid(row=1, column=1, sticky=W)
root.title = 'Window'
root.mainloop()
def directory(app):
#app = QApplication(sys.argv)
QCoreApplication.setApplicationVersion(QT_VERSION_STR)
parser = QCommandLineParser()
parser.setApplicationDescription("File Directory")
parser.addHelpOption()
parser.addVersionOption()
dontUseCustomDirectoryIconsOption = QCommandLineOption(
'C', "Set QFileIconProvider.DontUseCustomDirectoryIcons")
parser.addOption(dontUseCustomDirectoryIconsOption)
parser.addPositionalArgument('', "The directory to start in.")
parser.process(app)
try:
rootPath = parser.positionalArguments().pop(0)
except IndexError:
rootPath = None
model = QFileSystemModel()
model.setRootPath('')
filter = ['*.db'] #filtering out just by db
model.setNameFilters(filter)
model.setNameFilterDisables(0) #Only show the filtered .db paths
#filename = model.filePath()
#print(filename)
if parser.isSet(dontUseCustomDirectoryIconsOption):
model.iconProvider().setOptions(
QFileIconProvider.DontUseCustomDirectoryIcons)
tree = QTreeView()
tree.setModel(model)
if rootPath is not None:
rootIndex = model.index(QDir.cleanPath(rootPath))
if rootIndex.isValid():
tree.setRootIndex(rootIndex)
# Demonstrating look and feel features.
tree.setAnimated(False)
tree.setIndentation(20)
tree.setSortingEnabled(True)
availableSize = QApplication.desktop().availableGeometry(tree).size()
tree.resize(availableSize / 2)
tree.setColumnWidth(0, tree.width() / 3)
tree.setWindowTitle("Directory View")
tree.show()
sys.exit(app.exec_())
class DirectoryTree(QWidget):
def __init__(self):
super().__init__()
self.title = 'PyQt5 file system view'
self.left = 10
self.top = 10
self.width = 640
self.height = 480
self.initUI()
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.model = QFileSystemModel()
self.model.setRootPath(QDir.rootPath())
self.model.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot)
self.tree = QTreeView()
self.tree.setModel(self.model)
self.tree.hideColumn(1)
self.tree.hideColumn(2)
self.tree.hideColumn(3)
self.tree.setAnimated(False)
self.tree.setIndentation(20)
self.tree.setSortingEnabled(True)
self.tree.setWindowTitle("Dir View")
self.tree.resize(640, 480)
self.fileModel = QFileSystemModel()
self.fileModel.setRootPath(QDir.rootPath())
self.list = QTableView()
self.list.setModel(self.fileModel)
self.list.setShowGrid(False)
self.list.verticalHeader().setVisible(False)
self.list.setSelectionBehavior(QTableView().SelectRows)
self.tree.clicked.connect(self.onClicked)
windowLayout = QHBoxLayout()
windowLayout.addWidget(self.tree)
windowLayout.addWidget(self.list)
self.setLayout(windowLayout)
self.show()
def onClicked(self, index):
path = self.model.fileInfo(index).absoluteFilePath()
self.list.setRootIndex(self.fileModel.setRootPath(path))
class DIR_WINDOW(QtWidgets.QMainWindow):
def __init__(self):
super().__init__()
self.title = "Convex"
self.top = 100
self.left = 100
self.width = 800
self.height = 400
self.icon_name = "NIT-Silchar-Logo.png"
self.path = ''
self.initApp()
def initApp(self):
self.setWindowIcon(QtGui.QIcon(self.icon_name))
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.model = QFileSystemModel()
self.model.setRootPath("C:")
self.tree = QTreeView()
self.tree.setModel(self.model)
self.tree.setAnimated(False)
self.tree.setIndentation(20)
self.tree.setSortingEnabled(True)
self.tree.setWindowTitle("Explorer")
self.tree.resize(640, 480)
self.tree.move(20, 20)
self.tree.clicked.connect(self.selectPath)
self.select_button = QPushButton("Select", self)
self.select_button.setToolTip("Click to select image")
self.select_button.setMinimumHeight(40)
self.select_button.clicked.connect(self.obtainPath)
#windowLayout = QVBoxLayout()
#windowLayout.addWidget(self.tree)
#windowLayout.addWidget(select_button)
#self.setLayout(windowLayout)
self.show()
def selectPath(self, index):
self.path = self.sender().model().filePath(index)
def obtainPath(self):
print("obtain path:" + self.path)
class App(QWidget):
def __init__(self):
print("xx")
#QMainWindow.__init__(self)
super(App,self).__init__()
#QtWidgets.QWidget.__init__(self)
self.title = 'select file'
self.left = 10
self.top = 10
self.width = 640
self.height = 480
self.initUI()
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.model = QFileSystemModel()
self.model.setRootPath('')
self.tree = QTreeView()
self.tree.clicked.connect(self.onClicked)
self.tree.setModel(self.model)
self.fileSystemModel = QFileSystemModel(self.tree)
self.fileSystemModel.setReadOnly(True)
self.fileSystemModel.setRootPath('')
self.tree.setAnimated(False)
self.tree.setIndentation(20)
self.tree.setSortingEnabled(True)
self.tree.setWindowTitle("Dir View")
self.tree.resize(640, 480)
windowLayout = QVBoxLayout()
windowLayout.addWidget(self.tree)
self.setLayout(windowLayout)
self.show()
def onClicked(self, index):
global path
path = self.sender().model().filePath(index)
#path1=self.sender().model().filePath()
print(path)
self.close()
Ui_MainWindow.display1(self)
class App(QWidget):
def __init__(self):
super().__init__()
self.title = 'PyQt5 file system view - pythonspot.com'
self.left = 10
self.top = 10
self.width = 640
self.height = 480
self.initUI()
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.model = QFileSystemModel()
self.model.setRootPath('/home/rob/Muziek')
filter = ["*.wav", "*.ogg"]
self.model.setNameFilters(filter)
self.model.setNameFilterDisables(0)
root = self.model.setRootPath('/home/rob/Muziek')
#print(root)
self.tree = QTreeView()
self.tree.setModel(self.model)
self.tree.setRootIndex(root)
self.tree.setAnimated(False)
self.tree.setIndentation(20)
self.tree.setSortingEnabled(True)
self.tree.doubleClicked.connect(self.test)
self.tree.setWindowTitle("Dir View")
self.tree.resize(640, 480)
windowLayout = QVBoxLayout()
windowLayout.addWidget(self.tree)
self.setLayout(windowLayout)
self.show()
def test(self, signal):
file_path = self.model.filePath(signal)
print(file_path)
class App(QWidget):
def __init__(self):
super().__init__()
self.title = 'PyQt5 file system view - pythonspot.com'
self.left = 10
self.top = 10
self.width = 640
self.height = 480
self.initUI()
def tree_cilcked(self, Qmodelidx):
print(self.model.filePath(Qmodelidx))
print(self.model.fileName(Qmodelidx))
print(self.model.fileInfo(Qmodelidx))
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
# 这里得到目录结构
self.model = QFileSystemModel()
self.model.setRootPath(QDir.currentPath())
# 这里过滤，只显示 py 文件
mf = self.model.setNameFilters(['*.py'])
self.model.setNameFilterDisables(False)
# 这里做展示
self.tree = QTreeView()
self.tree.setModel(self.model)
# self.tree.setRootIndex(self.model.index(QDir.currentPath()))
self.tree.setRootIndex(self.model.index('g:\l'))
self.tree.doubleClicked.connect(self.tree_cilcked)
# 这里隐藏了目录信息展示
for i in [1, 2, 3]:
self.tree.setColumnHidden(i, True)
# 缩进
self.tree.setIndentation(10)
self.tree.setWindowTitle("Dir View")
self.tree.resize(640, 480)
windowLayout = QVBoxLayout()
windowLayout.addWidget(self.tree)
self.setLayout(windowLayout)
self.show()
class view(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.setGeometry(0, 0, 800, 600)
self.model = QFileSystemModel()
self.model.setReadOnly(False)
self.model.setRootPath("")
self.tree = QTreeView()
self.tree.setModel(self.model)
self.tree.setAnimated(True)
self.tree.setIndentation(10)
self.tree.setSortingEnabled(True)
self.tree.setWindowTitle("Dir View")
self.tree.resize(640, 480)
windowLayout = QVBoxLayout()
windowLayout.addWidget(self.tree)
self.setLayout(windowLayout)
self.show()
## (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
## OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
## $QT_END_LICENSE$
#############################################################################
import sys
from PyQt5.QtCore import QLoggingCategory, QUrl
from PyQt5.QtRemoteObjects import QRemoteObjectNode
from PyQt5.QtWidgets import QApplication, QTreeView
QLoggingCategory.setFilterRules("qt.remoteobjects.debug=false\n"
"qt.remoteobjects.warning=false\n"
"qt.remoteobjects.models.debug=false\n"
"qt.remoteobjects.models.debug=false")
app = QApplication(sys.argv)
node = QRemoteObjectNode(QUrl("local:registry"))
node.setHeartbeatInterval(1000)
view = QTreeView()
view.setWindowTitle("RemoteView")
view.resize(640, 480)
model = node.acquireModel("RemoteModel")
view.setModel(model)
view.show()
sys.exit(app.exec_())
class ModelGui(QDialog):
"""The gui to start and manipulate the analysis model"""
ANALYSIS, ID, NUMPOINTS = range(3)
NO_PARENT_ID = 0xFFFFFFFF
def __init__(self, analysis_event_queue, select, delete, load):
super(ModelGui, self).__init__()
self.analysis_event_queue = analysis_event_queue
self.select_callback = select
self.delete_callback = delete
self.load_callback = load
self.name = None
self.label_name = None
self.meta_name = None
self.hsne_name = None
self.title = 'Analysis hierarchy viewer'
self.left = 10
self.top = 10
self.width = 1000
self.height = 400
self.init_ui()
self.id_item = {}
self.root_id = None
def init_ui(self):
"""All the ui layout in one place. Note: Part of the ui
is switchable depending on the selected demo type, see the ui_matrix"""
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.model = self.create_analysis_model(self)
self.analysis_model = None
self.top_scale = None
self.thumb_size = (40, 40)
# The analysis tree
self.tree = QTreeView()
self.tree.setSelectionBehavior(QAbstractItemView.SelectRows)
self.tree.header().setSectionResizeMode(QHeaderView.ResizeToContents)
self.tree.setIconSize(QSize(*self.thumb_size))
self.tree.setModel(self.model)
self.tree.setAnimated(False)
self.tree.setIndentation(20)
self.tree.setSortingEnabled(True)
self.tree.resize(640, 480)
# Control layout
controlLayout = QVBoxLayout()
self.preconfigured_group = QGroupBox("Preconfigured")
preconfigured_layout = QFormLayout(self)
self.preconfigured_combo = QComboBox(self)
self.preconfigured_combo.addItem('None', userData=None)
for config in CONFIGS:
self.preconfigured_combo.addItem(config.descriptor,
userData=config)
self.preconfigured_combo.currentIndexChanged[int].connect(
self.on_preconfigured)
preconfigured_layout.addRow(QLabel("Load preset demo:"),
self.preconfigured_combo)
self.preconfigured_group.setLayout(preconfigured_layout)
controlLayout.addWidget(self.preconfigured_group)
# Data type settings
self.demo_type_group = QGroupBox("Data type")
data_type_layout = QFormLayout(self)
self.data_type_combo = QComboBox(self)
self.data_type_combo.addItem("Image is a data point",
DemoType.LABELLED_DEMO)
self.data_type_combo.addItem("Point and metadata", DemoType.POINT_DEMO)
self.data_type_combo.addItem("Hyperspectral image",
DemoType.HYPERSPECTRAL_DEMO)
data_type_layout.addRow(QLabel("Visualization style:"),
self.data_type_combo)
self.data_type_combo.currentIndexChanged[int].connect(
self.on_demo_style)
data_button = QPushButton("Data")
data_button.clicked.connect(self.on_load)
self.data_label = QLabel("<choose data .npy>")
data_type_layout.addRow(data_button, self.data_label)
self.xy_label = QLabel("Image size")
self.label_x = QLabel("X:")
self.label_y = QLabel("Y:")
self.image_x = QLineEdit()
self.image_x.setValidator(QIntValidator(1, 10000))
self.image_y = QLineEdit()
self.image_y.setValidator(QIntValidator(1, 10000))
self.xy_container = QWidget()
self.xy_layout = QHBoxLayout()
self.xy_layout.setContentsMargins(0, 0, 0, 0)
self.xy_layout.addWidget(self.label_x)
self.xy_layout.addWidget(self.image_x)
self.xy_layout.addWidget(self.label_y)
self.xy_layout.addWidget(self.image_y)
self.xy_container.setLayout(self.xy_layout)
data_type_layout.addRow(self.xy_label, self.xy_container)
self.label_button = QPushButton("Labels")
self.label_button.clicked.connect(self.on_load_labels)
self.label_label = QLabel("<optionally choose labels .npy>")
data_type_layout.addRow(self.label_button, self.label_label)
self.meta_button = QPushButton("Label/Color metadata")
self.meta_button.clicked.connect(self.on_load_labelscolors)
self.meta_label = QLabel("<optionally choose label/color .csv>")
data_type_layout.addRow(self.meta_button, self.meta_label)
self.demo_type_group.setLayout(data_type_layout)
controlLayout.addWidget(self.demo_type_group)
# Hsne settings
self.hsne_group = QGroupBox("hSNE settings")
self.hsne_form_layout = QFormLayout(self)
hsne_button = QPushButton("Preload")
hsne_button.clicked.connect(self.on_load_hsne)
self.hsne_label = QLabel("<optionally choose existing .hsne>")
self.hsne_form_layout.addRow(hsne_button, self.hsne_label)
self.scale_spin = QSpinBox(self)
self.scale_spin.setRange(1, 10)
self.scale_spin.setValue(4)
self.hsne_form_layout.addRow(QLabel("Scales:"), self.scale_spin)
self.hsne_group.setLayout(self.hsne_form_layout)
controlLayout.addWidget(self.hsne_group)
# Embedding settings
self.embedding_group = QGroupBox("Embedding settings")
embed_form_layout = QFormLayout(self)
self.iter_spin = QSpinBox(self)
self.iter_spin.setRange(350, 1000)
self.iter_spin.setSingleStep(5)
self.iter_spin.setValue(500)
embed_form_layout.addRow(QLabel("Iterations:"), self.iter_spin)
self.embedding_group.setLayout(embed_form_layout)
controlLayout.addWidget(self.embedding_group)
clear_start_layout = QHBoxLayout()
self.start_button = QPushButton("Start")
self.start_button.clicked.connect(self.on_start)
self.start_button.setDisabled(True)
self.clear_button = QPushButton("Clear")
self.clear_button.clicked.connect(self.on_clear)
clear_start_layout.addWidget(self.start_button)
clear_start_layout.addWidget(self.clear_button)
controlLayout.addLayout(clear_start_layout)
self.delete_button = QPushButton("Delete selected")
self.delete_button.clicked.connect(self.on_delete)
# Selection
self.tree.clicked.connect(self.on_selected)
# Layout
main_layout = QGridLayout()
# row, col, rowSpan, colSpan
main_layout.addWidget(self.tree, 0, 0, 10, 5)
main_layout.addLayout(controlLayout, 0, 5, 10, 3)
main_layout.addWidget(self.delete_button, 11, 2, 1, 2)
self.setLayout(main_layout)
self.counter = 0
self.event_timer = QTimer(self)
self.event_timer.start(500)
self.event_timer.timeout.connect(self.update_tree)
# Dynamic UI matrix
# According to DemoType True widgets are shown False widgets hidden
self.ui_matrix = {
DemoType.LABELLED_DEMO: {
True: [
self.label_button, self.label_label, self.xy_container,
self.xy_label
],
False: [self.meta_button, self.meta_label]
},
DemoType.POINT_DEMO: {
True: [self.meta_button, self.meta_label],
False: [
self.label_button, self.label_label, self.xy_container,
self.xy_label
]
},
DemoType.HYPERSPECTRAL_DEMO: {
True: [self.xy_container, self.xy_label],
False: [
self.label_button, self.label_label, self.meta_button,
self.meta_label
]
}
}
self.show()
self.on_demo_style(0)
def set_analysis_model(self, analysis_model):
# TODO empty event queue
self.analysis_model = analysis_model
self.top_scale = self.analysis_model.top_scale_id
@property
def iterations(self):
return self.iter_spin.value()
@property
def scales(self):
return self.scale_spin.value()
@property
def demo_type(self):
return self.data_type_combo.currentData()
@property
def im_size_x(self):
return int(self.image_x.text())
@property
def im_size_y(self):
return int(self.image_y.text())
@pyqtSlot(int)
def on_preconfigured(self, index):
config = self.preconfigured_combo.itemData(index)
self.on_clear()
if config is None:
return
if type(config).__name__ == "LabelledImage":
self.data_type_combo.setCurrentIndex(0)
self.name = config.data.data_file
self.data_label.setText(config.data.data_file)
self.label_name = config.data.label_file
self.label_label.setText(config.data.label_file)
if config.hsne.hsne_file != "":
self.hsne_name = config.hsne.hsne_file
self.__set_scale_from_hsne_file()
self.scale_spin.setDisabled(True)
elif config.hsne.scales > 0:
self.scale_spin.setValue(config.hsne.scales)
if config.image.dim_x > 0 and config.image.dim_y > 0:
self.image_x.setText(str(config.image.dim_x))
self.image_y.setText(str(config.image.dim_y))
elif type(config).__name__ == "PointMeta":
self.data_type_combo.setCurrentIndex(1)
self.name = config.data.data_file
self.data_label.setText(config.data.data_file)
self.meta_name = config.data.meta_file
self.meta_label.setText(config.data.meta_file)
if config.hsne.hsne_file != "":
self.hsne_name = config.hsne.hsne_file
self.__set_scale_from_hsne_file()
self.scale_spin.setDisabled(True)
elif config.hsne.scales > 0:
self.scale_spin.setValue(config.hsne.scales)
elif type(config).__name__ == "HyperspectralImage":
self.data_type_combo.setCurrentIndex(2)
self.name = config.data.data_file
self.data_label.setText(config.data.data_file)
if config.hsne.hsne_file != "":
self.hsne_name = config.hsne.hsne_file
self.__set_scale_from_hsne_file()
self.scale_spin.setDisabled(True)
elif config.hsne.scales > 0:
self.scale_spin.setValue(config.hsne.scales)
if config.image.dim_x > 0 and config.image.dim_y > 0:
self.image_x.setText(str(config.image.dim_x))
self.image_y.setText(str(config.image.dim_y))
self.start_button.setEnabled(True)
@pyqtSlot(int)
def on_demo_style(self, index):
# set the visibility of the widgets according to the
# type of demo being given
for state in [False, True]:
for widget in self.ui_matrix[self.demo_type][state]:
widget.setVisible(state)
@pyqtSlot()
def on_load(self):
workdir = os.path.dirname(os.path.abspath(__file__))
result = QFileDialog.getOpenFileName(
self,
'Open a numpy file where each row is a data point and columns are dimensions',
workdir, "Numpy files (*.npy)")
if result[0]:
self.hsne_label.setText("")
self.hsne_name = None
self.scale_spin.setEnabled(True)
self.name = result[0]
# print(f"Selected: {self.name}")
self.start_button.setEnabled(True)
if (self.demo_type == DemoType.LABELLED_DEMO
or self.demo_type == DemoType.HYPERSPECTRAL_DEMO):
# partial data load (in memory) to read the shape
the_data = np.load(self.name, mmap_mode='r')
image_flat_size = the_data.shape[1]
if self.demo_type == DemoType.HYPERSPECTRAL_DEMO:
image_flat_size = the_data.shape[0]
xsize = int(math.sqrt(image_flat_size))
ysize = int(image_flat_size / xsize)
self.image_x.setText(str(xsize))
self.image_y.setText(str(ysize))
self.data_label.setText(str(Path(self.name).name))
def __set_scale_from_hsne_file(self):
scale_value = nptsne.HSne.read_num_scales(self.hsne_name)
self.hsne_label.setText(str(Path(self.hsne_name).name))
self.scale_spin.setValue(scale_value)
self.scale_spin.setDisabled(True)
@pyqtSlot()
def on_load_hsne(self):
workdir = os.path.dirname(os.path.abspath(__file__))
result = QFileDialog.getOpenFileName(
self, 'Open a pre-calculated hSNE analysis file .hsne', workdir,
"hSNE files (*.hsne)")
if result[0]:
self.hsne_name = result[0]
# print(f"Selected: {self.name}")
self.__set_scale_from_hsne_file()
@pyqtSlot()
def on_load_labels(self):
workdir = os.path.dirname(os.path.abspath(__file__))
result = QFileDialog.getOpenFileName(
self, 'Open a numpy file where each row is an integer label',
workdir, "Numpy files (*.npy)")
if result[0]:
self.label_name = result[0]
self.label_label.setText(Path(self.label_name).name)
@pyqtSlot()
def on_load_labelscolors(self):
workdir = os.path.dirname(os.path.abspath(__file__))
result = QFileDialog.getOpenFileName(
self,
'Open a CSV file with header where the columns pairs of Label, #COLOR_',
workdir, "CSV files (*.csv)")
if result[0]:
self.meta_name = result[0]
self.meta_label.setText(Path(self.meta_name).name)
@pyqtSlot()
def on_start(self):
self.load_callback(self.name, self.label_name, self.meta_name,
self.hsne_name)
@pyqtSlot()
def on_selected(self):
analysis_id = self._get_selected_id()
if analysis_id:
self.select_callback(int(analysis_id))
@pyqtSlot()
def on_delete(self):
analysis_id = self._get_selected_id()
if analysis_id:
self.delete_callback([int(analysis_id)])
@pyqtSlot()
def on_clear(self):
if not self.root_id is None:
self.select_callback(int(self.root_id))
self.clear()
self.name = None
self.data_label.setText("<choose data .npy>")
self.label_name = None
self.label_label.setText("<optionally choose labels .npy>")
self.meta_name = None
self.meta_label.setText("<optionally choose label/color .csv>")
self.scale_spin.setValue(4)
self.scale_spin.setEnabled(True)
self.start_button.setDisabled(True)
self.hsne_name = None
self.hsne_label.setText("<optionally choose existing .hsne>")
self.image_x.setText("")
self.image_y.setText("")
def _get_selected_id(self):
index = self.tree.currentIndex()
if index is None:
return None
return self.model.itemData(index.siblingAtColumn(self.ID))[0]
def create_analysis_model(self, parent):
model = QStandardItemModel(0, 3, parent)
model.setHeaderData(self.ANALYSIS, Qt.Horizontal, "Analysis")
model.setHeaderData(self.ID, Qt.Horizontal, "Id")
model.setHeaderData(self.NUMPOINTS, Qt.Horizontal, "#Points")
return model
def add_test_analysis(self):
parent_id = ModelGui.NO_PARENT_ID
if self.counter > 0:
parent_id = self.counter - 1
self.add_analysis(self.counter, f"{self.counter} Blah blah blah",
parent_id, 150)
self.counter = self.counter + 1
def update_tree(self):
# Update tree based on queued events
while True:
event = {}
try:
event = self.analysis_event_queue.get_nowait()
except queue.Empty:
break
if event['event'] == AnalysisEvent.ADDED:
self.add_analysis(event['id'], event['name'],
event['parent_id'],
event['number_of_points'])
continue
if event['event'] == AnalysisEvent.FINISHED:
self.finish_analysis(event['id'], event['name'],
event['image_buf'])
continue
if event['event'] == AnalysisEvent.REMOVED:
self.remove_analysis(event['id'])
def add_analysis(self, analysis_id, name, parent_id, numpoints):
im = ImageQt.ImageQt(Image.new('RGB', self.thumb_size, (100, 0, 200)))
item = QStandardItem(QIcon(QPixmap.fromImage(im)), name)
# Need to persist the thumbnails otherwise the ImageQT will get garbage
# collected along with the memory
item.__thumb = im
if parent_id == ModelGui.NO_PARENT_ID:
#print("Adding root")
self.clear()
self.model.insertRow(0, [
item,
QStandardItem(str(analysis_id)),
QStandardItem(str(numpoints))
])
self.root_id = analysis_id
self.id_item[analysis_id] = item
else:
#print("Adding child")
parent = self.find_analysis_item(parent_id)
if parent is not None:
parent.appendRow([
item,
QStandardItem(str(analysis_id)),
QStandardItem(str(numpoints))
])
self.id_item[analysis_id] = item
self.tree.expand(parent.index())
def remove_analysis(self, analysis_id):
if analysis_id == self.root_id:
self.clear()
return
item = self.find_analysis_item(analysis_id)
if item:
if item.parent:
try:
item.parent().removeRow(item.row())
except RuntimeError:
# TODO fix bug that means this is being deleted twice
pass
del self.id_item[analysis_id]
def finish_analysis(self, analysis_id, name, image_buf):
print("finished ", analysis_id)
img = PIL.Image.open(image_buf)
thumbnail = img.resize(self.thumb_size, PIL.Image.ANTIALIAS)
# thumbnail.show()
im = ImageQt.ImageQt(thumbnail)
item = self.find_analysis_item(analysis_id)
item.setIcon(QIcon(QPixmap.fromImage(im)))
item.__thumb = im
def find_analysis_item(self, analysis_id):
""" Get the item using the numeric analysis_id """
return self.id_item.get(analysis_id, None)
def clear(self):
print('Clear model content')
if self.model is not None:
# print('Remove rows')
self.model.removeRows(0, self.model.rowCount())
# print('Reset bookkeeping')
self.id_item = {}
self.root_id = None
class FileBrowserWidget(QWidget):
on_open = pyqtSignal(str)
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.model = QFileSystemModel()
self.rootFolder = ''
self.model.setRootPath(self.rootFolder)
self.tree = QTreeView()
self.tree.setModel(self.model)
self.tree.setAnimated(False)
self.tree.setIndentation(20)
self.tree.setSortingEnabled(True)
self.tree.sortByColumn(0, 0)
self.tree.setColumnWidth(0, 200)
self.tree.setDragEnabled(True)
self.tree.setWindowTitle("Dir View")
self.tree.resize(640, 480)
self.tree.doubleClicked.connect(self.onDblClick)
self.tree.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.tree.customContextMenuRequested.connect(
self.onCustomContextMenuRequested)
windowLayout = QVBoxLayout()
windowLayout.addWidget(self.tree)
windowLayout.setContentsMargins(0, 0, 0, 0)
self.setLayout(windowLayout)
def onCustomContextMenuRequested(self, point):
index = self.tree.indexAt(point)
selectedFile = None
selectedFolder = None
ctx = QMenu("Context menu", self)
if index.isValid():
file = self.model.fileInfo(index)
selectedFile = file.absoluteFilePath()
selectedFolder = selectedFile if file.isDir(
) else file.absolutePath()
if file.isDir():
ctx.addAction(
"Open in file manager", lambda: QDesktopServices.openUrl(
QUrl.fromLocalFile(selectedFile)))
if not file.isDir():
for wndTyp, meta in WindowTypes.types:
text = 'Open with ' + meta.get('displayName', meta['name'])
print(wndTyp, meta)
ctx.addAction(
QAction(text,
self,
statusTip=text,
triggered=lambda dummy, meta=meta: navigate(
"WINDOW", "Type=" + meta['name'],
"FileName=" + selectedFile)))
ctx.addSeparator()
ctx.addAction("Set root folder ...",
lambda: self.selectRootFolder(preselect=selectedFolder))
ctx.exec(self.tree.viewport().mapToGlobal(point))
def selectRootFolder(self, preselect=None):
if preselect == None: preselect = self.rootFolder
dir = QFileDialog.getExistingDirectory(self, "Set root folder",
preselect)
if dir != None:
self.setRoot(dir)
def setRoot(self, dir):
self.rootFolder = dir
self.model.setRootPath(dir)
self.tree.setRootIndex(self.model.index(dir))
def onDblClick(self, index):
if index.isValid():
file = self.model.fileInfo(index)
if not file.isDir():
navigate("OPEN", "FileName=" + file.absoluteFilePath())
def saveState(self):
if self.tree.currentIndex().isValid():
info = self.model.fileInfo(self.tree.currentIndex())
return {"sel": info.absoluteFilePath(), "root": self.rootFolder}
def restoreState(self, state):
try:
self.setRoot(state["root"])
except:
pass
try:
idx = self.model.index(state["sel"])
if idx.isValid():
self.tree.expand(idx)
self.tree.setCurrentIndex(idx)
self.tree.scrollTo(idx, QAbstractItemView.PositionAtCenter)
except:
pass
try:
rootPath = parser.positionalArguments().pop(0)
except IndexError:
rootPath = None
model = QFileSystemModel()
model.setRootPath('')
if parser.isSet(dontUseCustomDirectoryIconsOption):
model.iconProvider().setOptions(
QFileIconProvider.DontUseCustomDirectoryIcons)
tree = QTreeView()
tree.setModel(model)
if rootPath is not None:
rootIndex = model.index(QDir.cleanPath(rootPath))
if rootIndex.isValid():
tree.setRootIndex(rootIndex)
# Demonstrating look and feel features.
tree.setAnimated(False)
tree.setIndentation(20)
tree.setSortingEnabled(True)
availableSize = QApplication.desktop().availableGeometry(tree).size()
tree.resize(availableSize / 2)
tree.setColumnWidth(0, tree.width() / 3)
tree.setWindowTitle("Dir View")
tree.show()
sys.exit(app.exec_())
## DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
## THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
## (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
## OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
## $QT_END_LICENSE$
##
#############################################################################
import sys
from PyQt5.QtWidgets import QApplication, QFileSystemModel, QTreeView
app = QApplication(sys.argv)
model = QFileSystemModel()
model.setRootPath('')
tree = QTreeView()
tree.setModel(model)
tree.setAnimated(False)
tree.setIndentation(20)
tree.setSortingEnabled(True)
tree.setWindowTitle("Dir View")
tree.resize(640, 480)
tree.show()
sys.exit(app.exec_())
class ftp_client_GUI(QtWidgets.QWidget):
def __init__(self):
super(ftp_client_GUI, self).__init__()
self.initGUI()
def initGUI(self):
qr = self.frameGeometry()
cp = QtWidgets.QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
self.setWindowTitle("FTP Client")
#label
self.title_label = QtWidgets.QLabel(self)
self.title_label.resize(300, 40)
self.title_label.move(300, 20)
self.title_label.setText("FTP Client End")
self.title_label.setStyleSheet("border-color: rgb(170, 150, 163);"
"font: 75 20pt;"
"color: rgb(126, 120, 46);")
# ip_edit
self.ip_edit = QLineEdit(self)
self.ip_edit.resize(230, 40)
self.ip_edit.move(100, 80)
self.ip_edit.setPlaceholderText("ip like 127.0.0.1")
#port_edit
self.port_edit = QLineEdit(self)
self.port_edit.resize(130, 40)
self.port_edit.move(370, 80)
self.port_edit.setPlaceholderText("port like 3000")
# connect_btn
self.connect_btn = QtWidgets.QPushButton('connect', self)
self.connect_btn.resize(150, 40)
self.connect_btn.move(550, 80)
self.connect_btn.clicked.connect(self.on_connect_btn)
# cmd edit
self.sentence_editor = QLineEdit(self)
self.sentence_editor.resize(400, 40)
self.sentence_editor.move(100, 130)
self.sentence_editor.setPlaceholderText(
"input command and argument, like 'USER anonymous'")
# cmd btn
self.cmd_btn = QtWidgets.QPushButton('push command', self)
self.cmd_btn.resize(150, 40)
self.cmd_btn.move(550, 130)
self.cmd_btn.clicked.connect(self.on_cmd_btn)
# text browser
self.text_browser = QTextBrowser(self)
self.text_browser.resize(450, 160)
self.text_browser.move(730, 20)
# file tree
self.file_model = QFileSystemModel(self)
dir_path = os.path.dirname(os.path.abspath(__file__))
self.file_model.setRootPath(dir_path)
self.tree = QTreeView(self)
self.tree.setModel(self.file_model)
self.tree.setRootIndex(self.file_model.index(dir_path))
self.tree.setAnimated(True)
self.tree.setIndentation(20)
self.tree.setSortingEnabled(True)
self.tree.setWindowTitle("Dir View")
self.tree.resize(500, 370)
self.tree.move(830, 200)
# timer
self.timer = QBasicTimer()
self.timer.start(1000, self)
# internet speed display
self.width = 200
self.height = 20
self.bias = 1200
self.cur_load_volume = 0
self.pre_load_volume = 0
self.internet_speed_label = QLabel(self)
self.internet_speed_label.move(110, 600)
self.internet_speed_label.resize(300, 20)
self.internet_speed_label.setStyleSheet(
"border-color: rgb(170, 150, 163);"
"font: 30 12pt;"
"color: rgb(126, 120, 46);")
# file total load
self.file_total_upload = 0
self.file_total_download = 0
self.file_total_upload_num = 0
self.file_total_download_num = 0
self.file_total_upload_label = QLabel(self)
self.file_total_upload_num_label = QLabel(self)
self.file_total_download_label = QLabel(self)
self.file_total_download_num_label = QLabel(self)
self.file_total_upload_label.move(self.bias, self.height + 40)
self.file_total_upload_num_label.move(self.bias, self.height + 60)
self.file_total_download_label.move(self.bias, self.height + 80)
self.file_total_download_num_label.move(self.bias, self.height + 100)
self.file_total_upload_label.resize(self.width, self.height)
self.file_total_upload_num_label.resize(self.width, self.height)
self.file_total_download_label.resize(self.width, self.height)
self.file_total_download_num_label.resize(self.width, self.height)
self.file_total_upload_label.setStyleSheet(
"border-color: rgb(170, 150, 163);"
"font: 30 12pt;"
"color: rgb(126, 120, 46);")
self.file_total_upload_num_label.setStyleSheet(
"border-color: rgb(170, 150, 163);"
"font: 30 12pt;"
"color: rgb(126, 120, 46);")
self.file_total_download_label.setStyleSheet(
"border-color: rgb(170, 150, 163);"
"font: 30 12pt;"
"color: rgb(126, 120, 46);")
self.file_total_download_num_label.setStyleSheet(
"border-color: rgb(170, 150, 163);"
"font: 30 12pt;"
"color: rgb(126, 120, 46);")
# tabel widget
self.TableWidget = QTableWidget(self)
self.TableWidget.resize(710, 370)
self.TableWidget.move(100, 200)
self.TableWidget.setRowCount(0)
self.TableWidget.setColumnCount(3)
self.TableWidget.setHorizontalHeaderLabels(['name', 'info', 'code'])
self.TableWidget.setColumnWidth(0, 80)
self.TableWidget.setColumnWidth(1, 560)
self.TableWidget.setColumnWidth(2, 65)
# progress bar
self.step = 0
self.retr_file_size = 0
self.pbar = QProgressBar(self)
self.pbar.resize(700, 15)
self.pbar.move(110, 580)
self.pbar.setValue(self.step)
self.resize(1400, 650)
self.show()
self.client_command_socket = 1
self.client_file_socket = 1
self.server_file_socket = 1
self.file_port = 3000
self.file_addr = "127.0.0.1"
self.server_port = 3000
self.server_addr = "127.0.0.1"
self.reply_sentence = ""
self.req_sentence = ""
self.client_command = ""
self.client_argument = ""
self.client_state = 0
self.offset_read = 0
self.transfer_file_path = ""
self.common_command = {
"USER", "PASS", "TYPE", "MKD", "RNFR", "RMD", "RNTO", "PWD", "CWD",
"SYST", "REST"
}
self.parti_command = {"QUIT", "PORT", "PASV", "RETR", "LIST", "STOR"}
def timerEvent(self, *args, **kwargs):
volume = self.cur_load_volume - self.pre_load_volume
byte_volume = volume % 1024
kbyte_volume = volume / 1024
self.internet_speed_label.setText("load file rate : " +
str(kbyte_volume) + " kb/s")
self.pre_load_volume = self.cur_load_volume
self.file_total_upload_label.setText(
"upload : " + str(int(self.file_total_upload / 1024)) + " kb")
self.file_total_upload_num_label.setText(
"upload : " + str(int(self.file_total_upload_num)) + " files")
self.file_total_download_label.setText(
"download : " + str(int(self.file_total_download / 1024)) + " kb")
self.file_total_download_num_label.setText(
"download : " + str(self.file_total_download_num) + " files")
if self.step == 100:
self.step = 0
self.pbar.setValue(0)
return
# send client connect msg
def on_connect_btn(self):
port = self.port_edit.text()
ip = self.ip_edit.text()
try:
self.client_command_socket = socket(AF_INET, SOCK_STREAM)
self.client_command_socket.connect((ip, int(port)))
self.reply_sentence = str(
self.client_command_socket.recv(4096).decode())
self.add_item("server " + str(self.reply_sentence))
self.client_state = 1
except:
self.client_state = 1
sent = "system 0 already connect!"
self.add_item(sent)
# receive client input and push
def on_cmd_btn(self):
sentence = self.sentence_editor.text()
cmd_arg = sentence.split(' ')
cmd_arg[0] = cmd_arg[0].upper()
# according to rfc959
temp = ""
if self.client_state == 0:
sent = "system 0 not connect!"
self.add_item(sent)
elif self.client_state == 1 or self.client_state == 2 or self.client_state == 3:
if cmd_arg[0] in self.common_command:
if cmd_arg[0] == "REST":
sentence = sentence + " " + str(self.offset_read)
sentence = sentence + "\r\n"
self.client_command_socket.send(sentence.encode())
senten = self.client_command_socket.recv(4096)
self.reply_sentence = senten.decode()
self.add_item("server " + self.reply_sentence)
elif cmd_arg[0] in self.parti_command:
if cmd_arg[0] == "QUIT":
sentence = sentence + "\r\n"
self.client_command_socket.send(sentence.encode())
self.reply_sentence = str(
self.client_command_socket.recv(4096).decode())
self.add_item("server " + str(self.reply_sentence))
self.client_command_socket.close()
return
elif cmd_arg[0] == "PORT":
port_addr = cmd_arg[1].split(',')
if len(port_addr) < 6:
self.text_browser.append(
"system : invalid PORT addr!\r\n")
self.text_browser.moveCursor(
self.text_browser.textCursor().End)
return
else:
addr = port_addr[0] + '.' + port_addr[
1] + '.' + port_addr[2] + '.' + port_addr[3]
port = int(port_addr[4]) * 256 + int(port_addr[5])
self.client_file_socket = socket(AF_INET, SOCK_STREAM)
self.client_file_socket.bind((addr, port))
self.client_file_socket.listen(10)
sentence = sentence + "\r\n"
self.client_command_socket.send(sentence.encode())
self.reply_sentence = str(
self.client_command_socket.recv(4096).decode())
self.add_item("server " + str(self.reply_sentence))
self.client_state = 2
elif cmd_arg[0] == "PASV":
sentence = sentence + "\r\n"
self.client_command_socket.send(sentence.encode())
self.reply_sentence = str(
self.client_command_socket.recv(4096).decode())
self.add_item("server " + self.reply_sentence)
li = 1
li = re.search(r"\(.*\)", self.reply_sentence)
addr = li.group()[1:-1]
addr = addr.split(',')
port = int(addr[-2]) * 256 + int(addr[-1])
addr = addr[0] + '.' + addr[1] + '.' + addr[
2] + '.' + addr[3]
self.file_addr = addr[0:]
self.file_port = port
self.client_state = 3
self.client_file_socket = socket(AF_INET, SOCK_STREAM)
elif cmd_arg[0] == "RETR":
if self.client_state == 2:
sentence = sentence + "\r\n"
self.client_command_socket.send(sentence.encode())
self.server_file_socket, temp = self.client_file_socket.accept(
)
self.reply_sentence = str(
self.client_command_socket.recv(4096).decode())
self.add_item("server " + str(self.reply_sentence))
if self.reply_sentence.split(
' ')[0] != "550" and self.reply_sentence.split(
' ')[0] != "503":
self.retr_file_size = self.get_retr_file_size(
self.reply_sentence)
self.transfer_file_path = cmd_arg[1][:]
self.recv_data()
self.server_file_socket.close()
self.client_file_socket.close()
self.server_file_socket = -1
self.client_file_socket = -1
elif self.client_state == 3:
sentence = sentence + "\r\n"
self.client_command_socket.send(sentence.encode())
self.client_file_socket.connect(
(self.file_addr, self.file_port))
self.reply_sentence = str(
self.client_command_socket.recv(4096).decode())
self.add_item("server " + str(self.reply_sentence))
self.server_file_socket = self.client_file_socket
if self.reply_sentence.split(
' ')[0] != "550" and self.reply_sentence.split(
' ')[0] != "503":
self.retr_file_size = self.get_retr_file_size(
self.reply_sentence)
self.transfer_file_path = cmd_arg[1][:]
self.recv_data()
self.server_file_socket.close()
else:
self.add_item("system 0 require PASV/PORT mode")
if self.reply_sentence.split(' ')[0] != "550" and len(
self.reply_sentence.split("\r\n")[1]
) == 0 and self.step == 100 and self.reply_sentence.split(
' ')[0] != "503" and self.client_state != 1:
self.reply_sentence = str(
self.client_command_socket.recv(4096).decode())
self.add_item("server " + str(self.reply_sentence))
self.client_state = 1
elif cmd_arg[0] == "LIST":
if self.client_state == 2:
sentence = sentence + "\r\n"
self.client_command_socket.send(sentence.encode())
self.server_file_socket, temp = self.client_file_socket.accept(
)
self.reply_sentence = str(
self.client_command_socket.recv(4096).decode())
self.add_item("server " + str(self.reply_sentence))
if self.reply_sentence.startswith("150"):
self.print_list(self.server_file_socket)
self.server_file_socket.close()
self.client_file_socket.close()
self.server_file_socket = -1
self.client_file_socket = -1
elif self.client_state == 3:
sentence = sentence + "\r\n"
self.client_command_socket.send(sentence.encode())
self.client_file_socket.connect(
(self.file_addr, self.file_port))
self.reply_sentence = str(
self.client_command_socket.recv(4096).decode())
self.add_item("server " + str(self.reply_sentence))
if self.reply_sentence.startswith("150"):
self.server_file_socket = self.client_file_socket
self.print_list(self.server_file_socket)
self.server_file_socket.close()
else:
self.add_item("system 0 require PASV/PORT mode")
if self.reply_sentence.startswith(
"150") and self.client_state != 1:
self.reply_sentence = str(
self.client_command_socket.recv(4096).decode())
self.add_item("server " + str(self.reply_sentence))
self.client_state = 1
elif cmd_arg[0] == "STOR":
if self.get_file_size(cmd_arg[1]) == 0:
self.add_item("system 0 file not found")
return
if self.client_state == 2:
sentence = sentence + "\r\n"
self.client_command_socket.send(sentence.encode())
self.server_file_socket, temp = self.client_file_socket.accept(
)
self.reply_sentence = str(
self.client_command_socket.recv(4096).decode())
self.add_item("server " + str(self.reply_sentence))
self.send_data(cmd_arg[1], self.server_file_socket)
self.server_file_socket.close()
self.client_file_socket.close()
self.server_file_socket = -1
self.client_file_socket = -1
elif self.client_state == 3:
sentence = sentence + "\r\n"
self.client_command_socket.send(sentence.encode())
self.client_file_socket.connect(
(self.file_addr, self.file_port))
self.reply_sentence = str(
self.client_command_socket.recv(4096).decode())
self.add_item("server " + str(self.reply_sentence))
self.server_file_socket = self.client_file_socket
self.send_data(cmd_arg[1], self.server_file_socket)
self.server_file_socket.close()
else:
self.add_item("system 0 require PASV/PORT mode")
if self.client_state != 1:
self.reply_sentence = str(
self.client_command_socket.recv(4096).decode())
self.add_item("server " + str(self.reply_sentence))
self.client_state = 1
else:
self.text_browser.append("system : invalid command")
self.text_browser.moveCursor(
self.text_browser.textCursor().End)
else:
sent = "system 0 not connect!"
self.add_item(sent)
def recv_data(self):
file_path = self.transfer_file_path[:]
sock = self.server_file_socket
if self.offset_read == 0:
fp = open(file_path, "wb")
else:
fp = open(file_path, "ab")
fp.seek(self.offset_read - 1, 0)
self.retr_file_size = self.retr_file_size - self.offset_read
data_stream = sock.recv(4096)
self.pre_load_volume = 0
self.cur_load_volume = 0
count = 0
time1 = int(time.time() * 10000)
time2 = int(time.time() * 10000)
while data_stream:
self.cur_load_volume += len(data_stream)
self.step = (self.cur_load_volume / self.retr_file_size) * 100
self.pbar.setValue(self.step)
fp.write(data_stream)
data_stream = ''
data_stream = sock.recv(4096)
count += 1
if count == 20:
volume = self.cur_load_volume - self.pre_load_volume
byte_volume = volume % 1024
kbyte_volume = volume / 1024
time2 = int(time.time() * 10000)
interval = (time2 - time1) / 10000
if interval != 0:
self.internet_speed_label.setText(
"load file rate : " +
str(round(kbyte_volume / interval, 1)) + " kb/s")
self.pre_load_volume = self.cur_load_volume
time1 = time2
count = 0
else:
continue
if self.step == 100:
self.offset_read = 0
else:
self.offset_read = self.cur_load_volume
fp.close()
self.file_total_download += self.cur_load_volume
self.file_total_download_num += 1
self.pre_load_volume = 0
self.cur_load_volume = 0
return
def send_data(self, file_path, sock):
fp = open(file_path, "rb")
n = 2
buf = ""
file_size = int(self.get_file_size(file_path))
self.pre_load_volume = 0
self.cur_load_volume = 0
count = 0
time1 = int(time.time() * 10000)
time2 = int(time.time() * 10000)
while n > 0:
buf = fp.read(4096)
n = len(buf)
self.cur_load_volume += n
self.step = (self.cur_load_volume / file_size) * 100
self.pbar.setValue(self.step)
count += 1
if count == 20:
volume = self.cur_load_volume - self.pre_load_volume
byte_volume = volume % 1024
kbyte_volume = volume / 1024
time2 = int(time.time() * 10000)
interval = (time2 - time1) / 10000
if interval != 0:
self.internet_speed_label.setText(
"load file rate : " +
str(round(kbyte_volume / interval, 1)) + " kb/s")
self.pre_load_volume = self.cur_load_volume
time1 = time2
count = 0
sock.send(buf)
fp.close()
self.file_total_upload += self.cur_load_volume
self.file_total_upload_num += 1
self.pre_load_volume = 0
self.cur_load_volume = 0
return
def print_list(self, sock):
n = 2
data_stream = sock.recv(4096)
while n > 0:
self.text_browser.setText(data_stream.decode())
self.text_browser.moveCursor(self.text_browser.textCursor().End)
data_stream = sock.recv(4096)
n = len(data_stream)
return
def recv_info(self):
self.reply_sentence = self.client_command_socket.recv(4096).decode()
self.text_browser.append("server : " + self.reply_sentence)
self.text_browser.moveCursor(self.text_browser.textCursor().End)
return
def add_item(self, sentence):
spl = sentence.split(' ')
name = spl[0]
code = spl[1]
info = ""
for i in spl[2:]:
info += i + ' '
self.TableWidget.setRowCount(self.TableWidget.rowCount() + 1)
newItem = QTableWidgetItem(name)
self.TableWidget.setItem(self.TableWidget.rowCount() - 1, 0, newItem)
newItem = QTableWidgetItem(info)
self.TableWidget.setItem(self.TableWidget.rowCount() - 1, 1, newItem)
newItem = QTableWidgetItem(code)
self.TableWidget.setItem(self.TableWidget.rowCount() - 1, 2, newItem)
def get_file_size(self, file_path):
try:
size = os.path.getsize(file_path)
return size
except Exception as err:
return 0
def get_retr_file_size(self, sentence):
li = re.search(r"\(.*\)", self.reply_sentence)
if li.group() != None:
temp = li.group()[1:-1]
cv = re.search(r"\d+", temp)
return int(cv.group())
else:
return 99999999
## DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
## THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
## (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
## OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
## $QT_END_LICENSE$
##
#############################################################################
import sys
from PyQt5.QtWidgets import QApplication, QFileSystemModel, QTreeView
app = QApplication(sys.argv)
model = QFileSystemModel()
model.setRootPath('')
tree = QTreeView()
tree.setModel(model)
tree.setAnimated(False)
tree.setIndentation(5)
tree.setSortingEnabled(True)
tree.setWindowTitle("MRAT workspace")
tree.resize(340, 480)
tree.show()
sys.exit(app.exec_())
print('Directory') # Directory 출력
else:
path = model.filePath(index)
label.setPixmap(QPixmap(path))
if __name__ == '__main__':
app = QApplication(sys.argv)
tree_view = QTreeView()
tree_view.show()
model = QFileSystemModel() # 파일 창 띄우기
tree_view.setModel(model)
root_path = "../" # 파일 경로
model.setRootPath(root_path)
tree_view.setRootIndex(model.index(root_path))
tree_view.setColumnWidth(0, 400)
tree_view.resize(700, 500)
tree_view.setColumnHidden(1, True) # 두번째 컬럼 숨기기
tree_view.setColumnHidden(2, True) # 세번째 컬럼 숨기기
tree_view.setColumnHidden(3, True) # 네번째 컬럼 숨기기
tree_view.doubleClicked.connect(double_click_event) # 트리 창 더블클릭하면 함수 double_click_event수행
label = QLabel("label") # label 창 띄우기
label.resize(600, 400) # label 창 크기 정하기
label.show() # label 창 보여주기
app.exec_()
treeView = QTreeView()
#treeView.addAction()
treeView = QTreeView()
treeView.setSelectionBehavior(QAbstractItemView.SelectRows)
model = QStandardItemModel()
model.setHorizontalHeaderLabels(["Properties", "Values"])
treeView.setModel(model)
treeView.setUniformRowHeights(True)
for i in range(3):
child1 = QStandardItem("Property")
child1.setEditable(False)
child2 = QStandardItem("Value")
model.appendRow([child1, child2])
treeView.resize(QSize(100, 100))
layout = QHBoxLayout()
layout.addWidget(treeView)
layout.addWidget(view)
layout.addWidget(textEdit)
w.setLayout(layout)
mainWindow.menuBar().addMenu("File")
mainWindow.menuBar().addMenu("Help")
toolBar = QToolBar()
toolBar.setGeometry(QRect(100, 100, 100, 100))
toolBar.addAction("Node")
# 如果是文件夹
return self.DirIcon
return super(FileIconProvider, self).icon(type_info)
def getInfoIcon(self, type_info):
if type_info.isDir(): # 文件夹
return self.DirIcon
if type_info.isFile() and type_info.suffix() == "txt": # 文件并且是txt
return self.TxtIcon
return super(FileIconProvider, self).icon(type_info)
if __name__ == "__main__":
app = QApplication(sys.argv)
model = QFileSystemModel()
model.setIconProvider(FileIconProvider()) # 设置为自定义的图标提供类
model.setRootPath("")
tree = QTreeView()
tree.setModel(model)
tree.setAnimated(False)
tree.setIndentation(20)
tree.setSortingEnabled(True)
tree.setWindowTitle("Dir View")
tree.resize(640, 480)
tree.show()
sys.exit(app.exec_())
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#@Time : 14:16 2019/11/25
#@Author : tb_youth
#@FileName: TreeWidget3.py
#@SoftWare: PyCharm
#@Blog : http://blog.csdn.net/tb_youth
'''
QTreeView 控件与系统定制模式
QTreeWidget
Model
QDirModel
'''
import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QTreeView, QDirModel
if __name__ == '__main__':
app = QApplication(sys.argv)
model = QDirModel()
tree = QTreeView()
tree.setModel(model)
tree.show()
tree.resize(800, 400)
tree.setWindowTitle('QTreeView')
sys.exit(app.exec_())
try:
rootPath = parser.positionalArguments().pop(0)
except IndexError:
rootPath = None
model = QFileSystemModel()
model.setRootPath("")
if parser.isSet(dontUseCustomDirectoryIconsOption):
model.iconProvider().setOptions(
QFileIconProvider.DontUseCustomDirectoryIcons)
tree = QTreeView()
tree.setModel(model)
if rootPath is not None:
rootIndex = model.index(QDir.cleanPath(rootPath))
if rootIndex.isValid():
tree.setRootIndex(rootIndex)
# Demonstrating look and feel features.
tree.setAnimated(False)
tree.setIndentation(20)
tree.setSortingEnabled(True)
availableSize = QApplication.desktop().availableGeometry(tree).size()
tree.resize(availableSize / 2)
tree.setColumnWidth(0, tree.width() / 3)
tree.setWindowTitle("Dir View")
tree.show()
sys.exit(app.exec_())
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.resize(800, 600)
MainWindow.setMinimumSize(600, 400)
icon = QIcon()
icon.addPixmap(QPixmap("icon.png"), QIcon.Normal, QIcon.Off)
font = QFont()
font.setFamily("MS Sans Serif")
font.setBold(True)
font.setWeight(75)
MainWindow.setWindowIcon(icon)
self.centralwidget = QWidget(MainWindow)
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QMenuBar(MainWindow)
self.menuFiles = QMenu(self.menubar)
self.menuMark = QMenu(self.menubar)
self.menuCommands = QMenu(self.menubar)
self.menuNet = QMenu(self.menubar)
self.menuShow = QMenu(self.menubar)
self.menuConfiguration = QMenu(self.menubar)
self.menuStart = QMenu(self.menubar)
MainWindow.setMenuBar(self.menubar)
self.helpMenuBar = QMenuBar(self.menubar)
self.menuHelp = QMenu(self.helpMenuBar)
self.helpMenuBar.addMenu(self.menuHelp)
self.menubar.setCornerWidget(self.helpMenuBar)
self.toolBar = QToolBar(MainWindow)
self.toolBar.setMovable(False)
MainWindow.addToolBar(QtCore.Qt.TopToolBarArea, self.toolBar)
self.toolBar_2 = QToolBar(MainWindow)
font2 = QFont()
font2.setFamily("MS Sans Serif")
font2.setWeight(700)
font2.setPixelSize(8)
font2.setBold(True)
self.model1 = QFileSystemModel()
self.model1.setRootPath('C:\\Windows')
self.tree1 = QTreeView()
self.tree1.setModel(self.model1)
self.tree1.setRootIndex(self.model1.index("C:\\Windows\\"))
self.tree1.setAnimated(False)
self.tree1.setFont(font2)
self.tree1.setIndentation(20)
self.tree1.setSortingEnabled(True)
self.tree1.setItemsExpandable(False)
self.tree1.setRootIsDecorated(False)
self.tree1.sortByColumn(0, QtCore.Qt.AscendingOrder)
self.tree1.resize(350, 480)
self.model2 = QFileSystemModel()
self.model2.setRootPath('C:\\Windows\\System32')
self.tree2 = QTreeView()
self.tree2.setModel(self.model2)
self.tree2.setRootIndex(self.model2.index("C:\\Windows\\System32\\"))
self.tree2.setAnimated(False)
self.tree2.setFont(font2)
self.tree2.setIndentation(20)
self.tree2.setItemsExpandable(False)
self.tree2.setRootIsDecorated(False)
self.tree2.setSortingEnabled(True)
self.tree2.resize(350, 480)
for i in range(1, self.tree1.model().columnCount()):
self.tree1.header().hideSection(i)
for i in range(1, self.tree2.model().columnCount()):
self.tree2.header().hideSection(i)
self.centralHBox = QHBoxLayout()
self.centralHBox.addWidget(self.tree1)
self.centralHBox.addWidget(self.tree2)
self.centralHBox.setContentsMargins(3, 3, 3, 3)
self.centralwidget.setLayout(self.centralHBox)
self.toolBar_2.setMovable(False)
self.toolBar_3 = QToolBar(MainWindow)
self.toolBar_3.setFixedHeight(30)
self.toolBar_3.setContentsMargins(1, 1, 1, 1)
self.dirLabel = QLabel()
self.dirLabel.setText('c:\\Windows>')
self.dirBox = QComboBox()
self.dirBox.setEditable(True)
self.dirBox.addItem('')
self.dirBox.setFixedWidth(470)
self.spacer = QWidget()
self.spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
self.toolBar_3.addWidget(self.spacer)
self.toolBar_3.addWidget(self.dirLabel)
self.toolBar_3.addWidget(self.dirBox)
self.toolBar_3.setFont(font)
self.toolBar_3.setMovable(False)
self.toolBar_3.setStyleSheet("QToolBar{spacing: 5px;}")
MainWindow.addToolBar(QtCore.Qt.BottomToolBarArea, self.toolBar_2)
MainWindow.addToolBar(QtCore.Qt.BottomToolBarArea, self.toolBar_3)
MainWindow.insertToolBarBreak(self.toolBar_3)
self.actionIndex = QAction(MainWindow)
icon1 = QIcon()
icon1.addPixmap(QPixmap("help.png"), QIcon.Normal, QIcon.Off)
self.actionIndex.setIcon(icon1)
self.actionKeyboard = QAction(MainWindow)
self.actionRegistration_Info = QAction(MainWindow)
self.actionVisit_Total_CMD_s_website = QAction(MainWindow)
self.actionAbout_Total_Commander = QAction(MainWindow)
self.actionOption_1 = QAction(MainWindow)
self.actionOption_2 = QAction(MainWindow)
self.actionOption_3 = QAction(MainWindow)
self.actionOption_4 = QAction(MainWindow)
self.actionOption_5 = QAction(MainWindow)
self.actionOption_6 = QAction(MainWindow)
self.actionOption_7 = QAction(MainWindow)
self.actionOption_8 = QAction(MainWindow)
self.actionOption_9 = QAction(MainWindow)
self.actionOption_10 = QAction(MainWindow)
self.actionOption_11 = QAction(MainWindow)
self.actionOption_12 = QAction(MainWindow)
self.actionOption_13 = QAction(MainWindow)
self.actionOption_14 = QAction(MainWindow)
self.Refresh = QAction(MainWindow)
icon2 = QIcon()
icon2.addPixmap(QPixmap("refresh.png"), QIcon.Normal, QIcon.Off)
self.Refresh.setIcon(icon2)
self.action_view1 = QAction(MainWindow)
icon3 = QIcon()
icon3.addPixmap(QPixmap("folder_structure_1.png"), QIcon.Normal,
QIcon.Off)
self.view_group = QActionGroup(MainWindow)
self.action_view1.setIcon(icon3)
self.action_view1.setCheckable(True)
self.action_view2 = QAction(MainWindow)
self.action_view2.setCheckable(True)
self.action_view2.setChecked(True)
icon4 = QIcon()
icon4.addPixmap(QPixmap("folder_structure_2.png"), QIcon.Normal,
QIcon.Off)
self.action_view2.setIcon(icon4)
self.view_group.addAction(self.action_view1)
self.view_group.addAction(self.action_view2)
self.view_group.setExclusive(True)
self.actionF3_View = QToolButton(MainWindow)
self.actionF3_View.setStyleSheet("QToolButton{border: none;}")
self.actionF3_View.setFont(font)
self.actionF4_Edit = QToolButton(MainWindow)
self.actionF4_Edit.setStyleSheet("QToolButton{border: none;}")
self.actionF4_Edit.setFont(font)
self.actionF5_Copy = QToolButton(MainWindow)
self.actionF5_Copy.setStyleSheet("QToolButton{border: none;}")
self.actionF5_Copy.setFont(font)
self.actionF6_Move = QToolButton(MainWindow)
self.actionF6_Move.setStyleSheet("QToolButton{border: none;}")
self.actionF6_Move.setFont(font)
self.actionF5_NewFolder = QToolButton(MainWindow)
self.actionF5_NewFolder.setStyleSheet("QToolButton{border: none;}")
self.actionF5_NewFolder.setFont(font)
self.actionF8_Delete = QToolButton(MainWindow)
self.actionF8_Delete.setStyleSheet("QToolButton{border: none;}")
self.actionF8_Delete.setFont(font)
self.actionAlt_F4_Exit = QToolButton(MainWindow)
self.actionAlt_F4_Exit.setStyleSheet("QToolButton{border: none;}")
self.actionAlt_F4_Exit.setFont(font)
self.menuFiles.addAction(self.actionOption_1)
self.menuFiles.addAction(self.actionOption_2)
self.menuMark.addAction(self.actionOption_3)
self.menuMark.addAction(self.actionOption_4)
self.menuCommands.addAction(self.actionOption_5)
self.menuCommands.addAction(self.actionOption_6)
self.menuNet.addAction(self.actionOption_7)
self.menuNet.addAction(self.actionOption_8)
self.menuShow.addAction(self.actionOption_9)
self.menuShow.addAction(self.actionOption_10)
self.menuConfiguration.addAction(self.actionOption_11)
self.menuConfiguration.addAction(self.actionOption_12)
self.menuStart.addAction(self.actionOption_13)
self.menuStart.addAction(self.actionOption_14)
self.menuHelp.addAction(self.actionIndex)
self.menuHelp.addAction(self.actionKeyboard)
self.menuHelp.addAction(self.actionRegistration_Info)
self.menuHelp.addAction(self.actionVisit_Total_CMD_s_website)
self.menuHelp.addSeparator()
self.menuHelp.addAction(self.actionAbout_Total_Commander)
self.menubar.addAction(self.menuFiles.menuAction())
self.menubar.addAction(self.menuMark.menuAction())
self.menubar.addAction(self.menuCommands.menuAction())
self.menubar.addAction(self.menuNet.menuAction())
self.menubar.addAction(self.menuShow.menuAction())
self.menubar.addAction(self.menuConfiguration.menuAction())
self.menubar.addAction(self.menuStart.menuAction())
self.helpMenuBar.addAction(self.menuHelp.menuAction())
self.toolBar.addAction(self.Refresh)
self.toolBar.addSeparator()
self.toolBar.addAction(self.action_view1)
self.toolBar.addSeparator()
self.toolBar.addAction(self.action_view2)
self.separator1 = QFrame()
self.separator1.setFrameShape(QFrame.VLine)
self.separator1.setFrameShadow(QFrame.Sunken)
self.separator2 = QFrame()
self.separator2.setFrameShape(QFrame.VLine)
self.separator2.setFrameShadow(QFrame.Sunken)
self.separator3 = QFrame()
self.separator3.setFrameShape(QFrame.VLine)
self.separator3.setFrameShadow(QFrame.Sunken)
self.separator4 = QFrame()
self.separator4.setFrameShape(QFrame.VLine)
self.separator4.setFrameShadow(QFrame.Sunken)
self.separator5 = QFrame()
self.separator5.setFrameShape(QFrame.VLine)
self.separator5.setFrameShadow(QFrame.Sunken)
self.separator6 = QFrame()
self.separator6.setFrameShape(QFrame.VLine)
self.separator6.setFrameShadow(QFrame.Sunken)
self.toolbarHBoxWidget = QWidget()
self.toolbarHBoxWidget.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Preferred)
self.toolbarHBox = QGridLayout()
self.toolbarHBoxWidget.setLayout(self.toolbarHBox)
self.toolbarHBox.addWidget(self.actionF3_View, 0, 0)
self.toolbarHBox.addWidget(self.separator1, 0, 1)
self.toolbarHBox.addWidget(self.actionF4_Edit, 0, 2)
self.toolbarHBox.addWidget(self.separator2, 0, 3)
self.toolbarHBox.addWidget(self.actionF5_Copy, 0, 4)
self.toolbarHBox.addWidget(self.separator3, 0, 5)
self.toolbarHBox.addWidget(self.actionF6_Move, 0, 6)
self.toolbarHBox.addWidget(self.separator4, 0, 7)
self.toolbarHBox.addWidget(self.actionF5_NewFolder, 0, 8)
self.toolbarHBox.addWidget(self.separator5, 0, 9)
self.toolbarHBox.addWidget(self.actionF8_Delete, 0, 10)
self.toolbarHBox.addWidget(self.separator6, 0, 11)
self.toolbarHBox.addWidget(self.actionAlt_F4_Exit, 0, 12)
self.toolBar_2.addWidget(self.toolbarHBoxWidget)
self.toolBar_2.setFixedHeight(40)
self.retranslateUi(MainWindow)
QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
MainWindow.setWindowTitle(
"Total Commander 7.50a - Politechnika Lodzka - Wydzial EEIA")
self.menuFiles.setTitle("Files")
self.menuMark.setTitle("Mark")
self.menuCommands.setTitle("Commands")
self.menuNet.setTitle("Net")
self.menuShow.setTitle("Show")
self.menuConfiguration.setTitle("Configuration")
self.menuStart.setTitle("Start")
self.menuHelp.setTitle("Help")
self.toolBar.setWindowTitle("toolBar")
self.toolBar_2.setWindowTitle("toolBar_2")
self.actionIndex.setText("Index")
self.actionIndex.setIconText("Index")
self.actionIndex.setShortcut("F1")
self.actionKeyboard.setText("Keyboard")
self.actionRegistration_Info.setText("Registration Info")
self.actionVisit_Total_CMD_s_website.setText(
"Visit Totalcmd\'s Web Site")
self.actionAbout_Total_Commander.setText("About Total Commander...")
self.actionOption_1.setText("Option 1")
self.actionOption_2.setText("Option 2")
self.actionOption_3.setText("Option 1")
self.actionOption_4.setText("Option 2")
self.actionOption_5.setText("Option 1")
self.actionOption_6.setText("Option 2")
self.actionOption_7.setText("Option 1")
self.actionOption_8.setText("Option 2")
self.actionOption_9.setText("Option 1")
self.actionOption_10.setText("Option 2")
self.actionOption_11.setText("Option 1")
self.actionOption_12.setText("Option 2")
self.actionOption_13.setText("Option 1")
self.actionOption_14.setText("Option 2")
self.Refresh.setText("Refresh")
self.action_view1.setText("View 1")
self.action_view2.setText("View 2")
self.actionF3_View.setText("F3 View")
self.actionF3_View.setShortcut("F3")
self.actionF4_Edit.setText("F4 Edit")
self.actionF4_Edit.setShortcut("F4")
self.actionF5_Copy.setText("F5 Copy")
self.actionF5_Copy.setShortcut("F5")
self.actionF6_Move.setText("F6 Move")
self.actionF6_Move.setShortcut("F6")
self.actionF5_NewFolder.setText("F7 NewFolder")
self.actionF5_NewFolder.setShortcut("F7")
self.actionF8_Delete.setText("F8 Delete")
self.actionF8_Delete.setShortcut("F8")
self.actionAlt_F4_Exit.setText("Alt+F4 Exit")
self.actionAlt_F4_Exit.setShortcut("Ctrl+Alt+F4")
