def draw_cursor(self, cr, rect):
        x, y, w, h = rect.x, rect.y, rect.width, rect.height
        cursor_ir = self.__buffer.get_iter_at_cursor()
        left_str = cursor_ir.get_line_text()[0:cursor_ir.get_line_offset()]
        left_str_width = self.get_content_width(left_str)
        
        current_line = cursor_ir.get_line()

        line_offset = 0
        
        utf_8_height = get_content_size("好Height", self.font_size)[-1]
        no_utf_8_height = get_content_size("Height", self.font_size)[-1]

        for x in range(0, current_line):
            if self.__is_utf_8_text_in_line(x):
                line_offset += utf_8_height
            else:
                line_offset += no_utf_8_height

        temp_line_offset = 1 # solve the offset problem while adding lines
        

        cr.set_source_rgb(0,0,0)
        cr.rectangle(x + self.padding_x + left_str_width - temp_line_offset * current_line, y  + line_offset + utf_8_height - no_utf_8_height , 1, no_utf_8_height)
        cr.fill()

 def update_size(self):
     '''Update size.'''
     if self.label_width == None:
         (label_width, label_height) = get_content_size(self.text, self.text_size, wrap_width=self.wrap_width)
     else:
         (label_width, label_height) = get_content_size(self.text, self.text_size, wrap_width=self.wrap_width)
         label_width = self.label_width
         
     if self.enable_gaussian:
         label_width += self.gaussian_radious * 2
         label_height += self.gaussian_radious * 2
         
     self.set_size_request(label_width, label_height)

    def __time_label_press(self, widget, event):
        (self.time_width, text_height) = get_content_size("12")
        (self.time_comma_width, text_comma_height) = get_content_size(" : ")

        if event.x < self.padding_x + self.time_width:
            self.set_time = self.SET_HOUR
            return

        if event.x > self.padding_x + self.time_width and event.x < self.padding_x + (self.time_width + self.time_comma_width) * 2:
            self.set_time = self.SET_MIN
            return

        if event.x > self.padding_x + self.time_width + self.time_comma_width * 2:
            self.set_time = self.SET_SEC
            return

    def __init__(self,
                 element,
                 index,
                 font_size,
                 padding_x,
                 padding_y,
                 vertical,
                 set_index, get_index,
                 item_hover_pixbuf,
                 item_press_pixbuf,
                 ):
        '''
        Initialize NavItem class.

        @param element: Item format: (item_icon_dpixbuf, item_content, clicked_callback)
        @param index: Item index.
        @param font_size: Font size.
        @param padding_x: Padding value horizontal.
        @param padding_y: Padding value vertical.
        @param vertical: Draw direction.
        @param set_index: Set index callback.
        @param get_index: Get index callback.
        @param item_hover_pixbuf: Item hover pixbuf.
        @param item_press_pixbuf: Item press pixbuf.
        '''
        # Init.
        self.index = index
        self.font_size = font_size
        self.vertical = vertical
        self.set_index = set_index
        self.get_index = get_index
        self.item_hover_pixbuf = item_hover_pixbuf
        self.item_press_pixbuf = item_press_pixbuf
        self.notify_num = 0
        (self.icon_dpixbuf, self.content, self.clicked_callback) = element
        self.nav_item_pixbuf = self.icon_dpixbuf.get_pixbuf()
        pixbuf = self.item_hover_pixbuf.get_pixbuf()
        (self.text_width, self.text_height) = get_content_size(self.content, self.font_size)

        # Init item button.
        self.pixbuf_width_scale = False
        self.item_button = gtk.Button()
        if self.text_width + self.nav_item_pixbuf.get_width() > pixbuf.get_width():
            self.item_button.set_size_request(
                    self.text_width + self.nav_item_pixbuf.get_width()+ 10,
                    pixbuf.get_height())
            self.pixbuf_width_scale = True
        else:
            self.item_button.set_size_request(pixbuf.get_width(), pixbuf.get_height())

        widget_fix_cycle_destroy_bug(self.item_button)

        self.item_button.connect("expose-event", self.expose_nav_item)
        self.item_button.connect("clicked", lambda w: self.wrap_nav_item_clicked_action())

        # Init item box.
        self.item_box = gtk.Alignment()
        self.item_box.set(0.5, 0.5, 1.0, 1.0)
        self.item_box.set_padding(padding_y, padding_y, padding_x, padding_x)
        self.item_box.add(self.item_button)

    def __init__(self, tab_names, font_size=11, padding_x=0, padding_y=0):
        """
        Initialize TabSwitcher class.

        @param tab_names: The name of tabs.
        @param padding_x: The padding x around tab name, default is 0 pixel.
        @param padding_y: The padding y around tab name, default is 0 pixel.
        """
        EventBox.__init__(self)
        self.add_events(gtk.gdk.ALL_EVENTS_MASK)
        self.tab_names = tab_names
        self.tab_name_size = font_size
        self.tab_number = len(self.tab_names)
        tab_sizes = map(lambda tab_name: get_content_size(tab_name, self.tab_name_size), self.tab_names)
        self.tab_name_padding_x = 10
        self.tab_name_padding_y = 2
        self.tab_width = max(map(lambda (width, height): width, tab_sizes)) + self.tab_name_padding_x * 2
        self.tab_height = tab_sizes[0][1] + self.tab_name_padding_y * 2
        self.tab_line_height = 3
        self.tab_index = 0

        self.tab_animation_x = 0
        self.tab_animation_time = 200  # milliseconds

        self.padding_x = padding_x
        self.padding_y = padding_y
        self.in_animiation = False
        self.line_dcolor = ui_theme.get_color("globalItemHighlight")

        self.set_size_request(-1, self.tab_height + self.tab_line_height)

        self.connect("realize", self.realize_tab_switcher)
        self.connect("expose-event", self.expose_tab_switcher)
        self.connect("button-press-event", self.button_press_tab_switcher)

    def __init__(self,
                 title,
                 item_value,
                 item_width=None,
                 font_size=DEFAULT_FONT_SIZE,
                 ):
        '''
        Initialize ComboTextItem class.

        @param title: Title of item, we use this for display name (include internationalization).
        @param item_value: The value of item, use for index item in program.
        @param item_width: The width of item, default is None to calculate width with item content.
        @param font_size: Font size of item, default is DEFAULT_FONT_SIZE.
        '''
        AbstractItem.__init__(self)
        self.column_index = 0
        self.item_height = 22
        self.spacing_x = 15
        self.padding_x = 5
        self.font_size = font_size
        if item_width == None:
            self.item_width, _ = get_content_size(title, font_size)
            self.item_width += self.spacing_x * 2
        else:
            self.item_width = item_width
        self.title = title
        self.item_value = item_value

    def draw_ip(self, cr, rect):
        x, y, w, h = rect.x, rect.y, rect.width, rect.height
        ip_segment_distance = self.width / self.segment_number
        for (ip_segment_index, ip_segment) in enumerate(self.ip.split(self.segment_split_char)):
            text_color = "#000000"
            if ip_segment_index == self.highlight_segment_index:
                (ip_segment_width, ip_segment_height) = get_content_size(ip_segment)

                if self.grab_focus_flag:
                    background_color = self.select_active_color.get_color_info()
                else:
                    background_color = self.select_inactive_color.get_color_info()
                draw_hlinear(
                    cr,
                    x + ip_segment_index * ip_segment_distance + (ip_segment_distance - ip_segment_width) / 2,
                    y + self.cursor_padding_y,
                    ip_segment_width + 1,
                    h - self.cursor_padding_y * 2,
                    background_color,
                    )

                text_color = "#FFFFFF"

            draw_text(cr, ip_segment,
                      x + ip_segment_index * ip_segment_distance,
                      y,
                      ip_segment_distance,
                      h,
                      alignment=pango.ALIGN_CENTER,
                      text_color=text_color,
                      )

    def __init__(self, item, index, font_size, icon_width, 
                 padding_left, padding_middle, padding_right, 
                 set_index, get_index):
        '''Init category item.'''
        # Init.
        gtk.Button.__init__(self)
        self.font_size = font_size
        self.index = index
        self.set_index = set_index
        self.get_index = get_index
        self.padding_left = padding_left
        self.padding_right = padding_right
        (self.icon_dpixbuf, self.content, self.clicked_callback) = item
        (content_width, font_height) = get_content_size(self.content, self.font_size)
        
        # Init item button.
        self.font_offset = 0
        if icon_width == 0:
            self.font_offset = 0
        else:
            self.font_offset = padding_middle + icon_width
        self.set_size_request(
            padding_left + self.font_offset + content_width + padding_right,
            -1
            )

        self.connect("expose-event", self.expose_category_item)    
        self.connect("clicked", lambda w: self.wrap_category_item_clicked_action())

 def add_items(self, items, default_index=0):
     '''Add items.'''
     self.tab_items += items
     
     for item in items:
         self.tab_title_widths.append(get_content_size(item[0], DEFAULT_FONT_SIZE)[0] + self.tab_padding_x * 2)
         
     self.switch_content(default_index)

 def set_label(self, label, font_size=DEFAULT_FONT_SIZE):
     '''Set label.'''
     self.label = label
     (self.label_width, self.label_height) = get_content_size(label, self.font_size)
     self.set_size_request(max(self.label_width + self.padding_x * 2, self.min_width),
                           max(self.label_height + self.padding_y * 2, self.min_height))
     
     self.queue_draw()

 def get_tab_width(self, tab_name):
     '''
     docs
     '''
     (text_width, text_height) = get_content_size(tab_name)
     tab_height = self.height
     triangle_width = int(tab_height / math.tan(math.radians(self.tab_angle)))
     middle_width = text_width + self.tab_name_padding_x * 2
     return middle_width + self.tab_radious * 4 + triangle_width * 2

 def get_droplist_width(self):
     '''Get droplist width.'''
     item_content_width = max(map(lambda item: get_content_size(item.item[0], self.font_size)[0], 
                                  filter(lambda item: isinstance(item.item_box, gtk.Button), self.droplist_items)))
     if self.max_width != None:
         return self.padding_x * 2 + min(self.max_width,
                                         self.item_padding_left + self.item_padding_right + int(item_content_width))
     else:
         return self.padding_x * 2 + self.item_padding_left + self.item_padding_right + int(item_content_width)

    def show(self, text):
        '''
        Show.

        @param text: OSD tooltip text.
        '''
        # Remove callback.j
        remove_signal_id(self.configure_event_callback_id)
        remove_signal_id(self.destroy_callback_id)
        remove_signal_id(self.focus_out_callback_id)
        remove_timeout_id(self.start_hide_callback_id)

        # Update text.
        self.text = text

        # Get tooltip size.
        (tooltip_width, tooltip_height) = get_content_size(
            self.text,
            self.text_size + self.border_radious * 2,
            self.text_font)
        self.tooltip_width = tooltip_width * 2
        self.tooltip_height = tooltip_height

        # Move tooltip to given position.
        (monitor_x, monitor_y) = self.monitor_widget.window.get_origin()
        self.tooltip_x = monitor_x + self.offset_x
        self.tooltip_y = monitor_y + self.offset_y

        # Monitor configure-event signal.
        self.monitor_window = self.monitor_widget.get_toplevel()
        configure_event_handler_id = self.monitor_window.connect("configure-event", self.handle_configure_event)
        self.configure_event_callback_id = (self.monitor_window, configure_event_handler_id)
        destroy_handler_id = self.monitor_window.connect("destroy", lambda w: self.hide_immediately())
        self.destroy_callback_id = (self.monitor_window, destroy_handler_id)
        focus_out_handler_id = self.monitor_window.connect("focus-out-event", lambda w, e: self.hide_immediately())
        self.focus_out_callback_id = (self.monitor_window, focus_out_handler_id)

        # Save monitor window position.
        rect = self.monitor_window.allocation
        (monitor_window_x, monitor_window_y) = self.monitor_window.window.get_origin()
        monitor_window_width, monitor_window_height = rect.width, rect.height
        self.monitor_window_x = monitor_window_x
        self.monitor_window_y = monitor_window_y
        self.monitor_window_width = monitor_window_width
        self.monitor_window_height = monitor_window_height

        # Show.
        self.set_opacity(1)
        self.show_all()

        self.start_hide_callback_id = gobject.timeout_add(
            self.start_hide_delay,
            lambda : Animation(self, "opacity", self.hide_time, [1, 0],
                           stop_callback=self.hide_immediately).start())

        self.queue_draw()       # make sure redraw

    def __init__(self,
                 label_content,
                 label_wrap_width,
                 label_init_height,
                 label_init_line,
                 label_font_size,
                 label_font_color,
                 animation_time=200, # milliseconds
                 ):
        '''
        Initialize ResizableLabelBuffer class.
        
        @param label_content: The content of label.
        @param label_wrap_width: The wrap width of label.
        @param label_init_height: The initialize height of label. 
        @param label_init_line: The initialize line number of label.
        @param label_font_size: The font size.
        @param label_font_color: The font color.
        @param animation_time: The time of animation, default is 200 milliseconds.
        '''
        gobject.GObject.__init__(self)
        
        self.label_content = label_content
        self.label_init_height = label_init_height
        self.label_init_line = label_init_line
        self.label_font_size = label_font_size
        self.label_font_color = label_font_color
        self.label_wrap_width = label_wrap_width

        self.animation_time = animation_time
        self.in_animation = False
        self.label_line_height = int(float(self.label_init_height / self.label_init_line))
        self.label_expand_height = self.label_line_height * 2
        (self.max_width, self.max_height) = self.get_max_size()
        self.is_expandable = not (self.max_height <= self.label_init_height)
        (self.init_width, self.init_height) = self.get_init_size()
        self.has_expand = False
        (self.expand_width, self.expand_height) = self.get_expand_size()
        self.expand_button_content = _("Expand")
        self.shrink_button_content = _("Shrink")
        (self.expand_button_width, self.expand_button_height) = get_content_size(self.expand_button_content, self.label_font_size)
        (self.shrink_button_width, self.shrink_button_height) = get_content_size(self.shrink_button_content, self.label_font_size)

    def realize_item_box(self, widget, item_content):
        '''Realize item box.'''
        # Set button size.
        (width, height) = get_content_size(item_content, self.font_size)
        self.item_box_height = self.item_padding_y * 2 + int(height)
        self.item_box_width = self.item_padding_left + self.item_padding_right + int(width)

        if self.max_width != None:
            self.item_box_width = min(self.item_box_width, self.max_width)        
        else:
            self.item_box_width = self.item_box_width        
            
        self.item_box.set_size_request(self.item_box_width, self.item_box_height)        

 def add_items(self, items, default_index=0):
     '''
     Add items.
     
     @param items: A list of tab item, tab item format: (tab_name, tab_widget)
     @param default_index: Initialize index, default is 0.
     '''
     self.tab_items += items
     
     for item in items:
         self.tab_title_widths.append(get_content_size(item[0], DEFAULT_FONT_SIZE)[0] + self.tab_padding_x * 2)
         
     self.switch_content(default_index)

 def __init__(self, icon_dpixbufs, text, text_size=DEFAULT_FONT_SIZE, icon_width=16, padding_x=10, padding_y=6):
     """
     Initialize IconTextItem class.
     """
     # Init.
     TreeItem.__init__(self)
     (self.icon_normal_dpixbuf, self.icon_hover_dpixbuf, self.icon_disable_dpixbuf) = icon_dpixbufs
     self.item_width = 160
     self.text = text
     self.text_size = text_size
     self.icon_width = 16
     self.padding_x = padding_x
     self.padding_y = padding_y
     (self.text_width, self.text_height) = get_content_size(self.text)

    def realize_item_box(self, widget, item_content):
        '''Realize item box.'''
        # Set button size.
        (width, height) = get_content_size(item_content, self.font_size)
        self.item_box_height = self.item_padding_y * 2 + max(int(height), self.icon_height)
        if self.select_scale:
            self.item_box_width = widget.get_parent().get_parent().allocation.width
        else:
            self.item_box_width = self.item_padding_x * 3 + self.icon_width + int(width)

            if self.have_submenu:
                self.item_box_width += self.item_padding_x + self.submenu_width + self.arrow_padding_x * 2
                
        self.item_box_width = max(self.item_box_width, self.min_width)        
                
        self.item_box.set_size_request(self.item_box_width, self.item_box_height)        

    def __init__(self, 
                 item, 
                 index, 
                 font_size, 
                 icon_width, 
                 padding_left, 
                 padding_middle, 
                 padding_right, 
                 set_index, 
                 get_index):
        '''
        Initialize CategoryItem class.
        
        @param item: Category item, format: (item_dpixbuf, content, click_callback)
        @param index: Category item index.
        @param font_size: Font size.
        @param icon_width: Icon width.
        @param padding_left: Padding at left of item. 
        @param padding_middle: Padding between icon and font.
        @param padding_right: Padding at right of item.
        @param set_index: Set index callback.
        @param get_index: Get index callback.
        '''
        # Init.
        gtk.Button.__init__(self)
        self.font_size = font_size
        self.index = index
        self.set_index = set_index
        self.get_index = get_index
        self.padding_left = padding_left
        self.padding_right = padding_right
        (self.icon_dpixbuf, self.content, self.clicked_callback) = item
        (content_width, font_height) = get_content_size(self.content, self.font_size)
        
        # Init item button.
        self.font_offset = 0
        if icon_width == 0:
            self.font_offset = 0
        else:
            self.font_offset = padding_middle + icon_width
        self.set_size_request(
            padding_left + self.font_offset + content_width + padding_right,
            -1
            )

        self.connect("expose-event", self.expose_category_item)    
        self.connect("clicked", lambda w: self.wrap_category_item_clicked_action())

 def draw_entry_cursor(self, cr, rect):
     '''Draw entry cursor.'''
     if self.grab_focus_flag and self.select_start_index == self.select_end_index:
         # Init.
         x, y, w, h = rect.x, rect.y, rect.width, rect.height
         left_str = self.content[0:self.cursor_index]
         left_str_width = self.get_content_width(left_str)
         padding_y = (h - (get_content_size("Height", self.font_size)[-1])) / 2
         
         # Draw cursor.
         cr.set_source_rgb(*color_hex_to_cairo(ui_theme.get_color("entry_cursor").get_color()))
         cr.rectangle(x + self.padding_x + left_str_width - self.offset_x,
                      y + padding_y,
                      1, 
                      h - padding_y * 2
                      )
         cr.fill()