def display():
# pylint: disable=too-many-branches
def format_zeros(str_val):
"""Zeros should be handled separately as they cannot be negative."""
if float(str_val) == 0:
num_decimals = min(self.variables[row].number_of_decimals,
2)
str_val = f"{0:.{num_decimals}f}"
return str_val
def render_value(value):
if np.isnan(value):
return ""
if np.isinf(value):
return "∞"
str_val = attribute.str_val(value)
if attribute.is_continuous and not attribute.is_time:
str_val = format_zeros(str_val)
return str_val
if column == self.Columns.NAME:
return attribute.name
elif column == self.Columns.DISTRIBUTION:
if isinstance(attribute,
(DiscreteVariable, ContinuousVariable)):
if row not in self.__distributions_cache:
scene = QGraphicsScene(parent=self)
histogram = Histogram(
data=self.table,
variable=attribute,
color_attribute=self.target_var,
border=(0, 0, 2, 0),
border_color='#ccc',
)
scene.addItem(histogram)
self.__distributions_cache[row] = scene
return self.__distributions_cache[row]
elif column == self.Columns.CENTER:
return render_value(self._center[row])
elif column == self.Columns.MEDIAN:
return render_value(self._median[row])
elif column == self.Columns.DISPERSION:
if isinstance(attribute, TimeVariable):
return format_time_diff(self._min[row], self._max[row])
elif isinstance(attribute, DiscreteVariable):
return "%.3g" % self._dispersion[row]
else:
return render_value(self._dispersion[row])
elif column == self.Columns.MIN:
if not isinstance(attribute, DiscreteVariable):
return render_value(self._min[row])
elif column == self.Columns.MAX:
if not isinstance(attribute, DiscreteVariable):
return render_value(self._max[row])
elif column == self.Columns.MISSING:
return '%d (%d%%)' % (self._missing[row], 100 *
self._missing[row] / self.n_instances)
return None
def setUp(self):
import logging
from AnyQt.QtWidgets import QApplication, QGraphicsScene, QGraphicsView
from AnyQt.QtGui import QPainter
from AnyQt.QtCore import QTimer
logging.basicConfig()
self.app = QApplication([])
self.scene = QGraphicsScene()
self.view = QGraphicsView(self.scene)
self.view.setRenderHints(QPainter.Antialiasing
| QPainter.SmoothPixmapTransform
| QPainter.TextAntialiasing)
self.view.resize(500, 300)
self.view.show()
QTimer.singleShot(10000, self.app.exit)
def my_excepthook(*args):
sys.setrecursionlimit(1010)
traceback.print_exc(limit=4)
self._orig_excepthook = sys.excepthook
sys.excepthook = my_excepthook
self.singleShot = QTimer.singleShot
def paint(self, painter, option, index):
# type: (QPainter, QStyleOptionViewItem, QModelIndex) -> None
data = index.data(FeatureStatisticsTableModel.DistributionRole)
if data is None:
return super().paint(painter, option, index)
row = index.model().mapToSourceRows(index.row())
if row not in self.__cache:
scene = QGraphicsScene(self)
attribute, data = data
histogram = Histogram(
data=data,
variable=attribute,
color_attribute=self.color_attribute,
border=(0, 0, 2, 0),
border_color='#ccc',
)
scene.addItem(histogram)
self.__cache[row] = scene
painter.setRenderHint(QPainter.HighQualityAntialiasing)
if option.state & QStyle.State_Selected:
background_color = option.palette.highlight()
else:
background_color = index.data(Qt.BackgroundRole)
self.__cache[row].setBackgroundBrush(background_color)
self.__cache[row].render(
painter,
target=QRectF(option.rect),
mode=Qt.IgnoreAspectRatio,
)
def setUp(self) -> None:
super().setUp()
self.scene = QGraphicsScene()
self.view = QGraphicsView(self.scene)
self.view.resize(300, 300)
self.widget = DendrogramWidget()
self.scene.addItem(self.widget)
def data(self, index, role=Qt.DisplayRole):
# type: (QModelIndex, Qt.QDisplayRole) -> Any
if not index.isValid():
return None
idx = index.row()
if role == Qt.SizeHintRole:
return self.item_scale * QSize(100, 100)
if role == Qt.DisplayRole:
if 'tree' not in self._other_data[idx]:
scene = QGraphicsScene(parent=self)
tree = PythagorasTreeViewer(
adapter=self._list[idx],
weight_adjustment=OWPythagoreanForest.SIZE_CALCULATION[
self.size_calc_idx][1],
interactive=False,
padding=100,
depth_limit=self.depth_limit,
target_class_index=self.target_class_idx,
)
scene.addItem(tree)
self._other_data[idx]['scene'] = scene
self._other_data[idx]['tree'] = tree
return self._other_data[idx]['scene']
return super().data(index, role)
def __init__(self):
# pylint: disable=missing-docstring
super().__init__()
self.data = self.discrete_data = None
self.attrs = []
self.input_features = None
self.areas = []
self.selection = set()
self.attr_box = gui.hBox(self.mainArea)
self.domain_model = DomainModel(valid_types=DomainModel.PRIMITIVE)
combo_args = dict(widget=self.attr_box,
master=self,
contentsLength=12,
callback=self.attr_changed,
sendSelectedValue=True,
valueType=str,
model=self.domain_model)
fixed_size = (QSizePolicy.Fixed, QSizePolicy.Fixed)
gui.comboBox(value="attr_x", **combo_args)
gui.widgetLabel(self.attr_box, "\u2715", sizePolicy=fixed_size)
gui.comboBox(value="attr_y", **combo_args)
self.vizrank, self.vizrank_button = SieveRank.add_vizrank(
self.attr_box, self, "Score Combinations", self.set_attr)
self.vizrank_button.setSizePolicy(*fixed_size)
self.canvas = QGraphicsScene()
self.canvasView = ViewWithPress(self.canvas,
self.mainArea,
handler=self.reset_selection)
self.mainArea.layout().addWidget(self.canvasView)
self.canvasView.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.canvasView.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
def __init__(self):
super().__init__()
# Diagram update is in progress
self._updating = False
# Input update is in progress
self._inputUpdate = False
# Input datasets in the order they were 'connected'.
self.data = {}
# Extracted input item sets in the order they were 'connected'
self.itemsets = {}
# A list with 2 ** len(self.data) elements that store item sets
# belonging to each area
self.disjoint = []
# A list with 2 ** len(self.data) elements that store keys of tables
# intersected in each area
self.area_keys = []
# Main area view
self.scene = QGraphicsScene()
self.view = QGraphicsView(self.scene)
self.view.setRenderHint(QPainter.Antialiasing)
self.view.setBackgroundRole(QPalette.Window)
self.view.setFrameStyle(QGraphicsView.StyledPanel)
self.mainArea.layout().addWidget(self.view)
self.vennwidget = VennDiagram()
self._resize()
self.vennwidget.itemTextEdited.connect(self._on_itemTextEdited)
self.scene.selectionChanged.connect(self._on_selectionChanged)
self.scene.addItem(self.vennwidget)
controls = gui.hBox(self.mainArea)
box = gui.radioButtonsInBox(controls,
self,
'rowwise', [
"Columns (features)",
"Rows (instances), matched by",
],
box="Elements",
callback=self._on_matching_changed)
gui.comboBox(gui.indentedBox(box),
self,
"selected_feature",
model=itemmodels.VariableListModel(
placeholder="Instance identity"),
callback=self._on_inputAttrActivated)
box.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)
self.outputs_box = box = gui.vBox(controls, "Output")
self.output_duplicates_cb = gui.checkBox(
box,
self,
"output_duplicates",
"Output duplicates",
callback=lambda: self.commit()) # pylint: disable=unnecessary-lambda
gui.auto_send(box, self, "autocommit", box=False)
self.output_duplicates_cb.setEnabled(bool(self.rowwise))
self._queue = []
def __init__(self, pixmap, parentItem=None, crop=False, in_subset=True,
add_label=False, text="", **kwargs):
super().__init__(parentItem, **kwargs)
self.setFocusPolicy(Qt.StrongFocus)
self._size = QSizeF()
layout = QGraphicsLinearLayout(Qt.Vertical, self)
layout.setSpacing(1)
layout.setContentsMargins(5, 5, 5, 5)
self.setContentsMargins(0, 0, 0, 0)
self.pixmapWidget = GraphicsPixmapWidget(pixmap, self)
self.pixmapWidget.setCrop(crop)
self.pixmapWidget.setSubset(in_subset)
self.selectionBrush = DEFAULT_SELECTION_BRUSH
self.selectionPen = DEFAULT_SELECTION_PEN
layout.addItem(self.pixmapWidget)
self.label = None
if add_label:
l1 = ElidedLabel(text)
l1.setStyleSheet("background-color: rgba(255, 255, 255, 10);")
l1.setAlignment(Qt.AlignCenter)
l1.setFixedHeight(16)
self.label = l1
gs = QGraphicsScene()
w = gs.addWidget(l1)
layout.addItem(w)
layout.setAlignment(self.pixmapWidget, Qt.AlignCenter)
self.setLayout(layout)
self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
def main(argv=None): # pragma: no cover
# pylint: disable=import-outside-toplevel
import sys
from AnyQt.QtWidgets import QGraphicsScene, QMenu
from AnyQt.QtGui import QBrush
app = QApplication(argv or sys.argv)
scene = QGraphicsScene()
view = GraphicsWidgetView(scene)
scene.setParent(view)
view.setContextMenuPolicy(Qt.CustomContextMenu)
def context(pos):
menu = QMenu(view)
menu.addActions(view.actions())
a = menu.addAction("Aspect mode")
am = QMenu(menu)
am.addAction("Ignore", lambda: view.setAspectMode(Qt.IgnoreAspectRatio))
am.addAction("Keep", lambda: view.setAspectMode(Qt.KeepAspectRatio))
am.addAction("Keep by expanding", lambda: view.setAspectMode(Qt.KeepAspectRatioByExpanding))
a.setMenu(am)
menu.popup(view.viewport().mapToGlobal(pos))
view.customContextMenuRequested.connect(context)
w = QGraphicsWidget()
w.setPreferredSize(500, 500)
palette = w.palette()
palette.setBrush(palette.Window, QBrush(Qt.red, Qt.BDiagPattern))
w.setPalette(palette)
w.setAutoFillBackground(True)
scene.addItem(w)
view.setCentralWidget(w)
view.show()
return app.exec()
def test_editlinksnode(self):
from ...registry.tests import small_testing_registry
reg = small_testing_registry()
file_desc = reg.widget("Orange.widgets.data.owfile.OWFile")
bayes_desc = reg.widget("Orange.widgets.classify.ownaivebayes."
"OWNaiveBayes")
source_node = SchemeNode(file_desc, title="This is File")
sink_node = SchemeNode(bayes_desc)
scene = QGraphicsScene()
view = QGraphicsView(scene)
node = EditLinksNode(node=source_node)
scene.addItem(node)
node = EditLinksNode(direction=Qt.RightToLeft)
node.setSchemeNode(sink_node)
node.setPos(300, 0)
scene.addItem(node)
view.show()
view.resize(800, 300)
self.app.exec_()
def test_other_exporter(self):
sc = QGraphicsScene()
sc.addItem(QGraphicsRectItem(0, 0, 3, 3))
with patch("orangewidget.io.ImgFormat._get_exporter", Mock()) as mfn:
with self.assertRaises(Exception):
imgio.ImgFormat.write("", sc)
self.assertEqual(0, mfn.call_count)
def __init__(self, parent=None):
super().__init__(parent)
self.nodes = []
self.edges = []
self._selection = []
self._clicked_node = None
self.is_animating = False
scene = QGraphicsScene(self)
scene.setItemIndexMethod(scene.BspTreeIndex)
scene.setBspTreeDepth(2)
self.setScene(scene)
self.setText('')
self.setCacheMode(self.CacheBackground)
self.setViewportUpdateMode(
self.FullViewportUpdate
) # BoundingRectViewportUpdate doesn't work on Mac
self.setTransformationAnchor(self.AnchorUnderMouse)
self.setResizeAnchor(self.AnchorViewCenter)
self.setDragMode(self.RubberBandDrag)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.positionsChanged.connect(self._update_positions,
type=Qt.BlockingQueuedConnection)
self.animationFinished.connect(
lambda: setattr(self, 'is_animating', False))
def __init__(self):
super().__init__()
self.data = None
self.discrete_data = None
self.subset_data = None
self.subset_indices = None
self.__pending_selection = self.selection
self.selection = set()
self.color_data = None
self.areas = []
self.canvas = QGraphicsScene()
self.canvas_view = ViewWithPress(self.canvas,
handler=self.clear_selection)
self.mainArea.layout().addWidget(self.canvas_view)
self.canvas_view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.canvas_view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.canvas_view.setRenderHint(QPainter.Antialiasing)
box = gui.vBox(self.controlArea, box=True)
self.model_1 = DomainModel(order=DomainModel.MIXED,
valid_types=DomainModel.PRIMITIVE)
self.model_234 = DomainModel(order=DomainModel.MIXED,
valid_types=DomainModel.PRIMITIVE,
placeholder="(None)")
self.attr_combos = [
gui.comboBox(box,
self,
value="variable{}".format(i),
orientation=Qt.Horizontal,
contentsLength=12,
callback=self.attr_changed,
model=self.model_1 if i == 1 else self.model_234)
for i in range(1, 5)
]
self.vizrank, self.vizrank_button = MosaicVizRank.add_vizrank(
box, self, "Find Informative Mosaics", self.set_attr)
box2 = gui.vBox(self.controlArea, box="Interior Coloring")
self.color_model = DomainModel(order=DomainModel.MIXED,
valid_types=DomainModel.PRIMITIVE,
placeholder="(Pearson residuals)")
self.cb_attr_color = gui.comboBox(box2,
self,
value="variable_color",
orientation=Qt.Horizontal,
contentsLength=12,
labelWidth=50,
callback=self.set_color_data,
model=self.color_model)
self.bar_button = gui.checkBox(box2,
self,
'use_boxes',
label='Compare with total',
callback=self.update_graph)
gui.rubber(self.controlArea)
def test_pdf(self):
sc = QGraphicsScene()
sc.addItem(QGraphicsRectItem(0, 0, 20, 20))
fd, fname = tempfile.mkstemp()
os.close(fd)
try:
imgio.PdfFormat.write_image(fname, sc)
finally:
os.unlink(fname)
def setUp(self):
super().setUp()
self.scene = QGraphicsScene()
self.view = QGraphicsView(self.scene)
self.item = GraphicsTextItem()
self.item.setPlainText("AAA")
self.item.setTextInteractionFlags(Qt.TextEditable)
self.scene.addItem(self.item)
self.view.setFocus()
def __init__(self, parent=None):
super().__init__(parent)
## Attributes
self.data = None
self.distances = None
self.groups = None
self.unique_pos = None
self.base_group_index = 0
## GUI
box = gui.widgetBox(self.controlArea, "Info")
self.info_box = gui.widgetLabel(box, "\n")
## Separate By box
box = gui.widgetBox(self.controlArea, "Separate By")
self.split_by_model = itemmodels.PyListModel(parent=self)
self.split_by_view = QListView()
self.split_by_view.setSelectionMode(QListView.ExtendedSelection)
self.split_by_view.setModel(self.split_by_model)
box.layout().addWidget(self.split_by_view)
self.split_by_view.selectionModel().selectionChanged.connect(
self.on_split_key_changed)
## Sort By box
box = gui.widgetBox(self.controlArea, "Sort By")
self.sort_by_model = itemmodels.PyListModel(parent=self)
self.sort_by_view = QListView()
self.sort_by_view.setSelectionMode(QListView.ExtendedSelection)
self.sort_by_view.setModel(self.sort_by_model)
box.layout().addWidget(self.sort_by_view)
self.sort_by_view.selectionModel().selectionChanged.connect(
self.on_sort_key_changed)
## Distance box
box = gui.widgetBox(self.controlArea, "Distance Measure")
gui.comboBox(box, self, "selected_distance_index",
items=[name for name, _ in self.DISTANCE_FUNCTIONS],
callback=self.on_distance_measure_changed)
self.scene = QGraphicsScene()
self.scene_view = QGraphicsView(self.scene)
self.scene_view.setRenderHints(QPainter.Antialiasing)
self.scene_view.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.mainArea.layout().addWidget(self.scene_view)
self.scene_view.installEventFilter(self)
self._disable_updates = False
self._cached_distances = {}
self._base_index_hints = {}
self.main_widget = None
self.resize(800, 600)
def setUp(self):
super().setUp()
self.scene = QGraphicsScene()
self.view = QGraphicsView(self.scene)
self.view.setRenderHints(QPainter.Antialiasing
| QPainter.SmoothPixmapTransform
| QPainter.TextAntialiasing)
self.view.resize(500, 300)
self.view.show()
def __init__(self):
super().__init__()
self.setLayout(QHBoxLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self.setFixedSize(50, 50)
view = QGraphicsView()
self.layout().addWidget(view)
self.scene = QGraphicsScene(view)
view.setScene(self.scene)
def test_graphicstextwidget(self):
scene = QGraphicsScene()
view = QGraphicsView(scene)
text = GraphicsTextWidget()
text.setHtml("<center><b>a text</b></center><p>paragraph</p>")
scene.addItem(text)
view.show()
view.resize(400, 300)
self.app.exec_()
def test_other(self):
fd, fname = tempfile.mkstemp('.pdf')
os.close(fd)
sc = QGraphicsScene()
sc.addItem(QGraphicsRectItem(0, 0, 3, 3))
try:
imgio.PdfFormat.write(fname, sc)
with open(fname, "rb") as f:
self.assertTrue(f.read().startswith(b'%PDF'))
finally:
os.unlink(fname)
def test_other(self):
fd, fname = tempfile.mkstemp('.png')
os.close(fd)
sc = QGraphicsScene()
sc.addItem(QGraphicsRectItem(0, 0, 3, 3))
try:
imgio.PngFormat.write(fname, sc)
im = QImage(fname)
# writer adds 15*2 of empty space
self.assertEqual((30+4, 30+4), (im.width(), im.height()))
finally:
os.unlink(fname)
def __init__(self, parent=None):
super().__init__(parent)
self.nodes = OrderedDict()
self.edges = []
self.setScene(QGraphicsScene(self))
self.setCacheMode(self.CacheBackground)
self.setViewportUpdateMode(self.FullViewportUpdate)
self.setTransformationAnchor(self.AnchorUnderMouse)
self.setResizeAnchor(self.AnchorViewCenter)
self.setRenderHints(QPainter.Antialiasing | QPainter.TextAntialiasing)
def __init__(self):
super().__init__()
self.dataset = None
self.attrs = DomainModel(valid_types=Orange.data.DiscreteVariable,
separators=False)
cb = gui.comboBox(self.controlArea,
self,
"attribute",
box=True,
model=self.attrs,
callback=self.update_scene,
contentsLength=12)
grid = QGridLayout()
self.legend = gui.widgetBox(gui.indentedBox(cb.box), orientation=grid)
grid.setColumnStretch(1, 1)
grid.setHorizontalSpacing(6)
self.legend_items = []
self.split_vars = DomainModel(
valid_types=Orange.data.DiscreteVariable,
separators=False,
placeholder="None",
)
self.split_combobox = gui.comboBox(self.controlArea,
self,
"split_var",
box="Split by",
model=self.split_vars,
callback=self.update_scene)
self.explode_checkbox = gui.checkBox(self.controlArea,
self,
"explode",
"Explode pies",
box=True,
callback=self.update_scene)
gui.rubber(self.controlArea)
gui.widgetLabel(
gui.hBox(self.controlArea, box=True),
"The aim of this widget is to\n"
"demonstrate that pie charts are\n"
"a terrible visualization. Please\n"
"don't use it for any other purpose.")
self.scene = QGraphicsScene()
self.view = QGraphicsView(self.scene)
self.view.setRenderHints(QPainter.Antialiasing
| QPainter.TextAntialiasing
| QPainter.SmoothPixmapTransform)
self.mainArea.layout().addWidget(self.view)
self.mainArea.setMinimumWidth(500)
def main(args): # pragma: no cover
# pylint: disable=import-outside-toplevel,protected-access
from AnyQt.QtWidgets import QApplication, QAction
from AnyQt.QtGui import QKeySequence
app = QApplication(args)
view = StickyGraphicsView()
scene = QGraphicsScene(view)
scene.setBackgroundBrush(QBrush(Qt.lightGray, Qt.CrossPattern))
view.setScene(scene)
scene.addRect(QRectF(0, 0, 300, 20), Qt.red,
QBrush(Qt.red, Qt.BDiagPattern))
scene.addRect(QRectF(0, 25, 300, 100))
scene.addRect(QRectF(0, 130, 300, 20), Qt.darkGray,
QBrush(Qt.darkGray, Qt.BDiagPattern))
view.setHeaderSceneRect(QRectF(0, 0, 300, 20))
view.setFooterSceneRect(QRectF(0, 130, 300, 20))
view.show()
zoomin = QAction("Zoom in", view, shortcut=QKeySequence.ZoomIn)
zoomout = QAction("Zoom out", view, shortcut=QKeySequence.ZoomOut)
zoomreset = QAction("Reset",
view,
shortcut=QKeySequence(Qt.ControlModifier | Qt.Key_0))
view._zoom = 100
def set_zoom(zoom):
if view._zoom != zoom:
view._zoom = zoom
view.setTransform(QTransform.fromScale(*(view._zoom / 100, ) * 2))
zoomout.setEnabled(zoom >= 20)
zoomin.setEnabled(zoom <= 300)
@zoomin.triggered.connect
def _():
set_zoom(view._zoom + 10)
@zoomout.triggered.connect
def _():
set_zoom(view._zoom - 10)
@zoomreset.triggered.connect
def _():
set_zoom(100)
view.addActions([zoomin, zoomout, zoomreset])
return app.exec()
def __init__(self, master, *args):
QGraphicsView.__init__(self, *args)
self.master = master
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.setRenderHints(QPainter.Antialiasing)
scene = QGraphicsScene(self)
self.pixmapGraphicsItem = QGraphicsPixmapItem(None)
scene.addItem(self.pixmapGraphicsItem)
self.setScene(scene)
self.setMouseTracking(True)
self.viewport().setMouseTracking(True)
self.setFocusPolicy(Qt.WheelFocus)
def display():
# pylint: disable=too-many-branches
def render_value(value):
return "" if np.isnan(value) else attribute.str_val(value)
if column == self.Columns.NAME:
return attribute.name
elif column == self.Columns.DISTRIBUTION:
if isinstance(attribute,
(DiscreteVariable, ContinuousVariable)):
if row not in self.__distributions_cache:
scene = QGraphicsScene(parent=self)
histogram = Histogram(
data=self.table,
variable=attribute,
color_attribute=self.target_var,
border=(0, 0, 2, 0),
border_color='#ccc',
)
scene.addItem(histogram)
self.__distributions_cache[row] = scene
return self.__distributions_cache[row]
elif column == self.Columns.CENTER:
return render_value(self._center[row])
elif column == self.Columns.DISPERSION:
if isinstance(attribute, TimeVariable):
return format_time_diff(self._min[row], self._max[row])
elif isinstance(attribute, DiscreteVariable):
return "%.3g" % self._dispersion[row]
else:
return render_value(self._dispersion[row])
elif column == self.Columns.MIN:
if not isinstance(attribute, DiscreteVariable) \
or attribute.ordered:
return render_value(self._min[row])
elif column == self.Columns.MAX:
if not isinstance(attribute, DiscreteVariable) \
or attribute.ordered:
return render_value(self._max[row])
elif column == self.Columns.MISSING:
return '%d (%d%%)' % (
self._missing[row],
100 * self._missing[row] / self.n_instances
)
return None
def __init__(self):
super().__init__()
self.data = None
self.discrete_data = None
self.unprocessed_subset_data = None
self.subset_data = None
self.areas = []
self.canvas = QGraphicsScene()
self.canvas_view = ViewWithPress(self.canvas,
handler=self.clear_selection)
self.mainArea.layout().addWidget(self.canvas_view)
self.canvas_view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.canvas_view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.canvas_view.setRenderHint(QPainter.Antialiasing)
box = gui.vBox(self.controlArea, box=True)
self.attr_combos = [
gui.comboBox(box,
self,
value="variable{}".format(i),
orientation=Qt.Horizontal,
contentsLength=12,
callback=self.reset_graph,
sendSelectedValue=True,
valueType=str,
emptyString="(None)") for i in range(1, 5)
]
self.vizrank, self.vizrank_button = MosaicVizRank.add_vizrank(
box, self, "Find Informative Mosaics", self.set_attr)
self.rb_colors = gui.radioButtonsInBox(self.controlArea,
self,
"interior_coloring",
self.interior_coloring_opts,
box="Interior Coloring",
callback=self.coloring_changed)
self.bar_button = gui.checkBox(gui.indentedBox(self.rb_colors),
self,
'use_boxes',
label='Compare with total',
callback=self._compare_with_total)
gui.rubber(self.controlArea)
def __init__(self, parent=None):
self.canvas = QGraphicsScene(0, 0, 1000, ColorButtonSize)
QGraphicsView.__init__(self, self.canvas, parent)
self.ensureVisible(0, 0, 1, 1)
self.color1 = None
self.color2 = None
self.rgbColors = []
self.passThroughColors = None
#self.setFrameStyle(QFrame.NoFrame)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setFixedHeight(ColorButtonSize)
self.setMinimumWidth(ColorButtonSize)
if parent and parent.layout() is not None:
parent.layout().addWidget(self)
def render_drop_shadow_frame(pixmap, shadow_rect, shadow_color, offset, radius,
rect_fill_color):
pixmap.fill(QColor(0, 0, 0, 0))
scene = QGraphicsScene()
rect = QGraphicsRectItem(shadow_rect)
rect.setBrush(QColor(rect_fill_color))
rect.setPen(QPen(Qt.NoPen))
scene.addItem(rect)
effect = QGraphicsDropShadowEffect(color=shadow_color,
blurRadius=radius,
offset=offset)
rect.setGraphicsEffect(effect)
scene.setSceneRect(QRectF(QPointF(0, 0), QSizeF(pixmap.size())))
painter = QPainter(pixmap)
scene.render(painter)
painter.end()
scene.clear()
scene.deleteLater()
return pixmap
def save_widget_icon(
background,
icon: str,
outname: str,
export_size=QSize(100, 100),
format="png",
):
# create fake windget and category descriptions
widget_description = WidgetDescription("",
"",
icon=icon,
qualified_name="orangecanvas")
category = CategoryDescription(background=background)
item = NodeItem(widget_description)
item.setWidgetCategory(category)
iconItem = item.icon_item
shapeItem = item.shapeItem
shapeSize = export_size
iconSize = QSize(export_size.width() * 3 / 4, export_size.height() * 3 / 4)
rect = QRectF(QPointF(-shapeSize.width() / 2, -shapeSize.height() / 2),
QSizeF(shapeSize))
shapeItem.setShapeRect(rect)
iconItem.setIconSize(iconSize)
iconItem.setPos(-iconSize.width() / 2, -iconSize.height() / 2)
image = QImage(export_size, QImage.Format_ARGB32)
image.fill(QColor("#00FFFFFF"))
painter = QPainter(image)
painter.setRenderHint(QPainter.Antialiasing, 1)
scene = QGraphicsScene()
scene.addItem(shapeItem)
scene.render(painter, QRectF(image.rect()), scene.sceneRect())
painter.end()
if not image.save(outname, format, 80):
print("Failed to save " + outname)
