def restart(self):
self.play_button = Button(settings=self.settings, screen=self.screen, msg="Play", type='play')
self.score_button = Button(settings=self.settings, screen=self.screen, msg="SCORES", type='score')
self.stats = GameStats(settings=self.settings)
self.sb = Scoreboard(game=self, sound=self.sound)
self.settings.init_dynamic_settings()
self.barriers = Barriers(game=self)
self.aliens = Aliens(ship_height=self.ship_height, game=self, barriers=self.barriers)
self.ship = Ship(aliens=self.aliens, sound=self.sound, game=self, barriers=self.barriers)
self.splash_screen = SplashScreen(settings=self.settings,screen=self.screen,play_button=self.play_button,score_button=self.score_button)
self.score_screen = ScoreScreen(settings=self.settings,screen=self.screen,button=self.play_button)
self.aliens.add_ship(ship=self.ship)
self.sb.prep_high_score()
def __init__(self, application=None):
self._adjustments = AdjustmentToolbar()
self._blurs = BlurToolbar()
self._transformations = TransformToolbar()
self._filters = FilterToolbar()
self._borders = BorderToolbar()
self._distorts = DistortToolbar()
categories = [
self._filters, self._transformations, self._adjustments,
self._distorts, self._blurs, self._borders
]
self._left_toolbar = PhotosLeftToolbar(categories=categories)
self._splash_screen = SplashScreen(name="splash-eventbox")
self._right_toolbar = PhotosRightToolbar()
self._image_container = ImageContainer(name="image-container")
self._window = PhotosWindow(splash_screen=self._splash_screen,
left_toolbar=self._left_toolbar,
right_toolbar=self._right_toolbar,
image_container=self._image_container,
title=_("Photos"),
application=application)
def run_game():
# Initialize game and create a screen object
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption('Space Fighter')
# Set the background
background = Background(screen, ai_settings)
# Make the buttons and splash screen
play_button = Button(screen, "Play", "g")
quit_button = Button(screen, "Quit", "r")
splash_screen = SplashScreen(screen, ai_settings)
# Create an instance to store game stats & create a scoreboard
stats = GameStats(ai_settings)
sb = Scoreboard(ai_settings, screen, stats)
# Make a ship
ship = Ship(ai_settings, screen)
# Make a group to store bullets & aliens in
bullets = Group()
aliens = Group()
# Create the fleet of aliens
gf.create_fleet(ai_settings, screen, ship, aliens)
# Start the main loop for the game
while True:
ce.check_events(ai_settings, screen, stats, sb, play_button,
quit_button, ship, aliens, bullets, splash_screen)
if stats.game_active:
ship.update()
gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens,
bullets)
gf.update_aliens(ai_settings, screen, stats, sb, ship, aliens,
bullets, splash_screen)
gf.update_screen(screen, stats, sb, ship, aliens, bullets, play_button,
quit_button, splash_screen, background)
# Make the most recently drawn screen visible
pygame.display.flip()
def main():
# Create splash screen
exception_handlers = {'NetworkError': NetworkError,
'UnexpectedError': UnexpectedError}
root = SplashScreen(func=check_updates_and_run_app,
exception_handlers=exception_handlers)
root.overrideredirect(True)
logo = PhotoImage(file='resources/payment.png')
logo_label = Label(root, image=logo)
logo_label.pack(side='top', pady=40)
copyright_label = Label(root, text='© 2019-2021 Офис контролинга логистики')
copyright_label.pack(side='bottom', pady=5)
label = Label(root,
text='Выполняется поиск обновлений и запуск приложения...')
label.pack(expand='yes')
root.after(300, root.task)
root.mainloop()
def on_start(self):
ss = SplashScreen()
self.root.add_widget(ss)
self.root.current = 'splash_screen'
if __name__ == '__main__':
app = QApplication(sysargv)
#app.setAttribute(Qt.AA_NativeWindows, True)
#print(QStyleFactory.keys())
app.setStyle(QStyleFactory().create("Fusion"))
fuente = QFont()
#fuente.setFamily("Cantarell")
#fuente.setFamily("Candara")
fuente.setFamily("Verdana")
fuente.setPointSize(10)
app.setFont(fuente)
app.setWindowIcon(QIcon("iconos/auction.png"))
pantalla_principal = PantallaPrincipal()
splash = SplashScreen()
splash.finish(pantalla_principal)
while pantalla_principal.exec() == QDialog.Accepted:
accion = pantalla_principal.obtener_accion()
if accion == PantallaPrincipal.A_CREAR:
print("Crear")
licitador = crear_nueva_licitacion(
Licitador(pantalla_principal.obtener_nombre_licitacion()))
Combinacion.maxima = 0
if licitador == None:
continue
elif licitador == 1:
break
else:
licitador.guardar_licitacion()
dialogo_cargando = DialogoCargando()
class PhotosView(object):
"""
The main view class for the photo application. Mainly just passes the
presenter calls to the appropriate UI elements. PhotosWindow does the
actual toplevel layout of the toolbars and central view.
"""
def __init__(self, application=None):
self._adjustments = AdjustmentToolbar()
self._blurs = BlurToolbar()
self._transformations = TransformToolbar()
self._filters = FilterToolbar()
self._borders = BorderToolbar()
self._distorts = DistortToolbar()
categories = [
self._filters, self._transformations, self._adjustments,
self._distorts, self._blurs, self._borders
]
self._left_toolbar = PhotosLeftToolbar(categories=categories)
self._splash_screen = SplashScreen(name="splash-eventbox")
self._right_toolbar = PhotosRightToolbar()
self._image_container = ImageContainer(name="image-container")
self._window = PhotosWindow(splash_screen=self._splash_screen,
left_toolbar=self._left_toolbar,
right_toolbar=self._right_toolbar,
image_container=self._image_container,
title=_("Photos"),
application=application)
def set_presenter(self, presenter):
self._presenter = presenter
self._splash_screen.set_presenter(presenter)
self._left_toolbar.set_presenter(presenter)
self._right_toolbar.set_presenter(presenter)
self._image_container.set_presenter(presenter)
self._blurs.set_presenter(presenter)
self._transformations.set_presenter(presenter)
self._adjustments.set_presenter(presenter)
self._borders.set_presenter(presenter)
self._filters.set_presenter(presenter)
self._distorts.set_presenter(presenter)
self._window.set_presenter(presenter)
# This should be called to update the UI from outside of GTK's thread. It
# will call an update function fn to be called on the main thread at the
# next opportunity.
def update_async(self, fn):
Gdk.threads_add_idle(GLib.PRIORITY_DEFAULT_IDLE, lambda dummy: fn(),
None)
def get_window(self):
return self._window
def close_window(self):
self._window.destroy()
def minimize_window(self):
self._window.iconify()
def set_image_widget(self, widget):
self._image_container.set_image_widget(widget)
widget._crop_overlay._crop_box.set_view(self)
def set_cursor(self, cursor):
if cursor is not None:
self.get_window().get_window().set_cursor(cursor)
def set_photo_editor_active(self):
self._window.set_photo_editor_active()
def set_image_fullscreen(self, fullscreen):
self._window.set_image_fullscreen(fullscreen)
def set_filters(self, filters):
self._filters.set_options(filters)
def set_blurs(self, blurs):
self._blurs.set_blurs(blurs)
def set_transformations(self, transformations):
self._transformations.set_transformations(transformations)
def set_borders(self, borders):
self._borders.set_options(borders)
def set_distortions(self, distortions):
self._distorts.set_options(distortions)
def select_filter(self, filter_name):
self._filters.select(filter_name)
def select_blur(self, blur_name):
self._blurs.select(blur_name)
def select_transformation(self, transformation_name):
self._transformations.select(transformation_name)
def select_border(self, border_name):
self._borders.select(border_name)
def select_distortion(self, distort_name):
self._distorts.select(distort_name)
def set_brightness_slider(self, value):
self._adjustments.set_brightness_slider(value)
def set_contrast_slider(self, value):
self._adjustments.set_contrast_slider(value)
def set_saturation_slider(self, value):
self._adjustments.set_saturation_slider(value)
def facebook_login_callback(self, dialog, response, message_to_post):
self._presenter.facebook_login_handler(message_to_post,
dialog.get_access_token(),
dialog.get_message())
dialog.hide()
def show_facebook_login_dialog(self, message_to_post):
dialog = FacebookAuthDialog(transient_for=self.get_window())
dialog.connect('response', self.facebook_login_callback,
message_to_post)
dialog.show()
def show_open_dialog(self, starting_dir, callback):
# Opens a dialog window where the user can choose an image file
dialog = PreviewFileChooserDialog(title=_("Open Image"),
parent=self.get_window(),
action=Gtk.FileChooserAction.OPEN,
modal=True)
if starting_dir != None:
dialog.set_current_folder(starting_dir)
# Adds 'Cancel' and 'OK' buttons
dialog.add_button(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL)
dialog.add_button(Gtk.STOCK_OK, Gtk.ResponseType.OK)
# Sets default to 'OK'
dialog.set_default_response(Gtk.ResponseType.OK)
# Filters and displays files which can be opened by Gtk.Image
filefilter = Gtk.FileFilter()
filefilter.add_pixbuf_formats()
dialog.set_filter(filefilter)
def open_callback(dialog, response):
if response == Gtk.ResponseType.OK:
callback(dialog.get_filename())
dialog.destroy()
dialog.connect('response', open_callback)
dialog.show()
def show_save_dialog(self, curr_name, dir_path, callback):
# Opens a dialog window where the user can choose an image file
dialog = Gtk.FileChooserDialog(_("Save Image"),
self.get_window(),
Gtk.FileChooserAction.SAVE,
modal=True)
dialog.set_do_overwrite_confirmation(True)
# Adds 'Cancel' and 'OK' buttons
dialog.add_button(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL)
dialog.add_button(Gtk.STOCK_OK, Gtk.ResponseType.OK)
dialog.set_current_folder(dir_path)
dialog.set_current_name(curr_name)
# Sets default to 'OK'
dialog.set_default_response(Gtk.ResponseType.OK)
def save_callback(dialog, response):
if response == Gtk.ResponseType.OK:
should_close = callback(dialog.get_filename())
if should_close:
dialog.destroy()
else:
dialog.destroy()
dialog.connect('response', save_callback)
dialog.show()
def show_confirm_open_new_dialog(self, save_callback, open_callback):
dialog = Gtk.MessageDialog(
parent=self.get_window(),
text=_("Open new photo without save?"),
secondary_text=
_("Your changes have not been saved. Are you sure you want to open a new photo without saving?"
),
message_type=Gtk.MessageType.WARNING,
modal=True)
dialog.add_button(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL)
dialog.add_button(Gtk.STOCK_SAVE, Gtk.ResponseType.ACCEPT)
dialog.add_button(Gtk.STOCK_OK, Gtk.ResponseType.OK)
# set default to cancel
dialog.set_default_response(Gtk.ResponseType.CANCEL)
def confirm_open_new_callback(dialog, response):
dialog.destroy()
if response == Gtk.ResponseType.ACCEPT:
save_callback()
elif response == Gtk.ResponseType.OK:
open_callback()
dialog.connect('response', confirm_open_new_callback)
dialog.show()
def show_confirm_close(self, save_callback, close_callback):
dialog = Gtk.MessageDialog(
parent=self.get_window(),
text=_("Quit Without Save?"),
secondary_text=
_("Your changes have not been saved. Are you sure you want to quit?"
),
message_type=Gtk.MessageType.WARNING,
modal=True)
dialog.add_button(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL)
dialog.add_button(Gtk.STOCK_SAVE, Gtk.ResponseType.ACCEPT)
dialog.add_button(Gtk.STOCK_QUIT, Gtk.ResponseType.OK)
# set default to cancel
dialog.set_default_response(Gtk.ResponseType.CANCEL)
def confirm_close_callback(dialog, response):
dialog.destroy()
if response == Gtk.ResponseType.ACCEPT:
save_callback()
elif response == Gtk.ResponseType.OK:
close_callback()
dialog.connect('response', confirm_close_callback)
dialog.show()
def show_message(self, text="", secondary_text="", warning=False):
dialog_type = Gtk.MessageType.WARNING if warning else Gtk.MessageType.INFO
dialog = Gtk.MessageDialog(parent=self.get_window(),
text=text,
secondary_text=secondary_text,
message_type=dialog_type,
name='message-dialog',
modal=True)
dialog.add_button(Gtk.STOCK_OK, 0)
# set default to cancel
dialog.set_default_response(0)
dialog.connect('response', lambda dialog, response: dialog.destroy())
dialog.show()
# Gets responses from a user. Args is a list of requested responses
# from the user.
def get_message(self, prompt, callback, *args):
dialog = Gtk.Dialog(transient_for=self.get_window(),
modal=True,
name='message-box')
# Title is not shown by default for transient windows anymore
title = Gtk.Label(label='<b>' + prompt + '</b>', use_markup=True)
title.get_style_context().add_class('dialog-title')
dialog.set_titlebar(title)
grid = Gtk.Grid()
continue_button = Gtk.Button(label=_("Continue"),
name='continue-button')
cancel_button = Gtk.Button(_("Cancel"))
dialog.add_action_widget(cancel_button, Gtk.ResponseType.CANCEL)
dialog.add_action_widget(continue_button, Gtk.ResponseType.OK)
dialog.get_action_area().set_layout(Gtk.ButtonBoxStyle.EDGE)
cancel_button.grab_focus()
dialog.set_size_request(500, -1)
entries = []
# Create an entry for all but the last of the requested responses
# used solely for email popup, a currently disabled feature, so hasn't been tested
for index in range(0, len(args) - 1):
entry = Gtk.Entry()
entry.set_size_request(-1, 30)
entry.set_activates_default(True)
entries.append(entry)
align = Gtk.Alignment(xalign=0, yalign=0, xscale=0, yscale=0)
align.add(Gtk.Label(args[index]))
vbox = Gtk.VBox()
vbox.pack_start(align, False, 5, 5)
vbox.pack_end(entry, True, True, 0)
grid.attach(vbox, 0, index, 1, 1)
text_view = TextEntry(args[len(args) - 1])
entries.append(text_view)
grid.attach(text_view, 0, len(args) - 1, 1, 1)
dialog.get_content_area().pack_start(grid, True, True, 10)
def message_callback(dialog, confirm, entries):
responses = []
map(lambda x: responses.append(x.get_text()), entries)
dialog.hide()
callback(confirm, responses)
dialog.connect('response', message_callback, entries)
dialog.show_all()
def lock_ui(self):
watch = Gdk.Cursor(Gdk.CursorType.WATCH)
gdk_window = self._window.get_window()
gdk_window.set_cursor(watch)
self._window.set_sensitive(False)
def unlock_ui(self):
pointer = Gdk.Cursor(Gdk.CursorType.ARROW)
gdk_window = self._window.get_window()
gdk_window.set_cursor(pointer)
self._window.queue_draw()
self._window.set_sensitive(True)
from splash_screen import SplashScreen
# from variables import Objects as ob
if __name__ == "__main__":
app = QtGui.QApplication(sys.argv)
app_icon = QtGui.QIcon()
v = Variables()
# dw = QtGui.QDesktopWidget()
app_icon.addFile(v.app_icon, QtCore.QSize(16, 20))
app_icon.addFile(v.app_icon, QtCore.QSize(24, 30))
app_icon.addFile(v.app_icon, QtCore.QSize(32, 40))
app_icon.addFile(v.app_icon, QtCore.QSize(48, 60))
app_icon.addFile(v.app_icon, QtCore.QSize(223, 283))
# app.setStyle("cleanlooks")
app.setWindowIcon(app_icon)
app.setApplicationName('AMDock: Assisted Molecular Docking for AutoDock and AutoDock Vina')
splash = SplashScreen(QtGui.QPixmap(v.splashscreen_path), app)
main = AMDock()
splash.finish(main)
main.setWindowState(QtCore.Qt.WindowMaximized)
# main.setMinimumSize(1080, 740)
# main.resize(1200, int(dw.height() * 0.9))
main.setWindowTitle('AMDock: Assisted Molecular Docking with AutoDock4 and AutoDock Vina')
main.setWindowIcon(app_icon)
main.show()
if splash.import_error():
sys.exit(app.exec_())
else:
sys.exit(app.exit(1))
playing_area.bounding_box,
Tile(6, 6, [
0b00110000,
0b01111000,
0b11111100,
0b11111100,
0b01111000,
0b00110000])),
players,
score_font = font_5x8,
message_font = font_5x8)
with open("lophtware-128x64.raw", "rb") as logo_fd:
logo = Tile.from_raw(logo_fd.read(), 128, 64)
SplashScreen(logo).show(display)
quit = False
def on_keyboard_input(cmd):
global quit
quit = cmd == 'q'
return quit
keyboard = KeyboardThread(on_keyboard_input)
playing_area.draw()
while not quit:
if not game.do_frame(display):
break
display.blit()
class Game:
def __init__(self):
pg.init()
self.settings = Settings()
self.screen = pg.display.set_mode(size=(self.settings.screen_width, self.settings.screen_height))
pg.display.set_caption("Alien Invasion")
ship_image = pg.image.load('images/ship.bmp')
self.ship_height = ship_image.get_rect().height
self.sound = Sound(bg_music="sounds/startrektheme.wav")
self.sound.play()
self.sound.pause_bg()
self.splash_screen = self.score_button = self.play_button = self.aliens = self.stats = self.sb = self.ship = None
self.restart()
def restart(self):
self.play_button = Button(settings=self.settings, screen=self.screen, msg="Play", type='play')
self.score_button = Button(settings=self.settings, screen=self.screen, msg="SCORES", type='score')
self.stats = GameStats(settings=self.settings)
self.sb = Scoreboard(game=self, sound=self.sound)
self.settings.init_dynamic_settings()
self.barriers = Barriers(game=self)
self.aliens = Aliens(ship_height=self.ship_height, game=self, barriers=self.barriers)
self.ship = Ship(aliens=self.aliens, sound=self.sound, game=self, barriers=self.barriers)
self.splash_screen = SplashScreen(settings=self.settings,screen=self.screen,play_button=self.play_button,score_button=self.score_button)
self.score_screen = ScoreScreen(settings=self.settings,screen=self.screen,button=self.play_button)
self.aliens.add_ship(ship=self.ship)
self.sb.prep_high_score()
def play(self):
atexit.register(self.exit_handler)
while True:
gf.check_events(stats=self.stats, play_button=self.play_button, score_button=self.score_button, ship=self.ship, sound=self.sound)
if self.stats.game_active:
self.ship.update()
self.aliens.update()
self.barriers.update()
self.screen.fill(self.settings.bg_color)
self.ship.draw()
self.aliens.draw()
self.barriers.draw()
self.sb.show_score()
if not self.stats.game_active:
if self.stats.score_active:
self.screen.fill(self.settings.bg_color)
self.score_screen.draw()
else:
self.screen.fill(self.settings.bg_color)
self.splash_screen.draw()
self.sound.pause_bg()
else:
if not self.sound.playing_bg: self.sound.unpause_bg()
pg.display.flip()
def reset(self):
if self.stats.ships_left > 0:
self.stats.ships_left -= 1
self.sb.prep_ships()
self.aliens.empty()
self.aliens.create_fleet()
self.ship.center_ship()
time.sleep(0.5)
self.ship.timer = Ship.timer
else:
self.stats.game_active = False
self.sound.pause_bg()
self.hs = self.stats.high_score
self.restart()
def exit_handler(self):
high_score_file = open("highscores.txt", "r")
temphigh = []
num_lines = self.file_len("highscores.txt")
for x in range(num_lines):
temphigh.append(int(high_score_file.readline()))
temphigh.sort()
high_score_file.close()
if temphigh[0] < self.stats.high_score & temphigh[4] != self.stats.high_score:
temphigh[0] = self.stats.high_score
with open('highscores.txt', 'w') as f:
for item in temphigh:
f.write("%s\n" % item)
def file_len(self, fname):
with open(fname) as f:
for i, l in enumerate(f):
pass
return i + 1