Example #1
0
 def __init__(self,
              parent=None,
              title="PocketPyGui",
              action=None,
              menu=None,
              tab_traversal=True,
              visible=True,
              enabled=True,
              has_sip=True,
              has_toolbar=False):
     '''\
     Arguments :
         - parent: the parent window of this CeFrame.
         - title: the title as appearing in the title bar.
         - action : a tuple ('Label', callback) .
         - menu : the title of the right menu as a string
                  if not None, the menu can be filled via the cb_menu attribute
                  after CeFrame initialization.
     '''
     Frame.__init__(self,
                    parent,
                    title,
                    tab_traversal=tab_traversal,
                    visible=visible,
                    enabled=enabled)
     self.bind(_activate=self._on_activate,
               _settingchanged=self._on_setting_changed)
     if has_toolbar:
         self.toolbar = ToolBar(self)
     else:
         self.toolbar = None
     self.__create_menubar(action, menu, has_sip)
Example #2
0
    def __init__(self, parent=None):
        super(AfelApp, self).__init__(parent)
        self.setGeometry(10, 10, 1000, 1200)
        # self.setStyleSheet("""
        #
        #              font-size: 200;
        #
        #         """)
        # Flags
        self.modes = {
            'outer_window': True,
            'live_mode': False
        }

        self.result_box_group = None
        self.result_box = None

        self.module_btns = []

        mainWindow = QWidget(self)
        self.setCentralWidget(mainWindow)
        mainlay = QHBoxLayout()

        mainWindow.setLayout(mainlay)

        #  load area
        btns_group = QGroupBox()
        btns_lay = QVBoxLayout()
        btns_group.setLayout(btns_lay)
        btns_lay.addStretch(1)
        self.btns_lay = btns_lay

        self.load_modules_btns()

        startbtn = QPushButton('start process')
        startbtn.clicked.connect(self.start_process)
        btns_lay.addWidget(startbtn)



        #  sandbox area
        self.sandbox = SandBox()
        self.sandboxlay = QVBoxLayout()
        # self.sandboxlay.addStretch(209)
        self.sandbox.setLayout(self.sandboxlay)

        mainlay.addWidget(btns_group,1)
        mainlay.addWidget(self.sandbox,10)

        # toolbar
        # toolbar.setIconSize(QSize(16, 16))
        self.toolbar = ToolBar(self)
        self.addToolBar(self.toolbar)
Example #3
0
	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):
        tk.Tk.__init__(self)
        self.filename = None
        self.origin_image = None
        self.processed_image = None
        
        self.title("Segmentation and Edge Detection")

        self.toolbar = ToolBar(master=self)
        separator = ttk.Separator(master=self)
        self.image_viewer = Viewer(master=self)

        self.toolbar.pack(pady=10)
        separator.pack(fill=tk.X, padx=20, pady=5)
        self.image_viewer.pack(fill=tk.BOTH, padx=20, pady=10, expand=1)
Example #5
0
File: ce.py Project: BitBldr/loxodo
 def __init__(self, parent=None, 
                    title="PocketPyGui", 
                    action=None, 
                    menu=None,
                    right_action=None, 
                    tab_traversal=True, 
                    visible=True, 
                    enabled=True, 
                    has_sip=True, 
                    has_toolbar=False):
     '''\
     Arguments :
         - parent: the parent window of this CeFrame.
         - title: the title as appearing in the title bar.
         - action : a tuple ('Label', callback) .
         - menu : the title of the right menu as a string
                  if not None, the menu can be filled via the cb_menu attribute
                  after CeFrame initialization.
     '''
     Frame.__init__(self, parent, title, tab_traversal=tab_traversal, visible=visible, enabled=enabled)
     self.bind(_activate=self._on_activate,
               _settingchanged=self._on_setting_changed,
               size=self._on_size)
     if has_toolbar :
         self.toolbar = ToolBar(self)
     else:
         self.toolbar = None
     self.__create_menubar(action, menu, right_action, has_sip)
Example #6
0
    def __init__(self, parent=None):
        super(MainWindow, self).__init__(parent)
        self.mdiArea = QMdiArea(self)
        self.setCentralWidget(self.mdiArea)
        self.mainMenu = QMenuBar(self)
        self.setMenuBar(self.mainMenu)
        m = self.mainMenu.addMenu("Window")
        a = m.addAction("Cascade windows")
        a.triggered.connect(self.mdiArea.cascadeSubWindows)

        self.treePanel = QDockWidget("Дерево задач", self)
        w = QWidget(self.treePanel)
        lay = QVBoxLayout(w)
        lay.setSpacing(1)
        lay.setContentsMargins(1, 1, 1, 1)
        w.setLayout(lay)
        self.tree = TreeWidget(self.treePanel)
        lay.addWidget(self.tree)
        edit = QTextEdit(w)
        lay.addWidget(edit)

        self.treePanel.setWidget(w)
        self.tree.activated.connect(self.handle_dblclick)
        self.addDockWidget(Qt.LeftDockWidgetArea, self.treePanel)

        self.tools = ToolBar("tools.ini", self)
        self.addToolBar(self.tools)
 def _build_widgets(self):
     """Builds own widgets."""
     
     self.lastActiveLayer = None
     self._disconnect_connect_from_to_iface()
     self.iface.currentLayerChanged.connect(
         self._disconnect_connect_from_to_iface)
     
     QgsMapLayerRegistry.instance().legendLayersAdded.connect(
         self._check_added_perimeter_layer)
     
     self.toolBar = ToolBar(
         self, self.dWName, self.iface, self.pluginDir)
     self.gridLayout.addWidget(self.toolBar, 0, 0, 1, 1)
     
     self.statusBar = StatusBar(
         self, self.dWName, self.iface, self.pluginDir)
     self.gridLayout.addWidget(self.statusBar, 2, 0, 1, 1)
     
     self.frame = QFrame(self)
     self.frame.setObjectName(u'frame')
     self.frame.setFrameShape(QFrame.StyledPanel)
     self.frame.setFrameShadow(QFrame.Raised)
     self.gridLayout.addWidget(self.frame, 1, 0, 1, 1)
     
     self.stackedWidget = StackedWidget(
         self, self.dWName, self.iface, self.pluginDir)
     self.gridLayout.addWidget(self.stackedWidget, 1, 0, 1, 1)
Example #8
0
	def initGui(self, screen_width, screen_height):
		bar_height = 30

		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))
		
		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
		
		# 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()
Example #9
0
    def __init__(self, *args, **kwargs):

        super(MainWindow, self).__init__(*args, **kwargs)

        self.setWindowTitle("Ini Editor")
        self.initMenu()

        self.docks = []

        self.statusBar()

        self.toolbar = ToolBar()
        self.addToolBar(self.toolbar)

        self.show()
Example #10
0
    def __init__(self, master=None, periodeManager=None, **kwargs):
        """
        Constructeur de CalendarZone.
        @param master: master du tkinter.Frame() que cet objet est.
        @param periodeManager: le PeriodeManager pour la barre d'outil des périodes, connue dans cet objet.
        @param **kwargs: Les options d'affichages pour le tkinter.Frame() que cet objet est.
        """
        Frame.__init__(self, master, **kwargs)
        # Note : self.master est référence vers l'Application.

        self.__isBarrePeriode = False
        # Barre du haut
        self.outilBar = ToolBar(self)  # frame avec tous les boutons outils
        self.outilBar.pack(side=TOP, fill=X, expand=NO)

        # Barre du haut pour les périodes
        self.outilBarPeriode = PeriodToolBar(
            self, periodeManager)  # frame avec tous les boutons outils

        # Zone calendrier
        self.zoneDynamicCalendarFrame = ZoneAffichage(
            self
        )  # frame avec la zone d'affichage des paramètre et la zone avec les données
        self.zoneDynamicCalendarFrame.pack(side=BOTTOM, fill=BOTH, expand=YES)
Example #11
0
    def __init__(self, tasksFile, parent=None):
        super(MainWindow, self).__init__(parent)
        self.mdiArea = QMdiArea(self)
        self.setCentralWidget(self.mdiArea)
        self.mainMenu = QMenuBar(self)
        self.setMenuBar(self.mainMenu)
        m = self.mainMenu.addMenu("Window")
        a = m.addAction("Cascade windows")
        a.triggered.connect(self.mdiArea.cascadeSubWindows)

        self.treePanel = QDockWidget("Дерево задач", self)
        w = QWidget(self.treePanel)
        lay = QVBoxLayout(w)
        lay.setSpacing(1)
        lay.setContentsMargins(1, 1, 1, 1)
        w.setLayout(lay)
        self.tree = TreeWidget(self.treePanel)
        lay.addWidget(self.tree)

        self.treePanel.setWidget(w)
        self.tree.activated.connect(self.handle_dblclick)
        self.addDockWidget(Qt.LeftDockWidgetArea, self.treePanel)

        self.winsPanel = QDockWidget("Окна", self)
        self.winlist = WinList(self.winsPanel)
        self.winsPanel.setWidget(self.winlist)
        self.addDockWidget(Qt.LeftDockWidgetArea, self.winsPanel)
        global wins
        wins = self.winsPanel

        self.tools = ToolBar("data/tools.ini", self)
        self.addToolBar(self.tools)

        model = TreeModel(tasksFile)
        self.tree.setModel(model)
        self.tree.expandAll()
        self.tree.setColumnHidden(1, True)
        self.dataPath = os.path.split(tasksFile)[0]
Example #12
0
    def __setup_layout(self):
        """One time setup of the scene."""
        if not self.__need_setup:
            return
        stat_size = self.config['pyos']['status_size'].split(',')
        tool_size = self.config['pyos']['toolbar_size'].split(',')
        layout = TableLayout(self.config.getfloat('pyos', 'card_ratio'),
                             self.config.getfloat('pyos', 'padding'),
                             tuple([float(i) for i in stat_size]),
                             tuple([float(i) for i in tool_size]))
        layout.root.reparent_to(self.root)

        hud = HUD(layout.status, tuple([float(i) for i in stat_size]),
                  self.config['font']['normal'], self.config['font']['bold'])

        toolbar = ToolBar(self.ui.bottom_center,
                          tuple([float(i) for i in tool_size]),
                          self.config['font']['bold'],
                          (self.__new_deal, self.__reset_deal, self.__undo_move,
                           self.__menu))
        game_table = Table(layout.callback)
        layout.set_table(game_table)
        self.__systems = GameSystems(game_table, layout, hud, toolbar)
        self.__need_setup = False
Example #13
0
    def initUI(self):
        #init Text edit
        self.textEdit = TextEdit(self)
        self.textEdit.textChanged.connect(self.textChanged)
        self.bTextChanged = False
        self.bTextSaved = True
        self.bCursorPosChanged = False
        #init Tool bar
        self.toolBar = ToolBar(self)
        initToolBar(self)
        #init textSplitter
        self.textSplitter = QSplitter(Qt.Horizontal, self)
        self.textSplitter.addWidget(self.textEdit)
        #init textBrowser
        self.bShowPW = False
        self.textBrowser = None
        #init timer
        self.timer = None

        #init layout
        self.centerVBox = QVBoxLayout()
        self.centerVBox.addWidget(self.textSplitter)
        self.centerVBox.addWidget(self.toolBar)
        self.centerVBox.setSpacing(0)
        self.centerVBox.setContentsMargins(0, 0, 0, 0)
        self.setLayout(self.centerVBox)

        #init tile
        self.updateWindowTitle()
        #init position
        screen = QDesktopWidget().screenGeometry()
        self.setGeometry(screen.width() / 4,
                         screen.height() / 6,
                         screen.width() / 2,
                         screen.height() * 2 / 3)
        self.show()
Example #14
0
class App(Frame):
    def __init__(self, master=None):
        self.master = master
        Frame.__init__(self, master, relief=SUNKEN, bd=2)

        self.gcode = []
        self.slicing = False
        self.printing = False
        self.connected = False
        self.monitorTemp = False
        self.paused = False
        self.sdpresent = False
        self.sdlisting = False
        self.sdchecking = False
        self.sdprinting = False
        self.sdpaused = False
        self.sduploading = False
        self.sdbytes = 0
        self.sdmaxbytes = 0
        self.insidelisting = False
        self.readingFirmware = False
        self.sdfiles = []
        self.bedtemp = float(0)
        self.bedtarget = float(0)
        self.exttemp = float(0)
        self.exttarget = float(0)
        self.acceleration = 0
        self.m114count = 0
        self.speedcount = 0
        self.location = [0, 0, 0, 0]
        self.pausePoint = [0, 0, 0, 0]
        self.percent = 0.0
        self.ets = "??"
        self.gcodeInfo = None
        self.GCodeFile = None
        self.StlFile = None
        self.Profile = None
        self.printStartLine = 0
        self.startTime = 0
        self.endTime = 0
        self.elapsedTime = 0
        self.FanSpeed = 0
        self.FeedMultiply = 100
        self.ExtrudeMultiply = 100

        self.timingReport = None
        self.filamentReport = None
        self.measurementsReport = None

        self.macroButtons = None

        self.rpt1re = re.compile(" *T:([0-9\.]+) *E:[0-9\.]+ *B:([0-9\.]+)")
        self.rpt2re = re.compile(" *T:([0-9\.]+) *E:[0-9\.]+ *W:.*")
        self.locrptre = re.compile("^X:([0-9\.\-]+)Y:([0-9\.\-]+)Z:([0-9\.\-]+)E:([0-9\.\-]+) *Count")
        self.speedrptre = re.compile("Fan speed:([0-9]+) Feed Multiply:([0-9]+) Extrude Multiply:([0-9]+)")

        self.sdre = re.compile("SD printing byte *([0-9]+) *\/ *([0-9]+)")

        self.printer = printcore()
        self.settings = Settings()
        self.settings.cmdFolder = cmd_folder
        self.logger = Logger(self)

        if self.settings.speedcommand is not None:
            allow_while_printing.append(self.settings.speedcommand)

        self.acceleration = self.settings.acceleration

        self.dataLoggers = {}
        for d in DLLIST:
            self.dataLoggers[d] = DataLogger(self, d)

        self.skeinforge = Skeinforge(self.settings)
        self.slic3r = Slic3r(self.settings)

        self.httpServer = RepRapServer(self, self.printer, self.settings, self.logger, self.settings.port)

        self.menubar = Menu(self)
        self.filemenu = Menu(self.menubar, tearoff=0)
        self.menubar.add_cascade(label="File", menu=self.filemenu)
        self.filemenu.add_command(label="Slice", command=self.openSTLFile)
        self.filemenu.add_command(label="Load GCode", command=self.openGCodeFile)
        self.slicemenuindex = self.filemenu.index("Slice")
        self.loadgcodemenuindex = self.filemenu.index("Load GCode")

        self.filemenu.add_separator()
        self.filemenu.add_command(label="Exit", command=self.quitApp)

        self.editmenu = Menu(self.menubar, tearoff=0)
        self.menubar.add_cascade(label="Edit", menu=self.editmenu)

        self.editmenu.add_command(label="Settings", command=self.editSettings)
        self.editmenu.add_command(label="Firmware Settings", command=self.FirmwareSettings)
        self.editmenu.add_separator()
        self.editmenu.add_command(label=GCODE_MENU_TEXT, command=self.doGEdit, state=DISABLED)

        self.slicermenu = Menu(self.menubar, tearoff=0)
        self.menubar.add_cascade(label="Slicer", menu=self.slicermenu)
        self.rbSlicer = StringVar()

        self.slicermenu.add_radiobutton(
            label="Skeinforge", command=self.selSlicer, value=SKEINFORGE, variable=self.rbSlicer
        )
        self.slicermenu.add_command(label="Settings", command=self.skeinforgeSettings)
        self.slicermenu.add_command(label="Choose Profile", command=self.chooseSFProfile)
        self.SFprofileindex = self.slicermenu.index("Choose Profile")
        self.setSFProfileMenuText()
        self.slicermenu.add_command(label="Alterations", command=self.doEditAlterations)

        self.slicermenu.add_separator()
        self.slicermenu.add_radiobutton(label="Slic3r", command=self.selSlicer, value=SLIC3R, variable=self.rbSlicer)
        self.slicermenu.add_command(label="Settings", command=self.slic3rSettings)
        self.slicermenu.add_command(label="Choose Profile", command=self.chooseS3Profile)
        self.S3profileindex = self.slicermenu.index("Choose Profile")
        self.setS3ProfileMenuText()

        self.rbSlicer.set(self.settings.slicer)

        self.macromenu = Menu(self.menubar, tearoff=0)
        self.menubar.add_cascade(label="Macros", menu=self.macromenu)
        self.macromenu.add_command(label="New", command=self.doNewMacro)
        self.macromenu.add_command(label="Edit", command=self.doEditMacro)
        self.macromenu.add_command(label="Delete", command=self.doDelMacro)
        self.macromenu.add_separator()
        self.cbShowMacroButtons = BooleanVar()
        self.cbShowMacroButtons.set(self.settings.showmacrobuttons)
        self.macromenu.add_checkbutton(
            label="Show Macro Buttons",
            command=self.doShowButtons,
            onvalue=True,
            offvalue=False,
            variable=self.cbShowMacroButtons,
        )
        self.macromenu.add_separator()
        self.runmacromenu = Menu(self.macromenu, tearoff=0)
        self.loadMacros()
        self.macromenu.add_cascade(label="Run", menu=self.runmacromenu)

        self.reportmenu = Menu(self.menubar, tearoff=0)
        self.menubar.add_cascade(label="View", menu=self.reportmenu)
        self.cbShowPrevious = BooleanVar()
        self.cbShowPrevious.set(self.settings.showprevious)
        self.reportmenu.add_checkbutton(
            label="Show Previous Layer",
            command=self.toggleShowPrevious,
            onvalue=True,
            offvalue=False,
            variable=self.cbShowPrevious,
        )
        self.cbShowMoves = BooleanVar()
        self.cbShowMoves.set(self.settings.showmoves)
        self.reportmenu.add_checkbutton(
            label="Show Non-extrusion Moves",
            command=self.toggleShowMoves,
            onvalue=True,
            offvalue=False,
            variable=self.cbShowMoves,
        )
        self.reportmenu.add_separator()
        self.reportmenu.add_command(label="Show Hours of Usage", command=self.doDataLogReport)
        self.reportmenu.add_command(label="Reset Hours of Usage", command=self.doDataLogReset)
        self.reportmenu.add_separator()
        self.reportmenu.add_command(label="Layer by Layer Timing", command=self.doTimingReport)
        self.reportmenu.add_command(label="Layer by Layer Filament Usage", command=self.doFilamentReport)
        self.reportmenu.add_command(label="GCode Measurements", command=self.doMeasurementsReport)

        self.toolsmenu = Menu(self.menubar, tearoff=0)
        n = 0
        if self.settings.platercmd is not None:
            n += 1
            self.toolsmenu.add_command(label="Plater", command=self.doPlater)

        if self.settings.gcodeviewcmd is not None:
            n += 1
            self.toolsmenu.add_command(label="GCode Viewer", command=self.doGCodeView)

        if self.settings.stlviewcmd is not None:
            n += 1
            self.toolsmenu.add_command(label="STL Viewer", command=self.doSTLView)

        if self.settings.openscadcmd is not None:
            n += 1
            self.toolsmenu.add_command(label="OpenSCAD", command=self.doOpenSCAD)

        if n > 0:
            self.menubar.add_cascade(label="Tools", menu=self.toolsmenu)

        try:
            self.master.config(menu=self.menubar)
        except AttributeError:
            self.master.tk.call(master, "config", "-menu", self.menubar)

        self.toolbar = ToolBar(self, self.printer, self.settings, self.logger)
        self.toolbar.grid(row=1, column=1, columnspan=4, sticky=W)

        self.ctl = MoveControl(self, self.printer, self.settings, self.logger)
        self.ctl.grid(row=2, column=1, rowspan=3, sticky=N)

        self.extr = Extruder(self, self.printer, self.settings, self.logger)
        self.extr.grid(row=2, column=2, rowspan=1, sticky=N + E + W)

        self.temps = Temperatures(self, self.printer, self.settings, self.logger)
        self.temps.grid(row=3, column=2, rowspan=2, sticky=N + E + W)

        self.gc = GcFrame(self, None, [], self.settings, self.logger)
        self.gc.grid(row=2, column=3, rowspan=3, sticky=N)

        self.statline = Status(self, self.printer, self.settings, self.logger)
        self.statline.grid(row=5, column=1, columnspan=4, sticky=E + W)

        self.logger.grid(row=2, column=4, rowspan=2, sticky=N + E + W)

        self.sendgcode = SendGCode(self, self.printer, self.settings, self.logger)
        self.sendgcode.grid(row=4, column=4, sticky=N + E + W)

        self.printer.errorcb = self.errorcb
        self.printer.sendcb = self.sendcb
        self.printer.recvcb = self.recvcb

        self.sd = SDCard(self, self.printer, self.settings, self.logger)
        self.firmware = FirmwareParms(self, self.printer, self.settings, self.logger)
        self.bind(MWM_FIRMWARECOMPLETE, self.firmwareReportComplete)
        self.bind(MWM_SLICERCOMPLETE, self.sliceComplete)
        self.bind(MWM_GCODELOADCOMPLETE, self.loadgcodeFinished)
        self.bind(MWM_GEDITMEASURECOMPLETE, self.geditMeasureComplete)
        self.bind(MWM_REQUESTPOSITIONREPORT, self.requestPosition)

        self.doShowButtons()

    def doStopAll(self):
        self.toolbar.doPause()
        self.temps.doOffBed()
        self.temps.doOffExt()

    def requestPosition(self, *arg):
        self.m114count += 1
        self.printer.send_now("M400")  # finish all moves
        self.printer.send_now("M114")

    def doShowButtons(self):
        self.settings.showmacrobuttons = self.cbShowMacroButtons.get() == 1
        self.settings.setModified()
        if self.settings.showmacrobuttons:
            self.macroButtons = MacroButtons(self, self.printer, self.settings, self.logger)
        else:
            if self.macroButtons:
                self.macroButtons.close()
                self.macroButtons = None

    def toggleShowPrevious(self):
        self.settings.showprevious = self.cbShowPrevious.get() == 1
        self.settings.setModified()
        self.gc.drawCanvas()

    def toggleShowMoves(self):
        self.settings.showmoves = self.cbShowMoves.get() == 1
        self.settings.setModified()
        self.gc.drawCanvas()

    def selSlicer(self):
        self.settings.slicer = self.rbSlicer.get()
        self.settings.setModified()
        self.toolbar.setSliceText()

    def macroButtonClose(self):
        self.settings.showmacrobuttons = False
        self.settings.setModified()
        self.cbShowMacroButtons.set(False)

    def firmwareReportComplete(self, *arg):
        p = self.firmware.reportComplete()
        if p is not None:
            self.acceleration = p["m204_s"].getFlash()
            print "Retrieved acc value of ", self.acceleration

    def openSTLFile(self):
        if self.printing:
            self.logger.logMsg("Cannot open a new file while printing")
            return

        if self.StlFile is None:
            fn = askopenfilename(
                filetypes=[("STL files", "*.stl"), ("G Code files", "*.gcode")], initialdir=self.settings.lastdirectory
            )
        else:
            fn = askopenfilename(
                filetypes=[("STL files", "*.stl"), ("G Code files", "*.gcode")],
                initialdir=self.settings.lastdirectory,
                initialfile=os.path.basename(self.StlFile),
            )
        if fn:
            self.settings.lastdirectory = os.path.dirname(os.path.abspath(fn))
            self.settings.setModified()
            if fn.lower().endswith(".gcode"):
                self.StlFile = None
                self.loadgcode(fn)
            elif fn.lower().endswith(".stl"):
                self.StlFile = fn
                self.doSlice(fn)
            else:
                self.logger.logMsg("Invalid file type")

    def openGCodeFile(self):
        if self.printing:
            self.logger.logMsg("Cannot open a new file while printing")
            return

        fn = askopenfilename(filetypes=[("G Code files", "*.gcode")], initialdir=self.settings.lastdirectory)
        if fn:
            self.settings.lastdirectory = os.path.dirname(os.path.abspath(fn))
            self.settings.setModified()
            if fn.lower().endswith(".gcode"):
                self.StlFile = None
                self.loadgcode(fn)
            else:
                self.logger.logMsg("Invalid file type")
        else:
            self.toolbar.clearCancelMode()

    def loadgcode(self, fn):
        self.GCodeFile = fn
        self.gcodeloadSuccess = True
        self.toolbar.setLoading(True)
        self.loader = threading.Thread(target=self.loadgcodeThread)
        self.loader.daemon = True
        self.loader.start()

    def loadgcodeFinished(self, *arg):
        self.toolbar.setLoading(False)
        if self.gcodeloadSuccess:
            self.showMetrics()

    def loadgcodeThread(self):
        try:
            self.gcode = []
            l = list(open(self.GCodeFile))
            for s in l:
                self.gcode.append(s.rstrip())
            self.logger.logMsg("read %d lines from %s" % (len(self.gcode), os.path.basename(self.GCodeFile)))
        except:
            self.logger.logMsg("Problem reading gcode from %s" % self.GCodeFile)
            self.gcode = []
            self.GCodeFile = None

        if len(self.gcode) != 0:
            self.logger.logMsg("Processing...")
            self.gc.loadFile(self.GCodeFile, self.gcode)
            self.printStartLine = self.gc.getPrintStartLine()
            self.gcodeInfo = GCode(self.gcode)
            self.logger.logMsg("Measuring...")
            self.gcodeInfo.measure(self.acceleration)
            self.estEta = self.gcodeInfo.totalduration
            self.timeLayers = self.gcodeInfo.layerdurations
        else:
            self.gcodeloadSuccess = False

        self.event_generate(MWM_GCODELOADCOMPLETE)

    def replace(self, s, slicer):
        if slicer == SLIC3R:
            d = os.path.expandvars(os.path.expanduser(self.settings.s3profiledir))
            profile = os.path.join(d, self.slic3r.getProfile() + ".ini")
        else:
            profile = self.skeinforge.getProfile()

        d = {}

        d["%starttime%"] = time.strftime("%H:%M:%S", time.localtime(self.startTime))
        d["%endtime%"] = time.strftime("%H:%M:%S", time.localtime(self.endTime))
        d["%elapsed%"] = formatElapsed(self.elapsedTime)

        d["%profile%"] = profile
        d["%slicer%"] = self.settings.slicer

        if self.StlFile is not None:
            d["%stlbase%"] = os.path.basename(self.StlFile)
            d["%stl%"] = self.StlFile
        else:
            d["%stlbase%"] = ""
            d["%stl%"] = ""

        if self.GCodeFile is not None:
            d["%gcodebase%"] = os.path.basename(self.GCodeFile)
            d["%gcode%"] = self.GCodeFile
        else:
            d["%gcodebase%"] = ""
            d["%gcode%"] = ""

        for t in d.keys():
            if d[t] is not None:
                s = s.replace(t, d[t])

        s = s.replace('""', "")
        return s

    def showMetrics(self):
        if len(self.gcode) != 0:
            self.paused = False
            self.toolbar.initializeToolbar()
            self.toolbar.checkAllowPrint()
            self.allowGEdit()

            self.logger.logMsg(
                "Width: %f mm (%f -> %f)" % (self.gcodeInfo.width, self.gcodeInfo.xmin, self.gcodeInfo.xmax)
            )
            self.logger.logMsg(
                "Depth: %f mm (%f -> %f)" % (self.gcodeInfo.depth, self.gcodeInfo.ymin, self.gcodeInfo.ymax)
            )
            self.logger.logMsg(
                "Height: is %f mm (%f -> %f)" % (self.gcodeInfo.height, self.gcodeInfo.zmin, self.gcodeInfo.zmax)
            )
            self.logger.logMsg("Total extrusion length: %f mm" % self.gcodeInfo.filament_length())

            self.logger.logMsg("Estimated print time: %s" % formatElapsed(self.estEta))

    def calcEta(self, line, timeThusFar):
        foundLayer = False
        for i in range(len(self.timeLayers)):
            if self.timeLayers[i][0] > line:
                foundLayer = True
                break

        if not foundLayer:
            return 0

        currentLayer = i - 1
        if currentLayer < 0:
            return 0

        totalInLayer = self.timeLayers[i][0] - self.timeLayers[currentLayer][0]
        printedInLayer = line - self.timeLayers[currentLayer][0]
        pct = printedInLayer / float(totalInLayer)
        thisLayerTime = (self.timeLayers[currentLayer][1]) * pct
        ratio = (self.timeLayers[currentLayer][2] - self.timeLayers[currentLayer][1] + thisLayerTime) / float(
            timeThusFar
        )
        ne = self.estEta / float(ratio)
        return ne - timeThusFar

    def doTimingReport(self):
        if not self.printing:
            self.logger.logMsg("Only available while printing")
            return

        self.timingReport = TimingReport(self, self.printer, self.settings, self.logger)

    def closeTimingReport(self):
        if self.timingReport is not None:
            self.timingReport.cleanup()
            self.timingReport.destroy()

        self.timingReport = None

    def doMeasurementsReport(self):
        if not self.gcodeInfo:
            self.logger.logMsg("Only available when GCode loaded")
            return

        self.measurementsReport = MeasurementsReport(self, self.printer, self.settings, self.logger)

    def closeMeasurementsReport(self):
        if self.measurementsReport is not None:
            self.measurementsReport.destroy()

        self.measurementsReport = None

    def doFilamentReport(self):
        if not self.gcodeInfo:
            self.logger.logMsg("Only available when GCode loaded")
            return
        if len(self.gcodeInfo.filLayers) == 0:
            self.logger.logMsg("No filament usage in this gcode")
            return

        self.filamentReport = FilamentReport(self, self.printer, self.settings, self.logger)

    def closeFilamentReport(self):
        if self.filamentReport is not None:
            self.filamentReport.destroy()

        self.filamentReport = None

    def closeAllReports(self):
        self.closeTimingReport()
        self.closeFilamentReport()
        self.closeMeasurementsReport()

    def doPlater(self):
        s = self.replace(self.settings.platercmd, self.settings.slicer)
        args = shlex.split(os.path.expandvars(os.path.expanduser(s)))
        subprocess.Popen(args, close_fds=True)

    def doGCodeView(self):
        s = self.replace(self.settings.gcodeviewcmd, self.settings.slicer)
        args = shlex.split(os.path.expandvars(os.path.expanduser(s)))
        subprocess.Popen(args, close_fds=True)

    def doSTLView(self):
        s = self.replace(self.settings.stlviewcmd, self.settings.slicer)
        self.logger.logMsg(s)
        args = shlex.split(os.path.expandvars(os.path.expanduser(s)))
        subprocess.Popen(args, close_fds=True)

    def doOpenSCAD(self):
        s = self.replace(self.settings.openscadcmd, self.settings.slicer)
        args = shlex.split(os.path.expandvars(os.path.expanduser(s)))
        subprocess.Popen(args, close_fds=True)

    def doSlice(self, fn):
        self.paused = False
        self.toolbar.initializeToolbar()
        self.slicerfn = fn
        self.slicing = True
        self.slicerCancel = False
        self.toolbar.setCancelMode()
        if self.settings.slicer == SLIC3R:
            self.GCodeFile = fn.replace(".stl", ".gcode")
            cmd = self.replace(os.path.expandvars(os.path.expanduser(self.settings.s3cmd)), SLIC3R)
        else:
            self.GCodeFile = fn.replace(".stl", "_export.gcode")
            cmd = self.replace(os.path.expandvars(os.path.expanduser(self.settings.sfcmd)), SKEINFORGE)
        self.slicer = threading.Thread(target=self.slicerThread, args=(cmd,))
        self.slicer.daemon = True
        self.slicer.start()

    def slicerThread(self, cmd):
        args = shlex.split(cmd)
        p = subprocess.Popen(args, stderr=subprocess.STDOUT, stdout=subprocess.PIPE)
        obuf = ""
        while not self.slicerCancel:
            o = p.stdout.read(1)
            if o == "":
                break
            if o == "\r" or o == "\n":
                self.logger.logMsg(obuf)
                obuf = ""
            elif ord(o) < 32:
                pass
            else:
                obuf += o

        if self.slicerCancel:
            p.kill()

        p.wait()
        self.event_generate(MWM_SLICERCOMPLETE)

    def sliceComplete(self, *arg):
        self.slicing = False
        self.toolbar.clearCancelMode()
        if self.slicerCancel:
            self.slicerCancel = False
            self.logger.logMsg("Slicing was cancelled")
            return

        self.logger.logMsg("Slicing has completed successfully")
        if os.path.exists(self.GCodeFile):
            self.loadgcode(self.GCodeFile)
        else:
            self.logger.logMsg("Unable to find slicer output file: %s" % self.GCodeFile)

    def allowGEdit(self):
        self.editmenu.entryconfig(self.editmenu.index(GCODE_MENU_TEXT), state=NORMAL)

    def allowSliceMenu(self, flag=True):
        s = NORMAL
        if not flag:
            s = DISABLED
        self.filemenu.entryconfig(self.slicemenuindex, state=s)

    def allowLoadGCodeMenu(self, flag=True):
        s = NORMAL
        if not flag:
            s = DISABLED
        self.filemenu.entryconfig(self.loadgcodemenuindex, state=s)

    def doGEdit(self):
        GEditor(self, self.gcode, None)

    def geditMeasureComplete(self, *arg):
        self.showMetrics()

    def gEditSave(self, newgcode, fn, editwindow):
        if fn == None:
            self.gcode = newgcode
            self.meas = threading.Thread(target=self.geditMeasureThread)
            self.meas.daemon = True
            self.meas.start()
            return False
        else:
            try:
                f = open(fn, "w")
                for l in newgcode:
                    f.write(l + "\n")
                f.close()
                self.logger.logMsg("Alterations %s successfully saved" % fn)
                return True
            except:
                self.logger.logMsg("Unable to open %s for output" % fn)
                return False

    def geditMeasureThread(self):
        self.logger.logMsg("Processing...")
        self.gcodeInfo = GCode(self.gcode)
        self.logger.logMsg("Measuring...")
        self.gcodeInfo.measure(self.acceleration)
        self.estEta = self.gcodeInfo.totalduration
        self.timeLayers = self.gcodeInfo.layerdurations
        self.event_generate(MWM_GEDITMEASURECOMPLETE)

    def doSD(self):
        if not self.sd.isActive():
            self.sd.start()

    def setToolbarSDPrint(self):
        self.toolbar.setSDPrint()

    def startUpload(self):
        self.sduploading = True
        self.toolbar.doPrint()

    def printerAvailable(self, silent=False, cmd="xx"):
        if not self.connected:
            if not silent:
                self.logger.logMsg("Unable to comply - printer not on-line")
            return False
        if (self.printing or self.sdprinting) and cmd.upper() not in allow_while_printing:
            if not silent:
                self.logger.logMsg("Unable to comply - currently printing")
            return False

        return True

    def printerConnected(self, flag):
        self.sendgcode.activate(flag)
        self.connected = flag
        if flag:
            self.firmware.start(True)

    def updateScreen(self):
        if self.printing:
            self.gc.updatePrintProgress(self.printer.queueindex)

    def errorcb(self, s):
        self.logger.logMsg(s.rstrip())

    def sendcb(self, s):
        # self.logger.logMsg("Sent: %s" % s)
        pass

    def recvcb(self, s):
        if self.readingFirmware:
            if "M92" in s:
                X = self.parseG(s, "X")
                Y = self.parseG(s, "Y")
                Z = self.parseG(s, "Z")
                E = self.parseG(s, "E")
                self.firmware.m92(X, Y, Z, E)
                return
            elif "M201" in s:
                X = self.parseG(s, "X")
                Y = self.parseG(s, "Y")
                Z = self.parseG(s, "Z")
                E = self.parseG(s, "E")
                self.firmware.m201(X, Y, Z, E)
                return
            elif "M203" in s:
                X = self.parseG(s, "X")
                Y = self.parseG(s, "Y")
                Z = self.parseG(s, "Z")
                E = self.parseG(s, "E")
                self.firmware.m203(X, Y, Z, E)
                return
            elif "M204" in s:
                S = self.parseG(s, "S")
                T = self.parseG(s, "T")
                self.firmware.m204(S, T)
                return
            elif "M205" in s:
                S = self.parseG(s, "S")
                T = self.parseG(s, "T")
                B = self.parseG(s, "B")
                X = self.parseG(s, "X")
                Z = self.parseG(s, "Z")
                E = self.parseG(s, "E")
                self.firmware.m205(S, T, B, X, Z, E)
                return
            elif "M206" in s:
                X = self.parseG(s, "X")
                Y = self.parseG(s, "Y")
                Z = self.parseG(s, "Z")
                self.firmware.m206(X, Y, Z)
                return
            elif "M301" in s:
                P = self.parseG(s, "P")
                I = self.parseG(s, "I")
                D = self.parseG(s, "D")
                self.firmware.m301(P, I, D)
                return
            elif (
                ("Steps per unit" in s)
                or ("Acceleration:" in s)
                or ("Maximum Acceleration" in s)
                or ("Maximum feedrates" in s)
                or ("Advanced variables" in s)
                or ("Home offset" in s)
                or ("PID settings" in s)
                or ("Stored settings retreived" in s)
            ):
                return

        if self.sdchecking:
            if "SD card ok" in s:
                self.sdchecking = False
                self.sdpresent = True
                self.sd.sdCheckComplete(True)
                return
            elif "SD init fail" in s:
                self.sdchecking = False
                self.sdpresent = False
                self.sd.sdCheckComplete(False)
                return

        if self.sdlisting:
            if "Begin file list" in s:
                self.insidelisting = True
                self.sdfiles = []
                return
            elif "End file list" in s:
                self.sdlisting = False
                self.insidelisting = False
                self.sd.sdListComplete(self.sdfiles)
                return
            else:
                if self.insidelisting:
                    self.sdfiles.append(s.strip())
                    return

        if "SD printing byte" in s:
            m = self.sdre.search(s)
            t = m.groups()
            if len(t) != 2:
                return

            self.sdbytes = int(t[0])
            self.sdmaxbytes = int(t[1])
            return

        elif "Done printing file" in s:
            if self.sdprinting:
                self.sdprinting = False
                self.toolbar.clearSDPrint()

        m = self.speedrptre.search(s)
        if m:
            t = m.groups()
            if len(t) >= 3:
                if self.settings.forcefanspeed:
                    ns = int(t[0])
                    if ns != self.FanSpeed:
                        self.logger.logMsg("Asserting fan speed of %d" % self.FanSpeed)
                        self.toolbar.forceFanSpeed(self.FanSpeed)
                else:
                    self.FanSpeed = int(t[0])

                self.FeedMultiply = int(t[1])
                self.ExtrudeMultiply = int(t[2])
                self.toolbar.syncSpeeds()
                if self.speedcount > 0:
                    self.speedcount -= 1
                    return

        m = self.locrptre.search(s)
        if m:
            t = m.groups()
            if len(t) >= 4:
                self.location[XAxis] = float(t[0])
                self.location[YAxis] = float(t[1])
                self.location[ZAxis] = float(t[2])
                self.location[EAxis] = float(t[3])
                if self.m114count != 0:
                    self.m114count -= 1
                    if self.m114count < 0:
                        self.m114count = 0
                    return

        if s.startswith("ok"):
            return

        if s.startswith("echo:"):
            s = s[5:]

        m = self.rpt1re.search(s)
        if m:
            t = m.groups()
            if len(t) >= 1:
                self.exttemp = float(t[0])
            if len(t) >= 2:
                self.bedtemp = float(t[1])
            self.temps.updateTempDisplay(self.bedtemp, self.exttemp)

        m = self.rpt2re.search(s)
        if m:
            t = m.groups()
            if len(t) >= 1:
                self.exttemp = float(t[0])
            self.temps.updateTempDisplay(self.bedtemp, self.exttemp)

        self.logger.logMsg(s.rstrip())

    def parseG(self, s, v):
        l = s.split()
        for p in l:
            if p.startswith(v):
                try:
                    return float(p[1:])
                except:
                    return None
        return None

    def editSettings(self):
        # TO DO
        pass

    def slic3rSettings(self):
        s = self.replace(self.settings.s3config, SLIC3R)
        args = shlex.split(os.path.expandvars(os.path.expanduser(s)))
        subprocess.Popen(args, close_fds=True)

    def skeinforgeSettings(self):
        s = self.replace(self.settings.sfconfig, SKEINFORGE)
        args = shlex.split(os.path.expandvars(os.path.expanduser(s)))
        subprocess.Popen(args, close_fds=True)

    def chooseS3Profile(self):
        pl = self.slic3r.getProfileOptions()
        if len(pl) > 0:
            l = ListBoxChoice(
                clist=pl.keys(), master=self, title="Choose Slic3r Profile", message="Choose Slic3r profile"
            )
            pn = l.returnValue()
            if pn:
                self.slic3r.setProfile(pn)
                self.setS3ProfileMenuText()
                self.toolbar.setSliceText()
        else:
            self.logger.logMsg("Unable to retrieve available slic3r profiles")

    def chooseSFProfile(self):
        pl = self.skeinforge.getProfileOptions()
        if len(pl) > 0:
            l = ListBoxChoice(
                clist=pl.keys(), master=self, title="Choose Skeinforge Profile", message="Choose Skeinforge profile"
            )
            pn = l.returnValue()
            if pn:
                self.skeinforge.setProfile(pn)
                self.setSFProfileMenuText()
                self.toolbar.setSliceText()
        else:
            self.logger.logMsg("Unable to retrieve available skeinforge profiles")

    def setS3ProfileMenuText(self):
        self.slicermenu.entryconfig(self.S3profileindex, label="Choose Profile (%s)" % self.slic3r.getProfile())

    def setSFProfileMenuText(self):
        self.slicermenu.entryconfig(self.SFprofileindex, label="Choose Profile (%s)" % self.skeinforge.getProfile())

    def quitApp(self):
        self.cleanUp()
        self.master.quit()

    def cleanUp(self):
        if self.connected:
            self.printer.disconnect()
        if self.slicing:
            self.slicerCancel = True
        self.httpServer.close()
        self.statline.cleanUp()
        self.settings.cleanUp()

    def doEditMacro(self):
        idir = os.path.join(self.settings.cmdFolder, "macros")
        try:
            l = os.listdir(idir)
        except:
            self.logger.logMsg("Unable to get listing from macros directory: " + idir)
            return
        r = []
        for f in sorted(l):
            if f.endswith(".macro"):
                r.append(f)

        l = ListBoxChoice(master=self, title="Macro Files", message="Choose a macro to edit", clist=r)
        fn = l.returnValue()
        if fn:
            try:
                fn = os.path.join(idir, fn)
                with open(fn) as f:
                    text = f.read()
                self.macroEdit = MacroEdit(self, self.printer, self.settings, self.logger, fn, text)
            except:
                self.logger.logMsg("Unable to open %s for input" % fn)

    def doEditAlterations(self):
        idir = os.path.expandvars(os.path.expanduser(self.settings.sfalterationsdir))
        try:
            l = os.listdir(idir)
        except:
            self.logger.logMsg("Unable to get listing from alterations directory: " + idir)
            return
        r = []
        for f in sorted(l):
            if f.endswith(".gcode"):
                r.append(f)

        l = ListBoxChoice(master=self, title="Alteration Files", message="Choose an alteration file to edit", clist=r)
        fn = l.returnValue()
        if fn:
            try:
                fn = os.path.join(idir, fn)
                text = [line.strip() for line in open(fn)]
                GEditor(self, text, fn)
            except:
                self.logger.logMsg("Unable to open %s for input" % fn)

    def doNewMacro(self):
        self.macroEdit = MacroEdit(self, self.printer, self.settings, self.logger, None, "")

    def doDelMacro(self):
        idir = os.path.join(self.settings.cmdFolder, "macros")
        try:
            l = os.listdir(idir)
        except:
            self.logger.logMsg("Unable to get listing from macros directory: " + idir)
            return
        r = []
        for f in sorted(l):
            if f.endswith(".macro"):
                r.append(f)

        l = ListBoxChoice(master=self, title="Macro Files", message="Choose a macro to delete", clist=r)
        fn = l.returnValue()
        if fn:
            if askyesno("Delete?", "Are you sure you want to delete this macro?", parent=self):
                try:
                    os.unlink(os.path.join(idir, fn))
                    self.adjustMacroMenu(fn, True)
                    if self.settings.getMacroList().delMacroByName(fn):
                        self.settings.setModified()
                        if self.settings.showmacrobuttons:
                            self.macroButtons.close()
                            self.macroButtons = MacroButtons(self, self.printer, self.settings, self.logger)
                except:
                    self.logger.logMsg("Unable to delete %s" % fn)

    def macroEditSave(self, fn, text, btn, editwindow):
        if fn == None:
            idir = os.path.join(self.settings.cmdFolder, "macros")

            try:
                l = os.listdir(idir)
            except:
                self.logger.logMsg("Unable to get listing from macros directory: " + idir)
                return

            r = []
            for f in sorted(l):
                if f.endswith(".macro"):
                    r.append(f)

            l = ListBoxChoice(
                master=self,
                title="Macro Files",
                message="Choose a macro to overwrite",
                clist=r,
                newmessage="or enter new file name:",
            )
            fn = l.returnValue()
            if fn:
                fn = os.path.join(idir, fn)
                if not fn.endswith(".macro"):
                    fn += ".macro"

        if fn is None:
            return False

        try:
            f = open(fn, "w")
            f.write(text)
            f.close()
            self.settings.setModified()
            if btn != None:
                if not self.settings.getMacroList().addMacro(btn[0], btn[1], os.path.basename(fn), btn[2]):
                    self.settings.getMacroList().setMacroByName(btn[0], btn[1], os.path.basename(fn), btn[2])
                self.settings.setModified()

                if self.settings.showmacrobuttons:
                    self.macroButtons.close()
                    self.macroButtons = MacroButtons(self, self.printer, self.settings, self.logger)

            self.adjustMacroMenu(fn)
            self.logger.logMsg("Macro %s successfully saved" % fn)
            return True
        except:
            self.logger.logMsg("Unable to open %s for output" % fn)
            return False

    def macroEditExit(self, fn):
        pass

    def loadMacros(self):
        p = os.path.join(".", "macros")
        if not os.path.exists(p):
            os.makedirs(p)

        self.macroList = {}
        for filename in sorted(os.listdir(p)):
            if filename.endswith(".macro"):
                n = os.path.splitext(filename)[0]
                self.macroList[n] = 1
                self.runmacromenu.add_command(label=n, command=lambda m=n: self.doMacro(m))

    def adjustMacroMenu(self, fn, delete=False):
        mn = os.path.splitext(os.path.basename(fn))[0]

        if not delete:
            if mn in self.macroList:
                # nothing to be done here
                pass
            else:
                self.macroList[mn] = 1
                self.runmacromenu.add_command(label=mn, command=lambda m=mn: self.doMacro(name=mn))
        else:
            # delete the menu entry
            if mn in self.macroList:
                self.runmacromenu.delete(self.runmacromenu.index(mn))
                del self.macroList[mn]
            else:
                # huh??
                pass

    def doMacro(self, name=None, fname=None, silent=False):
        if name:
            if not silent:
                self.logger.logMsg("Invoking macro: %s" % name)
            n = os.path.join(self.settings.cmdFolder, "macros", name + ".macro")
        elif fname:
            if not silent:
                self.logger.logMsg("Invoking macro file: %s" % fname)
            n = os.path.join(self.settings.cmdFolder, "macros", fname)
        else:
            self.logger.logMsg("Error - must provide a macro name or filename")
            return

        try:
            l = list(open(n))
            for s in l:
                sl = s.lower()
                if sl.startswith("@log "):
                    self.logger.logMsg(self.replace(s[5:].strip(), self.settings.slicer))
                elif sl.startswith("@sh "):
                    s = self.replace(sl[4:], self.settings.slicer)
                    args = shlex.split(os.path.expandvars(os.path.expanduser(s)))
                    subprocess.Popen(args, close_fds=True)
                else:
                    verb = s.split()[0]
                    if self.printerAvailable(cmd=verb):
                        self.printer.send_now(s)
                    else:
                        self.logger.logMsg("Printer not available for %s command" % verb)

            if not silent:
                self.logger.logMsg("End of macro")
        except:
            self.logger.logMsg("Error attempting to invoke macro file %s" % n)

    def FirmwareSettings(self):
        if self.connected:
            if not self.firmware.isActive():
                self.firmware.start()
        else:
            self.logger.logMsg("Unable to comply - printer not on-line")

    def doDataLogReport(self):
        for d in DLLIST:
            self.logger.logMsg("%s Usage: %s" % (DLNAMES[d], self.dataLoggers[d].getToNowStr()))

    def doDataLogReset(self):
        DataLogReset(self)
Example #15
0
File: ce.py Project: BitBldr/loxodo
class CeFrame(Frame):
    '''\
    CeFrame is a frame designed to be a Windows CE compliant window.
    A CeFrame will track the SIP position and size and will automatically
    resize itself to always fit the screen.
    '''
    _dispatchers = {"_activate" : (MSGEventDispatcher, WM_ACTIVATE),
                    "_settingchanged" : (MSGEventDispatcher, WM_SETTINGCHANGE),
                    }
    _dispatchers.update(Frame._dispatchers)
    
    def __init__(self, parent=None, 
                       title="PocketPyGui", 
                       action=None, 
                       menu=None,
                       right_action=None, 
                       tab_traversal=True, 
                       visible=True, 
                       enabled=True, 
                       has_sip=True, 
                       has_toolbar=False):
        '''\
        Arguments :
            - parent: the parent window of this CeFrame.
            - title: the title as appearing in the title bar.
            - action : a tuple ('Label', callback) .
            - menu : the title of the right menu as a string
                     if not None, the menu can be filled via the cb_menu attribute
                     after CeFrame initialization.
        '''
        Frame.__init__(self, parent, title, tab_traversal=tab_traversal, visible=visible, enabled=enabled)
        self.bind(_activate=self._on_activate,
                  _settingchanged=self._on_setting_changed,
                  size=self._on_size)
        if has_toolbar :
            self.toolbar = ToolBar(self)
        else:
            self.toolbar = None
        self.__create_menubar(action, menu, right_action, has_sip)
        
        
    def _on_size(self, ev):
        if ev.wParam == 1:
            self.close()
        else:
            self.layout()
        ev.skip()
        
    def layout(self):
        if self.toolbar is None:
            return Frame.layout(self)
        if self._sizer is not None:
            rc = RECT()
            GetClientRect(self._w32_hWnd, byref(rc))
            self._sizer.size(rc.left, rc.top, rc.right, rc.bottom-24*HIRES_MULT)
            self.toolbar.move(rc.left, rc.bottom-26*HIRES_MULT, rc.right-rc.left, 26*HIRES_MULT)
    
    
    def __create_menubar(self, action, menu, right_action, has_sip):
        mbi = SHMENUBARINFO()
        mbi.cbSize = sizeof(SHMENUBARINFO)
        mbi.hwndParent = self._w32_hWnd
        mbi.hInstRes = GetModuleHandle(0)
        
        slots = []
        
        empty = True
        has_action = False
        has_menu = False
        has_right_action = False
        
        if (action is None) and (menu is None) :
            mbi.dwFlags = SHCMBF_EMPTYBAR
            
        else :
            empty = False
            temp_menu = Menu()
            i = 0
            if action is not None:
                label, cb = action
                action_item = temp_menu.append(label, callback=cb)
                #self.action = CommandBarAction(item, 0)
            else:
                action_item = temp_menu.append("", enabled=False)
              
            if right_action is not None:
                label, cb = right_action
                right_action_item = temp_menu.append(label, callback=cb)
                has_right_action = True
            elif menu is not None:
                sub_menu = PopupMenu()
                temp_menu.append_menu(menu, sub_menu) 
                has_menu = True
                
            mbi.dwFlags = SHCMBF_HMENU
            mbi.nToolBarId = temp_menu._hmenu
            
        if not has_sip:
            mbi.dwFlags |= SHCMBF_HIDESIPBUTTON
        SHCreateMenuBar(byref(mbi))
        self._mb_hWnd = mbi.hwndMB
        
        if not empty:
            self.cb_action = CommandBarAction(mbi.hwndMB, 0, action_item)
            if has_right_action:
                self.cb_right_action = CommandBarAction(mbi.hwndMB, 1, right_action_item)
            elif has_menu:
                tbbi = TBBUTTONINFO()
                tbbi.cbSize = sizeof(tbbi)
                tbbi.dwMask = 0x10 | 0x80000000
                SendMessage(mbi.hwndMB, WM_USER+63, 1, byref(tbbi))
                hMenu = tbbi.lParam         
                self.cb_menu = CommandBarMenu(mbi.hwndMB, 1, hMenu)
        
        rc = RECT()
        GetWindowRect(self._w32_hWnd, byref(rc))
        rcmb = RECT()
        GetWindowRect(self._mb_hWnd, byref(rcmb))
        rc.bottom -= (rcmb.bottom - rcmb.top)
        self.move(rc.left, rc.top, rc.right-rc.left, rc.bottom-rc.top)
        
    def _on_activate(self, event):
        if not hasattr(self, '_shai'):
            self._shai = InitSHActivateInfo()
        SHHandleWMActivate(event.hWnd, event.wParam, event.lParam, byref(self._shai), 0)
    
    def _on_setting_changed(self, event):
        if not hasattr(self, '_shai'):
            self._shai = InitSHActivateInfo()
        SHHandleWMSettingChange(self._w32_hWnd, event.wParam, event.lParam, byref(self._shai))

    def show_sipbutton(self, show=True):
        if show:
            SHFullScreen(self._w32_hWnd, SHFS_SHOWSIPBUTTON)
        else:
            SHFullScreen(self._w32_hWnd, SHFS_HIDESIPBUTTON)
        
    def hide_sipbutton(self):
        self.show_sipbutton(False)
Example #16
0
    def build(self):
        self.root = Tk()
        self.root.geometry("800x622+200+200")
        self.root.title("SecureMe")
        self.root.resizable(width=FALSE, height=FALSE)

        menubar = Menu(self.root)
        optionsmenu = Menu(menubar, tearoff=0)
        optionsmenu.add_command(label="Refresh (Ctrl+r)",
                                command=lambda: self.refresh("NONE"))
        optionsmenu.add_command(label="Exit", command=lambda: self.quitMenu())
        menubar.add_cascade(label="Options", menu=optionsmenu)
        self.root.config(menu=menubar)

        self.toolbar = ToolBar(self.root, self)

        style = Style()
        style.configure("BW.TLabel",
                        foreground="black",
                        background="slate gray",
                        borderwidth=2)

        mFrame = Frame(self.root, bg="slate gray", padx=25, pady=25)
        mFrame.pack(fill=BOTH)
        self.notebook = ttk.Notebook(mFrame, height=500, style="BW.TLabel")
        primaryFrame = Frame(self.notebook, padx=25, pady=25)
        usersFrame = Frame(self.notebook, padx=25, pady=25)
        firewallFrame = Frame(self.notebook, padx=25, pady=25)
        servicesFrame = Frame(self.notebook, padx=25, pady=25)
        processesFrame = Frame(self.notebook, padx=25, pady=25)
        self.notebook.add(primaryFrame, text='Primary')
        self.notebook.add(usersFrame, text='Users')
        self.notebook.add(firewallFrame, text='Firewall')
        self.notebook.add(servicesFrame, text='Services')
        self.notebook.add(processesFrame, text='Processes')
        self.notebook.pack(fill=X)

        self.updatebar = Frame(self.root)
        self.updatebar.pack(side=BOTTOM, fill=X)
        self.left_label = Label(self.updatebar, text="Status: None")
        self.left_label.pack(side=LEFT, fill=X)

        # Primary Panel
        primary_label = Label(primaryFrame,
                              text='Primary Settings',
                              font=self.liberation_font_15)
        primary_label.grid(row=0, column=0, columnspan=2, sticky=N + S + E + W)

        actionspanel = LabelFrame(primaryFrame,
                                  text='System Actions',
                                  padx=10,
                                  pady=10)
        actionspanel.grid(row=1, column=0, sticky=E + N, padx=25, pady=25)

        openterminal = Button(actionspanel,
                              text='Open Terminal',
                              command=lambda: self.openTerminal())
        openterminal.pack(padx=5, pady=5)

        opencontrol = Button(actionspanel,
                             text='Open Control Panel',
                             command=lambda: self.openControlPanel())
        opencontrol.pack(padx=5, pady=5)

        shutdown = Button(actionspanel,
                          text='Shutdown',
                          command=lambda: self.shutdown())
        shutdown.pack(padx=5, pady=5)

        rebootButton = Button(actionspanel,
                              text='Reboot',
                              command=lambda: self.reboot())
        rebootButton.pack(padx=5, pady=5)

        updatespanel = LabelFrame(primaryFrame,
                                  text='System Updates',
                                  padx=10,
                                  pady=10)
        updatespanel.grid(row=1, column=1, sticky=W + N, padx=25, pady=25)

        update_button = Button(updatespanel,
                               text='Basic Update',
                               command=lambda: self.basicUpdate())
        update_button.pack(padx=5, pady=5)

        upgrade_button = Button(updatespanel,
                                text='Basic Upgrade',
                                command=lambda: self.basicUpgrade())
        upgrade_button.pack(padx=5, pady=5)

        packageupdate_button = Button(updatespanel,
                                      text='Package Update',
                                      command=lambda: self.packageUpdate())
        packageupdate_button.pack(padx=5, pady=5)

        # Users Panel
        users_label = Label(usersFrame,
                            text='User Security Settings',
                            font=self.liberation_font_15)
        users_label.pack()

        editusers = Frame(usersFrame)
        editusers.pack()

        addusr = Button(editusers,
                        text='Add User...',
                        command=lambda: self.addUser())
        addusr.grid(row=0, column=0, padx=5, pady=5)

        delusr = Button(editusers,
                        text='Del User...',
                        command=lambda: self.delUser())
        delusr.grid(row=0, column=1, padx=5, pady=5)

        userpanel = LabelFrame(usersFrame, text="Users", padx=10, pady=10)
        userpanel.pack(side=TOP, fill=BOTH)

        self.uText = self.getUserText()
        self.users_listlabel = Label(userpanel,
                                     text=self.uText,
                                     padx=10,
                                     pady=10)
        self.users_listlabel.pack(side=LEFT)

        groupspanel = LabelFrame(usersFrame, text="Groups", padx=10, pady=10)
        groupspanel.pack(side=TOP, fill=BOTH)

        self.gText = self.getGroupText()
        self.groups_text = CustomText(groupspanel)
        self.groups_text.resetText(self.gText)
        self.groups_text.type(DISABLED)
        self.groups_text.pack(fill=BOTH)

        # Firewall Label
        firewall_label = Label(firewallFrame,
                               text='Firewall Settings',
                               font=self.liberation_font_15)
        firewall_label.pack()

        edFrame = Frame(firewallFrame)
        fwEnable = Button(edFrame,
                          text='Enable',
                          command=lambda: self.enableFirewall())
        fwEnable.pack(side=LEFT, padx=10, pady=10, fill=X)
        fwDisable = Button(edFrame,
                           text='Disable',
                           command=lambda: self.disableFirewall())
        fwDisable.pack(side=RIGHT, padx=10, pady=10, fill=X)
        edFrame.pack()

        firewallpanel = LabelFrame(firewallFrame,
                                   text='Firewall Status',
                                   height=100,
                                   width=450,
                                   padx=10,
                                   pady=10)
        firewallpanel.pack(side=TOP, fill=X)

        self.fText = self.getFirewallStatus()
        self.firewall_text = CustomText(firewallpanel)
        self.firewall_text.resetText(self.fText)
        self.firewall_text.type(DISABLED)
        self.firewall_text.pack(fill=X)

        # Services Pane
        services_label = Label(servicesFrame,
                               text='System Services',
                               font=self.liberation_font_15)
        services_label.pack()

        servicespanel = LabelFrame(servicesFrame,
                                   text="Services",
                                   padx=10,
                                   pady=10)
        servicespanel.pack(side=TOP, fill=BOTH)
        self.sText = self.getServicesText()
        self.services_text = CustomText(servicespanel)
        self.services_text.resetText(self.sText)
        self.services_text.type(DISABLED)
        self.services_text.pack(fill=BOTH)

        # Processes Pane
        processes_label = Label(processesFrame,
                                text='System Processes',
                                font=self.liberation_font_15)
        processes_label.pack()

        processespanel = LabelFrame(processesFrame,
                                    text='Processes',
                                    padx=10,
                                    pady=10)
        processespanel.pack(side=TOP, fill=BOTH)
        self.pText = self.getProcessesText()
        self.processes_text = CustomText(processespanel)
        self.processes_text.resetText(self.pText)
        self.processes_text.type(DISABLED)
        self.processes_text.pack(fill=BOTH)

        self.root.bind('<Control-r>', self.refresh)

        self.root.mainloop()
 def create_toolbar(self):
     self.grid(row=0, sticky='w')
     self.toolbar = ToolBar(self)
Example #18
0
class MainWindow(object):
    def __init__(self, *args, **kwargs):
        self._toolbar = None
        self._menubar = None
        self._statusbar = None

        self._rootwidget = None
        self._centralwidget = None
        self._dockareas = {
            DOCKAREA['left']: None,
            DOCKAREA['right']: None,
            DOCKAREA['top']: None,
            DOCKAREA['bottom']: None
        }

        self._toolbarareas = {
            DOCKAREA['left']: None,
            DOCKAREA['right']: None,
            DOCKAREA['top']: None,
            DOCKAREA['bottom']: None
        }

        self.dockareamarker = None

    def initGui(self, screen_width, screen_height):
        bar_height = 30

        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))

        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

        # 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 getCentralWidget(self):
        return self._centralwidget

    def getStatusBar(self):
        return self._statusbar

    def getMenuBar(self):
        return self._menubar

    def getToolBar(self):
        return self._toolbar

    def dockWidgetTo(self, widget, dockarea, x=-1, y=-1):
        """ docks a B{Panel} widget to the given dock area
		
		@note:	
			- ToolBar needs special treatment, given x, y coordinates
			  have no effect on this Panel
			- x, y are cursor coordinates, without giving them the
			  widgets are added beneath the already existing ones
			  nice feature, but also makes problems on editor startup
			  (e.g. if a user docked 2 widgets left, on startup they
			   are added in a col instead of a grouped tab)
				
		@todo:	turn x,y documentation into something more useful
		
		@type	widget:	Panel
		@param	widget:	a panel widget instance
		@type	dockarea:	str
		@param	dockarea:	id of the target dock area
		@type	x:	int
		@param	x:	x coordinate
		@type	y:	int
		@param	y:	y coordinate
		"""
        if isinstance(widget, pychan.widgets.Widget) is False:
            print "Argument is not a valid widget"
            return

        if widget.parent:
            widgetParent = widget.parent
            widgetParent.removeChild(widget)
            widgetParent.adaptLayout()

        # We must hide the widget before adding it to the dockarea,
        # or we will get a duplicate copy of the widget in the top left corner
        # of screen.
        #widget.hide()
        dockareas = self._dockareas

        # Panel widgets which provide an implementation for set_orientation()
        # should check if they need to re-align themselves
        if hasattr(widget, 'set_orientation'):
            key = ''
            if dockarea == DOCKAREA['left'] or dockarea == DOCKAREA['right']:
                key = 'Vertical'
            elif dockarea == DOCKAREA['top'] or dockarea == DOCKAREA['bottom']:
                key = 'Horizontal'
            widget.set_orientation(key=key)

        if isinstance(widget, ToolBar):
            dockareas = self._toolbarareas
            docked = False
            if dockarea == DOCKAREA['left']:
                docked = True
                dockareas[DOCKAREA['left']].addChild(widget)
                dockareas[DOCKAREA['left']].adaptLayout()

            elif dockarea == DOCKAREA['right']:
                docked = True
                dockareas[DOCKAREA['right']].addChild(widget)
                dockareas[DOCKAREA['right']].adaptLayout()

            elif dockarea == DOCKAREA['top']:
                docked = True
                dockareas[DOCKAREA['top']].addChild(widget)
                dockareas[DOCKAREA['top']].adaptLayout()

            elif dockarea == DOCKAREA['bottom']:
                docked = True
                dockareas[DOCKAREA['bottom']].addChild(widget)
                dockareas[DOCKAREA['bottom']].adaptLayout()

            else:
                print "Invalid dockarea"

            widget.dockareaname = dockarea
            widget.setDocked(docked)

        else:
            if dockarea == DOCKAREA['left']:
                dockareas[DOCKAREA['left']].dockChild(widget, x, y)

            elif dockarea == DOCKAREA['right']:
                dockareas[DOCKAREA['right']].dockChild(widget, x, y)

            elif dockarea == DOCKAREA['top']:
                dockareas[DOCKAREA['top']].dockChild(widget, x, y)

            elif dockarea == DOCKAREA['bottom']:
                dockareas[DOCKAREA['bottom']].dockChild(widget, x, y)

            else:
                print "Invalid dockarea"

    def getToolbarAreaAt(self, x, y, mark=False):
        if self.dockareamarker is None:
            self.dockareamarker = pychan.widgets.Container()
            self.dockareamarker.base_color = fifechan.Color(200, 0, 0, 100)
        if mark is False:
            self.dockareamarker.hide()

        # Mouse wasn't over any dockwidgets. See if it is near any edge of the screen instead
        if x <= self._toolbarareas["left"].getAbsolutePos()[0] + 10:
            if mark:
                self.dockareamarker.position = self._toolbarareas[
                    "left"].getAbsolutePos()
                self.dockareamarker.size = (10,
                                            self._toolbarareas["left"].height)
                self.dockareamarker.show()
            return DOCKAREA["left"]

        elif x >= self._toolbarareas["right"].getAbsolutePos()[0] - 10:
            if mark:
                self.dockareamarker.position = self._toolbarareas[
                    "right"].getAbsolutePos()
                self.dockareamarker.size = (10,
                                            self._toolbarareas["right"].height)
                self.dockareamarker.x -= 10
                self.dockareamarker.show()
            return DOCKAREA["right"]

        elif y <= self._toolbarareas["top"].getAbsolutePos()[1] + 10:
            if mark:
                self.dockareamarker.position = self._toolbarareas[
                    "top"].getAbsolutePos()
                self.dockareamarker.size = (self._toolbarareas["top"].width,
                                            10)
                self.dockareamarker.show()
            return DOCKAREA["top"]

        elif y >= self._toolbarareas["bottom"].getAbsolutePos()[1] - 10:
            if mark:
                self.dockareamarker.position = self._toolbarareas[
                    "bottom"].getAbsolutePos()
                self.dockareamarker.y -= 10
                self.dockareamarker.size = (self._toolbarareas["bottom"].width,
                                            10)
                self.dockareamarker.show()
            return DOCKAREA["bottom"]

        if mark is True:
            self.dockareamarker.hide()
        return None

    def getDockAreaAt(self, x, y, mark=False):
        """ returns the dock area at the given cursor coordinates (if possible)
		
			also used for highlighting the dock area (this method is used
			on drag mouse events of a B{Panel} widget)
		
		@type	x:	int
		@param	x:	cursor x coordinates
		@type	y:	int
		@param	y:	cursor y coordinates
		@type	mark:	bool
		@param	mark:	flag to wether show the dock area marker (red area indicator) or not
		@rtype	side:	str
		@return	side:	dockarea id (e.g. 'right', 'left' ...)
		"""
        side = None

        if self.dockareamarker is None:
            self.dockareamarker = pychan.widgets.Container()
            self.dockareamarker.base_color = fifechan.Color(200, 0, 0, 100)
        if mark is False:
            self.dockareamarker.hide()

        for key in DOCKAREA:
            side = DOCKAREA[key]

            dockarea = self._dockareas[side]
            #absX, absY = dockarea.getAbsolutePos()
            #if absX <= x and absY <= y \
            #		and absX+dockarea.width >= x and absX+dockarea.height >= y:
            #	return side
            placeIn, placeBefore, placeAfter = dockarea.getDockLocation(x, y)
            if placeIn or placeBefore or placeAfter:
                if mark is True:
                    if placeIn:
                        self.dockareamarker.position = placeIn.getAbsolutePos()
                        self.dockareamarker.size = placeIn.size
                    elif placeBefore:
                        self.dockareamarker.position = placeBefore.getAbsolutePos(
                        )
                        if side == "left" or side == "right":
                            self.dockareamarker.size = (placeBefore.width, 10)
                        else:
                            self.dockareamarker.size = (10, placeBefore.height)
                    elif placeAfter:
                        self.dockareamarker.position = placeAfter.getAbsolutePos(
                        )

                        if side == "left" or side == "right":
                            self.dockareamarker.size = (placeAfter.width, 10)
                            self.dockareamarker.y += placeAfter.height - 10
                        else:
                            self.dockareamarker.size = (10, placeAfter.height)
                            self.dockareamarker.x += placeAfter.width - 10

                    self.dockareamarker.show()
                return side

        # reset side, next attempt to find a new home
        side = None

        # Mouse wasn't over any dockwidgets. See if it is near any edge of the screen instead
        if x <= self._dockareas["left"].getAbsolutePos()[0] + 10:
            if mark:
                self.dockareamarker.position = self._dockareas[
                    "left"].getAbsolutePos()
                self.dockareamarker.size = (10, self._dockareas["left"].height)
                self.dockareamarker.show()
            side = DOCKAREA["left"]
            return side

        elif x >= self._dockareas["right"].getAbsolutePos()[0] - 10:
            if mark:
                self.dockareamarker.position = self._dockareas[
                    "right"].getAbsolutePos()
                self.dockareamarker.size = (10,
                                            self._dockareas["right"].height)
                self.dockareamarker.x -= 10
                self.dockareamarker.show()
            side = DOCKAREA["right"]
            return side

        elif y <= self._dockareas["top"].getAbsolutePos()[1] + 10:
            if mark:
                self.dockareamarker.position = self._dockareas[
                    "top"].getAbsolutePos()
                self.dockareamarker.size = (self._dockareas["top"].width, 10)
                self.dockareamarker.show()
            side = DOCKAREA["top"]
            return side

        elif y >= self._dockareas["bottom"].getAbsolutePos()[1] - 10:
            if mark:
                self.dockareamarker.position = self._dockareas[
                    "bottom"].getAbsolutePos()
                self.dockareamarker.y -= 10
                self.dockareamarker.size = (self._dockareas["bottom"].width,
                                            10)
                self.dockareamarker.show()
            side = DOCKAREA["bottom"]
            return side

        if mark is True:
            self.dockareamarker.hide()

        return side
Example #19
0
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()
Example #20
0
    def __init__(self, master=None):
        self.master = master
        Frame.__init__(self, master, relief=SUNKEN, bd=2)

        self.gcode = []
        self.slicing = False
        self.printing = False
        self.connected = False
        self.monitorTemp = False
        self.paused = False
        self.sdpresent = False
        self.sdlisting = False
        self.sdchecking = False
        self.sdprinting = False
        self.sdpaused = False
        self.sduploading = False
        self.sdbytes = 0
        self.sdmaxbytes = 0
        self.insidelisting = False
        self.readingFirmware = False
        self.sdfiles = []
        self.bedtemp = float(0)
        self.bedtarget = float(0)
        self.exttemp = float(0)
        self.exttarget = float(0)
        self.acceleration = 0
        self.m114count = 0
        self.speedcount = 0
        self.location = [0, 0, 0, 0]
        self.pausePoint = [0, 0, 0, 0]
        self.percent = 0.0
        self.ets = "??"
        self.gcodeInfo = None
        self.GCodeFile = None
        self.StlFile = None
        self.Profile = None
        self.printStartLine = 0
        self.startTime = 0
        self.endTime = 0
        self.elapsedTime = 0
        self.FanSpeed = 0
        self.FeedMultiply = 100
        self.ExtrudeMultiply = 100

        self.timingReport = None
        self.filamentReport = None
        self.measurementsReport = None

        self.macroButtons = None

        self.rpt1re = re.compile(" *T:([0-9\.]+) *E:[0-9\.]+ *B:([0-9\.]+)")
        self.rpt2re = re.compile(" *T:([0-9\.]+) *E:[0-9\.]+ *W:.*")
        self.locrptre = re.compile("^X:([0-9\.\-]+)Y:([0-9\.\-]+)Z:([0-9\.\-]+)E:([0-9\.\-]+) *Count")
        self.speedrptre = re.compile("Fan speed:([0-9]+) Feed Multiply:([0-9]+) Extrude Multiply:([0-9]+)")

        self.sdre = re.compile("SD printing byte *([0-9]+) *\/ *([0-9]+)")

        self.printer = printcore()
        self.settings = Settings()
        self.settings.cmdFolder = cmd_folder
        self.logger = Logger(self)

        if self.settings.speedcommand is not None:
            allow_while_printing.append(self.settings.speedcommand)

        self.acceleration = self.settings.acceleration

        self.dataLoggers = {}
        for d in DLLIST:
            self.dataLoggers[d] = DataLogger(self, d)

        self.skeinforge = Skeinforge(self.settings)
        self.slic3r = Slic3r(self.settings)

        self.httpServer = RepRapServer(self, self.printer, self.settings, self.logger, self.settings.port)

        self.menubar = Menu(self)
        self.filemenu = Menu(self.menubar, tearoff=0)
        self.menubar.add_cascade(label="File", menu=self.filemenu)
        self.filemenu.add_command(label="Slice", command=self.openSTLFile)
        self.filemenu.add_command(label="Load GCode", command=self.openGCodeFile)
        self.slicemenuindex = self.filemenu.index("Slice")
        self.loadgcodemenuindex = self.filemenu.index("Load GCode")

        self.filemenu.add_separator()
        self.filemenu.add_command(label="Exit", command=self.quitApp)

        self.editmenu = Menu(self.menubar, tearoff=0)
        self.menubar.add_cascade(label="Edit", menu=self.editmenu)

        self.editmenu.add_command(label="Settings", command=self.editSettings)
        self.editmenu.add_command(label="Firmware Settings", command=self.FirmwareSettings)
        self.editmenu.add_separator()
        self.editmenu.add_command(label=GCODE_MENU_TEXT, command=self.doGEdit, state=DISABLED)

        self.slicermenu = Menu(self.menubar, tearoff=0)
        self.menubar.add_cascade(label="Slicer", menu=self.slicermenu)
        self.rbSlicer = StringVar()

        self.slicermenu.add_radiobutton(
            label="Skeinforge", command=self.selSlicer, value=SKEINFORGE, variable=self.rbSlicer
        )
        self.slicermenu.add_command(label="Settings", command=self.skeinforgeSettings)
        self.slicermenu.add_command(label="Choose Profile", command=self.chooseSFProfile)
        self.SFprofileindex = self.slicermenu.index("Choose Profile")
        self.setSFProfileMenuText()
        self.slicermenu.add_command(label="Alterations", command=self.doEditAlterations)

        self.slicermenu.add_separator()
        self.slicermenu.add_radiobutton(label="Slic3r", command=self.selSlicer, value=SLIC3R, variable=self.rbSlicer)
        self.slicermenu.add_command(label="Settings", command=self.slic3rSettings)
        self.slicermenu.add_command(label="Choose Profile", command=self.chooseS3Profile)
        self.S3profileindex = self.slicermenu.index("Choose Profile")
        self.setS3ProfileMenuText()

        self.rbSlicer.set(self.settings.slicer)

        self.macromenu = Menu(self.menubar, tearoff=0)
        self.menubar.add_cascade(label="Macros", menu=self.macromenu)
        self.macromenu.add_command(label="New", command=self.doNewMacro)
        self.macromenu.add_command(label="Edit", command=self.doEditMacro)
        self.macromenu.add_command(label="Delete", command=self.doDelMacro)
        self.macromenu.add_separator()
        self.cbShowMacroButtons = BooleanVar()
        self.cbShowMacroButtons.set(self.settings.showmacrobuttons)
        self.macromenu.add_checkbutton(
            label="Show Macro Buttons",
            command=self.doShowButtons,
            onvalue=True,
            offvalue=False,
            variable=self.cbShowMacroButtons,
        )
        self.macromenu.add_separator()
        self.runmacromenu = Menu(self.macromenu, tearoff=0)
        self.loadMacros()
        self.macromenu.add_cascade(label="Run", menu=self.runmacromenu)

        self.reportmenu = Menu(self.menubar, tearoff=0)
        self.menubar.add_cascade(label="View", menu=self.reportmenu)
        self.cbShowPrevious = BooleanVar()
        self.cbShowPrevious.set(self.settings.showprevious)
        self.reportmenu.add_checkbutton(
            label="Show Previous Layer",
            command=self.toggleShowPrevious,
            onvalue=True,
            offvalue=False,
            variable=self.cbShowPrevious,
        )
        self.cbShowMoves = BooleanVar()
        self.cbShowMoves.set(self.settings.showmoves)
        self.reportmenu.add_checkbutton(
            label="Show Non-extrusion Moves",
            command=self.toggleShowMoves,
            onvalue=True,
            offvalue=False,
            variable=self.cbShowMoves,
        )
        self.reportmenu.add_separator()
        self.reportmenu.add_command(label="Show Hours of Usage", command=self.doDataLogReport)
        self.reportmenu.add_command(label="Reset Hours of Usage", command=self.doDataLogReset)
        self.reportmenu.add_separator()
        self.reportmenu.add_command(label="Layer by Layer Timing", command=self.doTimingReport)
        self.reportmenu.add_command(label="Layer by Layer Filament Usage", command=self.doFilamentReport)
        self.reportmenu.add_command(label="GCode Measurements", command=self.doMeasurementsReport)

        self.toolsmenu = Menu(self.menubar, tearoff=0)
        n = 0
        if self.settings.platercmd is not None:
            n += 1
            self.toolsmenu.add_command(label="Plater", command=self.doPlater)

        if self.settings.gcodeviewcmd is not None:
            n += 1
            self.toolsmenu.add_command(label="GCode Viewer", command=self.doGCodeView)

        if self.settings.stlviewcmd is not None:
            n += 1
            self.toolsmenu.add_command(label="STL Viewer", command=self.doSTLView)

        if self.settings.openscadcmd is not None:
            n += 1
            self.toolsmenu.add_command(label="OpenSCAD", command=self.doOpenSCAD)

        if n > 0:
            self.menubar.add_cascade(label="Tools", menu=self.toolsmenu)

        try:
            self.master.config(menu=self.menubar)
        except AttributeError:
            self.master.tk.call(master, "config", "-menu", self.menubar)

        self.toolbar = ToolBar(self, self.printer, self.settings, self.logger)
        self.toolbar.grid(row=1, column=1, columnspan=4, sticky=W)

        self.ctl = MoveControl(self, self.printer, self.settings, self.logger)
        self.ctl.grid(row=2, column=1, rowspan=3, sticky=N)

        self.extr = Extruder(self, self.printer, self.settings, self.logger)
        self.extr.grid(row=2, column=2, rowspan=1, sticky=N + E + W)

        self.temps = Temperatures(self, self.printer, self.settings, self.logger)
        self.temps.grid(row=3, column=2, rowspan=2, sticky=N + E + W)

        self.gc = GcFrame(self, None, [], self.settings, self.logger)
        self.gc.grid(row=2, column=3, rowspan=3, sticky=N)

        self.statline = Status(self, self.printer, self.settings, self.logger)
        self.statline.grid(row=5, column=1, columnspan=4, sticky=E + W)

        self.logger.grid(row=2, column=4, rowspan=2, sticky=N + E + W)

        self.sendgcode = SendGCode(self, self.printer, self.settings, self.logger)
        self.sendgcode.grid(row=4, column=4, sticky=N + E + W)

        self.printer.errorcb = self.errorcb
        self.printer.sendcb = self.sendcb
        self.printer.recvcb = self.recvcb

        self.sd = SDCard(self, self.printer, self.settings, self.logger)
        self.firmware = FirmwareParms(self, self.printer, self.settings, self.logger)
        self.bind(MWM_FIRMWARECOMPLETE, self.firmwareReportComplete)
        self.bind(MWM_SLICERCOMPLETE, self.sliceComplete)
        self.bind(MWM_GCODELOADCOMPLETE, self.loadgcodeFinished)
        self.bind(MWM_GEDITMEASURECOMPLETE, self.geditMeasureComplete)
        self.bind(MWM_REQUESTPOSITIONREPORT, self.requestPosition)

        self.doShowButtons()
Example #21
0
class CalendarZone(Frame):
    """
    Classe contenant la barre d'outil et la zone d'affichage.
    """
    def __init__(self, master=None, periodeManager=None, **kwargs):
        """
        Constructeur de CalendarZone.
        @param master: master du tkinter.Frame() que cet objet est.
        @param periodeManager: le PeriodeManager pour la barre d'outil des périodes, connue dans cet objet.
        @param **kwargs: Les options d'affichages pour le tkinter.Frame() que cet objet est.
        """
        Frame.__init__(self, master, **kwargs)
        # Note : self.master est référence vers l'Application.

        self.__isBarrePeriode = False
        # Barre du haut
        self.outilBar = ToolBar(self)  # frame avec tous les boutons outils
        self.outilBar.pack(side=TOP, fill=X, expand=NO)

        # Barre du haut pour les périodes
        self.outilBarPeriode = PeriodToolBar(
            self, periodeManager)  # frame avec tous les boutons outils

        # Zone calendrier
        self.zoneDynamicCalendarFrame = ZoneAffichage(
            self
        )  # frame avec la zone d'affichage des paramètre et la zone avec les données
        self.zoneDynamicCalendarFrame.pack(side=BOTTOM, fill=BOTH, expand=YES)

    ""  # Pour le repli de code je rappelle
    #############
    # Getters : #
    #############
    ""

    def getApplication(self):
        """
        Getter pour l'application.
        @return l'application.
        """
        return self.master

    def getBarreOutilActive(self):
        """
        Getter pour la barre d'outil des périodes active.
        @return la barre d'outil des périodes active.
        """
        if self.__isBarrePeriode:
            return self.outilBarPeriode
        else:
            return self.outilBar

    def getDonneeCalendrier(self):
        """
        Getter pour le DonneeCalendrier.
        @return le DonneeCalendrier.
        """
        return self.getZoneAffichage().getDonneeCalendrier()

    def getFirstAndLast(self):
        """
        Getter parmi les tâches sélectionnés
        Permet de déterminer la tache qui fini le plus tôt et la tache qui commence le plus tard
        @return first : (Task) tache qui fini le plus tôt
        @return last  : (Task) tache qui commence le plus tard
        """

        # Manière la plus simple avec min() et max() comme ceci, le critère se faisant suivant la lambda :
        first = min(self.getDonneeCalendrier().getSelectedSchedulable(),
                    key=lambda t: t.getFin())
        last = max(self.getDonneeCalendrier().getSelectedSchedulable(),
                   key=lambda t: t.getDebut())

        return first, last

    def getPanneauActif(self):
        """
        Getter pour le panneau actif dans DonneeCalendrier.
        @return le panneau actif dans DonneeCalendrier.
        """
        return self.getZoneAffichage().getPanneauActif()

    def getParametreAffichage(self):
        """
        Getter pour les ParametreAffichage.
        @return le ParametreAffichage.
        """
        return self.getZoneAffichage().getParametreAffichage()

    def getPeriodeActive(self):
        """
        Getter de la periode active.
        @return la période active.
        """
        return self.getDonneeCalendrier().getPeriodeActive()

    def getZoneAffichage(self):
        """
        Getter pour la ZoneAffichage.
        @return la ZoneAffichage.
        """
        return self.zoneDynamicCalendarFrame

    ""
    #############
    # Setters : #
    #############
    ""

    def setBarreOutilPeriode(self, value):
        """
        Permet de switcher entre la barre d'outil normale
        et la barre d'outil des périodes.
        @param value: True si c'est la barre d'outil des périodes, False sinon.
        """
        self.__isBarrePeriode = value
        if value:
            self.outilBarPeriode.pack(side=TOP, fill=X, expand=NO)
            self.outilBar.pack_forget()
        else:
            self.outilBarPeriode.pack_forget()
            self.outilBar.pack(side=TOP, fill=X, expand=NO)

    ""
    #####################################################
    # Pour la barre d'outil des calendriers standards : #
    #####################################################
    ""

    def afficherMasquerJour(self):
        """
        Permet d'afficher ou masquer un jour...
        """
        self.getBarreOutilActive().changeAfficherMasquerMode(
            askAfficherMasquer(self.getApplication().getPeriodManager()))
        # On se met à jour
        self.getDonneeCalendrier().updateAffichage()

    def ajouterHeure(self):
        """
        Méthode exécutée par la barre d'outil des périodes
        quand l'utilisateur appuie sur le bouton pour rajouter des heures.
        """
        min = self.getDonneeCalendrier().getHeureDebut()
        max = datetime.timedelta(hours=23) - datetime.timedelta(
            hours=self.getDonneeCalendrier().getHeureFin().hour)
        max2 = self.getDonneeCalendrier().getHeureFin()
        nbHeure = max2.hour - min.hour
        nb, pos = askAjouterHeure(min, max, nbHeure)
        self.gestionHeure(nb, pos)
        self.getDonneeCalendrier().updateAffichage(force=True)

    def ajouterJour(self):
        """
        Méthode exécutée par la barre d'outil des périodes
        quand l'utilisateur appuie sur le bouton pour rajouter des jours.
        """
        totalJour = self.getDonneeCalendrier().getLongueurPeriode().days - 1
        nb, pos = askAjouterJour(totalJour)
        self.gestionJour(nb, pos)

    def avancementMannuel(self):
        """
        Permet de valider les tâches sélectionnées.
        """
        schedulables = []
        for schedulable in self.getPeriodeActive().getInstanciatedSchedulables(
        ):  # On peut prendre Instanciated car on ne valide pas les taches conteneurs
            if schedulable.isSelected():
                schedulables.extend(schedulable.setDone(True))

        self.getApplication().getTaskEditor().redessiner()
        if schedulables != []:
            UndoRedoTasksValidations(schedulables)

    def avancementNormal(self):
        """
        Valide TOUTES les tâches qui sont avant maintenant.
        """
        schedulables = []
        now = datetime.datetime.now()
        for schedulable in self.getDonneeCalendrier().getPeriodeActive(
        ).getInstanciatedSchedulables():
            if schedulable.getFin() <= now:
                schedulables.extend(schedulable.setDone(True))

            #schedulable.updateStatut() fait dans la methode setDone()
        self.getApplication().getTaskEditor().redessiner()
        if schedulables != []:
            UndoRedoTasksValidations(schedulables)

    def avancementJourFini(self):
        """
        Valide toutes les tâches qui sont terminées aujourd'hui.
        """
        schedulables = []
        now = datetime.date.today()
        for tache in self.getDonneeCalendrier().getPeriodeActive(
        ).getInstanciatedSchedulables():
            if tache.getFin().date() == now:
                schedulables.extend(tache.setDone(True))

        self.getApplication().getTaskEditor().redessiner()
        if schedulables != []:
            UndoRedoTasksValidations(schedulables)

    def decalerHeure(self):
        """
        Permet de décaler les tâches sélectionnées par l'utilisateur,
        d'un certain nombre d'heures, suivant ce que l'utilisateur souhaite.
        Un message lui sera demandé si jamais cela dépasse de la journée.
        """
        # Si la liste est vide on évite la question
        if len(list(self.getDonneeCalendrier().getSelectedSchedulable())) == 0:
            return

        # On détermine le nombre d'heure min et max
        first, last = self.getFirstAndLast()

        periode = self.getPeriodeActive()

        heureDebut = self.getDonneeCalendrier().getHeureDebut()
        heureFin = self.getDonneeCalendrier().getHeureFin()

        lastDiffJour = (
            last.getDebut().date() -
            periode.getDebut()).days  # .days pour int-ifier le tout
        firstDiffJour = (periode.getFin() - first.getFin().date()).days
        heureRetirerMax = last.getDebut().hour + lastDiffJour * 24
        heureAjoutMax = heureFin.hour - first.getFin(
        ).hour + 1 + firstDiffJour * 24
        nb, pos, param = askDecalHeure(heureRetirerMax, heureAjoutMax,
                                       heureDebut, heureFin,
                                       last.getDebut().hour - heureDebut.hour,
                                       heureFin.hour - first.getFin().hour + 1)

        if nb is None or pos is None or param is None or nb == 0:
            return

        # Ajustement des heures
        horsChamp = False

        # map des undo-redo-s :
        mapIDBeginTaskBefore = {}
        mapIDBeginTaskAfter = {}

        for tache in self.getDonneeCalendrier().getSelectedSchedulable():
            if isinstance(tache, Task):
                # map d'avant le déplacement :
                mapIDBeginTaskBefore[tache.getUniqueID()] = tache.getDebut()

                # Si tout va bien
                if  (tache.getDebut()+datetime.timedelta(hours=nb)).date() == (tache.getFin()+datetime.timedelta(hours=nb)).date()\
                and heureDebut <= (tache.getDebut()+datetime.timedelta(hours=nb)).time()\
                and heureFin   >= (tache.getFin()+datetime.timedelta(hours=nb)).time():
                    tache.setDebut(tache.getDebut() +
                                   datetime.timedelta(hours=nb))

                # Si on dépasse, on cadre selon les limites et mode bloquer
                elif param == "bloquer":
                    # Si on retire des heures au début
                    if nb < 0:
                        # On peut pas mettre un
                        tache.setDebut(
                            datetime.datetime.combine(tache.getDebut().date(),
                                                      heureDebut))
                    # Si on ajoute pour mettre à la fin
                    else:
                        heureFin = heureFin  # Time
                        time = datetime.datetime.combine(
                            tache.getFin().date(), heureFin) - tache.getDuree(
                            )  # datetime - timedelta
                        tache.setDebut(time)

                # Si on dépasse et que l'on ne bloque pas
                elif param == "duree":
                    tache.setDebut(tache.getDebut() +
                                   datetime.timedelta(hours=nb))
                    horsChamp = True

                # Si au final il y a des tâches hors champs on demande si on affiche les heures pour voir le.s tache.s
                if horsChamp and askChangerHeure():
                    timeAvant = heureDebut
                    timeApres = heureFin
                    tacheAvant = None
                    tacheApres = None
                    for tache in self.getDonneeCalendrier().getSelectedTask():
                        # Si le début est avant la fin (hors date) ET qu'il est avant le referent
                        if tache.getDebut().time() < tache.getFin().time(
                        ) and tache.getDebut().time() < timeAvant:
                            tacheAvant = tache
                            timeAvant = tache.getDebut().time()

                        # Si la fin est avant le début (hors date) ET qu'il est avant le referent
                        elif tache.getDebut().time() > tache.getFin().time(
                        ) and tache.getFin().time() < timeAvant:
                            tacheAvant = tache
                            timeAvant = tache.getFin().time()

                        # Si la fin est après le début (hors date) ET qu'il est après le referent
                        if tache.getDebut().time() < tache.getFin().time(
                        ) and tache.getFin().time() > timeApres:
                            tacheApres = tache
                            timeApres = tache.getFin().time()

                        # Si le début est après la fin (hors date) ET qu'il est après le referent
                        elif tache.getDebut().time() > tache.getFin().time(
                        ) and tache.getDebut().time() > timeApres:
                            tacheApres = tache
                            timeApres = tache.getDebut().time()

                    # Maintenant on applique les changements
                    if tacheAvant is not None:
                        addAvant = heureDebut.hour - timeAvant.hour
                        self.gestionHeure(addAvant, "Avant")
                    if tacheApres is not None:
                        addApres = timeApres.hour - heureFin.hour
                        self.gestionHeure(addApres, "Apres")

                # map d'après le déplacement :
                mapIDBeginTaskAfter[tache.getUniqueID()] = tache.getDebut()

        # Undo-redo :
        UndoRedoDecaler(self.getPeriodeActive(), mapIDBeginTaskBefore,
                        mapIDBeginTaskAfter)

        # Update affichage :
        self.getDonneeCalendrier().updateAffichage(True)

    def decalerJour(self):
        """
        Permet de décaler les tâches sélectionnées par l'utilisateur,
        d'un certain nombre de jours, suivant ce que l'utilisateur souhaite.
        Un message lui sera demandé si jamais cela dépasse de la période.
        """
        # Si la liste est vide on évite la question
        if len(list(self.getDonneeCalendrier().getSelectedSchedulable())) == 0:
            return

        # On détermine le nombre de jour min et max
        first, last = self.getFirstAndLast()

        debut = self.getPeriodeActive().getDebut()  # Date de début
        fin = self.getPeriodeActive().getFin()  # Date de fin

        # Les variables ci-dessous calculent le nombre max de jours pour le décalage
        # si il y a un bloquage dans un sens ou dans l'autre. Cependant, quand on
        # bloque, on peut bouger jusqu'à ce que la fin de la tâche la plus tôt
        # atteigne la fin de la période ; ou que le début de la tâche la plus tard
        # atteigne le début de la période.
        jourRetireBloque = (last.getDebut().date() - debut).days
        jourAjoutBloque = (fin - first.getFin().date()).days

        # Appel du dialogue à l'utilisateur :
        nb, pos, param = askDecalJour(debut, fin, jourRetireBloque,
                                      jourAjoutBloque)

        if nb is None or pos is None or param is None or nb == 0:
            return

        # Ajustement des jours
        horsChamp = False
        duree = datetime.timedelta(days=nb)

        # map des undo-redo-s :
        mapIDBeginTaskBefore = {}
        mapIDBeginTaskAfter = {}

        for tache in self.getDonneeCalendrier().getSelectedSchedulable():
            if isinstance(tache, Task):  # TODO avec groupe.
                # map d'avant le déplacement :
                mapIDBeginTaskBefore[tache.getUniqueID()] = tache.getDebut()
                # Si tout va bien
                if  debut <= (tache.getDebut()+duree).date()\
                and fin   >= (tache.getFin()+duree).date():
                    tache.setDebut(tache.getDebut() + duree)

                # Si on dépasse, on cadre selon les limites et mode bloquer
                elif param == "bloquer":
                    # Si on retire des heures au début
                    if nb < 0:
                        # On peut pas mettre un
                        tache.setDebut(
                            datetime.datetime.combine(debut,
                                                      tache.getDebut().time()))
                    # Si on ajoute pour mettre à la fin
                    else:
                        time = datetime.datetime.combine(
                            fin,
                            tache.getFin().time()) - tache.getDuree(
                            )  # datetime - timedelta
                        tache.setDebut(time)

                # Si on dépasse et que l'on ne bloque pas
                elif param == "duree":
                    tache.setDebut(tache.getDebut() +
                                   datetime.timedelta(days=nb))
                    horsChamp = True

                # Si au final il y a des tâches hors champs on demande si on affiche les heures pour voir le.s tache.s
                if horsChamp:
                    horsChamp = False
                    choix, periode = askComplicationjour(
                        tache,
                        self.getApplication().getPeriodManager())
                    # On annule les changements
                    if choix is None:
                        tache.setDebut(tache.getDebut() -
                                       datetime.timedelta(days=nb))
                        continue
                    # On agrandit la période
                    elif choix == "agrandir":
                        if tache.getDebut().date() < debut:
                            addAvant = (debut - tache.getDebut().date()).days
                            self.gestionJour(addAvant, "Avant")

                        else:
                            addApres = (last.getFin().date() - fin).days
                            self.gestionJour(addApres, "Apres")
                    elif choix == "supprimer":  # TODO supprimer la tache
                        pass
                    elif choix == "independante":  # TODO rendre la tache indépendante
                        pass
                    elif choix == "changer":
                        tache.setPeriode(periode)

                # map d'après le déplacement :
                mapIDBeginTaskAfter[tache.getUniqueID()] = tache.getDebut()

        # Undo-redo :
        UndoRedoDecaler(self.getPeriodeActive(), mapIDBeginTaskBefore,
                        mapIDBeginTaskAfter)

        self.getDonneeCalendrier().updateAffichage(True)

    def degrouper(self):
        """
        Permet de dégrouper un groupe.
        """
        # Obtention de la période et des schedulables instanciés sélectionnés :
        periode = self.getDonneeCalendrier().getPeriodeActive()
        schedulables = set(self.getDonneeCalendrier().getSelectedSchedulable())
        schedPerGroup = {}  # dictionnaire des tâches à dégrouper, par groupe.
        # Calcul des tâches à enlever par groupes :
        for schedulable in set(schedulables):
            if isinstance(schedulable, Groupe):
                if schedulable not in schedPerGroup:
                    schedPerGroup[schedulable] = set()
            else:  # Task
                groupe = schedulable.getGroupe()
                if groupe is None:
                    showerror(
                        "Erreur de sélection",
                        "Vous ne pouvez pas dégrouper des tâches qui ne sont pas dans un groupe."
                    )
                    return
                if groupe not in schedPerGroup:
                    schedPerGroup[groupe] = set()
                schedPerGroup[groupe].add(schedulable)

        # Pour chaque groupes sélectionnés :
        for groupe in schedPerGroup:
            # Ré-ajout au calendrier des tâches qui étaient dans le groupe :
            for t in schedPerGroup[groupe] if schedPerGroup[
                    groupe] else groupe.getListTasks():
                groupe.removeTask(t, testDelete=True)

            # Demande de suppression du groupe, s'il n'y a plus qu'une tâche :
            if len(groupe.getListTasks()) == 1:
                if askyesnowarning(
                        title="Édition du groupe",
                        message=
                        'Le groupe "%s" ne possède plus qu\'une tache :\n\t- %s\nVoulez-vous supprimer le groupe ?'
                        % (groupe.getNom(), list(
                            groupe.getListTasks())[0].getNom())):
                    groupe.removeTask(list(groupe.getListTasks())[0],
                                      testDelete=True)
                    # Le groupe va s'auto-delete avec le testDelete.

        # Mise à jour de l'affichage qu'à la fin :
        self.getApplication().getTaskEditor().redessiner()
        self.getDonneeCalendrier().updateAffichage(
            True)  # True = on force la total, car suppression d'objet.

    def deplacerIntervertir(self):
        """
        Permet d'intervertir 2 jours exactement.
        Ce sont ceux sélectionnés par l'utilisateur.
        """
        self.getDonneeCalendrier().intervertir()

    def gestionHeure(self, nombreHeure, position):
        """
        Fonction qui s'occupe de rajouter des heures visibles.
        En dehors de la fonction ajouterHeure lié au bouton car on pourrait avoir à ajouter des heures autrement que par le bouton
        @param nombreHeure : int relatif, permet d'ajouter ou retirer des heures
        @param position    : string "Avant" / "Apres" pour savoir ou appliquer les changements
        """
        if nombreHeure is not None and position is not None:
            if position == "Avant":
                timeHeure = datetime.time(
                    self.getDonneeCalendrier().getHeureDebut().hour -
                    nombreHeure)
                self.getDonneeCalendrier().setHeureDebut(timeHeure)
            elif position == "Apres":
                timeHeure = datetime.time(
                    self.getDonneeCalendrier().getHeureFin().hour +
                    nombreHeure,
                    self.getDonneeCalendrier().getHeureFin().minute)
                self.getDonneeCalendrier().setHeureFin(timeHeure)

    def gestionJour(self, nombreDeJour, position):
        """
        Fonction qui s'occupe d'ajouter ou de supprimer des jours
        En dehors de la fonction ajouterJour lié au bouton car on pourrait avoir à ajouter des jours autrement que par le bouton
        @param nombreDeJour : int relatif, permet d'ajouter ou retirer des jours
        @param position     : string "Avant" / "Apres" pour savoir ou appliquer les changements
        """
        if nombreDeJour is not None and position is not None:
            periode = self.getPeriodeActive()
            if position == "Avant":
                self.getDonneeCalendrier().setPeriodeActiveDebut(
                    periode.getDebut() - datetime.timedelta(days=nombreDeJour))
            elif position == "Apres":
                self.getDonneeCalendrier().setPeriodeActiveFin(
                    periode.getFin() + datetime.timedelta(days=nombreDeJour))

            # Mise à jour du Combobox
            self.getParametreAffichage().updateComboboxNbJour()

    def grouper(self):
        """
        Permet de grouper les tâches.
        """
        periode = self.getPeriodeActive()
        schedulables = list(
            self.getDonneeCalendrier().getSelectedSchedulable())
        # Petite vérification :
        if len(schedulables) < 2:
            return showerror(
                "Sélection invalide",
                "Vous devez avoir au moins 2 éléments sélectionner pour pouvoir les grouper."
            )
        groupe = None
        taches = []
        for obj in schedulables:
            if isinstance(obj, Groupe):
                if groupe is None:
                    groupe = obj
                elif groupe != obj:
                    return showerror(
                        "Sélection invalide",
                        "Vous ne pouvez pas grouper des tâches dans plusieurs groupes."
                    )
            elif not isinstance(obj, Task):
                return showerror("Sélection invalide",
                                 "Vous ne pouvez grouper que des tâches.")
            else:
                taches.append(obj)

        # Création du groupe :
        ajout = True
        if groupe:
            ajout = False
        groupe = groupe or askGroup(periode)
        if groupe is None:
            return

        for t in taches:
            groupe.addTask(t)

        if ajout:
            periode.addPrimitiveSchedulable(groupe)
            self.getApplication().getTaskEditor().redessiner()
            groupe.instantiate()
            self.getDonneeCalendrier().updateAffichage()

    def selectionnerJour(self):
        """
        Méthode pour demander un jour à sélectionner à l'utilisateur, pour le sélectionner ensuite où qu'il soit.
        """
        jour = askdate()
        if jour is not None:
            donneeCalendrier = self.getDonneeCalendrier()
            if jour >= donneeCalendrier.getDebutPeriode(
            ) and jour <= donneeCalendrier.getFinPeriode():
                donneeCalendrier.deselectJours()
                donneeCalendrier.selectJour(jour)
                dureeJours = donneeCalendrier.getDureeJour()
                if donneeCalendrier.getJourDebut() > jour:
                    donneeCalendrier.setJourDebut(jour)
                    donneeCalendrier.setDureeJour(dureeJours)
                    donneeCalendrier.updateAffichage()
                elif donneeCalendrier.getJourFin() < jour:
                    donneeCalendrier.setJourFin(jour)
                    donneeCalendrier.setJourDebut(jour - dureeJours +
                                                  datetime.timedelta(days=1))
                    donneeCalendrier.updateAffichage()
            else:
                # TODO : mettre dans le dialogue lui-même
                showerror(
                    "Date invalide",
                    "La date que vous avez choisie est en dehors des limites de la période."
                )

    ""
    ########################################
    # Pour la barre d'outil des périodes : #
    ########################################
    ""

    def voirTacheDansVue(self):
        """
        Permet de voir une tâche dans une autre vue, via demande
        à l'utilisateur dans une boîte de dialogue usuelle.
        TODO
        """
        pass

    def supprimerTache(self):
        """
        Permet de supprimer une tâche indépendante.
        Fera-t-on des groupes indépendants ? Si oui -> renommer en supprimerSchedulable()...
        TODO
        """
        pass
Example #22
0
    def interactive(self):
        """ interactive shell"""
        self.op = ShellOperations()
        self.bindings = KeyBindings()
        cat_Storage = []
        line = ""
        self.toolBar = ToolBar()
        input_History = InMemoryHistory()
        operators = ["+", "-", "*", '**', '<', ">"]
        returnShellMethods = {"tod": self.op.do_tod()}
        listofprintMethods = [
            "meow", "help", "bll", "h", "cur", "bdir", "bl", "sh", 'wc', 'get',
            'cwl', 'cdir', 'man'
        ]
        linux_Commands = WordCompleter(listofprintMethods)

        while (True):  #excute while True
            enter_commands = prompt(
                ">>",
                history=input_History,
                key_bindings_registry=self.bindings.register,
                completer=linux_Commands,
                mouse_support=True,
                get_title=self.get_title,
                get_bottom_toolbar_tokens=self.toolBar.
                get_bottom_toolbar_tokens,
                style=self.toolBar.toolBarStyle)
            store = enter_commands
            store = store.split(" ")
            if (enter_commands in returnShellMethods.keys()):
                print(returnShellMethods[enter_commands])
            if (enter_commands not in returnShellMethods.keys()) and (
                    enter_commands
                    not in listofprintMethods) and (store[0]
                                                    not in listofprintMethods):
                try:
                    exec(enter_commands)
                except Exception as Err:
                    print(Err)
            if (enter_commands == 'cl'):
                self.op.do_cl()
            if (
                    enter_commands == "exit"
            ):  #if enter_commands equal to exit then exit interactive shell
                os.system("exit")
            if (len(enter_commands) > 1) and (enter_commands[1] in operators):
                try:
                    print(eval(enter_commands))
                except Exception as err:
                    print(err)
            if (enter_commands in listofprintMethods) and (enter_commands
                                                           == "bll"):
                self.op.do_bll()
            if (enter_commands == "h") and (enter_commands
                                            in listofprintMethods):
                self.op.do_h(line)
            if (enter_commands == "cur") and (enter_commands
                                              in listofprintMethods):
                self.op.do_cur(line)
            if (enter_commands == "bdir") and (enter_commands
                                               in listofprintMethods):
                self.op.do_bdir(line)
            if (enter_commands == 'bl') and (enter_commands
                                             in listofprintMethods):
                self.op.do_bl(line)
            if (store[0] == "sh") and (store[0] in listofprintMethods):
                try:
                    self.op.do_show(store[1])
                except Exception as err:
                    self.op.do_show(line)
            if (store[0] == "wc") and (store[0] in listofprintMethods):
                try:
                    self.op.do_cw(store[1])
                except Exception as err:
                    self.op.do_cw(line)
            if (store[0] == 'get') and (store[0] in listofprintMethods):
                try:
                    self.op.do_get(store[1])
                except Exception as err:
                    self.op.do_get(line)

            if (store[0] == "cwl") and (store[0] in listofprintMethods):
                try:
                    self.op.do_cwl(store[1])
                except Exception as err:
                    self.op.do_cwl(line)
            if (store[0] == "cdir") and (store[0] in listofprintMethods):
                try:
                    self.op.do_cdir(store[1])
                except Exception as err:
                    self.op.do_cdir(line)
            if (store[0] == "help") and (store[0] in listofprintMethods):
                try:
                    self.op.do_help(store[1])
                except Exception as err:
                    self.op.do_help(line)

            if (store[0] == "meow") and (store[0] in listofprintMethods):
                if (len(store) == 1):
                    self.op.do_cat(line)

                if (len(store) == 2):
                    if (do_cat_return[0] in dir()):
                        for cat_evaluation in eval(do_cat_return[0]):
                            print(cat_evaluation)

            if (store[0] == "meow") and (store[0]
                                         in listofprintMethods) and (len(store)
                                                                     == 3):
                do_cat_return = self.op.do_cat(store)
                exec(str(do_cat_return))
Example #23
0
class GeoLogic(Gtk.Window):
    def __init__(self):
        super(GeoLogic, self).__init__()

        self.imported_tools = load_tools("macros.gl")
        self.env = GraphicalEnv(self.imported_tools)
        self.vis = self.env.vis
        self.general_tools = GToolDict(self.imported_tools.tool_dict)
        self.keyboard_capture = None

        menu_items = (
            ("Undo", self.undo, "<Control>z"),
            ("Redo", self.redo, "<Control><Shift>z"),
            ("Reset", self.restart, "<Control>n"),
            ("Open...", self.load, "<Control>o"),
            ("Save", self.save, "<Control>s"),
            ("Save as...", self.save_as, "<Control><Shift>s"),
            ("Export SVG...", self.export_svg, "<Control><Shift>e"),
            ("Quit", self.on_exit, "<Control>q"),
        )
        gtools = (
            ComboPoint(),
            ComboLine(),
            ComboPerpLine(),
            ComboCircle(),
            ComboCircumCircle(),
            GToolMove(),
            GToolHide(),
            GToolLabel(),
            GToolReason(),
        )
        self.key_to_gtool = dict(
            (gtool.get_key_shortcut(), gtool) for gtool in gtools)

        vbox = Gtk.VBox()
        self.add(vbox)

        self.toolbar = ToolBar(menu_items, gtools, self.general_tools)
        vbox.pack_start(self.toolbar, False, False, 0)

        hpaned = Gtk.HPaned()
        vbox.add(hpaned)
        self.step_list = StepList(self.env)
        hpaned.pack1(self.step_list, False, True)

        self.viewport = Viewport(self.env, self)
        self.viewport.set_tool(ComboPoint())
        hpaned.pack2(self.viewport.darea, True, False)
        hpaned.set_position(250)

        self.viewport.click_hook = self.toolbar.entry.unselect
        self.toolbar.set_entry_unselect(self.viewport.darea.grab_focus)
        self.toolbar.change_tool_hook = self.viewport.set_tool
        self.add_accel_group(self.toolbar.accelerators)

        def update_progress_bar(done, size):
            if size == 0: self.progress_bar.set_fraction(0)
            else: self.progress_bar.set_fraction(done / size)
            return False

        def update_progress_bar_idle(done, size):
            GLib.idle_add(update_progress_bar, done, size)

        proof_checker.paralelize(progress_hook=update_progress_bar_idle)

        self.progress_bar = Gtk.ProgressBar(show_text=False)
        vbox.pack_end(self.progress_bar, False, False, 0)

        self.connect("key-press-event", self.on_key_press)
        self.connect("key-release-event", self.on_key_release)
        self.connect("delete-event", self.on_exit)
        self.resize(1000, 600)
        self.set_position(Gtk.WindowPosition.CENTER)
        self.set_events(Gdk.EventMask.KEY_PRESS_MASK
                        | Gdk.EventMask.KEY_RELEASE_MASK)

        self.show_all()

        self.update_title(None)

    # changes the default filename for saving and the title of the window
    def update_title(self, fname):
        self.default_fname = fname
        title = "GeoLogic"
        if fname is not None:
            title = "{} -- {}".format(title, fname.split('/')[-1])
        self.set_title(title)

    def reset_view(self):
        if self.vis.view_changed:
            self.viewport.gtool.reset()
            self.viewport.darea.queue_draw()

    def undo(self):
        proof_checker.disable()
        self.env.pop_step()
        self.reset_view()
        proof_checker.enable()

    def redo(self):
        self.env.redo()
        self.reset_view()

    def restart(self):
        #print("RESTART")
        self.update_title(None)
        self.viewport.reset_tool()
        self.env.set_steps((), ())
        self.viewport.reset_zoom()
        self.reset_view()

    def load(self):
        fname = select_file_open(self)
        self.load_file(fname)

    def save(self):
        fname = self.default_fname
        if fname is None: fname = select_file_save(self)
        self.save_file(fname)

    def save_as(self):
        fname = select_file_save(self)
        self.save_file(fname)

    def export_svg(self):
        fname = select_file_save(
            self,
            "Export SVG",
            folder="pictures",
            add_filters=add_svg_filters,
        )
        if fname is not None: self.viewport.export_svg(fname)

    def on_exit(self, *args):
        print_times()
        Gtk.main_quit()

    def load_file(self, fname):
        self.viewport.reset_tool()
        if fname is None: return
        self.update_title(fname)
        parser = Parser(self.imported_tools.tool_dict)
        parser.parse_file(fname, axioms=True)
        loaded_tool = parser.tool_dict['_', ()]
        steps = loaded_tool.assumptions
        names = [
            loaded_tool.var_to_name_proof[x]
            for x in range(len(loaded_tool.var_to_name_proof))
        ]
        if loaded_tool.implications:
            goals, proof = loaded_tool.implications, loaded_tool.proof
        else:
            goals, proof = None, None
        self.env.set_steps(steps, names=names, goals=goals, proof=proof)

        # hide objects
        visible = set(loaded_tool.result)  # old format
        if visible:
            for gi in range(len(self.vis.gi_to_hidden)):
                self.vis.gi_to_hidden[gi] = gi not in visible
        for gi, name in enumerate(names):  # new format
            if ("hide__{}".format(name), ()) in parser.tool_dict:
                self.vis.gi_to_hidden[gi] = True

        # set labels
        for gi, name in enumerate(names):  # new format
            label_pos_tool = parser.tool_dict.get(
                ("label__{}".format(name), ()), None)
            if label_pos_tool is not None:
                self.vis.gi_label_show[gi] = True
                logic = LogicalCore(basic_tools=self.imported_tools)
                pos_l = label_pos_tool.run((), (), logic, 0)
                pos_n = [logic.num_model[x] for x in pos_l]
                t = self.vis.gi_to_type(gi)
                if t == Point:
                    point, = pos_n
                    position = point.a
                    print(position)
                elif t == Line:
                    position = tuple(d.x for d in pos_n)
                elif t == Circle:
                    ang, offset = pos_n
                    position = ang.data * 2, offset.x
                else:
                    print(
                        "Warning: save label: unexpected type {} of {}".format(
                            t, name))
                    continue
                self.vis.gi_label_position[gi] = position

        self.vis.refresh()

        # viewport zoom and position
        view_data_tool = parser.tool_dict.get(('view__data', ()), None)

        if view_data_tool is None:
            self.viewport.set_zoom((375, 277), 1)
        else:
            logic = LogicalCore(basic_tools=self.imported_tools)
            anchor_l, zoom_l = view_data_tool.run((), (), logic, 0)
            anchor = logic.num_model[anchor_l].a
            zoom = logic.num_model[zoom_l].x
            self.viewport.set_zoom(anchor, zoom)

        self.reset_view()

    def save_file(self, fname):
        if fname is None: return
        print("saving to '{}'".format(fname))
        self.update_title(fname)
        with open(fname, 'w') as f:
            #visible = [
            #    "{}:{}".format(
            #        self.env.gi_to_name[gi],
            #        type_to_c[self.vis.gi_to_type(gi)]
            #    )
            #    for gi,hidden in enumerate(self.vis.gi_to_hidden)
            #    if not hidden
            #]
            #f.write('_ -> {}\n'.format(' '.join(sorted(visible))))
            f.write('_ ->\n')

            def write_step(step):
                tokens = [self.env.gi_to_name[x] for x in step.local_outputs]
                tokens.append('<-')
                tokens.append(step.tool.name)
                tokens.extend(map(str, step.hyper_params))
                tokens.extend(self.env.gi_to_name[x] for x in step.local_args)
                f.write('  ' + ' '.join(tokens) + '\n')

            if self.env.goals is None:
                for step in self.env.steps:
                    write_step(step)
            else:
                for step in self.env.steps[:self.env.min_steps]:
                    write_step(step)
                f.write('  THEN\n')
                for step in self.env.goals:
                    write_step(step)
                f.write('  PROOF\n')
                for step in self.env.steps[self.env.min_steps:]:
                    write_step(step)

            # hidden objects and labels
            f.write("\n")
            for gi, (name, hidden, label_show, label_pos) in enumerate(
                    zip(self.env.gi_to_name, self.vis.gi_to_hidden,
                        self.vis.gi_label_show, self.vis.gi_label_position)):
                if hidden: f.write("hide__{} ->\n".format(name))
                if label_show:
                    t = self.vis.gi_to_type(gi)
                    if t == Point:
                        label_attrs = [('pos', 'P', 'free_point',
                                        tuple(map(float, label_pos)))]
                    elif t == Line:
                        pos, offset = label_pos
                        label_attrs = [
                            ('pos', 'D', 'custom_ratio', (float(pos), 0.)),
                            ('offset', 'D', 'custom_ratio', (float(offset),
                                                             0.)),
                        ]
                    elif t == Circle:
                        direction, offset = label_pos
                        label_attrs = [
                            ('direction', 'A', 'custom_angle',
                             (float(direction / 2), )),
                            ('offset', 'D', 'custom_ratio', (float(offset),
                                                             0.)),
                        ]
                    else:
                        print("Warning: save label: unexpected type {} of {}".
                              format(t, name))
                        continue
                    label_attr_names = [
                        "{}:{}".format(attr_name, t)
                        for attr_name, t, _, _ in label_attrs
                    ]
                    f.write("label__{} -> {}\n".format(
                        name, ' '.join(label_attr_names)))
                    for attr_name, _, attr_constructor, attr_values in label_attrs:
                        f.write("  {} <- {} {}\n".format(
                            attr_name, attr_constructor,
                            ' '.join(map(str, attr_values))))

            # writing current zoom and position
            f.write("\n")
            f.write("view__data -> anchor:P zoom:D\n")
            f.write("  anchor <- free_point {} {}\n".format(
                *self.viewport.view_center))
            f.write("  zoom <- custom_ratio {} 0.\n".format(
                self.viewport.scale))

        self.reset_view()

    def on_key_press(self, w, e):

        if self.keyboard_capture is not None:
            return self.keyboard_capture(e)

        keyval = e.keyval
        keyval_name = Gdk.keyval_name(keyval)
        modifier = Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK
        if e.state & modifier: return False
        if self.toolbar.entry.is_focus(): return

        if keyval_name == "Return":
            self.toolbar.entry.select()
            return True
        elif keyval_name == "Escape":
            self.viewport.gtool.reset()
            if self.viewport.vis.view_changed:
                self.viewport.darea.queue_draw()
            return True
        elif keyval_name in self.key_to_gtool:
            gtool = self.key_to_gtool[keyval_name]
            self.toolbar.select_tool_button(gtool)
            self.reset_view()
            return True
        elif keyval_name.startswith("Shift"):
            self.viewport.update_shift_pressed(True)
            self.viewport.darea.queue_draw()
            return False
        else:
            #print(keyval_name)
            return False

    def on_key_release(self, w, e):
        keyval_name = Gdk.keyval_name(e.keyval)
        if keyval_name.startswith("Shift"):
            self.viewport.update_shift_pressed(False)
            self.viewport.darea.queue_draw()
Example #24
0
    def __init__(self):
        super(GeoLogic, self).__init__()

        self.imported_tools = load_tools("macros.gl")
        self.env = GraphicalEnv(self.imported_tools)
        self.vis = self.env.vis
        self.general_tools = GToolDict(self.imported_tools.tool_dict)
        self.keyboard_capture = None

        menu_items = (
            ("Undo", self.undo, "<Control>z"),
            ("Redo", self.redo, "<Control><Shift>z"),
            ("Reset", self.restart, "<Control>n"),
            ("Open...", self.load, "<Control>o"),
            ("Save", self.save, "<Control>s"),
            ("Save as...", self.save_as, "<Control><Shift>s"),
            ("Export SVG...", self.export_svg, "<Control><Shift>e"),
            ("Quit", self.on_exit, "<Control>q"),
        )
        gtools = (
            ComboPoint(),
            ComboLine(),
            ComboPerpLine(),
            ComboCircle(),
            ComboCircumCircle(),
            GToolMove(),
            GToolHide(),
            GToolLabel(),
            GToolReason(),
        )
        self.key_to_gtool = dict(
            (gtool.get_key_shortcut(), gtool) for gtool in gtools)

        vbox = Gtk.VBox()
        self.add(vbox)

        self.toolbar = ToolBar(menu_items, gtools, self.general_tools)
        vbox.pack_start(self.toolbar, False, False, 0)

        hpaned = Gtk.HPaned()
        vbox.add(hpaned)
        self.step_list = StepList(self.env)
        hpaned.pack1(self.step_list, False, True)

        self.viewport = Viewport(self.env, self)
        self.viewport.set_tool(ComboPoint())
        hpaned.pack2(self.viewport.darea, True, False)
        hpaned.set_position(250)

        self.viewport.click_hook = self.toolbar.entry.unselect
        self.toolbar.set_entry_unselect(self.viewport.darea.grab_focus)
        self.toolbar.change_tool_hook = self.viewport.set_tool
        self.add_accel_group(self.toolbar.accelerators)

        def update_progress_bar(done, size):
            if size == 0: self.progress_bar.set_fraction(0)
            else: self.progress_bar.set_fraction(done / size)
            return False

        def update_progress_bar_idle(done, size):
            GLib.idle_add(update_progress_bar, done, size)

        proof_checker.paralelize(progress_hook=update_progress_bar_idle)

        self.progress_bar = Gtk.ProgressBar(show_text=False)
        vbox.pack_end(self.progress_bar, False, False, 0)

        self.connect("key-press-event", self.on_key_press)
        self.connect("key-release-event", self.on_key_release)
        self.connect("delete-event", self.on_exit)
        self.resize(1000, 600)
        self.set_position(Gtk.WindowPosition.CENTER)
        self.set_events(Gdk.EventMask.KEY_PRESS_MASK
                        | Gdk.EventMask.KEY_RELEASE_MASK)

        self.show_all()

        self.update_title(None)
Example #25
0
 def create_toolbar(self):
     toolbar = ToolBar(self, 'Toolbar')
     self.addToolBar(toolbar)
Example #26
0
class CeFrame(Frame):
    '''\
    CeFrame is a frame designed to be a Windows CE compliant window.
    A CeFrame will track the SIP position and size and will automatically
    resize itself to always fit the screen.
    '''
    _dispatchers = {
        "_activate": (MSGEventDispatcher, WM_ACTIVATE),
        "_settingchanged": (MSGEventDispatcher, WM_SETTINGCHANGE),
    }
    _dispatchers.update(Frame._dispatchers)

    def __init__(self,
                 parent=None,
                 title="PocketPyGui",
                 action=None,
                 menu=None,
                 tab_traversal=True,
                 visible=True,
                 enabled=True,
                 has_sip=True,
                 has_toolbar=False):
        '''\
        Arguments :
            - parent: the parent window of this CeFrame.
            - title: the title as appearing in the title bar.
            - action : a tuple ('Label', callback) .
            - menu : the title of the right menu as a string
                     if not None, the menu can be filled via the cb_menu attribute
                     after CeFrame initialization.
        '''
        Frame.__init__(self,
                       parent,
                       title,
                       tab_traversal=tab_traversal,
                       visible=visible,
                       enabled=enabled)
        self.bind(_activate=self._on_activate,
                  _settingchanged=self._on_setting_changed)
        if has_toolbar:
            self.toolbar = ToolBar(self)
        else:
            self.toolbar = None
        self.__create_menubar(action, menu, has_sip)

    def layout(self):
        if self.toolbar is None:
            return Frame.layout(self)
        if self._sizer is not None:
            rc = RECT()
            GetClientRect(self._w32_hWnd, byref(rc))
            self._sizer.size(rc.left, rc.top, rc.right,
                             rc.bottom - 24 * HIRES_MULT)
            self.toolbar.move(rc.left, rc.bottom - 26 * HIRES_MULT,
                              rc.right - rc.left, 26 * HIRES_MULT)

    def __create_menubar(self, action, menu, has_sip):
        mbi = SHMENUBARINFO()
        mbi.cbSize = sizeof(SHMENUBARINFO)
        mbi.hwndParent = self._w32_hWnd
        mbi.hInstRes = GetModuleHandle(0)

        slots = []

        empty = True
        has_action = False
        has_menu = False

        if (action is None) and (menu is None):
            mbi.dwFlags = SHCMBF_EMPTYBAR

        else:
            empty = False
            temp_menu = Menu()
            i = 0
            if action is not None:
                label, cb = action
                action_item = temp_menu.append(label, callback=cb)
                #self.action = CommandBarAction(item, 0)
            else:
                action_item = temp_menu.append("", enabled=False)

            if menu is not None:
                sub_menu = PopupMenu()
                temp_menu.append_menu(menu, sub_menu)
                has_menu = True

            mbi.dwFlags = SHCMBF_HMENU
            mbi.nToolBarId = temp_menu._hmenu

        if not has_sip:
            mbi.dwFlags |= SHCMBF_HIDESIPBUTTON
        SHCreateMenuBar(byref(mbi))
        self._mb_hWnd = mbi.hwndMB

        if not empty:
            self.cb_action = CommandBarAction(mbi.hwndMB, 0, action_item)

            if has_menu:
                tbbi = TBBUTTONINFO()
                tbbi.cbSize = sizeof(tbbi)
                tbbi.dwMask = 0x10 | 0x80000000
                SendMessage(mbi.hwndMB, WM_USER + 63, 1, byref(tbbi))
                hMenu = tbbi.lParam
                self.cb_menu = CommandBarMenu(mbi.hwndMB, 0, hMenu)

        rc = RECT()
        GetWindowRect(self._w32_hWnd, byref(rc))
        rcmb = RECT()
        GetWindowRect(self._mb_hWnd, byref(rcmb))
        rc.bottom -= (rcmb.bottom - rcmb.top)
        self.move(rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top)

    def _on_activate(self, event):
        if not hasattr(self, '_shai'):
            self._shai = InitSHActivateInfo()
        SHHandleWMActivate(event.hWnd, event.wParam, event.lParam,
                           byref(self._shai), 0)

    def _on_setting_changed(self, event):
        SHHandleWMSettingChange(self._w32_hWnd, event.wParam, event.lParam,
                                byref(self._shai))

    def show_sipbutton(self, show=True):
        if show:
            SHFullScreen(self._w32_hWnd, SHFS_SHOWSIPBUTTON)
        else:
            SHFullScreen(self._w32_hWnd, SHFS_HIDESIPBUTTON)

    def hide_sipbutton(self):
        self.show_sipbutton(False)
Example #27
0
class MainWindow(object):

	def __init__(self, *args, **kwargs):
		self._toolbar = None
		self._menubar = None
		self._statusbar = None
	
		self._rootwidget = None
		self._centralwidget = None
		self._dockareas = {
				DOCKAREA['left']:None, 
				DOCKAREA['right']:None, 
				DOCKAREA['top']:None, 
				DOCKAREA['bottom']:None
			}
			
		self._toolbarareas = {
				DOCKAREA['left']:None, 
				DOCKAREA['right']:None, 
				DOCKAREA['top']:None, 
				DOCKAREA['bottom']:None
			}
			
		self.dockareamarker = None
			
	def initGui(self, screen_width, screen_height):
		bar_height = 30

		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))
		
		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
		
		# 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 getCentralWidget(self):
		return self._centralwidget
	
	def getStatusBar(self): 
		return self._statusbar
		
	def getMenuBar(self):
		return self._menubar
	
	def getToolBar(self): 
		return self._toolbar
	
	def dockWidgetTo(self, widget, dockarea, x=-1, y=-1):
		""" docks a B{Panel} widget to the given dock area
		
		@note:	
			- ToolBar needs special treatment, given x, y coordinates
			  have no effect on this Panel
			- x, y are cursor coordinates, without giving them the
			  widgets are added beneath the already existing ones
			  nice feature, but also makes problems on editor startup
			  (e.g. if a user docked 2 widgets left, on startup they
			   are added in a col instead of a grouped tab)
				
		@todo:	turn x,y documentation into something more useful
		
		@type	widget:	Panel
		@param	widget:	a panel widget instance
		@type	dockarea:	str
		@param	dockarea:	id of the target dock area
		@type	x:	int
		@param	x:	x coordinate
		@type	y:	int
		@param	y:	y coordinate
		"""
		if isinstance(widget, pychan.widgets.Widget) is False:
			print "Argument is not a valid widget"
			return
			
		if widget.parent:
			widgetParent = widget.parent
			widgetParent.removeChild(widget)
			widgetParent.adaptLayout()
			
		# We must hide the widget before adding it to the dockarea,
		# or we will get a duplicate copy of the widget in the top left corner
		# of screen.
		widget.hide() 
		dockareas = self._dockareas
		
		# Panel widgets which provide an implementation for set_orientation()
		# should check if they need to re-align themselves
		if hasattr(widget, 'set_orientation'):
			key = ''
			if dockarea == DOCKAREA['left'] or dockarea == DOCKAREA['right']:
				key = 'Vertical'
			elif dockarea == DOCKAREA['top'] or dockarea == DOCKAREA['bottom']:
				key = 'Horizontal'
			widget.set_orientation(key=key)
	
		if isinstance(widget, ToolBar):
			dockareas = self._toolbarareas
			docked = False
			if dockarea == DOCKAREA['left']:
				docked = True
				dockareas[DOCKAREA['left']].addChild(widget)
				dockareas[DOCKAREA['left']].adaptLayout()
				
			elif dockarea == DOCKAREA['right']:
				docked = True
				dockareas[DOCKAREA['right']].addChild(widget)
				dockareas[DOCKAREA['right']].adaptLayout()
				
			elif dockarea == DOCKAREA['top']:
				docked = True
				dockareas[DOCKAREA['top']].addChild(widget)
				dockareas[DOCKAREA['top']].adaptLayout()
				
			elif dockarea == DOCKAREA['bottom']:
				docked = True
				dockareas[DOCKAREA['bottom']].addChild(widget)
				dockareas[DOCKAREA['bottom']].adaptLayout()
				
			else:
				print "Invalid dockarea"
			
			widget.dockareaname = dockarea
			widget.setDocked(docked)
				
		else:
			if dockarea == DOCKAREA['left']:
				dockareas[DOCKAREA['left']].dockChild(widget, x, y)
				
			elif dockarea == DOCKAREA['right']:
				dockareas[DOCKAREA['right']].dockChild(widget, x, y)
				
			elif dockarea == DOCKAREA['top']:
				dockareas[DOCKAREA['top']].dockChild(widget, x, y)
				
			elif dockarea == DOCKAREA['bottom']:
				dockareas[DOCKAREA['bottom']].dockChild(widget, x, y)
				
			else:
				print "Invalid dockarea"

	def getToolbarAreaAt(self, x, y, mark=False):
		if self.dockareamarker is None:
			self.dockareamarker = pychan.widgets.Container()
			self.dockareamarker.base_color = fifechan.Color(200, 0, 0, 100)
		if mark is False:
			self.dockareamarker.hide()
	
		# Mouse wasn't over any dockwidgets. See if it is near any edge of the screen instead
		if x <= self._toolbarareas["left"].getAbsolutePos()[0]+10:
			if mark:
				self.dockareamarker.position = self._toolbarareas["left"].getAbsolutePos()
				self.dockareamarker.size = (10, self._toolbarareas["left"].height)
				self.dockareamarker.show()
			return DOCKAREA["left"]
			
		elif x >= self._toolbarareas["right"].getAbsolutePos()[0]-10:
			if mark:
				self.dockareamarker.position = self._toolbarareas["right"].getAbsolutePos()
				self.dockareamarker.size = (10, self._toolbarareas["right"].height)
				self.dockareamarker.x -= 10
				self.dockareamarker.show()
			return DOCKAREA["right"]
			
		elif y <= self._toolbarareas["top"].getAbsolutePos()[1]+10:
			if mark:
				self.dockareamarker.position = self._toolbarareas["top"].getAbsolutePos()
				self.dockareamarker.size = (self._toolbarareas["top"].width, 10)
				self.dockareamarker.show()
			return DOCKAREA["top"]
			
		elif y >= self._toolbarareas["bottom"].getAbsolutePos()[1]-10:
			if mark:
				self.dockareamarker.position = self._toolbarareas["bottom"].getAbsolutePos()
				self.dockareamarker.y -= 10
				self.dockareamarker.size = (self._toolbarareas["bottom"].width, 10)
				self.dockareamarker.show()
			return DOCKAREA["bottom"]

		if mark is True:
			self.dockareamarker.hide()
		return None
			
	def getDockAreaAt(self, x, y, mark=False):
		""" returns the dock area at the given cursor coordinates (if possible)
		
			also used for highlighting the dock area (this method is used
			on drag mouse events of a B{Panel} widget)
		
		@type	x:	int
		@param	x:	cursor x coordinates
		@type	y:	int
		@param	y:	cursor y coordinates
		@type	mark:	bool
		@param	mark:	flag to wether show the dock area marker (red area indicator) or not
		@rtype	side:	str
		@return	side:	dockarea id (e.g. 'right', 'left' ...)
		"""
		side = None
		
		if self.dockareamarker is None:
			self.dockareamarker = pychan.widgets.Container()
			self.dockareamarker.base_color = fifechan.Color(200, 0, 0, 100)
		if mark is False:
			self.dockareamarker.hide()
	
		for key in DOCKAREA:
			side = DOCKAREA[key]
			
			dockarea = self._dockareas[side]
			#absX, absY = dockarea.getAbsolutePos()
			#if absX <= x and absY <= y \
			#		and absX+dockarea.width >= x and absX+dockarea.height >= y:
			#	return side
			placeIn, placeBefore, placeAfter = dockarea.getDockLocation(x, y)
			if placeIn or placeBefore or placeAfter:
				if mark is True:
					if placeIn:
						self.dockareamarker.position = placeIn.getAbsolutePos()
						self.dockareamarker.size = placeIn.size
					elif placeBefore:
						self.dockareamarker.position = placeBefore.getAbsolutePos()
						if side == "left" or side == "right":
							self.dockareamarker.size = (placeBefore.width, 10)
						else:
							self.dockareamarker.size = (10, placeBefore.height)
					elif placeAfter:
						self.dockareamarker.position = placeAfter.getAbsolutePos()
						
						if side == "left" or side == "right":
							self.dockareamarker.size = (placeAfter.width, 10)
							self.dockareamarker.y += placeAfter.height-10
						else:
							self.dockareamarker.size = (10, placeAfter.height)
							self.dockareamarker.x += placeAfter.width-10
						
					self.dockareamarker.show()
				return side

		# reset side, next attempt to find a new home
		side = None

		# Mouse wasn't over any dockwidgets. See if it is near any edge of the screen instead
		if x <= self._dockareas["left"].getAbsolutePos()[0]+10:
			if mark:
				self.dockareamarker.position = self._dockareas["left"].getAbsolutePos()
				self.dockareamarker.size = (10, self._dockareas["left"].height)
				self.dockareamarker.show()
			side = DOCKAREA["left"]
			return side
			
		elif x >= self._dockareas["right"].getAbsolutePos()[0]-10:
			if mark:
				self.dockareamarker.position = self._dockareas["right"].getAbsolutePos()
				self.dockareamarker.size = (10, self._dockareas["right"].height)
				self.dockareamarker.x -= 10
				self.dockareamarker.show()
			side = DOCKAREA["right"]
			return side
			
		elif y <= self._dockareas["top"].getAbsolutePos()[1]+10:
			if mark:
				self.dockareamarker.position = self._dockareas["top"].getAbsolutePos()
				self.dockareamarker.size = (self._dockareas["top"].width, 10)
				self.dockareamarker.show()
			side = DOCKAREA["top"]
			return side
			
		elif y >= self._dockareas["bottom"].getAbsolutePos()[1]-10:
			if mark:
				self.dockareamarker.position = self._dockareas["bottom"].getAbsolutePos()
				self.dockareamarker.y -= 10
				self.dockareamarker.size = (self._dockareas["bottom"].width, 10)
				self.dockareamarker.show()
			side = DOCKAREA["bottom"]
			return side

		if mark is True:
			self.dockareamarker.hide()
			
		return side
Example #28
0
class MainWindow(object):

	def __init__(self, *args, **kwargs):
		self._toolbar = None
		self._menubar = None
		self._statusbar = None
	
		self._rootwidget = None
		self._centralwidget = None
		self._dockareas = {
				DOCKAREA['left']:None, 
				DOCKAREA['right']:None, 
				DOCKAREA['top']:None, 
				DOCKAREA['bottom']:None
			}
			
		self._toolbarareas = {
				DOCKAREA['left']:None, 
				DOCKAREA['right']:None, 
				DOCKAREA['top']:None, 
				DOCKAREA['bottom']:None
			}
			
		self.dockareamarker = None
			
	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 getCentralWidget(self):
		return self._centralwidget
	
	def getStatusBar(self): 
		return self._statusbar
		
	def getMenuBar(self):
		return self._menubar
	
	def getToolBar(self): 
		return self._toolbar
	
	def dockWidgetTo(self, widget, dockarea, x=-1, y=-1):
		if isinstance(widget, pychan.widgets.Widget) is False:
			print "Argument is not a valid widget"
			return
			
		if widget.parent:
			widgetParent = widget.parent
			widgetParent.removeChild(widget)
			widgetParent.adaptLayout()
			
		# We must hide the widget before adding it to the dockarea,
		# or we will get a duplicate copy of the widget in the top left corner
		# of screen.
		widget.hide() 
		dockareas = self._dockareas
		if isinstance(widget, ToolBar):
			dockareas = self._toolbarareas
			if dockarea == DOCKAREA['left'] or dockarea == DOCKAREA['right']:
				widget.setOrientation(ToolBar.ORIENTATION["Vertical"])
			elif dockarea == DOCKAREA['top'] or dockarea == DOCKAREA['bottom']:
				widget.setOrientation(ToolBar.ORIENTATION["Horizontal"])
	
		if isinstance(widget, ToolBar):
			if dockarea == DOCKAREA['left']:
				widget.setDocked(True)
				dockareas[DOCKAREA['left']].addChild(widget)
				dockareas[DOCKAREA['left']].adaptLayout()
				
			elif dockarea == DOCKAREA['right']:
				widget.setDocked(True)
				dockareas[DOCKAREA['right']].addChild(widget)
				dockareas[DOCKAREA['right']].adaptLayout()
				
			elif dockarea == DOCKAREA['top']:
				widget.setDocked(True)
				dockareas[DOCKAREA['top']].addChild(widget)
				dockareas[DOCKAREA['top']].adaptLayout()
				
			elif dockarea == DOCKAREA['bottom']:
				widget.setDocked(True)
				dockareas[DOCKAREA['bottom']].addChild(widget)
				dockareas[DOCKAREA['bottom']].adaptLayout()
				
			else:
				print "Invalid dockarea"
		else:
			if dockarea == DOCKAREA['left']:
				dockareas[DOCKAREA['left']].dockChild(widget, x, y)
				
			elif dockarea == DOCKAREA['right']:
				dockareas[DOCKAREA['right']].dockChild(widget, x, y)
				
			elif dockarea == DOCKAREA['top']:
				dockareas[DOCKAREA['top']].dockChild(widget, x, y)
				
			elif dockarea == DOCKAREA['bottom']:
				dockareas[DOCKAREA['bottom']].dockChild(widget, x, y)
				
			else:
				print "Invalid dockarea"
				
	def getToolbarAreaAt(self, x, y, mark=False):
		if self.dockareamarker is None:
			self.dockareamarker = pychan.widgets.Container()
			self.dockareamarker.base_color = fife.Color(200, 0, 0, 100)
		if mark is False:
			self.dockareamarker.hide()
	
		# Mouse wasn't over any dockwidgets. See if it is near any edge of the screen instead
		if x <= self._toolbarareas["left"].getAbsolutePos()[0]+10:
			if mark:
				self.dockareamarker.position = self._toolbarareas["left"].getAbsolutePos()
				self.dockareamarker.size = (10, self._toolbarareas["left"].height)
				self.dockareamarker.show()
			return DOCKAREA["left"]
			
		elif x >= self._toolbarareas["right"].getAbsolutePos()[0]-10:
			if mark:
				self.dockareamarker.position = self._toolbarareas["right"].getAbsolutePos()
				self.dockareamarker.size = (10, self._toolbarareas["right"].height)
				self.dockareamarker.x -= 10
				self.dockareamarker.show()
			return DOCKAREA["right"]
			
		elif y <= self._toolbarareas["top"].getAbsolutePos()[1]+10:
			if mark:
				self.dockareamarker.position = self._toolbarareas["top"].getAbsolutePos()
				self.dockareamarker.size = (self._toolbarareas["top"].width, 10)
				self.dockareamarker.show()
			return DOCKAREA["top"]
			
		elif y >= self._toolbarareas["bottom"].getAbsolutePos()[1]-10:
			if mark:
				self.dockareamarker.position = self._toolbarareas["bottom"].getAbsolutePos()
				self.dockareamarker.y -= 10
				self.dockareamarker.size = (self._toolbarareas["bottom"].width, 10)
				self.dockareamarker.show()
			return DOCKAREA["bottom"]

		if mark is True:
			self.dockareamarker.hide()
		return None
			
	def getDockAreaAt(self, x, y, mark=False):
		if self.dockareamarker is None:
			self.dockareamarker = pychan.widgets.Container()
			self.dockareamarker.base_color = fife.Color(200, 0, 0, 100)
		if mark is False:
			self.dockareamarker.hide()
	
		for key in DOCKAREA:
			side = DOCKAREA[key]
			
			dockarea = self._dockareas[side]
			#absX, absY = dockarea.getAbsolutePos()
			#if absX <= x and absY <= y \
			#		and absX+dockarea.width >= x and absX+dockarea.height >= y:
			#	return side
			placeIn, placeBefore, placeAfter = dockarea.getDockLocation(x, y)
			if placeIn or placeBefore or placeAfter:
				if mark is True:
					if placeIn:
						self.dockareamarker.position = placeIn.getAbsolutePos()
						self.dockareamarker.size = placeIn.size
					elif placeBefore:
						self.dockareamarker.position = placeBefore.getAbsolutePos()
						if side == "left" or side == "right":
							self.dockareamarker.size = (placeBefore.width, 10)
						else:
							self.dockareamarker.size = (10, placeBefore.height)
					elif placeAfter:
						self.dockareamarker.position = placeAfter.getAbsolutePos()
						
						if side == "left" or side == "right":
							self.dockareamarker.size = (placeAfter.width, 10)
							self.dockareamarker.y += placeAfter.height-10
						else:
							self.dockareamarker.size = (10, placeAfter.height)
							self.dockareamarker.x += placeAfter.width-10
						
					self.dockareamarker.show()
				return side
			

		# Mouse wasn't over any dockwidgets. See if it is near any edge of the screen instead
		if x <= self._dockareas["left"].getAbsolutePos()[0]+10:
			if mark:
				self.dockareamarker.position = self._dockareas["left"].getAbsolutePos()
				self.dockareamarker.size = (10, self._dockareas["left"].height)
				self.dockareamarker.show()
			return DOCKAREA["left"]
			
		elif x >= self._dockareas["right"].getAbsolutePos()[0]-10:
			if mark:
				self.dockareamarker.position = self._dockareas["right"].getAbsolutePos()
				self.dockareamarker.size = (10, self._dockareas["right"].height)
				self.dockareamarker.x -= 10
				self.dockareamarker.show()
			return DOCKAREA["right"]
			
		elif y <= self._dockareas["top"].getAbsolutePos()[1]+10:
			if mark:
				self.dockareamarker.position = self._dockareas["top"].getAbsolutePos()
				self.dockareamarker.size = (self._dockareas["top"].width, 10)
				self.dockareamarker.show()
			return DOCKAREA["top"]
			
		elif y >= self._dockareas["bottom"].getAbsolutePos()[1]-10:
			if mark:
				self.dockareamarker.position = self._dockareas["bottom"].getAbsolutePos()
				self.dockareamarker.y -= 10
				self.dockareamarker.size = (self._dockareas["bottom"].width, 10)
				self.dockareamarker.show()
			return DOCKAREA["bottom"]

		if mark is True:
			self.dockareamarker.hide()
		return None
Example #29
0
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()
Example #30
0
class AfelApp(QMainWindow):
    def __init__(self, parent=None):
        super(AfelApp, self).__init__(parent)
        self.setGeometry(10, 10, 1000, 1200)
        # self.setStyleSheet("""
        #
        #              font-size: 200;
        #
        #         """)
        # Flags
        self.modes = {
            'outer_window': True,
            'live_mode': False
        }

        self.result_box_group = None
        self.result_box = None

        self.module_btns = []

        mainWindow = QWidget(self)
        self.setCentralWidget(mainWindow)
        mainlay = QHBoxLayout()

        mainWindow.setLayout(mainlay)

        #  load area
        btns_group = QGroupBox()
        btns_lay = QVBoxLayout()
        btns_group.setLayout(btns_lay)
        btns_lay.addStretch(1)
        self.btns_lay = btns_lay

        self.load_modules_btns()

        startbtn = QPushButton('start process')
        startbtn.clicked.connect(self.start_process)
        btns_lay.addWidget(startbtn)



        #  sandbox area
        self.sandbox = SandBox()
        self.sandboxlay = QVBoxLayout()
        # self.sandboxlay.addStretch(209)
        self.sandbox.setLayout(self.sandboxlay)

        mainlay.addWidget(btns_group,1)
        mainlay.addWidget(self.sandbox,10)

        # toolbar
        # toolbar.setIconSize(QSize(16, 16))
        self.toolbar = ToolBar(self)
        self.addToolBar(self.toolbar)

    def load_modules_btns(self):
        self.clear_modules_btns()
        all_modules, errors = Module.get_all_modules()
        for btn in [ModuleBtn(m) for m in all_modules]:
            self.btns_lay.insertWidget(0, btn)
            self.module_btns.append(btn)
        self.pop_errors(errors)

    def pop_errors(self, errors):
        for e in errors:
            w = QMainWindow(self)
            w.setCentralWidget(AMsgBox(self,e))
            w.show()

    def clear_modules_btns(self):
        [b.deleteLater() for b in self.module_btns]
        self.module_btns = []

    def reload(self):  # reload all - sandbox and modules btn
        temp_path = 'm/temp/temporaryModules'  # sandbox cash

        self.sandbox.dump_sandbox(temp_path)
        self.clear_modules_btns()
        self.load_modules_btns()
        self.sandbox.clear_sandbox(force=True)
        self.sandbox.load_file_modules(temp_path)

    def start_process(self):
        if self.result_box_group:  # Qgroup to include the results window when not poped
            self.result_box_group.deleteLater()  # improve memory
            self.result_box_group = None
        self.old_box = self.result_box
        starter = self.sandbox.starter
        if starter:
            try:
                extras = starter.module.run()
                self.result_box = ResultView(self, extras)
                if self.modes['outer_window']:
                    w = QMainWindow(self)
                    w.setCentralWidget(self.result_box)
                    w.show()
                else:
                    g = QGroupBox()
                    gl = QHBoxLayout()
                    g.setLayout(gl)
                    gl.addWidget(self.result_box)
                    self.result_box_group = g
                    self.layout().addWidget(g, 5)
            except:
                self.pop_errors([format_exc()])


        else:
            self.statusBar().showMessage('please define starter', 2000)
            self.sandbox.force_stater()
            self.start_process()

    def keyPressEvent(self, event):
        self.toolbar.shortcut(event.key())