工事管理システム製品化対応

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Diagnostics;

using System.Windows.Forms;

using System.Drawing;

using System.IO;

using System.Text.RegularExpressions;

using System.Data;

using System.Security.Cryptography;

using System.Globalization;

using System.Runtime.InteropServices;

using System.Collections;

using Microsoft.VisualBasic; //for StrConv

using log4net;

using log4net.Appender;

using log4net.Repository.Hierarchy;

using ProcessManagement.DB.Core;

using ProcessManagement.DataModel;

using ProcessManagement.DB.IOAccess;

using ProcessManagement.Forms.CustomControls;

using ProcessManagement.Forms.DataEntry;

namespace ProcessManagement.Common

{

    /// <summary>

    /// 工事管理システム共通クラス

    /// </summary>

    public static class CommonMotions

    {

        #region 定義部

        /// <summary>

        /// log4netログを使用する

        /// </summary>

        private static readonly ILog logger = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

        #endregion

        #region 変数

        /// <summary>

        /// 定義ファイル読込クラス定義

        /// </summary>

        private static DefinitionFileRead m_dfr_model = null;

        /// <summary>

        /// 管理マスタデータ保持領域

        /// </summary>

        private static SystemMaster m_systemMaster = new SystemMaster();

        /// <summary>

        /// 消費税データ保持領域

        /// </summary>

        private static List<ConsumptionTax> m_ConsumptionTax = new List<ConsumptionTax>();

        /// <summary>

        /// ログインユーザー担当者データ

        /// </summary>

        private static PersonInChargeMaster m_LoginUserData = new PersonInChargeMaster();

        /// <summary>

        /// ログインユーザー参照部署データ

        /// </summary>

        private static List<PersonDepartmentMaster> m_LoginUserRefDepartment = new List<PersonDepartmentMaster>();

        /// <summary>

        /// ログインユーザーセキュリティ区分

        /// </summary>

        private static SecurityMaster m_LoginUserSecurity = new SecurityMaster();

        /// <summary>

        /// ログインユーザー処理起動区分

        /// </summary>

        private static List<ProcessExcute> m_LoginUserProcExe = new List<ProcessExcute>();

        /// <summary>

        /// 製品ファイルバージョン格納エリア

        /// </summary>

        private static FileVersionInfo m_ProductVersionInfo = FileVersionInfo.GetVersionInfo(System.Reflection.Assembly.GetExecutingAssembly().Location);

        /// <summary>

        /// RGBカラーテーブル

        /// </summary>

        private static Color[] m_RGBColor = new Color[256];

        #endregion

        #region コンストラクタ

        /// <summary>

        /// 何もしない

        /// </summary>

        #endregion

        #region プロパティ

        /// <summary>

        /// 本稼働フラグ

        /// </summary>

        public static bool ProductionExecution

        {

            get { return CommonDefine.m_ProductionExecution; }

        }

        /// <summary>

        /// 定義ファイル読込クラス

        /// </summary>

        public static DefinitionFileRead DFRModel

        {

            get { return m_dfr_model; }

        }

        /// <summary>

        /// 管理マスタデータ

        /// </summary>

        public static SystemMaster SystemMasterData

        {

            get { return m_systemMaster; }

            set { m_systemMaster = value; }

        }

        /// <summary>

        /// 消費税データ

        /// </summary>

        public static List<ConsumptionTax> ConsumptionTax

        {

            get { return m_ConsumptionTax; }

            set { m_ConsumptionTax = value; }

        }

        /// <summary>

        /// ログインユーザー担当者データ

        /// </summary>

        public static PersonInChargeMaster LoginUserData

        {

            get { return m_LoginUserData; }

            set { m_LoginUserData = value; }

        }

        /// <summary>

        /// ログインユーザー参照部署データ

        /// </summary>

        public static List<PersonDepartmentMaster> LoginUserRefDepartment

        {

            get { return m_LoginUserRefDepartment; }

            set { m_LoginUserRefDepartment = value; }

        }

        /// <summary>

        /// ログインユーザーセキュリティ区分

        /// </summary>

        public static SecurityMaster LoginUserSecurity

        {

            get { return m_LoginUserSecurity; }

            set { m_LoginUserSecurity = value; }

        }

        /// <summary>

        /// ログインユーザー処理起動区分

        /// </summary>

        public static List<ProcessExcute> LoginUserProcExe

        {

            get { return m_LoginUserProcExe; }

            set { m_LoginUserProcExe = value; }

        }

        /// <summary>

        /// RGBカラーテーブル

        /// </summary>

        public static Color[] RGBColor

        {

            get { return m_RGBColor; }

            set { m_RGBColor = value; }

        }

        /// <summary>

        /// 製品ファイルバージョン格納エリア

        /// </summary>

        public static FileVersionInfo ProductVersionInfo

        {

            get { return m_ProductVersionInfo; }

        }

        #endregion

        #region 初期化

        /// <summary>

        /// 初期化

        /// </summary>

        public static bool Initialize()

        {

            try

            {

                // 定義ファイル読込

                DefinitionFileInit();

                // ----- 他共通クラス初期化

                // DB接続情報取得

                DBCommon.Instance.Initialize();

                // 管理マスタ取得

                if (!SetSystemMaster()) return false;

                // 消費税データ取得

                if (!SetconsumptionTax()) return false;

                // 共通費計算係数取得

                if(!ClsCostCulculation.DBToArrayData()) return false;

                // ＲＧＢカラーパレット作成処理

                CreatePalette();

                return true;

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("初期化エラー:{0}：{1}", GetMethodName(), ex.Message);

                return false;

            }

        }

        #endregion

        #region ---------- データ変換メソッド

        #region 西暦を和暦に変換する

        /// <summary>

        /// 西暦を和暦に変換する

        /// </summary>

        /// <returns></returns>

        public static string cnvJapaneseCalendar(DateTime Terget)

        {

            try

            {

                CultureInfo culture = new CultureInfo("ja-JP", true);

                culture.DateTimeFormat.Calendar = new JapaneseCalendar();

                return Terget.ToString("ggyy年M月d日", culture);

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);

                return string.Empty;

            }

        }

        #endregion

        #region 今の年号を取得する

        /// <summary>

        /// 今の年号を取得する

        /// </summary>

        /// <returns></returns>

        public static string GetNameOfAnEra(DateTime TargetDate)

        {

            try

            {

                CultureInfo culture = new CultureInfo("ja-JP", true);

                culture.DateTimeFormat.Calendar = new JapaneseCalendar();

                return TargetDate.ToString("gg", culture);

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);

                return string.Empty;

            }

        }

        #endregion

        #region Int値より文字列に変化して指定位置に指定文字を入れる。(工事番号編集)

        /// <summary>

        /// Int値より文字列に変化して指定位置に指定文字を入れる。

        /// </summary>

        /// <param name="strCode"></param>

        /// <returns></returns>

        public static string cnvStringCodeFromInt(int IntCode, string strCode, int iPoint)

        {

            try

            {

                // 文字列変換

                string strWork = IntCode.ToString();

                // 指定位置が文字列長を超えている場合はエラー

                if (strWork.Length <= iPoint) return string.Empty;

                // 文字挿入

                strWork = strWork.Substring(0, iPoint) + strCode + strWork.Substring(iPoint);

                return strWork;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return string.Empty;

            }

        }

        #endregion

        #region 文字列より指定文字を除去してInt値に変換する

        /// <summary>

        /// 文字列より指定文字を除去してInt値に変換する

        /// </summary>

        /// <param name="strCode"></param>

        /// <returns></returns>

        public static int cnvIntFromStringCode(string strCode, string strRemove)

        {

            try

            {

                // 文字列除去後変換

                return cnvInt(strCode.Replace(strRemove, ""));

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return 0;

            }

        }

        #endregion

        #region オブジェクトを日付に変換する

        /// <summary>

        /// 日付返還変換

        /// </summary>

        /// <param name="sendData"></param>

        /// <returns></returns>

        public static DateTime cnvDate(object sendData)

        {

            DateTime dtDateWork = DateTime.MinValue;

            try

            {

                // 空判定

                if (sendData == null) return dtDateWork;

                if (sendData.ToString().Length == 0) return dtDateWork;

                // 変換

                bool bRet = DateTime.TryParse(sendData.ToString(), out dtDateWork);

                return dtDateWork;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return dtDateWork;

            }

        }

        #endregion

        #region オブジェクトより数値変換（long）

        /// <summary>

        /// オブジェクトより数値変換（long）

        /// </summary>

        /// <param name="sendData"></param>

        /// <returns></returns>

        public static long cnvLong(object sendData)

        {

            try

            {

                long retData = 0;

                // 空判定

                if (sendData == null) return retData;

                if (sendData.ToString().Trim().Length == 0) return retData;

                // 変換

                long.TryParse(sendData.ToString().Replace(",", "").Replace("\\", "").Trim(), out retData);

                return retData;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return 0;

            }

        }

        #endregion

        #region オブジェクトより数値変換（int）

        /// <summary>

        /// オブジェクトより数値変換（int）

        /// </summary>

        /// <param name="sendData"></param>

        /// <returns></returns>

        public static int cnvInt(object sendData)

        {

            try

            {

                int retData = 0;

                // 空判定

                if (sendData == null) return retData;

                if (sendData.ToString().Trim().Length == 0) return retData;

                // 変換

                int.TryParse(sendData.ToString().Replace(",", "").Replace("\\", "").Trim(), out retData);

                return retData;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return 0;

            }

        }

        #endregion

        #region オブジェクトより数値変換（string）

        /// <summary>

        /// オブジェクトより数値変換（string）

        /// </summary>

        /// <param name="sendData"></param>

        /// <returns></returns>

        public static string cnvString(object sendData)

        {

            try

            {

                string retData = string.Empty;

                // 空判定

                if (sendData == null) return retData;

                if (sendData.ToString().Trim().Length == 0) return retData;

                // 変換

                retData = sendData.ToString();

                return retData;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return "";

            }

        }

        #endregion

        #region オブジェクトより数値変換（double）

        /// <summary>

        /// オブジェクトより数値変換（double）

        /// </summary>

        /// <param name="sendData"></param>

        /// <returns></returns>

        public static double cnvDouble(object sendData)

        {

            try

            {

                double retData = 0;

                // 空判定

                if (sendData == null) return retData;

                if (sendData.ToString().Trim().Length == 0) return retData;

                // 変換

                double.TryParse(sendData.ToString().Replace(",", "").Replace("\\", "").Trim(), out retData);

                return retData;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return 0;

            }

        }

        #endregion

        #region オブジェクトより数値変換（float）

        /// <summary>

        /// オブジェクトより数値変換（float）

        /// </summary>

        /// <param name="sendData"></param>

        /// <returns></returns>

        public static float cnvFloat(object sendData)

        {

            try

            {

                float retData = 0;

                // 空判定

                if (sendData == null) return retData;

                if (sendData.ToString().Trim().Length == 0) return retData;

                // 変換

                float.TryParse(sendData.ToString().Replace(",", "").Replace("\\", "").Trim(), out retData);

                return retData;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return 0;

            }

        }

        #endregion

        #region オブジェクトより数値変換（decimal）

        /// <summary>

        /// オブジェクトより数値変換（decimal）

        /// </summary>

        /// <param name="sendData"></param>

        /// <returns></returns>

        public static decimal cnvDecimal(object sendData)

        {

            try

            {

                decimal retData = 0;

                // 空判定

                if (sendData == null) return retData;

                if (sendData.ToString().Trim().Length == 0) return retData;

                // 変換

                decimal.TryParse(sendData.ToString().Replace(",", "").Replace("\\", "").Trim(), out retData);

                return retData;

            }

            catch (System.Exception ex)

            {

                Console.WriteLine("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return 0;

            }

        }

        #endregion

        #region オブジェクトよりBool値変換（bool）

        /// <summary>

        /// オブジェクトよりBool値変換（bool）

        /// </summary>

        /// <param name="sendData"></param>

        /// <returns></returns>

        public static bool cnvBool(object sendData)

        {

            try

            {

                bool retData = false;

                // 空判定

                if (sendData == null) return retData;

                if (sendData.ToString().Trim().Length == 0) return retData;

                // 変換

                bool.TryParse(sendData.ToString(), out retData);

                return retData;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return false;

            }

        }

        #endregion

        #region オブジェクトより数値変換（TimeSpan）

        /// <summary>

        /// オブジェクトより数値変換（TimeSpan）

        /// </summary>

        /// <param name="sendData"></param>

        /// <returns></returns>

        public static TimeSpan cnvTimeSpan(object sendData)

        {

            try

            {

                TimeSpan retData = TimeSpan.Zero;

                // 空判定

                if (sendData == null) return retData;

                if (sendData.ToString().Trim().Length == 0) return retData;

                // 変換

                TimeSpan.TryParse(sendData.ToString().Trim(), out retData);

                return retData;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return TimeSpan.MinValue;

            }

        }

        #endregion

        #region decimal値をTimeSpan値へ変換する

        /// <summary>

        /// decimal値をTimeSpan値へ変換する

        /// </summary>

        public static TimeSpan cnvDecimal2TimeSpan(decimal sendData)

        {

            try

            {

                TimeSpan retData = TimeSpan.Zero;

                // 空判定

                if (sendData.ToString().Trim().Length == 0) return retData;

                // 変換

                retData = new TimeSpan((int)sendData, (int)((sendData % 1) * 100.00m), 0);

                return retData;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return TimeSpan.MinValue;

            }

        }

        #endregion

        #region TimeSpan値をdecimal値へ変換する

        /// <summary>

        /// TimeSpan値をdecimal値へ変換する

        /// </summary>

        public static decimal cnvTimeSpan2Decimal(TimeSpan sendData)

        {

            try

            {

                decimal retData = 0;

                // 空判定

                if (sendData.ToString().Trim().Length == 0) return retData;

                // 変換

                retData = sendData.Hours + (sendData.Minutes / 100.00m);

                return retData;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return 0.0m;

            }

        }

        #endregion

        #region 四捨五入

        /// <summary>

        /// 四捨五入

        /// </summary>

        /// <param name="InputData"></param>

        /// <returns></returns>

        public static int cnvRound(double InputData)

        {

            int retRoundData = 0;

            try

            {

                retRoundData = (int)Math.Round(InputData, 0, MidpointRounding.AwayFromZero);

                return retRoundData;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return retRoundData;

            }

        }

        #endregion

        #region 切り上げ

        /// <summary>

        /// 切り上げ

        /// </summary>

        /// <param name="InputData"></param>

        /// <returns></returns>

        public static int cnvRoundUp(double InputData)

        {

            int retRoundData = 0;

            try

            {

                retRoundData = (int)Math.Ceiling(InputData);

                return retRoundData;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return retRoundData;

            }

        }

        #endregion

        #region 切り捨て

        /// <summary>

        /// 切り捨て

        /// </summary>

        /// <param name="InputData"></param>

        /// <returns></returns>

        public static int cnvTruncate(double InputData)

        {

            int retRoundData = 0;

            try

            {

                retRoundData = (int)Math.Truncate(InputData);

                return retRoundData;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return retRoundData;

            }

        }

        #endregion

        #region 四捨五入（四捨五入位置指定）

        /// <summary>

        /// 四捨五入（四捨五入位置指定）

        /// </summary>

        /// <param name="value"></param>

        /// <param name="pos"></param>

        /// <returns></returns>

        public static int IntRound(double value, int pos)

        {

            // 何乗かを求める

            int posion = (int)Math.Pow(10, (pos + 1));

            int upperval = (int)(value / posion);

            upperval *= posion;

            int lowerval = (int)(value % posion);

            int chkval = (int)(lowerval / Math.Pow(10, pos));

            if (chkval > 4) upperval += (1 * posion);

            return upperval;

        }

        #endregion

        #region 切り捨て（切り捨て位置指定）

        /// <summary>

        /// 切り捨て（切り捨て位置指定）

        /// </summary>

        /// <param name="value"></param>

        /// <param name="pos"></param>

        /// <returns></returns>

        public static int IntRoundDown(double value, int pos)

        {

            // 何乗かを求める

            int posion = (int)Math.Pow(10, (pos + 1));

            int upperval = (int)(value / posion);

            upperval *= posion;

            return upperval;

        }

        #endregion

        #region 切り上げ（切り上げ位置指定）

        /// <summary>

        /// 切り上げ（切り上げ位置指定）

        /// </summary>

        /// <param name="value"></param>

        /// <param name="pos"></param>

        /// <returns></returns>

        public static int IntRoundUp(double value, int pos)

        {

            // 何乗かを求める

            int posion = (int)Math.Pow(10, (pos + 1));

            int upperval = (int)(value / posion);

            upperval *= posion;

            int lowerval = (int)(value % posion);

            int chkval = (int)(lowerval / Math.Pow(10, pos));

            if (chkval > 0) upperval += (1 * posion);

            return upperval;

        }

        public static decimal DecimalRoundUp(decimal value, int pos)

        {

            // 何乗かを求める

            int posion = (int)Math.Pow(10, pos);

            return (Math.Ceiling(value * posion) / posion);

        }

        #endregion

        #region 0～26までの数字をA～Zに変換する

        /// <summary>

        /// 0～26までの数字をA～Zに変換する

        /// </summary>

        /// <param name="num"></param>

        /// <returns></returns>

        public static string cnvNumberToAlphaChar(int num)

        {

            try

            {

                // ----- 16進数文字列 -> 数値

                int CnvCode = Convert.ToInt32("0041", 16);      // 'A'

                int LastCode = Convert.ToInt32("005A", 16);     // 'Z'

                // 'Z'を超えたら余剰を使って変換する

                int work = (CnvCode + num);

                if (work <= LastCode)

                {

                    // 変換値を加算する

                    CnvCode += num;

                }

                else

                {

                    CnvCode += (work % LastCode);

                }

                // 'Z'を超えたら採番しない

                //if (CnvCode > LastCode) return string.Empty;

                // 数値(文字コード) -> 文字

                char c = Convert.ToChar(CnvCode);

                // 英字「文字列」

                string newChar = c.ToString();

                return newChar;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return "";

            }

        }

        #endregion

        #region Excelのカラム名的なアルファベットを数値へ変換します。

        /// <summary>

        /// Excelのカラム名的なアルファベットを数値へ変換します。

        /// </summary>

        /// <returns></returns>

        public static int cnvAlphaToNumber(this string self)

        {

            int result = 0;

            if (string.IsNullOrEmpty(self)) return result;

            char[] chars = self.ToCharArray();

            int len = self.Length - 1;

            foreach (var c in chars)

            {

                int asc = (int)c - 64;

                if (asc < 1 || asc > 26) return 0;

                result += asc * (int)Math.Pow((double)26, (double)len--);

            }

            return (result - 1);

        }

        #endregion

        #region 日付が最小値ならば"未定"文字を返す

        /// <summary>

        /// 日付が最小値ならば"未定"文字を返す

        /// </summary>

        /// <param name="srcDate"></param>

        /// <returns></returns>

        public static string cnvDateToUndecidedString(DateTime srcDate)

        {

            try

            {

                string work = "";

                if (srcDate.Equals(DateTime.MinValue))

                    work = CommonDefine.s_UndecidedString;

                else

                    work = srcDate.ToShortDateString();

                return work;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return "";

            }

        }

        #endregion

        #region オブジェクトより日付を返す（文字列が"未定"文字ならば日付最小値を返す）

        /// <summary>

        /// オブジェクトより日付を返す

        /// 文字列が"未定"文字ならば日付最小値を返す

        /// </summary>

        /// <param name="srcDate"></param>

        /// <returns></returns>

        public static DateTime cnvUndecidedStringToDate(object srcDate)

        {

            DateTime work = DateTime.MinValue;

            try

            {

                if (!srcDate.Equals(CommonDefine.s_UndecidedString))

                    work = cnvDate(srcDate);

                return work;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return work;

            }

        }

        #endregion

        #region オブジェクトより数値（文字列が"未定"文字ならば0を返す）

        /// <summary>

        /// オブジェクトより数値

        /// 文字列が"未定"文字ならば0を返す

        /// </summary>

        /// <param name="srcDate"></param>

        /// <returns></returns>

        public static double cnvUndecidedStringToDouble(object srcDate)

        {

            double work = 0;

            try

            {

                if (!srcDate.Equals(CommonDefine.s_UndecidedString))

                    work = cnvDouble(srcDate);

                return work;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return work;

            }

        }

        #endregion

        #region 色指定文字列より色を返す

        /// <summary>

        /// 色指定文字列より色を返す

        /// </summary>

        /// <param name="strColor"></param>

        /// <returns></returns>

        public static Color cnvStringToColor(string strColor)

        {

            Color ColorRet = Color.White;

            try

            {

                // 色文字列チェック

                if (!CommonMotions.chkObjectIsNull(strColor) && strColor.Length != 0)

                {

                    ColorRet = ColorTranslator.FromHtml(strColor);

                }

                return ColorRet;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return ColorRet;

            }

        }

        #endregion

        #region 色指定文字列より色を返す・設定無しは指定場所のデフォルトを返す

        /// <summary>

        /// 色指定文字列より色を返す・設定無しは指定場所のデフォルトを返す

        /// </summary>

        /// <param name="strColor"></param>

        /// <param name="point"></param>

        /// <returns></returns>

        public static Color getBackForeColor(string strColor, TermMaster.PalceOfColorDef point)

        {

            Color ColorRet = Color.White;

            try

            {

                // デフォルトセット

                if (point == TermMaster.PalceOfColorDef.BackColor)

                {   // 背景

                    ColorRet = Color.White;

                }

                else if (point == TermMaster.PalceOfColorDef.ForeColor)

                {   // 文字色

                    ColorRet = Color.Black;

                }

                else

                {

                    ColorRet = Color.Transparent;

                }

                if (!chkObjectIsNull(strColor) && strColor.Length != 0)

                {

                }

                else

                {

                    strColor = String.Format("0x{0:X2}{1:X2}{2:X2}", ColorRet.R, ColorRet.G, ColorRet.B);

                }

                ColorRet = cnvStringToColor(strColor);

                return ColorRet;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return ColorRet;

            }

        }

        #endregion

        #region 補色を取得する

        /// <summary>

        /// 補色を取得する

        /// </summary>

        /// <param name="color"></param>

        /// <returns></returns>

        public static Color GetComplementaryColor(Color color)

        {

            try

            {

                byte r = (byte)(color.R ^ 0xFF);

                byte g = (byte)(color.G ^ 0xFF);

                byte b = (byte)(color.B ^ 0xFF);

                return Color.FromArgb(r, g, b);

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return color;

            }

        }

        #endregion

        #region 指定桁数の数値最大値を返す

        /// <summary>

        /// 指定桁数の数値最大値を返す

        /// </summary>

        /// <param name="NumLen"></param>

        /// <returns></returns>

        public static int CreateMaxNumeric(int NumLen)

        {

            try

            {

                string strNum = string.Empty;

                for (int i = 0; i < NumLen; i++)

                {

                    strNum += "9";

                }

                return cnvInt(strNum);

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return 0;

            }

        }

        #endregion

        #region ＲＧＢカラーパレット作成処理

        /// <summary>

        /// ＲＧＢカラーパレット作成処理

        /// </summary>

        /// <returns></returns>

        private static void CreatePalette()

        {

            try

            {

                // 青→緑

                for (int i = 0; i < 64; i++)

                {

                    int _green = i * 4;

                    m_RGBColor[i] = Color.FromArgb(255, 0, _green, 255 - _green);

                }

                // 緑→黄

                for (int i = 0; i < 64; i++)

                {

                    int _red = i * 4;

                    m_RGBColor[i + 64] = Color.FromArgb(255, _red, 255, 0);

                }

                // 黄→赤

                for (int i = 0; i < 128; i++)

                {

                    int _green = 255 - i * 2;

                    m_RGBColor[i + 128] = Color.FromArgb(255, 255, _green, 0);

                }

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);

            }

        }

        #endregion

        #region 半角数字を全角数字に変換する。

        /// <summary>

        /// 半角数字を全角数字に変換する。

        /// </summary>

        public static string HanToZenNum(string s)

        {

            return Regex.Replace(s, "[0-9]", p => ((char)(p.Value[0] - '0' + '０')).ToString());

        }

        #endregion

        #region TimeSpanから年数を取得する

        /// <summary>

        /// TimeSpanから年数を取得する（切り上げ）

        /// </summary>

        /// <param name="timespan"></param>

        /// <returns></returns>

        public static int GetTimeSpanYears(this TimeSpan timespan)

        {

            return CommonMotions.cnvRoundUp((double)timespan.Days / 365.2425);

        }

        #endregion

        #region TimeSpanから月数を取得する

        /// <summary>

        /// TimeSpanから月数を取得する

        /// </summary>

        /// <param name="timespan"></param>

        /// <returns></returns>

        public static int GetTimeSpanMonths(this TimeSpan timespan)

        {

            return (int)((double)timespan.Days / 30.436875);

        }

        #endregion

        #endregion

        #region ---------- データチェックメソッド

        #region ディレクトリの存在チェック

        /// <summary>

        /// ディレクトリの存在チェック

        /// </summary>

        /// <param name="DirectryName">フォルダパス</param>

        /// <returns></returns>

        public static bool ChkDirPath(string DirectryName, bool CreateFlg = false)

        {

            try

            {

                // フォルダ (ディレクトリ) が存在しているかどうか確認する

                if (!Directory.Exists(@DirectryName))

                {

                    // 作成フラグOffならばエラー

                    if (!CreateFlg) return false;

                    // ディレクトリを作成する

                    Directory.CreateDirectory(@DirectryName);

                }

                return true;

            }

            catch (Exception ex)

            {

                logger.ErrorFormat(ex.Message);

                return false;

            }

        }

        #endregion

        #region オブジェクトのNullチェック

        /// <summary>

        /// オブジェクトのNullチェック

        /// </summary>

        /// <param name="sendData">オブジェクト</param>

        /// <returns></returns>

        public static bool chkObjectIsNull(Object sendData)

        {

            try

            {

                if (sendData == null) return true;

                return false;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return false;

            }

        }

        #endregion

        #region 数値チェック

        /// <summary>

        /// 数値チェック

        /// </summary>

        /// <param name="data">Long文字列</param>

        /// <param name="indispensable">入力必須チェック</param>

        /// <returns>true:正常 false:異常</returns>

        public static bool chkNumeric(object CheckData, bool indispensable = false)

        {

            try

            {

                if (chkObjectIsNull(CheckData)) return false;

                string RecvData = cnvString(CheckData);

                double revData = 0;

                // 必須入力チェック

                if (indispensable)

                {

                    if (RecvData.Replace(",", "").Replace("\\", "").Trim().Length == 0) return false;

                }

                // Nullが入っていなくてレングスが0は数値として扱う

                if (RecvData.Replace(",", "").Replace("\\", "").Trim().Length == 0) return true;

                return double.TryParse(RecvData.Replace(",", "").Replace("\\", "").Trim(), out revData);

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return false;

            }

        }

        #endregion

        #region 数値チェック（long）

        /// <summary>

        /// 数値チェック（long）

        /// </summary>

        /// <param name="data">Long文字列</param>

        /// <param name="indispensable">入力必須チェック</param>

        /// <returns>true:正常 false:異常</returns>

        public static bool chkNumeric(object sendData, ref long retData, bool indispensable = false)

        {

            try

            {

                // 必須入力チェック

                if (indispensable)

                {

                    if (cnvString(sendData).Replace(",", "").Replace("\\", "").Trim().Length == 0) return false;

                }

                return long.TryParse(cnvString(sendData).Replace(",", "").Replace("\\", "").Trim(), out retData);

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return false;

            }

        }

        #endregion

        #region 数値チェック（int）

        /// <summary>

        /// 数値チェック（int）

        /// </summary>

        /// <param name="data">Long文字列</param>

        /// <param name="indispensable">入力必須チェック</param>

        /// <returns>true:正常 false:異常</returns>

        public static bool chkNumeric(object sendData, ref int retData, bool indispensable = false)

        {

            try

            {

                // 必須入力チェック

                if (indispensable)

                {

                    if (cnvString(sendData).Replace(",", "").Replace("\\", "").Trim().Length == 0) return false;

                }

                return int.TryParse(cnvString(sendData).Replace(",", "").Replace("\\", "").Trim(), out retData);

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return false;

            }

        }

        #endregion

        #region 数値チェック（double）

        /// <summary>

        /// 数値チェック（double）

        /// </summary>

        /// <param name="data">Long文字列</param>

        /// <param name="indispensable">入力必須チェック</param>

        /// <returns>true:正常 false:異常</returns>

        public static bool chkNumeric(object sendData, ref double retData, bool indispensable = false)

        {

            try

            {

                // 必須入力チェック

                if (indispensable)

                {

                    if (cnvString(sendData).Replace(",", "").Replace("\\", "").Trim().Length == 0) return false;

                }

                return double.TryParse(cnvString(sendData).Replace(",", "").Replace("\\", "").Trim(), out retData);

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return false;

            }

        }

        #endregion

        #region 時間チェック（TimeSpan）

        /// <summary>

        /// 時間チェック（TimeSpan）

        /// </summary>

        /// <returns>true:正常 false:異常</returns>

        public static bool chkTimeSpan(object sendData, ref TimeSpan retData, bool indispensable = false)

        {

            try

            {

                // 必須入力チェック

                if (indispensable)

                {

                    if (cnvString(sendData).Trim().Length == 0) return false;

                }

                return TimeSpan.TryParse(cnvString(sendData).Replace(",", "").Replace("\\", "").Trim(), out retData);

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return false;

            }

        }

        #endregion

        #region 文字列長さチェック（UTF-8）

        /// <summary>

        /// 文字列長さチェック（UTF-8）

        /// </summary>

        /// <param name="strData">対象文字列</param>

        /// <param name="lngMaxLen">最大長</param>

        /// <param name="indispensable">入力必須チェック</param>

        /// <returns>true:正常 false:異常</returns>

        public static bool chkStringLength(string strData, int lngMaxLen, bool indispensable = false)

        {

            bool bRet = true;

            //int lngLen = 0;

            try

            {

                //Encoding sjis = Encoding.GetEncoding("shift-jis");

                Encoding utf8 = Encoding.GetEncoding("utf-8");

                // 必須入力チェック

                if (indispensable)

                {

                    if (strData.Length == 0) bRet = false;

                }

                // S-Jisチェック

                //lngLen = sjis.GetByteCount(strData);

                // UTF-8チェック

                //lngLen = utf8.GetByteCount(strData);

                //if (lngLen > lngMaxLen) bRet = false;

                // C#内はUTFなので文字長だけをチェックする

                if (strData.Length > lngMaxLen) bRet = false;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                bRet = false;

            }

            return bRet;

        }

        #endregion

        #region 郵便番号チェック

        /// <summary>

        /// 郵便番号チェック

        /// </summary>

        /// <param name="strData">郵便番号文字列</param>

        /// <returns>true:正常 false:異常</returns>

        public static bool chkZipcode(string strdata)

        {

            bool bRet = false;

            Regex regex = new Regex("^[0-9]{3}[-][0-9]{4}$");

            if (regex.IsMatch(strdata))

            {

                bRet = true;

            }

            return bRet;

        }

        #endregion

        #region 電話番号/ＦＡＸ番号チェック

        /// <summary>

        /// 電話番号/ＦＡＸ番号チェック

        /// </summary>

        /// <param name="data">電話番号文字列</param>

        /// <returns>true:正常 false:異常</returns>

        public static bool chkPhoneNumber(string strdata)

        {

            bool bRet = false;

            Regex regex = new Regex("^[0-9]{2,5}-[0-9]{1,4}-[0-9]{3,4}$");

            if (regex.IsMatch(strdata))

            {

                bRet = true;

            }

            return bRet;

        }

        #endregion

        #region メールアドレスチェック

        /// <summary>

        /// メールアドレスチェック

        /// </summary>

        /// <param name="data">電話番号文字列</param>

        /// <returns>true:正常 false:異常</returns>

        public static bool chkMailAddress(string strdata)

        {

            bool bRet = false;

            Regex regex = new Regex(@"\A\P{Cc}+@\P{Cc}+\z");

            if (regex.IsMatch(strdata))

            {

                bRet = true;

            }

            return bRet;

        }

        #endregion

        #region 日付チェック

        /// <summary>

        /// 日付チェック

        /// </summary>

        /// <param name="data">日付文字列</param>

        /// <returns>true:正常 false:異常</returns>

        public static bool chkDate(string strdata)

        {

            bool bRet = true;

            try

            {

                DateTime dtwork = DateTime.MinValue;

                return DateTime.TryParse(strdata, out dtwork);

            }

            catch (System.Exception ex)

            {

                logger.DebugFormat("chkDate Error message:{0}", ex.Message);

                bRet = false;

            }

            return bRet;

        }

        #endregion

        #region 対象が空かどうかをチェックする

        /// <summary>

        /// 対象が空かどうかをチェックする

        /// </summary>

        /// <param name="objCell"></param>

        /// <param name="iColumn"></param>

        /// <returns>true:空　flase:有効</returns>

        public static bool chkCellBlank(object objCell)

        {

            try

            {

                if (chkObjectIsNull(objCell)) return true;

                if (objCell.ToString().Length == 0) return true;

                return false;

            }

            catch (System.Exception ex)

            {

                logger.DebugFormat("chkDate Error message:{0}", ex.Message);

                return true;

            }

        }

        #endregion

        #region 指定文字が全てひらがなのチェック

        /// <summary>

        /// 指定文字が全てひらがなのチェック

        /// </summary>

        /// <param name="str"></param>

        /// <returns></returns>

        public static bool chkIsHiragana(string str)

        {

            return Regex.IsMatch(str, @"^\p{IsHiragana}*$");

        }

        #endregion

        #region 指定文字が全てカタカナのチェック

        /// <summary>

        /// 指定文字が全てカタカナのチェック

        /// </summary>

        /// <param name="str"></param>

        /// <returns></returns>

        public static bool chkIsKatakana(string str)

        {

            return Regex.IsMatch(str, @"^\p{IsKatakana}*$");

        }

        #endregion

        #region 指定文字が全て数字のチェック

        /// <summary>

        /// 指定文字が全て数字のチェック

        /// </summary>

        /// <param name="str"></param>

        /// <returns></returns>

        public static bool chkIsNumeric(string str)

        {

            return Regex.IsMatch(str, @"[^a-zA-z0-9-_]");

        }

        #endregion

        #region 画面フィールド入力必須チェック

        /// <summary>

        /// 画面フィールド入力必須チェック

        /// </summary>

        /// <param name="dispControl">コントロールオブジェクト</param>

        /// <returns>false:エラー true:エラーなし</returns>

        public static bool DispFieldIndispensable(Control dispControl)

        {

            bool bAns = true;

            try

            {

                // 必須入力チェック

                if (chkObjectIsNull(dispControl))

                {

                    bAns = false;

                }

                else

                {

                    if (dispControl.Text.ToString().Length == 0)

                    {

                        bAns = false;

                    }

                }

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}：{2}", GetMethodName(), GetMethodName(2), ex.Message);

                bAns = false;

            }

            finally

            {

                // 背景色変更

                chgBackColor(dispControl, bAns);

            }

            return bAns;

        }

        #endregion

        #region 画面フィールド入力文字数チェック

        /// <summary>

        /// 画面フィールド入力文字数チェック

        /// </summary>

        /// <param name="dispControl">コントロールオブジェクト</param>

        /// <param name="sLength">文字列長</param>

        /// <param name="indispensable">true:必須入力チェック</param>

        /// <returns>false:エラー true:エラーなし</returns>

        public static bool DispFieldLengthCheck(Control dispControl, int sLength, bool indispensable = false)

        {

            bool bAns = true;

            try

            {

                // 必須入力チェック

                if (indispensable)

                {

                    bAns = DispFieldIndispensable(dispControl);

                }

                if (dispControl.Text.ToString().Length != 0)

                {

                    // レングスチェック

                    bAns = chkStringLength(dispControl.Text.ToString(), sLength);

                }

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}：{2}", GetMethodName(), GetMethodName(2), ex.Message);

                bAns = false;

            }

            finally

            {

                // 背景色変更

                chgBackColor(dispControl, bAns);

            }

            return bAns;

        }

        #endregion

        #region 画面フィールド入力日付チェック

        /// <summary>

        /// 画面フィールド入力日付チェック

        /// </summary>

        /// <param name="dispControl">コントロールオブジェクト</param>

        /// <param name="indispensable">true:必須入力チェック</param>

        /// <returns>false:エラー true:エラーなし</returns>

        public static bool DispFieldDateCheck(Control dispControl, bool indispensable = false)

        {

            bool bAns = true;

            try

            {

                // 必須入力チェック

                if (indispensable)

                {

                    bAns = DispFieldIndispensable(dispControl);

                }

                if (dispControl.Text.ToString().Length != 0)

                {

                    // 未定はエラーにしない

                    if (!indispensable && dispControl.Text.Equals(CommonDefine.s_UndecidedString)) { }

                    else

                        // 日付チェック

                        bAns = chkDate(dispControl.Text.ToString());

                }

            }

            catch (Exception ex)

            {