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 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 get_title(self):
# Globalize title variable
global title
try:
title = wnck.screen_get_default().get_active_window().get_name()
if self.title != title:
self.title = title
# Detects YouTube browsing
keyw = "YouTube"
keyw2 = "Twitch"
keyw3 = "gmail"
# Keyword Finder ----
# Detect Specific Web Server
if title.find(keyw) != -1:
print "----------------------------"
print " - YouTube Detected! -"
print "----------------------------"
elif title.find(keyw2) != -1:
print "----------------------------"
print " - Twitch Detected! -"
print "----------------------------"
elif title.find(keyw3) != -1:
print "----------------------------"
print " - Gmail Detected! -"
print "----------------------------"
# -------------------
print "\n%s\n" % (title)
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 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 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_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 __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 get_both_windows():
import wnck
import gtk
import gobject
def getonce():
s = wnck.screen_get_default()
ws = s.get_windows()
return ws
w = [w for w in getonce() if w.get_name().startswith('SPICEc:0')]
# run gtk event loop long enough to register all window names
gobject.idle_add(gtk.main_quit)
gtk.main()
w = [w for w in getonce() if w.get_name().startswith('SPICEc:0')]
if len(w) != 1:
if len(w) > 1:
print "more then one spice window:", w
import pdb
pdb.set_trace()
else:
print "no spice windows"
import pdb
pdb.set_trace()
sys.exit(-1)
return w[0], wnck.screen_get_default().get_active_window()
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 __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 __init__(self, dbx_dict):
DockXApplet.__init__(self, dbx_dict)
self.image = gtk.Image()
self.add(self.image)
self.image.show()
self.show()
self.screen = wnck.screen_get_default()
while gtk.events_pending():
gtk.main_iteration()
self.cfg_scroll_enabled = self.get_setting("scroll_enabled", CFG_SCROLL_ENABLED)
self.cfg_active_color = self.get_setting("active_color", CFG_ACTIVE_COLOR)
self.cfg_color = self.get_setting("color", CFG_COLOR)
self.cfg_cell_spacing = self.get_setting("cell_spacing", CFG_CELL_SPACING)
self.cfg_padding = self.get_setting("padding", CFG_PADDING)
self.cfg_desk_name_pattern = self.get_setting("desk_name_pattern", CFG_DESK_NAME_PATTERN)
self.cfg_aspect_ratio = self.get_setting("aspect_ratio", CFG_ASPECT_RATIO)
self.update()
self.connect("scroll-event", self.on_scroll)
self.screen.connect("active-workspace-changed", self.on_active_workspace_changed)
self.screen.connect("viewports-changed", self.on_viewports_changed)
self.screen.connect("workspace-created", self.on_workspace_created)
self.screen.connect("workspace-destroyed", self.on_workspace_destroyed)
self.connect("button-press-event", self.on_click)
def __init__(self,
handler_focus,
handler_rm,
display_name=None,
viewer1=None,
viewer2=None):
'''handler_*(self, level): called for each stack window changes'''
self.lock_handler = Lock()
self.lock_switch = Lock()
self.handler_client_focus = handler_focus
self.handler_client_rm = handler_rm
self.level_focus = LEVEL_NAME[1]
self.level_rm = self.level_focus
for fname in [LEVEL_FOCUS_FILE, LEVEL_RM_FILE]:
with open(fname, 'w') as fd:
fd.write(self.level_focus)
while gtk.events_pending():
gtk.main_iteration()
self.dpy = display.Display(display_name)
# TODO: use display_name for wnck too
self.scr = wnck.screen_get_default()
self.view_current = Viewer(self.dpy, viewer1)
if viewer2:
self.view_previous = Viewer(self.dpy, viewer2)
else:
self.view_previous = None
self.scr.connect("active-window-changed", self.handler_switch)
self.scr.connect("window-stacking-changed", self.handler_order)
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 __init__(self):
ItemSource.__init__(self, name="Computer Running Source")
self.pager = None
self.orientation = None
try:
# This might not exist, so be careful
self.tray_mgr = TrayManagerBox()
self.tray_mgr.show()
except AttributeError:
self.tray_mgr = None
self.pager = FriendlyPager(wnck.screen_get_default())
self.pager.show()
self.pager_align = gtk.Alignment()
self.pager_align.add(self.pager)
self.pager_align.show()
self.clock = FriendlyClock()
self.clock.show()
self.settings_apps = RunningSettingsApplications()
self.settings_apps.connect_after("reload",
lambda x: self.emit("reload"))
gconf_bridge.connect("changed::clockapplet",
lambda gb: self.emit("reload"))
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, 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 __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 _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 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):
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 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 __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 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 startupGame(self):
# Open up TF2
if self.isTF2Running() == True:
raise FatalGameMapRunnerException(
"Team Fortress 2 is currently running.")
print("Attempting to start game ...")
self.game_p = subprocess.Popen(
['/usr/bin/steam', '-applaunch', '440', '-nosound', '-novid'],
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
time.sleep(self.default_game_start_wait)
# Click the wait button for GNOME process freeze
self.clickGNOMEWaitProcess()
time.sleep(15)
if self.isTF2Running():
print("Game is now started.")
else:
self.startupGame()
return
# Activate window
screen = wnck.screen_get_default()
titlePattern = re.compile('.*Team Fortress 2.*')
windows = screen.get_windows()
for w in windows:
if titlePattern.match(w.get_name()):
print("Activated window, waiting for input ...")
w.activate(
gtk.gdk.x11_get_server_time(
gtk.gdk.get_default_root_window()))
return
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 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)
#print window
img.save("{0}/{1}.png".format(home,
binascii.hexlify(
window["icon"])))
windows.append(window)
return windows
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 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 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 linux_get_windows_bytitle(title_text, exact=False):
"""
Finds a linux (Gtk) window by title. Returns window.
"""
debug = False
default = wnck.screen_get_default()
while gtk.events_pending():
gtk.main_iteration(False)
window_list = default.get_windows()
if debug:
for w in window_list:
print w.get_name()
if len(window_list) == 0:
print "No Windows Found"
for win in window_list:
if exact:
if win.get_name() == title_text:
return win
else:
if title_text in win.get_name():
return win
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 _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 __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 _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 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)
def for_Linux():
try:
import wnck
# import gi
# gi.require_version('Wnck', '3.0')
# from gi.repository import Wnck
except ImportError:
logging.info("Using Ubuntu 18.04 or higher")
wnck = None
if wnck is not None:
screen = wnck.screen_get_default()
screen.force_update()
window = screen.get_active_window()
if window is not None:
pid = window.get_pid()
with open("/proc/{pid}/cmdline".format(pid=pid)) as f:
active_window_name = f.read()
x, y, w, h = wnck.window.get_client_window_geometry()
# print('dimensions: ', x, y, w, h)
return "No name", [x, y, w, h]
else:
try:
import gi
print("text")
gi.require_version('Wnck', '3.0')
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk, Wnck
gi = "Installed"
except ImportError:
logging.info("gi.repository not installed")
gi = None
if gi is not None:
Gtk.init([]) # necessary if not using a Gtk.main() loop
screen = Wnck.Screen.get_default()
screen.force_update() # recommended per Wnck documentation
windows = screen.get_windows()
browser_names = [
'Firefox', 'Mozilla Firefox', 'Chrome', 'Google Chrome',
'Safari', 'Mss :: Anaconda Cloud - Google Chrome'
]
for each in windows:
name = each.get_application().get_name()
if any(substring in name for substring in browser_names):
browser_window = each
article_name = name
# browser_window.activate(1)
# browser_window.set_fullscreen(True)
x, y, w, h = Wnck.Window.get_geometry(browser_window)
# print(x, y, w, h)
# print(name)
else:
each.minimize()
# dim_file = open("Window_dim.txt", "w+")
# dim_file.write(article_name+" :: "+ x + y + w + h)
# dim_file.close()
return article_name, [x, y, w, h]
def __init__(self):
# silently ignore x errors
gtk.gdk.error_trap_push()
# init screen and hook into WnckSceen's events
self.screen = wnck.screen_get_default()
self.screen.force_update()
def get_window_max(name):
screen = wnck.screen_get_default()
while gtk.events_pending():
gtk.main_iteration()
for window in screen.get_windows():
if name == window.get_name():
return window.is_maximized()
def __init__(self):
# silently ignore x errors
gtk.gdk.error_trap_push()
# init screen and hook into WnckSceen's events
self.screen = wnck.screen_get_default()
self.screen.force_update()
def getWindow(title):
screen = wnck.screen_get_default()
screen.force_update()
window_list = screen.get_windows()
for w in window_list:
if w.get_name() == title:
return w
print "oops " + title
def get_all_workspaces():
global workspaces, current_ws
scr = wnck.screen_get_default()
flush_events()
current_ws = scr.get_active_workspace().get_number()
workspaces = []
for i in range(scr.get_workspace_count()):
workspaces.append(scr.get_workspace(i))
def show_desktop(show):
def _start_showing():
screen.toggle_showing_desktop(show)
screen = wnck.screen_get_default()
gobject.idle_add(_start_showing)
gobject.idle_add(gtk.main_quit)
gtk.main()
def show_desktop(show):
def _start_showing():
screen.toggle_showing_desktop(show)
screen = wnck.screen_get_default()
gobject.idle_add(_start_showing)
gobject.idle_add(gtk.main_quit)
gtk.main()
def getWindow(title):
screen = wnck.screen_get_default()
screen.force_update()
window_list = screen.get_windows()
for w in window_list:
if w.get_name() == title:
return w
print "oops " + title
def __init__(self, parent=None, what_filter=''):
gtk.Window.__init__(self)
self.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
self.set_decorated(False)
self.set_position(gtk.WIN_POS_CENTER_ALWAYS)
self.set_border_width(style.LINE_WIDTH)
self._selected_object_id = None
self.add_events(gtk.gdk.VISIBILITY_NOTIFY_MASK)
self.connect('visibility-notify-event',
self.__visibility_notify_event_cb)
self.connect('delete-event', self.__delete_event_cb)
self.connect('key-press-event', self.__key_press_event_cb)
if parent is None:
logging.warning('ObjectChooser: No parent window specified')
else:
self.connect('realize', self.__realize_cb, parent)
screen = wnck.screen_get_default()
screen.connect('window-closed', self.__window_closed_cb, parent)
vbox = gtk.VBox()
self.add(vbox)
vbox.show()
title_box = TitleBox()
title_box.connect('volume-changed', self.__volume_changed_cb)
title_box.close_button.connect('clicked',
self.__close_button_clicked_cb)
title_box.set_size_request(-1, style.GRID_CELL_SIZE)
vbox.pack_start(title_box, expand=False)
title_box.show()
separator = gtk.HSeparator()
vbox.pack_start(separator, expand=False)
separator.show()
self._toolbar = SearchToolbar()
self._toolbar.connect('query-changed', self.__query_changed_cb)
self._toolbar.set_size_request(-1, style.GRID_CELL_SIZE)
vbox.pack_start(self._toolbar, expand=False)
self._toolbar.show()
self._list_view = ChooserListView()
self._list_view.connect('entry-activated', self.__entry_activated_cb)
vbox.pack_start(self._list_view)
self._list_view.show()
self._toolbar.set_mount_point('/')
width = gtk.gdk.screen_width() - style.GRID_CELL_SIZE * 2
height = gtk.gdk.screen_height() - style.GRID_CELL_SIZE * 2
self.set_size_request(width, height)
if what_filter:
self._toolbar.set_what_filter(what_filter)
def __init__(self, parent=None, what_filter=''):
gtk.Window.__init__(self)
self.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
self.set_decorated(False)
self.set_position(gtk.WIN_POS_CENTER_ALWAYS)
self.set_border_width(style.LINE_WIDTH)
self._selected_object_id = None
self.add_events(gtk.gdk.VISIBILITY_NOTIFY_MASK)
self.connect('visibility-notify-event',
self.__visibility_notify_event_cb)
self.connect('delete-event', self.__delete_event_cb)
self.connect('key-press-event', self.__key_press_event_cb)
if parent is None:
logging.warning('ObjectChooser: No parent window specified')
else:
self.connect('realize', self.__realize_cb, parent)
screen = wnck.screen_get_default()
screen.connect('window-closed', self.__window_closed_cb, parent)
vbox = gtk.VBox()
self.add(vbox)
vbox.show()
title_box = TitleBox()
title_box.connect('volume-changed', self.__volume_changed_cb)
title_box.close_button.connect('clicked',
self.__close_button_clicked_cb)
title_box.set_size_request(-1, style.GRID_CELL_SIZE)
vbox.pack_start(title_box, expand=False)
title_box.show()
separator = gtk.HSeparator()
vbox.pack_start(separator, expand=False)
separator.show()
self._toolbar = SearchToolbar()
self._toolbar.connect('query-changed', self.__query_changed_cb)
self._toolbar.set_size_request(-1, style.GRID_CELL_SIZE)
vbox.pack_start(self._toolbar, expand=False)
self._toolbar.show()
self._list_view = ChooserListView()
self._list_view.connect('entry-activated', self.__entry_activated_cb)
vbox.pack_start(self._list_view)
self._list_view.show()
self._toolbar.set_mount_point('/')
width = gtk.gdk.screen_width() - style.GRID_CELL_SIZE * 2
height = gtk.gdk.screen_height() - style.GRID_CELL_SIZE * 2
self.set_size_request(width, height)
if what_filter:
self._toolbar.set_what_filter(what_filter)
def __on_idle(self):
self.globals = Globals()
self.autohide_sid = None
self.should_autohide = True
self.hide_inhibit_cookie = None
self.geometry_time = 0
self.last_geometry_window = lambda: None
self.windows = weakref.WeakKeyDictionary()
self.border_distances = weakref.WeakKeyDictionary()
self.old_child = self.get_child()
self.wnck_screen = wnck.screen_get_default()
gdk_screen = gtk.gdk.screen_get_default()
self.icon = self.get_icon()
self.remove(self.old_child)
self.alignment = gtk.Alignment()
self.add(self.alignment)
self.alignment.show()
self.db = dockbarx.dockbar.DockBar(self)
self.db.set_parent_window_reporting(True)
self.db.load()
# Inactive dockbarx's size overflow management
self.db.set_max_size(3000)
if self.get_pos_type() == gtk.POS_RIGHT:
self.db.set_orient("right")
self.alignment.set(1, 0, 0, 0)
elif self.get_pos_type() == gtk.POS_TOP:
self.db.set_orient("up")
self.alignment.set(0, 0, 0, 0)
elif self.get_pos_type() == gtk.POS_LEFT:
self.db.set_orient("left")
self.alignment.set(0, 0, 0, 0)
else:
self.db.set_orient("down")
self.alignment.set(0, 1, 0, 0)
container = self.db.get_container()
if self.db.get_orient() in ("down", "up"):
container.set_size_request(-1, self.get_size() + \
self.icon.get_offset() + 5)
else:
container.set_size_request(self.get_size() + \
self.icon.get_offset() + 5, -1)
self.alignment.add(container)
self.connect("size-changed", self.__on_size_changed)
self.connect("offset-changed", self.__on_size_changed)
self.connect("position-changed", self.__on_position_changed)
self.globals.connect("awn-behavior-changed",
self.__on_behavior_changed)
container.show_all()
self.show()
self.wnck_screen.connect("active-window-changed",
self.__on_active_window_changed)
gobject.timeout_add(200, self.__update_autohide)
for window in self.db.get_windows():
self.add_window(window)
self.db_loaded = True
self.__compute_should_autohide()
def _do_reload_menu(self):
if not self.active:
return
this_items = {}
if self._mode == "applications":
if self.bamf_matcher != None:
for window in self.bamf_matcher.RunningApplications():
try:
item = self._get_item_for_bamf_application(window)
this_items[item.id] = item
except Exception as e:
logger.debug("Could not get info from BAMF", exc_info = e)
pass
else:
import wnck
screen = wnck.screen_get_default()
for window in screen.get_windows():
pid = window.get_pid()
if pid > 0:
item = self._get_menu_item(pid)
item.process_name = window.get_name()
this_items[item.id] = item
pixbuf = window.get_icon()
if pixbuf:
item.icon = g15cairo.pixbuf_to_surface(pixbuf)
else:
for process_id in gtop.proclist():
process_id = "%d" % process_id
try :
pid = int(process_id)
proc_state = gtop.proc_state(pid)
proc_args = gtop.proc_args(pid)
if self._mode == "all" or ( self._mode != "all" and proc_state.uid == os.getuid()):
item = self._get_menu_item(pid)
item.icon = None
item.process_name = self._get_process_name(proc_args, proc_state.cmd)
this_items[item.id] = item
except Exception as e:
logger.debug("Process may have disappeared", exc_info = e)
# In case the process disappears
pass
# Remove any missing items
for item in self.menu.get_children():
if not item.id in this_items:
self.menu.remove_child(item)
# Make sure selected still exists
if self.menu.selected != None and self.menu.get_child_by_id(self.menu.selected.id) is None:
if len(self.menu.get_child_count()) > 0:
self.menu.selected = self.menu.get_children()[0]
else:
self.menu.selected = None
self.page.mark_dirty()
self.screen.redraw(self.page)
def closeApp(self):
if self.name in ("dde-desktop", "Dock", "running script"):
return
screen = wnck.screen_get_default()
while gtk.events_pending():
gtk.main_iteration()
print "Closed Window: name[%s] xid[%s]" % (self.name, self.xid)
wrapped_window = gtk.gdk.window_foreign_new(int(self.xid))
wrapped_window.destroy()
def __init__(self):
try:
import wnck
except:
pass
else:
self.screen = wnck.screen_get_default()
self.wins=[]
self.win=None
def check_win(): if __name__ == '__main__': screen = wnck.screen_get_default() screen.force_update() while True: while gtk.events_pending(): gtk.main_iteration() return screen.get_active_window().get_name()
def __init__(self, window):
gobject.GObject.__init__(self)
self.globals = Globals()
self.globals.connect('color-changed', self.update_label_state)
self.globals.connect('show-only-current-monitor-changed',
self.on_show_only_current_monitor_changed)
self.globals.connect('show-previews-changed',
self.on_show_preview_changed)
self.screen = wnck.screen_get_default()
self.name = window.get_name()
self.window = window
self.is_active_window = False
self.needs_attention = False
self.opacified = False
self.button_pressed = False
self.window_button = CairoWindowButton()
self.label = gtk.Label()
self.label.set_alignment(0, 0.5)
self.on_window_name_changed(self.window)
if window.needs_attention():
self.needs_attention = True
self.window_button_icon = gtk.Image()
self.on_window_icon_changed(window)
self.preview_image = None
self.on_show_preview_changed()
self.update_label_state()
#--- 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.geometry_changed_event = None
self.on_show_only_current_monitor_changed()
#--- D'n'D
self.window_button.drag_dest_set(gtk.DEST_DEFAULT_HIGHLIGHT, [], 0)
self.window_button.connect("drag_motion", self.on_button_drag_motion)
self.window_button.connect("drag_leave", self.on_button_drag_leave)
self.button_drag_entered = False
self.dnd_select_window = None
def __init__(self, dbx_dict):
DockXApplet.__init__(self, dbx_dict)
self.menu = gtk.Menu()
preferences_item = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES)
preferences_item.connect('activate', self.open_preferences)
self.menu.insert(preferences_item, 0)
self.menu.show_all()
self.connect("clicked", self.on_clicked)
self.shown_window = None
self.active_window = None
self.aw_state_handler = None
self.container = None
#~ wnck.set_client_type(wnck.CLIENT_TYPE_PAGER)
self.screen = wnck.screen_get_default()
self.screen.force_update()
#--- Gconf settings
gconf_set = {
str: GCONF_CLIENT.set_string,
bool: GCONF_CLIENT.set_bool,
int: GCONF_CLIENT.set_int
}
for name, value in settings.items():
gc_value = None
try:
gc_value = GCONF_CLIENT.get_value(GCONF_DIR + '/' + name)
except:
gconf_set[type(value)](GCONF_DIR + '/' + name, value)
else:
if type(gc_value) != type(value):
gconf_set[type(value)](GCONF_DIR + '/' + name, value)
else:
settings[name] = gc_value
GCONF_CLIENT.add_dir(GCONF_DIR, gconf.CLIENT_PRELOAD_NONE)
GCONF_CLIENT.notify_add(GCONF_DIR, self.on_gconf_changed, None)
self.window_state = 'active'
self.label = gtk.Label()
self.label_box = gtk.EventBox()
self.label_box.set_visible_window(False)
self.label_box.add(self.label)
self.label_box.connect("button-press-event", self.on_label_press_event)
self.on_alignment_changed()
self.repack()
self.screen.connect("active-window-changed",
self.on_active_window_changed)
self.screen.connect("window-closed", self.on_window_closed)
self.on_active_window_changed(self.screen)
self.show()
def get_active_window():
"""
Get the currently active window.
Returns
-------
string :
Name of the currently active window.
"""
import sys
active_window_name = None
if sys.platform in ['linux', 'linux2']:
# Alternatives: http://unix.stackexchange.com/q/38867/4784
try:
import wnck
except ImportError:
logging.info("wnck not installed")
wnck = None
if wnck is not None:
screen = wnck.screen_get_default()
screen.force_update()
window = screen.get_active_window()
if window is not None:
pid = window.get_pid()
with open("/proc/{pid}/cmdline".format(pid=pid)) as f:
active_window_name = f.read()
else:
try:
from gi.repository import Gtk, Wnck
gi = "Installed"
except ImportError:
logging.info("gi.repository not installed")
gi = None
if gi is not None:
Gtk.init([]) # necessary if not using a Gtk.main() loop
screen = Wnck.Screen.get_default()
screen.force_update() # recommended per Wnck documentation
active_window = screen.get_active_window()
pid = active_window.get_pid()
with open("/proc/{pid}/cmdline".format(pid=pid)) as f:
active_window_name = f.read()
elif sys.platform in ['Windows', 'win32', 'cygwin']:
# http://stackoverflow.com/a/608814/562769
import win32gui
window = win32gui.GetForegroundWindow()
active_window_name = win32gui.GetWindowText(window)
elif sys.platform in ['Mac', 'darwin', 'os2', 'os2emx']:
# http://stackoverflow.com/a/373310/562769
from AppKit import NSWorkspace
active_window_name = (NSWorkspace.sharedWorkspace().activeApplication(
)['NSApplicationName'])
else:
print("sys.platform={platform} is unknown. Please report.".format(
platform=sys.platform))
print(sys.version)
return active_window_name
def get_windows(self):
"Libwnck list of currently open windows."
# Get the current screen.
screen = wnck.screen_get_default()
# Object list of windows in screen.
windows = screen.get_windows()
# Return the actual list of windows or an empty list.
return [win.get_icon_name() for win in windows if len(windows)]
