[X2Go-Commits] pyhoca-gui.git - build-59a18b6e3b5d3f1dd8f07f26433d37fe5984a57d (branch) updated: 0.1.0.10-136-g53a9d5c

X2Go dev team git-admin at x2go.org
Tue Aug 27 13:22:10 CEST 2013


The branch, build-59a18b6e3b5d3f1dd8f07f26433d37fe5984a57d has been updated
       via  53a9d5c9ea81eb1cd903f31aa9d9c1821097bd97 (commit)
      from  eb73a2ac865c600edfd2aa22c4c17a10ef0333c9 (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
-----------------------------------------------------------------------

Summary of changes:
 pyhoca/wxgui/frontend.py       |  147 ++++++++-------
 pyhoca/wxgui/menus_taskbar.py  |  389 ++++++++++++++++++++++------------------
 pyhoca/wxgui/profilemanager.py |   14 +-
 3 files changed, 312 insertions(+), 238 deletions(-)

The diff of changes is:
diff --git a/pyhoca/wxgui/frontend.py b/pyhoca/wxgui/frontend.py
index 1231e2c..18e636c 100644
--- a/pyhoca/wxgui/frontend.py
+++ b/pyhoca/wxgui/frontend.py
@@ -178,7 +178,7 @@ class PyHocaGUI(wx.App, x2go.X2goClient):
 
         wx.App.__init__(self, redirect=False, clearSigInt=False)
 
-        SetExitHandler(self._exit_handler)
+        #SetExitHandler(self._exit_handler)
 
         if not self.args.disable_splash:
             splash.PyHocaGUI_SplashScreen()
@@ -224,11 +224,12 @@ class PyHocaGUI(wx.App, x2go.X2goClient):
 
         """
         # cmd line options
+        self.auto_connect = self.args.auto_connect
         self.start_on_connect = self.args.start_on_connect
         self.resume_newest_on_connect = self.args.resume_newest_on_connect
         self.resume_oldest_on_connect = self.args.resume_oldest_on_connect
         self.resume_all_on_connect = self.args.resume_all_on_connect
-        self.exit_on_disconnect = self.args.exit_on_disconnect or self.args.single_session_profile
+        self.exit_on_disconnect = self.args.exit_on_disconnect
         self.disconnect_on_suspend = self.args.disconnect_on_suspend
         self.disconnect_on_terminate = self.args.disconnect_on_terminate
         self.show_profile_metatypes = self.args.show_profile_metatypes
@@ -278,41 +279,51 @@ class PyHocaGUI(wx.App, x2go.X2goClient):
 
         if self.args.session_profile:
             for profile_name in self.args.session_profile.split(','):
-                _dummy_id = wx.NewId()
-                self._eventid_profilenames_map[_dummy_id] = profile_name
-                evt = wx.CommandEvent()
-                evt.SetId(_dummy_id)
                 self.start_on_connect = True
                 self.resume_newest_on_connect = True
+                if not self.args.single_session_profile:
+                    self.auto_connect = True
                 self._pyhoca_logger('opening default session profile %s' % profile_name, loglevel=x2go.log.loglevel_NOTICE)
-                self.OnSessionAuthenticate(evt)
+                self._X2goClient__register_session(profile_name=profile_name, auto_connect=True)
 
-        if self.args.auto_connect or self.args.single_session_profile:
+        if self.auto_connect:
             gevent.spawn(self._auto_connect)
 
-
     def _auto_connect(self):
 
         # wait for splash to appear
         if not self.args.disable_splash:
             gevent.sleep(1)
-        if not self.args.single_session_profile:
+        if not self.args.session_profile:
             self._X2goClient__register_all_session_profiles()
 
     def session_auto_connect(self, session_uuid):
 
         # override X2goClient method
-        if self.args.auto_connect and self._X2goClient__session_can_auto_connect(session_uuid):
-            self._X2goClient__session_auto_connect(session_uuid)
+        if self.auto_connect:
+            self.HOOK_profile_auto_connect(self.get_session_profile_name(session_uuid))
+
+    def HOOK_profile_auto_connect(self, profile_name):
+
+        session_uuids = self.client_registered_sessions_of_profile_name(profile_name=profile_name)
+        if session_uuids:
+            session_uuid = session_uuids[0]
+
+            _dummy_id = wx.NewId()
+            self._eventid_profilenames_map[_dummy_id] = profile_name
+            evt = wx.CommandEvent()
+            evt.SetId(_dummy_id)
+
+            self.OnSessionAuthenticate(evt, session_uuid=session_uuid)
 
     def session_auto_start_or_resume(self, session_uuid, newest=True, oldest=False, all_suspended=False):
 
         if self.resume_newest_on_connect:
             self._X2goClient__session_auto_start_or_resume(session_uuid, newest=True, start=self.start_on_connect)
         elif self.resume_oldest_on_connect:
-            self._X2goClient__session_auto_start_or_resume(session_uuid, oldest=True, start=self.start_on_connect)
+            self._X2goClient__session_auto_start_or_resume(session_uuid, newest=False, oldest=True, start=self.start_on_connect)
         elif self.resume_all_on_connect:
-            self._X2goClient__session_auto_start_or_resume(session_uuid, all_suspended=True, start=self.start_on_connect)
+            self._X2goClient__session_auto_start_or_resume(session_uuid, newest=False, all_suspended=True, start=self.start_on_connect)
 
     def _exit_handler(self, *args):
         self.WakeUpIdle()
@@ -332,9 +343,8 @@ class PyHocaGUI(wx.App, x2go.X2goClient):
             if not self._hide_notifications_map.has_key(profile_name):
                 self._hide_notifications_map[profile_name] = []
             self._hide_notifications_map[profile_name].append(session_obj.get_session_name())
-            gevent.spawn(session_obj.suspend)
+            session_obj.suspend()
         x2go.x2go_cleanup()
-
         self.about.Close()
         self.taskbar.Close()
 
@@ -348,21 +358,18 @@ class PyHocaGUI(wx.App, x2go.X2goClient):
         if self.args.single_session_profile:
             if not x2go.defaults.X2GOCLIENT_OS == 'Windows':
                 if self.client_running_sessions_of_profile_name(self.args.session_profile):
-                    self.notifier.send(self.args.session_profile, _('Suspending sessions and exiting...'), icon='application-exit', timeout=10000)
+                    self.notifier.send(self.appname, _('Suspending sessions and exiting application...'), icon='application-exit', timeout=10000)
                 else:
                     if self.is_profile_connected(profile_name=self.args.session_profile):
-                        self.notifier.send(self.args.session_profile, _('Disconnecting and exiting...'), icon='application-exit', timeout=10000)
+                        self.notifier.send(self.appname, _('Disconnecting %s and exiting application ...') % self.args.session_profile, icon='application-exit', timeout=10000)
                     else:
-                        self.notifier.send(self.args.session_profile, _('Exiting...'), icon='application-exit', timeout=10000)
+                        self.notifier.send(self.appname, _('Exiting application...'), icon='application-exit', timeout=10000)
             self._eventid_profilenames_map[evt.GetId()] = self.args.session_profile
-            self.OnServerDisconnect(evt)
         self.WakeUpIdle()
         self.ExitMainLoop()
 
     def _init_pubapp_session(self, session_uuid=None, profile_name=None):
 
-        session_list = self._X2goClient__list_sessions(session_uuid=session_uuid, profile_name=profile_name, refresh_cache=True, update_sessionregistry=True)
-
         if profile_name is None and session_uuid:
             profile_name = self._X2goClient__get_session_profile_name(session_uuid)
 
@@ -370,52 +377,70 @@ class PyHocaGUI(wx.App, x2go.X2goClient):
             session_uuid = self._X2goClient__client_connected_sessions_of_profile_name(profile_name, return_objects=False)[0]
 
         connected_session = self._X2goClient__get_session(session_uuid)
-        if connected_session.has_server_feature('X2GO_PUBLISHED_APPLICATIONS'):
+        if connected_session.has_server_feature('X2GO_PUBLISHED_APPLICATIONS') and self.get_profile_config(profile_name)['published']:
+
+            if len(self.client_pubapp_sessions_of_profile_name(profile_name=profile_name)):
+                return False
 
             if profile_name not in self._temp_launching_pubapp_profiles:
                 self._temp_launching_pubapp_profiles.append(profile_name)
 
-            pubapp_sessions = self._X2goClient__client_pubapp_sessions_of_profile_name(profile_name, return_objects=True)
             pubapp_session_started = False
             pubapp_session_resumed = False
-            pubapp_session_running = (len([ _pas for _pas in pubapp_sessions if _pas.is_running() ]) >= 1)
-            if not pubapp_session_running:
-                for session_name in [_sn for _sn in session_list.keys() if session_list[_sn].is_suspended() ]:
-
-                    if session_list[session_name].is_published_applications_provider() and not pubapp_session_resumed:
-                        # resume sessions in published applications mode immediately
-                        pubapp_session = self._X2goClient__register_session(profile_name=profile_name,
-                                                                            published_applications=True,
-                                                                            cmd='PUBLISHED',
-                                                                            session_type='published',
-                                                                            session_name=session_name,
-                                                                            published_applications_no_submenus=self.args.published_applications_no_submenus,
-                                                                            return_object=True
-                                                                           )
-                        pubapp_session.resume()
-                        pubapp_session_resumed = True
-                    elif session_list[session_name].is_published_applications_provider() and pubapp_session_resumed:
-                        # if there are more then one (in suspended state, of course), terminate them now...
-                        self._X2goClient__get_session_of_session_name(session_name, return_object=True).terminate()
 
-                if not pubapp_session_resumed:
+            ### PyHoca-GUI does not support more than one session in published applications mode...
+
+            # suspend any running session that is in published applications mode (unless we are already associated with it)
+            session_list = self._X2goClient__list_sessions(session_uuid=session_uuid, profile_name=profile_name, refresh_cache=True, update_sessionregistry=True)
+            pubapp_sessions_running = [ _sn for _sn in session_list.keys() if session_list[_sn].is_running() and session_list[_sn].is_published_applications_provider() ]
+            for session_name in pubapp_sessions_running:
+
+                self.suspend_session(session_uuid=connected_session(), session_name=session_name)
+
+            # resume first available session in published applications mode... (from PyHoca-GUI's perspective there should only
+            # be one)
+            session_list = self._X2goClient__list_sessions(session_uuid=session_uuid, profile_name=profile_name, refresh_cache=True, update_sessionregistry=True)
+            pubapp_sessions_suspended = [ _sn for _sn in session_list.keys() if session_list[_sn].is_suspended() and session_list[_sn].is_published_applications_provider() ]
 
+            for session_name in pubapp_sessions_suspended:
+
+                if not pubapp_session_resumed:
+                    # resume one single session in published applications mode immediately, if available
                     pubapp_session = self._X2goClient__register_session(profile_name=profile_name,
                                                                         published_applications=True,
                                                                         cmd='PUBLISHED',
                                                                         session_type='published',
+                                                                        session_name=session_name,
                                                                         published_applications_no_submenus=self.args.published_applications_no_submenus,
                                                                         return_object=True
                                                                        )
-                    pubapp_session.start()
-                    pubapp_session_started = True
+                    pubapp_session_resumed = pubapp_session.resume()
+                elif session_list[session_name].is_published_applications_provider() and pubapp_session_resumed:
+
+                    # if there are more then one published applications mode sessions (in suspended state), terminate them now...
+
+                    connected_session.terminate(session_name=session_name)
+
+            if not pubapp_session_resumed:
+
+                pubapp_session = self._X2goClient__register_session(profile_name=profile_name,
+                                                                    published_applications=True,
+                                                                    cmd='PUBLISHED',
+                                                                    session_type='published',
+                                                                    published_applications_no_submenus=self.args.published_applications_no_submenus,
+                                                                    return_object=True
+                                                                   )
+                pubapp_session.start()
+                pubapp_session_started = True
 
             if profile_name in self._temp_launching_pubapp_profiles:
                 self._temp_launching_pubapp_profiles.remove(profile_name)
 
             return pubapp_session_started | pubapp_session_resumed
 
-        self.notifier.send(_(u'%s - server warning') % profile_name, _(u'The X2Go Server does not publish an application menu.'), icon='session_warning', timeout=10000)
+        elif not connected_session.has_server_feature('X2GO_PUBLISHED_APPLICATIONS'):
+            self.notifier.send(_(u'%s - server warning') % profile_name, _(u'The X2Go Server does not publish an application menu.'), icon='session_warning', timeout=10000)
+
         return None
 
     def _post_authenticate(self, evt, session_uuid):
@@ -424,11 +449,7 @@ class PyHocaGUI(wx.App, x2go.X2goClient):
 
             profile_name = self.get_session(session_uuid).get_profile_name()
             self._hide_notifications_map[profile_name] = []
-            if self._X2goClient__get_profile_config(profile_name)['published']:
-                if self.args.single_session_profile:
-                    self._init_pubapp_session(session_uuid=session_uuid)
-                else:
-                    gevent.spawn(self._init_pubapp_session, session_uuid=session_uuid)
+            gevent.spawn(self._init_pubapp_session, session_uuid)
 
         except x2go.X2goSessionRegistryException:
             # there might have been a disconnect event inbetween...
@@ -543,26 +564,28 @@ class PyHocaGUI(wx.App, x2go.X2goClient):
             if os.environ.has_key('PYHOCAGUI_DEVELOPMENT') and os.environ['PYHOCAGUI_DEVELOPMENT'] == '1': 
                 raise
 
-
         if connect_failed and self.exit_on_disconnect:
             self.WakeUpIdle()
             self.ExitMainLoop()
 
         self.taskbar.SetIconIdle()
 
-    def OnSessionAuthenticate(self, evt):
+    def OnSessionAuthenticate(self, evt, session_uuid=None):
         """\
         STILL UNDOCUMENTED
 
         """
         self.current_profile_name = self._eventid_profilenames_map[evt.GetId()]
         self.taskbar.SetIconConnecting(self.current_profile_name)
-        session_uuid = self._X2goClient__register_session(profile_name=self.current_profile_name)
+        if session_uuid is None:
+            session_uuid = self._X2goClient__register_session(profile_name=self.current_profile_name)
         if session_uuid:
             self._temp_disabled_profile_names.append(self.current_profile_name)
             gevent.spawn(self._do_authenticate, evt, session_uuid)
         elif self.args.session_profile:
-            self.notifier.send(_('Unknown Session Profile'), _(u'Unknown session profile %s') % self.current_profile_name, icon='profile_warning', timeout=10000)
+            self.notifier.send(self.current_profile_name, _(u'Unknown session profile, configure before using it...'), icon='profile_warning', timeout=10000)
+            if not self.is_session_profile(self.current_profile_name):
+                profilemanager.PyHocaGUI_ProfileManager(self, 'ADD_EXPLICITLY', profile_name=self.current_profile_name)
 
     def OnSessionStart(self, evt):
         """\
@@ -704,13 +727,13 @@ class PyHocaGUI(wx.App, x2go.X2goClient):
 
         gevent.spawn(self._X2goClient__disconnect_profile, self.current_profile_name)
 
-        if not self.args.single_session_profile:
-            self.notifier.send(_(u'%s - disconnect') % self.current_profile_name, _(u'X2Go Profile is now disconnected.'), icon='auth_disconnect', timeout=4000)
-
         if self.exit_on_disconnect:
             self._pyhoca_logger('Exiting %s because %s got disconnected.' % (self.appname, self.current_profile_name), loglevel=x2go.loglevel_NOTICE)
             self.WakeUpIdle()
             self.ExitMainLoop()
+        else:
+            self.notifier.send(_(u'%s - disconnect') % self.current_profile_name, _(u'X2Go Profile is now disconnected.'), icon='auth_disconnect', timeout=4000)
+
         try:
             del self._temp_disabled_session_names[self.current_profile_name]
         except KeyError:
@@ -731,7 +754,11 @@ class PyHocaGUI(wx.App, x2go.X2goClient):
         """
         self.current_profile_name = self._eventid_profilenames_map[evt.GetId()]
         self._pyhoca_logger('editing session profile %s' % self.current_profile_name, loglevel=x2go.log.loglevel_INFO, )
-        profilemanager.PyHocaGUI_ProfileManager(self, 'EDIT', profile_name=self.current_profile_name)
+        if self.args.single_session_profile:
+            _edit_action = "EDIT_EXPLICITLY"
+        else:
+            _edit_action = "EDIT"
+        profilemanager.PyHocaGUI_ProfileManager(self, _edit_action, profile_name=self.current_profile_name)
 
     def OnProfileCopy(self, evt):
         """\
diff --git a/pyhoca/wxgui/menus_taskbar.py b/pyhoca/wxgui/menus_taskbar.py
index 126de26..aecaa19 100644
--- a/pyhoca/wxgui/menus_taskbar.py
+++ b/pyhoca/wxgui/menus_taskbar.py
@@ -66,9 +66,10 @@ class PyHocaGUI_Menu_TaskbarManageProfile(wx.Menu):
             self._PyHocaGUI._eventid_profilenames_map[ID_DELETEPROFILE] = profile_name
 
         self.Append(text=_(u"Edit Profile"), id=ID_EDITPROFILE)
-        self.AppendSeparator()
-        self.Append(text=_(u"Use as Template for New Profile"), id=ID_COPYPROFILE)
-        self.Append(text=_(u"Delete Profile"), id=ID_DELETEPROFILE)
+        if not self._PyHocaGUI.args.single_session_profile:
+            self.AppendSeparator()
+            self.Append(text=_(u"Use as Template for New Profile"), id=ID_COPYPROFILE)
+            self.Append(text=_(u"Delete Profile"), id=ID_DELETEPROFILE)
 
         self._PyHocaGUI.Bind(wx.EVT_MENU, self._PyHocaGUI.OnProfileEdit, id=ID_EDITPROFILE)
         self._PyHocaGUI.Bind(wx.EVT_MENU, self._PyHocaGUI.OnProfileCopy, id=ID_COPYPROFILE)
@@ -120,6 +121,9 @@ class PyHocaGUI_Menu_TaskbarOptionsManager(wx.Menu):
                                                          text=_(u'Manage Session Profile'),
                                                          submenu=PyHocaGUI_Menu_TaskbarManageProfile(self._PyHocaGUI, caller=self, profile_name=self._PyHocaGUI.args.session_profile),
                                                         )
+                if self._PyHocaGUI.args.session_profile in self._PyHocaGUI.client_connected_profiles(return_profile_names=True):
+                    _maintain_profile_item.Enable(False)
+
             self.AppendSeparator()
 
             ID_PRINTINGPREFS = wx.NewId()
@@ -146,7 +150,7 @@ class PyHocaGUI_Menu_TaskbarSessionActions(wx.Menu):
     STILL UNDOCUMENTED
 
     """
-    def __init__(self, _PyHocaGUI, caller=None, profile_name=None, session_name=None, status=None):
+    def __init__(self, _PyHocaGUI, caller=None, profile_name=None, session_name=None, session_info=None, status=None):
         """\
         STILL UNDOCUMENTED
 
@@ -182,24 +186,32 @@ class PyHocaGUI_Menu_TaskbarSessionActions(wx.Menu):
             self._PyHocaGUI._eventid_sessionnames_map[ID_TERMINATESESSION] = session_name
 
         _s = self._PyHocaGUI.get_session_of_session_name(session_name, return_object=True)
+        _session_status = status
+        if session_info is not None:
+            _session_status = session_info.get_status()
+        elif _s.get_session_info() is not None:
+            _session_status = _s.get_session_info().get_status()
 
         if _s is not None and \
-           _s.get_session_cmd() in x2go.defaults.X2GO_DESKTOPSESSIONS and \
-           status == 'R' and \
-           not _s.is_published_applications_provider():
+            _s.get_session_cmd() in x2go.defaults.X2GO_DESKTOPSESSIONS and \
+            _session_status == 'R' and \
+            not _s.is_published_applications_provider():
 
             _title = self.Append(text=_("Window title") + ": " + _s.get_session_title(), id=wx.NewId())
             self.AppendSeparator()
 
-        if status == 'S':
+        if _session_status == 'S':
 
             if _s is not None and _s.is_color_depth_ok():
-                self.Append(text=_("Resume Session"), id=ID_RESUMESESSION)
+                _rs = self.Append(text=_("Resume Session"), id=ID_RESUMESESSION)
             else:
                 _rs = self.Append(text=_(u"Resume Session (not possible)"), id=ID_RESUMESESSION_DISABLED)
                 _rs.Enable(False)
 
-        elif status == 'R':
+            if session_info is not None and session_info.is_published_applications_provider() and not self._PyHocaGUI.get_profile_config(profile_name)['published']:
+                _rs.Enable(False)
+
+        elif _session_status == 'R':
 
             if not session_name in self._PyHocaGUI.client_associated_sessions_of_profile_name(profile_name, return_session_names=True):
 
@@ -209,14 +221,17 @@ class PyHocaGUI_Menu_TaskbarSessionActions(wx.Menu):
                     _ts = self.Append(text=_(u"Transfer Session (not possible)"), id=ID_TRANSFERSESSION_DISABLED)
                     _ts.Enable(False)
 
-            self.Append(text=_(u"Suspend Session"), id=ID_SUSPENDSESSION)
+            _ss = self.Append(text=_(u"Suspend Session"), id=ID_SUSPENDSESSION)
 
+            if _s.is_published_applications_provider() and not self._PyHocaGUI.get_profile_config(profile_name)['published']:
+                _ss.Enable(False)
 
         self.Append(text=_(u"Terminate Session"), id=ID_TERMINATESESSION)
 
         if _s is not None and \
            _s.get_session_cmd() in x2go.defaults.X2GO_DESKTOPSESSIONS and \
-           status == 'R' and \
+           not _s.is_published_applications_provider() and \
+           _session_status == 'R' and \
            _s in self._PyHocaGUI.client_associated_sessions_of_profile_name(profile_name, return_objects=True):
 
             self.AppendSeparator()
@@ -340,8 +355,8 @@ def _generate_Menu_PublishedApplications(_PyHocaGUI, caller=None, profile_name=N
 
     """
     _lang = _PyHocaGUI.lang
-    _pub_app_session = _PyHocaGUI.get_session_of_session_name(session_name, return_object=True)
-    menu_map = _pub_app_session.get_published_applications(lang=_lang, max_no_submenus=_PyHocaGUI.args.published_applications_no_submenus)
+    _pubapp_session = _PyHocaGUI.get_session_of_session_name(session_name, return_object=True)
+    menu_map = _pubapp_session.get_published_applications(lang=_lang, max_no_submenus=_PyHocaGUI.args.published_applications_no_submenus)
     if not menu_map.has_key(_lang):
         return {}
 
@@ -428,102 +443,52 @@ class PyHocaGUI_Menu_TaskbarSessionProfile(wx.Menu):
         ID_SHARELOCALFOLDER = wx.NewId()
         ID_UNSHAREFOLDERS = wx.NewId()
 
-        current_profile_config = self._PyHocaGUI.get_profile_config(profile_name)
-
-        if profile_name in self._PyHocaGUI._temp_disabled_profile_names:
-            _connecting_info = self.Append(wx.NewId(), text=_(u'Currently connecting...'))
-            _connecting_info.Enable(False)
-
-        elif self._PyHocaGUI.args.single_session_profile and not self._PyHocaGUI.is_profile_connected(profile_name=profile_name):
-            self._PyHocaGUI._eventid_profilenames_map[ID_CONNECT] = profile_name
-            self.Append(id=ID_CONNECT, text=_(u'Connect %s') % profile_name)
-            self._PyHocaGUI.Bind(wx.EVT_MENU, self._PyHocaGUI.OnSessionAuthenticate, id=ID_CONNECT)
+        _foldersharing_disabled = False
 
+        if self._PyHocaGUI.args.single_session_profile and not self._PyHocaGUI.is_session_profile(profile_name):
+            connect = self.Append(id=ID_CONNECT, text=_(u'Connect %s') % profile_name)
+            connect.Enable(False)
         else:
+            current_profile_config = self._PyHocaGUI.get_profile_config(profile_name)
 
-            self._PyHocaGUI._eventid_profilenames_map[ID_SESSIONSTART] = profile_name
-
-            if current_profile_config['command'] in x2go.defaults.X2GO_DESKTOPSESSIONS:
-                self.Append(id=ID_SESSIONSTART, text='%s (%s)' % (_(u"Start &new Desktop Session"), current_profile_config['command']))
-                self._PyHocaGUI.Bind(wx.EVT_MENU, self._PyHocaGUI.OnSessionStart, id=ID_SESSIONSTART)
-            elif current_profile_config['command'] == '' and current_profile_config['published']:
-                if profile_name in self._PyHocaGUI._temp_launching_pubapp_profiles:
-                    _pub_app_start_item = self.Append(id=ID_PUBAPPSESSIONSTART, text=_(u"Retrieving Application Menu..."))
-                    _pub_app_start_item.Enable(False)
-                else:
-                    self._PyHocaGUI._eventid_profilenames_map[ID_PUBAPPSESSIONSTART] = profile_name
-                    _pub_app_start_item = self.Append(id=ID_PUBAPPSESSIONSTART, text=_(u"Retrieve Application Menu"))
-                self._PyHocaGUI.Bind(wx.EVT_MENU, self._PyHocaGUI.OnPubAppSessionStart, id=ID_PUBAPPSESSIONSTART)
-            else:
-                self.Append(id=ID_SESSIONSTART, text=_(u"Start &new Session"))
-                self._PyHocaGUI.Bind(wx.EVT_MENU, self._PyHocaGUI.OnSessionStart, id=ID_SESSIONSTART)
+            if profile_name in self._PyHocaGUI._temp_disabled_profile_names:
+                _connecting_info = self.Append(wx.NewId(), text=_(u'Currently connecting...'))
+                _connecting_info.Enable(False)
 
-            self.AppendSeparator()
-
-            if current_profile_config['command'] == '' and current_profile_config['published']:
-
-                _pub_app_sessions = [ _pas for _pas in self._PyHocaGUI.client_pubapp_sessions_of_profile_name(profile_name, return_objects=True) if _pas.is_running() ]
-                if _pub_app_sessions:
-                    _pub_app_session = _pub_app_sessions[0]
-                    _pub_app_start_item.Enable(False)
-                    _session_name_disabled = self._PyHocaGUI.is_session_name_disabled(profile_name, _pub_app_session.get_session_name())
-                    _category_map = _generate_Menu_PublishedApplications(self._PyHocaGUI, caller=self, profile_name=profile_name, session_name=_pub_app_session.get_session_name())
-                    _category_names = _category_map.keys()
-                    _category_names.sort()
-                    for cat_name in [ _cn for _cn in _category_names if _cn != 'NO_SUBMENUS' ]:
-                        _submenu = self.AppendMenu(id=wx.NewId(), text=cat_name, submenu=_category_map[cat_name][0])
-                        _submenu.SetBitmap(wx.Bitmap(_category_map[cat_name][1]))
-                        if _session_name_disabled:
-                            _submenu.Enable(False)
-                    if 'NO_SUBMENUS' in _category_names:
-                        for _menu_item in _category_map['NO_SUBMENUS'][0].GetMenuItems():
-                            _item = self.AppendItem(item=_menu_item)
-                            if _session_name_disabled:
-                                _item.Enable(False)
-                    self.AppendSeparator()
-
-                    ID_RESUMESESSION = wx.NewId()
-                    ID_SUSPENDSESSION = wx.NewId()
-                    ID_TERMINATESESSION = wx.NewId()
-                    self._PyHocaGUI._eventid_profilenames_map[ID_RESUMESESSION] = \
-                        self._PyHocaGUI._eventid_profilenames_map[ID_SUSPENDSESSION] = \
-                        self._PyHocaGUI._eventid_profilenames_map[ID_TERMINATESESSION] = profile_name
-                    self._PyHocaGUI._eventid_sessionnames_map[ID_RESUMESESSION] = \
-                        self._PyHocaGUI._eventid_sessionnames_map[ID_SUSPENDSESSION] = \
-                        self._PyHocaGUI._eventid_sessionnames_map[ID_TERMINATESESSION] = _pub_app_session.get_session_name()
-
-                    if _pub_app_session.is_running():
-                        self.Append(text=_(u"Suspend Session"), id=ID_SUSPENDSESSION)
-                    elif _pub_app_session.is_suspended():
-                        self.Append(text=_(u"Resume Session"), id=ID_RESUMESESSION)
-                    self.Append(text=_(u"Terminate Session"), id=ID_TERMINATESESSION)
-                    self.AppendSeparator()
-
-                    self._PyHocaGUI.Bind(wx.EVT_MENU, self._PyHocaGUI.OnSessionResume, id=ID_RESUMESESSION)
-                    self._PyHocaGUI.Bind(wx.EVT_MENU, self._PyHocaGUI.OnSessionSuspend, id=ID_SUSPENDSESSION)
-                    self._PyHocaGUI.Bind(wx.EVT_MENU, self._PyHocaGUI.OnSessionTerminate, id=ID_TERMINATESESSION)
+            elif self._PyHocaGUI.args.single_session_profile and \
+                 not self._PyHocaGUI.is_profile_connected(profile_name=profile_name):
+                    self._PyHocaGUI._eventid_profilenames_map[ID_CONNECT] = profile_name
+                    self.Append(id=ID_CONNECT, text=_(u'Connect %s') % profile_name)
+                    self._PyHocaGUI.Bind(wx.EVT_MENU, self._PyHocaGUI.OnSessionAuthenticate, id=ID_CONNECT)
 
             else:
 
-                # preparing profile_name information for the main PyHocaGUI instance
-                self._PyHocaGUI._eventid_profilenames_map[ID_LAUNCHAPPLICATION] = \
-                    self._PyHocaGUI._eventid_profilenames_map[ID_CLEANSESSIONS] = profile_name
+                self._PyHocaGUI._eventid_profilenames_map[ID_SESSIONSTART] = profile_name
 
-                if current_profile_config['applications'] and current_profile_config['command'] in x2go.defaults.X2GO_DESKTOPSESSIONS and not current_profile_config['published']:
-                    self.AppendMenu(id=ID_LAUNCHAPPLICATION, text=_(u"Launch Single Application"),
-                                    submenu=PyHocaGUI_Menu_LaunchSingleApplication(self._PyHocaGUI, caller=self, profile_name=profile_name)
-                                   )
-                    self.AppendSeparator()
+                if current_profile_config['command'] in x2go.defaults.X2GO_DESKTOPSESSIONS:
+                    self.Append(id=ID_SESSIONSTART, text='%s (%s)' % (_(u"Start &new Desktop Session"), current_profile_config['command']))
+                    self._PyHocaGUI.Bind(wx.EVT_MENU, self._PyHocaGUI.OnSessionStart, id=ID_SESSIONSTART)
+                elif current_profile_config['command'] == '' and current_profile_config['published']:
+                    if profile_name in self._PyHocaGUI._temp_launching_pubapp_profiles:
+                        _pub_app_start_item = self.Append(id=ID_PUBAPPSESSIONSTART, text=_(u"Retrieving Application Menu..."))
+                        _pub_app_start_item.Enable(False)
+                    else:
+                        self._PyHocaGUI._eventid_profilenames_map[ID_PUBAPPSESSIONSTART] = profile_name
+                        _pub_app_start_item = self.Append(id=ID_PUBAPPSESSIONSTART, text=_(u"Retrieve Application Menu"))
+                    self._PyHocaGUI.Bind(wx.EVT_MENU, self._PyHocaGUI.OnPubAppSessionStart, id=ID_PUBAPPSESSIONSTART)
+                else:
+                    self.Append(id=ID_SESSIONSTART, text=_(u"Start &new Session"))
+                    self._PyHocaGUI.Bind(wx.EVT_MENU, self._PyHocaGUI.OnSessionStart, id=ID_SESSIONSTART)
 
-                if current_profile_config['published']:
+                if current_profile_config['command'] == '' and current_profile_config['published']:
 
-                    _pub_app_session = None
-                    _pub_app_sessions = [ _pas for _pas in self._PyHocaGUI.client_pubapp_sessions_of_profile_name(profile_name, return_objects=True) if _pas.is_running() ]
-                    if _pub_app_sessions:
-                        _pub_app_session = _pub_app_sessions[0]
-                    if _pub_app_session and _pub_app_session.is_running():
-                        _session_name_disabled = self._PyHocaGUI.is_session_name_disabled(profile_name, _pub_app_session.get_session_name())
-                        _category_map = _generate_Menu_PublishedApplications(self._PyHocaGUI, caller=self, profile_name=profile_name, session_name=_pub_app_session.get_session_name())
+                    self.AppendSeparator()
+                    _pubapp_sessions = [ _pas for _pas in self._PyHocaGUI.client_pubapp_sessions_of_profile_name(profile_name, return_objects=True) if _pas.is_running() ]
+                    if _pubapp_sessions:
+                        _pubapp_session = _pubapp_sessions[0]
+                        _pub_app_start_item.Enable(False)
+                        _foldersharing_disabled = _session_name_disabled = self._PyHocaGUI.is_session_name_disabled(profile_name, _pubapp_session.get_session_name())
+                        _category_map = _generate_Menu_PublishedApplications(self._PyHocaGUI, caller=self, profile_name=profile_name, session_name=_pubapp_session.get_session_name())
                         _category_names = _category_map.keys()
                         _category_names.sort()
                         for cat_name in [ _cn for _cn in _category_names if _cn != 'NO_SUBMENUS' ]:
@@ -536,102 +501,180 @@ class PyHocaGUI_Menu_TaskbarSessionProfile(wx.Menu):
                                 _item = self.AppendItem(item=_menu_item)
                                 if _session_name_disabled:
                                     _item.Enable(False)
-
                         self.AppendSeparator()
 
-                        _marker = ''
-                        _status = None
-                        if _pub_app_session.is_master_session(): _marker = '(*)'
-                        if _pub_app_session.is_running(): _status = 'R'
-                        elif _pub_app_session.is_suspended(): _status = 'S'
-
-                        if _status:
-                            _submenu = self.AppendMenu(id=wx.NewId(), text=_(u'Manage Application Menu')+' %s' % _marker,
-                                                       submenu=PyHocaGUI_Menu_TaskbarSessionActions(self._PyHocaGUI, caller=self,
-                                                                                                    profile_name=profile_name,
-                                                                                                    session_name=_pub_app_session.get_session_name(),
-                                                                                                    status=_status,
-                                                                                                   )
-                                                  )
+                        ID_RESUMESESSION = wx.NewId()
+                        ID_SUSPENDSESSION = wx.NewId()
+                        ID_TERMINATESESSION = wx.NewId()
+                        self._PyHocaGUI._eventid_profilenames_map[ID_RESUMESESSION] = \
+                            self._PyHocaGUI._eventid_profilenames_map[ID_SUSPENDSESSION] = \
+                            self._PyHocaGUI._eventid_profilenames_map[ID_TERMINATESESSION] = profile_name
+                        self._PyHocaGUI._eventid_sessionnames_map[ID_RESUMESESSION] = \
+                            self._PyHocaGUI._eventid_sessionnames_map[ID_SUSPENDSESSION] = \
+                            self._PyHocaGUI._eventid_sessionnames_map[ID_TERMINATESESSION] = _pubapp_session.get_session_name()
+
+                        if _pubapp_session.is_running():
+                            _suspend_item = self.Append(text=_(u"Suspend Session"), id=ID_SUSPENDSESSION)
                             if _session_name_disabled:
-                                _submenu.Enable(False)
+                                _suspend_item.Enable(False)
+                        elif _pubapp_session.is_suspended():
+                            _resume_item = self.Append(text=_(u"Resume Session"), id=ID_RESUMESESSION)
+                            if _session_name_disabled:
+                                _resume_item.Enable(False)
+                        _terminate_item = self.Append(text=_(u"Terminate Session"), id=ID_TERMINATESESSION)
+                        if _session_name_disabled:
+                            _terminate_item.Enable(False)
+
+                        self.AppendSeparator()
+
+                        self._PyHocaGUI.Bind(wx.EVT_MENU, self._PyHocaGUI.OnSessionResume, id=ID_RESUMESESSION)
+                        self._PyHocaGUI.Bind(wx.EVT_MENU, self._PyHocaGUI.OnSessionSuspend, id=ID_SUSPENDSESSION)
+                        self._PyHocaGUI.Bind(wx.EVT_MENU, self._PyHocaGUI.OnSessionTerminate, id=ID_TERMINATESESSION)
+
+                else:
+
+                    # preparing profile_name information for the main PyHocaGUI instance
+                    self._PyHocaGUI._eventid_profilenames_map[ID_LAUNCHAPPLICATION] = \
+                        self._PyHocaGUI._eventid_profilenames_map[ID_CLEANSESSIONS] = profile_name
+
+                    if current_profile_config['applications'] and current_profile_config['command'] in x2go.defaults.X2GO_DESKTOPSESSIONS and not current_profile_config['published']:
+                        self.AppendSeparator()
+                        self.AppendMenu(id=ID_LAUNCHAPPLICATION, text=_(u"Launch Single Application"),
+                                        submenu=PyHocaGUI_Menu_LaunchSingleApplication(self._PyHocaGUI, caller=self, profile_name=profile_name)
+                                       )
+
+                    if current_profile_config['published']:
+
+                        self.AppendSeparator()
+
+                        _pubapp_session = None
+                        _pubapp_sessions = [ _pas for _pas in self._PyHocaGUI.client_pubapp_sessions_of_profile_name(profile_name, return_objects=True) if _pas.is_running() ]
+                        if _pubapp_sessions:
+                            _pubapp_session = _pubapp_sessions[0]
+                        if _pubapp_session and _pubapp_session.is_running():
+                            _session_name_disabled = self._PyHocaGUI.is_session_name_disabled(profile_name, _pubapp_session.get_session_name())
+                            _category_map = _generate_Menu_PublishedApplications(self._PyHocaGUI, caller=self, profile_name=profile_name, session_name=_pubapp_session.get_session_name())
+                            _category_names = _category_map.keys()
+                            _category_names.sort()
+                            for cat_name in [ _cn for _cn in _category_names if _cn != 'NO_SUBMENUS' ]:
+                                _submenu = self.AppendMenu(id=wx.NewId(), text=cat_name, submenu=_category_map[cat_name][0])
+                                _submenu.SetBitmap(wx.Bitmap(_category_map[cat_name][1]))
+                                if _session_name_disabled:
+                                    _submenu.Enable(False)
+                            if 'NO_SUBMENUS' in _category_names:
+                                for _menu_item in _category_map['NO_SUBMENUS'][0].GetMenuItems():
+                                    _item = self.AppendItem(item=_menu_item)
+                                    if _session_name_disabled:
+                                        _item.Enable(False)
+
                             self.AppendSeparator()
-                    else:
-                        self._PyHocaGUI._eventid_profilenames_map[ID_PUBAPPSESSIONSTART] = profile_name
-                        if profile_name in self._PyHocaGUI._temp_launching_pubapp_profiles:
-                            _ram = self.Append(id=ID_PUBAPPSESSIONSTART, text=_(u"Retrieving Application Menu..."))
-                            _ram.Enable(False)
+
+                            _marker = ''
+                            _status = None
+                            if _pubapp_session.is_master_session(): _marker = '(*)'
+                            if _pubapp_session.is_running(): _status = 'R'
+                            elif _pubapp_session.is_suspended(): _status = 'S'
+
+                            if _status:
+                                _submenu = self.AppendMenu(id=wx.NewId(), text=_(u'Manage Application Menu')+' %s' % _marker,
+                                                           submenu=PyHocaGUI_Menu_TaskbarSessionActions(self._PyHocaGUI, caller=self,
+                                                                                                        profile_name=profile_name,
+                                                                                                        session_name=_pubapp_session.get_session_name(),
+                                                                                                        status=_status,
+                                                                                                       )
+                                                      )
+                                if _session_name_disabled:
+                                    _submenu.Enable(False)
+
                         else:
-                            self.Append(id=ID_PUBAPPSESSIONSTART, text=_(u"Retrieve Application Menu"))
-                        self._PyHocaGUI.Bind(wx.EVT_MENU, self._PyHocaGUI.OnPubAppSessionStart, id=ID_PUBAPPSESSIONSTART)
+                            self._PyHocaGUI._eventid_profilenames_map[ID_PUBAPPSESSIONSTART] = profile_name
+                            if profile_name in self._PyHocaGUI._temp_launching_pubapp_profiles:
+                                _ram = self.Append(id=ID_PUBAPPSESSIONSTART, text=_(u"Retrieving Application Menu..."))
+                                _ram.Enable(False)
+                            else:
+                                self.Append(id=ID_PUBAPPSESSIONSTART, text=_(u"Retrieve Application Menu"))
+                            self._PyHocaGUI.Bind(wx.EVT_MENU, self._PyHocaGUI.OnPubAppSessionStart, id=ID_PUBAPPSESSIONSTART)
+
+                    _query_session_uuid = self._PyHocaGUI.client_connected_sessions_of_profile_name(profile_name, return_objects=False)[0]
+                    _session_list = self._PyHocaGUI.list_sessions(_query_session_uuid)
+
+                    _session_list_names = []
+                    if _session_list:
+
                         self.AppendSeparator()
 
-                _query_session_uuid = self._PyHocaGUI.client_connected_sessions_of_profile_name(profile_name, return_objects=False)[0]
-                _session_list = self._PyHocaGUI.list_sessions(_query_session_uuid)
-
-                if _session_list:
-
-                    # newest sessions at the top
-                    _session_list_names = [ _s_name for _s_name in _session_list.keys() if not _session_list[_s_name].is_published_applications_provider() ]
-                    _session_list_names.reverse()
-                    for session_name in _session_list_names:
-
-                        session = self._PyHocaGUI.get_session_of_session_name(session_name, return_object=True)
-
-                        _s_id = wx.NewId()
-
-                        if _session_list[session_name].status == 'R':
-                            state = _(u'Running')
-                        elif _session_list[session_name].status == 'S':
-                            state = _(u'Suspended')
-                        _marker = ''
-                        if session and session.is_master_session():
-                            _marker = '(*)'
-                        if session:
-                            session_submenu = self.AppendMenu(id=_s_id, text=u'%s: »%s« %s' % (state, session_name, _marker),
-                                                              submenu=PyHocaGUI_Menu_TaskbarSessionActions(self._PyHocaGUI, caller=self,
-                                                                                                           profile_name=profile_name,
-                                                                                                           session_name=session_name,
-                                                                                                           status=_session_list[session_name].status,
-                                                                                                          )
-                                                         )
-                            if self._PyHocaGUI._temp_disabled_session_names.has_key(profile_name) and session_name in self._PyHocaGUI._temp_disabled_session_names[profile_name]:
-                                session_submenu.Enable(False)
+                        # newest sessions at the top
+                        if current_profile_config['published']:
+                            _session_list_names = [ _s_name for _s_name in _session_list.keys() if not _session_list[_s_name].is_published_applications_provider() ]
+                        else:
+                            _session_list_names = _session_list.keys()
+                        _session_list_names.reverse()
 
                     if _session_list_names:
-                        self.Append(id=ID_CLEANSESSIONS, text=_(u"&Clean all sessions"))
-                        self.AppendSeparator()
 
-                self._PyHocaGUI.Bind(wx.EVT_MENU, self._PyHocaGUI.OnCleanSessions, id=ID_CLEANSESSIONS)
+                        for session_name in _session_list_names:
+
+                            session = self._PyHocaGUI.get_session_of_session_name(session_name, return_object=True)
+
+                            _s_id = wx.NewId()
 
-            self._PyHocaGUI._eventid_profilenames_map[ID_EDITPROFILEWHILECONNECTED] = \
-                self._PyHocaGUI._eventid_profilenames_map[ID_SHARELOCALFOLDER] = \
-                self._PyHocaGUI._eventid_profilenames_map[ID_UNSHAREFOLDERS] = profile_name
+                            if _session_list[session_name].get_status() == 'R':
+                                state = _(u'Running')
+                            elif _session_list[session_name].get_status() == 'S':
+                                state = _(u'Suspended')
+                            _marker = ''
+                            if session and session.is_master_session():
+                                _marker = '(*)'
+                            if session:
+                                session_submenu = self.AppendMenu(id=_s_id, text=u'%s: »%s« %s' % (state, session_name, _marker),
+                                                                  submenu=PyHocaGUI_Menu_TaskbarSessionActions(self._PyHocaGUI, caller=self,
+                                                                                                               profile_name=profile_name,
+                                                                                                               session_name=session_name,
+                                                                                                               session_info=_session_list[session_name],
+                                                                                                              )
+                                                                 )
+                                if self._PyHocaGUI._temp_disabled_session_names.has_key(profile_name) and session_name in self._PyHocaGUI._temp_disabled_session_names[profile_name]:
+                                    session_submenu.Enable(False)
 
-            self.Append(id=ID_EDITPROFILEWHILECONNECTED, text=_(u"Customize &profile"))
-            self._PyHocaGUI.Bind(wx.EVT_MENU, self._PyHocaGUI.OnProfileEditWhileConnected, id=ID_EDITPROFILEWHILECONNECTED)
+                        # redefine list of session names to decide if the clean all session menu item is not be shown
+                        _session_list_names = [ _s_name for _s_name in _session_list.keys() if not _session_list[_s_name].is_published_applications_provider() ]
 
-            if current_profile_config['useexports'] and self._PyHocaGUI._X2goClient__profile_is_folder_sharing_available(profile_name=profile_name):
+                        if _session_list_names:
+                            self.Append(id=ID_CLEANSESSIONS, text=_(u"&Clean all sessions"))
+                            self._PyHocaGUI.Bind(wx.EVT_MENU, self._PyHocaGUI.OnCleanSessions, id=ID_CLEANSESSIONS)
 
-                _shared_folders = self.AppendMenu(id=ID_SHARELOCALFOLDER, text=_(u"Shared &folders"),
-                                                  submenu=PyHocaGUI_Menu_TaskbarProfileSharedFolders(self._PyHocaGUI, caller=self,
-                                                  profile_name=profile_name)
-                                                 )
-                if not self._PyHocaGUI._X2goClient__client_associated_sessions_of_profile_name(profile_name=profile_name, return_objects=False):
-                    _shared_folders.Enable(False)
+                        if _session_list_names:
+
+                            self.AppendSeparator()
+
+                self._PyHocaGUI._eventid_profilenames_map[ID_EDITPROFILEWHILECONNECTED] = \
+                    self._PyHocaGUI._eventid_profilenames_map[ID_SHARELOCALFOLDER] = \
+                    self._PyHocaGUI._eventid_profilenames_map[ID_UNSHAREFOLDERS] = profile_name
+
+                self.Append(id=ID_EDITPROFILEWHILECONNECTED, text=_(u"Customize &profile"))
+                self._PyHocaGUI.Bind(wx.EVT_MENU, self._PyHocaGUI.OnProfileEditWhileConnected, id=ID_EDITPROFILEWHILECONNECTED)
+
+                if current_profile_config['useexports'] and self._PyHocaGUI._X2goClient__profile_is_folder_sharing_available(profile_name=profile_name):
+
+                    _shared_folders = self.AppendMenu(id=ID_SHARELOCALFOLDER, text=_(u"Shared &folders"),
+                                                      submenu=PyHocaGUI_Menu_TaskbarProfileSharedFolders(self._PyHocaGUI, caller=self,
+                                                      profile_name=profile_name)
+                                                     )
+                    if not self._PyHocaGUI._X2goClient__client_associated_sessions_of_profile_name(profile_name=profile_name, return_objects=False) or _foldersharing_disabled:
+                        _shared_folders.Enable(False)
 
         self.AppendSeparator()
 
-        if not self._PyHocaGUI.args.single_session_profile:
+        if profile_name in self._PyHocaGUI.client_connected_profiles(return_profile_names=True):
             ID_DISCONNECT = wx.NewId()
             self._PyHocaGUI._eventid_profilenames_map[ID_DISCONNECT] = profile_name
             self.Append(id=ID_DISCONNECT, text=_(u"&Disconnect from Server"))
             self._PyHocaGUI.Bind(wx.EVT_MENU, self._PyHocaGUI.OnServerDisconnect, id=ID_DISCONNECT)
-        else:
+        if self._PyHocaGUI.args.single_session_profile:
             ID_EXIT = wx.NewId()
-            if self._PyHocaGUI.client_running_sessions_of_profile_name(profile_name=self._PyHocaGUI.args.session_profile):
+            if self._PyHocaGUI.client_running_sessions_of_profile_name(profile_name=self._PyHocaGUI.args.session_profile) and self._PyHocaGUI.args.exit_on_disconnect:
                 self.Append(id=ID_EXIT, text=_(u"Suspend Sessions and E&xit"))
-            elif self._PyHocaGUI.is_profile_connected(profile_name=self._PyHocaGUI.args.session_profile):
+            elif self._PyHocaGUI.is_profile_connected(profile_name=self._PyHocaGUI.args.session_profile) and self._PyHocaGUI.args.exit_on_disconnect:
                 self.Append(id=ID_EXIT, text=_(u"Disconnect and E&xit"))
             else:
                 self.Append(id=ID_EXIT, text=_(u"E&xit"))
diff --git a/pyhoca/wxgui/profilemanager.py b/pyhoca/wxgui/profilemanager.py
index 4ed854e..fac17b5 100644
--- a/pyhoca/wxgui/profilemanager.py
+++ b/pyhoca/wxgui/profilemanager.py
@@ -120,25 +120,24 @@ class PyHocaGUI_ProfileManager(wx.Dialog):
 
         if profile_id is not None:
             self.profile_id = profile_id
-        elif profile_name is not None and self.action in ('EDIT', 'EDIT_CONNECTED', 'COPY'):
+        elif profile_name is not None and self.action in ('EDIT', 'EDIT_CONNECTED', 'EDIT_EXPLICITLY', 'COPY'):
             self.profile_id = self.session_profiles.to_profile_id(profile_name)
         else:
             self.profile_id = None
 
-        if self.action in ('EDIT', 'EDIT_CONNECTED') and self.profile_id:
+        if self.action in ('EDIT', 'EDIT_CONNECTED', 'EDIT_EXPLICITLY') and self.profile_id:
             self.profile_name = self.session_profiles.to_profile_name(self.profile_id)
             self.profile_config = self.session_profiles.get_profile_config(self.profile_id)
         elif self.action == 'COPY' and self.profile_id:
             self.profile_name = self.session_profiles.to_profile_name(self.profile_id)
             self.profile_config = self.session_profiles.get_profile_config(self.profile_id)
             self.profile_name = self.profile_config['name'] = '%s %s' % (_('settings derived from '), self.profile_name)
-        else:
-            # if self.action == 'ADD' ...
+        elif self.action in ("ADD", "ADD_EXPLICITLY"):
             self.profile_config = self.session_profiles.default_profile_config()
             # allow localization of the default keyboard settings
             self.profile_config['layout'] = _(u'us')
             self.profile_config['type'] = _(u'pc105/us')
-            self.profile_name = self.profile_config['name'] = '%s' %_('new session profile')
+            self.profile_name = self.profile_config['name'] = profile_name
 
         # we create a backup dict of our profile_config immediately (for being able to reset erroneously made changes)
         self.profile_config_bak = copy.deepcopy(self.profile_config)
@@ -169,6 +168,11 @@ class PyHocaGUI_ProfileManager(wx.Dialog):
         ###
         self.ProfileNameLabel = wx.StaticText(self.tab_Profile, -1, _(u"Name")+":")
         self.ProfileName = wx.TextCtrl(self.tab_Profile, -1, "")
+
+        if self.action in ("EDIT_EXPLICITLY", "EDIT_EXPLICITLY"):
+            self.ProfileNameLabel.Enable(False)
+            self.ProfileName.Enable(False)
+
         self.SetSessionWindowTitle = wx.CheckBox(self.tab_Profile, -1, _(u"Set session window title"))
         self.UseDefaultSessionWindowTitle = wx.CheckBox(self.tab_Profile, -1, _(u"Use a default session window title"))
         self.CustomSessionWindowTitleLabel = wx.StaticText(self.tab_Profile, -1, _(u"Custom session window title") + ":")


hooks/post-receive
-- 
pyhoca-gui.git (Python X2Go Client (wxPython GUI))

This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "pyhoca-gui.git" (Python X2Go Client (wxPython GUI)).




More information about the x2go-commits mailing list