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):
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(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)
