def isAuthorizationRequestOpen():
    """Used to determine if the authorization dialog is still open. Fixes the multiple authorization requests."""
    wnck.screen_get_default().force_update()
    window_list = wnck.screen_get_default().get_windows()
    if len(window_list) == 0:
    	return False
    for win in window_list:
        if "Skype API Authorisation Request" in win.get_name():
            return True
    return False    

def resize_single_window(geometries):

    def similar_geometries(ga,gb):
        for i in range(4):
            if abs(ga[i] - gb[i]) >= window_geometry_error_margin:
                return False
        return True
 
    window = wnck.screen_get_default().get_active_window()    
    window_original_geometry = window.get_geometry()

    #not an arrangement, but a list of geometires for that matter
    geometries_numeric = parse_arrangement(geometries)
    geometry_list_args = [0,255]
    
    i=1
    geometry_to_use_index=0    
    for geometry_numeric in geometries_numeric:
        if similar_geometries(geometry_numeric, window_original_geometry):
            geometry_to_use_index = i % len(geometries_numeric)
            break
        i+=1 

    geometry_list_args.extend(map (int,geometries_numeric[geometry_to_use_index]))
    window.unmaximize()
    window.set_geometry(*geometry_list_args)

 def __init__(self,reserve_left,reserve_right,reserve_top,reserve_bottom):
     self.screen = wnck.screen_get_default()
     
     self.left=0+reserve_left
     self.top=0+reserve_top
     self.bottom = screen.get_height()-reserve_bottom
     self.right = screen.get_width()-reserve_right

    def init_workspace_tracking(self):
        if not wnck: # can't track if we don't have the trackable
            return

        self.screen = wnck.screen_get_default()
        self.screen.workspace_handler = self.screen.connect("active-workspace-changed", self.on_workspace_changed)
        self.workspace_activities = {}

def _get_active_process_name():
    import wnck
    ''' deprecated '''
    try:
        # http://askubuntu.com/questions/152191
        screen = wnck.screen_get_default()
        # print screen
        window = screen.get_active_window()
        # print window
        pid = window.get_pid()
        process = psutil.Process(pid)
        # print(pid)
        # print(process.name)
        # print(process.exe)
        # print(process.cmdline)
        # print('strange: process.cmdline is of type "%s"' % type(process.cmdline))
        try:
            #  # in psutil 2+ cmdline is a getter
            return ' '.join(process.cmdline())
        except TypeError:
            return ' '.join(process.cmdline)
        except Exception:
            return "error in get_active_process_name(%s)" % str(pid)
    except (psutil.NoSuchProcess, AttributeError) as e:
        # print e
        raise WindowInformationError()

 def __init__(self, name=_("Window List")):
     super(WindowsSource, self).__init__(name)
     # "preload" windows: Ask for them early
     # since the first call "primes" the event loop
     # and always comes back empty
     screen = wnck.screen_get_default()
     screen.get_windows_stacked()

    def __init__(self, wnck_window, group):
        self.group_r = weakref.ref(group)
        self.globals = Globals()
        self.opacify_obj = Opacify()
        connect(self.globals, "show-only-current-monitor-changed",
                             self.__on_show_only_current_monitor_changed)
        self.screen = wnck.screen_get_default()
        self.wnck = wnck_window
        self.deopacify_sid = None
        self.opacify_sid = None
        self.select_sid = None
        self.xid = self.wnck.get_xid()
        self.is_active_window = False
        self.on_current_desktop = self.is_on_current_desktop()
        self.monitor = self.get_monitor()

        self.state_changed_event = self.wnck.connect("state-changed",
                                                self.__on_window_state_changed)
        self.icon_changed_event = self.wnck.connect("icon-changed",
                                                self.__on_window_icon_changed)
        self.name_changed_event = self.wnck.connect("name-changed",
                                                self.__on_window_name_changed)
        self.geometry_changed_event = self.wnck.connect("geometry-changed",
                                                self.__on_geometry_changed)

        self.item = WindowItem(self, group)
        self.needs_attention = self.wnck.needs_attention()
        self.item.show()
        self.__on_show_only_current_monitor_changed()

def ripeti():
	global posatt, mmode, player
	if (mmode==1):
		window_list = wnck.screen_get_default().get_windows()
		for win in window_list:
			#print win.get_name()
			nome = win.get_application().get_name().upper()
			if ((nome.find(player.upper())!=-1)):
				(x, y, width, height) = win.get_client_window_geometry()		
				d = display.Display().screen().root.query_pointer()._data
				mx = d['root_x']
				my = d['root_y']

				if ((nome.find(player.upper())!=-1) and (mx>x) and (my>y) and (mx<(x+width)) and (my<(y+width))):
					if posatt < 500: 
						posatt = 500
					else: 
						posatt = 0
					win.set_geometry ('WNCK_WINDOW_GRAVITY_CURRENT', 'WNCK_WINDOW_CHANGE_Y', x, posatt, width, height)

						
				elif ((nome.find(player.upper())!=-1) and (my<y) and (mx<x)):
						win.set_geometry ('WNCK_WINDOW_GRAVITY_CURRENT', 'WNCK_WINDOW_CHANGE_Y', x, 0, width, height)

			#print str(mx)
	d = []
	return True

def display_osd(options):
    s = wnck.screen_get_default()
    s.force_update()
    windows = s.get_windows()
    osds = []
    ws = s.get_active_workspace()

    windows = sorted(windows, key=operator.methodcaller("get_pid"))
    windows = [window for window in windows if window.is_visible_on_workspace(ws)]

    for i, window in enumerate(windows):
        if window.is_visible_on_workspace(ws):
            osd = pyosd.osd(options.font)
            osd.set_timeout(-1)
            osd.set_colour(options.colour)
            osd.set_outline_offset(1)
            osd.set_outline_colour(options.outline_colour)
            osd.set_shadow_offset(2)
            x, y = window.get_geometry()[:2]
            osd.set_horizontal_offset(x)
            osd.set_vertical_offset(y)
            # XXX explodes if more than 26 windows are visable.
            osd.display(string.lowercase[i])
            osds.append(osd)
    return osds, windows

def getScreenshot():
    screen = wnck.screen_get_default()
    while gtk.events_pending(): gtk.main_iteration()
    windowList = screen.get_windows()
    mineWindow = filter ((lambda w: w.get_name() == "Mines"), windowList)

    if len (mineWindow) == 0:
        print "Couldn't find the Mines window."
        exit()
        
    mineWindow[0].move_to_workspace(screen.get_active_workspace())
    mineWindow[0].activate(0)
    mineSize = mineWindow[0].get_client_window_geometry()
    #46 pixels from the top is the toolbar
    mineSize = (mineSize[0], mineSize[1] + 46, mineSize[2], mineSize[3] - 46)

    time.sleep(0.5)

    #Screenshot the window (46 pixels from the top is the toolbar)
    desktop = gtk.gdk.get_default_root_window()
    desktopSize = desktop.get_size()
    pb = gtk.gdk.Pixbuf(
        gtk.gdk.COLORSPACE_RGB,False,8,mineSize[2], mineSize[3])
    pb = pb.get_from_drawable(desktop, desktop.get_colormap(),
        mineSize[0], mineSize[1], 0,0, mineSize[2], mineSize[3])
    if (pb == None):
        print "Unable to get the screenshot."

    bitmap = pb.get_pixels_array()
    windowX = mineSize[0]
    windowY = mineSize[1]
    
    return (bitmap, windowX, windowY)

def find_windows(app_regex, win_regex):
    """
    Returns a list with all windows matching application name and
    windows name regular expressions.
    """
    if app_regex is None and win_regex is None:
        return

    screen = wnck.screen_get_default()
    screen.force_update()  # updates the window list
    wins = screen.get_windows()

    rapp = re.compile(app_regex) if app_regex is not None else None
    rwin = re.compile(win_regex) if win_regex is not None else None

    result = []
    for win in wins:
        app = win.get_application()
        win_name = win.get_name() or ''
        app_name = app and app.get_name() or ''

        if rapp is not None:
            m_app = rapp.search(app_name)
            if m_app is None:
                continue

        if rwin is not None:
            m_win = rwin.search(win_name)
            if m_win is None:
                continue

        result.append(win)

    return result

	def __init__(self, blenders=2):
		self._num_blenders = blenders
		self._not_ready = self._num_blenders
		self._waiting = False
		self._window = win = gtk.Window()	#gtk.window_new( gtk.GTK_WINDOW_TOPLEVEL )
		self._screen = wnck.screen_get_default()
		print( win )
		#win.set_title( 'ctypes_ooapi_gtk_test')	# segfaults, name too long?
		win.set_title('GtkBlender')
		#win.set_default_size( 640, 480 )
		win.set_border_width( 2 )
		win.connect( 'destroy', lambda *args: gtk.main_quit() )

		frame = gtk.Frame()
		win.add( frame )
		frame.set_border_width( 4 )

		self._notebook = note = gtk.Notebook()
		frame.add( note )
		self._pages = []
		self._sockets = []
		self._procs = []
		self._plugs = 0
		for i in range( blenders ):
			exe = os.path.expanduser('~/Blender25/blender')
			self._procs.append(
				subprocess.Popen( [exe]+ '--window-geometry 0 0 640 480'.split() )
			)
			frame = gtk.Frame(); self._pages.append( frame )
			frame.set_size_request( 640, 480 )
			note.append_page( frame, gtk.Label( 'blender %s' %i ) )

		win.show_all()
		self._blender_windows = []

 def get_title(self):
     global act_table, min_delta, max_delta, db, max_idle
     try:
         window = wnck.screen_get_default().get_active_window()
         title = window.get_name()
         end = datetime.now()
         delta = end - self.start
         
         if delta >= max_delta:
             print str(end) + "> db.ping()"
             self.start = end
             db.ping()
         
         if self.idle and self.xscsaver.get_idle() < max_idle:
             self.idle = False
         
         if self.title != title or (self.xscsaver.get_idle() >= max_idle and not self.idle):
             app = window.get_application().get_name()
             self.title = title
             self.start = end
             
             if delta >= min_delta:
                 self.item.set_end(end)
                 act_table.additem(self.item)
                 print str(delta) + " [" + app + "]: \t" + title
             
             if self.xscsaver.get_idle() > max_idle:
                 app = "Screensaver"
                 title = "Idle"
                 self.idle = True
             
             self.item = ActivityItem(end, app, title, self.user_id)
     except AttributeError:
         pass
     return True

    def __init__(self):
        """ EmbedApp() -> A wrapper object to make it easier to embed an 
        external application window.  It also handles catching the title and 
        icon of the embeded window so the parent object can use them as it 
        wishes.

        """

        super(EmbedApp, self).__init__()

        # Get the default screen and connect some signals to catch when a
        # new window or application is opened.
        self._screen = wnck.screen_get_default()
        self._screen.connect("window-opened", self._window_opened)
        self._screen.connect("application-opened", self._application_opened)

        # Set the default title.
        self._title = "Embedded Window"

        self._type = "EmbedApp"

        # Create an object to hold the window icon of the embedded window.
        self._icon = gtk.Image()
        self._icon.show_all()

        self._app = None

        # Setup a dictionary to link signals emitted by a window with their
        # appropriate signal handlers.
        self._window_connect_dict = {
            "name-changed": self._window_name_changed,
            "icon-changed": self._window_icon_changed,
        }

 def _get_object(self):
     scr = wnck.screen_get_default()
     wspc = scr.get_active_workspace()
     for win in scr.get_windows_stacked():
         if not win.is_skip_tasklist():
             if win.is_on_workspace(wspc):
                 return win

def getIcon(acc):
  '''
  Loads an icon for the given application or accessible widget. Tries to use
  the current theme or wnck to get application icons. Uses icons from 
  at-poke for widgets.
  '''
  theme = gtk.icon_theme_get_default()
  try:
    role_name = acc.getRoleName()
    role = acc.getRole()
    if role_name == 'application':
      # try the theme first
      try:
        return theme.load_icon(acc.name, 24, gtk.ICON_LOOKUP_USE_BUILTIN)
      except gobject.GError:
        pass
      # then try wnck
      s = wnck.screen_get_default()
      s.force_update()
      for win in s.get_windows():
        wname = win.get_name()
        for child in acc:
          if child.name == wname:
            return win.get_mini_icon()
      return None
    else:
      name = role_name.replace(' ', '')
      try:
        fn = os.path.join(ICONS_PATH, '%s.png' % name)
        return gtk.gdk.pixbuf_new_from_file(fn)
      except gobject.GError:
        pass
  except Exception, e:
    pass

def get_open_windows():
	gtk.main_iteration()
	screen = wnck.screen_get_default()
	screen.force_update()
	win = screen.get_windows()
	windows=[]
	for w in win:
			if  'NORMAL' in str(w.get_window_type()):
				if "ducklauncher!!!"==w.get_name():
					pass			
				elif w.is_sticky()!=True and "ducklauncher!!"!=w.get_name():
					window={}	
					window['id']=w.get_xid()
					window['title'] =w.get_name()
					window['app']=w.get_application().get_name()
					window['icon']=w.get_application().get_icon_name()
					pix=w.get_icon()
					pix= pix.scale_simple(128,128,gtk.gdk.INTERP_HYPER)
					ico_data=  pix.get_pixels_array()
					img = Image.fromarray(ico_data, 'RGBA')
					home = os.path.expanduser("~")+"/.duck"
					try:
    						os.stat(home)
					except:
    						os.mkdir(home)

    def __init__(self):
        self.wallpapers = {
            "none":             "/home/themylogin/Images/Wallpapers/3200x1200/pure-none.jpg",
            "frame":            "/home/themylogin/Images/Wallpapers/3200x1200/pure-frame.jpg",
            "frame-inactive":   "/home/themylogin/Images/Wallpapers/3200x1200/pure-frame-inactive.jpg",
        }

        self.tint2_signals = {
            "none":             signal.SIGUSR1,
            "frame":            signal.SIGUSR2,
            "frame-inactive":   signal.SIGUSR1,
        }

        self.screen = wnck.screen_get_default()
        self.screen.force_update()

        self.tint2_pid = None

        self.last_maximized_window = None
        for window in self.screen.get_windows():
            if self.is_maximized_window(window):
                self.last_maximized_window = window
                break

        self.current_environment = None
        self.fit_environment()

        self.screen.connect("active-window-changed", self.on_active_window_changed)
        self.screen.connect("showing-desktop-changed", self.on_showing_desktop_changed)

    def __init__(self):
        self.config = ConfigObj(self.config_file, write_empty_values=True)
        self.populate_config()

        self.display = display.Display()
        self.screen = wnck.screen_get_default()
        self.clipboard = gtk.clipboard_get("CLIPBOARD")
        self.alt_clip = gtk.clipboard_get("PRIMARY")
        self.new_clip = None
        self.our_data = None
        self.clips = []
        self.clips_ins = 0
        self.pasting = False
        self.need_paste = False

        self.terminals = ["Terminal", "terminator", "lxterminal", "Yakuake", "guake.py", "sakura", "tilda", "ROXTerm"]

        self.alt_terms = ["xterm", "mrxvt", "urxvt", "Eterm"]

        if self.options["initial_clip"]:
            self.clipboard.request_text(self.on_clipboard_text)
        else:
            self.our_data = self.clipboard.wait_for_text()
        gobject.timeout_add(500, self.fetch_clipboard_info)

        self.setup_ui()

        gtk.main()

def update_ui(queue,LOG_FILE_NAME,graph_queue):
	global stopped,EVENT_COUNT
	
	#setup logging
	foregroundLogger = logging.getLogger("ForegroundLogger")
	foregroundLogger.setLevel(logging.INFO)
	handler = logging.handlers.RotatingFileHandler(LOG_FILE_NAME, maxBytes= 10240)
	foregroundLogger.addHandler(handler)
	
	old_window = ""
	old_time = datetime.now()
	count_updates = 0
	screen = wnck.screen_get_default()
	screen.force_update()
	event_count = 10
	x = [(i+1) for i in range(event_count)]
	xlabels = ['' for i in range(event_count)]
	y = [0 for i in range(event_count)]
	c = ['g' for i in range(event_count)]
	while True:
	
		# obtain current active window
		while gtk.events_pending():
			gtk.main_iteration()
		active_window_name = screen.get_active_window().get_name()
		current_time = datetime.now()
		new_data = str(current_time)+" :: "+old_window
		
		#print "RAW stream:",new_data
		if(active_window_name != old_window and new_data != None):
			
			elapsed_time = (current_time - old_time).total_seconds()
			
			queue.put(new_data+' ['+str("%.2f" % round(elapsed_time/60.0,4))+' minutes ]')	
						
			if(elapsed_time > 1):  #consider only those switches with more than 1 s times
				# obtain the data for graph update
				
				xlabels = []
				for i in range(event_count-1):
					y[i] = y[i+1]
					c[i] = c[i+1]
				
				y[event_count-1] = elapsed_time/60.0
				if(old_window.find('Facebook') >= 0):
					c[event_count-1] = 'r'
				elif(old_window.find('Firefox') >= 0):
					c[event_count-1] = 'b'
				else:
					c[event_count-1] = 'g'
				graph_queue.put((x,y,xlabels,c))
			old_window = active_window_name
			old_time = current_time

			foregroundLogger.info(new_data+' ['+str("%.2f" % round(elapsed_time/60.0,4))+' minutes ]') # write name of active window to logfile
			if(stopped):
				break
		
		time.sleep(0.5)