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)
