def remove_entry(self): # Obtain the index and widget of the currently shown plot entry index = get_box_value(self.plot_entries, int) name = get_box_value(self.plot_entries, str) widget = self.plot_pages.currentWidget() # If index is -1, return if (index == -1): return # Show a warning message asking if the user really wants to remove it # TODO: Should this be removed once changes can be discarded? button_clicked = GW.QMessageBox.warning( self, "WARNING: Delete plot", ("Are you sure you want to delete the plot with name <b>%s</b>? " "(<i>Note: This action is irreversible!</i>)" % (name)), GW.QMessageBox.Yes | GW.QMessageBox.No, GW.QMessageBox.No) # Remove the entry and page at this index if the user answered 'yes' if (button_clicked == GW.QMessageBox.Yes): self.plot_entries.removeItem(index) self.plot_pages.removeWidget(widget) widget.setParent(None) widget.close() del widget
def get_box_value(self, *value_sig): """ Returns the current values of this entries box as a dict. Returns ------- entries_dict : dict A dict with the entries currently in this entries box, formatted as `{'<entry_name>': <entry_value>}`. """ # Create an empty dict to hold the entry values in entries_dict = dict() # Loop over all entries in the entries grid and save them to the dict for i in range(4, 4 + 3 * self.entryCount(), 3): # Obtain the name of this entry name_box = self.entries_grid.itemAt(i).widget() entry_name = get_box_value(name_box) # If the entry_name is invalid, skip this entry if not self.is_valid(name_box): continue # Obtain the value of this entry value_box = self.entries_grid.itemAt(i + 1).widget() entry_value = get_box_value(value_box) # Add this entry to the dict entries_dict[entry_name] = entry_value # Return entries_dict return (entries_dict)
def hideEvent(self, *args, **kwargs): # Set the column name and dtype self.set_column_name(get_box_value(self.name_box)) self.set_column_dtype(get_box_value(self.dtype_box)) # Tell data table to update the header of the requested column self.data_table.h_header.headerDataChanged(QC.Qt.Horizontal, self.col, self.col) # Call super event super().hideEvent(*args, **kwargs)
def get_box_value(self, *value_sig): # Obtain value of checkbox check = get_box_value(self.checkbox) # If True, value is obtained from the widget if check: value = get_box_value(self.widget, *value_sig) else: value = self.untoggled # Return value return(value)
def update_plot(self): # Draw the plot self.draw_plot() # If scatter currently exists, update it if self.plot is not None: # Set label self.plot.set_label(get_box_value(self.data_label_box)) # Update marker style, size and color self.plot.set_marker(get_box_value(self.marker_style_box)) self.plot.set_markersize(get_box_value(self.marker_size_box)) self.plot.set_markeredgecolor(get_box_value(self.marker_color_box)) self.plot.set_markerfacecolor(get_box_value(self.marker_color_box))
def get_box_value(self, *value_sig): """ Returns the current values of this figure label box as a tuple. Returns ------- value : tuple A tuple containing the values of the figure label box, formatted as `(label, {'fontsize': size})`. """ return(get_box_value(self.left_box), {'fontsize': get_box_value(self.right_box)})
def get_box_value(self, *value_sig): """ Returns the current values of this items box as a list. Returns ------- value_list : list A list with the values of all items currently in this items box. """ # Create an empty list to hold the item values in value_list = [] # Loop over all items in the items form and save them to the list for i in range(self.itemCount()): # Obtain the value of this entry item_layout = self.items_layout.itemAt(i) item_box = item_layout.itemAt(1).widget() item_value = get_box_value(item_box) # Add this item to the list if it is not None if item_value is not None: value_list.append(item_value) # Return value_list return (value_list)
def apply_table_dimensions(self): # Obtain the values of the dimensions_box n_rows, n_cols = get_box_value(self.dimensions_box) # Set the rows and columns in the model self.view.setRowCount(n_rows) self.view.setColumnCount(n_cols)
def init(self): # Check if this class has been initialized before, and do so if not if not self.init_flag: self.first_init() # Create a layout for this widget box_layout = GL.QHBoxLayout(self) box_layout.setContentsMargins(0, 0, 0, 0) # Create a combobox for cmaps cmaps_box = GW.EditableComboBox() validator = GW.ComboBoxValidator(cmaps_box) cmaps_box.setValidator(validator) # Add all colormaps to cmaps_box for cmap in self.cmaps_cl: cmap_icon = self.cmap_icons[cmap] cmaps_box.addItem(cmap_icon, cmap) # Add some separators for i in reversed(self.cum_len[:-2]): cmaps_box.insertSeparator(i) # Set remaining properties set_box_value(cmaps_box, rcParams['image.cmap']) cmaps_box.setIconSize(QC.QSize(*self.cmap_size)) cmaps_box.completer().popup().setIconSize(QC.QSize(*self.cmap_size)) get_modified_signal(cmaps_box, str).connect(self.cmap_selected) cmaps_box.focusLost.connect( lambda: set_box_value(cmaps_box, get_box_value(cmaps_box, int))) # Add cmaps_box to layout box_layout.addWidget(cmaps_box) self.cmaps_box = cmaps_box
def remove_item(self, item_layout): """ Removes the item associated with the provided `item_layout` from the items box. """ # Obtain the value in the layout item_box = item_layout.itemAt(1).widget() item_value = get_box_value(item_box) # If item_value is not None, a modified signal must be emitted later emit_signal = (item_value is not None) # Remove corresponding item layout self.items_layout.removeItem(item_layout) # Remove the two items in item_layout for _ in range(2): # Remove the current item at index 0 item = item_layout.takeAt(0) # Close the widget in this item and delete it item.widget().close() del item # Emit modified signal if required if emit_signal: self.modified.emit()
def update_plot(self): # Draw the plot self.draw_plot() # If histograms currently exist, update them if self.plot is not None: # Obtain the labels and colors of all elements labels = get_box_value(self.multi_data_box, 'data_label_box') colors = get_box_value(self.multi_data_box, 'hist_color_box') for i, (plot, label, color) in enumerate(zip(self.plot, labels, colors)): # Set label plot.set_label(label) # Update bin colors for patch in plot.patches: patch.set_color(color)
def get_box_value(self, *value_sig): # Obtain the current index of this combobox index = get_box_value(self.combobox, int) # Obtain the corresponding user data value = self.combobox.itemData(index) # Return value return (value)
def get_box_value(self, *value_sig): # Use normal method value = get_box_value(self, *value_sig, no_custom=True) # If the returned value is a bool and bools are used, convert value if value in ('True', 'False', 'None') and self.uses_bools: value = literal_eval(value) # Return value return(value)
def add_options_entry(self, widget): """ Adds the provided `widget` as an options entry to this options dialog. This allows for the values of `widget` to be tracked and potentially discarded/reverted. """ # Add widget as an entry to options_dict self.options_dict[widget] = get_box_value(widget) get_modified_signal(widget).connect(self.enable_apply_button)
def set_legend(self): # Obtain the legend_flag flag, loc = get_box_value(self.legend_togglebox) # If flag is True, create a legend if flag: self.axis.legend(loc=loc) # Else, remove the current one if it exists elif self.axis.legend_ is not None: self.axis.legend_.remove()
def get_box_value(self, *value_sig): """ Returns the current values of this togglebox as a tuple. Returns ------- value : bool or tuple A tuple containing the values of the checkbox and widget, formatted as `(checkbox, widget)`. If `value_sig` contains type 'bool', only the value of `checkbox` is returned. """ # If solely the value of the checkbox was requested, return it if bool in value_sig: return (get_box_value(self.checkbox)) # Else, return the checkbox and widget values else: return (get_box_value(self.checkbox), get_box_value(self.widget, *value_sig))
def get_box_value(self, *value_sig): """ Returns the current color value of the color combobox. Returns ------- color : str The current matplotlib color value. """ # Return the value currently set return (get_box_value(self.color_combobox, *value_sig))
def draw_plot(self): # Obtain the x and y columns try: xcol = get_box_value(self.x_data_box)[1] ycol = get_box_value(self.y_data_box)[1] # If any of the columns cannot be called, return except IndexError: self.remove_plot() return # If either xcol or ycol is None, return if xcol is None or ycol is None: self.remove_plot() return # If xcol and ycol are not the same shape, return if (len(xcol) != len(ycol)): self.remove_plot() return # If the current saved scatter is not already in the figure, make one if self.plot not in self.axis.lines: # Make and update plot self.plot = self.axis.plot(xcol, ycol)[0] self.plot.set_linestyle('') # Obtain label currently set in label box label = get_box_value(self.data_label_box) # If label is not empty, reuse it in the plot if label: self.plot.set_label(label) # Else, obtain its label from MPL else: set_box_value(self.data_label_box, self.plot.get_label()) # If the figure currently has no title, set it title_box = self.options.title_box[0] if not get_box_value(title_box): set_box_value(title_box, "%s vs. %s" % (xcol.name, ycol.name)) # If the figure currently has no axes labels, set them x_label_box = self.options.x_label_box[0] y_label_box = self.options.y_label_box[0] if not (get_box_value(x_label_box) or get_box_value(y_label_box)): set_box_value(x_label_box, xcol.name) set_box_value(y_label_box, ycol.name) # If it does exist, check if it requires updating else: # Obtain the data currently used for this plot xcol_cur = self.plot.get_xdata() ycol_cur = self.plot.get_ydata() # If there are differences, update plot if not (xcol_cur == xcol).all(): self.plot.set_xdata(xcol) if not (ycol_cur == ycol).all(): self.plot.set_ydata(ycol)
def set_tab_name(self): """ Sets the name of the tab that was being edited when this :obj:`~TabNameEditor` was called. """ # Obtain the current text in the lineedit name = get_box_value(self) # If name is not empty, set name if name: # Set the name of the tab indicated with index self.tabbar.setTabText(self.index, name)
def is_valid(self, name_box): # Determine the current value of the name_box entry_name = get_box_value(name_box) # Check if the name_box is editable if name_box.isEditable(): # If so, check if its current input is valid valid = name_box.lineEdit().hasAcceptableInput() else: # If not, check if the current input is not empty valid = bool(entry_name) # Return valid return (valid)
def apply_options(self): """ Applies all current values of all figure options. """ # Emit the applying signal self.applying.emit() # Apply all new values for widget in self.options_dict.keys(): self.options_dict[widget] = get_box_value(widget) # Disable the apply button self.disable_apply_button()
def set_box_value(self, value_list, *value_sig): """ Sets the values of the items in this items box to the provided `value_list`. Parameters ---------- value_list : list A list containing the values of all items that must be set in this items box. """ # Hide the items box to allow for its values to be set properly self.hide() # Remove all items from the items box, registering their values cur_items_dict = {} for _ in range(self.itemCount()): # Remove this item and obtain its value layout = self.items_layout.takeAt(0) value = get_box_value(layout.itemAt(1).widget()) # Check if it is required later if value in value_list: # If so, store for later cur_items_dict[value] = layout else: # If not, delete it self.remove_item(layout) # Add all items in value_list for row, value in enumerate(value_list): # Check if this value is in cur_items_dict if value in cur_items_dict: # If so, put it back into the items box self.items_layout.insertLayout(row, cur_items_dict.pop(value)) else: # If not, add a new item self.add_item() # Set the value of this item item_layout = self.items_layout.itemAt(row) item_box = item_layout.itemAt(1).widget() set_box_value(item_box, value) # Show the items box again now that its values have been set self.show()
def get_box_value(self, *value_sig): """ Returns the current value of the value box. Returns ------- value : bool, float, int or str The current value of this generic value box. """ # If value_box is currently a QWidget, return None if type(self.value_box) is GW.QWidget: return (None) # Else, return its actual value else: return (get_box_value(self.value_box, *value_sig))
def update_plot(self): # Draw the plot self.draw_plot() # If line currently exists, update it if self.plot is not None: # Set plot label self.plot.set_label(get_box_value(self.data_label_box)) # Update line style, width and color self.plot.set_linestyle(get_box_value(self.line_style_box)) self.plot.set_linewidth(get_box_value(self.line_width_box)) self.plot.set_color(get_box_value(self.line_color_box)) # Update marker style, size and color self.plot.set_marker(get_box_value(self.marker_style_box)) self.plot.set_markersize(get_box_value(self.marker_size_box)) self.plot.set_markeredgecolor(get_box_value(self.marker_color_box)) self.plot.set_markerfacecolor(get_box_value(self.marker_color_box))
def get_box_value(self, *value_sig): """ Returns the current colormap of the colormap box. Returns ------- cmap : str or :obj:`~matplotlib.colors.Colormap` object The currently selected colormap. """ # Obtain the value cmap = get_box_value(self.cmaps_box) # Obtain the Colormap object if requested if Colormap in value_sig: cmap = plt.get_cmap(cmap) # Return it return (cmap)
def get_box_value(self, *value_sig): """ Returns the current values of this items box as a list. Returns ------- items_list : object or list If `value_sig` contains a single index, the value of the corresponding item. Otherwise, a list with the values of all items in this items box. """ # Check if value_sig contains an integer if value_sig and isinstance(value_sig[0], INT_TYPES): # If so, return the value of that specific item return (get_box_value(self.items[value_sig[0]], *value_sig[1:])) else: # If not, return the values of all items return (list(map(get_box_value, self.items)))
def get_box_value(self, *value_sig): """ Returns the current values for the config section belonging to this config page. Returns ------- config_dict : dict Dict containing the current config section values. """ # Create empty dict of config values config_dict = sdict() # Retrieve values of all config entries for key, entry_box in self.config_entries.items(): config_dict[key] = get_box_value(entry_box) # Return the config_dict return(config_dict)
def get_box_value(self, *value_sig): """ Returns the index or text of the current radiobutton that is set to *True*. Returns ------- value : int or str The index or text of the current radiobutton that is set to *True*. """ # Obtain the index of the current radiobutton index = np.argmax(list(map(get_box_value, self.buttons))) # If value_sig is not int, return its text if int not in value_sig: return (get_box_value(self[index], str)) # Else, return its index else: return (index)
def get_box_value(self, *args, **kwargs): """ Returns the currently selected data table and its associated column. Returns ------- data_table : :obj:`~guipy.plugins.data_table.widgets.DataTableWidget` \ object The data table that is currently set in this data column box. data_column : :obj:`~guipy.plugins.data_table.widgets.DataTableColumn`\ object The data table column in `data_table` that is currently set. """ # Obtain the currently selected column column_index = get_box_value(self.columns_box, int) # If currently a valid column is selected, return table and column if (column_index != -1): return (self.data_table, self.model.dataColumn(column_index)) # Else, return (None, None) else: return (None, None)
def remove_columns(self, parent, first, last): """ Removes the columns from the columns box between given `first` and `last`. Parameters ---------- parent : :obj:`~PyQt5.QtCore.QModelIndex` object The parent that was used in the data table model. This function does not need it. first : int The logical index of the first column that was removed. last : int The logical index of the last column that was removed. """ # If the currently set column has been removed, set it to -1 if get_box_value(self.columns_box, int) in range(first, last + 1): set_box_value(self.columns_box, -1) # Remove all columns between first and last+1 from the columns box for i in reversed(range(first, last + 1)): self.columns_box.removeItem(i)