def __init__(self):
Gtk.VBox.__init__(self)
self.view_type = ViewType.NULL
self.forward_view = ViewType.NULL
self.client = Client()
self.client.connect("profile-loaded", self.__profile_loaded_cb)
self.client.connect("loading", self.__start_load)
self.client.connect("loaded", self.__end_load)
self.client.connect("thread-loaded", self.__thread_loaded_cb)
self.client.connect("error", self.__error_cb)
self.client.connect("login", self.__login_cb)
self.client.connect("logged", self.__logged_cb)
self.client.connect("mail-sent", self.__mail_sent_cb)
self.view_box = Gtk.VBox()
self.pack_start(self.view_box, True, True, 0)
self.loading_view = LoadingView()
self.mails_listbox = MailsListBox()
self.mails_listbox.connect("label-selected", self.__label_selected_cb)
self.mails_listbox.connect("thread-selected",
self.__thread_selected_cb)
self.mails_listbox.connect("favorite-clicked",
self.__favorite_clicked_cb)
self.mail_viewer = MailViewer()
self.mail_viewer.connect("send", self.__send_cb)
self.redactor = Redactor()
self.redactor.connect("send", self.__send_cb)
self.login_screen = LoginScreen()
self.login_screen.connect("send-code", self.__send_code_cb)
self.error_viewer = ErrorViewer()
self.viewers = {
ViewType.LOADING: self.loading_view,
ViewType.MAILS_LIST: self.mails_listbox,
ViewType.MAIL: self.mail_viewer,
ViewType.REDACT: self.redactor,
ViewType.LOGIN_SCREEN: self.login_screen,
ViewType.ERROR: self.error_viewer,
}
self.connect("realize", self.__realize_cb)
self.show_all()
def login_screen(self, instance):
signup_screen = APP.root.current_screen
from login_screen import LoginScreen
self.login_screen = LoginScreen()
APP.root.add_widget(self.login_screen)
APP.root.current = "login_screen"
APP.root.remove_widget(signup_screen)
def build(self):
global tick_evnt
tick_evnt = Clock.schedule_interval(networking.tick, 1.0 / TPS)
sm.add_widget(LoginScreen(id='login', name='login_screen'))
sm.add_widget(ChatScreen(id='chat_screen', name='chat_screen'))
sm.add_widget(
ServerCrashScreen(id='server_crash', name='server_crash_screen'))
return sm
def log_out(self, instance):
with open("refresh_token.txt", "w") as f:
f.write("")
home_screen = APP.root.current_screen
from login_screen import LoginScreen
self.login_screen = LoginScreen()
APP.root.add_widget(self.login_screen)
APP.root.current = "login_screen"
APP.root.remove_widget(home_screen)
def build(self):
self.title = "Advanced Civilization"
self.screen_manager = ScreenManager(pos=(0, 0),
pos_hint={
'x': 0,
'y': 0
},
size_hint=(1, 1))
self.login_page = LoginScreen()
screen = Screen(name="Login")
screen.add_widget(self.login_page)
self.screen_manager.add_widget(screen)
self.login_page.bind(connected=self.handle_connect)
self.nation_selection_page = NationSelectionScreen()
screen = Screen(name="NationSelection")
screen.add_widget(self.nation_selection_page)
self.screen_manager.add_widget(screen)
self.nation_selection_page.bind(finished=self.handle_finish)
self.nation_selection_page.player_name = self.login_page.name
self.nation_selection_page.server_url = self.login_page.url
self.login_page.bind(
name=self.nation_selection_page.setter('player_name'))
self.login_page.bind(
url=self.nation_selection_page.setter('server_url'))
self.nation_selection_page.bind(nation=self.setter('active_nation'))
self.civ_map_page = CivMapScreen(pos_hint={
'x': 0,
'y': 0
},
size_hint=(1, 1))
screen = Screen(name="CivMap",
pos_hint={
'x': 0,
'y': 0
},
size_hint=(1, 1))
screen.add_widget(self.civ_map_page)
self.screen_manager.add_widget(screen)
self.bind(active_nation=self.civ_map_page.st.setter('nation'))
return self.screen_manager
def log_out(self, instance):
with open("resources/refresh_token.txt", "w") as f:
f.write("")
if not APP.root.has_screen("login_screen"):
from login_screen import LoginScreen
self.login_screen = LoginScreen()
APP.root.add_widget(self.login_screen)
APP.root.current = "login_screen"
APP.root.remove_widget(APP.root.get_screen("navigation_screen"))
def on_enter(self):
from home_screen import HomeScreen
from login_screen import LoginScreen
home_screen = HomeScreen()
login_screen = LoginScreen()
self.app.root.add_widget(home_screen)
self.app.root.add_widget(login_screen)
try:
with open("refresh_token.txt", "r") as f:
refresh_token = f.read()
self.my_firebase.exchange_refresh_token(refresh_token)
Clock.schedule_once(lambda dt: self.load_home(), 1)
except:
Clock.schedule_once(lambda dt: self.load_login(), 1)
def on_enter(self):
pantalla_navegacion = NavigationScreen()
pantalla_inicio = LoginScreen()
self.app.root.add_widget(pantalla_navegacion)
self.app.root.add_widget(pantalla_inicio)
try:
with open("info_paciente.txt", "r") as f:
lineas_texto = f.readlines()
nombre = lineas_texto[0]
apellido = lineas_texto[1]
num_dni = lineas_texto[2]
centro = lineas_texto[3]
f.close()
self.mi_conexion.verificar_mi_conexion(nombre, apellido,
num_dni, centro)
Clock.schedule_once(lambda dt: self.cargar_navegacion(), 2)
except:
Clock.schedule_once(lambda dt: self.cargar_login(), 2)
def build(self):
return LoginScreen()
def build(self):
# self.theme_cls.primary_palette = "Orange"
return LoginScreen()
from kivy.app import App
from kivy.uix.screenmanager import *
from welcome_screen import WelcomeScreen
from login_screen import LoginScreen
sm = ScreenManager(transition=WipeTransition())
sm.add_widget(WelcomeScreen(name='welcome'))
sm.add_widget(LoginScreen(name='login'))
class ScreensApp(App):
def build(self):
return sm
def on_pause(self):
return True
def on_resume(self):
pass
if __name__ == '__main__':
ScreensApp().run()
from PyQt5.QtWidgets import QApplication, QWidget, QPushButton, QVBoxLayout
from login_screen import LoginScreen
app = QApplication([])
app.setStyle('Fusion')
login_screen = LoginScreen()
app.exec_()
EAST = "1"
NORTH = "4"
pygame.init()
screen = pygame.display.set_mode( [WIDTH, HEIGHT] )
pygame.display.set_caption("Bomberman Game")
# Used to manage how fast the screen updates
clock = pygame.time.Clock()
done = False
world = PygameWorld(screen)
login_screen = LoginScreen(screen, width = WIDTH, height = HEIGHT)
game_select_screen = GameSelect(screen, width = WIDTH, height = HEIGHT)
game_lobby_screen = None
owner = None
# -------- Main Program Loop -----------
while not done:
for event in pygame.event.get(): # User did something
if event.type == pygame.QUIT: # If user clicked close
done = True # Flag that we are done so we exit this loop
elif state.in_game == True and event.type == pygame.KEYUP:
if not world.players[world.me].walking:
class GmailCanvas(Gtk.VBox):
__gsignals__ = {
"update-buttons":
(GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE, [GObject.TYPE_PYOBJECT]),
"history-changed": (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE, []),
}
def __init__(self):
Gtk.VBox.__init__(self)
self.view_type = ViewType.NULL
self.forward_view = ViewType.NULL
self.client = Client()
self.client.connect("profile-loaded", self.__profile_loaded_cb)
self.client.connect("loading", self.__start_load)
self.client.connect("loaded", self.__end_load)
self.client.connect("thread-loaded", self.__thread_loaded_cb)
self.client.connect("error", self.__error_cb)
self.client.connect("login", self.__login_cb)
self.client.connect("logged", self.__logged_cb)
self.client.connect("mail-sent", self.__mail_sent_cb)
self.view_box = Gtk.VBox()
self.pack_start(self.view_box, True, True, 0)
self.loading_view = LoadingView()
self.mails_listbox = MailsListBox()
self.mails_listbox.connect("label-selected", self.__label_selected_cb)
self.mails_listbox.connect("thread-selected",
self.__thread_selected_cb)
self.mails_listbox.connect("favorite-clicked",
self.__favorite_clicked_cb)
self.mail_viewer = MailViewer()
self.mail_viewer.connect("send", self.__send_cb)
self.redactor = Redactor()
self.redactor.connect("send", self.__send_cb)
self.login_screen = LoginScreen()
self.login_screen.connect("send-code", self.__send_code_cb)
self.error_viewer = ErrorViewer()
self.viewers = {
ViewType.LOADING: self.loading_view,
ViewType.MAILS_LIST: self.mails_listbox,
ViewType.MAIL: self.mail_viewer,
ViewType.REDACT: self.redactor,
ViewType.LOGIN_SCREEN: self.login_screen,
ViewType.ERROR: self.error_viewer,
}
self.connect("realize", self.__realize_cb)
self.show_all()
def __realize_cb(self, widget):
# thread = threading.Thread(target=self.client.start)
# thread.start()
self.client.start()
def __profile_loaded_cb(self, client, profile):
self.loading_view.set_profile(profile)
self.mail_viewer.set_profile(profile)
self.redactor.set_profile(profile)
def __start_load(self, client):
self.set_view(ViewType.LOADING)
def __end_load(self, client, threads, labels):
self.loading_view.stop()
self.set_view(ViewType.MAILS_LIST)
GLib.idle_add(self.mails_listbox.set_threads, threads)
GLib.idle_add(self.mails_listbox.set_labels, labels)
def __thread_loaded_cb(self, client, thread):
self.mail_viewer.set_thread(thread)
self.set_view(ViewType.MAIL)
def __error_cb(self, client):
self.set_view(ViewType.ERROR)
def __login_cb(self, client, url):
self.set_view(ViewType.LOGIN_SCREEN)
self.login_screen.set_url(url)
def __logged_cb(self, client):
# thread = threading.Thread(target=self.client.load)
# thread.start()
self.client.load()
def __mail_sent_cb(self, client, mail):
self.client.request_thread(mail["threadId"])
def __label_selected_cb(self, view, labelid):
print "LABEL SELECTED", labelid
def __thread_selected_cb(self, view, threadid):
# thread = threading.Thread(target=self.client.request_thread, args=(threadid,))
# thread.start()
self.client.request_thread(threadid)
def __favorite_clicked_cb(self, view, threadid, starred):
self.client.set_star(threadid, starred)
def __send_cb(self, widget, mail):
# thread = threading.Thread(target=self.client.send, args=(mail,))
# thread.start()
self.client.send(mail)
def __send_code_cb(self, screen, code):
self.client.set_code(code)
def __update_buttons(self):
invalids = [ViewType.NULL, ViewType.LOADING]
if self.view_type in invalids:
self.forward_view = ViewType.NULL
else:
self.forward_view
data = {
"back": self.view_type in [ViewType.MAIL, ViewType.REDACT],
"forward": self.forward_view
not in [ViewType.NULL, ViewType.ERROR],
"redact": self.view_type == ViewType.MAILS_LIST
}
self.emit("update-buttons", data)
def show_redactor(self):
self.set_view(ViewType.REDACT, False)
self.forward_view = ViewType.NULL
self.__update_buttons()
def set_view(self, view_type, emit=True):
if view_type == self.view_type:
return
self.view_type = view_type
if self.view_box.get_children() != []:
self.view_box.remove(self.view_box.get_children()[0])
child = None
if self.view_type in self.viewers.keys():
child = self.viewers[self.view_type]
if self.view_type == ViewType.LOADING:
self.loading_view.start()
else:
self.loading_view.stop()
if child is not None:
self.view_box.pack_start(child, True, True, 0)
if emit:
self.__update_buttons()
self.show_all()
def go_back(self):
current = self.view_type
self.set_view(ViewType.MAILS_LIST, False)
self.forward_view = current
self.__update_buttons()
def go_forward(self):
self.set_view(self.forward_view)
self.forward_view = ViewType.NULL
self.__update_buttons()
class AdvCivClientApp(App):
player = ''
screen_manager = ObjectProperty(None)
login_page = None
nation_selection_page = None
civ_map_page = None
active_nation = StringProperty('')
def update_buttons(self):
pass
def show_stuff(self, root=None):
if not root:
root = self.root
def build(self):
self.title = "Advanced Civilization"
self.screen_manager = ScreenManager(pos=(0, 0),
pos_hint={
'x': 0,
'y': 0
},
size_hint=(1, 1))
self.login_page = LoginScreen()
screen = Screen(name="Login")
screen.add_widget(self.login_page)
self.screen_manager.add_widget(screen)
self.login_page.bind(connected=self.handle_connect)
self.nation_selection_page = NationSelectionScreen()
screen = Screen(name="NationSelection")
screen.add_widget(self.nation_selection_page)
self.screen_manager.add_widget(screen)
self.nation_selection_page.bind(finished=self.handle_finish)
self.nation_selection_page.player_name = self.login_page.name
self.nation_selection_page.server_url = self.login_page.url
self.login_page.bind(
name=self.nation_selection_page.setter('player_name'))
self.login_page.bind(
url=self.nation_selection_page.setter('server_url'))
self.nation_selection_page.bind(nation=self.setter('active_nation'))
self.civ_map_page = CivMapScreen(pos_hint={
'x': 0,
'y': 0
},
size_hint=(1, 1))
screen = Screen(name="CivMap",
pos_hint={
'x': 0,
'y': 0
},
size_hint=(1, 1))
screen.add_widget(self.civ_map_page)
self.screen_manager.add_widget(screen)
self.bind(active_nation=self.civ_map_page.st.setter('nation'))
return self.screen_manager
def handle_connect(self, instance, connected):
if connected:
print('Login screen connected successfully')
print(self.nation_selection_page.player_name)
print(self.nation_selection_page.server_url)
self.nation_selection_page.request_update()
self.screen_manager.current = "NationSelection"
def handle_finish(self, instance, finished):
if finished:
self.active_nation = self.nation_selection_page.nation
print(
f"Nation Selection finished successfully (I'm {self.active_nation})"
)
self.screen_manager.current = "CivMap"
snap_map = SnapMap(self.civ_map_page.ms)
fl = self.civ_map_page.fl
for n in self.nation_selection_page.get_selected_nations():
self.civ_map_page.nations.append(Nation(n, fl, snap_map))
for n in self.civ_map_page.nations:
n.show_or_hide_stock(self.active_nation)
self.update_board(0)
Clock.schedule_interval(self.update_board, 1)
def update_board(self, dt):
n = [
n for n in self.civ_map_page.nations
if n.name == self.active_nation
][0]
url = self.login_page.url
if dt == 0:
body = None
else:
body = json.dumps(n.get_dict())
req = UrlRequest(url=f"{url}/civ_board",
on_success=self.handle_update,
on_failure=self.show_error_msg,
on_error=self.show_error_msg,
req_body=body,
req_headers={'Content-Type': 'application/json'},
timeout=None,
decode=True,
debug=False,
file_path=None,
ca_file=None,
verify=False)
def handle_update(self, req, res):
res_list = json.loads(res)
for n in self.civ_map_page.nations:
if n.name not in res_list:
print(f"{n.name} not listed on server: {res_list.keys()}")
return
if n.name == self.active_nation:
if res_list[n.name] == n.get_dict():
pass
else:
print(f"Client {n.name} doesn't match server!")
if res_list[n.name] == {}:
continue
else:
for i in range(len(res_list[n.name]['tokens'])):
if n.name == self.active_nation:
if res_list[n.name]['tokens'][i] == 'HiddenUnitStock':
res_list[n.name]['tokens'][i] = 'UnitStock'
if res_list[n.name]['tokens'][i] == 'HiddenCityStock':
res_list[n.name]['tokens'][i] = 'CityStock'
if res_list[n.name]['tokens'][i] == 'HiddenBoatStock':
res_list[n.name]['tokens'][i] = 'BoatStock'
else:
if res_list[n.name]['tokens'][i] == 'UnitStock':
res_list[n.name]['tokens'][i] = 'HiddenUnitStock'
if res_list[n.name]['tokens'][i] == 'CityStock':
res_list[n.name]['tokens'][i] = 'HiddenCityStock'
if res_list[n.name]['tokens'][i] == 'BoatStock':
res_list[n.name]['tokens'][i] = 'HiddenBoatStock'
n.update(res_list[n.name])
@staticmethod
def show_error_msg(request, error):
print('Error')
print(error)
def load_login_screen(self):
login_screen = LoginScreen()
APP.root.add_widget(login_screen)
APP.root.current = "login_screen"
self.remove_screen()
def load_login_screen(self):
login_screen = LoginScreen()
self.app.root.add_widget(login_screen)
self.app.root.current = "login_screen"
