def on_expose_combo_frame(self, widget, event):
        # Init.
        cr = widget.window.cairo_create()
        rect = widget.allocation

        # Draw frame.
        with cairo_disable_antialias(cr):
            cr.set_line_width(1)
            if self.get_sensitive():
                cr.set_source_rgb(*color_hex_to_cairo(ui_theme.get_color("combo_entry_frame").get_color()))
            else:
                cr.set_source_rgb(*color_hex_to_cairo(ui_theme.get_color("disable_frame").get_color()))
            cr.rectangle(rect.x, rect.y, rect.width, rect.height)
            cr.stroke()

            if self.focus_flag:
                color = (ui_theme.get_color("combo_entry_select_background").get_color(), 0.9)
                cr.set_source_rgba(*alpha_color_hex_to_cairo(color))
                cr.rectangle(rect.x, rect.y, rect.width - 1 - self.drop_button_width, rect.height - 1)
                cr.fill()
                cr.set_source_rgba(*alpha_color_hex_to_cairo((ui_theme.get_color("combo_entry_background").get_color(), 0.9)))
                cr.rectangle(rect.x + rect.width - 1 - self.drop_button_width, rect.y, self.drop_button_width, rect.height - 1)
                cr.fill()
            else:
                cr.set_source_rgba(*alpha_color_hex_to_cairo((ui_theme.get_color("combo_entry_background").get_color(), 0.9)))
                cr.rectangle(rect.x, rect.y, rect.width - 1, rect.height - 1)
                cr.fill()

        # Propagate expose to children.
        propagate_expose(widget, event)

        return True

 def expose_button_item(self, widget, event):    
     
     # Init.
     cr = widget.window.cairo_create()
     rect = widget.allocation
     select_index = self.get_index()
     
     # Draw background
     if widget.state == gtk.STATE_NORMAL:
         if select_index == self.index:
             select_status = BUTTON_PRESS
         else:    
             select_status = BUTTON_NORMAL
             
     elif widget.state == gtk.STATE_PRELIGHT:        
         if select_index == self.index:
             select_status = BUTTON_PRESS
         else:    
             select_status = BUTTON_HOVER
             
     elif widget.state == gtk.STATE_ACTIVE:   
         select_status = BUTTON_PRESS
         
     if select_status == BUTTON_PRESS:    
         pixbuf = self.press_dpixbuf.get_pixbuf()
     elif select_status == BUTTON_NORMAL:    
         pixbuf = self.normal_dpixbuf.get_pixbuf()
     elif select_status == BUTTON_HOVER:    
         pixbuf = self.hover_dpixbuf.get_pixbuf()
         
     draw_pixbuf(cr, pixbuf, rect.x, rect.y)    
     propagate_expose(widget, event)
     return True

    def expose_spin_bg(self, widget, event):
        '''
        Internal callback for `expose-event` signal.
        '''
        # Init.
        cr = widget.window.cairo_create()
        rect = widget.allocation
        x, y, w, h = rect.x, rect.y, rect.width, rect.height

        # Draw frame.
        with cairo_disable_antialias(cr):
            cr.set_line_width(1)
            if widget.state == gtk.STATE_INSENSITIVE:
                cr.set_source_rgb(*color_hex_to_cairo(ui_theme.get_color("disable_frame").get_color()))
            else:
                cr.set_source_rgb(*color_hex_to_cairo(ui_theme.get_color("combo_entry_frame").get_color()))
            cr.rectangle(rect.x, rect.y, rect.width, rect.height)
            cr.stroke()

            if widget.state == gtk.STATE_INSENSITIVE:
                cr.set_source_rgba(*alpha_color_hex_to_cairo((ui_theme.get_color("disable_background").get_color(), 0.9)))
            else:
                cr.set_source_rgba(*alpha_color_hex_to_cairo((ui_theme.get_color("combo_entry_background").get_color(), 0.9)))
            cr.rectangle(rect.x, rect.y, rect.width - 1, rect.height - 1)
            cr.fill()

        propagate_expose(widget, event)

        return False

    def expose_event(self, widget, event):
        cr = widget.window.cairo_create()
        rect = widget.allocation
        cr.set_source_rgb(*color_hex_to_cairo(THEME['bg']))
        cr.rectangle(*rect)
        cr.fill()

        if self.changable:
            if widget.state == gtk.STATE_PRELIGHT:
                x_offset = rect.width
            elif widget.state == gtk.STATE_ACTIVE:
                x_offset = rect.width * 2
            elif self.show_state == "active":
                x_offset = rect.width * 2
            else:
                x_offset = 0
            pixbuf = self.image.scale_simple(rect.width * 3,
                                             rect.height,
                                             gtk.gdk.INTERP_BILINEAR)
            pixbuf = pixbuf.subpixbuf(x_offset,
                                      0,
                                      rect.width,
                                      rect.height)
        else:
            pixbuf = self.image.scale_simple(rect.width, rect.height,
                                             gtk.gdk.INTERP_BILINEAR)

        draw_pixbuf(cr, pixbuf, rect.x, rect.y)
        propagate_expose(widget, event)
        return True

    def expose_event(self, widget, event):
        cr = widget.window.cairo_create()
        rect = widget.allocation
        cr.set_source_rgb(*color_hex_to_cairo(THEME['bg']))
        cr.rectangle(0, 0, rect.width, rect.height)
        cr.fill()

        pixbuf = gtk.gdk.pixbuf_new_from_file(self.image)

        image_size = [pixbuf.get_width(),
                      pixbuf.get_height()]
        self.real_size = self.get_real_size(
            [rect.width, rect.height], image_size
        )
        pixbuf = pixbuf.scale_simple(self.real_size[0],
                                     self.real_size[1],
                                     gtk.gdk.INTERP_HYPER)
        pixbuf = pixbuf.rotate_simple(self.rotate_type[self.rotate])

        offset_x = (rect.width - self.real_size[0]) / 2
        offset_y = (rect.height - self.real_size[1]) / 2
        draw_pixbuf(cr, pixbuf, offset_x, offset_y)

        propagate_expose(widget, event)
        return True

    def scrollbar_expose_event(self, widget, event, direction="v"):
        cr = widget.window.cairo_create()
        rect = widget.allocation
        if direction == "v":
            widget.set_size_request(self.bar_width, rect.height)
        else:
            widget.set_size_request(rect.width, self.bar_width)
        cr.set_source_rgb(*color_hex_to_cairo(THEME['bg']))
        cr.rectangle(*rect)
        cr.fill()

        if direction == "v":
            real_height = self._eventBox.allocation.height
            bar_height = rect.height ** 2 / real_height + 2
            _adjustment = widget.get_adjustment()
            offsetY = _adjustment.get_value() * rect.height / real_height
            real_rect = (rect.x - 1, rect.y + offsetY,
                         self.bar_width + 1, bar_height)
        else:
            real_width = self._eventBox.allocation.width
            if self._vscrollbar:
                bar_width = rect.width ** 2 / real_width + rect.height + 2
            else:
                bar_width = rect.width ** 2 / real_width
            _adjustment = widget.get_adjustment()
            offsetX = _adjustment.get_value() * rect.width / real_width
            real_rect = (rect.x + offsetX, rect.y - 1,
                         bar_width, self.bar_width + 1)

        cr.set_source_rgb(*color_hex_to_cairo(THEME['hover']))
        cr.rectangle(*real_rect)
        cr.fill()

        propagate_expose(widget, event)
        return True

 def expose_droplist_item(self, widget, event, item_content):
     '''Expose droplist item.'''
     # Init.
     cr = widget.window.cairo_create()
     rect = widget.allocation
     font_color = ui_theme.get_color("menu_font").get_color()
     
     # Draw select effect.
     if self.subdroplist_active or widget.state in [gtk.STATE_PRELIGHT, gtk.STATE_ACTIVE]:
         # Draw background.
         draw_vlinear(cr, rect.x, rect.y, rect.width, rect.height, 
                      ui_theme.get_shadow_color("menu_item_select").get_color_info())
         
         # Set font color.
         font_color = ui_theme.get_color("menu_select_font").get_color()
         
     # Draw item content.
     draw_text(cr, item_content, 
                 rect.x + self.item_padding_left,
                 rect.y,
                 rect.width,
                 rect.height,
                 self.font_size, font_color,
                 )
     
     # Propagate expose to children.
     propagate_expose(widget, event)
 
     return True

    def on_expose_event(win, e):
        cr = win.swindow.cairo_create()
        cr.set_source_rgba(1, 1, 1, 0)
        cr.set_operator(cairo.OPERATOR_SOURCE)
        cr.paint()
        winfo = TooltipInfo.winfo
        if winfo.has_shadow:

            (x, y, width, height) = (0, 0, win.allocation.width, win.allocation.height)
            (o_x, o_y) = (5, 5)


            #right-bottom corner
            radial = cairo.RadialGradient(width - o_x, height-o_y, 1,  width -o_x, height-o_y, o_x)
            radial.add_color_stop_rgba(0.0, 0,0,0, 0.3)
            radial.add_color_stop_rgba(0.6, 0,0,0, 0.1)
            radial.add_color_stop_rgba(1, 0,0,0, 0)
            cr.set_source(radial)
            cr.rectangle(width-o_x, height-o_y, o_x, o_y)
            cr.fill()

            #left-bottom corner
            radial = cairo.RadialGradient(o_x, height-o_y, 1,  o_x, height-o_y, o_x)
            radial.add_color_stop_rgba(0.0, 0,0,0, 0.3)
            radial.add_color_stop_rgba(0.6, 0,0,0, 0.1)
            radial.add_color_stop_rgba(1, 0,0,0, 0)
            cr.set_source(radial)
            cr.rectangle(0, height-o_y, o_x, o_y)
            cr.fill()

            #left-top corner
            radial = cairo.RadialGradient(width-o_x, o_y, 1, width-o_x, o_y, o_x)
            radial.add_color_stop_rgba(0.0, 0,0,0, 0.3)
            radial.add_color_stop_rgba(0.6, 0,0,0, 0.1)
            radial.add_color_stop_rgba(1, 0,0,0, 0)
            cr.set_source(radial)
            cr.rectangle(width-o_x, 0, o_x, o_y)
            cr.fill()


            vradial = cairo.LinearGradient(0, height-o_y, 0, height)
            vradial.add_color_stop_rgba(0.0, 0,0,0, .5)
            vradial.add_color_stop_rgba(0.4, 0,0,0, 0.25)
            vradial.add_color_stop_rgba(1, 0,0,0, 0.0)
            cr.set_source(vradial)
            cr.rectangle(o_x, height-o_x, width-2*o_x, height)
            cr.fill()

            hradial = cairo.LinearGradient(width-o_x, 0, width, 0)
            hradial.add_color_stop_rgba(0.0, 0,0,0, .5)
            hradial.add_color_stop_rgba(0.4, 0,0,0, 0.25)
            hradial.add_color_stop_rgba(1, 0,0,0, 0.0)
            cr.set_source(hradial)
            cr.rectangle(width-o_x, o_y, width, height-2*o_y)
            cr.fill()

        gtk.Alignment.do_expose_event(TooltipInfo.alignment, e)
        propagate_expose(win, e)
        return True

 def expose_event(self, widget, event):
     cr = widget.window.cairo_create()
     rect = widget.allocation
     with cairo_disable_antialias(cr):
         cr.set_source_rgb(*color_hex_to_cairo(THEME['bg']))
         cr.rectangle(*rect)
         cr.fill()
     propagate_expose(widget, event)
     return True

 def expose_menu_item(self, widget, event):
     '''Expose menu item.'''
     # Init.
     cr = widget.window.cairo_create()
     rect = widget.allocation
     font_color = ui_theme.get_color("menu_font").get_color()
     (item_icons, item_content, item_node) = self.item[0:3]
     
     # Draw select effect.
     if self.submenu_active or widget.state in [gtk.STATE_PRELIGHT, gtk.STATE_ACTIVE]:
         # Draw background.
         draw_vlinear(cr, rect.x, rect.y, rect.width, rect.height, 
                      ui_theme.get_shadow_color("menu_item_select").get_color_info(),
                      MENU_ITEM_RADIUS)
         
         # Set font color.
         font_color = ui_theme.get_color("menu_select_font").get_color()
         
     # Draw item icon.
     pixbuf = None
     pixbuf_width = 0
     if item_icons:
         (item_normal_dpixbuf, item_hover_dpixbuf) = item_icons
         if self.submenu_active or widget.state in [gtk.STATE_PRELIGHT, gtk.STATE_ACTIVE]:
             if item_hover_dpixbuf == None:
                 pixbuf = item_normal_dpixbuf.get_pixbuf()
             else:
                 pixbuf = item_hover_dpixbuf.get_pixbuf()
         else:
             pixbuf = item_normal_dpixbuf.get_pixbuf()
         pixbuf_width += pixbuf.get_width()
         draw_pixbuf(cr, pixbuf, rect.x + self.item_padding_x, rect.y + (rect.height - pixbuf.get_height()) / 2)
         
     # Draw item content.
     draw_text(cr, item_content, 
                 rect.x + self.item_padding_x * 2 + self.icon_width,
                 rect.y,
                 rect.width,
                 rect.height,
                 self.font_size, font_color,
                 )
     
     # Draw submenu arrow.
     if isinstance(item_node, Menu):
         if self.submenu_active or widget.state in [gtk.STATE_PRELIGHT, gtk.STATE_ACTIVE]:
             submenu_pixbuf = ui_theme.get_pixbuf("menu/arrow_hover.png").get_pixbuf()
         else:
             submenu_pixbuf = ui_theme.get_pixbuf("menu/arrow_normal.png").get_pixbuf()
         draw_pixbuf(cr, submenu_pixbuf,
                     rect.x + rect.width - self.item_padding_x - submenu_pixbuf.get_width() - self.arrow_padding_x,
                     rect.y + (rect.height - submenu_pixbuf.get_height()) / 2)
     
     # Propagate expose to children.
     propagate_expose(widget, event)
 
     return True

 def expose_category_item(self, widget, event):
     '''Expose navigate item.'''
     # Init.
     cr = widget.window.cairo_create()
     rect = widget.allocation
     select_index = self.get_index()
     font_color = ui_theme.get_color("category_item").get_color()
     
     # Draw background.
     if widget.state == gtk.STATE_NORMAL:
         if select_index == self.index:
             select_status = BUTTON_PRESS
         else:
             select_status = BUTTON_NORMAL
     elif widget.state == gtk.STATE_PRELIGHT:
         if select_index == self.index:
             select_status = BUTTON_PRESS
         else:
             select_status = BUTTON_HOVER
     elif widget.state == gtk.STATE_ACTIVE:
         select_status = BUTTON_PRESS
         
     if select_status == BUTTON_PRESS:
         draw_vlinear(cr, rect.x, rect.y, rect.width, rect.height, 
                     ui_theme.get_shadow_color("category_item_press").get_color_info())
 
         font_color = ui_theme.get_color("category_select_item").get_color()
     elif select_status == BUTTON_HOVER:
         draw_vlinear(cr, rect.x, rect.y, rect.width, rect.height, 
                     ui_theme.get_shadow_color("category_item_hover").get_color_info())
         
         font_color = ui_theme.get_color("category_select_item").get_color()
         
     # Draw navigate item.
     category_item_pixbuf = self.icon_dpixbuf.get_pixbuf()
     draw_pixbuf(
         cr, category_item_pixbuf, 
         rect.x + self.padding_left,
         rect.y + (rect.height - category_item_pixbuf.get_height()) / 2
         )
     
     # Draw font.
     draw_text(cr, self.content, 
                 rect.x + self.padding_left + self.font_offset,
                 rect.y,
                 rect.width - self.padding_left - self.font_offset - self.padding_right,
                 rect.height,
                 self.font_size, 
                 font_color,
                 )
     
     # Propagate expose to children.
     propagate_expose(widget, event)
 
     return True

    def expose_star_view(self, widget, event):
        # Init.
        cr = widget.window.cairo_create()
        rect = widget.allocation

        self.star_buffer.render(cr, rect)

        # Propagate expose.
        propagate_expose(widget, event)

        return True

 def expose_label(self, widget, event):
     '''Expose label.'''
     cr = widget.window.cairo_create()
     rect = widget.allocation
     
     self.draw_label_background(cr, rect)
     
     self.draw_label_text(cr, rect)
     
     propagate_expose(widget, event)
     
     return True

    def _expose_event(self, widget, event):
        cr = widget.window.cairo_create()
        rect = widget.allocation
        rect.y, rect.x = 0, 0

        cr.set_source_rgba(*alpha_color_hex_to_cairo(
            (self.bg, self.opacity)))
        cr.rectangle(*rect)
        cr.fill()

        propagate_expose(widget, event)
        return True

def expose_linear_background(widget, event, color_infos):
    '''Expose linear background.'''
    # Init.
    cr = widget.window.cairo_create()
    rect = widget.allocation
    
    # Draw linear background.
    draw_vlinear(cr, rect.x, rect.y, rect.width, rect.height, color_infos)
    
    # Propagate expose.
    propagate_expose(widget, event)
    
    return True

    def loading_flag(self, widget, event):
        cr = widget.window.cairo_create()
        rect = widget.allocation
        cr.set_source_rgb(*color_hex_to_cairo(THEME['bg']))
        cr.rectangle(0, 0, rect.width, rect.height)
        cr.fill()

        draw_text(cr,
                  rect.x,
                  rect.y,
                  text_size=20,
                  text_color=THEME['font_color'])
        propagate_expose(widget, event)

    def expose_event(self, widget, event):
        cr = widget.window.cairo_create()
        rect = widget.allocation

        size = min(rect. width, rect.height)

        pixbuf = self.image.scale_simple(size, size,
                                         gtk.gdk.INTERP_BILINEAR)
        draw_pixbuf(cr, pixbuf,
                    rect.x + (rect.width - size) / 2,
                    rect.y + (rect.height - size) / 2)
        propagate_expose(widget, event)
        return True

 def expose_nav_item(self, widget, event):
     '''Expose navigate item.'''
     # Init.
     cr = widget.window.cairo_create()
     rect = widget.allocation
     select_index = self.get_index()
     hover_pixbuf = ui_theme.get_pixbuf("navigatebar/nav_item_hover.png").get_pixbuf()
     press_pixbuf = ui_theme.get_pixbuf("navigatebar/nav_item_press.png").get_pixbuf()
     
     # Draw background.
     if widget.state == gtk.STATE_NORMAL:
         if select_index == self.index:
             select_pixbuf = press_pixbuf
         else:
             select_pixbuf = None
     elif widget.state == gtk.STATE_PRELIGHT:
         if select_index == self.index:
             select_pixbuf = press_pixbuf
         else:
             select_pixbuf = hover_pixbuf
     elif widget.state == gtk.STATE_ACTIVE:
         select_pixbuf = press_pixbuf
         
     if select_pixbuf:
         draw_pixbuf(cr, select_pixbuf, rect.x, rect.y)
     
     # Draw navigate item.
     nav_item_pixbuf = self.icon_dpixbuf.get_pixbuf()
     draw_pixbuf(
         cr, nav_item_pixbuf, 
         rect.x + (rect.width - nav_item_pixbuf.get_width()) / 2,
         rect.y)
     
     # Draw font.
     draw_text(cr, 
               self.content, 
               rect.x, 
               rect.y + nav_item_pixbuf.get_height() - 3, 
               rect.width, 
               rect.height - nav_item_pixbuf.get_height(),
               text_color="#FFFFFF",
               alignment=pango.ALIGN_CENTER,
               gaussian_radious=2, gaussian_color="#000000",
               border_radious=1, border_color="#000000", 
               )
     
     # Propagate expose to children.
     propagate_expose(widget, event)
 
     return True

    def image_button_expose_event(self, widget, event):
        cr = widget.window.cairo_create()
        rect = widget.allocation
        if widget.state == gtk.STATE_NORMAL:
            image = self.normal_image_pixbuf
        elif widget.state == gtk.STATE_PRELIGHT:
            image = self.hover_image_pixbuf
        elif widget.state == gtk.STATE_ACTIVE:
            image = self.press_image_pixbuf

        draw_pixbuf(cr, image, rect.x, rect.y)

        propagate_expose(widget, event)
        return True

 def expose_progressbar(self, widget, event):
     '''
     Internal callback for `expose` signal.
     '''
     # Init.
     cr = widget.window.cairo_create()
     rect = widget.allocation
     
     self.progress_buffer.render(cr, rect)
            
     # Propagate expose.
     propagate_expose(widget, event)
     
     return True