def __init__(self):
gtk.gdk.threads_init()
mainWindow = gtk.Window(type=gtk.WINDOW_TOPLEVEL)
mainWindow.resize(640,480)
mainWindow.show()
hbox = gtk.HBox(False, 0)
mainWindow.add(hbox)
hbox.show()
print 'Pullin in Canvas \n '
self.abiword_canvas = Canvas()
print 'Canvas obtained \n'
toolbar = Toolbar(self.abiword_canvas)
hbox.pack_start(toolbar, False)
toolbar.show()
hbox.add(self.abiword_canvas)
self.abiword_canvas.show()
mainWindow.connect("delete_event",self._delete_cb)
#
# test out signals
#
self.styleName_id = self.abiword_canvas.connect("style-name",self.styleName_cb)
self.fontFamily_id = self.abiword_canvas.connect("font-family",self.fontFamily_cb)
self.fontSize_id = self.abiword_canvas.connect("font-size",self.fontSize_cb)
self.textSelected_id = self.abiword_canvas.connect("text-selected",self.textSelected_cb)
self.imageSelected_id = self.abiword_canvas.connect("image-selected",self.imageSelected_cb)
self.selectionCleared_id = self.abiword_canvas.connect("selection-cleared",self.selectionCleared_cb)
self.enterSelection_id = self.abiword_canvas.connect("enter-selection",self.enterSelection_cb)
self.leaveSelection_id = self.abiword_canvas.connect("leave-selection",self.leaveSelection_cb)
def __init__(self, capacity: int, def_pos: tuple, def_cells_per_row: int,
color: pygame.Color, cell_color: pygame.Color):
# The inventory's contents (a list of items)
self.contents = [None] * capacity
# Maximum number of items the inventory can hold
self.capacity = capacity
# Default position of the UI in pixels
self.def_pos = def_pos
# Default width of the inventory in item cells
self.def_cells_per_row = def_cells_per_row
# Colours of inventory rect and small grid rects respectively
self.color = color
self.cell_color = cell_color
# Apply defaults (defaults are used if these params are not specified by in the open() function
self.pos = def_pos
self.cells_per_row = def_cells_per_row
self.rect = pygame.Rect(self.pos, self.get_size())
#self.search_bar = SearchBar(new_bar_pos = (def_pos[0], def_pos[1]-30))
self.tool_bar = Toolbar(self.rect.width, self.rect.topleft,
pygame.Color(100, 100, 100), color)
# Inventory menu is initialized to a "closed" state
self.is_open = False
def test_next_image(self):
tool = AnnotationTool()
tool.load_app(True)
# Annotation added
tool.annotations = []
tool.file_list = []
tool.class_list = ['winston', 'prince', 'duckie']
tool.colorspace = ['#0000FF', '#FF0000', '#00FF00']
tool.current_file = 0
tool.num_pages = 1
for i in range(5):
a = Annotation()
a.rotation = 3
tool.file_list.append('file%d.jpg' % i)
for p in range(3):
roi = ROI()
roi.push(0,0)
roi.push(100.0,100.0)
a.push(roi, i%len(tool.class_list))
tool.annotations.append(a)
toolbar = Toolbar(tool)
self.assertEqual(tool.current_file, 0)
truth = [1, 2, 3, 4, 4]
for i in range(5):
toolbar._next_image()
self.assertEqual(tool.current_file, truth[i])
def test_delete_from_project(self):
tool = AnnotationTool()
tool.load_app(True)
# Annotation added
tool.annotations = []
tool.file_list = []
tool.class_list = ['winston', 'prince', 'duckie']
tool.colorspace = ['#0000FF', '#FF0000', '#00FF00']
tool.current_file = 0
tool.num_pages = 1
tool.class_count = [5, 5, 5]
for i in range(5):
a = Annotation()
a.rotation = 3
tool.file_list.append('file%d.jpg' % i)
for p in range(3):
roi = ROI()
roi.push(0,0)
roi.push(100.0,100.0)
a.push(roi, p%len(tool.class_list))
tool.annotations.append(a)
toolbar = Toolbar(tool)
self.assertEqual(len(tool.annotations) , 5)
self.assertEqual(len(tool.file_list) , 5)
self.assertListEqual(tool.class_count, [5,5,5])
toolbar._delete_from_project()
self.assertEqual(len(tool.annotations) , 4)
self.assertEqual(len(tool.file_list) , 4)
self.assertListEqual(tool.class_count, [4,4,4])
def __init__(self, arg):
# setting
self.name_map = arg.name_map
self.opt = Setting()
# pygame
pygame.init()
self.screen = pygame.display.set_mode(self.opt.WINDOW_SIZE)
pygame.display.set_caption(self.opt.TITLE % self.name_map)
self.clock = pygame.time.Clock()
self.set_grill_surface()
# data
self.path = os.path.dirname(__file__)
self.path_img = os.path.join(self.path, "..", "src", "img")
file = self.name_map + self.opt.LUA_FORMAT
self.path_maps = os.path.join(self.path, "..", "src", "maps", file)
self.create = not os.path.exists(self.path_maps)
# objects
self.builder = Builder(self)
self.converter = Converter(self)
self.images = Images(self)
self.map = Map(self)
self.selector = Selector(self)
self.toolbar = Toolbar(self)
# loop
self.saved = True
self.loop()
pygame.quit()
class Program:
def __init__(self, arg):
pygame.init()
self.opt = Setting()
self.name_map = arg.name_map
self.screen = pygame.display.set_mode((self.opt.WIDTH + self.opt.TILE_SIZE*15,self.opt.HEIGHT + self.opt.TILE_SIZE*3))
self.set_grill_surface()
pygame.display.set_caption(self.opt.TITLE)
self.path = os.path.dirname(__file__)
self.path_img = os.path.join(self.path, ".." , "src", "img")
self.images = Spritesheet(self)
self.path_maps = os.path.join(self.path, ".." , "src", "maps", self.name_map + self.opt.LUA_FORMAT)
self.create = not os.path.exists(self.path_maps)
self.builder = Builder(self)
self.clock = pygame.time.Clock()
self.converter = Converter(self)
self.map = Map(self)
self.selector = Selector(self)
self.toolbar = Toolbar(self)
self.loop()
pygame.quit()
def set_grill_surface(self):
self.grill = self.screen.copy()
for y in range(0, self.opt.HEIGHT+1, self.opt.TILE_SIZE): pygame.draw.line(self.grill, (255,255,255), (0, y), (self.opt.WIDTH, y))
for x in range(0, self.opt.WIDTH+1, self.opt.TILE_SIZE): pygame.draw.line(self.grill, (255,255,255), (x, 0), (x, self.opt.HEIGHT))
self.grill.set_colorkey((0,0,0))
def draw(self):
self.screen.fill((0,0,0))
self.screen.blit(self.map.screen,(0,0))
self.screen.blit(self.grill,(0,0))
self.toolbar.draw(self.screen)
self.selector.draw(self.screen)
pygame.display.flip()
def event(self):
for event in pygame.event.get():
if event.type == pygame.QUIT: self.running = False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE: self.pause = not self.pause
elif event.key == pygame.K_s: self.builder.save()
elif event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 1: self.selector.click()
if event.button == 3: self.selector.remove()
elif event.type == pygame.MOUSEMOTION:
if event.buttons[0] == 1: self.selector.click()
if event.buttons[2] == 1: self.selector.remove()
def loop(self):
self.running = True
self.pause = False
while self.running:
self.clock.tick(50)
self.converter.update()
self.selector.update()
self.event()
self.draw()
def __init__(self):
self._running = True
self._display_surf = None
self._image_surf = None
self._apple_surf = None
self.game = Game()
self.player = Player(3, self.windowDimX, self.windowDimY)
self.windowWidth = self.windowDimX * self.player.step
self.windowHeight = self.windowDimY * self.player.step
self.toolbar = Toolbar(self.toolbarWidth, self.windowWidth,
self.windowHeight)
self.apple = Apple(randint(0, self.windowDimX - 1),
randint(0, self.windowDimY - 1))
def __init__(self, options):
self.options = options
self.main_window = MainWindow(self)
self.session_manager = debugsession.SessionManager(self)
self.console = Console(self)
self.main_window.console = self.console
self.stack = StackViewer(self)
self.namespace = AllNamespaceViewer(self)
self.threads = ThreadsViewer(self)
self.source = SourceViewer(self)
self.status = StatusBar(self)
self.breaks = BreakpointViewer(self)
self.toolbar = Toolbar(self)
debugsession.connect_events(self)
def test_delete_from_project_button(self):
tool = AnnotationTool()
tool.load_app(True)
# Annotation added
tool.annotations = []
tool.file_list = []
tool.class_list = ['winston', 'prince', 'duckie']
tool.colorspace = ['#0000FF', '#FF0000', '#00FF00']
tool.current_file = 0
tool.num_pages = 1
for i in range(5):
a = Annotation()
a.rotation = 3
tool.file_list.append('file%d.jpg' % i)
for p in range(3):
roi = ROI()
roi.push(0,0)
roi.push(100.0,100.0)
a.push(roi, i%len(tool.class_list))
tool.annotations.append(a)
toolbar = Toolbar(tool)
button = toolbar.toolbar_frame.winfo_children()[1]
self.assertEqual(button.cget('text'), '')
self.assertEqual(button.cget('width'), 40)
self.assertEqual(button.cget('height'), 40)
def paned_window(self):
self.panedwindow = ttk.Panedwindow(self.parent, orient = tk.HORIZONTAL)
self.panedwindow.pack(expand = True, fill = tk.BOTH)
self.left_pane = ttk.Frame(self.panedwindow, height = root.winfo_screenheight() - 140, relief = tk.SUNKEN)
self.middle_pane = ttk.Frame(self.panedwindow, height = (root.winfo_screenheight() - 140), relief = tk.SUNKEN)
self.right_pane = ttk.Frame(self.panedwindow, height = (root.winfo_screenheight() - 140), relief = tk.SUNKEN)
self.panedwindow.add(self.left_pane, weight = 1)
self.panedwindow.add(self.middle_pane, weight = 1)
self.panedwindow.add(self.right_pane, weight = 10)
self.panedwindow_left = ttk.Panedwindow(self.left_pane, orient = tk.VERTICAL)
self.panedwindow_left.pack(expand = True, fill = tk.BOTH)
self.pane_projects = ttk.Frame(self.panedwindow_left, height = (root.winfo_screenheight() - 140) / 2, relief = tk.SUNKEN)
self.pane_actions = ttk.Frame(self.panedwindow_left, height = (root.winfo_screenheight() - 140) / 2, relief = tk.SUNKEN)
self.panedwindow_left.add(self.pane_projects, weight = 1)
self.panedwindow_left.add(self.pane_actions, weight = 1)
self.panewindow_middle = ttk.PanedWindow(self.middle_pane, orient = tk.VERTICAL)
self.panewindow_middle.pack(expand = True, fill = tk.BOTH)
self.pane_canvas = ttk.Frame(self.panewindow_middle, relief = tk.SUNKEN)
self.pane_resources = ttk.Frame(self.panewindow_middle, width = 100, relief = tk.SUNKEN)
self.panewindow_middle.add(self.pane_canvas, weight = 5)
self.panewindow_middle.add(self.pane_resources, weight = 1)
self.menubar = Menubar(self.parent)
self.properties = Properties(self.right_pane)
self.canvas = Canvas(self.properties)
self.toolbar = Toolbar(self.pane_canvas, self.canvas)
self.project_explorer = ProjectExplorer(self.pane_projects)
self.canvas.create_Ui(self.pane_canvas)
self.actions = Actions(self.pane_actions, self.canvas, self.properties)
self.resources = Resources(self.pane_resources)
def __init__(self,dq,state,freq):
self._running = True
self._display_surf = None
self._image_surf = None
self._apple_surf = None
self.game = Game()
self.player = Player(3,self.windowDimX, self.windowDimY)
self.windowWidth = self.windowDimX*self.player.step
self.windowHeight = self.windowDimY*self.player.step
self.toolbar = Toolbar(self.toolbarWidth, self.windowWidth, self.windowHeight)
self.apple = Apple(randint(0,self.windowDimX-1), randint(0,self.windowDimY-1))
self.dataCollect = DataCollector()
self.displayq=dq
self.state_size = state
self.frequency = freq
def __init__(self):
self.root = self._create_root_app()
self.curdir = os.getcwd()
self.curfile = f'{os.path.dirname(self.curdir)}\\images\\asciify.jpg'
self.curimg = None
self.ascii_image = ""
self.gradientEntry = tk.StringVar()
self.use_custom_gradient = tk.BooleanVar(value=False)
self.gradientStep = tk.StringVar(value=str(settings.gradient["step"]))
self.fontsize = tk.StringVar(value=str(settings.font["size"]))
self.curfont = tk.StringVar(value=settings.font["family"])
self.percent = tk.StringVar(value=float(settings.output["percent"]))
self.outputSize = tk.StringVar(value="0x0")
self.targetWidth = tk.IntVar(value=int(settings.output["width"]))
self.targetHeight = tk.IntVar(value=int(settings.output["height"]))
self.curoutputoption = tk.StringVar(value=settings.output["type"])
self.contrast = tk.StringVar(value=settings.adjustments["contrast"])
self.brightness = tk.StringVar(
value=settings.adjustments["brightness"])
self.aspectRatioFit = (16, 9)
# application elements
self.menubar = MenuBar(self)
self.toolbar_widget = Toolbar(self)
self.ascii_wdiget = self.create_ascii_zone()
self.update_current_working_img()
self.update_ascii()
def parse(self, model, root_node, fields):
attrs = common.node_attributes(root_node)
self.title = attrs.get('string', 'Unknown')
vbox = gtk.VBox()
if not Calendar_:
return vbox, {}, [], '', [], None
goocalendar = Calendar_(attrs=attrs,
model=model,
root_node=root_node,
fields=fields,
screen=self.screen)
toolbar = Toolbar(goocalendar)
goocalendar.connect('view-changed', self.on_view_changed, toolbar)
goocalendar.connect('page-changed', self.on_page_changed, toolbar)
goocalendar.connect('event-pressed', self.on_event_pressed)
goocalendar.connect('event-activated', self.on_event_activated)
goocalendar.connect('event-released', self.on_event_released, attrs)
goocalendar.connect('day-pressed', self.on_day_pressed)
goocalendar.connect('day-activated', self.on_day_activated)
scrolledWindow = gtk.ScrolledWindow()
scrolledWindow.add_with_viewport(goocalendar)
vbox.pack_start(toolbar, False, False)
vbox.pack_start(scrolledWindow, True, True)
return vbox, {
'root': scrolledWindow,
'toolbar': toolbar,
'goocalendar': goocalendar
}, [], '', [], None
def test_draw_class_selection_menu(self):
tool = AnnotationTool()
tool.load_app(True)
# Annotation added
tool.annotations = []
tool.file_list = []
tool.class_list = ['winston', 'prince', 'duckie']
tool.colorspace = ['#0000FF', '#FF0000', '#00FF00']
tool.current_file = 0
tool.num_pages = 1
tool.class_count = [5, 5, 5]
for i in range(5):
a = Annotation()
a.rotation = 3
tool.file_list.append('file%d.jpg' % i)
for p in range(3):
roi = ROI()
roi.push(0,0)
roi.push(100.0,100.0)
a.push(roi, p%len(tool.class_list))
tool.annotations.append(a)
toolbar = Toolbar(tool)
option_menu = toolbar.toolbar_frame.winfo_children()[2]
self.assertEqual(option_menu.winfo_name(), '!optionmenu')
def test_draw_image_navigator(self):
tool = AnnotationTool()
tool.load_app(True)
# Annotation added
tool.annotations = []
tool.file_list = []
tool.class_list = ['winston', 'prince', 'duckie']
tool.colorspace = ['#0000FF', '#FF0000', '#00FF00']
tool.current_file = 0
tool.num_pages = 1
for i in range(5):
a = Annotation()
a.rotation = 3
tool.file_list.append('file%d.jpg' % i)
for p in range(3):
roi = ROI()
roi.push(0,0)
roi.push(100.0,100.0)
a.push(roi, i%len(tool.class_list))
tool.annotations.append(a)
toolbar = Toolbar(tool)
nav_frame = toolbar.toolbar_frame.winfo_children()[0]
nav_frame_children = nav_frame.winfo_children()
self.assertEqual(len(nav_frame_children), 3)
self.assertEqual(nav_frame_children[0].cget('text'), "Page 1/2")
def __init__(self, config=default):
"""Create an instance of a PyRysunek application.
Optional arguments:
config -- dictionary containing configuration values (see `config.default`)
"""
self.config = config
self.width, self.height = self.config.window_size
self.toolbar = Toolbar(self.config.toolbar)
self.context = Context(
objects=ObjectList(),
color_picker=self.toolbar.color_picker,
)
self._init_opengl()
if config.auto_load_on_start:
self.load()
def __init__(self):
gtk.gdk.threads_init()
mainWindow = gtk.Window(type=gtk.WINDOW_TOPLEVEL)
mainWindow.resize(640,480)
mainWindow.show()
hbox = gtk.HBox(False, 0)
mainWindow.add(hbox)
hbox.show()
print 'Pullin in Canvas \n '
self.abiword_canvas = Canvas()
print 'Canvas obtained \n'
toolbar = Toolbar(self.abiword_canvas)
hbox.pack_start(toolbar, False)
toolbar.show()
hbox.add(self.abiword_canvas)
self.abiword_canvas.load_file("", "")
#self.abiword_canvas.set_property("shadow-type", gtk.SHADOW_ETCHED_OUT)
self.abiword_canvas.show()
mainWindow.connect("delete_event",self._delete_cb)
def __init__(self, arg):
pygame.init()
self.opt = Setting()
self.name_map = arg.name_map
self.screen = pygame.display.set_mode((self.opt.WIDTH + self.opt.TILE_SIZE*15,self.opt.HEIGHT + self.opt.TILE_SIZE*3))
self.set_grill_surface()
pygame.display.set_caption(self.opt.TITLE)
self.path = os.path.dirname(__file__)
self.path_img = os.path.join(self.path, ".." , "src", "img")
self.images = Spritesheet(self)
self.path_maps = os.path.join(self.path, ".." , "src", "maps", self.name_map + self.opt.LUA_FORMAT)
self.create = not os.path.exists(self.path_maps)
self.builder = Builder(self)
self.clock = pygame.time.Clock()
self.converter = Converter(self)
self.map = Map(self)
self.selector = Selector(self)
self.toolbar = Toolbar(self)
self.loop()
pygame.quit()
def __init__(self):
QWidget.__init__(self)
self._ui_model = None
self._toolbar = Toolbar()
self._sheet_area = SheetArea()
v = QVBoxLayout()
v.setMargin(0)
v.addWidget(self._toolbar)
v.addWidget(self._sheet_area)
self.setLayout(v)
class Sheet(QWidget):
def __init__(self):
QWidget.__init__(self)
self._ui_model = None
self._toolbar = Toolbar()
self._sheet_area = SheetArea()
v = QVBoxLayout()
v.setMargin(0)
v.addWidget(self._toolbar)
v.addWidget(self._sheet_area)
self.setLayout(v)
def set_ui_model(self, ui_model):
self._ui_model = ui_model
self._toolbar.set_ui_model(ui_model)
self._sheet_area.set_ui_model(ui_model)
def unregister_updaters(self):
self._sheet_area.unregister_updaters()
self._toolbar.unregister_updaters()
def _draw_workspace(self):
'''
This draws the main project in the background frame
Parameters
----------
None
Attributes
----------
background : tkinter Frame object
This is the frame that covers the entire window object
Raises
------
None
Returns
-------
complete : bool
Returns True for unittesting
'''
self.app_menu._draw_menu()
self.background.destroy()
# Build Background Frame
self.background = Frame(self.window,
bg="gray",
width=self.window_width,
height=self.window_height)
self.background.place(x=0,
y=0,
width = self.window_width,
height = self.window_height)
if self.annotations:
self.num_pages = int(len(self.annotations)/self.img_per_page)
# Draw Toolbar on Left
toolbar = Toolbar(self)
# Draw Canvas on Right
self.draw_canvas()
if len(self.annotations):
self.navigator = Navigator(self)
return True
def __init__(self, options):
self.options = options
self.main_window = MainWindow(self)
self.session_manager = debugsession.SessionManager(self)
self.console = Console(self)
self.main_window.console = self.console
self.stack = StackViewer(self)
self.namespace = AllNamespaceViewer(self)
self.threads = ThreadsViewer(self)
self.source = SourceViewer(self)
self.status = StatusBar(self)
self.breaks = BreakpointViewer(self)
self.toolbar = Toolbar(self)
debugsession.connect_events(self)
def __init__(self, width=640, height=400, fps=30):
"""Initialize pygame, window, background, font,...
"""
pygame.init()
pygame.display.set_caption("Press ESC to quit")
self.pygame = pygame
self.width = width
self.height = height
#self.height = width // 4
self.display = pygame.display
self.screen = pygame.display.set_mode((self.width, self.height),
pygame.DOUBLEBUF)
self.background = pygame.Surface(self.screen.get_size()).convert()
self.clock = pygame.time.Clock()
self.fps = fps
self.playtime = 0.0
self.font = PygFont(pygame)
self.sudoku = Sudoku()
self.helper = False
self.x_loc = 30
self.y_loc = 30
self.x_size = 450
self.y_size = 450
self.x_inc = self.x_size / 9 #number of columns
self.y_inc = self.y_size / 9 #number of rows
self.grid_x = -1
self.grid_y = -1
self.stats_x_loc = self.x_loc + self.x_size + 30
self.stats_y_loc = self.y_loc
self.stats_x_size = 50
self.stats_y_size = 450
self.toolbar_x_loc = 20
self.toolbar_y_loc = self.y_loc + self.y_size + 70
self.toolbar_x_size = 600
self.toolbar_y_size = 80
self.toolbar = Toolbar(self.toolbar_x_size, self.toolbar_y_size,
self.toolbar_x_loc, self.toolbar_y_loc)
def test_init(self):
tool = AnnotationTool()
tool.load_app(True)
# Annotation added
tool.annotations = []
tool.file_list = []
tool.class_list = ['winston', 'prince', 'duckie']
tool.colorspace = ['#0000FF', '#FF0000', '#00FF00']
tool.current_file = 0
tool.num_pages = 1
toolbar = Toolbar(tool)
self.assertEqual(toolbar.root_app, tool)
self.assertEqual(toolbar.toolbar_width, tool.window_width)
self.assertEqual(toolbar.toolbar_height, tool.toolbar_height)
self.assertEqual(len(toolbar.toolbar_frame.winfo_children()), 0)
for i in range(5):
a = Annotation()
a.rotation = 3
tool.file_list.append('file%d.jpg' % i)
for p in range(3):
roi = ROI()
roi.push(0,0)
roi.push(100.0,100.0)
a.push(roi, i%len(tool.class_list))
tool.annotations.append(a)
toolbar = Toolbar(tool)
self.assertEqual(toolbar.root_app, tool)
self.assertEqual(toolbar.toolbar_width, tool.window_width)
self.assertEqual(toolbar.toolbar_height, tool.toolbar_height)
self.assertEqual(len(toolbar.toolbar_frame.winfo_children()), 3)
def __init__(self):
super().__init__()
self.title = 'ADF Explorer'
self.width = 640
self.height = 512
self.adf = ADF(self)
self.actions = Actions(self)
self.toolbar = Toolbar(self)
self.menu = Menu(self)
self.path = Path(self)
self.browser = Browser(self)
self.status = Status(self)
self.initUI()
def __init__(self, config=default):
"""Create an instance of a PyRysunek application.
Optional arguments:
config -- dictionary containing configuration values (see `config.default`)
"""
self.config = config
self.width, self.height = self.config.window_size
self.toolbar = Toolbar(self.config.toolbar)
self.context = Context(
objects = ObjectList(),
color_picker = self.toolbar.color_picker,
)
self._init_opengl()
if config.auto_load_on_start:
self.load()
def _init_ui(self):
menu_cb = {
'new': self._new_cmd,
'open': self._open_cmd,
'save': self._save_cmd,
'save_as': self._save_as_cmd,
'exit': self._exit_cmd
}
toolbar_cb = {
'snap': self.set_snap,
'zoom': {
'zoomx': self.set_zoomx,
'zoomy': self.set_zoomy
},
'tool': self.set_canvas_tool
}
bottombar_cb = {
'length': self.set_canvas_length,
'timesig': self.set_canvas_timesig
}
root = self._root()
menu = PianoRollMenu(root, menu_cb)
root.config(menu=menu)
root.title(make_title("Untitled", self._dirty))
try:
image = PhotoImage(file=ICON_IMG_PATH)
root.tk.call('wm', 'iconphoto', root._w, image)
except TclError:
print "Couldn't load icon file"
self.toolbar = Toolbar(self, toolbar_cb)
self.piano_roll_frame = PianoRollFrame(
self, lambda *args, **kwargs: self.set_dirty(True))
self.bottombar = BottomBar(self, bottombar_cb)
self.toolbar.pack(side=TOP, fill=X)
self.bottombar.pack(side=BOTTOM, fill=X)
self.piano_roll_frame.pack(fill=BOTH, expand=True)
self.pack(fill=BOTH, expand=True)
def initUI(self):
"""Initialize GUi's elements"""
main_layout = QVBoxLayout()
self.setStyleSheet('background-color: rgb(51,51,51); color: white')
self.setLayout(main_layout)
# define view's widgets
central_layout = QHBoxLayout()
toolbar = Toolbar(self.configuration, self.controller, self.parent)
self.matrix = LayoutMatrix(self.layout_configuration,
self.configuration, self)
central_layout.addWidget(toolbar)
central_layout.addWidget(self.matrix)
# main_layout.addWidget(logo)
main_layout.addLayout(central_layout)
self.show_information_popup()
class frm_main(tk.Tk):
"""Start object to render the application window.\n
use:\n
import libs.frm_main as mainwindow\n
if __name__ == "__main__":\n
app = mainwindow()\n
app.mainloop()\n\n
"""
settings = configparser.ConfigParser()
settings_file = "settings.ini"
viewlogg = False
gfxpath = "gfx/"
_data_list = dict()
_data_list['targets'] = list()
_data_list['hosts'] = list()
listwidget = dict()
def __init__(self, settingspath="conf/", gfxpath="gfx/"):
tk.Tk.__init__(self)
self.settings_file = os.path.join(settingspath, self.settings_file)
self.gfxpath = gfxpath
self.wm_title("Tracemac 2.0")
self.mainframe = tk.Frame(master=self, bg="white")
self.minsize(width=800, height=640)
self.mainframe.pack(expand=True, fill=BOTH)
self.logg = Logwindow(self.mainframe)
self.createWidgets()
self.bind_all("<Control-x>", self.quit)
self.bind_all("<Control-t>", lambda x:self.list_add(widget=self.list_targets))
self.bind_all("<Control-h>", lambda x:self.list_add(widget=self.list_hosts))
#self.list_targets.insert(END, "1.1.1.1")
#checks if the settings_file exists, if not it creates it with defaults.
if os.path.isfile(self.settings_file):
self.settings.read(self.settings_file)
else:
print("No settings file - reverting to standard and saving file to conf/settings.ini")
self.settings['DEFAULT'] = { 'community': 'public',
'community_password': '******' }
self.settings['userdata'] = {}
self._save_settings_to_file()
def quit(self, *event):
"""
master frame destroy. Quits the application.
"""
self.destroy()
def list_add(self, widget=None):
"""add new target to list of targets"""
datacol = Collectdata(self, title="Enter IP-addres", gfxpath=self.gfxpath)
valid, ip, ip2, mask = datacol.show()
lst = widget.get(0, END)
dname = self.listwidget[widget.winfo_name]
if valid:
if ip and ip2:
#It's a range
v=dict()
item = ip + "-" + ip2
if item in lst:
messagebox.showinfo("message", "IP-Range %s is allready in the list of targets!" % item)
else:
v = { item: {
'ip': ip,
'ip2': ip2,
'mask': mask,
'type': 'range'
}}
self._data_list[dname].append(v)
widget.insert(END, item)
elif ip and mask and not ip2:
#It's a network with a mask
#Need to deside how to add these to the list?!?!
print("It's a Network %s/%s" % (ip, mask))
if len(mask) < 3:
mask = self.convertmask(int(mask))
print("New mask:", mask)
elif ip and not ip2 and not mask:
#It's a single IP-address ( same as /32 mask )
print("It's a single ip-adress:", ip)
if ip in lst:
messagebox.showinfo("message", "Ip %s is allready in the list of targets!" % ip)
else:
widget.insert(END, ip)
@staticmethod
def convertmask(mask:int) -> str:
b = newmask = ""
cnt=0
for a in range(32):
b += "1" if a <= mask else "0"
nums = [int(b[i:i+8], 2) for i in range(0, 32, 8)]
for cnt, item in enumerate(nums):
newmask += str(item) + "." if cnt < 3 else str(item)
return newmask
def edit_item(self, widget=None):
"""Edits selected target"""
#Need to check if anything is selected!
curselec = widget.curselection()
if curselec:
index = int(curselec[0])
curitem = widget.get(index)
d = Collectdata(self, title="Edit target", edit=widget.get(curselec), gfxpath=self.gfxpath)
valid, ip, ip2, mask = d.show()
if ip is not curitem:
try:
widget.delete(index)
except:
pass
widget.insert(index, ip)
def delete_item(self, widget=None):
try:
curindex = widget.curselection()
curtarget = widget.get(curindex)
ret = messagebox.askyesnocancel(title="Delete?", message="Do you want to delete target:\n%s" % curtarget)
if ret is True:
try:
widget.delete(curindex)
except:
pass
except:
messagebox.showinfo(title="Info", message="Nothing selected!")
def createWidgets(self):
""" Creates and lays out the widgets for the mainwindow."""
# create Menus:
self.menubar = tk.Menu(self.mainframe)
filemenu = tk.Menu(self.menubar, tearoff=0)
mnuimport = tk.Menu(filemenu, tearoff=0)
mnuimport.add_command(label="Target list", command=self._file_menu_import_target_list)
mnuimport.add_command(label="Switch list", command=self._file_menu_import_switch_list)
filemenu.add_command(label="New search", command=self._file_menu_new_search, underline=1)
filemenu.add_cascade(label="Import", menu=mnuimport)
filemenu.add_separator()
filemenu.add_command(label="Settings", command=self._file_menu_settings, underline=0)
filemenu.add_command(label="Exit", command=self.quit, underline=1, accelerator="Ctrl+X")
#--end-- File menu build
#--start-- edit menu build
editmenu = Menu(self.menubar, tearoff=0)
editmenu.add_command(label="Add target(s)", underline=4, accelerator="Ctrl-T", command=self._edit_menu_add_target_to_list)
editmenu.add_command(label="Edit selected target", command=self._edit_menu_edit_selected_target)
editmenu.add_command(label="Delete selected target", command=self._edit_menu_del_selected_target)
editmenu.add_separator()
editmenu.add_command(label="Add host(s)", underline=4, accelerator="Ctrl-H", command=self._edit_menu_add_host_to_list)
editmenu.add_command(label="Edit selected host", command=self._edit_menu_edit_selected_host)
editmenu.add_command(label="Delete selected host", command=self._edit_menu_del_selected_host)
editmenu.add_separator()
editmenu.add_command(label="Clear log window", command=self.logg.clear)
#--end-- edit menu build
#--start-- view menu
viewmenu = Menu(self.menubar, tearoff=0)
viewmenu.add_checkbutton(label="Show/hide Logg", onvalue=True, offvalue=False, variable=self.viewlogg, command=self._viewmenu_show_window_pane)
#--end-- viewmenu
#--start-- help menu build
hlpmenu = tk.Menu(self.menubar, tearoff=0)
hlpmenu.add_command(label="Help", command=self._help_menu_help)
hlpmenu.add_command(label="About", command=self._help_menu_about)
#--end-- help menu build
#--start-- adding menus to main menu
self.menubar.add_cascade(label="File", menu=filemenu)
self.menubar.add_cascade(label="Edit", menu=editmenu)
self.menubar.add_cascade(label="View", menu=viewmenu)
self.menubar.add_cascade(label="Help", menu=hlpmenu)
#--end-- adding menus to main menu
try:
self.config(menu=self.menubar)
except AttributeError:
print("this faild!!!!")
# master is a toplevel window (Python 1.4/Tkinter 1.63)
tk.call(self, "config", "-menu", self.menubar)
#create Toolbar
toolbar = Toolbar(parent=self.mainframe)
toolbar.add(wtype="button", gfxpath=self.gfxpath + "start.png",
tooltip="Start the search", command=self.addtext)
toolbar.add(wtype="button", gfxpath=self.gfxpath + "new.png",
tooltip="Clears all results and start fresh")
toolbar.add(wtype="separator")
## toolbar.add(wtype="button", gfxpath=self.gfxpath + "addtarget.png",
## tooltip="Add target or a range of targets to targetslist", command=self.list_add)
## toolbar.add(wtype="button", gfxpath=self.gfxpath + "addhost.png",
## tooltip="Add a host or range of hosts to hostslist")
## toolbar.add(wtype="separator")
toolbar.add(wtype="button", gfxpath=self.gfxpath + "exit.png",
tooltip="Exits the program. (Ctrl-X)", command=self.quit)
toolbar.show()
# create Statusbar
self.status = StringVar()
self.statusbar = Label(self, textvariable=self.status, bd=1, relief=SUNKEN, anchor=W)
self.statusbar.pack(side=BOTTOM, fill=X)
self.status.set("Idle")
#create input boxes:
self.inputframe = Frame(self.mainframe, width=50, bd=1, relief=GROOVE, padx=12, pady=12)
Label(self.inputframe, text="Targets to look for:", pady=2).pack()
self.list_targets = Listbox(self.inputframe, selectmode=BROWSE)
self.list_targets.pack(side=TOP, pady=5)
self.listwidgets[self.list_targets.winfo_name] = 'targets'
self.list_targets_toolbar = Toolbar(parent=self.inputframe)
self.list_targets_toolbar.add(wtype="button", gfxpath=self.gfxpath + "addtarget.png",
tooltip="Add new target", command=lambda: self.list_add(widget=self.list_targets))
self.list_targets_toolbar.add(wtype="button", gfxpath=self.gfxpath + "edit.png",
tooltip="Edit selected target", command=lambda: self.edit_item(widget=self.list_targets))
self.list_targets_toolbar.add(wtype="button", gfxpath=self.gfxpath + "trash.png",
tooltip="Delete selected target", command=lambda: self.delete_item(widget=self.list_targets))
self.list_targets_toolbar.show()
Frame(self.inputframe, height=2, bd=1, relief=SUNKEN).pack(fill=X, padx=0, pady=10)
Label(self.inputframe, text="Hosts to scan:", pady=2).pack()
self.list_hosts = Listbox(self.inputframe, selectmode=BROWSE)
self.list_hosts.pack(side=TOP, pady=5)
self.listwidgets[self.list_hosts.winfo_name] = 'hosts'
self.list_hosts_toolbar = Toolbar(parent=self.inputframe)
self.list_hosts_toolbar.add(wtype="button", gfxpath=self.gfxpath + "addhost.png",
tooltip="Add new host", command=lambda: self.list_add(self.list_hosts))
self.list_hosts_toolbar.add(wtype="button", gfxpath=self.gfxpath + "edit.png",
tooltip="Edit selected host", command=lambda: self.edit_item(widget=self.list_hosts))
self.list_hosts_toolbar.add(wtype="button", gfxpath=self.gfxpath + "trash.png",
tooltip="Delete selected host", command=lambda: self.delete_item(widget=self.list_hosts))
self.list_hosts_toolbar.show()
self.inputframe.pack(side=RIGHT, fill=Y)
def addtext(self, *args):
self.logg.println("test", "text2", "text3")
self.logg.println("test", "text2", "text3", prefix="switch1")
def _viewmenu_show_window_pane(self, *args):
self.viewlogg = not self.viewlogg
if self.viewlogg:
self.logg.show()
else:
self.logg.hide()
def _edit_menu_add_target_to_list(self):
self.list_add(widget=self.list_targets)
def _edit_menu_del_selected_target(self):
self.delete_item(widget=self.list_targets)
def _edit_menu_edit_selected_target(self):
self.edit_item(widget=self.list_targets)
def _edit_menu_add_host_to_list(self): pass
def _edit_menu_del_selected_host(self): pass
def _edit_menu_edit_selected_host(self): pass
def _file_menu_import_target_list(self):
"""
private function _file_menu_import_target_list
opens Dialog to open a file containing a list of ip-adresses or MAC-adresses either separated with comma (,) or one line per target.
TODO: figure out how to do this.
"""
pass
def _file_menu_import_switch_list(self):
"""
private function _file_menu_import_switch_list
opens Dialog to open a file containing a list of ip-adresses either separated with comma (,) or new-line (\\n)
TODO: figure out how to do this.
"""
pass
def _file_menu_new_search(self):
"""
function _file_menu_new_search
clears all current settings and unloads any files imported.
"""
pass
def _help_menu_help(self):
"""
private function _help_menu_help
display help-window
TODO: everything!
"""
pass
def _help_menu_about(self):
"""
private function _help_menu_about
Display Aoutdialog popupwindow.
"""
about_dialog = tk.Toplevel(self)
about_dialog.wm_title("About Tracemac v2.0")
about_frame = tk.Frame(about_dialog, width=200, height=300)
about_frame.pack()
with codecs.open("texts\\about.txt", "r", "utf8") as f:
about_text= f.read()
about_label=tk.Label(about_frame, text=about_text)
about_label.config(anchor="center")
about_label.grid(columnspan="3", row="0")
about_btn_OK = tk.Button(about_frame,
text="OK",
command=about_dialog.destroy,
width="30")
about_btn_OK.grid(column="1", row="1")
about_dialog.mainloop()
print("and then some!!!")
def _file_menu_settings(self):
"""
private function _file_menu_settings
Display settingsdialog popupwindow.
"""
settings_dialog = Settings_dialog(self, self.settings)
return_val, changed = settings_dialog.show()
if changed:
self._save_settings_to_file()
def _save_settings_to_file(self):
with open(self.settings_file, 'w') as configfile:
self.settings.write(configfile)
class Application(object):
def __init__(self, options):
self.options = options
self.main_window = MainWindow(self)
self.session_manager = debugsession.SessionManager(self)
self.console = Console(self)
self.main_window.console = self.console
self.stack = StackViewer(self)
self.namespace = AllNamespaceViewer(self)
self.threads = ThreadsViewer(self)
self.source = SourceViewer(self)
self.status = StatusBar(self)
self.breaks = BreakpointViewer(self)
self.toolbar = Toolbar(self)
debugsession.connect_events(self)
def launch(self, filename):
def _l(filename):
import threading
if filename is not None:
def _t():
self.session_manager.launch(True, filename)
t = threading.Thread(target=_t)
t.start()
gobject.idle_add(_l, filename)
def update_threads(self, event):
current_thread = event.m_current_thread
threads_list = event.m_thread_list
def _u(threads_list, current_thread):
self.threads.update_threads(threads_list, current_thread)
gobject.idle_add(_u, threads_list, current_thread)
def update_thread_broken(self, event):
print 'threadbroken'
tid = event.m_tid
def _u(tid):
self.threads.broken_thread(tid)
gobject.idle_add(_u, tid)
def update_no_threads(self, event):
print 'nothreads'
def update_state(self, event):
state = event.m_state
print 'state', state
def _u(state):
self.status.update_running_status(state)
def _u2(state):
self.toolbar.update_state(state)
def _u3(state):
self.source.update_state(state)
gobject.idle_add(_u, state)
gobject.idle_add(_u2, state)
def update_frame(self, event):
print 'frame', event.m_frame_index
index = event.m_frame_index
def _u(index):
self.stack.select_frame(index)
gobject.idle_add(_u, index)
self.update_source(-index - 1)
def update_stack(self, event):
print 'updatestack'
stack = event.m_stack
self._last_stack = stack
def _u(stack):
self.stack.update_stack(stack)
gobject.idle_add(_u, stack)
self.update_source(-1)
def update_source(self, index):
def _u(index):
si =StackItem(index, *self._last_stack['stack'][index])
self.source.goto(si.filename, si.linenumber)
gobject.idle_add(_u, index)
def update_namespace(self, event):
def _u():
self.namespace.update_namespace()
gobject.idle_add(_u)
def update_bp(self, event):
def _u(event):
act = event.m_action
if event.m_bp is not None:
filename = event.m_bp.m_filename
linenumber = event.m_bp.m_lineno
index = event.m_bp.m_id
indices = None
else:
filename = None
linenumber = None
index = None
indices = event.m_id_list
self.breaks.update_bp(act, index, indices, filename, linenumber)
gobject.idle_add(_u, event)
def __init__(self, root, sizeX, sizeY, title):
super().__init__(root)
# self.pack(expand='no', fill='both')
self.root = root
self.state_ = False
root.wm_title(title)
root.focus_force()
self.img_ = create_img()
self.pack(expand=True, fill=tk.BOTH)
set_application_icons(root, 'ico') # imgdir
self.path = pathlib.Path(cwddir)
path_ = self.path.joinpath(
'Проекты') # каталог для файлов конвертора 'project'
if not path_.exists():
os.mkdir(path_)
self.b = {} # контейнер для виджетов
self.dir_cvt = path_
self._zona = config.getfloat('System', 'vzona')
self._opgl = 0
self.mb = config.getboolean('Amplituda', 'mb') # 1 - RGB
# fxen = dict(fill=tk.X, expand=False)
(self.glub_var, self.stop_var, self.time_var, self.numstr_var,
self.ampl_var, self.skale_var, self.porog_var,
self.frek_var) = (tk.StringVar() for _ in range(8))
self.tol_bar = Toolbar(self, bso_) # объект tolbar
self.tol_bar.pack(fill=tk.X, expand=False)
# ttk.Separator(self).pack(**fxen)
self.head = Head(self) # объект этикетки head
self.head.pack(fill=tk.X, expand=False)
self.stbar = Footer(self, bso_) # объект строки состояния
self.stbar.pack(side=tk.BOTTOM, fill=tk.X)
self.sep = ttk.Separator(self)
self.sep.pack(side=tk.BOTTOM, fill=tk.X, pady=1)
self.frame_upr = ttk.Frame(self) # фрейм для управления
self.frame_upr.pack(side=tk.BOTTOM, fill=tk.X)
self.infobar = InfoBar(self) # объект Info
self.infobar.pack(side=tk.BOTTOM, fill=tk.X)
self.board = CanvasT(self, sizeX, sizeY, bso_) # объект CanvasT
self.board.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
self.ser = RS232(trace) # объект Serial
self.gser = Gps(trace) # объект Gps
self.gser.tty.baudrate = 4800
self.gser.tty.timeout = 0.01
self._zg = config.getfloat('System', 'zagl')
self.head.set_z(self.zg) # zg - свойство
self.d0 = {
'L': 'МГ',
'M': 'СГ',
'H': 'БГ',
'C': 'B8',
'D': 'B10',
'B': 'Б6'
}
self.fil_ametka = 'DodgerBlue2'
self.stringfile = 0 # число строк записанных в файл
self.txt_opmetka = 0 # счётчик оперативных отметок ручн.
self.y_g = 0
# self.error = 0 # занулить ошибки при старте проги
self.file_gals = None # нет файла для записи галса
self.man_metkawriteok = (False, False)
self.avto_metkawriteok = False
self.yold_ = 0.0 # для перемещен текста врем. меток
self.hide_metka = False # Показывать метки
self.hide_grid = False # Показывать гор. линии
self.gl_0 = 0
self.d_gps = None
self.last_d_gps = None
self.tavto_ = None
self.tbname = None
self.view_db = None
# self.count_gps = 0
self.ida = None
self.ida_ = True
self.last_sec = -1
self.count_tmetka = 1
self.vz_last = self.rej_last = 0
self.diap_last = self.old_depth = 'МГ'
self.helpDialog = None
self.color_ch = True
self.t_pausa = 0
self.y_metka = self.board.y_top
self.flag_gals = False
self.vzvuk = 1500
if bso_:
self.gui_main()
self.sep.pack_forget()
class App(ttk.Frame):
"""Класс приложения"""
def __init__(self, root, sizeX, sizeY, title):
super().__init__(root)
# self.pack(expand='no', fill='both')
self.root = root
self.state_ = False
root.wm_title(title)
root.focus_force()
self.img_ = create_img()
self.pack(expand=True, fill=tk.BOTH)
set_application_icons(root, 'ico') # imgdir
self.path = pathlib.Path(cwddir)
path_ = self.path.joinpath(
'Проекты') # каталог для файлов конвертора 'project'
if not path_.exists():
os.mkdir(path_)
self.b = {} # контейнер для виджетов
self.dir_cvt = path_
self._zona = config.getfloat('System', 'vzona')
self._opgl = 0
self.mb = config.getboolean('Amplituda', 'mb') # 1 - RGB
# fxen = dict(fill=tk.X, expand=False)
(self.glub_var, self.stop_var, self.time_var, self.numstr_var,
self.ampl_var, self.skale_var, self.porog_var,
self.frek_var) = (tk.StringVar() for _ in range(8))
self.tol_bar = Toolbar(self, bso_) # объект tolbar
self.tol_bar.pack(fill=tk.X, expand=False)
# ttk.Separator(self).pack(**fxen)
self.head = Head(self) # объект этикетки head
self.head.pack(fill=tk.X, expand=False)
self.stbar = Footer(self, bso_) # объект строки состояния
self.stbar.pack(side=tk.BOTTOM, fill=tk.X)
self.sep = ttk.Separator(self)
self.sep.pack(side=tk.BOTTOM, fill=tk.X, pady=1)
self.frame_upr = ttk.Frame(self) # фрейм для управления
self.frame_upr.pack(side=tk.BOTTOM, fill=tk.X)
self.infobar = InfoBar(self) # объект Info
self.infobar.pack(side=tk.BOTTOM, fill=tk.X)
self.board = CanvasT(self, sizeX, sizeY, bso_) # объект CanvasT
self.board.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
self.ser = RS232(trace) # объект Serial
self.gser = Gps(trace) # объект Gps
self.gser.tty.baudrate = 4800
self.gser.tty.timeout = 0.01
self._zg = config.getfloat('System', 'zagl')
self.head.set_z(self.zg) # zg - свойство
self.d0 = {
'L': 'МГ',
'M': 'СГ',
'H': 'БГ',
'C': 'B8',
'D': 'B10',
'B': 'Б6'
}
self.fil_ametka = 'DodgerBlue2'
self.stringfile = 0 # число строк записанных в файл
self.txt_opmetka = 0 # счётчик оперативных отметок ручн.
self.y_g = 0
# self.error = 0 # занулить ошибки при старте проги
self.file_gals = None # нет файла для записи галса
self.man_metkawriteok = (False, False)
self.avto_metkawriteok = False
self.yold_ = 0.0 # для перемещен текста врем. меток
self.hide_metka = False # Показывать метки
self.hide_grid = False # Показывать гор. линии
self.gl_0 = 0
self.d_gps = None
self.last_d_gps = None
self.tavto_ = None
self.tbname = None
self.view_db = None
# self.count_gps = 0
self.ida = None
self.ida_ = True
self.last_sec = -1
self.count_tmetka = 1
self.vz_last = self.rej_last = 0
self.diap_last = self.old_depth = 'МГ'
self.helpDialog = None
self.color_ch = True
self.t_pausa = 0
self.y_metka = self.board.y_top
self.flag_gals = False
self.vzvuk = 1500
if bso_:
self.gui_main()
self.sep.pack_forget()
def gui_main(self):
self.b.update(self.tol_bar.b)
self.head.set_format(
('DBT', 'DBK', 'DBS')[config.getint('Preferens', 'd')])
self.numstr_var.set('')
# scl = config.getboolean('Scale', 'amplscl')
# if scl:
# self.board.sclrbar.pack(side=tk.RIGHT, fill=tk.Y, expand=False) # показать шкалу
yscroll = config.getboolean('Scale', 'yscroll')
if yscroll:
self.board.sbar.pack(side=tk.LEFT,
fill=tk.Y) # показать полосу прокрутки
self.board.canv.pack(side=tk.LEFT, fill=tk.BOTH,
expand=True) # пакуем здесь
self.open_port()
self.init_board()
path = pathlib.Path(config.get('Dir', 'dirprj'))
# path = os.path.abspath(path)
if path.exists():
self.dbname = path.joinpath(path.name + '.db') # path + '.db'
self.tol_bar.set_dir(str(path) + ' ...Галс не выбран')
else:
self.tol_bar.set_dir('Проект не выбран!')
self.tol_bar.pr_name.set(' ?! ')
self.b['bgals'].config(state='disabled')
def init_board(self):
"""Создание нового полотна и очередей"""
self.visible = False # Показать все точки
self.visible_len = False # Показать длительность
self.board.create_fild()
self.root.update_idletasks()
maxlen = int(self.max_width_canv() - self.board.x_right - 2)
self.board.create_list_deque(maxlen)
self.bind_()
def open_port(self):
"""Открытие портов"""
port_pui = config.get('Port', 'port_pui')
baudrate_pui = config.getint('Port', 'baudrate_pui')
port_gps = config.get('Port', 'port_gps')
baudrate_gps = config.getint('Port', 'baudrate_gps')
try:
self.ser.open_port(port_pui)
self.ser.tty.baudrate = baudrate_pui
except port_exc:
self.stbar.set_device(f'Не открыть порт {port_pui}')
self.stbar.set_icon(self.img_['networky'])
if self.ser.is_open():
self.stbar.set_device(self.ser.get_port_info())
self.stbar.set_icon(self.img_['networkon'])
try:
self.gser.open_port(port_gps)
self.gser.tty.baudrate = baudrate_gps
except port_exc:
self.stbar.set_gps(f'Не открыть порт {port_gps}')
self.stbar.set_icon_gps(self.img_['networky'])
if self.gser.is_open():
self.stbar.set_gps(self.gser.get_port_info('НАП СНС'))
self.stbar.set_icon_gps(self.img_['networkon'])
def runview_mem(self, arg=None):
"""Запуск просмотра Viewer"""
# from ttkthemes import ThemedStyle
# bakfile = None
# if self.file_gals:
# fd, bakfile = tempfile.mkstemp() # bakdir = tempfile.mkdtemp() shutil.rmtree(bakdir)
# try: # see path_test.py
# shutil.copyfile(self.file_gals, bakfile)
# os.close(fd)
# except IOError:
# bakfile = None
# self.root.set_theme('arc')
top = tk.Toplevel()
# top = ThemedTk(theme='arc', toplevel=True)
title = 'БСО просмотр логов' if bso_ else 'ПУИ просмотр логов'
# app_view = show_bso.App(top, title=title, filename=bakfile, galsname=self.file_gals)
app_view = show_bso.App(top, title=title, galsname=self.file_gals)
# style = ThemedStyle(top)
# style.set_theme("arc")
app_view.run()
top.protocol("WM_DELETE_WINDOW", app_view.file_quit)
top.iconbitmap(self.path.joinpath(imgdir, 'bookmark.ico'))
top.focus_force()
def clr_data(self):
"""Если ПУИ перейти в Ожидание"""
self.init_board()
if not bso_:
# self.root.go_nel()
pass
#======= callback =============#
def new_avtom__(self, arg=None):
"""Запуск автометок"""
if arg is None:
return
if self.ida:
self.root.after_cancel(self.ida) # остановить цикл
if arg == 0.0:
# self.odl_arg_time = arg
self.b['btnmetka'].config(text='0.0 м')
return
else:
# self.odl_arg_time = arg
self.b['btnmetka'].config(text=f'{arg:0.1f} м')
self.b['btnametka_on'].config(state='normal')
self.count_tmetka = 1
self.timeravto(arg) # запустить цикл
def new_vzona__(self, arg=None):
if arg is not None:
self.zona = arg
#============== metki ==========================================
def ch_state(self, dis=(), nor=()):
"""Изменение state кнопок (list 'disabled'), (list 'normal')"""
for obj in dis:
self.b[obj].state(['disabled', 'selected'])
for obj in nor:
self.b[obj].state(['!disabled', '!selected'])
def opavto(self, arg=None):
"""Обработчик кнопки постановки авто. метки"""
dlg_.get_float(self,
'Автоинтервал',
'Введите интервал в мин.',
self.new_avtom__,
initial=0.0,
minimum=0.5,
maximum=100)
def timeravto(self, t):
"""Тик для автометок 1 секунда"""
# if t:
sec = time.localtime(time.time())[5]
if sec != self.last_sec:
self.last_sec = sec # 1 сек
self.count_tmetka -= 1
if self.count_tmetka == 0:
if self.ida_:
self.draw_t()
self.count_tmetka = t * 60
self.ida = self.root.after(100, lambda: self.timeravto(t))
# else:
# if self.ida:
# self.root.after_cancel(self.ida)
def review_db(self, geom):
"""Обновить окно меток"""
self.view_db.destroy() # withdraw()
self.opmetka_list(geom)
def state_db_norm(self, arg=None):
"""Удалить окно просмотра меток и разблокировать кнопку db"""
# self.b['b_db'].config(state='normal') #
self.view_db.destroy() # withdraw()
self.view_db = None #
def opmetka_list(self, geom=None):
""""Обработчик кнопки просмотр BD"""
try:
result = request_data_all(self.dbname, self.tbname)
except Exception: # as er
# print(er)
return
if self.view_db:
self.view_db.destroy()
self.view_db = ViewMetka(self, result, geom)
self.view_db.show_tree() #
self.view_db.set_name_db(self.dbname)
# self.b['b_db'].config(state='disabled') #
def data_coment(self, num):
"""Получить коментарий из базы"""
return request_data_coment(self.dbname, self.tbname, num)
def save_new_coment(self, num, txt):
"""Сохранить коментарий в базе"""
update_table(self.dbname, self.tbname, num, txt)
def decorate_metka(*d_arg):
"""Декоратор функции"""
def my_decorator(func):
def wrapped(self, *f_arg):
if self.hide_metka:
for tag in d_arg:
self.board.canv.move(tag, 0, 100)
func(self, *f_arg)
if self.hide_metka:
for tag in d_arg:
self.board.canv.move(tag, 0, -100)
return wrapped
return my_decorator
@decorate_metka('', 'mman_td')
def opmanual(self, arg=None):
"""Обработчик кнопки постановки ручной метки"""
if not self.flag_gals and bso_:
return # если галс не выбран то не ставим отметку
color, tag = ("spring green", 'mman_td') if arg else ("red", 'mman_t')
x = self.board.x0 - 3
self.board.canv.create_line(x,
self.board.y_top + 1,
x,
self.y_metka,
fill=color,
tag='mmetka')
self.txt_opmetka += 1
self.board.canv.create_text(x,
self.board.y_top - 7 + self.yold_,
text=self.txt_opmetka,
anchor='center',
font=('Helvetica', 8),
fill=color,
tag=tag)
# Y = -100 if self.tol_bar.visible_time_metka_on else 0
# self.board.canv.create_text(x+6, self.board.y_top+27+self.yold_+Y, text=self.gl_0, anchor=tk.CENTER,
# angle=90, font=('Helvetica', 8), fill=self.fil_ametka, tag='mman_t_glub')
self.man_metkawriteok = (True, False) if color == "red" else (True,
True)
req.num = self.txt_opmetka
self.get_data_db()
insert_table(self.dbname, self.tbname, req)
if self.view_db: #
geom = self.view_db.geometry().split('+')
self.review_db(geom)
if self.hide_metka:
self.board.canv.delete('mmetka')
def del_metka_man(self):
"""Удаление ручных и авто отметок при смене галса"""
for tag in ('mmetka', 'mman_t', 'mman_td', 'ametka', 'tametka',
'point', 'point_g', 'glub',
'timeametka'): # 'mman_t_glub',
self.board.canv.delete(tag)
self.txt_opmetka = 0
@decorate_metka('tametka', 'timeametka')
def draw_t(self, arg=None):
"""Рисуем временные автоматич. метки"""
x = self.board.x0 - 3
if self.d_gps is None:
text = time.strftime('%H:%M:%S')
else:
text = self.d_gps[0].split()[-1]
self.txt_opmetka += 1
Y = -100 if self.tol_bar.visible_time_metka_on else 0
if not self.hide_metka:
self.board.canv.create_line(x,
self.board.y_top,
x,
self.y_metka,
fill=self.fil_ametka,
tag='ametka')
self.board.canv.create_text(x,
self.board.y_top - 7 + self.yold_,
text=self.txt_opmetka,
anchor=tk.CENTER,
font=('Helvetica', 8),
fill=self.fil_ametka,
tag='tametka')
self.board.canv.create_text(x - 6,
self.board.y_top + 27 + self.yold_ + Y,
text=text,
anchor=tk.CENTER,
angle=90,
font=('Helvetica', 8),
fill=self.fil_ametka,
tag='timeametka')
# self.board.canv.create_text(x+6, self.board.y_top+27+self.yold_+Y, text=self.gl_0, anchor=tk.CENTER,
# angle=90, font=('Helvetica', 8), fill=self.fil_ametka, tag='timeametka')
self.avto_metkawriteok = True
self.get_data_db()
req.num = self.txt_opmetka
req.coment = 'A'
insert_table(self.dbname, self.tbname, req)
if self.view_db:
geom = self.view_db.geometry().split('+')
self.review_db(geom)
def hide_metki(self):
"""Показать, скрыть метки"""
if self.hide_metka:
self.board.move_metkai_hide(hide=False)
image = self.img_['geoon']
ToolTip(self.b['btnmetki'], msg='Метки видны')
if self.flag_gals:
self.ch_state((), ('bmman', 'btnmetka'))
else:
self.board.move_metkai_hide(hide=True)
image = self.img_['geooff']
ToolTip(self.b['btnmetki'], msg='Метки скрыты')
self.ch_state(('bmman', 'btnmetka'), ())
self.b['btnmetki'].configure(image=image)
self.hide_metka = not self.hide_metka
def hide_hline(self, arg=None):
"""Показать, скрыть гор. линии поля"""
if self.hide_grid:
self.board.move_grid(2700, 0)
image = self.img_['grid2']
ToolTip(self.b['btnhidevline'], msg='Линии видны')
else:
self.board.move_grid(-2700, 0)
image = self.img_['lauernogrid']
ToolTip(self.b['btnhidevline'], msg='Линии скрыты')
self.b['btnhidevline'].configure(image=image)
self.hide_grid = not self.hide_grid
#----------------------------------------------------------------------------------------------#
def ch_diap(self, *arg):
"""Вызов при смене диапазона"""
t1 = time.time()
if t1 - self.t_pausa > 5: # ставить отметку не чаще чем 5 сек.
self.t_pausa = t1
arg = self.infobar.diap_var.get()
if arg != self.diap_last and arg: # не ставить если не изменился диапазон
if self.diap_last:
if self.tbname and self.txt_opmetka: # не ставить если небыло меток
self.opmanual("green")
if self.tol_bar.id_rec:
txt = f"Диапазон {self.infobar.diap_var.get()}"
num = self.txt_opmetka
self.save_new_coment(num, txt)
self.diap_last = arg
def pref_form(self, D, z):
"""Возврат результата из формы 'DBT.., z(заглубл.) если есть изменения'"""
self.zg = z # изменение заглубл.
self.head.set_format(D)
@property
def zona(self):
"""Временная зона"""
return self._zona
@zona.setter
def zona(self, value):
self._zona = value
self.head.set_utc(t=True)
config.set('System', 'vzona', f'{value}')
write_config()
@property
def zg(self):
"""Заглубление"""
return self._zg
@zg.setter
def zg(self, value):
"""Изменение заглубления"""
self._zg = value
self.head.set_z(value)
config.set('System', 'zagl', f'{value}')
write_config()
def gals(self, name):
"""Выбор галса"""
path = pathlib.Path(config.get('Dir', 'dirprj'))
dir_gals = path.joinpath(
'Исходные данные') # каталог галсов 'base_data'
# if name in (i.name for i in os.scandir(dir_gals)):
if name in os.listdir(dir_gals):
if not box.askyesno(
'!',
'Файл с таким именем уже существует!\n Переписать файл?'):
return
self.file_gals = path.joinpath('Исходные данные',
name) # имя файла данных 'base_data'
self.tol_bar.set_dir(str(self.file_gals))
head = [
'format_', 'glub', 'ampl', 'lenth', 'timdata', 'shir', 'dolg',
'vs', 'kurs', 'vz', 'zg', 'ku', 'depth', 'rej', 'frek', 'cnt', 'm',
'm_man', 'color_mm', 'm_avto'
]
for i in range(20):
head.append(f'g{i}')
head.append(f'a{i}')
head.append(f'l{i}')
with open(self.file_gals, 'w',
newline='') as f: # пишем в файл шапку a!
f_csv = csv.writer(f)
f_csv.writerow(head)
fname = pathlib.Path(name).stem
md5 = hashlib.md5(fname.encode('utf-8')).hexdigest()
# md5 = hashlib.md5(os.path.splitext(name)[0].encode('utf-8')).hexdigest()
self.tbname = f'tb_{md5}' # "tb_" префикс т.к. имя не может начмнаться с цмфры
try:
create_table(self.dbname,
self.tbname) # создать таблицу и если надо базу
except sqlite3.OperationalError as err:
if str(err) == f'table {self.tbname} already exists':
del_table(self.dbname, self.tbname)
else:
box.showerror('!', f'Ошидка базы данных!\n{str(err)}')
req.num = 0
self.del_metka_man()
return True
@staticmethod
def get_prj_name():
return pathlib.Path(config.get('Dir', 'dirprj')).name
# return os.path.basename(config.get('Dir', 'dirprj'))
def opendir_gals(self):
"""Открыть существующий проект"""
path = pathlib.Path(config.get('Dir', 'dirprj')).parent
# path = config.get('Dir', 'dirprj')
# path = os.path.dirname(path)
name = askdirectory(initialdir=path)
if name:
# dir_ = os.path.abspath(name)
self.prepare_gals(name)
self.tol_bar.set_dir(name + ' ...Галc не выбран')
return name
def prepare_gals(self, dir):
config.set('Dir', 'dirprj', dir)
write_config()
path = pathlib.Path(dir)
self.dbname = path.joinpath(path.name + '.db')
# self.dbname = os.path.join(dir, os.path.split(dir)[-1] + '.db') # dir + '.db'
# self.ch_state(('btn', 'b_db'), ()) #
self.ch_state(('btn', ), ())
self.tol_bar.num_gals.set(f"{' ':^19}")
self.flag_gals = False
self.b['bgals'].config(state='normal')
def vzonav_(self):
"""Обработка кнопки врем. зона"""
ini = config.getfloat('System', 'vzona')
dlg_.get_float(self.root,
'Часовой пояс',
'Введите часовой пояс',
self.new_vzona__,
initial=ini,
minimum=-12,
maximum=14)
def zaglub_(self):
"""Обработка кнопки осадки"""
Window(self)
######################## Work ############################
def color_ch_(self, arg=None):
"""Обработчик ккнопки смены фона"""
if self.color_ch:
bg = 'beige' # '#eee'
fil = 'darkblue'
image = self.img_['on']
else:
bg = 'gray22' # '#444'
fil = 'orange3'
image = self.img_['off']
self.b['btnrgb'].configure(image=image)
self.color_ch = not self.color_ch
self.board.reconfig()
self.board.canv.config(background=bg)
self.board.canv.itemconfigure('fild_t', fill=fil)
self.board.canv.itemconfigure('ametka', fill=self.fil_ametka)
self.board.canv.itemconfigure('tametka', fill=self.fil_ametka)
########################## Start Wait #########################
def write_data(self, data):
"""
Пишем данные в файл
(b'${or %},work,rej,depth,notused,ku,vh,vl,ksh,ksl,\r\n')
(b'! or ?, #')
(b'$,depth,ku,m,cnt,gl_0h,gl_0l,am_0h,am_0l,glh,gll,amh,aml,...,\r\n')
'$GPRMC,123519.xxx,A,4807.038x,N,01131.000x,E,022.4,084.4,230394,003.1,W*6A\n'
' , time , , latitude, , logitude , ,spid ,track, data ,degrees, '
"""
if self.b["btn"].cget('text') == '.' and data:
# self.b['bgals'].state(['disabled', 'selected']) # откл кнопки галс
if bso_:
vz = int.from_bytes(data[6:8], 'big') # скорость звука
frek = '25' if data[0] == 0x25 else '50' # частота
rej = 'S' if data[2] == 0x53 else 'R' # режим
data = data[15:-2]
else:
vz = self.head.vz_var.get()[:-3] ################ убрать м/с
frek = '25' if self.frek_var.get() == '25кГц' else '50'
rej = 'S' if self.infobar.rej_var.get() == 'Авто' else 'R'
depth = chr(data[0]) # диапазон глубин
ku = int(chr(data[1]), 16) # порог
m = data[2] # корелир. стопы
glub = int.from_bytes(data[4:6], 'big')
glub += self.zg * 10 if glub else 0 # self.zg -> float
glub = int(glub)
#ampl = data[6] if self.mb else data[7] # amplful = int.from_bytes(data[6:8], 'big')
ampl = data[6] # цвет
# lenth = data[7] # длительность импульса
lenth = self.cal_len(data[7])
# print(f'> {glub} - {data[7]}')
# lenth = self.cal_len(data[7], self.d0[depth])
# print(data[7], lenth)
m_avto = m_man = color_mm = '' # авто метка, ручн.метка, цвет ручной метки
format_ = self.head.format_var.get() # формат
if self.d_gps is None: # если нет GPS
gps1 = gps2 = gps3 = gps4 = ''
gps0 = time.strftime('%d.%m.%y %H:%M:%S')
else:
# time, shir, dolg, speed, kurs
gps0, gps1, gps2, gps3, gps4 = (self.d_gps[i]
for i in range(5))
if self.man_metkawriteok[0]:
m_man = self.txt_opmetka
color_mm = "spring green" if self.man_metkawriteok[1] else "red"
if self.avto_metkawriteok:
m_avto = self.txt_opmetka # авто метка
cnt = data[3] # стопы
zg = self.zg # осадка
# формат, глубина, амплитуда, длительность, объект дата время, широта, долгота, скорость, курс, скорость звука, осадка, порог,
# диап. глубин, режим, частота, число стопов, число кор. стопов, ручн. метка, цвет ручн. метки , авто метка.
file_list = [
format_, glub, ampl, lenth, gps0, gps1, gps2, gps3, gps4, vz,
zg, ku, depth, rej, frek, cnt, m, m_man, color_mm, m_avto
]
if cnt:
st_d = []
data = data[8:]
if cnt > 20:
cn = 20 # если > 20 то except т.к. матрица = 20
else:
cn = cnt
for i in range(0, cn * 4, 4):
gd = int.from_bytes(data[i:i + 2], 'big')
gd += self.zg * 10 if gd else 0
gd = int(gd)
# ad = data[i+2] if self.mb else data[i+3] # ad = int.from_bytes(data[i+2:i+4], 'big')
ad = data[i + 2]
# ld = data[i + 3]
# ld = self.cal_len(data[i + 3], self.d0[depth])
ld = self.cal_len(data[i + 3])
st_d.append(gd)
st_d.append(ad)
st_d.append(ld)
print(f'{gd} - {data[i + 3]}, ', end='')
print()
file_list.extend(st_d)
with open(self.file_gals, 'a', newline='') as f:
f_csv = csv.writer(f)
f_csv.writerow(file_list)
self.stringfile += 1
self.numstr_var.set(
f'{self.stringfile:=05d}') # число строк зап. в файл
self.man_metkawriteok = (False, False)
self.avto_metkawriteok = False
def bind_(self):
"""Привязки событий"""
self.root.bind("<Up>", self.board.up)
self.root.bind("<Down>", self.board.down)
self.root.bind("<Home>", self.board.home)
self.root.bind("<End>", self.board.en)
self.root.bind("<Alt-F4>", self.exit_)
# self.root.bind('<MouseWheel>', self.scroll)
self.board.canv.bind("<Configure>", self.board.size_canv)
self.root.bind("<Control-Alt-e>", self.stbar.err_show)
self.root.bind("<Return>", lambda: None)
def max_width_canv(self):
"""Возвращает максимально возможную ширину холста"""
screen = self.root.winfo_screenwidth()
labl = self.board.colorbar.winfo_width()
sbar = self.board.sbar.winfo_width()
return screen - labl - sbar
def clr(self):
"""Тригер показ всех точек или одна цель"""
if self.visible:
self.board.show_data_zip(on_eco=True)
image = self.img_['sloion']
ToolTip(self.b['btnall'], msg='Все эхо')
else:
self.board.canv.delete('point')
image = self.img_['sloi3']
ToolTip(self.b['btnall'], msg='Одно эхо')
# self.board.canv.itemconfigure('point_g', fill='black') # 'green3'
self.b['btnall'].config(image=image)
self.visible = not self.visible
self.board.reconfig()
def len_view(self): #
"""Тригер показ длительности целей"""
if self.visible_len:
self.board.show_data_zip(on_eco=True)
image = self.img_['candlestick']
ToolTip(self.b['btnlen'], msg='Длительность видна')
else:
self.board.canv.delete('point')
image = self.img_['linechart']
ToolTip(self.b['btnlen'], msg='Длительность скрыта')
self.b['btnlen'].config(image=image)
self.visible_len = not self.visible_len
self.board.reconfig()
#=================================================================
def blink(self):
"""Мигнуть телевизорами порта"""
self.stbar.lab_tel.config(image=self.img_['network1'])
self.root.after(
200,
lambda: self.stbar.lab_tel.config(image=self.img_['network3']))
def blink_g(self):
"""Мигнуть телевизорами порта"""
self.stbar.lab_tel_gps.config(image=self.img_['network1'])
self.root.after(
200,
lambda: self.stbar.lab_tel_gps.config(image=self.img_['network3']))
def set_local_time(self):
"""Установка машинного времени"""
s = ttk.Style()
s.configure('H.TLabel', foreground='#2754aa') # синий
t = time.strftime('%d.%m.%y %H:%M:%S')
self.head.set_utc(False)
self.head.set_t(t)
def gps_data(self, data):
"""Получение данных из GPS
'$GPRMC,123519.xxx,A,4807.038x,N,01131.000x,E,022.4,084.4,230394,003.1,W*6A\n'"""
s = ttk.Style()
self.d_gps = None
data = data.split(',') # type list
self.blink_g()
try:
s_ = data[3].split('.')
d_ = data[5].split('.')
sh = f"{s_[0][:-2]} {s_[0][-2:]}.{s_[1][:3]} {data[4]}" # {0xB0:c} °
d = f"{d_[0][:-2]} {d_[0][-2:]}.{d_[1][:3]} {data[6]}"
except Exception:
sh = f"xx xx.xxx x"
d = f"xxx xx.xxx x"
try:
str_struct = time.strptime(data[1].split('.')[0] + data[9],
"%H%M%S%d%m%y")
tsek = time.mktime(str_struct)
tsek += self.zona * 3600
str_struct = time.localtime(tsek)
t = time.strftime("%d.%m.%y %H:%M:%S", str_struct)
except Exception:
t = "xx.xx.xx xx:xx:xx"
try:
vs = f"{float(data[7]):=04.1f}" # ! 05.1f
k = f"{float(data[8]):=05.1f}"
except Exception:
vs = k = ''
s.configure('H.TLabel', foreground='black')
self.head.set_(sh, d, vs, k, t, True)
# self.head.labelTime.config(foreground='green3')
self.d_gps = (t, sh, d, vs, k)
def get_data_db(self):
"""Получить данные для базы"""
if self.d_gps is None:
t, sh_, d_ = time.strftime('%d.%m.%y %H:%M:%S'), '', ''
else:
t, sh, d = self.d_gps[0], self.d_gps[1], self.d_gps[2]
sh__ = sh.split()
d__ = d.split()
sh_ = f"{sh__[0]}{0xB0:c} {sh__[1]}{0xB4:c} {sh__[2]}"
d_ = f"{d__[0]}{0xB0:c} {d__[1]}{0xB4:c} {d__[2]}"
req.timedata, req.shirota, req.dolgota = t, sh_, d_
req.glubina = f'{self.gl_0} м'
req.coment = ''
def update_scale(self):
"""Установка шкалы по глубине"""
if not self.data_point:
return
# x = self.data_point[0]
x = self.data_point[0] / 10
up = (20, 40, 100, 200, 400, 800, 1000, 2000, 4000, 4500)
down = (0, 16, 35, 75, 190, 350, 750, 950, 1900, 3900)
if x > up[self.board.i]:
self.board.up()
elif x < down[self.board.i]:
self.board.down()
def work(self, data):
"""data = bytes"""
# len(data)=105
if bso_:
vz = int.from_bytes(data[6:8], 'big') # скорость звука
self.infobar.vz_var.set(vz) # for trace
self.head.set_v(vz)
rej = 'Авто' if data[2] == 0x53 else 'Ручной' # режим
self.infobar.rej_var.set(f"{rej}")
frek = '25 кГц' if data[0] == 0x25 else '50 кГц' # частота
self.frek_var.set(f"{frek}")
self.parse_data(data[15:-2], vz)
if self.data_point[0] > 0:
# self.y_metka = self.board.y_top + self.data_point[0] * self.board.px / self.board.k + 1
self.y_metka = self.board.y_top + self.data_point[
0] / 10 * self.board.px / self.board.k + 1
else:
self.y_metka = self.board.y_top
self.board.update_data_deque()
if self.tol_bar.enable_skale:
self.update_scale() # изменить шкалу !
self.board.show_point() # в canvast
self.board.del_widht_canvas() # удалить всё за холстом
def getmsg(self, que):
"""Поточная функция чтения ППУ"""
while self.flag_gals:
msg = self.ser.read_allb() # byte or None
if msg:
que.put(msg) # ждём пока очередь будет пуста
def getmsg_gp(self, que_gp):
"""Поточная функция чтения НСП"""
while self.flag_gals:
msg = self.gser.get_msg() # str or None
if msg:
que_gp.put(msg) # ждём пока очередь будет пуста
def run_loop(self):
"""
Работа в режиме просмотра и возможной записи в лог.
(b'${or%},work,rej,depth,notused,ku,vh,vl,ksh,ksl,\r\n')
(b'! or ?, #')
(b'$,depth,ku,m,cnt,gl_0h,gl_0l,am_0h,am_0l,glh,gll,amh,aml,...,\r\n')
"""
# Вызов при выборе галса (start)
# s = ttk.Style()
self.init_board(
) # очистить все очереди, иначе при reconfig() появяться цели от старого галса
if not self.ser.is_open(): # нет открытого порта
self.b["btn"].state(['disabled', 'selected'])
return
self.ser.clear_port() # очистка порта
que = queue.Queue(1)
self.flag_gals = True
if self.gser.is_open():
que_g = queue.Queue(1)
thread_g = threading.Thread(target=self.getmsg_gp,
args=(que_g, ),
daemon=True) # daemon=True
thread_g.start()
thread_d = threading.Thread(target=self.getmsg,
args=(que, ),
daemon=True)
thread_d.start()
self.end_loop = False
self.timer = True
self.local = False
self.timer_g = True
self.not_data_g()
while self.flag_gals:
if self.gser.is_open():
try:
data_g = que_g.get_nowait()
except queue.Empty:
data_g = None
if self.timer_g:
self.timer_g = False
tg = threading.Timer(3.0, self.not_data_g)
tg.start()
if data_g:
if not self.timer_g:
tg.cancel()
self.timer_g = True
self.local = True
self.gps_data(data_g)
if not self.local:
self.set_local_time() # локальное время
self.d_gps = None
else:
# s.configure('H.TLabel', foreground='#2754aa') # синий
self.set_local_time()
self.root.update()
try:
data = que.get_nowait() # не ждём
except queue.Empty:
data = None
if self.timer:
self.timer = False
t = threading.Timer(9.5, self.not_data)
t.start()
if data:
if not self.timer:
t.cancel()
self.timer = True
self.work(data)
self.write_data(data) # если надо то пишем в файл
self.board.clr_error() # убераем надпись Нет данных!
self.ch_state((), ('bmman', 'btnmetka', 'btnametka_on'))
self.blink()
self.root.update()
self.ida_ = True
try:
t.cancel()
tg.cancel()
except:
pass
self.flag_gals = False
self.end_loop = True
def not_data(self):
"""Вызов при отсутствии данных в линии"""
# self.timer = True
self.stbar.set_icon(self.img_['networkx'])
self.board.create_error() # Выводим на холст Нет данных
self.ch_state(('bmman', 'btnmetka', 'btnametka_on'), ())
self.ida_ = False
def not_data_g(self):
"""Вызов при отсутствии данных в линии GPS"""
# s = ttk.Style()
# self.timer_g = True
self.local = False
# s.configure('H.TLabel', foreground='#2754aa') # синий
self.set_local_time()
def parse_data(self, data, vz):
"""
Разбор данных глубин и амплитуд
(b'depth,ku,m,cnt,gl_0h,gl_0l,am_0h,am_0l,glh,gll,amh,aml,...glh,gll,amh,aml')
"""
self.vzvuk = vz
# data_point = []
# data_ampl = [] # 1+cnt глубин и 1+cnt (амплитуд, длительностей)
# data_len = []
data_point = array.array('H') # float 'f' 4 bytes 'B' 1 bytes
data_ampl = array.array('B') # 1 + cnt глубин, амплттуд, длительностей
data_len = array.array('B')
if data:
cnt = data[3] # число принятых стопов
m = data[2] # число коррелир. стопов
ku = int(chr(data[1]), 16) # порог
depth = self.d0[chr(data[0])] # диапазон глубин
self.depth = depth
if depth != self.old_depth or not self.infobar.diap_var.get():
self.infobar.diap_var.set(f"{depth}")
self.old_depth = depth
self.porog_var.set(f"{ku}")
self.stop_var.set(f" {m} из {cnt} ")
glub = int.from_bytes(data[4:6], 'big')
if glub:
gl_0 = glub / 10 + self.zg
data_point.append(glub + int(self.zg * 10)) # в дециметрах
else:
gl_0 = 0
data_point.append(0)
self.glub_var.set(
f'{glub / 10:5.1f} м') if glub > 0 else self.glub_var.set('')
self.board.view_glub(gl_0, self._opgl) # вывод лгубины на холст
# data_point.append(gl_0) # основной стоп
# ampl = data[6] if self.mb else data[7] amplful = int.from_bytes(data[6:8], 'big')
ampl = data[6]
lenth = data[7]
# print(lenth)
bg = self.board.rgbc(ampl * 7) if ampl else 'gray85' ## ~
self.infobar.lab_a_l.config(background=bg)
# lenth = self.cal_len(data[7], depth)
# lenth = lenth if lenth else ' -'
# lenth = data[7]
# data_ampl.append((ampl, lenth)) # основной стоп
data_ampl.append(ampl) # основной стоп
data_len.append(lenth) # основной стоп
a = ampl if ampl else ''
l = str(self.cal_len(lenth)) + ' м' if lenth else '' #
self.ampl_var.set(
f'{a:3} \\ {l:5}') # вывод амплитуды и длит. в лабель
foreground = 'black' if m else '#2754aa' # синий
self.infobar.lab_am_ln[1].config(foreground=foreground)
# self.vmeter(ampl)
datas = data[8:] # данные с матрицы
if cnt > 20:
cnt = 20
for i in range(0, cnt * 4, 4):
glubs = int.from_bytes(datas[i:i + 2], 'big')
if glubs:
# gl = glubs / 10.0 + self.zg
data_point.append(glubs + int(self.zg * 10))
else:
data_point.append(0)
# data_point.append(gl)
ampl2 = datas[i + 2]
# lenth2 = self.cal_len(datas[i + 3], depth) # в метрах
lenth2 = datas[i + 3] # в дециметрах
data_ampl.append(ampl2)
data_len.append(lenth2)
self.gl_0 = round(gl_0, 1) # глубина глобально
self.data_point = data_point
self.data_ampl = data_ampl
self.data_len = data_len
def cal_len(self, cod):
if self.depth == 'МГ': n = 0.4
elif self.depth == 'СГ': n = 1.6
elif self.depth == 'БГ': n = 12.8
elif self.depth == 'Б6': n = 12.8 # !
else:
n = 0
return round(cod * n * self.vzvuk / 10000, 2)
# def cal_len(self, cod):
# cod = cod * 1.5 / 100
# # print(depth, type(depth))
# if self.depth == 'МГ': n = 4
# elif self.depth == 'СГ': n = 32
# elif self.depth == 'БГ': n = 256
# elif self.depth == 'Б6': n = 256 # !
# else:
# n = 0
# return cod * n
#========================================================
def convt(self, arg=None):
"""Конвертировать в формат ..."""
import conv_csv
dir__ = conv_csv.convert(self.dir_cvt)
self.dir_cvt = dir__
def help(self, event=None):
"""Окно справки"""
if self.helpDialog is None:
self.helpDialog = help_.Window(self, bso_)
else:
self.helpDialog.deiconify()
def quitter(self):
"""Закрыть сокеты и убить окно"""
if self.ser.is_open():
self.ser.close_port()
if self.gser.is_open():
self.gser.close_port()
if not bso_:
if self.pser.is_open():
self.pser.close_port()
# main_thread = threading.main_thread()
# for t in threading.enumerate():
# if t is main_thread:
# continue
# t.join(timeout=2.0)
try:
self.root.destroy()
sys.exit(0)
except Exception:
pass
def exit_(self, arg=None):
"""Обработчик меню Exit"""
if self.okay_to_exit():
# sys.stderr = open('err.log', 'a') #
self.root.withdraw()
self.tol_bar.t = 0
self.flag_gals = False
shutil.rmtree(bakdir) # удаляем tmp каталог
self.after(500, self.quitter)
def okay_to_exit(self):
"""Подтверждение выхода"""
reply = box.askokcancel("Выход",
"Закончить работу программы?",
parent=self.root)
if reply is False:
return False
return True
# import logging
# logging.basicConfig(
# filename = "bso.log",
# format = "%(asctime)s %(message)s", # %(levelname)-10s
# #level = logging.DEBUG
# level = logging.ERROR
# )
# logging.debug('start app')
def __init__(self):
"""
This method is constructor.
"""
System()
Gtk.Window.__init__(self, title="Mosaicode")
self.resize(System.properties.width, System.properties.height)
self.main_control = MainControl(self)
# GUI components
self.menu = Menu(self)
self.toolbar = Toolbar(self)
self.search = SearchBar(self)
self.block_notebook = BlockNotebook(self)
self.property_box = PropertyBox(self)
self.work_area = WorkArea(self)
self.status = Status(self)
self.block_menu = BlockMenu()
self.menu.add_help()
System.set_log(self.status)
# vbox main
# -----------------------------------------------------
# | Menu
# -----------------------------------------------------
# | Toolbar
# -----------------------------------------------------
# | V Paned bottom
# -----------------------------------------------------
# First Vertical Box
vbox_main = Gtk.VBox()
self.add(vbox_main)
vbox_main.pack_start(self.menu, False, True, 0)
vbox_main.pack_start(self.toolbar, False, False, 0)
self.vpaned_bottom = Gtk.Paned.new(Gtk.Orientation.VERTICAL)
vbox_main.add(self.vpaned_bottom)
# vpaned_bottom
# -----------------------------------------------------
# | hpaned_work_area
# =====================================================
# | status
# -----------------------------------------------------
self.hpaned_work_area = Gtk.HPaned()
self.hpaned_work_area.connect("accept-position", self.__resize)
self.hpaned_work_area.set_position(System.properties.hpaned_work_area)
self.vpaned_bottom.add1(self.hpaned_work_area)
self.vpaned_bottom.add2(self.__create_frame(self.status))
self.vpaned_bottom.set_position(System.properties.vpaned_bottom)
self.vpaned_bottom.set_size_request(50, 50)
# hpaned_work_area
# -----------------------------------------------------
# | vbox_left || work_area
# -----------------------------------------------------
vbox_left = Gtk.VBox(False, 0)
self.hpaned_work_area.add1(vbox_left)
self.hpaned_work_area.add2(self.work_area)
# vbox_left
# -----------------------------------------------------
# |search
# -----------------------------------------------------
# |vpaned_left
# -----------------------------------------------------
vbox_left.pack_start(self.search, False, False, 0)
self.vpaned_left = Gtk.VPaned()
vbox_left.pack_start(self.vpaned_left, True, True, 0)
# vpaned_left
# -----------------------------------------------------
# |blocks_tree_view
# =====================================================
# |property_box
# -----------------------------------------------------
self.vpaned_left.add1(self.__create_frame(self.block_notebook))
self.vpaned_left.add2(self.__create_frame(self.property_box))
self.vpaned_left.set_position(System.properties.vpaned_left)
self.connect("delete-event", self.main_control.exit)
self.connect("key-press-event", self.__on_key_press)
self.connect("check-resize", self.__resize)
self.main_control.init()
def __init__(self):
'''Init Main screenshot.'''
# Init.
self.action = ACTION_WINDOW # current action status
# the windows in this workspace coordinate info
self.screenshot_window_info = get_screenshot_window_info()
#print "window info:", self.screenshot_window_info
self.monitor_x, self.monitor_y, self.width, self.height = get_current_monitor_info()
#self.width = SCREEN_WIDTH # this monitor width
#self.height = SCREEN_HEIGHT # this monitor height
#self.monitor_x = SCREEN_X # this monitor source point's x coordinate
#self.monitor_y = SCREEN_Y # this monitor source point's y coordinate
# the screenshot area's x, y, width, height
self.x = self.y = self.rect_width = self.rect_height = 0
self.save_op_index = SAVE_OP_AUTO # current operation when the save button clicked
#self.buttonToggle = None
self.drag_position = None
self.last_drag_position = None
self.dragStartX = self.dragStartY = self.dragStartOffsetX = self.dragStartOffsetY = 0
self.textDragOffsetX = self.textDragOffsetY = 0
self.drag_flag = False # a flag if the selected area can be dragged
self.show_toolbar_flag = False # a flag if the toolbar has shown
self.show_colorbar_flag = False # a flag if the colorbar has shown
self.show_text_window_flag = False # a flag if the text_window has shown
self.text_drag_flag = False # a flag if the text_window can be dragged
self.text_modify_flag = False # a flag if the text has been modified
self.draw_text_layout_flag = False # a flag if the text layout will be drawn
self.share_to_flag = False # a flag if the screenshot will be shared
self.window_flag = True # a flag if has not selected area or window
self.is_subprocess = config.OPTION_SUB
self.saveFiletype = 'png'
self.saveFilename = config.OPTION_FILE
# make sure the toolbar in this monitor
self.toolbarOffsetX = self.monitor_x + 10
self.toolbarOffsetY = self.monitor_y + 10
#self.toolbarOffsetX = 10
#self.toolbarOffsetY = 10
#self.toolbar_height = 50
self.action_size = ACTION_SIZE_SMALL # the draw action's line width
self.action_color = "#FF0000" # the draw action's color
self.font_name = "Sans" # the fontname of text to draw
self.font_size = 12 # the fontsize of text to draw
# Init action list.
self.current_action = None # current drawing action
self.action_list = [] # a list of actions have created
self.current_text_action = None # current drawing text action
self.text_action_list = [] # a list of text actions have created
self.text_action_info = {} # the created text actions' info
# Get desktop background.
# a gtk.gdk.Pixbuf of the desktop_background
self.desktop_background = self.get_desktop_snapshot()
# a string containing the pixel data of the pixbuf
self.desktop_background_pixels= self.desktop_background.get_pixels()
# the number of the pixbuf channels.
self.desktop_background_n_channels = self.desktop_background.get_n_channels()
# the number of bytes between rows.
self.desktop_background_rowstride = self.desktop_background.get_rowstride()
# Init window.
self.window = RootWindow(self)
# Init toolbar window.
self.toolbar = Toolbar(self.window.window, self)
# Init color window.
self.colorbar = Colorbar(self.window.window, self)
# right button press menu
self.right_menu = RightMenu(self)
# Show.
self.window.show()
self.window.set_cursor(ACTION_WINDOW)
dss.hide()
class Application(object):
def __init__(self, options):
self.options = options
self.main_window = MainWindow(self)
self.session_manager = debugsession.SessionManager(self)
self.console = Console(self)
self.main_window.console = self.console
self.stack = StackViewer(self)
self.namespace = AllNamespaceViewer(self)
self.threads = ThreadsViewer(self)
self.source = SourceViewer(self)
self.status = StatusBar(self)
self.breaks = BreakpointViewer(self)
self.toolbar = Toolbar(self)
debugsession.connect_events(self)
def launch(self, filename):
def _l(filename):
import threading
if filename is not None:
def _t():
self.session_manager.launch(True, filename)
t = threading.Thread(target=_t)
t.start()
gobject.idle_add(_l, filename)
def update_threads(self, event):
current_thread = event.m_current_thread
threads_list = event.m_thread_list
def _u(threads_list, current_thread):
self.threads.update_threads(threads_list, current_thread)
gobject.idle_add(_u, threads_list, current_thread)
def update_thread_broken(self, event):
print 'threadbroken'
tid = event.m_tid
def _u(tid):
self.threads.broken_thread(tid)
gobject.idle_add(_u, tid)
def update_no_threads(self, event):
print 'nothreads'
def update_state(self, event):
state = event.m_state
print 'state', state
def _u(state):
self.status.update_running_status(state)
def _u2(state):
self.toolbar.update_state(state)
def _u3(state):
self.source.update_state(state)
gobject.idle_add(_u, state)
gobject.idle_add(_u2, state)
def update_frame(self, event):
print 'frame', event.m_frame_index
index = event.m_frame_index
def _u(index):
self.stack.select_frame(index)
gobject.idle_add(_u, index)
self.update_source(-index - 1)
def update_stack(self, event):
print 'updatestack'
stack = event.m_stack
self._last_stack = stack
def _u(stack):
self.stack.update_stack(stack)
gobject.idle_add(_u, stack)
self.update_source(-1)
def update_source(self, index):
def _u(index):
si = StackItem(index, *self._last_stack['stack'][index])
self.source.goto(si.filename, si.linenumber)
gobject.idle_add(_u, index)
def update_namespace(self, event):
def _u():
self.namespace.update_namespace()
gobject.idle_add(_u)
def update_bp(self, event):
def _u(event):
act = event.m_action
if event.m_bp is not None:
filename = event.m_bp.m_filename
linenumber = event.m_bp.m_lineno
index = event.m_bp.m_id
indices = None
else:
filename = None
linenumber = None
index = None
indices = event.m_id_list
self.breaks.update_bp(act, index, indices, filename, linenumber)
gobject.idle_add(_u, event)
def __init__(self):
gtk.Window.__init__(self)
self.set_size_request(640, 480)
self.set_default_size(1366, 768)
#self.set_default_size(800, 600)
self.winstate = 0
self.maximize()
self.connect("delete-event", self.quit)
self.bindings = gtk.AccelGroup()
self.add_accel_group(self.bindings)
self.setup = gtk.PageSetup()
self.settings = gtk.PrintSettings()
self.filename = None
self.update_title()
icon = gtk.gdk.pixbuf_new_from_file(os.path.join(os.path.dirname(__file__), "..", "images", "canvas-logo.png"))
self.set_icon(icon)
vbox = gtk.VBox()
self.add(vbox)
self.menu = MenuBar(self)
vbox.pack_start(self.menu, False, False)
self.menu.append_menu("_" + _("File"))
self.menu.append_item(gtk.STOCK_NEW, "new", "<Control>N")
self.menu.append_item(gtk.STOCK_OPEN, "open", "<Control>O")
self.menu.append_item(gtk.STOCK_SAVE, "save", "<Control>S")
self.menu.append_item(gtk.STOCK_SAVE_AS, "save-as", "<Control><Shift>S")
self.menu.append_separator()
self.menu.append_item(gtk.STOCK_PAGE_SETUP, "page-setup")
self.menu.append_item(gtk.STOCK_PRINT_PREVIEW, "print-preview", "<Control><Shift>P")
self.menu.append_item(gtk.STOCK_PRINT, "print", "<Control>P")
self.menu.append_separator()
self.menu.append_menu("_" + _("Document"), True)
self.menu.append_item(SET_BACKGROUND, "set-background")
self.menu.ascend()
self.menu.append_separator()
self.menu.append_menu("_" + _("Export"), True)
self.menu.append_item(EXPORT_TO_PDF, "export-to-pdf")
self.menu.ascend()
self.menu.append_separator()
self.menu.append_item(gtk.STOCK_QUIT, "quit", "<Control>Q")
self.menu.append_menu("_" + _("Edit"))
self.menu.append_item(gtk.STOCK_UNDO, "undo", "<Control>Z")
self.menu.append_item(gtk.STOCK_REDO, "redo", "<Control>Y")
self.menu.append_separator()
self.menu.append_item(gtk.STOCK_COPY, "copy", "<Control>C")
self.menu.append_item(gtk.STOCK_CUT, "cut", "<Control>X")
self.menu.append_item(gtk.STOCK_PASTE, "paste", "<Control>V")
self.menu.append_separator()
self.menu.append_item(gtk.STOCK_DELETE, "delete", "Delete")
self.menu.append_separator()
self.menu.append_item(gtk.STOCK_SELECT_ALL, "select-all", "<Control>A")
self.menu.append_menu("_" + _("View"))
self.menu.append_toggle(MARGINS_ENABLED, "margins")
self.menu.append_toggle(GRID, "grid")
self.menu.append_toggle(GUIDES, "guides")
self.menu.append_toggle(SNAP_ENABLED, "snap")
self.menu.append_toggle(_("Z-Order hint"), "hints", toggled = False)
self.menu.append_separator()
self.menu.append_toggle(gtk.STOCK_PROPERTIES, "properties")
self.menu.append_toggle(_("Menubar"), "menubar")
self.menu.append_toggle(_("Statusbar"), "statusbar")
self.menu.append_menu("_" + _("Insert"))
self.menu.append_item(LINE, "line")
self.menu.append_item(ARC, "arc")
self.menu.append_item(CURVE, "curve")
self.menu.append_item(CONNECTOR, "connector")
self.menu.append_menu(BOX, "box", True)
self.menu.append_item(BOX, "box")
self.menu.append_item(SPLIT_HORIZONTALLY, "split-horizontally")
self.menu.append_item(SPLIT_VERTICALLY, "split-vertically")
self.menu.append_item(REMOVE_SPLIT, "remove-split")
self.menu.ascend()
self.menu.append_item(ROUNDED_BOX, "rounded-box")
self.menu.append_item(TEXT, "text")
self.menu.append_item(TABLE, "table")
self.menu.append_item(CHART, "chart")
self.menu.append_item(BARCODE, "barcode")
self.menu.append_item(IMAGE, "image")
self.menu.append_menu("_" + _("Format"))
self.menu.append_item(gtk.STOCK_SELECT_FONT, "select-font")
self.menu.append_separator()
self.menu.append_item(gtk.STOCK_SELECT_COLOR, "select-color")
self.menu.append_menu("_" + _("Tools"))
self.menu.append_item(GROUP, "group", "<Control>G")
self.menu.append_item(UNGROUP, "ungroup", "<Control><Shift>G")
self.menu.append_separator()
self.menu.append_item(BRING_TO_FRONT, "bring-to-front", "<Control>plus")
self.menu.append_item(BRING_TO_BACK, "bring-to-back", "<Control>minus")
self.menu.append_separator()
self.menu.append_menu("_" + _("Zoom"), True)
self.menu.append_item(gtk.STOCK_ZOOM_FIT, "zoom-fit", "<Control>0")
self.menu.append_item(gtk.STOCK_ZOOM_100, "zoom-100", "<Control>1")
self.menu.append_item(gtk.STOCK_ZOOM_IN, "zoom-in", "<Control><Shift>plus")
self.menu.append_item(gtk.STOCK_ZOOM_OUT, "zoom-out", "<Control><Shift>minus")
self.menu.ascend()
self.menu.append_separator()
self.menu.append_menu("_" + _("Objects alignment"), True)
self.menu.append_item(ALIGN_OBJECTS_NORTHWEST, "align-objects-northwest")
self.menu.append_item(ALIGN_OBJECTS_NORTH, "align-objects-north")
self.menu.append_item(ALIGN_OBJECTS_NORTHEAST, "align-objects-northeast")
self.menu.append_item(ALIGN_OBJECTS_SOUTHWEST, "align-objects-southwest")
self.menu.append_item(ALIGN_OBJECTS_SOUTH, "align-objects-south")
self.menu.append_item(ALIGN_OBJECTS_SOUTHEAST, "align-objects-southeast")
self.menu.append_item(ALIGN_OBJECTS_WEST, "align-objects-west")
self.menu.append_item(ALIGN_OBJECTS_CENTER_BOTH, "align-objects-center-both")
self.menu.append_item(ALIGN_OBJECTS_EAST, "align-objects-east")
self.menu.append_item(ALIGN_OBJECTS_CENTER_HORIZONTAL, "align-objects-center-horizontal")
self.menu.append_item(ALIGN_OBJECTS_CENTER_VERTICAL, "align-objects-center-vertical")
self.menu.ascend()
self.menu.append_menu("_" + _("Paper alignment"), True)
self.menu.append_item(ALIGN_PAPER_NORTHWEST, "align-paper-northwest")
self.menu.append_item(ALIGN_PAPER_NORTH, "align-paper-north")
self.menu.append_item(ALIGN_PAPER_NORTHEAST, "align-paper-northeast")
self.menu.append_item(ALIGN_PAPER_SOUTHWEST, "align-paper-southwest")
self.menu.append_item(ALIGN_PAPER_SOUTH, "align-paper-south")
self.menu.append_item(ALIGN_PAPER_SOUTHEAST, "align-paper-southeast")
self.menu.append_item(ALIGN_PAPER_WEST, "align-paper-west")
self.menu.append_item(ALIGN_PAPER_CENTER_BOTH, "align-paper-center-both")
self.menu.append_item(ALIGN_PAPER_EAST, "align-paper-east")
self.menu.append_item(ALIGN_PAPER_CENTER_HORIZONTAL, "align-paper-center-horizontal")
self.menu.append_item(ALIGN_PAPER_CENTER_VERTICAL, "align-paper-center-vertical")
self.menu.ascend()
self.menu.append_menu("_" + _("Window"))
self.menu.append_item(gtk.STOCK_FULLSCREEN, "fullscreen", "<Control>F")
self.menu.append_menu("_" + _("Help"), right=True)
self.menu.append_item(gtk.STOCK_HELP, "help", "F1")
self.menu.append_separator()
self.menu.append_item(gtk.STOCK_ABOUT, "about")
self.menu.show_all()
htoolbar = Toolbar(HORIZONTAL)
vbox.pack_start(htoolbar, False, False)
htoolbar.append(gtk.STOCK_NEW, "new")
htoolbar.append(gtk.STOCK_OPEN, "open")
htoolbar.append(gtk.STOCK_SAVE, "save")
htoolbar.append_separator()
htoolbar.append(gtk.STOCK_PRINT, "print")
htoolbar.append_separator()
htoolbar.append(gtk.STOCK_UNDO, "undo")
htoolbar.append(gtk.STOCK_REDO, "redo")
htoolbar.append_separator()
htoolbar.append(gtk.STOCK_CUT, "cut")
htoolbar.append(gtk.STOCK_COPY, "copy")
htoolbar.append(gtk.STOCK_PASTE, "paste")
htoolbar.append_separator()
htoolbar.append(gtk.STOCK_DELETE, "delete")
htoolbar.append_separator()
htoolbar.append_with_submenu(LINE_STYLE_CONTINUOUS, "line-style-continuous")
htoolbar.append_to_submenu(LINE_STYLE_POINT_DASH, "line-style-point-dash")
htoolbar.append_to_submenu(LINE_STYLE_POINT, "line-style-point")
htoolbar.append_to_submenu(LINE_STYLE_DASH, "line-style-dash")
htoolbar.append_separator()
htoolbar.append_with_submenu(gtk.STOCK_ZOOM_FIT, "zoom-fit")
htoolbar.append_to_submenu(gtk.STOCK_ZOOM_100, "zoom-100")
htoolbar.append_to_submenu(gtk.STOCK_ZOOM_IN, "zoom-in")
htoolbar.append_to_submenu(gtk.STOCK_ZOOM_OUT, "zoom-out")
htoolbar.append_separator()
htoolbar.append_toggle(MARGINS_ENABLED, "margins")
htoolbar.append_toggle(GRID, "grid")
htoolbar.append_toggle(GUIDES, "guides")
htoolbar.append_toggle(SNAP_ENABLED, "snap")
htoolbar.append_separator()
htoolbar.append(EXPORT_TO_PDF, "export-to-pdf")
htoolbar.append_separator()
htoolbar.append_toggle(GROUP, "group")
htoolbar.append_separator()
htoolbar.append(BRING_TO_FRONT, "bring-to-front")
htoolbar.append(BRING_TO_BACK, "bring-to-back")
htoolbar.append_separator()
htoolbar.append_with_submenu(ALIGN_OBJECTS_CENTER_BOTH, "align-object-center-both")
htoolbar.append_to_submenu(ALIGN_OBJECTS_NORTHWEST, "align-object-northwest")
htoolbar.append_to_submenu(ALIGN_OBJECTS_NORTH, "align-object-north")
htoolbar.append_to_submenu(ALIGN_OBJECTS_SOUTHWEST, "align-object-southwest")
htoolbar.append_to_submenu(ALIGN_OBJECTS_NORTHEAST, "align-object-northeast")
htoolbar.append_to_submenu(ALIGN_OBJECTS_SOUTH, "align-object-south")
htoolbar.append_to_submenu(ALIGN_OBJECTS_SOUTHEAST, "align-object-southeast")
htoolbar.append_to_submenu(ALIGN_OBJECTS_WEST, "align-object-west")
htoolbar.append_to_submenu(ALIGN_OBJECTS_EAST, "align-object-east")
htoolbar.append_to_submenu(ALIGN_OBJECTS_CENTER_HORIZONTAL, "align-object-center-horizontal")
htoolbar.append_to_submenu(ALIGN_OBJECTS_CENTER_VERTICAL, "align-object-center-vertical")
htoolbar.append_with_submenu(ALIGN_PAPER_CENTER_BOTH, "align-paper-center-both")
htoolbar.append_to_submenu(ALIGN_PAPER_NORTHWEST, "align-paper-northwest")
htoolbar.append_to_submenu(ALIGN_PAPER_NORTH, "align-paper-north")
htoolbar.append_to_submenu(ALIGN_PAPER_SOUTHWEST, "align-paper-southwest")
htoolbar.append_to_submenu(ALIGN_PAPER_NORTHEAST, "align-paper-northeast")
htoolbar.append_to_submenu(ALIGN_PAPER_SOUTH, "align-paper-south")
htoolbar.append_to_submenu(ALIGN_PAPER_SOUTHEAST, "align-paper-southeast")
htoolbar.append_to_submenu(ALIGN_PAPER_WEST, "align-paper-west")
htoolbar.append_to_submenu(ALIGN_PAPER_EAST, "align-paper-east")
htoolbar.append_to_submenu(ALIGN_PAPER_CENTER_HORIZONTAL, "align-paper-center-horizontal")
htoolbar.append_to_submenu(ALIGN_PAPER_CENTER_VERTICAL, "align-paper-center-vertical")
htoolbar.append_separator()
htoolbar.append(gtk.STOCK_HELP, "help")
hbox = gtk.HBox()
vbox.add(hbox)
vtoolbar = Toolbar()
vtoolbar.set_style(gtk.TOOLBAR_ICONS)
hbox.pack_start(vtoolbar, False, False)
vtoolbar.append(LINE, "line")
vtoolbar.append(ARC, "arc")
vtoolbar.append(CURVE, "curve")
vtoolbar.append(CONNECTOR, "connector")
vtoolbar.append_with_submenu(BOX, "box")
vtoolbar.append_to_submenu(SPLIT_HORIZONTALLY, "split-horizontally")
vtoolbar.append_to_submenu(SPLIT_VERTICALLY, "split-vertically")
vtoolbar.append_to_submenu(REMOVE_SPLIT, "remove-split")
vtoolbar.append(ROUNDED_BOX, "rounded-box")
vtoolbar.append(TEXT, "text")
vtoolbar.append(BARCODE, "barcode")
vtoolbar.append(TABLE, "table")
vtoolbar.append(CHART, "chart")
vtoolbar.append(IMAGE, "image")
notebook = gtk.Notebook()
notebook.set_show_tabs(True)
notebook.set_show_border(False)
#notebook.set_tab_pos(gtk.POS_LEFT)
notebook.set_tab_pos(gtk.POS_RIGHT)
hbox.add(notebook)
self.status = Statusbar()
self.id = self.status.get_context_id(_("Edit mode"))
vbox.pack_start(self.status, False, False)
label = gtk.Label(_("Design view"))
label.set_angle(90)
self.editor = Editor(self)
self.editor.set_paper()
notebook.append_page(self.editor, label)
label = gtk.Label(_("XML view"))
label.set_angle(90)
def get_source_view():
source = gtk.ScrolledWindow()
source.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
view = gtk.TextView()
self.code = gtk.TextBuffer()
view.set_buffer(self.code)
source.add(view)
return source
if '--source-editor-test' in sys.argv:
while True:
try:
from ui.code_editor import SourcePad
except:
source = get_source_view()
break
source = SourcePad(self)
self.code = source.buffer
source.set_language("xml")
break
else:
source = get_source_view()
notebook.append_page(source, label)
self.menu.connect("new", self.new)
self.menu.connect("open", self.open)
self.menu.connect("save", self.save)
self.menu.connect("save-as", self.save_as)
self.menu.connect("page-setup", self.page_setup)
self.menu.connect("export-to-pdf", self.export_to_pdf)
self.menu.connect("set-background", self.set_background)
self.menu.connect("quit", self.quit)
self.menu.connect("cut", self.editor.canvas.cut)
self.menu.connect("copy", self.editor.canvas.copy)
self.menu.connect("paste", self.editor.canvas.paste)
self.menu.connect("delete", self.editor.canvas.delete)
self.menu.connect("select-all", self.editor.canvas.select_all)
self.menu.connect("margins", self.editor.canvas.toggle_margins)
self.menu.connect("grid", self.editor.canvas.toggle_grid)
self.menu.connect("guides", self.editor.canvas.toggle_guides)
self.menu.connect("snap", self.editor.canvas.toggle_snap)
self.menu.connect("hints", self.editor.canvas.toggle_hints)
self.menu.connect("properties", self.editor.toggle_properties)
self.menu.connect("menubar", self.toggle_menubar)
self.menu.connect("statusbar", self.toggle_statusbar)
self.menu.connect("bring-to-front", self.editor.canvas.bring_to_front)
self.menu.connect("bring-to-back", self.editor.canvas.bring_to_back)
self.menu.connect("align-paper-center-horizontal", self.editor.canvas.paper_center_horizontal)
self.menu.connect("line", self.create, "Line")
self.menu.connect("curve", self.create, "Curve")
self.menu.connect("connector", self.create, "Connector")
self.menu.connect("box", self.create, "Box")
self.menu.connect("rounded-box", self.create, "Rounded")
self.menu.connect("text", self.create, "Text")
self.menu.connect("barcode", self.create, "BarCode")
self.menu.connect("table", self.create, "Table")
self.menu.connect("image", self.create, "Image")
self.menu.connect("chart", self.create, "Chart")
self.menu.connect("fullscreen", self.fullscreen)
self.menu.connect("about", self.about)
self.menu.connect("help", self.help)
self.menu.connect("split-horizontally", self.editor.canvas.split_horizontally)
self.menu.connect("split-vertically", self.editor.canvas.split_vertically)
self.menu.connect("remove-split", self.editor.canvas.remove_split)
htoolbar.connect("new", self.new)
htoolbar.connect("open", self.open)
htoolbar.connect("save", self.save)
htoolbar.connect("snap", self.editor.canvas.toggle_snap)
htoolbar.connect("grid", self.editor.canvas.toggle_grid)
htoolbar.connect("guides", self.editor.canvas.toggle_guides)
htoolbar.connect("margins", self.editor.canvas.toggle_margins)
htoolbar.connect("cut", self.editor.canvas.cut)
htoolbar.connect("copy", self.editor.canvas.copy)
htoolbar.connect("paste", self.editor.canvas.paste)
htoolbar.connect("delete", self.editor.canvas.delete)
htoolbar.connect("bring-to-front", self.editor.canvas.bring_to_front)
htoolbar.connect("bring-to-back", self.editor.canvas.bring_to_back)
htoolbar.connect("export-to-pdf", self.export_to_pdf)
htoolbar.connect("help", self.help)
vtoolbar.connect("line", self.create, "Line")
vtoolbar.connect("arc", self.create, "Arc")
vtoolbar.connect("curve", self.create, "Curve")
vtoolbar.connect("connector", self.create, "Connector")
vtoolbar.connect("box", self.create, "Box")
vtoolbar.connect("rounded-box", self.create, "Rounded")
vtoolbar.connect("text", self.create, "Text")
vtoolbar.connect("barcode", self.create, "BarCode")
vtoolbar.connect("table", self.create, "Table")
vtoolbar.connect("image", self.create, "Image")
vtoolbar.connect("chart", self.create, "Chart")
vtoolbar.connect("split-horizontally", self.editor.canvas.split_horizontally)
vtoolbar.connect("split-vertically", self.editor.canvas.split_vertically)
vtoolbar.connect("remove-split", self.editor.canvas.remove_split)
notebook.connect("switch-page", self.switch)
self.connect("key-press-event", self.key_press)
class L1(object):
def __init__(self, windowSurface, mainClock, SKY_BLUE, gameData, showFPS):
self.getFiles = File
#Create game data
self.lockedGuns = gameData['lockedGuns']
self.lockedTools = gameData['lockedTools']
self.sound = gameData['sound']
self.runGame = True
self.showFPS = showFPS
#Setup theme music
pygame.mixer.music.load('files//sound//gameTheme.mp3')
#Constants
self.BPS = 8 #(Bullets Per Second)
self.TOTAL_SUPPLIES = 12 #Total Supplies for each powerup
self.SKY_BLUE = SKY_BLUE #Sky color
self.TOTAL_COPS = 32 #Total number of all cops in level
#Variables
self.windowSurface = windowSurface
self.clock = mainClock
#Setup Dr. Taco's Direction
self.moveRight = False
self.moveLeft = False
#Set Start Weapon and tool, and make sure menus are closed.
self.currentWeapon = '9mm'
self.currentTool = 'crowbar'
self.dropDownGun = False
self.dropDownTool = False
#Set Basic Values
self.score = 0
self.ammo = 30
self.hit = False
self.gunButtonCoords = [695, 30, 735, 30, 715, 50]
self.toolButtonCoords = [395, 30, 435, 30, 415, 50]
self.officerX = 1500
self.officerGunX = {'right':abs(self.officerX) + 55, 'left':self.officerX + -3}
self.gunXlist = []
self.takeStep = 0
self.direction = 1
self.goUp = None
self.shootBullet = False
self.message = 'This is the Message Box.'
self.skill_level = 800
self.centered = False
self.drop = False
self.paused = False
self.reload = False
self.endReload = False
self.endBack = False
self.die = False
self.val = None
self.rapidFire = [0, False]
self.lifeLeft = 0
self.endPoint = 0
self.back = False
self.tacosCollected = 0
self.first = True
self.flame = False
#Initialize Objects
self.level_1 = Level_1(self.windowSurface)
self.tools = Toolbar(self.lockedGuns, self.windowSurface)
self.gunMenu = selectGunMenu(self.lockedGuns)
self.toolMenu = selectToolMenu(self.lockedTools)
self.gunArrowButton = Button(self.windowSurface)
self.toolArrowButton = Button(self.windowSurface)
self.DrTaco = Person('Doctor Taco', self.windowSurface, self.officerX, self.officerGunX)
self.wingame = Popups(self.windowSurface)
#Default lists
self.copList = []
self.Xlist = []
self.num = 700
#Add a cop every 250 pixels for the range in TOTAL_COPS
for i in range(0, self.TOTAL_COPS):
self.Xlist.append(self.num)
self.num += 250
self.num = 0
#Add the cop object
self.index = 0
for cop in range(0, self.TOTAL_COPS):
self.copList.append(AI(self.windowSurface, self.skill_level, self.Xlist[self.index]))
self.index += 1
#Add the cops gun
self.index = 0
for i in range(0, self.TOTAL_COPS):
self.gunXlist.append({'right':abs(self.Xlist[self.index]) + 80, 'left':self.Xlist[self.index] + -10})
self.index += 1
#Add Supplies to random locations
self.healthX = []
self.tacosX = []
self.tacosY = []
self.ammoX = []
self.ammoBoxes = []
self.healthBoxes = []
self.tacos = []
for i in range(0, self.TOTAL_SUPPLIES):
self.ammoBoxes.append(Powerups(self.windowSurface, self.score))
self.healthBoxes.append(Powerups(self.windowSurface, self.score))
for i in range(0, 2):
self.tacos.append(Powerups(self.windowSurface, self.score))
self.tacosX.append(random.randint(300, 9000))
self.tacosY.append(random.randint(300, 490))
self.healthX.append(random.randint(300, 9000))
self.ammoX.append(random.randint(300, 9000))
def play(self, highscore, totalscore):
#If there is no quit event, (i.e reload or back)
while self.runGame == True:
self.stopAll = False
#Setup rect list and blit background
self.reload = False
self.ammoX, self.healthX, self.tacosX, self.endPoint = self.level_1.blitBackground(self.moveRight, self.moveLeft, self.ammoX,
self.healthX, self.tacosX, self.copList, self.centered)
#Setup all the cops gun position.
self.index = 0
for cop in self.copList:
self.gunXlist[self.index] = {'right':self.copList[self.index].get_rect()[0] + 80, 'left':self.copList[self.index].get_rect()[0] + -10}
self.index += 1
for event in pygame.event.get():
self.sound, self.paused, self.reload, self.back = self.tools.addButtons(self.sound, event)
if event.type == QUIT:
self.runGame = False
self.stopAll = True
if event.type == KEYDOWN:
if event.key == K_RIGHT:
self.direction = 1
self.moveRight = True
self.moveLeft = False
if event.key == K_LEFT:
self.direction = 0
self.moveLeft = True
self.moveRight = False
if event.key == K_UP:
if self.goUp == None:
self.goUp = True
if event.key == K_SPACE:
self.shootBullet = True
self.rapidFire[1] = True
if event.type == KEYUP:
self.moveRight = False
self.moveLeft = False
self.shootBullet = False
self.rapidFire[1] = False
if self.currentWeapon == 'flamethrower':
self.shootBullet = False
self.dropDownGun = self.gunArrowButton.arrow(self.dropDownGun, event, self.gunButtonCoords)
self.dropDownTool = self.toolArrowButton.arrow(self.dropDownTool, event, self.toolButtonCoords)
if self.dropDownGun:
self.currentWeapon = self.gunMenu.selectGunButton(self.currentWeapon, event)
if self.dropDownTool:
self.currentTool = self.toolMenu.selectToolButton(self.currentTool, event)
self.rapidFire[0] += 1
if self.rapidFire[0] == self.BPS:
self.rapidFire[0] = 0
if self.rapidFire[1]:
if self.currentWeapon == 'AK-47':
self.shootBullet = True
#Add Health bar, score, message box, buttons, and ammo text to screen
self.tools.display()
self.tools.messageBox(self.message)
self.tools.countScore(self.score)
self.tools.countAmmo(self.ammo, self.currentWeapon)
self.sound, self.paused, self.reaload, self.backk = self.tools.addButtons(self.sound, None)
self.tools.health(self.lifeLeft)
#Blit select gun menu, select tool menu, and drop down arrows to screen and allow user to select weapon (or gun)
self.dropDownGun, self.currentWeapon = self.gunMenu.chooseGun(self.windowSurface, self.dropDownGun, self.currentWeapon)
self.dropDownTool, self.currentTool = self.toolMenu.chooseTool(self.windowSurface, self.dropDownTool, self.currentTool)
self.gunArrowButton.blitArrow(self.windowSurface, self.dropDownGun, self.gunButtonCoords)
self.toolArrowButton.blitArrow(self.windowSurface, self.dropDownTool, self.toolButtonCoords)
#Get Frames per second and and it to screen
self.fps = int(self.clock.get_fps())
self.tools.FPS(self.fps, self.showFPS)
#If game is not paused, let Dr. Taco walk, jump, and shoot selected weapon
if self.paused != True:
#Make it so Dr. Taco can jump and move
self.takeStep, self.centered = self.DrTaco.walk(self.takeStep, self.direction, self.moveLeft, self.moveRight, self.currentWeapon)
self.goUp = self.DrTaco.jump(self.goUp)
#If weapon is the Pistol, put it in Dr. Taco's hand and enable it for use.
if self.currentWeapon == '9mm':
self.shootBullet, self.hit, self.ammo, self.message, self.score, self.officerX, self.drop, self.val, self.val, self.lifeLeft = self.DrTaco.shootPistol(
self.shootBullet, self.hit, self.direction, self.officerGunX, self.sound, self.copList, self.ammo, self.message, self.score,
lifeLeft = self.lifeLeft)
#If weapon is the Shotgun, put it in Dr. Taco's hand and enable it for use.
if self.currentWeapon == 'shotgun':
self.shootBullet, self.hit, self.ammo, self.message, self.score, self.officerX, self.drop, self.val, self.lifeLeft = self.DrTaco.shootShotgun(
self.shootBullet, self.hit, self.direction, self.officerGunX, self.sound, self.copList, self.ammo, self.message, self.score,
lifeLeft = self.lifeLeft)
#If weapon is the AK-47, put it in Dr. Taco's hand and enable it for use.
if self.currentWeapon == 'AK-47':
self.shootBullet, self.hit, self.ammo, self.message, self.score, self.officerX, self.drop, self.val, self.lifeLeft = self.DrTaco.shootAK(
self.shootBullet, self.hit, self.direction, self.officerGunX, self.sound, self.copList, self.ammo, self.message, self.score,
lifeLeft = self.lifeLeft)
self.shootBullet = False
#If weapon is the bazooka, put it in Dr. Taco's hand and enable it for use.
if self.currentWeapon == 'bazooka':
self.shootBullet, self.hit, self.ammo, self.message, self.score, self.officerX, self.drop, self.val, self.lifeLeft = self.DrTaco.shootBazooka(
self.shootBullet, self.hit, self.direction, self.officerGunX, self.sound, self.copList, self.ammo, self.message, self.score,
self.currentWeapon, lifeLeft = self.lifeLeft)
#If weapon is the flamethrower, put it in Dr. Taco's hand and enable it for use.
if self.currentWeapon == 'flamethrower':
self.shootBullet, self.hit, self.ammo, self.message, self.score, self.officerX, self.drop, self.val, self.lifeLeft, self.flame = self.DrTaco.shootFlame(
self.shootBullet, self.hit, self.direction, self.officerGunX, self.sound, self.copList, self.ammo, self.message, self.score,
self.currentWeapon, self.lifeLeft)
#Make all the cops think
self.index = 0
for cop in self.copList:
self.hit, self.endReload, self.endBack, self.lifeLeft = cop.think(self.DrTaco.get_rect(), self.copList[self.index].get_rect()[0], self.gunXlist[self.index],
self.drop, self.hit, self.sound, self.lifeLeft, self.flame)
#If Dr. Taco is dead break out of loop
if self.endReload:
break
if self.endBack:
break
self.index += 1
#Blit all the supplies to the screen by running their functions
self.index = 0
for box in self.ammoBoxes:
self.score, self.ammo = box.ammoBox(self.ammoX[self.index], 490, self.DrTaco.get_rect(), self.ammo, self.score, self.sound)
self.index += 1
self.index = 0
for box in self.healthBoxes:
self.score, self.lifeLeft = box.healthBox(self.healthX[self.index], 490, self.DrTaco.get_rect(), self.lifeLeft, self.sound, self.score)
self.index += 1
self.index = 0
for box in self.tacos:
self.score, self.tacosCollected = box.taco(self.tacosX[self.index], self.tacosY[self.index],
self.DrTaco.get_rect(), self.sound, self.score, self.tacosCollected)
self.index += 1
#If Dr. Taco has reached the end of the level, display level completed popup and exit loop
if self.endPoint < 298:
self.endReload, self.back = self.wingame.wingame(self.score, self.tacosCollected)
#If the health bar length is too much set it to right size
if self.lifeLeft >= 20:
self.lifeLeft = 20
#Update screen and fill background
pygame.display.update()
self.clock.tick()
self.windowSurface.fill(self.SKY_BLUE)
#If reload button is clicked exit loop and enter another object
if self.endReload:
pygame.mixer.music.stop()
self.runGame = False
self.reload = True
if self.reload:
pygame.mixer.music.stop()
self.runGame = False
if self.back:
pygame.mixer.music.stop()
self.runGame = False
if self.endBack:
pygame.mixer.music.stop()
self.runGame = False
self.back = True
#Add score to total score
if self.runGame != True:
totalscore += self.score
#Check for high score
if highscore < self.score:
highscore = self.score
#Play music
if self.sound == True:
if self.first:
pygame.mixer.music.play(-1, 0.0)
self.first = False
else:
pygame.mixer.music.stop()
self.first = True
return self.reload, self.back, highscore, totalscore, self.stopAll
class App(object):
"""A simple OpenGL drawing application."""
def __init__(self, config=default):
"""Create an instance of a PyRysunek application.
Optional arguments:
config -- dictionary containing configuration values (see `config.default`)
"""
self.config = config
self.width, self.height = self.config.window_size
self.toolbar = Toolbar(self.config.toolbar)
self.context = Context(
objects = ObjectList(),
color_picker = self.toolbar.color_picker,
)
self._init_opengl()
if config.auto_load_on_start:
self.load()
def _init_opengl(self):
"""OpenGL initialization commands."""
glutInit(sys.argv)
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE)
glutInitWindowSize(self.width, self.height)
glutInitWindowPosition(*self.config.window_position)
glutCreateWindow(self.config.window_title)
# Assign callback functions
glutDisplayFunc(self.display)
glutReshapeFunc(self.reshape)
glutMouseFunc(self.mouse)
glutMotionFunc(self.motion)
glutIdleFunc(self.display)
glutKeyboardFunc(self.keyboard)
# Set background color
glClearColor(*self.config.bg_color)
def display(self):
"""Callback to draw the application in the screen."""
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
# Clear frame buffer
glClear(GL_COLOR_BUFFER_BIT)
for obj in self.context.objects:
obj.draw()
# Make sure that toolbar is on top of everything
self.toolbar.draw()
# Flush and swap buffers
glutSwapBuffers()
def reshape(self, w, h):
"""Callback to adjust the coordinate system whenever a window is
created, moved or resized.
"""
self.width, self.height = w, h
glViewport(0, 0, w, h)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
# Define left, right, bottom, top coordinates
gluOrtho2D(0.0, w, h, 0.0)
def mouse(self, button, state, x, y):
"""Callback to handle mouse click events."""
if (x, y) in self.toolbar:
self.toolbar.mouse(button, state, x, y)
else:
if state == GLUT_DOWN:
self.toolbar.current_tool.mouse_down(x, y, self.context)
elif state == GLUT_UP:
self.toolbar.current_tool.mouse_up(x, y, self.context)
if DEBUG:
print "<Mouse click event>"
print " button=%s, state=%s, x=%s, y=%s" % (button, state, x, y)
print " current_tool = %s" % self.toolbar.current_tool
print " len(objects) = %s" % len(self.context.objects)
print " objects[-3:] = %s" % self.context.objects[-3:]
def motion(self, x, y):
"""Callback to handle mouse drag events.
This method is called by OpenGL/GLUT when a mouse button is pressed
and movement occurs.
"""
self.toolbar.current_tool.mouse_move(x, y, self.context)
def keyboard(self, key, x, y):
"""Callback to handle key down events."""
if key == "\x1b":
# Exit on `ESC` keycode.
sys.exit(0)
elif key == "\x13":
# Ctrl+s
self.save()
elif key == "\x12":
# Ctrl+r
self.load()
else:
# Propagate event to toolbar.
self.toolbar.keyboard(key, x, y)
def save(self):
"""Save the current objects to disk.
Fail silently if `self.config.temp_file` fails to open.
"""
try:
temp_file = open(self.config.temp_file, "wb")
pickle.dump(self.context.objects, temp_file)
temp_file.close()
if DEBUG:
print "<Saved objects>"
except IOError:
if DEBUG:
print "<Failed to save objects>"
def load(self):
"""Load objects from disk.
Fail silently if `self.config.temp_file` fails to open.
"""
try:
temp_file = open(self.config.temp_file, "rb")
self.context.objects = pickle.load(temp_file)
temp_file.close()
if DEBUG:
print "<Load objects>"
except IOError:
if DEBUG:
print "<Failed to load objects>"
def createWidgets(self):
""" Creates and lays out the widgets for the mainwindow."""
# create Menus:
self.menubar = tk.Menu(self.mainframe)
filemenu = tk.Menu(self.menubar, tearoff=0)
mnuimport = tk.Menu(filemenu, tearoff=0)
mnuimport.add_command(label="Target list", command=self._file_menu_import_target_list)
mnuimport.add_command(label="Switch list", command=self._file_menu_import_switch_list)
filemenu.add_command(label="New search", command=self._file_menu_new_search, underline=1)
filemenu.add_cascade(label="Import", menu=mnuimport)
filemenu.add_separator()
filemenu.add_command(label="Settings", command=self._file_menu_settings, underline=0)
filemenu.add_command(label="Exit", command=self.quit, underline=1, accelerator="Ctrl+X")
#--end-- File menu build
#--start-- edit menu build
editmenu = Menu(self.menubar, tearoff=0)
editmenu.add_command(label="Add target(s)", underline=4, accelerator="Ctrl-T", command=self._edit_menu_add_target_to_list)
editmenu.add_command(label="Edit selected target", command=self._edit_menu_edit_selected_target)
editmenu.add_command(label="Delete selected target", command=self._edit_menu_del_selected_target)
editmenu.add_separator()
editmenu.add_command(label="Add host(s)", underline=4, accelerator="Ctrl-H", command=self._edit_menu_add_host_to_list)
editmenu.add_command(label="Edit selected host", command=self._edit_menu_edit_selected_host)
editmenu.add_command(label="Delete selected host", command=self._edit_menu_del_selected_host)
editmenu.add_separator()
editmenu.add_command(label="Clear log window", command=self.logg.clear)
#--end-- edit menu build
#--start-- view menu
viewmenu = Menu(self.menubar, tearoff=0)
viewmenu.add_checkbutton(label="Show/hide Logg", onvalue=True, offvalue=False, variable=self.viewlogg, command=self._viewmenu_show_window_pane)
#--end-- viewmenu
#--start-- help menu build
hlpmenu = tk.Menu(self.menubar, tearoff=0)
hlpmenu.add_command(label="Help", command=self._help_menu_help)
hlpmenu.add_command(label="About", command=self._help_menu_about)
#--end-- help menu build
#--start-- adding menus to main menu
self.menubar.add_cascade(label="File", menu=filemenu)
self.menubar.add_cascade(label="Edit", menu=editmenu)
self.menubar.add_cascade(label="View", menu=viewmenu)
self.menubar.add_cascade(label="Help", menu=hlpmenu)
#--end-- adding menus to main menu
try:
self.config(menu=self.menubar)
except AttributeError:
print("this faild!!!!")
# master is a toplevel window (Python 1.4/Tkinter 1.63)
tk.call(self, "config", "-menu", self.menubar)
#create Toolbar
toolbar = Toolbar(parent=self.mainframe)
toolbar.add(wtype="button", gfxpath=self.gfxpath + "start.png",
tooltip="Start the search", command=self.addtext)
toolbar.add(wtype="button", gfxpath=self.gfxpath + "new.png",
tooltip="Clears all results and start fresh")
toolbar.add(wtype="separator")
## toolbar.add(wtype="button", gfxpath=self.gfxpath + "addtarget.png",
## tooltip="Add target or a range of targets to targetslist", command=self.list_add)
## toolbar.add(wtype="button", gfxpath=self.gfxpath + "addhost.png",
## tooltip="Add a host or range of hosts to hostslist")
## toolbar.add(wtype="separator")
toolbar.add(wtype="button", gfxpath=self.gfxpath + "exit.png",
tooltip="Exits the program. (Ctrl-X)", command=self.quit)
toolbar.show()
# create Statusbar
self.status = StringVar()
self.statusbar = Label(self, textvariable=self.status, bd=1, relief=SUNKEN, anchor=W)
self.statusbar.pack(side=BOTTOM, fill=X)
self.status.set("Idle")
#create input boxes:
self.inputframe = Frame(self.mainframe, width=50, bd=1, relief=GROOVE, padx=12, pady=12)
Label(self.inputframe, text="Targets to look for:", pady=2).pack()
self.list_targets = Listbox(self.inputframe, selectmode=BROWSE)
self.list_targets.pack(side=TOP, pady=5)
self.listwidgets[self.list_targets.winfo_name] = 'targets'
self.list_targets_toolbar = Toolbar(parent=self.inputframe)
self.list_targets_toolbar.add(wtype="button", gfxpath=self.gfxpath + "addtarget.png",
tooltip="Add new target", command=lambda: self.list_add(widget=self.list_targets))
self.list_targets_toolbar.add(wtype="button", gfxpath=self.gfxpath + "edit.png",
tooltip="Edit selected target", command=lambda: self.edit_item(widget=self.list_targets))
self.list_targets_toolbar.add(wtype="button", gfxpath=self.gfxpath + "trash.png",
tooltip="Delete selected target", command=lambda: self.delete_item(widget=self.list_targets))
self.list_targets_toolbar.show()
Frame(self.inputframe, height=2, bd=1, relief=SUNKEN).pack(fill=X, padx=0, pady=10)
Label(self.inputframe, text="Hosts to scan:", pady=2).pack()
self.list_hosts = Listbox(self.inputframe, selectmode=BROWSE)
self.list_hosts.pack(side=TOP, pady=5)
self.listwidgets[self.list_hosts.winfo_name] = 'hosts'
self.list_hosts_toolbar = Toolbar(parent=self.inputframe)
self.list_hosts_toolbar.add(wtype="button", gfxpath=self.gfxpath + "addhost.png",
tooltip="Add new host", command=lambda: self.list_add(self.list_hosts))
self.list_hosts_toolbar.add(wtype="button", gfxpath=self.gfxpath + "edit.png",
tooltip="Edit selected host", command=lambda: self.edit_item(widget=self.list_hosts))
self.list_hosts_toolbar.add(wtype="button", gfxpath=self.gfxpath + "trash.png",
tooltip="Delete selected host", command=lambda: self.delete_item(widget=self.list_hosts))
self.list_hosts_toolbar.show()
self.inputframe.pack(side=RIGHT, fill=Y)
class Inventory:
# Global size for all item rects
cell_size = (64, 64)
# Global padding between inventory cells
cell_padding = 4
def __init__(self, capacity: int, def_pos: tuple, def_cells_per_row: int,
color: pygame.Color, cell_color: pygame.Color):
# The inventory's contents (a list of items)
self.contents = [None] * capacity
# Maximum number of items the inventory can hold
self.capacity = capacity
# Default position of the UI in pixels
self.def_pos = def_pos
# Default width of the inventory in item cells
self.def_cells_per_row = def_cells_per_row
# Colours of inventory rect and small grid rects respectively
self.color = color
self.cell_color = cell_color
# Apply defaults (defaults are used if these params are not specified by in the open() function
self.pos = def_pos
self.cells_per_row = def_cells_per_row
self.rect = pygame.Rect(self.pos, self.get_size())
#self.search_bar = SearchBar(new_bar_pos = (def_pos[0], def_pos[1]-30))
self.tool_bar = Toolbar(self.rect.width, self.rect.topleft,
pygame.Color(100, 100, 100), color)
# Inventory menu is initialized to a "closed" state
self.is_open = False
# Getters & setters
def get_contents(self):
return self.contents
def get_capacity(self):
return self.capacity
def get_pos(self):
return self.pos
def get_size(self):
width = (self.cell_size[0] +
self.cell_padding) * self.cells_per_row + self.cell_padding
height = (self.cell_size[1] + self.cell_padding) * math.ceil(
self.capacity / float(self.cells_per_row)) + self.cell_padding
return (width, height)
# Inventory manipulation
def take_item(self, screen_pos: tuple):
if isOpen:
i = self.pos_to_index(screen_pos)
if i is not None:
return self.take_item(i)
return None
def take_item(self, index: int):
return self.place_item(None, index)
def place_item(self, item: item.Item, screen_pos: tuple):
if isOpen:
i = self.pos_to_index(screen_pos)
if i is not None:
return self.place_item(item, i)
return None
def place_item(self, item: item.Item, index: int):
if self.contents[
index] is not None and item is not None and self.contents[
index].get_id() == item.get_id():
total_num = item.num + self.contents[index].num
if total_num <= item.max_stack:
self.contents[index].set_num(total_num)
taken = None
else:
item.set_num(total_num - item.max_stack)
self.contents[index].set_num(item.max_stack)
taken = item
else:
taken = self.contents[index]
self.contents[index] = item
return taken
def append_item(self, item: item.Item):
if item is None:
return
for i in range(0, self.capacity):
if (self.contents[i] is
None) or (self.contents[i].get_id() == item.get_id()
and self.contents[i].num < item.max_stack):
remaining = self.place_item(item, i)
if remaining is not None:
self.append_item(remaining)
return
# Main Interface
def menu_update(self, event):
# Update returns the number of the button that was pressed, set that to a number that we can use
sort_num = self.tool_bar.update(event)
# Yandere Dev let's GOOOOOOOOOOO!
if sort_num == 0:
print(len(self.contents))
sorted = sort.sort_by_id(self.contents)
elif sort_num == 1:
sorted = sort.sort_by_name(self.contents)
elif sort_num == 2:
sorted = sort.sort_by_type(self.contents)
elif sort_num == 3:
sorted = sort.sort_by_number(self.contents)
self.contents = sorted
return
elif sort_num == 4:
sorted = sort.sort_by_highlight(self.contents)
else:
return
self.contents = [None] * self.capacity
for i in sorted:
self.append_item(i)
def items_update(self, event, cursor_item):
if (event.type == pygame.MOUSEBUTTONDOWN
and cursor_item is None) or (event.type == pygame.MOUSEBUTTONUP
and cursor_item is not None):
i = self.pos_to_index(event.pos)
if i is not None:
return self.place_item(cursor_item, i)
return cursor_item
def open(self, pos=None, cells_per_row=None):
if pos is None:
pos = self.def_pos
if cells_per_row is None:
cells_per_row = self.def_cells_per_row
self.pos = pos
self.cells_per_row = cells_per_row
self.rect = pygame.Rect(self.pos, self.get_size())
self.is_open = True
self.tool_bar.set_active(True)
def close(self):
self.tool_bar.set_active(False)
self.is_open = False
def draw(self, screen: pygame.display):
pygame.draw.rect(screen, self.color, self.rect)
for i in range(0, self.capacity):
cell_pos = self.index_to_pos(i)
# Draw cell background
pygame.draw.rect(screen, self.cell_color,
pygame.Rect(cell_pos, self.cell_size))
# If cell is not empty, draw contained item
if self.contents[i] is not None:
self.contents[i].set_pos(cell_pos)
self.contents[i].display(screen)
for i in range(0, self.capacity):
# Display amount of items and description
if self.contents[i] is not None:
self.contents[i].description(screen, pygame.mouse.get_pos())
# Draw toolbar and get text from text_input
self.tool_bar.display(screen)
self.search_items(self.tool_bar.get_text())
# Utility
def pos_to_index(self, pos: tuple):
rel_pos = (pos[0] - self.pos[0], pos[1] - self.pos[1])
size = self.get_size()
if rel_pos[0] < 0 or rel_pos[0] > size[0] or rel_pos[1] < 0 or rel_pos[
1] > size[1]:
return None
x = int((rel_pos[0] + float(self.cell_padding) / 2) /
(self.cell_size[0] + self.cell_padding))
y = int((rel_pos[1] + float(self.cell_padding) / 2) /
(self.cell_size[1] + self.cell_padding))
i = x + (y * self.cells_per_row)
if i < self.capacity:
return int(i)
else:
return None
def index_to_pos(self, index: int):
x = self.pos[0] + (index % self.cells_per_row) * (
self.cell_size[0] + self.cell_padding) + self.cell_padding
y = self.pos[1] + int(index / self.cells_per_row) * (
self.cell_size[1] + self.cell_padding) + self.cell_padding
return (x, y)
# Use searchBar and inventory to find items from user input and highlights them
def search_items(self, search_term):
#print('Search term: ' + search_term)
if search_term == '':
self.unhighlight_all_items()
return
for i in self.contents:
if i is not None:
i.set_highlight(True)
if search_term.lower() in i.get_name().lower():
i.set_highlight_color(pygame.Color(255, 255, 0))
i.highlight_sort = True
else:
i.set_highlight_color(pygame.Color(100, 100, 100))
i.highlight_sort = False
def unhighlight_all_items(self):
for i in self.contents:
if i is not None:
i.set_highlight(False)
i.highlight_sort = False
class PianoRoll(Frame):
def __init__(self, parent=None):
Frame.__init__(self, parent)
self.parent = parent
self._init_data()
self._init_ui()
def _init_data(self):
self._initial_dir = None
self._filepath = None
self._dirty = False
def _init_ui(self):
menu_cb = {
'new': self._new_cmd,
'open': self._open_cmd,
'save': self._save_cmd,
'save_as': self._save_as_cmd,
'exit': self._exit_cmd
}
toolbar_cb = {
'snap': self.set_snap,
'zoom': {
'zoomx': self.set_zoomx,
'zoomy': self.set_zoomy
},
'tool': self.set_canvas_tool
}
bottombar_cb = {
'length': self.set_canvas_length,
'timesig': self.set_canvas_timesig
}
root = self._root()
menu = PianoRollMenu(root, menu_cb)
root.config(menu=menu)
root.title(make_title("Untitled", self._dirty))
try:
image = PhotoImage(file=ICON_IMG_PATH)
root.tk.call('wm', 'iconphoto', root._w, image)
except TclError:
print "Couldn't load icon file"
self.toolbar = Toolbar(self, toolbar_cb)
self.piano_roll_frame = PianoRollFrame(
self, lambda *args, **kwargs: self.set_dirty(True))
self.bottombar = BottomBar(self, bottombar_cb)
self.toolbar.pack(side=TOP, fill=X)
self.bottombar.pack(side=BOTTOM, fill=X)
self.piano_roll_frame.pack(fill=BOTH, expand=True)
self.pack(fill=BOTH, expand=True)
def _new_cmd(self):
clear_notes = True
if self._dirty:
title = "New Score"
msg = "Save changes before starting a new score?"
answer = askyesnocancel(title, msg)
if answer == None:
return
elif answer:
if self._filepath:
self._save_cmd()
else:
clear_notes = self._save_as_cmd()
self.set_bottombar_length((2, 1, 0))
self.set_bottombar_timesig((4, 4))
if clear_notes:
self.piano_roll_frame.grid_canvas.remove_note('all')
self._filepath = None
self.set_dirty(False)
def _open_cmd(self):
if self._dirty:
title = "New Score"
msg = "Save changes before opening a new score?"
answer = askyesnocancel(title, msg)
if answer == None:
return
elif answer:
if self._filepath:
self._save_cmd()
elif not self._save_as_cmd():
return False
filename = askopenfilename(
parent=self, initialdir=self._initial_dir)
if not filename: return False
self._initial_dir = os.path.dirname(filename)
self._filepath = filename
song_data = load_song(filename)
self.set_bottombar_length(song_data['length'])
self.set_bottombar_timesig(song_data['timesig'])
self.piano_roll_frame.setup(song_data['notes'])
self.set_dirty(False)
def _save_cmd(self):
if not self._filepath:
self._save_as_cmd()
else:
data = self.piano_roll_frame.get_song_state()
save_song(self._filepath, data)
self.set_dirty(False)
def _save_as_cmd(self):
from tkFileDialog import asksaveasfilename
initial_file = os.path.basename(
self._filepath or "Untitled")
filename = asksaveasfilename(
parent=self, initialdir=self._initial_dir,
initialfile=initial_file)
if not filename: return False
self._filepath = filename
self._initial_dir = os.path.dirname(filename)
data = self.piano_roll_frame.get_song_state()
save_song(filename, data)
self.set_dirty(False)
return True
def _exit_cmd(self):
if self._dirty:
title = "New Score"
msg = "Save changes before exiting?"
answer = askyesnocancel(title, msg)
if answer == None:
return
elif answer:
if self._filepath:
self._save_cmd()
elif not self._save_as_cmd():
return False
self.quit()
def set_snap(self, snap_value):
self.piano_roll_frame.set_subdiv(snap_value)
def set_zoomx(self, zoomx):
self.piano_roll_frame.set_zoomx(zoomx)
def set_zoomy(self, zoomy):
self.piano_roll_frame.set_zoomy(zoomy)
def set_canvas_length(self, length):
self.piano_roll_frame.set_length(length)
def set_bottombar_length(self, length):
self.bottombar.set_length(length)
def set_canvas_tool(self, tool):
self.piano_roll_frame.grid_canvas.set_tool(tool)
def set_toolbox_tool(self, value):
self.toolbar.set_tool(value)
def set_canvas_timesig(self, timesig):
self.piano_roll_frame.set_timesig(timesig)
self.bottombar.set_max_beat_count(timesig[0])
def set_bottombar_timesig(self, timesig):
self.bottombar.set_timesig(timesig)
def set_dirty(self, dirty):
self._dirty = dirty
self._root().title(make_title(
os.path.basename(self._filepath or "Untitled"), dirty))
def __init__(self):
gtk.Window.__init__(self)
set_props(self, title='OCFS2 Console',
default_width=600,
default_height=460,
border_width=0)
self.connect('delete_event', self.cleanup)
notebook = gtk.Notebook()
notebook.set_tab_pos(gtk.POS_TOP)
info_frames = []
for desc, info in info_items:
frame = gtk.Frame()
set_props(frame, shadow=gtk.SHADOW_NONE,
border_width=0)
notebook.add_with_properties(frame, 'tab_label', desc)
info_frames.append((frame, info))
self.pv = PartitionView(info_frames)
self.pv.set_size_request(-1, 100)
vbox = gtk.VBox()
self.add(vbox)
menu = Menu(self)
menubar, sel_items, unmounted_items = menu.get_widgets()
vbox.pack_start(menubar, expand=False, fill=False)
self.pv.add_sel_widgets(sel_items)
self.pv.add_unmount_widgets(unmounted_items)
toolbar = Toolbar(self)
tb, buttons, filter_entry = toolbar.get_widgets()
vbox.pack_start(tb, expand=False, fill=False)
self.pv.add_mount_widgets([buttons['unmount']])
self.pv.add_unmount_widgets([buttons['mount']])
filter_entry.connect('activate', self.refresh)
self.pv.set_filter_entry(filter_entry)
vpaned = gtk.VPaned()
vpaned.set_border_width(4)
vbox.pack_start(vpaned, expand=True, fill=True)
scrl_win = gtk.ScrolledWindow()
set_props(scrl_win, hscrollbar_policy=gtk.POLICY_AUTOMATIC,
vscrollbar_policy=gtk.POLICY_AUTOMATIC)
scrl_win.add(self.pv)
vpaned.pack1(scrl_win)
vpaned.pack2(notebook)
self.pv.grab_focus()
self.show_all()
self.refresh()
import tkinter as tk from toolbar import Toolbar from text_write import TextWrite from statusbar import Statusbar from linebar import Linebar from menu import Menu main_application = tk.Tk() toolbar = Toolbar(main_application) linebar = Linebar(main_application) text_write = TextWrite(main_application, toolbar) statusbar = Statusbar(main_application, text_write, linebar) menu = Menu(main_application, text_write, statusbar, toolbar, linebar) main_application.mainloop()
def __init__(self, windowSurface, mainClock, SKY_BLUE, gameData, showFPS):
self.getFiles = File
#Create game data
self.lockedGuns = gameData['lockedGuns']
self.lockedTools = gameData['lockedTools']
self.sound = gameData['sound']
self.runGame = True
self.showFPS = showFPS
#Setup theme music
pygame.mixer.music.load('files//sound//gameTheme.mp3')
#Constants
self.BPS = 8 #(Bullets Per Second)
self.TOTAL_SUPPLIES = 12 #Total Supplies for each powerup
self.SKY_BLUE = SKY_BLUE #Sky color
self.TOTAL_COPS = 32 #Total number of all cops in level
#Variables
self.windowSurface = windowSurface
self.clock = mainClock
#Setup Dr. Taco's Direction
self.moveRight = False
self.moveLeft = False
#Set Start Weapon and tool, and make sure menus are closed.
self.currentWeapon = '9mm'
self.currentTool = 'crowbar'
self.dropDownGun = False
self.dropDownTool = False
#Set Basic Values
self.score = 0
self.ammo = 30
self.hit = False
self.gunButtonCoords = [695, 30, 735, 30, 715, 50]
self.toolButtonCoords = [395, 30, 435, 30, 415, 50]
self.officerX = 1500
self.officerGunX = {'right':abs(self.officerX) + 55, 'left':self.officerX + -3}
self.gunXlist = []
self.takeStep = 0
self.direction = 1
self.goUp = None
self.shootBullet = False
self.message = 'This is the Message Box.'
self.skill_level = 800
self.centered = False
self.drop = False
self.paused = False
self.reload = False
self.endReload = False
self.endBack = False
self.die = False
self.val = None
self.rapidFire = [0, False]
self.lifeLeft = 0
self.endPoint = 0
self.back = False
self.tacosCollected = 0
self.first = True
self.flame = False
#Initialize Objects
self.level_1 = Level_1(self.windowSurface)
self.tools = Toolbar(self.lockedGuns, self.windowSurface)
self.gunMenu = selectGunMenu(self.lockedGuns)
self.toolMenu = selectToolMenu(self.lockedTools)
self.gunArrowButton = Button(self.windowSurface)
self.toolArrowButton = Button(self.windowSurface)
self.DrTaco = Person('Doctor Taco', self.windowSurface, self.officerX, self.officerGunX)
self.wingame = Popups(self.windowSurface)
#Default lists
self.copList = []
self.Xlist = []
self.num = 700
#Add a cop every 250 pixels for the range in TOTAL_COPS
for i in range(0, self.TOTAL_COPS):
self.Xlist.append(self.num)
self.num += 250
self.num = 0
#Add the cop object
self.index = 0
for cop in range(0, self.TOTAL_COPS):
self.copList.append(AI(self.windowSurface, self.skill_level, self.Xlist[self.index]))
self.index += 1
#Add the cops gun
self.index = 0
for i in range(0, self.TOTAL_COPS):
self.gunXlist.append({'right':abs(self.Xlist[self.index]) + 80, 'left':self.Xlist[self.index] + -10})
self.index += 1
#Add Supplies to random locations
self.healthX = []
self.tacosX = []
self.tacosY = []
self.ammoX = []
self.ammoBoxes = []
self.healthBoxes = []
self.tacos = []
for i in range(0, self.TOTAL_SUPPLIES):
self.ammoBoxes.append(Powerups(self.windowSurface, self.score))
self.healthBoxes.append(Powerups(self.windowSurface, self.score))
for i in range(0, 2):
self.tacos.append(Powerups(self.windowSurface, self.score))
self.tacosX.append(random.randint(300, 9000))
self.tacosY.append(random.randint(300, 490))
self.healthX.append(random.randint(300, 9000))
self.ammoX.append(random.randint(300, 9000))
class App:
windowDimY = 14
windowDimX = 18
windowWidth = 0
windowHeight = 0
toolbarWidth = 200
player = 0
apple = 0
toolbar = 0
dataCollect = 0
displayq = False
def __init__(self,dq,state,freq):
self._running = True
self._display_surf = None
self._image_surf = None
self._apple_surf = None
self.game = Game()
self.player = Player(3,self.windowDimX, self.windowDimY)
self.windowWidth = self.windowDimX*self.player.step
self.windowHeight = self.windowDimY*self.player.step
self.toolbar = Toolbar(self.toolbarWidth, self.windowWidth, self.windowHeight)
self.apple = Apple(randint(0,self.windowDimX-1), randint(0,self.windowDimY-1))
self.dataCollect = DataCollector()
self.displayq=dq
self.state_size = state
self.frequency = freq
def on_init(self):
pygame.init()
if(self.displayq):
self._display_surf = pygame.display.set_mode((self.windowWidth+self.toolbarWidth,self.windowHeight), pygame.HWSURFACE)
pygame.display.set_caption('Pygame Snake game!')
self._image_surf = pygame.image.load("images/game_objects/smake.png").convert()
self._apple_surf = pygame.image.load("images/game_objects/smapple.png").convert()
self.toolbar.load_images()
self._running = True
# self.savepath = "frames/"+time.strftime("%Y%m%d-%H%M%S")
# os.mkdir(self.savepath)
def on_event(self, event):
if event.type == QUIT:
self._running = False
def on_loop(self):
self.player.update()
# does snake collide with itself?
for i in range(2,self.player.length):
if self.game.isCollision(self.player.x[0],self.player.y[0],self.player.x[i], self.player.y[i],self.player.step-1):
print("You lose! Collision with yourself: ")
print("x[0] (" + str(self.player.x[0]) + "," + str(self.player.y[0]) + ")")
print("x[" + str(i) + "] (" + str(self.player.x[i]) + "," + str(self.player.y[i]) + ")")
self.player.crashed = True
# does snake eat apple?
for i in range(0,self.player.length):
if self.game.isCollision(self.apple.x,self.apple.y,self.player.x[i], self.player.y[i],self.player.step-1):
self.apple.x = randint(0,self.windowDimX-1) * self.player.step
self.apple.y = randint(0,self.windowDimY-1) * self.player.step
print("apple x=",self.apple.x,"apple y=",self.apple.y)
self.player.eatenApple = True
#does snake collide with wall?
if(self.player.x[0]<0 or self.player.x[0]>=self.windowWidth or self.player.y[0]<0 or self.player.y[0]>=self.windowHeight):
print("You lose! Collision with wall: ")
print("x[0] (" + str(self.player.x[0]) + "," + str(self.player.y[0]) + ")")
self.player.crashed = True
pass
def on_render(self, state):
self._display_surf.fill((0,0,0))
self.player.draw(self._display_surf, self._image_surf)
self.apple.draw(self._display_surf, self._apple_surf)
self.toolbar.draw(self._display_surf, self.player.direction, state)
pygame.display.flip()
def on_cleanup(self):
pygame.quit()
# initializing agent before the 1st move
def init_agent(self, agent):
state_init1 = agent.get_state(game, self.player, self.food) #first state after random placement
#first action
def reset_player(self):
self.player = Player(3,self.windowDimX, self.windowDimY)
#print(self.player.x)
#print(self.player.y)
def on_execute(self,speed):
print('starting execution!')
params = parameters()
agent = dqnagent(params,self.state_size) #initialize the agent!
if(agent.load_weights): #load weights maybe
agent.model.load_weights(agent.weights)
print("loaded the weights")
counter = 0 #how many games have been played/trials done
record = 0 #highest score
#---------------------------------------------------------------------------
#------------------------- LOOP THRU EPISODES ------------------------------
#---------------------------------------------------------------------------
while counter<params['episodes']: #still have more trials to do
counter += 1
print(counter)
print("\nEPISODE ", counter, "\n")
if not params['train']: # if you're not training it, no need for exploration
agent.epsilon = 0
else:
agent.epsilon = 1.0 - ((counter -1) * params['epsilon_decay_linear'])#exploration/randomness factor that decreases over time
#print("EPSILON = ", agent.epsilon, "\n")
if self.on_init() == False:
self._running = False
#print("PLAYER\tx : ", self.player.x,"\ty : ", self.player.y, "\n")
duration = 0
#---------------------------------------------------------------------------
#--------------------------- INDIVIDUAL EPISODE ----------------------------
#---------------------------------------------------------------------------
# indexx = 0
while(self._running):
if(counter%self.frequency==0):
self.dataCollect.record(self.player.x, self.player.y, self.apple.x, self.apple.y)
duration+=1
#print("\nMOVE : ", duration, "\n")
if(self.displayq):
pygame.event.pump()
keys = pygame.key.get_pressed()
if (keys[K_ESCAPE]):
exit(0)
oldstate = agent.get_state(self, self.player, self.apple)
#print("\noldstate = ", oldstate)
#--------------------------- GET AGENT ACTION ----------------------------
if random() < agent.epsilon: #every so often random exploration
action = randint(0,3) #random action
#print("random action : ",action)
else: #Actionprecited by agent
state = oldstate.reshape(1,self.state_size**2+8)
predictedq= agent.model.predict(state) # predicts the q values for the action in that state
action = np.argmax(predictedq[0]) #maximum (highest q) action
#print("predicted action : ", action, "\tq-values : ", predictedq)
#---------------------------- EXECUTE ACTION -----------------------------
print(action)
self.player.do_move(action) #do the action
self.on_loop()
newstate = agent.get_state(self, self.player, self.apple) #new state from the action we've taken
reward = agent.set_reward(self.player)
#print("newstate = ", newstate)
#print("reward = ", reward)
#print("crashed = ", self.player.crashed, "\n")
#---------------------------- SHORT TRAINING -----------------------------
if(params['train']):
agent.train_short_memory(oldstate,action, reward, newstate, self.player.crashed)
agent.remember(oldstate,action, reward, newstate, self.player.crashed)
#------------------------------ RENDER GAME ------------------------------
self._running = not(self.player.crashed)
if(self.displayq):
self.on_render(newstate)
# if(counter%self.frequency==0):
# self.on_render(newstate)
# pygame.image.save(self._display_surf,savepath+str(indexx))
time.sleep (speed/1000.0)
# indexx +=1
#---------------------------------------------------------------------------
#----------------------- TRAINING & DATA COLLECTION ------------------------
#---------------------------------------------------------------------------
if(params['train']):
agent.replay_new(agent.memory, params['batch_size'])
# self.dataCollect.add(self.player.length,duration,agent.epsilon,agent.history.losses)
self.dataCollect.add(self.player.length,duration,agent.epsilon, 0.0)
self.dataCollect.save()
#print(agent.history.losses.length())
#agent.history.losses = []
self.player.reset(3,self.windowDimX, self.windowDimY )
self.on_cleanup()
#---------------------------------------------------------------------------
#------------------------------ DATA OUTPUT --------------------------------
#---------------------------------------------------------------------------
if(params['train']):
os.mkdir(params['weights_path_save'])
agent.model.save_weights(params['weights_path_save']+'/weights.hdf5')
self.dataCollect.save()
def __init__(self, parent = None):
Toolbar.__init__(self, parent)
self.label = 'toolbar'
self.background = ''
def run(states, level):
# Set up the window for this game state
gameWindow = pygame.display.get_surface()
pygame.display.set_caption("Editor: " + level)
# Get the window width and height
rect = gameWindow.get_rect()
SCREEN_WIDTH = rect.width
SCREEN_HEIGHT = rect.height
# Create Pygame clock to regulate frames
clock = pygame.time.Clock()
# Set up sprite groups
sprites = pygame.sprite.Group()
dummies = pygame.sprite.Group()
Dummy.containers = sprites, dummies
player = None
# Load and parse the level text file
leveltext = open(level, "r")
for line in leveltext:
line = line.split()
if len(line) > 0:
if line[0] == "dimensions":
LEVEL_WIDTH, LEVEL_HEIGHT = int(line[1]), int(line[2])
elif line[0] == "player":
if player != None:
player.kill()
player = Dummy(line)
else:
Dummy(line)
# Create the camera
camera = Camera(0, 0, LEVEL_WIDTH, LEVEL_HEIGHT)
# Create the toolbar
toolbar = Toolbar(SCREEN_WIDTH)
# Create the variables for editor tools
clickStart = [0, 0]
justSaved = False
makingPlatform = False
while True:
# Get events on the event queue
for event in pygame.event.get():
if event.type == QUIT:
return states["quit"]
elif event.type == KEYDOWN:
if event.key == K_ESCAPE:
return states["menu"]
elif event.key == K_w:
camera.setSpeedY(camera.getSpeedY() - 5)
elif event.key == K_a:
camera.setSpeedX(camera.getSpeedX() - 5)
elif event.key == K_s:
if pygame.key.get_mods() & KMOD_CTRL:
leveltext = open(level, "w")
# Save level dimensions
leveltext.write("dimensions " + str(LEVEL_WIDTH) + " " + str(LEVEL_HEIGHT) + "\n")
# Add all dummy objects to level data
for dummy in dummies:
leveltext.write(dummy.getDataString())
justSaved = True
print "Level saved as " + level
else:
camera.setSpeedY(camera.getSpeedY() + 5)
elif event.key == K_d:
camera.setSpeedX(camera.getSpeedX() + 5)
elif event.key == K_SPACE:
toolbar.toggle()
elif event.key == K_1:
toolbar.setTool("player")
elif event.key == K_2:
toolbar.setTool("platform")
elif event.key == K_3:
toolbar.setTool("enemy")
elif event.key == K_4:
toolbar.setTool("datboi")
elif event.type == KEYUP:
if event.key == K_w:
camera.setSpeedY(camera.getSpeedY() + 5)
elif event.key == K_a:
camera.setSpeedX(camera.getSpeedX() + 5)
elif event.key == K_s:
if not justSaved:
camera.setSpeedY(camera.getSpeedY() - 5)
else:
justSaved = False
elif event.key == K_d:
camera.setSpeedX(camera.getSpeedX() - 5)
elif event.type == MOUSEBUTTONDOWN:
if event.button == 1:
mouse = pygame.mouse.get_pos()
toolbarButton = toolbar.handleMouse(mouse, event.button)
if toolbarButton == "none":
clickStart = snapToGrid([mouse[0] + camera.getX(), mouse[1] + camera.getY()])
if toolbar.getTool() == "platform":
makingPlatform = True
elif toolbar.getTool() == "enemy":
Dummy(["enemy", str(clickStart[0]), str(clickStart[1])])
elif toolbar.getTool() == "datboi":
Dummy(["datboi", str(clickStart[0]), str(clickStart[1] - 32)])
elif toolbar.getTool() == "player":
# Replace the old player dummy with the new one
if player != None:
player.kill()
player = Dummy(["player", str(clickStart[0]), str(clickStart[1])])
elif toolbarButton == "quit":
return states["menu"]
elif toolbarButton == "save":
leveltext = open(level, "w")
# Save level dimensions
leveltext.write("dimensions " + str(LEVEL_WIDTH) + " " + str(LEVEL_HEIGHT) + "\n")
# Add all dummy objects to level data
for dummy in dummies:
leveltext.write(dummy.getDataString())
print "Level saved as " + level
elif event.button == 3:
mouse = pygame.mouse.get_pos()
for dummy in dummies:
if dummy.rect.left <= camera.getX() + mouse[0] <= dummy.rect.right and dummy.rect.top <= camera.getY() + mouse[1] <= dummy.rect.bottom:
dummy.kill()
break
elif event.type == MOUSEBUTTONUP:
if event.button == 1:
if toolbar.getTool() == "platform" and makingPlatform:
createPlatform(camera, clickStart)
makingPlatform = False
camera.move()
gameWindow.fill((18, 188, 255))
for sprite in sprites:
gameWindow.blit(sprite.image, (sprite.rect.left - camera.getX() + sprite.getOffset()[0], sprite.rect.top - camera.getY() + sprite.getOffset()[1]))
if toolbar.getTool() == "platform" and pygame.mouse.get_pressed()[0] and makingPlatform:
drawPreviewRect(gameWindow, camera, clickStart)
drawGuidelines(gameWindow, camera, SCREEN_WIDTH, SCREEN_HEIGHT)
drawBorderlines(gameWindow, camera, LEVEL_WIDTH, LEVEL_HEIGHT)
toolbar.draw(gameWindow)
clock.tick(60)
pygame.display.flip()
