def start(self, firstPlayer):
self.GameState = 0
EventManager.notify("GameStarting")
# move counter init
self.moveCounter = 0
# generate fresh state
self.HexBoard = HexBoard(self.size[0], self.size[1])
self.HexBoard.setReferenceToGame(self)
# current player depending on decision
self._currentPlayer = firstPlayer
if self.mode == "ki":
self.KI = MonteCarloTreeSearch(self, 2) # TODO: ki_player_id == 2?
# self.KI = HexKI(self.size[0], self.size[1])
if self.mode == "inter" or self.mode == "machine":
self.KI = []
self.KI.append(HexKI(self.size[0], self.size[1]))
self.KI.append(HexKI(self.size[0], self.size[1]))
self._currentPlayerType = "ki"
# if random number wanted, generate one
if firstPlayer == 0:
self.chooseFirst()
EventManager.notify("GameStarted")
def __init__(self, score, time):
"Initialises resources and start level"
self.background = pygame.image.load("sprites/sky.jpg")
self.background.convert() #for blitting more faster
self.screen = Constants.SCREEN
self.score = score
self.display_items = pygame.sprite.Group()
self.timeclock = GameTime((0.05, 0.05), time)
self.display_items.add(self.timeclock, self.score)
self.time_speed = pygame.time.Clock()
self.time = 0.0
self.quit = False
self.pause = False
self.start = False
self.completed = False
self.gameover = False
self.message = None
self.polygon = Polygon(self)
self.event_manager = EventManager(self)
self.on_enter()
def callbackVerschiebe(self, event):
from EventManager import EventManager
from TimeManager import TimeManager
if event.keysym == "Return":
nach = Zeit.fromString(self.text)
self.unfokusiere()
self.aktualisiereText(
) #setzt den Text auf die gespeicherte Zeit, wird nur überschrieben falls nach passt
if nach is not None:
if self.event is not None:
EventManager.verschiebeZeitNach(self.event,
self.istStartzeit(), nach)
self.text = nach.text
# überprüft ob die Zeit die Start oder Endzeit ist wenn sie einem Event zugeordnet ist
assert (self.istStartzeit() or self.istEndzeit())
assert not (self.istStartzeit() and self.istEndzeit())
else:
TimeManager.verschiebeZeit(self, nach)
self.zeichne()
elif event.keysym == "BackSpace":
self.text = self.text[:-1]
elif event.keysym == "Delete":
self.unfokusiere()
else:
self.text += event.char
self.zeichneMarkiert()
def __init__(self,
messageManager,
iface,
settingsPrefix="/SeismicRisk",
organizationName=None,
applicationName=None):
QObject.__init__(self)
self.msg = messageManager
self.settings = QSettings(
organizationName, applicationName
) if organizationName and applicationName else QSettings()
self.dictAutoFields = OrderedDict()
self.settingsPrefix = settingsPrefix
self.eventManager = EventManager(self.msg, iface, settingsPrefix)
self.eventManager.layersAddedCheckIfAutoFields.connect(
self.checkAndEnableAutoFieldsForLayers)
self.eventManager.autoFieldsReadyToBeDisabled.connect(
self.disableAutoFields)
self.eventManager.attributesAddedCheckIfAutoFields.connect(
self.checkAndEnableAutoFieldsForLayerFields)
self.eventManager.attributesDeletedCheckIfAutoFields.connect(
self.checkAndDisableAutoFieldsForLayer)
self.eventManager.setAFM(self)
self.fieldCalculator = FieldCalculator(self.msg, iface)
def main():
ScreenManager.init()
TM.ladeZeiten()
EM.ladeEvents()
ScreenManager.zeichneHintergrund()
ScreenManager.root.protocol("WM_DELETE_WINDOW", beenden)
ScreenManager.run()
def receiveMove(self, move):
# first store the last move
self.lastMove = move
# get the vertex the move pointed on
vertex = self.getVertex(move[1], move[0])
# mark it
vertex.player = self.Game.currentPlayer()
# first add it to a new group (later on merge them)
vertex.group = self._groupCounter
# increment the group counter to avoid conflicts
self._groupCounter = self._groupCounter +1
# the following lines manipulate the groups of
# vertices at the border of the gameboard
# red: left 0, right -1
# blue: top 0, right -1
if self.Game.currentPlayer() == 1:
if move[1] == 0:
vertex.group = 0
if move[1] == self.size[0]-1:
vertex.group = -1
else:
if move[0] == 0:
vertex.group = 0
if move[0] == self.size[1]-1:
vertex.group = -1
# get the adjacent vertices to that one, which is marked
adjVertices = self.getSurroundingVertices(move[1], move[0])
# any neightbours?:
if len(adjVertices) > 0:
# put the marked one to the list
adjVertices.append(vertex)
# only concentrate on the groups
groups = [x.group for x in adjVertices]
# WIN Condition
# either within the gameboard
# or the last vertex marked has been at the borders
if (-1 in groups and 0 in groups):
EventManager.notify("GameFinished")
# get the minimum group
minGroup = min(groups)
# set all neighbours to the minimum of the group
for key, value in self.Vertices.items():
if value.group in groups:
value.group = minGroup
def setupEnv():
em = EventManager()
em.listVpns()
em.createVpn(vpnName)
em.createQ(vpnName, "q1")
em.addQSubscription(vpnName, "q1", "a/b")
em.addQSubscription(vpnName, "q1", "d/>")
def test_fire_global(self):
em = EventManager()
em.test = Event(test_func)
em.got_event.add_handler(test_func_global)
with self.assertRaises(TestError):
em.test()
def main():
# initializing and drawing background UI elements
background = UIBox(g_const.screen_size, (0, 0, 0), (0, 0))
arena = UIBox(g_const.arena_size, (50, 50, 50), g_const.arena_pos)
sidebar = UIBox(g_const.sidebar_size, (50, 50, 50), g_const.sidebar_pos)
background.draw()
sidebar.draw()
evt_man = EventManager()
terrain = Terrain()
game_state = GameState(terrain)
start = time.time()
evt_man.start_world_update()
while True:
dt = time.time() - start
if dt >= frame_length:
start = time.time() # reset start tick
events = evt_man.processEvents() # handle events
game_state.update(events) # update game state
# draw objects
arena.draw()
game_state.curr_shape.draw()
terrain.draw()
# update display
pyg.display.update()
def beenden():
EM.speichereEvents()
TM.speichereZeiten()
try:
ScreenManager.root.destroy()
except:
exit()
def receiveMove(self, move):
# first store the last move
self.lastMove = move
# get the vertex the move pointed on
vertex = self.getVertex(move[1], move[0])
# mark it
vertex.player = self.Game.currentPlayer()
# first add it to a new group (later on merge them)
vertex.group = self._groupCounter
# increment the group counter to avoid conflicts
self._groupCounter = self._groupCounter + 1
# the following lines manipulate the groups of
# vertices at the border of the gameboard
# red: left 0, right -1
# blue: top 0, right -1
if self.Game.currentPlayer() == 1:
if move[1] == 0:
vertex.group = 0
if move[1] == self.size[0] - 1:
vertex.group = -1
else:
if move[0] == 0:
vertex.group = 0
if move[0] == self.size[1] - 1:
vertex.group = -1
# get the adjacent vertices to that one, which is marked
adjVertices = self.getSurroundingVertices(move[1], move[0])
# any neightbours?:
if len(adjVertices) > 0:
# put the marked one to the list
adjVertices.append(vertex)
# only concentrate on the groups
groups = [x.group for x in adjVertices]
# WIN Condition
# either within the gameboard
# or the last vertex marked has been at the borders
if (-1 in groups and 0 in groups):
EventManager.notify("GameFinished")
# get the minimum group
minGroup = min(groups)
# set all neighbours to the minimum of the group
for key, value in self.Vertices.items():
if value.group in groups:
value.group = minGroup
def onUITick(self):
if not self.Game._pause:
# notify subscripts
EventManager.notify("UITick")
# redo this step every nth seconds
self.tkInstance.after(200, self.onUITick)
def onUITick(self):
if not self.Game._pause:
# notify subscripts
EventManager.notify("UITick")
# redo this step every nth seconds
self.tkInstance.after(200, self.onUITick)
def __init__(self, screenRes=(640, 480)):
self.running = True
self.surfaceManager = SurfaceManager(
) #Handles the drawing of a scene, managers that have draw functions are added at the bottom of init using .setObjects()
self.uiManager = UIManager(
) #UI managers keep all the buttons and text together, and position them
self.eventHandlers = EventHandlers() #Event Handlers
self.eventManager = EventManager() #Manages event handlers
self.surfaceManager.setObjects() #Sets objects that need drawn
def openPage(self, page):
if page == "menu":
self._GUIMenu.show()
self._GUIGameBoard.hide()
elif page == "game":
self._GUIMenu.hide()
self._GUIGameBoard.show()
EventManager.notify("GameUILoaded")
def test_addEvent(self):
EM.events = []
SM.init()
event1 = Event(Zeit(14, 30), Zeit(15, 00))
event2 = Event(Zeit(16, 30), Zeit(17, 00))
event3 = Event(Zeit(14, 45), Zeit(17, 00))
lsg1 = Event(Zeit(15, 0), Zeit(16, 30))
EM.addEvent(event1)
EM.addEvent(event2)
# hinzufügen ohne Überlapp
self.assertEqual(
str(EM.events[0]),
f"Start 14:30 Ende 15:00 am {EM.events[0].startzeit.erhalteDatum()}"
)
self.assertEqual(
str(EM.events[1]),
f"Start 16:30 Ende 17:00 am {EM.events[1].startzeit.erhalteDatum()}"
)
# mit überlapp
EM.addEvent(event3)
self.assertTrue(EM.hatEvent(lsg1))
self.assertTrue(EM.hatEvent(event1))
self.assertTrue(EM.hatEvent(event2))
def __init__(self, m, n, game):
self.size = [m,n]
self.Game = game
EventManager.subscribe("GameFinished", self.onGameFinished)
self._finished = False
self.targetIterations = 100
self.q = 0
print("MachineGUI loaded")
def __init__(self, m, n, game):
self.size = [m, n]
self.Game = game
EventManager.subscribe("GameFinished", self.onGameFinished)
self._finished = False
self.targetIterations = 100
self.q = 0
print("MachineGUI loaded")
def entferne(self):
from EventManager import EventManager
from ScreenManager import ScreenManager
self.unfokusiere()
#rufe entferne für die Zeiten auf, damit diese vom Canvas gelöscht werden können
self.startzeit.entferne()
self.endzeit.entferne()
#entferne das events aus events[]
EventManager.removeEvent(self)
#lösche das Event vom Canvas
for form in self.form:
ScreenManager.canvas.delete(form)
self.form = []
def makeMove(self, move):
# Notify
EventManager.notify("MoveBegan")
# if already marked dont do anything
if self.HexBoard.isMarked(move[1], move[0]):
EventManager.notify("MoveDenied")
else:
# otherwise count the click
self.moveCounter = self.moveCounter + 1
# notify Model
self.HexBoard.receiveMove(move)
# notify View
self.changePlayer()
EventManager.notify("PlayerChanged")
if not self.isPlayerHuman():
move = self.KI.getMove()
self.makeMove(move)
EventManager.notify("MoveFinished")
def makeMove(self, move):
# Notify
EventManager.notify("MoveBegan")
# if already marked dont do anything
if self.HexBoard.isMarked(move[0], move[1]):
EventManager.notify("MoveDenied")
assert False
else:
# otherwise count the click
self.moveCounter = self.moveCounter + 1
# notify Model
self.HexBoard.receiveMove(move)
if self.mode == "inter":
self.KI[0].receiveMove(move)
self.KI[1].receiveMove(move)
elif self.mode == "ki":
self.KI.receiveMove(move)
# notify View
self.changePlayer()
EventManager.notify("PlayerChanged")
EventManager.notify("MoveFinished")
def test_removeElement(self):
EM.events = []
event1 = Event(Zeit(11, 30), Zeit(15, 00))
event2 = Event(Zeit(16, 30), Zeit(22, 00))
event3 = Event(Zeit(14, 45), Zeit(17, 00))
EM.addEvent(event1)
EM.addEvent(event2)
EM.addEvent(event3)
EM.removeEvent(event1)
self.assertIsNone(EM.findeEvent(Zeit(12, 0)))
self.assertEqual(len(EM.events), 2)
def openPage(self, page):
if page == "splash":
self._GUIMenu.hide()
self._GUIGameBoard.hide()
self._GUISplashScreen.show()
elif page == "menu":
self._GUIMenu.show()
self._GUIGameBoard.hide()
self._GUISplashScreen.hide()
elif page == "game":
self._GUIMenu.hide()
self._GUIGameBoard.show()
self._GUISplashScreen.hide()
EventManager.notify("GameUILoaded")
def __init__(self, config):
self.logger = logging.getLogger("SmartHome")
self.config = config
httpThreadsNumber = int(config['http_threads_number'])
self.httpDispatcher = MultiThreadingDispatcher("HttpDispatcher",
httpThreadsNumber)
self.httpHandler = HTTPCommandHandler()
self.httpHandler.setHandler('ping', self.pingHandler)
self.httpHandler.setHandler('status', self.statusHandler)
self.videoController = VideoController(config['VideoController'])
self.videoCommandHandler = VideoCommandHandler(self.videoController)
self.httpHandler.setHandler('video',
self.videoCommandHandler.handleCommand)
self.controlManager = ControlManager(config['ControlManager'])
self.controlCommandHandler = ControlCommandHandler(self.controlManager)
self.httpHandler.setHandler('control',
self.controlCommandHandler.handleCommand)
self.sensorManager = SensorManager(config['SensorManager'])
self.sensorCommandHandler = SensorCommandHandler(self.sensorManager)
self.httpHandler.setHandler('sensor',
self.sensorCommandHandler.handleCommand)
self.http_port = int(config['http_port'])
self.httpServer = DispatchedBackgroundHTTPServer(
('', self.http_port), self.httpHandler.getRequestHandlerClass(),
self.httpDispatcher)
self.httpServer.allow_reuse_address = True
self.arduinoController = ArduinoController(config['ArduinoController'])
self.shellSensorProvider = ShellSensorProvider(
config['ShellSensorProvider'])
self.shellControlProvider = ShellControlProvider(
config['ShellControlProvider'])
self.eventManager = EventManager(config['EventManager'])
self.eventCommandHandler = EventCommandHandler(self.eventManager)
self.shellEventHandlerProvider = ShellEventHandlerProvider(
config['ShellEventHandlerProvider'])
self.httpHandler.setHandler('event',
self.eventCommandHandler.handleCommand)
def test():
# 实例化监听器
# listner1 = Listener("thinkroom") #订阅者1
# listner2 = Listener("steve") #订阅者2
gh_port = 8849
ghclient = GhClient("127.0.0.1", gh_port)
# 实例化事件操作函数
eventManager = EventManager()
eventManager.AddEventListener(EVENT_ARTICAL, ghclient.receiveData)
#绑定事件和监听器响应函数(新文章)
# eventManager.AddEventListener(EVENT_ARTICAL, listner1.ReadArtical)
# eventManager.AddEventListener(EVENT_ARTICAL, listner2.ReadArtical)
# 启动事件管理器,# 启动事件处理线程
eventManager.Start()
def borrowBook(self, cloudDB, userName, bookID = -1):
if bookID == -1:
print('Please enter the ISBN number of the book you want to borrow:')
bookID = TakeInput.inputInteger(1,cloudDB.getBookQuantity())
availabale = cloudDB.checkBookStatus(bookID)
if availabale == False:
print("Sorry, this book is current not availabale, please borrow another one..")
else:
borrowDate = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
returnDate = (datetime.now() + timedelta(days = 7)).strftime("%Y-%m-%d %H:%M:%S")
userID = cloudDB.getUserID(userName)
bookName = cloudDB.getBookName(bookID)
eid = EventManager.insert(bookName,userName)
print("")
print('Book borrow detail')
print("Borrow Date: "+borrowDate)
print("Return Date: "+returnDate)
print("Book detail:")
cloudDB.printABookDetail(bookID)
cloudDB.insertBookBorrowed(userID,bookID,borrowDate,eid)
print("")
print('Book Borrowed Successfull! Please return it within 7 days!')
print("")
return
def __init__(self, m, n, Game):
self.size = [m, n]
self.Game = Game
self.screenSize = [800, 600]
EventManager.subscribe("MoveFinished", self.onMoveFinished)
# init Tkinter
self.tkInstance = Tk()
self._GUISplashScreen = SplashScreenView(self.tkInstance, self)
self._GUIMenu = MenuView(self.tkInstance, self)
self._GUIGameBoard = GameView(self.tkInstance, self, Game)
self._GUIMenu.show()
def __init__(self,score,time):
"Initialises resources and start level"
self.background=pygame.image.load("sprites/sky.jpg")
self.background.convert() #for blitting more faster
self.screen=Constants.SCREEN
self.score = score
self.display_items = pygame.sprite.Group()
self.timeclock = GameTime((0.05,0.05),time)
self.display_items.add(self.timeclock,self.score)
self.time_speed=pygame.time.Clock()
self.time=0.0
self.quit = False
self.pause = False
self.start = False
self.completed = False
self.gameover = False
self.message = None
self.polygon=Polygon(self)
self.event_manager = EventManager(self)
self.on_enter()
def __init__(self, m, n, Game):
self.size = [m,n]
self.Game = Game
self.screenSize = [800, 600]
EventManager.subscribe("MoveFinished", self.onMoveFinished)
# init Tkinter
self.tkInstance = Tk()
self._GUISplashScreen = SplashScreenView(self.tkInstance, self)
self._GUIMenu = MenuView(self.tkInstance, self)
self._GUIGameBoard = GameView(self.tkInstance, self, Game)
self._GUIMenu.show()
def main():
pg.init()
ev_manager = EventManager()
model = GameEngine(ev_manager)
controller = Controller(ev_manager, model)
view = GraphicalView(ev_manager, model)
model.run()
class Scene(object):
"""A scene is like a level, or one section of the program. There will be an intro scene, the sokoban scene and an ending scene displaying the users score. This is a TEMPLATE class"""
def __init__(self, screenRes=(640, 480)):
self.running = True
self.surfaceManager = SurfaceManager(
) #Handles the drawing of a scene, managers that have draw functions are added at the bottom of init using .setObjects()
self.uiManager = UIManager(
) #UI managers keep all the buttons and text together, and position them
self.eventHandlers = EventHandlers() #Event Handlers
self.eventManager = EventManager() #Manages event handlers
self.surfaceManager.setObjects() #Sets objects that need drawn
#events are handled and draw managers draw to main display
def run(self, surface, events):
#Events
self.eventManager.run(events)
#Draw
self.surfaceManager.draw()
def __init__(self, m, n, Game):
self.size = [m,n]
self.Game = Game
self.screenSize = [800, 600]
EventManager.subscribe("MoveFinished", self.onMoveFinished)
# init Tkinter
self.tkInstance = Tk()
self.tkInstance.title("HexGame by Daniel, Jannis and Mats")
self.tkInstance.after(1000, self.onUITick)
self._GUIMenu = MenuView(self.tkInstance, self)
self._GUIGameBoard = GameView(self.tkInstance, self, Game)
self._GUIMenu.show()
def start(self, firstPlayer):
EventManager.notify("GameStarting")
# move counter init
self.moveCounter = 0
# generate fresh state
self.HexBoard = HexBoard(self.size[0], self.size[1])
self.HexBoard.setReferenceToGame(self)
# current player depending on decision
self._currentPlayer = firstPlayer
# if random number wanted, generate one
if firstPlayer == 0:
self.chooseFirst()
EventManager.notify("GameStarted")
def handle_raw_event(self, event):
result = '\t' + pygame.event.event_name(event.type)
if EventManager.is_keyboard_event(event.type):
result += '\t' + pygame.key.name(event.key)
elif event.type in EventManager.JOYSTICK_BUTTON_EVENTS:
result += '\t' + str(event.button)
elif event.type in EventManager.JOYSTICK_AXIS_EVENTS:
result += '\tjoy: ' + \
str(event.joy) + '\taxis: ' + str(event.axis) + \
'\tvalue: ' + '%.3f' % (event.value)
elif event.type in EventManager.JOYSTICK_HAT_EVENTS:
result += '\tjoy: ' + \
str(event.joy) + '\that: ' + str(event.hat) + \
'\tvalue: ' + str(event.value)
elif EventManager.is_joystick_event(event.type):
result = '\t' + str(event)
else:
return
print result
def start(self, firstPlayer):
EventManager.notify("GameStarting")
# move counter init
self.moveCounter = 0
# generate fresh state
self.HexBoard = HexBoard(self.size[0], self.size[1])
self.HexBoard.setReferenceToGame(self)
# current player depending on decision
self._currentPlayer = firstPlayer
# if random number wanted, generate one
if firstPlayer == 0:
self.chooseFirst()
EventManager.notify("GameStarted")
def run_app(self):
print('gui')
Process(target=gui.run_app,
args=(self.cfg, self.GuiRecvMsg, self.CtrlRecvMsg)).start()
print('ctrl')
# Process(target = Controller.run_app, args = ( self.cfg, self.GuiRecvMsg, self.CtrlRecvMsg )).start()
funMap = ServiceEvent(self.cfg, self.GuiRecvMsg)
handlers = ['tumblr', 'sys']
EventManager(self.CtrlRecvMsg, handlers, funMap).Start()
print('exitApp')
def test_findeEvent(self):
EM.events = []
event1 = Event(Zeit(14, 30), Zeit(15, 00))
event2 = Event(Zeit(16, 30), Zeit(17, 00))
event3 = Event(Zeit(14, 45), Zeit(17, 00))
EM.addEvent(event1)
EM.addEvent(event2)
EM.addEvent(event3)
lsg1 = EM.findeEvent(Zeit(14, 45))
lsg2 = EM.findeEvent(Zeit(15, 00))
lsg3 = EM.findeEvent(Zeit(16, 30))
self.assertEqual(event1, lsg1)
self.assertEqual(event3, lsg2)
self.assertEqual(event2, lsg3)
def __init__(self, m, n):
self.size = [m, n]
# subscribe to certain events
EventManager.subscribe("GameFinished", self.onGameFinished)
# keep track, increment on each added vertex
self._groupCounter = 2
# bool to determine machine state
self._finished = False
# dictionary for all vertices
self.Vertices = {}
for i in range(m):
for j in range(n):
# add Hexagon instance to the dict
# with key => i;j
self.Vertices[str(i) + "," + str(j)] = Hexagon(i, j)
def __init__(self, m, n):
self.size = [m, n]
# subscribe to certain events
EventManager.subscribe("GameFinished", self.onGameFinished)
# keep track, increment on each added vertex
self._groupCounter = 2
# bool to determine machine state
self._finished = False
# dictionary for all vertices
self.Vertices = {}
for i in range(m):
for j in range(n):
# add Hexagon instance to the dict
# with key => i;j
self.Vertices[str(i) + "," + str(j)] = Hexagon(i, j)
def callbackRightClick(clickEvent):
from EventManager import EventManager
from TimeManager import TimeManager
from Event import Event
if ScreenManager.ausgewaehlt is not None: # auswahl für altes Element aufheben
ScreenManager.ausgewaehlt.zeichne()
ScreenManager.ausgewaehlt.unfokusiere()
pixel = (clickEvent.x, clickEvent.y)
# x_root ist realtiv zum canvas
zeit = ScreenManager.pixelZuZeit(pixel[1]).runde(
TimeManager.genauigkeit) # ausgewählte Zeit, gerundet
event = EventManager.findeEvent(zeit)
if event is not None:
pause = EventManager.addPause(zeit, EventManager.pausenLaenge)
pause.zeichne()
ScreenManager.ausgewaehlt = pause.endzeit
ScreenManager.ausgewaehlt.zeichneMarkiert()
ScreenManager.ausgewaehlt.fokusiere()
def __init__(self, m, n, mode):
# init all events
EventManager.initEvents()
EventManager.subscribe("GameFinished", self.onGameFinished)
EventManager.subscribe("GameStarted", self.onGameStarted)
# save size and mode
self.size = [m,n]
self.mode = mode
# just to init the value
self._currentPlayer = 1
# instantiate model and view
self.HexBoard = HexBoard(self.size[0], self.size[1])
self.HexBoard.setReferenceToGame(self)
if self.UIRequired():
self.HexGUI = HexGUI(self.size[0], self.size[1], self)
else:
self.MachineGUI = MachineGUI(self.size[0], self.size[1], self)
# set the game to entry point
self.start(self._currentPlayer)
if self.UIRequired():
# main loop starts for event receiving
self.HexGUI.mainloop()
if self.UIRequired() == False:
self.MachineGUI.gameLoop()
def __init__( self, messageManager, iface, settingsPrefix="/AutoFields", organizationName=None, applicationName=None ):
QObject.__init__( self )
self.msg = messageManager
self.settings = QSettings( organizationName, applicationName ) if organizationName and applicationName else QSettings()
self.dictAutoFields = OrderedDict()
self.settingsPrefix = settingsPrefix
self.eventManager = EventManager( self.msg, iface, settingsPrefix )
self.eventManager.layersAddedCheckIfAutoFields.connect( self.checkAndEnableAutoFieldsForLayers )
self.eventManager.autoFieldsReadyToBeDisabled.connect( self.disableAutoFields )
self.eventManager.attributesAddedCheckIfAutoFields.connect( self.checkAndEnableAutoFieldsForLayerFields )
self.eventManager.attributesDeletedCheckIfAutoFields.connect( self.checkAndDisableAutoFieldsForLayer )
self.eventManager.setAFM( self )
self.fieldCalculator = FieldCalculator( self.msg, iface )
def __init__(self, videoMode=sf.VideoMode(800, 600, 32), \
title="window", parent=0, framerateLimit=60,\
backgroundColor = sf.Color.BLACK, backgroundImage = Image()):
sf.RenderWindow.__init__(self, videoMode, title)
Render.__init__(self, parent, sf.Rectangle(sf.Vector2(),\
videoMode.size), backgroundColor, backgroundImage)
self._isStaticToView = False
self.position = (0,0)
self.framerate_limit = framerateLimit
self._framerate = framerateLimit
self._event = EventManager(self)
self.resetView()
self.clear(backgroundColor)
def __init__(self,arguments):
self.debug = False
self.capturing = False
self.captureFPSWait = 0
self.running = True
self.fullscreen = False
self.paused = False
self.cachedScenes = {}
self.currentScene = None
self.currentElement = None
self.currentWindow = None
self.currentWidget = None
self.values = {}
self.Loader = Loader(self)
self.setupScreen()
self.setupAudio()
self.displayTitle()
self.Loader.preload()
self.TitleManager = TitleManager(self)
self.Cursor = Cursor(self)
self.Renderer = Renderer(self)
self.AudioController = AudioController(self)
self.Inventory = Inventory(self)
self.TopicMenu = TopicMenu(self)
self.ScriptManager = ScriptManager(self)
self.Player = Player(self)
self.EventManager = EventManager(self)
self.parseArguments(arguments)
self.loadScene("blacksmith")
self.run()
def onGameFinished(self):
if not self._eventsSuppressed:
EventManager.notify("GameFinished")
self._finished = True
def __init__(self): EventManager.__init__(self)
def onGameFinished(self):
EventManager.notify("GameFinished")
self._finished = True
def __init__(self):
""" Constructor of an output pin. This constructor takes a referece to
the event-manager. """
self._d_inputs = list()
self._d_event_manager = EventManager()
self._d_logger = logging.getLogger("edef.core")
class Battle:
def __init__(self):
self.attackers_list = [];
self.defenders_list = [];
self.frame = 0;
self.msg_manager = MsgManager();
self.event_manager = EventManager();
def add_msg(self,msg):
self.msg_manager.add_msg(msg);
"""
战斗中的存活对象执行自己的操作
"""
def execute_actors(self):
alive_attack_actors = list(Battle.get_all_alive(self.attackers_list));
alive_defend_actors = list(Battle.get_all_alive(self.defenders_list));
for attacker in alive_attack_actors:
attacker.run();
for defender in alive_defend_actors:
defender.run();
def add_event(self,event):
self.event_manager.get_event_list_by_key(event.event_type).append(event);
"""
让怪物进入战场
"""
def enter_battle(self,monsters,is_attackers):
if is_attackers:
self.attackers_list.extend(monsters);
else:
self.defenders_list.extend(monsters);
@staticmethod
def is_one_side_all_dead(side_list):
for one in side_list:
if one.hp > 0:
return False;
return True;
"""
检查比赛是否真的结束了
"""
def is_end(self):
if Battle.is_one_side_all_dead(self.defenders_list):
self.msg_manager.add_msg("defenders all dead");
return True;
if Battle.is_one_side_all_dead(self.attackers_list):
self.msg_manager.add_msg("attackers all dead");
return True;
return False;
@staticmethod
def get_all_alive(monster_list):
return filter(lambda attack:attack.hp > 0, monster_list);
def do_one_frame(self):
self.msg_manager.clear_one_round_msg();
# 处理帧开始的事件,例如时间注册函数(buff到期,dot的执行和到期)
self.event_manager.handle_event_list(EventManager.FRAME_EVENT_KEY);
if self.is_end():
print(self.msg_manager.send_msg());
self.msg_manager.send_msg();
return False;
#执行玩家操作
self.execute_actors();
if self.is_end():
self.msg_manager.send_msg();
self.msg_manager.send_msg();
return False;
# 处理玩家操作使得使用的技能的事件
self.event_manager.handle_event_list(EventManager.ACTION_EVENT_KEY);
# 处理技能释放出来未经过处理的伤害增益buff等
self.event_manager.handle_event_list(EventManager.FILTER_EFFECT_EVENT_KEY);
# 处理实际最后增减释放过的伤害buff等
self.event_manager.handle_event_list(EventManager.REAL_EFFECT_EVENT_KEY);
if self.is_end():
self.msg_manager.send_msg();
self.msg_manager.send_msg();
return False;
self.msg_manager.send_msg();
print("frame" + str(self.frame) + ":===================")
time.sleep(2);
return True;
def all_run(self):
while self.do_one_frame():
self.frame += 1;
class Window(Render, sf.RenderWindow):
"""This class create a window
Cette classe créé une fenêtre"""
def __init__(self, videoMode=sf.VideoMode(800, 600, 32), \
title="window", parent=0, framerateLimit=60,\
backgroundColor = sf.Color.BLACK, backgroundImage = Image()):
sf.RenderWindow.__init__(self, videoMode, title)
Render.__init__(self, parent, sf.Rectangle(sf.Vector2(),\
videoMode.size), backgroundColor, backgroundImage)
self._isStaticToView = False
self.position = (0,0)
self.framerate_limit = framerateLimit
self._framerate = framerateLimit
self._event = EventManager(self)
self.resetView()
self.clear(backgroundColor)
def update(self):
"""Update the Window. It Update all event, and update framerate.
It Draw and display also all widgets child"""
if self.canUpdate:
self._event.update()
self._framerate = 1/(self._event.elapsedTime*10**-6)
if self._event.isResize:
Render._setSize(self,self.size)
if self.event._mouseMoved:
Widget.widgetFocus = None
if self.event._mouseMoved and self.event.isMouseInRect(self.rect):
Updatable._focusIsChecked= False
Updatable.updateFocus(self)
Widget.update(self, self)
self.display()
self.clear(self.backgroundColor)
def getEventFromRootParent(self):
return self._event
def _setSize(self, size):
sf.RenderWindow.size.__set__(self, size)
Widget.size.__set__(self,size)
self._event._defaultWindowSize = size
def getPosOnScreen(self, *args):
return sf.Vector2(0,0)
def setPos(self, position, *args):
Widget.setPos(position, False)
self.position = position
def getSizeOnScreen(self, *args):
return self.size
def _setView(self,view):
sf.RenderWindow.view.__set__(self, view)
Render._setView(self,view)
size = sf.RenderWindow.size
event = property(lambda self:self._event)
framerate = property(lambda self:self._framerate)
setPosOnScreen = setPos
draw = sf.RenderWindow.draw
sizeOnScreen = sf.RenderWindow.size
class Game:
def __init__(self,arguments):
self.debug = False
self.capturing = False
self.captureFPSWait = 0
self.running = True
self.fullscreen = False
self.paused = False
self.cachedScenes = {}
self.currentScene = None
self.currentElement = None
self.currentWindow = None
self.currentWidget = None
self.values = {}
self.Loader = Loader(self)
self.setupScreen()
self.setupAudio()
self.displayTitle()
self.Loader.preload()
self.TitleManager = TitleManager(self)
self.Cursor = Cursor(self)
self.Renderer = Renderer(self)
self.AudioController = AudioController(self)
self.Inventory = Inventory(self)
self.TopicMenu = TopicMenu(self)
self.ScriptManager = ScriptManager(self)
self.Player = Player(self)
self.EventManager = EventManager(self)
self.parseArguments(arguments)
self.loadScene("blacksmith")
self.run()
def setupScreen(self,fullscreen=False):
#There seems to be no way to make this work right other than doing this:
pygame.display.set_icon(pygame.image.load(os.path.join('Resources','Icons','gameicon.png')))
if fullscreen:
self.window = pygame.display.set_mode((0,0),pygame.FULLSCREEN)
else:
self.window = pygame.display.set_mode((1024,768))
pygame.display.set_caption('Subterranean')
def displayTitle(self):
#Temporary but neat
logo = pygame.image.load(os.path.join('Resources','Graphics','Misc','logo.png'))
self.window.blit(logo,(self.window.get_rect().centerx - logo.get_width()/2,self.window.get_rect().centery - logo.get_height()/2))
pygame.display.flip()
def setupAudio(self):
pygame.mixer.init(44100)
def parseArguments(self,arguments):
avalibleArguments = {
'--fullscreen':self.toggleFullscreen,
'--nomusic':self.AudioController.disableMusic,
'--nosound':self.AudioController.disableSound,
'--debug':self.activateDebug
}
for argument in avalibleArguments.keys():
if argument in arguments:
argumentMethod = avalibleArguments.get(argument)
argumentMethod()
def pause(self):
self.paused = True
def unpause(self):
self.paused = False
def loop(self):
while self.running:
self.EventManager.checkEvents()
self.Renderer.draw()
self.Renderer.Timer.tick()
def loadScene(self,sceneName):
if sceneName in self.cachedScenes:
self.log("Got",sceneName,"from cache")
self.currentScene = self.cachedScenes.get(sceneName)
#Run the enter method if it is not the first time we do
self.currentScene.enter()
else:
self.log("Loaded",sceneName,"from file")
scene = imp.load_source(sceneName,os.path.join('Assets','Scenes',sceneName+'.py'))
sceneClass = getattr(scene,'Room');
self.currentScene = sceneClass(self)
self.cacheScene(self.currentScene,sceneName)
def loadAsset(self,assetType,assetName):
try:
module = imp.load_source(assetName,os.path.join('Assets',assetType,assetName+'.py'))
assetClass = getattr(module,assetName);
asset = assetClass(self)
return asset
except IOError:
print "Fatal error: Could not load",assetName,"from",assetType
exit()
def cacheScene(self,sceneObject,sceneName):
self.cachedScenes[sceneName] = sceneObject
def quit(self,event=None):
self.running = False
sys.exit()
def run(self):
self.loop()
def toggleFullscreen(self):
if self.fullscreen == False:
self.fullscreen = True
self.setupScreen(True)
else:
self.fullscreen = False
self.setupScreen(False)
def activateDebug(self):
self.debug = True
def log(self,*values):
if self.debug:
logValues = []
for value in values:
logValues.append(str(value)+" ")
print "".join(logValues)
def setValue(self,key,value):
self.values[key] = value
def getValue(self,key):
return self.values.get(key)
def dump(self):
if self.debug:
self.debug = False
else:
self.debug = True
def get(self,key):
return self.Loader.get(key)
class Level:
"Level Base class"
def __init__(self,score,time):
"Initialises resources and start level"
self.background=pygame.image.load("sprites/sky.jpg")
self.background.convert() #for blitting more faster
self.screen=Constants.SCREEN
self.score = score
self.display_items = pygame.sprite.Group()
self.timeclock = GameTime((0.05,0.05),time)
self.display_items.add(self.timeclock,self.score)
self.time_speed=pygame.time.Clock()
self.time=0.0
self.quit = False
self.pause = False
self.start = False
self.completed = False
self.gameover = False
self.message = None
self.polygon=Polygon(self)
self.event_manager = EventManager(self)
self.on_enter()
def get_score_object(self):
return self.score
def set_score_object(self, score_object):
self.score = score_object
def on_enter(self):
self.screen.blit(self.background, (0, 0))
pygame.display.flip()
self.start = True
self.pause = True
self.timeclock.delete_timer()
self.message = MessageBox(self,3000)
self.display_items.add(self.message)
def on_exit(self):
self.display_items.remove(self.timeclock)
del self.polygon
del self.timeclock
if self.completed == False: #end of game, so music fadeout
pygame.mixer.music.fadeout(500)
f = FadeTransition(500,Constants.FADECOLOR,"to")
del f
def run(self):
while 1:
self.time+=self.time_speed.tick(Constants.FPS)
if self.gameover and (not self.pause):
self.pause = True
self.polygon.reset()
self.timeclock.delete_timer()
self.message = MessageBox(self,4000)
self.display_items.add(self.message)
if self.completed and (not self.pause):
self.pause = True
self.polygon.reset()
self.timeclock.delete_timer()
self.message = MessageBox(self,4000)
self.display_items.add(self.message)
self.polygon.set_alive(False)
self.polygon.reset()
if self.quit:
self.on_exit()
if self.gameover == True:
h = HighScores()
h.insert_HighScores(Constants.PLAYERNAME,str(self.score.get_score()))
hlist = HighScores().get_HighScores()
if len(hlist)<5 or self.score.get_score() > hlist[4].get_points():
h.flush()
pygame.event.clear()
highscores = HighScoresMenu("sprites/sky.jpg")
highscores.run()
return False
else:
return
self.event_manager.run()
self.screen.blit(self.background, (0, 0))
self.display_items.update()
self.display_items.draw(self.screen)
self.atoms.update()
self.atoms.draw(self.screen)
if self.start == True and self.pause == False:
self.display_items.remove(self.message)
self.message = None
self.start = False
self.polygon.set_alive(False)
self.polygon.reset()
self.timeclock.add_timer()
if not self.pause:
self.polygon.draw()
pygame.display.flip()
def handle_raw_event(self, event):
if event.type in SetJoystickKeyState.ALLOWED_TYPES and \
EventManager.is_keydown(event):
self.set_event(event)
def __init__(self):
self.attackers_list = [];
self.defenders_list = [];
self.frame = 0;
self.msg_manager = MsgManager();
self.event_manager = EventManager();
class BaseOutput:
""" This is the base class for all output types. Please do not use this
output directly. Use one of L{ValueOutput}, L{StreamOutput} or
L{FrameOutput} instead.
All other types are subclassed from this one. But they provide some
additional functions or other behavior like this."""
_d_inputs = None # List of inputs connected to this output
_d_event_manager = None
_d_logger = None
def __init__(self):
""" Constructor of an output pin. This constructor takes a referece to
the event-manager. """
self._d_inputs = list()
self._d_event_manager = EventManager()
self._d_logger = logging.getLogger("edef.core")
def __call__(self, value):
""" This method will be used to set the value of this output. Simply
call o_out(value) to set the value """
self.set_value(value)
def __rshift__(self, inp):
""" This operatior is used to add this putput as an event-source to
the other input. The usage is ModA.o_out >> ModB.i_in
inp should be a callable."""
self.add_input(inp)
def __iadd__(self, inp):
""" Does the same like __rshift__() but can be used otherwise:
ModA.o_out += ModB.i_in """
self.add_input(inp)
return self
def __isub__(self, inp):
""" Removes the given input from this output.
Usage: ModA.o_out -= ModB.i_in """
self.rem_input(inp)
return self
def __contains__(self, inp):
""" This method should return true if the give input is connected to
this output.
Usage: if ModB.i_in in ModB.o_out: pass
inp should be a callable. """
return self.has_input(inp)
def set_value(self, value):
""" This method will be called by the __call__ special method to set
the value of the output. Please use the __call__ method instead of
calling this method directly. Also the __call__method will provide
some eye-candy for you. Simple do C{output(new_value)} to set the
new value to the output. """
self._d_logger.debug("Set output %s => %s"%(getattr(self,"__name__",self),value))
for inp in self._d_inputs:
self._d_event_manager.add_event(inp, value)
def add_input(self, callback):
""" This method will add an input to the output. This input will be
called if the value of the output changes. Please use the
overwritten operator C{+=} or C{>>} to add new inputs to an
output instead of calling this method direct. Example:
C{output += new_input} or C{output >> another_input}. The imput
should be a I{callable} that takes only one argument, may be a
function or a method of a class. """
if not callback in self._d_inputs:
self._d_logger.debug("Adding input %s (%s) to list"%(callback, id(callback)))
self._d_inputs.append(callback)
def rem_input(self, callback):
""" This method will remove the given input from this output. But
PLEASE do not call this method direct! Use the overwritten
operator C{-=} instead.
Example: C{output -= any_input_added_first}
If the given input was not added to the output first, this method
will raise an exception. """
self._d_logger.debug("Remove input %s (%s) from list"%(callback, id(callback)))
del self._d_inputs[self._d_inputs.index(callback)]
def has_input(self, callback):
""" This method will return True if the given input was added to this
output and False otherwise. Please do not use this method direct.
Use the overwritten operator C{in} instead:
C{if any_input in output: do_somethin()} """
return callback in self._d_inputs
def handle_raw_event(self, event):
if EventManager.is_keyboard_event(event.type) and \
event not in SettingsManager.EVENTS_ESCAPE and \
event not in SettingsManager.EVENTS_RETURN and \
event not in SettingsManager.EVENTS_ACTION:
self.handle_return()
class AutoFieldManager( QObject ):
""" Class in charge of the AutoFields administration.
Main class of the plugin, as AutoFields can only be created, removed,
and overwritten from it.
"""
autoFieldCreated = pyqtSignal( str )
autoFieldRemoved = pyqtSignal( str )
autoFieldEnabled = pyqtSignal( str )
autoFieldDisabled = pyqtSignal( str )
def __init__( self, messageManager, iface, settingsPrefix="/AutoFields", organizationName=None, applicationName=None ):
QObject.__init__( self )
self.msg = messageManager
self.settings = QSettings( organizationName, applicationName ) if organizationName and applicationName else QSettings()
self.dictAutoFields = OrderedDict()
self.settingsPrefix = settingsPrefix
self.eventManager = EventManager( self.msg, iface, settingsPrefix )
self.eventManager.layersAddedCheckIfAutoFields.connect( self.checkAndEnableAutoFieldsForLayers )
self.eventManager.autoFieldsReadyToBeDisabled.connect( self.disableAutoFields )
self.eventManager.attributesAddedCheckIfAutoFields.connect( self.checkAndEnableAutoFieldsForLayerFields )
self.eventManager.attributesDeletedCheckIfAutoFields.connect( self.checkAndDisableAutoFieldsForLayer )
self.eventManager.setAFM( self )
self.fieldCalculator = FieldCalculator( self.msg, iface )
def createAutoField( self, layer, fieldName, expression, layer2="", field2="", calculateOnExisting=True ):
""" Add AutoField properties to both QSettings and dictAutoFields """
if not layer or not type(layer) is QgsVectorLayer:
self.msg.show(
QApplication.translate( "AutoFieldManager", "[Error] A 'layer' parameter of type QgsVectorLayer must be given." ),
'warning' )
return False
if not layer.hasGeometryType():
self.msg.show( QApplication.translate( "AutoFieldManager",
"[Error] The layer has an unknown geometry, but AutoFieds does not support alphanumeric tables." ),
'warning' )
return False
capabilities = layer.dataProvider().capabilities()
if not ( capabilities & QgsVectorDataProvider.ChangeAttributeValues ):
self.msg.show( QApplication.translate( "AutoFieldManager",
"[Error] The vector layer provider does not allow to change attribute values.\nYou would need to export the data to another format for adding AutoFields." ),
'warning' )
return False
if not ( capabilities & QgsVectorDataProvider.AddFeatures ):
self.msg.show( "[Warning] The vector layer provider does not allow to add features.", 'warning', True )
if not ( capabilities & QgsVectorDataProvider.ChangeGeometries ):
self.msg.show( "[Warning] The vector layer provider does not allow to change geometries.", 'warning', True )
if layer.isReadOnly():
self.msg.show( QApplication.translate( "AutoFieldManager",
"[Error] The vector layer is read only, so no AutoFields can be created on it." ),
'warning' )
return False
if not fieldName or type(fieldName) != unicode:
self.msg.show( QApplication.translate( "AutoFieldManager",
"[Error] A 'fieldName' parameter of type unicode must be given." ),
'warning' )
return False
if not fieldName.strip():
self.msg.show( QApplication.translate( "AutoFieldManager",
"[Error] 'fieldName' variable has not a valid value." ), 'warning' )
return False
if layer.fieldNameIndex( fieldName ) == -1:
self.msg.show( QApplication.translate( "AutoFieldManager",
"[Error] Layer " ) + layer.name() + \
QApplication.translate( "AutoFieldManager", " has no field called " ) + \
fieldName + QApplication.translate( "AutoFieldManager",
". You need to create it beforehand." ), 'warning' )
return False
#if layer.fields[layer.fieldNameIndex( field )].isEditable():
# print "Error: Field",field,"is not editable! It won't be possible to write in it."
# return False
if not expression or type(expression) != unicode:
self.msg.show( QApplication.translate( "AutoFieldManager",
"[Error] An 'expression' parameter of type unicode must be given." ),
'warning' )
return False
elif not expression.strip():
self.msg.show( QApplication.translate( "AutoFieldManager",
"[Error] 'expression' variable has not a valid value." ),
'warning' )
return False
autoFieldId = self.buildAutoFieldId( layer, fieldName )
self.msg.show( "Create AutoField with Id: " + autoFieldId, 'info', True )
if self.isFieldAnAutoField( layer, fieldName ):
self.msg.show( QApplication.translate( "AutoFieldManager",
"[Error] This field is already an AutoField. You cannot create another AutoField on the same field, but you can use overwriteAutoField(), which supports the same parameters." ),
'warning' )
return False
if calculateOnExisting:
self.fieldCalculator.calculate( layer, fieldName, expression )
# Create AutoField in dictionary
if not self.dictAutoFields:
order = 1
else:
order = max( self.dictAutoFields.iteritems(),
key=lambda d: d[1]['order'] )[1]['order'] + 1
self.dictAutoFields[autoFieldId] = { 'layer':layer.publicSource(),
'field':fieldName, 'expression':expression, 'layer2':layer2,
'field2':field2, 'layerId': layer.id(), 'order': order }
self.dictAutoFields[autoFieldId]['enabled'] = self.validateAutoField( self.dictAutoFields[autoFieldId] )
# Create AutoField in QSettings and set corresponding events
self.writeAutoField( autoFieldId, self.dictAutoFields[autoFieldId] )
self.eventManager.setEventsForAutoField( autoFieldId, self.dictAutoFields[autoFieldId] )
self.msg.show( QApplication.translate( "AutoFieldManager", "The AutoField (" ) + \
layer.name() + "." + fieldName + ": " + expression + \
QApplication.translate( "AutoFieldManager", ") was created properly!" ), 'info' )
self.autoFieldCreated.emit( autoFieldId )
return autoFieldId
def overwriteAutoField( self, layer, fieldName, expression, layer2="", field2="", calculateOnExisting=True ):
""" Logic to overwrite an existing AutoField in both QSettings and dictAutoFields """
autoFieldId = self.buildAutoFieldId( layer, fieldName )
if autoFieldId in self.dictAutoFields:
self.removeAutoField( autoFieldId )
return self.createAutoField( layer, fieldName, expression, layer2, field2, calculateOnExisting )
return False
def removeAutoField( self, autoFieldId ):
""" Get rid of AutoField from both QSettings and dictAutoFields """
if not autoFieldId in self.dictAutoFields:
self.msg.show( QApplication.translate( "AutoFieldManager",
"[Warning] AutoField with Id " ) + autoFieldId + \
QApplication.translate( "AutoFieldManager",
" was not found, so it couldn't be removed." ), 'warning' )
return False
self.settings.beginGroup( self.settingsPrefix + "/data" )
self.settings.remove( autoFieldId )
self.settings.endGroup()
self.settings.sync()
# Disconnect SIGNAL/SLOTS for this AutoField
if 'layerId' in self.dictAutoFields[autoFieldId]:
if self.dictAutoFields[autoFieldId]['enabled']:
layer = QgsMapLayerRegistry.instance().mapLayer( self.dictAutoFields[autoFieldId]['layerId'] )
self.eventManager.removeEventsForAutoField( autoFieldId, layer, self.dictAutoFields[autoFieldId]['expression'] )
del self.dictAutoFields[autoFieldId]
self.autoFieldRemoved.emit( autoFieldId )
def readAutoFields( self ):
""" Read AutoFields from QSettings, overwriting dictAutoFields """
self.dictAutoFields = OrderedDict()
dictTempAutoFields = {} # We will sort it when everything is read
self.settings.beginGroup( self.settingsPrefix + "/data" )
autoFieldsIds = self.settings.childGroups()
self.settings.endGroup()
for autoFieldId in autoFieldsIds:
dictTmpProperties = {}
self.settings.beginGroup( self.settingsPrefix + "/data/" + autoFieldId )
dictTmpProperties['layer'] = self.settings.value( "layer", u"", type=unicode )
dictTmpProperties['field'] = self.settings.value( "field", u"", type=unicode )
dictTmpProperties['expression'] = self.settings.value( "expression", u"", type=unicode )
dictTmpProperties['layer2'] = self.settings.value( "layer2", "", type=str )
dictTmpProperties['field2'] = self.settings.value( "field2", "", type=str )
dictTmpProperties['order'] = self.settings.value( "order", 0, type=int )
self.settings.endGroup()
# Check whether the AutoField must be enabled or not
layer = self.getLayer( dictTmpProperties['layer'] )
if layer:
dictTmpProperties['layerId'] = layer.id()
dictTmpProperties['enabled'] = self.validateAutoField( dictTmpProperties )
dictTempAutoFields[autoFieldId] = dictTmpProperties
# We need to set events in order of creation, so that the use case of
# AutoFields depending on other AutoFields becomes predictable
self.dictAutoFields = OrderedDict( sorted( dictTempAutoFields.items(),
key=lambda d: d[1]['order'] ) )
for autoFieldId in self.dictAutoFields.keys():
self.eventManager.setEventsForAutoField( autoFieldId, self.dictAutoFields[autoFieldId] )
def writeAutoField( self, autoFieldId, dictProperties ):
""" Write an AutoField from dictAutoFields to QSettings """
self.settings.beginGroup( self.settingsPrefix + "/data/" + autoFieldId )
self.settings.setValue( "layer", dictProperties['layer'] )
self.settings.setValue( "field", dictProperties['field'] )
self.settings.setValue( "expression", dictProperties['expression'] )
self.settings.setValue( "layer2", dictProperties['layer2'] )
self.settings.setValue( "field2", dictProperties['field2'] )
self.settings.setValue( "enabled", dictProperties['enabled'] )
self.settings.setValue( "order", dictProperties['order'] )
self.settings.endGroup()
self.settings.sync()
def listAutoFields( self ):
return self.dictAutoFields
def validateAutoField( self, dictProperties ):
""" Check whether this AutoField is ready or if there is something missing """
if not 'layerId' in dictProperties:
self.msg.show( "[Warning] A layer that is part of an AutoField was not found in QGIS registry.", 'warning', True )
return False
layer = QgsMapLayerRegistry.instance().mapLayer( dictProperties['layerId'] )
if not layer:
self.msg.show( "[Warning] Layer id " + dictProperties['layerId'] + " was not found in QGIS registry.", 'warning', True )
return False
if layer.fieldNameIndex( dictProperties['field'] ) == -1:
self.msg.show( "[Warning] Field was not found in layer "+layer.name()+".", 'warning', True )
return False
# TODO add checks for layer2 and field2
return True
def normalizeSource( self, source ):
""" Avoid issues with spaces and other weird characters for AutoField ids """
pieces = source.split(" ")
newPieces = [ piece for piece in pieces if not (piece.startswith("type=") or piece.startswith("srid=")) ]
source = "".join( newPieces )
return source.replace("\"","").replace("'","").replace("/","|").replace("\\","|")
def buildAutoFieldId( self, layer, fieldName ):
""" Centralizes the definition of AutoField identifiers """
if not layer or not type(layer) is QgsVectorLayer:
self.msg.show( "[Error] A 'layer' parameter of type QgsVectorLayer must be given.", 'warning', True )
return None
if not fieldName or type(fieldName) != unicode:
self.msg.show( "[Error] A 'fieldName' parameter of type unicode must be given.", 'warning', True )
return None
return self.normalizeSource( layer.publicSource() ) + '@@' + fieldName
def isFieldAnAutoField( self, layer, fieldName ):
""" Returns whether a layer field is an AutoField or not """
autoFieldId = self.buildAutoFieldId( layer, fieldName )
return autoFieldId in self.dictAutoFields
def getFieldExpression( self, layer, fieldName ):
""" If the given field is an AutoField, it returns its expression """
autoFieldId = self.buildAutoFieldId( layer, fieldName )
if autoFieldId in self.dictAutoFields:
return self.dictAutoFields[autoFieldId]['expression']
return ''
def getLayer( self, autoFieldLayerSource ):
""" Iterate layers and get one, comparing sources """
for tmpLayer in QgsMapLayerRegistry.instance().mapLayers().values():
if self.compareLayersPublicSources( tmpLayer.publicSource(), autoFieldLayerSource ):
return tmpLayer
return None
def compareLayersPublicSources( self, source1, source2 ):
""" Normalize sources before comparing them.
On Windows, adding a layer from the Add Layer button and from
QGIS Browser give different directory separators (/ vs \\), which
hampers comparison.
"""
return self.normalizeSource( source1 ) == self.normalizeSource( source2 )
def checkAndEnableAutoFieldsForLayers( self, mapLayers ):
""" After a notification on layers being added, check and enable AutoFields if needed.
1. Check if added layers are part of currently disabled AutoFields
2. Enable it in Dict
3. Enable it in QSettings
4. Connect its SIGNALS / SLOTS
"""
for layer in mapLayers:
for autoFieldId in self.dictAutoFields:
if self.dictAutoFields[autoFieldId]['enabled'] == False: # Don't check enabled AutoFields
if self.compareLayersPublicSources( layer.publicSource(), self.dictAutoFields[autoFieldId]['layer'] ): #1
self.dictAutoFields[autoFieldId]['layerId'] = layer.id()
if self.validateAutoField( self.dictAutoFields[autoFieldId] ):
self.dictAutoFields[autoFieldId]['enabled'] = True #2
self.writeAutoField( autoFieldId, self.dictAutoFields[autoFieldId] ) #3
self.eventManager.setEventsForAutoField( autoFieldId, self.dictAutoFields[autoFieldId] )#4
self.autoFieldEnabled.emit( autoFieldId )
def disableAutoFields( self, layerId ):
""" After a notification on layers being removed, disable all their AutoFields """
#for layerId in layerIds:
for autoFieldId in self.dictAutoFields:
if 'layerId' in self.dictAutoFields[autoFieldId]:
if layerId == self.dictAutoFields[autoFieldId]['layerId']:
self.dictAutoFields[autoFieldId]['enabled'] = False
self.writeAutoField( autoFieldId, self.dictAutoFields[autoFieldId] )
del self.dictAutoFields[autoFieldId]['layerId'] # layerId is meaningless now
self.autoFieldDisabled.emit( autoFieldId )
def checkAndEnableAutoFieldsForLayerFields( self, layerId, fields ):
""" After a notification on fields being added, check and enable AutoFields if needed.
1. Check if added fields are part of currently disabled AutoFields
2. Enable it in Dict
3. Enable it in QSettings
4. Connect its SIGNALS / SLOTS
"""
for autoFieldId in self.dictAutoFields:
if self.dictAutoFields[autoFieldId]['enabled'] == False: # Don't check enabled AutoFields
if 'layerId' in self.dictAutoFields[autoFieldId]:
if layerId == self.dictAutoFields[autoFieldId]['layerId']: #1
for field in fields:
if field.name() == self.dictAutoFields[autoFieldId]['field']:
if self.validateAutoField( self.dictAutoFields[autoFieldId] ):
self.dictAutoFields[autoFieldId]['enabled'] = True #2
self.writeAutoField( autoFieldId, self.dictAutoFields[autoFieldId] ) #3
self.eventManager.setEventsForAutoField( autoFieldId, self.dictAutoFields[autoFieldId] )#4
self.autoFieldEnabled.emit( autoFieldId )
def checkAndDisableAutoFieldsForLayer( self, layerId ):
""" After a notification on fields being removed, check and disable AutoFields if needed.
1. Check if any field is missing in AutoFields set for this layer.
2. Disable it in Dict
3. Disable it in QSettings
4. Disconnect its SIGNAL / SLOTS
"""
for autoFieldId in self.dictAutoFields:
if self.dictAutoFields[autoFieldId]['enabled'] == True: # Don't check disabled AutoFields
if layerId == self.dictAutoFields[autoFieldId]['layerId']:
layer = QgsMapLayerRegistry.instance().mapLayer( layerId )
if layer.fieldNameIndex( self.dictAutoFields[autoFieldId]['field'] ) == -1: #1
self.dictAutoFields[autoFieldId]['enabled'] = False #2
self.writeAutoField( autoFieldId, self.dictAutoFields[autoFieldId] ) #3
self.eventManager.removeEventsForAutoField( autoFieldId, layer, self.dictAutoFields[autoFieldId]['expression'] ) #4
self.autoFieldDisabled.emit( autoFieldId )
def disconnectAll( self ):
""" Terminates all SIGNAL/SLOT connections created by this class """
self.eventManager.layersAddedCheckIfAutoFields.disconnect( self.checkAndEnableAutoFieldsForLayers )
self.eventManager.autoFieldsReadyToBeDisabled.disconnect( self.disableAutoFields )
self.eventManager.attributesAddedCheckIfAutoFields.disconnect( self.checkAndEnableAutoFieldsForLayerFields )
self.eventManager.attributesDeletedCheckIfAutoFields.disconnect( self.checkAndDisableAutoFieldsForLayer )
# Disconnect all SIGNAL/SLOT connections created by eventManager
self.eventManager.disconnectAll()
# Disconnect all events for each enabled AutoField
for autoFieldId in self.dictAutoFields:
if self.dictAutoFields[autoFieldId]['enabled'] == True: # Don't check disabled AutoFields
layerId = self.dictAutoFields[autoFieldId]['layerId']
layer = QgsMapLayerRegistry.instance().mapLayer( layerId )
self.eventManager.removeEventsForAutoField( autoFieldId, layer, self.dictAutoFields[autoFieldId]['expression'] )