c2275c4f4f
When pasting a string on the search entry that triggers suggestions (google, etc) and this is done on the favorites tab, a cycle of changed events occurs. It throws an exception, although everything still seems to work. With this fix the search entry isn't modified when changing tabs.
1820 lines
76 KiB
Python
Executable File
1820 lines
76 KiB
Python
Executable File
#!/usr/bin/env python
|
|
|
|
import gi
|
|
gi.require_version("Gtk", "2.0")
|
|
|
|
from gi.repository import Gtk, Pango, Gdk, Gio, GLib
|
|
|
|
import os
|
|
import time
|
|
import string
|
|
import gettext
|
|
import threading
|
|
import commands
|
|
import subprocess
|
|
import filecmp
|
|
import ctypes
|
|
from ctypes import *
|
|
from easybuttons import *
|
|
from execute import Execute
|
|
from easygsettings import EasyGSettings
|
|
from easyfiles import *
|
|
|
|
gtk = CDLL("libgtk-x11-2.0.so.0")
|
|
|
|
|
|
from filemonitor import monitor as filemonitor
|
|
|
|
#import xdg.Menu
|
|
import matemenu
|
|
|
|
from user import home
|
|
|
|
# i18n
|
|
gettext.install("mintmenu", "/usr/share/linuxmint/locale")
|
|
|
|
class PackageDescriptor():
|
|
def __init__(self, name, summary, description):
|
|
self.name = name
|
|
self.summary = summary
|
|
self.description = description
|
|
|
|
def print_timing(func):
|
|
def wrapper(*arg):
|
|
t1 = time.time()
|
|
res = func(*arg)
|
|
t2 = time.time()
|
|
print '%s took %0.3f ms' % (func.func_name, (t2-t1)*1000.0)
|
|
return res
|
|
return wrapper
|
|
|
|
# Evil patching
|
|
#def xdgParsePatched(filename=None):
|
|
# # conver to absolute path
|
|
# if filename and not os.path.isabs(filename):
|
|
# filename = xdg.Menu.__getFileName(filename)
|
|
#
|
|
# # use default if no filename given
|
|
# if not filename:
|
|
# filename = xdg.Menu.__getFileName("applications.menu")
|
|
#
|
|
# if not filename:
|
|
# raise xdg.Menu.ParsingError(_("File not found"), "/etc/xdg/menus/applications.menu")
|
|
#
|
|
# # check if it is a .menu file
|
|
# if not os.path.splitext(filename)[1] == ".menu":
|
|
# raise xdg.Menu.ParsingError(_("Not a .menu file"), filename)
|
|
#
|
|
# # create xml parser
|
|
# try:
|
|
# doc = xdg.Menu.xml.dom.minidom.parse(filename)
|
|
# except xdg.Menu.xml.parsers.expat.ExpatError:
|
|
# raise xdg.Menu.ParsingError(_("Not a valid .menu file"), filename)
|
|
#
|
|
# # parse menufile
|
|
# xdg.Menu.tmp["Root"] = ""
|
|
# xdg.Menu.tmp["mergeFiles"] = []
|
|
# xdg.Menu.tmp["DirectoryDirs"] = []
|
|
# xdg.Menu.tmp["cache"] = xdg.Menu.MenuEntryCache()
|
|
#
|
|
# xdg.Menu.__parse(doc, filename, xdg.Menu.tmp["Root"])
|
|
# xdg.Menu.__parsemove(xdg.Menu.tmp["Root"])
|
|
# xdg.Menu.__postparse(xdg.Menu.tmp["Root"])
|
|
#
|
|
# xdg.Menu.tmp["Root"].Doc = doc
|
|
# xdg.Menu.tmp["Root"].Filename = filename
|
|
#
|
|
# # generate the menu
|
|
# xdg.Menu.__genmenuNotOnlyAllocated(xdg.Menu.tmp["Root"])
|
|
# xdg.Menu.__genmenuOnlyAllocated(xdg.Menu.tmp["Root"])
|
|
#
|
|
# # and finally sort
|
|
# xdg.Menu.sort(xdg.Menu.tmp["Root"])
|
|
# xdg.Menu.tmp["Root"].Files = xdg.Menu.tmp["mergeFiles"] + [ xdg.Menu.tmp["Root"].Filename ]
|
|
# return xdg.Menu.tmp["Root"]
|
|
#
|
|
#xdg.Menu.parse = xdgParsePatched
|
|
|
|
# Helper function for retrieving the user's location for storing new or modified menu items
|
|
def get_user_item_path():
|
|
item_dir = None
|
|
|
|
if os.environ.has_key('XDG_DATA_HOME'):
|
|
item_dir = os.path.join(os.environ['XDG_DATA_HOME'], 'applications')
|
|
else:
|
|
item_dir = os.path.join(os.environ['HOME'], '.local', 'share', 'applications')
|
|
|
|
if not os.path.isdir(item_dir):
|
|
os.makedirs(item_dir)
|
|
|
|
return item_dir
|
|
|
|
def get_system_item_paths():
|
|
item_dir = None
|
|
|
|
if os.environ.has_key('XDG_DATA_DIRS'):
|
|
item_dirs = os.environ['XDG_DATA_DIRS'].split(":")
|
|
else:
|
|
item_dirs = [os.path.join('usr', 'share')]
|
|
|
|
return item_dirs
|
|
|
|
def rel_path(target, base=os.curdir):
|
|
|
|
if not os.path.exists(target):
|
|
raise OSError, 'Target does not exist: '+target
|
|
|
|
if not os.path.isdir(base):
|
|
raise OSError, 'Base is not a directory or does not exist: '+base
|
|
|
|
base_list = (os.path.abspath(base)).split(os.sep)
|
|
target_list = (os.path.abspath(target)).split(os.sep)
|
|
|
|
for i in range(min(len(base_list), len(target_list))):
|
|
if base_list[i] <> target_list[i]: break
|
|
else:
|
|
i += 1
|
|
|
|
rel_list = [os.pardir] * (len(base_list)-i) + target_list[i:]
|
|
|
|
return os.path.join(*rel_list)
|
|
|
|
|
|
class Menu:
|
|
def __init__( self, MenuToLookup ):
|
|
self.tree = matemenu.lookup_tree( MenuToLookup )
|
|
self.directory = self.tree.get_root_directory()
|
|
|
|
def getMenus( self, parent=None ):
|
|
if parent == None:
|
|
#gives top-level "Applications" item
|
|
yield self.tree.root
|
|
else:
|
|
for menu in parent.get_contents():
|
|
if menu.get_type() == matemenu.TYPE_DIRECTORY and self.__isVisible( menu ):
|
|
yield menu
|
|
|
|
def getItems( self, menu ):
|
|
for item in menu.get_contents():
|
|
if item.get_type() == matemenu.TYPE_ENTRY and item.get_desktop_file_id()[-19:] != '-usercustom.desktop' and self.__isVisible( item ):
|
|
yield item
|
|
|
|
def __isVisible( self, item ):
|
|
if item.get_type() == matemenu.TYPE_ENTRY:
|
|
return not ( item.get_is_excluded() or item.get_is_nodisplay() )
|
|
if item.get_type() == matemenu.TYPE_DIRECTORY and len( item.get_contents() ):
|
|
return True
|
|
|
|
|
|
|
|
class SuggestionButton ( Gtk.Button ):
|
|
|
|
def __init__( self, iconName, iconSize, label ):
|
|
Gtk.Button.__init__( self )
|
|
self.iconName = iconName
|
|
self.set_relief( Gtk.ReliefStyle.NONE )
|
|
self.set_size_request( -1, -1 )
|
|
Align1 = Gtk.Alignment()
|
|
Align1.set( 0, 0.5, 1.0, 0 )
|
|
HBox1 = Gtk.HBox()
|
|
labelBox = Gtk.VBox( False, 2 )
|
|
self.image = Gtk.Image()
|
|
self.image.set_from_stock( self.iconName, iconSize )
|
|
self.image.show()
|
|
HBox1.pack_start( self.image, False, False, 5 )
|
|
self.label = Gtk.Label()
|
|
self.label.set_ellipsize( Pango.EllipsizeMode.END )
|
|
self.label.set_alignment( 0.0, 1.0 )
|
|
self.label.show()
|
|
labelBox.pack_start( self.label, True, True, 2 )
|
|
labelBox.show()
|
|
HBox1.pack_start( labelBox, True, True, 2 )
|
|
HBox1.show()
|
|
Align1.add( HBox1 )
|
|
Align1.show()
|
|
self.add( Align1 )
|
|
self.show()
|
|
|
|
def set_image(self, path):
|
|
self.image.set_from_file(path)
|
|
|
|
def set_text( self, text):
|
|
self.label.set_markup(text)
|
|
|
|
def set_icon_size (self, size):
|
|
self.image.set_from_stock( self.iconName, size )
|
|
|
|
class TargetEntry(Structure):
|
|
_fields_ = [("target", c_char_p),
|
|
("flags", c_int),
|
|
("info", c_int)]
|
|
|
|
class pluginclass( object ):
|
|
TARGET_TYPE_TEXT = 80
|
|
array2 = TargetEntry * 2
|
|
toButton = array2( ("text/uri-list", 0, TARGET_TYPE_TEXT), ("text/uri-list", 0, TARGET_TYPE_TEXT) )
|
|
TARGET_TYPE_FAV = 81
|
|
array = TargetEntry * 3
|
|
toFav = array( ( "FAVORITES", Gtk.TargetFlags.SAME_APP, 81 ), ( "text/plain", 0, 100 ), ( "text/uri-list", 0, 101 ) )
|
|
array1 = TargetEntry * 2
|
|
fromFav = array1( ("FAVORITES", Gtk.TargetFlags.SAME_APP, 81), ("FAVORITES", Gtk.TargetFlags.SAME_APP, 81) )
|
|
|
|
@print_timing
|
|
def __init__( self, mintMenuWin, toggleButton, de ):
|
|
self.mintMenuWin = mintMenuWin
|
|
|
|
self.mainMenus = [ ]
|
|
|
|
self.toggleButton = toggleButton
|
|
self.de = de
|
|
|
|
self.builder = Gtk.Builder()
|
|
# The Glade file for the plugin
|
|
self.builder.add_from_file (os.path.join( os.path.dirname( __file__ ), "applications.glade" ))
|
|
|
|
# Read GLADE file
|
|
self.searchEntry =self.builder.get_object( "searchEntry" )
|
|
self.searchButton =self.builder.get_object( "searchButton" )
|
|
self.showAllAppsButton =self.builder.get_object( "showAllAppsButton" )
|
|
self.showFavoritesButton =self.builder.get_object( "showFavoritesButton" )
|
|
self.applicationsBox =self.builder.get_object( "applicationsBox" )
|
|
self.categoriesBox =self.builder.get_object( "categoriesBox" )
|
|
self.favoritesBox =self.builder.get_object( "favoritesBox" )
|
|
self.applicationsScrolledWindow =self.builder.get_object( "applicationsScrolledWindow" )
|
|
|
|
#i18n
|
|
self.builder.get_object("searchLabel").set_text("<span weight='bold'>" + _("Search:") + "</span>")
|
|
self.builder.get_object("searchLabel").set_use_markup(True)
|
|
self.builder.get_object("label6").set_text(_("Favorites"))
|
|
self.builder.get_object("label3").set_text(_("Favorites"))
|
|
self.builder.get_object("label7").set_text(_("All applications"))
|
|
self.builder.get_object("label2").set_text(_("Applications"))
|
|
|
|
self.headingstocolor = [self.builder.get_object("label6"),self.builder.get_object("label2")]
|
|
|
|
self.numApps = 0
|
|
# These properties are NECESSARY to maintain consistency
|
|
|
|
# Set 'window' property for the plugin (Must be the root widget)
|
|
self.window =self.builder.get_object( "mainWindow" )
|
|
|
|
# Set 'heading' property for plugin
|
|
self.heading = ""#_("Applications")
|
|
|
|
# This should be the first item added to the window in glade
|
|
self.content_holder =self.builder.get_object( "Applications" )
|
|
|
|
# Items to get custom colors
|
|
self.itemstocolor = [self.builder.get_object( "viewport1" ),self.builder.get_object( "viewport2" ),self.builder.get_object( "viewport3" ) ]
|
|
|
|
# Unset all timers
|
|
self.filterTimer = None
|
|
self.menuChangedTimer = None
|
|
# Hookup for text input
|
|
self.content_holder.connect( "key-press-event", self.keyPress )
|
|
|
|
self.favoritesBox.connect( "drag-data-received", self.ReceiveCallback )
|
|
|
|
gtk.gtk_drag_dest_set ( hash(self.favoritesBox), Gtk.DestDefaults.MOTION | Gtk.DestDefaults.HIGHLIGHT | Gtk.DestDefaults.DROP, self.toButton, 2, Gdk.DragAction.COPY )
|
|
self.showFavoritesButton.connect( "drag-data-received", self.ReceiveCallback )
|
|
gtk.gtk_drag_dest_set ( hash(self.showFavoritesButton), Gtk.DestDefaults.MOTION | Gtk.DestDefaults.HIGHLIGHT | Gtk.DestDefaults.DROP, self.toButton, 2, Gdk.DragAction.COPY )
|
|
|
|
# self.searchButton.connect( "button_release_event", self.SearchWithButton )
|
|
try:
|
|
# GSettings stuff
|
|
self.settings = EasyGSettings( "com.linuxmint.mintmenu.plugins.applications" )
|
|
self.GetGSettingsEntries()
|
|
self.settings.notifyAdd( "icon-size", self.changeIconSize )
|
|
self.settings.notifyAdd( "favicon-size", self.changeFavIconSize )
|
|
self.settings.notifyAdd( "height", self.changePluginSize )
|
|
self.settings.notifyAdd( "width", self.changePluginSize )
|
|
self.settings.notifyAdd( "categories-mouse-over", self.changeCategoriesMouseOver )
|
|
self.settings.notifyAdd( "swap-generic-name", self.changeSwapGenericName )
|
|
self.settings.notifyAdd( "show-category-icons", self.changeShowCategoryIcons )
|
|
self.settings.notifyAdd( "show-application-comments", self.changeShowApplicationComments )
|
|
self.settings.notifyAdd( "use-apt", self.switchAPTUsage)
|
|
self.settings.notifyAdd( "fav-cols", self.changeFavCols )
|
|
self.settings.notifyAdd( "remember-filter", self.changeRememberFilter)
|
|
|
|
self.settings.bindGSettingsEntryToVar( "int", "category-hover-delay", self, "categoryhoverdelay" )
|
|
self.settings.bindGSettingsEntryToVar( "bool", "do-not-filter", self, "donotfilterapps" )
|
|
self.settings.bindGSettingsEntryToVar( "string", "search-command", self, "searchtool" )
|
|
self.settings.bindGSettingsEntryToVar( "int", "default-tab", self, "defaultTab" )
|
|
except Exception, detail:
|
|
print detail
|
|
self.currentFavCol = 0
|
|
self.favorites = []
|
|
|
|
self.content_holder.set_size_request( self.width, self.height )
|
|
self.categoriesBox.set_size_request( self.width / 3, -1 )
|
|
self.applicationsBox.set_size_request( self.width / 2, -1 )
|
|
|
|
self.buildingButtonList = False
|
|
self.stopBuildingButtonList = False
|
|
|
|
self.categoryList = []
|
|
self.applicationList = []
|
|
#self.menuFileMonitors = []
|
|
|
|
#dirty ugly hack, to get favorites drag origin position
|
|
self.drag_origin = None
|
|
|
|
self.rebuildLock = False
|
|
self.activeFilter = (1, "", self.searchEntry)
|
|
|
|
self.adminMenu = None
|
|
|
|
for mainitems in [ "mate-applications.menu", "mate-settings.menu" ]:
|
|
mymenu = Menu( mainitems )
|
|
mymenu.tree.add_monitor( self.menuChanged, None )
|
|
#for f in mymenu.directory.Files:
|
|
# self.menuFileMonitors.append( filemonitor.addMonitor(f, self.onMenuChanged, mymenu.directory.Filename ) )
|
|
#for f in mymenu.directory.AppDirs:
|
|
# self.menuFileMonitors.append( filemonitor.addMonitor(f, self.onMenuChanged, mymenu.directory.Filename ) )
|
|
|
|
self.refresh_apt_cache()
|
|
self.suggestions = []
|
|
self.current_suggestion = None
|
|
self.panel = "top"
|
|
self.panel_position = -1
|
|
|
|
self.builder.get_object("searchButton").connect( "button-press-event", self.searchPopup )
|
|
|
|
def refresh_apt_cache(self):
|
|
if self.useAPT:
|
|
os.system("mkdir -p %s/.linuxmint/mintMenu/" % home)
|
|
os.system("/usr/lib/linuxmint/mintMenu/plugins/get_apt_cache.py > %s/.linuxmint/mintMenu/apt.cache &" % home)
|
|
|
|
def get_panel(self):
|
|
panelsettings = Gio.Settings.new("org.mate.panel")
|
|
applet_list = panelsettings.get_strv("object-id-list")
|
|
for applet in applet_list:
|
|
object_schema = Gio.Settings.new_with_path("org.mate.panel.object", "/org/mate/panel/objects/%s/" % (applet))
|
|
keys = object_schema.list_keys()
|
|
if "applet-iid" in keys:
|
|
iid = object_schema.get_string("applet-iid")
|
|
if iid is not None and iid.find("MintMenu") != -1:
|
|
self.panel = object_schema.get_string("toplevel-id")
|
|
self.panel_position = object_schema.get_int("position") + 1
|
|
|
|
def apturl_install(self, widget, pkg_name):
|
|
if os.path.exists("/usr/bin/apturl"):
|
|
os.system("/usr/bin/apturl apt://%s &" % pkg_name)
|
|
else:
|
|
os.system("xdg-open apt://" + pkg_name + " &")
|
|
self.mintMenuWin.hide()
|
|
|
|
def __del__( self ):
|
|
print u"Applications plugin deleted"
|
|
|
|
def wake (self) :
|
|
pass
|
|
|
|
def destroy( self ):
|
|
self.content_holder.destroy()
|
|
self.searchEntry.destroy()
|
|
self.searchButton.destroy()
|
|
self.showAllAppsButton.destroy()
|
|
self.showFavoritesButton.destroy()
|
|
self.applicationsBox.destroy()
|
|
self.categoriesBox.destroy()
|
|
self.favoritesBox.destroy()
|
|
|
|
self.settings.notifyRemoveAll()
|
|
|
|
#for mId in self.menuFileMonitors:
|
|
# filemonitor.removeMonitor( mId )
|
|
|
|
def changePluginSize( self, settings, key, args ):
|
|
if key == "width":
|
|
self.width = settings.get_int(key)
|
|
self.categoriesBox.set_size_request( self.width / 3, -1 )
|
|
self.applicationsBox.set_size_request( self.width / 2, -1 )
|
|
|
|
elif key == "height":
|
|
self.heigth = settings.get_int(key)
|
|
self.content_holder.set_size_request( self.width, self.height )
|
|
|
|
def changeSwapGenericName( self, settings, key, args ):
|
|
self.swapgeneric = settings.get_boolean(key)
|
|
|
|
for child in self.favoritesBox:
|
|
if isinstance( child, FavApplicationLauncher):
|
|
child.setSwapGeneric( self.swapgeneric )
|
|
|
|
def changeShowCategoryIcons( self, settings, key, args ):
|
|
self.showcategoryicons = settings.get_boolean(key)
|
|
|
|
if self.showcategoryicons:
|
|
categoryIconSize = self.iconSize
|
|
else:
|
|
categoryIconSize = 0
|
|
|
|
for child in self.categoriesBox:
|
|
child.setIconSize( categoryIconSize )
|
|
|
|
def changeIconSize( self, settings, key, args ):
|
|
self.iconSize = settings.get_int(key)
|
|
|
|
if self.showcategoryicons:
|
|
categoryIconSize = self.iconSize
|
|
else:
|
|
categoryIconSize = 0
|
|
|
|
for child in self.categoriesBox:
|
|
child.setIconSize( categoryIconSize )
|
|
|
|
for child in self.applicationsBox:
|
|
try:
|
|
child.setIconSize( self.iconSize )
|
|
except:
|
|
pass
|
|
|
|
def changeFavIconSize( self, settings, key, args ):
|
|
self.faviconsize = settings.get_int(key)
|
|
|
|
for child in self.favoritesBox:
|
|
if isinstance( child, FavApplicationLauncher):
|
|
child.setIconSize( self.faviconsize )
|
|
|
|
def switchAPTUsage( self, settings, key, args ):
|
|
self.useAPT = settings.get_boolean(key)
|
|
self.refresh_apt_cache()
|
|
|
|
def changeRememberFilter( self, settings, key, args):
|
|
self.rememberFilter = settings.get_boolean(key)
|
|
|
|
def changeShowApplicationComments( self, settings, key, args ):
|
|
self.showapplicationcomments = settings.get_boolean(key)
|
|
for child in self.applicationsBox:
|
|
child.setShowComment( self.showapplicationcomments )
|
|
|
|
def changeCategoriesMouseOver( self, settings, key, args ):
|
|
self.categories_mouse_over = settings.get_boolean(key)
|
|
for child in self.categoriesBox:
|
|
if self.categories_mouse_over and not child.mouseOverHandlerIds:
|
|
startId = child.connect( "enter", self.StartFilter, child.filter )
|
|
stopId = child.connect( "leave", self.StopFilter )
|
|
child.mouseOverHandlerIds = ( startId, stopId )
|
|
elif not self.categories_mouse_over and child.mouseOverHandlerIds:
|
|
child.disconnect( child.mouseOverHandlerIds[0] )
|
|
child.disconnect( child.mouseOverHandlerIds[1] )
|
|
child.mouseOverHandlerIds = None
|
|
|
|
def changeFavCols(self, settings, key, args):
|
|
self.favCols = settings.get_int(key)
|
|
for fav in self.favorites:
|
|
self.favoritesBox.remove( fav )
|
|
self.favoritesPositionOnGrid( fav )
|
|
|
|
def RegenPlugin( self, *args, **kargs ):
|
|
self.refresh_apt_cache()
|
|
|
|
# save old config - this is necessary because the app will notified when it sets the default values and you don't want the to reload itself several times
|
|
oldcategories_mouse_over = self.categories_mouse_over
|
|
oldtotalrecent = self.totalrecent
|
|
oldsticky = self.sticky
|
|
oldminimized = self.minimized
|
|
oldicon = self.icon
|
|
oldhideseparator = self.hideseparator
|
|
oldshowapplicationcomments = self.showapplicationcomments
|
|
|
|
self.GetGSettingsEntries()
|
|
|
|
# if the config hasn't changed return
|
|
if oldcategories_mouse_over == self.categories_mouse_over and oldiconsize == self.iconSize and oldfaviconsize == self.faviconsize and oldtotalrecent == self.totalrecent and oldswapgeneric == self.swapgeneric and oldshowcategoryicons == self.showcategoryicons and oldcategoryhoverdelay == self.categoryhoverdelay and oldsticky == self.sticky and oldminimized == self.minimized and oldicon == self.icon and oldhideseparator == self.hideseparator and oldshowapplicationcomments == self.showapplicationcomments:
|
|
return
|
|
|
|
self.Todos()
|
|
self.buildFavorites()
|
|
self.RebuildPlugin()
|
|
|
|
def GetGSettingsEntries( self ):
|
|
|
|
self.categories_mouse_over = self.settings.get( "bool", "categories-mouse-over")
|
|
self.width = self.settings.get( "int", "width")
|
|
self.height = self.settings.get( "int", "height")
|
|
self.donotfilterapps = self.settings.get( "bool", "do-not-filter")
|
|
self.iconSize = self.settings.get( "int", "icon-size")
|
|
self.faviconsize = self.settings.get( "int", "favicon-size")
|
|
self.favCols = self.settings.get( "int", "fav-cols")
|
|
self.swapgeneric = self.settings.get( "bool", "swap-generic-name")
|
|
self.showcategoryicons = self.settings.get( "bool", "show-category-icons")
|
|
self.categoryhoverdelay = self.settings.get( "int", "category-hover-delay")
|
|
self.showapplicationcomments = self.settings.get( "bool", "show-application-comments")
|
|
self.useAPT = self.settings.get( "bool", "use-apt")
|
|
self.rememberFilter = self.settings.get( "bool", "remember-filter")
|
|
|
|
self.lastActiveTab = self.settings.get( "int", "last-active-tab")
|
|
self.defaultTab = self.settings.get( "int", "default-tab")
|
|
|
|
|
|
# Allow plugin to be minimized to the left plugin pane
|
|
self.sticky = self.settings.get( "bool", "sticky")
|
|
self.minimized = self.settings.get( "bool", "minimized")
|
|
|
|
# Search tool
|
|
self.searchtool = self.settings.get( "string", "search-command")
|
|
if self.searchtool == "beagle-search SEARCH_STRING":
|
|
self.searchtool = "mate-search-tool --named \"%s\" --start"
|
|
self.settings.set( "string", "search-command", "mate-search-tool --named \"%s\" --start" )
|
|
|
|
# Plugin icon
|
|
self.icon = self.settings.get( "string", "icon" )
|
|
|
|
# Hide vertical dotted separator
|
|
self.hideseparator = self.settings.get( "bool", "hide-separator")
|
|
|
|
def SetHidden( self, state ):
|
|
if state == True:
|
|
self.settings.set( "bool", "minimized", True )
|
|
else:
|
|
self.settings.set( "bool", "minimized", False )
|
|
|
|
def RebuildPlugin(self):
|
|
self.content_holder.set_size_request( self.width, self.height )
|
|
|
|
def checkMintMenuFolder( self ):
|
|
if os.path.exists( os.path.join( os.path.expanduser( "~" ), ".linuxmint", "mintMenu", "applications" ) ):
|
|
return True
|
|
try:
|
|
os.makedirs( os.path.join( os.path.expanduser( "~" ), ".linuxmint", "mintMenu", "applications" ) )
|
|
return True
|
|
except:
|
|
pass
|
|
|
|
return False
|
|
|
|
def onShowMenu( self ):
|
|
if len( self.favorites ):
|
|
if self.defaultTab == -1:
|
|
self.changeTab( self.lastActiveTab)
|
|
else:
|
|
self.changeTab( (self.defaultTab - 1) * -1 )
|
|
else:
|
|
self.changeTab( 1 )
|
|
|
|
self.searchEntry.select_region( 0, -1 )
|
|
if self.rememberFilter and self.searchEntry.get_text().strip() != "":
|
|
self.Filter(self.activeFilter[2], self.activeFilter[1])
|
|
|
|
def onHideMenu( self ):
|
|
self.settings.set( "int", "last-active-tab", self.lastActiveTab )
|
|
|
|
def changeTab( self, tabNum, clear = True ):
|
|
notebook = self.builder.get_object( "notebook2" )
|
|
if tabNum == 0:
|
|
notebook.set_current_page( 0 )
|
|
elif tabNum == 1:
|
|
notebook.set_current_page( 1 )
|
|
|
|
self.focusSearchEntry(clear)
|
|
self.lastActiveTab = tabNum
|
|
|
|
|
|
def Todos( self ):
|
|
self.searchEntry.connect( "popup-menu", self.blockOnPopup )
|
|
self.searchEntry.connect( "button-press-event", self.blockOnRightPress )
|
|
self.searchEntry.connect( "changed", self.Filter )
|
|
self.searchEntry.connect( "activate", self.Search )
|
|
self.showAllAppsButton.connect( "clicked", lambda widget: self.changeTab( 1 ) )
|
|
self.showFavoritesButton.connect( "clicked", lambda widget: self.changeTab( 0 ) )
|
|
self.buildButtonList()
|
|
|
|
def blockOnPopup( self, *args ):
|
|
self.mintMenuWin.stopHiding()
|
|
return False
|
|
|
|
def blockOnRightPress( self, widget, event ):
|
|
if event.button == 3:
|
|
self.mintMenuWin.stopHiding()
|
|
return False
|
|
|
|
def focusSearchEntry( self, clear = True ):
|
|
# grab_focus() does select all text,
|
|
# restoring the original selection is somehow broken, so just select the end
|
|
# of the existing text, that's the most likely candidate anyhow
|
|
self.searchEntry.grab_focus()
|
|
if self.rememberFilter or not clear:
|
|
gtk.gtk_editable_set_position(hash(self.searchEntry), -1)
|
|
else:
|
|
self.searchEntry.set_text("")
|
|
|
|
def buildButtonList( self ):
|
|
if self.buildingButtonList:
|
|
self.stopBuildingButtonList = True
|
|
GLib.timeout_add( 100, self.buildButtonList )
|
|
return
|
|
|
|
self.stopBuildingButtonList = False
|
|
|
|
self.updateBoxes(False)
|
|
|
|
def categoryBtnFocus( self, widget, event, category ):
|
|
self.scrollItemIntoView( widget )
|
|
self.StartFilter( widget, category )
|
|
|
|
def StartFilter( self, widget, category ):
|
|
# if there is a timer for a different category running stop it
|
|
if self.filterTimer:
|
|
GLib.source_remove( self.filterTimer )
|
|
self.filterTimer = GLib.timeout_add( self.categoryhoverdelay, self.Filter, widget, category )
|
|
|
|
def StopFilter( self, widget ):
|
|
if self.filterTimer:
|
|
GLib.source_remove( self.filterTimer )
|
|
self.filterTimer = None
|
|
|
|
def add_search_suggestions(self, text):
|
|
|
|
text = "<b>%s</b>" % text
|
|
|
|
suggestionButton = SuggestionButton(Gtk.STOCK_ADD, self.iconSize, "")
|
|
suggestionButton.connect("clicked", self.search_google)
|
|
suggestionButton.set_text(_("Search Google for %s") % text)
|
|
suggestionButton.set_image("/usr/lib/linuxmint/mintMenu/search_engines/google.ico")
|
|
self.applicationsBox.add(suggestionButton)
|
|
self.suggestions.append(suggestionButton)
|
|
|
|
suggestionButton = SuggestionButton(Gtk.STOCK_ADD, self.iconSize, "")
|
|
suggestionButton.connect("clicked", self.search_wikipedia)
|
|
suggestionButton.set_text(_("Search Wikipedia for %s") % text)
|
|
suggestionButton.set_image("/usr/lib/linuxmint/mintMenu/search_engines/wikipedia.ico")
|
|
self.applicationsBox.add(suggestionButton)
|
|
self.suggestions.append(suggestionButton)
|
|
|
|
separator = Gtk.EventBox()
|
|
separator.add(Gtk.HSeparator())
|
|
separator.set_visible_window(False)
|
|
separator.set_size_request(-1, 20)
|
|
separator.type = "separator"
|
|
separator.show_all()
|
|
self.applicationsBox.add(separator)
|
|
self.suggestions.append(separator)
|
|
|
|
suggestionButton = SuggestionButton(Gtk.STOCK_ADD, self.iconSize, "")
|
|
suggestionButton.connect("clicked", self.search_dictionary)
|
|
suggestionButton.set_text(_("Lookup %s in Dictionary") % text)
|
|
suggestionButton.set_image("/usr/lib/linuxmint/mintMenu/search_engines/dictionary.png")
|
|
self.applicationsBox.add(suggestionButton)
|
|
self.suggestions.append(suggestionButton)
|
|
|
|
suggestionButton = SuggestionButton(Gtk.STOCK_FIND, self.iconSize, "")
|
|
suggestionButton.connect("clicked", self.Search)
|
|
suggestionButton.set_text(_("Search Computer for %s") % text)
|
|
self.applicationsBox.add(suggestionButton)
|
|
self.suggestions.append(suggestionButton)
|
|
|
|
#self.last_separator = gtk.EventBox()
|
|
#self.last_separator.add(gtk.HSeparator())
|
|
#self.last_separator.set_size_request(-1, 20)
|
|
#self.last_separator.type = "separator"
|
|
#self.mintMenuWin.SetPaneColors( [ self.last_separator ] )
|
|
#self.last_separator.show_all()
|
|
#self.applicationsBox.add(self.last_separator)
|
|
#self.suggestions.append(self.last_separator)
|
|
|
|
def add_apt_filter_results(self, keyword):
|
|
try:
|
|
# Wait to see if the keyword has changed.. before doing anything
|
|
current_keyword = keyword
|
|
current_keyword = self.searchEntry.get_text()
|
|
if keyword != current_keyword:
|
|
return
|
|
found_packages = []
|
|
found_in_name = []
|
|
found_elsewhere = []
|
|
keywords = keyword.split(" ")
|
|
command = "cat %(home)s/.linuxmint/mintMenu/apt.cache" % {'home':home}
|
|
for word in keywords:
|
|
command = "%(command)s | grep %(word)s" % {'command':command, 'word':word}
|
|
pkgs = commands.getoutput(command)
|
|
pkgs = pkgs.split("\n")
|
|
num_pkg_found = 0
|
|
for pkg in pkgs:
|
|
values = string.split(pkg, "###")
|
|
if len(values) == 4:
|
|
status = values[0]
|
|
if (status == "ERROR"):
|
|
print "Could not refresh APT cache"
|
|
elif (status == "CACHE"):
|
|
name = values[1]
|
|
summary = values[2]
|
|
description = values[3].replace("~~~", "\n")
|
|
package = PackageDescriptor(name, summary, description)
|
|
#See if all keywords are in the name (so we put these results at the top of the list)
|
|
some_found = False
|
|
some_not_found = False
|
|
for word in keywords:
|
|
if word in package.name:
|
|
some_found = True
|
|
else:
|
|
some_not_found = True
|
|
if some_found and not some_not_found:
|
|
found_in_name.append(package)
|
|
else:
|
|
found_elsewhere.append(package)
|
|
num_pkg_found+=1
|
|
else:
|
|
print "Invalid status code: " + status
|
|
|
|
found_packages.extend(found_in_name)
|
|
found_packages.extend(found_elsewhere)
|
|
if keyword == self.searchEntry.get_text() and len(found_packages) > 0:
|
|
last_separator = Gtk.EventBox()
|
|
last_separator.add(Gtk.HSeparator())
|
|
last_separator.set_visible_window(False)
|
|
last_separator.set_size_request(-1, 20)
|
|
last_separator.type = "separator"
|
|
last_separator.show_all()
|
|
self.applicationsBox.add(last_separator)
|
|
self.suggestions.append(last_separator)
|
|
#Reduce the number of results to 10 max... it takes a HUGE amount of time to add the GTK box in the menu otherwise..
|
|
if len(found_packages) > 10:
|
|
found_packages = found_packages[:10]
|
|
for pkg in found_packages:
|
|
name = pkg.name
|
|
for word in keywords:
|
|
if word != "":
|
|
name = name.replace(word, "<b>%s</b>" % word);
|
|
suggestionButton = SuggestionButton(Gtk.STOCK_ADD, self.iconSize, "")
|
|
suggestionButton.connect("clicked", self.apturl_install, pkg.name)
|
|
suggestionButton.set_text(_("Install package '%s'") % name)
|
|
suggestionButton.set_tooltip_text("%s\n\n%s\n\n%s" % (pkg.name, pkg.summary, pkg.description))
|
|
suggestionButton.set_icon_size(self.iconSize)
|
|
self.applicationsBox.add(suggestionButton)
|
|
self.suggestions.append(suggestionButton)
|
|
#if cache != self.current_results:
|
|
# self.current_results.append(pkg)
|
|
|
|
#if len(found_packages) == 0:
|
|
# gtk.gdk.threads_enter()
|
|
# try:
|
|
# self.applicationsBox.remove(self.last_separator)
|
|
# self.suggestions.remove(self.last_separator)
|
|
# finally:
|
|
# gtk.gdk.threads_leave()
|
|
|
|
except Exception, detail:
|
|
print detail
|
|
|
|
|
|
def add_apt_filter_results_sync(self, cache, keyword):
|
|
try:
|
|
found_packages = []
|
|
keywords = keyword.split(" ")
|
|
if cache is not None:
|
|
for pkg in cache:
|
|
some_found = False
|
|
some_not_found = False
|
|
for word in keywords:
|
|
if word in pkg.name:
|
|
some_found = True
|
|
else:
|
|
some_not_found = True
|
|
if some_found and not some_not_found:
|
|
found_packages.append(pkg)
|
|
|
|
if len(found_packages) > 0:
|
|
last_separator = Gtk.EventBox()
|
|
last_separator.add(Gtk.HSeparator())
|
|
last_separator.set_visible_window(False)
|
|
last_separator.set_size_request(-1, 20)
|
|
last_separator.type = "separator"
|
|
last_separator.show_all()
|
|
self.applicationsBox.add(last_separator)
|
|
self.suggestions.append(last_separator)
|
|
|
|
for pkg in found_packages:
|
|
name = pkg.name
|
|
for word in keywords:
|
|
if word != "":
|
|
name = name.replace(word, "<b>%s</b>" % word);
|
|
suggestionButton = SuggestionButton(Gtk.STOCK_ADD, self.iconSize, "")
|
|
suggestionButton.connect("clicked", self.apturl_install, pkg.name)
|
|
suggestionButton.set_text(_("Install package '%s'") % name)
|
|
suggestionButton.set_tooltip_text("%s\n\n%s\n\n%s" % (pkg.name, pkg.summary.capitalize(), pkg.description))
|
|
suggestionButton.set_icon_size(self.iconSize)
|
|
self.applicationsBox.add(suggestionButton)
|
|
self.suggestions.append(suggestionButton)
|
|
|
|
#if len(found_packages) == 0:
|
|
# self.applicationsBox.remove(self.last_separator)
|
|
# self.suggestions.remove(self.last_separator)
|
|
|
|
except Exception, detail:
|
|
print detail
|
|
|
|
def Filter( self, widget, category = None ):
|
|
self.filterTimer = None
|
|
|
|
for suggestion in self.suggestions:
|
|
self.applicationsBox.remove(suggestion)
|
|
self.suggestions = []
|
|
|
|
if widget == self.searchEntry:
|
|
if self.donotfilterapps:
|
|
widget.set_text( "" )
|
|
else:
|
|
text = widget.get_text()
|
|
if self.lastActiveTab != 1:
|
|
self.changeTab( 1, clear = False )
|
|
text = widget.get_text()
|
|
showns = False # Are any app shown?
|
|
shownList = []
|
|
for i in self.applicationsBox.get_children():
|
|
shown = i.filterText( text )
|
|
if (shown):
|
|
dupe = False
|
|
for item in shownList:
|
|
if i.desktopFile == item.desktopFile:
|
|
dupe = True
|
|
if dupe:
|
|
i.hide()
|
|
else:
|
|
shownList.append(i)
|
|
showns = True
|
|
if (not showns and os.path.exists("/usr/lib/linuxmint/mintInstall/icon.svg")):
|
|
if len(text) >= 3:
|
|
if self.current_suggestion is not None and self.current_suggestion in text:
|
|
# We're restricting our search...
|
|
self.add_search_suggestions(text)
|
|
#if (len(self.current_results) > 0):
|
|
#self.add_apt_filter_results_sync(self.current_results, text)
|
|
#else:
|
|
GLib.timeout_add (300, self.add_apt_filter_results, text)
|
|
else:
|
|
self.current_results = []
|
|
self.add_search_suggestions(text)
|
|
GLib.timeout_add (300, self.add_apt_filter_results, text)
|
|
|
|
self.current_suggestion = text
|
|
else:
|
|
self.current_suggestion = None
|
|
self.current_results = []
|
|
else:
|
|
self.current_suggestion = None
|
|
self.current_results = []
|
|
|
|
for i in self.categoriesBox.get_children():
|
|
i.released()
|
|
i.set_relief( Gtk.ReliefStyle.NONE )
|
|
|
|
allButton = self.categoriesBox.get_children()[0];
|
|
allButton.set_relief( Gtk.ReliefStyle.HALF )
|
|
self.activeFilter = (0, text, widget)
|
|
else:
|
|
#print "CATFILTER"
|
|
self.activeFilter = (1, category, widget)
|
|
if category == "":
|
|
listedDesktopFiles = []
|
|
for i in self.applicationsBox.get_children():
|
|
if not i.desktop_file_path in listedDesktopFiles:
|
|
listedDesktopFiles.append( i.desktop_file_path )
|
|
i.show_all()
|
|
else:
|
|
i.hide()
|
|
else:
|
|
for i in self.applicationsBox.get_children():
|
|
i.filterCategory( category )
|
|
|
|
for i in self.categoriesBox.get_children():
|
|
i.released()
|
|
i.set_relief( Gtk.ReliefStyle.NONE )
|
|
widget.set_relief( Gtk.ReliefStyle.HALF )
|
|
|
|
self.applicationsScrolledWindow.get_vadjustment().set_value( 0 )
|
|
|
|
def FilterAndClear( self, widget, category = None ):
|
|
self.searchEntry.set_text( "" )
|
|
self.Filter( widget, category )
|
|
|
|
# Forward all text to the search box
|
|
def keyPress( self, widget, event ):
|
|
if event.string.strip() != "" or event.keyval == Gdk.KEY_BackSpace:
|
|
self.searchEntry.grab_focus()
|
|
gtk.gtk_editable_set_position(hash(self.searchEntry), -1)
|
|
self.searchEntry.event( event )
|
|
return True
|
|
|
|
if event.keyval == Gdk.KEY_Down and self.searchEntry.is_focus():
|
|
self.applicationsBox.get_children()[0].grab_focus()
|
|
|
|
return False
|
|
|
|
def favPopup( self, widget, ev ):
|
|
if ev.button == 3:
|
|
if ev.y > widget.get_allocation().height / 2:
|
|
insertBefore = False
|
|
else:
|
|
insertBefore = True
|
|
|
|
if widget.type == "location":
|
|
mTree = Gtk.Menu()
|
|
mTree.set_events(Gdk.EventMask.POINTER_MOTION_MASK | Gdk.EventMask.POINTER_MOTION_HINT_MASK |
|
|
Gdk.EventMask.BUTTON_PRESS_MASK | Gdk.EventMask.BUTTON_RELEASE_MASK)
|
|
#i18n
|
|
|
|
desktopMenuItem = Gtk.MenuItem(_("Add to desktop"))
|
|
panelMenuItem = Gtk.MenuItem(_("Add to panel"))
|
|
separator1 = Gtk.SeparatorMenuItem()
|
|
insertSpaceMenuItem = Gtk.MenuItem(_("Insert space"))
|
|
insertSeparatorMenuItem = Gtk.MenuItem(_("Insert separator"))
|
|
separator2 = Gtk.SeparatorMenuItem()
|
|
startupMenuItem = Gtk.CheckMenuItem(_("Launch when I log in"))
|
|
separator3 = Gtk.SeparatorMenuItem()
|
|
launchMenuItem = Gtk.MenuItem(_("Launch"))
|
|
removeFromFavMenuItem = Gtk.MenuItem(_("Remove from favorites"))
|
|
separator4 = Gtk.SeparatorMenuItem()
|
|
propsMenuItem = Gtk.MenuItem(_("Edit properties"))
|
|
|
|
desktopMenuItem.connect("activate", self.add_to_desktop, widget)
|
|
panelMenuItem.connect("activate", self.add_to_panel, widget)
|
|
insertSpaceMenuItem.connect( "activate", self.onFavoritesInsertSpace, widget, insertBefore )
|
|
insertSeparatorMenuItem.connect( "activate", self.onFavoritesInsertSeparator, widget, insertBefore )
|
|
if widget.isInStartup():
|
|
startupMenuItem.set_active( True )
|
|
startupMenuItem.connect( "toggled", self.onRemoveFromStartup, widget )
|
|
else:
|
|
startupMenuItem.set_active( False )
|
|
startupMenuItem.connect( "toggled", self.onAddToStartup, widget )
|
|
launchMenuItem.connect( "activate", self.onLaunchApp, widget)
|
|
removeFromFavMenuItem.connect( "activate", self.onFavoritesRemove, widget )
|
|
propsMenuItem.connect( "activate", self.onPropsApp, widget)
|
|
|
|
if self.de == "mate":
|
|
mTree.append(desktopMenuItem)
|
|
mTree.append(panelMenuItem)
|
|
mTree.append(separator1)
|
|
mTree.append(insertSpaceMenuItem)
|
|
mTree.append(insertSeparatorMenuItem)
|
|
mTree.append(separator2)
|
|
mTree.append(startupMenuItem)
|
|
mTree.append(separator3)
|
|
mTree.append(launchMenuItem)
|
|
mTree.append(removeFromFavMenuItem)
|
|
mTree.append(separator4)
|
|
mTree.append(propsMenuItem)
|
|
|
|
mTree.show_all()
|
|
self.mintMenuWin.stopHiding()
|
|
gtk.gtk_menu_popup(hash(mTree), None, None, None, None, ev.button, ev.time)
|
|
else:
|
|
mTree = Gtk.Menu()
|
|
mTree.set_events(Gdk.EventMask.POINTER_MOTION_MASK | Gdk.EventMask.POINTER_MOTION_HINT_MASK |
|
|
Gdk.EventMask.BUTTON_PRESS_MASK | Gdk.EventMask.BUTTON_RELEASE_MASK)
|
|
|
|
#i18n
|
|
removeMenuItem = Gtk.MenuItem(_("Remove"))
|
|
insertSpaceMenuItem = Gtk.MenuItem(_("Insert space"))
|
|
insertSeparatorMenuItem = Gtk.MenuItem(_("Insert separator"))
|
|
mTree.append(removeMenuItem)
|
|
mTree.append(insertSpaceMenuItem)
|
|
mTree.append(insertSeparatorMenuItem)
|
|
mTree.show_all()
|
|
|
|
removeMenuItem.connect( "activate", self.onFavoritesRemove, widget )
|
|
insertSpaceMenuItem.connect( "activate", self.onFavoritesInsertSpace, widget, insertBefore )
|
|
insertSeparatorMenuItem.connect( "activate", self.onFavoritesInsertSeparator, widget, insertBefore )
|
|
self.mintMenuWin.stopHiding()
|
|
gtk.gtk_menu_popup(hash(mTree), None, None, None, None, ev.button, ev.time)
|
|
|
|
def menuPopup( self, widget, event ):
|
|
if event.button == 3:
|
|
mTree = Gtk.Menu()
|
|
#i18n
|
|
desktopMenuItem = Gtk.MenuItem(_("Add to desktop"))
|
|
panelMenuItem = Gtk.MenuItem(_("Add to panel"))
|
|
separator1 = Gtk.SeparatorMenuItem()
|
|
favoriteMenuItem = Gtk.CheckMenuItem(_("Show in my favorites"))
|
|
startupMenuItem = Gtk.CheckMenuItem(_("Launch when I log in"))
|
|
separator2 = Gtk.SeparatorMenuItem()
|
|
launchMenuItem = Gtk.MenuItem(_("Launch"))
|
|
uninstallMenuItem = Gtk.MenuItem(_("Uninstall"))
|
|
deleteMenuItem = Gtk.MenuItem(_("Delete from menu"))
|
|
separator3 = Gtk.SeparatorMenuItem()
|
|
propsMenuItem = Gtk.MenuItem(_("Edit properties"))
|
|
|
|
if self.de == "mate":
|
|
mTree.append(desktopMenuItem)
|
|
mTree.append(panelMenuItem)
|
|
mTree.append(separator1)
|
|
|
|
mTree.append(favoriteMenuItem)
|
|
mTree.append(startupMenuItem)
|
|
|
|
mTree.append(separator2)
|
|
|
|
mTree.append(launchMenuItem)
|
|
mTree.append(uninstallMenuItem)
|
|
if home in widget.desktopFile:
|
|
mTree.append(deleteMenuItem)
|
|
deleteMenuItem.connect("activate", self.delete_from_menu, widget)
|
|
|
|
mTree.append(separator3)
|
|
|
|
mTree.append(propsMenuItem)
|
|
|
|
mTree.show_all()
|
|
|
|
desktopMenuItem.connect("activate", self.add_to_desktop, widget)
|
|
panelMenuItem.connect("activate", self.add_to_panel, widget)
|
|
|
|
launchMenuItem.connect( "activate", self.onLaunchApp, widget )
|
|
propsMenuItem.connect( "activate", self.onPropsApp, widget)
|
|
uninstallMenuItem.connect ( "activate", self.onUninstallApp, widget )
|
|
|
|
if self.isLocationInFavorites( widget.desktopFile ):
|
|
favoriteMenuItem.set_active( True )
|
|
favoriteMenuItem.connect( "toggled", self.onRemoveFromFavorites, widget )
|
|
else:
|
|
favoriteMenuItem.set_active( False )
|
|
favoriteMenuItem.connect( "toggled", self.onAddToFavorites, widget )
|
|
|
|
if widget.isInStartup():
|
|
startupMenuItem.set_active( True )
|
|
startupMenuItem.connect( "toggled", self.onRemoveFromStartup, widget )
|
|
else:
|
|
startupMenuItem.set_active( False )
|
|
startupMenuItem.connect( "toggled", self.onAddToStartup, widget )
|
|
|
|
self.mintMenuWin.stopHiding()
|
|
gtk.gtk_menu_popup(hash(mTree), None, None, None, None, event.button, event.time)
|
|
|
|
|
|
def searchPopup( self, widget=None, event=None ):
|
|
menu = Gtk.Menu()
|
|
|
|
menuItem = Gtk.ImageMenuItem(_("Search Google"))
|
|
img = Gtk.Image()
|
|
img.set_from_file('/usr/lib/linuxmint/mintMenu/search_engines/google.ico')
|
|
menuItem.set_image(img)
|
|
menuItem.connect("activate", self.search_google)
|
|
menu.append(menuItem)
|
|
|
|
menuItem = Gtk.ImageMenuItem(_("Search Wikipedia"))
|
|
img = Gtk.Image()
|
|
img.set_from_file('/usr/lib/linuxmint/mintMenu/search_engines/wikipedia.ico')
|
|
menuItem.set_image(img)
|
|
menuItem.connect("activate", self.search_wikipedia)
|
|
menu.append(menuItem)
|
|
|
|
menuItem = Gtk.SeparatorMenuItem()
|
|
menu.append(menuItem)
|
|
|
|
menuItem = Gtk.ImageMenuItem(_("Lookup Dictionary"))
|
|
img = Gtk.Image()
|
|
img.set_from_file('/usr/lib/linuxmint/mintMenu/search_engines/dictionary.png')
|
|
menuItem.set_image(img)
|
|
menuItem.connect("activate", self.search_dictionary)
|
|
menu.append(menuItem)
|
|
|
|
menuItem = Gtk.ImageMenuItem(_("Search Computer"))
|
|
img = Gtk.Image()
|
|
img.set_from_stock(Gtk.STOCK_FIND, self.iconSize)
|
|
menuItem.set_image(img)
|
|
menuItem.connect("activate", self.Search)
|
|
menu.append(menuItem)
|
|
|
|
menuItem = Gtk.SeparatorMenuItem()
|
|
menu.append(menuItem)
|
|
|
|
menuItem = Gtk.ImageMenuItem(_("Find Software"))
|
|
img = Gtk.Image()
|
|
img.set_from_file('/usr/lib/linuxmint/mintMenu/search_engines/software.png')
|
|
menuItem.set_image(img)
|
|
menuItem.connect("activate", self.search_mint_software)
|
|
menu.append(menuItem)
|
|
|
|
menuItem = Gtk.ImageMenuItem(_("Find Tutorials"))
|
|
img = Gtk.Image()
|
|
img.set_from_file('/usr/lib/linuxmint/mintMenu/search_engines/tutorials.png')
|
|
menuItem.set_image(img)
|
|
menuItem.connect("activate", self.search_mint_tutorials)
|
|
menu.append(menuItem)
|
|
|
|
menuItem = Gtk.ImageMenuItem(_("Find Hardware"))
|
|
img = Gtk.Image()
|
|
img.set_from_file('/usr/lib/linuxmint/mintMenu/search_engines/hardware.png')
|
|
menuItem.set_image(img)
|
|
menuItem.connect("activate", self.search_mint_hardware)
|
|
menu.append(menuItem)
|
|
|
|
menuItem =Gtk.ImageMenuItem(_("Find Ideas"))
|
|
img = Gtk.Image()
|
|
img.set_from_file('/usr/lib/linuxmint/mintMenu/search_engines/ideas.png')
|
|
menuItem.set_image(img)
|
|
menuItem.connect("activate", self.search_mint_ideas)
|
|
menu.append(menuItem)
|
|
|
|
menuItem = Gtk.ImageMenuItem(_("Find Users"))
|
|
img = Gtk.Image()
|
|
img.set_from_file('/usr/lib/linuxmint/mintMenu/search_engines/users.png')
|
|
menuItem.set_image(img)
|
|
menuItem.connect("activate", self.search_mint_users)
|
|
menu.append(menuItem)
|
|
|
|
menu.show_all()
|
|
|
|
self.mintMenuWin.stopHiding()
|
|
gtk.gtk_menu_popup(hash(menu), None, None, None, None, event.button, event.time)
|
|
|
|
#menu.attach_to_widget(self.searchButton, None)
|
|
#menu.reposition()
|
|
#menu.reposition()
|
|
#self.mintMenuWin.grab()
|
|
self.focusSearchEntry(clear = False)
|
|
return True
|
|
|
|
def pos_func(self, menu=None):
|
|
rect = self.searchButton.get_allocation()
|
|
x = rect.x + rect.width
|
|
y = rect.y + rect.height
|
|
return (x, y, False)
|
|
|
|
def search_google(self, widget):
|
|
text = self.searchEntry.get_text()
|
|
text = text.replace(" ", "+")
|
|
os.system("xdg-open \"http://www.google.com/cse?cx=002683415331144861350%3Atsq8didf9x0&ie=utf-8&sa=Search&q=" + text + "\" &")
|
|
self.mintMenuWin.hide()
|
|
|
|
def search_wikipedia(self, widget):
|
|
text = self.searchEntry.get_text()
|
|
text = text.replace(" ", "+")
|
|
os.system("xdg-open \"http://en.wikipedia.org/wiki/Special:Search?search=" + text + "\" &")
|
|
self.mintMenuWin.hide()
|
|
|
|
def search_dictionary(self, widget):
|
|
text = self.searchEntry.get_text()
|
|
os.system("mate-dictionary \"" + text + "\" &")
|
|
self.mintMenuWin.hide()
|
|
|
|
def search_mint_tutorials(self, widget):
|
|
text = self.searchEntry.get_text()
|
|
text = text.replace(" ", "%20")
|
|
os.system("xdg-open \"http://community.linuxmint.com/index.php/tutorial/search/0/" + text + "\" &")
|
|
self.mintMenuWin.hide()
|
|
|
|
def search_mint_ideas(self, widget):
|
|
text = self.searchEntry.get_text()
|
|
text = text.replace(" ", "%20")
|
|
os.system("xdg-open \"http://community.linuxmint.com/index.php/idea/search/0/" + text + "\" &")
|
|
self.mintMenuWin.hide()
|
|
|
|
def search_mint_users(self, widget):
|
|
text = self.searchEntry.get_text()
|
|
text = text.replace(" ", "%20")
|
|
os.system("xdg-open \"http://community.linuxmint.com/index.php/user/search/0/" + text + "\" &")
|
|
self.mintMenuWin.hide()
|
|
|
|
def search_mint_hardware(self, widget):
|
|
text = self.searchEntry.get_text()
|
|
text = text.replace(" ", "%20")
|
|
os.system("xdg-open \"http://community.linuxmint.com/index.php/hardware/search/0/" + text + "\" &")
|
|
self.mintMenuWin.hide()
|
|
|
|
def search_mint_software(self, widget):
|
|
text = self.searchEntry.get_text()
|
|
text = text.replace(" ", "%20")
|
|
os.system("xdg-open \"http://community.linuxmint.com/index.php/software/search/0/" + text + "\" &")
|
|
self.mintMenuWin.hide()
|
|
|
|
|
|
def add_to_desktop(self, widget, desktopEntry):
|
|
try:
|
|
# Determine where the Desktop folder is (could be localized)
|
|
import sys, commands
|
|
sys.path.append('/usr/lib/linuxmint/common')
|
|
from configobj import ConfigObj
|
|
config = ConfigObj(home + "/.config/user-dirs.dirs")
|
|
desktopDir = home + "/Desktop"
|
|
tmpdesktopDir = config['XDG_DESKTOP_DIR']
|
|
tmpdesktopDir = commands.getoutput("echo " + tmpdesktopDir)
|
|
if os.path.exists(tmpdesktopDir):
|
|
desktopDir = tmpdesktopDir
|
|
# Copy the desktop file to the desktop
|
|
os.system("cp \"%s\" \"%s/\"" % (desktopEntry.desktopFile, desktopDir))
|
|
os.system("chmod a+rx %s/*.desktop" % (desktopDir))
|
|
except Exception, detail:
|
|
print detail
|
|
|
|
def add_to_panel(self, widget, desktopEntry):
|
|
self.get_panel()
|
|
i = 0
|
|
panel_schema = Gio.Settings.new("org.mate.panel")
|
|
applet_list = panel_schema.get_strv("object-id-list")
|
|
|
|
while True:
|
|
test_obj = "object_%d" % (i)
|
|
if test_obj in applet_list:
|
|
i += 1
|
|
else:
|
|
break
|
|
|
|
path = "/org/mate/panel/objects/%s/" % (test_obj)
|
|
new_schema = Gio.Settings.new_with_path("org.mate.panel.object", path)
|
|
new_schema.set_string("launcher-location", desktopEntry.desktopFile)
|
|
new_schema.set_string("object-type", "launcher")
|
|
new_schema.set_string("toplevel-id", self.panel)
|
|
new_schema.set_int("position", self.panel_position)
|
|
applet_list.append(test_obj)
|
|
panel_schema.set_strv("object-id-list", applet_list)
|
|
|
|
def delete_from_menu(self, widget, desktopEntry):
|
|
try:
|
|
os.system("rm \"%s\" &" % desktopEntry.desktopFile)
|
|
except Exception, detail:
|
|
print detail
|
|
|
|
def onLaunchApp( self, menu, widget ):
|
|
widget.execute()
|
|
self.mintMenuWin.hide()
|
|
|
|
def onPropsApp( self, menu, widget ):
|
|
|
|
newFileFlag = False
|
|
|
|
sysPaths = get_system_item_paths()
|
|
|
|
for path in sysPaths:
|
|
|
|
path += "applications"
|
|
|
|
relPath = os.path.relpath(widget.desktopFile, path)
|
|
|
|
if widget.desktopFile == os.path.join(path, relPath):
|
|
filePath = os.path.join(get_user_item_path(), relPath)
|
|
(head,tail) = os.path.split(filePath)
|
|
|
|
if not os.path.isdir(head):
|
|
os.makedirs(head)
|
|
|
|
if not os.path.isfile(filePath):
|
|
data = open(widget.desktopFile).read()
|
|
open(filePath, 'w').write(data)
|
|
newFileFlag = True
|
|
break
|
|
|
|
else:
|
|
filePath = widget.desktopFile
|
|
|
|
self.mintMenuWin.hide()
|
|
Gdk.flush()
|
|
|
|
editProcess = subprocess.Popen(["/usr/bin/mate-desktop-item-edit", filePath])
|
|
subprocess.Popen.communicate(editProcess)
|
|
|
|
if newFileFlag:
|
|
|
|
if filecmp.cmp(widget.desktopFile, filePath):
|
|
os.remove(filePath)
|
|
|
|
else:
|
|
favoriteChange = 0
|
|
|
|
for favorite in self.favorites:
|
|
if favorite.type == "location":
|
|
if favorite.desktopFile == widget.desktopFile:
|
|
favorite.desktopFile = filePath
|
|
favoriteChange = 1
|
|
|
|
if favoriteChange == 1:
|
|
self.favoritesSave()
|
|
self.buildFavorites()
|
|
|
|
else:
|
|
self.buildFavorites()
|
|
|
|
|
|
def onUninstallApp( self, menu, widget ):
|
|
widget.uninstall()
|
|
self.mintMenuWin.hide()
|
|
|
|
def onFavoritesInsertSpace( self, menu, widget, insertBefore ):
|
|
if insertBefore:
|
|
self.favoritesAdd( self.favoritesBuildSpace(), widget.position )
|
|
else:
|
|
self.favoritesAdd( self.favoritesBuildSpace(), widget.position + 1 )
|
|
|
|
def onFavoritesInsertSeparator( self, menu, widget, insertBefore ):
|
|
if insertBefore:
|
|
self.favoritesAdd( self.favoritesBuildSeparator(), widget.position )
|
|
else:
|
|
self.favoritesAdd( self.favoritesBuildSeparator(), widget.position + 1 )
|
|
|
|
def onFavoritesRemove( self, menu, widget ):
|
|
self.favoritesRemove( widget.position )
|
|
|
|
def onAddToStartup( self, menu, widget ):
|
|
widget.addToStartup()
|
|
|
|
def onRemoveFromStartup( self, menu, widget ):
|
|
widget.removeFromStartup()
|
|
|
|
def onAddToFavorites( self, menu, widget ):
|
|
self.favoritesAdd( self.favoritesBuildLauncher( widget.desktopFile ) )
|
|
|
|
def onRemoveFromFavorites( self, menu, widget ):
|
|
self.favoritesRemoveLocation( widget.desktopFile )
|
|
|
|
def ReceiveCallback( self, widget, context, x, y, selection, targetType, time ):
|
|
if targetType == self.TARGET_TYPE_TEXT:
|
|
for uri in selection.get_uris():
|
|
self.favoritesAdd( self.favoritesBuildLauncher( uri ) )
|
|
|
|
def Search( self, widget ):
|
|
text = self.searchEntry.get_text().strip()
|
|
if text != "":
|
|
self.mintMenuWin.hide()
|
|
fullstring = self.searchtool.replace( "%s", text )
|
|
os.system(fullstring + " &")
|
|
|
|
def SearchWithButton( self, widget, event ):
|
|
self.Search( widget )
|
|
|
|
def do_plugin( self ):
|
|
self.Todos()
|
|
self.buildFavorites()
|
|
|
|
# Scroll button into view
|
|
def scrollItemIntoView( self, widget, event = None ):
|
|
viewport = widget.parent
|
|
while not isinstance( viewport, Gtk.Viewport ):
|
|
if not viewport.parent:
|
|
return
|
|
viewport = viewport.parent
|
|
aloc = widget.get_allocation()
|
|
viewport.get_vadjustment().clamp_page(aloc.y, aloc.y + aloc.height)
|
|
|
|
def favoritesBuildSpace( self ):
|
|
space = Gtk.EventBox()
|
|
space.set_size_request( -1, 20 )
|
|
space.set_visible_window(False)
|
|
space.connect( "button-press-event", self.favPopup )
|
|
space.type = "space"
|
|
|
|
space.show()
|
|
|
|
return space
|
|
|
|
def favoritesBuildSeparator( self ):
|
|
separator = Gtk.HSeparator()
|
|
separator.set_size_request( -1, 20 )
|
|
separator.type = "separator"
|
|
|
|
separator.show_all()
|
|
box = Gtk.EventBox()
|
|
box.type = "separator"
|
|
box.add(separator)
|
|
box.set_visible_window(False)
|
|
box.connect( "button-press-event", self.favPopup )
|
|
box.show_all()
|
|
return box
|
|
|
|
def favoritesBuildLauncher( self, location ):
|
|
try:
|
|
ButtonIcon = None
|
|
# For Folders and Network Shares
|
|
location = string.join( location.split( "%20" ) )
|
|
|
|
if location.startswith( "file" ):
|
|
ButtonIcon = "mate-fs-directory"
|
|
|
|
if location.startswith( "smb" ) or location.startswith( "ssh" ) or location.startswith( "network" ):
|
|
ButtonIcon = "mate-fs-network"
|
|
|
|
#For Special locations
|
|
if location == "x-nautilus-desktop:///computer":
|
|
location = "/usr/share/applications/nautilus-computer.desktop"
|
|
elif location == "x-nautilus-desktop:///home":
|
|
location = "/usr/share/applications/nautilus-home.desktop"
|
|
elif location == "x-nautilus-desktop:///network":
|
|
location = "/usr/share/applications/network-scheme.desktop"
|
|
elif location.startswith( "x-nautilus-desktop:///" ):
|
|
location = "/usr/share/applications/nautilus-computer.desktop"
|
|
|
|
if location.startswith( "file://" ):
|
|
location = location[7:]
|
|
|
|
# Don't add a location twice
|
|
for fav in self.favorites:
|
|
if fav.type == "location" and fav.desktopFile == location:
|
|
return None
|
|
|
|
favButton = FavApplicationLauncher( location, self.faviconsize, self.swapgeneric )
|
|
if favButton.appExec:
|
|
favButton.show()
|
|
favButton.connect( "popup-menu", self.favPopup )
|
|
favButton.connect( "button-press-event", self.favPopup )
|
|
favButton.connect( "focus-in-event", self.scrollItemIntoView )
|
|
favButton.connect( "clicked", lambda w: self.mintMenuWin.hide() )
|
|
|
|
self.mintMenuWin.setTooltip( favButton, favButton.getTooltip() )
|
|
favButton.type = "location"
|
|
return favButton
|
|
except Exception, e:
|
|
print u"File in favorites not found: '" + location + "'", e
|
|
|
|
return None
|
|
|
|
def buildFavorites( self ):
|
|
try:
|
|
from user import home
|
|
if (not os.path.exists(home + "/.linuxmint/mintMenu/applications.list")):
|
|
os.system("mkdir -p " + home + "/.linuxmint/mintMenu/applications")
|
|
os.system("cp /usr/lib/linuxmint/mintMenu/applications.list " + home + "/.linuxmint/mintMenu/applications.list")
|
|
|
|
applicationsFile = open ( os.path.join( os.path.expanduser( "~" ), ".linuxmint", "mintMenu", "applications.list" ), "r" )
|
|
applicationsList = applicationsFile.readlines()
|
|
|
|
self.favorites = []
|
|
|
|
for child in self.favoritesBox:
|
|
child.destroy()
|
|
|
|
position = 0
|
|
|
|
for app in applicationsList :
|
|
app = app.strip()
|
|
|
|
if app[0:9] == "location:":
|
|
favButton = self.favoritesBuildLauncher( app[9:] )
|
|
elif app == "space":
|
|
favButton = self.favoritesBuildSpace()
|
|
elif app == "separator":
|
|
favButton = self.favoritesBuildSeparator()
|
|
else:
|
|
if ( app.endswith( ".desktop" ) ):
|
|
favButton = self.favoritesBuildLauncher( app )
|
|
else:
|
|
favButton = None
|
|
|
|
|
|
if favButton:
|
|
favButton.position = position
|
|
self.favorites.append( favButton )
|
|
self.favoritesPositionOnGrid( favButton )
|
|
favButton.connect( "drag-data-received", self.onFavButtonDragReorder )
|
|
gtk.gtk_drag_dest_set( hash(favButton), Gtk.DestDefaults.MOTION | Gtk.DestDefaults.HIGHLIGHT | Gtk.DestDefaults.DROP, self.fromFav, 2, Gdk.DragAction.COPY )
|
|
favButton.connect( "drag-data-get", self.onFavButtonDragReorderGet )
|
|
gtk.gtk_drag_source_set( hash(favButton), Gdk.ModifierType.BUTTON1_MASK, self.toFav, 3, Gdk.DragAction.COPY )
|
|
position += 1
|
|
|
|
self.favoritesSave()
|
|
except Exception, e:
|
|
print e
|
|
|
|
def favoritesGetNumRows( self ):
|
|
rows = 0
|
|
col = 0
|
|
for fav in self.favorites:
|
|
if ( fav.type == "separator" or fav.type == "space" ) and col != 0:
|
|
rows += 1
|
|
col = 0
|
|
col += 1
|
|
if fav.type == "separator" or fav.type == "space":
|
|
rows += 1
|
|
col = 0
|
|
|
|
if col >= self.favCols:
|
|
rows += 1
|
|
col = 0
|
|
return rows
|
|
|
|
def favoritesPositionOnGrid( self, favorite ):
|
|
row = 0
|
|
col = 0
|
|
for fav in self.favorites:
|
|
if ( fav.type == "separator" or fav.type == "space" ) and col != 0:
|
|
row += 1
|
|
col = 0
|
|
if fav.position == favorite.position:
|
|
break
|
|
col += 1
|
|
if fav.type == "separator" or fav.type == "space":
|
|
row += 1
|
|
col = 0
|
|
|
|
if col >= self.favCols:
|
|
row += 1
|
|
col = 0
|
|
|
|
if favorite.type == "separator" or favorite.type == "space":
|
|
self.favoritesBox.attach( favorite, col, col + self.favCols, row, row + 1, yoptions = 0 )
|
|
else:
|
|
self.favoritesBox.attach( favorite, col, col + 1, row, row + 1, yoptions = 0 )
|
|
|
|
def favoritesReorder( self, oldposition, newposition ):
|
|
if oldposition == newposition:
|
|
return
|
|
tmp = self.favorites[ oldposition ]
|
|
if newposition > oldposition:
|
|
if ( self.favorites[ newposition - 1 ].type == "space" or self.favorites[ newposition - 1 ].type == "separator" ) and self.favCols > 1:
|
|
newposition = newposition - 1
|
|
for i in range( oldposition, newposition ):
|
|
self.favorites[ i ] = self.favorites[ i + 1 ]
|
|
self.favorites[ i ].position = i
|
|
elif newposition < oldposition:
|
|
for i in range( 0, oldposition - newposition ):
|
|
self.favorites[ oldposition - i ] = self.favorites[ oldposition - i - 1 ]
|
|
self.favorites[ oldposition - i ] .position = oldposition - i
|
|
self.favorites[ newposition ] = tmp
|
|
self.favorites[ newposition ].position = newposition
|
|
|
|
for fav in self.favorites:
|
|
self.favoritesBox.remove( fav )
|
|
self.favoritesPositionOnGrid( fav )
|
|
|
|
self.favoritesSave()
|
|
self.favoritesBox.resize( self.favoritesGetNumRows(), self.favCols )
|
|
|
|
def favoritesAdd( self, favButton, position = -1 ):
|
|
if favButton:
|
|
favButton.position = len( self.favorites )
|
|
self.favorites.append( favButton )
|
|
self.favoritesPositionOnGrid( favButton )
|
|
|
|
favButton.connect( "drag-data-received", self.onFavButtonDragReorder )
|
|
gtk.gtk_drag_dest_set( hash(favButton), Gtk.DestDefaults.MOTION | Gtk.DestDefaults.HIGHLIGHT | Gtk.DestDefaults.DROP, self.toFav, 3, Gdk.DragAction.COPY )
|
|
favButton.connect( "drag-data-get", self.onFavButtonDragReorderGet )
|
|
gtk.gtk_drag_source_set ( hash(favButton), Gdk.ModifierType.BUTTON1_MASK, self.toFav, 3, Gdk.DragAction.COPY )
|
|
|
|
if position >= 0:
|
|
self.favoritesReorder( favButton.position, position )
|
|
|
|
self.favoritesSave()
|
|
|
|
def favoritesRemove( self, position ):
|
|
tmp = self.favorites[ position ]
|
|
self.favorites.remove( self.favorites[ position ] )
|
|
tmp.destroy()
|
|
|
|
for i in range( position, len( self.favorites ) ):
|
|
self.favorites[ i ].position = i
|
|
self.favoritesBox.remove( self.favorites[ i ] )
|
|
self.favoritesPositionOnGrid( self.favorites[ i ] )
|
|
self.favoritesSave()
|
|
self.favoritesBox.resize( self.favoritesGetNumRows(), self.favCols )
|
|
|
|
def favoritesRemoveLocation( self, location ):
|
|
for fav in self.favorites:
|
|
if fav.type == "location" and fav.desktopFile == location:
|
|
self.favoritesRemove( fav.position )
|
|
|
|
def favoritesSave( self ):
|
|
try:
|
|
self.checkMintMenuFolder()
|
|
appListFile = open( os.path.join( os.path.expanduser( "~"), ".linuxmint", "mintMenu", "applications.list" ) , "w" )
|
|
|
|
for favorite in self.favorites:
|
|
if favorite.type == "location":
|
|
appListFile.write( "location:" + favorite.desktopFile + "\n" )
|
|
else:
|
|
appListFile.write( favorite.type + "\n" )
|
|
|
|
appListFile.close( )
|
|
except Exception, e:
|
|
msgDlg = Gtk.MessageDialog( None, gtk.DialogFlags.MODAL, Gtk.MessageType.ERROR, Gtk.ButtonsType.OK, _("Couldn't save favorites. Check if you have write access to ~/.linuxmint/mintMenu")+"\n(" + e.__str__() + ")" )
|
|
msgDlg.run();
|
|
msgDlg.destroy();
|
|
|
|
def isLocationInFavorites( self, location ):
|
|
for fav in self.favorites:
|
|
if fav.type == "location" and fav.desktopFile == location:
|
|
return True
|
|
|
|
return False
|
|
|
|
def onFavButtonDragReorderGet( self, widget, context, selection, targetType, eventTime ):
|
|
if targetType == self.TARGET_TYPE_FAV:
|
|
self.drag_origin = widget.position
|
|
selection.set( selection.target, 8, str(widget.position))
|
|
|
|
def onFavButtonDragReorder( self, widget, context, x, y, selection, targetType, time ):
|
|
if targetType == self.TARGET_TYPE_FAV:
|
|
#self.favoritesReorder( int(selection.data), widget.position )
|
|
self.favoritesReorder( self.drag_origin, widget.position )
|
|
|
|
def menuChanged( self, x, y ):
|
|
# wait some miliseconds because there a multiple events send at the same time and we don't want to rebuild the menu for each
|
|
if self.menuChangedTimer:
|
|
GLib.source_remove( self.menuChangedTimer )
|
|
|
|
self.menuChangedTimer = GLib.timeout_add( 100, self.updateBoxes, True )
|
|
|
|
def updateBoxes( self, menu_has_changed ):
|
|
# FIXME: This is really bad!
|
|
if self.rebuildLock:
|
|
return
|
|
|
|
self.rebuildLock = True
|
|
|
|
self.menuChangedTimer = None
|
|
|
|
self.loadMenuFiles()
|
|
|
|
# Find added and removed categories than update the category list
|
|
newCategoryList = self.buildCategoryList()
|
|
addedCategories = []
|
|
removedCategories = []
|
|
|
|
# TODO: optimize this!!!
|
|
if not self.categoryList:
|
|
addedCategories = newCategoryList
|
|
else:
|
|
for item in newCategoryList:
|
|
found = False
|
|
for item2 in self.categoryList:
|
|
pass
|
|
if item["name"] == item2["name"] and item["icon"] == item2["icon"] and item["tooltip"] == item2["tooltip"] and item["index"] == item2["index"]:
|
|
found = True
|
|
break
|
|
if not found:
|
|
addedCategories.append(item)
|
|
|
|
for item in self.categoryList:
|
|
found = False
|
|
for item2 in newCategoryList:
|
|
if item["name"] == item2["name"] and item["icon"] == item2["icon"] and item["tooltip"] == item2["tooltip"] and item["index"] == item2["index"]:
|
|
found = True
|
|
break
|
|
if not found:
|
|
removedCategories.append( item )
|
|
|
|
if self.showcategoryicons == True:
|
|
categoryIconSize = self.iconSize
|
|
else:
|
|
categoryIconSize = 0
|
|
|
|
for item in removedCategories:
|
|
try:
|
|
button = item["button"]
|
|
self.categoryList.remove(item)
|
|
button.destroy()
|
|
del item
|
|
except Exception, e:
|
|
print e
|
|
|
|
if addedCategories:
|
|
sortedCategoryList = []
|
|
for item in self.categoryList:
|
|
try:
|
|
self.categoriesBox.remove( item["button"] )
|
|
sortedCategoryList.append( ( str(item["index"]) + item["name"], item["button"] ) )
|
|
except Exception, e:
|
|
print e
|
|
|
|
# Create new category buttons and add the to the list
|
|
for item in addedCategories:
|
|
try:
|
|
item["button"] = CategoryButton( item["icon"], categoryIconSize, [ item["name"] ], item["filter"] )
|
|
self.mintMenuWin.setTooltip( item["button"], item["tooltip"] )
|
|
|
|
if self.categories_mouse_over:
|
|
startId = item["button"].connect( "enter", self.StartFilter, item["filter"] )
|
|
stopId = item["button"].connect( "leave", self.StopFilter )
|
|
item["button"].mouseOverHandlerIds = ( startId, stopId )
|
|
else:
|
|
item["button"].mouseOverHandlerIds = None
|
|
|
|
item["button"].connect( "clicked", self.FilterAndClear, item["filter"] )
|
|
item["button"].connect( "focus-in-event", self.categoryBtnFocus, item["filter"] )
|
|
item["button"].show()
|
|
|
|
self.categoryList.append( item )
|
|
sortedCategoryList.append( ( str(item["index"]) + item["name"], item["button"] ) )
|
|
except Exception, e:
|
|
print e
|
|
|
|
sortedCategoryList.sort()
|
|
|
|
for item in sortedCategoryList:
|
|
try:
|
|
self.categoriesBox.pack_start( item[1], False, False, 0 )
|
|
except Exception, e:
|
|
print e
|
|
|
|
|
|
# Find added and removed applications add update the application list
|
|
newApplicationList = self.buildApplicationList()
|
|
addedApplications = []
|
|
removedApplications = []
|
|
|
|
# TODO: optimize this!!!
|
|
if not self.applicationList:
|
|
addedApplications = newApplicationList
|
|
else:
|
|
for item in newApplicationList:
|
|
found = False
|
|
for item2 in self.applicationList:
|
|
if item["entry"].get_desktop_file_path() == item2["entry"].get_desktop_file_path():
|
|
found = True
|
|
break
|
|
if not found:
|
|
addedApplications.append(item)
|
|
|
|
key = 0
|
|
for item in self.applicationList:
|
|
found = False
|
|
for item2 in newApplicationList:
|
|
if item["entry"].get_desktop_file_path() == item2["entry"].get_desktop_file_path():
|
|
found = True
|
|
break
|
|
if not found:
|
|
removedApplications.append(key)
|
|
else:
|
|
# don't increment the key if this item is going to be removed
|
|
# because when it is removed the index of all later items is
|
|
# going to be decreased
|
|
key += 1
|
|
|
|
for key in removedApplications:
|
|
self.applicationList[key]["button"].destroy()
|
|
del self.applicationList[key]
|
|
if addedApplications:
|
|
sortedApplicationList = []
|
|
for item in self.applicationList:
|
|
self.applicationsBox.remove( item["button"] )
|
|
sortedApplicationList.append( ( item["button"].appName, item["button"] ) )
|
|
for item in addedApplications:
|
|
item["button"] = MenuApplicationLauncher( item["entry"].get_desktop_file_path(), self.iconSize, item["category"], self.showapplicationcomments, highlight=(True and menu_has_changed) )
|
|
if item["button"].appExec:
|
|
self.mintMenuWin.setTooltip( item["button"], item["button"].getTooltip() )
|
|
item["button"].connect( "button-press-event", self.menuPopup )
|
|
item["button"].connect( "focus-in-event", self.scrollItemIntoView )
|
|
item["button"].connect( "clicked", lambda w: self.mintMenuWin.hide() )
|
|
if self.activeFilter[0] == 0:
|
|
item["button"].filterText( self.activeFilter[1] )
|
|
else:
|
|
item["button"].filterCategory( self.activeFilter[1] )
|
|
item["button"].desktop_file_path = item["entry"].get_desktop_file_path()
|
|
sortedApplicationList.append( ( item["button"].appName.upper(), item["button"] ) )
|
|
self.applicationList.append( item )
|
|
else:
|
|
item["button"].destroy()
|
|
|
|
|
|
sortedApplicationList.sort()
|
|
for item in sortedApplicationList:
|
|
self.applicationsBox.pack_start( item[1], False, False, 0 )
|
|
|
|
self.rebuildLock = False
|
|
|
|
# Reload the menufiles from the filesystem
|
|
def loadMenuFiles( self ):
|
|
self.menuFiles = []
|
|
for mainitems in [ "mate-applications.menu", "mate-settings.menu" ]:
|
|
self.menuFiles.append( Menu( mainitems) )
|
|
|
|
# Build a list of all categories in the menu ( [ { "name", "icon", tooltip" } ]
|
|
def buildCategoryList( self ):
|
|
newCategoryList = [ { "name": _("All"), "icon": "stock_select-all", "tooltip": _("Show all applications"), "filter":"", "index": 0 } ]
|
|
|
|
num = 1
|
|
|
|
for menu in self.menuFiles:
|
|
for child in menu.directory.get_contents():
|
|
if child.get_type() == matemenu.TYPE_DIRECTORY:
|
|
icon = str(child.icon)
|
|
#if (icon == "preferences-system"):
|
|
# self.adminMenu = child.name
|
|
#if (icon != "applications-system" and icon != "applications-other"):
|
|
newCategoryList.append( { "name": child.name, "icon": child.icon, "tooltip": child.name, "filter": child.name, "index": num } )
|
|
num += 1
|
|
|
|
return newCategoryList
|
|
|
|
# Build a list containing the DesktopEntry object and the category of each application in the menu
|
|
def buildApplicationList( self ):
|
|
|
|
newApplicationsList = []
|
|
|
|
def find_applications_recursively(app_list, directory, catName):
|
|
for item in directory.get_contents():
|
|
if item.get_type() == matemenu.TYPE_ENTRY:
|
|
print "=======>>> " + str(item.name) + " = " + str(catName)
|
|
app_list.append( { "entry": item, "category": catName } )
|
|
elif item.get_type() == matemenu.TYPE_DIRECTORY:
|
|
find_applications_recursively(app_list, item, catName)
|
|
|
|
for menu in self.menuFiles:
|
|
directory = menu.directory
|
|
for entry in directory.get_contents():
|
|
if entry.get_type() == matemenu.TYPE_DIRECTORY and len(entry.get_contents()):
|
|
#Entry is a top-level category
|
|
#catName = entry.name
|
|
#icon = str(entry.icon)
|
|
#if (icon == "applications-system" or icon == "applications-other"):
|
|
# catName = self.adminMenu
|
|
for item in entry.get_contents():
|
|
if item.get_type() == matemenu.TYPE_DIRECTORY:
|
|
find_applications_recursively(newApplicationsList, item, entry.name)
|
|
elif item.get_type() == matemenu.TYPE_ENTRY:
|
|
newApplicationsList.append( { "entry": item, "category": entry.name } )
|
|
#elif entry.get_type() == matemenu.TYPE_ENTRY:
|
|
# if not (entry.get_is_excluded() or entry.get_is_nodisplay()):
|
|
# print "=======>>> " + item.name + " = top level"
|
|
# newApplicationsList.append( { "entry": item, "category": "" } )
|
|
|
|
return newApplicationsList
|