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