def __init__(self, inVid): """Create the VideoContainer with the /path/videoFile as string. Args: Param1 (str): Single video file location """ # Create a window and a video player cv2.namedWindow('ContainerOne', cv2.WINDOW_NORMAL) self.player = videoPlayer.StaticVideo(inVid) self.firstFrame = None # Create some Observable instances with respective base classes. self.sliderObservable = Observable(slider) self.videoObservable = Observable(videoPlayer) #Create some sliders self.thresholdFloorSlider = slider.Slider('ThresFloor-Slider', 'ContainerOne', 0, 255 ) self.thresholdMaxSlider = slider.Slider('ThresMax-Slider', 'ContainerOne', 0, 255 ) self.thresholdAdaptSlider = slider.Slider('AdaptiveMax-Slider', 'ContainerOne', 0, 255 ) self.filterViewSlider = slider.Slider('filterView-Slider', 'ContainerOne', 0, 1) self.histogramOne = HistoPyPlot('histoOne','ContainerOne') #Register some observers self.sliderObservable.register(self.player) #I'm registering these with the instance for now. self.videoObservable.register(self.histogramOne)
def add_slider(self, min_value, max_value, length, text): if self.slider_amount == 0: s = slider.Slider(self.sliders_coordinates[0], min_value, max_value, length, text) else: s = slider.Slider(self.__get_slider_coordinates(), min_value, max_value, length, text) self.sliders.append(s) self.width = self.get_width() self.slider_amount += 1
def __init__(self, parent, id, label="", value=128, min_value=0, max_value=255, label_size=(-1, -1), int_ctrl_size=(30, -1)): textslider.TextSlider.__init__(self, parent, id) label_ctrl = wx.StaticText(self, -1, label, size=label_size, style=cfg.SLIDER_LABEL_ALIGN) slider_ctrl = slider.Slider(self, -1, value, min_value, max_value) int_ctrl = intctrl.IntCtrl(parent=self, limited=True, value=value, min=min_value, max=max_value, size=int_ctrl_size, style=wx.TE_RIGHT) self._create(value, label_ctrl, slider_ctrl, int_ctrl)
def __init__( self, parent, id, label="", value=0.0, min_value=-1.0, max_value=1.0, precision=1000.0, round_decimals=5, float_ctrl_size=(45,-1) ): textslider.TextSlider.__init__(self, parent, id) self.precision = precision self.round_decimals = 5 label_ctrl = wx.StaticText(self, -1, label, style=cfg.SLIDER_LABEL_ALIGN) slider_ctrl = slider.Slider( self, -1, self._value_to_slider(value), self._value_to_slider(min_value), self._value_to_slider(max_value) ) float_ctrl = floatctrl.FloatCtrl( parent=self, limited=True, value=self._value_to_text(value), min=self._value_to_text(min_value), max=self._value_to_text(max_value), size=float_ctrl_size, style=wx.TE_RIGHT, round_decimals=round_decimals ) self._create(value, label_ctrl, slider_ctrl, float_ctrl)
def __init__(self, composition, *args, **kwargs): super(CompositionScene, self).__init__(*args, **kwargs) self.DEFAULT_SCENE_HEIGHT = 200 self.DEFAULT_SCENE_WIDTH = 1000 # Setting default CompositionScene geometry 1000x200. self.setSceneRect(0, 0, self.DEFAULT_SCENE_WIDTH, self.DEFAULT_SCENE_HEIGHT) self.timeline_matrix = matrix.Matrix() self.scene_signals = CompositionSceneSignals() self.connect_signals() # Creating header for slider. slider_head_brush = QtGui.QBrush(QtGui.QColor(66, 66, 66, 255)) self.addRect(0, self.sceneRect().height() - slider.SLIDER_HEIGHT, tracks.CELL_WIDTH, slider.SLIDER_HEIGHT, brush=slider_head_brush) self._current_y_pos = slider.SLIDER_HEIGHT self.slider_rect = self.sceneRect() self.slider_rect.setWidth(tracks.CELL_WIDTH) self.slider_rect.setHeight(slider.SLIDER_HEIGHT) self.slider = slider.Slider(self.slider_rect) self.slider.setPos(slider.SLIDER_START, self.sceneRect().height() - slider.SLIDER_HEIGHT) self.slider.setZValue(float('inf')) self.addItem(self.slider) self.playhead = slider.PlayHead(self._current_y_pos) self.playhead.setParentItem(self.slider) self._video_tracks_index = 0 self._audio_tracks_index = 0 self._data_tracks_index = 0 self.track_mapping = { "V": 'video', "A": 'audio', "D": 'data', "Context": 'context' } # self.context_list and self.track_list will remember order of tracks and contexts. self.context_list = [] self.track_list = [] # self.track_dict will store track object againest tack name for future reference. self.track_dict = {} # Adding Context track self.add_track("Context") if composition: self.populate_compsition(composition)
def run(self): g.init() g.journal=self.journal if not self.journal: utils.load(); self.score=g.score; self.level=g.level else: g.score=self.score; g.level=self.level self.buttons_setup() if self.journal: # Sugar only a,b,c,d=pygame.cursors.load_xbm('my_cursor.xbm','my_cursor_mask.xbm') pygame.mouse.set_cursor(a,b,c,d) self.slider=slider.Slider(g.sx(16),g.sy(20.5),9,utils.GREEN) self.grid=ah.Grid() self.grid.new1(); self.grid.setup() going=True while going: # Pump GTK messages. while gtk.events_pending(): gtk.main_iteration() # Pump PyGame messages. for event in pygame.event.get(): if event.type==pygame.QUIT: if not self.journal: utils.save() going=False elif event.type == pygame.MOUSEMOTION: g.redraw=True if self.canvas<>None: self.canvas.grab_focus() elif event.type == pygame.MOUSEBUTTONDOWN: g.redraw=True if event.button==2: # centre button if not self.journal: g.version_display=not g.version_display if event.button==1: if self.grid.click(): pass elif self.slider.mouse(): self.grid.new1(); self.grid.setup(); buttons.clear() # level changed else: bu=buttons.check() if bu!='': self.do_button(bu) else: self.grid.colour_ind=0 elif event.type == pygame.KEYDOWN: self.do_key(event.key); g.redraw=True if not going: break if self.grid.complete(): buttons.clear() if g.redraw: self.display() if g.version_display: utils.version_display() pygame.display.flip() g.redraw=False self.score=g.score; self.level=g.level tf=False if pygame.mouse.get_focused(): tf=True pygame.mouse.set_visible(tf) g.clock.tick(40)
def run(self): g.init() if not self.journal: utils.load() self.oms = [] for n in range(3, 8): omm = om.Om(n) omm.setup() self.oms.append(omm) load_save.retrieve() self.omm = self.oms[g.level - 1] self.buttons_setup() self.slider = slider.Slider(g.sx(10.5), g.sy(20), 5, utils.YELLOW) going = True while going: # Pump GTK messages. while gtk.events_pending(): gtk.main_iteration() # Pump PyGame messages. for event in pygame.event.get(): if event.type == pygame.QUIT: # only in standalone version if not self.journal: utils.save() going = False elif event.type == pygame.MOUSEMOTION: g.pos = event.pos self.omm.mouse_move() g.redraw = True if self.canvas <> None: self.canvas.grab_focus() elif event.type == pygame.MOUSEBUTTONDOWN: g.redraw = True if event.button == 2: # centre button if not self.journal: g.version_display = not g.version_display if event.button == 1: if self.do_click(): pass elif self.slider.mouse(): # level changed self.omm = self.oms[g.level - 1] else: bu = buttons.check() if bu != '': self.do_button(bu) if event.button == 3: # right button self.do_button('try') elif event.type == pygame.KEYDOWN: self.do_key(event.key) g.redraw = True if not going: break if g.redraw: self.display() if not self.journal: # not on XO if g.version_display: utils.version_display() g.screen.blit(g.pointer, g.pos) pygame.display.flip() g.redraw = False g.clock.tick(40)
def run(self): g.init() self.rects=rects.Rects() if not self.journal: utils.load() else: g.level=self.level self.slider=slider.Slider(g.sx(16),g.sy(20.5),10,utils.GREEN) self.new1() bx=g.sx(29.5); by=g.sy(12) buttons.Button("cyan",(bx,by),True) by=g.sy(16) buttons.Button("black",(bx,by),True) if self.journal: # Sugar only a,b,c,d=pygame.cursors.load_xbm('my_cursor.xbm','my_cursor_mask.xbm') pygame.mouse.set_cursor(a,b,c,d) going=True while going: # Pump GTK messages. while gtk.events_pending(): gtk.main_iteration() # Pump PyGame messages. for event in pygame.event.get(): if event.type==pygame.QUIT: if not self.journal: utils.save() going=False elif event.type == pygame.MOUSEMOTION: g.redraw=True elif event.type == pygame.MOUSEBUTTONDOWN: g.redraw=True if event.button==2: # centre button if not self.journal: g.version_display=not g.version_display; break bu=buttons.check() if bu<>'': self.button(bu); break if self.slider.mouse(): self.new1(); break if self.rects.click(): if not g.magic_show: if self.rects.correct(): g.score+=g.level; g.magic_show=True buttons.off("black") if not going: break if g.redraw: self.display() if g.version_display: utils.version_display() pygame.display.flip() g.redraw=False tf=False if pygame.mouse.get_focused(): tf=True pygame.mouse.set_visible(tf) g.clock.tick(40) # be ready for xo quit at any time self.level=g.level
def create(self, scene, pos): super().create(scene, pos) self.slider = slider.Slider(pos + V2(80, 0), 150, self.minimum, self.maximum, self.on_change, value=self.value) self.slider.on("mouse_enter", lambda a, b: self.on_hover) self.slider.on("mouse_exit", lambda a, b: self.on_unhover) scene.ui_group.add(self.slider)
def run(self): g.init() if not self.journal: utils.load(); self.level=g.level else: g.level=self.level x=g.sx(26); y=g.sy(11.2) buttons.Button("new",(x,y)) x=g.sx(4); y=g.sy(10); dx=g.sy(4) buttons.Button("back",(x,y)); x+=dx buttons.Button("plus",(x,y)); x+=dx buttons.Button("times",(x,y)); x+=dx buttons.Button("equals",(x,y)) self.slider=slider.Slider(g.sx(20.5),g.sy(20.5),10,utils.GREEN) if self.journal: # Sugar only a,b,c,d=pygame.cursors.load_xbm('my_cursor.xbm','my_cursor_mask.xbm') pygame.mouse.set_cursor(a,b,c,d) self.level1() # initial animation going=True while going: self.level=g.level # Pump GTK messages. while gtk.events_pending(): gtk.main_iteration() # Pump PyGame messages. for event in pygame.event.get(): if event.type==pygame.QUIT: if not self.journal: utils.save() going=False elif event.type == pygame.MOUSEMOTION: g.redraw=True elif event.type == pygame.MOUSEBUTTONDOWN: g.redraw=True if event.button==2: # centre button if not self.journal: g.version_display=not g.version_display; break bu=buttons.check() if bu=='': if not self.check_numbers(): if self.slider.mouse(): self.level1() else: self.do_button(bu) # eg do_button('plus') if not going: break if g.redraw: self.display() if g.version_display: utils.version_display() pygame.display.flip() g.redraw=False tf=False if pygame.mouse.get_focused(): tf=True pygame.mouse.set_visible(tf) g.clock.tick(40)
def main(): global speed,board,buttons win = pygame.display.set_mode((540, 600)) board = Grid(9, 9, 540, 540, win) pygame.display.set_caption("Sudoku") # creating slider speed = slider.Slider("Speed", 100, 300, 10, (230,545),win) start_button=button.Button(win,"Solve", (100, 570), board.solve_gui ) buttons=[start_button] while True: board.draw() events(speed,board,buttons)
def __init__(self, parent, id, label="", color=(128, 128, 128)): wx.PyControl.__init__(self, parent, id, style=wx.NO_BORDER | wx.TAB_TRAVERSAL) self.color = color # Also used to remember the initial color when using the 'slider all' # to darken/lighten a color. This avoids trunkating a color between # scroll changes and 'forgetting' the initial color hue. self.old_color = color self.staticbox = wx.StaticBox(self, -1, label) self.slider_R = intslider.IntSlider(self, -1, "R:", color[0]) self.slider_G = intslider.IntSlider(self, -1, "G:", color[1]) self.slider_B = intslider.IntSlider(self, -1, "B:", color[2]) average = self.__get_average(self.color) self.slider_all = slider.Slider(self, -1, average, 0, 255) self.color_sel = wx.lib.colourselect.ColourSelect(self, -1) self.__set_properties() self.__do_layout() self.__bind_events()
def __init__(self): SceneBase.__init__(self) self.time = datetime.now() self.bodies = [ gravsim.Body(np.array([0., 0.]), 1.989e30, 6.9551e8, np.array([0.+1e5, 0.])), # Sun gravsim.Body(np.array([1.496e11, 0.]), 5.972e24, 6.371e6, np.array([1e5+0., 2.9786e4])), # Earth gravsim.Body(np.array([1.496e11+3.844e8, 0.]), 7.347e22, 1.7371e6, np.array([1e5+0., 2.9786e4+1.023e3])) # Moon ] self.focus = self.genFocus() self.new_body = None self.trajectory = None self.active = TOOLS[0] self.flags = { 'body_placed':False } self.scale = slider.Slider('Scale', 9., 12., 4., (630, 20)) self.timestep = slider.Slider('Timestep', 4., 4.5, 0., (630, 90)) self.g = slider.Slider('G', -10.1756, -5., -11., (630, 160)) self.minsize = slider.Slider('Min Body Size', 2., 10., 1., (630, 230)) self.newmass = slider.Slider('Body Mass', 24., 31., 1., (630, 300)) self.newradius = slider.Slider('Body Radius', 6., 11., 1., (630, 370)) self.sliders = [ self.scale, self.timestep, self.g, self.minsize, self.newmass, self.newradius ] self.trails = button.Button((620, 480, 100, 50), 'Toggle Trails') self.x = button.Button((730, 480, 100, 50), '') self.reset = button.Button((840, 480, 100, 50), 'Reset All') self.delete = button.Button((620, 540, 100, 50), 'Delete Focus') self.switch = button.Button((730, 540, 100, 50), 'Switch Focus') self.zoom = button.Button((840, 540, 100, 50), 'Zoom Focus') self.buttons = [ self.trails, self.x, self.reset, self.delete, self.switch, self.zoom ]
RED = (255, 0, 0) # Set the height and width of the screen size = [700, 400] screen = pygame.display.set_mode(size) pygame.display.set_caption("T flappy birds") #Loop until the user clicks the close button. done = False clock = pygame.time.Clock() fps = 60 all_sprites = pygame.sprite.Group() #flappy-bird specific #TODO: load in best bird as option slider = slider_module.Slider("Speed", 1, 20, 1, 25) birds = [] savedBirds = [] score = 0 current_generation = 0 pipesOnScreen = [] BackGround = Background('background.png', [0, 0]) if type_of_play == 'best': totalBirds = 1 birds.append(getBestBirdBrain()) elif type_of_play == 'train': totalBirds = 400 # initialize totalBirds for i in range(totalBirds): # create new bird, add to list of birds
def run(self): g.init() if not self.journal: utils.load() load_save.retrieve() self.buttons_setup() self.slider=slider.Slider(g.sx(16),g.sy(20.5),9,utils.GREEN) self.grid=ah.Grid() self.grid.new1(); self.grid.setup() if self.canvas!=None: self.canvas.grab_focus() ctrl=False pygame.key.set_repeat(600,120); key_ms=pygame.time.get_ticks() going=True while going: if self.journal: # Pump GTK messages. while Gtk.events_pending(): Gtk.main_iteration() # Pump PyGame messages. for event in pygame.event.get(): if event.type==pygame.QUIT: if not self.journal: utils.save() going=False elif event.type == pygame.MOUSEMOTION: g.pos=event.pos g.redraw=True if self.canvas!=None: self.canvas.grab_focus() elif event.type == pygame.MOUSEBUTTONDOWN: g.redraw=True if event.button==1: if self.grid.click(): pass elif self.slider.mouse(): self.grid.new1(); self.grid.setup(); buttons.clear() # level changed else: bu=buttons.check() if bu!='': self.do_button(bu) else: self.grid.colour_ind=0 self.flush_queue() elif event.button==3: self.do_button('reset') elif event.type == pygame.KEYDOWN: # throttle keyboard repeat if pygame.time.get_ticks()-key_ms>110: key_ms=pygame.time.get_ticks() if ctrl: if event.key==pygame.K_q: if not self.journal: utils.save() going=False; break else: ctrl=False if event.key in (pygame.K_LCTRL,pygame.K_RCTRL): ctrl=True; break self.do_key(event.key); g.redraw=True self.flush_queue() elif event.type == pygame.KEYUP: ctrl=False if not going: break if self.grid.complete(): buttons.clear() if g.redraw: self.display() if g.version_display: utils.version_display() g.screen.blit(g.pointer,g.pos) pygame.display.flip() g.redraw=False self.score=g.score; self.level=g.level g.clock.tick(40)
def __init__(self, parent=None): super(VideoPlayer, self).__init__(parent) self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface) btnSize = QSize(16, 16) videoWidget = QVideoWidget() openButton = QPushButton("Open Video") openButton.setToolTip("Open Video File") openButton.setStatusTip("Open Video File") openButton.setFixedHeight(24) openButton.setIconSize(btnSize) openButton.setFont(QFont("Noto Sans", 8)) openButton.setIcon( QIcon.fromTheme("document-open", QIcon("D:/_Qt/img/open.png"))) openButton.clicked.connect(self.abrir) speedButton = QPushButton("speedVideo") speedButton.setToolTip("Open Video File") speedButton.setStatusTip("Open Video File") speedButton.setFixedHeight(24) speedButton.setIconSize(btnSize) speedButton.setFont(QFont("Noto Sans", 8)) speedButton.setIcon( QIcon.fromTheme("document-open", QIcon("D:/_Qt/img/open.png"))) speedButton.clicked.connect(self.speed) self.playButton = QPushButton() self.playButton.setEnabled(False) self.playButton.setFixedHeight(24) self.playButton.setIconSize(btnSize) self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay)) self.playButton.clicked.connect(self.play) self.positionSlider = slider.Slider(QtCore.Qt.Horizontal) self.positionSlider.setRange(0, 0) self.positionSlider.sliderMoved.connect(self.setPosition) self.positionSlider.sliderPressed.connect(self.setPosition) self.positionSlider.sliderReleased.connect(self.setPosition) self.statusBar = QStatusBar() self.statusBar.setFont(QFont("Noto Sans", 7)) self.statusBar.setFixedHeight(14) controlLayout = QHBoxLayout() controlLayout.setContentsMargins(0, 0, 0, 0) controlLayout.addWidget(openButton) controlLayout.addWidget(speedButton) controlLayout.addWidget(self.playButton) controlLayout.addWidget(self.positionSlider) layout = QVBoxLayout() layout.addWidget(videoWidget) layout.addLayout(controlLayout) layout.addWidget(self.statusBar) self.setLayout(layout) self.mediaPlayer.setVideoOutput(videoWidget) self.mediaPlayer.stateChanged.connect(self.mediaStateChanged) self.mediaPlayer.positionChanged.connect(self.positionChanged) self.mediaPlayer.durationChanged.connect(self.durationChanged) self.mediaPlayer.error.connect(self.handleError) self.statusBar.showMessage("Ready")
def __init__(self, game, path_xml): ''' @brief Constructor. @param game Referencia a game @param path_xml Ruta del archivo xml con la configuración ''' basicmenu.BasicMenu.__init__(self, game) #Cambiamos el título de la ventana pygame.display.set_caption("Zycars: Opciones") parse = xml.dom.minidom.parse(data.get_path_xml(path_xml)) #Obtenemos los elementos básicos del menú self.parser_basic_info(parse) #Declaramos distintos atributos de la clase self.text_layers = {} self.elements_layers = {} self.buttons_layers = {} self.images_layers = {} self.actual_layer = None #Recorremos las distintas capas que tendrá el menú for element in parse.getElementsByTagName('layer'): #Obtenemos el nombre de la capa que la indetificará name_layer = str(element.getAttribute('name')) self.text_layers[name_layer] = [] self.elements_layers[name_layer] = [] self.buttons_layers[name_layer] = [] self.images_layers[name_layer] = {} #Fuente que se usará y tamaño de esta font_code = str(element.getAttribute('font_code')) size = int(element.getAttribute('size')) font_temp = resource.get_font(font_code, size) #Obtenemos los distintos texto que aparecerán por capa for text in element.getElementsByTagName('text'): #Obtenemos texto y posición value = text.getAttribute('value') posx = int(text.getAttribute('x')) posy = int(text.getAttribute('y')) #Renderizamos text_render = font_temp.render(value, True, (0, 0, 0)) text_render_rect = text_render.get_rect() text_render_rect.x = posx text_render_rect.y = posy #Insertamos en la lista de textos por capa self.text_layers[name_layer].append( (text_render, text_render_rect)) #Obtenemos los distintos objetos que tendrán cada capa #En primer lugar obtenemos los slider for slider_option in element.getElementsByTagName('slider'): #Obtenemos archivo de configuración xml_path = str(slider_option.getAttribute('xml_file')) #Posición x = int(slider_option.getAttribute('x')) y = int(slider_option.getAttribute('y')) text = str(slider_option.getAttribute('text')) value = 0 if text == 'sonido': value = int(config.Config().get_sound_volume() * 100) else: value = int(config.Config().get_music_volume() * 100) #Obtenemos el slider new_slider = slider.Slider(xml_path, value, 100, x, y, text) #Lo introducimos en la lista de sliders self.elements_layers[name_layer].append(new_slider) for check_box in element.getElementsByTagName('checkbox'): xml_file = str(check_box.getAttribute('xml_file')) font_code = str(check_box.getAttribute('font')) show_text = False text = check_box.getAttribute('text') image_code = str(check_box.getAttribute('image_code')) image_x = int(check_box.getAttribute('image_x')) image_y = int(check_box.getAttribute('image_y')) x = int(check_box.getAttribute('x')) y = int(check_box.getAttribute('y')) new_checkbox = checkbox.CheckBox(self, xml_file, text, x, y, font_code, image_code, image_x, image_y, show_text) self.elements_layers[name_layer].append(new_checkbox) for button_layer in element.getElementsByTagName('button'): #Ruta del archivo xml con la configuración xml_file = str(button_layer.getAttribute('xml_file')) #Fuente y texto que apareceran en el boton font_code = str(button_layer.getAttribute('font')) text = button_layer.getAttribute('text') x = int(button_layer.getAttribute('x')) y = int(button_layer.getAttribute('y')) show_text = True #Miramos si se indica si se debe mostrar o no el texto #en el botón if button_layer.hasAttribute('show_text'): show_text = button_layer.getAttribute('show_text') show_text = button.strTobool(show_text) aux_button = button.Button(self, xml_file, text, x, y, font_code, show_text) #Lo añadimos a la lista de botones self.buttons_layers[name_layer].append(aux_button) for image in element.getElementsByTagName('image_layer'): image_code = image.getAttribute('image_code') x = int(image.getAttribute('x')) y = int(image.getAttribute('y')) self.images_layers[name_layer][image_code] = \ (resource.get_image(image_code), x, y) for chb in self.elements_layers['Pantalla']: if config.Config().get_fullscreen(): chb.set_checked() #La capa inicial será la de sonido self.actual_layer = "Sonido" self.direction = config.Config().get_direction() self.pause = 'p' if config.Config().get_pause_key() == \ pygame.K_p else 'esc' self.item = 'space' if config.Config().get_item_key() == \ pygame.K_SPACE else 'enter'
def run(self): g.init() if not self.journal: utils.load() self.tr = [None, None, None, None] self.menu = menu.Menu(4, 4, g.sy(.2), g.sy(1.3), g.sy(.2)) load_save.retrieve() self.buttons_setup() self.slider = [None, None] self.slider[0] = slider.Slider(g.sx(16), g.sy(20.8), 2, utils.GREEN) self.slider[1] = slider.Slider(g.sx(16), g.sy(20.8), 3, utils.GREEN) self.levels = [1] * 16 if self.canvas <> None: self.canvas.grab_focus() ctrl = False pygame.key.set_repeat(600, 120) key_ms = pygame.time.get_ticks() going = True while going: if self.journal: # Pump GTK messages. while gtk.events_pending(): gtk.main_iteration() # Pump PyGame messages. for event in pygame.event.get(): if event.type == pygame.QUIT: if not self.journal: utils.save() going = False elif event.type == pygame.MOUSEMOTION: g.pos = event.pos g.redraw = True if self.canvas <> None: self.canvas.grab_focus() elif event.type == pygame.MOUSEBUTTONDOWN: g.redraw = True if event.button == 1: if self.do_click(): pass else: if g.state == 'jigsaw': bu = buttons.check() if bu != '': self.do_button(bu) self.flush_queue() elif event.type == pygame.KEYDOWN: # throttle keyboard repeat if pygame.time.get_ticks() - key_ms > 110: key_ms = pygame.time.get_ticks() if ctrl: if event.key == pygame.K_q: if not self.journal: utils.save() going = False break else: ctrl = False if event.key in (pygame.K_LCTRL, pygame.K_RCTRL): ctrl = True break self.do_key(event.key) g.redraw = True self.flush_queue() elif event.type == pygame.KEYUP: ctrl = False if not going: break if g.redraw: self.display() if g.version_display: utils.version_display() g.screen.blit(g.pointer, g.pos) pygame.display.flip() g.redraw = False g.clock.tick(40)
def createSlider(self, x, y, height, width, minimum, maximum): slider.Slider(self, x, y, height, width, minimum, maximum)
def run(self, restore=False): self.g_init() if not self.journal: utils.load() load_save.retrieve() self.aim = simon.Simon(1200) # arg is glow time if self.sugar: self.set_delay(800) else: self.set_delay() self.player = simon.Simon(200) if restore: self.restore_pattern() self.aim.started = True if self.sugar: self.green_button.set_sensitive(True) self.back_button.set_sensitive(False) else: bx = g.sx(22.42) by = g.sy(20.8) buttons.Button('green', (bx, by), True) buttons.Button('back', (bx, by), True) buttons.off('back') self.slider = slider.Slider(g.sx(9), g.sy(20.8), 3, utils.BLUE) self.rc = rc_skip_last.RC(3, 5) if self.canvas is not None: self.canvas.grab_focus() ctrl = False pygame.key.set_repeat(600, 120) key_ms = pygame.time.get_ticks() going = True while going: if self.journal: # Pump GTK messages. while Gtk.events_pending(): Gtk.main_iteration() # Pump PyGame messages. for event in pygame.event.get(): if event.type == pygame.QUIT: if not self.journal: utils.save() going = False elif event.type == pygame.MOUSEMOTION: g.pos = event.pos g.redraw = True if self.canvas is not None: self.canvas.grab_focus() self.mouse_set() elif event.type == pygame.MOUSEBUTTONDOWN: g.redraw = True if event.button == 1: self.do_click() self.flush_queue() elif event.type == pygame.KEYDOWN: # throttle keyboard repeat if pygame.time.get_ticks() - key_ms > 110: key_ms = pygame.time.get_ticks() if ctrl: if event.key == pygame.K_q: if not self.journal: utils.save() going = False break else: ctrl = False if event.key in (pygame.K_LCTRL, pygame.K_RCTRL): ctrl = True break self.do_key(event.key) g.redraw = True self.flush_queue() elif event.type == pygame.KEYUP: ctrl = False if not going: break if self.sugar: if g.player_n == 0 and not self.green_button.get_sensitive(): self.back_button.set_sensitive(True) else: if g.player_n == 0 and not buttons.active('green'): buttons.on('back') self.player.do() self.aim.do() if g.redraw: self.display() if g.version_display: utils.version_display() if self.aim.running or self.aim.glow_active: pass else: g.screen.blit(g.pointer, g.pos) pygame.display.flip() g.redraw = False g.clock.tick(40)
def run(self): g.init() if not self.journal: utils.load() self.jigsaw = jigsaw.Jigsaw() self.menu = menu.Menu(3, 4, g.sy(1), g.sy(1.5), g.sy(.32)) load_save.retrieve() self.buttons_setup() self.slider = slider.Slider(g.sx(16), g.sy(20.5), len(jigsaw.rc), utils.GREEN) if self.canvas <> None: self.canvas.grab_focus() ctrl = False pygame.key.set_repeat(600, 120) key_ms = pygame.time.get_ticks() going = True while going: if self.journal: # Pump GTK messages. while gtk.events_pending(): gtk.main_iteration() # Pump PyGame messages. for event in pygame.event.get(): if event.type == pygame.QUIT: # only in standalone version if not self.journal: utils.save() going = False elif event.type == pygame.MOUSEMOTION: g.pos = event.pos if g.state == 2: self.menu.check_mouse() if g.state == 3: self.jigsaw.check_mouse() g.redraw = True if self.canvas <> None: self.canvas.grab_focus() elif event.type == pygame.MOUSEBUTTONDOWN: g.redraw = True if event.button == 1: bu = buttons.check() if bu != '': self.do_button(bu) else: self.do_click() if event.button == 3: self.jigsaw.moving = not self.jigsaw.moving self.flush_queue() elif event.type == pygame.KEYDOWN: # throttle keyboard repeat if pygame.time.get_ticks() - key_ms > 110: key_ms = pygame.time.get_ticks() if ctrl: if event.key == pygame.K_q: if not self.journal: utils.save() going = False break else: ctrl = False if event.key in (pygame.K_LCTRL, pygame.K_RCTRL): ctrl = True break self.do_key(event.key) g.redraw = True self.flush_queue() elif event.type == pygame.KEYUP: ctrl = False if not going: break if g.state == 3: self.jigsaw.update() if g.redraw: self.display() if g.version_display: utils.version_display() if g.state == 3: g.screen.blit(g.negative, g.pos) else: g.screen.blit(g.pointer, g.pos) pygame.display.flip() g.redraw = False g.clock.tick(40)
def slider_setup(self): self.slider = slider.Slider(g.sx(16), g.sy(20.5), g.best, utils.GREEN)
def edit_existing_body(self, body): #If a body is already being edited, switch to editing the new body instead if self.editing_body: self.finish_editing_body() if self.infolabels: self.remove_planet_info_labels() self.editing_body = True self.mouse_objects_stack.append( slider.Slider("Radius", body.radius, 1, 1 * 10**10, body.radius.var, Vec(10, 160), 200, 10, 10, interpolation_type=1)) self.mouse_objects_stack.append( slider.Slider("Mass", body.mass, 1, 1 * 10**36, body.mass.var, Vec(10, 240), 200, 10, 10, interpolation_type=1)) self.mouse_objects_stack.append( slider.Slider("Red", body.colour[0], 0, 255, body.colour[0].var, Vec(10, 320), 200, 10, 10)) self.mouse_objects_stack.append( slider.Slider("Green", body.colour[1], 0, 255, body.colour[1].var, Vec(10, 400), 200, 10, 10)) self.mouse_objects_stack.append( slider.Slider("Blue", body.colour[2], 0, 255, body.colour[2].var, Vec(10, 480), 200, 10, 10)) self.mouse_objects_stack.append( button.Button( "Delete", Vec(10, 560), 100, 30, lambda body=body: self.delete_body_during_editing(body), self.renderer.font_medium)) self.mouse_objects_stack.append( button.Button("Done", Vec(130, 560), 100, 30, self.finish_editing_body, self.renderer.font_medium)) self.infolabels.append( infolabel.InfoLabel("Velocity (m/s)", body.vel_magnitude, Vec(640, 50))) self.infolabels.append( infolabel.InfoLabel("Accel (m/s^2)", body.accel_magnitude, Vec(640, 100)))
def add_gui(self): #Quick function to format the time in the speed multiplier def format_time(x): if x > 31557600: return str(round(x / 31557600, 3)) + " years/s" if x > 2592000: return str(round(x / 2592000, 3)) + " months/s" if x > 604800: return str(round(x / 604800, 3)) + " weeks/s" if x > 86400: return str(round(x / 86400, 3)) + " days/s" if x > 3600: return str(round(x / 3600, 3)) + " hours/s" if x > 60: return str(round(x / 60, 3)) + " minutes/s" return str(round(x, 3)) + " seconds/s" # Add the GUI objects self.mouse_objects_stack.append( slider.Slider("Speed multiplier", self.dt, 1, 50000000, self.dt.var, Vec(410, 10), 200, 10, 10, var_formatter=format_time, interpolation_type=1)) self.scale = scale.Scale(Vec(630, 10), 150, 10, 1 / (self.camera.zoom)) self.mouse_objects_stack.append( dropdownmenu.DropDownMenu("File", Vec(0, 0), 100, 30)) self.mouse_objects_stack[-1].add_button("Save", self.save_bodies, self.renderer.font_medium, self.mouse_objects_stack) self.mouse_objects_stack[-2].add_button("Load", self.load_bodies, self.renderer.font_medium, self.mouse_objects_stack) self.mouse_objects_stack[-3].add_button("Random", self.generate_solar_system, self.renderer.font_medium, self.mouse_objects_stack) self.mouse_objects_stack.append( dropdownmenu.DropDownMenu("Options", Vec(297, 0), 100, 30)) self.mouse_objects_stack[-1].add_button( "Tracers", lambda: self.change_flags(flags_file.RENDER_TRACERS), self.renderer.font_medium, self.mouse_objects_stack) self.mouse_objects_stack[-2].add_button( "Labels", lambda: self.change_flags(flags_file.RENDER_PLANET_LABELS), self.renderer.font_medium, self.mouse_objects_stack) self.mouse_objects_stack[-3].add_button( "Shadows", lambda: self.change_flags(flags_file.SHADOWS), self.renderer.font_medium, self.mouse_objects_stack) self.mouse_objects_stack[-4].add_button( "Unrealistic", lambda: self.change_flags(flags_file.REALISTIC), self.renderer.font_medium, self.mouse_objects_stack, toggled_name="Realistic") self.mouse_objects_stack[-5].add_button( "Pause", lambda: self.change_flags(flags_file.PAUSED), self.renderer.font_medium, self.mouse_objects_stack, toggled_name="Unpause") self.mouse_objects_stack[-6].add_button( "Fullscreen", lambda: self.renderer.toggle_fullscreen(self), self.renderer.font_medium, self.mouse_objects_stack) self.mouse_objects_stack[-7].add_button("Quit", pygame.quit, self.renderer.font_medium, self.mouse_objects_stack) self.mouse_objects_stack.append( button.Button("Add body", Vec(99, 0), 100, 30, self.start_creating_new_body, self.renderer.font_medium)) self.mouse_objects_stack.append( dropdownmenu.DropDownMenu("Bodies", Vec(198, 0), 100, 30)) self.mouse_objects_stack[-1].add_button( "None", lambda: [ self.camera.stop_tracking(), self.finish_editing_body(), self.remove_planet_info_labels() ], self.renderer.font_medium, self.mouse_objects_stack) for body in self.bodies: self.mouse_objects_stack[-1].add_button( body.name, lambda body=body: [self.camera.track_body(body), self.edit_existing_body(body)], self.renderer.font_medium, self.mouse_objects_stack)
def start_creating_new_body(self): #Make sure a body is not already being created if self.body_being_created != None: return self.remove_planet_info_labels() self.finish_editing_body() self.camera.stop_tracking() #Initialise a default body self.body_being_created = body.Body("", 1 * 10**6, 1 * 10**20, Vec(0, 0), Vec(0, 0), (100, 100, 100)) #Add the 'Body Placer' self.mouse_objects_stack.append( bodyplacer.BodyPlacer(self.body_being_created.pos, self.body_being_created.vel, self.camera)) #Add the GUI elements self.mouse_objects_stack.append( slider.Slider("Radius", self.body_being_created.radius, 1, 1 * 10**10, self.body_being_created.radius.var, Vec(10, 160), 200, 10, 10, interpolation_type=1)) self.mouse_objects_stack.append( slider.Slider("Mass", self.body_being_created.mass, 1, 1 * 10**36, self.body_being_created.mass.var, Vec(10, 240), 200, 10, 10, interpolation_type=1)) self.mouse_objects_stack.append( slider.Slider("Red", self.body_being_created.colour[0], 0, 255, self.body_being_created.colour[0].var, Vec(10, 320), 200, 10, 10)) self.mouse_objects_stack.append( slider.Slider("Green", self.body_being_created.colour[1], 0, 255, self.body_being_created.colour[1].var, Vec(10, 400), 200, 10, 10)) self.mouse_objects_stack.append( slider.Slider("Blue", self.body_being_created.colour[2], 0, 255, self.body_being_created.colour[2].var, Vec(10, 480), 200, 10, 10)) self.mouse_objects_stack.append( button.Button("Done", Vec(10, 560), 100, 30, self.add_new_body, self.renderer.font_medium)) self.mouse_objects_stack.append( button.Button("Cancel", Vec(130, 560), 100, 30, self.cancel_creating_new_body, self.renderer.font_medium))
def run(self, restore=False): self.black = False for event in pygame.event.get(): if event.type == pygame.QUIT: return elif event.type == pygame.VIDEORESIZE: pygame.display.set_mode(event.size, pygame.RESIZABLE) break g.init() if not self.journal: utils.load() load_save.retrieve() x = g.sx(26) y = g.sy(11.2) if not self.sugar: buttons.Button("new", (x, y)) x, y = g.cxy2 dx = g.sy(4) self.back_button = buttons.Button("back", (x, y)) x += dx buttons.Button("plus", (x, y)) x += dx buttons.Button("times", (x, y)) x += dx buttons.Button("equals", (x, y)) self.ops = ['back', 'plus', 'times', 'equals'] if not self.sugar: self.slider = slider.Slider(g.sx(22.4), g.sy(20.5), 10, utils.GREEN) self.mouse_auto = True self.anim_ms = None self.level1() # initial animation self.scored = False if restore: g.score = self.save_score ctrl = False pygame.key.set_repeat(600, 120) key_ms = pygame.time.get_ticks() going = True if self.canvas is not None: self.canvas.grab_focus() while going: if self.journal: # Pump GTK messages. while Gtk.events_pending(): Gtk.main_iteration() # Pump PyGame messages. for event in pygame.event.get(): if event.type == pygame.QUIT: if not self.journal: utils.save() going = False elif event.type == pygame.MOUSEMOTION: g.pos = event.pos g.redraw = True if self.canvas is not None: self.canvas.grab_focus() elif event.type == pygame.MOUSEBUTTONDOWN: g.redraw = True self.anim_end() if event.button == 1: bu = buttons.check() if bu == '': if not self.check_numbers(): if not self.sugar: if self.slider.mouse(): self.level1() else: self.do_button(bu) # eg do_button('plus') self.flush_queue() elif event.type == pygame.KEYDOWN: self.anim_end() # throttle keyboard repeat if pygame.time.get_ticks() - key_ms > 110: key_ms = pygame.time.get_ticks() if ctrl: if event.key == pygame.K_q: if not self.journal: utils.save() going = False break else: ctrl = False if event.key in (pygame.K_LCTRL, pygame.K_RCTRL): ctrl = True break self.do_key(event.key) g.redraw = True self.flush_queue() elif event.type == pygame.KEYUP: ctrl = False if not going: break self.animation() if g.redraw: self.display() if g.version_display: utils.version_display() if not self.black: g.screen.blit(g.pointer, g.pos) pygame.display.flip() g.redraw = False g.clock.tick(40)
def run(self, restore=False): for event in pygame.event.get(): if event.type==pygame.QUIT: return elif event.type == pygame.VIDEORESIZE: pygame.display.set_mode(event.size, pygame.RESIZABLE) break self.g_init() if not self.journal: utils.load() load_save.retrieve() if restore: self.restore_pattern() else: g.delay = (3 - g.level) * 400 self.tu = my_turtle.TurtleClass() self.tu.current = [1, 1, 1, 3, 2] self.get_goal() if g.pattern == 1: self.tu.current = utils.copy_list(g.goals[0]) self.tu.setup(self.colors[0]) g.numbers = utils.copy_list(self.tu.current) # buttons x = g.sx(7.3) y = g.sy(16.5) dx = g.sy(2.6) if not self.sugar: buttons.Button("cyan", (x, y), True) x += dx buttons.off('cyan') buttons.Button("green", (x, y), True) x += dx buttons.Button("red", (x, y), True) x += dx buttons.Button("black", (x, y), True) x += dx self.slider = slider.Slider(g.sx(23.5), g.sy(21), 3, utils.YELLOW) self.mouse_1st_no() # to 1st number if self.canvas is not None: self.canvas.grab_focus() ctrl = False pygame.key.set_repeat(600, 120) key_ms = pygame.time.get_ticks() going = True while going: if self.journal: # Pump Gtk messages. while Gtk.events_pending(): Gtk.main_iteration() # Pump PyGame messages. for event in pygame.event.get(): if event.type == pygame.QUIT: if not self.journal: utils.save() going = False elif event.type == pygame.MOUSEMOTION: g.pos = event.pos g.redraw = True if self.canvas is not None: self.canvas.grab_focus() elif event.type == pygame.MOUSEBUTTONDOWN: g.redraw = True if g.big: g.big = False else: bu = buttons.check() if bu != '': self.do_button(bu) self.flush_queue() elif not self.sugar: if utils.mouse_on_img1(g.magician, g.magician_c): self.help2() elif utils.mouse_in(g.x1, g.y0, g.x1 + g.bw, g.y0 + g.bw): self.big_pic() elif self.slider.mouse(): g.delay = (3 - g.level) * 400 else: g.show_help = False self.check_nos(event.button) else: g.show_help = False self.check_nos(event.button) elif event.type == pygame.KEYDOWN: # throttle keyboard repeat if pygame.time.get_ticks() - key_ms > 110: key_ms = pygame.time.get_ticks() if ctrl: if event.key == pygame.K_q: if not self.journal: utils.save() going = False break else: ctrl = False if event.key in (pygame.K_LCTRL, pygame.K_RCTRL): ctrl = True break self.do_key(event.key) g.redraw = True self.flush_queue() elif event.type == pygame.KEYUP: ctrl = False if not going: break if self.tu.running: self.tu.move() if not g.crash_drawn: g.crash_drawn = True g.redraw = True if g.redraw: self.display() if g.version_display: utils.version_display() g.screen.blit(g.pointer, g.pos) pygame.display.flip() g.redraw = False g.clock.tick(40)
def __run(self): """ Wird aufgerufen, wenn der Längsschnitt angeklickt wird. """ self.__log.info(u"Längsschnitt-Tool gestartet!") def init_application(): """ Initialisiert den Längsschnitt und liest die gewählten Layer aus. Prüft außerdem auf Kompatibilität und Anzahl der Layer. Bricht ggf. die Funktion ab, wenn der Datensatz fehlerhaft ist. :return: Gibt eine Liste der selektierten Layer zurück und einen LayerType :rtype: (list,LayerType) """ if self.__animator is not None: self.__log.info("Animator bereits vorhanden!") self.__animator.pause() if self.__speed_controller is not None: self.__log.info("Speed-Controller bereits vorhanden!") self.__speed_controller.reset() if self.__ganglinie is not None: self.__dlg2.close() self.__log.info("Ganglinie wurde geschlossen.") self.__dlg.close() selected_layers = self.__iface.legendInterface().selectedLayers() if len(selected_layers) == 0: self.__log.critical(u"Es wurde kein Layer ausgewählt!") self.__iface.messageBar().pushCritical( "Fehler", u"Wählen Sie zunächst ein Layer!") return False layer_types = [] for layer in selected_layers: layer_types.append(self.__layer_to_type(layer)) layer_types = list(set(layer_types)) if len(layer_types) != 1: for _l in layer_types: if _l not in [ LayerType.Haltung, LayerType.Wehr, LayerType.Pumpe ]: self.__log.critical( u"Gewählte Layer sind inkompatibel zueinander!") self.__iface.messageBar().pushCritical( "Fehler", "Inkompatible Layer-Kombination!") return False _layer_type = LayerType.Haltung else: _layer_type = layer_types[0] if _layer_type in [LayerType.Wehr, LayerType.Pumpe]: _layer_type = LayerType.Haltung if _layer_type not in [LayerType.Haltung, LayerType.Schacht]: self.__log.critical( u"Ausgewählter Layer wird nicht unterstützt.") self.__iface.messageBar().pushCritical( "Fehler", u"Ausgewählter Layer wird nicht unterstützt!") return False self.__log.info(u"Layer wurde ausgewählt") self.__log.debug(u"Gewählter Layer ist {}".format( "Schacht" if _layer_type == LayerType.Schacht else "Haltung")) while self.__result_db == "": stop = self.__show_message_box( "Ergebnis-Datenbank", "Bitte wählen Sie eine Ergebnis-Datenbank aus!", Type.Selection) if stop: self.__log.info( "Ergebnis-Datenbank-Auswahl wurde abgebrochen.") return False self.__result_db = QFileDialog.getOpenFileName( self.__dlg, u"Wählen Sie eine Simulations-Datenbank", self.__workspace, filter="IDBF (*.idbf);; Alle Dateien (*.*)") self.__dlg.label_dbname.setText(self.__result_db) self.__log.info(u"Ergebnis-Datenbank wurde ausgewählt") self.__log.debug(u"Ergebnis-Datenbank liegt in {}".format( self.__result_db)) self.__log.info("Navigator wurde initiiert.") return selected_layers, _layer_type initialized = init_application() if initialized: self.__log.info(u"Längsschnitt wurde erfolgreich initiiert!") layers, layer_type = initialized else: self.__log.warning( u"Initiierung abgebrochen. Längsschnitt-Tool wird beendet.") return speed_controller_initialized = self.__speed_controller is None layout = QGridLayout() if speed_controller_initialized: self.__speed_controller = s.Slider() self.__speed_controller.setMaximumWidth(500) self.__speed_controller.setMinimumWidth(300) layout.addWidget(self.__speed_controller, 0, 0, 1, 1, Qt.AlignRight) self.__speed_label = QLabel("Geschwindigkeit: 0x") self.__speed_label.setStyleSheet( "QLabel {color:qlineargradient(x1:0, y1:0, x2:0, y2:1, stop:0 #050DFF, stop:1 #757AFF);}" ) self.__speed_controller.setToolTip( "Links: Geschwindigkeit einstellen\nRechts: Pause/Start\nStrg+Rechts: Geschwindigkeit umkehren" ) layout.addWidget(self.__speed_label, 1, 0, 1, 1, Qt.AlignCenter) self.__dlg.widget.setLayout(layout) self.__log.info( "Speed-Controller wurde erfolgreich initiiert und in den Dialog eingebettet." ) feature_count = 0 for l in layers: feature_count += l.selectedFeatureCount() self.__log.debug( "Es wurden {} Elemente selektiert.".format(feature_count)) if feature_count < 2 and layer_type == LayerType.Schacht: self.__log.critical( "Es wurde eine unzureichende Menge an Elementen selektiert!") self.__iface.messageBar().pushCritical( "Fehler", u"Bitte wählen Sie mindestens einen Start- und" u" Endpunkt Ihrer gewünschten Route!") return elif feature_count < 1: self.__log.critical("Es wurde kein Element selektiert!") self.__iface.messageBar().pushCritical( "Fehler", u"Bitte wählen Sie mindestens einen Start- und Endpunkt" u" Ihrer gewünschten Route!") return # run application features = [] for l in layers: features += [f[1] for f in l.selectedFeatures()] features = list(set(features)) self.__log.debug(u"{} wurde ausgewählt.".format(features)) self.__iface.messageBar().pushMessage("Navigation", "Route wird berechnet...", self.__iface.messageBar().INFO, 60) navigator = MyNavigator(self.__spatialite) if layer_type == LayerType.Haltung: route = navigator.calculate_route_haltung(features) else: route = navigator.calculate_route_schacht(features) self.__iface.messageBar().clearWidgets() if route: self.__log.info(u"Navigation wurde erfolgreich durchgeführt!") valid_db = self.__check_resultDB(route) if not valid_db: self.__log.critical( u"Die übergebene Ergebnisdatenbank ist nicht vollständig.") self.__iface.messageBar().pushCritical( "Fehler", u"Unvollständige oder fehlerhafte Ergebnisdatenbank übergeben!" ) self.__select_db() return self.__log.debug("Route:\t{}".format(route)) else: error_msg = navigator.get_error_msg() self.__log.critical( u"Es trat ein Fehler in der Navigation auf:\t\"{}\"".format( error_msg)) self.__iface.messageBar().pushCritical("Fehler", error_msg) return laengsschnitt = plotter.Laengsschnitt(copy.deepcopy(route)) plotter.set_ax_labels("m", "m") widget, _toolbar = laengsschnitt.get_widget() for i in reversed(range(self.__dlg.verticalLayout.count())): self.__dlg.verticalLayout.itemAt(i).widget().setParent(None) self.__dlg.verticalLayout.addWidget(_toolbar) self.__dlg.stackedWidget.insertWidget(0, widget) self.__dlg.stackedWidget.setCurrentIndex(0) self.__log.info("Toolbar wurde eingebettet.") # init methods self.__dlg.checkbox_maximum.setChecked(True) self.__animator = None self.__animator = plotter.Animator(copy.deepcopy(route), self.__result_db, self.__dlg.slider, self.__dlg.btn_forward, self.__dlg.btn_backward, self.__dlg.label_timestamp) self.__ganglinie.refresh(haltungen=route.get("haltungen"), schaechte=route.get("schaechte"), dbname=self.__result_db, laengsschnitt=laengsschnitt) self.__ganglinie.draw_at( self.__animator.get_timestamps()[self.__animator.get_last_index()]) self.__maximizer = None self.__maximizer = plotter.Maximizer(copy.deepcopy(route), self.__result_db) self.__switch_max_values(2) self.__animator.set_ganglinie(self.__ganglinie) self.__dlg2.auto_update.hide() self.__log.info("Auto-Update-Checkbox wurde versteckt") self.__speed_controller.valueChanged.connect(self.__speed_control) self.__dlg.slider.valueChanged.connect(self.__animator.go_step) self.__dlg.slider.setToolTip( "Links: Zeitpunkt einstellen\nRechts: Pause/Start\nStrg+Rechts: Geschwindigkeit umkehren" ) if self.__default_function is None: self.__default_function = self.__dlg.slider.mousePressEvent self.__log.info("MousePressEvent des Sliders wurde gespeichert") self.__dlg.slider.mousePressEvent = lambda event: self.__slider_click( event) plotter.set_legend() self.__dlg.show() self.__log.info("Dialog wird angezeigt") # Längsschnitt starten self.__speed_controller.setValue(5) self.__animator.play(5, SliderMode.Forward) self.__speed_controller.set_paused() # Run the dialog event loop result = self.__dlg.exec_() # See if OK was pressed if result: # neustart # Do something useful here - delete the line containing pass and # substitute with your code. pass # else: # beenden self.__animator.pause() self.__speed_controller.reset() self.__log.info(u"Längsschnitt wurde geschlossen!")
def run(self): g.init() if not self.journal: utils.load() self.sim=sim.Sim() load_save.retrieve() self.buttons_setup() if g.saved_n==0: buttons.off('cyan') self.slider=slider.Slider(g.sx(23.4),g.sy(20.2),5,utils.GREEN) if self.canvas<>None: self.canvas.grab_focus() ctrl=False pygame.key.set_repeat(600,120); key_ms=pygame.time.get_ticks() going=True while going: if self.journal: # Pump GTK messages. while gtk.events_pending(): gtk.main_iteration() # Pump PyGame messages. for event in pygame.event.get(): if event.type==pygame.QUIT: if not self.journal: utils.save() going=False elif event.type == pygame.MOUSEMOTION: g.pos=event.pos g.redraw=True if self.canvas<>None: self.canvas.grab_focus() elif event.type == pygame.MOUSEBUTTONDOWN: g.redraw=True if g.help_on: g.help_on=False elif event.button==1: if self.do_click(): pass elif self.slider.mouse(): pass # level changed else: bu=buttons.check() if bu!='': self.do_button(bu); self.flush_queue() elif event.button==3: self.right_click() elif event.type == pygame.KEYDOWN: # throttle keyboard repeat if pygame.time.get_ticks()-key_ms>110: key_ms=pygame.time.get_ticks() if ctrl: if event.key==pygame.K_q: if not self.journal: utils.save() going=False; break else: ctrl=False if event.key in (pygame.K_LCTRL,pygame.K_RCTRL): ctrl=True; break self.do_key(event.key); g.redraw=True self.flush_queue() elif event.type == pygame.KEYUP: ctrl=False if not going: break self.update() if g.redraw: self.display() if g.version_display: utils.version_display() g.screen.blit(g.pointer,g.pos) pygame.display.flip() g.redraw=False g.clock.tick(40)