Пример #1
0
        bool SyncSmarFanProfile4HighAmperageFanHeader(bool bUseOrigConfig, ref List <SmartFanMultiCurveConfig> targetCfgs, out bool pbTargetConfigChanged)
        {
            int pFanControlIndex       = -1;
            int pMinDutyCyclePercetage = 0;

            pbTargetConfigChanged = false;

            if (targetCfgs == null || targetCfgs.Count == 0)
            {
                return(false);
            }

            if (!this.CheckAnyHighAmperageFanHeaderEnable(out pFanControlIndex, out pMinDutyCyclePercetage) || pFanControlIndex == -1)
            {
                return(true);
            }

            if (pFanControlIndex >= targetCfgs.Count)
            {
                return(false);
            }

            if (this.highAmpFanMgr.IsQualify(targetCfgs[pFanControlIndex]))
            {
                return(true);
            }

            bool ret;

            if (bUseOrigConfig)
            {
                var mCfg = new SmartFanMultiCurveConfig();
                this.fanConfigProfMgr.Read(pFanControlIndex, ref mCfg);
                targetCfgs.RemoveAt(pFanControlIndex);
                targetCfgs.Insert(pFanControlIndex, mCfg);
                pbTargetConfigChanged = true;
                ret = true;
            }
            else
            {
                SmartFanMultiCurveConfig targetSmartFanMultiCurveConfig = targetCfgs[pFanControlIndex];
                ret = this.highAmpFanMgr.ModifyProfile(pFanControlIndex, SmartFanLevels.Standard, ref targetSmartFanMultiCurveConfig, out pbTargetConfigChanged);
            }

            return(ret);
        }
Пример #2
0
        bool SyncSmartFanProfile(string xmlFilePath, ref List <SmartFanMultiCurveConfig> pNewFanCfgs, out bool profHasSameAtr)
        {
            bool pbTargetConfigChanged = false;
            bool pbSameAttribute       = false;

            profHasSameAtr = false;

            if (pNewFanCfgs == null)
            {
                return(false);
            }

            if (pNewFanCfgs.Count > 0)
            {
                pNewFanCfgs.Clear();
            }

            if (string.IsNullOrEmpty(xmlFilePath) || string.IsNullOrWhiteSpace(xmlFilePath) || (this.fanConfigProfMgr == null || this.fanConfigProfMgr.FanControlCount == 0))
            {
                return(false);
            }

            int fanControlCount = this.fanConfigProfMgr.FanControlCount;

            for (int fanControlIndex = 0; fanControlIndex < fanControlCount; ++fanControlIndex)
            {
                var curveCfg = new SmartFanMultiCurveConfig();
                this.fanConfigProfMgr.Read(fanControlIndex, ref curveCfg);
                pNewFanCfgs.Add(curveCfg);
            }

            if (pNewFanCfgs.Count == 0)
            {
                return(false);
            }

            try {
                var  exportMgr = new SmartFanMultiCurveConfigProfileImportExportManagement();
                bool readed    = exportMgr.ReadFile(xmlFilePath, true, ref pNewFanCfgs, out pbSameAttribute);
                profHasSameAtr = pbSameAttribute;

                if (!readed || pNewSmartFanConfigs.Count == 0)
                {
                    Console.WriteLine("Invalid file: " + xmlFilePath);
                    return(false);
                }

                SyncSmarFanProfile4HighAmperageFanHeader(true, ref pNewFanCfgs, out pbTargetConfigChanged);

                for (int fanControlIndex = 0; fanControlIndex < pNewFanCfgs.Count; ++fanControlIndex)
                {
                    SmartFanMultiCurveConfig newSmartFanMultiCurveConfig = pNewFanCfgs[fanControlIndex];
                    this.fanConfigProfMgr.Write(fanControlIndex, newSmartFanMultiCurveConfig);
                }
            }
            catch (Exception ex) {
                Console.WriteLine("Exception: " + ex.Message);
                return(false);
            }

            return(true);
        }