/// <summary>
    /// ddlDropDownList2のSelectedIndexChangedイベント
    /// </summary>
    /// <param name="fxEventArgs">イベントハンドラの共通引数</param>
    /// <returns>URL</returns>
    protected string UOC_ddlDropDownList2_SelectedIndexChanged(FxEventArgs fxEventArgs)
    {
        // Ajaxを制御する場合は、ScriptManagerを使用する。
        // このクラスを使用すると、Ajax中であるかどうかを判別できる。
        bool isInAsyncPostBack = this.CurrentScriptManager.IsInAsyncPostBack;

        FxEnum.AjaxExtStat ajaxES = this.AjaxExtensionStatus;

        // 待機する(二重送信確認用)
        System.Threading.Thread.Sleep(3000);

        // テキストボックスの値を変更
        TextBox textBox = (TextBox)this.GetContentWebControl("TextBox4");

        textBox.Text = "通常のポストバック(DDLのセレクト インデックス チェンジ)";

        return("");
    }
    /// <summary>btnButton2のクリックイベント</summary>
    /// <param name="fxEventArgs">イベントハンドラの共通引数</param>
    /// <returns>URL</returns>
    protected string UOC_btnButton2_Click(FxEventArgs fxEventArgs)
    {
        // Ajaxを制御する場合は、ScriptManagerを使用する。
        // このクラスを使用すると、Ajax中であるかどうかを判別できる。
        bool isInAsyncPostBack = this.CurrentScriptManager.IsInAsyncPostBack;

        FxEnum.AjaxExtStat ajaxES = this.AjaxExtensionStatus;

        // 待機する(二重送信確認用)
        System.Threading.Thread.Sleep(3000);

        // テキストボックスの値を変更
        TextBox textBox = (TextBox)this.GetContentWebControl("TextBox2");

        textBox.Text = "通常のポストバック(ボタンクリック)";

        return("");
    }
예제 #3
0
        /// <summary>
        /// ddlDropDownList1のSelectedIndexChangedイベント
        /// </summary>
        /// <param name="fxEventArgs">Event Handlerの共通引数</param>
        /// <returns>URL</returns>
        protected string UOC_ddlDropDownList1_SelectedIndexChanged(FxEventArgs fxEventArgs)
        {
            // Ajaxを制御する場合は、ScriptManagerを使用する。
            // このクラスを使用すると、Ajax中であるかどうかを判別できる。
            bool isInAsyncPostBack = this.CurrentScriptManager.IsInAsyncPostBack;

            FxEnum.AjaxExtStat ajaxES = this.AjaxExtensionStatus;

            // 待機する(UpdateProgress、二重送信確認用)
            System.Threading.Thread.Sleep(this.SleepCnt);

            // テキストボックスの値を変更
            TextBox textBox = (TextBox)this.GetContentWebControl("TextBox3");

            textBox.Text = "ajaxのPost Back(DDLのSelected Index Changed)";

            // ajaxのEvent Handlerでは画面遷移しないこと。
            return("");
        }
예제 #4
0
        /// <summary>Page_Loadのイベントハンドラ</summary>
        private void Page_Load(object sender, EventArgs e)
        {
            // isNoSessionフラグをtrueに設定すると、当該画面でのみ以下の機能をOFFにして、
            // ・ボタン履歴情報記録機能
            // ・不正操作防止機能

            // 最後に

            // ・Session.Abandon();
            //  + Sessionタイムアウト検出用Cookieの消去

            // を実行する。

            // これにより、ログイン画面相当(先頭画面であること)で、
            // 基盤側の処理でSessionIDを返さないように都度クリア。

            // なお、次画面への遷移には、リダイレクトのGETを使用する。
            // (ブラウザウィンドウ スコープが自動消去されなくなるので必要であれば念の為)

            // 中間画面でこのフラグをTrueに設定した場合の動作保証はしない。
            // (IDEのインテリセンスに出ない(隠しコマンド的)扱いにする)

            bool isNoSession = this.IsNoSession;
            bool? canCheckIllegalOperation = this.CanCheckIllegalOperation;

            try
            {
                #region セッション スコープのロック

                // 2009/09/25-start

                // セッションステートレス対応
                if (HttpContext.Current.Session == null)
                {
                    // SessionがOFFの場合
                    this.SessionLock = new object();
                }
                else
                {
                    // チェック
                    this.SessionLock = Session[FxHttpSessionIndex.SESSION_LOCK];

                    if (this.SessionLock == null)
                    {
                        // nullの場合、新規生成
                        Session[FxHttpSessionIndex.SESSION_LOCK] = new object();
                        this.SessionLock = Session[FxHttpSessionIndex.SESSION_LOCK];
                    }
                    else
                    {
                        // 存在する。
                    }
                }

                // 2009/09/25-end

                #endregion

                // 念のためセッション単位でロック。
                lock (this.SessionLock)
                {
                    #region フレームワークの初期処理

                    #region マスタ ページの初期化

                    // コンテンツ ページのファイル名(拡張子抜き)を取り出す
                    //string[] aryContentPageFile = this.AppRelativeVirtualPath.Split('/');
                    //this.ContentPageFileNoEx = aryContentPageFile[aryContentPageFile.Length - 1].Split('.')[0];
                    this.ContentPageFileNoEx = PubCmnFunction.GetFileNameNoEx(this.AppRelativeVirtualPath, '/');

                    // マスタ ページを取得し、
                    // ルートのマスタ ページ名も初期化する。
                    this.GetMasterPages();

                    #endregion

                    #region ユーザ コントロールの初期化

                    // ユーザ コントロールの初期化
                    this.GetUserControl(this);

                    #endregion

                    #region Ajaxの状態を確認

                    #region ASP.NET Ajax

                    // スクリプト マネージャを取得
                    this.CurrentScriptManager = ScriptManager.GetCurrent(this);

                    if (this.CurrentScriptManager == null)
                    {
                        // AjaxExtensionをサポートしない画面
                        this.AjaxExtensionStatus = FxEnum.AjaxExtStat.NoAjaxExtension;
                    }
                    else
                    {
                        if (this.CurrentScriptManager.IsInAsyncPostBack)
                        {
                            // AjaxExtensionをサポートする画面であり、当該処理はAjaxExtensionである。
                            this.AjaxExtensionStatus = FxEnum.AjaxExtStat.IsAjaxExtension;
                        }
                        else
                        {
                            // AjaxExtensionをサポートする画面だが、当該処理はAjaxExtensionでない。
                            this.AjaxExtensionStatus = FxEnum.AjaxExtStat.IsNotAjaxExtension;
                        }
                    }

                    #endregion

                    #region ClientCallback

                    if (Request.Form[FxLiteral.CALLBACK_ID] == null)
                    {
                        // ClientCallbackのポストバック以外のリクエスト
                        this.IsClientCallback = false;
                    }
                    else
                    {
                        // #22-start
                        //if (this.AjaxExtensionStatus == FxEnum.AjaxExtStat.IsAjaxExtension)
                        //{
                        //    // ClientCallbackを使用したAjaxExtension
                        //    this.IsClientCallback = false;
                        //}
                        //else
                        //{
                        // ClientCallbackのポストバック
                        this.IsClientCallback = true;
                        //}
                        // #22-end
                    }

                    #endregion

                    #endregion

                    #region エラー画面へのパスチェック

                    string errorScreenPath =
                        GetConfigParameter.GetConfigValue(FxLiteral.ERROR_SCREEN_PATH);

                    // エラー処理
                    if (errorScreenPath == null || errorScreenPath == "")
                    {
                        throw new FrameworkException(
                            FrameworkExceptionMessage.ERROR_IN_WRITING_OF_FX_PATH1[0],
                            String.Format(FrameworkExceptionMessage.ERROR_IN_WRITING_OF_FX_PATH1[1], FxLiteral.ERROR_SCREEN_PATH));
                    }

                    #endregion

                    #region セッションタイムアウト検出処理

                    // セッションタイムアウト検出処理の定義を取得
                    string sessionTimeOutCheck =
                        GetConfigParameter.GetConfigValue(FxLiteral.SESSION_TIMEOUT_CHECK);

                    // デフォルト値対策:設定なし(null)の場合の扱いを決定
                    if (sessionTimeOutCheck == null)
                    {
                        // OFF扱い
                        sessionTimeOutCheck = FxLiteral.OFF;
                    }

                    // ON / OFF
                    if (sessionTimeOutCheck.ToUpper() == FxLiteral.ON)
                    {
                        // セッションタイムアウト検出処理(ON)

                        // セッション状態の確認
                        if (Session.IsNewSession)
                        {
                            // 新しいセッションが開始された

                            // セッションタイムアウト検出用Cookieをチェック
                            HttpCookie cookie = Request.Cookies.Get(FxHttpCookieIndex.SESSION_TIMEOUT);

                            if (cookie == null)
                            {
                                // セッションタイムアウト検出用Cookie無し → 新規のアクセス

                                // 2009/09/18-start

                                // セッションタイムアウト検出用Cookieを新規作成(値は空文字以外、何でも良い)

                                // Set-Cookie HTTPヘッダをレスポンス
                                Response.Cookies.Set(FxCmnFunction.CreateCookieForSessionTimeoutDetection());
                                // 2009/09/18-end
                            }
                            else
                            {
                                // セッションタイムアウト検出用Cookie有り

                                if (cookie.Value == "")
                                {
                                    // セッションタイムアウト発生後の新規アクセス

                                    // だが、値が消去されている(空文字に設定されている)場合は、
                                    // 一度エラー or セッションタイムアウトになった後の新規のアクセスである。

                                    // 2009/09/18-start

                                    // セッションタイムアウト検出用Cookieを再作成(値は空文字以外、何でも良い)

                                    // Set-Cookie HTTPヘッダをレスポンス
                                    Response.Cookies.Set(FxCmnFunction.CreateCookieForSessionTimeoutDetection());
                                    // 2009/09/18-end
                                }
                                else
                                {
                                    // セッションタイムアウト発生

                                    // エラー画面で以下の処理を実行する。
                                    // ・セッションタイムアウト検出用Cookieを消去
                                    // ・セッションを消去

                                    // ※ エラー画面への遷移方法がTransferになっているため、
                                    //    ここでセッションタイムアウト検出用Cookieを消去できないため。

                                    // セッションタイムアウト例外を発生させる
                                    throw new FrameworkException(
                                        FrameworkExceptionMessage.SESSION_TIMEOUT[0],
                                        FrameworkExceptionMessage.SESSION_TIMEOUT[1]);
                                }
                            }
                        }
                        else
                        {
                            // セッション継続中
                        }
                    }
                    else if (sessionTimeOutCheck.ToUpper() == FxLiteral.OFF)
                    {
                        // セッションタイムアウト検出処理(OFF)
                    }
                    else
                    {
                        // パラメータ・エラー(書式不正)
                        throw new FrameworkException(
                            FrameworkExceptionMessage.ERROR_IN_WRITING_OF_FX_SWITCH1[0],
                            String.Format(FrameworkExceptionMessage.ERROR_IN_WRITING_OF_FX_SWITCH1[1],
                                FxLiteral.SESSION_TIMEOUT_CHECK));
                    }

                    // 2008/10/16---チェック処理の追加(ここまで)

                    #endregion

                    #region HIDDENコントロールの検索・取得

                    // 2009/07/21-start-end

                    #region 画面遷移制御関連

                    // ブラウザ ウィンドウGUID
                    this.WindowGuid = (HiddenField)this.RootMasterPage.FindControl(FxLiteral.HIDDEN_WINDOW_GUID); // 2009/07/21-この行

                    // エラー処理
                    if (this.WindowGuid == null)
                    {
                        throw new FrameworkException(
                            FrameworkExceptionMessage.NO_FX_HIDDEN[0],
                            String.Format(FrameworkExceptionMessage.NO_FX_HIDDEN[1], FxLiteral.HIDDEN_WINDOW_GUID));
                    }

                    // リクエストチケットGUID
                    this.RequestTicketGuid = (HiddenField)this.RootMasterPage.FindControl(FxLiteral.HIDDEN_REQUEST_TICKET_GUID); // 2009/07/21-この行

                    // エラー処理
                    if (this.RequestTicketGuid == null)
                    {
                        throw new FrameworkException(
                            FrameworkExceptionMessage.NO_FX_HIDDEN[0],
                            String.Format(FrameworkExceptionMessage.NO_FX_HIDDEN[1], FxLiteral.HIDDEN_REQUEST_TICKET_GUID));
                    }

                    #endregion

                    #region ダイアログ表示関連

                    // 開く子画面のタイプ
                    this.ChildScreenType =
                        (HiddenField)this.RootMasterPage.FindControl(FxLiteral.HIDDEN_CHILD_SCREEN_TYPE); // 2009/07/21-この行

                    // エラー処理
                    if (this.ChildScreenType == null)
                    {
                        throw new FrameworkException(
                            FrameworkExceptionMessage.NO_FX_HIDDEN[0],
                            String.Format(FrameworkExceptionMessage.NO_FX_HIDDEN[1], FxLiteral.HIDDEN_CHILD_SCREEN_TYPE));
                    }
                    else
                    {
                        // 逐次初期化
                        this.ChildScreenType.Value = "0";
                    }

                    // 開く子画面のURL
                    this.ChildScreenUrl =
                        (HiddenField)this.RootMasterPage.FindControl(FxLiteral.HIDDEN_CHILD_SCREEN_URL); // 2009/07/21-この行

                    // エラー処理
                    if (this.ChildScreenUrl == null)
                    {
                        throw new FrameworkException(
                            FrameworkExceptionMessage.NO_FX_HIDDEN[0],
                            String.Format(FrameworkExceptionMessage.NO_FX_HIDDEN[1], FxLiteral.HIDDEN_CHILD_SCREEN_URL));
                    }

                    // 子画面を閉じるフラグ
                    this.CloseFlag = (HiddenField)this.RootMasterPage.FindControl(FxLiteral.HIDDEN_CLOSE_FLAG); // 2009/07/21-この行

                    // エラー処理
                    if (this.CloseFlag == null)
                    {
                        throw new FrameworkException(
                            FrameworkExceptionMessage.NO_FX_HIDDEN[0],
                            String.Format(FrameworkExceptionMessage.NO_FX_HIDDEN[1], FxLiteral.HIDDEN_CLOSE_FLAG));

                    }

                    // 子画面を閉じた後の後処理を判別するフラグ
                    this.SubmitFlag = (HiddenField)this.RootMasterPage.FindControl(FxLiteral.HIDDEN_SUBMIT_FLAG); // 2009/07/21-この行

                    // エラー処理
                    if (this.SubmitFlag == null)
                    {
                        throw new FrameworkException(
                            FrameworkExceptionMessage.NO_FX_HIDDEN[0],
                            String.Format(FrameworkExceptionMessage.NO_FX_HIDDEN[1], FxLiteral.HIDDEN_SUBMIT_FLAG));

                    }

                    // 画面GUIDを保存するHiddenコントロールを取得
                    this.ScreenGuid = (HiddenField)this.RootMasterPage.FindControl(FxLiteral.HIDDEN_SCREEN_GUID); // 2009/07/21-この行

                    // エラー処理
                    if (this.ScreenGuid == null)
                    {
                        throw new FrameworkException(
                            FrameworkExceptionMessage.NO_FX_HIDDEN[0],
                            String.Format(FrameworkExceptionMessage.NO_FX_HIDDEN[1], FxLiteral.HIDDEN_SCREEN_GUID));
                    }

                    #endregion

                    #endregion

                    #region 二重送信の検出処理

                    // 二重送信の検出処理の定義を取得
                    string doubleTransmissionCheck =
                        GetConfigParameter.GetConfigValue(FxLiteral.DOUBLE_TRANSMISSION_CHECK);

                    // デフォルト値対策:設定なし(null)の場合の扱いを決定
                    if (doubleTransmissionCheck == null)
                    {
                        // OFF扱い
                        doubleTransmissionCheck = FxLiteral.OFF;
                    }

                    // ON / OFF
                    if (doubleTransmissionCheck.ToUpper() == FxLiteral.ON)
                    {
                        // 二重送信の検出処理(ON)
                        // onSubmitイベントに、JavaScriptを仕掛ける。
                        this.Form.Attributes.Add("onSubmit", "return Fx_OnSubmit();");
                    }
                    else if (doubleTransmissionCheck.ToUpper() == FxLiteral.OFF)
                    {
                        // 二重送信の検出処理(OFF)
                    }
                    else
                    {
                        // パラメータ・エラー(書式不正)
                        throw new FrameworkException(
                            FrameworkExceptionMessage.ERROR_IN_WRITING_OF_FX_SWITCH1[0],
                            String.Format(FrameworkExceptionMessage.ERROR_IN_WRITING_OF_FX_SWITCH1[1],
                                FxLiteral.DOUBLE_TRANSMISSION_CHECK));
                    }

                    #endregion

                    #region 不正操作の検出機能

                    int requestTicketGuidMaxQueueLength = 0;

                    // ajaxの場合は、実行しない。
                    if (this.IsClientCallback)
                    {
                        // ClientCallbackなので実行しない。
                        // requestTicketGuidMaxQueueLength = 0 のままに
                    }
                    else
                    {
                        if (this.AjaxExtensionStatus == FxEnum.AjaxExtStat.IsAjaxExtension)
                        {
                            // Ajax Extensionなので実行しない。
                            // requestTicketGuidMaxQueueLength = 0 のままに
                        }
                        else
                        {
                            // 不正操作の検出機能の定義を取得
                            // ※ 記録する操作の最大数
                            requestTicketGuidMaxQueueLength =
                                FxCmnFunction.GetNumFromConfig(
                                    FxLiteral.REQUEST_TICKET_GUID_MAX_QUEUE_LENGTH, 0);
                        }
                    }

                    // isNoSessionフラグ
                    if (isNoSession)
                    {
                        // 不正操作の検出機能(強制OFF)
                        requestTicketGuidMaxQueueLength = 0;
                    }
                    else
                    {
                        if (canCheckIllegalOperation == null)
                        {
                            // 定義値による
                        }
                        else if (canCheckIllegalOperation == true)
                        {
                            // 不正操作の検出機能(強制ON)
                            if (requestTicketGuidMaxQueueLength <= 0)
                            {
                                // OFF→ON // 保持する履歴の数は固定。
                                requestTicketGuidMaxQueueLength = 100;
                            }
                            else //(canCheckIllegalOperation == false)
                            {
                                // ON→ON // 定義値による。
                            }
                        }
                        else
                        {
                            // 不正操作の検出機能(強制OFF)
                            requestTicketGuidMaxQueueLength = 0;
                        }
                    }

                    // 定義のチェック
                    if (0 < requestTicketGuidMaxQueueLength)
                    {
                        // キューの取得
                        this.GetGuidQueue(
                            out this.RequestTicketGuid_Queue,
                            FxHttpSessionIndex.REQUEST_TICKET_GUID_QUEUE,
                            requestTicketGuidMaxQueueLength);

                        // チェック対象はポストバックのみ
                        if (this.IsPostBack)
                        {
                            // ポストバック

                            // HIDDENとSESSIONのリクエスト チケットGUIDをチェック
                            if (this.RequestTicketGuid_Queue.Contains(this.RequestTicketGuid.Value))
                            {
                                // = → 正常

                                // 旧リクエスト チケットGUIDの作成
                                string oldGuid = this.RequestTicketGuid.Value;
                                // 新規リクエスト チケットGUIDの作成
                                string newGuid = Guid.NewGuid().ToString();

                                // HIDDENとSESSIONに保存

                                // HIDDEN
                                this.RequestTicketGuid.Value = newGuid;

                                // SESSION(リクエスト チケットGUIDキューの再構築)
                                this.RestructureGuidQueue(
                                    oldGuid, newGuid, out this.RequestTicketGuid_Queue,
                                    FxHttpSessionIndex.REQUEST_TICKET_GUID_QUEUE,
                                    requestTicketGuidMaxQueueLength);
                            }
                            else
                            {
                                // ≠ → 異常

                                //  不正操作を検出
                                throw new FrameworkException(
                                    FrameworkExceptionMessage.ILLEGAL_OPERATION_CHECK_ERROR[0],
                                    FrameworkExceptionMessage.ILLEGAL_OPERATION_CHECK_ERROR[1]);
                            }
                        }
                        else
                        {
                            // 初回ロード

                            // 新規リクエスト チケットGUIDの作成
                            string guid = Guid.NewGuid().ToString();

                            // HIDDENとSESSIONに保存

                            // HIDDEN
                            this.RequestTicketGuid.Value = guid;

                            // SESSION

                            // キューの最大長を超える場合は、デキューする
                            if (requestTicketGuidMaxQueueLength <= this.RequestTicketGuid_Queue.Count)
                            {
                                // 最も古いリクエスト チケットGUIDをデキュー
                                RequestTicketGuid_Queue.Dequeue();

                            }

                            // 新規のリクエスト チケットGUIDをエンキュー
                            RequestTicketGuid_Queue.Enqueue(guid);
                        }
                    }

                    #endregion

                    #region 画面遷移制御機能

                    // 2009/07/31-start

                    #region ウィンドウGUID設定

                    // ウィンドウGUID
                    string browserWindowGuid = "";

                    // ウィンドウ別セッション領域の自動削除機能の定義を取得
                    // ※ ウィンドウ別セッション領域のスコープの最大数
                    int windowGuidMaxQueueLength =
                        FxCmnFunction.GetNumFromConfig(
                            FxLiteral.WINDOW_GUID_MAX_QUEUE_LENGTH, 0);

                    if (this.WindowGuid.Value.Length == 36)
                    {
                        // ウィンドウGUIDがある場合

                        #region ウィンドウGUIDキューの再構築

                        // 定義のチェック
                        if (0 < windowGuidMaxQueueLength)
                        {
                            // ウィンドウGUIDキューの再構築
                            this.RestructureGuidQueue(this.WindowGuid.Value, out this.WindowGuid_Queue,
                                FxHttpSessionIndex.WINDOW_GUID_QUEUE, windowGuidMaxQueueLength);
                        }

                        #endregion
                    }
                    else
                    {
                        // ウィンドウGUIDがない場合

                        #region ウィンドウGUIDの初期化

                        // HTTP ContextにウィンドウGUIDがあるか?
                        if (HttpContext.Current.Items[
                            FxHttpContextIndex.BROWSER_WINDOW_GUID] == null)
                        { }
                        else
                        {
                            browserWindowGuid
                                = HttpContext.Current.Items[
                                    FxHttpContextIndex.BROWSER_WINDOW_GUID].ToString();
                        }

                        // 無かった場合、
                        if (browserWindowGuid == "")
                        {
                            // HTTP Query StringにウィンドウGUIDがあるか?
                            if (HttpContext.Current.Request.QueryString[
                                    FxHttpQueryStringIndex.BROWSER_WINDOW_GUID] == null)
                            { }
                            else
                            {
                                browserWindowGuid
                                    = HttpContext.Current.Request.QueryString[
                                        FxHttpQueryStringIndex.BROWSER_WINDOW_GUID].ToString();
                            }
                        }

                        // ウィンドウGUIDが新規生成されたか判別するフラグ
                        bool isNewWindowGuid = false;

                        // 無かった場合、
                        if (browserWindowGuid == "")
                        {
                            // ウィンドウGUIDを新規生成し、ウィンドウGUIDをHIDDEに設定
                            this.WindowGuid.Value = Guid.NewGuid().ToString();
                            isNewWindowGuid = true;
                        }
                        else
                        {
                            // ウィンドウGUIDをHIDDEに設定
                            this.WindowGuid.Value = browserWindowGuid;
                            isNewWindowGuid = false;
                        }

                        #endregion

                        #region ウィンドウ別セッション領域の自動削除とウィンドウGUIDキューの再構築

                        // 定義のチェック
                        if (0 < windowGuidMaxQueueLength)
                        {
                            if (isNewWindowGuid)
                            {
                                // 新規ウィンドウGUIDが生成された場合

                                // ウィンドウGUIDキューからセッション自動削除
                                this.DeleteSessionWithGuidQueueAutomatically(
                                    this.WindowGuid.Value, this.WindowGuid_Queue,
                                    FxHttpSessionIndex.WINDOW_GUID_QUEUE, windowGuidMaxQueueLength);
                            }
                            else
                            {
                                // 新規ウィンドウGUIDが生成されなかった場合

                                // ウィンドウGUIDキューの再構築
                                this.RestructureGuidQueue(this.WindowGuid.Value, out this.WindowGuid_Queue,
                                    FxHttpSessionIndex.WINDOW_GUID_QUEUE, windowGuidMaxQueueLength);
                            }
                        }

                        #endregion
                    }

                    #endregion

                    // 2009/07/31-end

                    #region 画面遷移チェック処理

                    if (SC.TransitionCheck)
                    {
                        // ポストバック
                        if (this.IsPostBack)
                        {
                            // ポストバック時はチェックしない。
                        }
                        else
                        {
                            // 初回ロード時にチェックする。

                            // ウィンドウ別セッション領域から前画面情報を取得する。
                            if (this.GetDataFromBrowserWindow(
                                    FxHttpSessionIndex.SCREEN_TRANSITION_INFO) == null)
                            {
                                this.FormerAspxVirtualPath = "";
                            }
                            else
                            {
                                this.FormerAspxVirtualPath
                                = this.GetDataFromBrowserWindow(
                                    FxHttpSessionIndex.SCREEN_TRANSITION_INFO).ToString();
                            }

                            // 取得後、直ちに消去
                            this.DeleteDataFromBrowserWindow(
                                    FxHttpSessionIndex.SCREEN_TRANSITION_INFO);

                            if (this.FormerAspxVirtualPath == "")
                            {
                                // 全画面情報無しなので、部品で遷移していない場合の、画面遷移チェック
                                if (HttpContext.Current.Request.HttpMethod.ToUpper() == FxLiteral.GET)
                                {
                                    // GET → GETチェック
                                    BaseController.SC.
                                        CheckScreenTransitionGet(this.AppRelativeVirtualPath);
                                }
                                else
                                {
                                    // POST → 強制的にエラー
                                    BaseController.SC.
                                        CheckScreenTransitionPost(this.AppRelativeVirtualPath);
                                }
                            }
                            else
                            {
                                // 前画面情報有りなので、部品で遷移している場合の、画面遷移チェック
                                BaseController.SC.CheckScreenTransition(
                                    this.FormerAspxVirtualPath,
                                    this.AppRelativeVirtualPath);
                            }
                        }
                    }
                    else
                    {
                        // 画面遷移チェックしない。
                    }

                    #endregion

                    #endregion

                    #region 画面GUID関連の処理

                    // ClientCallback時は実行しない。
                    if (!this.IsClientCallback)
                    {
                        // 2010/10/04-start

                        # region ボタン履歴情報記録機能のon・off

                        // ボタン履歴情報記録機能のon・offの定義を取得
                        int tempButtonhistoryMaxQueueLength =
                            FxCmnFunction.GetNumFromConfig(
                                    FxLiteral.BUTTON_HISTORY_MAX_QUEUE_LENGTH,
                                    FxLiteral.BUTTON_HISTORY_DEFAULT_QUEUE_LENGTH);

                        // ON( > 0) / OFF( <= 0)
                        if (tempButtonhistoryMaxQueueLength > 0)
                        {
                            // ボタン履歴情報記録機能(ON)
                            this.ButtonHistoryRecorder = true;
                        }
                        else
                        {
                            // ボタン履歴情報記録機能(OFF)
                            this.ButtonHistoryRecorder = false;
                        }

                        // isNoSessionフラグ
                        if (isNoSession)
                        {
                            // ボタン履歴情報記録機能(OFF)
                            this.ButtonHistoryRecorder = false;
                        }

                        #endregion

                        #region ボタン履歴情報(キュー)の初期化

                        if (this.ButtonHistoryRecorder) // 2008/03/29---ボタン履歴記録機能が有効な場合のみ実行する(追加)。
                        {
                            // ボタン履歴記録機能が無効な場合、キューの最大長を指定
                            this.ButtonhistoryMaxQueueLength = tempButtonhistoryMaxQueueLength;
                        }
                        else
                        {
                            // ボタン履歴記録機能が無効な場合は「0」で初期化
                            this.ButtonhistoryMaxQueueLength = 0; // = tempButtonhistoryMaxQueueLength;
                        }

                        if (this.ButtonHistoryRecorder) // 2008/11/28---ボタン履歴記録機能が有効な場合のみ実行する(追加)。
                        {
                            if (Session[FxHttpSessionIndex.BUTTON_HISTORY] == null)
                            {
                                // 新規生成(キューの最大長を指定する)
                                this.Buttonhistory_Queue = new Queue<ArrayList>(this.ButtonhistoryMaxQueueLength);

                                // Sessionに設定
                                Session[FxHttpSessionIndex.BUTTON_HISTORY] = this.Buttonhistory_Queue;
                            }
                            else
                            {
                                // Session領域から取得
                                this.Buttonhistory_Queue = (Queue<ArrayList>)Session[FxHttpSessionIndex.BUTTON_HISTORY];
                            }
                        }

                        #endregion

                        // 2010/10/04-end

                        // 2009/07/31-start

                        // 画面GUIDが新規生成されたか判別するフラグ
                        bool isNewScreenGuid = false;

                        // 親画面別セッション領域の自動削除機能の定義を取得
                        // ※ 親画面別セッション領域のスコープの最大数
                        int screenGuidMaxQueueLength =
                            FxCmnFunction.GetNumFromConfig(
                                FxLiteral.SCREEEN_GUID_MAX_QUEUE_LENGTH, 0);

                        if (this.ScreenGuid.Value.Length == 36)
                        {
                            // 画面GUIDがある場合 → 親画面・子画面のポストバック時

                            #region ボタン履歴(キュー)の再構築

                            if (this.ButtonHistoryRecorder) // 2008/11/28---ボタン履歴記録機能が有効な場合のみ実行する(追加)。
                            {
                                // ボタン履歴情報(キュー)から、
                                // 画面GUID付きボタン履歴情報(スタック)を取得
                                foreach (ArrayList tempObj in this.Buttonhistory_Queue) // ここはArrayListでないとNG(Buttonhistory_Queue)
                                {
                                    // 画面GUIDのインデックスを確認
                                    if (tempObj[0].ToString() == this.ScreenGuid.Value)
                                    {
                                        // ボタン履歴情報(スタック)を取得
                                        this.Buttonhistory_Stack = (Stack<FxEventArgs>)tempObj[1];
                                    }
                                }

                                // ※ 上記の処理で、Buttonhistory_Stackが取得できない場合に考えられる理由。
                                //   ・ セッションタイムアウトした場合(検出機能OFFの場合)
                                //   ・ 古いキャッシュを参照した場合
                                //   ・ スタックがキューからデキューされた場合

                                if (this.Buttonhistory_Stack == null)
                                {
                                    // キャッシュを参照した可能性
                                    throw new FrameworkException(
                                        FrameworkExceptionMessage.FX_PROCESSING_STATUS_ERROR[0],
                                        String.Format(FrameworkExceptionMessage.FX_PROCESSING_STATUS_ERROR[1],
                                            FrameworkExceptionMessage.FX_PROCESSING_STATUS_ERROR_NO_BH_QUEUE));
                                }

                                // ボタン履歴情報(キュー)の再構築

                                // ☆ Sessionに再設定する必要がある
                                //    (作り直しでインスタンスが変わったため)
                                Session[FxHttpSessionIndex.BUTTON_HISTORY]
                                    = FxCmnFunction.RestructuringLRUQueue2(
                                        this.Buttonhistory_Queue,
                                        this.ScreenGuid.Value,
                                        this.ButtonhistoryMaxQueueLength);

                                // ※ ボタン履歴情報(スタック)を操作するのは、イベント ハンドラ
                            }

                            #endregion

                            #region 画面GUIDキューの再構築

                            // 定義のチェック
                            if (0 < screenGuidMaxQueueLength)
                            {
                                // 画面GUIDキューの再構築
                                this.RestructureGuidQueue(this.ScreenGuid.Value, out this.ScreenGuid_Queue,
                                    FxHttpSessionIndex.SCREEN_GUID_QUEUE, screenGuidMaxQueueLength);
                            }

                            #endregion
                        }
                        else
                        {
                            // 画面GUIDがない場合 → 親画面・子画面の初回ロード時

                            #region 画面GUIDの初期化

                            string QueryStringScreenGuid
                                = (string)Request.QueryString[FxHttpQueryStringIndex.PARENT_SCREEN_GUID];

                            if (QueryStringScreenGuid == null)
                            {
                                QueryStringScreenGuid = "";
                            }

                            #endregion

                            #region ボタン履歴(スタック)の初期化

                            if (QueryStringScreenGuid.Length == 36)
                            {
                                // クエリーストリングがある場合 → 自画面は業務モーダル画面で、且つ初回ロード時

                                // 画面GUIDを設定
                                this.ScreenGuid.Value = QueryStringScreenGuid;

                                #region ボタン履歴(スタックをキューから取得)

                                if (this.ButtonHistoryRecorder) // 2008/11/28---ボタン履歴記録機能が有効な場合のみ実行する(追加)。
                                {
                                    // ボタン履歴情報(キュー)から、
                                    // 画面GUID付きボタン履歴情報(スタック)を取得
                                    foreach (ArrayList tempObj in this.Buttonhistory_Queue) // ここはArrayListでないとNG(Buttonhistory_Queue)
                                    {
                                        // 画面GUIDのインデックスを確認
                                        if (tempObj[0].ToString() == this.ScreenGuid.Value)
                                        {
                                            // ボタン履歴情報(スタック)を取得
                                            this.Buttonhistory_Stack = (Stack<FxEventArgs>)tempObj[1];
                                        }
                                    }

                                    // 初期値をプッシュ
                                    this.Buttonhistory_Stack.Push(
                                        new FxEventArgs(FxLiteral.VALUE_STR_DUMMY_STRING, 0, 0, "", ""));
                                }

                                #endregion
                            }
                            else
                            {
                                // クエリーストリングがない場合 → 自画面は親画面で、且つ初回ロード時

                                // 画面GUIDを新規生成
                                this.ScreenGuid.Value = Guid.NewGuid().ToString();
                                isNewScreenGuid = true;

                                #region ボタン履歴(スタックを新規生成)

                                if (this.ButtonHistoryRecorder) // 2008/11/28---ボタン履歴記録機能が有効な場合のみ実行する(追加)。
                                {
                                    // ボタン履歴情報(スタック)を新規生成
                                    this.Buttonhistory_Stack = new Stack<FxEventArgs>();

                                    // 初期値をプッシュ
                                    this.Buttonhistory_Stack.Push(
                                        new FxEventArgs(FxLiteral.VALUE_STR_DUMMY_STRING, 0, 0, "", ""));

                                    // ボタン履歴情報(スタック)をボタン履歴情報(キュー)に格納

                                    // ボタン履歴情報(スタック)に格納するデータ型は配列
                                    ArrayList tempObj = new ArrayList(2); // ここはArrayListでないとNG(Buttonhistory_Queue)

                                    // 画面GUIDのインデックス
                                    tempObj.Add(this.ScreenGuid.Value);

                                    // ボタン履歴情報(スタック)
                                    tempObj.Add(this.Buttonhistory_Stack);

                                    // キューの最大長を超える場合は、デキューする
                                    if (this.ButtonhistoryMaxQueueLength <= this.Buttonhistory_Queue.Count) // 2009/08/12-この行
                                    {
                                        // デキュー
                                        this.Buttonhistory_Queue.Dequeue();
                                    }

                                    // エンキュー
                                    this.Buttonhistory_Queue.Enqueue(tempObj);
                                }

                                #endregion
                            }

                            #endregion

                            #region 親画面別セッション領域の自動削除と画面GUIDキューの再構築

                            // 定義のチェック
                            if (0 < screenGuidMaxQueueLength)
                            {
                                if (isNewScreenGuid)
                                {
                                    // 新規画面GUIDが生成された場合

                                    // 画面GUIDキューからセッション自動削除
                                    this.DeleteSessionWithGuidQueueAutomatically(
                                        this.ScreenGuid.Value, this.ScreenGuid_Queue,
                                        FxHttpSessionIndex.SCREEN_GUID_QUEUE, screenGuidMaxQueueLength);
                                }
                                else
                                {
                                    // 新規画面GUIDが生成されなかった場合

                                    // 画面GUIDキューの再構築
                                    this.RestructureGuidQueue(this.ScreenGuid.Value, out this.ScreenGuid_Queue,
                                        FxHttpSessionIndex.SCREEN_GUID_QUEUE, screenGuidMaxQueueLength);
                                }
                            }

                            #endregion
                        }

                        // 2009/07/31-end
                    }

                    #endregion

                    #region コントロール取得処理

                    #region 旧処理
                    ////#if DEBUG // 2009/09/01-このプリプロセッサ
                    ////                    PerformanceRecorder perfRec = new PerformanceRecorder();
                    ////                    perfRec.StartsPerformanceRecord();
                    ////#endif

                    //// BUTTON
                    //FxCmnFunction.GetCtrlAndSetClickEventHandler(
                    //    this, GetConfigParameter.GetConfigValue(FxLiteral.PREFIX_OF_BUTTON),
                    //    new System.EventHandler(this.Button_Click), this.ControlHt);

                    ////#if DEBUG // 2009/09/01-このプリプロセッサ
                    ////                    Debug.WriteLine("BUTTONコントロール検索のパフォーマンス情報:\r\n" + perfRec.EndsPerformanceRecord());
                    ////#endif

                    //// LINK BUTTON
                    //FxCmnFunction.GetCtrlAndSetClickEventHandler(
                    //    this, GetConfigParameter.GetConfigValue(FxLiteral.PREFIX_OF_LINK_BUTTON),
                    //    new System.EventHandler(this.Button_Click), this.ControlHt);

                    //// IMAGE BUTTON
                    //FxCmnFunction.GetCtrlAndSetClickEventHandler(
                    //    this, GetConfigParameter.GetConfigValue(FxLiteral.PREFIX_OF_IMAGE_BUTTON),
                    //    new System.Web.UI.ImageClickEventHandler(this.ImageButton_Click), this.ControlHt);

                    //// IMAGE MAP
                    //FxCmnFunction.GetCtrlAndSetClickEventHandler(
                    //    this, GetConfigParameter.GetConfigValue(FxLiteral.PREFIX_OF_IMAGE_MAP),
                    //    new System.Web.UI.WebControls.ImageMapEventHandler(this.ImageMap_Click), this.ControlHt);

                    //// DROP DOWN LIST
                    //FxCmnFunction.GetCtrlAndSetClickEventHandler(
                    //    this, GetConfigParameter.GetConfigValue(FxLiteral.PREFIX_OF_DROP_DOWN_LIST),
                    //    new System.EventHandler(this.List_SelectedIndexChanged), this.ControlHt);

                    //// LIST BOX
                    //FxCmnFunction.GetCtrlAndSetClickEventHandler(
                    //    this, GetConfigParameter.GetConfigValue(FxLiteral.PREFIX_OF_LIST_BOX),
                    //    new System.EventHandler(this.List_SelectedIndexChanged), this.ControlHt);

                    //// RADIO BUTTON
                    //FxCmnFunction.GetCtrlAndSetClickEventHandler(
                    //    this, GetConfigParameter.GetConfigValue(FxLiteral.PREFIX_OF_RADIO_BUTTON),
                    //    new System.EventHandler(this.Check_CheckedChanged), this.ControlHt);

                    //// REPEATER
                    //FxCmnFunction.GetCtrlAndSetClickEventHandler(
                    //    this, GetConfigParameter.GetConfigValue(FxLiteral.PREFIX_OF_REPEATER),
                    //    new RepeaterCommandEventHandler(this.Repeater_ItemCommand), this.ControlHt);

                    //// GRIDVIEW
                    //object[] gridViewEventHandlers = new object[]{
                    //    new GridViewCommandEventHandler(this.GridView_RowCommand),
                    //    new EventHandler(this.List_SelectedIndexChanged),
                    //    new GridViewUpdateEventHandler(this.GridView_RowUpdating),
                    //    new GridViewDeleteEventHandler(this.GridView_RowDeleting),
                    //    new GridViewPageEventHandler(this.GridView_PageIndexChanging),
                    //    new GridViewSortEventHandler(this.GridView_Sorting)
                    //};

                    //FxCmnFunction.GetCtrlAndSetClickEventHandler(
                    //    this, GetConfigParameter.GetConfigValue(FxLiteral.PREFIX_OF_GRIDVIEW),
                    //    gridViewEventHandlers, this.ControlHt);
                    #endregion

                    // プレフィックス
                    string prefix = "";
                    // プレフィックスとイベント ハンドラのディクショナリを生成
                    Dictionary<string, object> prefixAndEvtHndHt = new Dictionary<string, object>();

                    // BUTTON
                    prefix = GetConfigParameter.GetConfigValue(FxLiteral.PREFIX_OF_BUTTON);
                    if (!string.IsNullOrEmpty(prefix))
                    {
                        prefixAndEvtHndHt.Add(prefix, new System.EventHandler(this.Button_Click));
                    }

                    // LINK BUTTON
                    prefix = GetConfigParameter.GetConfigValue(FxLiteral.PREFIX_OF_LINK_BUTTON);
                    if (!string.IsNullOrEmpty(prefix))
                    {
                        prefixAndEvtHndHt.Add(prefix, new System.EventHandler(this.Button_Click));
                    }

                    // IMAGE BUTTON
                    prefix = GetConfigParameter.GetConfigValue(FxLiteral.PREFIX_OF_IMAGE_BUTTON);
                    if (!string.IsNullOrEmpty(prefix))
                    {
                        prefixAndEvtHndHt.Add(prefix, new System.Web.UI.ImageClickEventHandler(this.ImageButton_Click));
                    }

                    // IMAGE MAP
                    prefix = GetConfigParameter.GetConfigValue(FxLiteral.PREFIX_OF_IMAGE_MAP);
                    if (!string.IsNullOrEmpty(prefix))
                    {
                        prefixAndEvtHndHt.Add(prefix, new System.Web.UI.WebControls.ImageMapEventHandler(this.ImageMap_Click));
                    }

                    // DROP DOWN LIST
                    prefix = GetConfigParameter.GetConfigValue(FxLiteral.PREFIX_OF_DROP_DOWN_LIST);
                    if (!string.IsNullOrEmpty(prefix))
                    {
                        prefixAndEvtHndHt.Add(prefix, new System.EventHandler(this.List_SelectedIndexChanged));
                    }

                    // LIST BOX
                    prefix = GetConfigParameter.GetConfigValue(FxLiteral.PREFIX_OF_LIST_BOX);
                    if (!string.IsNullOrEmpty(prefix))
                    {
                        prefixAndEvtHndHt.Add(prefix, new System.EventHandler(this.List_SelectedIndexChanged));
                    }

                    // RADIO BUTTON
                    prefix = GetConfigParameter.GetConfigValue(FxLiteral.PREFIX_OF_RADIO_BUTTON);
                    if (!string.IsNullOrEmpty(prefix))
                    {
                        prefixAndEvtHndHt.Add(prefix, new System.EventHandler(this.Check_CheckedChanged));
                    }

                    // REPEATER
                    prefix = GetConfigParameter.GetConfigValue(FxLiteral.PREFIX_OF_REPEATER);
                    if (!string.IsNullOrEmpty(prefix))
                    {
                        prefixAndEvtHndHt.Add(prefix, new RepeaterCommandEventHandler(this.Repeater_ItemCommand));
                    }

                    // GRIDVIEW
                    prefix = GetConfigParameter.GetConfigValue(FxLiteral.PREFIX_OF_GRIDVIEW);
                    if (!string.IsNullOrEmpty(prefix))
                    {
                        object[] gridViewEventHandlers = new object[]{
                        new GridViewCommandEventHandler(this.GridView_RowCommand),
                        new EventHandler(this.List_SelectedIndexChanged),
                        new GridViewUpdateEventHandler(this.GridView_RowUpdating),
                        new GridViewDeleteEventHandler(this.GridView_RowDeleting),
                        new GridViewPageEventHandler(this.GridView_PageIndexChanging),
                        new GridViewSortEventHandler(this.GridView_Sorting)};

                        prefixAndEvtHndHt.Add(prefix, gridViewEventHandlers);
                    }

                    // コントロール検索&イベントハンドラ設定
                    FxCmnFunction.GetCtrlAndSetClickEventHandler2(this, prefixAndEvtHndHt, this.ControlHt);

                    #endregion

                    #endregion

                    #region 画面の初期処理(初回ロード、ポストバック)

                    #region 共通UOC処理(UOC_CMNFormInit、UOC_CMNFormInit_PostBack)。

                    if (this.IsPostBack)
                    {
                        // ポストバック時

                        // ポストバック時のUOCメソッド
                        this.UOC_CMNFormInit_PostBack();
                    }
                    else
                    {
                        // 初回起動時

                        // 初回起動時のUOCメソッド
                        this.UOC_CMNFormInit();
                    }

                    #endregion

                    #region 個別UOC処理(UOC_FormInit、UOC_FormInit_PostBack)。

                    if (this.IsPostBack)
                    {
                        // ポストバック時

                        // ポストバック時のUOCメソッド
                        this.UOC_FormInit_PostBack();
                    }
                    else
                    {
                        // 初回起動時

                        // 初回起動時のUOCメソッド
                        this.UOC_FormInit();
                    }

                    #endregion

                    #endregion

                    // ・ ポストバック時のみ実行
                    // ・ ClientCallback時は実行しない。
                    // ・ AjaxExtension時は実行しない。
                    if (this.IsPostBack
                        && !this.IsClientCallback
                        && !(this.AjaxExtensionStatus == FxEnum.AjaxExtStat.IsAjaxExtension))
                    {
                        #region ダイアログ(から戻った場合)の後処理(イベント)

                        // 子画面を閉じた後の後処理を判別するフラグのnullチェック
                        if (this.SubmitFlag == null)
                        {
                            // nullの場合
                        }
                        else
                        {
                            // 値が1・2・3・4に該当する場合、後処理をする。

                            // ★1:「YES」・「NO」メッセージ・ダイアログの「×」が押され閉じられた場合。
                            // ★2:「YES」・「NO」メッセージ・ダイアログの「YES」が押された場合。
                            // ★3:「YES」・「NO」メッセージ・ダイアログの「NO」が押された場合。
                            // ★4:業務モーダル・ダイアログから戻った場合。

                            if (((int)FxEnum.SubmitMode.YesNo_X).ToString() == this.SubmitFlag.Value)
                            {
                                // ★ イベントの開始前のUOC処理
                                this.UOC_PreAction(new FxEventArgs(FxLiteral.EVENT_AFTER_YES_NO_X, 0, 0, "", ""));

                                // ★:「YES」・「NO」メッセージ・ダイアログの「×」が押され閉じられた場合。

                                if (this.ButtonHistoryRecorder) // 2008/11/28---ボタン履歴記録機能が有効な場合のみ実行する(追加)。
                                {
                                    // 引数:親画面で押したボタン情報
                                    this.UOC_YesNoDialog_X_Click((FxEventArgs)this.Buttonhistory_Stack.Peek());
                                }
                                else
                                {
                                    // 引数:ダミーのボタン情報
                                    this.UOC_YesNoDialog_X_Click(
                                        new FxEventArgs(FxLiteral.VALUE_STR_DUMMY_STRING, 0, 0, "", ""));
                                }

                                // ★ イベントの終了後のUOC処理
                                this.UOC_AfterAction(new FxEventArgs(FxLiteral.EVENT_AFTER_YES_NO_X, 0, 0, "", ""));
                            }
                            else if (((int)FxEnum.SubmitMode.YesNo_Yes).ToString() == this.SubmitFlag.Value)
                            {
                                // ★ イベントの開始前のUOC処理
                                this.UOC_PreAction(new FxEventArgs(FxLiteral.EVENT_AFTER_YES_NO_YES, 0, 0, "", ""));

                                // ★:「YES」・「NO」メッセージ・ダイアログの「YES」が押された場合。

                                if (this.ButtonHistoryRecorder) // 2008/11/28---ボタン履歴記録機能が有効な場合のみ実行する(追加)。
                                {
                                    // 引数:親画面で押したボタン情報
                                    this.UOC_YesNoDialog_Yes_Click((FxEventArgs)this.Buttonhistory_Stack.Peek());
                                }
                                else
                                {
                                    // 引数:ダミーのボタン情報
                                    this.UOC_YesNoDialog_Yes_Click(
                                        new FxEventArgs(FxLiteral.VALUE_STR_DUMMY_STRING, 0, 0, "", ""));
                                }

                                // ★ イベントの終了後のUOC処理
                                this.UOC_AfterAction(new FxEventArgs(FxLiteral.EVENT_AFTER_YES_NO_YES, 0, 0, "", ""));
                            }
                            else if (((int)FxEnum.SubmitMode.YesNo_No).ToString() == this.SubmitFlag.Value)
                            {
                                // ★ イベントの開始前のUOC処理
                                this.UOC_PreAction(new FxEventArgs(FxLiteral.EVENT_AFTER_YES_NO_NO, 0, 0, "", ""));

                                // ★:「YES」・「NO」メッセージ・ダイアログの「NO」が押された場合。

                                if (this.ButtonHistoryRecorder) // 2008/11/28---ボタン履歴記録機能が有効な場合のみ実行する(追加)。
                                {
                                    // 引数:親画面で押したボタンの情報
                                    this.UOC_YesNoDialog_No_Click((FxEventArgs)this.Buttonhistory_Stack.Peek());
                                }
                                else
                                {
                                    // 引数:ダミーのボタン情報
                                    this.UOC_YesNoDialog_No_Click(
                                        new FxEventArgs(FxLiteral.VALUE_STR_DUMMY_STRING, 0, 0, "", ""));
                                }

                                // ★ イベントの終了後のUOC処理
                                this.UOC_AfterAction(new FxEventArgs(FxLiteral.EVENT_AFTER_YES_NO_NO, 0, 0, "", ""));
                            }
                            else if (((int)FxEnum.SubmitMode.Modal).ToString() == this.SubmitFlag.Value)
                            {
                                // ★ イベントの開始前のUOC処理
                                this.UOC_PreAction(new FxEventArgs(FxLiteral.EVENT_AFTER_MODAL_DIALOG, 0, 0, "", ""));

                                // 親画面で押したボタンの情報
                                FxEventArgs parentFxEventArgs;

                                //子画面で押されたボタンの情報
                                FxEventArgs childFxEventArgs;

                                try
                                {
                                    if (this.ButtonHistoryRecorder) // 2008/11/28---ボタン履歴記録機能が有効な場合のみ実行する(追加)。
                                    {
                                        // POP(Nullチェックしない)
                                        childFxEventArgs = (FxEventArgs)this.Buttonhistory_Stack.Pop();
                                    }
                                    else
                                    {
                                        // ダミーのボタン情報
                                        childFxEventArgs = new FxEventArgs(FxLiteral.VALUE_STR_DUMMY_STRING, 0, 0, "", "");
                                    }

                                    if (this.ButtonHistoryRecorder) // 2008/11/28---ボタン履歴記録機能が有効な場合のみ実行する(追加)。
                                    {
                                        // 親画面で押したボタンの情報
                                        parentFxEventArgs = (FxEventArgs)this.Buttonhistory_Stack.Peek();
                                    }
                                    else
                                    {
                                        // ダミーのボタン情報
                                        parentFxEventArgs = new FxEventArgs(FxLiteral.VALUE_STR_DUMMY_STRING, 0, 0, "", "");
                                    }
                                }
                                catch (Exception ex)
                                {
                                    // 子画面でかならずプッシュされるが、異常な状態に陥った場合NullReferenceが発生する。
                                    // エラー発生時や、親画面の後処理でファイルダウンロードのHTTPレスポンスを返した場合など。
                                    throw new FrameworkException(
                                        FrameworkExceptionMessage.DIALOG_AFTER_PROCESSING_STATUS_ERROR[0],
                                        String.Format(FrameworkExceptionMessage.DIALOG_AFTER_PROCESSING_STATUS_ERROR[1], ex.Message));
                                }

                                // ★ 業務モーダル・ダイアログの後処理を実行する。
                                this.UOC_ModalDialog_End(parentFxEventArgs, childFxEventArgs);

                                // ★ イベントの終了後のUOC処理
                                this.UOC_AfterAction(new FxEventArgs(FxLiteral.EVENT_AFTER_MODAL_DIALOG, 0, 0, "", ""));
                            }
                        }

                        #endregion
                    }
                }
            }