Home Forums Wiki Doc Install Extras Screenshots Source Code Projects Blog Users Groups Register
Glx-Dock / Cairo-Dock List of forums Applets | Applets xfce 4.10 et mint menu
The latest stable release is the *3.4.0* : How to install it here.
Note: We just switched from BZR to Git on Github! (only to host the code and your future pull requests)
Applets | Applets

Subjects Author Language Messages Last message
[Locked] xfce 4.10 et mint menu
jackinthebox Français 14 fabounet [Read]
13 November 2012 à 15:56

jackinthebox, Tuesday 06 November 2012 à 11:17


Subscription date : 05 November 2012
Messages : 8
Je souhaite installer mint menu dans xfce 4.10. J'y suis parvenu (http://xubuntugeek.blogspot.nl/2012/07/how-to-install-mint-menu-in-xubuntu.html pour ceux que ça intéresse, il me parait plus sage de virer/etc/apt/sources.list.d/linuxmint.list une fois la manœuvre effectuée..).
Le problème est d’intégrer tout ça à cairo dock, l'applet d'intégration de cairo dock ne fonctionnant pas :
File "./MintMenu", line 26, in <module>
import gnomeapplet
ImportError: No module named gnomeapplet
.
Renseignements pris, il me manque le package python-gnomeapplet... qui n'est plus maintenu depuis ubuntu 11.10 au moins pour cause d'incompatibilité avec gnome 3 - je suis passé à xfce du fait de gnome3, et gnome3 continue de me casser les pieds, à ce niveau là c'est du harcèlement ... Je tente tout de même de récupérer une ancienne version du dit package mais gdebi me dit

La dépendance ne peut être satisfaite :
libpanel-applet2.0(>=2.26.0)


Et là je tergiverse un peu, voulant éviter les âneries dans l'ensemble de mes packages... quelqu'un aurait une idée pour ne pas y mettre trop le bazar?

Guest, Tuesday 06 November 2012 à 16:17

je progresse, j'ai réussi à régler les soucis de dépendances... mais un autre problème a surgi :

(mintMenu.py:7045): MateComponent-CRITICAL **: matecomponent_corba_object_type_register_static: assertion `g_type_from_name (name) == 0' failed
/usr/lib/python2.7/dist-packages/gtk-2.0/matecomponent/init.py:12: Warning: /build/buildd/glib2.0-2.34.0/./gobject/gsignal.c:1634: parameter 1 of type `<unknown>' for signal "MateComponentObject::system_exception" is not a value type
from _matecomponent import *
gtk_widget_realize: assertion `widget->priv->anchored || GTK_IS_INVISIBLE (widget)' failed

Je précise tout de même que mint menu fonctionne hors du contexte de cairo-dock...

matttbe, Tuesday 06 November 2012 à 18:15


Subscription date : 24 January 2009
Messages : 12573
Salut,

Malheureusement, j'ai bien l'impression que l'applet est "cassé" vu qu'ils sont passés à Mate...

Pourrais-tu éventuellement regarder s'il n'y a pas une commande qui permet de lancer ce menu (ex: 'mintmenu')
ls /usr/bin/mint*
Et quelles options sont dispo?

@fabounet: ne serait-ce pas plus simple d'avoir une "bête" applet qui ne fait que lancer une commande?

Guest, Tuesday 06 November 2012 à 18:48

il y a une commande mintmenu qui lance le menu, mais dans une jolie petite fenêtre, qui se lance en plein milieu de l’écran... pas génial. En plus il n'y a pas d'option -help, alors comment savoir quel paramètre on peut lui passer? Apparemment, l'essentiel du code est du python a en croire le répertoire lib associé. voilà le code de mintMenu.py, si ça peut faire avancer les choses :

#!/usr/bin/env python

try:
    
import sys
    import gtk
    import gtk
.glade
    import pango
    import os
    import commands
    import mateapplet
    import gettext
    import matevfs
    import traceback
    import time
    import gc
    import xdg
.Config
    import pygtk
    pygtk
.require( "2.0" )
except Exceptione:
    print 
e
    sys
.exit( )

global 
mbindkey
# Load the key binding lib (developped by deskbar-applet, copied into mintMenu so we don't end up with an unnecessary dependency)
try:
    
from deskbar.core.keybinder import tomboy_keybinder_bind as bind_key
except Exception
cause:
    print 
"*********** Keybind Driver Load Failure **************"
    
print "Error Report : "str(cause)
    
pass

# Rename the process
architecture commands.getoutput("uname -a")
if (
architecture.find("x86_64") >= 0):
    
import ctypes
    libc 
ctypes.CDLL('libc.so.6')
    
libc.prctl(15'mintmenu'000)
else:
    
import dl
    
if os.path.exists('/lib/libc.so.6'):
        
libc dl.open('/lib/libc.so.6')
        
libc.call('prctl'15'mintmenu'000)
    
elif os.path.exists('/lib/i386-linux-gnu/libc.so.6'):
        
libc dl.open('/lib/i386-linux-gnu/libc.so.6')
        
libc.call('prctl'15'mintmenu'000)

# i18n
gettext.install("mintmenu""/usr/share/linuxmint/locale")

NAME _("Menu")
PATH os.path.abspathos.path.dirnamesys.argv[0] ) )

ICON "/usr/lib/linuxmint/mintMenu/visualisation-logo.png"

sys.path.appendos.path.joinPATH "plugins") )

windowManager os.getenv("DESKTOP_SESSION")
if 
not windowManager:
    
windowManager "MATE"
xdg.Config.setWindowManagerwindowManager.upper() )

from easybuttons import iconManager
from easygconf import EasyGConf
from execute import 
*



class 
MainWindow( object ):
    
"""This is the main class for the application"""

    
def __init__selftoggleButton ):

        
self.path PATH
        sys
.path.appendos.path.joinself.path"plugins") )

        
self.detect_desktop_environment()

        
self.icon ICON

        self
.toggle toggleButton
        
# Load glade file and extract widgets
        
gladefile       os.path.joinself.path"mintMenu.glade" )
        
wTree           gtk.glade.XMLgladefile"mainWindow" )
        
self.window     wTree.get_widget"mainWindow" )
        
self.paneholder wTree.get_widget"paneholder" )        
        
self.border     wTree.get_widget"border" )

        
self.panesToColor = [ ]
        
self.headingsToColor = [ ]

        
self.window.connect"map-event"self.onMap )
        
self.window.connect"show"self.onShow )
        
self.window.connect"unmap-event"self.onUnmap )
        
self.window.connect"button-press-event"self.onButtonPress )
        
self.window.connect"key-press-event"self.onKeyPress )
        
self.window.connect"grab-broken-event"self.onGrabBroken )

        
self.window.stick()

        
plugindir os.path.joinos.path.expanduser"~" ), ".linuxmint/mintMenu/plugins" )
        
sys.path.appendplugindir )

        
dic = {"on_window1_destroy" self.quit_cb}
        
wTree.signal_autoconnectdic )

        
self.gconf EasyGConf"/apps/mintMenu/" )

        
self.getSetGconfEntries()
        
self.SetupMintMenuBorder()
        
self.SetupMintMenuOpacity()

        
self.tooltips gtk.Tooltips()
        if 
self.globalEnableTooltips and self.enableTooltips:
            
self.tooltips.enable()
        else:
            
self.tooltips.disable()

        
self.PopulatePlugins();

        
self.gconf.notifyAdd"plugins_list"self.RegenPlugins )
                
        
self.gconf.notifyAdd"start_with_favorites"self.toggleStartWithFavorites )
        
self.gconf.notifyAdd"/apps/panel/global/tooltips_enabled"self.toggleTooltipsEnabled )
        
self.gconf.notifyAdd"tooltips_enabled"self.toggleTooltipsEnabled )

        
self.gconf.notifyAdd"use_custom_color"self.toggleUseCustomColor )
        
self.gconf.notifyAdd"custom_border_color"self.toggleCustomBorderColor )
        
self.gconf.notifyAdd"custom_heading_color"self.toggleCustomHeadingColor )
        
self.gconf.notifyAdd"custom_color"self.toggleCustomBackgroundColor )
        
self.gconf.notifyAdd"border_width"self.toggleBorderWidth )
        
self.gconf.notifyAdd"opacity"self.toggleOpacity )

    
def quit_cb (self):
        
gtk.main_quit()
        
sys.exit(0)

    
def wakePluginsself ):
        
# Call each plugin and let them know we're showing up
        
for plugin in self.plugins.values():
            if 
hasattrplugin"destroy" ):
                
plugin.wake()

    
def toggleTooltipsEnabledselfclientconnection_identryargs ):
        if 
entry.get_key() == "/apps/panel/global/tooltips_enabled":
            
self.globalEnableTooltips entry.get_value().get_bool()
        else:
            
self.enableTooltips entry.get_value().get_bool()

        if 
self.globalEnableTooltips and self.enableTooltips:
            
self.tooltips.enable()
        else:
            
self.tooltips.disable()

    
def toggleStartWithFavoritesselfclientconnection_identryargs ):
        
self.startWithFavorites entry.get_value().get_bool()    

    
def toggleBorderWidthselfclientconnection_identryargs ):
        
self.borderwidth entry.get_value().get_int()
        
self.SetupMintMenuBorder()

    
def toggleOpacityselfclientconnection_identryargs ):
        
self.opacity entry.get_value().get_int()
        
self.SetupMintMenuOpacity()

    
def toggleUseCustomColorselfclientconnection_identryargs ):
        
self.usecustomcolor entry.get_value().get_bool()
        
self.SetupMintMenuBorder()
        
self.SetPaneColorsself.panesToColor )
        
self.SetHeadingStyleself.headingsToColor )


    
def toggleCustomBorderColorselfclientconnection_identryargs ):
        
self.custombordercolor entry.get_value().get_string()
        
self.SetupMintMenuBorder()

    
def toggleCustomBackgroundColorselfclientconnection_identryargs ):
        
self.customcolor entry.get_value().get_string()
        
self.SetPaneColorsself.panesToColor )

    
def toggleCustomHeadingColorselfclientconnection_identryargs ):
        
self.customheadingcolor entry.get_value().get_string()
        
self.SetHeadingStyleself.headingsToColor )


    
def getSetGconfEntriesself ):
        
self.pluginlist          self.gconf.get"list-string""plugins_list",['places''system_management''newpane''applications'] )
        
self.dottedfile          os.path.joinself.path"dotted.png")

        
self.usecustomcolor      self.gconf.get"bool""use_custom_color"False )
        
self.customcolor         self.gconf.get"color""custom_color""#EEEEEE" )
        
self.customheadingcolor  self.gconf.get"color""custom_heading_color""#001155" )
        
self.custombordercolor   self.gconf.get"color""custom_border_color""#001155" )

        
self.borderwidth          self.gconf.get"int""border_width")
        
self.opacity              self.gconf.get"int""opacity"98 )
        
self.offset               self.gconf.get"int""mintMenu_offset")        
        
self.enableTooltips       self.gconf.get"bool""tooltips_enabled"True )
        
self.globalEnableTooltips self.gconf.get"bool""/apps/panel/global/tooltips_enabled"True )        
        
self.startWithFavorites   self.gconf.get"bool""start_with_favorites"False )

    
def SetupMintMenuBorderself ):
        if 
self.usecustomcolor:
            
self.window.modify_bggtk.STATE_NORMALgtk.gdk.color_parseself.custombordercolor ) )
        else:
            
self.window.modify_bggtk.STATE_NORMALself.window.rc_get_style().bggtk.STATE_SELECTED ] )
        
self.border.set_paddingself.borderwidthself.borderwidthself.borderwidthself.borderwidth )        

    
def SetupMintMenuOpacityself ):
        print 
"Opacity is: " str(self.opacity)
        
opacity float(self.opacity) / float(100)
        print 
"Setting opacity to: " str(opacity)
        
self.window.set_opacity(opacity)
        
    
def detect_desktop_environment (self):
        
self.de "mate"
        
try:
            
de os.environ["DESKTOP_SESSION"]
            if 
de in ["gnome""gnome-shell""mate""kde""xfce"]:
                
self.de de
            
else:
                if 
os.path.exists("/usr/bin/caja"):
                    
self.de "mate"
                
elif os.path.exists("/usr/bin/thunar"):
                    
self.de "xfce"
        
except Exceptiondetail:
            print 
detail

    def PopulatePlugins
self ):
        
self.panesToColor = [ ]
        
self.headingsToColor = [ ]
        
start time.time()
        
PluginPane gtk.EventBox()
        
PluginPane.show()
        
PaneLadder gtk.VBoxFalse)
        
PluginPane.addPaneLadder )
        
self.SetPaneColors( [ PluginPane ] )
        
ImageBox gtk.EventBox()
        
self.SetPaneColors( [ ImageBox ] )
        
ImageBox.show()

        
seperatorImage gtk.gdk.pixbuf_new_from_fileself.dottedfile )

        
self.plugins = {}

        for 
plugin in self.pluginlist:
            if 
plugin in self.plugins:
                print 
u"Duplicate plugin in list: "plugin
                
continue

            if 
plugin != "newpane":
                try:
                    
__import__plugin )
                    
# If no parameter passed to plugin it is autonomous
                    
if X.pluginclass.__init__.func_code.co_argcount == 1:
                        
MyPlugin X.pluginclass()
                    else:
                        
# pass mintMenu and togglebutton instance so that the plugin can use it
                        
MyPlugin X.pluginclassselfself.toggleself.de )

                    if 
not MyPlugin.icon:
                        
MyPlugin.icon "mate-logo-icon.png"

                    
#if hasattr( MyPlugin, "hideseparator" ) and not MyPlugin.hideseparator:
                    #    Image1 = gtk.Image()
                    #    Image1.set_from_pixbuf( seperatorImage )
                    #    if not ImageBox.get_child():
                    #        ImageBox.add( Image1 )
                    #        Image1.show()

                    #print u"Loading plugin '" + plugin + "' : sucessful"
                
except Exceptione:
                    
MyPlugin gtk.EventBox() #Fake class for MyPlugin
                    
MyPlugin.heading _("Couldn't load plugin:") + " " plugin
                    MyPlugin
.content_holder gtk.EventBox()

                    
# create traceback
                    
info sys.exc_info()

                    
errorLabel gtk.Label"\n".join(traceback.format_exceptioninfo[0], info[1], info[2] )).replace("\\n""\n") )
                    
errorLabel.set_selectableTrue )
                    
errorLabel.set_line_wrapTrue )
                    
errorLabel.set_alignment0.00.0 )
                    
errorLabel.set_padding5)
                    
errorLabel.show()

                    
MyPlugin.content_holder.adderrorLabel )
                    
MyPlugin.addMyPlugin.content_holder )
                    
MyPlugin.width 270
                    MyPlugin
.icon 'mate-logo-icon.png'
                    
print u"Unable to load " plugin " plugin :-("


                
self.SetPaneColors( [MyPlugin.content_holder] )


                
MyPlugin.content_holder.show()

                
VBox1 gtk.VBoxFalse)
                if 
MyPlugin.heading != "":                    
                    
Label1 gtk.LabelMyPlugin.heading )
                    
Align1 gtk.Alignment000)
                    
Align1.set_padding10510)
                    
Align1.addLabel1 )
                    
self.SetHeadingStyle( [Label1] )
                    
Align1.show()
                    
Label1.show()

                    if 
not hasattrMyPlugin'sticky' ) or MyPlugin.sticky == True:
                        
heading gtk.EventBox()
                        
Align1.set_padding0010)
                        
self.SetPaneColors( [heading] )
                        
heading.set_size_requestMyPlugin.width30 )
                    else:
                        
heading gtk.HBox()
                        
#heading.set_relief( gtk.RELIEF_NONE )
                        
heading.set_size_requestMyPlugin.width, -)
                        
#heading.set_sensitive(False)
                        #heading.connect( "button_press_event", self.TogglePluginView, VBox1, MyPlugin.icon, MyPlugin.heading, MyPlugin )

                    
heading.addAlign1 )
                    
heading.show()
                    
VBox1.pack_startheadingFalse )                    
                
VBox1.show()
                
MyPlugin.container VBox1
                
#Add plugin to Plugin Box under heading button
                
MyPlugin.content_holder.reparentVBox1 )

                
#Add plugin to main window
                
PaneLadder.pack_startVBox1 )
                
PaneLadder.show()

                if 
MyPlugin.window:
                    
MyPlugin.window.destroy()

                try:
                    if 
hasattrMyPlugin'do_plugin' ):
                        
MyPlugin.do_plugin()
                    if 
hasattrMyPlugin'height' ):
                        
MyPlugin.content_holder.set_size_request( -1MyPlugin.height )
                    if 
hasattrMyPlugin'itemstocolor' ):
                        
self.SetPaneColorsMyPlugin.itemstocolor )                   
                
except:
                    
# create traceback
                    
info sys.exc_info()

                    
error _("Couldn't initialize plugin") + " " plugin " : " "\n".join(traceback.format_exceptioninfo[0], info[1], info[2] )).replace("\\n""\n")
                    
msgDlg gtk.MessageDialogNonegtk.DIALOG_MODALgtk.MESSAGE_ERRORgtk.BUTTONS_OKerror )
                    
msgDlg.run();
                    
msgDlg.destroy();

                
self.plugins[plugin] = MyPlugin

            
else:
                
self.paneholder.pack_startImageBoxFalseFalse)
                
self.paneholder.pack_startPluginPaneFalseFalse)
                
PluginPane gtk.EventBox()
                
PaneLadder gtk.VBoxFalse)
                
PluginPane.addPaneLadder )
                
self.SetPaneColors( [PluginPane] )
                
ImageBox gtk.EventBox()
                
self.SetPaneColors( [ImageBox] )
                
ImageBox.show()
                
PluginPane.show_all()

                if 
self.plugins and hasattrMyPlugin'hideseparator' ) and not MyPlugin.hideseparator:
                    
Image1 gtk.Image()
                    
Image1.set_from_pixbufseperatorImage )
                    
Image1.show()
                    
#ImageBox.add( Image1 )
                    
                    
Align1 gtk.Alignment()
                    
Align1.set_padding006)
                    
Align1.add(Image1)
                    
ImageBox.add(Align1)
                    
ImageBox.show_all()


        
self.paneholder.pack_startImageBoxFalseFalse)
        
self.paneholder.pack_startPluginPaneFalseFalse)
        
self.tooltips.disable()

        
#print u"Loading", (time.time() - start), "s"

    
def SetPaneColorsselfitems ):
        for 
item in items:
            if 
item not in self.panesToColor:
                
self.panesToColor.appenditem )

        if 
self.usecustomcolor:
            for 
item in items:
                
item.modify_bggtk.STATE_NORMALgtk.gdk.color_parseself.customcolor ) )
        else:
            for 
item in items:
                
item.modify_bggtk.STATE_NORMALself.paneholder.rc_get_style().bggtk.STATE_NORMAL ] )


    
def SetHeadingStyleselfitems ):
        for 
item in items:
            if 
item not in self.headingsToColor:
                
self.headingsToColor.appenditem )

        
HeadingStyle pango.AttrList()
        
attr pango.AttrSize120000, -)
        
HeadingStyle.insertattr )

        if 
self.usecustomcolor:
            
headingcolor gtk.gdk.color_parseself.customheadingcolor )
            
attr pango.AttrForegroundheadingcolor.redheadingcolor.greenheadingcolor.blue0, -)
            
HeadingStyle.insertattr )
#               else:
#                       headingcolor = self.window.rc_get_style().bg[ gtk.STATE_SELECTED ]

        
attr pango.AttrWeightpango.WEIGHT_BOLD0, -)
        
HeadingStyle.insertattr )

        for 
item in items:
            
item.set_attributesHeadingStyle )

    
def setTooltipselfwidgettiptipPrivate None ):
        
self.tooltips.set_tipwidgettiptipPrivate )

    
def RegenPluginsself, *args, **kargs ):
        
#print
        #print u"Reloading Plugins..."
        
for item in self.paneholder:
            
item.destroy()

        for 
plugin in self.plugins.values():
            if 
hasattrplugin"destroy" ):
                
plugin.destroy()

        try:
            
del plugin
        except
:
            
pass
    
        
try:
            
del self.plugins
        except
:
            
pass

        gc
.collect()

        
self.getSetGconfEntries()
        
self.PopulatePlugins()

        
#print NAME+u" reloaded"


    
def showself ):
        
self.window.present()

        if ( 
"applications" in self.plugins ) and ( hasattrself.plugins["applications"], "focusSearchEntry" ) ):
            if (
self.startWithFavorites):
                
self.plugins["applications"].changeTab(0)
            
self.plugins["applications"].focusSearchEntry()

    
def grabself ):
        
gtk.gdk.pointer_grabself.window.windowTruegtk.gdk.BUTTON_PRESS_MASK )
        
gtk.gdk.keyboard_grabself.window.windowFalse )
        
self.window.grab_add()

    
def ungrabself ):
        
self.window.grab_remove()
        
self.window.hide()
        
gtk.gdk.pointer_ungrab()
        
gtk.gdk.keyboard_ungrab()

    
def onMapselfwidgetevent ):
        
self.grab()

    
def onShowselfwidget ):
        for 
plugin in self.plugins.values():
            if 
hasattrplugin"onShowMenu" ):
                
plugin.onShowMenu()

    
def onUnmapselfwidgetevent ):
        
self.ungrab()

        for 
plugin in self.plugins.values():
            if 
hasattrplugin"onHideMenu" ):
                
plugin.onHideMenu()

    
def onKeyPressselfwidgetevent ):
        if 
event.keyval == gtk.keysyms.Escape or event.keyval == gtk.keysyms.Super_L:
            
self.hide()
        return 
False

    def onButtonPress
selfwidgetevent ):
        
# Check if the pointer is within the menu, else hide the menu
        
winatptr gtk.gdk.window_at_pointer()

        if 
winatptr:
            
win winatptr[0]
            while 
win:
                if 
win == self.window.window:
                    break
                
win win.get_parent()
            if 
not win:
                
self.hideTrue )
        else:
            
self.hideTrue )

        return 
True

    def onGrabBroken
selfwidgetevent ):
        if 
event.grab_window:
            try:
                
theft event.grab_window.get_user_data()
                
theft.connect"event"self.onGrabTheftEvent )
            
except:
                
self.window.hideTrue )

    
def onGrabTheftEventselfwidgetevent ):
        if 
event.type == gtk.gdk.UNMAP or event.type == gtk.gdk.SELECTION_CLEAR:
            
self.grab()

    
def hide(selfforceHide False):        
        
self.window.hide()

class 
MenuWin( object ):
    
def __init__selfappletiid ):
        
self.applet applet

        self
.gconf EasyGConf"/apps/mintMenu/" )
        
self.gconf.notifyAdd"applet_text"self.gconfEntriesChanged )
        
self.gconf.notifyAdd"theme_name"self.changeTheme )
        
self.gconf.notifyAdd"hot_key"self.gconfEntriesChanged )
        
self.gconf.notifyAdd"applet_icon"self.gconfEntriesChanged )
        
self.gconf.notifyAdd"hide_applet_icon"self.gconfEntriesChanged )
        
self.gconf.notifyAdd"applet_icon_size"self.gconfEntriesChanged )
        
self.getGconfEntries()

        
self.gconftheme EasyGConf"/desktop/mate/interface/" )
        
self.gconftheme.notifyAdd"gtk_theme"self.changeTheme )

        
self.createPanelButton()

        
self.applet.set_applet_flagsmateapplet.EXPAND_MINOR )
        
self.applet.connect"button-press-event"self.showMenu )
        
self.applet.connect"change-orient"self.changeOrientation )
        
self.applet.connect"change-background"self.changeBackground )
        
self.applet.connect("enter-notify-event"self.enter_notify)
        
self.applet.connect("leave-notify-event"self.leave_notify)
        
self.mainwin MainWindowself.button_box )
        
self.mainwin.window.connect"map-event"lambda *argsself.applet.set_stategtk.STATE_SELECTED ) )
        
self.mainwin.window.connect"unmap-event"lambda *argsself.applet.set_stategtk.STATE_NORMAL ) )
        
self.mainwin.window.connect"size-allocate"lambda *argsself.positionMenu() )

        
self.mainwin.window.set_name("mintmenu"# Name used in Gtk RC files

        
icon iconManager.getIconself.mainwin.icon)
        if 
icon:
            
gtk.window_set_default_iconicon )

        
self.propxml """
                <popup name="
button3">
                                <menuitem name="
Item 1" verb="Preferences" label="%s" pixtype="stock" pixname="gtk-preferences" />
                                <menuitem name="
Item 1" verb="Edit" label="%s" pixtype="stock" pixname="gtk-edit" />
                                <menuitem name="
Item 2" verb="Reload" label="%s" pixtype="stock" pixname="gtk-refresh" />
                                <menuitem name="
Item 3" verb="About" label="%s" pixtype="stock" pixname="gtk-about" />
                </popup>
                """ 
% ( _("Preferences"), _("Edit menu"), _("Reload plugins"), _("About") )
        
self.verbs = [ ("Preferences"self.showPreferences), ("Edit"self.showMenuEditor), ("About"self.showAboutDialog), ("Reload",self.mainwin.RegenPlugins) ]
        
self.bind_hot_key()

    
def onBindingPress(self):
        try:
            if 
self.mainwin.window.flags() & gtk.VISIBLE:
                
self.mainwin.window.hide()
                
self.mainwin.toggle.set_active(False)
            else:
                
MenuWin.showMenu(self,self.mainwin.toggle)
                
self.mainwin.window.show()
                
#self.mainwin.wTree.get_widget( 'PluginTabs' ).set_curremenu_editor = SetGconf( self.client, "string", "/apps/usp/menu_editor", "mozo" )
        
except Exceptioncause:
            print 
cause

    def enter_notify
(selfappletevent):
        
self.do_image(self.buttonIconTrue)

    
def leave_notify(selfappletevent):
        
self.do_image(self.buttonIconFalse)

    
def do_image(selfimage_filesaturate):
        
pixbuf gtk.gdk.pixbuf_new_from_file(image_file)
        if 
saturate:
            
gtk.gdk.Pixbuf.saturate_and_pixelate(pixbufpixbuf1.5False)
        
self.button_icon.set_from_pixbuf(pixbuf)

    
def createPanelButtonself ):
        
self.button_icon gtk.image_new_from_fileself.buttonIcon )
        
self.systemlabel gtk.Labelself.buttonText )
        if 
os.path.exists("/etc/linuxmint/info"):
            
import commands
            tooltip 
commands.getoutput("cat /etc/linuxmint/info | grep DESCRIPTION")
            
tooltip tooltip.replace("DESCRIPTION""")
            
tooltip tooltip.replace("=""")
            
tooltip tooltip.replace("\"""")
            
self.systemlabel.set_tooltip_text(tooltip)
            
self.button_icon.set_tooltip_text(tooltip)

        if 
self.applet.get_orient() == mateapplet.ORIENT_UP or self.applet.get_orient() == mateapplet.ORIENT_DOWN:
            
self.button_box gtk.HBox()
            
self.button_box.pack_startself.button_iconFalseFalse )
            
self.button_box.pack_startself.systemlabelFalseFalse )

            
self.button_icon.set_padding5)
        
# if we have a vertical panel
        
elif self.applet.get_orient() == mateapplet.ORIENT_LEFT:
            
self.button_box gtk.VBox()
            
self.systemlabel.set_angle270 )
            
self.button_box.pack_startself.systemlabel )
            
self.button_box.pack_startself.button_icon )
            
self.button_icon.set_padding5)
        
elif self.applet.get_orient() == mateapplet.ORIENT_RIGHT:
            
self.button_box gtk.VBox()
            
self.systemlabel.set_angle90 )
            
self.button_box.pack_startself.button_icon )
            
self.button_box.pack_startself.systemlabel )
            
self.button_icon.set_padding0)

        
self.button_box.set_homogeneousFalse )
        
self.button_box.show_all()
        
self.sizeButton()

        
self.applet.addself.button_box )


    
def getGconfEntriesself, *args, **kargs ):
        
self.hideIcon   =  self.gconf.get"bool""hide_applet_icon"False )
        
self.buttonText =  self.gconf.get"string""applet_text""Menu" )
        
self.theme_name =  self.gconf.get"string""theme_name""default" )
        
self.hotkeyText =  self.gconf.get"string""hot_key""<Control>Super_L" )
        
self.buttonIcon =  self.gconf.get"string""applet_icon"ICON )
        
self.iconSize self.gconf.get"int""applet_icon_size"22 )    

    
def changeBackgroundselfapplettypecolorpixmap ):
        
        
self.applyTheme()
        
        
# get reset style
        
self.applet.set_style(None)
        
rc_style gtk.RcStyle()
        
self.applet.modify_style(rc_style)

        if 
mateapplet.COLOR_BACKGROUND == type:
            
applet.modify_bggtk.STATE_NORMALcolor )
        
elif mateapplet.PIXMAP_BACKGROUND == type:
            
style applet.style
            style
.bg_pixmapgtk.STATE_NORMAL ] = pixmap
            applet
.set_stylestyle )
            
    
def changeTheme(self, *args):        
        
self.gconfEntriesChanged()
        
self.applyTheme()
        
self.mainwin.RegenPlugins()
    
    
def applyTheme(self):
        
style_settings gtk.settings_get_default()
        
desktop_theme self.gconf.get"string"'/desktop/mate/interface/gtk_theme'"")
        if 
self.theme_name == "default":
            
style_settings.set_property("gtk-theme-name"desktop_theme)        
        else:
            try:
                
style_settings.set_property("gtk-theme-name"self.theme_name)
            
except:
                
style_settings.set_property("gtk-theme-name"desktop_theme)            

    
def changeOrientationself, *args, **kargs ):

        if 
self.applet.get_orient() == mateapplet.ORIENT_UP or self.applet.get_orient() == mateapplet.ORIENT_DOWN:
            
tmpbox gtk.HBox()
            
self.systemlabel.set_angle)
            
self.button_box.reorder_childself.button_icon)
            
self.button_icon.set_padding5)
        
elif self.applet.get_orient() == mateapplet.ORIENT_LEFT:
            
tmpbox gtk.VBox()
            
self.systemlabel.set_angle270 )
            
self.button_box.reorder_childself.button_icon)
            
self.button_icon.set_padding0)
        
elif self.applet.get_orient() == mateapplet.ORIENT_RIGHT:
            
tmpbox gtk.VBox()
            
self.systemlabel.set_angle90 )
            
self.button_box.reorder_childself.button_icon)
            
self.button_icon.set_padding0)

        
tmpbox.set_homogeneousFalse )

        
# reparent all the hboxes to the new tmpbox
        
for i in self.button_box:
            
i.reparenttmpbox )

        
self.button_box.destroy()

        
self.button_box tmpbox
        self
.button_box.show()

        
# this call makes sure width stays intact
        
self.updateButton()
        
self.applet.addself.button_box )


    
def updateButtonself ):
        
self.systemlabel.set_textself.buttonText )
        
self.button_icon.clear()
        
self.button_icon.set_from_fileself.buttonIcon )
        
self.sizeButton()

    
def bind_hot_key (self):
        try:
            
# Binding menu to hotkey
            
print "Binding to Hot Key: " self.hotkeyText
            bind_key
self.hotkeyTextself.onBindingPress )
        
except Exceptioncause:
            print 
"** WARNING ** - Menu Hotkey Binding Error"
            
print "Error Report :\n"str(cause)
            
pass

    def sizeButton
self ):
        if 
self.hideIcon:
            
self.button_icon.hide()
        else:
            
self.button_icon.show()
        
# This code calculates width and height for the button_box
        # and takes the orientation in account
        
if self.applet.get_orient() == mateapplet.ORIENT_UP or self.applet.get_orient() == mateapplet.ORIENT_DOWN:
            if 
self.hideIcon:
                
self.applet.set_size_requestself.systemlabel.size_request()[0] + 2, -)
            else:
                
self.applet.set_size_requestself.systemlabel.size_request()[0] + self.button_icon.size_request()[0] + 5self.button_icon.size_request()[1] )
        else:
            if 
self.hideIcon:
                
self.applet.set_size_requestself.button_icon.size_request()[0], self.systemlabel.size_request()[1] + )
            else:
                
self.applet.set_size_requestself.button_icon.size_request()[0], self.systemlabel.size_request()[1] + self.button_icon.size_request()[1] + )

    
def gconfEntriesChangedself, *args ):
        
self.getGconfEntries()
        
self.updateButton()        

    
def showAboutDialogselfuicomponentverb ):

        
gtk.about_dialog_set_email_hooklambda dialogmailgnomevfs.url_show"mailto:" mail ) )
        
gtk.about_dialog_set_url_hooklambda dialogurlgnomevfs.url_showurl ) )
        
about gtk.AboutDialog()
        
about.set_name("mintMenu")
        
import commands
        version 
commands.getoutput("/usr/lib/linuxmint/common/version.py mintmenu")
        
about.set_version(version)
        try:
            
open('/usr/share/common-licenses/GPL','r')
            
h.readlines()
            
gpl ""
            
for line in s:
                
gpl += line
            h
.close()
            
about.set_license(gpl)
        
except Exceptiondetail:
            print 
detail
        about
.set_comments_("Advanced Gnome Menu") )
        
about.set_authors( ["Clement Lefebvre <clem@linuxmint.com>""Lars-Peter Clausen <lars@laprican.de>"] )
        
about.set_translator_credits(("translator-credits") )
        
#about.set_copyright( _("Based on USP from S.Chanderbally") )
        
about.set_logogtk.gdk.pixbuf_new_from_file("/usr/lib/linuxmint/mintMenu/icon.svg") )
        
about.connect"response"lambda dialogrdialog.destroy() )
        
about.show()


    
def showPreferencesselfuicomponentverb ):
#               Execute( "mateconf-editor /apps/mintMenu" )
        
Executeos.path.joinPATH"mintMenuConfig.py" ) )

    
def showMenuEditorselfuicomponentverb ):
        
Execute"mozo" )

    
def showMenuselfwidget=Noneevent=None ):
        if 
event == None or event.button == 1:
            
self.toggleMenu()
        
# show right click menu
        
elif event.button == 3:
            
self.create_menu()
        
# allow middle click and drag
        
elif event.button == 2:
            
self.mainwin.hideTrue )

    
def toggleMenuself ):
        if 
self.applet.state gtk.STATE_SELECTED:
            
self.mainwin.hideTrue )
        else:
            
self.positionMenu()
            
self.mainwin.show()
            
self.wakePlugins()

    
def wakePluginsself ):
        
self.mainwin.wakePlugins()

    
def positionMenuself ):
        
# Get our own dimensions & position
        
ourWidth  self.mainwin.window.get_size()[0]
        
ourHeight self.mainwin.window.get_size()[1] + self.mainwin.offset

        
# Get the dimensions/position of the widgetToAlignWith
        
entryXentryY self.applet.window.get_origin()
        
entryWidthentryHeight =  self.applet.get_allocation().widthself.applet.get_allocation().height
        entryHeight 
entryHeight self.mainwin.offset

        
# Get the screen dimensions
        
screenHeight gtk.gdk.screen_height()
        
screenWidth gtk.gdk.screen_width()

        if 
self.applet.get_orient() == mateapplet.ORIENT_UP or self.applet.get_orient() == mateapplet.ORIENT_DOWN:
            if 
entryX ourWidth screenWidth or  entryX entryWidth screenWidth 2:
            
# Align to the left of the entry
                
newX entryX
            
else:
                
# Align to the right of the entry
                
newX entryX entryWidth ourWidth

            
if entryY entryHeight screenHeight 2:
                
# Align to the bottom of the entry
                
newY entryY entryHeight
            
else:
                
newY entryY ourHeight
        
else:
            if 
entryX entryWidth screenWidth 2:
                
# Align to the left of the entry
                
newX entryX entryWidth
            
else:
                
# Align to the right of the entry
                
newX entryX ourWidth

            
if entryY ourHeight screenHeight or entryY entryHeight screenHeight 2:
                
# Align to the bottom of the entry
                
newY entryY
            
else:
                
newY entryY ourHeight entryHeight
        
# -"Move window"
        
self.mainwin.window.movenewXnewY )

    
# this callback is to create a context menu
    
def create_menu(self):
        
self.applet.setup_menu(self.propxmlself.verbsNone)

def menu_factoryappletiid ):
    
MenuWinappletiid )
    
applet.show()
    return 
True

def quit_all
(widget):
    
gtk.main_quit()
    
sys.exit(0)

if 
len(sys.argv) == and sys.argv[1] == "run-in-window":
    
gtk.gdk.threads_init()
    
main_window gtk.Windowgtk.WINDOW_TOPLEVEL )
    
main_window.set_titleNAME )
    
main_window.connect"destroy"quit_all )
    
app mateapplet.Applet()
    
menu_factoryappNone )
    
app.reparentmain_window )
    
main_window.show()
    
gtk.gdk.threads_enter()
    
gtk.main()
    
gtk.gdk.threads_leave()
else:
    
mateapplet.matecomponent_factory("OAFIID:MATE_mintMenu_Factory",
                         
mateapplet.Applet.__gtype__,
                         
"mintMenu""0"menu_factory)




la bête applet n'est pas idiote, d'autant plus que Xfapplet permet d'intégrer mintmenu dans le panel de xfce, avec une icone trés trés moche...

jackinthebox, Tuesday 06 November 2012 à 19:03


Subscription date : 05 November 2012
Messages : 8
L'invité précédent est bien moi, sauf que j'avais oublié de me connecter...

matttbe, Tuesday 06 November 2012 à 19:14


Subscription date : 24 January 2009
Messages : 12573
Il n'y a pas un manuel?
man mintmenu


J'y vois cependant une option comme: "run-in-window", ça pourrait aider mais à première vue, je ne vois pas d'option pour forcer une position

jackinthebox, Tuesday 06 November 2012 à 19:23


Subscription date : 05 November 2012
Messages : 8
non, j'y avais songé, duc oup je suis aller faire un tour du coté des sources :
#!/usr/bin/python

import sys, os

if len(sys.argv) > 1:
if (sys.argv[1] in ["clean", "clear", "reset", "--clean", "--clear", "--reset"]):
os.system("mateconftool-2 --recursive-unset /apps/mintMenu")
os.system("rm -rf ~/.linuxmint/mintMenu")
os.system("mateconftool-2 --recursive-unset /apps/mintMenu")
os.system("rm -rf ~/.linuxmint/mintMenu")
print "All mintMenu settings are now restored to default"
else:
os.system("/usr/lib/linuxmint/mintMenu/mintMenu.py run-in-window")


Peut être y a t'il moyen , à en croire la dernière ligne, de passer d'autres options à mintMenu.py pour l'afficher où l'on souhaite? J'avoue de très sérieuses lacunes en python, et en programmation en général d'ailleurs...

jackinthebox, Thursday 08 November 2012 à 00:36


Subscription date : 05 November 2012
Messages : 8
Bon apparemment certains utilisateurs de linux mint rencontrent le même souci d'après d'autres forums. J'ai tenté de regarder ce que pouvait faire pour régler simplement la situation, mais ça dépasse mes maigres compétences...

fabounet, Saturday 10 November 2012 à 23:08


Subscription date : 30 November 2007
Messages : 17118


@fabounet: ne serait-ce pas plus simple d'avoir une "bête" applet qui ne fait que lancer une commande?

non, pour les différentes raisons citées par jackinthebox

depuis qu'ils ont renommé gnomeapplet en mateapplet, ben notre applet est cassée
la solution pour nous est de modifier le code pour importer mateapplet.
par contre, il faut de toute facon que ce package soit installé (et je ne sais même pas d'où il vient). jackinthebox est-ce que tu peux vérifier que tu l'as ? il doit être dans /usr/lib/python2.7/dist-packages ou un endroit de ce genre.

matttbe, Saturday 10 November 2012 à 23:24


Subscription date : 24 January 2009
Messages : 12573
On peut aussi y aller à coups de try/catch

fabounet, Saturday 10 November 2012 à 23:51


Subscription date : 30 November 2007
Messages : 17118
oui, d'ailleurs voici un petit patch
peux-tu éditer le fichier ~/.config/cairo-dock/third-party/MintMenu/MintMenu, et changer la ligne 26 (import gnomeapplet) en :

try:
    
import gnomeapplet
except
:
    
import mateapplet as gnomeapplet


C'est du python, donc pense à bien ajouter une tabulation devant chaque "import" pour indenter le code.
relance l'applet, et dis-nous ce que tu vois dans le terminal et si ça marche
Merci !

jackinthebox, Sunday 11 November 2012 à 10:58


Subscription date : 05 November 2012
Messages : 8
ok j'essaie ça... merci à Vous !

Guest, Sunday 11 November 2012 à 11:05

bon, je me retrouve avec la même erreur hélas après la modification :

(mintMenu.py:3574): MateComponent-CRITICAL **: matecomponent_corba_object_type_register_static: assertion `g_type_from_name (name) == 0' failed
/usr/lib/python2.7/dist-packages/gtk-2.0/matecomponent/init.py:12: Warning: /build/buildd/glib2.0-2.34.0/./gobject/gsignal.c:1634: parameter 1 of type `<unknown>' for signal "MateComponentObject::system_exception" is not a value type
from _matecomponent import *

Guest, Sunday 11 November 2012 à 11:12

Au passage, oui j'ai bien gnomeapplet dans mes librairies python (qui au passage n'est plus dans les dépôts d'ubuntu depuis la 11.10 au mois, j'iai du fait un saut chez debian pour le récupérer) et également mateapplet.

fabounet, Tuesday 13 November 2012 à 15:56


Subscription date : 30 November 2007
Messages : 17118
il te faut soit l'une, soit l'autre.
je pense que tu as mateapplet installé mais pas le reste (il dépend d'autres packages);

sachant que Mintmenu est fait par et pour mint, qui utilise mate, je pense qu'utiliser mintmenu est devenu impossible en dehors de mint
ou alors, il faut rester avec une version plus ancienne (celle de mint11 ou 12 qui utilisait gnomeapplet).

Applets | Applets

Subjects Author Language Messages Last message
[Locked] xfce 4.10 et mint menu
jackinthebox Français 14 fabounet [Read]
13 November 2012 à 15:56


Glx-Dock / Cairo-Dock List of forums Applets | Applets xfce 4.10 et mint menu Top

Online users :

Powered by ElementSpeak © 2007 Adrien Pilleboue, 2009-2013 Matthieu Baerts.
Dock based on CSS Dock Menu (Ndesign) with jQuery. Icons by zgegball
Cairo-Dock is a free software under GNU-GPL3 licence. First stable version created by Fabounet.
Many thanks to TuxFamily for the web Hosting and Mav for the domain name.