class Trigger(SignalManager, TriggerManager):
def __init__(self, editor):
SignalManager.__init__(self)
TriggerManager.__init__(self, editor)
self.__init_attributes(editor)
self.connect(self.__trigger, "activate", self.__show_cb)
def __init_attributes(self, editor):
self.__editor = editor
from Manager import Manager
self.__manager = Manager(editor)
from MenuItem import MenuItem
self.__menuitem = MenuItem(editor)
self.__trigger = self.create_trigger("show-autoreplace-dialog")
return
def __show_cb(self, *args):
self.__manager.show()
return
def destroy(self):
self.disconnect()
self.remove_triggers()
self.__menuitem.destroy()
self.__manager.destroy()
del self
return
class Trigger(SignalManager, TriggerManager):
def __init__(self, editor):
SignalManager.__init__(self)
TriggerManager.__init__(self, editor)
self.__init_attributes(editor)
self.connect(self.__trigger, "activate", self.__activate_cb)
def __init_attributes(self, editor):
self.__editor = editor
name, shortcut, description, category = (
"find-matching-bracket",
"<alt><shift>b",
_("Move cursor to matching bracket"),
_("Navigation Operations")
)
self.__trigger = self.create_trigger(name, shortcut, description, category)
self.__manager = None
return
def destroy(self):
self.disconnect()
self.remove_triggers()
if self.__manager: self.__manager.destroy()
del self
return False
def __activate_cb(self, *args):
try:
self.__manager.match()
except AttributeError:
from Manager import Manager
self.__manager = Manager(self.__editor)
self.__manager.match()
return False
class Trigger(SignalManager, TriggerManager):
def __init__(self, editor):
SignalManager.__init__(self)
TriggerManager.__init__(self, editor)
self.__init_attributes(editor)
self.connect(self.__trigger, "activate", self.__show_cb)
def __init_attributes(self, editor):
self.__editor = editor
from Manager import Manager
self.__manager = Manager(editor)
from MenuItem import MenuItem
self.__menuitem = MenuItem(editor)
self.__trigger = self.create_trigger("show-autoreplace-dialog")
return
def __show_cb(self, *args):
self.__manager.show()
return
def destroy(self):
self.disconnect()
self.remove_triggers()
self.__menuitem.destroy()
self.__manager.destroy()
del self
return
class Trigger(SignalManager, TriggerManager):
def __init__(self, editor):
SignalManager.__init__(self)
TriggerManager.__init__(self, editor)
self.__init_attributes(editor)
self.connect(self.__trigger, "activate", self.__show_window_cb)
def __init_attributes(self, editor):
self.__editor = editor
self.__manager = None
self.__trigger = self.create_trigger(
"show-advanced-configuration-window")
from MenuItem import MenuItem
self.__menuitem = MenuItem(editor)
return
def __show_window_cb(self, *args):
try:
self.__manager.show()
except AttributeError:
from Manager import Manager
self.__manager = Manager(self.__editor)
self.__manager.show()
return
def destroy(self):
if self.__manager: self.__manager.destroy()
if self.__menuitem: self.__menuitem.destroy()
self.remove_triggers()
self.disconnect()
del self
return
class Trigger(SignalManager, TriggerManager):
def __init__(self, editor):
SignalManager.__init__(self)
TriggerManager.__init__(self, editor)
self.__init_attributes(editor)
self.connect(self.__trigger, "activate", self.__activate_cb)
def __init_attributes(self, editor):
self.__editor = editor
self.__manager = None
name, shortcut, description, category = (
"show-python-symbol-brower", "F5",
_("Show classes, methods and functions"), _("Python"))
self.__trigger = self.create_trigger(name, shortcut, description,
category)
return
def __activate_cb(self, *args):
try:
self.__manager.show_browser()
except AttributeError:
from Manager import Manager
self.__manager = Manager(self.__editor)
self.__manager.show_browser()
return
def destroy(self):
self.disconnect()
self.remove_triggers()
if self.__manager: self.__manager.destroy()
del self
return
class Trigger(SignalManager, TriggerManager):
def __init__(self, editor):
SignalManager.__init__(self)
TriggerManager.__init__(self, editor)
self.__init_attributes(editor)
self.connect(self.__trigger, "activate", self.__activate_cb)
editor.get_toolbutton("SaveToolButton").props.sensitive = True
def __init_attributes(self, editor):
self.__editor = editor
name, shortcut, description, category = ("show-save-dialog",
"<ctrl><shift>s",
_("Rename the current file"),
_("File Operations"))
self.__trigger = self.create_trigger(name, shortcut, description,
category)
self.__manager = None
return
def destroy(self):
self.disconnect()
self.remove_triggers()
if self.__manager: self.__manager.destroy()
del self
return False
def __activate_cb(self, *args):
try:
self.__manager.show()
except AttributeError:
from Manager import Manager
self.__manager = Manager(self.__editor)
self.__manager.show()
return
class Trigger(SignalManager, TriggerManager):
def __init__(self, editor):
SignalManager.__init__(self)
TriggerManager.__init__(self, editor)
self.__init_attributes(editor)
self.connect(self.__trigger, "activate", self.__activate_cb)
self.__editor.get_toolbutton("GotoToolButton").props.sensitive = True
def __init_attributes(self, editor):
self.__editor = editor
name, shortcut, description, category = ("show-gotobar", "<ctrl>i",
_("Jump to a specific line"),
_("Navigation Operations"))
self.__trigger = self.create_trigger(name, shortcut, description,
category)
self.__manager = None
return
def destroy(self):
self.disconnect()
self.remove_triggers()
if self.__manager: self.__manager.destroy()
del self
return False
def __activate_cb(self, *args):
try:
self.__manager.show()
except AttributeError:
from Manager import Manager
self.__manager = Manager(self.__editor)
self.__manager.show()
return
def run(self, problem):
print("초기 시작")
print("스도쿠 문제번호 : ")
print("스도쿠 난이도 : ")
temp = np.array(list(map(int, list(problem)))).reshape(3, 3, 3, 3)
self.helpArray = Sudoku(
np.array([[SubBlock(subblock) for subblock in subblocks]
for subblocks in temp]))
print("helpArray: ")
self.helpArray.printSudoku()
self.manager = Manager(self.helpArray)
count = self.gaCount
while not self.end: # and self.gaCount < 3:
print("세대 : ", self.gaCount)
print("fitness : ", self.manager.fmin)
print("best solution: ")
self.manager.sudokuPool[0].printSudoku()
if count > 2000:
self.restart()
count = 1
self.end = self.manager.nextGeneration()
self.gaCount = self.gaCount + 1
count += 1
self.print()
class MainWindow(QMainWindow):
startBut = Signal()
def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.manager = Manager(self)
self.__threadRun = QThread()
self.__threadRun.start()
self.manager.moveToThread(self.__threadRun)
self.ui.openFile_button.clicked.connect(self.openFileButtonClicked)
self.ui.start_button.clicked.connect(self.startButtonClicked)
self.startBut.connect(self.manager.startButtonClicked)
self.manager.sendMessageConsole.connect(self.setMessage)
def setMessage(self, message):
self.ui.console_textBrowser.append(message)
def openFileButtonClicked(self):
path_to_file, _ = QFileDialog.getOpenFileName(
self, self.tr("Load Image"), self.tr("~/Desktop/"),
self.tr("Images (*.png *.jpg)"))
self.manager.setImage(path_to_file)
pix = QPixmap(path_to_file)
pix = pix.scaled(640, 480, Qt.KeepAspectRatio)
self.ui.inputImage_label.setPixmap(pix)
def startButtonClicked(self):
self.startBut.emit()
class Trigger(SignalManager, TriggerManager):
def __init__(self, editor):
SignalManager.__init__(self)
TriggerManager.__init__(self, editor)
self.__init_attributes(editor)
self.connect(self.__trigger, "activate", self.__show_window_cb)
def __init_attributes(self, editor):
self.__editor = editor
self.__manager = None
self.__trigger = self.create_trigger("show-advanced-configuration-window")
from MenuItem import MenuItem
self.__menuitem = MenuItem(editor)
return
def __show_window_cb(self, *args):
try:
self.__manager.show()
except AttributeError:
from Manager import Manager
self.__manager = Manager(self.__editor)
self.__manager.show()
return
def destroy(self):
if self.__manager: self.__manager.destroy()
if self.__menuitem: self.__menuitem.destroy()
self.remove_triggers()
self.disconnect()
del self
return
class Trigger(SignalManager, TriggerManager):
def __init__(self, editor):
SignalManager.__init__(self)
TriggerManager.__init__(self, editor)
self.__init_attributes(editor)
self.connect(self.__trigger, "activate", self.__activate_cb)
def __init_attributes(self, editor):
self.__editor = editor
name, shortcut, description, category = (
"show-document-statistics",
"<alt>Return",
_("Show document statistics"),
_("Miscellaneous Operations")
)
self.__trigger = self.create_trigger(name, shortcut, description, category)
self.__manager = None
return
def destroy(self):
self.disconnect()
self.remove_triggers()
if self.__manager: self.__manager.destroy()
del self
return False
def __activate_cb(self, *args):
try:
self.__manager.show()
except AttributeError:
from Manager import Manager
self.__manager = Manager(self.__editor)
self.__manager.show()
return False
def doLogin(request):
# 把参数字符串转化为字典
paras = request.GET
# print(paras)
username = paras.get('username')
password = paras.get('password')
password = sha1(password.encode('utf8')).hexdigest()
# print(username,password)
# 数据库操作
db = Manager('user')
result = db.where(name=username,password=password).select()
# request.start_response('200 ok', [('Content-Type', 'text/html')])
# 如果查询成功
if result:
response = MyResponse(request)
print(result)
response.setCookie('name',result[0]['name'])
response.setCookie('id',result[0]['id'])
# html=""
# with open('templates/tip.html') as fp:
# html = fp.read()
return response.load('index.html')
else:
request.start_response('200 ok', [('Content-Type', 'text/html')])
return ["用户名或密码错误，请重新登陆".encode('utf-8')]
class Trigger(SignalManager, TriggerManager):
def __init__(self, editor):
SignalManager.__init__(self)
TriggerManager.__init__(self, editor)
self.__init_attributes(editor)
self.connect(self.__trigger, "activate", self.__activate_cb)
def __init_attributes(self, editor):
self.__editor = editor
name, shortcut, description, category = (
"find-matching-bracket", "<alt><shift>b",
_("Move cursor to matching bracket"), _("Navigation Operations"))
self.__trigger = self.create_trigger(name, shortcut, description,
category)
self.__manager = None
return
def destroy(self):
self.disconnect()
self.remove_triggers()
if self.__manager: self.__manager.destroy()
del self
return False
def __activate_cb(self, *args):
try:
self.__manager.match()
except AttributeError:
from Manager import Manager
self.__manager = Manager(self.__editor)
self.__manager.match()
return False
def doLogin(request):
# 把参数字符串转化为字典
paras = request.GET
print(paras)
username = paras.get('username')
password = paras.get('password')
print(username,password)
password = sha1(password.encode('utf8')).hexdigest() #如果签名，需要转换
print(username,password)
# 数据库操作
db = Manager('student')
result = db.where(sname=username, password=password).select()
request.start_response('200 ok', [('Content-Type', 'text/html')])
# 如果查询成功
if result:
html = ""
with open('templates/tip.html') as fp:
html = fp.read()
return [html.encode('utf-8')]
else:
html = ""
with open('templates/tip2.html') as fp:
html = fp.read()
return [html.encode('utf-8')]
class Trigger(SignalManager, TriggerManager):
def __init__(self, editor):
SignalManager.__init__(self)
TriggerManager.__init__(self, editor)
self.__init_attributes(editor)
self.connect(self.__trigger, "activate", self.__activate_cb)
def __init_attributes(self, editor):
self.__editor = editor
from Manager import Manager
self.__manager = Manager(self.__editor)
name, shortcut, description, category = (
"toggle-word-completion", "<ctrl><shift><alt>c",
_("Toggle automatic word completion"),
_("Miscellaneous Operations"))
self.__trigger = self.create_trigger(name, shortcut, description,
category)
return
def destroy(self):
self.disconnect()
self.remove_triggers()
if self.__manager: self.__manager.destroy()
del self
return False
def __activate(self):
self.__manager.activate()
return False
def __activate_cb(self, *args):
from gobject import idle_add
idle_add(self.__activate)
return False
class Trigger(SignalManager, TriggerManager):
def __init__(self, editor):
SignalManager.__init__(self)
TriggerManager.__init__(self, editor)
self.__init_attributes(editor)
self.connect(self.__trigger, "activate", self.__activate_cb)
def __init_attributes(self, editor):
self.__editor = editor
name, shortcut, description, category = ("show-document-statistics",
"<alt>Return",
_("Show document statistics"),
_("Miscellaneous Operations"))
self.__trigger = self.create_trigger(name, shortcut, description,
category)
self.__manager = None
return
def destroy(self):
self.disconnect()
self.remove_triggers()
if self.__manager: self.__manager.destroy()
del self
return False
def __activate_cb(self, *args):
try:
self.__manager.show()
except AttributeError:
from Manager import Manager
self.__manager = Manager(self.__editor)
self.__manager.show()
return False
def __init_attributes(self, editor):
self.__editor = editor
from Manager import Manager
self.__manager = Manager(editor)
name, shortcut, description, category = ("open-recent-files",
"<ctrl><alt>r",
_("Open recent files"),
_("File Operations"))
self.__trigger = self.create_trigger(name, shortcut, description,
category)
self.__trigger.command = "activate"
name, shortcut, description, category = ("reopen-closed-file",
"<ctrl><shift>w",
_("Reopen last closed file"),
_("File Operations"))
self.__trigger1 = self.create_trigger(name, shortcut, description,
category)
self.__trigger1.command = "open-last-file"
name, shortcut, description, category = ("reopen-closed-files",
"<ctrl><shift>q",
_("Reopen last closed file"),
_("File Operations"))
self.__trigger2 = self.create_trigger(name, shortcut, description,
category)
self.__trigger2.command = "open-last-files"
return
def init():
"""
Game initialization function.
1. Creates a L{Debugger} (debugger) and L{EventTimer} (eventTimer) and
stores references to them in an instance of L{EventManager}.
2. Several listeners are started and registered with eventManager:
- Instance of L{Universe} (universe)
- Instance of L{UserInterface} (ui)
- Instance of L{Window} (gameWindow)
3. We send the eventManager a message to start the game
- This message is interpreted by the gameWindow
"""
debugger = Debugger()
eventTimer = EventTimer()
#Create the event manager for low-level events
eventManager = Manager(eventTimer,debugger) #FIXME: more specific manager\
#classes will be needed later?
try:
client = GameClient(eventManager,host='10.41.24.79',port=1567)
except:
pass
#Create the occurence manager for high-level events (same across client and server)
#FIXME: NOT YET IMPLEMENTED
#Note: Do we even need this anymore? - Julian
#Response: I don't think so. - Jared
#===========================================
#Create and register the standard listeners
#With the event manager
#===========================================
#FIXME: Not yet fully implemented
#THIS WILL BE CHANGED LATER TO ACCOUNT FOR LOADING, ETC.
# World w is set to the activeWorld of the universe
universe = Universe(eventManager)
ui = UserInterface(eventManager,universe.activeWorld)
gameWindow = Window(eventManager,width=1024,height=768)
w = World()
universe.changeWorld(w)
#===========================================
# Initialize 500 entities in World w
for i in range(100):
#w.addEntity(Entity('ball.png',i*50,i*50, w, (255,255,255)))
#w.addEntity(TestEntity('testBuilding.png', i*50, i*50, w, 'alpha'))
w.addEntity(TestEntity('testCraft.png',i*50,i*50,w,'alpha'))
eventManager.post(Event.WorldManipulationEvent())
#Notify the manager that the window should start to accept input:
eventManager.post(Event.StartEvent())
return eventManager.eventTypesToListeners
def setup(self, browser):
manager = Manager(browser)
global driver
driver = manager.get_driver()
open_hiway = OpenHiwayUrl(driver)
open_hiway.open()
yield
manager.close_browser()
def __show_window_cb(self, *args):
try:
self.__manager.show()
except AttributeError:
from Manager import Manager
self.__manager = Manager(self.__editor)
self.__manager.show()
return
def __init__(
self, loggername
): # loggername is a name of your choice to refer to the logger object
Manager.__init__(self, loggername)
self.clientList = []
self.dirList = []
self.clientDict = {}
self.inputDirDict = {}
def main():
options = Options()
args = options.get_arguments()
database = Database()
manager = Manager(args, database)
manager.run()
def __activate(self):
try:
self.__manager.activate()
except AttributeError:
from Manager import Manager
self.__manager = Manager(self.__editor)
self.__manager.activate()
return False
def __init_attributes(self, editor):
self.__editor = editor
from Manager import Manager
self.__manager = Manager(editor)
from MenuItem import MenuItem
self.__menuitem = MenuItem(editor)
self.__trigger = self.create_trigger("show-autoreplace-dialog")
return
def __activate_cb(self, *args):
try:
self.__manager.match()
except AttributeError:
from Manager import Manager
self.__manager = Manager(self.__editor)
self.__manager.match()
return False
def studentList(request):
db = Manager('student')
data = db.values('sno,sname,ssex,sbirthday,sclass').select()
print(data)
env = jinja2.Environment(loader=jinja2.FileSystemLoader('./templates'))
template = env.get_template('studentlist.html')
print(template)
request.start_response('200 ok', [('Content-Type', 'text/html')])
return [template.render(students=data).encode('utf-8')]
def init(host='localhost',server=None):
"""
Most of this code is copied from init() function in client.py
Game initialization function.
1. Creates a L{Debugger} (debugger) and L{EventTimer} (eventTimer) and
stores references to them in an instance of L{EventManager}.
2. Several listeners are started and registered with eventManager:
- Instance of L{Universe} (universe)
- Instance of L{UserInterface} (ui)
- Instance of L{Window} (gameWindow)
3. We send the eventManager a message to start the game
- This message is interpreted by the gameWindow
"""
#Creates a Debugger that posts events to the terminal for debugging purposes
debugger = Debugger()
eventTimer = EventTimer()
#Create the event manager for low-level events
eventManager = Manager(eventTimer,debugger) #FIXME: more specific manager\
Entity.manager = eventManager
# World w is set to the activeWorld of the universe
universe = Universe(eventManager)
ui = UserInterface(eventManager,universe.activeWorld,'BROADCASTSERVER')
gameWindow = Window(eventManager,width=1024,height=768)
gameWindow.fullscreenMode = False
gameWindow.updateScreenMode()
w = World(universe)
s.world=w
networked = True
client = GameClient(eventManager,host=s.host,port=1567)
#wait until the client is assigned an ID before proceeding
while client.ID == None:
import time
time.sleep(.02)
print 'Got an ID',client.ID
clientID = client.ID
ui.setClientID(clientID)
wManipulator = WorldManipulator(eventManager,w,networked,gameClientID = clientID)
#generate the resources in the server, the existance of these
#resources will propogate through to every client when they connect
w._generateResources()
#Notify the manager that the window should start to accept input:
eventManager.post(Event.StartEvent())
return eventManager.eventTypesToListeners
def method_calculate(self):
initial_interval = self.method_intial_interval_textbox.toPlainText()
method = self.method_combobox.currentText()
equation_item = self.input_list.currentItem()
if equation_item is None:
self.output_textbox.setPlainText('No equation string detected!\n')
return
elif method == 'None----':
self.output_textbox.setPlainText('Method couldnt be None\n')
return
elif initial_interval == '':
self.output_textbox.setPlainText('No initial point\n')
return
# global variables
equation_str: str = None
initial_point: List[float] = None
intervals: List[List[float]] = None
answer: str = None
Xs: List[Arrai] = None
vars_form: List[str] = None
# exception added
try:
equation_str = equation_item.text()
# get initial point and intervals
initial_point, vars_form, intervals = get_ip_intervals(
initial_interval)
# manager = Manager(equation_str, vars_form, method, initial_point, intervals)
manager = Manager(equation_str=equation_str,
vars_form=vars_form,
method_name=method,
initial_point=initial_point,
intervals=intervals)
answer, Xs = manager.run()
# write answer to output
self.output_textbox.setPlainText(answer)
except Exception as explosion:
answer = explosion.args[0]
self.output_textbox.setPlainText(answer)
try:
# draw out graph
draw_graph(self, equation_str, vars_form, Xs, intervals)
# catch graph drawing exception
except:
self.graph_error_texbox.setPlainText(
'Error while building graph!\n Current Equation: %s' %
equation_str)
class Trigger(SignalManager, TriggerManager):
def __init__(self, editor):
SignalManager.__init__(self)
TriggerManager.__init__(self, editor)
self.__init_attributes(editor)
self.connect(self.__trigger, "activate", self.__activate_cb)
self.connect(self.__trigger1, "activate", self.__activate_cb)
self.connect(self.__trigger2, "activate", self.__activate_cb)
def __init_attributes(self, editor):
self.__editor = editor
from Manager import Manager
self.__manager = Manager(editor)
name, shortcut, description, category = (
"open-recent-files",
"<ctrl><alt>r",
_("Open recent files"),
_("File Operations")
)
self.__trigger = self.create_trigger(name, shortcut, description, category)
self.__trigger.command = "activate"
name, shortcut, description, category = (
"reopen-closed-file",
"<ctrl><shift>w",
_("Reopen last closed file"),
_("File Operations")
)
self.__trigger1 = self.create_trigger(name, shortcut, description, category)
self.__trigger1.command = "open-last-file"
name, shortcut, description, category = (
"reopen-closed-files",
"<ctrl><shift>q",
_("Reopen last closed file"),
_("File Operations")
)
self.__trigger2 = self.create_trigger(name, shortcut, description, category)
self.__trigger2.command = "open-last-files"
return
def destroy(self):
self.disconnect()
self.remove_triggers()
if self.__manager: self.__manager.destroy()
del self
return False
def __activate(self, trigger):
command = trigger.command
self.__manager.activate(command)
return False
def __activate_cb(self, trigger):
from gobject import idle_add
idle_add(self.__activate, trigger)
return False
class Inventory:
option = 0
def selectOptions(self):
print("press 1 to purchase:")
print("press 2 to return:")
print("press 3 to display Inventory:")
return int(raw_input())
def __init__(self):
self.manager = Manager()
self.cashier = Cashier()
flag = True
while flag:
self.option = self.selectOptions()
if self.option == 1:
self.client_id = random.randint(1, 1000)
self.manager.itemList()
orderDetails = self.manager.takeOrder(self.client_id)
if orderDetails[0] == "checkout":
self.cashier.checkout(orderDetails[1])
self.manager.displayInventory()
elif orderDetails[0] == "don't checkout":
print("we have ordered the requested items right away! please wait for us to get back to you.")
elif self.option ==2:
self.manager.close()
self.cashier.close()
flag = False
sys.exit(0)
elif self.option == 3:
self.manager.displayInventory()
class Trigger(SignalManager, TriggerManager):
def __init__(self, editor):
SignalManager.__init__(self, editor)
TriggerManager.__init__(self, editor)
self.__init_attributes(editor)
# self.connect(editor.textview, "populate-popup", self.__popup_cb)
self.connect(self.__trigger1, "activate", self.__activate_cb)
self.connect(self.__trigger2, "activate", self.__activate_cb)
self.connect(self.__trigger3, "activate", self.__activate_cb)
def __init_attributes(self, editor):
from Manager import Manager
self.__manager = Manager(editor)
self.__editor = editor
name, shortcut, description, category = (
"toggle-bookmark", "<ctrl>d",
_("Add or remove bookmark on a line"), _("Bookmark Operations"))
self.__trigger1 = self.create_trigger(name, shortcut, description,
category)
name, shortcut, description, category = ("remove-all-bookmarks",
"<ctrl><alt>b",
_("Remove all bookmarks"),
_("Bookmark Operations"))
self.__trigger2 = self.create_trigger(name, shortcut, description,
category)
name, shortcut, description, category = ("show-bookmark-browser",
"<ctrl>b",
_("Navigate bookmarks"),
_("Bookmark Operations"))
self.__trigger3 = self.create_trigger(name, shortcut, description,
category)
self.__browser = None
return
def destroy(self):
self.disconnect()
self.remove_triggers()
if self.__manager: self.__manager.destroy()
del self
return
def __popup_cb(self, textview, menu):
from PopupMenuItem import PopupMenuItem
self.__editor.add_to_popup(PopupMenuItem(self.__editor))
return False
def __activate_cb(self, trigger):
function = {
self.__trigger1: self.__manager.toggle,
self.__trigger2: self.__manager.remove,
self.__trigger3: self.__manager.show,
}
function[trigger]()
return False
def __init_attributes(self, editor):
self.__editor = editor
from Manager import Manager
self.__manager = Manager(self.__editor)
name, shortcut, description, category = (
"toggle-word-completion", "<ctrl><shift><alt>c",
_("Toggle automatic word completion"),
_("Miscellaneous Operations"))
self.__trigger = self.create_trigger(name, shortcut, description,
category)
return
def province(request,aid):
print(aid)
db = Manager('areainfo')
res = db.where(pid=aid).select()
print (res)
import json
data = '数据不存在'
if res:
data = json.dumps(res)
request.start_response('200 ok', [('Content-Type', 'application/json')])
return [data.encode('utf-8')]
def __init_attributes(self, editor):
self.__editor = editor
from Manager import Manager
self.__manager = Manager(editor)
name, shortcut, description, category = (
"show-white-spaces",
"<alt>period",
_("Show or hide white spaces"),
_("Miscellaneous Operations")
)
self.__trigger = self.create_trigger(name, shortcut, description, category)
return
def main():
if len(sys.argv) == 2:
c = Config(sys.argv[1])
else:
print("Usage : ./main.py [config_file]")
m = Manager(c.stock, c.process)
m.linkStock()
print("")
m.displayStock()
def jsonp(request,aid,funcname):
print(aid,funcname)
db = Manager('areainfo')
res = db.where(pid=aid).select()
print(res)
import json
data = "数据不存在"
if res:
data = json.dumps(res)
s1 = funcname + "(" + data+")"
request.start_response('200 ok', [('Content-Type', 'text/html')])
return [s1.encode('utf-8')]
def create_configure_dialog(self):
if not self.dlg:
self.dlg = Manager(self.get_data_dir())
else:
self.dlg.run()
window = pluma.app_get_default().get_active_window()
if window:
self.dlg.dlg.set_transient_for(window)
return self.dlg.dlg
def monitor(self):
while True:
self.lock.acquire()
if self.requests[0].offtime >= time.time():
Manager().del_request_info(self.requests[0])
for v in self.requests[0].sfc:
Manager().del_vnf_info(v)
heapq.heappop()
self.lock.release()
time.sleep(1)
if not config.FLAG:
break
class Trigger(SignalManager, TriggerManager):
def __init__(self, editor):
SignalManager.__init__(self)
TriggerManager.__init__(self, editor)
self.__init_attributes(editor)
self.connect(self.__trigger, "activate", self.__activate_cb)
self.connect(self.__trigger1, "activate", self.__activate_cb)
self.connect(self.__trigger2, "activate", self.__activate_cb)
def __init_attributes(self, editor):
self.__editor = editor
from Manager import Manager
self.__manager = Manager(editor)
name, shortcut, description, category = ("open-recent-files",
"<ctrl><alt>r",
_("Open recent files"),
_("File Operations"))
self.__trigger = self.create_trigger(name, shortcut, description,
category)
self.__trigger.command = "activate"
name, shortcut, description, category = ("reopen-closed-file",
"<ctrl><shift>w",
_("Reopen last closed file"),
_("File Operations"))
self.__trigger1 = self.create_trigger(name, shortcut, description,
category)
self.__trigger1.command = "open-last-file"
name, shortcut, description, category = ("reopen-closed-files",
"<ctrl><shift>q",
_("Reopen last closed file"),
_("File Operations"))
self.__trigger2 = self.create_trigger(name, shortcut, description,
category)
self.__trigger2.command = "open-last-files"
return
def destroy(self):
self.disconnect()
self.remove_triggers()
if self.__manager: self.__manager.destroy()
del self
return False
def __activate(self, trigger):
command = trigger.command
self.__manager.activate(command)
return False
def __activate_cb(self, trigger):
from gobject import idle_add
idle_add(self.__activate, trigger)
return False
class Trigger(SignalManager, TriggerManager):
def __init__(self, editor):
SignalManager.__init__(self)
TriggerManager.__init__(self, editor)
self.__init_attributes(editor)
self.connect(self.__trigger1, "activate", self.__activate_cb)
self.connect(self.__trigger2, "activate", self.__activate_cb)
from MenuItem import MenuItem
MenuItem(editor)
def __init_attributes(self, editor):
self.__editor = editor
name, shortcut, description, category = (
"show-trigger-area-window",
"",
_("Show trigger area configuration window"),
_("Miscellaneous Operations")
)
self.__trigger1 = self.create_trigger(name, shortcut, description, category)
self.__trigger1.command = "show-trigger-area-window"
name, shortcut, description, category = (
"show-full-view",
"<ctrl><alt>m",
_("Show editor's full view"),
_("Miscellaneous Operations")
)
self.__trigger2 = self.create_trigger(name, shortcut, description, category)
self.__trigger2.command = "show-full-view"
from Manager import Manager
self.__manager = Manager(editor)
return
def destroy(self):
self.disconnect()
self.remove_triggers()
self.__manager.destroy()
del self
return False
def __activate(self, command):
activate = {
"show-trigger-area-window": self.__manager.show,
"show-full-view": self.__manager.fullview,
}
activate[command]()
return False
def __activate_cb(self, trigger):
from gobject import idle_add
idle_add(self.__activate, trigger.command)
return
class Trigger(SignalManager, TriggerManager):
def __init__(self, editor):
SignalManager.__init__(self)
TriggerManager.__init__(self, editor)
self.__init_attributes(editor)
self.connect(self.__trigger1, "activate", self.__activate_cb)
self.connect(self.__trigger2, "activate", self.__activate_cb)
def __init_attributes(self, editor):
self.__editor = editor
self.__manager = None
name, shortcut, description, category = (
"focus-next-window",
"<ctrl>Page_Up",
_("Focus next window"),
_("Window Operations")
)
self.__trigger1 = self.create_trigger(name, shortcut, description, category)
self.__trigger1.command = "next-window"
name, shortcut, description, category = (
"focus-previous-window",
"<ctrl>Page_Down",
_("Focus previous window"),
_("Window Operations")
)
self.__trigger2 = self.create_trigger(name, shortcut, description, category)
self.__trigger2.command = "previous-window"
return
def destroy(self):
self.disconnect()
self.remove_triggers()
if self.__manager: self.__manager.destroy()
del self
return False
def __init_manager(self):
from Manager import Manager
self.__manager = Manager(self.__editor)
return
def __activate(self, command):
if not self.__manager: self.__init_manager()
self.__manager.activate(command)
return False
def __activate_cb(self, trigger):
from gobject import idle_add
idle_add(self.__activate, trigger.command)
return
def __init_attributes(self, editor):
self.__editor = editor
from Manager import Manager
self.__manager = Manager(editor)
name, shortcut, description, category = (
"open-recent-files",
"<ctrl><alt>r",
_("Open recent files"),
_("File Operations")
)
self.__trigger = self.create_trigger(name, shortcut, description, category)
self.__trigger.command = "activate"
name, shortcut, description, category = (
"reopen-closed-file",
"<ctrl><shift>w",
_("Reopen last closed file"),
_("File Operations")
)
self.__trigger1 = self.create_trigger(name, shortcut, description, category)
self.__trigger1.command = "open-last-file"
name, shortcut, description, category = (
"reopen-closed-files",
"<ctrl><shift>q",
_("Reopen last closed file"),
_("File Operations")
)
self.__trigger2 = self.create_trigger(name, shortcut, description, category)
self.__trigger2.command = "open-last-files"
return
class Trigger(SignalManager, TriggerManager):
def __init__(self, editor):
SignalManager.__init__(self)
TriggerManager.__init__(self, editor)
self.__init_attributes(editor)
self.connect(self.__trigger, "activate", self.__activate_cb)
def __init_attributes(self, editor):
self.__editor = editor
self.__manager = None
name, shortcut, description, category = (
"toggle-comments",
"<alt>c",
_("Toggle comments"),
_("Line Operations")
)
self.__trigger = self.create_trigger(name, shortcut, description, category)
return
def __get_manager(self):
if self.__manager: return self.__manager
from Manager import Manager
self.__manager = Manager(self.__editor)
return self.__manager
def __activate(self):
if self.__editor.readonly: return False
self.__get_manager().activate()
return False
def __activate_cb(self, *args):
from gobject import idle_add
idle_add(self.__activate)
return False
def __destroy(self):
self.disconnect()
self.remove_triggers()
if self.__manager: self.__manager.destroy()
del self
return False
def destroy(self):
from gobject import idle_add
idle_add(self.__destroy)
return False
def __activate(self): try: self.__manager.activate() except AttributeError: from Manager import Manager self.__manager = Manager(self.__editor) self.__manager.activate() return False
def __activate_cb(self, *args): try: self.__manager.match() except AttributeError: from Manager import Manager self.__manager = Manager(self.__editor) self.__manager.match() return False
def __init_attributes(self, editor):
self.__editor = editor
from Manager import Manager
self.__manager = Manager(editor)
from MenuItem import MenuItem
self.__menuitem = MenuItem(editor)
self.__trigger = self.create_trigger("show-autoreplace-dialog")
return
class Trigger(SignalManager, TriggerManager):
def __init__(self, editor):
SignalManager.__init__(self)
TriggerManager.__init__(self, editor)
self.__init_attributes(editor)
self.connect(self.__trigger1, "activate", self.__activate_cb)
self.connect(self.__trigger2, "activate", self.__activate_cb)
def __init_attributes(self, editor):
self.__editor = editor
from Manager import Manager
self.__manager = Manager(editor)
name, shortcut, description, category = (
"select-next-highlighted-match",
"<ctrl>g",
_("Navigate to next highlighted match"),
_("Navigation Operations")
)
self.__trigger1 = self.create_trigger(name, shortcut, description, category)
self.__trigger1.action = "select-next-match"
name, shortcut, description, category = (
"select-previous-highlighted-match",
"<ctrl><shift>g",
_("Navigation to previous highlighted match"),
_("Navigation Operations")
)
self.__trigger2 = self.create_trigger(name, shortcut, description, category)
self.__trigger2.action = "select-previous-match"
return
def destroy(self):
self.disconnect()
self.remove_triggers()
self.__manager.destroy()
del self
return False
def __activate(self, action):
self.__manager.activate(action)
return False
def __activate_cb(self, trigger):
from gobject import idle_add
idle_add(self.__activate, trigger.action)
return
def __show_window_cb(self, *args): try: self.__manager.show() except AttributeError: from Manager import Manager self.__manager = Manager(self.__editor) self.__manager.show() return
class Trigger(SignalManager, TriggerManager):
def __init__(self, editor):
SignalManager.__init__(self)
TriggerManager.__init__(self, editor)
self.__init_attributes(editor)
self.connect(self.__trigger, "activate", self.__activate_cb)
def __init_attributes(self, editor):
self.__editor = editor
name, shortcut, description, category = (
"activate-shortcut-window",
"<ctrl>h",
_("Show Shortcut Window"),
_("Window Operations")
)
self.__trigger = self.create_trigger(name , shortcut, description, category)
self.__manager = None
return
def __destroy(self):
if self.__manager: self.__manager.destroy()
self.disconnect()
self.remove_triggers()
del self
return False
def __activate(self):
try :
self.__manager.activate()
except AttributeError :
from Manager import Manager
self.__manager = Manager(self.__editor)
self.__manager.activate()
return False
def __activate_cb(self, *args):
from gobject import idle_add
idle_add(self.__activate)
return
def destroy(self):
self.__destroy()
return
class Trigger(SignalManager, TriggerManager):
def __init__(self, editor):
SignalManager.__init__(self)
TriggerManager.__init__(self, editor)
self.__init_attributes(editor)
self.connect(self.__trigger1, "activate", self.__activate_cb)
self.connect(self.__trigger2, "activate", self.__activate_cb)
def __init_attributes(self, editor):
self.__editor = editor
self.__manager = None
name, shortcut, description, category = (
"show-document-browser",
"F9",
_("Focus any file window"),
_("Window Operations")
)
self.__trigger1 = self.create_trigger(name, shortcut, description, category)
name, shortcut, description, category = (
"show-document-browser_",
"<super>b",
_("Focus any file window"),
_("Window Operations")
)
self.__trigger2 = self.create_trigger(name, shortcut, description, category)
return
def __activate_cb(self, *args):
try:
self.__manager.show()
except AttributeError:
from Manager import Manager
self.__manager = Manager(self.__editor)
self.__manager.show()
return
def destroy(self):
self.disconnect()
self.remove_triggers()
if self.__manager: self.__manager.destroy()
del self
return
class Trigger(SignalManager, TriggerManager):
def __init__(self, editor):
SignalManager.__init__(self)
TriggerManager.__init__(self, editor)
self.__init_attributes(editor)
self.connect(self.__trigger1, "activate", self.__activate_cb)
self.connect(self.__trigger2, "activate", self.__activate_cb)
def __init_attributes(self, editor):
from Manager import Manager
self.__manager = Manager(editor)
name, shortcut, description, category = (
"escape-quotes",
"<ctrl><shift>e",
_("Escape quotes"),
_("Text Operations")
)
self.__trigger1 = self.create_trigger(name, shortcut, description, category)
name, shortcut, description, category = (
"unescape-quotes",
"<ctrl><alt>e",
_("Unescape quotes"),
_("Text Operations")
)
self.__trigger2 = self.create_trigger(name, shortcut, description, category)
return
def destroy(self):
self.disconnect()
self.remove_triggers()
if self.__manager: self.__manager.destroy()
del self
return False
def __activate_cb(self, trigger):
function = {
self.__trigger1: self.__manager.escape,
self.__trigger2: self.__manager.unescape,
}
function[trigger]()
return False
class Trigger(SignalManager, TriggerManager):
def __init__(self, editor):
SignalManager.__init__(self)
TriggerManager.__init__(self, editor)
self.__init_attributes(editor)
self.connect(self.__trigger1, "activate", self.__activate_cb)
self.connect(self.__trigger2, "activate", self.__activate_cb)
def __init_attributes(self, editor):
self.__editor = editor
from Manager import Manager
self.__manager = Manager(editor)
name, shortcut, description, category = (
"move-cursor-to-errors",
"F2",
_("Move cursor to errors in python code"),
_("Python"),
)
self.__trigger1 = self.create_trigger(name, shortcut, description, category)
self.__trigger1.command = "activate"
name, shortcut, description, category = (
"toggle-error-checking",
"<shift>F2",
_("Move cursor to errors in python code"),
_("Python"),
)
self.__trigger2 = self.create_trigger(name, shortcut, description, category)
self.__trigger2.command = "toggle-error-check"
return
def __activate_cb(self, trigger):
self.__manager.activate(trigger.command)
return
def destroy(self):
self.disconnect()
self.remove_triggers()
if self.__manager: self.__manager.destroy()
del self
return
class Trigger(SignalManager, TriggerManager):
def __init__(self, editor):
SignalManager.__init__(self)
TriggerManager.__init__(self, editor)
self.__init_attributes(editor)
self.connect(self.__trigger, "activate", self.__activate_cb)
editor.get_toolbutton("PrintToolButton").props.sensitive = True
def __init_attributes(self, editor):
self.__editor = editor
name, shortcut, description, category = (
"show-print-window",
"<ctrl>p",
_("Print the current file"),
_("File Operations")
)
self.__trigger = self.create_trigger(name, shortcut, description, category)
self.__manager = None
return
def destroy(self):
self.disconnect()
self.remove_triggers()
if self.__manager: self.__manager.destroy()
del self
return False
def __activate(self):
try :
self.__manager.activate()
except AttributeError :
from Manager import Manager
self.__manager = Manager(self.__editor)
self.__manager.activate()
return False
def __activate_cb(self, *args):
from gobject import idle_add
idle_add(self.__activate)
return
def installStandardDAR(darfile, installDir):
"""
_installStandardDAR_
Installation of a standard DARball
"""
config = {
"dar_shared_pool" : os.getcwd(),
"dar_dist_pool" : os.getcwd(),
"dar_inst_pool" : os.getcwd(),
"dar_tmp_dir" : os.getcwd(),
}
darConf = []
darConf.append("use dar file %s\n" % darfile)
manager = Manager( darConf, cnf=config, pltf=Platform() )
manager.installApplication( installDir, None )
return installDir
def create_configure_dialog(self):
if not self.dlg:
self.dlg = Manager(self.plugin_info.get_data_dir())
else:
self.dlg.run()
window = Pluma.App.get_default().get_active_window()
if window:
self.dlg.dlg.set_transient_for(window)
return self.dlg.dlg
def create_configure_dialog(self):
if not self.dlg:
self.dlg = Manager(self.get_data_dir())
else:
self.dlg.run()
window = gedit.app_get_default().get_active_window()
if window:
self.dlg.dlg.set_transient_for(window)
return self.dlg.dlg
def __init_attributes(self, editor):
self.__editor = editor
from Manager import Manager
self.__manager = Manager(self.__editor)
name, shortcut, description, category = (
"toggle-word-completion",
"<ctrl><shift><alt>c",
_("Toggle automatic word completion"),
_("Miscellaneous Operations")
)
self.__trigger = self.create_trigger(name, shortcut, description, category)
return
class Trigger(SignalManager, TriggerManager):
def __init__(self, editor):
SignalManager.__init__(self)
TriggerManager.__init__(self, editor)
self.__init_attributes(editor)
self.connect(self.__trigger, "activate", self.__activate_cb)
def __init_attributes(self, editor):
self.__editor = editor
name, shortcut, description, category = (
"activate-foo-power",
"<ctrl><alt>f",
_("Activate the holy power of foo"),
_("Example")
)
self.__trigger = self.create_trigger(name, shortcut, description, category)
self.__manager = None
return
def destroy(self):
self.disconnect()
self.remove_triggers()
if self.__manager: self.__manager.destroy()
del self
return False
def __activate(self):
try:
self.__manager.activate()
except AttributeError:
from Manager import Manager
self.__manager = Manager(self.__editor)
self.__manager.activate()
return False
def __activate_cb(self, *args):
from gobject import idle_add
idle_add(self.__activate)
return False
class Trigger(SignalManager, TriggerManager):
def __init__(self, editor):
SignalManager.__init__(self)
TriggerManager.__init__(self, editor)
self.__init_attributes(editor)
self.connect(self.__trigger, "activate", self.__activate_cb)
def __init_attributes(self, editor):
self.__editor = editor
name, shortcut, description, category = (
"toggle-comment",
"<alt>c",
_("Toggle comment"),
_("Miscellaneous Operations")
)
self.__trigger = self.create_trigger(name, shortcut, description, category)
self.__manager = None
return
def destroy(self):
self.disconnect()
self.remove_triggers()
if self.__manager: self.__manager.destroy()
del self
return False
def __activate(self):
try :
self.__manager.activate()
except AttributeError :
from Manager import Manager
self.__manager = Manager(self.__editor)
self.__manager.activate()
return False
def __activate_cb(self, *args):
from gobject import idle_add
idle_add(self.__activate)
return
