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): 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, 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): 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): 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, 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, 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__(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): 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, box, pref): QWidget.__init__(self) self._box = box self.pref = pref vbox = QVBoxLayout(self) hbox = QHBoxLayout() self.btnMyFiles = QPushButton(QIcon(config.images['myfiles']), 'My Files') self.btnFriendFiles = QPushButton(QIcon(config.images['friends']), 'Friends Files') self.btnUpload = QPushButton(QIcon(config.images['upload']), 'Manage/Upload') self.btnFind = QPushButton(QIcon(config.images['search']), 'Find Friends') hbox.addWidget(self.btnMyFiles) hbox.addWidget(self.btnFriendFiles) hbox.addWidget(self.btnUpload) hbox.addWidget(self.btnFind) vbox.addLayout(hbox) self.stack = StackedWidget() self.myFiles = MyFiles(self, self.pref) self.stack.addWidget(self.myFiles) self.friendFiles = FriendFiles(self, self.pref) self.stack.addWidget(self.friendFiles) self.uploadFiles = UploadFiles() self.stack.addWidget(self.uploadFiles) self.inviteFriends = InviteFriends(self) self.stack.addWidget(self.inviteFriends) vbox.addWidget(self.stack) self._status = StatusBar(self) self._status.hide() vbox.addWidget(self._status) self.overlay = Overlay(self) self.overlay.show() self.shortFind = QShortcut(QKeySequence(Qt.CTRL + Qt.Key_F), self) self.connect(self.btnMyFiles, SIGNAL("clicked()"), lambda: self.stack.setCurrentIndex(0)) self.connect(self.btnFriendFiles, SIGNAL("clicked()"), lambda: self.stack.setCurrentIndex(1)) self.connect(self.btnUpload, SIGNAL("clicked()"), lambda: self.stack.setCurrentIndex(2)) self.connect(self.btnFind, SIGNAL("clicked()"), lambda: self.stack.setCurrentIndex(3)) self.connect(self.shortFind, SIGNAL("activated()"), self._status.show_status) self.timer = QTimer(self) self.connect(self.timer, SIGNAL("timeout()"), self.update) self.timer.start(self.pref.get('time', 10) * 1000 * 60)
def status_bar(self): """ Show the bars for health and stamina """ x = 0 if self.num == 0: x = 10 # bar for first player else: x = 614 # bar for second player health_bar = StatusBar(self.screen, x, 10, (228,7,7)) stamina_bar = StatusBar(self.screen, x, 40, (55,204,55)) health_bar.update(self.current_health / self.total_health) stamina_bar.update(self.current_stamina / self.total_stamina)
def __init__(self): super(MainWindow, self).__init__() self.setWindowTitle(self.tr("Editor - PyQt4")) self.setMinimumSize(700,500) #MenuBar menu = self.menuBar() self.__crear_acciones() self.__crear_menu(menu) #Widget central self.editor = Editor() self.editor.modificationChanged[bool].connect(self._modificado) self.editor.cursorPositionChanged.connect(self._actualizar_status_bar) self.setCentralWidget(self.editor) #ToolBar self.toolbar = QToolBar() self.__crear_toolbar(self.toolbar) #agregamos a la pagina principal el toolbar self.addToolBar(Qt.LeftToolBarArea, self.toolbar) #StatusBar self.status = StatusBar() self.setStatusBar(self.status) #Conexiones self.abrir.triggered.connect(self._abrir_archivo) self.guardar.triggered.connect(self._guardar_archivo) self.cortar.triggered.connect(self._cortar) self.copiar.triggered.connect(self._copiar) self.pegar.triggered.connect(self._pegar) self.deshacer.triggered.connect(self._deshacer) self.rehacer.triggered.connect(self._rehacer) self.guardar_como.triggered.connect(self._guardar_como) self.salir.triggered.connect(self.close) self.nuevo.triggered.connect(self._nuevo) self.acerca_de.triggered.connect(self._acerca_de)
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"])
class GET(object): JUMP_VAL = 20 _VERSION = '0.1' _helptext = """ GET - %s Geodezyjny Edytor Tekstowy """ def __init__(self, root): self.root = root self.root.title('GET') self.root.geometry('450x200') self.root.bind('<Control-s>', self.save_file_shrt) self.file_path = None self.initialdir = './' self.column_select_var = tk.BooleanVar() self.move_window_var = tk.BooleanVar() self.make_widgets() self.menu_bar() 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') def menu_bar(self): self.menu = tk.Menu(self.root) self.file_menu = tk.Menu(self.menu, tearoff=0) self.file_menu.add_command(label='Otwórz', command=self.open_file) self.file_menu.add_command(label='Zapisz', command=self.save_file, accelerator='Ctrl+S') self.file_menu.add_command(label='Zapisz jako...', command=self.save_file_as) # menu edycji self.edit_menu = tk.Menu(self.menu, tearoff=0) self.edit_menu.add_command(label='Kopiuj', command=self.copy, accelerator='Ctrl+C') self.edit_menu.add_command(label='Wklej', command=self.paste, accelerator='Ctrl+V') self.edit_menu.add_command(label='Wytnij', command=self.cut, accelerator='Ctrl+X') self.edit_menu.add_checkbutton(label='Zaznaczanie blokowe', onvalue=1, offvalue=0, variable=self.column_select_var, command=self.selection_mode) self.edit_menu.add_checkbutton(label='Tryb skokowy', onvalue=1, offvalue=0, variable=self.move_window_var, command=self.move_mode) self.edit_menu.add_command(label='Ustawa skok', command=self.chane_jump_val) # menu operacji na liniach self.line_menu = tk.Menu(self.menu, tearoff=0) self.line_menu.add_command(label='Usuń duplikaty', command=self.text_area.remove_duplicates) # menu operacji na kolumnach self.column_menu = tk.Menu(self.menu, tearoff=0) self.column_menu.add_command(label='Zamiana początkowych kolumn', command=self.text_area.column_swap) self.column_menu.add_command(label='Spłaszczenie danych', command=self.text_area.flat) # pomoc self.help_menu = tk.Menu(self.menu, tearoff=0) self.help_menu.add_command(label='O programie', command=self.help) self.menu.add_cascade(label='Plik', menu=self.file_menu) self.menu.add_cascade(label='Edycja', menu=self.edit_menu) self.menu.add_cascade(label='Linie', menu=self.line_menu) self.menu.add_cascade(label='Kolumny', menu=self.column_menu) self.menu.add_cascade(label='Pomoc', menu=self.help_menu) self.root.config(menu=self.menu) def read_chunk(self): return self.file.read(1024) def open_file(self): self.text_area.clear() self.file_path = askopenfilename(title='Wskaż plik', initialdir=self.initialdir) self.initialdir = os.path.dirname( self.file_path) # to open last opend directory self.file = open(self.file_path) for frag in iter(self.read_chunk, ''): self.text_area.insert(tk.END, frag) self.status_bar.set(self.file_path) def save_file(self): content = self.text_area.get(1.0, tk.END) try: with open(self.file_path, 'w') as save_file: save_file.writelines(content) self.status_bar.set('Zapisano!') except AttributeError: self.save_file_as() def save_file_shrt(self, event): self.save_file() def save_file_as(self): content = self.text_area.get(1.0, tk.END) self.file_path = asksaveasfilename(title='Zapisz plik', initialdir=self.initialdir) if content != '': try: with open(self.file_path, 'w') as save_file: save_file.writelines(content) except FileNotFoundError: showwarning('Uwaga', 'Nie wskazano pliku!!!') def copy(self, event): if self.column_select_var.get(): try: self.root.clipboard_clear() self.root.clipboard_append(self.text_area.block_txt.strip()) except AttributeError: pass else: self.text_area.event_generate("<<Copy>>") return "break" def paste(self, event): if self.column_select_var.get(): try: w, k = self.text_area.index(tk.INSERT).split('.') w_kon, k_kon = self.text_area.index(tk.END).split('.') ran = int(w_kon) - int(w) clipboard = self.root.clipboard_get().split('\n') if ran < len(clipboard): for i in range(0, len(clipboard) - ran): self.text_area.insert(tk.END, '\n' + ' ' * int(k)) for l in range(0, len(clipboard)): wiersz = str(int(w) + l) self.text_area.insert("%s.%s" % (wiersz, k), clipboard[l]) except tk.TclError: pass else: self.text_area.event_generate("<<Paste>>") return "break" def cut(self, event): if self.column_select_var.get(): try: self.root.clipboard_clear() self.root.clipboard_append(self.text_area.block_txt.strip()) for i in range(int(self.text_area.start_row), int(self.text_area.row) + 1): self.text_area.delete( '%s.%s' % (i, self.text_area.start_column), '%s.%s' % (i, self.text_area.column)) except AttributeError: pass else: self.text_area.event_generate("<<Cut>>") return "break" def selection_mode(self, event=None): if self.column_select_var.get(): self.text_area.bind('<ButtonPress-1>', self.text_area.column_select_start) self.text_area.bind('<B1-Motion>', self.text_area.active_choice) self.text_area.bind('<ButtonRelease-1>', self.text_area.column_select) self.text_area.bind('<Control-x>', self.cut) self.text_area.bind('<Control-X>', self.cut) self.text_area.bind('<Control-v>', self.paste) self.text_area.bind('<Control-V>', self.paste) self.text_area.bind('<Control-c>', self.copy) self.text_area.bind('<Control-C>', self.copy) self.text_area.tag_configure("block", background="gainsboro") self.text_area.tag_configure("sel", background='white', foreground='black') else: self.text_area.tag_delete("block") self.text_area.unbind('<ButtonPress-1>') self.text_area.unbind('<B1-Motion>') self.text_area.unbind('<ButtonRelease-1>') self.text_area.tag_configure("sel", background='gainsboro') def chane_jump_val(self): d = Dialog(self.root, jump_val=self.JUMP_VAL, title='Ustaw skok') self.JUMP_VAL = d.result def move(self, event): """ Metoda umożliwiajaca przesuwanie całego okna w pionie, przydatana podczas przepisywania współrzędnych :param event: :return: """ current_x = self.root.winfo_x() current_y = self.root.winfo_y() y = str(int(current_y) + self.JUMP_VAL) self.root.geometry(f'+{current_x}+{y}') def move_mode(self, event=None): if self.move_window_var.get(): self.root.bind('<Return>', self.move) else: self.root.unbind('<Return>') def help(self): showinfo('O programie', self._helptext % (self._VERSION))
class Winged(QWidget): def __init__(self, box, pref): QWidget.__init__(self) self._box = box self.pref = pref vbox = QVBoxLayout(self) hbox = QHBoxLayout() self.btnMyFiles = QPushButton(QIcon(config.images['myfiles']), 'My Files') self.btnFriendFiles = QPushButton(QIcon(config.images['friends']), 'Friends Files') self.btnUpload = QPushButton(QIcon(config.images['upload']), 'Manage/Upload') self.btnFind = QPushButton(QIcon(config.images['search']), 'Find Friends') hbox.addWidget(self.btnMyFiles) hbox.addWidget(self.btnFriendFiles) hbox.addWidget(self.btnUpload) hbox.addWidget(self.btnFind) vbox.addLayout(hbox) self.stack = StackedWidget() self.myFiles = MyFiles(self, self.pref) self.stack.addWidget(self.myFiles) self.friendFiles = FriendFiles(self, self.pref) self.stack.addWidget(self.friendFiles) self.uploadFiles = UploadFiles() self.stack.addWidget(self.uploadFiles) self.inviteFriends = InviteFriends(self) self.stack.addWidget(self.inviteFriends) vbox.addWidget(self.stack) self._status = StatusBar(self) self._status.hide() vbox.addWidget(self._status) self.overlay = Overlay(self) self.overlay.show() self.shortFind = QShortcut(QKeySequence(Qt.CTRL + Qt.Key_F), self) self.connect(self.btnMyFiles, SIGNAL("clicked()"), lambda: self.stack.setCurrentIndex(0)) self.connect(self.btnFriendFiles, SIGNAL("clicked()"), lambda: self.stack.setCurrentIndex(1)) self.connect(self.btnUpload, SIGNAL("clicked()"), lambda: self.stack.setCurrentIndex(2)) self.connect(self.btnFind, SIGNAL("clicked()"), lambda: self.stack.setCurrentIndex(3)) self.connect(self.shortFind, SIGNAL("activated()"), self._status.show_status) self.timer = QTimer(self) self.connect(self.timer, SIGNAL("timeout()"), self.update) self.timer.start(self.pref.get('time', 10) * 1000 * 60) def update(self): self.tempSizeFiles = self.sizeMyFiles self.tempSizeFriends = self.sizeFriendFiles self.thread.executable = self.thread.update_files self.thread.start() def find_friend(self, name): self.thread.api.invite(name) def files_updated(self): self.load_tables() if self.tempSizeFiles != self.sizeMyFiles or self.tempSizeFriends != self.sizeFriendFiles: self.show_tray_message('New Files added!') def find(self, text): widget = self.stack.currentWidget() widget.find(text) def delete(self, data): self.thread.api.delete_file(data) def preview_item(self, link): html = '<html><body><img src="' + link + '"/></body></html>' self.web = Web(self, '', html) self.web.show() def save_file(self, data, folder): self.myFiles._btnDownload.setEnabled(False) self.friendFiles._btnDownload.setEnabled(False) self._status.showMessage('DOWNLOADING...', 2000) self.thread.data = data self.thread.folder = folder self.thread.executable = self.thread.download_file self.thread.start() def load_tables(self): self.overlay.hide() self.myFiles.load_table(self.thread.api.files) self.friendFiles.load_table(self.thread.api.filesFriends) self.sizeMyFiles = len(self.thread.api.files) self.sizeFriendFiles = len(self.thread.api.filesFriends) self._status.hide() def clean_tables(self): rowsCount = range(self.myFiles._table.rowCount()) rowsCount.reverse() for i in rowsCount: self.myFiles._table.removeRow(i) rowsCount = range(self.friendFiles._table.rowCount()) rowsCount.reverse() for i in rowsCount: self.friendFiles._table.removeRow(i) def show(self): self._box.setFixedWidth(800) self._box.setFixedHeight(350) self.thread = Thread(self._box.user, self._box.password) self.thread.executable = self.thread.get_files self.connect(self.thread, SIGNAL("filesList()"), self.load_tables) self.connect(self.thread, SIGNAL("filesUpdated()"), self.files_updated) self.connect(self.thread, SIGNAL("downloadFinished(QString)"), self.download_complete) self.thread.start() self.setVisible(True) def download_complete(self, name): self.show_tray_message('DOWNLOAD COMPLETE: ' + name) self.myFiles._btnDownload.setEnabled(True) self.friendFiles._btnDownload.setEnabled(True) def show_tray_message(self, message): self._box._tray.showMessage('WingedBox', message, QSystemTrayIcon.Information, 2000) def resizeEvent(self, event): self.overlay.resize(event.size()) event.accept()
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')
# 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(),
class MainWindow(QMainWindow): """ Esta es la ventana principal de la App """ 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 __crear_acciones(self): #Menu Archivo self.nuevo = QAction("Nuevo", self) self.nuevo.setShortcut("Ctrl+N") self.nuevo.setIcon(QIcon("images/nuevo.svg")) self.abrir = QAction("Abrir", self) self.abrir.setShortcut("Ctrl+O") self.abrir.setIcon(QIcon("images/abrir.svg")) self.guardar = QAction("Guardar", self) self.guardar.setShortcut("Ctrl+S") self.guardar.setIcon(QIcon("images/guardar.svg")) self.salir = QAction("Salir", self) self.salir.setShortcut("Ctrl+Q") #Menu Editar self.desacer = QAction("Desacer", self) self.desacer.setShortcut("Ctrl+Z") self.desacer.setIcon(QIcon("images/desacer.svg")) self.rehacer = QAction("Rehacer", self) self.rehacer.setShortcut("Ctrl+Y") self.rehacer.setIcon(QIcon("images/rehacer.svg")) self.cortar = QAction("Cortar", self) self.cortar.setShortcut("Ctrl+X") self.cortar.setIcon(QIcon("images/cortar.svg")) self.copiar = QAction("Copiar", self) self.copiar.setShortcut("Ctrl+C") self.copiar.setIcon(QIcon("images/copiar.svg")) self.pegar = QAction("Pegar", self) self.pegar.setShortcut("Ctrl+V") self.pegar.setIcon(QIcon("images/pegar.svg")) #Menu Ayuda self.ayuda = QAction("Documentacion", self) #Menu About self.about = QAction("About", self) self.github = QAction("GitHub", self) self.connect(self.about,QtCore.SIGNAL("triggered()"),self._about) def __crear_menu(self, menu_bar): menu_archivo = menu_bar.addMenu("&Archivo") menu_archivo.addAction(self.nuevo) menu_archivo.addAction(self.abrir) menu_archivo.addAction(self.guardar) menu_archivo.addSeparator() menu_archivo.addAction(self.salir) menu_editar = menu_bar.addMenu("&Editar") menu_editar.addAction(self.desacer) menu_editar.addAction(self.rehacer) menu_editar.addSeparator() menu_editar.addAction(self.cortar) menu_editar.addAction(self.copiar) menu_editar.addAction(self.pegar) menu_ayuda = menu_bar.addMenu("&Ayuda") menu_ayuda.addAction(self.ayuda) menu_about = menu_bar.addMenu("About Us") menu_about.addAction(self.about) menu_about.addAction(self.github) def __crear_Toolbar(self, toolbar): toolbar.addAction(self.nuevo) self.toolbar.setStyleSheet("background-color:#333333;") toolbar.addAction(self.abrir) toolbar.addAction(self.guardar) toolbar.addSeparator() toolbar.addAction(self.cortar) toolbar.addAction(self.copiar) toolbar.addAction(self.pegar) def _about(self): import contact_us as US ventana=US.About_us().exec_() def _abrir_archivo(self): nombre = QFileDialog.getOpenFileName(self, self.tr("Abrir archivo")) if nombre: with open(nombre) as archivo: contenido = archivo.read() self.editor.setPlainText(contenido) self.editor.es_nuevo = False self.editor.nombre = nombre def _guardar_archivo(self): if self.editor.es_nuevo: self._guardar_como() else: contenido = self.editor.toPlainText() with open(self.editor.nombre, 'w') as archivo: archivo.write(contenido) def _guardar_como(self): nombre = QFileDialog.getSaveFileName(self, self.tr("Guardar archivo")) if nombre: contenido = self.editor.toPlainText() with open(nombre, 'w') as archivo: archivo.write(contenido) def _nuevo_archivo(self): #ESTE METODO ME ESTA TIRANDO ERROR #Ya no creo xD? self.filename = QFileDialog.getSaveFileName() if(self.filename == ""): pass else: file = open(self.filename,"w") codigo = self.editor.toPlainText() file.write(codigo) file.close() def _modificado(self, valor): if valor: self.editor.modificado = True else: self.editor.modificao = False def _actualizar_status_bar(self): linea = self.editor.textCursor().blockNumber() + 1 columna = self.editor.textCursor().columnNumber() self.status.actualizar_label(linea, columna) def closeEvent(self, evento): dialog = Dialog(self) dialog.setWindowTitle("Mi Aplicacion") dialog.setText("¿Deseas salir sin guardar?") dialog.show() resultado = dialog.exec_() print(resultado) if resultado == QMessageBox.Ok: evento.accept() else: evento.ignore()
class Qttp(QMainWindow, Ui_MainWindow): 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 prepareMenu(self): menubar = self.menuBar() fileMenu = menubar.addMenu("&File") exitAction = fileMenu.addAction("Exit") exitAction.triggered.connect(self.close) exitAction.setShortcut("Ctrl+Q") def rawTypeChanged(self, rawType): if rawType is not "Text": contentTypeToSet = re.search(r"\(([A-Za-z0-9_/]+)\)", rawType).group(1) self.setContentType(contentTypeToSet) def postBodySwitched(self, button): if button is self.formUrlEncodedButton: self.setContentType("application/x-www-form-urlencoded") elif button is self.binaryButton: self.setContentType("application/octet-stream") elif button is self.formDataButton: self.setContentType("multipart/form-data") if button is self.rawButton: self.comboBox.setEnabled(True) else: self.comboBox.setEnabled(False) if button is self.binaryButton: self.resetBodyEditor() self.currentBodyEditor = self.fileLine elif button is self.formDataButton or button is self.formUrlEncodedButton: self.resetBodyEditor() self.currentBodyEditor = KeyValueEditor() else: self.resetBodyEditor() self.currentBodyEditor = self.requestBody self.verticalLayout_21.addWidget(self.currentBodyEditor) def resetBodyEditor(self): self.currentBodyEditor.setParent(None) def setContentType(self, contentTypeToSet): contentType = self.inputHeaders.findItems("Content-Type", Qt.MatchExactly) if len(contentType) > 0: row = contentType[0].row() else: self.addHeaderRow() row = self.inputHeaders.rowCount() - 1 item = self.inputHeaders.item(row, 1) if not item: headerName = QTableWidgetItem() headerName.setText("Content-Type") self.inputHeaders.setItem(row, 0, headerName) item = QTableWidgetItem() self.inputHeaders.setItem(row, 1, item) self.addHeaderRow() item.setText(contentTypeToSet) def getMainSplitterSizes(self): config = self.config config.read("config.ini") sizes = config["splitter"]["sizes"] if sizes: return [int(s) for s in sizes.split(",")] return [] def prepareConfig(self): config = ConfigParser() config.read("config.ini") if not config.has_section("splitter"): config["splitter"] = {} if not config.has_option("splitter", "sizes"): config["splitter"]["sizes"] = ",".join(map(str, [200, 400, 400])) with open("config.ini", "w") as configfile: config.write(configfile) self.config = config def enableRequestBody(self): bodyTabIndex = self.requestContentTabs.indexOf(self.reqBodyTab) self.requestContentTabs.setTabEnabled(bodyTabIndex, True) def disableRequestBody(self): bodyTabIndex = self.requestContentTabs.indexOf(self.reqBodyTab) self.requestContentTabs.setTabEnabled(bodyTabIndex, False) def onMethodChange(self, httpMethod): if httpMethod == "GET": self.disableRequestBody() else: self.enableRequestBody() def resizeInputHeadersHeader(self): header = self.inputHeaders.horizontalHeader() for column in range(header.count()): header.setSectionResizeMode(column, QHeaderView.Stretch) def forceAddHeaderRow(self): count = self.inputHeaders.rowCount() self.inputHeaders.setRowCount(count + 1) def addHeaderRow(self): count = self.inputHeaders.rowCount() item = self.inputHeaders.item(count - 1, 0) if item: self.inputHeaders.setRowCount(count + 1) def removeHeaderRow(self, item): self.inputHeaders.removeRow(item.row()) def getInputHeaders(self): returnDict = {} rows = self.inputHeaders.rowCount() for row in range(0, rows): key = self.inputHeaders.item(row, 0) value = self.inputHeaders.item(row, 1) if key and value and key.text() and value.text(): returnDict[key.text()] = value.text() return returnDict def buildReqObject(self): method = self.method.currentText() parsedUrl = urlparse(self.url.text()) protocol = parsedUrl.scheme or "https" url = parsedUrl.netloc + parsedUrl.path headers = self.getInputHeaders() if type(self.currentBodyEditor) == KeyValueEditor: body = self.currentBodyEditor.getData() else: body = self.requestBody.toPlainText() rawFile = self.fileLine.getFile() return Req(method, protocol, url, headers, body, rawFile, self.getContext()) def getContext(self): # Temporary stuff return {"url": "api.github.com", "file": "/home/martin/pseudo.txt"} def request(self): self.responseInfo.reset() reqObject = self.buildReqObject() self.thread = ReqThread(reqObject) self.thread.request_done.connect(self.afterRequest) self.thread.request_stopped.connect(self.afterStoppedRequest) self.statusBar.cancel_request.connect(self.thread.stop) self.statusBar.enable() self.thread.start() def afterStoppedRequest(self): self.statusBar.disable() def afterRequest(self, response, reqObject): self.statusBar.disable() self.urlCompleter.addItem(reqObject) self.collectionsHistoryTabs.insertToHistory(response, reqObject) self.responseInfo.translateStatus(response.status_code) self.responseInfo.setTime(response.elapsed.total_seconds()) self.responseInfo.setContentType(response.headers["content-type"]) self.responseTabs.setHeaders(response.headers) self.responseTabs.setResponseBody(response) def saveRequest(self): item = self.buildReqObject() self.collectionsHistoryTabs._saveRequest(item) def setFromHistory(self, req): self.url.setText(req.buildUrl()) index = self.method.findText(req.method) self.method.setCurrentIndex(index) self.setInputHeadersFromHistory(req.headers) self.requestBody.setText(req.body) def setInputHeadersFromHistory(self, headers): self.inputHeaders.setRowCount(0) for key, value in headers.items(): rowCount = self.inputHeaders.rowCount() self.inputHeaders.insertRow(rowCount) self.inputHeaders.setItem(rowCount, 0, QTableWidgetItem(key)) self.inputHeaders.setItem(rowCount, 1, QTableWidgetItem(value)) self.inputHeaders.insertRow(self.inputHeaders.rowCount()) def headersMenu(self, position): menu = QMenu() newAction = menu.addAction("New") deleteAction = menu.addAction("Delete") action = menu.exec_(self.inputHeaders.mapToGlobal(position)) if action == deleteAction: item = self.inputHeaders.itemAt(position) if item: self.removeHeaderRow(item) elif action == newAction: self.forceAddHeaderRow() def closeEvent(self, event): config = self.config config["splitter"]["sizes"] = ",".join( map(str, self.mainSplitter.sizes())) with open("config.ini", "w") as configfile: config.write(configfile) def setTime(self, elapsed_seconds): self.time.setText(str(int(elapsed_seconds * 1000)) + " ms")
class Game: 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 can_start_game(self): return self.selected_their_team is not None and self.our_board.is_valid( ) def start_game(self): self.their_team = self.selected_their_team state = STATE_OUR_TURN if self.our_team_first_move > self.selected_their_team_first_move else STATE_THEIR_TURN self.change_game_state(state) def change_game_state(self, state): self.game_state = state if state == STATE_OUR_TURN: self.status_bar.update_text("It's your move. Good luck!") elif state == STATE_OUR_WIN: self.status_bar.update_text("Congratulations! You win!") elif state == STATE_THEIR_WIN: self.status_bar.update_text("You lost. Maybe next time.") else: self.status_bar.update_text( 'Waiting for %s to make their move...' % self.their_team) pygame.event.post( pygame.event.Event( pygame.USEREVENT, dict(action=ACTION_GAME_STATE_CHANGED, state=state))) def handle_event(self, event): if event.type == pygame.KEYDOWN: print("Down!") elif event.type == pygame.MOUSEBUTTONUP: if self.save_positions_button.check_click(event.pos[0], event.pos[1]) == HANDLED: pass elif self.load_positions_button.check_click( event.pos[0], event.pos[1]) == HANDLED: pass elif self.game_state == STATE_PREPARING \ and self.our_board.toggle_ship_click(event.pos[0], event.pos[1]) == HANDLED: self.start_game_button.set_enabled(self.can_start_game()) else: if self.game_state == STATE_PREPARING: self.teams.check_click(event.pos[0], event.pos[1]) self.start_game_button.check_click(event.pos[0], event.pos[1]) else: self.their_board.make_move_click(event.pos[0], event.pos[1]) elif event.type == pygame.USEREVENT: if event.action == ACTION_FIND_ME: if not event.team == self.our_team: self.teams.found_team(event.team, event.row) elif event.action == ACTION_HIT and event.team == self.their_team: self.their_board.record_hit(event.row, event.col) if self.their_board.is_wiped_out(): self.change_game_state(STATE_OUR_WIN) else: self.change_game_state(STATE_THEIR_TURN) elif event.action == ACTION_MAKE_MOVE and self.game_state == STATE_OUR_TURN: self.messages_to_send.put( '%s|%s|%d|%d' % (self.our_team, ACTION_MOVE, event.row, event.col)) elif event.action == ACTION_MISS and event.team == self.their_team: self.their_board.record_miss(event.row, event.col) self.change_game_state(STATE_THEIR_TURN) elif event.action == ACTION_MOVE: if event.team == self.their_team and self.our_board.check_move( event.row, event.col) == HANDLED: if self.our_board.is_wiped_out(): self.change_game_state(STATE_THEIR_WIN) else: self.change_game_state(STATE_OUR_TURN) elif event.action == ACTION_SELECT_TEAM: self.selected_their_team = event.team self.selected_their_team_first_move = event.first_move_number self.start_game_button.set_enabled(self.can_start_game()) elif event.action == ACTION_STATUS: self.status_bar.update_text(event.text) elif event.action == ACTION_WE_GOT_HIT: self.messages_to_send.put( '%s|%s|%d|%d' % (self.our_team, ACTION_HIT, event.row, event.col)) elif event.action == ACTION_WE_WERE_MISSED: self.messages_to_send.put( '%s|%s|%d|%d' % (self.our_team, ACTION_MISS, event.row, event.col)) self.screen.fill(DARK_BLUE) self.our_board.draw(self.screen) self.status_bar.draw(self.screen) if self.game_state == STATE_PREPARING: self.save_positions_button.draw(self.screen) self.load_positions_button.draw(self.screen) self.start_game_button.draw(self.screen) self.teams.draw(self.screen) else: self.their_board.draw(self.screen)
class MainWindow(QMainWindow): def __init__(self): super(MainWindow, self).__init__() self.setWindowTitle(self.tr("Editor - PyQt4")) self.setMinimumSize(700,500) #MenuBar menu = self.menuBar() self.__crear_acciones() self.__crear_menu(menu) #Widget central self.editor = Editor() self.editor.modificationChanged[bool].connect(self._modificado) self.editor.cursorPositionChanged.connect(self._actualizar_status_bar) self.setCentralWidget(self.editor) #ToolBar self.toolbar = QToolBar() self.__crear_toolbar(self.toolbar) #agregamos a la pagina principal el toolbar self.addToolBar(Qt.LeftToolBarArea, self.toolbar) #StatusBar self.status = StatusBar() self.setStatusBar(self.status) #Conexiones self.abrir.triggered.connect(self._abrir_archivo) self.guardar.triggered.connect(self._guardar_archivo) self.cortar.triggered.connect(self._cortar) self.copiar.triggered.connect(self._copiar) self.pegar.triggered.connect(self._pegar) self.deshacer.triggered.connect(self._deshacer) self.rehacer.triggered.connect(self._rehacer) self.guardar_como.triggered.connect(self._guardar_como) self.salir.triggered.connect(self.close) self.nuevo.triggered.connect(self._nuevo) self.acerca_de.triggered.connect(self._acerca_de) def __crear_acciones(self): self.nuevo = QAction("Nuevo", self) self.nuevo.setIcon(QIcon("imagenes/nuevo.png")) self.nuevo.setShortcut("Ctrl+N") self.abrir = QAction("Abrir", self) self.abrir.setIcon(QIcon("imagenes/abrir.png")) self.abrir.setShortcut("Ctrl+O") self.guardar = QAction("Guardar", self) self.guardar.setIcon(QIcon("imagenes/guardar.png")) self.guardar.setShortcut("Ctrl+S") self.guardar_como = QAction("Guardar Como", self) self.salir = QAction("Salir", self) self.deshacer = QAction("Deshacer", self) self.deshacer.setIcon(QIcon("imagenes/deshacer.png")) self.deshacer.setShortcut("Ctrl+Z") self.rehacer = QAction("Rehacer", self) self.rehacer.setIcon(QIcon("imagenes/rehacer.png")) self.rehacer.setShortcut("Ctrl+Y") self.cortar = QAction("Cortar", self) self.cortar.setIcon(QIcon("imagenes/cortar.png")) self.cortar.setShortcut("Ctrl+X") self.copiar = QAction("Copiar", self) self.copiar.setIcon(QIcon("imagenes/copiar.png")) self.copiar.setShortcut("Ctrl+C") self.pegar = QAction("Pegar", self) self.pegar.setIcon(QIcon("imagenes/pegar.png")) self.pegar.setShortcut("Ctrl+V") self.acerca_de = QAction("Acerca de", self) def __crear_menu(self, menu_bar): menu_archivo = menu_bar.addMenu("&Archivo") menu_archivo.addAction(self.nuevo) menu_archivo.addAction(self.abrir) menu_archivo.addAction(self.guardar) menu_archivo.addAction(self.guardar_como) menu_archivo.addSeparator() menu_archivo.addAction(self.salir) menu_editar = menu_bar.addMenu("&Editar") menu_editar.addAction(self.deshacer) menu_editar.addAction(self.rehacer) menu_editar.addSeparator() menu_editar.addAction(self.cortar) menu_editar.addAction(self.copiar) menu_editar.addAction(self.pegar) menu_ayuda = menu_bar.addMenu("A&yuda") menu_ayuda.addAction(self.acerca_de) def __crear_toolbar(self, toolbar): toolbar.addAction(self.nuevo) toolbar.addAction(self.abrir) toolbar.addAction(self.guardar) toolbar.addSeparator() toolbar.addAction(self.cortar) toolbar.addAction(self.copiar) toolbar.addAction(self.pegar) def _abrir_archivo(self): nombre = QFileDialog.getOpenFileName(self, self.tr("Abrir Archivo")) if nombre: if not self.editor.modificado: self.__abrir_archivo(nombre) else: flags = QMessageBox.Yes flags |= QMessageBox.No flags |= QMessageBox.Cancel r = QMessageBox.information(self, self.tr("Modificado"), self.tr("No se ha guardado el archivo"), flags) if r == QMessageBox.Yes: self._guardar_archivo() self.__abrir_archivo(nombre) elif r == QMessageBox.No: self.__abrir_archivo(nombre) else: return def __abrir_archivo(self, nombre): with open(nombre) as archivo: contenido = archivo.read() self.editor.setPlainText(contenido) self.editor.es_nuevo = False self.editor.nombre = nombre def _guardar_archivo(self): if self.editor.es_nuevo: self._guardar_como() else: contenido=self.editor.toPlainText() with open(self.editor.nombre, "w") as archivo: archivo.write(contenido) def _guardar_como(self): nombre = QFileDialog.getSaveFileName(self, self.tr("Gardar archivo")) if nombre: contenido = self.editor.toPlainText() with open(nombre, "w") as archivo: archivo.write(contenido) def _actualizar_status_bar(self): linea = self.editor.textCursor().blockNumber() columna = self.editor.textCursor().columnNumber() self.status.actualizar_label(linea, columna) def closeEvent(self, evento): flags = QMessageBox.Yes flags |= QMessageBox.No flags |= QMessageBox.Cancel r = QMessageBox.information(self, self.tr("Modificado"), self.tr("Cerrar la aplicacion sin guardar?"), flags) if r == QMessageBox.Yes: self._guardar_archivo() elif r == QMessageBox.No: evento.accept() else: evento.ignore() def _modificado(self, valor): if valor: self.editor.modificado = True else: self.editor.modificado = False def _cortar(self): self.editor.cut() def _copiar(self): self.editor.copy() def _pegar(self): self.editor.paste() def _deshacer(self): self.editor.undo() def _rehacer(self): self.editor.redo() def _nuevo(self): if not self.editor.modificado: self.editor.es_nuevo = True self.editor.setPlainText("") else: flags = QMessageBox.Yes flags |= QMessageBox.No flags |= QMessageBox.Cancel r = QMessageBox.information(self, self.tr("Modificado"), self.tr("No se ha guardado el archivo"), flags) if r == QMessageBox.Yes: self._guardar_archivo() elif r == QMessageBox.No: self.editor.es_nuevo = True self.editor.setPlainText("") else: return def _acerca_de(self): QMessageBox.information(self, self.tr("Realizado por"), "<h2>Ing. Diego Guerrero</h2><h3>Venezuela</h3>" )
class Player(): 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 load_background(self): self.background_image = get_background_image(self.levels[self.level], self.track_size['width'], self.track_size['height']) # def speak(self): # self.speak_sound.play(maxtime=250) # def jiggle(self): # # center = self.image.get_rect().center # self.image = pygame.transform.rotate(self.original_image, self.angle) # self.angle += 10 # # self.rect = self.image.get_rect(center=center) def finished_level(self): self.level += 1 if self.level == len(self.levels): self.complete = True # Move the sprite based on user keypresses def update(self, pressed_keys, screen): # If done don't do anything if (self.complete): return # Draw background screen.blit(self.background_image, (0, self.y)) # Compute speed if pressed_keys[K_q]: self.speed = max(self.speed - 1, self.min_speed) # self.speak() elif pressed_keys[K_w]: self.speed = min(self.speed + 1, self.max_speed) # self.speak() # Draw player # self.rect.move_ip(self.speed, 0) self.body.update(self.speed) self.legs_front.update(self.speed) self.legs_back.update(self.speed) # Draw all sprites for entity in self.sprites: screen.blit(entity.image, entity.rect) # Status bar self.status_bar.update(self.speed / self.max_speed, screen) # Detect completion of level if self.rect.right > self.track_size['width']: self.finished_level() print(self.level)
class MainWindow(Tk): 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 mouse_move(self, event): x = event.x + self.x_scrollbar.get()[0] * self.img.shape[1] y = event.y + self.y_scrollbar.get()[0] * self.img.shape[0] x = int(x * self.display_scale) y = int(y * self.display_scale) s = f'XY = ({x}, {y})' self.status_bar.set_status(s) def mouse_wheel(self, event): if event.num == 5 or event.delta == -120: self.zoom_out() if event.num == 4 or event.delta == 120: self.zoom_in() def left_click(self, event): x = event.x + self.x_scrollbar.get()[0] * self.img.shape[1] y = event.y + self.y_scrollbar.get()[0] * self.img.shape[0] x = int(x * self.display_scale) y = int(y * self.display_scale) msg = 'Please enter comma-separated landmark properties in format:\n' msg += '\nLandmarkName,CODE,radius,color\n\n' msg += 'e.g.\nCarpiquet,CQ,58,cyan\nEvreux,ER,46,yellow\n' title = 'Adding landmark' landmark_string = self.request_landmark_string(title, msg) if not landmark_string: return landmark_string += f',{x},{y}' val = self.info_bar.landmarks.get() landmarks = list(eval(val)) if val else list() landmarks.append(landmark_string) landmarks.sort() self.info_bar.landmarks.set(landmarks) self.update_preview() def right_click(self, event): x = event.x + self.x_scrollbar.get()[0] * self.img.shape[1] y = event.y + self.y_scrollbar.get()[0] * self.img.shape[0] x = int(x * self.display_scale) y = int(y * self.display_scale) sh = self.info_bar.slide_height.get() sw = int(sh / 1.5) left = max(1, min(x - sw // 2, self.img.shape[1] - sw - 1)) top = max(1, min(y - sh // 2, self.img.shape[0] - sh - 1)) center_xy = (left + sw // 2, top + sh // 2) self.info_bar.slide_centers.append(center_xy) self.update_preview() def pop_slide_center(self, _=None): if self.info_bar.slide_centers: self.info_bar.slide_centers.pop() self.update_preview() def add_connection(self, _=None): msg = 'Please enter two comma-separated landmark codes:\n' msg += '\nCODE1,CODE2\n\n' msg += 'e.g.\nCQ,ER\n' title = 'Adding connection' connection_string = self.request_connection_string(title, msg) if not connection_string: return val = self.info_bar.connections.get() connections = list(eval(val)) if val else list() connections.append(connection_string) connections.sort() self.info_bar.connections.set(connections) self.update_preview() def request_landmark_string(self, title, msg, initial_value='Name,CODE,50,yellow'): landmark_string = None while True: try: landmark_string = askstring(title, msg, initialvalue=initial_value, parent=self) except: pass if not landmark_string: break check_message = self.validate_landmark_string(landmark_string) if check_message: initial_value = landmark_string landmark_string = None messagebox.showwarning('Wrong landmark string', check_message) else: break return landmark_string def request_connection_string(self, title, msg, initial_value='L1,L2'): connection_string = None while True: try: connection_string = askstring(title, msg, initialvalue=initial_value) except: pass if not connection_string: break check_message = self.validate_connection_string(connection_string) if check_message: initial_value = connection_string connection_string = None messagebox.showwarning('Wrong connection string', check_message) else: break return connection_string @staticmethod def validate_landmark_string(s): parts = s.split(',') if len(parts) != 4: return 'There mut be 4 comma-separated values' try: i = int(parts[2]) if i < 1: raise Exception('.') except: msg = f'"{parts[2]}" is not a valid positive integer\n\n' msg += 'Third value must be positive integer' return msg try: ImageColor.getrgb(parts[3]) except: msg = f'"{parts[3]}" is not a valid color string\n\n' msg += 'Fourth value must be a valid color name (e.g. "red", "blue", "cyan", "yellow", "magenta", ...)' return msg return None @staticmethod def validate_connection_string(s): parts = s.split(',') if len(parts) != 2: return 'There mut be 2 comma-separated values' return None def zoom_in(self, _=None): if self.display_scale > self.min_display_scale: self.display_scale //= 2 self.update_preview() self.info_bar.update_info() def zoom_out(self, _=None): if self.display_scale < self.max_display_scale: self.display_scale *= 2 self.update_preview() self.info_bar.update_info() def save_info(self, _=None): info_path = os.path.splitext(self.file_path)[0] + '_info.json' info = {'landmarks': [s for s in self.info_bar.listbox_landmarks.get(0, last=END)], 'connections': [s for s in self.info_bar.listbox_connections.get(0, last=END)], 'scale_kilometers_per_pixel': self.info_bar.scale_kilometers_per_pixel.get(), 'slide_height': self.info_bar.slide_height.get(), 'slide_centers': self.info_bar.slide_centers, 'draw': {'landmarks': self.info_bar.draw_landmarks.get(), 'connections': self.info_bar.draw_connections.get(), 'angles': self.info_bar.draw_angles.get(), 'distances': self.info_bar.draw_distances.get()} } with open(info_path, 'wt') as f: json.dump(info, f, indent=2) self.status_bar.set_status('Image info saved') def open_image(self, _=None): formats = '*.jpg *.png *.bmp *.jpeg *.JPG *.JPEG *.PNG *.BMP' file_types = (('Image files', formats), ('All Files', '*.*')) file_path = askopenfilename(initialdir='test_data/', filetypes=file_types, title='Choose a file.') if not file_path: return try: img = io.imread(file_path) self.file_path = file_path self.img = img self.status_bar.set_status('Image loaded') except Exception as e: self.status_bar.set_status('Image load failed') msg = f'Failed to read image from "{file_path}":\n\n{str(e)}' messagebox.showwarning('Failed to read image', msg) info_path = os.path.splitext(file_path)[0] + '_info.json' if not os.path.isfile(info_path): self.info_bar.update_info() self.update_preview() return try: with open(info_path,'rt') as f: info = json.load(f) self.info_bar.landmarks.set(info['landmarks']) self.info_bar.connections.set(info['connections']) self.info_bar.scale_kilometers_per_pixel.set(info['scale_kilometers_per_pixel']) self.info_bar.slide_height.set(info['slide_height']) self.info_bar.slide_centers = info['slide_centers'] self.info_bar.draw_landmarks.set(info['draw']['landmarks']) self.info_bar.draw_connections.set(info['draw']['connections']) self.info_bar.draw_angles.set(info['draw']['angles']) self.info_bar.draw_distances.set(info['draw']['distances']) self.info_bar.sld_slide_size.config(from_=self.img.shape[0] // 4, to=self.img.shape[0] - 2) self.info_bar.update_info() self.update_preview() except Exception as e: self.status_bar.set_status('Image info load failed') msg = f'Failed to read image info from "{file_path}":\n\n{str(e)}' messagebox.showwarning('Failed to read image info', msg) def update_preview(self, _=None): preview = PIL_Image.fromarray(self.img) if self.info_bar.draw_landmarks.get(): draw_landmarks(self, preview) if self.info_bar.draw_connections.get(): draw_connections(self, preview) draw_slides(self, preview) size = (preview.size[0] // self.display_scale, preview.size[1] // self.display_scale) preview.thumbnail(size) preview = ImageTk.PhotoImage(preview) self.preview_canvas.create_image(0, 0, image=preview, anchor=NW) self.preview_canvas.config(scrollregion=(0, 0, size[0], size[1])) self.preview = preview def set_image_scale(self, _=None): value = askfloat('Enter image scale', 'Enter image pixel size in kilometers', initialvalue=self.info_bar.scale_kilometers_per_pixel.get()) if value: self.info_bar.scale_kilometers_per_pixel.set(value) self.update_preview() def export_slides(self, _=None): self.status_bar.set_status('Exporting ...') preview = PIL_Image.fromarray(self.img) if self.info_bar.draw_landmarks.get(): draw_landmarks(self, preview) if self.info_bar.draw_connections.get(): draw_connections(self, preview) sts = DisplaySettings() us = sts.export_upsize order = sts.export_interpolation_order out_dir = os.path.splitext(self.file_path)[0] + '_slides' os.makedirs(out_dir, exist_ok=True) img = np.array(preview) for i, xy in enumerate(self.info_bar.slide_centers): sh = self.info_bar.slide_height.get() sw = int(sh / 1.5) left = max(1, min(xy[0] - sw // 2, self.img.shape[1] - sw - 1)) top = max(1, min(xy[1] - sh // 2, self.img.shape[0] - sh - 1)) slide = img[top:top + sh, left:left + sw] slide = resize(slide, (slide.shape[0] * us, slide.shape[1] * us), order=order) slide = (slide * 255).astype(np.uint8) slide_path = os.path.join(out_dir, 'slide_%02i.jpg' % i) io.imsave(slide_path, slide) draw_slides(self, preview) preview = np.array(preview) preview = resize(preview, (preview.shape[0] * us, preview.shape[1] * us), order=order) preview = (preview * 255).astype(np.uint8) preview_path = os.path.join(out_dir, 'preview.jpg') io.imsave(preview_path, preview) msg = f'The slides have been exported to "{out_dir}"' messagebox.showinfo('Export finished', msg)
class IDE(QMainWindow, IDEGeneric): max_opacity = 1 min_opacity = 0.3 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 show_status_message(self, message): self._status.showMessage(message, 2000) def add_toolbar_item(self, plugin, name, icon): self._toolbar.addSeparator() action = self._toolbar.addAction(QIcon(icon), name) self.connect(action, SIGNAL("triggered()"), lambda: plugin.toolbarAction()) def closeEvent(self, event): settings = QSettings('NINJA-IDE','Kunai') if settings.value('Preferences/General/load_files', 2).toInt()[0]==2: settings.setValue('Open_Files/projects',self.main.get_open_projects()) settings.setValue('Open_Files/tab1', self.main._central._tabs.get_open_files()) settings.setValue('Open_Files/tab2', self.main._central._tabs2.get_open_files()) else: settings.setValue('Open_Files/projects',[]) if self.main._central.check_for_unsaved(): val = QMessageBox.question(self, 'Some changes were not saved', 'Do you want to exit anyway?', QMessageBox.Yes, QMessageBox.No) if val == QMessageBox.No: event.ignore() else: self.main._properties._treeProjects.close_open_projects() else: self.main._properties._treeProjects.close_open_projects() def wheelEvent(self, event): if event.modifiers() == Qt.AltModifier: if event.delta() == 120 and self.opacity < self.max_opacity: self.opacity += 0.1 elif event.delta() == -120 and self.opacity > self.min_opacity: self.opacity -= 0.1 self.setWindowOpacity(self.opacity) event.ignore() else: super(IDE, self).wheelEvent(event)
class MainWindow(gtk.Window): __gsignals__ = { # Emitted when the window is closed and a new target is being requested "change-target": (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, tuple()), } # Number of ms between screen refreshes REFRESH_INTERVAL = 300 # Default window size on start DEFAULT_SIZE = (1024, 768) def __init__(self, system): """ A main-window which contains controls, error logs, and register & memory viewers. """ gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL) self.system = system # Number of log entries received while the log-viewer was collapsed self.unread_log_entries = 0 # A list of peripheral viewer widgets self.periph_viewers = [] # A list of extra memory-viewer windows self.memory_viewers = [] # A list of extra register-viewer windows self.register_viewers = [] # A flag which can be set to kill the refresh loop self.killed = False # Set the window icon self.set_icon_list(*about.get_icon_list()) # General components self.control_bar = ControlBar(self.system) self.register_viewer = RegisterViewer(self.system) self.log_viewer = LogViewer(self.system) self.status_bar = StatusBar(self.system) # Two memory viewers, one disassembly view by default, one not self.memory_viewer_top = MemoryViewer(self.system, True) self.memory_viewer_btm = MemoryViewer(self.system, False) # Placeholder messages self._init_placeholders() # Set up keyboard shortcuts self.add_accel_group(self.control_bar.accelerators) # Propagate out refreshes when the device's state is changed self.control_bar.connect("device-state-changed", self._on_device_state_changed) self.register_viewer.connect("edited", self._on_device_state_changed) self.memory_viewer_top.connect("edited", self._on_device_state_changed) self.memory_viewer_btm.connect("edited", self._on_device_state_changed) # Calls from the control bar self.control_bar.connect("refresh-clicked", self._on_device_state_changed) self.control_bar.connect("select-target-clicked", self._on_select_target_clicked) self.control_bar.connect("quit-clicked", self._on_quit_clicked) self.control_bar.connect("new-memory-viewer-clicked", self._on_new_viewer_clicked, MemoryViewer, self.memory_viewers, "Memory Viewer") self.control_bar.connect("new-register-viewer-clicked", self._on_new_viewer_clicked, RegisterViewer, self.register_viewers, "Register Viewer") self._init_gui() self._init_adjustments() # A recurring call which is used to refresh the display glib.timeout_add(MainWindow.REFRESH_INTERVAL, self._on_interval) # Load up all architecture-specific stuff self._architecture_changed() def _init_placeholders(self): """ Create the placeholder messages which may be shown. """ self.unknown_device_placeholder = Placeholder( "Unknown Architecture", "The connected device's architecture is unknown. "+ "Peripherals and general board functions may still " + "be used but register banks and memories cannot be " + "accessed.", gtk.STOCK_DIALOG_WARNING) self.no_reg_or_mem_placeholder = Placeholder( "No Register Banks or Memories", "The connected device does not have any known register banks "+ "or memories.", gtk.STOCK_DIALOG_WARNING) def _remove_main_widgets(self): """ Remove all main widgets (and any container they're in). """ top_level_containers = set() # Scan each widget removing it from its container and checking if it is not # the vbox. for widget in (self.register_viewer, self.mem_panes, self.unknown_device_placeholder, self.no_reg_or_mem_placeholder): parent = widget.get_parent() if parent is not None: # Remove the widget from wherever it is contained parent.remove(widget) # Was this widget is contained in some sub-container if parent is not self.vbox: top_level_containers.add(parent) # Remove the top-level containers for container in top_level_containers: self.vbox.remove(container) container.destroy() def _set_mem_reg_visible(self, enable_memory_viewer, enable_register_viewer): """ Will show the memory and/or register viewer widgets (or a placeholder) in the main window. """ self._remove_main_widgets() # The widget to insert into the main space of the window top_level_widget = None if enable_memory_viewer and enable_register_viewer: # Both memory and registers are visible, show them in two panes top_level_widget = gtk.HPaned() top_level_widget.pack1(self.register_viewer, shrink = False) top_level_widget.pack2(self.mem_panes, shrink = False) elif enable_memory_viewer: # Only the memory viewer is enabled top_level_widget = self.mem_panes elif enable_register_viewer: # Only the register viewer is enabled top_level_widget = self.register_viewer elif self.system.architecture is not None: # The architecture doesn't feature either memory or registers top_level_widget = self.no_reg_or_mem_placeholder else: # The architecture is unknown top_level_widget = self.unknown_device_placeholder # Insert the widget into the main slot of the window self.vbox.pack_start(top_level_widget, expand = True, fill = True) self.vbox.reorder_child(top_level_widget, 1) top_level_widget.show_all() def _init_gui(self): """ Set up the GUI and all its widgets! """ # Default window size self.set_default_size(*MainWindow.DEFAULT_SIZE) self.vbox = gtk.VBox() self.add(self.vbox) # Add the control/menu bar self.vbox.pack_start(self.control_bar, expand = False, fill = True) # Add a movable division between the register and memory viewers reg_mem_panes = gtk.HPaned() self.vbox.pack_start(reg_mem_panes, expand = True, fill = True) # Add the register viewer reg_mem_panes.pack1(self.register_viewer, shrink = False) # Add a movable division between the two memory viewers self.mem_panes = gtk.VPaned() reg_mem_panes.pack2(self.mem_panes, shrink = False) # Display the memory viewers self.mem_panes.pack1(self.memory_viewer_top, resize = True, shrink = False) self.mem_panes.pack2(self.memory_viewer_btm, resize = True, shrink = False) # Ensure the log viewer is a decent size self.log_viewer.set_size_request(-1, 200) # Add an expander with a log viewer in self.log_expander = gtk.Expander("Error Log") self.log_expander.add(self.log_viewer) self.log_expander.set_use_markup(True) self.vbox.pack_start(self.log_expander, expand = False, fill = True) # Expand the viewer if a flagged entry arrives self.log_viewer.connect("update", self._on_log_update) # Clear the unread counter when shown self.log_expander.connect("activate", self._on_log_update, None) # Add a status-bar self.vbox.pack_start(self.status_bar, fill=True, expand=False) # Tick the auto-refresh box self.control_bar.auto_refresh_button.set_active(True) # Quit when closing this window self.connect("destroy", self._on_quit_clicked) def _init_adjustments(self): """ Add all background process progress adjustments to the status-bar. """ # Memory image loading self.status_bar.add_adjustment( ControlBar.loader_background_decorator.get_adjustment(self.control_bar), "Loading Memory Image" ) # Assembler self.status_bar.add_adjustment( ControlBar.assembler_background_decorator.get_adjustment(self.control_bar), "Assembling File" ) def _make_container_window(self, title, widget, icon = None, size = None): """ Make a simple window containing a widget. """ periph_window = gtk.Window() periph_window.set_transient_for(self) periph_window.add(widget) periph_window.set_title(title) if icon is not None: periph_window.set_icon(icon) if size is not None: periph_window.set_default_size(*size) # Share main window's keyboard shortcuts periph_window.add_accel_group(self.control_bar.accelerators) return periph_window def _init_periph(self, periph_num, periph_id, periph_sub_id, name, PeripheralWidget): """ Instantiate and create a window for this peripheral viewer and hook up all events. """ periph_widget = PeripheralWidget(self.system, periph_num, periph_id, periph_sub_id) periph_widget.connect("global-refresh", self._on_device_state_changed) self.periph_viewers.append(periph_widget) # Create a window to display the widget periph_window = self._make_container_window(periph_widget.get_name(), periph_widget, periph_widget.get_icon(gtk.ICON_SIZE_MENU)) # Prevent being closed (just hide) def on_close(window, event): # Don't close the window, just hide it window.hide() return True periph_window.connect("delete-event", on_close) # Add toolbar button to show the window def show_periph_window(button): periph_window.show_all() periph_window.present() self.control_bar.add_periph(periph_widget, show_periph_window) # Add progress monitors for adjustment, name in periph_widget.get_progress_adjustments(): self.status_bar.add_adjustment(adjustment, name) def _destroy_periph(self, periph_widget): """ Destroy a periph_widget and disconnect everything. """ periph_window = periph_widget.get_parent() # Disconnect all the adjustments adjustments = periph_widget.get_progress_adjustments() for adjustment in adjustments: self.status_bar.remove_adjustment(adjustment) # Remove from the control bar self.control_bar.remove_periph(periph_widget) # Close the window periph_window.destroy() @RunInBackground() def _update_peripherals(self): """ Update the peripheral viewers. """ # Get the periph list in another thread periph_ids = self.system.get_peripheral_ids() # Return to the GTK thread yield # A list of periph_id/periph_sub_id pairs in the same order as the list of # periph_viewers for lookups. Entries which have been updated are replaced # with None to flag them as being up-to-date. cur_periph_ids = [(p.periph_id, p.periph_sub_id) for p in self.periph_viewers] for periph_num, (periph_id, periph_sub_id) in enumerate(periph_ids): if (periph_id, periph_sub_id) in cur_periph_ids: # A viewer already been created for this widget, make sure its # peripheral number is up-to-date index = cur_periph_ids.index((periph_id, periph_sub_id)) self.periph_viewers[index].architecture_changed(periph_num) # Widget has been updated cur_periph_ids[index] = None else: # No viewer exists, create one (if possible) name, PeripheralWidget = get_peripheral_view(periph_id, periph_sub_id) if PeripheralWidget is not None: self._init_periph(periph_num, periph_id, periph_sub_id, name, PeripheralWidget) # Remove any old peripherals which still remain for index, periph_ids in list(enumerate(cur_periph_ids))[::-1]: # If the periph_ids has not been cleared to None, it was not updated and # thus the corresponding widget should be destroyed. if periph_ids is not None: periph_viewer = self.periph_viewers.pop(index) self._destroy_periph(periph_viewer) def _on_interval(self): """ Callback called at a regular interval. Update the screen. """ # Die if killed if self.killed: return False # If auto-refresh is enabled, do it! if self.control_bar.auto_refresh_button.get_active(): self.refresh() # Reschedule the interval return True def _on_log_update(self, widget, flag): """ Called when a new log item appears. If it is flagged, expand the log viewer. """ if flag: self.log_expander.set_expanded(True) if self.log_expander.get_expanded(): # Viewer expanded self.unread_log_entries = 0 else: if flag is not None: # Flag is none on activate self.unread_log_entries += 1 if self.unread_log_entries > 0: self.log_expander.set_label("<b>Error Log (%d)</b>"%self.unread_log_entries) else: self.log_expander.set_label("Error Log") def _on_device_state_changed(self, *args): """ Emitted whenever a change occurs to the device which may cause changes in all widgets and thus should force a global refresh. """ self.refresh() def _on_select_target_clicked(self, btn): """ Close this window and re-show the initial target selection window. """ for viewer in self.memory_viewers + self.register_viewers + self.periph_viewers: window = viewer.get_parent() window.destroy() # Stop the refresh timer self.killed = True self.handler_block_by_func(self._on_quit_clicked) self.emit("change-target") self.destroy() def _on_quit_clicked(self, btn): """ Quit the program, NOW! """ gtk.main_quit() def _on_new_viewer_clicked(self, btn, ViewerType, viewer_list, title): """ Create a new viewer in a window. ViewerType is a class which implements a viewer widget. viewer_list is a list to which the viewer widget will be added and then removed when the window is closed. title is a title for the window. """ viewer = ViewerType(self.system) def on_close(window, event, viewer): viewer_list.remove(viewer) window = self._make_container_window(title, viewer, size = (600,500)) window.connect("delete-event", on_close, viewer) window.show_all() viewer.refresh() viewer_list.append(viewer) @RunInBackground() def refresh(self): """ Refresh all widgets' data """ self.system.clear_cache() # Check to see if the architecture changed board_changed = self.system.get_board_definition_changed() if board_changed: self.system.update_architecture() # Return to GTK thread yield if board_changed: self.architecture_changed() return # Board didn't change, just refresh as-per-usual self.control_bar.refresh() self.status_bar.refresh() # Don't update the register windows unless we actually have some if self.system.architecture is not None: if self.system.architecture.memories: self.memory_viewer_top.refresh() self.memory_viewer_btm.refresh() if self.system.architecture.register_banks: self.register_viewer.refresh() # Update all viewer widgeglobal-refresh for viewer in self.memory_viewers + self.register_viewers + self.periph_viewers: viewer.refresh() def _architecture_changed(self): """ Local version for just the MainWindow's own widgets. Does not propogate out. Called when the architecture changes, deals with all the architecture-specific changes which need to be made to the GUI. """ # Set the window title self.set_title("%s (%s) — %s v%s"%( (self.system.architecture.name if self.system.architecture is not None else "Unknown Architecture"), self.system.back_end.name, about.NAME, about.VERSION, )) # Update the peripherals available self._update_peripherals() # Display the appropriate main viewers (or display a placeholder) enable_memory_viewer = False enable_register_viewer = False if self.system.architecture is not None: enable_memory_viewer = len(self.system.architecture.memories) > 0 enable_register_viewer = len(self.system.architecture.register_banks) > 0 self._set_mem_reg_visible(enable_memory_viewer, enable_register_viewer) self.refresh() def architecture_changed(self): """ Called when the architecture changes, deals with all the architecture-specific changes which need to be made to the GUI. """ # Update this window's widgets self._architecture_changed() # Propogate to widgets self.control_bar.architecture_changed() self.register_viewer.architecture_changed() self.log_viewer.architecture_changed() self.status_bar.architecture_changed() self.memory_viewer_top.architecture_changed() self.memory_viewer_btm.architecture_changed() for viewer in self.memory_viewers + self.register_viewers: viewer.architecture_changed()
def __init__(self, system): """ A main-window which contains controls, error logs, and register & memory viewers. """ gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL) self.system = system # Number of log entries received while the log-viewer was collapsed self.unread_log_entries = 0 # A list of peripheral viewer widgets self.periph_viewers = [] # A list of extra memory-viewer windows self.memory_viewers = [] # A list of extra register-viewer windows self.register_viewers = [] # A flag which can be set to kill the refresh loop self.killed = False # Set the window icon self.set_icon_list(*about.get_icon_list()) # General components self.control_bar = ControlBar(self.system) self.register_viewer = RegisterViewer(self.system) self.log_viewer = LogViewer(self.system) self.status_bar = StatusBar(self.system) # Two memory viewers, one disassembly view by default, one not self.memory_viewer_top = MemoryViewer(self.system, True) self.memory_viewer_btm = MemoryViewer(self.system, False) # Placeholder messages self._init_placeholders() # Set up keyboard shortcuts self.add_accel_group(self.control_bar.accelerators) # Propagate out refreshes when the device's state is changed self.control_bar.connect("device-state-changed", self._on_device_state_changed) self.register_viewer.connect("edited", self._on_device_state_changed) self.memory_viewer_top.connect("edited", self._on_device_state_changed) self.memory_viewer_btm.connect("edited", self._on_device_state_changed) # Calls from the control bar self.control_bar.connect("refresh-clicked", self._on_device_state_changed) self.control_bar.connect("select-target-clicked", self._on_select_target_clicked) self.control_bar.connect("quit-clicked", self._on_quit_clicked) self.control_bar.connect("new-memory-viewer-clicked", self._on_new_viewer_clicked, MemoryViewer, self.memory_viewers, "Memory Viewer") self.control_bar.connect("new-register-viewer-clicked", self._on_new_viewer_clicked, RegisterViewer, self.register_viewers, "Register Viewer") self._init_gui() self._init_adjustments() # A recurring call which is used to refresh the display glib.timeout_add(MainWindow.REFRESH_INTERVAL, self._on_interval) # Load up all architecture-specific stuff self._architecture_changed()
class App: 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 txt_report(self): with open(self.file_path, 'w') as outfile: for row in self.map_canvas.obliczone: wline = ' '.join(row[0]) + '\n' outfile.writelines(wline) outfile.close() showinfo('INFO', 'Zapisano raport %s' % self.filename) def make_widgets(self): menu = tk.Menu(self.root) menu_obiekty = tk.Menu(menu, tearoff=0) menu_etykiety = tk.Menu(menu, tearoff=0) menu.add_command(label="Import txt", command=self.map_canvas.import_map) menu.add_command(label="Raport txt", command=self.txt_report) submenu_liniowe = tk.Menu(menu) submenu_liniowe.add_command(label="Linia Bazowa [LB]", command=self.map_canvas.linia_bazowa) submenu_liniowe.add_command(label="Miary ortogonalne [MO]", command=self.map_canvas.ortog) submenu_liniowe.add_command( label="Przecięcie prostych [PP]", command=self.map_canvas.przeciecie_prostych) submenu_liniowe.add_command(label="Szukaj", command=self.search) submenu_liniowe.add_command(label="Anuluj", command=self.map_canvas.clear) menu.add_cascade(label="Obliczenia", menu=submenu_liniowe) self.toolbar = tk.Frame(self.root, bd=1, relief=tk.RAISED) StartButton = tk.Button(self.toolbar, text='LB', relief=tk.FLAT, command=self.map_canvas.linia_bazowa) StartButton.pack(side=tk.LEFT, padx=2, pady=2) CalcButton = tk.Button(self.toolbar, text='MO', relief=tk.FLAT, command=self.map_canvas.ortog) CalcButton.pack(side=tk.LEFT, padx=2, pady=2) CalcButton = tk.Button(self.toolbar, text='PP', relief=tk.FLAT, command=self.map_canvas.przeciecie_prostych) CalcButton.pack(side=tk.LEFT, padx=2, pady=2) SearchButton = tk.Button(self.toolbar, text='Szukaj', relief=tk.FLAT, command=self.search) SearchButton.pack(side=tk.LEFT, padx=2, pady=2) ClearButton = tk.Button(self.toolbar, text='Anuluj', relief=tk.FLAT, command=self.map_canvas.clear) ClearButton.pack(side=tk.LEFT, padx=2, pady=2) UpdateButton = tk.Button(self.toolbar, text='PktNum', relief=tk.FLAT, command=self.map_canvas.update_point_shortcut) UpdateButton.pack(side=tk.LEFT, padx=2, pady=2) self.toolbar.pack(side=tk.TOP, fill=tk.X) self.root.config(menu=menu) self.map_canvas.pack(fill='both', expand=1) self.status_bar.pack(side=tk.LEFT) def search(self): if len(self.last_searched) > 0: for elem in self.last_searched: i, c = elem self.map_canvas.itemconfigure(i, fill=c) d = SDialog(self.root, title='Szukaj') if d.result is not None: id = d.result else: id = '' try: for cid, pt in self.map_canvas.points.items(): if pt.number == id: self.last_searched.append( (cid, self.map_canvas.itemcget(cid, 'fill'))) self.map_canvas.itemconfigure(cid, fill='red') self.map_canvas.configure( scrollregion=self.map_canvas.bbox(cid)) except KeyError: showwarning('UWAGA', 'Brak punktu o numerze %s' % id)
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()
class MainWindow(QtGui.QMainWindow): 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 __create_menu(self, menu): # menus menu_file = menu.addMenu('File') menu_edit = menu.addMenu('Edit') menu_file.addAction(self.new_action) menu_file.addAction(self.open_action) menu_file.addSeparator() menu_file.addAction(self.save_action) menu_file.addAction(self.save_as_action) menu_file.addSeparator() menu_file.addAction(self.exit_action) menu_edit.addAction(self.cut_action) menu_edit.addAction(self.copy_action) menu_edit.addAction(self.paste_action) menu_edit.addSeparator() menu_edit.addAction(self.undo_action) def __create_actions(self): # actions self.new_action = QtGui.QAction('New', self) self.new_action.setShortcut('Ctrl+N') self.new_action.setStatusTip('New File') self.new_action.triggered.connect(self.new) self.new_action.setIcon( QtGui.QIcon(os.path.join(ICONS_FOLDER, 'new.png'))) self.new_action.setShortcut('Ctrl+N') self.save_action = QtGui.QAction('Save', self) self.save_action.setStatusTip('Save File') self.save_action.setIcon( QtGui.QIcon(os.path.join(ICONS_FOLDER, 'save.png'))) self.save_action.triggered.connect(self.save) self.save_action.setShortcut('Ctrl+S') self.save_as_action = QtGui.QAction('Save As', self) self.save_as_action.setStatusTip('Save as file') self.save_as_action.setIcon( QtGui.QIcon(os.path.join(ICONS_FOLDER, 'save.png'))) self.save_as_action.triggered.connect(self.save_as) self.exit_action = QtGui.QAction('Quit', self) self.exit_action.setShortcut('Ctrl+Q') self.exit_action.setStatusTip('close the application') self.exit_action.setIcon( QtGui.QIcon(os.path.join(ICONS_FOLDER, 'exit.png'))) self.exit_action.triggered.connect(self.close) self.open_action = QtGui.QAction('Open', self) self.open_action.setStatusTip('Open File') self.open_action.setIcon( QtGui.QIcon(os.path.join(ICONS_FOLDER, 'open.png'))) self.open_action.triggered.connect(self.open) self.open_action.setShortcut('Ctrl+O') self.cut_action = QtGui.QAction('Cut', self) self.cut_action.setIcon( QtGui.QIcon(os.path.join(ICONS_FOLDER, 'cut.png'))) self.cut_action.setShortcut('Ctrl+X') self.copy_action = QtGui.QAction('Copy', self) self.copy_action.setIcon( QtGui.QIcon(os.path.join(ICONS_FOLDER, 'copy.png'))) self.copy_action.triggered.connect(self.copy) self.copy_action.setShortcut('Ctrl+C') self.paste_action = QtGui.QAction('Paste', self) self.paste_action.setIcon( QtGui.QIcon(os.path.join(ICONS_FOLDER, 'paste.png'))) self.paste_action.setToolTip('Paste') self.paste_action.setShortcut('Ctrl+V') self.undo_action = QtGui.QAction('Undo', self) self.undo_action.setIcon( QtGui.QIcon(os.path.join(ICONS_FOLDER, 'undo.png'))) self.undo_action.setShortcut('Ctrl+Z') def __create_toolbar(self, toolbar): toolbar.addAction(self.new_action) toolbar.addAction(self.open_action) toolbar.addAction(self.save_action) toolbar.addAction(self.save_as_action) toolbar.addAction(self.copy_action) toolbar.addAction(self.paste_action) toolbar.addSeparator() toolbar.addAction(self.undo_action) toolbar.addSeparator() toolbar.addAction(self.exit_action) self.addToolBar(toolbar) def update_statusbar(self): line = self.text.textCursor().blockNumber() + 1 column = self.text.textCursor().columnNumber() self.status.update_label(line, column) def new(self): self.text.setPlainText("") def open(self): _file = QtGui.QFileDialog.getOpenFileName(self, "Open a file") if _file: self.filename = _file with open(_file, 'r') as f: content = f.read() self.text.setPlainText(content) self.text.is_new = False self.text.filename = _file def copy(self): self.text.copy() def paste(self): self.text.paste() def cut(self): self.text.cut() def undo(self): self.text.undo() def save(self): if self.text.is_new: self.save_as() else: content = self.text.toPlainText() with open(self.text.filename, 'w') as f: f.write(content) def save_as(self): _file = QtGui.QFileDialog.getSaveFileName() if _file: self.text.filename = _file self.text.is_new = False self.save() def closeEvent(self, event): if self.text.is_new: flags = QtGui.QMessageBox.Yes flags |= QtGui.QMessageBox.No flags |= QtGui.QMessageBox.Cancel r = QtGui.QMessageBox.information( self, 'Modificado!', 'Desea guardar los cambios antes de salir', flags) if r == QtGui.QMessageBox.Yes: self.save() elif r == QtGui.QMessageBox.No: event.accept() else: event.ignore()
class IDE(QMainWindow, IDEGeneric): max_opacity = 1 min_opacity = 0.3 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 show_status_message(self, message): self._status.showMessage(message, 2000) def add_toolbar_item(self, plugin, name, icon): self._toolbar.addSeparator() action = self._toolbar.addAction(QIcon(icon), name) self.connect(action, SIGNAL("triggered()"), lambda: plugin.toolbarAction()) def closeEvent(self, event): settings = QSettings('NINJA-IDE', 'Kunai') if settings.value('Preferences/General/load_files', 2).toInt()[0] == 2: settings.setValue('Open_Files/projects', self.main.get_open_projects()) settings.setValue('Open_Files/tab1', self.main._central._tabs.get_open_files()) settings.setValue('Open_Files/tab2', self.main._central._tabs2.get_open_files()) else: settings.setValue('Open_Files/projects', []) if self.main._central.check_for_unsaved(): val = QMessageBox.question(self, 'Some changes were not saved', 'Do you want to exit anyway?', QMessageBox.Yes, QMessageBox.No) if val == QMessageBox.No: event.ignore() else: self.main._properties._treeProjects.close_open_projects() else: self.main._properties._treeProjects.close_open_projects() def wheelEvent(self, event): if event.modifiers() == Qt.AltModifier: if event.delta() == 120 and self.opacity < self.max_opacity: self.opacity += 0.1 elif event.delta() == -120 and self.opacity > self.min_opacity: self.opacity -= 0.1 self.setWindowOpacity(self.opacity) event.ignore() else: super(IDE, self).wheelEvent(event)