root/branch/ggpolo/umitInventory/TLGraphToolbar.py @ 1030

# Copyright (C) 2007 Insecure.Com LLC.
#
# Authors: Guilherme Polo <ggpolo@gmail.com>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 
# USA

import gtk

from umitCore.I18N import _

from DataGrabber import DataGrabber
from TLGraphPreferences import GraphPreferences

"""
ToDO: Add support for time range change, show current visualization date.
"""

class GraphControllerTB(gtk.Toolbar):
    """
    Builds a Toolbar for controlling Interactive Timeline Graph.
    """
    
    def __init__(self, daddy, connector):
        gtk.Toolbar.__init__(self)
        
        self.daddy = daddy
        self.connector = connector
        
        index = (i for i in xrange(7))
        self.tooltips = gtk.Tooltips()
        
        #self.insert(self.zoom_control(), index.next())
        self.insert(self.viewing_kind(), index.next())
        self.insert(self.graph_kind(), index.next())
        self.insert(self.graph_pref(), index.next())

        self.connector.connect('data-update', self._update_graph_data)


    def packed(self, *widgets):
        """
        Pack widgets in a gtk.HBox and returns a gtk.ToolItem
        """
        tbox = gtk.HBox()
        for w in widgets:
            tbox.pack_start(w, False, False, 0)

        titem = gtk.ToolItem()
        titem.add(tbox)

        return titem


    def timerange_control(self):
        """
        Creates widgets for handling graph timerange visualization.
        """
        
        

    def zoom_control(self):
        """
        Setup combobox for managing graph zoom level.
        """
        views = (_("Yearly View"), _("Monthly View"), _("Daily View"), _("Hourly View"))     
        self.zoomgraph = gtk.combo_box_new_text()

        for v in views:
            self.zoomgraph.append_text(v)

        self.zoomgraph.set_active(0)
        self.zoomgraph.connect('changed', self._change_graph_zoom)
   
        return self.packed(self.zoomgraph)

    
    def viewing_kind(self):
        """
        Combobox that displays possible ways on how graph may grab changes.
        """
        modes = (_("Sum of changes"), _("By category"))
        self.evtsgraph = gtk.combo_box_new_text()
        self.evtsgraph.append_text(_("Select visualization"))
        
        for mode in modes:
            self.evtsgraph.append_text(mode)

        self.evtsgraph.set_active(1)
        self.evtsgraph.connect('changed', self._change_graph_data)

        return self.packed(self.evtsgraph)


    def graph_kind(self):
        """
        Combobox for setting graph kind. Right now there is only line graph
        and area graph.
        """
        modes = (_("Line Graph"), _("Area Graph"))
        self.cbgraphs = gtk.combo_box_new_text()
        self.cbgraphs.append_text(_("Select a graph style"))

        for mode in modes:
            self.cbgraphs.append_text(mode)

        self.cbgraphs.set_active(1)
        self.cbgraphs.connect('changed', self._change_graph_kind)

        return self.packed(self.cbgraphs)


    def graph_pref(self):
        """
        Button for opening Graph Preferences window.
        """
        self.btn_gpref = gtk.Button(stock=gtk.STOCK_EDIT)
        self.sched_name_edit = gtk.Button(stock=gtk.STOCK_EDIT)
        # get label widget to change default label text "Edit" to 
        # "Graph Preferences"
        blbl = self.btn_gpref.get_children()[0].get_children()[0].get_children()[1]
        blbl.set_text(_("Graph Preferences"))
        
        self.btn_gpref.connect('clicked', self._open_graph_pref)
        self.btn_gpref.show()

        self.tooltips.set_tip(self.btn_gpref, _("Edit Graph Preferences"))

        return self.packed(self.btn_gpref)
    

    def update_graph(self):
        """
        Active options set.
        """
        self.daddy.setup_new_graph()


    def _change_graph_zoom(self, event):
        """
        Set new zoom level
        """
        self.connector.emit('zoom-update', event.get_active())


    def _change_graph_kind(self, event):
        """
        Set new graph kind.
        """
        active = event.get_active()
        if active: # Didnt select "Select a graph style"
            setattr(self.daddy, "graph_type", active-1)


    def _update_graph_data(self, obj):
        self._change_graph_data(self.evtsgraph.get_active())


    def _change_graph_data(self, event):
        """
        Changing how graph displays events will result in grabbing events in
        a different way.
        """
        active = (type(0) == type(event)) and event or event.get_active()
        if active: # Didnt select "Select visualization"

            # this may be changed soon! (1)
            if active == 1:
                max, start, evts = DataGrabber().changes_in_year_by_week(2007)
                filter = { }
                filter[0] = (True, _("Changes Sum"))
            elif active == 2:
                filter, max, start, \
                evts = DataGrabber().changes_in_year_by_category_by_week(2007)
                
                for key, value in filter.items():
                    filter[key-1] = (True, value)

                if len(filter): # database has no changes registered yet
                    del filter[len(filter)-1]
            # (1)
            
            self.daddy.max = max
            self.daddy.start_pts_data = start
            self.daddy.graph_data = evts
            
            self.connector.emit('filter-update', filter)
            
            self.update_graph()


    def _open_graph_pref(self, event):
        """
        Open Graph Preferences window.
        """
        w = GraphPreferences(self)
        w.show_all()


    def __set_graph_mode(self, mode):
        """
        Change graph mode.
        """
        getattr(self.daddy, mode)()

    
    def __set_graph_attr(self, (attr, value)):
        """
        Change some graph attribute.
        """
        setattr(self.daddy, attr, value)
    

    # Properties
    change_graph_mode = property(fset=__set_graph_mode)
    change_graph_attr = property(fset=__set_graph_attr)