Merge lp:~skokec/dockbar/win7ish-feel into lp:dockbar

[skokec]

Added some options that mimic some of the behavior of win7 taskbar.

Unmerged revisions

234. By Domen Tabernik on 2010-07-05

Merged new options for more win7 feel.

=== modified file 'dbx_preference.py'
--- dbx_preference.py	2010-06-21 04:19:21 +0000
+++ dbx_preference.py	2010-07-05 16:50:40 +0000
@@ -1,4 +1,4 @@
-#!/usr/bin/python
+#!/usr/bin/python2.6
 
 #   dbx_preference.py
 #
@@ -274,6 +274,24 @@
             table.attach(label, 0, 1, row, row + 1, xpadding = 5)
             table.attach(self.wb_combos[text], 1, 2, row, row + 1 )
 
+
+        self.gb_close_popup_on_click_checkbutton_names = ['windowbutton_close_popup_on_left_click',
+                            'windowbutton_close_popup_on_shift_and_left_click',
+                            'windowbutton_close_popup_on_middle_click',
+                            'windowbutton_close_popup_on_shift_and_middle_click',
+                            'windowbutton_close_popup_on_right_click',
+                            'windowbutton_close_popup_on_shift_and_right_click',
+                            'windowbutton_close_popup_on_scroll_up',
+                            'windowbutton_close_popup_on_scroll_down']
+        self.gb_close_popup_on_click_checkbutton = {}
+        
+        for i in range(len(self.gb_close_popup_on_click_checkbutton_names)):
+            name = self.gb_close_popup_on_click_checkbutton_names[i]
+            self.gb_close_popup_on_click_checkbutton[name] = gtk.CheckButton('Close popup on click')
+
+            self.gb_close_popup_on_click_checkbutton[name].connect('toggled', self.checkbutton_toggled, name)
+            table.attach(self.gb_close_popup_on_click_checkbutton[name], 2, 3, i, i + 1, xpadding = 5 )
+
         hbox.pack_start(table, False)
         frame.add(hbox)
         windowbutton_box.pack_start(frame, False, padding=5)
@@ -385,6 +403,11 @@
                                  'no_popup_for_one_window')
         popup_box.pack_start(self.no_popup_cb, False, padding=5)
         
+        self.close_popup_on_click_cb = gtk.CheckButton('Close popup on any mouse click outside of focus (instead of when out of focus)')
+        self.close_popup_on_click_cb.connect('toggled', self.checkbutton_toggled, 'close_popup_on_click')
+        popup_box.pack_start(self.close_popup_on_click_cb, False, padding=5)
+        
+        
         # Alignment
         vbox = gtk.VBox()
         label1 = gtk.Label("<b><big>%s</big></b>"%_("Alignment"))
@@ -417,6 +440,17 @@
         spinbox.pack_start(spinlabel, False)
         spinbox.pack_start(self.delay_spin, False, padding=5)
         vbox.pack_start(spinbox, False)
+        
+        spinbox = gtk.HBox()
+        spinlabel = gtk.Label("Second delay when already opened by first delay:")
+        spinlabel.set_alignment(0,0.5)
+        adj = gtk.Adjustment(0, 0, 2000, 1, 50)
+        self.delay_second_spin = gtk.SpinButton(adj, 0.5, 0)
+        adj.connect("value_changed", self.adjustment_changed, 'popup_delay_second')
+        spinbox.pack_start(spinlabel, False)
+        spinbox.pack_start(self.delay_second_spin, False, padding=5)
+        vbox.pack_start(spinbox, False)
+        
         popup_box.pack_start(vbox, False, padding=5)
         
         # Previews
@@ -440,7 +474,23 @@
         vbox.pack_start(spinbox, False)
         popup_box.pack_start(vbox, False, padding=5)
         
-        
+        # On group button action
+        vbox = gtk.VBox()
+        label2 = gtk.Label("<b>When group button is executed action:</b>")
+        label2.set_alignment(0,0.5)
+        label2.set_use_markup(True)
+        vbox.pack_start(label2,False)
+        
+        self.disable_popup_on_gbbutton_click_cb = gtk.CheckButton('Disable popup delay if popup not opened')
+        self.disable_popup_on_gbbutton_click_cb.connect('toggled', self.checkbutton_toggled, 'disable_popup_on_groupbutton_click')
+        vbox.pack_start(self.disable_popup_on_gbbutton_click_cb, False)
+        
+        self.close_popup_on_gbbutton_click_cb = gtk.CheckButton('Close popup if popup is opened (ignored on "show popup" action)')
+        self.close_popup_on_gbbutton_click_cb.connect('toggled', self.checkbutton_toggled, 'close_popup_on_groupbutton_click')
+        vbox.pack_start(self.close_popup_on_gbbutton_click_cb, False)
+        
+        popup_box.pack_start(vbox, False, padding=5)
+    
         #--- Groupbutton page        
         frame = gtk.Frame(_("Groupbutton actions"))
         frame.set_border_width(5)
@@ -759,8 +809,11 @@
 
         # Popup
         self.delay_spin.set_value(self.globals.settings['popup_delay'])
-        self.no_popup_cb.set_active(
-                            self.globals.settings['no_popup_for_one_window'])
+        self.delay_second_spin.set_value(self.globals.settings['popup_delay_second'])
+        self.no_popup_cb.set_active(self.globals.settings['no_popup_for_one_window'])
+        self.close_popup_on_click_cb.set_active(self.globals.settings['close_popup_on_click'])
+        self.disable_popup_on_gbbutton_click_cb.set_active(self.globals.settings['disable_popup_on_groupbutton_click'])
+        self.close_popup_on_gbbutton_click_cb.set_active(self.globals.settings['close_popup_on_groupbutton_click'])
 
         # Group button keys
         for cb_name, setting_name in self.gb_labels_and_settings.items():
@@ -783,8 +836,10 @@
                     break
 
         for name in self.gb_doubleclick_checkbutton_names:
-            self.gb_doubleclick_checkbutton[name].set_active(
-                                                self.globals.settings[name])
+            self.gb_doubleclick_checkbutton[name].set_active(self.globals.settings[name])
+
+        for name in self.gb_close_popup_on_click_checkbutton_names:
+            self.gb_close_popup_on_click_checkbutton[name].set_active(self.globals.settings[name])
 
         # Opacify
         self.opacify_cb.set_active(self.globals.settings['opacify'])
 
=== modified file 'dockbarx/__init__.py' (properties changed: -x to +x)
=== modified file 'dockbarx/cairowidgets.py' (properties changed: -x to +x)
--- dockbarx/cairowidgets.py	2010-05-25 15:06:34 +0000
+++ dockbarx/cairowidgets.py	2010-07-05 16:50:40 +0000
@@ -209,4 +209,3 @@
         ctx.set_source_rgba(0.0, 0.0, 0.0, alpha)
         ctx.set_line_width(1)
         ctx.stroke()
-
 
=== modified file 'dockbarx/common.py' (properties changed: -x to +x)
--- dockbarx/common.py	2010-06-29 16:11:43 +0000
+++ dockbarx/common.py	2010-07-05 16:50:40 +0000
@@ -140,6 +140,7 @@
             return False
 
 
+
 class Globals(gobject.GObject):
     """ Globals is a signletron containing all the "global" variables of dockbarx.
 
@@ -156,38 +157,37 @@
         'gkey-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,())
     }
 
-    DEFAULT_SETTINGS = {
-                          "theme": "default",
+    DEFAULT_SETTINGS = {  "theme": "default",
                           "groupbutton_attention_notification_type": "red",
                           "workspace_behavior": "switch",
                           "popup_delay": 250,
+                          "popup_delay_second": 30,
+                          "close_popup_on_click": False,
+                          "disable_popup_on_groupbutton_click":False,
+                          "close_popup_on_groupbutton_click":False,
                           "popup_align": "center",
                           "no_popup_for_one_window": False,
                           "show_only_current_desktop": False,
                           "preview": False,
+                          "remember_previews": False,
                           "preview_size": 230,
-
+    
                           "select_one_window": "select or minimize window",
                           "select_multiple_windows": "select all",
-
+    
                           "opacify": False,
                           "opacify_group": False,
                           "opacify_alpha": 11,
-
+    
                           "separate_wine_apps": True,
                           "separate_ooo_apps": True,
-
-                          "groupbutton_left_click_action": \
-                                                "select or minimize group",
-                          "groupbutton_shift_and_left_click_action": \
-                                                "launch application",
-                          "groupbutton_middle_click_action": \
-                                                "close all windows",
-                          "groupbutton_shift_and_middle_click_action": \
-                                                "no action",
+    
+                          "groupbutton_left_click_action":"select or minimize group",
+                          "groupbutton_shift_and_left_click_action":"launch application",
+                          "groupbutton_middle_click_action":"close all windows",
+                          "groupbutton_shift_and_middle_click_action": "no action",
                           "groupbutton_right_click_action": "show menu",
-                          "groupbutton_shift_and_right_click_action": \
-                                                "no action",
+                          "groupbutton_shift_and_right_click_action": "no action",
                           "groupbutton_scroll_up": "select next window",
                           "groupbutton_scroll_down": "select previous window",
                           "groupbutton_left_click_double": False,
@@ -196,19 +196,22 @@
                           "groupbutton_shift_and_middle_click_double": False,
                           "groupbutton_right_click_double": False,
                           "groupbutton_shift_and_right_click_double": False,
-                          "windowbutton_left_click_action": \
-                                                "select or minimize window",
-                          "windowbutton_shift_and_left_click_action": \
-                                                "no action",
-                          "windowbutton_middle_click_action": \
-                                                "close window",
-                          "windowbutton_shift_and_middle_click_action": \
-                                                "no action",
+                          "windowbutton_left_click_action":"select or minimize window",
+                          "windowbutton_shift_and_left_click_action":"no action",
+                          "windowbutton_middle_click_action":"close window",
+                          "windowbutton_shift_and_middle_click_action": "no action",
                           "windowbutton_right_click_action": "show menu",
-                          "windowbutton_shift_and_right_click_action": \
-                                                "no action",
+                          "windowbutton_shift_and_right_click_action": "no action",
                           "windowbutton_scroll_up": "shade window",
                           "windowbutton_scroll_down": "unshade window",
+                          "windowbutton_close_popup_on_left_click": False,
+                          "windowbutton_close_popup_on_shift_and_left_click": False,
+                          "windowbutton_close_popup_on_middle_click": False,
+                          "windowbutton_close_popup_on_shift_and_middle_click": False,
+                          "windowbutton_close_popup_on_right_click": False,
+                          "windowbutton_close_popup_on_shift_and_right_click": False,
+                          "windowbutton_close_popup_on_scroll_up": False,
+                          "windowbutton_close_popup_on_scroll_down": False,
 
                           "gkeys_select_next_group": False,
                           "gkeys_select_next_group_keystr": '<super>Tab',
@@ -257,6 +260,8 @@
             self.orient = 'h'
             self.apps_by_id = {}
             self.theme_name = None
+            # link to current popup being shown
+            self.popup_showing = None
 
             # Get gconf settings
             self.settings = self.DEFAULT_SETTINGS.copy()
 
=== modified file 'dockbarx/dockbar.py' (properties changed: -x to +x)
--- dockbarx/dockbar.py	2010-07-03 14:15:35 +0000
+++ dockbarx/dockbar.py	2010-07-05 16:50:40 +0000
@@ -257,7 +257,7 @@
         self.windows = None
         self.container = None
         self.theme = None
-
+        self.popup_showing = None
         self.gkeys = {
                         'gkeys_select_next_group': None,
                         'gkeys_select_previous_group': None,
@@ -453,9 +453,8 @@
 
 
     def reset_all_surfaces(self):
-        # Removes all saved pixbufs with active glow in groupbuttons
-        # iconfactories. Use this def when the looks of active glow
-        # has been changed.
+        # Removes all saved pixbufs with active glow in groupbuttons iconfactories.
+        # Use this def when the looks of active glow has been changed.
         for group in self.groups.get_groups():
             group.icon_factory.reset_surfaces()
 
@@ -475,6 +474,9 @@
 
     #### Applet events
     def on_ppm_pref(self,event=None,data=None):
+        # close any popup list before
+        if self.popup_showing is not None:
+            self.popup_showing.hide_list()
         # Starts the preference dialog
         os.spawnlp(os.P_NOWAIT,'/usr/bin/dbx_preference.py',
                     '/usr/bin/dbx_preference.py')
@@ -1013,8 +1015,7 @@
         entry = combobox.get_child()
         if identifier:
             entry.set_text(identifier)
-        # Fill the popdown list with the names of all class
-        # names of buttons that hasn't got a launcher already
+        # Fill the popdown list with the names of all class names of buttons that hasn't got a launcher already
         for name in self.groups.get_non_launcher_names():
             combobox.append_text(name)
         entry = combobox.get_child()
@@ -1211,4 +1212,4 @@
                 gr.action_select_next_with_popup(previous=previous)
 
     def gkey_select_previous_window_in_group(self):
-        self.gkey_select_next_window_in_group(previous=True)
 \ No newline at end of file
+        self.gkey_select_next_window_in_group(previous=True)
 
=== modified file 'dockbarx/groupbutton.py' (properties changed: -x to +x)
--- dockbarx/groupbutton.py	2010-06-22 11:05:20 +0000
+++ dockbarx/groupbutton.py	2010-07-05 16:50:40 +0000
@@ -112,12 +112,14 @@
             uri = uri.replace("%20","\ ")
             uri = unquote(uri)
             self.execute("%s %s"%(self.desktop_entry.getExec(), uri))
-
+            exe = exe[:exe.rfind('.')]
+        return exe
 
     def launch(self):
         os.chdir(os.path.expanduser('~'))
         if self.app:
             print "Executing", self.app.get_name()
+
             return self.app.launch(None, None)
         else:
             print 'Executing %s'%self.desktop_entry.getExec()
@@ -187,7 +189,6 @@
                 "Can't initiate Group button without identifier or launcher."
 
 
-
         # Variables
         self.windows = {}
         self.minimized_windows_count = 0
@@ -205,7 +206,7 @@
         # Compiz sends out false mouse enter messages after button is pressed.
         # This works around that bug.
         self.button_pressed = False
-
+        self.button_pressed_left = False
         self.screen = wnck.screen_get_default()
         self.root_xid = int(gtk.gdk.screen_get_default().get_root_window().xid)
 
@@ -219,13 +220,11 @@
 
 
         # Button events
-        self.button.connect("enter-notify-event", self.on_button_mouse_enter)
-        self.button.connect("leave-notify-event", self.on_button_mouse_leave)
-        self.button.connect("button-release-event",
-                            self.on_group_button_release_event)
-        self.button.connect("button-press-event",
-                            self.on_group_button_press_event)
-        self.button.connect("scroll-event", self.on_group_button_scroll_event)
+        self.button.connect("enter-notify-event",self.on_button_mouse_enter)
+        self.button.connect("leave-notify-event",self.on_button_mouse_leave)
+        self.button.connect("button-release-event",self.on_group_button_release_event)
+        self.button.connect("button-press-event",self.on_group_button_press_event)
+        self.button.connect("scroll-event",self.on_group_button_scroll_event)
         self.button.connect("size-allocate", self.on_sizealloc)
         self.button_old_alloc = self.button.get_allocation()
 
@@ -251,6 +250,16 @@
         self.winlist = None
         self.on_show_previews_changed()
 
+
+        self.popup = cairo_popup.window
+        self.popup_showing = False
+        self.popup_showing_by_delay = False
+        self.popup_just_closed_by_group_button = False
+        self.popup_delay_request_id = None
+        self.disable_popup_delay = False
+        self.delay_hide_list_request_id = None
+        self.delay_hide_list_done = False
+        self.popup.connect("leave-notify-event",self.on_popup_mouse_leave)
         self.popup.add(self.popup_box)
 
 
@@ -322,7 +331,7 @@
         return False
 
     #### State
-    def update_popup_label(self, arg=None):
+    def update_popup_label(self):
         self.popup_label.set_text(
                     "<span foreground='%s'>"%self.globals.colors['color2'] + \
                     "<big><b>%s</b></big></span>"%self.name
@@ -369,15 +378,13 @@
         else:
             icon_effect = 0
 
-        if self.mouse_over:
-            mouse_over = IconFactory.MOUSE_OVER
-        elif self.button_drag_entered and not self.launcher_drag:
-            # Mouse over effect on other drag and drop
-            # than launcher dnd.
+        if self.button_pressed_left is True:
+            mouse_over = IconFactory.MOUSE_BUTTON_DOWN
+        elif self.mouse_over:
             mouse_over = IconFactory.MOUSE_OVER
         else:
             mouse_over = 0
-
+        
         if self.launch_effect:
             launch_effect = IconFactory.LAUNCH_EFFECT
         else:
@@ -702,19 +709,27 @@
         
 
     #### Show/hide list
-    def show_list_request(self):
+    def show_list_request(self, request_by_popup_delay = False):
+        # ignore request if just closed popup
+        #if self.popup_just_closed_by_group_button is True:
+        if self.disable_popup_delay is True:
+            return False
         # If mouse cursor is over the button, show popup window.
         b_m_x,b_m_y = self.button.get_pointer()
         b_r = self.button.get_allocation()
-        if self.popup_showing \
-        or ((b_m_x>=0 and b_m_x<b_r.width) \
-        and (b_m_y >= 0 and b_m_y < b_r.height) \
-        and not self.globals.right_menu_showing \
-        and not self.globals.dragging):
-            self.show_list()
+        if self.popup_showing is False and ((b_m_x>=0 and b_m_x<b_r.width) and (b_m_y >= 0 and b_m_y < b_r.height) \
+           and not self.globals.right_menu_showing and not self.globals.dragging):
+            self.show_list(request_by_popup_delay)
         return False
 
-    def show_list(self):
+    def show_list(self, request_by_popup_delay = False):
+        # set what kind of request we have
+        # tist must even if popup already showing so that it will be known what is last request
+        self.popup_showing_by_delay = request_by_popup_delay
+        # no need to do anything if alreay showing popup
+        if self.popup_showing is True:
+            return
+                
         # Move popup to it's right spot and show it.
         offset = 3
 
@@ -780,10 +795,17 @@
                 self.popup.move(x - w - offset,y)
             else:
                 self.popup.move(x + b_alloc.width + offset,y)
+
         self.popup.show()
         self.popup_showing = True
-        self.on_set_icongeo_win()
-        # The popup must be shown before the
+        self.delay_hide_list_done = False
+        
+        # close any others current popups
+        if self.globals.popup_showing is not None:
+            self.globals.popup_showing.hide_list()
+        # and define this one as current popup 
+        self.globals.popup_showing = self
+        self.on_set_icongeo_win() 
         # preview can be set. Iterate gtk events.
         while gtk.events_pending():
                 gtk.main_iteration(False)
@@ -811,73 +833,151 @@
                                           previews)
         return False
 
-    def hide_list_request(self):
-        if self.popup.window == None:
-            return
-        # Checks if mouse cursor really isn't hovering the button
-        # or the popup window anymore and hide the popup window
-        # if so.
-        p_m_x,p_m_y = self.popup.get_pointer()
-        p_w,p_h = self.popup.get_size()
-        b_m_x,b_m_y = self.button.get_pointer()
-        b_r = self.button.get_allocation()
-        r = 6 #radius for the rounded corner of popup window
-
-        # Make sure that the popup list isn't closed when
-        # howering the gap between button and list.
-        w,h = self.popup.get_size()
-        p_x,p_y = self.popup.window.get_origin()
-        offset = 3
-        b_x,b_y = self.button.window.get_origin()
-        if self.globals.orient == 'h' \
-        and b_m_x >= -8 and b_m_x <= (b_r.width+7):
-            if (p_y < b_y and b_m_y >= -offset and b_m_y <= 0) \
-            or (p_y > b_y and b_m_y >= (b_r.height - 1) \
-            and b_m_y <= (b_r.height - 1 + offset)):
-                gobject.timeout_add(50, self.hide_list_request)
-                return
-        elif self.globals.orient == 'v' \
-        and b_m_y >= -8 and b_m_y <= (b_r.height+7):
-            if (p_x < b_x and b_m_x >= -offset and b_m_x <= 0) \
-            or (p_x > b_x and b_m_x >= (b_r.width - 1) \
-            and b_m_x <= (b_r.width - 1 + offset)):
-                gobject.timeout_add(50, self.hide_list_request)
-                return
-
-        if p_m_x >= 0 and p_m_x < p_w \
-        and p_m_y >= 0 and p_m_y < p_h:
-            # Mouse pointer is inside the "rectangle"
-            # but check if it's still outside the rounded corners
-            x = None
-            y = None
-            if p_m_x < r:
-                x = r - p_m_x
-            if (p_w - p_m_x) < r:
-                x = p_m_x - (p_w - r)
-            if p_m_y < r:
-                y = r - p_m_y
-            if (p_h - p_m_y) < r:
-                y = p_m_y - (p_h - r)
-            if x == None or y == None \
-            or (x**2 + y**2) < (r-1)**2:
-                # It's inside the rounded corners!
-                return
-        if b_m_x >= 0 and b_m_x < b_r.width \
-        and b_m_y >= 0 and b_m_y < b_r.height:
-            # Mouse pointer is over the group button.
-            gobject.timeout_add(50, self.hide_list_request)
-            # This timeout add is needed if mouse cursor leaves the
-            # screen following the screen edge.
-            return
+    def delay_hide_list_request(self):
+        # remove hide_list_request id if was called by timeout  
+        self.delay_hide_list_request_id = None
+        self.delay_hide_list_done = True
+        
+
+    def hide_list_request(self):        
+        
+        # verify that popup window is present and is showing else dont have to do anything
+        if self.popup.window == None or self.popup_showing is False:
+            return
+        
+
+        # verify validity of request based on close_popup_on_click settings
+        if self.globals.settings['close_popup_on_click'] is not True: 
+            # Checks if mouse cursor really isn't hovering the button
+            # or the popup window anymore and hide the popup window
+            # if so.
+            p_m_x,p_m_y = self.popup.get_pointer()
+            p_w,p_h = self.popup.get_size()
+            b_m_x,b_m_y = self.button.get_pointer()
+            b_r = self.button.get_allocation()
+            r = 5 #radius for the rounded corner of popup window
+    
+            # Make sure that the popup list isn't closed when
+            # howering the gap between button and list.
+            w,h = self.popup.get_size()
+            p_x,p_y = self.popup.window.get_origin()
+            offset = 3
+            b_x,b_y = self.button.window.get_origin()
+            if self.globals.orient == 'h' and b_m_x>=0 and b_m_x<=(b_r.width-1):
+                if (p_y < b_y and b_m_y>=-offset and b_m_y<=0) \
+                or (p_y > b_y and b_m_y>=(b_r.height-1) and b_m_y<=(b_r.height-1+offset)):
+                    gobject.timeout_add(50, self.hide_list_request) # org value was 50
+                    return
+            elif self.globals.orient == 'v' and b_m_y>=0 and b_m_y<=(b_r.height-1):
+                if (p_x < b_x and b_m_x>=-offset and b_m_x<=0) \
+                or (p_x > b_x and b_m_x>=(b_r.width-1) and b_m_x<=(b_r.width-1+offset)):
+                    gobject.timeout_add(50, self.hide_list_request) # org value was 50
+                    return
+    
+            if not ((p_m_x<0 or p_m_x>(p_w-1))or(p_m_y<0 or p_m_y>(p_h-1))):
+                # Mouse pointer is inside the "rectangle"
+                # but check if it's still outside the rounded corners
+                x = None
+                y = None
+                if p_m_x < r:
+                    x = r - p_m_x
+                if (p_w - p_m_x) < r:
+                    x = p_m_x - (p_w - r)
+                if p_m_y < r:
+                    y = r - p_m_y
+                if (p_h - p_m_y) < r:
+                    y = p_m_y - (p_h - r)
+                if x == None or y == None \
+                or (x**2 + y**2) < (r-1)**2:
+                    # It's inside the rounded corners!
+                    return
+            if not ((b_m_x<0 or b_m_x>(b_r.width-1)) or (b_m_y<0 or b_m_y>(b_r.height-1))):
+                # Mouse pointer is over the group button.
+                gobject.timeout_add(50, self.hide_list_request) # org value was 50
+                # This timeout add is needed if mouse cursor leaves the
+                # screen following the screen edge.
+                return
+        else:
+            # if closing popup on mouse click
+            # then get all global click (desktop global) by getting pointer position and mask            
+            display = gtk.gdk.display_get_default()
+            pos = display.get_pointer()
+            # if button modifiers are clicked then check if should realy close popup
+            if pos[3] == gtk.gdk.BUTTON1_MASK or pos[3] == gtk.gdk.BUTTON2_MASK \
+                or pos[3] == gtk.gdk.BUTTON3_MASK or pos[3] == gtk.gdk.BUTTON4_MASK \
+                or pos[3] == gtk.gdk.BUTTON5_MASK or (self.popup_showing_by_delay is True and self.delay_hide_list_done is True):
+                # close popup only if mouse position is not on list or on group button
+                p_m_x,p_m_y = self.popup.get_pointer()
+                p_w,p_h = self.popup.get_size()
+                b_m_x,b_m_y = self.button.get_pointer()
+                b_r = self.button.get_allocation()
+                r = 5 #radius for the rounded corner of popup window
+        
+                # Make sure that the popup list isn't closed when
+                # howering the gap between button and list.
+                w,h = self.popup.get_size()
+                p_x,p_y = self.popup.window.get_origin()
+                offset = 3
+                b_x,b_y = self.button.window.get_origin()
+                if self.globals.orient == 'h' and b_m_x>=0 and b_m_x<=(b_r.width-1):
+                    if (p_y < b_y and b_m_y>=-offset and b_m_y<=0) \
+                    or (p_y > b_y and b_m_y>=(b_r.height-1) and b_m_y<=(b_r.height-1+offset)):
+                        ##gobject.timeout_add(10, self.hide_list_request)
+                        #print "waiting for new on click ..."
+                        return
+                elif self.globals.orient == 'v' and b_m_y>=0 and b_m_y<=(b_r.height-1):
+                    if (p_x < b_x and b_m_x>=-offset and b_m_x<=0) \
+                    or (p_x > b_x and b_m_x>=(b_r.width-1) and b_m_x<=(b_r.width-1+offset)):
+                        ##gobject.timeout_add(10, self.hide_list_request)
+                        #print "waiting for new on click ..."
+                        return
+        
+                if not ((p_m_x<0 or p_m_x>(p_w-1))or(p_m_y<0 or p_m_y>(p_h-1))):
+                    # Mouse pointer is inside the "rectangle"
+                    # but check if it's still outside the rounded corners
+                    x = None
+                    y = None
+                    if p_m_x < r:
+                        x = r - p_m_x
+                    if (p_w - p_m_x) < r:
+                        x = p_m_x - (p_w - r)
+                    if p_m_y < r:
+                        y = r - p_m_y
+                    if (p_h - p_m_y) < r:
+                        y = p_m_y - (p_h - r)
+                    if x == None or y == None \
+                    or (x**2 + y**2) < (r-1)**2:
+                        # It's inside the rounded corners!
+                        return
+                if not ((b_m_x<0 or b_m_x>(b_r.width-1)) or (b_m_y<0 or b_m_y>(b_r.height-1))):
+                    # click inside of group button - just ignore this request
+                    # new request will be made when mouse leaves group button so 
+                    # there is no need to call timout
+                    ##gobject.timeout_add(10, self.hide_list_request)
+                    return
+            else:
+                # no click yet - continute waiting
+                gobject.timeout_add(10, self.hide_list_request)
+                #print "waiting for click ", self.global_click_id, " ..."
+                return
+        
         self.hide_list()
         return
 
     def hide_list(self):
+        print "request to close popup"
         self.popup.hide()
         self.popup_showing = False
+        self.popup_showing_by_delay = False
+        self.globals.popup_showing = None
+        self.delay_hide_list_done = False
+        
+        if self.mouse_over is True:        
+            self.disable_popup_delay = True
+            
         self.on_set_icongeo_grp()
         if self.globals.settings["preview"]:
-            # Remove preview icon to save memory
+            # Remove previews to save memory.
             for win in self.get_windows():
                 self.windows[win].clear_preview_image()
             gc.collect()
@@ -950,16 +1050,12 @@
         if self.globals.opacity_values == None:
             return False
         try:
-            compiz_call('obs/screen0/opacity_values','set', 
-                        self.globals.opacity_values)
-            compiz_call('obs/screen0/opacity_matches','set', 
-                        self.globals.opacity_matches)
+            compiz_call('obs/screen0/opacity_values','set', self.globals.opacity_values)
+            compiz_call('obs/screen0/opacity_matches','set', self.globals.opacity_matches)
         except:
             try:
-                compiz_call('core/screen0/opacity_values','set', 
-                            self.globals.opacity_values)
-                compiz_call('core/screen0/opacity_matches','set', 
-                            self.globals.opacity_matches)
+                compiz_call('core/screen0/opacity_values','set', self.globals.opacity_values)
+                compiz_call('core/screen0/opacity_matches','set', self.globals.opacity_matches)
             except:
                 print "Error: Couldn't set opacity back to normal."
         self.globals.opacity_values = None
@@ -1131,8 +1227,7 @@
             self.on_set_icongeo_grp()
 
     def on_button_mouse_enter (self, widget, event):
-        # In compiz there is a enter and a leave event 
-        # before a button_press event.
+        # In compiz there is a enter and a leave event before a button_press event.
         if self.button_pressed :
             return
         self.mouse_over = True
@@ -1152,69 +1247,123 @@
         if self.globals.settings["popup_delay"]>0:
             self.on_set_icongeo_delay()
         if not self.globals.right_menu_showing and not self.globals.dragging:
-            gobject.timeout_add(self.globals.settings['popup_delay'], 
-                                self.show_list_request)
+            # if already showing some other popup then make request only if showing by group button delay
+            if self.globals.popup_showing is not None and self.globals.popup_showing.popup_showing_by_delay is True:
+                #make request with lower delay
+                gobject.timeout_add(self.globals.settings['popup_delay_second'], self.show_list_request, True)
+            elif self.globals.popup_showing is None:
+                gobject.timeout_add(self.globals.settings['popup_delay'], self.show_list_request, True)
 
     def on_button_mouse_leave (self, widget, event):
-        # In compiz there is a enter and 
-        # a leave event before a button_press event.
+        # In compiz there is a enter and a leave event before a button_press event.
         self.button_pressed = False
         self.mouse_over = False
+        self.disable_popup_delay = False
+        
         self.update_state()
-        self.hide_list_request()
+        if self.popup_showing is True:
+            # also remove and previous hide_list_request's so that timout will be correct 
+            if self.delay_hide_list_request_id is not None:
+                gobject.source_remove(self.delay_hide_list_request_id)
+            
+            # clear delay hide_list request flag    
+            self.delay_hide_list_done = False
+            
+            # request for popup list to hide
+            # if closing popup on click then should delay request
+            if self.popup_showing_by_delay is True and self.globals.settings['close_popup_on_click']:
+                 
+                # make request
+                request_timeout = 600 
+                self.delay_hide_list_request_id = gobject.timeout_add(request_timeout,self.delay_hide_list_request)
+            
+            self.hide_list_request()
+                
+        elif self.popup_delay_request_id is not None:
+            gobject.source_remove(self.popup_delay_request_id)
+            self.popup_delay_request_id = None 
         if self.popup.window == None:
             # self.hide_list takes care of 'set-icongeo-grp' normally
             # but if no popup window exist its taken care of here.
             self.on_set_icongeo_grp()
-        if self.globals.settings["opacify"] \
-        and self.globals.settings["opacify_group"]:
+        if self.globals.settings["opacify"] and self.globals.settings["opacify_group"]:
             self.deopacify_request()
 
     def on_popup_mouse_leave (self,widget,event):
+        # request for popup list to hide
+        
+        # remove any previous hide_list_request's o that timout will be correct
+        if self.delay_hide_list_request_id is not None:
+            gobject.source_remove(self.delay_hide_list_request_id)
+        
+        # clear delay hide_list request flag    
+        self.delay_hide_list_done = False
+        
+        # if closing popup on click then should delay request
+        if self.popup_showing_by_delay is True and self.globals.settings['close_popup_on_click']:
+            # make request
+            request_timeout = 600
+            self.delay_hide_list_request_id = gobject.timeout_add(request_timeout,self.delay_hide_list_request)
+
         self.hide_list_request()
+        return
 
     def on_group_button_scroll_event (self,widget,event):
+        disable_popup = True
         if event.direction == gtk.gdk.SCROLL_UP:
             action = self.globals.settings['groupbutton_scroll_up']
             self.action_function_dict[action](self, widget, event)
         elif event.direction == gtk.gdk.SCROLL_DOWN:
             action = self.globals.settings['groupbutton_scroll_down']
             self.action_function_dict[action](self, widget, event)
+        else:
+            disable_popup = False
+            
+        # disbale popup list to be shown by delay when mouse clicked and action executed
+        if self.globals.settings['disable_popup_on_groupbutton_click'] is True:
+            self.disable_popup_delay = disable_popup;
 
     def on_group_button_release_event(self, widget, event):
+        disable_popup = True
+        self.button_pressed = False
+        self.button_pressed_left = False 
+        self.update_state()
+
         # Check that the mouse still is over the group button.
         b_m_x,b_m_y = self.button.get_pointer()
         b_r = self.button.get_allocation()
         if b_m_x < 0 or b_m_x >= b_r.width or b_m_y < 0 or b_m_y >= b_r.height:
             return
-
         # If a drag and drop just finnished set self.draggin to false
         # so that left clicking works normally again
         if event.button == 1 and self.globals.dragging:
             self.globals.dragging = False
             return
+       
 
-        if not event.button in (1, 2, 3):
-            return
-        button = {1:'left', 2: 'middle', 3: 'right'}[event.button]
-        if event.state & gtk.gdk.SHIFT_MASK:
-            mod = 'shift_and_'
+        if event.button in (1, 2, 3):
+            button = {1:'left', 2: 'middle', 3: 'right'}[event.button]
+            if event.state & gtk.gdk.SHIFT_MASK:
+                mod = 'shift_and_'
+            else:
+                mod = ''
+            if not self.globals.settings[
+                                    'groupbutton_%s%s_click_double'%(mod, button)]:
+                # No double click required, go ahead and do the action.
+                action = self.globals.settings[
+                                    'groupbutton_%s%s_click_action'%(mod, button)]
+                self.action_function_dict[action](self, widget, event)
         else:
-            mod = ''
-        if not self.globals.settings[
-                                'groupbutton_%s%s_click_double'%(mod, button)]:
-            # No double click required, go ahead and do the action.
-            action = self.globals.settings[
-                                'groupbutton_%s%s_click_action'%(mod, button)]
-            self.action_function_dict[action](self, widget, event)
+            disable_popup = False
 
+        # disbale popup list to be shown by delay when mouse clicked and action executed
+        if self.globals.settings['disable_popup_on_groupbutton_click'] is True:
+            self.disable_popup_delay = disable_popup;
 
     def on_group_button_press_event(self,widget,event):
-        # In compiz there is a enter and a leave 
-        # event before a button_press event.
+        # In compiz there is a enter and a leave event before a button_press event.
         # self.button_pressed is used to stop functions started with
-        # gobject.timeout_add from self.button_mouse_enter 
-        # or self.on_button_mouse_leave.
+        # gobject.timeout_add from self.button_mouse_enter or self.on_button_mouse_leave.
         self.button_pressed = True
         gobject.timeout_add(600, self.set_button_pressed_false)
 
@@ -1237,10 +1386,15 @@
         elif event.button == 1:
             # Return False so that a drag-and-drop can be initiated if needed.
             return False
+        
+        # disbale popup list to be shown by delay when mouse clicked and action executed  
+        if self.globals.settings['disable_popup_on_groupbutton_click'] is True:
+            self.disable_popup_delay = True;
+        
         return True
 
     def set_button_pressed_false(self):
-        # Helper function to group_button_press_event.
+        # Helper function to group_button_press_event
         self.button_pressed = False
         return False
 
@@ -1286,6 +1440,7 @@
 
     #### Actions
     def action_select(self, widget, event):
+        should_close_popup = self.globals.settings['close_popup_on_groupbutton_click']
         wins = self.get_windows()
         if (self.launcher and not wins):
             self.action_launch_application()
@@ -1293,29 +1448,24 @@
         elif len(wins) == 1:
             sow = self.globals.settings["select_one_window"]
             if sow == "select window":
-                self.windows[wins[0]].action_select_window(widget, event)
+                self.windows[wins[0]].action_select_window(widget, event, close_popup = should_close_popup)
             elif sow == "select or minimize window":
-                self.windows[wins[0]].action_select_or_minimize_window(widget, 
-                                                                       event)
+                self.windows[wins[0]].action_select_or_minimize_window(widget, event, close_popup = should_close_popup)
         # Multiple windows
         elif len(wins) > 1:
             smw = self.globals.settings["select_multiple_windows"]
             if smw == "select all":
-                self.action_select_or_minimize_group(widget, event, 
-                                                     minimize=False)
+                self.action_select_or_minimize_group(widget, event, minimize=False)
             elif smw == "select or minimize all":
-                self.action_select_or_minimize_group(widget, event, 
-                                                     minimize=True)
+                self.action_select_or_minimize_group(widget, event, minimize=True)
             elif smw == "compiz scale":
                 umw = self.get_unminimized_windows()
                 if len(umw) == 1:
                     sow = self.globals.settings["select_one_window"]
                     if sow == "select window":
-                        self.windows[umw[0]].action_select_window(widget, 
-                                                                  event)
+                        self.windows[umw[0]].action_select_window(widget, event, close_popup = should_close_popup)
                     elif sow == "select or minimize window":
-                        self.windows[umw[0]].action_select_or_minimize_window(
-                                                                 widget, event)
+                        self.windows[umw[0]].action_select_or_minimize_window(widget, event, close_popup = should_close_popup)
                 elif len(umw) == 0:
                     self.action_select_or_minimize_group(widget, event)
                 else:
@@ -1326,7 +1476,7 @@
                 self.action_select_popup(widget, event)
 
     def action_select_popup(self, widget, event):
-        if self.popup_showing is True:
+        if self.popup_showing is True and self.popup_showing_by_delay is not True:
             self.hide_list()
         else:
             self.show_list()
@@ -1348,6 +1498,9 @@
         wingr = False
         active_workspace = screen.get_active_workspace()
 
+        # close popup if at least one window gets activated
+        close_popup = False
+
         # Check if there are any uminimized windows, unminimize
         # them (unless they are on another workspace and work-
         # space behavior is somehting other than move) and
@@ -1358,7 +1511,7 @@
                 if win.is_minimized():
                     ignored = False
                     if not win.is_pinned() and win.get_workspace() != None \
-                    and screen.get_active_workspace() != win.get_workspace():
+                       and screen.get_active_workspace() != win.get_workspace():
                         if mode == 'move':
                             ws = screen.get_active_workspace()
                             win.move_to_workspace(ws)
@@ -1375,7 +1528,11 @@
                     if not ignored:
                         win.unminimize(event.time)
                         unminimized = True
+                        close_popup = True
         if unminimized:
+            # before returing also close popup if at least one window got shown
+            if close_popup is True and self.globals.settings['close_popup_on_groupbutton_click'] is True:
+                self.hide_list()            
             return
 
         # Make a list of the windows in group with the bottom most
@@ -1386,8 +1543,7 @@
         # topmost windows.
         for win in windows_stacked:
             if (not win.is_skip_tasklist()) and (not win.is_minimized()) \
-            and (win.get_window_type() in [wnck.WINDOW_NORMAL,
-                                           wnck.WINDOW_DIALOG]):
+            and (win.get_window_type() in [wnck.WINDOW_NORMAL,wnck.WINDOW_DIALOG]):
                 if win in self.windows:
                     ignored = False
                     if not win.is_pinned() and win.get_workspace() != None \
@@ -1420,9 +1576,8 @@
                         grtop = False
 
         if not grp_win_stacked and mode == 'switch':
-            # Put the windows in dictionaries according to workspace and 
-            # viewport so we can compare which workspace and viewport that 
-            # has most windows.
+            # Put the windows in dictionaries according to workspace and viewport
+            # so we can compare which workspace and viewport that has most windows.
             workspaces ={}
             for win in self.windows:
                 if win.get_workspace() == None:
@@ -1457,8 +1612,8 @@
                             grp_win_stacked = vp
                         elif nr == max:
                             # Check wether this workspace or previous workspace
-                            # with the same amount of windows has been 
-                            # activated later.
+                            # with the same amount of windows has been activated
+                            # later.
                             for win in ignorelist:
                                 if win in grp_win_stacked:
                                     break
@@ -1479,7 +1634,11 @@
                 if win.is_minimized():
                     win.unminimize(event.time)
                     unminimized = True
+                    close_popup = True
             if unminimized:
+                # before returing also close popup if at least one window got shown
+                if close_popup is True and self.globals.settings['close_popup_on_groupbutton_click'] is True:
+                    self.hide_list()
                 return
             ordered_list = []
             ignorelist.reverse() #Bottommost window fist again.
@@ -1491,9 +1650,15 @@
         if grtop and not moved and minimize:
             for win in grp_win_stacked:
                 self.windows[win].window.minimize()
+                close_popup = False
         if not grtop:
             for win in grp_win_stacked:
                 self.windows[win].window.activate(event.time)
+                close_popup = True
+        
+        # before returing also close popup if at least one window got shown
+        if close_popup is True and self.globals.settings['close_popup_on_groupbutton_click'] is True:
+            self.hide_list()
 
     def action_select_only(self, widget, event):
         self.action_select_or_minimize_group(widget, event, False)
@@ -1503,13 +1668,19 @@
         if  len(wins) > 1:
             self.action_compiz_scale_windows(widget, event)
         elif len(wins) == 1:
-            self.windows[wins[0]].action_select_window(widget, event)
+            self.windows[wins[0]].action_select_window(widget, event, close_popup = True)
 
     def action_minimize_all_windows(self,widget=None, event=None):
+        # no need to hide list - user can that way select any specific window when all minimized 
+        #self.hide_list()
+        
         for window in self.get_windows():
             window.minimize()
 
     def action_maximize_all_windows(self,widget=None, event=None):
+        # should hide popup list first
+        if self.globals.settings['close_popup_on_groupbutton_click'] is True:
+            self.hide_list()
         try:
             action_maximize = wnck.WINDOW_ACTION_MAXIMIZE
         except:
@@ -1559,7 +1730,10 @@
         # Just a safety check
         if not win in self.windows:
             return
+        
         self.windows[win].action_select_window(widget, event)
+        # do not know if it is better to close popup or leave it open
+        #self.windows[win].action_select_window(widget, event, close_popup = True)
         if previous:
             self.nextlist.insert(0, win)
         else:
@@ -1578,6 +1752,8 @@
                                                      self.hide_list_request)
 
     def action_close_all_windows(self, widget=None, event=None):
+        # should hide popup list first
+        self.hide_list()
         if event:
             t = event.time
         else:
@@ -1586,6 +1762,9 @@
             window.close(t)
 
     def action_launch_application(self, widget=None, event=None):
+        # should hide popup list first
+        if self.globals.settings['close_popup_on_groupbutton_click'] is True:
+            self.hide_list()
         if self.lastlaunch != None \
         and time() - self.lastlaunch < 2:
                 return
@@ -1599,11 +1778,9 @@
         self.launch_effect = True
         self.update_state()
         if self.windows:
-            self.launch_effect_timeout = gobject.timeout_add(2000, 
-                                                    self.remove_launch_effect)
+            self.launch_effect_timeout = gobject.timeout_add(2000, self.remove_launch_effect)
         else:
-            self.launch_effect_timeout = gobject.timeout_add(10000, 
-                                                    self.remove_launch_effect)
+            self.launch_effect_timeout = gobject.timeout_add(10000, self.remove_launch_effect)
 
 
     def action_show_menu(self, widget, event):
@@ -1625,15 +1802,13 @@
             #Launch program item
             launch_program_item = gtk.MenuItem(_('_Launch application'))
             menu.append(launch_program_item)
-            launch_program_item.connect("activate", 
-                                self.action_launch_application)
+            launch_program_item.connect("activate", self.action_launch_application)
             launch_program_item.show()
         if self.launcher:
             #Remove launcher item
             remove_launcher_item = gtk.MenuItem(_('Unpin application'))
             menu.append(remove_launcher_item)
-            remove_launcher_item.connect("activate", 
-                                         self.action_remove_launcher)
+            remove_launcher_item.connect("activate", self.action_remove_launcher)
             remove_launcher_item.show()
             #Edit identifier item
             edit_identifier_item = gtk.MenuItem(_('Edit Identifier'))
@@ -1683,7 +1858,6 @@
             sep = gtk.SeparatorMenuItem()
             menu.append(sep)
             sep.show()
-        # Windows stuff
         win_nr = self.get_windows_count()
         if win_nr:
             if win_nr == 1:
@@ -1723,13 +1897,14 @@
             # Close all
             close_all_windows_item = gtk.MenuItem('%s%s'%(_("_Close"), t))
             menu.append(close_all_windows_item)
-            close_all_windows_item.connect("activate", 
-                                           self.action_close_all_windows)
+            close_all_windows_item.connect("activate", self.action_close_all_windows)
             close_all_windows_item.show()
         menu.popup(None, None, None, event.button, event.time)
         self.globals.right_menu_showing = True
 
     def action_remove_launcher(self, widget=None, event=None):
+        # should hide popup list first
+        self.hide_list()
         print 'Removing launcher ', self.identifier
         if self.identifier:
             name = self.identifier
@@ -1756,7 +1931,7 @@
         if not self.class_group or not wins:
             return
         if len(wins) == 1:
-            self.windows[wins[0]].action_select_window(widget, event)
+            self.windows[wins[0]].action_select_window(widget, event, close_popup = True)
             return
         if self.globals.settings['show_only_current_desktop']:
             path = 'scale/allscreens/initiate_key'
@@ -1769,15 +1944,20 @@
             return
         # A new button enter signal is sent when compiz is called,
         # a delay is therefor needed.
-        gobject.timeout_add(self.globals.settings['popup_delay'] + 200, 
-                            self.hide_list)
+        if self.globals.settings['disable_popup_on_groupbutton_click'] is True:
+            # there is no problem with aditional compiz call since popup list
+            # is disabled on any click (self.disable_popup_delay)
+            self.hide_list()
+        else:    
+            gobject.timeout_add(settings['popup_delay'] + 200, self.hide_list)
+        
 
     def action_compiz_shift_windows(self, widget, event):
         wins = self.get_unminimized_windows()
         if not self.class_group or not wins:
             return
         if len(wins) == 1:
-            self.windows[wins[0]].action_select_window(widget, event)
+            self.windows[wins[0]].action_select_window(widget, event, close_popup = True)
             return
 
         if self.globals.settings['show_only_current_desktop']:
@@ -1791,42 +1971,51 @@
             return
         # A new button enter signal is sent when compiz is called,
         # a delay is therefor needed.
-        gobject.timeout_add(self.globals.settings['popup_delay']+ 200, 
-                            self.hide_list)
+        if self.globals.settings['disable_popup_on_groupbutton_click'] is True:
+            # there is no problem with aditional compiz call since popup list
+            # is disabled on any click (self.disable_popup_delay)
+            self.hide_list()
+        else:
+            gobject.timeout_add(settings['popup_delay']+ 200, self.hide_list)
 
     def action_compiz_scale_all(self, widget, event):
         try:
-            compiz_call('scale/allscreens/initiate_key', 'activate',
-                        'root', self.root_xid)
+            compiz_call('scale/allscreens/initiate_key','activate','root', self.root_xid)
         except:
             return
         # A new button enter signal is sent when compiz is called,
         # a delay is therefor needed.
-        gobject.timeout_add(self.globals.settings['popup_delay']+ 200, 
-                            self.hide_list)
+        if self.globals.settings['disable_popup_on_groupbutton_click'] is True:
+            # there is no problem with aditional compiz call since popup list
+            # is disabled on any click (self.disable_popup_delay)
+            self.hide_list()
+        else:
+            gobject.timeout_add(settings['popup_delay']+ 200, self.hide_list)
 
     def action_dbpref (self,widget=None, event=None):
         # Preferences dialog
         self.emit('launch-preference')
 
     def action_none(self, widget = None, event = None):
+        # if there is no action then reenable popup list
+        self.disable_popup_delay = False
         pass
 
-    action_function_dict = \
-            ODict((
-            ("select", action_select),
-            ("close all windows", action_close_all_windows),
-            ("minimize all windows", action_minimize_all_windows),
-            ("maximize all windows", action_maximize_all_windows),
-            ("launch application", action_launch_application),
-            ("show menu", action_show_menu),
-            ("remove launcher", action_remove_launcher),
-            ("select next window", action_select_next),
-            ("select previous window", action_select_previous),
-            ("minimize all other groups", action_minimize_all_other_groups),
-            ("compiz scale windows", action_compiz_scale_windows),
-            ("compiz shift windows", action_compiz_shift_windows),
-            ("compiz scale all", action_compiz_scale_all),
-            ("show preference dialog", action_dbpref),
-            ("no action", action_none)
-            ))
 \ No newline at end of file
+    action_function_dict = ODict((
+                                  ("select", action_select),
+                                  ("close all windows", action_close_all_windows),
+                                  ("minimize all windows", action_minimize_all_windows),
+                                  ("maximize all windows", action_maximize_all_windows),
+                                  ("launch application", action_launch_application),
+                                  ("show menu", action_show_menu),
+                                  ("remove launcher", action_remove_launcher),
+                                  ("select next window", action_select_next),
+                                  ("select previous window", action_select_previous),
+                                  ("minimize all other groups", action_minimize_all_other_groups),
+                                  ("compiz scale windows", action_compiz_scale_windows),
+                                  ("compiz shift windows", action_compiz_shift_windows),
+                                  ("compiz scale all", action_compiz_scale_all),
+                                  ("show preference dialog", action_dbpref),
+                                  ("no action", action_none)
+                                ))
+
 
=== modified file 'dockbarx/i18n.py' (properties changed: -x to +x)
=== modified file 'dockbarx/iconfactory.py' (properties changed: -x to +x)
--- dockbarx/iconfactory.py	2010-06-29 16:11:43 +0000
+++ dockbarx/iconfactory.py	2010-07-05 16:50:40 +0000
@@ -45,6 +45,7 @@
     LAUNCHER = 1<<6
     # Icon effects
     MOUSE_OVER = 1<<7
+    MOUSE_BUTTON_DOWN = 1<<13
     NEEDS_ATTENTION = 1<<8
     BLINK  = 1<<9
     # ACTIVE_WINDOW
@@ -56,6 +57,7 @@
                  'all_minimized':ALL_MINIMIZED,
                  'launcher':LAUNCHER,
                  'mouse_over':MOUSE_OVER,
+                 'mouse_button_down':MOUSE_BUTTON_DOWN,
                  'needs_attention':NEEDS_ATTENTION,
                  'blink':BLINK,
                  'active':ACTIVE,
@@ -104,9 +106,6 @@
 
 
     def set_size(self, size):
-        if size <= 0:
-            # To avoid chrashes.
-            size = 15
         self.size = size
         self.surfaces = {}
         self.average_color = None
@@ -120,8 +119,7 @@
 
 
     def surface_update(self, type = 0):
-        # Checks if the requested pixbuf is already
-        # drawn and returns it if it is.
+        # Checks if the requested pixbuf is already drawn and returns it if it is.
         # Othervice the surface is drawn, saved and returned.
         self.win_nr = type & 15
         if self.win_nr > self.max_win_nr:
@@ -445,8 +443,7 @@
     def find_icon_pixbuf(self, size):
         # Returns the icon pixbuf for the program. Uses the following metods:
 
-        # 1) If it is a launcher, return the icon from the
-        #    launcher's desktopfile
+        # 1) If it is a launcher, return the icon from the launcher's desktopfile
         # 2) Get the icon from the gio app
         # 3) Check if the res_class fits an themed icon.
         # 4) Search in path after a icon matching reclass.
@@ -464,8 +461,7 @@
             icon = self.app.get_icon()
             if icon.__class__ == gio.FileIcon:
                 if icon.get_file().query_exists(None):
-                    pixbuf = self.icon_from_file_name(
-                                            icon.get_file().get_path(), size)
+                    pixbuf = self.icon_from_file_name(icon.get_file().get_path(), size)
                     if pixbuf != None:
                         return pixbuf
             elif icon.__class__ == gio.ThemedIcon:
@@ -504,8 +500,7 @@
         # If no pixbuf has been found (can only happen for an unlaunched
         # launcher), make an empty pixbuf and show a warning.
         if self.icon_theme.has_icon('application-default-icon'):
-            pixbuf = self.icon_theme.load_icon('application-default-icon',
-                                                size, 0)
+            pixbuf = self.icon_theme.load_icon('application-default-icon',size,0)
         else:
             pixbuf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, True, 8, size,size)
             pixbuf.fill(0x00000000)
@@ -529,8 +524,7 @@
     def icon_from_file_name(self, icon_name, icon_size = -1):
         if os.path.isfile(icon_name):
             try:
-                return gtk.gdk.pixbuf_new_from_file_at_size(icon_name, -1,
-                                                            icon_size)
+                return gtk.gdk.pixbuf_new_from_file_at_size(icon_name, -1, icon_size)
             except:
                 pass
         return None
 
=== modified file 'dockbarx/theme.py' (properties changed: -x to +x)
=== modified file 'dockbarx/windowbutton.py' (properties changed: -x to +x)
--- dockbarx/windowbutton.py	2010-06-22 11:15:41 +0000
+++ dockbarx/windowbutton.py	2010-07-05 16:50:40 +0000
@@ -78,22 +78,14 @@
 
 
         #--- Events
-        self.window_button.connect("enter-notify-event",
-                                   self.on_button_mouse_enter)
-        self.window_button.connect("leave-notify-event",
-                                   self.on_button_mouse_leave)
-        self.window_button.connect("button-press-event",
-                                   self.on_window_button_press_event)
-        self.window_button.connect("button-release-event",
-                                   self.on_window_button_release_event)
-        self.window_button.connect("scroll-event",
-                                   self.on_window_button_scroll_event)
-        self.state_changed_event = self.window.connect("state-changed",
-                                                self.on_window_state_changed)
-        self.icon_changed_event = self.window.connect("icon-changed",
-                                                self.on_window_icon_changed)
-        self.name_changed_event = self.window.connect("name-changed",
-                                                self.on_window_name_changed)
+        self.window_button.connect("enter-notify-event",self.on_button_mouse_enter)
+        self.window_button.connect("leave-notify-event",self.on_button_mouse_leave)
+        self.window_button.connect("button-press-event",self.on_window_button_press_event)
+        self.window_button.connect("button-release-event",self.on_window_button_release_event)
+        self.window_button.connect("scroll-event",self.on_window_button_scroll_event)
+        self.state_changed_event = self.window.connect("state-changed",self.on_window_state_changed)
+        self.icon_changed_event = self.window.connect("icon-changed",self.on_window_icon_changed)
+        self.name_changed_event = self.window.connect("name-changed",self.on_window_name_changed)
 
         #--- D'n'D
         self.window_button.drag_dest_set(gtk.DEST_DEFAULT_HIGHLIGHT, [], 0)
@@ -103,6 +95,7 @@
         self.dnd_select_window = None
 
 
+
     def set_button_active(self, mode):
         self.is_active_window = mode
         self.update_label_state()
@@ -280,22 +273,18 @@
         # to this windowbutton transparent.
         if self.globals.opacity_values == None:
             try:
-                self.globals.opacity_values = compiz_call(
-                                        'obs/screen0/opacity_values','get')
+                self.dockbar.opacity_values = compiz_call('obs/screen0/opacity_values','get')
             except:
                 try:
-                    self.globals.opacity_values = compiz_call(
-                                        'core/screen0/opacity_values','get')
+                    self.dockbar.opacity_values = compiz_call('core/screen0/opacity_values','get')
                 except:
                     return
         if self.globals.opacity_matches == None:
             try:
-                self.globals.opacity_matches = compiz_call(
-                                        'obs/screen0/opacity_matches','get')
+                self.dockbar.opacity_matches = compiz_call('obs/screen0/opacity_matches','get')
             except:
                 try:
-                    self.globals.opacity_matches = compiz_call(
-                                        'core/screen0/opacity_matches','get')
+                    self.dockbar.opacity_values = compiz_call('core/screen0/opacity_matches','get')
                 except:
                     return
         self.globals.opacified = True
@@ -339,16 +328,12 @@
         if self.globals.opacity_values == None:
             return False
         try:
-            compiz_call('obs/screen0/opacity_values','set', 
-                        self.globals.opacity_values)
-            compiz_call('obs/screen0/opacity_matches','set', 
-                        self.globals.opacity_matches)
+            compiz_call('obs/screen0/opacity_values','set', self.dockbar.opacity_values)
+            compiz_call('obs/screen0/opacity_matches','set', self.dockbar.opacity_matches)
         except:
             try:
-                compiz_call('core/screen0/opacity_values','set', 
-                            self.globals.opacity_values)
-                compiz_call('core/screen0/opacity_matches','set', 
-                            self.globals.opacity_matches)
+                compiz_call('core/screen0/opacity_values','set', self.dockbar.opacity_values)
+                compiz_call('core/screen0/opacity_matches','set', self.dockbar.opacity_matches)
             except:
                 print "Error: Couldn't set opacity back to normal."
         self.globals.opacity_values = None
@@ -361,8 +346,7 @@
         # Make sure that mouse cursor really has left the window button.
         b_m_x,b_m_y = self.window_button.get_pointer()
         b_r = self.window_button.get_allocation()
-        if b_m_x >= 0 and b_m_x < b_r.width \
-        and b_m_y >= 0 and b_m_y < b_r.height:
+        if (b_m_x>=0 and b_m_x<b_r.width) and (b_m_y >= 0 and b_m_y < b_r.height):
             return True
         self.globals.opacified = False
         self.opacified = False
@@ -390,8 +374,7 @@
 
     #### Events
     def on_button_mouse_enter(self, widget, event):
-        # In compiz there is a enter and 
-        # a leave event before a button_press event.
+        # In compiz there is a enter and a leave event before a button_press event.
         # Keep that in mind when coding this def!
         if self.button_pressed :
             return
@@ -402,8 +385,7 @@
             gobject.timeout_add(500, self.deopacify_request)
 
     def on_button_mouse_leave(self, widget, event):
-        # In compiz there is a enter and a leave 
-        # event before a button_press event.
+        # In compiz there is a enter and a leave event before a button_press event.
         # Keep that in mind when coding this def!
         self.button_pressed = False
         self.update_label_state(False)
@@ -411,11 +393,9 @@
             self.deopacify_request()
 
     def on_window_button_press_event(self, widget,event):
-        # In compiz there is a enter and a leave event before
-        # a button_press event.
+        # In compiz there is a enter and a leave event before a button_press event.
         # self.button_pressed is used to stop functions started with
-        # gobject.timeout_add from self.on_button_mouse_enter 
-        # or self.on_button_mouse_leave.
+        # gobject.timeout_add from self.on_button_mouse_enter or self.on_button_mouse_leave.
         self.button_pressed = True
         gobject.timeout_add(600, self.set_button_pressed_false)
 
@@ -432,9 +412,13 @@
         if event.direction == gtk.gdk.SCROLL_UP:
             action = self.globals.settings['windowbutton_scroll_up']
             self.action_function_dict[action](self, widget, event)
+            if self.globals.settings['windowbutton_close_popup_on_scroll_up'] is True:
+                self.emit('popup-hide', None)
         elif event.direction == gtk.gdk.SCROLL_DOWN:
             action = self.globals.settings['windowbutton_scroll_down']
             self.action_function_dict[action](self, widget, event)
+            if self.globals.settings['windowbutton_close_popup_on_scroll_down'] is True:
+                self.emit('popup-hide', None)
 
     def on_window_button_release_event(self, widget,event):
         if self.globals.settings["opacify"]and self.opacified:
@@ -442,26 +426,36 @@
             self.opacified = False
             self.deopacify()
         if event.button == 1 and event.state & gtk.gdk.SHIFT_MASK :
-            action = self.globals.settings[
-                                    'windowbutton_shift_and_left_click_action']
+            action = self.globals.settings['windowbutton_shift_and_left_click_action']
             self.action_function_dict[action](self, widget, event)
+            if self.globals.settings['windowbutton_close_popup_on_shift_and_left_click'] is True:
+                self.emit('popup-hide', None)
         elif event.button == 1:
             action = self.globals.settings['windowbutton_left_click_action']
             self.action_function_dict[action](self, widget, event)
+            if self.globals.settings['windowbutton_close_popup_on_left_click'] is True:
+                self.emit('popup-hide', None)
         elif event.button == 2 and event.state & gtk.gdk.SHIFT_MASK:
-            action = self.globals.settings[
-                                'windowbutton_shift_and_middle_click_action']
+            action = self.globals.settings['windowbutton_shift_and_middle_click_action']
             self.action_function_dict[action](self, widget,event)
+            if self.globals.settings['windowbutton_close_popup_on_shift_and_middle_click'] is True:
+                self.emit('popup-hide', None)
         elif event.button == 2:
             action = self.globals.settings['windowbutton_middle_click_action']
             self.action_function_dict[action](self, widget,event)
+            if self.globals.settings['windowbutton_close_popup_on_middle_click'] is True:
+                self.emit('popup-hide', None)
         elif event.button == 3 and event.state & gtk.gdk.SHIFT_MASK:
-            action = self.globals.settings[
-                                'windowbutton_shift_and_right_click_action']
+            action = self.globals.settings['windowbutton_shift_and_right_click_action']
             self.action_function_dict[action](self, widget, event)
+            if self.globals.settings['windowbutton_close_popup_on_shift_and_right_click'] is True:
+                self.emit('popup-hide', None)
         elif event.button == 3:
             action = self.globals.settings['windowbutton_right_click_action']
             self.action_function_dict[action](self, widget, event)
+            if self.globals.settings['windowbutton_close_popup_on_right_click'] is True:
+                self.emit('popup-hide', None)
+        
 
     #### Menu functions
     def menu_closed(self, menushell):
@@ -475,8 +469,7 @@
             self.window.minimize()
 
     #### Actions
-    def action_select_or_minimize_window(self, widget=None, 
-                                         event=None, minimize=True):
+    def action_select_or_minimize_window(self, widget=None, event=None, minimize=True, close_popup = False):
         # The window is activated, unless it is already
         # activated, then it's minimized. Minimized
         # windows are unminimized. The workspace
@@ -491,21 +484,27 @@
             self.window.get_workspace().activate(t)
         if not self.window.is_in_viewport(self.screen.get_active_workspace()):
             win_x,win_y,win_w,win_h = self.window.get_geometry()
-            self.screen.move_viewport(win_x-(win_x%self.screen.get_width()),
-                                      win_y-(win_y%self.screen.get_height()))
+            self.screen.move_viewport(win_x-(win_x%self.screen.get_width()),win_y-(win_y%self.screen.get_height()))
             # Hide popup since mouse movment won't
             # be tracked during compiz move effect
             # which means popup list can be left open.
-            self.emit('popup-hide', 'viewport-change')
+            #self.emit('popup-hide', 'viewport-change')
+            close_popup = True
         if self.window.is_minimized():
             self.window.unminimize(t)
         elif self.window.is_active() and minimize:
             self.window.minimize()
+            close_popup = False
         else:
             self.window.activate(t)
 
-    def action_select_window(self, widget = None, event = None):
-        self.action_select_or_minimize_window(widget, event, False)
+        # also close popup list unless if we just minimized window
+        # but only if needed by caller or due to compiz
+        if close_popup is True:
+            self.emit('popup-hide', None)
+
+    def action_select_window(self, widget = None, event = None, close_popup = False):
+        self.action_select_or_minimize_window(widget, event, False, close_popup)
 
     def action_close_window(self, widget=None, event=None):
         self.window.close(gtk.get_current_event_time())
@@ -570,8 +569,7 @@
         pass
 
     action_function_dict = ODict((
-                                  ('select or minimize window', 
-                                            action_select_or_minimize_window),
+                                  ('select or minimize window', action_select_or_minimize_window),
                                   ('select window', action_select_window),
                                   ('maximize window', action_maximize_window),
                                   ('close window', action_close_window),
@@ -581,4 +579,3 @@
                                   ('no action', action_none)
                                 ))
 
-
 
=== modified file 'dockbarx/zg.py' (properties changed: -x to +x)