def __init__(self, master=None): tk.Frame.__init__(self, master, relief=tk.SUNKEN, bd=2) self.create_menubar() self.master.config(menu=self.menubar) #self.pack(side=tk.TOP, fill=tk.BOTH, expand=True) self.canvas = XCanvas(self.master, bg="white", width=900, height=540, scalewidget=False, bd=0, highlightthickness=0) self.tkcon = TkConsole(self.master, height=12, width=90, background='ivory') self.status = StatusBar(self.master) self.canvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True) self.tkcon.pack(side=tk.TOP, fill=tk.BOTH, expand=True) self.status.pack(side=tk.BOTTOM, fill=tk.X, expand=True) self.tkcon.focus_set() self.lastdir = os.environ['HOMEPATH'] self.units = [] self.title() self.status.set("Level Placer Status")
class MainApplication(tk.Tk): """Container for all frames within the application""" def __init__(self, *args, **kwargs): tk.Tk.__init__(self, *args, **kwargs) # initialize menu self.config(menu=MenuBar(self)) self.title("FIFA 16 Auto Buyer") self.geometry("950x650-5+40") self.minsize(width=650, height=450) # bind ctrl+a if platform == "darwin": self.bind_class("Entry", "<Command-a>", self.selectall) else: self.bind_class("Entry", "<Control-a>", self.selectall) self.status = StatusBar(self) self.status.pack(side="bottom", fill="x") self.status.set_credits("0") self.appFrame = Application(self) self.appFrame.pack(side="top", fill="both", expand="True") def selectall(self, e): e.widget.select_range(0, tk.END) return "break"
class MainApplication(tk.Tk): """Container for all frames within the application""" def __init__(self, *args, **kwargs): tk.Tk.__init__(self, *args, **kwargs) #initialize menu self.config(menu=MenuBar(self)) self.title('FIFA 16 Auto Buyer') self.geometry('850x650-5+40') self.minsize(width=650, height=450) # bind ctrl+a if(platform == 'darwin'): self.bind_class("Entry", "<Command-a>", self.selectall) else: self.bind_class("Entry", "<Control-a>", self.selectall) self.status = StatusBar(self) self.status.pack(side='bottom', fill='x') self.status.set_credits('0') self.appFrame = Application(self) self.appFrame.pack(side='top', fill='both', expand='True') def selectall(self, e): e.widget.select_range(0, tk.END) return 'break'
class MainApplication(tk.Tk): """Container for all frames within the application""" def __init__(self, *args, **kwargs): tk.Tk.__init__(self, *args, **kwargs) #initialize menu self.config(menu=MenuBar(self)) self.title('FIFA 17 Auto Buyer') self.geometry('950x650-5+40') self.minsize(width=650, height=450) # bind ctrl+a if(platform == 'darwin'): self.bind_class("Entry", "<Command-a>", self.selectall) else: self.bind_class("Entry", "<Control-a>", self.selectall) self.status = StatusBar(self) self.status.pack(side='bottom', fill='x') self.status.set_credits('0') self.appFrame = Application(self) self.appFrame.pack(side='top', fill='both', expand='True') def selectall(self, e): e.widget.select_range(0, tk.END) return 'break'
def __init__(self, direction=Direction.right, loc=[50, 200]): super().__init__(direction, loc) self.pressed_keys = [] self.hp_status_bar = StatusBar(100, pg.Color("red"), [5, 10]) self.charge_status_bar = StatusBar(0, pg.Color("lightblue"), [5, 50]) self.right_direction_key = pg.K_d self.left_direction_key = pg.K_a self.controls = { Action.running: [pg.K_a, pg.K_d], Action.block: [pg.K_LSHIFT], Action.jumping: [pg.K_w], Action.crouched: [pg.K_s], Action.attack: [pg.K_SPACE] }
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)
def __init__(self, master): self.master = master master.option_add('*tearOff', FALSE) master.title('Super CAOS') master.columnconfigure(0, weight=1) master.rowconfigure(0, weight=1) self.mainframe = Frame(master) # self.mainframe.grid(column=0, row=0, sticky=N+S+E+W) self.mainframe.pack(fill=BOTH, expand=True) self.logo_frame = LogoFrame(self.mainframe, 0, 0) self.global_menu = GlobalMenu(self.mainframe, 0, 1) self.method_menu = MethodMenu(self.mainframe, 0, 2) self.status_bar = StatusBar(self.mainframe, 0, 3) self.top_menu = TopMenu(self.mainframe, 1, 0) self.image_area = ImageArea(self.mainframe, 1, 1) self.overlay_menu = OverlayMenu(self.mainframe, 2, 1) self.mainframe.columnconfigure(0, weight=0, minsize=175) self.mainframe.columnconfigure(1, weight=1) self.mainframe.columnconfigure(2, weight=0, minsize=75) self.mainframe.rowconfigure(0, weight=0, minsize=75) self.mainframe.rowconfigure(1, weight=1, minsize=200) self.mainframe.rowconfigure(2, weight=1, minsize=200) self.mainframe.rowconfigure(3, weight=0, minsize=20) master.update() master.minsize(master.winfo_width(), master.winfo_height())
def create_win(self): self.frdls = FrdLs( self.stdscr, self._frdls_info.smaxcol - self._frdls_info.smincol + 1, self._frdls_info.sminrow, self._frdls_info.smincol, self._frdls_info.smaxrow, self._frdls_info.smaxcol, self.friends, Config['color']['frdls']['fgcolor'], Config['color']['frdls']['bgcolor']) self.msgls_set[self.current_receiver] = MsgLs( self.stdscr, self._msgls_info.smaxcol - self._msgls_info.smincol + 1, self._msgls_info.sminrow, self._msgls_info.smincol, self._msgls_info.smaxrow, self._msgls_info.smaxcol, [], fgcolor=Config['color']['msgls']['fgcolor'], bgcolor=Config['color']['msgls']['bgcolor']) self.input = Input( self.stdscr, self._input_info.smaxcol - self._input_info.smincol + 1, self._input_info.sminrow, self._input_info.smincol, self._input_info.smaxrow, self._input_info.smaxcol, self.text, Config['color']['input']['fgcolor'], Config['color']['input']['bgcolor']) self.command = Command( self.stdscr, self._command_info.smaxrow - self._command_info.sminrow + 1, self._command_info.sminrow, self._command_info.smincol, self._command_info.smaxrow, self._command_info.smaxcol, self.command, Config['color']['command']['fgcolor'], Config['color']['command']['bgcolor']) self.statusbar = StatusBar(self.stdscr, 1, self._statusbar_info.smaxcol - self._statusbar_info.smincol + 1, self._statusbar_info.sminrow, self._statusbar_info.smincol, self._statusbar_info.smaxrow, self._statusbar_info.smaxcol, "NORMAL", "xxxxxx", fgcolor=curses.COLOR_BLACK, bgcolor=curses.COLOR_WHITE)
def __init__(self, *args, **kwargs): tk.Tk.__init__(self, *args, **kwargs) #initialize menu self.config(menu=MenuBar(self)) self.title('FIFA 17 Auto Buyer') self.geometry('950x650-5+40') self.minsize(width=650, height=450) # bind ctrl+a if(platform == 'darwin'): self.bind_class("Entry", "<Command-a>", self.selectall) else: self.bind_class("Entry", "<Control-a>", self.selectall) self.status = StatusBar(self) self.status.pack(side='bottom', fill='x') self.status.set_credits('0') self.appFrame = Application(self) self.appFrame.pack(side='top', fill='both', expand='True')
def __init__(self, master=None): Frame.__init__(self, master, relief=SUNKEN, bd=2) self.create_menubar() self.master.config(menu=self.menubar) self.pack(side=TOP, fill=BOTH, expand=True) panwin = PanedWindow(self, orient=VERTICAL, sashwidth=5, bd=0, bg='gray80', opaqueresize=0) self.canvas = XCanvas(self.master, bg="white", width=1200, height=640, x_axis=11, scalewidget=False, bd=0, highlightthickness=0) self.tkcon = TkConsole(self.master, height=12, width=90, background='ivory') self.status = StatusBar(self.master) self.canvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True) self.tkcon.pack(side=tk.TOP, fill=tk.BOTH, expand=True) self.status.pack(side=BOTTOM, fill=X, expand=False) self.tkcon.focus_set() # Put here all initializations you want to have in console # However it's better to use an initialization file for tkcon (look at tkcon.py) self.tkcon.eval('import os') self.tkcon.eval('import sys') self.tkcon.eval('from basics import *') self.status.set("%-60s %-16s %-16s", "Status line for this eda app (60 chars)", "Part2 (16c)", "Part3 (16c)")
def create_widget(self): self.text_area = TextArea(self.frame1, bg=self.text_background, fg=self.text_foreground, undo=True, relief=tk.FLAT, font=(self.text_font_family, self.text_font_size), insertbackground=self.insertbackground) self.text_area.config(highlightthickness=0) self.text_area.grid(row=0, column=1, sticky='wens') self.text_area.focus_set() self.welcome(event=None) self.status_bar1 = StatusBar(self.frame2, bg="pink", width=30, height=10) self.status_bar2 = StatusBar(self.frame2, bg="orange", width=30, height=10) self.status_bar3 = StatusBar(self.frame2, bg="blue", width=30, height=10) self.status_bar4 = StatusBar(self.frame2, bg="green", width=30, height=10) self.status_bar5 = StatusBar(self.frame2, bg="purple", width=30, height=10) self.status_bar1.pack(side=tk.LEFT, fill=tk.BOTH, expand=True) self.status_bar2.pack(side=tk.LEFT, fill=tk.BOTH, expand=True) self.status_bar3.pack(side=tk.LEFT, fill=tk.BOTH, expand=True) self.status_bar4.pack(side=tk.LEFT, fill=tk.BOTH, expand=True) self.status_bar5.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
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, **kwargs): super(Designer, self).__init__(**kwargs) self.root_name = "" self.popup = None self.file = "" # A count variable to give ids to generated widget self.count = 0 #This variable updates to True when ctrl is pressed self.ctrl_pressed = False #Instantiate the WidgetTree self.widget_tree = WidgetTree(self) self.widget_tree_box.add_widget(self.widget_tree) #Instantiate MenuBar self.menubar = MenuBar(designer = self, pos_hint = {'x':0,'top':1}, \ canvas_area = self.canvas_area, size_hint = (.70,None),height = 25) self.add_widget(self.menubar) #Instantiate right widgets bar # We update the same widgets bar, and dont create new instances everytime self.widgetbar = NewWidgetsMenu(self) self.rightbox.add_widget(self.widgetbar) #Initialize the keyboard and set up handlers for key press and release self.canvas_area._keyboard = Window.request_keyboard(self._keyboard_closed,self) self.canvas_area._keyboard.bind(on_key_down=self._on_keyboard_down) self.canvas_area._keyboard.bind(on_key_up = self._on_keyboard_up) # Setup canvas for highlighting with self.canvas.after: self.gcolor = Color(1, 1, 0, .25) PushMatrix() self.gtranslate = Translate(0, 0, 0) self.grotate = Rotate(0, 0, 0, 1) self.gscale = Scale(1.) self.grect = Rectangle(size=(0, 0)) PopMatrix() # Instantiate Statusbar self.status_bar = StatusBar(size_hint = (1,.05)) self.leftbox.add_widget(self.status_bar) #Show properties binding # self.widget -> updated on_touch_down in 'canvas_area' # So, whenever we have a new self.widget, we call show_properties self.bind(widget = self.show_properties) self.bind(widget = self.widget_tree.select_highlighted)
def __init__(self): """ Main window constructor """ tk.Tk.__init__(self) # constructeur de la classe parente # self.root = tk.Tk() self.title("Morg") self.geometry("800x800") self.wm_iconbitmap( r"D:\PythonWorkspace\Python_Project\Morg\Notepad.ico") self.minsize(width=600, height=600) workframe_frame = WorkFrame(self) statusbar_frame = StatusBar(self) # spacebar_frame = SpaceBar(self) # MODE Binding # MasterCommand(self, workframe_frame, statusbar_frame, spacebar_frame) self.mainloop()
def run(): (window_size, f) = get_args() tb = TextBuffer() if f: tb.load(f) sdl2.ext.init() window = sdl2.ext.Window(WINDOW_TITLE, size=window_size) window.show() factory = sdl2.ext.SpriteFactory(sdl2.ext.SOFTWARE) font_img = factory.from_image(FONT_IMG_PATH) sdl2.SDL_SetColorKey( font_img.surface, sdl2.SDL_TRUE, sdl2.SDL_MapRGB(font_img.surface.format, COLOR_KEY_R, COLOR_KEY_G, COLOR_KEY_B)) font = sdl2.ext.BitmapFont(font_img, FONT_SIZE, mapping=FONT_MAPPING) sb = StatusBar(window, tb, font, STATUS_BAR_COLOR, (STATUS_BAR_BORDER_TOP, STATUS_BAR_BORDER_RIGHT, STATUS_BAR_BORDER_BOTTOM, STATUS_BAR_BORDER_LEFT)) ta = TextArea(window, font, tb, (TEXT_AREA_BORDER_TOP, TEXT_AREA_BORDER_RIGHT, sb.height + TEXT_AREA_BORDER_BOTTOM, TEXT_AREA_BORDER_LEFT), TEXT_AREA_LINE_SPACING) state = EditState(Editor(None, window, ta, sb)) sdl2.SDL_StartTextInput() while True: start = sdl2.SDL_GetTicks() state = state.update(sdl2.ext.get_events()) if state is None: break ticks = sdl2.SDL_GetTicks() - start if ticks < 1000 / FRAMES_PER_SECOND: sdl2.SDL_Delay((1000 / FRAMES_PER_SECOND) - ticks) sdl2.SDL_StopTextInput() sdl2.ext.quit() return 0
def __init__(self, *args, **kwargs): tk.Tk.__init__(self, *args, **kwargs) # initialize menu self.config(menu=MenuBar(self)) self.title("FIFA 16 Auto Buyer") self.geometry("950x650-5+40") self.minsize(width=650, height=450) # bind ctrl+a if platform == "darwin": self.bind_class("Entry", "<Command-a>", self.selectall) else: self.bind_class("Entry", "<Control-a>", self.selectall) self.status = StatusBar(self) self.status.pack(side="bottom", fill="x") self.status.set_credits("0") self.appFrame = Application(self) self.appFrame.pack(side="top", fill="both", expand="True")
def __init__(self, *args, **kwargs): tk.Tk.__init__(self, *args, **kwargs) #initialize menu self.config(menu=MenuBar(self)) self.title('FIFA 16 Auto Buyer') self.geometry('850x650-5+40') self.minsize(width=650, height=450) # bind ctrl+a if(platform == 'darwin'): self.bind_class("Entry", "<Command-a>", self.selectall) else: self.bind_class("Entry", "<Control-a>", self.selectall) self.status = StatusBar(self) self.status.pack(side='bottom', fill='x') self.status.set_credits('0') self.appFrame = Application(self) self.appFrame.pack(side='top', fill='both', expand='True')
def populate(self): for key, value in self.main.user_response.items(): if hasattr(self, key): if key in ['chain']: status_bar = StatusBar(key, **value) value = status_bar setattr(self, key, value) self.window.border() #Create a new window for the character bars contents = self.window.derwin(1, 1) self.new_line("Chain Status", contents, attributes=curses.A_UNDERLINE | curses.A_BOLD) self.new_line("", contents) if self.chain.cooldown > 0: #Chain is in cooldown. This has not been tested self.new_line("{:8}: {}".format("Maximum", self.chain.maximum), contents) self.new_line( "{:8}: {}".format("Current", self.get_counter(self.chain.current)), contents) self.new_line("{:8}: {}s".format("Cooldown", self.chain.cooldown), contents) else: #Chain in progress self.new_line("{:8}: {}".format("Current", self.chain.current), contents) self.new_line( "{:8}: {}".format("Timeout", self.get_counter(self.chain.timeout)), contents) self.new_line("{:8}: {}".format("Modifier", self.chain.modifier), contents)
def populate(self): for k, v in self.main.user_response.items(): if hasattr(self, k): if k in ['happy', 'life', 'energy', 'nerve', 'chain']: bar = StatusBar(k, **v) v = bar setattr(self, k, v) self.window.border() #Create a new window for the character bars contents = self.window.derwin(1, 1) self.new_line("Status Window", contents, attributes=curses.A_UNDERLINE | curses.A_BOLD) self.new_line("", contents) self.new_line("{:6}: {}[{}]".format("Name", self.name, self.player_id), contents) self.new_line("{:6}: {}".format("Status", self.status[0]), contents) #Life self.new_line(self.life.__str__(), contents, attributes=curses.color_pair( constants.COLOR_GREEN.index)) #Energy self.new_line(self.energy.__str__(), contents) #Nerve self.new_line(self.nerve.__str__(), contents) #Happiness self.new_line(self.happy.__str__(), contents)
class RecentTab(BaseTab): """ Content of the Recent Servers tab. - serverlist treeview, - detailarea with playerlist, servervars, serverinfo and buttons """ def __init__(self): """ Constructor """ gtk.VBox.__init__(self) self.filter = RecentSeversFilter() self.filter.show() self.pack_start(self.filter, False, False) # top pane area paned = gtk.VPaned() paned.show() self.pack_start(paned) # bottom add a statusbar self.statusbar = StatusBar(self) self.pack_start(self.statusbar, False, False) # serverlist window self.serverlist = RecentServersList(self) paned.pack1(self.serverlist, True, False) #paned.add1(self.serverlist) # bottom panearea bottompane = gtk.HPaned() paned.pack2(bottompane, True, False) #paned.add2(bottompane) #left box self.playerlist = PlayerList() bottompane.pack1(self.playerlist, False, False) #right box self.detailsbox = ServerDetailBox() vbox = gtk.VBox() bottompane.pack2(vbox, True, False) buttonbox = gtk.HBox() vbox.pack_start(buttonbox, False, False) vbox.pack_start(self.detailsbox) refresh_button = gtk.Button('Refresh') refreshimage = gtk.Image() refreshimage.set_from_stock(gtk.STOCK_REFRESH, gtk.ICON_SIZE_BUTTON) refresh_button.set_image(refreshimage) connect_button = gtk.Button('Connect') connectimage = gtk.Image() connectimage.set_from_stock(gtk.STOCK_CONNECT, gtk.ICON_SIZE_BUTTON) connect_button.set_image(connectimage) addfav_button = gtk.Button('Add to Favorites') favimage = gtk.Image() favimage.set_from_stock(gtk.STOCK_ADD, gtk.ICON_SIZE_BUTTON) addfav_button.set_image(favimage) removerecent_button = gtk.Button('Remove Server from List') removeimage = gtk.Image() removeimage.set_from_stock(gtk.STOCK_DELETE, gtk.ICON_SIZE_BUTTON) removerecent_button.set_image(removeimage) buttonbox.pack_start(refresh_button, True, True) buttonbox.pack_start(connect_button, True, True) buttonbox.pack_start(addfav_button, True, True) buttonbox.pack_start(removerecent_button, True, True) refresh_button.connect("clicked", self.onRefreshButtonClicked) connect_button.connect("clicked", self.connect_button_clicked) removerecent_button.connect("clicked", self.onRemoveRecentClicked) addfav_button.connect("clicked", self.onAddFavButtonClicked) self.show_all() def onRemoveRecentClicked(self, widget): """ Callback method for the remove button. Triggers the removal of the recent server entry by calling the gui controller which then removes the recent server (from list in memory and also from file) Also removes the recent server directly from the liststore. @param widget - the widget that emitted the clicked signal - the button """ #remove row from liststore and also the server from the recent list selection = self.serverlist.serverlistview.get_selection() result = selection.get_selected() if result: model, iter = result server = self.serverlist.liststore.get_value(iter, 8) #remove it from the favoriteslist gui = GuiController() gui.removeRecent(server) model.remove(iter) def serverlist_loading_finished(self): """ Callback method executed when the search has finished """ #reactivate the search button self.filter.refresh_button.set_sensitive(True) self.statusbar.lock() self.qm = None
def __init__(self): """ Constructor """ gtk.VBox.__init__(self) fm = FileManager() config = fm.getConfiguration() if cfgvalues.BASIC_FILTER == config[cfgkey.OPT_FILTER]: self.filter = ServerListFilter(self) else: self.filter = AdvancedFilter(self) self.filter.show() self.pack_start(self.filter, False, False) # top pane area paned = gtk.VPaned() paned.show() self.pack_start(paned) # bottom add a statusbar self.statusbar = StatusBar(self) self.pack_start(self.statusbar, False, False) # serverlist window self.serverlist = ServerList(self) paned.pack1(self.serverlist, True, False) #paned.add1(self.serverlist) # bottom panearea bottompane = gtk.HPaned() paned.pack2(bottompane, True, False) #paned.add2(bottompane) #left box self.playerlist = PlayerList() bottompane.pack1(self.playerlist, False, False) #right box self.detailsbox = ServerDetailBox() vbox = gtk.VBox() bottompane.pack2(vbox, True, False) buttonbox = gtk.HBox() #self.detailsbox.pack_start(buttonbox, False, False) vbox.pack_start(buttonbox, False, False) vbox.pack_start(self.detailsbox) refresh_button = gtk.Button('Refresh') refreshimage = gtk.Image() refreshimage.set_from_stock(gtk.STOCK_REFRESH, gtk.ICON_SIZE_BUTTON) refresh_button.set_image(refreshimage) connect_button = gtk.Button('Connect') connectimage = gtk.Image() connectimage.set_from_stock(gtk.STOCK_CONNECT, gtk.ICON_SIZE_BUTTON) connect_button.set_image(connectimage) addfav_button = gtk.Button('Add to Favorites') favimage = gtk.Image() favimage.set_from_stock(gtk.STOCK_ADD, gtk.ICON_SIZE_BUTTON) addfav_button.set_image(favimage) buttonbox.pack_start(refresh_button, True, True) buttonbox.pack_start(connect_button, True, True) buttonbox.pack_start(addfav_button, True, True) refresh_button.connect("clicked", self.onRefreshButtonClicked) addfav_button.connect("clicked", self.onAddFavButtonClicked) connect_button.connect("clicked", self.connect_button_clicked) self.show_all()
class ServerTab(BaseTab): """ Contents of the Servers tab. Displays the servers retreived from the master server """ def __init__(self): """ Constructor """ gtk.VBox.__init__(self) fm = FileManager() config = fm.getConfiguration() if cfgvalues.BASIC_FILTER == config[cfgkey.OPT_FILTER]: self.filter = ServerListFilter(self) else: self.filter = AdvancedFilter(self) self.filter.show() self.pack_start(self.filter, False, False) # top pane area paned = gtk.VPaned() paned.show() self.pack_start(paned) # bottom add a statusbar self.statusbar = StatusBar(self) self.pack_start(self.statusbar, False, False) # serverlist window self.serverlist = ServerList(self) paned.pack1(self.serverlist, True, False) #paned.add1(self.serverlist) # bottom panearea bottompane = gtk.HPaned() paned.pack2(bottompane, True, False) #paned.add2(bottompane) #left box self.playerlist = PlayerList() bottompane.pack1(self.playerlist, False, False) #right box self.detailsbox = ServerDetailBox() vbox = gtk.VBox() bottompane.pack2(vbox, True, False) buttonbox = gtk.HBox() #self.detailsbox.pack_start(buttonbox, False, False) vbox.pack_start(buttonbox, False, False) vbox.pack_start(self.detailsbox) refresh_button = gtk.Button('Refresh') refreshimage = gtk.Image() refreshimage.set_from_stock(gtk.STOCK_REFRESH, gtk.ICON_SIZE_BUTTON) refresh_button.set_image(refreshimage) connect_button = gtk.Button('Connect') connectimage = gtk.Image() connectimage.set_from_stock(gtk.STOCK_CONNECT, gtk.ICON_SIZE_BUTTON) connect_button.set_image(connectimage) addfav_button = gtk.Button('Add to Favorites') favimage = gtk.Image() favimage.set_from_stock(gtk.STOCK_ADD, gtk.ICON_SIZE_BUTTON) addfav_button.set_image(favimage) buttonbox.pack_start(refresh_button, True, True) buttonbox.pack_start(connect_button, True, True) buttonbox.pack_start(addfav_button, True, True) refresh_button.connect("clicked", self.onRefreshButtonClicked) addfav_button.connect("clicked", self.onAddFavButtonClicked) connect_button.connect("clicked", self.connect_button_clicked) self.show_all() # self.pack_start(button,False) def serverlist_loading_finished(self): """ Callback method executed when the search has finished """ #reactivate the search button self.filter.unlock() self.statusbar.lock() self.qm = None
def __init__(self): """ Constructor """ gtk.VBox.__init__(self) self.filter = RecentSeversFilter() self.filter.show() self.pack_start(self.filter, False, False) # top pane area paned = gtk.VPaned() paned.show() self.pack_start(paned) # bottom add a statusbar self.statusbar = StatusBar(self) self.pack_start(self.statusbar, False, False) # serverlist window self.serverlist = RecentServersList(self) paned.pack1(self.serverlist, True, False) #paned.add1(self.serverlist) # bottom panearea bottompane = gtk.HPaned() paned.pack2(bottompane, True, False) #paned.add2(bottompane) #left box self.playerlist = PlayerList() bottompane.pack1(self.playerlist, False, False) #right box self.detailsbox = ServerDetailBox() vbox = gtk.VBox() bottompane.pack2(vbox, True, False) buttonbox = gtk.HBox() vbox.pack_start(buttonbox, False, False) vbox.pack_start(self.detailsbox) refresh_button = gtk.Button('Refresh') refreshimage = gtk.Image() refreshimage.set_from_stock(gtk.STOCK_REFRESH, gtk.ICON_SIZE_BUTTON) refresh_button.set_image(refreshimage) connect_button = gtk.Button('Connect') connectimage = gtk.Image() connectimage.set_from_stock(gtk.STOCK_CONNECT, gtk.ICON_SIZE_BUTTON) connect_button.set_image(connectimage) addfav_button = gtk.Button('Add to Favorites') favimage = gtk.Image() favimage.set_from_stock(gtk.STOCK_ADD, gtk.ICON_SIZE_BUTTON) addfav_button.set_image(favimage) removerecent_button = gtk.Button('Remove Server from List') removeimage = gtk.Image() removeimage.set_from_stock(gtk.STOCK_DELETE, gtk.ICON_SIZE_BUTTON) removerecent_button.set_image(removeimage) buttonbox.pack_start(refresh_button, True, True) buttonbox.pack_start(connect_button, True, True) buttonbox.pack_start(addfav_button, True, True) buttonbox.pack_start(removerecent_button, True, True) refresh_button.connect("clicked", self.onRefreshButtonClicked) connect_button.connect("clicked", self.connect_button_clicked) removerecent_button.connect("clicked", self.onRemoveRecentClicked) addfav_button.connect("clicked", self.onAddFavButtonClicked) self.show_all()
def __create_widget(self): '''create gtk widget''' title_item_font_size = TITLE_FONT_SIZE option_item_font_size = CONTENT_FONT_SIZE # image init self.image_widgets["custom"] = ImageBox( app_theme.get_pixbuf("%s/pad_l%s.png" % (MODULE_NAME, self.has_touchpad_icon))) self.image_widgets["speed"] = ImageBox( app_theme.get_pixbuf("%s/pointer%s.png" % (MODULE_NAME, self.has_touchpad_icon))) self.image_widgets["double"] = ImageBox( app_theme.get_pixbuf("%s/double-click%s.png" % (MODULE_NAME, self.has_touchpad_icon))) self.image_widgets["drag"] = ImageBox( app_theme.get_pixbuf("%s/drag%s.png" % (MODULE_NAME, self.has_touchpad_icon))) self.image_widgets["double_test_1"] = app_theme.get_pixbuf( "%s/smiley00%s.png" % (MODULE_NAME, self.has_touchpad_icon)) self.image_widgets["double_test_2"] = app_theme.get_pixbuf( "%s/smiley01.png" % (MODULE_NAME)) # label init self.label_widgets["custom"] = Label( _("Custom"), app_theme.get_color("globalTitleForeground"), text_size=title_item_font_size, enable_select=False, enable_double_click=False) self.label_widgets["pointer_speed"] = Label( _("Pointer Speed"), app_theme.get_color("globalTitleForeground"), text_size=title_item_font_size, enable_select=False, enable_double_click=False) self.label_widgets["acceleration"] = Label( _("Acceleration"), text_size=option_item_font_size, text_x_align=ALIGN_END, enable_select=False, enable_double_click=False, fixed_width=STANDARD_LINE) self.label_widgets["sensitivity"] = Label( _("Sensitivity"), text_size=option_item_font_size, text_x_align=ALIGN_END, enable_select=False, enable_double_click=False, fixed_width=STANDARD_LINE) self.label_widgets["double_click"] = Label( _("Double-click"), app_theme.get_color("globalTitleForeground"), text_size=title_item_font_size, enable_select=False, enable_double_click=False) self.label_widgets["click_rate"] = Label( _("Frequency"), text_size=option_item_font_size, text_x_align=ALIGN_END, enable_select=False, enable_double_click=False, fixed_width=STANDARD_LINE) self.label_widgets["double_test"] = Label( _("Double-click on the smiley face to test your settings."), label_width=HSCALEBAR_WIDTH, wrap_width=HSCALEBAR_WIDTH, enable_select=False, enable_double_click=False) self.label_widgets["drag_drop"] = Label( _("Drag and Drop"), app_theme.get_color("globalTitleForeground"), text_size=title_item_font_size, enable_select=False, enable_double_click=False) self.label_widgets["drag_threshold"] = Label( _("Drag threshold"), text_size=option_item_font_size, text_x_align=ALIGN_END, enable_select=False, enable_double_click=False, fixed_width=STANDARD_LINE) self.label_widgets["relevant"] = Label(_("Relevant Settings"), text_size=title_item_font_size, enable_select=False, enable_double_click=False, fixed_width=180) # button init self.button_widgets["right_hand_radio"] = RadioButton( _("Right-handed"), padding_x=10) self.button_widgets["left_hand_radio"] = RadioButton(_("Left-handed"), padding_x=10) self.button_widgets["double_test"] = gtk.EventBox() # relevant settings button self.button_widgets["keyboard_setting"] = Label( "<u>%s</u>" % _("Keyboard Settings"), DynamicColor(GOTO_FG_COLOR), text_size=option_item_font_size, enable_select=False, enable_double_click=False, fixed_width=180) self.button_widgets["mouse_setting"] = Label( "<u>%s</u>" % _("Mouse Settings"), DynamicColor(GOTO_FG_COLOR), text_size=option_item_font_size, enable_select=False, enable_double_click=False, fixed_width=180) self.button_widgets["set_to_default"] = Button(_("Reset")) # container init self.container_widgets["main_vbox"] = gtk.VBox(False) self.container_widgets["statusbar"] = StatusBar() self.container_widgets["main_swindow"] = ScrolledWindow() self.container_widgets["main_hbox"] = gtk.HBox(False) self.container_widgets["left_vbox"] = gtk.VBox(False) self.container_widgets["right_vbox"] = gtk.VBox(False) self.container_widgets["custom_main_vbox"] = gtk.VBox(False) # custom self.container_widgets["custom_label_hbox"] = gtk.HBox(False) self.container_widgets["custom_button_hbox"] = gtk.HBox(False) self.container_widgets["pointer_speed_main_vbox"] = gtk.VBox( False) # pointer speed self.container_widgets["pointer_speed_label_hbox"] = gtk.HBox(False) self.container_widgets["pointer_speed_table"] = gtk.Table(2, 4, False) self.container_widgets["double_click_main_vbox"] = gtk.VBox( False) # double click self.container_widgets["double_click_label_hbox"] = gtk.HBox(False) self.container_widgets["double_click_table"] = gtk.Table(2, 4, False) self.container_widgets["drag_threshold_main_vbox"] = gtk.VBox( False) # mouse wheel self.container_widgets["drag_threshold_label_hbox"] = gtk.HBox(False) self.container_widgets["drag_threshold_table"] = gtk.Table(1, 4, False) # alignment init self.alignment_widgets["left"] = gtk.Alignment() self.alignment_widgets["right"] = gtk.Alignment() self.alignment_widgets["custom_label"] = gtk.Alignment() # custom self.alignment_widgets["custom_button"] = gtk.Alignment() self.alignment_widgets["pointer_speed_label"] = gtk.Alignment( ) # pointer speed self.alignment_widgets["pointer_speed_table"] = gtk.Alignment() self.alignment_widgets["double_click_label"] = gtk.Alignment( ) # double click self.alignment_widgets["double_click_table"] = gtk.Alignment() self.alignment_widgets["drag_threshold_label"] = gtk.Alignment( ) # mouse wheel self.alignment_widgets["drag_threshold_table"] = gtk.Alignment() self.alignment_widgets["keyboard_setting"] = gtk.Alignment() self.alignment_widgets["mouse_setting"] = gtk.Alignment() # adjust init self.adjust_widgets["pointer_speed_accel"] = gtk.Adjustment( 1.0, 1.0, 10.0, 1, 2) self.adjust_widgets["pointer_speed_sensitiv"] = gtk.Adjustment( 1, 1, 10, 1, 2) self.adjust_widgets["double_click_rate"] = gtk.Adjustment( 100, 100, 1000, 100, 200) self.adjust_widgets["drag_threshold_time"] = gtk.Adjustment( 1, 1, 10, 1, 2) # scale init self.scale_widgets["pointer_speed_accel"] = HScalebar(value_min=1.0, value_max=10.0) self.scale_widgets["pointer_speed_sensitiv"] = HScalebar(value_min=1, value_max=10) self.scale_widgets["double_click_rate"] = HScalebar(value_min=100, value_max=1000) self.scale_widgets["drag_threshold_time"] = HScalebar(value_min=1, value_max=10)
class EdaApp(Frame): def __init__(self, master=None): Frame.__init__(self, master, relief=SUNKEN, bd=2) self.create_menubar() self.master.config(menu=self.menubar) self.pack(side=TOP, fill=BOTH, expand=True) panwin = PanedWindow(self, orient=VERTICAL, sashwidth=5, bd=0, bg='gray80', opaqueresize=0) self.canvas = XCanvas(self.master, bg="white", width=1200, height=640, x_axis=11, scalewidget=False, bd=0, highlightthickness=0) self.tkcon = TkConsole(self.master, height=12, width=90, background='ivory') self.status = StatusBar(self.master) self.canvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True) self.tkcon.pack(side=tk.TOP, fill=tk.BOTH, expand=True) self.status.pack(side=BOTTOM, fill=X, expand=False) self.tkcon.focus_set() # Put here all initializations you want to have in console # However it's better to use an initialization file for tkcon (look at tkcon.py) self.tkcon.eval('import os') self.tkcon.eval('import sys') self.tkcon.eval('from basics import *') self.status.set("%-60s %-16s %-16s", "Status line for this eda app (60 chars)", "Part2 (16c)", "Part3 (16c)") def create_menubar(self): self.menubar = tk.Menu(self) # File menu menu = tk.Menu(self.menubar, tearoff=0) self.menubar.add_cascade(label="File", menu=menu) menu.add_command(label="New", command=self.new) menu.add_command(label="Open", command=self.open) menu.add_command(label="Exit", command=self.exit) # Edit menu menu = tk.Menu(self.menubar, tearoff=0) self.menubar.add_cascade(label="Edit", menu=menu) menu.add_command(label="Cut", command=self.cut) menu.add_command(label="Copy", command=self.copy) menu.add_command(label="Paste", command=self.paste) menu.add_command(label="Clear ALL", command=self.clear) # Help menu menu = tk.Menu(self.menubar, tearoff=0) self.menubar.add_cascade(label="Help", menu=menu) menu.add_command(label="About", command=self.about) menu.add_command(label="Help", command=self.help) def debug(self, event): #print(event.keysym) #print(self.panwin.cget('sashwidth')) #self.panwin.config(sashwidth=6) #print(self.winfo_geometry()) #self.panwin.paneconfigure(self.tkcon, minsize=100) pass def new(self): messagebox.showwarning("Not implemented", "The 'new' method is not implemented yet") def open(self): messagebox.showwarning("Not implemented", "The 'open' method is not implemented yet") def exit(self): answer = messagebox.askyesno("Exit?", "Are you sure you want to exit?") if answer: sys.exit(0) def clear(self): self.tkcon.clear() def cut(self): messagebox.showwarning("Not implemented", "The 'cut' method is not implemented yet") def copy(self): messagebox.showwarning("Not implemented", "The 'copy' method is not implemented yet") def paste(self): messagebox.showwarning("Not implemented", "The 'paste' method is not implemented yet") def help(self): try: self.help_top.destroy() except: pass self.help_top = tk.Tk() self.help_top.wm_title('HELP WINDOW') t = tk.Text(self.help_top, font=('Consolas', 10, 'bold'), width=80, height=24, background='cornsilk', foreground='blue') t.insert( END, "Edit the help method:\nRead some help file and insert it here") t.pack(fill=BOTH, expand=True) def about(self): messagebox.showinfo( "About EDA Application", "Engineering Design Project\nEEE Depatment\nPublic Education College" )
class EdaPlacer(tk.Frame): def __init__(self, master=None): tk.Frame.__init__(self, master, relief=tk.SUNKEN, bd=2) self.create_menubar() self.master.config(menu=self.menubar) #self.pack(side=tk.TOP, fill=tk.BOTH, expand=True) self.canvas = XCanvas(self.master, bg="white", width=900, height=540, scalewidget=False, bd=0, highlightthickness=0) self.tkcon = TkConsole(self.master, height=12, width=90, background='ivory') self.status = StatusBar(self.master) self.canvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True) self.tkcon.pack(side=tk.TOP, fill=tk.BOTH, expand=True) self.status.pack(side=tk.BOTTOM, fill=tk.X, expand=True) self.tkcon.focus_set() self.lastdir = os.environ['HOMEPATH'] self.units = [] self.title() self.status.set("Level Placer Status") #self.update() def create_menubar(self): self.menubar = tk.Menu(self) # File menu menu = tk.Menu(self.menubar, tearoff=0) self.menubar.add_cascade(label="File", menu=menu) menu.add_command(label="New", command=self.new) menu.add_command(label="Open", command=self.open) menu.add_command(label="Exit", command=self.exit) # Edit menu menu = tk.Menu(self.menubar, tearoff=0) self.menubar.add_cascade(label="Edit", menu=menu) menu.add_command(label="Run Placer", command=self.place) menu.add_command(label="Collapse", command=self.collapse) menu.add_command(label="Clear ALL", command=self.clear) menu.add_separator() self.showNets = tk.IntVar(master=self.menubar, value=True) menu.add_checkbutton(label="Show nets", variable=self.showNets, command=self.draw_nets) # Help menu menu = tk.Menu(self.menubar, tearoff=0) self.menubar.add_cascade(label="Help", menu=menu) menu.add_command(label="About", command=self.about) menu.add_command(label="Help", command=self.help) def new(self): easygui.msgbox("The 'new' method is not implemented yet", "Not implemented") def open(self, locfile=None): if locfile is None: filetypes = [['.loc', 'LOCATION files']] #lastdir = self.lastdir + '/*.loc' lastdir = self.lastdir locfile = easygui.fileopenbox('Dialog', 'Select Location File', default=lastdir, filetypes=filetypes) if locfile is None: return design_dir, locfile = os.path.split(locfile) design_name = os.path.splitext(locfile)[0] self.design = Design(design_dir, design_name) self.title(self.design.name) self.clear() #self.canvas.fit() self.draw_units() self.draw_nets(True) self.status.set("units=%s nets=%s Total Area = %s Total Length = %s" % \ (len(self.design.units), len(self.design.nets), self.design.total_area(), self.design.total_length())) def draw_units(self): width = self.design.tech['design_width'] height = self.design.tech['design_height'] self.canvas.config(scrollregion=(-50, -50, width + 50, height + 50)) self.canvas.draw_axis(10, 10) self.design.chip.draw(self.canvas, outline='maroon', width=3, fill=None, stipple=None, tags=['root', 'chip']) for u in self.design.units: u.draw(self.canvas, fill='red', stipple='gray12') def draw_nets(self, show=None): if show is None: show = self.showNets.get() if show: for net in self.design.nets: net.draw(self.canvas) else: self.canvas.delete('net') def place(self, netlist=None): self.clear('eda&&net') if self.units is None: print("You must open a loc file first!") return self.placer = LevelPlacer(self.design.chip, self.design.units) self.placer.run() self.unplaced_units = self.placer.list_unplaced_units() print("Unplaced units:", self.unplaced_units) for u in self.placer.list_placed_units(): #print(u) self.canvas.delete(u.name) u.draw(self.canvas, fill='green', stipple='gray12') #self.update() #time.sleep(0.05) for u in self.unplaced_units: self.canvas.tag_raise(u.name) if netlist is not None: nets = read_nets(netlist, udict) for n in nets: n.draw(self.canvas) #self.update() #time.sleep(1) self.canvas.delete(n.name) self.unplaced() def unplaced(self): "Put the unplaced units in a special container called unchip" x1 = self.design.chip.x1 y1 = self.design.chip.y1 + self.design.chip.height() + 40 x2 = self.design.chip.x2 y2 = self.design.chip.y2 + self.design.chip.height() + 40 self.unchip = Unit("unchip", x1, y1, x2, y2) self.unchip.draw(self.canvas, outline='blue', width=3, tags=['unchip', 'unplaced']) self.canvas.config(scrollregion=(-50, -50, x2 + 50, y2 + 50)) placer = LevelPlacer(self.unchip, list(self.unplaced_units), False) placer.run() for u in placer.list_placed_units(): #print(u) self.canvas.delete(u.name) u.draw(self.canvas, fill='red', stipple='gray12', tags=['unplaced']) #self.update() #time.sleep(0.05) def collapse(self): self.clear() for u in self.units: u.place(0, 0) self.draw_units() def exit(self): answer = easygui.ynbox("Exit?", "Are you sure you want to exit?") if answer: sys.exit(0) def clear(self, tag='eda'): self.canvas.delete(tag) def help(self): try: self.help_top.destroy() except: pass self.help_top = tk.Tk() self.help_top.wm_title('HELP WINDOW') t = tk.Text(self.help_top, font=('Consolas', 10, 'bold'), width=80, height=24, background='cornsilk', foreground='blue') t.insert( END, "Edit the help method:\nRead some help file and insert it here") t.pack(fill=BOTH, expand=True) def title(self, postfix=None): ttl = "Simple Shelf Placer" if not postfix is None: ttl += ":" + " " + postfix self.master.wm_title(ttl) def about(self): easygui.msgbox( "Engineering Design Project\nEEE Depatment\nSimpleton College", "About EDA Application") def debug(self, event): #print(event.keysym) #print(self.panwin.cget('sashwidth')) #self.panwin.config(sashwidth=6) #print(self.winfo_geometry()) #self.panwin.paneconfigure(self.tkcon, minsize=100) pass
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()
class FavoritesTab(BaseTab): """ UI Element for the content of the favorites tab. """ def __init__(self): """ Constructor """ gtk.VBox.__init__(self) self.filter = FavoritesFilter() self.filter.show() self.pack_start(self.filter, False, False) # top pane area paned = gtk.VPaned() paned.show() self.pack_start(paned) # bottom add a statusbar self.statusbar = StatusBar(self) self.pack_start(self.statusbar, False, False) # serverlist window self.serverlist = ServerList(self) paned.pack1(self.serverlist, True, False) #paned.add1(self.serverlist) # bottom panearea bottompane = gtk.HPaned() paned.pack2(bottompane, True, False) #paned.add2(bottompane) #left box self.playerlist = PlayerList() bottompane.pack1(self.playerlist, False, False) #right box self.detailsbox = ServerDetailBox() vbox = gtk.VBox() bottompane.pack2(vbox, True, False) buttonbox = gtk.HBox() #self.detailsbox.pack_start(buttonbox, False, False) vbox.pack_start(buttonbox, False, False) vbox.pack_start(self.detailsbox) refresh_button = gtk.Button('Refresh') refreshimage = gtk.Image() refreshimage.set_from_stock(gtk.STOCK_REFRESH, gtk.ICON_SIZE_BUTTON) refresh_button.set_image(refreshimage) connect_button = gtk.Button('Connect') connectimage = gtk.Image() connectimage.set_from_stock(gtk.STOCK_CONNECT, gtk.ICON_SIZE_BUTTON) connect_button.set_image(connectimage) removefav_button = gtk.Button('Remove from Favorites') removeimage = gtk.Image() removeimage.set_from_stock(gtk.STOCK_DELETE, gtk.ICON_SIZE_BUTTON) removefav_button.set_image(removeimage) buttonbox.pack_start(refresh_button, True, True) buttonbox.pack_start(connect_button, True, True) buttonbox.pack_start(removefav_button, False, False) refresh_button.connect("clicked", self.onRefreshButtonClicked) removefav_button.connect("clicked", self.onRemoveFavoriteClicked) connect_button.connect("clicked", self.connect_button_clicked) self.show_all() # self.pack_start(button,False) def connect_button_clicked(self, widget): """ Callback of the the connect button """ gui = GuiController() server = self.detailsbox.current_server if server: if server.needsPassword(): passdialog = PasswordDialog(server, PassDialogType\ .SERVER_PASSWORD) passdialog.run() else: gui.connectToServer(server) def onRemoveFavoriteClicked(self, widget): """ Callback method for the remove button. Triggers the removal of the favorite entry by calling the gui controller which then removes the favorite (from list in memory and also from file) Also removes the favorite directly from the liststore. @param widget - the widget that emitted the clicked signal - the button """ #the current selected server displayed in the details server = self.detailsbox.current_server if server: #remove it from the favoriteslist gui = GuiController() gui.removeFavorite(server) #remove row from liststore selection = self.serverlist.serverlistview.get_selection() result = selection.get_selected() if result: model, iter = result model.remove(iter) def onRefreshButtonClicked(self, widget): """ Callback of the refreshbutton. """ selection = self.serverlist.serverlistview.get_selection() model, paths = selection.get_selected_rows() if paths: row = model[paths[0][0]] server = row[8] guicontroller = GuiController() guicontroller.setDetailServer(server, self) def addServer(self, server): """ Add a server to the listview/store. Called by the guicontroller. """ self.serverlist.addServer(server) def clearServerList(self): """ Clears the embeded serverlist treeview """ self.serverlist.clear() def setServerdetails(self, server): """ Updates the embedded serverdetails element """ self.playerlist.clear() for player in server.getPlayerList(): self.playerlist.addPlayer(player) self.detailsbox.setServerDetails(server) # update row in list # but only if the corresponding option is True fm = FileManager() config = fm.getConfiguration() if 'True' == config[cfgkey.OPT_UPDATE_SL_ROW]: self.serverlist.update_selected_row(server) def serverlist_loading_finished(self): """ Callback method executed when the search has finished """ #reactivate the search button self.filter.refresh_button.set_sensitive(True) self.statusbar.lock() self.qm = None
class Player(Fighter): def __init__(self, direction=Direction.right, loc=[50, 200]): super().__init__(direction, loc) self.pressed_keys = [] self.hp_status_bar = StatusBar(100, pg.Color("red"), [5, 10]) self.charge_status_bar = StatusBar(0, pg.Color("lightblue"), [5, 50]) self.right_direction_key = pg.K_d self.left_direction_key = pg.K_a self.controls = { Action.running: [pg.K_a, pg.K_d], Action.block: [pg.K_LSHIFT], Action.jumping: [pg.K_w], Action.crouched: [pg.K_s], Action.attack: [pg.K_SPACE] } def handle_event(self, event): if not self.gg: if event.key in self.control_keys(): if event.type == pg.KEYDOWN: self.press_key(event.key) elif event.type == pg.KEYUP: self.key_released(event.key) def control_keys(self): control_keys = [] for action, keys in self.controls.items(): control_keys += keys return control_keys def press_key(self, key): if key in self.control_keys(): self.pressed_keys += [key] if Action.damaged not in self.actions: if key in self.controls[Action.running]: self.start_running_with_key(key) elif key in self.controls[Action.block]: self.start_block() elif key in self.controls[Action.jumping]: self.start_jumping_charge() elif key in self.controls[Action.crouched]: self.start_crouching() elif key in self.controls[Action.attack]: if Action.crouched in self.actions: self.start_attacking() else: self.start_charging_attack() def start_running_with_key(self, key): if Action.crouched not in self.actions: if key == self.right_direction_key: self.start_running(Direction.right) elif key == self.left_direction_key: self.start_running(Direction.left) def start_sliding_with_key(self, velocity, key): if key == self.right_direction_key: self.direction = Direction.right self.start_sliding(velocity) elif key == self.left_direction_key: self.direction = Direction.left self.start_sliding(velocity) def pressed_key(self): return self.pressed_keys[-1] def key_released(self, key): new_pressed_keys = [] for pressed_key in self.pressed_keys: if pressed_key != key: new_pressed_keys += [pressed_key] self.pressed_keys = new_pressed_keys if key == self.controls[Action.block][0]: self.is_blocking = False self.remove_action(Action.block) if key == self.controls[Action.attack][0]: self.remove_action(Action.charge) self.start_attacking() return if key == self.controls[Action.crouched][0]: self.remove_action(Action.crouched) self.pressed_keys = [] self.current_speed = self.start_speed if key == self.controls[Action.jumping][0]: self.start_jumping() return if not self.pressed_keys: if self.current_speed > ((self.start_speed + self.max_speed) / 2): self.start_sliding_with_key(self.current_speed, key) else: self.update_action(Action.idle) return for remaining_key in self.pressed_keys: if remaining_key in self.controls[Action.running]: self.start_running_with_key(remaining_key) break def draw(self, surface, force=False): super().draw(surface, force) self.hp_status_bar.fill_value = self.hp self.hp_status_bar.draw(surface) if Action.charge in self.actions: self.charge_status_bar.fill_value = self.attack_charge / self.attack_max_charge * 100 self.charge_status_bar.draw(surface)
# self.work_frame.active_buffer.delete(a - 1) # self.workframe.active_buffer.insert(tk.END, "") # self.workframe.active_buffer.config(state=tk.DISABLED) # self.spacebar.focus_set() else: return if __name__ == "__main__": from workframe import WorkFrame from statusbar import StatusBar from spacebar import SpaceBar ROOT = tk.Tk() FRAME_1 = WorkFrame(ROOT) FRAME_2 = StatusBar(ROOT) FRAME_3 = SpaceBar(ROOT) FRAME_1.pack() FRAME_2.pack() FRAME_3.pack() MasterCommand(ROOT, FRAME_1, FRAME_2, FRAME_3) ROOT.mainloop()
class CmyChat(object): def __init__(self, stdscr, nlines, ncols, begin_y, begin_x): self.stdscr = stdscr self.nlines = nlines self.ncols = ncols self.begin_y = begin_y self.begin_x = begin_x self.init_variable() self.init_pair() self.cal_wininfo() self.set_win_color(self._frdls_info, 1) self.set_win_color(self._msgls_info, 2) self.set_win_color(self._input_info, 3) self.set_win_color(self._command_info, 4) self.create_win() # send file path self.filepath = '' self.file_sender = '' self.file_receiver = '' self.sio = socketio.Client() def init_variable(self): self.friends = [] self.text = '' self.command = '' self.mode = MODE_NORMAL self.user = {'username': ''} self.current_receiver = 'no_receiver' self.msgls_set = {} self.logged_in = False def init_pair(self): frdls_color = Config['color']['frdls'] msgls_color = Config['color']['msgls'] input_color = Config['color']['input'] command_color = Config['color']['command'] curses.init_pair(1, frdls_color['fgcolor'], frdls_color['bgcolor']) curses.init_pair(2, msgls_color['fgcolor'], msgls_color['bgcolor']) curses.init_pair(3, input_color['fgcolor'], input_color['bgcolor']) curses.init_pair(4, command_color['fgcolor'], command_color['bgcolor']) def cal_wininfo(self): self._frdls_info = WinInfo( self.begin_y + 1, self.begin_x + 1, (self.begin_y + 1) + (self.nlines - 2 - 4 - 1), (self.begin_x + 1) + (int((self.ncols - 4) * 0.25) - 1)) self._msgls_info = WinInfo(self.begin_y + 1, self._frdls_info.smaxcol + 1 + 1 + 1, (self.begin_y + 1) + (int( (self.nlines - 2 - 2 - 4) * 0.7) - 1), (self.begin_x + self.ncols - 1 - 1)) self._input_info = WinInfo(self._msgls_info.smaxrow + 1 + 1 + 1, self._frdls_info.smaxcol + 1 + 1 + 1, self.begin_y + self.nlines - 1 - 4 - 1, self.begin_x + self.ncols - 1 - 1) self._command_info = WinInfo(self.begin_y + self.nlines - 1 - 1 - 1, self.begin_x + 1, self.begin_y + self.nlines - 1 - 1 - 1, self.begin_x + self.ncols - 1 - 1) self._statusbar_info = WinInfo(self.begin_y + self.nlines - 1, self.begin_x, self.begin_y + self.nlines - 1, self.begin_x + self.ncols - 1) def set_win_color(self, wininfo, colorpair): line = wininfo.sminrow while line <= wininfo.smaxrow: self.stdscr.chgat(line, wininfo.smincol, wininfo.smaxcol - wininfo.smincol + 1, curses.color_pair(colorpair)) line = line + 1 def create_win(self): self.frdls = FrdLs( self.stdscr, self._frdls_info.smaxcol - self._frdls_info.smincol + 1, self._frdls_info.sminrow, self._frdls_info.smincol, self._frdls_info.smaxrow, self._frdls_info.smaxcol, self.friends, Config['color']['frdls']['fgcolor'], Config['color']['frdls']['bgcolor']) self.msgls_set[self.current_receiver] = MsgLs( self.stdscr, self._msgls_info.smaxcol - self._msgls_info.smincol + 1, self._msgls_info.sminrow, self._msgls_info.smincol, self._msgls_info.smaxrow, self._msgls_info.smaxcol, [], fgcolor=Config['color']['msgls']['fgcolor'], bgcolor=Config['color']['msgls']['bgcolor']) self.input = Input( self.stdscr, self._input_info.smaxcol - self._input_info.smincol + 1, self._input_info.sminrow, self._input_info.smincol, self._input_info.smaxrow, self._input_info.smaxcol, self.text, Config['color']['input']['fgcolor'], Config['color']['input']['bgcolor']) self.command = Command( self.stdscr, self._command_info.smaxrow - self._command_info.sminrow + 1, self._command_info.sminrow, self._command_info.smincol, self._command_info.smaxrow, self._command_info.smaxcol, self.command, Config['color']['command']['fgcolor'], Config['color']['command']['bgcolor']) self.statusbar = StatusBar(self.stdscr, 1, self._statusbar_info.smaxcol - self._statusbar_info.smincol + 1, self._statusbar_info.sminrow, self._statusbar_info.smincol, self._statusbar_info.smaxrow, self._statusbar_info.smaxcol, "NORMAL", "xxxxxx", fgcolor=curses.COLOR_BLACK, bgcolor=curses.COLOR_WHITE) def resize(self, nlines, ncols, begin_y=0, begin_x=0): self.nlines = nlines self.ncols = ncols self.begin_y = begin_y self.begin_x = begin_x def draw(self): self.frdls.draw() self.msgls_set[self.current_receiver].draw() self.input.draw() self.command.draw() self.statusbar.draw() def refresh(self): self.stdscr.refresh() self.frdls.refresh() self.msgls_set[self.current_receiver].refresh() self.input.refresh() self.command.refresh() self.statusbar.refresh() def clear(self): self.stdscr.clear() self.frdls.clear() self.msgls_set[self.current_receiver].clear() self.input.clear() self.command.clear() self.statusbar.clear() def run(self): self.connect(URL) self.event_listenning() while True: ch = self.stdscr.getch() if ch == curses.KEY_RESIZE: self.on_key_resize() elif ch == 27: self.on_key_esc() elif self.mode == MODE_NORMAL: if ch == ord('q'): if self.logged_in: self.sio.emit( 'logout', {}, callback=lambda res: self.sio.disconnect()) else: self.sio.emit('quit', {}, callback=lambda: self.sio.disconnect()) break else: self.on_normal(ch) elif self.mode == MODE_FRDLS: self.on_frdls(ch) elif self.mode == MODE_MSGLS: self.on_msgls(ch) elif self.mode == MODE_INPUT: self.on_input(ch) elif self.mode == MODE_COMMAND: self.on_command(ch) def on_key_resize(self): nlines, ncols = self.stdscr.getmaxyx() if nlines >= 25 and ncols >= 55: self.clear() self.friends = self.frdls.friends self.msgs = self.msgls_set[self.current_receiver].msgs self.text = self.input.text self.command = self.command.command self.resize(nlines, ncols) self.cal_wininfo() self.set_win_color(self._frdls_info, 1) self.set_win_color(self._msgls_info, 2) self.set_win_color(self._input_info, 3) self.set_win_color(self._command_info, 4) self.create_win() self.draw() self.refresh() else: self.stdscr.clear() try: curses.init_pair(6, curses.COLOR_RED, curses.COLOR_BLACK) self.stdscr.addstr(int(nlines / 2), int((ncols - len("TOO SMALL")) / 2), "TOO SMALL", curses.color_pair(6)) except curses.error: pass self.stdscr.refresh() def on_key_esc(self): self.mode = MODE_NORMAL self.statusbar.mode = "NORMAL" self.statusbar.content() self.statusbar.refresh() def on_normal(self, ch): if ch == ord('f'): self.mode = MODE_FRDLS self.statusbar.mode = "FRDLS" self.statusbar.content() self.statusbar.refresh() elif ch == ord('m'): self.mode = MODE_MSGLS self.statusbar.mode = "MSGLS" self.statusbar.content() self.statusbar.refresh() elif ch == ord('i'): self.mode = MODE_INPUT self.statusbar.mode = "INPUT" self.statusbar.content() self.statusbar.refresh() elif ch == ord('c'): self.mode = MODE_COMMAND self.statusbar.mode = "COMMAND" self.statusbar.content() self.statusbar.refresh() elif ch == ord('r'): # reconnect self.connect(URL) def on_frdls(self, ch): if ch == curses.KEY_UP: self.frdls.current_row_style( curses.color_pair(self.frdls.color_pair)) self.frdls.onkeyup() self.frdls.current_row_style(curses.A_REVERSE) self.refresh() elif ch == curses.KEY_DOWN: self.frdls.current_row_style( curses.color_pair(self.frdls.color_pair)) self.frdls.onkeydown() self.frdls.current_row_style(curses.A_REVERSE) self.refresh() elif ch == ord('\n'): receiver = self.frdls.friends[self.frdls.current_row - 1] if receiver != self.user['username']: self.msgls_set[self.current_receiver].clear() self.msgls_set[self.current_receiver].refresh() self.current_receiver = receiver self.msgls_set[self.current_receiver].content() self.msgls_set[self.current_receiver].refresh() self.mode = MODE_INPUT self.statusbar.mode = "INPUT" self.statusbar.content() self.statusbar.refresh() def on_msgls(self, ch): if ch == curses.KEY_UP: self.msgls_set[self.current_receiver].current_row_style( self.msgls_set[self.current_receiver].color_pair) self.msgls_set[self.current_receiver].onkeyup() self.msgls_set[self.current_receiver].current_row_style( curses.A_REVERSE) self.msgls_set[self.current_receiver].refresh() elif ch == curses.KEY_DOWN: self.msgls_set[self.current_receiver].current_row_style( self.msgls_set[self.current_receiver].color_pair) self.msgls_set[self.current_receiver].onkeydown() self.msgls_set[self.current_receiver].current_row_style( curses.A_REVERSE) self.msgls_set[self.current_receiver].refresh() def on_input(self, ch): if ch == curses.KEY_BACKSPACE: self.input.delete() self.input.clear() self.input.refresh() self.input.content() self.input.ondelete() self.set_win_color(self._input_info, 3) self.stdscr.refresh() self.input.refresh() elif ch == curses.KEY_UP: self.input.onkeyup() self.input.refresh() elif ch == curses.KEY_DOWN: self.input.onkeydown() self.input.refresh() elif ch == ord('\n'): msg = Msg(self.user['username'], self.current_receiver, self.input.text, time.strftime('%H:%M:%S', time.localtime(time.time()))) self.sio.emit('message', { 'receiver': self.current_receiver, 'message': self.input.text }, callback=lambda res: self.onmessage(res, msg)) self.input.text = '' self.input.clear() self.input.refresh() self.input.content() self.set_win_color(self._input_info, 3) self.stdscr.refresh() self.input.refresh() else: self.input.read(ch) self.input.content() self.input.oninsert() self.input.refresh() def on_command(self, ch): if ch == curses.KEY_LEFT: self.command.onkeyleft() self.command.refresh() elif ch == curses.KEY_RIGHT: self.command.onkeyright() self.command.refresh() elif ch == curses.KEY_BACKSPACE: self.command.delete() self.command.clear() self.command.refresh() self.command.content() self.command.ondelete() self.set_win_color(self._command_info, 4) self.stdscr.refresh() self.command.refresh() elif ch == ord('\n'): res = self.command.reslove() self.exec_cmd(res) self.command.command = '' self.command.clear() self.command.refresh() self.command.content() self.set_win_color(self._command_info, 4) self.stdscr.refresh() self.command.refresh() else: self.command.read(ch) self.command.content() self.command.oninsert() self.command.refresh() def exec_cmd(self, cmd): if cmd['status'] == COMMAND_IS_EMPTY: self.prompt('command is empty') else: if cmd['cmd'] == 'login': self.login(cmd['parms']) elif cmd['cmd'] == 'register': self.register(cmd['parms']) elif cmd['cmd'] == 'logout': self.logout(cmd['parms']) elif cmd['cmd'] == 'sendfile': self.sendfile(cmd['parms']) else: self.prompt('command undefined') def connect(self, url): try: self.sio.connect(url) except socketio.exceptions.ConnectionError as e: self.prompt(str(e)) except ValueError as e: self.prompt(str(e)) else: self.prompt('successful connection') def login(self, parms): if len(parms) != 2: self.prompt('parms error') else: username = parms[0] password = parms[1] try: self.sio.emit('login', { 'username': username, 'password': password }, callback=lambda res: self.onlogin(username, res)) except socketio.exceptions.ConnectionError as e: self.prompt(str(e)) def register(self, parms): if len(parms) != 2: self.prompt('parms error') else: username = parms[0] password = parms[1] try: self.sio.emit('register', { 'username': username, 'password': password }, callback=lambda res: self.onregister(res)) except socketio.exceptions.ConnectionError as e: self.prompt(str(e)) def logout(self, parms): if len(parms) != 0: self.prompt('parms error') else: self.sio.emit('logout', '', callback=lambda res: self.onlogout(res)) def sendfile(self, parms): if len(parms) != 1: self.prompt('parms error') else: filepath = parms[0] if (not os.path.exists(filepath)) or ( not os.path.isfile(filepath)): self.prompt('can not found file {}'.format(filepath)) else: self.filepath = filepath self.file_receiver = self.current_receiver try: self.sio.emit( 'fconnect', { 'name': self.user['username'], 'filename': os.path.split(filepath)[0], 'filesize': os.path.getsize(filepath) }) except socketio.exceptions.ConnectionError as e: self.prompt(str(e)) def prompt(self, prompt): self.statusbar.other = prompt self.statusbar.clear() self.statusbar.refresh() self.statusbar.content() self.statusbar.refresh() def event_listenning(self): @self.sio.on('connect') def connect(): pass @self.sio.on('disconnect') def disconnect(): pass @self.sio.on('friend_login') def friend_login(friend): self.frdls.friends.append(friend) self.frdls.content() self.frdls.refresh() self.msgls_set[friend] = MsgLs(self.stdscr, self._msgls_info.smaxcol - self._msgls_info.smincol + 1, self._msgls_info.sminrow, self._msgls_info.smincol, self._msgls_info.smaxrow, self._msgls_info.smaxcol, [], receiver=friend) @self.sio.on('friend_logout') def friend_logout(friend): self.frdls.clear() self.frdls.refresh() self.frdls.friends.remove(friend) self.frdls.content() self.frdls.refresh() self.msgls_set.pop(friend) @self.sio.on('user_online') def user_online(users): for friend in users['users']: self.frdls.friends.append(friend) self.msgls_set[friend] = MsgLs(self.stdscr, self._msgls_info.smaxcol - self._msgls_info.smincol + 1, self._msgls_info.sminrow, self._msgls_info.smincol, self._msgls_info.smaxrow, self._msgls_info.smaxcol, [], receiver=friend) self.frdls.content() self.frdls.refresh() @self.sio.on('message') def message(msg): sender = msg['sender'] message = msg['message'] msg = Msg(sender, self.user['username'], message, time.strftime('%H:%M:%S', time.localtime())) self.msgls_set[sender].add_msg(msg) if sender == self.current_receiver: self.msgls_set[self.current_receiver].content() self.msgls_set[self.current_receiver].move2bottom() self.msgls_set[self.current_receiver].refresh() self.prompt("Receive messages from " + sender) @self.sio.on('connect_ok') def connect_ok(data): th = threading.Thread(target=self._sendfile) th.start() th.join() self.prompt('file has sended') @self.sio.on('fconnect') def fconnect(data): self.file_sender = data['name'] self.sio.emit('connect_ok', {'name': self.file_sender}) th = threading.Thread(target=self._recvfile, args=(data['filename'], data['filesize'])) th.start() th.join() self.prompt('file has recved') def onlogin(self, username, res): if res['code'] == 0 or res['code'] == 1: self.logged_in = True self.user['username'] = username self.prompt(res['text']) def onmessage(self, res, msg): if res['code'] == 1: self.prompt(res['text']) self.msgls_set[self.current_receiver].add_msg(msg) self.msgls_set[self.current_receiver].content() self.msgls_set[self.current_receiver].move2bottom() self.msgls_set[self.current_receiver].refresh() else: self.prompt(res['text']) def onlogout(self, res): if res['code'] == 1: self.logged_in = False self.init_variable() self.create_win() self.draw() self.refresh() self.prompt(res['text']) def onregister(self, res): self.prompt(res['text']) def _sendfile(self): fsio = socketio.Client() fsio.connect('http://*****:*****@fsio.on('end') def end(data): fsio.disconnect() @fsio.on('recv_ok') def recv_ok(data): self.prompt(str(data['has'])) with open(self.filepath, 'rb') as f: buffer = f.read(10) block = 1 while buffer: fsio.emit('send_file', {'block': block, 'data': buffer}) buffer = f.read(10) block = block + 1 fsio.wait() def _recvfile(self, filename, filesize): fsio = socketio.Client() fsio.connect('http://*****:*****@fsio.on('end') def end(data): fsio.disconnect() @fsio.on('recv_file') def recv_file(data): file['recv_bytes'] = file['recv_bytes'] + len(data['data']) file['file_buffer'].append((data['block'], data['data'])) fsio.emit('recv_ok', { 'has': '[{:.2f}%]'.format((file['recv_bytes'] / filesize) * 100) }) self.prompt('[{:.2f}%]'.format( (file['recv_bytes'] / filesize) * 100)) if file['recv_bytes'] == filesize: file['file_buffer'].sort(key=lambda data: data[0]) with open('xxx.txt', 'ab+') as f: for block in file['file_buffer']: f.write(block[1]) fsio.emit('end', {}) fsio.wait()
def __create_widget(self): '''create gtk widget''' title_item_font_size = TITLE_FONT_SIZE option_item_font_szie = CONTENT_FONT_SIZE self.label_widgets["speaker"] = Label(_("Speaker"), app_theme.get_color("globalTitleForeground"), text_size=title_item_font_size, enable_select=False, enable_double_click=False) self.label_widgets["microphone"] = Label(_("Microphone"), app_theme.get_color("globalTitleForeground"), text_size=title_item_font_size, enable_select=False, enable_double_click=False) self.label_widgets["left"] = Label(_("Left"), enable_select=False, enable_double_click=False) self.label_widgets["right"] = Label(_("Right"), enable_select=False, enable_double_click=False) self.label_widgets["speaker_port"] = Label(_("Output Port"), text_size=option_item_font_szie, text_x_align=ALIGN_END, enable_select=False, enable_double_click=False, fixed_width=STANDARD_LINE) self.label_widgets["speaker_volume"] = Label(_("Output Volume"), text_size=option_item_font_szie, text_x_align=ALIGN_END, enable_select=False, enable_double_click=False, fixed_width=STANDARD_LINE) self.label_widgets["speaker_mute"] = Label(_("Sound Enabled"), text_size=option_item_font_szie, text_x_align=ALIGN_END, enable_select=False, enable_double_click=False, fixed_width=STANDARD_LINE) self.label_widgets["speaker_balance"] = Label(_("Balance"), text_size=option_item_font_szie, text_x_align=ALIGN_END, enable_select=False, enable_double_click=False, fixed_width=STANDARD_LINE) self.label_widgets["microphone_port"] = Label(_("Input Port"), text_size=option_item_font_szie, text_x_align=ALIGN_END, enable_select=False, enable_double_click=False, fixed_width=STANDARD_LINE) self.label_widgets["microphone_volume"] = Label(_("Input Volume"), text_size=option_item_font_szie, text_x_align=ALIGN_END, enable_select=False, enable_double_click=False, fixed_width=STANDARD_LINE) self.label_widgets["microphone_mute"] = Label(_("Sound Enabled"), text_size=option_item_font_szie, text_x_align=ALIGN_END, enable_select=False, enable_double_click=False, fixed_width=STANDARD_LINE) ##################################### # image init self.image_widgets["balance"] = ImageBox(app_theme.get_pixbuf("%s/balance.png" % MODULE_NAME)) self.image_widgets["speaker"] = ImageBox(app_theme.get_pixbuf("%s/speaker-3.png" % MODULE_NAME)) self.image_widgets["microphone"] = ImageBox(app_theme.get_pixbuf("%s/microphone.png" % MODULE_NAME)) self.image_widgets["device"] = app_theme.get_pixbuf("%s/device.png" % MODULE_NAME) # button init self.button_widgets["balance"] = SwitchButton( inactive_disable_dpixbuf=app_theme.get_pixbuf("toggle_button/inactive_normal.png"), active_disable_dpixbuf=app_theme.get_pixbuf("toggle_button/inactive_normal.png")) self.button_widgets["speaker"] = SwitchButton( inactive_disable_dpixbuf=app_theme.get_pixbuf("toggle_button/inactive_normal.png"), active_disable_dpixbuf=app_theme.get_pixbuf("toggle_button/inactive_normal.png")) self.button_widgets["microphone"] = SwitchButton( inactive_disable_dpixbuf=app_theme.get_pixbuf("toggle_button/inactive_normal.png"), active_disable_dpixbuf=app_theme.get_pixbuf("toggle_button/inactive_normal.png")) self.button_widgets["advanced"] = Button(_("Advanced")) self.button_widgets["speaker_combo"] = ComboBox(fixed_width=HSCALEBAR_WIDTH) self.button_widgets["microphone_combo"] = ComboBox(fixed_width=HSCALEBAR_WIDTH) # container init self.container_widgets["main_vbox"] = gtk.VBox(False) self.container_widgets["statusbar"] = StatusBar() self.container_widgets["slider"] = HSlider() self.container_widgets["swin"] = ScrolledWindow() self.container_widgets["advance_set_tab_box"] = TabBox() self.container_widgets["advance_set_tab_box"].draw_title_background = self.draw_tab_title_background self.container_widgets["main_hbox"] = gtk.HBox(False) self.container_widgets["left_vbox"] = gtk.VBox(False) self.container_widgets["right_vbox"] = gtk.VBox(False) self.container_widgets["balance_hbox"] = gtk.HBox(False) self.container_widgets["speaker_main_vbox"] = gtk.VBox(False) # speaker self.container_widgets["speaker_label_hbox"] = gtk.HBox(False) self.container_widgets["speaker_table"] = gtk.Table(4, 2) self.container_widgets["microphone_main_vbox"] = gtk.VBox(False) # microphone self.container_widgets["microphone_label_hbox"] = gtk.HBox(False) self.container_widgets["microphone_table"] = gtk.Table(4, 2) # alignment init self.alignment_widgets["slider"] = gtk.Alignment() self.alignment_widgets["main_hbox"] = gtk.Alignment() self.alignment_widgets["advance_set_tab_box"] = gtk.Alignment() self.alignment_widgets["left"] = gtk.Alignment() self.alignment_widgets["right"] = gtk.Alignment() self.alignment_widgets["speaker_label"] = gtk.Alignment() # speaker self.alignment_widgets["speaker_set"] = gtk.Alignment() self.alignment_widgets["microphone_label"] = gtk.Alignment() # microphone self.alignment_widgets["microphone_set"] = gtk.Alignment() # adjust init volume_max_percent = pypulse.MAX_VOLUME_VALUE * 100 / pypulse.NORMAL_VOLUME_VALUE self.adjust_widgets["balance"] = gtk.Adjustment(0, -1.0, 1.0, 0.1, 0.2) self.adjust_widgets["speaker"] = gtk.Adjustment(0, 0, volume_max_percent, 1, 5) self.adjust_widgets["microphone"] = gtk.Adjustment(0, 0, volume_max_percent, 1, 5) # scale init self.scale_widgets["balance"] = HScalebar(value_min=-1, value_max=1, gray_progress=True) self.scale_widgets["balance"].set_magnetic_values([(0, 0.1), (1, 0.1), (2, 0.1)]) self.scale_widgets["speaker"] = HScalebar(show_value=True, format_value="%", value_min=0, value_max=volume_max_percent) self.scale_widgets["speaker"].set_magnetic_values([(0, 5), (100, 5), (volume_max_percent, 5)]) self.scale_widgets["microphone"] = HScalebar(show_value=True, format_value="%", value_min=0, value_max=volume_max_percent) self.scale_widgets["microphone"].set_magnetic_values([(0, 5), (100, 5), (volume_max_percent, 5)]) ################################### # advance set self.container_widgets["advance_input_box"] = gtk.VBox(False) self.container_widgets["advance_output_box"] = gtk.VBox(False) self.container_widgets["advance_hardware_box"] = gtk.VBox(False) self.alignment_widgets["advance_input_box"] = gtk.Alignment() self.alignment_widgets["advance_output_box"] = gtk.Alignment() self.alignment_widgets["advance_hardware_box"] = gtk.Alignment() # self.label_widgets["ad_output"] = Label(_("Choose a device for sound output:"), enable_select=False, enable_double_click=False) self.label_widgets["ad_input"] = Label(_("Choose a device for sound input:"), enable_select=False, enable_double_click=False) self.label_widgets["ad_hardware"] = Label(_("Choose a device to configure:"), enable_select=False, enable_double_click=False) # self.container_widgets["ad_output"] = gtk.VBox(False) self.container_widgets["ad_input"] = gtk.VBox(False) self.container_widgets["ad_hardware"] = gtk.VBox(False) # self.view_widgets["ad_output"] = TreeView() self.view_widgets["ad_input"] = TreeView() self.view_widgets["ad_hardware"] = TreeView()
class MainWindow(tk.Tk): def __init__(self): super().__init__() self.title('THEE') self.minsize(550, 40) # (width, height) self.winfo_screenwidth = self.winfo_screenwidth() self.winfo_screenheight = self.winfo_screenheight() self.grid_columnconfigure(0, weight=1) self.grid_rowconfigure(0, weight=1) self.width = int(self.winfo_screenwidth / 3) self.height = int(self.winfo_screenheight / 3) self.geometry(f'{self.width}x{self.height}') self.thee_mode = 0 # 0: welcome, 1: editor, 2: terminal, 3: help self.count_text_changed = 0 self.editor_mode_buffer = "" self.terminal_mode_buffer = "" self.key_buffer = [] self.file_name = "untitled" self.status = "unsaved" self.spaces = 4 self.line = 1 self.column = 1 self.foreground = config.color['foreground'] self.background = config.color['background'] self.text_foreground = config.color['text_foreground'] self.text_background = config.color['text_background'] self.insertbackground = config.color['insertbackground'] self.statusbar_background = config.color['statusbarbg'] self.frame1 = tk.Frame(self, bg=self.background, width=self.width, height=self.height - 15) self.frame2 = tk.Frame(self, bg=self.statusbar_background, width=self.width, height=10) self.frame1.grid(row=0, column=0, sticky='wens') self.frame2.grid(row=1, column=0, sticky='wens') self.frame1.grid_columnconfigure(1, weight=1) self.frame1.grid_rowconfigure(0, weight=1) self.config_dir = os.path.join(str(Path.home()), '.thee') self.text_font_size = config.font['text']['size'] self.text_font_family = config.font['text']['family'] self.statusbar_font_size = config.font['statusbar']['size'] self.statusbar_font_family = config.font['statusbar']['family'] self.create_widget() # Entry point ==========# self.terminal = Terminal(self, self.text_area) # run terminal self.bind_events() self.open_file = '' self.protocol("WM_DELETE_WINDOW", self.close_window) def create_widget(self): self.text_area = TextArea(self.frame1, bg=self.text_background, fg=self.text_foreground, undo=True, relief=tk.FLAT, font=(self.text_font_family, self.text_font_size), insertbackground=self.insertbackground) self.text_area.config(highlightthickness=0) self.text_area.grid(row=0, column=1, sticky='wens') self.text_area.focus_set() self.welcome(event=None) self.status_bar1 = StatusBar(self.frame2, bg="pink", width=30, height=10) self.status_bar2 = StatusBar(self.frame2, bg="orange", width=30, height=10) self.status_bar3 = StatusBar(self.frame2, bg="blue", width=30, height=10) self.status_bar4 = StatusBar(self.frame2, bg="green", width=30, height=10) self.status_bar5 = StatusBar(self.frame2, bg="purple", width=30, height=10) self.status_bar1.pack(side=tk.LEFT, fill=tk.BOTH, expand=True) self.status_bar2.pack(side=tk.LEFT, fill=tk.BOTH, expand=True) self.status_bar3.pack(side=tk.LEFT, fill=tk.BOTH, expand=True) self.status_bar4.pack(side=tk.LEFT, fill=tk.BOTH, expand=True) self.status_bar5.pack(side=tk.LEFT, fill=tk.BOTH, expand=True) def editor_mode(self, event=None): self.text_area.config(state=tk.NORMAL, tabs=4) self.text_area.delete('1.0', tk.END) self.text_area.insert(tk.END, self.editor_mode_buffer) self.highlighter = Highlighter(self.text_area) self.thee_mode = 1 self.line_numbers = LineNumbers(self.frame1, self.text_area) self.line_numbers.config(bg=self.text_background, width=len(self.line_numbers.line_number) * 10, highlightthickness=0) self.line_numbers.grid(row=0, column=0, sticky='ns') self.status_bar1.set("Line %d, Column %d" % (self.line, self.column)) self.status_bar3.set("%s" % self.file_name) self.status_bar4.set("Spaces: %d" % self.spaces) self.status_bar5.set("%s" % self.status) def terminal_mode(self, event=None): if self.thee_mode == 1: self.line_numbers.destroy() self.text_area.config(state=tk.NORMAL, tabs=4) self.text_area.delete('1.0', tk.END) self.text_area.insert(tk.END, self.terminal_mode_buffer) self.terminal.writeLoop() self.highlighter = Highlighter(self.text_area) self.thee_mode = 2 def text_been_modified(self, event=None): flag = self.text_area.edit_modified() if flag: # prevent from getting called twice if self.thee_mode == 1 and self.count_text_changed > 1: # editor mode self.editor_mode_buffer = self.text_area.get( 1.0, tk.END + "-1c") self.status = "unsaved" self.status_bar5.set("%s" % self.status) self.update_line_column() self.line_numbers.config( width=len(self.line_numbers.line_number) * 10) elif self.thee_mode == 2 and self.count_text_changed > 1: # terminal mode self.terminal_mode_buffer = self.text_area.get( 1.0, tk.END + "-1c") self.count_text_changed += 1 #reset so this will be called on the next change self.text_area.edit_modified(False) def retrieve_selected_line(self, event=None): if self.thee_mode == 1: self.current_line = self.text_area.get("1.0", 'end').rstrip() if event.keysym.isnumeric(): self.key_buffer.append(event.keysym) # check buffer after 500ms (0.5s) self.after(500, self.selected_line_action) def selected_line_action(self): if self.key_buffer: index = int(''.join(self.key_buffer)) - 1 self.key_buffer.clear() self.selected_line = self.current_line.split('\n')[index] selected_str = self.selected_line + "\n" # write selected code line(s) to the console in order to it running self.terminal.proc.stdin.write(selected_str.encode()) self.terminal.proc.stdin.flush() self.terminal_mode() def update_line_column(self, event=None): if self.thee_mode == 1: line, column = self.text_area.index(tk.INSERT).split('.') self.line = int(line) self.column = int(column) + 1 self.status_bar1.set("Line %d, Column %d" % (self.line, self.column)) def close_window(self): if self.editor_mode_buffer and self.status == "unsaved": #and self.status.get() == "unsaved": #SATUSBAR if msg.askokcancel("Quit", "Would you like to save the data?"): self.file_save() self.terminal.alive = False self.terminal.destroy() else: self.terminal.alive = False self.terminal.destroy() else: self.terminal.alive = False self.terminal.destroy() def bind_events(self): self.focus_set() self.text_area.bind_all('<<Modified>>', self.text_been_modified) self.text_area.bind('<Return>', self.enter) self.bind_all('<Button-1>', self.update_line_column) self.bind_all('<Control-e>', self.editor_mode) self.bind_all('<Control-t>', self.terminal_mode) self.bind_all('<Control-Key>', self.retrieve_selected_line) self.bind('<Control-f>', self.show_find_window) self.bind('<Control-n>', self.file_new) self.bind('<Control-o>', self.file_open) self.bind('<Control-s>', self.file_save) self.bind('<Control-S>', self.file_save_as) self.bind('<Control-w>', self.welcome) self.bind('<Control-h>', self.help_about) def enter(self, event=None): if self.thee_mode == 2: self.terminal.enter() def show_find_window(self, event=None): FindWindow(self.frame1, self.text_area) def show_welcome_page(self): if self.thee_mode == 1: self.line_numbers.destroy() self.text_area.config(state=tk.NORMAL) self.text_area.delete('1.0', tk.END) message = ''' \n\n THEE version 1.0 THE simple python key bindings Editor type Ctrl-h for help information by Fidel R. Monteiro <*****@*****.**> \n The Pynosso Project | Sat, Jun 26 2020 ''' self.text_area.insert(tk.END, message) self.text_area.config(state=tk.DISABLED) self.thee_mode = 0 def show_about_page(self): if self.thee_mode == 1: self.line_numbers.destroy() self.text_area.config(state=tk.NORMAL) self.text_area.delete('1.0', tk.END) message = ''' HELP Mode Commands Ctrl+e : Text mode Ctrl+t : Terminal mode Ctrl+<number> : Run selected line in python console Editing Commands Ctrl+a : Select all text Ctrl+x : Cut selected text Ctrl+c : Copy selected text Ctrl+v : Paste cut/copied text Ctrl+z : Undo Ctrl+y : Redo File Commands Ctrl+o : Open file Ctrl+s : Save current content Ctrl+S : Save current content as <filename> Ctrl+p : Print current content Ctrl+n : Open new file General Ctrl+m : Change syntax highlighting Ctrl+g : Change colour scheme Ctrl+l : Change font Ctrl+h : Display this help window AUTHOR Written by Fidel R. Monteiro (fm65) Sat, Jun 26 2020 thee version 1.0 "simple is better than complex" ''' self.text_area.insert(tk.END, message) self.text_area.config(state=tk.DISABLED) self.thee_mode = 3 def apply_colour_scheme(self, foreground, background, text_foreground, text_background): self.text_area.configure(fg=text_foreground, bg=text_background) self.background = background self.foreground = foreground for menu in self.all_menus: menu.configure(bg=self.background, fg=self.foreground) def update_font(self): #self.load_font_file(self.font_scheme_path) self.text_area.configure(font=(self.text_font_family, self.text_font_size)) def create_config_directory_if_needed(self): if not os.path.exists(self.config_dir): os.mkdir(self.config_dir) # =========== Menu Functions ============== def file_new(self, event=None): """ Ctrl+N """ self.text_area.delete(1.0, tk.END) self.open_file = None self.editor_mode() self.line_numbers.force_update() def file_open(self, event=None): """ Ctrl+O """ self.editor_mode() file_to_open = filedialog.askopenfilename(filetypes=[('Python files', '*.py')], defaultextension='.py') if file_to_open: self.open_file = file_to_open self.file_name = self.open_file.split('/')[-1] self.status_bar3.set("%s" % self.file_name) self.text_area.display_file_contents(file_to_open) self.highlighter.force_highlight() self.line_numbers.force_update() def file_save(self, event=None): """ Ctrl+s """ current_file = self.open_file if self.open_file else None if not current_file: current_file = filedialog.asksaveasfilename(filetypes=[ ('Python files', '*.py') ], defaultextension='.py') self.open_file = current_file self.file_name = current_file.split('/')[-1] self.status_bar3.set("%s" % self.file_name) if current_file: contents = self.text_area.get(1.0, tk.END) with open(current_file, 'w') as file: file.write(contents) self.status = "saved" self.status_bar5.set("%s" % self.status) def file_save_as(self, event=None): """ Ctrl+S """ new_file_name = filedialog.asksaveasfilename(filetypes=[ ('Python files', '*.py') ], defaultextension='.py', confirmoverwrite=False) f = open(self.new_file_name, 'w') f.write(self.get('1.0', 'end')) f.close() self.status = "saved" self.status_bar5.set("%s" % self.status) def edit_cut(self, event=None): """ Ctrl+X """ self.text_area.event_generate("<Control-x>") self.line_numbers.force_update() def edit_paste(self, event=None): """ Ctrl+V """ self.text_area.event_generate("<Control-v>") self.line_numbers.force_update() self.highlighter.force_highlight() def edit_copy(self, event=None): """ Ctrl+C """ self.text_area.event_generate("<Control-c>") def edit_select_all(self, event=None): """ Ctrl+A """ self.text_area.event_generate("<Control-a>") def edit_find_and_replace(self, event=None): """ Ctrl+F """ self.show_find_window() def welcome(self, event=None): """ Ctrl+W """ self.show_welcome_page() def help_about(self, event=None): """ Ctrl+H """ self.show_about_page()
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()
def __init__(self, parent, safetyMode="viewAccess", *args, **kwargs): wx.Frame.__init__(self, parent, *args, **kwargs) self.safetyMode = safetyMode ConfigData.__init__(self, *args, **kwargs) StatusBar.__init__(self, parent, *args, **kwargs) MenuBar.__init__(self, parent, *args, **kwargs) ToolBar.__init__(self, parent, *args, **kwargs) TreeContextMenu.__init__(self, parent, *args, **kwargs) # Some actions which are not relevant for any specific area Actions.__init__(self, *args, **kwargs) # The functions to enable printing Printing.__init__(self, parent, *args, **kwargs) # The functions to enable the help system Help.__init__(self, *args, **kwargs) # The functions to enable the about dialog About.__init__(self, *args, **kwargs) # The functions to enable the about dialog Settings.__init__(self, *args, **kwargs) #Set main splitter MainSplitter.__init__(self, *args, **kwargs) #Add the xml tree Document.__init__(self, *args, **kwargs) #Fill xml tree GetData.__init__(self, *args, **kwargs) #Add functions to modify the view of the xml tree ViewData.__init__(self, *args, **kwargs) #Add functions to edit the xml tree EditData.__init__(self, *args, **kwargs) #Copy example files: Comment this out if Template-Designer is in productive use. #self.getExamples() #Some kind of self check self.saveConfig() #Set panels #self.propertiesPanel = wx.Panel(self.mainSplitter) self.propertiesPanel = wx.ScrolledWindow(self.mainSplitter) self.templatePanel = wx.Panel(self.mainSplitter) #Buttons on main frame self.applyButton = wx.Button(self.propertiesPanel, wx.ID_APPLY, _(u"Apply changes"), name="applyButton") self.defaultsButton = wx.Button(self.propertiesPanel, wx.ID_RESET, _(u"Restore settings"), name="defaultsButtons") expandAllButtonPath = self.documentTreeGraphics() + "/2downarrow.png" expandAllButtonBmp = wx.Image(expandAllButtonPath, wx.BITMAP_TYPE_PNG).ConvertToBitmap() self.expandAllButton = wx.BitmapButton(self.templatePanel, -1, expandAllButtonBmp, name="expandButton") collapseAllButtonPath = self.documentTreeGraphics() + "/2uparrow.png" collapseAllButtonBmp = wx.Image(collapseAllButtonPath, wx.BITMAP_TYPE_PNG).ConvertToBitmap() self.collapseAllButton = wx.BitmapButton(self.templatePanel, -1, collapseAllButtonBmp, name="collapseButton") addButtonPath = self.documentTreeGraphics() + "/filenew.png" addButtonBmp = wx.Image(addButtonPath, wx.BITMAP_TYPE_PNG).ConvertToBitmap() self.addButton = wx.BitmapButton(self.templatePanel, -1, addButtonBmp, name="addButton") deleteButtonPath = self.documentTreeGraphics() + "/edit_delete.png" deleteButtonBmp = wx.Image(deleteButtonPath, wx.BITMAP_TYPE_PNG).ConvertToBitmap() self.deleteButton = wx.BitmapButton(self.templatePanel, -1, deleteButtonBmp, name="deleteButton") """ Set taskbar icon. If you remove this, do not forget to remove the RemoveIcon() and Destroy() methods in self.onCloseWindow() """ self.taskBarIcon = wx.TaskBarIcon() iconPath = self.skinGraphics() + "/domtreeviewer.png" icon = wx.Icon(iconPath, wx.BITMAP_TYPE_PNG) self.taskBarIcon.SetIcon(icon, _(u"Template-Designer")) #Set titlebar icon self.SetIcon(icon) #Initiate the contents of the property panel self.pp = pp self.__doProperties() self.__doBindings() self.__doLayout() Safety(self)