def addItem(self,
project_info: ProjectInfo,
plugin_name=None,
enabled=True):
# don't add duplicates
if (self.findItems(project_info.name, Qt.MatchFixedString)
and not plugin_name):
return
# including summary here for sake of filtering below.
searchable_text = project_info.name + " " + project_info.summary
item = QListWidgetItem(searchable_text, parent=self)
item.version = project_info.version
super().addItem(item)
widg = PluginListItem(
*project_info,
parent=self,
plugin_name=plugin_name,
enabled=enabled,
)
method = getattr(self.installer,
'uninstall' if plugin_name else 'install')
widg.action_button.clicked.connect(lambda: method([project_info.name]))
item.setSizeHint(widg.sizeHint())
self.setItemWidget(item, widg)
def __set_name(self, index: int) -> None:
"""Load the parameters of the point."""
if not len(self.vpoints) > index:
return
vpoint = self.vpoints[index]
self.x_box.setValue(vpoint.x)
self.y_box.setValue(vpoint.y)
color_text = vpoint.color_str
color_index = self.color_box.findText(color_text)
if color_index > -1:
self.color_box.setCurrentIndex(color_index)
else:
self.color_box.addItem(color_icon(color_text), color_text)
self.color_box.setCurrentIndex(self.color_box.count() - 1)
self.type_box.setCurrentIndex(vpoint.type)
self.angle_box.setValue(vpoint.angle)
self.noSelected.clear()
self.selected.clear()
for linkName in vpoint.links:
self.selected.addItem(QListWidgetItem(self.link_icon, linkName))
for vlink in self.vlinks:
if vlink.name in vpoint.links:
continue
self.noSelected.addItem(QListWidgetItem(self.link_icon,
vlink.name))
def __set_name(self, index: int) -> None:
"""Load the parameters of the link."""
if not self.name_box.isEnabled():
return
if len(self.vlinks) > index:
vlink = self.vlinks[index]
self.name_edit.setText(vlink.name)
color_text = vlink.color_str
color_index = self.color_box.findText(color_text)
if color_index > -1:
self.color_box.setCurrentIndex(color_index)
else:
self.color_box.addItem(color_icon(color_text), color_text)
self.color_box.setCurrentIndex(self.color_box.count() - 1)
self.noSelected.clear()
self.selected.clear()
for p in vlink.points:
self.selected.addItem(QListWidgetItem(self.icon, f'Point{p}'))
for p in range(len(self.vpoints)):
if p in vlink.points:
continue
self.noSelected.addItem(QListWidgetItem(self.icon, f'Point{p}'))
not_ground = index > 0
for widget in (self.name_edit, self.color_box, self.color_pick_button):
widget.setEnabled(not_ground)
def addItem(self,
project_info: ProjectInfo,
plugin_name=None,
enabled=True):
# don't add duplicates
if self.findItems(project_info.name, Qt.MatchFixedString):
if not plugin_name:
return
item = QListWidgetItem(project_info.name, parent=self)
item.version = project_info.version
super().addItem(item)
widg = PluginListItem(
*project_info,
parent=self,
plugin_name=plugin_name,
enabled=enabled,
)
method = getattr(self.installer,
'uninstall' if plugin_name else 'install')
widg.action_button.clicked.connect(lambda: method([project_info.name]))
item.setSizeHint(widg.sizeHint())
self.setItemWidget(item, widg)
def update_progress(self, progress):
if not progress:
return
self.log.clear()
for entry in progress:
title, description, date, icon = entry
entry = EntryWidget()
entry.setTitle(title)
entry.setDescription(description)
entry.setDate(date)
entry.setIcon(QIcon.fromTheme(icon), self.iconsize)
if self.style_thresh:
if (int(date) < self.style_thresh):
entry.setStyle("color: lightgreen")
else:
entry.setStyle("color: lightsalmon")
item = QListWidgetItem(self.log)
item.setSizeHint(entry.sizeHint())
self.log.insertItem(0, item)
self.log.setItemWidget(item, entry)
def rebuild_selected_packages_list_widget(self):
# remove all items
self.selected_packages_list_widget.clear()
for f in self.file_paths:
file_item = QListWidgetItem()
file_item.setText(f)
self.selected_packages_list_widget.addItem(file_item)
def update_list(self, filter_text):
"""
Update the displayed list by filtering self.completion_list.
If no items are left on the list the autocompletion should stop
"""
self.clear()
icons_map = {CompletionItemKind.TEXT: 'text',
CompletionItemKind.METHOD: 'method',
CompletionItemKind.FUNCTION: 'function',
CompletionItemKind.CONSTRUCTOR: 'constructor',
CompletionItemKind.FIELD: 'field',
CompletionItemKind.VARIABLE: 'variable',
CompletionItemKind.CLASS: 'class',
CompletionItemKind.INTERFACE: 'interface',
CompletionItemKind.MODULE: 'module',
CompletionItemKind.PROPERTY: 'property',
CompletionItemKind.UNIT: 'unit',
CompletionItemKind.VALUE: 'value',
CompletionItemKind.ENUM: 'enum',
CompletionItemKind.KEYWORD: 'keyword',
CompletionItemKind.SNIPPET: 'snippet',
CompletionItemKind.COLOR: 'color',
CompletionItemKind.FILE: 'filenew',
CompletionItemKind.REFERENCE: 'reference',
}
height = self.item_height
width = self.item_width
for completion in self.completion_list:
if not self.is_internal_console:
completion_label = completion['filterText']
icon = icons_map.get(completion['kind'], 'no_match')
completion_data = completion['insertText']
completion_text = self.get_html_item_representation(
completion_data, icon, height=height, width=width)
item = QListWidgetItem(ima.icon(icon),
completion_text)
item.setData(Qt.UserRole, completion_data)
else:
completion_label = completion[0]
completion_text = self.get_html_item_representation(
completion_label, '', height=height, width=width)
item = QListWidgetItem()
item.setData(Qt.UserRole, completion_label)
item.setText(completion_text)
if self.check_can_complete(
completion_label, filter_text):
self.addItem(item)
if self.count() > 0:
self.setCurrentRow(0)
self.scrollTo(self.currentIndex(),
QAbstractItemView.PositionAtTop)
else:
self.hide()
def __init__(self,
name: str,
widget: QListWidget,
parent: Optional[QWidget] = None):
super(AddInput, self).__init__(parent)
self.setText(f"Add variable of {name}")
self.item = QListWidgetItem(name)
self.item.setToolTip(name)
self.widget = widget
def update(self, files):
self.clear()
for i, fname in enumerate(files):
fname = fname.encode('utf-8')
text = os.path.basename(fname)
icon = QIcon(FILE_ICON)
item = QListWidgetItem(icon, text)
item.setData(Qt.UserRole, fname)
self.addItem(item)
def setup_symbol_list(self, filter_text, current_path):
"""Setup list widget content for symbol list display."""
# Get optional symbol name
filter_text, symbol_text = filter_text.split('@')
# Fetch the Outline explorer data, get the icons and values
oedata = self.get_symbol_list()
icons = get_python_symbol_icons(oedata)
# The list of shorten paths here is needed in order to have the same
# point of measurement for the list widget width as in the file list
# See issue 4648
short_paths = shorten_paths(self.paths, self.save_status)
symbol_list = process_python_symbol_data(oedata)
line_fold_token = [(item[0], item[2], item[3]) for item in symbol_list]
choices = [item[1] for item in symbol_list]
scores = get_search_scores(symbol_text, choices, template="<b>{0}</b>")
# Build the text that will appear on the list widget
results = []
lines = []
self.filtered_symbol_lines = []
for index, score in enumerate(scores):
text, rich_text, score_value = score
line, fold_level, token = line_fold_token[index]
lines.append(text)
if score_value != -1:
results.append((score_value, line, text, rich_text, fold_level,
icons[index], token))
template = '{0}{1}'
for (score, line, text, rich_text, fold_level, icon,
token) in sorted(results):
fold_space = ' ' * (fold_level)
line_number = line + 1
self.filtered_symbol_lines.append(line_number)
textline = template.format(fold_space, rich_text)
item = QListWidgetItem(icon, textline)
item.setSizeHint(QSize(0, 16))
self.list.addItem(item)
# To adjust the delegate layout for KDE themes
self.list.files_list = False
# Move selected item in list accordingly
# NOTE: Doing this is causing two problems:
# 1. It makes the cursor to auto-jump to the last selected
# symbol after opening or closing a different file
# 2. It moves the cursor to the first symbol by default,
# which is very distracting.
# That's why this line is commented!
# self.set_current_row(0)
# Update list size
self.fix_size(short_paths, extra=100)
def update_list(self):
"""Update path list"""
self.listwidget.clear()
for name in self.pathlist+self.ro_pathlist:
item = QListWidgetItem(name)
item.setIcon(ima.icon('DirClosedIcon'))
if name in self.ro_pathlist:
item.setFlags(Qt.NoItemFlags)
self.listwidget.addItem(item)
self.refresh()
def _on_data_change(self, *event):
components = getattr(type(self.state), 'component').get_choices(self.state)
self.ui.list_component.clear()
for component in components:
item = QListWidgetItem(component.label)
item.setCheckState(Qt.Checked)
self.ui.list_component.addItem(item)
def activated_details(self, item: QListWidgetItem):
"""
Handles context switch when another working day was selected in the left list.
:param item:
:return:
"""
self.ui.tabWidget_Details.setEnabled(True)
self.time_capture_service.selected_day = item.text()
self.__clean_and_load_entries__(item.text())
self.__clean_and_load_bookings__(item.text())
self.ui.label_sumHours.setText("Sum: {} hrs".format(self.__sum_booked_hours__()))
def setup_file_list(self, filter_text, current_path):
"""Setup list widget content for file list display."""
short_paths = shorten_paths(self.paths, self.save_status)
paths = self.paths
results = []
trying_for_line_number = ':' in filter_text
# Get optional line number
if trying_for_line_number:
filter_text, line_number = filter_text.split(':')
else:
line_number = None
# Get all available filenames and get the scores for "fuzzy" matching
scores = get_search_scores(filter_text, self.filenames,
template="<b>{0}</b>")
# Build the text that will appear on the list widget
for index, score in enumerate(scores):
text, rich_text, score_value = score
if score_value != -1:
text_item = '<big>' + rich_text.replace('&', '') + '</big>'
if trying_for_line_number:
text_item += " [{0:} {1:}]".format(self.line_count[index],
_("lines"))
text_item += "<br><i>{0:}</i>".format(short_paths[index])
results.append((score_value, index, text_item))
# Sort the obtained scores and populate the list widget
self.filtered_path = []
for result in sorted(results):
index = result[1]
text = result[-1]
path = paths[index]
item = QListWidgetItem(ima.icon('FileIcon'), text)
item.setToolTip(path)
item.setSizeHint(QSize(0, 25))
self.list.addItem(item)
self.filtered_path.append(path)
# To adjust the delegate layout for KDE themes
self.list.files_list = True
# Move selected item in list accordingly and update list size
if current_path in self.filtered_path:
self.set_current_row(self.filtered_path.index(current_path))
elif self.filtered_path:
self.set_current_row(0)
self.fix_size(short_paths, extra=200)
# If a line number is searched look for it
self.line_number = line_number
self.goto_line(line_number)
def setup_symbol_list(self, filter_text, current_path):
"""Setup list widget content for symbol list display."""
# Get optional symbol name
filter_text, symbol_text = filter_text.split('@')
# Fetch the Outline explorer data, get the icons and values
oedata = self.get_symbol_list()
icons = get_python_symbol_icons(oedata)
# The list of paths here is needed in order to have the same
# point of measurement for the list widget size as in the file list
# See issue 4648
paths = self.paths
# Update list size
self.fix_size(paths)
symbol_list = process_python_symbol_data(oedata)
line_fold_token = [(item[0], item[2], item[3]) for item in symbol_list]
choices = [item[1] for item in symbol_list]
scores = get_search_scores(symbol_text, choices, template="<b>{0}</b>")
# Build the text that will appear on the list widget
results = []
lines = []
self.filtered_symbol_lines = []
for index, score in enumerate(scores):
text, rich_text, score_value = score
line, fold_level, token = line_fold_token[index]
lines.append(text)
if score_value != -1:
results.append((score_value, line, text, rich_text,
fold_level, icons[index], token))
template = '{{0}}<span style="color:{0}">{{1}}</span>'.format(
ima.MAIN_FG_COLOR)
for (score, line, text, rich_text, fold_level, icon,
token) in sorted(results):
fold_space = ' '*(fold_level)
line_number = line + 1
self.filtered_symbol_lines.append(line_number)
textline = template.format(fold_space, rich_text)
item = QListWidgetItem(icon, textline)
item.setSizeHint(QSize(0, 16))
self.list.addItem(item)
# To adjust the delegate layout for KDE themes
self.list.files_list = False
# Select edit line when using symbol search initially.
# See issue 5661
self.edit.setFocus()
def setup_symbol_list(self, filter_text, current_path):
"""Setup list widget content for symbol list display."""
# Get optional symbol name
filter_text, symbol_text = filter_text.split('@')
# Fetch the Outline explorer data, get the icons and values
oedata = self.get_symbol_list()
icons = get_python_symbol_icons(oedata)
# The list of paths here is needed in order to have the same
# point of measurement for the list widget size as in the file list
# See issue 4648
paths = self.paths
# Update list size
self.fix_size(paths)
symbol_list = process_python_symbol_data(oedata)
line_fold_token = [(item[0], item[2], item[3]) for item in symbol_list]
choices = [item[1] for item in symbol_list]
scores = get_search_scores(symbol_text, choices, template="<b>{0}</b>")
# Build the text that will appear on the list widget
results = []
lines = []
self.filtered_symbol_lines = []
for index, score in enumerate(scores):
text, rich_text, score_value = score
line, fold_level, token = line_fold_token[index]
lines.append(text)
if score_value != -1:
results.append((score_value, line, text, rich_text, fold_level,
icons[index], token))
template = '{{0}}<span style="color:{0}">{{1}}</span>'.format(
ima.MAIN_FG_COLOR)
for (score, line, text, rich_text, fold_level, icon,
token) in sorted(results):
fold_space = ' ' * (fold_level)
line_number = line + 1
self.filtered_symbol_lines.append(line_number)
textline = template.format(fold_space, rich_text)
item = QListWidgetItem(icon, textline)
item.setSizeHint(QSize(0, 16))
self.list.addItem(item)
# To adjust the delegate layout for KDE themes
self.list.files_list = False
# Select edit line when using symbol search initially.
# See issue 5661
self.edit.setFocus()
def setup_symbol_list(self, filter_text, current_path):
"""Setup list widget content for symbol list display."""
# Get optional symbol name
filter_text, symbol_text = filter_text.split('@')
# Fetch the Outline explorer data, get the icons and values
oedata = self.get_symbol_list()
icons = get_python_symbol_icons(oedata)
symbol_list = process_python_symbol_data(oedata)
line_fold_token = [(item[0], item[2], item[3]) for item in symbol_list]
choices = [item[1] for item in symbol_list]
scores = get_search_scores(symbol_text, choices, template="<b>{0}</b>")
# Build the text that will appear on the list widget
results = []
lines = []
self.filtered_symbol_lines = []
for index, score in enumerate(scores):
text, rich_text, score_value = score
line, fold_level, token = line_fold_token[index]
lines.append(text)
if score_value != -1:
results.append((score_value, line, text, rich_text,
fold_level, icons[index], token))
template = '{0}{1}'
for (score, line, text, rich_text, fold_level, icon,
token) in sorted(results):
fold_space = ' '*(fold_level)
line_number = line + 1
self.filtered_symbol_lines.append(line_number)
textline = template.format(fold_space, rich_text)
item = QListWidgetItem(icon, textline)
item.setSizeHint(QSize(0, 16))
self.list.addItem(item)
# To adjust the delegate layout for KDE themes
self.list.files_list = False
# Move selected item in list accordingly
# NOTE: Doing this is causing two problems:
# 1. It makes the cursor to auto-jump to the last selected
# symbol after opening or closing a different file
# 2. It moves the cursor to the first symbol by default,
# which is very distracting.
# That's why this line is commented!
# self.set_current_row(0)
# Update list size
self.fix_size(lines, extra=125)
def addEntry(self, title, description, icon):
entry = EntryWidget()
entry.setTitle(title)
entry.setDescription(description)
entry.setDate("")
entry.setIcon(QIcon.fromTheme(icon))
item = QListWidgetItem(self.list)
item.setSizeHint(entry.sizeHint())
self.list.insertItem(0, item)
self.list.setItemWidget(item, entry)
return self.list.count()
def add_page(self, widget):
scrollarea = QScrollArea(self)
scrollarea.setWidgetResizable(True)
scrollarea.setWidget(widget)
self.pages_widget.addWidget(scrollarea)
item = QListWidgetItem(self.contents_widget)
try:
item.setIcon(widget.get_icon())
except TypeError:
pass
item.setText(widget.get_name())
item.setFlags(Qt.ItemIsSelectable|Qt.ItemIsEnabled)
item.setSizeHint(QSize(0, 25))
def addItem(
self,
project_info: ProjectInfo,
installed=False,
plugin_name=None,
enabled=True,
npe_version=1,
):
# don't add duplicates
if (
self.findItems(project_info.name, Qt.MatchFixedString)
and not plugin_name
):
return
# including summary here for sake of filtering below.
searchable_text = project_info.name + " " + project_info.summary
item = QListWidgetItem(searchable_text, parent=self)
item.version = project_info.version
super().addItem(item)
widg = PluginListItem(
*project_info,
parent=self,
plugin_name=plugin_name,
enabled=enabled,
installed=installed,
npe_version=npe_version,
)
item.widget = widg
item.npe_version = npe_version
action_name = 'uninstall' if installed else 'install'
item.setSizeHint(widg.sizeHint())
self.setItemWidget(item, widg)
if project_info.url:
import webbrowser
widg.help_button.clicked.connect(
lambda: webbrowser.open(project_info.url)
)
else:
widg.help_button.setVisible(False)
widg.action_button.clicked.connect(
lambda: self.handle_action(item, project_info.name, action_name)
)
widg.update_btn.clicked.connect(
lambda: self.handle_action(
item, project_info.name, "install", update=True
)
)
widg.cancel_btn.clicked.connect(
lambda: self.handle_action(item, project_info.name, "cancel")
)
item.setSizeHint(widg.sizeHint())
self.setItemWidget(item, widg)
def setup_symbol_list(self, filter_text, current_path):
"""Setup list widget content for symbol list display."""
# Get optional symbol name
filter_text, symbol_text = filter_text.split('@')
# Fetch the Outline explorer data, get the icons and values
oedata = self.get_symbol_list()
icons = get_python_symbol_icons(oedata)
symbol_list = process_python_symbol_data(oedata)
line_fold_token = [(item[0], item[2], item[3]) for item in symbol_list]
choices = [item[1] for item in symbol_list]
scores = get_search_scores(symbol_text, choices, template="<b>{0}</b>")
# Build the text that will appear on the list widget
results = []
lines = []
self.filtered_symbol_lines = []
for index, score in enumerate(scores):
text, rich_text, score_value = score
line, fold_level, token = line_fold_token[index]
lines.append(text)
if score_value != -1:
results.append((score_value, line, text, rich_text,
fold_level, icons[index], token))
template_1 = '<code>{0}<big>{1} {2}</big></code>'
template_2 = '<br><code>{0}</code><i>[Line {1}]</i>'
for (score, line, text, rich_text, fold_level, icon,
token) in sorted(results):
fold_space = ' '*(fold_level)
line_number = line + 1
self.filtered_symbol_lines.append(line_number)
textline = template_1.format(fold_space, token, rich_text)
textline += template_2.format(fold_space, line_number)
item = QListWidgetItem(icon, textline)
item.setSizeHint(QSize(0, 16))
self.list.addItem(item)
# Move selected item in list accordingly
# NOTE: Doing this is causing two problems:
# 1. It makes the cursor to auto-jump to the last selected
# symbol after opening or closing a different file
# 2. It moves the cursor to the first symbol by default,
# which is very distracting.
# That's why this line is commented!
# self.set_current_row(0)
# Update list size
self.fix_size(lines, extra=125)
def __grounded(self) -> None:
"""Grounded combinations."""
current_item = self.collection_list.currentItem()
self.collections_grounded.clear()
self.grounded_list.clear()
g = self.collections[self.collection_list.row(current_item)]
item = QListWidgetItem("Released")
icon = graph2icon(g,
self.grounded_list.iconSize().width(),
self.graph_link_as_node.isChecked(),
self.graph_show_label.isChecked(),
self.prefer.monochrome_option,
pos=self.ground_engine)
item.setIcon(icon)
self.collections_grounded.append(g)
self.grounded_list.addItem(item)
for node, graph_ in labeled_enumerate(g):
item = QListWidgetItem(f"link_{node}")
icon = graph2icon(g,
self.grounded_list.iconSize().width(),
self.graph_link_as_node.isChecked(),
self.graph_show_label.isChecked(),
self.prefer.monochrome_option,
except_node=node,
pos=self.ground_engine)
item.setIcon(icon)
self.collections_grounded.append(graph_)
self.grounded_list.addItem(item)
def setup(self):
"""
Initial setup for populating items if any.
"""
# TODO: Check against regex and raise error accordingly!
new_items = []
for text in self.items_text:
if self.normalize:
text = text.lower()
new_items.append(text)
self.items_text = new_items
if not self.duplicates:
if len(set(self.items_text)) != len(self.items_text):
raise Exception('The list cannot contains duplicates.')
for item in self.items_text:
item = QListWidgetItem(item)
item.extra_data = None
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self.add(item)
item.setSizeHint(QSize(item.sizeHint().width(), self._height()))
self.refresh()
def __setup__list__(self):
"""
Load working days and sets tooltips for list items.
:return:
"""
for k in self.time_capture_service.working_dates:
sum = 0
for booking in self.time_capture_service.load_bookings(str(k)):
sum += booking[bk.HOURS]
qlwi = QListWidgetItem(str(k))
qlwi.setToolTip("Day: {} | Sum: {} hrs".format(days[k.weekday()], sum))
self.ui.list_days.addItem(qlwi)
def _search(self, needle):
import Levenshtein
if not needle:
haystack = self._haystack[:]
if self._default:
haystack.insert(0,
(self._default[0].lower(), ) + self._default)
self._result_box.clear()
for lower_label, label, data, on_select in haystack:
item = QListWidgetItem(label, self._result_box)
item.data = data
item.on_select = on_select
self._result_box.addItem(item)
return
needle = needle.lower()
needles = needle.split()
self._result_box.show()
self._result_box.clear()
results = []
for lower_label, label, data, on_select in self._haystack:
for subneedle in needles:
if subneedle not in lower_label:
break
else:
results.append(
(Levenshtein.distance(needle, lower_label) / len(label),
label, data, on_select))
for score, label, data, on_select in sorted(results,
key=lambda t: t[0]):
item = QListWidgetItem(label, self._result_box)
item.data = data
item.on_select = on_select
self._result_box.addItem(item)
def __init__(self, settings: BaseSettings, parent=None):
super().__init__(parent)
self.settings = settings
self.file_list = QListWidget()
self.file_list.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.cancel_btn = QPushButton("Cancel", clicked=self.reject)
self.load_btn = QPushButton("Load", clicked=self.accept)
for name_list, method in settings.get_last_files_multiple():
entry = f"{name_list[0]} {method}"
item = QListWidgetItem(entry, self.file_list)
item.setData(Qt.UserRole, (name_list, method))
last_set = {(tuple(x), y)
for x, y in settings.get_last_files_multiple()}
for name_list, method in settings.get_last_files():
if (tuple(name_list), method) in last_set:
continue
entry = f"{name_list[0]} {method}"
item = QListWidgetItem(entry, self.file_list)
item.setData(Qt.UserRole, (name_list, method))
layout = QGridLayout()
layout.addWidget(QLabel("Select files"))
layout.addWidget(self.file_list, 1, 0, 1, 2)
layout.addWidget(self.cancel_btn, 2, 0)
layout.addWidget(self.load_btn, 2, 1)
self.setLayout(layout)
self.resize(
*self.settings.get_from_profile("multiple_files_dialog_size", (
self.size().width(), self.size().height())))
def submit(self):
"""Put a new command on the queue for later execution.
"""
# put the new command on the queue
cmd = str(self.mdi_entry_widget.text()).strip()
row_item = QListWidgetItem()
row_item.setText(cmd)
row_item.setData(MDIHistory.MDQQ_ROLE, MDIHistory.MDIQ_TODO)
row_item.setIcon(self.icon_waiting)
if self.mdi_listorder_natural:
self.addItem(row_item)
else:
self.insertItem(0, row_item)
# Set the recently added item as the "current" item
# if the queue is not paused this will quickly get overridden
# to the executing item highlight mode
self.clearSelection()
self.setCurrentItem(row_item)
# put the command onto the status channel mdi history
# This always adds this item at position Zero on the channel
STATUS.mdi_history.setValue(cmd)
# now clear down the mdi entry text ready for new input
self.mdi_entry_widget.clear()
def add_thumb_bytes(self, result):
bytes_, wrapper = result
img = QImage()
img.loadFromData(bytes_)
icon = QIcon(QPixmap.fromImage(img))
name = wrapper.getName()
if len(name) > 18:
name = name[:15] + "..."
item = QListWidgetItem(icon, name)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignBottom)
item.wrapper = wrapper
self._item_map[wrapper.getId()] = item
self.addItem(item)
if self._current_item.isImage():
self.select_image()
def append_hook_implementation(self, hook_implementation: HookImpl):
"""Add a list item for ``hook_implementation`` with a custom widget.
Parameters
----------
hook_implementation : pluggy.HookImpl
The hook implementation object to add to the list.
"""
item = QListWidgetItem(parent=self)
item.hook_implementation = hook_implementation
self.addItem(item)
widg = ImplementationListItem(item, parent=self)
item.setSizeHint(widg.sizeHint())
self.order_changed.connect(widg.update_position_label)
self.setItemWidget(item, widg)
def update_info(self):
res = self.calculation_manager.get_results()
for el in res.errors:
if el[0]:
QListWidgetItem(el[0], self.logs)
ExceptionListItem(el[1], self.logs)
if (state_store.report_errors and parsed_version.is_devrelease
and not isinstance(el[1][0], SegmentationLimitException)
and isinstance(el[1][1], tuple)):
with sentry_sdk.push_scope() as scope:
scope.set_tag("auto_report", "true")
sentry_sdk.capture_event(el[1][1][0])
self.whole_progress.setValue(res.global_counter)
working_search = True
for uuid, progress in res.jobs_status.items():
calculation = self.calculation_manager.calculation_dict[uuid]
total = len(calculation.file_list)
if uuid in self.progress_item_dict:
item = self.progress_item_dict[uuid]
item.update_count(progress)
else:
item = CalculationProcessItem(calculation, self.task_count,
progress)
self.task_count += 1
self.task_que.appendRow(item)
self.progress_item_dict[uuid] = item
if working_search and progress != total:
self.part_progress.setMaximum(total)
self.part_progress.setValue(progress)
working_search = False
if not self.calculation_manager.has_work:
self.part_progress.setValue(self.part_progress.maximum())
self.preview_timer.stop()
logging.info("Progress stop")
def __path_dlg(self, item: QListWidgetItem) -> None:
"""View path data."""
name = item.text().split(":", maxsplit=1)[0]
try:
paths = self.__paths[name]
except KeyError:
return
points_text = ", ".join(f"Point{i}" for i in range(len(paths)))
if QMessageBox.question(
self,
"Path data",
f"This path data including {points_text}.",
(QMessageBox.Save | QMessageBox.Close),
QMessageBox.Close
) != QMessageBox.Save:
return
file_name = self.output_to(
"path data",
["Comma-Separated Values (*.csv)", "Text file (*.txt)"]
)
if not file_name:
return
with open(file_name, 'w+', encoding='utf-8', newline='') as stream:
w = writer(stream)
for path in paths:
for point in path:
w.writerow(point)
w.writerow(())
logger.info(f"Output path data: {file_name}")
def __init__(self, text, packages=(), parent=None):
"""Accept actions for pacakge manager."""
super(ActionsDialog, self).__init__(parent=parent)
self.packages = packages
self.label = QLabel(text)
self.list = ListWidgetActionPackages(self)
self.button_cancel = ButtonDanger('Cancel')
self.button_accept = ButtonPrimary('Ok')
self.setWindowTitle('Proceed with the following actions?')
for item in packages:
item = QListWidgetItem(item)
self.list.addItem(item)
# Layout
layout_buttons = QHBoxLayout()
layout_buttons.addStretch()
layout_buttons.addWidget(self.button_cancel)
layout_buttons.addWidget(SpacerHorizontal())
layout_buttons.addWidget(self.button_accept)
layout = QVBoxLayout()
layout.addWidget(self.label)
layout.addWidget(SpacerVertical())
layout.addWidget(self.list)
layout.addWidget(SpacerVertical())
layout.addWidget(SpacerVertical())
layout.addLayout(layout_buttons)
self.setLayout(layout)
self.button_accept.clicked.connect(self.accept)
self.button_cancel.clicked.connect(self.reject)
def __init__(self, vpoints: List[VPoint], vlinks: List[VLink],
pos: Union[int, bool], parent: QWidget):
"""Input data reference from main window.
+ Needs VPoints and VLinks information.
+ If row is false: Create action.
"""
super(EditPointDialog, self).__init__(parent)
self.setupUi(self)
flags = self.windowFlags()
self.setWindowFlags(flags & ~Qt.WindowContextHelpButtonHint)
icon = self.windowIcon()
self.icon = QIcon(QPixmap(":/icons/link.png"))
self.vpoints = vpoints
self.vlinks = vlinks
vpoints_count = len(vpoints)
for i, e in enumerate(color_names):
self.color_box.insertItem(i, color_icon(e), e)
for vlink in vlinks:
self.no_selected.addItem(QListWidgetItem(self.icon, vlink.name))
if pos is False:
self.name_box.addItem(icon, f'Point{vpoints_count}')
self.name_box.setEnabled(False)
self.color_box.setCurrentIndex(self.color_box.findText('green'))
else:
for i in range(vpoints_count):
self.name_box.insertItem(i, icon, f'Point{i}')
self.name_box.setCurrentIndex(pos)
self.type_box.currentIndexChanged.connect(self.__check_angle)
self.__check_angle()
def update_info(self):
res = self.calculation_manager.get_results()
for el in res.errors:
if el[0]:
QListWidgetItem(el[0], self.logs)
ExceptionListItem(el[1], self.logs)
if (state_store.report_errors and parsed_version.is_devrelease
and not isinstance(el[1][0], SegmentationLimitException)
and isinstance(el[1][1], tuple)):
with sentry_sdk.push_scope() as scope:
scope.set_tag("auto_report", "true")
sentry_sdk.capture_event(el[1][1][0])
self.whole_progress.setValue(res.global_counter)
working_search = True
for i, (progress, total) in enumerate(res.jobs_status):
if working_search and progress != total:
self.part_progress.setMaximum(total)
self.part_progress.setValue(progress)
working_search = False
if i < self.task_que.count():
item = self.task_que.item(i)
item.setText("Task {} ({}/{})".format(i, progress, total))
else:
self.task_que.addItem("Task {} ({}/{})".format(
i, progress, total))
if not self.calculation_manager.has_work:
print(
"[ProgressView.update_info]",
self.calculation_manager.has_work,
self.calculation_manager.batch_manager.has_work,
self.calculation_manager.writer.writing_finished(),
)
self.part_progress.setValue(self.part_progress.maximum())
self.preview_timer.stop()
logging.info("Progress stop")
def _on_data_change(self, *event):
components = getattr(type(self.state), 'component').get_choices(self.state)
self.ui.list_component.clear()
for component in components:
if isinstance(component, ChoiceSeparator):
item = QListWidgetItem(str(component))
item.setFlags(item.flags() & ~Qt.ItemIsSelectable)
item.setForeground(Qt.gray)
else:
item = QListWidgetItem(component.label)
item.setCheckState(Qt.Checked)
self.ui.list_component.addItem(item)
def add_page(self, widget):
self.check_settings.connect(widget.check_settings)
widget.show_this_page.connect(lambda row=self.contents_widget.count():
self.contents_widget.setCurrentRow(row))
widget.apply_button_enabled.connect(self.apply_btn.setEnabled)
scrollarea = QScrollArea(self)
scrollarea.setWidgetResizable(True)
scrollarea.setWidget(widget)
self.pages_widget.addWidget(scrollarea)
item = QListWidgetItem(self.contents_widget)
try:
item.setIcon(widget.get_icon())
except TypeError:
pass
item.setText(widget.get_name())
item.setFlags(Qt.ItemIsSelectable|Qt.ItemIsEnabled)
item.setSizeHint(QSize(0, 25))
def setup_file_list(self, filter_text, current_path):
"""Setup list widget content for file list display."""
short_paths = shorten_paths(self.paths, self.save_status)
paths = self.paths
icons = self.icons
results = []
trying_for_line_number = ':' in filter_text
# Get optional line number
if trying_for_line_number:
filter_text, line_number = filter_text.split(':')
if line_number == '':
line_number = None
# Get all the available filenames
scores = get_search_scores('', self.filenames,
template="<b>{0}</b>")
else:
line_number = None
# Get all available filenames and get the scores for
# "fuzzy" matching
scores = get_search_scores(filter_text, self.filenames,
template="<b>{0}</b>")
# Get max width to determine if shortpaths should be used
max_width = self.get_item_size(paths)[0]
self.fix_size(paths)
# Build the text that will appear on the list widget
rich_font = CONF.get('appearance', 'rich_font/size', 10)
if sys.platform == 'darwin':
path_text_font_size = rich_font
filename_text_font_size = path_text_font_size + 2
elif os.name == 'nt':
path_text_font_size = rich_font
filename_text_font_size = path_text_font_size + 1
elif is_ubuntu():
path_text_font_size = rich_font - 2
filename_text_font_size = path_text_font_size + 1
else:
path_text_font_size = rich_font
filename_text_font_size = path_text_font_size + 1
for index, score in enumerate(scores):
text, rich_text, score_value = score
if score_value != -1:
text_item = ("<span style='color:{0:}; font-size:{1:}pt'>{2:}"
"</span>").format(ima.MAIN_FG_COLOR,
filename_text_font_size,
rich_text.replace('&', ''))
if trying_for_line_number:
text_item += " [{0:} {1:}]".format(self.line_count[index],
_("lines"))
if max_width > self.list.width():
text_item += (u" <span style='color:{0:};"
"font-size:{1:}pt'>{2:}"
"</span>").format(self.PATH_FG_COLOR,
path_text_font_size,
short_paths[index])
else:
text_item += (u" <span style='color:{0:};"
"font-size:{1:}pt'>{2:}"
"</span>").format(self.PATH_FG_COLOR,
path_text_font_size,
paths[index])
if (trying_for_line_number and self.line_count[index] != 0 or
not trying_for_line_number):
results.append((score_value, index, text_item))
# Sort the obtained scores and populate the list widget
self.filtered_path = []
plugin = None
for result in sorted(results):
index = result[1]
path = paths[index]
if sys.platform == 'darwin':
scale_factor = 0.9
elif os.name == 'nt':
scale_factor = 0.8
elif is_ubuntu():
scale_factor = 0.6
else:
scale_factor = 0.9
icon = ima.get_icon_by_extension(path, scale_factor)
text = ''
try:
title = self.widgets[index][1].get_plugin_title().split(' - ')
if plugin != title[0]:
plugin = title[0]
text += ("<br><big style='color:{0:}'>"
"<b>{1:}</b></big><br>").format(ima.MAIN_FG_COLOR,
plugin)
item = QListWidgetItem(text)
item.setToolTip(path)
item.setSizeHint(QSize(0, 25))
item.setFlags(Qt.ItemIsEditable)
self.list.addItem(item)
self.filtered_path.append(path)
except:
# The widget using the fileswitcher is not a plugin
pass
text = ''
text += result[-1]
item = QListWidgetItem(icon, text)
item.setToolTip(path)
item.setSizeHint(QSize(0, 25))
self.list.addItem(item)
self.filtered_path.append(path)
# To adjust the delegate layout for KDE themes
self.list.files_list = True
# Move selected item in list accordingly and update list size
if current_path in self.filtered_path:
self.set_current_row(self.filtered_path.index(current_path))
elif self.filtered_path:
self.set_current_row(0)
# If a line number is searched look for it
self.line_number = line_number
self.goto_line(line_number)
def __init__(self, parent, path):
self.path = path
QListWidgetItem.__init__(self, self.__repr__(), parent)
def update_list(self):
"""Update path list"""
self.listwidget.clear()
for name in self.pathlist+self.ro_pathlist:
item = QListWidgetItem(name)
item.setIcon(ima.icon('DirClosedIcon'))
if name in self.ro_pathlist:
item.setFlags(Qt.NoItemFlags | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Checked)
elif name in self.not_active_pathlist:
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Unchecked)
else:
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Checked)
self.listwidget.addItem(item)
self.refresh()
def setup_file_list(self, filter_text, current_path):
"""Setup list widget content for file list display."""
short_paths = shorten_paths(self.paths, self.save_status)
paths = self.paths
icons = self.icons
results = []
trying_for_line_number = ':' in filter_text
# Get optional line number
if trying_for_line_number:
filter_text, line_number = filter_text.split(':')
# Get all the available filenames
scores = get_search_scores('', self.filenames,
template="<b>{0}</b>")
else:
line_number = None
# Get all available filenames and get the scores for
# "fuzzy" matching
scores = get_search_scores(filter_text, self.filenames,
template="<b>{0}</b>")
# Get max width to determine if shortpaths should be used
max_width = self.get_item_size(paths)[0]
self.fix_size(paths)
# Build the text that will appear on the list widget
for index, score in enumerate(scores):
text, rich_text, score_value = score
if score_value != -1:
text_item = '<big>' + rich_text.replace('&', '') + '</big>'
if trying_for_line_number:
text_item += " [{0:} {1:}]".format(self.line_count[index],
_("lines"))
if max_width > self.list.width():
text_item += u"<br><i>{0:}</i>".format(short_paths[index])
else:
text_item += u"<br><i>{0:}</i>".format(paths[index])
if (trying_for_line_number and self.line_count[index] != 0 or
not trying_for_line_number):
results.append((score_value, index, text_item))
# Sort the obtained scores and populate the list widget
self.filtered_path = []
plugin = None
for result in sorted(results):
index = result[1]
path = paths[index]
icon = icons[index]
text = ''
try:
title = self.widgets[index][1].get_plugin_title().split(' - ')
if plugin != title[0]:
plugin = title[0]
text += '<br><big><b>' + plugin + '</b></big><br>'
item = QListWidgetItem(text)
item.setToolTip(path)
item.setSizeHint(QSize(0, 25))
item.setFlags(Qt.ItemIsEditable)
self.list.addItem(item)
self.filtered_path.append(path)
except:
# The widget using the fileswitcher is not a plugin
pass
text = ''
text += result[-1]
item = QListWidgetItem(icon, text)
item.setToolTip(path)
item.setSizeHint(QSize(0, 25))
self.list.addItem(item)
self.filtered_path.append(path)
# To adjust the delegate layout for KDE themes
self.list.files_list = True
# Move selected item in list accordingly and update list size
if current_path in self.filtered_path:
self.set_current_row(self.filtered_path.index(current_path))
elif self.filtered_path:
self.set_current_row(0)
# If a line number is searched look for it
self.line_number = line_number
self.goto_line(line_number)
