def __init__(self, screen, messages_to_send, our_team,
our_team_first_move):
self.game_state = STATE_PREPARING
self.images = {
'ocean': pygame.image.load('ocean.jpg').convert(),
'explosion': pygame.image.load('explosion.jpg').convert(),
'ship': pygame.image.load('battleship.jpg').convert()
}
self.our_board = Board(pygame.freetype.Font, GAME_SIZE, 5, 0,
self.images)
self.load_positions_button = Button(
"Load", 10, 750, self.our_board.load_positions_from_file)
self.messages_to_send = messages_to_send
self.our_team = our_team
self.our_team_first_move = our_team_first_move
self.save_positions_button = Button(
"Save", 70, 750, self.our_board.save_positions_to_file)
self.start_game_button = Button("Start", 130, 750, self.start_game)
self.status_bar = StatusBar()
self.screen = screen
self.selected_their_team = None
self.selected_their_team_first_move = None
self.start_game_button.set_enabled(False)
self.status_bar.update_text(
'Choose your positions, an opponent, and click Start.')
self.teams = Teams()
self.their_board = Board(pygame.freetype.Font, GAME_SIZE, 580, 0,
self.images)
self.their_team = None
def __init__(self):
super(MainWindow, self).__init__()
self.setWindowTitle(self.tr("Alum Code Editor"))
self.setMinimumSize(750,500)
self._want_to_close = False
#Barra de Menu TOP
menu = self.menuBar()
self.__crear_acciones()
self.__crear_menu(menu)
#Widget Cetral
self.editor = Editor()
self.setCentralWidget(self.editor)
self.editor.setStyleSheet("background-color:#1e1e1e;color:white;font-size:18px;border:none;")
self.editor.cursorPositionChanged.connect(self._actualizar_status_bar)
#ToolBar
self.toolbar = QToolBar()
self.__crear_Toolbar(self.toolbar)
self.addToolBar(Qt.LeftToolBarArea, self.toolbar)
#satusBar
self.status = StatusBar()
self.setStatusBar(self.status)
self.status.setStyleSheet("background-color:#252526;")
#Conexiones
self.abrir.triggered.connect(self._abrir_archivo)
self.guardar.triggered.connect(self._guardar_archivo)
self.nuevo.triggered.connect(self._nuevo_archivo)
def __init__(self, setup_file, track_size, levels, track_index):
super(Player, self).__init__()
setup = load_json(setup_file)
self.images = setup['images']
self.track_size = track_size
self.levels = levels
body = self.images['body']
surface = get_animal_image(**body)
self.image = surface
# self.original_image = surface
# factor = 0.1
# width, height = surf.get_size()
# scaled_size = (int(width*factor), int(height*factor))
# self.surf = pygame.transform.smoothscale(surf, scaled_size)
# self.surf.set_colorkey(None, RLEACCEL)
self.rect = self.image.get_rect(center=body['center'])
self.speed = 1
self.min_speed = 1
self.max_speed = 10
# self.speak_sound = pygame.mixer.Sound('barking.ogg')
# self.angle = 0
self.level = 0
self.complete = False
self.load_background()
self.y = track_index * track_size['height']
self.status_bar = StatusBar(track_size, self.y)
self.legs_front = BodyPart(self.images['legs_front'], self.y)
self.legs_back = BodyPart(self.images['legs_back'], self.y)
self.body = BodyPart(self.images['body'], self.y)
self.sprites = pygame.sprite.Group(
[self.body, self.legs_front, self.legs_back])
def __init__(self, env, **kwargs):
"""
Init Method.
"""
# Set environment.
self.env = env
# Create geometry instance.
self.geometry = Geometry()
geo = self.geometry
# Read quarks and set default values.
self._setDefaultValues(**kwargs)
# Create the window.
self.createWindow()
# Set the OpenGL state.
self.setOpenGLState()
# Set the caption of the window.
self.window.set_caption('OpenGL Waveform Database Viewer')
# Create the ordered groups used to get a layer like drawing of the
# window.
self._createdOrderedGroups()
# Add a background and add it to group 0.
Background(parent=self, group=0)
# Connect to SeisHub Server.
self.seishub = Seishub(parent=self, group=1)
# Create status bar if desired.
if self.status_bar:
# The status bar should always be seen. Add to a very high group.
self.status_bar = StatusBar(parent=self,
group=999,
height=self.geometry.status_bar_height,
error=self.default_error)
# Create Utils class.
self.utils = Utils(parent=self, group=1)
# Add the Time Scale.
self.time_scale = TimeScale(parent=self, group=999)
# These cannot be created earlier as they need some already set up GUI
# Elements.
# XXX: Need to make more dynamic.
# Maximum vertical span that is viewable.
self.max_viewable = 0
self.current_view_span = self.window.height - self.status_bar.height
# Add a scroll bar. Should also always be on top.
self.scroll_bar = ScrollBar(parent=self, group=999)
# Add the menu.
self.menu = Menu(parent=self,
group=999,
width=self.geometry.menu_width)
geo.menu_width = self.menu.menu.width
# Start of menu.
self.menu_start = self.window.width - (geo.menu_width +\
geo.horizontal_margin + geo.scroll_bar_width)
# Preload some cursors for faster access.
self.default_cursor = \
self.window.get_system_mouse_cursor(self.window.CURSOR_DEFAULT)
self.hand_cursor = self.window.get_system_mouse_cursor(
self.window.CURSOR_HAND)
# Init zoom box handler.
self.zoomBox()
# Start timers.
self.Timers = Timers(parent=self, group=1)
def load_playing_field(self, score, hp):
f = open(
'game_process_for_{}/level{}.txt'.format(self.count_pacmans,
self.level), 'r')
data = list(f.read().split(sep='\n'))
for i in range(len(data)):
data[i] = list(data[i])
f.close()
field = []
k = 0
for x in range(len(data[k])):
h = []
for y in range(len(data)):
h.append(data[y][x])
k += 1
field.append(h)
width = WIDTH_CELL
height = HEIGHT_CELL
self.field_width = len(field) * WIDTH_CELL
self.field_height = len(field[0]) * HEIGHT_CELL
for i in range(len(field)):
for k in range(len(field[i])):
x = INDENT_X + i * width
y = INDENT_Y + k * height
if field[i][k] != '1':
self.floor.append(
Floor(x, y, width, height, 0, constants.BLACK))
if field[i][k] == '1':
self.walls.append(
Wall(x, y, width, height, 1, constants.BROWN))
if field[i][k] == '2':
self.grains.append(
Grain(x, y, width, height, 2, constants.LIGHT_ORANGE))
if field[i][k] == '3':
self.grains.append(
SuperGrain(x, y, width, height, 3,
constants.LIGHT_ORANGE))
if field[i][k] == '5' and self.count_pacmans != len(
self.pacmans):
self.pacmans.append(
Pacman(x + 1, y + 1, width + LESS_OBJECT,
height + LESS_OBJECT, 3, None,
score[len(self.pacmans)],
hp[len(self.pacmans)]))
self.initial_coordinates['pacmans'].append((x + 1, y + 1))
self.status_bars.append(
StatusBar(
INDENT_X, self.walls[0].rect.y -
(len(self.status_bars) + 1) * 22))
if field[i][k] == '6':
self.ghosts.append(
Ghost(x + 1, y + 1, width + LESS_OBJECT,
height + LESS_OBJECT, 3, WHITE))
self.initial_coordinates['ghosts'].append((x + 1, y + 1))
if field[i][k] == '4':
self.teleports.append(
Teleport(x, y, width, height, 4, constants.BLACK))
def __init__(self):
QWidget.__init__(self)
IDEGeneric.__init__(self)
self.setWindowTitle('NINJA-IDE {Ninja Is Not Just Another IDE}')
self.setWindowIcon(QIcon(resources.images['icon']))
self.setWindowState(Qt.WindowMaximized)
self.setMinimumSize(700, 500)
#Opactity
self.opacity = 1
#ToolBar
self._toolbar = QToolBar()
self._toolbar.setToolTip('Press and Drag to Move')
styles.set_style(self._toolbar, 'toolbar-default')
self.addToolBar(Qt.LeftToolBarArea, self._toolbar)
self._toolbar.setToolButtonStyle(Qt.ToolButtonIconOnly)
#StatusBar
self._status = StatusBar()
self._status.hide()
self.setStatusBar(self._status)
#Main Widgets
self.main = MainWindow(self)
self.setCentralWidget(self.main)
#Menu
menubar = self.menuBar()
styles.apply(menubar, 'menu')
file_ = menubar.addMenu('&File')
edit = menubar.addMenu('&Edit')
view = menubar.addMenu('&View')
project = menubar.addMenu('&Project')
self.pluginsMenu = menubar.addMenu('P&lugins')
about = menubar.addMenu('&About')
#The order of the icons in the toolbar is defined by this calls
self._menuFile = MenuFile(file_, self._toolbar, self.main)
self._menuView = MenuView(view, self, self.main)
self._menuEdit = MenuEdit(edit, self._toolbar, self.main, self._status)
self._menuProject = MenuProject(project, self._toolbar, self.main)
self._menuPlugins = MenuPlugins(self.pluginsMenu, self)
self._menuAbout = MenuAbout(about, self.main)
self.main.container.load_toolbar(self._toolbar)
self.main._central.actual_tab().obtain_editor().setFocus()
filenames, projects_path = core.cliparser.parse()
for filename in filenames:
self.main.open_document(filename)
for project_path in projects_path:
self.main.open_project_folder(project_path)
self.connect(self.main, SIGNAL("fileSaved(QString)"),
self.show_status_message)
def __init__(self):
super(Qttp, self).__init__()
self.setupUi(self)
self.prepareConfig()
self.fileLine = FileLine()
self.prepareMenu()
self.envrionmentSwitcher = EnvironmentSwitcher()
self.statusBar = StatusBar()
self.statusbar.addPermanentWidget(self.statusBar)
self.responseInfo = ResponseInfo()
self.responseLayout.addWidget(self.responseInfo)
self.responseTabs = ResponseTabsWidget()
self.responseLayout.addWidget(self.responseTabs)
self.comboBox.setEnabled(False)
self.url.setFocus()
self.sendButton.clicked.connect(self.request)
self.saveButton.clicked.connect(self.saveRequest)
self.url.returnPressed.connect(self.request)
self.resizeInputHeadersHeader()
self.inputHeaders.setColumnCount(2)
self.inputHeaders.setRowCount(1)
self.inputHeaders.setHorizontalHeaderLabels(["Key", "Value"])
self.inputHeaders.cellDoubleClicked.connect(self.addHeaderRow)
self.inputHeaders.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.inputHeaders.customContextMenuRequested.connect(self.headersMenu)
headersDelegate = HeadersCompleter(self.inputHeaders)
self.inputHeaders.setItemDelegateForColumn(0, headersDelegate)
self.urlCompleter = UrlCompleter(self.url)
self.url.setCompleter(self.urlCompleter)
self.collectionsHistoryTabs = CollectionsHistoryTabs()
self.collectionsHistoryTabs.set_item.connect(self.setFromHistory)
self.collectionsHistoryLayout.addWidget(self.collectionsHistoryTabs)
self.envrionmentSwitcher = EnvironmentSwitcher()
self.collectionsHistoryLayout.addWidget(self.envrionmentSwitcher)
splitterSizes = self.getMainSplitterSizes()
print(type(splitterSizes))
self.mainSplitter.setSizes(splitterSizes)
self.disableRequestBody()
self.buttonGroup.buttonClicked.connect(self.postBodySwitched)
self.method.currentTextChanged.connect(self.onMethodChange)
self.comboBox.currentTextChanged.connect(self.rawTypeChanged)
self.currentBodyEditor = self.requestBody
def __init__(self):
super(Monster, self).__init__()
self.image = pygame.image.load('images/monster.bmp').convert()
self.rect = self.image.get_rect()
self.rect.x = s.DISPLAY_WIDTH // 2
self.rect.y = s.DISPLAY_HEIGHT - self.rect.height * 1.5
self.status_bar = StatusBar()
self.status_bar_group = pygame.sprite.Group()
self.status_bar_group.add(self.status_bar)
self.vel_x = 0
self.vel_y = 0
self.speed = 2
def run(self, task_name=None, task_flag=None, silent=False, paths=[]):
self.settings = None
self.setup_data_from_settings()
self.task_name = task_name
self.task_flag = task_flag if task_name is not None and task_flag is not None else self.get_flag_from_task_name(
)
self.silent = silent
self._working_dir = ""
self.searchable_folders = [
os.path.dirname(path) for path in paths
] if len(paths) > 0 else self.window.folders()
self.output_view = None
self.status_bar = StatusBar(self.window)
self.work()
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 __init__(self, parent=None):
super(MainWindow, self).__init__()
self.setMinimumSize(800, 600)
self.setWindowTitle("QPad")
# central widget
self.text = TextEdit()
self.text.cursorPositionChanged.connect(self.update_statusbar)
self.setCentralWidget(self.text)
# Actions
self.__create_actions()
# Menu
self.__create_menu(self.menuBar())
# Toolbar
self.__create_toolbar(QtGui.QToolBar())
# Status Bar
self.status = StatusBar()
self.setStatusBar(self.status)
def __init__(self, root):
self.root = root
self.root.title(u'Obliczenia graficzne')
# report creation - out directory and filepath
self.out_path = os.path.join(os.getcwd(), 'out')
if not os.path.exists(self.out_path):
os.mkdir(self.out_path)
self.filename = datetime.datetime.now().strftime(
'%Y%m%d_%H%M%S') + '.txt'
self.file_path = os.path.join(self.out_path, self.filename)
self.status_bar = StatusBar(self.root)
self.map_canvas = Map(self.root, self.status_bar, self.file_path)
self.make_widgets()
self.last_searched = []
self.root.iconbitmap('./img/gcalc.ico')
def _init_layout(self):
"""
Initializes the layout of the root and children views
"""
self.root = Tk()
self.root.wm_client("cbar")
# uniform background color
self.root["bg"] = self._config["Colors"]["bg_default"]
self.root.resizable(width=False, height=False)
# needed for top bar
self.root.wm_attributes("-type", "dock")
# other windows are always behind the bar
self.root.wm_attributes("-topmost", True)
# background for child elements
self.root.option_add("*Background",
self._config["Colors"]["bg_default"])
self.root.rowconfigure(0, weight=1)
self.root.columnconfigure(0, weight=1)
# Set width to screen width and height to minimal height given in config file
if "bottom" in self._config["General"]["position"].lower():
y_pos = self.root.winfo_screenheight()
else:
y_pos = 0
self.root.wm_geometry("+0+%d" % y_pos)
self.root.wm_minsize(self.root.winfo_screenwidth(),
height=self._config.getint(
"General", "min_height"))
# Initialize the workspace bar (left, shows workspace names/numbers)
self._workspace_bar = WorkspaceBar(self.root, self._xconnector,
self._config["Workspaces"],
self._config["Colors"])
# Initialize the status bar (right, shows status items)
self._status_bar = StatusBar(self.root, self._config["Status"],
self._config["Colors"])
# Allows the text box to stretch across the whole window
root.grid_rowconfigure(0, weight=1)
root.grid_columnconfigure(0, weight=1)
# Creates the text_area
text_box = TextBox(root)
text_area = text_box.get_text_area()
# Displays the text box
text_box.display_text_box()
# Displays the scrollbars
text_box.display_scroll_bars()
# Creates and displays the status_bar
status_bar = StatusBar(root, text_area)
# Creates a menu bar
menu_bar = MenuBar(root)
file_menu = FileMenu(root)
edit_menu = EditMenu(root)
format_menu = FormatMenu(root)
view_menu = ViewMenu(root)
help_menu = HelpMenu(root)
# Generates a space for the menu bar
root.config(menu=menu_bar.get_menu())
# Displays the menu bar ribbons
menu_bar.display_menu_bar(file_menu.get_file_menu(), edit_menu.get_edit_menu(),
format_menu.get_format_menu(),
def __init__(self):
QMainWindow.__init__(self)
self.setWindowTitle(cons.APP_TITLE)
self.setWindowIcon(
QIcon(os.path.join(cons.MEDIA_PATH, "misc", "ochd.ico")))
self.resize(MIN_WIDTH, MIN_HEIGHT)
self.center()
self.restore_wnd_geometry()
self.stop = (QToolButton(), media.get_icon(media.STOP, media.MEDIUM),
_('Stop Download'), self.on_stop_download, False)
self.start = (QToolButton(), media.get_icon(media.START, media.MEDIUM),
_('Start Download'), self.on_start_download, False)
accounts = (QToolButton(), media.get_icon(media.ACCOUNTS,
media.MEDIUM), _('Accounts'),
self.on_accounts, True)
preferences = (QToolButton(),
media.get_icon(media.PREFERENCES, media.MEDIUM),
_('Preferences'), self.on_preferences, True)
about = (QToolButton(), media.get_icon(media.ABOUT, media.MEDIUM),
_('About'), self.on_about, True)
self.menu = QMenu()
preferences[BTN].setPopupMode(QToolButton.MenuButtonPopup)
preferences[BTN].setMenu(self.menu)
toolbar = Toolbar(
self,
[self.start, self.stop, None, accounts, preferences, None, about])
self.toolbar = self.addToolBar(toolbar)
#self.vbox = QVBoxLayout(self)
#tabs
self.previous_tab = None
self.tab = QTabWidget(self)
#
self.downloads = Downloads(self)
self.tab.addTab(self.downloads, _('Downloads'))
#
self.add_downloads = AddDownloads(self.downloads, self)
self.tab_add_downloads = QWidget()
self.tab_add_downloads.setLayout(self.add_downloads)
self.tab.addTab(self.tab_add_downloads, _('Add downloads'))
#
#addons
self.addons_manager = AddonsManager(self)
self.addons_list = self.addons_manager.addons_list
#...tabs
self.addon_tab_widgets = []
self.load_addon_tabs()
#
self.log = Log()
self.tab_log = QWidget()
self.tab_log.setLayout(self.log)
self.tab.addTab(self.tab_log, _('Log'))
#
self.preferences = Preferences(self.addons_list, self)
#self.tab.addTab(self.preferences, 'Preferences')
#
self.tab.currentChanged.connect(self.on_tab_switch)
#
self.setCentralWidget(self.tab)
#status bar
self.status_bar = StatusBar(self)
self.setStatusBar(self.status_bar)
#drop down menu
[addon.set_menu_item() for addon in self.addons_list]
#self.menu.addSeparator()
#self.menu.addAction('Preferences', self.on_preferences)
#system tray icon
self.tray = Tray(self)
if self.tray.available:
self.can_close = False
else:
self.can_close = True
#on select button state
self.downloads.selectionModel().selectionChanged.connect(
self.on_selected)
#load session.
self.load_session()
#add core's event loop
self.idle_timeout(500, self.queue_loop)
#quit event
events.connect(cons.EVENT_QUIT, self.event_close)
self.show()
def make_widgets(self):
self.status_bar = StatusBar(self.root)
self.status_bar.pack(side=tk.BOTTOM, fill='both', expand=True)
self.text_area = TextArea(self.root, self.status_bar)
self.text_area['font'] = ('consolas', '12')
self.text_area.pack(expand=True, fill='both')
