gloss-mc/ui_elements/label_queue.py

import clutter
import pango
import pygtk
import gtk
import math
from utils.InputQueue import InputQueue

class LabelQueue(clutter.Group):
    DIRECTION_UP, DIRECTION_DOWN = range(2)
    ORIENTATION_TOP, ORIENTATION_BOTTOM = range(2)
    
    fps = 70
    frames = 50

    #Default values
    font_string = "Tahoma 30"
    item_height_percent = 1.00
    width = 0
    item_height = 0
    use_clip = True
    
    def __init__(self, orientation=ORIENTATION_TOP):
        clutter.Group.__init__(self)
        self.items = []
        self.orientation = orientation
        
        #Setup input queue controller
        self.input_queue = InputQueue()
        self.input_queue.set_action(InputQueue.NORTH, self.move_up)
        self.input_queue.set_action(InputQueue.SOUTH, self.move_down)
        
        self.selected = 0
        self.displayMin = 0 #The number of menu items that will be shown at a time
        self.displayMax = 5 # default value
        self.displaySize = self.displayMax - self.displayMin
        self.roll_point_min = 1 #The item number at which point the list will roll down
        self.roll_point_max = self.displaySize -1 #The item number at which point the list will roll up
        
        #There are 2 subgroups:
        # 1) item_group: Contains the labels themselves
        # 2) display_group: Contains groups 1 & 2. Display group can optionally have a clip applied to it
        # Group 2 is then added to self 
        self.item_group = clutter.Group()
        self.item_group.show()
        self.display_group = clutter.Group()
        self.display_group.show()
        
        self.display_group.add(self.item_group)
        
        self.inactive_item_background = None
        self.image_down = None
        self.image_up = None
        #Selector bar image, moves with selections to show current item
        self.selector_bar = None
        
        #Score is used when adding / removing items as it is a two stage process (eg 2 timelines)
        self.score = clutter.Score()
        self.score.connect("completed", self.flush_backlog)
        self.score.append(clutter.Timeline(20,20)) # Seems to be a bug in Clutter 0.6 if score.remove_all() is called before a timeline has been added, so just add an unusued timeline here
        self.backlog = []
    
    def setup_from_theme_id(self, themeMgr, id, parent=None):
        context = "label_queue"
        
        element = themeMgr.search_docs(context, id).childNodes
        img_element = themeMgr.search_docs(context, id).getElementsByTagName("texture")
        #Quick check to make sure we found something
        if element is None:
            return None
        
        self.item_height_percent = float(themeMgr.find_child_value(element, "item_height_percent"))
        self.item_width_percent = float(themeMgr.find_child_value(element, "item_width_percent"))
        
        #Grab the font
        font_node = themeMgr.get_subnode(element, "font")
        fontString = themeMgr.get_font("main", font_node)
        self.font_string = fontString
        
        #Set the selection effect steps
        self.opacityStep0 = int(themeMgr.find_child_value(element, "opacity_step0"))
        self.opacityStep1 = int(themeMgr.find_child_value(element, "opacity_step1"))
        self.opacityStep2 = int(themeMgr.find_child_value(element, "opacity_step2"))
        
        self.fps = int(themeMgr.find_child_value(element, "transition_fps"))
        self.frames = int(themeMgr.find_child_value(element, "transition_frames"))
        clip = themeMgr.find_child_value(element, "use_clip")
        if not clip is None: self.use_clip = (clip == "True")
        
        if parent is None: parent = themeMgr.stage
        themeMgr.setup_actor(self, element, parent)
        (self.width, self.height) = themeMgr.get_dimensions(element, parent)
        
        #Set the up/down images + the selector bar
        #This assumes images go in the bottom right corner, will add flexibility later
        img_element_up = themeMgr.find_element(img_element, "id", "image_up")
        img_element_down = themeMgr.find_element(img_element, "id", "image_down")
        img_element_selector_bar = themeMgr.find_element(img_element, "id", "selector_bar")
        if not img_element_up is None:
            img_element_up = img_element_up.childNodes
            self.image_up = themeMgr.get_texture("image_up", self, element = img_element_up)
            self.image_up.set_opacity(180)
            self.image_up.set_position( self.width-self.image_up.get_width(), self.height+1)
            self.image_up.show()
            self.add(self.image_up)
        if not img_element_down is None:
            img_element_down = img_element_down.childNodes
            self.image_down = themeMgr.get_texture("image_up", self, element = img_element_down)
            self.image_down.set_opacity(180)
            self.image_down.set_position( self.width-self.image_down.get_width()-self.image_up.get_width(), self.height+1)
            self.image_down.show()
            self.add(self.image_down)
        if not img_element_selector_bar is None:
            img_element_selector_bar = img_element_selector_bar.childNodes
            self.selector_bar = themeMgr.get_texture("selector_bar", parent=self, element=img_element_selector_bar)
            self.selector_bar.y_offset = self.selector_bar.get_y()
            self.selector_bar.set_width(self.width)
            self.selector_bar.show()
            self.selector_bar.set_opacity(0)
            self.add(self.selector_bar)
        
        #Get the item background img
        img_element_item = themeMgr.find_element(img_element, "id", "inactive_background")
        if not img_element_item is None:
            img_element_item = img_element_item.childNodes
            self.inactive_item_background = themeMgr.get_texture("inactive_background", self, element = img_element_item)
        
        #self.displayMax = math.floor(self.height / height)
        #For the moment, the roll_point_x is just the ends of the list
        self.roll_point_min = 1
        self.roll_point_max = self.displayMax-1
        self.displaySize = self.displayMax - self.displayMin

        #This will default to true if not set in the theme
        if self.use_clip: self.display_group.set_clip(0, 0, self.width, self.height)

        return True
        
    def on_key_press_event (self, event):
        self.input_queue.input(event)
        return self.timeline
    
    def add_item(self, itemLabel, newItem=None):
        
        if self.score.is_playing():
            self.backlog.append(itemLabel)
            return
        self.score.remove_all()
        
        if len(self.items) == 0:
            #self.displayMax = self.height / self.label_height
            label_width = 0
    
            #This has to go hear for layering purposes
            if self.display_group.get_parent() is None:
                self.add(self.display_group)
        
        if newItem is None: newItem = QueueItem(self.font_string, self, label=itemLabel)
        newItem.set_background(clutter.CloneTexture(self.inactive_item_background), self.item_width_percent, self.item_height_percent)

        item_height = newItem.get_height()
        
        if self.orientation == self.ORIENTATION_TOP:
            item_y = 0
        elif self.orientation == self.ORIENTATION_BOTTOM:
            running_y = int(self.height + (item_height/2))
            for item in self.items:
                running_y += (item.get_height())
            item_y = int(running_y)
        newItem.show()
        newItem.set_position(0, item_y)
        newItem.set_opacity(0)
        self.items.append(newItem)
        self.item_group.add(newItem)
        
        #Setup behaviours
        timeline1 = clutter.Timeline(20,30)
        alpha1 = clutter.Alpha(timeline1, clutter.ramp_inc_func)
        self.behaviours = []
        if self.orientation == self.ORIENTATION_TOP:
            #All items must be moved down by the new items height
            for item in self.items:
                knots = (\
                         (item.get_x(), item.get_y()),\
                         (item.get_x(), int(item.get_y()+item_height) )\
                         )
                tmp_behaviour = clutter.BehaviourPath(alpha1, knots)
                tmp_behaviour.apply(item)
                self.behaviours.append(tmp_behaviour)
        elif self.orientation == self.ORIENTATION_BOTTOM:
            knots = (\
                     (self.item_group.get_x(), self.item_group.get_y()),\
                     (self.item_group.get_x(), int(self.item_group.get_y()-item_height))\
                     )
            tmp_behaviour = clutter.BehaviourPath(alpha1, knots)
            tmp_behaviour.apply(self.item_group)
            self.behaviours.append(tmp_behaviour)

        timeline2 = clutter.Timeline(20,30)
        alpha2 = clutter.Alpha(timeline2, clutter.ramp_inc_func)
        self.behaviour_opacity_newitem = clutter.BehaviourOpacity(opacity_start=0, opacity_end=255, alpha=alpha2)
        self.behaviour_opacity_newitem.apply(newItem)
        
        self.score.append(timeline1)
        self.score.append(timeline2, timeline1)
        self.score.start()
        #timeline1.start()
        return newItem
    
    def flush_backlog(self, data):
        if len(self.backlog) > 0:
            nextLabel = self.backlog.pop()
            self.add_item(nextLabel)
    
    #Removes all items from the list
    def clear(self):
        timeline = clutter.Timeline(15,30)
        timeline.connect("completed", self.reset_item_group)
        alpha = clutter.Alpha(timeline, clutter.ramp_inc_func)
        self.behaviour_opacity = clutter.BehaviourOpacity(opacity_start=255, opacity_end=0, alpha=alpha)
        self.behaviour_opacity.apply(self.item_group)
        
        timeline.start()
        
    def reset_item_group(self, data):
        for item in self.items:
            self.item_group.remove(item)
            item = None
        self.items = []
        self.selected = 0
        
        self.item_group.set_position(0, 0)
        self.item_group.set_opacity(255)
        self.behaviour_opacity = None
    
    def display(self):
        if self.displayMax > len(self.items):
            self.displayMax = len(self.items)
        
        self.show()
        
    def move_selection(self, direction, timeline=None):

        if direction == self.DIRECTION_DOWN:
            #Check if we're at the last item in the list
            if (self.selected) == (len(self.items)-1):
                return
            else:
                self.selected += 1
        elif direction == self.DIRECTION_UP:
            #Check if we're at the first / last item in the list
            if (self.selected) == 0:
                return
            else:
                self.selected -= 1
                
        if timeline is None: self.timeline = clutter.Timeline (self.frames, self.fps)
        else: self.timeline = timeline
        alpha = clutter.Alpha(self.timeline, clutter.ramp_inc_func)
        self.input_queue.set_timeline(self.timeline)

        
        #This horrible loop does all the scaling
        #This includes, the selected item and the ones on either side of it
        for i in range(len(self.items)):
            if i == self.selected:
                #Currently selected item
                self.items[i].scaleLabel(ListItem.SCALE_FULL, self.timeline)
            elif (i == self.selected-1) and (i >= self.displayMin):
                #Item above the selected
                self.items[i].scaleLabel(ListItem.SCALE_MEDIUM, self.timeline)
            elif (i == self.selected+1) and (i <= self.displayMax-1):
                #Item below the selected
                self.items[i].scaleLabel(ListItem.SCALE_MEDIUM, self.timeline)
            #elif (i < self.displayMin) or (i > self.displayMax):
                #Item is off screen
            #    self.items[i].scaleLabel(ListItem.SCALE_OFFSCREEN, self.timeline)
            else:
                #All other items
                self.items[i].scaleLabel(ListItem.SCALE_NONE, self.timeline)
        
        #Check we're at the top of the viewable list
        if (self.selected < self.roll_point_min) and (self.displayMin > 0):
            #If yes, move the menu, leave the selection bar where is
            #self.rollList( self.items[self.displayMin-1], self.items[self.displayMax+1], self.DIRECTION_UP, self.timeline)
            self.rollList( self.DIRECTION_UP, self.timeline)
        #Check if we're at the bottom of the viewable list
        elif (self.selected >= self.roll_point_max) and (self.displayMax < (len(self.items))):
            #self.rollList( self.items[self.displayMax+1], self.items[self.displayMin-1], self.DIRECTION_DOWN, self.timeline)
            self.rollList( self.DIRECTION_DOWN, self.timeline)
        
        if not self.selector_bar is None:
            #move the selector bar
            abs_item = self.selected - self.displayMin
            abs_y = abs_item * self.item_height + self.selector_bar.y_offset
            knots = (\
                     (self.selector_bar.get_x(), self.selector_bar.get_y()),
                     (self.selector_bar.get_x(), abs_y)
                     )
            self.behaviour_path_bar = clutter.BehaviourPath(knots=knots, alpha=alpha)
            self.behaviour_path_bar.apply(self.selector_bar)
            #self.selector_bar().selectItem(self.menuItems[self.selected], self.timeline)

        self.timeline.start()
            
    def move_up(self):
        self.move_selection(self.DIRECTION_UP)
        
    def move_down(self):
        self.move_selection(self.DIRECTION_DOWN)
                        
    def select_first(self, frames=1, fps=75, timeline=None):
        if self.input_queue.is_in_queue():
            "ERROR: Timeline should NOT be playing here!"
            return
               
        if timeline is None:self.timeline = clutter.Timeline(frames, fps)
        else: self.timeline = timeline
        
        alpha = clutter.Alpha(self.timeline, clutter.ramp_inc_func)
        self.input_queue.set_timeline(self.timeline)
        self.selected = 0
        for i in range(0,len(self.items)):
            if i == 0:
                self.items[i].scaleLabel(ListItem.SCALE_FULL, self.timeline)
            elif i == 1:
                self.items[i].scaleLabel(ListItem.SCALE_MEDIUM, self.timeline)
            else:
                self.items[i].scaleLabel(ListItem.SCALE_NONE, self.timeline)
                
        #Show the selector bar
        if not self.selector_bar is None:
            self.behaviour_opacity = clutter.BehaviourOpacity(opacity_start=0, opacity_end=255, alpha=alpha)
            self.behaviour_opacity.apply(self.selector_bar)
            """
            #move the selector bar
            abs_y = self.selector_bar.y_offset
            knots = (\
                     (self.selector_bar.get_x(), self.selector_bar.get_y()),
                     (self.selector_bar.get_x(), abs_y)
                     )
            self.behaviour_path_bar = clutter.BehaviourPath(knots=knots, alpha=alpha)
            self.behaviour_path_bar.apply(self.selector_bar)
            """
               
        #Timeline only gets started if it was created in this function
        if timeline is None: self.timeline.start()
        
    #Just calls the above function with different arguements to result in the first item being selected in a 'prettier' manner
    def select_first_elegant(self, timeline=None):
        self.select_first(frames=self.frames, fps=self.fps, timeline=timeline)
        
    def select_none(self, frames = 1, fps = 75):
        self.timeline = clutter.Timeline(frames, fps)
        alpha = clutter.Alpha(self.timeline, clutter.ramp_inc_func)
        self.input_queue.set_timeline(self.timeline)
        self.selected = None
        for i in range(0,len(self.items)):
            self.items[i].scaleLabel(ListItem.SCALE_NONE, self.timeline)
        
        #Hide the selector bar
        if not self.selector_bar is None:
            self.behaviour_opacity = clutter.BehaviourOpacity(opacity_start=255, opacity_end=0, alpha=alpha)
            self.behaviour_opacity.apply(self.selector_bar)
        
        self.selected = 0
        self.timeline.start()
    
    def select_none_elegant(self):
        self.select_none(self.frames, self.fps)
        
    #When the menu needs to display a new item from the top or bottom, it rolls
    # The distance the menu moves is the distance (in pixels) between the incoming item and the selector bar
    def rollList(self, direction, timeline):          
        
        (group_x, group_y) = self.item_group.get_position()
        if direction == self.DIRECTION_DOWN:  
            #Then the incoming item is below the selector bar
            gap = self.item_height * -1
            self.displayMin += 1
            self.displayMax += 1
            self.roll_point_min += 1
            self.roll_point_max += 1
            
            """
            outgoing_item = self.items[self.displayMin-1]
            incoming_item = self.items[self.displayMax+1]
            """
        else:
            #Then the incoming item is above the selector bar
            gap = self.item_height
            self.displayMin -= 1
            self.displayMax -= 1
            self.roll_point_min -=1
            self.roll_point_max -=1
            """
            incoming_item = self.items[self.displayMin-1]
            outgoing_item = self.items[self.displayMax+1]
            """
        #print "Gap: " + str(gap)
        new_y = (group_y + gap)
        knots = (\
            (group_x, group_y),\
            (group_x, new_y )\
            )
        alpha = clutter.Alpha(timeline, clutter.ramp_inc_func)
        self.behaviour_path = clutter.BehaviourPath(alpha, knots)
        
        #self.behaviour_opacity_outgoing = clutter.BehaviourOpacity(opacity_start=outgoing_item.get_opacity(), opacity_end=0, alpha=alpha)
        #self.behaviour_opacity_incoming = clutter.BehaviourOpacity(opacity_start=0, opacity_end=outgoing_item.get_opacity(), alpha=alpha)
        
        self.behaviour_path.apply(self.item_group)
        self.behaviour_path.apply(self.background_group)
        
        """
        self.behaviour_opacity_outgoing.apply(outgoing_item)
        #The incoming opacity behaviour is only used if the incomingItem is NOT the currently selected one
        if not self.items[self.selected] == incoming_item: 
            self.behaviour_opacity_incoming.apply(incoming_item)
            #self.behaviour_opacity_incoming.apply(incomingMenutem)
        """
        
    def get_current_item(self, offset=0):
        selection = self.selected + offset
        if (selection < 0) or (selection >= len(self.items)): return None
        return self.items[self.selected+offset]
        
import gobject
class QueueItem(clutter.Group):
    #Setup signals
    __gsignals__ =  { 
        "selected": (
            gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, []),
        "deselected": (
            gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, [])
        }
    
    STATE_SELECTED, STATE_NEXT, STATE_UNSELECTED, STATE_OFFSCREEN = range(4)
    
    #Default values for zoom and opacity
    opacity_step_full = 255
    opacity_step_medium = 135
    opacity_step_none = 50

    def __init__ (self, font, label_queue, label=""):
        clutter.Group.__init__ (self)
        self.set_anchor_point_from_gravity(clutter.GRAVITY_NORTH)
        #self.set_anchor_point_from_gravity(clutter.GRAVITY_CENTER)
        
        self.background = None
        self.label = clutter.Label()
        
        #Takes the scale and opacity values from a label list, if given
        self.opacity_step_full = label_queue.opacityStep0
        self.opacity_step_medium = label_queue.opacityStep1
        self.opacity_step_none = label_queue.opacityStep2
        
        self.label_queue = label_queue
        self.label.set_width(label_queue.width)
            
        #setup the label/s
        self.add(self.label)
        self.label.show()
        self.label.set_font_name(font)
        self.label.set_text(label)
        self.color = clutter.Color(0xff, 0xff, 0xff, 0xdd)
        self.label.set_color(self.color)
        self.currentOpacity = 255
        self.data = label #By default the items data is simply its label
        
        self.label.set_line_wrap(True)
        
        #Text is actually scaled down in 'regular' position so that it doesn't get jaggies when zoomed in
        self.currentOpacity = self.opacity_step_medium
        self.set_anchor_point_from_gravity(clutter.GRAVITY_WEST)
        self.set_opacity(self.currentOpacity)
        
    def set_selection_level(self, level, timeline):
       
        #Default values (Just in case)
        opacityTo = 255

        STATE_SELECTED, STATE_NEXT, STATE_UNSELECTED, STATE_OFFSCREEN
        if level == STATE_SELECTED:
            opacityTo = self.opacity_step_full
            self.emit("selected")
        elif level == STATE_NEXT:
            opacityTo = self.opacity_step_medium
            self.emit("deselected")
        elif level == STATE_UNSELECTED:
            opacityTo = self.opacity_step_none
        elif level == STATE_OFFSCREEN:
            opacityTo = 0
        
        #Do a check for any actual changes. If there's no change, just return without applying any behaviours    
        if (opacityTo == self.currentOpacity):
            return None
    
        alpha = clutter.Alpha(timeline, clutter.ramp_inc_func)
        self.behaviourOpacity = clutter.BehaviourOpacity(opacity_start=self.currentOpacity, opacity_end=opacityTo, alpha=alpha)
        self.behaviourOpacity.apply(self)
        
        self.currentOpacity = opacityTo
        
    def set_background(self, texture, width_percent, height_percent):
        if self.background is None:
            texture.set_width(int(self.label_queue.width * width_percent))
            texture.set_height(int(self.label.get_height() * height_percent))
        else:
            texture.set_width(self.background.get_width())
            texture.set_height(self.background.get_height())
            self.remove(self.background)
        self.background = texture
        
        label_x = (self.background.get_width() - self.label.get_width()) / 2
        label_y = (self.background.get_height() - self.label.get_height()) / 2
        self.label.set_position(label_x, label_y)

        self.add(self.background)
        self.lower_child(self.label, self.background)
        self.background.show()
        
    def set_data(self, data):
        self.data = data
        
    def get_data(self):
        return self.data
    
    def get_menu(self):
        return self.menu