Ejemplo n.º 1
0
 public MitsubaOptionsPage(Rhino.PersistentSettings settings)
     : base("Mitsuba")
 {
     m_settings        = settings;
     m_mitsubaSettings = new MitsubaSettings();
     m_mitsubaSettings.Load(m_settings);
     m_control = new MitsubaOptionsControl(ref m_mitsubaSettings);
 }
 public bool ContainsModifiedValues(PersistentSettings allUserSettings)
 {
   if (null != m_Settings && m_Settings.Count > 0)
   {
     foreach (var v in m_Settings)
     {
       if (v.Value.ValueDifferentThanDefault)
         return true;
       if (null != allUserSettings && allUserSettings.m_Settings.ContainsKey(v.Key) && 0 != string.Compare(v.Value.GetValue(false), allUserSettings.m_Settings[v.Key].GetValue(false), StringComparison.Ordinal))
         return true;
     }
   }
   return false;
 }
 internal void CopyFrom(PersistentSettings source)
 {
   if (null != source)
   {
     foreach (var item in source.m_Settings)
     {
       if (m_Settings.ContainsKey(item.Key))
         m_Settings[item.Key].CopyFrom(item.Value);
       else
         m_Settings.Add(item.Key, new SettingValue(item.Value.GetValue(false), item.Value.GetValue(true)));
     }
   }
 }
 public PersistentSettings(PersistentSettings allUserSettings)
 {
   AllUserSettings = allUserSettings;
   m_Settings = new Dictionary<string, SettingValue>();
   m_SettingsValidators = new Dictionary<string, EventHandler<PersistentSettingsEventArgs>>();
 }
    /// <summary>
    /// Reads existing settings for a plug-in and its associated commands.
    /// Clears the dirty flag for the settings. 
    /// </summary>
    /// <returns>
    /// true if settings are successfully read. false if there was no existing
    /// settings file to read, or if a read lock could not be acquired.
    /// </returns>
    public bool ReadSettingsHelper(bool localSettings)
    {
      if (m_PluginSettings == null)
      {
        m_PluginSettings = new PersistentSettings(AllUserPlugInSettings);
        // If AllUserSettings is not null then we are reading local settings, when
        // reading local settings first get values previously read from the All Users
        // location and add them to the local dictionary so the settings will propagate
        // to the current user.
        if (localSettings && null != AllUserSettings)
          m_PluginSettings.CopyFrom(AllUserPlugInSettings);
      }

      if (m_CommandSettingsDict == null)
      {
        m_CommandSettingsDict = new Dictionary<string, PersistentSettings>();
        // If AllUserSettings is not null then we are reading local settings, when
        // reading local settings first get values previously read from the All Users
        // location and add them to the local dictionary so the settings will propagate
        // to the current user.
        if (null != AllUserSettings && null != AllUserSettings.m_CommandSettingsDict)
        {
          foreach (var item in AllUserSettings.m_CommandSettingsDict)
          {
            // Make a new settings dictionary to associate with this command
            PersistentSettings settings = new PersistentSettings(item.Value);
            // Copy settings from global command dictionary to local dictionary
            settings.CopyFrom(item.Value);
            // Add the settings to the local dictionary
            m_CommandSettingsDict.Add(item.Key, settings);
          }
        }
      }

      string settingsFileName = SettingsFileName(localSettings);

      if (File.Exists(settingsFileName) == false)
        return false;

      FileStream fs = null;
      try
      {
        bool bKeepTrying = false;
        int lockTryCount = 0;

        // Lame attempt to handle file locking. For performance reasons, only
        // try once more after failure to acquire lock.
        do
        {
          try
          {
            bKeepTrying = false;
            fs = new FileStream(settingsFileName, FileMode.Open, FileAccess.Read);
          }
          catch (IOException ioe)
          {
            if (!(ioe is FileNotFoundException) &&
              !(ioe is DirectoryNotFoundException) &&
              !(ioe is PathTooLongException))
            {
              // File is locked. Try once more then give up.  
              if (lockTryCount < 1)
              {
                bKeepTrying = true;
                lockTryCount++;
                System.Threading.Thread.Sleep(50);
              }
            }
          }
        } while (bKeepTrying);

        // Couldn't acquire lock
        if (fs == null)
          return false;

        XmlDocument doc = new XmlDocument();
        XmlNamespaceManager ns = new XmlNamespaceManager(doc.NameTable);
        ns.AddNamespace("xml", "http://www.w3.org/XML/1998/namespace");

        doc.Load(fs);

        fs.Close();
        fs.Dispose();

        // The settings attribute will either be "xml:id" or "id", this will check for "id" if "xml:id" is not found.
        XmlNode rootNode = doc.SelectSingleNode("/settings[@xml:id=\'" + CURRENT_XML_FORMAT_VERSION + "\']", ns) ??
                           doc.SelectSingleNode("/settings[@id=\'" + CURRENT_XML_FORMAT_VERSION + "\']", ns);
        if (rootNode == null)
          return false;

        // Parse main <plug-in> entry, if it exists, for plug-in settings
        m_PluginSettings.ParseXmlNodes(rootNode.SelectSingleNode("./plugin"));

        // Look for <command> nodes which will have a command name property that identifies the plug-in command settings
        XmlNodeList commandNodes = rootNode.SelectNodes("./command");
        if (commandNodes != null)
        {
          foreach (XmlNode commandNode in commandNodes)
          {
            XmlAttributeCollection attr_collection = commandNode.Attributes;
            if( attr_collection==null )
              continue;
            XmlNode attr = attr_collection.GetNamedItem("name");
            if (null != attr && !string.IsNullOrEmpty(attr.Value))
            {
              PersistentSettings entries = new PersistentSettings(AllUserCommandSettings(attr.Value));
              entries.ParseXmlNodes(commandNode);
              if (null != AllUserSettings && m_CommandSettingsDict.ContainsKey(attr.Value))
                m_CommandSettingsDict[attr.Value].CopyFrom(entries);
              else
                m_CommandSettingsDict[attr.Value] = entries;
            }
          }
        }
      }
      catch (Exception ex)
      {
        Rhino.Runtime.HostUtils.ExceptionReport(ex);
        return false;
      }
      finally
      {
        if (fs != null)
        {
          fs.Close();
          fs.Dispose();
        }
      }

      return true;
    }
 /// <summary>
 /// Gets the PersistentSettings associated with the specified command.  If the settings file
 /// has not been previously loaded and exists then it will get read.  If the command name is
 /// not in the command settings dictionary then a new entry will get created and its settings
 /// will be returned.
 /// </summary>
 /// <param name="name">Command name key to search for and/or add.</param>
 /// <returns>Returns PersistentSettings object associated with command name on success or null on error.</returns>
 public PersistentSettings CommandSettings(string name)
 {
   if (m_CommandSettingsDict == null)
   {
     ReadSettings();
     if (m_CommandSettingsDict == null)
       return null;
   }
   if (m_CommandSettingsDict.ContainsKey(name))
     return m_CommandSettingsDict[name];
   // There were no settings available for the command, so create one
   // for writing
   m_CommandSettingsDict[name] = new PersistentSettings(AllUserCommandSettings(name));
   return m_CommandSettingsDict[name];
 }
    /// <summary>
    /// If the settings dictionary contains one or more values, which are not equal to the default value, then Write the contents
    /// of this settings dictionary to the specified XmlWriter contained within elementName.
    /// </summary>
    /// <param name="xmlWriter">XmlWriter object to write to.</param>
    /// <param name="elementName">Element which will contain key value pairs.</param>
    /// <param name="attributeName">Optional element attribute.</param>
    /// <param name="attributeValue">Optional element attribute value.</param>
    /// <param name="allUserSettings">All users settings to compare with.</param>
    internal void WriteXmlElement(XmlWriter xmlWriter, string elementName, string attributeName, string attributeValue, PersistentSettings allUserSettings)
    {
      if (null != m_Settings && ContainsModifiedValues(allUserSettings))
      {
        xmlWriter.WriteStartElement(elementName);
        if (!string.IsNullOrEmpty(attributeName) && !string.IsNullOrEmpty(attributeValue))
          xmlWriter.WriteAttributeString(attributeName, attributeValue);

        foreach (var item in m_Settings)
        {
          string allUserValue = null;
          if (null != allUserSettings && allUserSettings.m_Settings.ContainsKey(item.Key))
            allUserValue = allUserSettings.m_Settings[item.Key].GetValue(false);
          string value = item.Value.GetValue(false);
          bool valueDifferentThanAllUser = (null != allUserValue && 0 != string.Compare(value, allUserValue, StringComparison.Ordinal));
          if (valueDifferentThanAllUser || item.Value.ValueDifferentThanDefault)
          {
            // Write current value
            xmlWriter.WriteStartElement("entry");
            xmlWriter.WriteAttributeString("key", item.Key);

            // The following is used when you want to write the default and all user values as item attributes
            // to the settings output file, useful when trying to determine why a value was written
            //const bool bWriteDefaultValue = false;
            //if (bWriteDefaullValue)
            //{
            //  string defaultValue = item.Value.GetValue(true);
            //  xmlWriter.WriteAttributeString("DefaultValue", null == defaultValue ? "" : defaultValue);
            //  if (null != allUserValue)
            //    xmlWriter.WriteAttributeString("AllUsersValue", allUserValue);
            //}

            if (!string.IsNullOrEmpty(value))
              xmlWriter.WriteString(value);
            xmlWriter.WriteEndElement();
          }
        }
        xmlWriter.WriteEndElement();
      }
    }