class ImageButton(Widget):
activated = QSignal()
def __init__(self, parent, image):
super().__init__(parent)
self.set_widget(QPushButton(QParent(parent)))
fsui.qt.QPushButton.__init__(self, parent.get_container())
icon = image.qicon
self._widget.setIcon(icon)
self._widget.setIconSize(fsui.qt.QSize(image.size[0], image.size[1]))
self._widget.clicked.connect(self.__clicked)
def set_image(self, image):
self._widget.setIcon(image.qicon)
def __clicked(self):
self.on_activated()
def on_activated(self):
self.activated.emit()
# FIXME: Remove
self.on_activate()
def on_activate(self):
pass
@property
def clicked(self):
warnings.warn("use activated instead", DeprecationWarning)
return self.activated
class Button(Widget):
activated = QSignal()
def __init__(self, parent, label=""):
super().__init__(parent)
label = " " + label + " "
self.set_widget(QPushButton(label, QParent(parent)))
self._widget.clicked.connect(self.__clicked)
def __clicked(self):
self.on_activated()
def on_activated(self):
self.activated.emit()
# FIXME: Remove
self.on_activate()
def on_activate(self):
pass
@property
def clicked(self):
warnings.warn("use activated instead", DeprecationWarning)
return self.activated
class Button(QPushButton, WidgetMixin):
activated = QSignal()
def __init__(self, parent, label=""):
label = " " + label + " "
# self._widget = QPushButton(label, parent.get_container())
QPushButton.__init__(self, label, parent.get_container())
# Widget.__init__(self, parent)
self.init_widget(parent)
# self._widget.clicked.connect(self.__clicked)
# if not System.macosx:
# self.set_min_height(28)
self.clicked.connect(self.__clicked)
def __clicked(self):
self.on_activated()
def on_activated(self):
self.activated.emit()
# FIXME: Remove
self.on_activate()
def on_activate(self):
pass
class Window(QObject):
shown = QSignal()
closed = QSignal()
def __init__(self,
parent,
title="",
border=True,
minimizable=True,
maximizable=True,
separator=True,
menu=False,
native=None,
header=True,
below=False,
closable=True,
color=None,
**_):
init_qt()
super().__init__()
# if parent is None and len(default_window_parent) > 0:
# parent = default_window_parent[-1]
# print("using default parent", parent)
# FIXME
self._window = weakref.ref(self)
if native is None:
if fsboot.get("fws") == "1":
native = False
else:
native = not _use_fws
if native:
self._real_window = RealWindow(QParent(parent, True),
self,
minimizable=minimizable,
maximizable=maximizable,
below=below,
border=border)
else:
self._real_window = FwsWindow(QParent(parent, True),
self,
below=below)
self._real_widget = RealWidget(self._real_window, self)
# Widget.__init__(self, parent)
# self.init_widget(parent)
# MixinBase.__init__(self)
self.set_title(title)
self.layout = None
self._size_specified = False
self.close_listeners = []
# _windows.add(self)
self.destroyed.connect(self.__destroyed)
self._real_window.setAttribute(Qt.WA_DeleteOnClose, True)
# if not border:
# self.setWindowFlags(Qt.FramelessWindowHint |
# Qt.NoDropShadowWindowHint)
# # self.setWindowFlags(Qt.FramelessWindowHint)
self.center_on_show = True
self._centered_on_initial_show = False
if hasattr(self, "accepted"):
self.accepted.connect(self.__accepted)
if hasattr(self, "rejected"):
self.rejected.connect(self.__rejected)
# Add a keep-alive reference
print("Adding window reference", self)
windows.add(self)
self.closed.connect(self.__closed)
self.title_panel = None
self.title_panel_visible = False
if not native:
self.real_window()._window = weakref.ref(self)
from workspace.ui.theme import WorkspaceTheme
from workspace.ui.window import WindowHeader
if header:
self.title_panel = WindowHeader(self.real_window(),
menu=menu,
minimizable=minimizable,
maximizable=maximizable,
separator=separator,
closable=closable,
background=color)
self.title_panel_visible = True
self.set_background_color(
WorkspaceTheme.instance().window_background)
def __closed(self):
print("Removing window reference", self)
windows.remove(self)
@property
def window(self):
return self
@property
def visible(self):
return self._real_window.isVisible()
@visible.setter
def visible(self, visible):
self._real_window.setVisible(visible)
def alert(self, msecs=0):
init_qt().alert(self._real_window, msecs)
def close(self):
self._real_window.close()
def real_window(self):
return self._real_window
def real_widget(self):
return self._real_widget
# DEPRECATED
def get_container(self):
return self.real_widget()
# FIXME: Is this used?
def center_on_initial_show(self):
if self._centered_on_initial_show:
return
if self.layout and not self._size_specified:
self.set_size(self.layout.get_min_size())
self.on_resize()
self.center_on_parent()
self._centered_on_initial_show = True
def __destroyed(self):
print(str(self) + ".__destroyed")
def add_close_listener(self, function):
# self.close_listeners.append(function)
self.closed.connect(function)
def top_level(self):
return self
def set_icon(self, icon):
self.real_window().setWindowIcon(icon.qicon())
def position(self):
# position = self._real_window.position()
# return position.x(), position.y()
return self._real_window.position()
def set_position(self, position):
self._real_window.set_position(position)
# def set_position_and_size(self, position, size):
# self.widget().setGeometry(position[0], position[1], size[0], size[1])
def size(self):
return self.width(), self.height()
def width(self):
return self._real_window.width()
def height(self):
return self._real_window.height()
def set_size(self, size):
self._size_specified = True
# self.SetClientSize(size)
# print("FIXME:\n\nDialog.set_size")
# self.resize(size[0], size[1])
# import traceback
# traceback.print_stack()
if size[0] == 0 or size[1] == 0:
print("Window.set_size ignoring size", size)
return
print("Window.set_size", size)
self._real_window.set_size(size)
self._real_widget.resize(size[0], size[1])
def set_initial_size_from_layout(self):
if self.layout and not self._size_specified:
self.set_size_from_layout()
def set_size_from_layout(self):
size = self.layout.get_min_size()
print("set_size_from_layout, size =", size)
self.set_size(size)
def title(self):
return self._real_window.windowTitle()
def set_title(self, title):
self._real_window.setWindowTitle(title)
def show(self, maximized=False, center=False, offset=False):
if center:
print("CENTER")
self.center_on_parent()
# self._centered_on_initial_show = True
elif offset:
self.offset_from_parent((20, 20))
# self._centered_on_initial_show = True
self.center_on_show = False
if maximized:
self._real_window.showMaximized()
else:
self._real_window.show()
def is_maximized(self):
# return self._real_window.windowState() == Qt.WindowMaximized
return self._real_window.is_maximized()
def is_fullscreen(self):
return self._real_window.is_fullscreen()
def set_fullscreen(self, fullscreen=True, geometry=None):
# We must set the size before maximizing, so this isn't done within
# showMaximized -> ... -> set_initial_size_from_layout -> set_size.
self.set_initial_size_from_layout()
if self.title_panel is not None:
self.title_panel.set_visible(not fullscreen)
self.title_panel_visible = not fullscreen
self._real_window.set_fullscreen(fullscreen, geometry)
def set_maximized(self, maximize=True, geometry=None):
# We must set the size before maximizing, so this isn't done within
# showMaximized -> ... -> set_initial_size_from_layout -> set_size.
self.set_initial_size_from_layout()
self._real_window.set_maximized(maximize, geometry)
def minimize(self):
# self.setWindowState(Qt.WindowMinimized)
return self._real_window.minimize()
def get_window_center(self):
position = self.position()
size = self.size()
return position[0] + size[0] // 2, position[1] + size[1] // 2
def center_on_parent(self):
# import traceback
# traceback.print_stack()
self.set_initial_size_from_layout()
real_parent = self.real_window().parent()
# print("center_on_parent real_parent = ",
# real_parent, default_window_center)
if real_parent:
pp = real_parent.x(), real_parent.y()
ps = real_parent.width(), real_parent.height()
ss = self.size()
print(pp, ps, ss)
self.set_position(
(pp[0] + (ps[0] - ss[0]) // 2, pp[1] + (ps[1] - ss[1]) // 2))
# elif len(default_window_center) > 0:
# x, y = default_window_center[-1]
# ss = self.size()
# self.set_position((x - ss[0] // 2, y - ss[1] // 2))
def offset_from_parent(self, offset):
self.set_initial_size_from_layout()
real_parent = self.real_window().parent()
# print("offset_from_parent real_parent = ",
# real_parent, default_window_center)
if real_parent:
pp = real_parent.x(), real_parent.y()
self.set_position((pp[0] + offset[0], pp[1] + offset[1]))
def center_on_screen(self):
frame_rect = self._real_window.frameGeometry()
frame_rect.moveCenter(QDesktopWidget().availableGeometry().center())
self._real_window.move(frame_rect.topLeft())
def set_background_color(self, color):
p = self.real_widget().palette()
p.setColor(self.real_widget().backgroundRole(), color)
self.real_widget().setPalette(p)
def is_shown(self):
return self._real_window.isVisible()
def raise_and_activate(self):
self._real_window.raise_()
self._real_window.activateWindow()
def on_close(self):
pass
def __rejected(self):
print(str(self) + ".__rejected")
self.__on_closed()
def __accepted(self):
print(str(self) + ".__accepted")
self.__on_closed()
def on_resize(self):
if self.layout:
self.layout.set_size(self.get_size())
self.layout.update()
# DEPRECATED
def resize(self, width, height):
self.set_size((width, height))
# DEPRECATED
def get_size(self):
return self.size()
# DEPRECATED
def get_window(self):
return self.top_level()
# DEPRECATED
def get_position(self):
return self.position()
# DEPRECATED
def maximized(self):
return self.is_maximized()
# DEPRECATED
def get_parent(self):
return None
# DEPRECATED
def set_icon_from_path(self, _):
print("FIXME: Window.set_icon_from_path")
# DEPRECATED
def get_title(self):
return self.title()
# DEPRECATED
def maximize(self, maximize=True):
return self.set_maximized(maximize)
def Signal():
return QSignal()