Changeset 1457

Timestamp:

07/05/08 09:43:06 (2 months ago)

Author:

rob

Message:

Fixed #393: added ApplySettingsSameMode? to make view settings default for current mode
* added ApplySettingsAll? to erase default values in the GlobalPrefs? for subclasses of FundamentalMode? so that the settings become the defaults for all modes

Location:

trunk/peppy

Files:

• frame.py (modified) (1 diff)
• fundamental_menu.py (modified) (3 diffs)
• lib/userparams.py (modified) (3 diffs)
• major.py (modified) (1 diff)

trunk/peppy/frame.py

@@ -344 +344 @@
         _("Edit"): 0.001,
         _("View"): 0.003,
+        _("View/Apply Settings"): -980,
         _("Tools"): 0.004,
         _("Transform"): 0.005,

trunk/peppy/fundamental_menu.py

@@ -10 +10 @@
 from peppy.actions.minibuffer import *
 from peppy.fundamental import *
+from peppy.lib.userparams import *
 
 
@@ -312 +313 @@
 
 
+class ApplySettingsSameMode(OnDemandActionNameMixin, SelectAction):
+    """Apply view settings to all tabs"""
+    name = "As Defaults for %s Mode"
+    default_menu = ("View/Apply Settings", 100)
+
+    def getMenuItemName(self):
+        """Override in subclass to provide the menu item name."""
+        return self.name % self.mode.keyword
+
+    def action(self, index=-1, multiplier=1):
+        locals = {}
+        locals[self.mode.__class__] = self.mode.classprefsDictFromLocals()
+        Publisher().sendMessage('peppy.preferences.changed', locals)
+        # Make the local values the defaults so that they'll become persistent
+        # by getting saved in the configuration file
+        self.mode.classprefsCopyFromLocals()
+
+
+class ApplySettingsAll(SelectAction):
+    """Apply view settings to editors"""
+    name = "As Defaults for All Modes"
+    default_menu = ("View/Apply Settings", 110)
+
+    def action(self, index=-1, multiplier=1):
+        msg_data = {}
+        settings = self.mode.classprefsDictFromLocals()
+        msg_data[FundamentalMode] = settings
+        msg_data['subclass'] = FundamentalMode
+        Publisher().sendMessage('peppy.preferences.changed', msg_data)
+        
+        FundamentalMode.classprefsOverrideSubclassDefaults(settings)
+
+
 class FundamentalMenu(IPeppyPlugin):
     """Trac plugin that provides the global menubar and toolbar.
@@ -343 +377 @@
                     EOLModeSelect, SelectBraces,
                     
-                    ElectricReturn, ElectricDelete, ElectricBackspace]
+                    ElectricReturn, ElectricDelete, ElectricBackspace,
+                    
+                    ApplySettingsSameMode, ApplySettingsAll,
+                    ]
         return []

trunk/peppy/lib/userparams.py

@@ -1300 +1300 @@
     def __call__(self, name):
         return self._get(name)
+    
+    def _getNameHierarchy(self):
+        return GlobalPrefs.name_hierarchy[self.__dict__['_startSearch']]
+
+    def _getClassHierarchy(self):
+        return GlobalPrefs.class_hierarchy[self.__dict__['_startSearch']]
 
     def _get(self, name, user=True, default=True):
@@ -1469 +1475 @@
     pass
 
-
 class ClassPrefs(object):
     """Base class to extend in order to support class prefs.
@@ -1509 +1514 @@
                     #dprint("setting classpref %s to %s" % (param.keyword, self.classprefs._get(param.keyword)))
                     self.classprefs._set(param.keyword, getattr(self.locals, param.keyword))
+    
+    @classmethod
+    def classprefsSetDefaults(cls, new_locals):
+        """Update the class defaults from the locals
+        """
+        hier = cls.classprefs._getMRO()
+        #dprint(hier)
+        updated = {}
+        for cls in hier:
+            if 'default_classprefs' not in dir(cls):
+                continue
+            for param in cls.default_classprefs:
+                if param.local and param.keyword in new_locals:
+                    #dprint("setting classpref %s to %s" % (param.keyword, self.classprefs._get(param.keyword)))
+                    cls.classprefs._set(param.keyword, new_locals[param.keyword])
+    
+    @classmethod
+    def classprefsOverrideSubclassDefaults(cls, new_locals):
+        """Override settings of this class and all subclasses
+        
+        Remove all the user values from GlobalPrefs of items that would
+        override these class settings definitions.  All subclasses of this
+        class will have their settings removed so that this class becomes the
+        default value for all of its subclasses.
+        
+        This is used to change the settings of FundamentalMode so that
+        subclasses like PythonMode or CPlusPlusMode will take their settings
+        from Fundamental mode.
+        """
+        cls.classprefsSetDefaults(new_locals)
+        #dprint("fund: %s" % GlobalPrefs.user)
+        #dprint("defaults: %s" % GlobalPrefs.default)
+        #dprint("name: %s" % GlobalPrefs.name_hierarchy)
+        parent = cls.__name__
+        for name, hier in GlobalPrefs.name_hierarchy.iteritems():
+            if parent in hier:
+                if name == parent:
+                    # Override fundamental mode defaults with user settings
+                    #dprint("before: %s: %s" % (name, GlobalPrefs.user[name]))
+                    for k in new_locals.keys():
+                        if k in GlobalPrefs.default[name] and GlobalPrefs.default[name] != new_locals[k]:
+                            GlobalPrefs.user[name][k] = new_locals[k]
+                    #dprint("after: %s: %s" % (name, GlobalPrefs.user[name]))
+                else:
+                    # erase user settings so that fundamental mode settings
+                    # will show through
+                    #dprint("before: %s: %s" % (name, GlobalPrefs.user[name]))
+                    for k in new_locals.keys():
+                        if k in GlobalPrefs.user[name]:
+                            del GlobalPrefs.user[name][k]
+                    #dprint("after: %s: %s" % (name, GlobalPrefs.user[name]))
+
+    def classprefsDictFromLocals(self):
+        """Return a dict copy of the local settings"""
+        copy = {}
+        for k in dir(self.locals):
+            if not k.startswith('_'):
+                copy[k] = getattr(self.locals, k)
+        return copy
     
     def classprefsUpdateLocals(self, new_locals):

trunk/peppy/major.py

@@ -858 +858 @@
     
     def applyLocals(self, locals):
-        if locals and self.__class__ in locals:
-            pairs = locals[self.__class__]
-            self.dprint("applying local variables from %s" % str(pairs))
-            self.classprefsUpdateLocals(pairs)
+        if locals:
+            pairs = None
+            if self.__class__ in locals:
+                pairs = locals[self.__class__]
+            elif 'subclass' in locals:
+                cls = locals['subclass']
+                if issubclass(self.__class__, cls):
+                    pairs = locals[cls]
+            if pairs:
+                self.dprint("applying local variables from %s" % str(pairs))
+                self.classprefsUpdateLocals(pairs)
         else:
             self.dprint("%s not found in %s" % (self.__class__, str(locals)))