Beispiel #1
0
    def __init__(self, **kwargs):
        super(MainView, self).__init__(**kwargs)

        data_items = []
        data_items.append(DataItem())
        data_items.append(DataItem())
        data_items.append(DataItem())

        list_item_args_converter = lambda row_index, obj: {'text': obj.name,
                                                           'size_hint_y': None,
                                                           'height': 25}

        self.list_adapter = \
                ListAdapter(data=data_items,
                            args_converter=list_item_args_converter,
                            selection_mode='single',
                            propagate_selection_to_data=False,
                            allow_empty_selection=False,
                            cls=ListItemButton)

        self.list_view = ListView(adapter=self.list_adapter)

        self.add_widget(self.list_view)

        self.toggle = 'adding'

        Clock.schedule_interval(self.update_list_data, 1)
Beispiel #2
0
	def move_topdown(self, top, from_keyboard=False):
		r = range(self.dim - 1, -1, -1) if top else range(self.dim)
		grid = self.grid
		moved = False

		for ix in range(self.dim):
			# get all the cube for the current line
			cubes = []
			for iy in r:
				cube = grid[ix][iy]
				if cube:
					cubes.append(cube)

			# combine them
			self.combine(cubes)

			# update the grid
			for iy in r:
				cube = cubes.pop(0) if cubes else None
				if grid[ix][iy] != cube:
					moved = True
				grid[ix][iy] = cube
				if not cube:
					continue
				pos = self.index_to_pos(ix, iy)
				if cube.pos != pos:
					cube.move_to(pos)

		if from_keyboard:
			return moved
		elif not self.check_end() and moved:
			Clock.schedule_once(self.spawn_number, .20)
Beispiel #3
0
    def anim_reset(self, allow_anim):
        '''Reset an animation if available.

        .. versionadded:: 1.0.8

        :Parameters:
            `allow_anim`: bool
                Indicate whether the animation should restart playing or not.

        Usage::

            # start/reset animation
            image.anim_reset(True)

            # or stop the animation
            image.anim_reset(False)

        You can change the animation speed whilst it is playing::

            # Set to 20 FPS
            image.anim_delay = 1 / 20.

        '''
        # stop animation
        Clock.unschedule(self._anim)
        if allow_anim and self._anim_available:
            Clock.schedule_interval(self._anim, self.anim_delay)
            self._anim()
Beispiel #4
0
	def build(self):
		self.service = None
		self.start_service()
		global RootApp
		RootApp = self

		# NavigationDrawer
		self.navigationdrawer = NavDrawer()

		# SidePanel
		side_panel = SidePanel()
		self.navigationdrawer.add_widget(side_panel)

		# MainPanel
		self.main_panel = MainPanel()

		# color picker
		self.color_selector = ColorSelector()

		# size selector
		self.size_selector = SizeSelector()

		self.navigationdrawer.anim_type = 'slide_above_simple'
		self.navigationdrawer.add_widget(self.main_panel)

		osc.init()
		oscid = osc.listen(port=3002)
		osc.bind(oscid, self.reCallback, '/date')
		Clock.schedule_interval(lambda *x: osc.readQueue(oscid), 0)

		return self.navigationdrawer
Beispiel #5
0
    def __init__(self, **kwargs):
        # Make sure opengl context exists
        EventLoop.ensure_window()

        self.canvas = RenderContext(use_parent_projection=True,
                                    use_parent_modelview=True)

        with self.canvas:
            self.fbo = Fbo(size=self.size)

        with self.fbo.before:
            PushMatrix()
        with self.fbo:
            ClearColor(0, 0, 0, 0)
            ClearBuffers()
            self._background_color = Color(*self.background_color)
            self.fbo_rectangle = Rectangle(size=self.size)
        with self.fbo.after:
            PopMatrix()

        super(EffectWidget, self).__init__(**kwargs)

        Clock.schedule_interval(self._update_glsl, 0)

        self.bind(size=self.refresh_fbo_setup,
                  effects=self.refresh_fbo_setup,
                  background_color=self._refresh_background_color)

        self.refresh_fbo_setup()
        self._refresh_background_color()  # In case thi was changed in kwargs
Beispiel #6
0
    def setupView(self):
        # Check gromacs version
        self.checkGromacVersion()

        #Check if folder is exits
        call('mkdir '+self.dataController.getdata('path '), shell=True)
        call('mkdir '+self.dataController.getdata('path ')+'/run', shell=True)
        call('mkdir '+self.dataController.getdata('path ')+'/output', shell=True)
        call('mkdir '+self.dataController.getdata('path ')+'/output/receptor', shell=True)
        call('mkdir '+self.dataController.getdata('path ')+'/output/ligand', shell=True)
        call('mkdir '+self.dataController.getdata('path ')+'/analyse', shell=True)
        
        runfolders = check_output('ls '+self.dataController.getdata('path ')+'/run/', shell = True).splitlines()
        if len(runfolders) > 0:
            popup = RemoveDialog()
            popup.open()
        else:
            call('rm -r '+self.dataController.getdata('path ')+'/run/*', shell=True)
            call('rm -r '+self.dataController.getdata('path ')+'/output/ligand/*', shell=True)
            call('rm -r '+self.dataController.getdata('path ')+'/output/receptor/*', shell=True)
            self.thread = Process(target= self.gromacsRun.main)
            self.thread.start()

        #Check log
        repeat_times = int(self.dataController.getdata('repeat_times '))
        self.progressUnit = 1000/(4.5 + repeat_times)/len(Variable.parsepdb.Ligands)
        self.progressPoint = 0
        self.dataController.setdata('status', '')
        Clock.schedule_interval(self.check_log, 5)
        Clock.schedule_interval(self.spin_progress, 0.05)
        # Clock.schedule_interval(self.pymol_log, 300)

        #close pymol
        self.pymol.cmd.window('hide')
Beispiel #7
0
    def on_touch_down(self, touch):
        if self._touch:
            return super(ScrollView, self).on_touch_down(touch)
        if not self.collide_point(*touch.pos):
            return
        # support scrolling !
        if self._viewport and 'button' in touch.profile and \
                touch.button.startswith('scroll'):
            # distance available to move, if no distance, do nothing
            vp = self._viewport
            if vp.height > self.height:
                # let's say we want to move over 40 pixels each scroll
                d = (vp.height - self.height)
                d = self.scroll_distance / float(d)
                if touch.button == 'scrollup':
                    syd = self.scroll_y - d
                elif touch.button == 'scrolldown':
                    syd = self.scroll_y + d
                self.scroll_y = min(max(syd, 0), 1)
                return True

        self._touch = touch
        uid = self._get_uid()
        touch.grab(self)
        touch.ud[uid] = {
            'mode': 'unknown',
            'sx': self.scroll_x,
            'sy': self.scroll_y,
            'dt': None,
            'time': touch.time_start}
        Clock.schedule_once(self._change_touch_mode, self.scroll_timeout/1000.)
        return True
Beispiel #8
0
    def __init__(self, **kwargs):
        kwargs.setdefault('filename', None)
        kwargs.setdefault('eos', 'stop')
        kwargs.setdefault('async', True)
        kwargs.setdefault('autoplay', False)

        super(VideoBase, self).__init__()

        self._wantplay = False
        self._buffer = None
        self._filename = None
        self._texture = None
        self._volume = 1.
        self._state = ''

        self._autoplay = kwargs.get('autoplay')
        self._async = kwargs.get('async')
        self.eos = kwargs.get('eos')
        if self.eos == 'pause':
            Logger.warning("'pause' is deprecated. Use 'stop' instead.")
            self.eos = 'stop'
        self.filename = kwargs.get('filename')

        Clock.schedule_interval(self._update, 1 / 30.)

        if self._autoplay:
            self.play()
Beispiel #9
0
 def __init__(self, **kwargs):
     super(TheCatWidget, self).__init__(**kwargs)
     Clock.schedule_interval(self.Update, 1.0 / 60.0)
     
     self._StateMachine = statemachine.StateMachine(self)
     self._StateMachine.SetState(statemachine.StateCatWander())
     self._CatPettingCounter = 0
Beispiel #10
0
    def __init__(self, **kwargs):
        super(Graph, self).__init__(**kwargs)

        self._mesh = Mesh(mode='lines')
        self._mesh_rect = Mesh(mode='line_strip')
        val = 0.25
        self.canvas.add(Color(1 * val, 1 * val, 1 * val))
        self.canvas.add(self._mesh)
        self.canvas.add(Color(1, 1, 1))
        self.canvas.add(self._mesh_rect)
        mesh = self._mesh_rect
        mesh.vertices = [0] * (5 * 4)
        mesh.indices = [k for k in xrange(5)]

        self._plot_area = StencilView()
        self.add_widget(self._plot_area)

        self._trigger = Clock.create_trigger(self._redraw_all)
        self._trigger_size = Clock.create_trigger(self._redraw_size)

        self.bind(center=self._trigger_size, padding=self._trigger_size,
                  font_size=self._trigger_size, plots=self._trigger_size,
                  x_grid=self._trigger_size, y_grid=self._trigger_size,
                  draw_border=self._trigger_size)
        self.bind(xmin=self._trigger, xmax=self._trigger,
                  xlog=self._trigger, x_ticks_major=self._trigger,
                  x_ticks_minor=self._trigger,
                  xlabel=self._trigger, x_grid_label=self._trigger,
                  ymin=self._trigger, ymax=self._trigger,
                  ylog=self._trigger, y_ticks_major=self._trigger,
                  y_ticks_minor=self._trigger,
                  ylabel=self._trigger, y_grid_label=self._trigger)
        self._trigger()
Beispiel #11
0
    def render_boggle_game_screen(self):
        logging.info("Rendering game screen.")

        self.clear_widgets()

        def handle_swipe_callback(self):
            # TODO: add in swipes or keyboard for user to input words.
            pass

        self.solve_boggle.set_board(self.num_columns, self.num_rows, None)
        logging.info("Solve Boggle created.")
        self.render_boggle_layout("", handle_swipe_callback, self.grid)
        logging.info("About to loop through buttons.")
        for i, button in enumerate(self.buttons):
            if i not in self.ignore:
                button.text = "[size=%s]%s[/size]" % (int(self.font), self.solve_boggle.boggle.boggle_array[i].upper())
            else:
                button.text = ""

        timer = Label(text="%s" % self.game_time, size_hint=(1, 1.0/self.num_rows), font_size=self.font)

        def timer_callback(dt):
            timer.text = str(int(timer.text) -1)
            if int(timer.text) == 0:
                self.render_boggle_solution_screen()

        Clock.schedule_interval(timer_callback, 1)

        self.add_widget(self.grid)
        self.add_widget(timer)

        # TODO: make this part of a function for a timer callback so it doesn't take time away from displaying the screen.
        self.words = self.solve_boggle.solve(ignore_indexes=self.ignore)
        logging.info("Got words.")
Beispiel #12
0
 def _on_click(self, sid):
     if sid == 'msgbox':
         XMessage(text='It could be your Ad', title='XMessage demo')
     elif sid == 'error':
         XError(text='Don`t panic! Its just the XError demo.')
     elif sid == 'confirm':
         XConfirmation(text='Do you see a confirmation?',
                       on_dismiss=self._callback)
     elif sid == 'progress':
         self._o_popup = XProgress(title='PopupProgress demo',
                                   text='Processing...', max=200)
         Clock.schedule_once(self._progress_test, .1)
     elif sid == 'input':
         XTextInput(title='Edit text', text='I\'m a text',
                    on_dismiss=self._callback)
     elif sid == 'notes':
         XNotes(title='Edit notes', on_dismiss=self._callback_notes,
                lines=['Text', 'Too many text...', 'Yet another row.'])
     elif sid == 'slider':
         self._o_popup = XSlider(
             min=.4, max=.9, value=.5, size_hint=(.6, .5),
             title_template='Slider test, Value: %0.2f',
             buttons=['Horizontal', 'Vertical', 'Close'],
             on_change=self._slider_value, on_dismiss=self._slider_click)
     elif sid == 'login':
         XAuthorization(
             on_dismiss=self._callback, login='login',
             required_fields={'login': 'Login', 'password': 'Password'},
             password='password')
Beispiel #13
0
 def build(self):
   """Initializes the user interface and starts timed events."""
   #TODO: Reorganize and consolidate; make necessary helper functions
   self.title = 'Open Lighting Architecture'
   self.ui_queue = Queue()
   self.layout = BoxLayout(orientation='vertical')
   self.selected_universe_service = UniverseSelectedService()
   self.ola_listener = OLAListener(self.ui_queue,
                                   self.create_select_server,
                                   self.create_ola_client,
                                   self.start_ola,
                                   self.stop_ola)
   #Screen creation and layout placing
   self.screen_tabs = ScreenTabs()
   self.monitor_screen = MonitorScreen(self.ola_listener,
                                       self.selected_universe_service,
                                       name='DMX Monitor')
   self.console_screen = ConsoleScreen(self.ola_listener,
                                       self.selected_universe_service,
                                       name='DMX Console')
   self.devsets = MainScreen(self.ola_listener,
                             self.selected_universe_service,
                             name='Device Settings')
   self.screen_tabs.ids.monitor_screen.add_widget(self.monitor_screen)
   self.screen_tabs.ids.console_screen.add_widget(self.console_screen)
   self.screen_tabs.ids.settings_screen.add_widget(self.devsets)
   self.layout.add_widget(self.screen_tabs)
   Clock.schedule_interval(lambda dt: self.display_tasks(),
                           self.EVENT_POLL_INTERVAL)
   Clock.schedule_interval(self._update_clock, 1 / 60.)
   return self.layout
Beispiel #14
0
    def add_term_widget(self, cfg):
        layout = TermBoxLayout()

        ti = TabbedPanelHeader()
        ti.text = ' '.join([str(len(self.root_widget.term_panel.tab_list) + 1), 'Terminal'])
        ti.content = layout
        ti.size_hint = (1,1)

        self.root_widget.term_panel.add_widget(ti)

        session = create_session(cfg, self.create_terminal(cfg))

        term_widget = TermTextInput(session)
        term_widget.size_hint = (1, 1)
        term_widget.pos_hint = {'center_y':.5, 'center_x':.5}

        layout.add_widget(term_widget)
        layout.term_widget = term_widget

        ti.term_widget = term_widget
        ti.session = session

        ti.session.term_widget = term_widget
        ti.session.terminal.term_widget = term_widget

        Clock.unschedule(self.root_widget.term_panel._load_default_tab_content)
        self.switch_to_tab(ti)

        conn_str = cfg.get_conn_str()

        if conn_str in self.conn_history:
            self.conn_history.remove(conn_str)

        self.conn_history.insert(0, conn_str)
 def on_leave(self):
     Clock.unschedule(self.update)
     self.player1.score = 0
     self.player2.score = 0
     for c in self.pongfloat.children:
         if isinstance(c, WinLabel):
             self.pongfloat.remove_widget(c)
Beispiel #16
0
 def __init__(self, **kwargs):
     super(KYRScreenManager, self).__init__(**kwargs)
     self.loadAssets()
     self.room1 = KYRScreen(name='room1',
                            bg = 'assets/art/room1.png',
                            music = self.overworld,
                            startLocations = dict(top = (512, 96),
                                                  bottom = (512, 416),
                                                  left = (928, 256),
                                                  right = (96, 256)
                             )) # inverse directions, based on direction you enter from
     self.room2 = KYRScreen(name='room2',
                            bg = 'assets/art/room2.png',
                            startLocations = dict(top = (512, 96),
                                                  bottom = (512, 416),
                                                  left = (928, 256),
                                                  right = (96, 256)
                             ))
     
     #self.add_widget(room1)
     #self.add_widget(room2)
     self.buildLocationEvent()
     self.transition=WipeTransition()
     
     self.switch_to(self.room1)
     self.room1.isCurrent = True    
     
     Clock.schedule_interval(self.updatePlayerLocation, 0.5)
Beispiel #17
0
 def delete_clock(self, touch, *args):
     # TODO: Fix touch_up passing through when popup dismissed.
     try:
         Clock.unschedule(touch.ud['event'])
     except KeyError:
         Logger.exception(
             'Application: Touch up passed through and unscheduled clock event could not be unscheduled. A bug...')
Beispiel #18
0
    def build(self):

        self.settings_cls = SettingsWithSidebar

        game = PlanetGame(do_rotation=False,do_translation=False)
        # Settings come in as unicode!
        sunmass = float(App.get_running_app().config.get('planetapp','defaultsunmass'))
        game.sunmass = sunmass
        game.gravity = float(App.get_running_app().config.get('planetapp','gravity'))
        game.planetmass = float(App.get_running_app().config.get('planetapp','planetmass'))
        game.resetmass = float(App.get_running_app().config.get('planetapp','resetmass'))

        game.add_planet(True, (100,100), (0,0), sunmass, 10, (1,1,1))
        
        Clock.schedule_interval(game.update, 1.0 / 120.0)

        self.root = PlanetGameLayout()
        self.root.add_widget(game)
        

        b = Button(text="Reset",size_hint=(.3,.05),pos_hint={'x':.7,'y':0})
        b.bind(on_press=self.root.clear_planets)
        self.root.add_widget(b)
        b2 = SettingsButton(text="Settings",size_hint=(.3,.05),pos_hint={'x':.4,'y':0})
        self.root.add_widget(b2)

        b3 = Button(text="Next",size_hint=(.3,.05),pos_hint={'x':.1,'y':0})
        b3.bind(on_press=self.root.next_trajectory)
        self.root.add_widget(b3)
        self.root.reset_game()
Beispiel #19
0
 def __init__(self, **kwargs):
     self.slides = []
     super(Slides, self).__init__(**kwargs)
     Window.bind(on_keyboard=self.on_keyboard)
     Clock.schedule_interval(self.increase_time, 1 / 30.0)
     Clock.schedule_once(self.init, 0)
     self.add_widget(SlidesForeground(slides=self))
Beispiel #20
0
    def __init__(self, **kwargs):
        # initialize variables
        self._clipboard = Clipboard
        self.info_bubble = None
        self.qrscanner = None
        self.nfcscanner = None
        self.tabs = None
        self.is_exit = False

        super(ElectrumWindow, self).__init__(**kwargs)

        title = _('Electrum App')
        self.electrum_config = config = kwargs.get('config', None)
        self.language = config.get('language', 'en')
        self.network = network = kwargs.get('network', None)
        self.plugins = kwargs.get('plugins', [])

        self.gui_object = kwargs.get('gui_object', None)

        #self.config = self.gui_object.config
        self.contacts = Contacts(self.electrum_config)
        self.invoices = InvoiceStore(self.electrum_config)

        # create triggers so as to minimize updation a max of 2 times a sec
        self._trigger_update_wallet =\
            Clock.create_trigger(self.update_wallet, .5)
        self._trigger_update_status =\
            Clock.create_trigger(self.update_status, .5)
        self._trigger_notify_transactions = \
            Clock.create_trigger(self.notify_transactions, 5)
Beispiel #21
0
    def _setup_default_tab(self):
        if self._default_tab in self.tab_list:
            return
        content = self._default_tab.content
        _tabs = self._tab_strip
        cls = self.default_tab_cls

        if not issubclass(cls, TabbedPanelHeader):
            raise TabbedPanelException('`default_tab_class` should be\
                subclassed from `TabbedPanelHeader`')

        # no need to instanciate if class is TabbedPanelHeader
        if cls != TabbedPanelHeader:
            self._current_tab = self._original_tab = self._default_tab = cls()

        default_tab = self.default_tab
        if self._original_tab == self.default_tab:
            default_tab.text = self.default_tab_text

        default_tab.height = self.tab_height
        default_tab.group = '__tab%r__' % _tabs.uid
        default_tab.state = 'down'
        default_tab.width = self.tab_width if self.tab_width else 100
        default_tab.content = content

        tl = self.tab_list
        if default_tab not in tl:
            _tabs.add_widget(default_tab, len(tl))

        if default_tab.content:
            self.clear_widgets()
            self.add_widget(self.default_tab.content)
        else:
            Clock.schedule_once(self._load_default_tab_content)
        self._current_tab = default_tab
Beispiel #22
0
 def _sign_tx(self, tx, password, on_success, on_failure):
     try:
         self.wallet.sign_transaction(tx, password)
     except InvalidPassword:
         Clock.schedule_once(lambda dt: on_failure(_("Invalid PIN")))
         return
     Clock.schedule_once(lambda dt: on_success(tx))
Beispiel #23
0
    def move_leftright(self, right):
        r = range(3, -1, -1) if right else range(4)
        grid = self.grid
        moved = False

        for iy in range(4):
            # get all the cube for the current line
            cubes = []
            for ix in r:
                cube = grid[ix][iy]
                if cube:
                    cubes.append(cube)

            # combine them
            self.combine(cubes)

            # update the grid
            for ix in r:
                cube = cubes.pop(0) if cubes else None
                if grid[ix][iy] != cube:
                    moved = True
                grid[ix][iy] = cube
                if not cube:
                    continue
                pos = self.index_to_pos(ix, iy)
                if cube.pos != pos:
                    cube.move_to(pos)

        if not self.check_end() and moved:
            Clock.schedule_once(self.spawn_number, tempo)
Beispiel #24
0
 def __init__(self, **kwargs):
     self.register_event_type('on_subprocess_done')
     super(KivyConsole, self).__init__(**kwargs)
     # initialisations
     self.txtinput_command_line_refocus = False
     self.txtinput_run_command_refocus = False
     self.win = None
     self.scheduled = False
     self.command_history = []
     self.command_history_pos = 0
     self.command_status = 'closed'
     if sys.version_info >= (3, 0):
         self.cur_dir = os.getcwd()
     else:
         self.cur_dir = os.getcwdu()
     self.stdout = std_in_out(self, 'stdout')
     self.stdin = std_in_out(self, 'stdin')
     # self.stderror = stderror(self)
     # delayed initialisation
     Clock.schedule_once(self._initialize)
     self_change_txtcache = self._change_txtcache
     _trig = Clock.create_trigger(self_change_txtcache)
     self.bind(textcache=_trig)
     self._hostname = 'unknown'
     try:
         if hasattr(os, 'uname'):
             self._hostname = os.uname()[1]
         else:
             self._hostname = os.environ.get('COMPUTERNAME', 'unknown')
     except Exception:
         pass
     self._username = os.environ.get('USER', '')
     if not self._username:
         self._username = os.environ.get('USERNAME', 'unknown')
Beispiel #25
0
 def __init__(self, cache_dir='cache', **kwargs):
     from kivy.base import EventLoop
     EventLoop.ensure_window()
     CACHE['directory'] = cache_dir
     self._invalid_scale = True
     self._tiles = []
     self._tiles_bg = []
     self._tilemap = {}
     self._layers = []
     self._default_marker_layer = None
     self._need_redraw_all = False
     self._transform_lock = False
     self.trigger_update(True)
     self.canvas = Canvas()
     self._scatter = MapViewScatter()
     self.add_widget(self._scatter)
     with self._scatter.canvas:
         self.canvas_map = Canvas()
         self.canvas_layers = Canvas()
     with self.canvas:
         self.canvas_layers_out = Canvas()
     self._scale_target_anim = False
     self._scale_target = 1.
     self._touch_count = 0
     Clock.schedule_interval(self._animate_color, 1 / 60.)
     self.lat = kwargs.get("lat", self.lat)
     self.lon = kwargs.get("lon", self.lon)
     super(MapView, self).__init__(**kwargs)
Beispiel #26
0
    def on_enter(self):
        anim = Animation(
            opacity=1.0, duration=2.0)

#        anim &= Animation(size=[self.menu_text.size[0]+4, self.menu_text[1]+4], duration=.2)
        anim.start(self.story_text1)
        Clock.schedule_once(self.show_text2, 2.0)
Beispiel #27
0
def send_osc_go_on_signal(*args):
    osc_address = osc_go_address

    #send the gate on signal (ie the rising edge of the gate signal)
    send_osc_message(osc_address, [1.0])
    #queue up the gate off signal (ie the falling edge)
    Clock.schedule_once(send_osc_go_off_signal, _osc_go_delay)
Beispiel #28
0
 def __init__(self):
     android.accelerometer_enable(True)
     Clock.schedule_interval(self.detect_motion, 0.1)
     self.last = None
     self.history = deque()
     self.shake_callback = None
     self.enabled = True
Beispiel #29
0
 def my_screen(self):
     self.ws = WeatherScreen()
     self._image_path = os.path.join(graphics_dir, "na.png")
     self.ws.change_image(self._image_path, self._image_path)
     self._weather_updater()
     Clock.schedule_interval(self._weather_updater, 300)
     return self.ws
Beispiel #30
0
	def next(self,*largs):
		
		Clock.unschedule(self.next)
		
		if(self.screenManager.current == 'page1'):
			next = 'page2'
			page = self.page2
		else:
			next = 'page1'
			page = self.page1
			
		self.index += 1
		if self.index == len(self.photos):
			self.index = 0
		page.source = self.photos[self.index]
		page.background.scale = 1.0		
		self.screenManager.transition = self.transitions[random.randint(0, len(self.transitions) -1)]
		self.screenManager.current = next
		
		anim = Animation(
			scale=page.background.scale*1.3, 
			duration=15.0
		)
		
		Clock.schedule_once(self.next, 10)
		
		anim.start(page.background)