def __init__(self):
self.gameover = False
self.screen = pygame.display.set_mode(constants.SIZE)
self.phase = 0
self.phases = [MainMenu, Play, GameOver]
self.inter = Interactor()
self.cur_phase = MainMenu(self.inter.get_top_5())
def initialize(standard_screen):
globals.STDSCR = standard_screen
globals.MAIN = MainMenu()
globals.INTERFACES.append(globals.MAIN)
globals.MAP = GameMap()
globals.INTERFACES.append(globals.MAP)
globals.INVENTORY = Inventory()
globals.INTERFACES.append(globals.INVENTORY)
globals.PAUSE = PauseMenu()
globals.INTERFACES.append(globals.PAUSE)
globals.STORY = StoryScreen()
globals.INTERFACES.append(globals.STORY)
globals.CONTROLS_MAP = Controls(Controls.Type.game_map)
globals.INTERFACES.append(globals.CONTROLS_MAP)
globals.CONTROLS_INVENTORY = Controls(Controls.Type.inventory)
globals.INTERFACES.append(globals.CONTROLS_INVENTORY)
globals.CREDITS = Credits()
globals.INTERFACES.append(globals.CREDITS)
globals.NEW_GAME = NewGameDialog()
globals.INTERFACES.append(globals.NEW_GAME)
globals.QUIT_GAME = EndGameDialog()
globals.INTERFACES.append(globals.QUIT_GAME)
globals.SAVE_GAME = SaveGameDialog()
globals.INTERFACES.append(globals.SAVE_GAME)
globals.MONSTER = MonsterDialog()
globals.INTERFACES.append(globals.MONSTER)
globals.ITEM = ItemDialog()
globals.INTERFACES.append(globals.ITEM)
globals.GAME_OVER = GameOverDialog()
globals.INTERFACES.append(globals.GAME_OVER)
globals.LADDER = LadderDialog()
globals.INTERFACES.append(globals.LADDER)
def update(self, method):
if method == "calculate":
self.alpha = float(self.alpha_entry.get())
self.l = float(self.l_entry.get())
self.u = float(self.u_entry.get())
result = erlang_c_time(self.l, self.u, self.alpha)
self.num_servers = result['c']
self.ew = result['ew']
self.en = result['en']
self.ens = result['ens']
self.num_servers_result.set(self.num_servers)
self.ew_result.set(self.ew)
self.en_result.set(self.en)
self.ens_result.set(self.ens)
self.write_to_excel()
elif method == "main-menu":
self.root.destroy()
from main_menu import MainMenu
m_menu = MainMenu(self.f_path)
m_menu.root.mainloop()
else: # reset
self.num_servers = 0
def main():
pygame.init()
screen = pygame.display.set_mode(config['screen']['size'])
elem = MainMenu(Rect((0, 0), config['screen']['size']), Color('white'))
m = MainLoop(elem, screen)
m.loop()
def __init__(self):
self.display = pg.display.set_mode([640, 480])
self.next_screen = None
self.running = True
# menu = menu.Menu()
self.screen = MainMenu()
# screen = Lore()
self.screen.bake()
self.clock = pg.time.Clock()
def initMainMenu(self, customMainMenu=None):
'''Call this to initialize and show main menu'''
if not self.mainMenu:
if not customMainMenu:
self.mainMenu = MainMenu()
else:
self.mainMenu = customMainMenu
self.mainMenu.open()
def build(self):
sm = ScreenManager()
sm.add_widget(Login(name='login'))
sm.add_widget(MainMenu(name='main_menu'))
sm.add_widget(Profile(name='profile'))
sm.add_widget(Results(name='results'))
sm.add_widget(Tests(name='tests'))
return sm
def __init__(self):
self.root = Tk()
self.root.geometry('{}x{}'.format(1000, 600))
self.root.wm_title("CMPUT 291 Database Application")
#self.page = LogInPage(self.root)
self.page = MainMenu(self.root)
self.root.after(300, self.mainTask)
self.root.mainloop()
def __init__(self):
ShowBase.__init__(self)
MainMenu.__init__(self)
GameApp.__init__(self)
BattleApp.__init__(self)
self.stack = [MainMenu()]
self.gameTask = taskMgr.add(self.programLoop, 'programLoop')
self.last = self.current()
self.hasDrawnMainMenu = False
self.disableMouse()
def main():
menu = MainMenu()
while True:
menu.show()
preset_chosen = menu.preset_chosen
if menu.exit:
break
board = Board(width=30, height=30, preset=presets_dict[preset_chosen])
controller = Controller(board, cell_size=20)
controller.run()
def init_ui(self):
self.main_menu = MainMenu(self)
self.setting_dialog = SettingDialog(self)
self.title_widget = TitleWidget(self)
self.btn_mainmenu = self.title_widget.btn_mainmenu
self.btn_min = self.title_widget.btn_min
self.btn_max = self.title_widget.btn_max
self.btn_close = self.title_widget.btn_close
self.controlbar = ControlBar()
self.controlbar.setFixedHeight(48)
self.btn_open = self.controlbar.btn_open
self.btn_play = self.controlbar.btn_play
self.btn_pause = self.controlbar.btn_pause
self.btn_stop = self.controlbar.btn_stop
self.btn_fullscreen = self.controlbar.btn_fullscreen
self.btn_playlist = self.controlbar.btn_playlist
self.lab_time = self.controlbar.lab_time
self.seekslider = self.controlbar.seekslider
self.volumeslider = self.controlbar.volumeslider
self.video.setMinimumSize(650, 350)
#self.playlist = PlayList(_('PlayList'))
self.playlist = PlayList()
self.playlist.setFixedSize(150, 850)
# playlist is hidden by default
#self.playlist.hide()
title_layout = QtGui.QHBoxLayout()
title_layout.addWidget(self.title_widget)
center_layout = QtGui.QHBoxLayout()
center_layout.addWidget(self.video)
center_layout.setSpacing(0)
center_layout.addWidget(self.playlist)
bottom_layout = QtGui.QHBoxLayout()
bottom_layout.addWidget(self.controlbar)
main_layout = QtGui.QGridLayout(self)
main_layout.addLayout(title_layout, 0, 0)
main_layout.addLayout(center_layout, 1, 0)
main_layout.setSpacing(0)
main_layout.addLayout(bottom_layout, 2, 0, 1, 2)
# Fill the window with all contents, no gap in border.
main_layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(main_layout)
def mainTask(self):
if self.page.successor != -1:
if self.page.successor == 0:
self.page.quit()
self.page.successor = -1 # Reset flag
self.page = MainMenu(self.root)
if self.page.successor == 1:
self.page.quit()
self.page.successor = -1 # Reset flag
self.page = VehicleRegPage(self.root)
elif self.page.successor == 2:
self.page.quit()
self.page.successor = -1 # Reset flag
self.page = AutoTransactionPage(self.root)
elif self.page.successor == 3:
self.page.quit()
self.page.successor = -1 # Reset flag
self.page = DriverLicencePage(self.root)
elif self.page.successor == 4:
self.page.quit()
self.page.successor = -1 # Reset flag
self.page = ViolationRecordPage(self.root)
elif self.page.successor == 5:
self.page.quit()
self.page.successor = -1 # Reset flag
self.page = MainSearchPage(self.root)
elif self.page.successor == 6:
self.page.quit()
self.page.successor = -1 # Reset flag
self.page = GeneralSearchPage(self.root)
elif self.page.successor == 7:
self.page.quit()
self.page.successor = -1 # Reset flag
self.page = ViolationsSearchPage(self.root)
elif self.page.successor == 8:
self.page.quit()
self.page.successor = -1 # Reset flag
self.page = VehicleHistorySearchPage(self.root)
self.root.after(300, self.mainTask) # reschedule event in 0.3 seconds
def __init__(self):
Tk.__init__(self)
self.app_version = '0.1'
self.title('DCS Kneeboard Maker ' + self.app_version)
self.main_menu = MainMenu(self)
self.status_bar = StatusBar(self)
self.status_bar.set_status('Ready')
self.info_bar = InfoBar(self)
x_scrollbar = Scrollbar(self, orient=HORIZONTAL)
x_scrollbar.pack(side=BOTTOM, fill=X)
y_scrollbar = Scrollbar(self, orient=VERTICAL)
y_scrollbar.pack(side=RIGHT, fill=Y)
self.x_scrollbar = x_scrollbar
self.y_scrollbar = y_scrollbar
self.file_path = ''
self.display_scale = 4
self.min_display_scale = 1
self.max_display_scale = 8
w = 800
h = 600
self.img = np.ones((h, w, 3), dtype=np.uint8) * 127
empty_preview = PIL_Image.fromarray(self.img)
empty_preview = ImageTk.PhotoImage(empty_preview)
preview_canvas = Canvas(self, width=w, height=h, bd=2, relief=SUNKEN, bg='gray',
xscrollcommand=x_scrollbar.set, yscrollcommand=y_scrollbar.set,
scrollregion=(0, 0, w, h))
preview_canvas.create_image(0, 0, image=empty_preview, anchor=NW)
preview_canvas.pack(side=TOP, expand=True, fill=BOTH)
self.preview_canvas = preview_canvas
self.preview_canvas.bind('<Motion>', self.mouse_move)
self.preview_canvas.bind('<Button-1>', self.left_click)
self.preview_canvas.bind('<Button-3>', self.right_click)
self.preview_canvas.bind('<MouseWheel>', self.mouse_wheel)
self.preview_canvas.bind('<Button-4>', self.mouse_wheel)
self.preview_canvas.bind('<Button-5>', self.mouse_wheel)
self.preview = empty_preview
x_scrollbar.config(command=preview_canvas.xview)
y_scrollbar.config(command=preview_canvas.yview)
warnings.filterwarnings('ignore')
self.mainloop()
def build(self):
screen_manager = ScreenManager()
main_menu_screen = MainMenu(name='main_menu')
questions_screen = Questions(name='questions')
evidence_unique_screen = EvidenceUnique(name='evidence_unique')
test_screen = Test(name='test')
result_screen = Result(name='result')
answers_screen = Answers(name='answers')
evidence_screen = Evidence(name='evidence')
screen_manager.add_widget(main_menu_screen)
screen_manager.add_widget(questions_screen)
screen_manager.add_widget(evidence_unique_screen)
screen_manager.add_widget(test_screen)
screen_manager.add_widget(result_screen)
screen_manager.add_widget(answers_screen)
screen_manager.add_widget(evidence_screen)
return screen_manager
def update(self, method):
if method == "calculate":
self.u2 = float(self.u2_entry.get())
self.l = float(self.l_entry.get())
self.u1 = float(self.u1_entry.get())
result = two_servers(self.l, self.u1, self.u2)
self.utilization = result['utilization']
self.p_idle = result['p_idle']
self.utilization_result.set(self.utilization)
self.p_idle_result.set(self.p_idle)
self.write_to_excel()
elif method == "main-menu":
self.root.destroy()
from main_menu import MainMenu
m_menu = MainMenu(self.f_path)
m_menu.root.mainloop()
else: # reset
self.utilization = 0
def update(self, method):
if method == "calculate":
self.pb = float(self.pb_entry.get())
self.l = float(self.l_entry.get())
self.u = float(self.u_entry.get())
result = erlang_b(self.pb, self.l, self.u)
self.num_servers = result['c']
self.pb_actual = result['pb_actual']
self.num_servers_result.set(self.num_servers)
self.pb_actual_result.set(self.pb_actual)
self.write_to_excel()
elif method == "main-menu":
self.root.destroy()
from main_menu import MainMenu
m_menu = MainMenu(self.f_path)
m_menu.root.mainloop()
else: # reset
self.num_servers = 0
def update(self, method):
if method == "calculate":
self.capacity = float(self.capacity_entry.get())
self.l = float(self.l_entry.get())
self.u = float(self.u_entry.get())
result = mm1k(self.l, self.capacity, self.u)
self.utilization = result['utilization']
self.en = result['en']
self.utilization_result.set(self.utilization)
self.en_result.set(self.en)
self.write_to_excel()
elif method == "main-menu":
self.root.destroy()
from main_menu import MainMenu
m_menu = MainMenu(self.f_path)
m_menu.root.mainloop()
else: # reset
self.utilization = 0
def main():
"""Main game loop. Loop until events returns false."""
global START_TIME, MAIN_MENU
pygame.init()
pygame.display.set_caption('Path Finder')
pygame.display.set_mode((600, 650), pygame.SRCALPHA)
MAIN_MENU = MainMenu()
running = True
setup()
clock = pygame.time.Clock()
START_TIME = pygame.time.get_ticks()
while running:
clock.tick(60)
pygame.time.wait(1)
running = events()
update()
render()
pygame.quit()
def __init__(self, parent=None, f=QtCore.Qt.WindowFlags()):
super(MainWindow, self).__init__(parent=parent)
self.setWindowTitle(u"CDATGUI")
self.spreadsheet = SpreadsheetWindow(f=QtCore.Qt.Widget)
self.setCentralWidget(self.spreadsheet)
var_widget = VariableWidget(parent=self)
self.add_left_dock(var_widget)
gm_widget = GraphicsMethodWidget(parent=self)
self.add_left_dock(gm_widget)
tmpl_widget = TemplateWidget(parent=self)
self.add_left_dock(tmpl_widget)
inspector = InspectorWidget(self.spreadsheet, parent=self)
self.add_right_dock(inspector)
con = ConsoleDockWidget(self.spreadsheet, parent=self)
self.add_right_dock(con)
self.setMenuBar(
MainMenu(self.spreadsheet, var_widget, gm_widget, tmpl_widget))
def mainMenu(self):
m = MainMenu(self.screen, self.screen_settings)
clock = pygame.time.Clock()
while True:
clock.tick()
action = m.checkEvents()
if action == "singleplayer":
self.runSinglePlayer()
m.need_screen_changes = True
m.need_draw_changes = True
continue
elif action == "multiplayer":
self.runMultiPlayer()
elif action == "settings":
self.runSettings()
m.need_screen_changes = True
m.need_draw_changes = True
continue
elif action == "quit":
pygame.quit()
exit()
if m.need_draw_changes:
m.draw()
m.need_draw_changes = False
from main_menu import MainMenu
print('School of Music')
print()
MainMenu()
from gameplay import Gameplay
from main_menu import MainMenu
while True:
MainMenu().run_menu()
currentGameplay = Gameplay()
currentGameplay.run_gameplay()
def main():
main_menu = MainMenu()
while True:
main_menu.display()
def run(self):
self.root = tk.Tk()
self.app = AppWindow(self.root)
GlobalEnvironment.change_screen(
MainMenu(GlobalEnvironment.get_master_frame()))
self.root.mainloop()
def main_menu(self):
menu = MainMenu(self)
menu.run()
#!/usr/bin/python3
# -*- coding: utf-8 -*-
__author__ = 'Anton Vanke <*****@*****.**>'
import sys
from PyQt5.Qt import *
from main_menu import MainMenu
from game import GameBoard
from hc_menu import ModeSelection
if __name__ == '__main__':
app = QApplication(sys.argv)
mainmenu = MainMenu()
def hc_menu():
hc_choice = ModeSelection(mainmenu)
hc_choice.show()
hc_choice.return_mainmenu_singal.connect(hc_choice.hide)
def human_computer_mode():
# 人机对战模式
hc_game = GameBoard(mainmenu)
hc_game.show()
hc_game.return_mainmenu_singal.connect(hc_game.hide)
mainmenu.human_computer_mode_singal.connect(hc_menu)
mainmenu.show()
sys.exit(app.exec_())
def setup(self):
# When game starts, setup and display main menu
self.main_menu_view = MainMenu()
self.main_menu_view.setup()
self.show_view(self.main_menu_view)
"""Entry point to the game."""
from main_menu import MainMenu
if __name__ == "__main__":
MainMenu().draw()
#!/usr/bin/env python
from card_config import *
from main_menu import MainMenu
from analog_menu import AnalogMenu
from gpio_blink_menu import GpioBlinkMenu
from pwm_dim_menu import PwmDimMenu
from uart_read_write_menu import UartReadWriteMenu
import curses
def init_screen():
screen = curses.initscr()
screen.nodelay(True)
curses.noecho()
return screen
if __name__ == '__main__':
screen = init_screen()
main_menu = MainMenu(
screen, {
'Test Analog Jacks': (lambda: AnalogMenu(screen, JACK_TO_ANALOG)),
'Test GPIO Outputs': (lambda: GpioBlinkMenu(screen, JACK_TO_GPIO)),
'Test PWM Outputs': (lambda: PwmDimMenu(screen, JACK_TO_PWM)),
'Test UART Outputs':
(lambda: UartReadWriteMenu(screen, UART_TX_TO_UART_RX)),
})
main_menu.show()
def __init__(self):
PSStatesManager.__init__(self)
self.add_state(MainMenu(self))
self.add_state(Game(self), False)
