示例#1
0
        /// <summary>
        /// レイアウト保存
        /// </summary>
        /// <param name="layoutName">レイアウト名</param>
        /// <returns>レイアウトID</returns>
        public long SaveLayout(string layoutName)
        {
            var id = 0L;

            // 空いているレイアウトIDを取得する
            var query = @$ "
SELECT
    ifnull(MIN( LayoutID + 1 ), 0) AS LayoutID
FROM
    WorkAreaLayouts
WHERE
    ( LayoutID + 1 ) NOT IN ( SELECT LayoutID FROM WorkAreaLayouts)";

            SettingDatabase.Instance.ExecQuery(query, (dr, args) =>
            {
                id = (long)dr["LayoutID"];
            });


            var param = new SQLiteCommandParameters(3);

            param.Add("layoutID", System.Data.DbType.Int32, id);
            param.Add("layoutName", System.Data.DbType.String, layoutName);
            param.Add("layout", System.Data.DbType.Binary, GetCurrentLayout() ?? throw new InvalidOperationException());

            SettingDatabase.Instance.ExecQuery("INSERT INTO WorkAreaLayouts(LayoutID, LayoutName, Layout) VALUES(:layoutID, :layoutName, :layout)", param);

            return(id);
        }
示例#2
0
        /// <summary>
        /// レイアウトを上書き保存
        /// </summary>
        /// <param name="layoutID">レイアウトID</param>
        public void OverwriteSaveLayout(long layoutID)
        {
            var param = new SQLiteCommandParameters(2);

            param.Add("layout", System.Data.DbType.Binary, GetCurrentLayout() ?? throw new InvalidOperationException());
            param.Add("LayoutID", System.Data.DbType.Int32, layoutID);
            SettingDatabase.Instance.ExecQuery($"UPDATE WorkAreaLayouts SET Layout = :layout WHERE LayoutID = :layoutID", param);
        }
        /// <summary>
        /// レイアウト名変更
        /// </summary>
        private void EditLayoutName(LayoutMenuItem menuItem)
        {
            var(onOK, newLayoutName) = SelectStringDialog.ShowDialog("Lang:EditLayoutName", "Lang:LayoutName", menuItem.LayoutName.Value, IsValidLayoutName);
            if (onOK && menuItem.LayoutName.Value != newLayoutName)
            {
                menuItem.LayoutName.Value = newLayoutName;

                var param = new SQLiteCommandParameters(2);
                param.Add("layoutName", System.Data.DbType.String, menuItem.LayoutName.Value);
                param.Add("layoutID", System.Data.DbType.Int32, menuItem.LayoutID);
                SettingDatabase.Instance.ExecQuery($"UPDATE WorkAreaLayouts SET LayoutName = :layoutName WHERE LayoutID = :layoutID", param);
            }
        }
        /// <summary>
        /// ウィンドウが閉じられる時
        /// </summary>
        /// <returns>キャンセルされたか</returns>
        public bool WindowClosing()
        {
            var canceled = false;

            // 未保存の内容が存在するか?
            if (_WorkAreaManager.Documents.Any(x => x.HasChanged))
            {
                var result = LocalizedMessageBox.Show("Lang:MainWindowClosingConfirmMessage", "Lang:Confirmation", MessageBoxButton.YesNoCancel, MessageBoxImage.Question);

                switch (result)
                {
                // 保存する場合
                case MessageBoxResult.Yes:
                    foreach (var doc in _WorkAreaManager.Documents)
                    {
                        doc.Save();
                    }
                    break;

                // 保存せずに閉じる場合
                case MessageBoxResult.No:
                    break;

                // キャンセルする場合
                case MessageBoxResult.Cancel:
                    canceled = true;
                    break;
                }
            }

            // 閉じる場合、開いていたファイル一覧を保存する
            if (!canceled)
            {
                var param = new SQLiteCommandParameters(1);

                var pathes = _WorkAreaManager.Documents.Where(x => File.Exists(x.SaveFilePath))
                             .Select(x => x.SaveFilePath);

                param.AddRange("path", System.Data.DbType.String, pathes);

                SettingDatabase.Instance.ExecQuery("INSERT INTO OpenedFiles(Path) VALUES(:path)", param);
            }

            return(canceled);
        }
        /// <summary>
        /// モジュール情報を集計
        /// </summary>
        /// <param name="modules">集計対象</param>
        /// <returns>集計結果</returns>
        private Dictionary <string, List <StorageDetailsListItem> > AggregateStorage(IEnumerable <ModulesGridItem> modules)
        {
            // 保管庫情報集計用
            var modulesDict = new Dictionary <string, List <StorageDetailsListItem> >();

            var targetModules = modules.Where(x => x.Module.ModuleType.ModuleTypeID == "storage")
                                .GroupBy(x => x.Module.ModuleID)
                                .Select(x => (x.First().Module.ModuleID, Count: x.Sum(y => y.ModuleCount)));

            if (!targetModules.Any())
            {
                return(modulesDict);
            }

            var query = $@"
SELECT
    TransportTypeID,
    Amount * :count AS Amount,
    :count AS Count,
    ModuleID

FROM
    ModuleStorage

WHERE
    ModuleID = :moduleID";

            var sqlParam = new SQLiteCommandParameters(2);

            foreach (var module in targetModules)
            {
                sqlParam.Add("moduleID", System.Data.DbType.String, module.ModuleID);
                sqlParam.Add("count", System.Data.DbType.Int32, module.Count);
            }

            // 容量をタイプ別に集計
            X4Database.Instance.ExecQuery(query, sqlParam, SumStorage, modulesDict);

            return(modulesDict);
        }
示例#6
0
        /// <summary>
        /// モジュール一覧を設定
        /// </summary>
        /// <param name="WorkArea"></param>
        /// <param name="saveData"></param>
        private void SetModules(IWorkArea WorkArea, SaveDataStationItem saveData)
        {
            var modParam    = new SQLiteCommandParameters(1);
            var eqParam     = new SQLiteCommandParameters(3);
            var moduleCount = 0;

            foreach (var entry in saveData.XElement.XPathSelectElements("construction/sequence/entry"))
            {
                var index = int.Parse(entry.Attribute("index").Value);
                modParam.Add("macro", System.Data.DbType.String, entry.Attribute("macro").Value);

                foreach (var equipmet in entry.XPathSelectElements("upgrades/groups/*"))
                {
                    eqParam.Add("index", System.Data.DbType.Int32, index);
                    eqParam.Add("macro", System.Data.DbType.String, equipmet.Attribute("macro").Value);
                    eqParam.Add("count", System.Data.DbType.Int32, int.Parse(equipmet.Attribute("exact")?.Value ?? "1"));
                }

                moduleCount++;
            }


            var modules = new List <ModulesGridItem>(moduleCount);

            // モジュール追加
            {
                var query = @"
SELECT
    ModuleID
FROM
    Module
WHERE
    Macro = :macro";


                X4Database.Instance.ExecQuery(query, modParam, (dr, _) =>
                {
                    var module = Module.Get((string)dr["ModuleID"]);

                    if (module != null)
                    {
                        modules.Add(new ModulesGridItem(module));
                    }
                });
            }


            // 装備追加
            {
                var query = @"
SELECT
    EquipmentID,
    :index AS 'Index',
    :count AS Count
FROM
    Equipment
WHERE
    MacroName = :macro";

                X4Database.Instance.ExecQuery(query, eqParam, (dr, _) =>
                {
                    var index           = (int)(long)dr["Index"] - 1;
                    var moduleEquipment = modules[index].ModuleEquipment;

                    var equipment = Equipment.Get((string)dr["EquipmentID"]);
                    if (equipment == null)
                    {
                        return;
                    }

                    var count = (long)dr["Count"];
                    moduleEquipment.AddEquipment(equipment, count);
                });
            }

            // 同一モジュールをマージ
            var dict = new Dictionary <int, (int, Module, ModuleProduction, long)>();

            foreach (var(module, idx) in modules.Select((x, idx) => (x, idx)))
            {
                var hash = HashCode.Combine(module.Module, module.SelectedMethod);
                if (dict.ContainsKey(hash))
                {
                    var tmp = dict[hash];
                    tmp.Item4 += module.ModuleCount;
                    dict[hash] = tmp;
                }
                else
                {
                    dict.Add(hash, (idx, module.Module, module.SelectedMethod, module.ModuleCount));
                }
            }

            // モジュール一覧に追加
            var range = dict.Select(x => (x.Value)).OrderBy(x => x.Item1).Select(x => new ModulesGridItem(x.Item2, x.Item3, x.Item4));

            WorkArea.StationData.ModulesInfo.Modules.AddRange(range);
        }