def __init__(self):
self.root = self._create_root_app()
self.curdir = os.getcwd()
self.curfile = f'{os.path.dirname(self.curdir)}\\images\\asciify.jpg'
self.curimg = None
self.ascii_image = ""
self.gradientEntry = tk.StringVar()
self.use_custom_gradient = tk.BooleanVar(value=False)
self.gradientStep = tk.StringVar(value=str(settings.gradient["step"]))
self.fontsize = tk.StringVar(value=str(settings.font["size"]))
self.curfont = tk.StringVar(value=settings.font["family"])
self.percent = tk.StringVar(value=float(settings.output["percent"]))
self.outputSize = tk.StringVar(value="0x0")
self.targetWidth = tk.IntVar(value=int(settings.output["width"]))
self.targetHeight = tk.IntVar(value=int(settings.output["height"]))
self.curoutputoption = tk.StringVar(value=settings.output["type"])
self.contrast = tk.StringVar(value=settings.adjustments["contrast"])
self.brightness = tk.StringVar(
value=settings.adjustments["brightness"])
self.aspectRatioFit = (16, 9)
# application elements
self.menubar = MenuBar(self)
self.toolbar_widget = Toolbar(self)
self.ascii_wdiget = self.create_ascii_zone()
self.update_current_working_img()
self.update_ascii()
def __init__(self):
QtGui.QMainWindow.__init__(self)
self.setGeometry(0, 30, 900, 650)
self.setWindowTitle(_(u'Power Management'))
self.setWindowIcon(QtGui.QIcon('icons/power-icon.png'))
self.menubar = MenuBar(self)
self.setMenuBar(self.menubar)
self.change_context(DashbordViewWidget)
def __init__(self):
QtGui.QMainWindow.__init__(self)
self.resize(900, 650)
self.setWindowTitle('Principale')
self.setWindowIcon(QtGui.QIcon('icons/fad.png'))
self.menubar = MenuBar(self)
self.setMenuBar(self.menubar)
self.change_context(DashbordViewWidget)
def __init__(self, parent=None):
super(fMain, self).__init__(parent)
self.setWindowTitle("Transient Spectra Analyzer")
self.resize(1800, 1000)
self.console = Console(self)
self.matrix = None # object of LFP matrix
self.addDockWidget(Qt.RightDockWidgetArea, self.console)
# fixing the resize bug https://stackoverflow.com/questions/48119969/qdockwidget-splitter-jumps-when-qmainwindow-resized
# self.resizeDocks([self.dockTreeWidget], [270], Qt.Horizontal)
self.resizeDocks([self.console], [200], Qt.Horizontal)
# self.setCorner(Qt.BottomLeftCorner, Qt.LeftDockWidgetArea)
self.coor_label = QLabel() # coordinates
self.plot_widget = PlotWidget(
set_coordinate_func=self.coor_label.setText, parent=self)
self.SVD_widget = SVDWidget(self)
self.fit_widget = FitWidget(None, self)
self.tabWidget = QtWidgets.QTabWidget(self)
self.tabWidget.addTab(self.plot_widget, "Data")
self.tabWidget.addTab(self.SVD_widget, "SVD + EFA")
self.tabWidget.addTab(self.fit_widget, "Fit")
self.tabWidget.currentChanged.connect(self.tabChanged)
self.setCentralWidget(self.tabWidget)
self.createStatusBar()
self.logger = Logger(self.console.show_message,
self.statusBar().showMessage)
sys.stdout = Transcript()
self.user_namespace = UserNamespace(self)
self.setMenuBar(MenuBar(self))
Settings.load()
self.update_recent_files()
Console.push_variables({'main_widget': self})
Console.execute_command(
"from LFP_matrix import LFP_matrix\nimport fitmodels as m\n"
"import matplotlib.pyplot as plt\nfrom Widgets.fit_widget import FitWidget\n"
"import augmentedmatrix")
Console.push_variables({'pw': self.plot_widget})
Console.push_variables({'fw': self.fit_widget})
Console.push_variables({'sw': self.SVD_widget})
def __init__(self, regions):
Display.__init__(self, regions)
self.root.title("ViewPY: A Data Viewing Program")
self.menubar = MenuBar(self.root)
self.mainframe = ttk.Frame(self.root, padding='5 5 5 5')
self.mainframe.pack()
self.canvas = Canvas(self.mainframe,
width=800,
height=800,
background='white')
self.draw = CanvasDrawing(self.canvas, self.regions)
def initGui(self, screen_width, screen_height):
bar_height = 30
self._statusbar = StatusBar(text=u"", panel_size=bar_height)
self._toolbar = ToolBar(title=u"Toolbar", button_style=0)
self._menubar = MenuBar(min_size=(screen_width, bar_height), position=(0, 0))
# Set up root widget
self._rootwidget = pychan.widgets.VBox(padding=0, vexpand=1, hexpand=1)
self._rootwidget.min_size = \
self._rootwidget.max_size = (screen_width, screen_height)
self._rootwidget.opaque = False
self._dockareas[DOCKAREA['left']] = DockArea("left")
self._dockareas[DOCKAREA['right']] = DockArea("right")
self._dockareas[DOCKAREA['top']] = DockArea("top")
self._dockareas[DOCKAREA['bottom']] = DockArea("bottom")
self._toolbarareas[DOCKAREA['left']] = pychan.widgets.VBox(margins=(0,0,0,0))
self._toolbarareas[DOCKAREA['right']] = pychan.widgets.VBox(margins=(0,0,0,0))
self._toolbarareas[DOCKAREA['top']] = pychan.widgets.HBox(margins=(0,0,0,0))
self._toolbarareas[DOCKAREA['bottom']] = pychan.widgets.HBox(margins=(0,0,0,0))
# This is where the map will be displayed
self._centralwidget = pychan.widgets.VBox(vexpand=1, hexpand=1)
self._centralwidget.opaque = False
middle = pychan.widgets.HBox(padding=0, vexpand=1, hexpand=1)
middle.opaque = False
# Pychan bug? Adding a spacer instead of a container creates
# a gap after the right dockarea
middle.addChild(self._toolbarareas['left'])
middle.addChild(self._dockareas['left'])
middle.addChild(self._centralwidget)
#middle.addSpacer(pychan.widgets.Spacer())
middle.addChild(self._dockareas['right'])
middle.addChild(self._toolbarareas['right'])
self._rootwidget.addChild(self._menubar)
#self._rootwidget.addChild(self._toolbar)
self._rootwidget.addChild(self._toolbarareas['top'])
self._rootwidget.addChild(self._dockareas['top'])
self._rootwidget.addChild(middle)
self._rootwidget.addChild(self._dockareas['bottom'])
self._rootwidget.addChild(self._toolbarareas['bottom'])
self._rootwidget.addChild(self._statusbar)
self._toolbar.setDocked(True)
self.dockWidgetTo(self._toolbar, "top")
self._rootwidget.show()
def __init__(self, parent=None):
super().__init__(parent)
self._parent = parent
self.winfo_toplevel().title(self._title)
self.grid(sticky="NEWS")
self.columnconfigure(0, weight=1)
self.rowconfigure(1, weight=1)
self.__menu = MenuBar(self,
on_new_game=self._on_new_game,
on_exit=self._on_exit)
self.__menu.grid(row=0, column=0)
self.__game_field = GameField(self, on_win=self._on_win)
self.__game_field.grid(row=1, column=0)
def __init__(self, **kwargs):
super(Designer, self).__init__(**kwargs)
self.root_name = ""
self.popup = None
self.file = ""
# A count variable to give ids to generated widget
self.count = 0
#This variable updates to True when ctrl is pressed
self.ctrl_pressed = False
#Instantiate the WidgetTree
self.widget_tree = WidgetTree(self)
self.widget_tree_box.add_widget(self.widget_tree)
#Instantiate MenuBar
self.menubar = MenuBar(designer = self, pos_hint = {'x':0,'top':1}, \
canvas_area = self.canvas_area, size_hint = (.70,None),height = 25)
self.add_widget(self.menubar)
#Instantiate right widgets bar
# We update the same widgets bar, and dont create new instances everytime
self.widgetbar = NewWidgetsMenu(self)
self.rightbox.add_widget(self.widgetbar)
#Initialize the keyboard and set up handlers for key press and release
self.canvas_area._keyboard = Window.request_keyboard(self._keyboard_closed,self)
self.canvas_area._keyboard.bind(on_key_down=self._on_keyboard_down)
self.canvas_area._keyboard.bind(on_key_up = self._on_keyboard_up)
# Setup canvas for highlighting
with self.canvas.after:
self.gcolor = Color(1, 1, 0, .25)
PushMatrix()
self.gtranslate = Translate(0, 0, 0)
self.grotate = Rotate(0, 0, 0, 1)
self.gscale = Scale(1.)
self.grect = Rectangle(size=(0, 0))
PopMatrix()
# Instantiate Statusbar
self.status_bar = StatusBar(size_hint = (1,.05))
self.leftbox.add_widget(self.status_bar)
#Show properties binding
# self.widget -> updated on_touch_down in 'canvas_area'
# So, whenever we have a new self.widget, we call show_properties
self.bind(widget = self.show_properties)
self.bind(widget = self.widget_tree.select_highlighted)
def __init__(self,
name,
menubar,
idle_icon_path=ICON_UNKNOWN,
open_icon_path=None,
function=None,
is_folder=False):
self.name = name # Name of app
self.menubar = menubar # The parent menubar
self.function = function
if is_folder:
self.function = self.toggle_is_open
idle_icon_path = ICON_FOLDER
open_icon_path = ICON_FOLDER_OPEN
self.idle_rect = pygame.Rect(0, 0, APP_DIMENSION, APP_DIMENSION)
self.selected_rect = pygame.Rect(0, 0, APP_DIMENSION + UI_PADDING,
APP_DIMENSION + UI_PADDING)
self.rect = self.idle_rect
self.idle_icon = pygame.transform.scale(
pygame.image.load(idle_icon_path), self.idle_rect.size)
self.selected_icon = pygame.transform.scale(self.idle_icon,
self.selected_rect.size)
self.open_icon = pygame.transform.scale(
pygame.image.load(idle_icon_path if open_icon_path ==
None else open_icon_path), self.idle_rect.size)
self.open_selected_icon = pygame.transform.scale(
self.open_icon, self.selected_rect.size)
self.icon = self.idle_icon
self.sub_apps = []
self.sub_app_menubar = MenuBar(
self.menubar.screen, self.menubar.font,
self.menubar.rect[1] + APP_MENUBAR_OFFSET)
self.is_selected = False
self.is_open = False
self.resize()
def __init__(self, *args, **kwargs):
tk.Tk.__init__(self, *args, **kwargs)
#initialize menu
self.config(menu=MenuBar(self))
self.title('FIFA 17 Auto Buyer')
self.geometry('950x650-5+40')
self.minsize(width=650, height=450)
# bind ctrl+a
if(platform == 'darwin'):
self.bind_class("Entry", "<Command-a>", self.selectall)
else:
self.bind_class("Entry", "<Control-a>", self.selectall)
self.status = StatusBar(self)
self.status.pack(side='bottom', fill='x')
self.status.set_credits('0')
self.appFrame = Application(self)
self.appFrame.pack(side='top', fill='both', expand='True')
class GtkUI(object):
def __init__(self, args):
self.daemon_bps = (0, 0, 0)
# Setup signals
try:
import gnome.ui
import gnome
#Suppress: Warning: Attempt to add property GnomeProgram::*** after class was initialised
original_filters = warnings.filters[:]
warnings.simplefilter("ignore")
try:
self.gnome_prog = gnome.init("Deluge",
deluge.common.get_version())
finally:
warnings.filters = original_filters
self.gnome_client = gnome.ui.master_client()
def on_die(*args):
reactor.stop()
self.gnome_client.connect("die", on_die)
log.debug("GNOME session 'die' handler registered!")
except Exception, e:
log.warning(
"Unable to register a 'die' handler with the GNOME session manager: %s",
e)
if deluge.common.windows_check():
from win32api import SetConsoleCtrlHandler
from win32con import CTRL_CLOSE_EVENT
from win32con import CTRL_SHUTDOWN_EVENT
def win_handler(ctrl_type):
log.debug("ctrl_type: %s", ctrl_type)
if ctrl_type in (CTRL_CLOSE_EVENT, CTRL_SHUTDOWN_EVENT):
reactor.stop()
return 1
SetConsoleCtrlHandler(win_handler)
if deluge.common.osx_check() and Gdk.WINDOWING == "quartz":
import gtkosx_application
self.osxapp = gtkosx_application.gtkosx_application_get()
def on_die(*args):
reactor.stop()
self.osxapp.connect("NSApplicationWillTerminate", on_die)
# Set process name again to fix gtk issue
setproctitle(getproctitle())
# Attempt to register a magnet URI handler with gconf, but do not overwrite
# if already set by another program.
common.associate_magnet_links(False)
# Make sure gtkui.conf has at least the defaults set
self.config = deluge.configmanager.ConfigManager(
"gtkui.conf", DEFAULT_PREFS)
# We need to check on exit if it was started in classic mode to ensure we
# shutdown the daemon.
self.started_in_classic = self.config["classic_mode"]
# Start the IPC Interface before anything else.. Just in case we are
# already running.
self.queuedtorrents = QueuedTorrents()
self.ipcinterface = IPCInterface(args)
# Initialize gdk threading
Gdk.threads_init()
GObject.threads_init()
# We make sure that the UI components start once we get a core URI
client.set_disconnect_callback(self.__on_disconnect)
self.trackericons = TrackerIcons()
self.sessionproxy = SessionProxy()
# Initialize various components of the gtkui
self.mainwindow = MainWindow()
self.menubar = MenuBar()
self.toolbar = ToolBar()
self.torrentview = TorrentView()
self.torrentdetails = TorrentDetails()
self.sidebar = SideBar()
self.filtertreeview = FilterTreeView()
self.preferences = Preferences()
self.systemtray = SystemTray()
self.statusbar = StatusBar()
self.addtorrentdialog = AddTorrentDialog()
if deluge.common.osx_check() and Gdk.WINDOWING == "quartz":
def nsapp_open_file(osxapp, filename):
# Will be raised at app launch (python opening main script)
if filename.endswith('Deluge-bin'):
return True
from deluge.ui.gtkui.ipcinterface import process_args
process_args([filename])
self.osxapp.connect("NSApplicationOpenFile", nsapp_open_file)
from menubar_osx import menubar_osx
menubar_osx(self, self.osxapp)
self.osxapp.ready()
# Initalize the plugins
self.plugins = PluginManager()
# Show the connection manager
self.connectionmanager = ConnectionManager()
from twisted.internet.task import LoopingCall
rpc_stats = LoopingCall(self.print_rpc_stats)
rpc_stats.start(10)
reactor.callWhenRunning(self._on_reactor_start)
# Start the gtk main loop
Gdk.threads_enter()
reactor.run()
self.shutdown()
Gdk.threads_leave()
# Open Meeting Link and Update Progress Bar
if link is not None:
self.message["text"] = "Opening Link for Period " + str(currentperiod)
webbrowser.open_new_tab(link)
elif currentperiodindex is not None:
curdiff = self.ctime - time_to_datetime(self.ctime, self.sched[currentperiodindex][1])
fulldiff = time_to_datetime(self.ctime,self.sched[currentperiodindex][2]) - time_to_datetime(self.ctime, self.sched[currentperiodindex][1])
self.progress["value"] = curdiff / fulldiff * 100
self.message["text"] = ""
else:
self.progress["value"] = 0
self.message["text"] = ""
# Update Output and Sleep
self.time["text"] = str(self.ctime)[11:16]
root.after(60000, self.timer)
# Run Simulator
root = Tk()
root.title("Meeting Scheduler")
try:
root.iconbitmap(resource_path("meetingschedulericon.ico"))
except:
pass
scheduler = Scheduler(root)
menu = Menu(root)
menubar = MenuBar(root, menu, scheduler)
root.configure(menu = menu, background = "white")
scheduler.mainloop()
def main(client, setupinfo=None):
gameid = 'test1' #setupinfo["request"]["parameters"]["id"]
height = 720
width = 1024
screensize = (width, height)
screen = pygame.display.set_mode(screensize)
clock = pygame.time.Clock()
pygame.mouse.set_visible(0)
animate = True
running = True
background, background_rect = load_image("stars.jpg")
outer_menu = MenuBar(planet1name, 1, backgroundcolor, True, (90, 0))
menubar.pdb_image, menubar.pdbrect = load_image("pdbup.png", None)
menubar.pdbrect.topleft = menubar.pdbboxpostion
screen.blit(background, background_rect)
mouse_ptr = MouseCursor("pointer2.png")
mouse_sel = MouseCursor("selected2.png")
mouse = pygame.sprite.RenderUpdates((mouse_ptr))
mouse.draw(screen)
pygame.display.flip()
#===========================================================================
# Object Initialization:
#===========================================================================
characterlist = client.root.get_state(
game_id=gameid, object_type="Character")["response"]["character"]
planetlist = client.root.get_state(
game_id=gameid, object_type="Planet")["response"]["planet"]
environlist = client.root.get_state(
game_id=gameid, object_type="Environ")["response"]["environ"]
militarylist = client.root.get_state(
game_id=gameid, object_type="Unit")["response"]["unit"]
stacklist = client.root.get_state(game_id=gameid,
object_type="Stack")["response"]["stack"]
star_system = System(screen, background, animate, characterlist,
planetlist, environlist, militarylist, stacklist)
#print characterlist
menu = Menu_Buttons.Menu(screen)
selected_unit = None
while running:
clock.tick(60)
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sysexit()
elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
pygame.quit()
sysexit()
if not mouse_ptr.down:
if event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
if selected_unit:
hover_unit = left_mouse_select_check(
client, mouse_sel, star_system)
if hover_unit != selected_unit:
#mergeresponse = client.root.merge_stack(unit.stack_id, selected_unit.stack_id)
#if mergeresponse["Success"]:
selected_unit.add_unit(hover_unit)
star_system.unit_list.remove(hover_unit)
print "SPACE BAR"
if event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 1:
mouse_ptr.pressed = mouse_sel.pressed = True
mouse_ptr.released = mouse_sel.released = False
selected_unit = left_mouse_select_check(
client, mouse_ptr, star_system)
# while the mouse button is down, change its cursor
mouse.remove(mouse_ptr)
mouse.add(mouse_sel)
#Update Buttons and menu status
menu.update_buttons(mouse_ptr.rect)
elif event.button == 3:
key_mod = pygame.key.get_mods()
if key_mod == 4097 or key_mod == 1:
hover_unit = star_system.unit_list.get_sprites_at(
mouse_ptr.pos)
print "STACK REMOVING FROM", hover_unit
if hover_unit:
if hover_unit[0].stack_list[-1].charflag:
splitresponse = client.root.split_stack(
stack_id=hover_unit[0].stack_id,
character_id=hover_unit[0].
stack_list[-1].id)
else:
splitresponse = client.root.split_stack(
stack_id=hover_unit[0].stack_id,
unit_id=hover_unit[0].stack_list[-1].id
)
print splitresponse
if splitresponse["request"]["success"]:
sprite = hover_unit[0].remove_unit()
sprite.set_stack_id(
splitresponse["response"]["unit"]
["stack_id"])
star_system.unit_list.add(sprite)
print "SHIFT RIGHT CLICK"
else:
hover_unit = star_system.unit_list.get_sprites_at(
mouse_ptr.pos)
if hover_unit:
hover_unit[0].cycle_unit()
print "RIGHT CLICK"
if event.type == pygame.MOUSEBUTTONUP:
mouse_ptr.released = mouse_sel.released = True
selected_unit = left_mouse_unselect_check(
client, mouse, selected_unit, star_system)
# while the mouse button is up, change its cursor
mouse.remove(mouse_sel)
mouse.add(mouse_ptr)
screen.blit(background, background_rect)
star_system.update()
if selected_unit:
selected_unit.update(True)
mouse.update()
star_system.draw()
#Draw buttons and menus
menu.draw_buttons(screen, height, width, selected_unit)
for planet in star_system.planet_list:
if planet.orient == 'center':
current_planet = planet
try:
outer_menu.update(current_planet.name, current_planet.loyalty,
current_planet.pdb_state, "Egrix", False, False)
except:
pass
outer_menu.draw(background, screen, menubar_)
mouse.draw(screen)
pygame.display.flip()
class GtkUI(object):
def __init__(self, args):
self.daemon_bps = (0, 0, 0)
# Setup signals
try:
import gnome.ui
import gnome
self.gnome_prog = gnome.init("Deluge", deluge.common.get_version())
self.gnome_client = gnome.ui.master_client()
def on_die(*args):
reactor.stop()
self.gnome_client.connect("die", on_die)
log.debug("GNOME session 'die' handler registered!")
except Exception, e:
log.warning(
"Unable to register a 'die' handler with the GNOME session manager: %s",
e)
if deluge.common.windows_check():
from win32api import SetConsoleCtrlHandler
from win32con import CTRL_CLOSE_EVENT
from win32con import CTRL_SHUTDOWN_EVENT
def win_handler(ctrl_type):
log.debug("ctrl_type: %s", ctrl_type)
if ctrl_type in (CTRL_CLOSE_EVENT, CTRL_SHUTDOWN_EVENT):
reactor.stop()
return 1
SetConsoleCtrlHandler(win_handler)
# Attempt to register a magnet URI handler with gconf, but do not overwrite
# if already set by another program.
common.associate_magnet_links(False)
# Make sure gtkui.conf has at least the defaults set
self.config = deluge.configmanager.ConfigManager(
"gtkui.conf", DEFAULT_PREFS)
# We need to check on exit if it was started in classic mode to ensure we
# shutdown the daemon.
self.started_in_classic = self.config["classic_mode"]
# Start the IPC Interface before anything else.. Just in case we are
# already running.
self.queuedtorrents = QueuedTorrents()
self.ipcinterface = IPCInterface(args)
# Initialize gdk threading
gtk.gdk.threads_init()
# We make sure that the UI components start once we get a core URI
client.set_disconnect_callback(self.__on_disconnect)
self.trackericons = TrackerIcons()
self.sessionproxy = SessionProxy()
# Initialize various components of the gtkui
self.mainwindow = MainWindow()
self.menubar = MenuBar()
self.toolbar = ToolBar()
self.torrentview = TorrentView()
self.torrentdetails = TorrentDetails()
self.sidebar = SideBar()
self.filtertreeview = FilterTreeView()
self.preferences = Preferences()
self.systemtray = SystemTray()
self.statusbar = StatusBar()
self.addtorrentdialog = AddTorrentDialog()
# Initalize the plugins
self.plugins = PluginManager()
# Late import because of setting up translations
from connectionmanager import ConnectionManager
# Show the connection manager
self.connectionmanager = ConnectionManager()
from twisted.internet.task import LoopingCall
rpc_stats = LoopingCall(self.print_rpc_stats)
rpc_stats.start(10)
reactor.callWhenRunning(self._on_reactor_start)
# Initialize gdk threading
gtk.gdk.threads_enter()
reactor.run()
self.shutdown()
gtk.gdk.threads_leave()
def __init__(self):
gtk.Window.__init__(self)
self.set_size_request(640, 480)
self.set_default_size(1366, 768)
#self.set_default_size(800, 600)
self.winstate = 0
self.maximize()
self.connect("delete-event", self.quit)
self.bindings = gtk.AccelGroup()
self.add_accel_group(self.bindings)
self.setup = gtk.PageSetup()
self.settings = gtk.PrintSettings()
self.filename = None
self.update_title()
icon = gtk.gdk.pixbuf_new_from_file(
os.path.join(os.path.dirname(__file__), "..", "images",
"canvas-logo.png"))
self.set_icon(icon)
vbox = gtk.VBox()
self.add(vbox)
self.menu = MenuBar(self)
vbox.pack_start(self.menu, False, False)
self.menu.append_menu("_" + _("File"))
self.menu.append_item(gtk.STOCK_NEW, "new", "<Control>N")
self.menu.append_item(gtk.STOCK_OPEN, "open", "<Control>O")
self.menu.append_item(gtk.STOCK_SAVE, "save", "<Control>S")
self.menu.append_item(gtk.STOCK_SAVE_AS, "save-as",
"<Control><Shift>S")
self.menu.append_separator()
self.menu.append_item(gtk.STOCK_PAGE_SETUP, "page-setup")
self.menu.append_item(gtk.STOCK_PRINT_PREVIEW, "print-preview",
"<Control><Shift>P")
self.menu.append_item(gtk.STOCK_PRINT, "print", "<Control>P")
self.menu.append_separator()
self.menu.append_menu("_" + _("Document"), True)
self.menu.append_item(SET_BACKGROUND, "set-background")
self.menu.ascend()
self.menu.append_separator()
self.menu.append_menu("_" + _("Export"), True)
self.menu.append_item(EXPORT_TO_PDF, "export-to-pdf")
self.menu.ascend()
self.menu.append_separator()
self.menu.append_item(gtk.STOCK_QUIT, "quit", "<Control>Q")
self.menu.append_menu("_" + _("Edit"))
self.menu.append_item(gtk.STOCK_UNDO, "undo", "<Control>Z")
self.menu.append_item(gtk.STOCK_REDO, "redo", "<Control>Y")
self.menu.append_separator()
self.menu.append_item(gtk.STOCK_COPY, "copy", "<Control>C")
self.menu.append_item(gtk.STOCK_CUT, "cut", "<Control>X")
self.menu.append_item(gtk.STOCK_PASTE, "paste", "<Control>V")
self.menu.append_separator()
self.menu.append_item(gtk.STOCK_DELETE, "delete", "Delete")
self.menu.append_separator()
self.menu.append_item(gtk.STOCK_SELECT_ALL, "select-all", "<Control>A")
self.menu.append_menu("_" + _("View"))
self.menu.append_toggle(MARGINS_ENABLED, "margins")
self.menu.append_toggle(GRID, "grid")
self.menu.append_toggle(GUIDES, "guides")
self.menu.append_toggle(SNAP_ENABLED, "snap")
self.menu.append_toggle(_("Z-Order hint"), "hints", toggled=False)
self.menu.append_separator()
self.menu.append_toggle(gtk.STOCK_PROPERTIES, "properties")
self.menu.append_toggle(_("Menubar"), "menubar")
self.menu.append_toggle(_("Statusbar"), "statusbar")
self.menu.append_menu("_" + _("Insert"))
self.menu.append_item(LINE, "line")
self.menu.append_item(ARC, "arc")
self.menu.append_item(CURVE, "curve")
self.menu.append_item(CONNECTOR, "connector")
self.menu.append_menu(BOX, "box", True)
self.menu.append_item(BOX, "box")
self.menu.append_item(SPLIT_HORIZONTALLY, "split-horizontally")
self.menu.append_item(SPLIT_VERTICALLY, "split-vertically")
self.menu.append_item(REMOVE_SPLIT, "remove-split")
self.menu.ascend()
self.menu.append_item(ROUNDED_BOX, "rounded-box")
self.menu.append_item(TEXT, "text")
self.menu.append_item(TABLE, "table")
self.menu.append_item(CHART, "chart")
self.menu.append_item(BARCODE, "barcode")
self.menu.append_item(IMAGE, "image")
self.menu.append_menu("_" + _("Format"))
self.menu.append_item(gtk.STOCK_SELECT_FONT, "select-font")
self.menu.append_separator()
self.menu.append_item(gtk.STOCK_SELECT_COLOR, "select-color")
self.menu.append_menu("_" + _("Tools"))
self.menu.append_item(GROUP, "group", "<Control>G")
self.menu.append_item(UNGROUP, "ungroup", "<Control><Shift>G")
self.menu.append_separator()
self.menu.append_item(BRING_TO_FRONT, "bring-to-front",
"<Control>plus")
self.menu.append_item(BRING_TO_BACK, "bring-to-back", "<Control>minus")
self.menu.append_separator()
self.menu.append_menu("_" + _("Zoom"), True)
self.menu.append_item(gtk.STOCK_ZOOM_FIT, "zoom-fit", "<Control>0")
self.menu.append_item(gtk.STOCK_ZOOM_100, "zoom-100", "<Control>1")
self.menu.append_item(gtk.STOCK_ZOOM_IN, "zoom-in",
"<Control><Shift>plus")
self.menu.append_item(gtk.STOCK_ZOOM_OUT, "zoom-out",
"<Control><Shift>minus")
self.menu.ascend()
self.menu.append_separator()
self.menu.append_menu("_" + _("Objects alignment"), True)
self.menu.append_item(ALIGN_OBJECTS_NORTHWEST,
"align-objects-northwest")
self.menu.append_item(ALIGN_OBJECTS_NORTH, "align-objects-north")
self.menu.append_item(ALIGN_OBJECTS_NORTHEAST,
"align-objects-northeast")
self.menu.append_item(ALIGN_OBJECTS_SOUTHWEST,
"align-objects-southwest")
self.menu.append_item(ALIGN_OBJECTS_SOUTH, "align-objects-south")
self.menu.append_item(ALIGN_OBJECTS_SOUTHEAST,
"align-objects-southeast")
self.menu.append_item(ALIGN_OBJECTS_WEST, "align-objects-west")
self.menu.append_item(ALIGN_OBJECTS_CENTER_BOTH,
"align-objects-center-both")
self.menu.append_item(ALIGN_OBJECTS_EAST, "align-objects-east")
self.menu.append_item(ALIGN_OBJECTS_CENTER_HORIZONTAL,
"align-objects-center-horizontal")
self.menu.append_item(ALIGN_OBJECTS_CENTER_VERTICAL,
"align-objects-center-vertical")
self.menu.ascend()
self.menu.append_menu("_" + _("Paper alignment"), True)
self.menu.append_item(ALIGN_PAPER_NORTHWEST, "align-paper-northwest")
self.menu.append_item(ALIGN_PAPER_NORTH, "align-paper-north")
self.menu.append_item(ALIGN_PAPER_NORTHEAST, "align-paper-northeast")
self.menu.append_item(ALIGN_PAPER_SOUTHWEST, "align-paper-southwest")
self.menu.append_item(ALIGN_PAPER_SOUTH, "align-paper-south")
self.menu.append_item(ALIGN_PAPER_SOUTHEAST, "align-paper-southeast")
self.menu.append_item(ALIGN_PAPER_WEST, "align-paper-west")
self.menu.append_item(ALIGN_PAPER_CENTER_BOTH,
"align-paper-center-both")
self.menu.append_item(ALIGN_PAPER_EAST, "align-paper-east")
self.menu.append_item(ALIGN_PAPER_CENTER_HORIZONTAL,
"align-paper-center-horizontal")
self.menu.append_item(ALIGN_PAPER_CENTER_VERTICAL,
"align-paper-center-vertical")
self.menu.ascend()
self.menu.append_menu("_" + _("Window"))
self.menu.append_item(gtk.STOCK_FULLSCREEN, "fullscreen", "<Control>F")
self.menu.append_menu("_" + _("Help"), right=True)
self.menu.append_item(gtk.STOCK_HELP, "help", "F1")
self.menu.append_separator()
self.menu.append_item(gtk.STOCK_ABOUT, "about")
self.menu.show_all()
htoolbar = Toolbar(HORIZONTAL)
vbox.pack_start(htoolbar, False, False)
htoolbar.append(gtk.STOCK_NEW, "new")
htoolbar.append(gtk.STOCK_OPEN, "open")
htoolbar.append(gtk.STOCK_SAVE, "save")
htoolbar.append_separator()
htoolbar.append(gtk.STOCK_PRINT, "print")
htoolbar.append_separator()
htoolbar.append(gtk.STOCK_UNDO, "undo")
htoolbar.append(gtk.STOCK_REDO, "redo")
htoolbar.append_separator()
htoolbar.append(gtk.STOCK_CUT, "cut")
htoolbar.append(gtk.STOCK_COPY, "copy")
htoolbar.append(gtk.STOCK_PASTE, "paste")
htoolbar.append_separator()
htoolbar.append(gtk.STOCK_DELETE, "delete")
htoolbar.append_separator()
htoolbar.append_with_submenu(LINE_STYLE_CONTINUOUS,
"line-style-continuous")
htoolbar.append_to_submenu(LINE_STYLE_POINT_DASH,
"line-style-point-dash")
htoolbar.append_to_submenu(LINE_STYLE_POINT, "line-style-point")
htoolbar.append_to_submenu(LINE_STYLE_DASH, "line-style-dash")
htoolbar.append_separator()
htoolbar.append_with_submenu(gtk.STOCK_ZOOM_FIT, "zoom-fit")
htoolbar.append_to_submenu(gtk.STOCK_ZOOM_100, "zoom-100")
htoolbar.append_to_submenu(gtk.STOCK_ZOOM_IN, "zoom-in")
htoolbar.append_to_submenu(gtk.STOCK_ZOOM_OUT, "zoom-out")
htoolbar.append_separator()
htoolbar.append_toggle(MARGINS_ENABLED, "margins")
htoolbar.append_toggle(GRID, "grid")
htoolbar.append_toggle(GUIDES, "guides")
htoolbar.append_toggle(SNAP_ENABLED, "snap")
htoolbar.append_separator()
htoolbar.append(EXPORT_TO_PDF, "export-to-pdf")
htoolbar.append_separator()
htoolbar.append_toggle(GROUP, "group")
htoolbar.append_separator()
htoolbar.append(BRING_TO_FRONT, "bring-to-front")
htoolbar.append(BRING_TO_BACK, "bring-to-back")
htoolbar.append_separator()
htoolbar.append_with_submenu(ALIGN_OBJECTS_CENTER_BOTH,
"align-object-center-both")
htoolbar.append_to_submenu(ALIGN_OBJECTS_NORTHWEST,
"align-object-northwest")
htoolbar.append_to_submenu(ALIGN_OBJECTS_NORTH, "align-object-north")
htoolbar.append_to_submenu(ALIGN_OBJECTS_SOUTHWEST,
"align-object-southwest")
htoolbar.append_to_submenu(ALIGN_OBJECTS_NORTHEAST,
"align-object-northeast")
htoolbar.append_to_submenu(ALIGN_OBJECTS_SOUTH, "align-object-south")
htoolbar.append_to_submenu(ALIGN_OBJECTS_SOUTHEAST,
"align-object-southeast")
htoolbar.append_to_submenu(ALIGN_OBJECTS_WEST, "align-object-west")
htoolbar.append_to_submenu(ALIGN_OBJECTS_EAST, "align-object-east")
htoolbar.append_to_submenu(ALIGN_OBJECTS_CENTER_HORIZONTAL,
"align-object-center-horizontal")
htoolbar.append_to_submenu(ALIGN_OBJECTS_CENTER_VERTICAL,
"align-object-center-vertical")
htoolbar.append_with_submenu(ALIGN_PAPER_CENTER_BOTH,
"align-paper-center-both")
htoolbar.append_to_submenu(ALIGN_PAPER_NORTHWEST,
"align-paper-northwest")
htoolbar.append_to_submenu(ALIGN_PAPER_NORTH, "align-paper-north")
htoolbar.append_to_submenu(ALIGN_PAPER_SOUTHWEST,
"align-paper-southwest")
htoolbar.append_to_submenu(ALIGN_PAPER_NORTHEAST,
"align-paper-northeast")
htoolbar.append_to_submenu(ALIGN_PAPER_SOUTH, "align-paper-south")
htoolbar.append_to_submenu(ALIGN_PAPER_SOUTHEAST,
"align-paper-southeast")
htoolbar.append_to_submenu(ALIGN_PAPER_WEST, "align-paper-west")
htoolbar.append_to_submenu(ALIGN_PAPER_EAST, "align-paper-east")
htoolbar.append_to_submenu(ALIGN_PAPER_CENTER_HORIZONTAL,
"align-paper-center-horizontal")
htoolbar.append_to_submenu(ALIGN_PAPER_CENTER_VERTICAL,
"align-paper-center-vertical")
htoolbar.append_separator()
htoolbar.append(gtk.STOCK_HELP, "help")
hbox = gtk.HBox()
vbox.add(hbox)
vtoolbar = Toolbar()
vtoolbar.set_style(gtk.TOOLBAR_ICONS)
hbox.pack_start(vtoolbar, False, False)
vtoolbar.append(LINE, "line")
vtoolbar.append(ARC, "arc")
vtoolbar.append(CURVE, "curve")
vtoolbar.append(CONNECTOR, "connector")
vtoolbar.append_with_submenu(BOX, "box")
vtoolbar.append_to_submenu(SPLIT_HORIZONTALLY, "split-horizontally")
vtoolbar.append_to_submenu(SPLIT_VERTICALLY, "split-vertically")
vtoolbar.append_to_submenu(REMOVE_SPLIT, "remove-split")
vtoolbar.append(ROUNDED_BOX, "rounded-box")
vtoolbar.append(TEXT, "text")
vtoolbar.append(BARCODE, "barcode")
vtoolbar.append(TABLE, "table")
vtoolbar.append(CHART, "chart")
vtoolbar.append(IMAGE, "image")
notebook = gtk.Notebook()
notebook.set_show_tabs(True)
notebook.set_show_border(False)
#notebook.set_tab_pos(gtk.POS_LEFT)
notebook.set_tab_pos(gtk.POS_RIGHT)
hbox.add(notebook)
self.status = Statusbar()
self.id = self.status.get_context_id(_("Edit mode"))
vbox.pack_start(self.status, False, False)
label = gtk.Label(_("Design view"))
label.set_angle(90)
self.editor = Editor(self)
self.editor.set_paper()
notebook.append_page(self.editor, label)
label = gtk.Label(_("XML view"))
label.set_angle(90)
def get_source_view():
source = gtk.ScrolledWindow()
source.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
view = gtk.TextView()
self.code = gtk.TextBuffer()
view.set_buffer(self.code)
source.add(view)
return source
if '--source-editor-test' in sys.argv:
while True:
try:
from ui.code_editor import SourcePad
except:
source = get_source_view()
break
source = SourcePad(self)
self.code = source.buffer
source.set_language("xml")
break
else:
source = get_source_view()
notebook.append_page(source, label)
self.menu.connect("new", self.new)
self.menu.connect("open", self.open)
self.menu.connect("save", self.save)
self.menu.connect("save-as", self.save_as)
self.menu.connect("page-setup", self.page_setup)
self.menu.connect("export-to-pdf", self.export_to_pdf)
self.menu.connect("set-background", self.set_background)
self.menu.connect("quit", self.quit)
self.menu.connect("cut", self.editor.canvas.cut)
self.menu.connect("copy", self.editor.canvas.copy)
self.menu.connect("paste", self.editor.canvas.paste)
self.menu.connect("delete", self.editor.canvas.delete)
self.menu.connect("select-all", self.editor.canvas.select_all)
self.menu.connect("margins", self.editor.canvas.toggle_margins)
self.menu.connect("grid", self.editor.canvas.toggle_grid)
self.menu.connect("guides", self.editor.canvas.toggle_guides)
self.menu.connect("snap", self.editor.canvas.toggle_snap)
self.menu.connect("hints", self.editor.canvas.toggle_hints)
self.menu.connect("properties", self.editor.toggle_properties)
self.menu.connect("menubar", self.toggle_menubar)
self.menu.connect("statusbar", self.toggle_statusbar)
self.menu.connect("bring-to-front", self.editor.canvas.bring_to_front)
self.menu.connect("bring-to-back", self.editor.canvas.bring_to_back)
self.menu.connect("align-paper-center-horizontal",
self.editor.canvas.paper_center_horizontal)
self.menu.connect("line", self.create, "Line")
self.menu.connect("curve", self.create, "Curve")
self.menu.connect("connector", self.create, "Connector")
self.menu.connect("box", self.create, "Box")
self.menu.connect("rounded-box", self.create, "Rounded")
self.menu.connect("text", self.create, "Text")
self.menu.connect("barcode", self.create, "BarCode")
self.menu.connect("table", self.create, "Table")
self.menu.connect("image", self.create, "Image")
self.menu.connect("chart", self.create, "Chart")
self.menu.connect("fullscreen", self.fullscreen)
self.menu.connect("about", self.about)
self.menu.connect("help", self.help)
self.menu.connect("split-horizontally",
self.editor.canvas.split_horizontally)
self.menu.connect("split-vertically",
self.editor.canvas.split_vertically)
self.menu.connect("remove-split", self.editor.canvas.remove_split)
htoolbar.connect("new", self.new)
htoolbar.connect("open", self.open)
htoolbar.connect("save", self.save)
htoolbar.connect("snap", self.editor.canvas.toggle_snap)
htoolbar.connect("grid", self.editor.canvas.toggle_grid)
htoolbar.connect("guides", self.editor.canvas.toggle_guides)
htoolbar.connect("margins", self.editor.canvas.toggle_margins)
htoolbar.connect("cut", self.editor.canvas.cut)
htoolbar.connect("copy", self.editor.canvas.copy)
htoolbar.connect("paste", self.editor.canvas.paste)
htoolbar.connect("delete", self.editor.canvas.delete)
htoolbar.connect("bring-to-front", self.editor.canvas.bring_to_front)
htoolbar.connect("bring-to-back", self.editor.canvas.bring_to_back)
htoolbar.connect("export-to-pdf", self.export_to_pdf)
htoolbar.connect("help", self.help)
vtoolbar.connect("line", self.create, "Line")
vtoolbar.connect("arc", self.create, "Arc")
vtoolbar.connect("curve", self.create, "Curve")
vtoolbar.connect("connector", self.create, "Connector")
vtoolbar.connect("box", self.create, "Box")
vtoolbar.connect("rounded-box", self.create, "Rounded")
vtoolbar.connect("text", self.create, "Text")
vtoolbar.connect("barcode", self.create, "BarCode")
vtoolbar.connect("table", self.create, "Table")
vtoolbar.connect("image", self.create, "Image")
vtoolbar.connect("chart", self.create, "Chart")
vtoolbar.connect("split-horizontally",
self.editor.canvas.split_horizontally)
vtoolbar.connect("split-vertically",
self.editor.canvas.split_vertically)
vtoolbar.connect("remove-split", self.editor.canvas.remove_split)
notebook.connect("switch-page", self.switch)
self.connect("key-press-event", self.key_press)
def main():
''' The main method :o '''
global PI_CLIENT
global PI_CLIENT_CONNECTED
global IS_RUNNING
joysticks = [
pygame.joystick.Joystick(x) for x in range(pygame.joystick.get_count())
]
PRINT('Found ' + ENC_VALUE(len(joysticks)) + ' joysticks.', INFO)
# Initialize detected joysticks
if len(joysticks) > 0:
for joystick in joysticks:
joystick.init()
PRINT(
'| ' + ENC_VALUE(joystick.get_id()) + ' ' +
ENC_VALUE(joystick.get_name()), INFO)
screen = pygame.display.set_mode(SCREEN_DIMENSION, pygame.RESIZABLE)
screen.set_alpha(None)
pygame.display.set_caption('LoggerheadROV Driver Station | ' +
random.choice(QUOTES))
pygame.display.set_icon(
pygame.image.load('gui/images/loggerhead_logo.png'))
clock = pygame.time.Clock()
horizon = Horizon(
screen.get_size()[0] - GAUGE_DIMENSION - UI_SCREEN_PADDING - UI_BORDER,
screen.get_size()[1] - GAUGE_DIMENSION - UI_SCREEN_PADDING - UI_BORDER)
menubar = MenuBar(screen, FONT)
menubar.add_app(App("Do Thing", menubar))
menubar.add_app(App("Do Other Thing", menubar))
folder = App("Image Recognition", menubar, is_folder=True)
folder.add_app(App("More Things", folder.sub_app_menubar))
menubar.add_app(folder)
# Create thread for the connection handler loop
connection_handler = Thread(target=connection_listener, args=(joysticks, ))
connection_handler.start()
while IS_RUNNING:
mouse_data = [False] * len(pygame.mouse.get_pressed())
key_data = [False] * len(pygame.key.get_pressed())
for event in pygame.event.get():
if event.type == pygame.QUIT:
shutdown()
if event.type == pygame.VIDEORESIZE:
screen = pygame.display.set_mode((event.w, event.h),
pygame.RESIZABLE)
horizon = Horizon(
screen.get_size()[0] - GAUGE_DIMENSION -
UI_SCREEN_PADDING - UI_BORDER,
screen.get_size()[1] - GAUGE_DIMENSION -
UI_SCREEN_PADDING - UI_BORDER)
menubar.resize()
if event.type == pygame.KEYDOWN:
key_data = pygame.key.get_pressed()
if event.type == pygame.MOUSEBUTTONDOWN:
mouse_data = pygame.mouse.get_pressed()
mouse_pos = pygame.mouse.get_pos()
screen.fill(UI_COLOR_4)
if PI_CLIENT_CONNECTED:
try:
# Get the video frame from the client and decode it
frame = cv2.imdecode(PI_CLIENT.recv_data[DATA_IDX_VIDEO],
cv2.IMREAD_COLOR)
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
frame = np.rot90(frame)
frame = cv2.flip(frame, 1)
frame = pygame.surfarray.make_surface(frame)
frame = pygame.transform.scale(frame, screen.get_size())
screen.blit(frame, (0, 0))
# cv2.imshow('frame', frame)
except:
pass
menubar.update(mouse_data, key_data)
# horizon.update(screen, mouse_pos[0] - (screen.get_size()[0] / 2), mouse_pos[1] - (screen.get_size()[1] / 2)) # Draws gauge too
menubar.draw()
draw_text(screen, FONT,
str(round(clock.get_fps(), 3)) + ' FPS',
(screen.get_size()[0] -
(UI_SCREEN_PADDING * 8), UI_SCREEN_PADDING), False)
pygame.display.update()
clock.tick(FPS)
cv2.destroyAllWindows()
connection_handler.join()
PRINT('Quit.', SUCCESS)
def initUI(self):
#start geometrie
self.width = 1200
self.height = 800
self.desktop = QApplication.desktop()
self.desktop_size = QRect()
self.desktop_size = self.desktop.screenGeometry()
self.miner = Miner()
self.miner.startMine()
self.logger = logging.getLogger()
self.logger.setLevel(self.log_level)
self.log_date = datetime.datetime.now()
log_date_str = self.log_date.strftime('%Y_%m_%d')
month = self.log_date.strftime('%b')
year = self.log_date.strftime('%Y')
home_dict = str(Path.home())
file_path = '{}/Pythonics_{}/{}/log_{}.txt'.format(
home_dict, year, month, log_date_str)
self.ensure_file_path(file_path)
file_handler = logging.FileHandler(file_path)
file_handler.setLevel(self.log_level)
file_handler.setFormatter(self.formatter)
self.logger.addHandler(file_handler)
# init language !
self.translator = QTranslator(self.app)
#self.translator.load('translations/spanish_es')
self.translator.load('translations/english_en.qm')
self.app.installTranslator(self.translator)
#QC.installTranslator(self.translator)
logging.debug('Translation: {}'.format(QC.translate('', 'Save')))
# setup the default language here
#self.changeTranslator('german_de.qm')
self.x_position = self.desktop_size.width() / 2 - self.width / 2
self.y_position = self.desktop_size.height() / 2 - self.height / 2
self.setAcceptDrops(True)
self.layout_v = QVBoxLayout()
# main_layout contains the workingarea and the toolbox
self.main_layout = QVBoxLayout()
self.main_layout.setSpacing(0)
self.main_layout.setContentsMargins(0, 0, 0, 0)
self.bottom_border_layout = QHBoxLayout()
self.bottom_border_layout.setSpacing(0)
self.setContentsMargins(0, 0, 0, 0)
# create class objects
#self.exceptwindow = ExceptWindow(self)
#self.working_area = WorkingArea(self)
self.working_area = WorkingArea()
self.menubar = MenuBar()
self.toolbox_tab = QTabWidget()
self.toolbox_tab.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Preferred)
self.topMenuBar = topMenuBar()
self.settings = Settings()
self.infoWindow = InfoWindow()
self.gridoperator = GridOperator(self.working_area.grid)
self.toolbox_basics = BasicTools(self)
self.toolbox_binance = BinanceTools(self)
# add Tabs to the toolbox
self.toolbox_tab.addTab(self.toolbox_basics, 'Basic')
self.toolbox_tab.addTab(self.toolbox_binance, 'Binance')
# signals and slots
self.menubar.save_file.connect(self.working_area.saveGrid)
self.menubar.load_file.connect(self.working_area.loadGrid)
self.menubar.set_info_text.connect(self.setInfoText)
self.menubar.start_debug.connect(self.startDebug)
self.menubar.start_exec.connect(self.startExec)
self.menubar.clear_grid.connect(self.working_area.setupDefault)
self.menubar.stop_exec.connect(self.gridoperator.stop_execution)
self.topMenuBar.switch_language.connect(self.changeTranslator)
self.topMenuBar.close_signal.connect(self.closeEvent)
self.topMenuBar.open_action.triggered.connect(
self.menubar.openFileNameDialog)
self.topMenuBar.save_action.triggered.connect(self.menubar.simpleSave)
self.topMenuBar.save_as_action.triggered.connect(
self.menubar.saveFileDialog)
self.topMenuBar.new_action.triggered.connect(self.menubar.saveQuestion)
self.topMenuBar.settings_action.triggered.connect(self.settings.show)
self.topMenuBar.info_action.triggered.connect(self.showInfo)
self.toolbox_binance.reg_tool.connect(self.working_area.regType)
self.toolbox_basics.reg_tool.connect(self.working_area.regType)
self.gridoperator.update_logger.connect(self.update_logfile)
# register tools
self.toolbox_binance.register_tools()
self.toolbox_basics.register_tools()
self.image_folder = QDir('images')
if not self.image_folder.exists():
logging.error('Image foulder not found')
pself.miner.stopMine()
sys.exit(0)
self.scrollArea = QScrollArea()
self.scrollArea.setWidget(self.working_area)
self.scrollArea.setWidgetResizable(True)
self.scrollArea.setMinimumSize(300, 300)
self.layout_v.addWidget(self.topMenuBar)
self.layout_v.addWidget(self.menubar)
self.layout_v.addWidget(self.toolbox_tab)
self.layout_v.addWidget(self.scrollArea)
self.main_widget = QWidget()
self.main_widget.setLayout(self.layout_v)
# add main widget to main layout
self.main_layout.addWidget(self.main_widget, 0)
self.main_layout.setSpacing(0)
# resize button
self.sizeGrip = QSizeGrip(self.main_widget)
# bottom info text
self.infoText = QLabel()
self.infoText.setText('')
# define the bottom border line
self.bottom_border_layout.addWidget(self.infoText)
self.bottom_border_layout.setSpacing(0)
# left, top, right, bottom
self.bottom_border_layout.setContentsMargins(5, 0, 5, 5)
self.bottom_border_layout.addWidget(self.sizeGrip, 0, Qt.AlignRight)
self.bottom_border = QWidget()
self.bottom_border.setLayout(self.bottom_border_layout)
self.main_layout.addWidget(self.bottom_border)
self.setLayout(self.main_layout)
self.setGeometry(self.x_position, self.y_position, self.width,
self.height)
