Return the next scene to be displayed.
490653
function nextScene() {
  switch (currentScene) {
    case scene1: return (currentScene = scene2);
    case scene2: return (currentScene = scene1);
    default: return (currentScene = scene1);
  }
}
733843
def get_next(self, label):
        """"""
        while self._get_current_label() != label:
            self._skip_section()
        return self._read_section()
882290
def gotoNext( self ):
        
        scene = self.scene()
        date  = scene.currentDate()
        
        # go forward a day
        if ( scene.currentMode() == scene.Mode.Day ):
            scene.setCurrentDate(date.addDays(1))
        
        # go forward a week
        elif ( scene.currentMode() == scene.Mode.Week ):
            scene.setCurrentDate(date.addDays(7))
        
        # go forward a month
        elif ( scene.currentMode() == scene.Mode.Month ):
            scene.setCurrentDate(date.addMonths(1))
164082
def get_next_page(self):
        """"""

        master_node = self._retrieve_next_page()

        seq = []
        for node in master_node.getElementsByTagName("album"):
            seq.append(
                Album(
                    _extract(node, "artist"),
                    _extract(node, "name"),
                    self.network,
                    info={"image": _extract_all(node, "image")},
                )
            )

        return seq
1304522
def next(self):
        """"""
        item = six.next(self._item_iter)
        result = self._item_to_value(self._parent, item)
        # Since we've successfully got the next value from the
        # iterator, we update the number of remaining.
        self._remaining -= 1
        return result
1209943
def next(self):
        """"""
        # pylint: disable=protected-access
        with self._pcontext._queuelock:
            # Check that the pool still deals with this loop.
            # pylint: disable=protected-access
            pool_loop_reached = max(self._pcontext._thread_loop_ids)
            if pool_loop_reached > self._loop_id or self._queue.empty():
                raise StopIteration()
            else:
                return self._queue.get()
268039
def next(self):
        """"""
        if self._current_index < len(self._collection):
            value = self._collection[self._current_index]
            self._current_index += 1
            return value
        elif self._next_cursor:
            self.__fetch_next()
            return self.next()
        else:
            self._current_index = 0
            raise StopIteration
1311491
def nextPlot(self):
        """"""
        if self.stacker.currentIndex() < self.stacker.count():
            self.stacker.setCurrentIndex(self.stacker.currentIndex()+1)
1266531
def next(self):
    "  "

    char = self.char
    if char == '\n':
      self.lineno += 1
      self.colno = 0
    else:
      self.colno += 1
    self.index += 1
    return self.char
974752
def next(self):
        """"""
        if not self.selected:
            self.cluster_view.next()
        else:
            self.similarity_view.next()
667297
def next(self):
        """"""
        batch = mx.nd.zeros((self.batch_size, self.size[1], self.size[0], 3))
        i = self.cur
        for i in range(self.cur, min(len(self.list), self.cur+self.batch_size)):
            str_img = open(self.root+self.list[i]+'.jpg').read()
            img = imdecode(str_img, 1)
            img, _ = random_crop(img, self.size)
            batch[i - self.cur] = img
        batch = mx.nd.transpose(batch, axes=(0, 3, 1, 2))
        ret = mx.io.DataBatch(data=[batch],
                              label=[],
                              pad=self.batch_size-(i-self.cur),
                              index=None)
        self.cur = i
        return ret
1247155
def _get_next_obj(self, length):
        """"""
        data = b''
        while len(data) < length:
            data += self.sock.recv(length - len(data))

        return pickle.loads(data)
199886
def fetch_next_page(self):
        """"""
        result = self.request_handler.get(url=self.next_page_url).json()
        self.__init__(self.request_handler, result,
                      self.data_type, self.automatic_pagination)
99456
def next(self):
        ""

        if not self._index_stack:
            return False

        index = self._index_stack[-1]

        if self._last_index != self._dic.ROOT:

            child_label = self._guide.child(index)  # UCharType

            if child_label:
                # Follows a transition to the first child.
                index = self._follow(child_label, index)
                if index is None:
                    return False
            else:
                while True:
                    sibling_label = self._guide.sibling(index)
                    # Moves to the previous node.
                    if len(self.key) > 0:
                        self.key.pop()
                        #self.key[-1] = 0

                    self._index_stack.pop()
                    if not self._index_stack:
                        return False

                    index = self._index_stack[-1]
                    if sibling_label:
                        # Follows a transition to the next sibling.
                        index = self._follow(sibling_label, index)
                        if index is None:
                            return False
                        break

        return self._find_terminal(index)
220892
def next(self):
        
        if self._cur_item is not None:
            res = self._cur_item
            self._cur_item = None
            return res
        
        return next(self._ex_context)
476775
def next(self):
        
        x, y = next(self.scan)
        xr = -x if self.rx else x
        yr = -y if self.ry else y
        return xr, yr
413688
def visit_continue(self, node, parent):
        """"""
        return nodes.Continue(
            getattr(node, "lineno", None), getattr(node, "col_offset", None), parent
        )