C言語+MySQL入門|在庫履歴を表示する

C言語+MySQL入門|在庫履歴を表示する

前の記事では、商品を選んで数量を入力し、出庫処理を実行できるようにしました。出庫に成功すると、在庫数の更新とOUT履歴の登録がまとめて確定します。

今回は、その入出庫の記録を画面から確認できるようにします。

この記事では、次の内容を詳しく解説します。

  • 履歴表示に必要なヘッダーと実装ファイルを配置する。
  • 選択中の商品IDを使って在庫履歴を取得する。
  • コンソール版と共通のfetch_stock_historyを呼び出す。
  • 履歴ID、入出庫の種類、数量、記録日時を表示する。
  • 履歴0件と取得エラーを区別する。
  • 別の商品を選択したら、前の商品の履歴を消す。
  • 取得した履歴配列を、表示後に解放する。

今回の到達点は、一覧で選んだ商品の入出庫記録をGUIで確認できることです。

実行例では、前の記事までの操作に合わせて、商品ID 23の入庫確認ノートA5を使用します。単価は190.50、在庫数は6個の状態です。

在庫数と在庫履歴の違いを確認しよう

商品一覧の在庫数は、現在いくつ残っているかを表します。

在庫履歴は、成功した入出庫について、その種類、数量、記録日時を確認するためのものです。

確認する情報分かること取得元
現在の在庫数今、何個あるかproducts
IN履歴何個入庫したかstock_history
OUT履歴何個出庫したかstock_history

前の記事までに、商品ID 23では次の操作を行いました。

操作在庫数の変化履歴
3個を入庫する5個から8個IN、数量3を追加
在庫8個に対して9個を出庫しようとする8個のまま追加しない
2個を出庫する8個から6個OUT、数量2を追加

在庫不足によって成立しなかった出庫は、今回の設計では履歴へ追加しません。

また、OUTの数量は負数ではなく正数です。出庫であることをmovement_typeのOUTで表しています。

図1:現在の在庫数と入出庫履歴を確認する

この図から分かること

商品一覧では現在の在庫数を確認し、在庫履歴では成功した入出庫の記録を確認します。

在庫不足で成立しなかった出庫は、在庫数も履歴も変更しません。

必要なファイルを先にそろえよう

今回は、15.6までのGUIへ履歴表示を追加します。

履歴表示には、型の定義、関数の宣言、関数の実装が必要です。stock_history.hだけでは、関数本体まで用意されるわけではありません。

以下の四つのファイルを、順番に整えてください。この記事では、それぞれの内容を全文掲載します。

ファイル役割
include/app_types.h商品と履歴の共通データ型を定義する
include/stock_history.h履歴取得と配列解放の関数を宣言する
src/stock/stock_history_list.c履歴取得と配列解放を実装する
gui/inventory_register.c商品操作と履歴表示の画面を実装する

既存のapp_result.h、product.h、stock.h、db.h、db_config.h、validation.hと、それらに対応する実装は、前の記事までのものを使用します。

stock_history_internal.hとは用途が異なる

履歴関連のファイルには、似た名前のものがあります。

ファイル用途
include/stock_history.h画面側から履歴を取得するための公開ヘッダー
src/stock/stock_history_internal.h入出庫処理の内部から履歴を登録するための内部ヘッダー
src/stock/stock_history.c履歴の登録処理
src/stock/stock_history_list.c履歴の取得処理

stock_history_internal.hの名前を変更して、stock_history.hとして使わないようにしてください。両方のヘッダーを、それぞれの場所へ配置します。

保存先のフォルダーを確認しよう

Windows側の作業フォルダーは、次の場所を使用します。

C:\c-mysql\chap15

MSYS2 UCRT64では、対応する場所へ移動します。

cd /c/c-mysql/chap15

たとえばstock_history.hの保存先は、次の場所です。

C:\c-mysql\chap15\include\stock_history.h

以下で示すファイル名は、すべてchap15からの相対パスです。

商品と履歴の共通データ型をそろえよう

include/app_types.hを、次の内容にそろえます。

既存の商品用の型を残したうえで、StockHistoryとStockHistoryListも定義します。

商品情報と在庫履歴の受け渡しに使う型を定義するヘッダーファイル

ファイル名: include/app_types.h

#ifndef APP_TYPES_H
#define APP_TYPES_H

#include <stddef.h>

/* 終端文字を含めた文字配列の容量 */
#define PRODUCT_NAME_CAPACITY 401
#define PRODUCT_PRICE_CAPACITY 12
#define PRODUCT_DATETIME_CAPACITY 20

/* 商品登録・変更で受け渡す入力データ */
typedef struct {
    char product_name[PRODUCT_NAME_CAPACITY];
    char price[PRODUCT_PRICE_CAPACITY];
} ProductInput;

/* DBから取得した商品一件分 */
typedef struct {
    int product_id;
    char product_name[PRODUCT_NAME_CAPACITY];
    char price[PRODUCT_PRICE_CAPACITY];
    int stock;
    char created_at[PRODUCT_DATETIME_CAPACITY];
} Product;

/* 動的に確保した商品配列と件数 */
typedef struct {
    Product *items;
    size_t count;
} ProductList;

/* INまたはOUTと終端文字を保存する容量 */
#define STOCK_MOVEMENT_CAPACITY 4
#define STOCK_HISTORY_DATETIME_CAPACITY 20

/* DBから取得した在庫履歴一件分 */
typedef struct {
    int history_id;
    int product_id;
    char product_name[PRODUCT_NAME_CAPACITY];
    char movement_type[STOCK_MOVEMENT_CAPACITY];
    int quantity;
    char recorded_at[STOCK_HISTORY_DATETIME_CAPACITY];
} StockHistory;

/* 動的に確保した履歴配列と件数 */
typedef struct {
    StockHistory *items;
    size_t count;
} StockHistoryList;

#endif

StockHistoryは履歴一件分、StockHistoryListは取得した履歴全体を表します。

メンバー内容
history_id履歴を識別する番号
product_id対象の商品ID
product_name検索時点の商品名
movement_typeINまたはOUT
quantity入出庫した数量
recorded_at記録日時

商品名は、productsとの結合で取得する現在の商品名です。入出庫当時の商品名を保存したものではありません。

履歴取得用の公開ヘッダーを作ろう

include/stock_history.hには、GUI側から使う二つの関数を宣言します。

商品ごとの履歴取得と配列解放を宣言するヘッダーファイル

ファイル名: include/stock_history.h

#ifndef STOCK_HISTORY_H
#define STOCK_HISTORY_H

#include <mysql.h>
#include "app_result.h"
#include "app_types.h"

/*
 * 指定商品の履歴を取得する。
 * 商品IDは1以上を指定する。
 *
 * 接続済み、utf8mb4、既存トランザクションなしを前提とする。
 * 同じ接続を別の処理から同時に使用しない。
 *
 * outはitemsがNULL、countが0の空の状態で渡す。
 * 全件の取得に成功した場合だけ、配列の所有権をoutへ渡す。
 * 履歴が0件でもAPP_OKを返す。
 *
 * 商品そのものが存在するかどうかは、この関数では判定しない。
 * ステートメントはこの関数が閉じる。
 * 接続は呼び出し元が閉じる。
 */
AppResult fetch_stock_history(
    MYSQL *conn,
    int product_id,
    StockHistoryList *out
);

/* 配列を解放し、空の状態に戻す */
void free_stock_history_list(StockHistoryList *list);

#endif
関数役割
fetch_stock_history指定した商品の履歴を取得する
free_stock_history_list取得した履歴配列を解放する

出力先には、空のStockHistoryListを渡します。

/* 取得先は空の状態で用意する */
StockHistoryList incoming = {0};

取得結果は、次のように判断します。

結果意味
APP_OK、1件以上履歴を取得できた
APP_OK、0件検索は成功したが、該当する履歴がない
APP_OK以外履歴を正常に取得できなかった

取得失敗を、履歴0件として扱わないことが大切です。

履歴取得の実装ファイルを配置しよう

次に、src/stock/stock_history_list.cを用意します。

これは第12章で作成した共通処理です。すでに配置済みの場合も、以下の内容と対応していることを確認してください。

指定商品の在庫履歴を取得し、構造体配列として返すプログラム

ファイル名: src/stock/stock_history_list.c

#include "stock_history.h"
#include "validation.h"

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* 最初のエラーを保存する */
static void save_error(AppError *out, const char *operation,
                       unsigned int number, const char *sqlstate)
{
    if (out->present) {
        return;
    }

    out->present = 1;
    out->has_mysql_error = number != 0;
    out->number = number;

    snprintf(out->sqlstate, sizeof out->sqlstate, "%.5s", sqlstate);
    snprintf(out->operation, sizeof out->operation, "%s", operation);
}

static void save_connection_error(AppError *out, MYSQL *conn,
                                   const char *operation)
{
    save_error(out, operation, mysql_errno(conn), mysql_sqlstate(conn));
}

static void save_statement_error(AppError *out, MYSQL_STMT *stmt,
                                  const char *operation)
{
    save_error(
        out, operation,
        mysql_stmt_errno(stmt), mysql_stmt_sqlstate(stmt)
    );
}

/* 取得長と埋め込みNULを確認し、終端文字を追加する */
static int finish_text(char *text, size_t capacity, unsigned long length)
{
    if (length >= capacity ||
        memchr(text, '\0', (size_t)length) != NULL) {
        return -1;
    }

    text[length] = '\0';
    return 0;
}

void free_stock_history_list(StockHistoryList *list)
{
    if (list != NULL) {
        free(list->items);
        *list = (StockHistoryList){0};
    }
}

AppResult fetch_stock_history(MYSQL *conn, int product_id,
                               StockHistoryList *out)
{
    AppResult result = {.status = APP_DB_ERROR};
    MYSQL_STMT *stmt = NULL;
    StockHistoryList list = {0};
    StockHistory row = {0};

    MYSQL_BIND input_bind[1] = {0};
    MYSQL_BIND output_bind[6] = {0};

    unsigned long lengths[6] = {0};
    my_bool is_null[6] = {0};
    my_bool errors[6] = {0};

    const char *sql =
        "SELECT h.history_id, h.product_id, p.product_name, "
        "h.movement_type, h.quantity, h.recorded_at "
        "FROM stock_history AS h "
        "INNER JOIN products AS p ON p.product_id = h.product_id "
        "WHERE h.product_id = ? "
        "ORDER BY h.history_id ASC";

    /* 既存の配列を上書きして失わないようにする */
    if (conn == NULL || product_id <= 0 || out == NULL ||
        out->items != NULL || out->count != 0) {
        result.status = APP_INVALID_ARGUMENT;
        save_error(
            &result.error, "validate_history_list", 0, "-----"
        );
        return result;
    }

    stmt = mysql_stmt_init(conn);

    if (stmt == NULL) {
        save_connection_error(
            &result.error, conn, "mysql_stmt_init"
        );
        return result;
    }

    if (mysql_stmt_prepare(
            stmt, sql, (unsigned long)strlen(sql)) != 0) {
        save_statement_error(
            &result.error, stmt, "prepare_history_list"
        );
        goto cleanup;
    }

    if (mysql_stmt_param_count(stmt) != 1) {
        save_error(
            &result.error, "check_history_parameters", 0, "-----"
        );
        goto cleanup;
    }

    input_bind[0].buffer_type = MYSQL_TYPE_LONG;
    input_bind[0].buffer = &product_id;
    input_bind[0].buffer_length = sizeof product_id;
    input_bind[0].is_unsigned = 0;

    if (mysql_stmt_bind_param(stmt, input_bind) != 0) {
        save_statement_error(
            &result.error, stmt, "bind_history_id"
        );
        goto cleanup;
    }

    if (mysql_stmt_execute(stmt) != 0) {
        save_statement_error(
            &result.error, stmt, "select_stock_history"
        );
        goto cleanup;
    }

    if (mysql_stmt_field_count(stmt) != 6) {
        save_error(
            &result.error, "check_history_columns", 0, "-----"
        );
        goto cleanup;
    }

    /* SELECTの列順に、六つの受け取り先を設定する */
    output_bind[0].buffer_type = MYSQL_TYPE_LONG;
    output_bind[0].buffer = &row.history_id;
    output_bind[0].buffer_length = sizeof row.history_id;
    output_bind[0].is_unsigned = 0;

    output_bind[1].buffer_type = MYSQL_TYPE_LONG;
    output_bind[1].buffer = &row.product_id;
    output_bind[1].buffer_length = sizeof row.product_id;
    output_bind[1].is_unsigned = 0;

    output_bind[2].buffer_type = MYSQL_TYPE_STRING;
    output_bind[2].buffer = row.product_name;
    output_bind[2].buffer_length = sizeof row.product_name - 1;

    output_bind[3].buffer_type = MYSQL_TYPE_STRING;
    output_bind[3].buffer = row.movement_type;
    output_bind[3].buffer_length = sizeof row.movement_type - 1;

    output_bind[4].buffer_type = MYSQL_TYPE_LONG;
    output_bind[4].buffer = &row.quantity;
    output_bind[4].buffer_length = sizeof row.quantity;
    output_bind[4].is_unsigned = 0;

    output_bind[5].buffer_type = MYSQL_TYPE_STRING;
    output_bind[5].buffer = row.recorded_at;
    output_bind[5].buffer_length = sizeof row.recorded_at - 1;

    for (size_t i = 0; i < 6; ++i) {
        output_bind[i].length = &lengths[i];
        output_bind[i].is_null = &is_null[i];
        output_bind[i].error = &errors[i];
    }

    if (mysql_stmt_bind_result(stmt, output_bind) != 0) {
        save_statement_error(
            &result.error, stmt, "bind_history_result"
        );
        goto cleanup;
    }

    if (mysql_stmt_store_result(stmt) != 0) {
        save_statement_error(
            &result.error, stmt, "store_history_result"
        );
        goto cleanup;
    }

    my_ulonglong count = mysql_stmt_num_rows(stmt);

    /* 配列を確保できる件数か確認する */
    if ((uintmax_t)count >
        (uintmax_t)(SIZE_MAX / sizeof(StockHistory))) {
        save_error(
            &result.error, "check_history_list_size", 0, "-----"
        );
        goto cleanup;
    }

    list.count = (size_t)count;

    if (list.count > 0) {
        list.items = calloc(list.count, sizeof *list.items);

        if (list.items == NULL) {
            save_error(
                &result.error, "allocate_history_list", 0, "-----"
            );
            goto cleanup;
        }
    }

    for (size_t i = 0; i < list.count; ++i) {
        /* 受け取り先のアドレスは変えず、値を初期化する */
        row = (StockHistory){0};
        int fetched = mysql_stmt_fetch(stmt);

        if (fetched == MYSQL_NO_DATA ||
            fetched == MYSQL_DATA_TRUNCATED) {
            save_error(
                &result.error, "check_history_fetch", 0, "-----"
            );
            goto cleanup;
        }

        if (fetched != 0) {
            save_statement_error(
                &result.error, stmt, "fetch_stock_history"
            );
            goto cleanup;
        }

        for (size_t column = 0; column < 6; ++column) {
            if (is_null[column] || errors[column]) {
                save_error(
                    &result.error, "check_history_values", 0, "-----"
                );
                goto cleanup;
            }
        }

        if (finish_text(
                row.product_name,
                sizeof row.product_name,
                lengths[2]) != 0 ||
            finish_text(
                row.movement_type,
                sizeof row.movement_type,
                lengths[3]) != 0 ||
            finish_text(
                row.recorded_at,
                sizeof row.recorded_at,
                lengths[5]) != 0) {
            save_error(
                &result.error, "check_history_text", 0, "-----"
            );
            goto cleanup;
        }

        if (row.history_id <= 0 ||
            row.product_id != product_id ||
            row.quantity <= 0 ||
            validate_product_name(row.product_name) != 0 ||
            (strcmp(row.movement_type, "IN") != 0 &&
             strcmp(row.movement_type, "OUT") != 0) ||
            strlen(row.recorded_at) != 19) {
            save_error(
                &result.error, "validate_history_row", 0, "-----"
            );
            goto cleanup;
        }

        /* 検証した一件分を配列へコピーする */
        list.items[i] = row;
    }

    /* 予定した件数の後で、結果の終端も確認する */
    int end_status = mysql_stmt_fetch(stmt);

    if (end_status != MYSQL_NO_DATA) {
        if (end_status == 0 ||
            end_status == MYSQL_DATA_TRUNCATED) {
            save_error(
                &result.error, "check_history_row_count", 0, "-----"
            );
        } else {
            save_statement_error(
                &result.error, stmt, "finish_history_fetch"
            );
        }
        goto cleanup;
    }

    /* 全件の取得を確認してから所有権を渡す */
    *out = list;
    list = (StockHistoryList){0};

    result.status = APP_OK;
    result.connection_reusable = 1;

cleanup:
    if (stmt != NULL) {
        int failed = mysql_stmt_close(stmt) != 0;
        stmt = NULL;

        if (failed) {
            save_connection_error(
                &result.cleanup_error, conn, "mysql_stmt_close"
            );
            result.connection_reusable = 0;
        }
    }

    /* 失敗時に残っている配列も解放する */
    free_stock_history_list(&list);
    return result;
}

履歴取得関数の役割を確認しよう

この関数は、取得した履歴を画面へ表示しません。

担当するのは、次の処理です。

  1. 商品IDをプリペアドステートメントへ設定する。
  2. 履歴を履歴IDの昇順で取得する。
  3. 件数に応じて配列を確保する。
  4. 各行の値を検証する。
  5. 全件取得できた場合だけ、配列を呼び出し元へ渡す。
  6. ステートメントを閉じる。

全件取得後の所有権の受け渡しは、次の部分です。

/* 配列の管理を呼び出し元へ渡す */
*out = list;
list = (StockHistoryList){0};

取得した配列は呼び出し元が解放します。一方、途中で失敗した場合の配列は、この関数内で解放します。

また、DB接続を閉じる処理は含めません。接続の終了は、GUI側のmainが担当します。

GUIでは商品確認から履歴表示へ進む

fetch_stock_historyは、商品そのものの存在を判定する関数ではありません。

そこで、GUIでは先にfind_productで商品を確認します。

順序処理
1選択中の商品IDを保存する
2find_productで商品を確認する
3処理結果と接続の継続利用可否を確認する
4fetch_stock_historyで履歴を取得する
5取得結果から表示部品を作る
6履歴欄を更新して配列を解放する

商品確認と履歴取得は別々の検索です。その間に別の接続から商品が変更される可能性があるため、画面全体を厳密に同じ時点の情報として取得する構成ではありません。

図2:共通の履歴取得関数から画面へ表示する

この図から分かること

GUIは選択した商品IDを共通関数へ渡し、取得できた配列から表示を作ります。

DB関数はデータの取得を担当し、GUIは表示と操作案内を担当します。検索成功で0件だった場合と、取得エラーは分けて扱います。

履歴表示をGUIへ追加しよう

gui/inventory_register.cを、次の内容へ置き換えます。

これまでの商品登録・変更・削除、入庫・出庫を残し、在庫履歴を表示ボタンと履歴欄を追加しています。

商品操作と入出庫に加えて、選択商品の在庫履歴を表示するプログラム

ファイル名: gui/inventory_register.c

#include <gtk/gtk.h>
#include "app_types.h"
#include "db.h"
#include "db_config.h"
#include "product.h"
#include "stock.h"
#include "stock_history.h"
#include "validation.h"
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* 商品一覧の取得と表示の結果を分ける */
typedef struct {
    AppResult db_result;
    int displayed;
} ListRefreshResult;

typedef enum {
    WRITE_REGISTER, WRITE_UPDATE, WRITE_DELETE, WRITE_RECEIVE, WRITE_SHIP
} WriteKind;

typedef struct {
    GtkWindow *window;
    GtkEntry *name_entry, *price_entry, *quantity_entry;
    GtkLabel *name_preview, *price_preview, *quantity_preview;
    GtkButton *register_button, *update_button, *delete_button;
    GtkButton *receive_button, *ship_button, *history_button;
    GtkButton *refresh_button, *clear_button;
    GtkLabel *connection_status, *summary, *selection_status, *input_mode;
    GtkScrolledWindow *list_scroll, *history_scroll;
    GtkListBox *product_list;
    gulong selection_handler_id;
    GtkLabel *history_scope;
    GtkWidget *delete_panel;
    GtkLabel *delete_detail;
    GtkButton *confirm_delete_button, *cancel_delete_button;
    Product delete_target;
    int delete_pending;
    GtkLabel *result_title, *message, *next_action;
    ProductList products;
    int products_loaded, list_stale;
    int selected_product_id, inputs_from_product;
    MYSQL *conn;
    ConnectionError connection_error;
    int db_available, db_failed;
} AppUi;

static void set_database_controls(AppUi *ui);

static const char *action_name(WriteKind kind)
{
    static const char *names[] = {"登録", "変更", "削除", "入庫", "出庫"};
    return names[kind];
}

static const char *action_code(WriteKind kind)
{
    static const char *codes[] = {"REG", "UPD", "DEL", "RCV", "SHP"};
    return codes[kind];
}

static int is_stock_action(WriteKind kind)
{
    return kind == WRITE_RECEIVE || kind == WRITE_SHIP;
}

static GtkLabel *append_label(GtkWidget *box, const char *text)
{
    GtkLabel *label = GTK_LABEL(gtk_label_new(text));

    gtk_label_set_xalign(label, 0.0f);
    gtk_label_set_wrap(label, TRUE);
    gtk_label_set_wrap_mode(label, PANGO_WRAP_WORD_CHAR);
    gtk_widget_set_hexpand(GTK_WIDGET(label), TRUE);
    gtk_box_append(GTK_BOX(box), GTK_WIDGET(label));

    return label;
}

static void show_message(AppUi *ui, const char *title, const char *detail,
                         const char *guide, const char *code)
{
    char *text = g_strdup_printf(
        "次の操作:%s\n確認コード:%s", guide, code
    );

    gtk_label_set_text(ui->result_title, title);
    gtk_label_set_text(ui->message, detail);
    gtk_label_set_text(ui->next_action, text);

    g_free(text);
}

static void record_error(const char *code, const char *kind, AppError error)
{
    if (error.present) {
        g_printerr(
            "%s %s operation=%s mysql_error=%u sqlstate=%s\n",
            code, kind, error.operation,
            error.has_mysql_error ? error.number : 0,
            error.has_mysql_error ? error.sqlstate : "-----"
        );
    }
}

static void record_result(const char *code, AppResult result)
{
    if (result.status != APP_OK || !result.connection_reusable) {
        g_printerr(
            "%s status=%d reusable=%d\n",
            code, (int)result.status, result.connection_reusable
        );
    }

    record_error(code, "main", result.error);
    record_error(code, "rollback", result.rollback_error);
    record_error(code, "cleanup", result.cleanup_error);
}

/* ラベルへ文字列を渡し、元の配列への参照は保存しない */
static void append_table_row(GtkListBox *list, const char *cells[4], int id)
{
    GtkWidget *row = gtk_list_box_row_new();
    GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 12);

    gtk_box_set_homogeneous(GTK_BOX(box), TRUE);

    for (int column = 0; column < 4; ++column) {
        GtkWidget *label = gtk_label_new(cells[column]);

        gtk_label_set_xalign(
            GTK_LABEL(label), column >= 2 ? 1.0f : 0.0f
        );
        gtk_label_set_ellipsize(GTK_LABEL(label), PANGO_ELLIPSIZE_END);
        gtk_widget_set_tooltip_text(label, cells[column]);

        gtk_box_append(GTK_BOX(box), label);
    }

    gtk_list_box_row_set_child(GTK_LIST_BOX_ROW(row), box);
    gtk_list_box_row_set_selectable(GTK_LIST_BOX_ROW(row), id > 0);
    gtk_list_box_row_set_activatable(GTK_LIST_BOX_ROW(row), FALSE);
    g_object_set_data(G_OBJECT(row), "product-id", GINT_TO_POINTER(id));
    gtk_list_box_append(list, row);
}

static GtkWidget *build_product_list(const ProductList *products)
{
    if (products->count > (size_t)INT_MAX - 2) {
        return NULL;
    }

    GtkListBox *list = GTK_LIST_BOX(gtk_list_box_new());

    gtk_list_box_set_selection_mode(list, GTK_SELECTION_SINGLE);
    gtk_list_box_set_show_separators(list, TRUE);

    const char *headers[4] = {"商品ID", "商品名", "単価", "在庫数"};
    append_table_row(list, headers, 0);

    for (size_t i = 0; i < products->count; ++i) {
        const Product *product = &products->items[i];
        char id[32], stock[32];

        snprintf(id, sizeof id, "%d", product->product_id);
        snprintf(stock, sizeof stock, "%d", product->stock);

        const char *cells[4] = {
            id, product->product_name, product->price, stock
        };

        append_table_row(list, cells, product->product_id);
    }

    if (products->count == 0) {
        const char *cells[4] = {"商品がありません。", "", "", ""};
        append_table_row(list, cells, 0);
    }

    return GTK_WIDGET(list);
}

/* 選択変更や一覧更新の際に、前の商品の履歴を外す */
static void clear_history(AppUi *ui)
{
    gtk_label_set_text(
        ui->history_scope,
        "履歴:商品を選択し、在庫履歴を表示ボタンを押してください。"
    );

    gtk_scrolled_window_set_child(
        ui->history_scroll,
        gtk_label_new("履歴は未取得です。")
    );
}

static const Product *find_displayed_product(AppUi *ui, int id)
{
    if (!ui->products_loaded || ui->list_stale || id <= 0) {
        return NULL;
    }

    for (size_t i = 0; i < ui->products.count; ++i) {
        if (ui->products.items[i].product_id == id) {
            return &ui->products.items[i];
        }
    }

    return NULL;
}

static int can_operate_selected_product(AppUi *ui)
{
    return ui->db_available && ui->conn != NULL && !ui->delete_pending &&
           ui->products_loaded && !ui->list_stale && ui->inputs_from_product &&
           ui->selected_product_id > 0;
}

static void update_selection_display(AppUi *ui)
{
    char text[80];

    if (ui->selected_product_id > 0) {
        snprintf(
            text, sizeof text,
            "選択中の商品ID:%d", ui->selected_product_id
        );
    } else {
        snprintf(text, sizeof text, "選択中の商品ID:未選択");
    }

    gtk_label_set_text(ui->selection_status, text);

    const char *mode = !ui->inputs_from_product
        ? "入力状態:新規登録用です。既存商品の操作では一覧から選択してください。"
        : ui->selected_product_id > 0
        ? "入力状態:既存商品の操作用です。商品名・単価は変更ボタンで保存します。"
        : "入力状態:選択解除後の入力を保持しています。再選択またはクリアしてください。";

    gtk_label_set_text(ui->input_mode, mode);
}

static void clear_product_selection(AppUi *ui)
{
    ui->selected_product_id = 0;

    if (ui->product_list != NULL) {
        gtk_list_box_unselect_all(ui->product_list);
    }

    clear_history(ui);
    update_selection_display(ui);
    set_database_controls(ui);
}

static void on_product_selected(GtkListBox *box, GtkListBoxRow *row,
                                 gpointer user_data)
{
    AppUi *ui = user_data;

    if (box != ui->product_list || ui->delete_pending) {
        return;
    }

    clear_history(ui);

    if (row == NULL) {
        ui->selected_product_id = 0;
    } else {
        int id = GPOINTER_TO_INT(
            g_object_get_data(G_OBJECT(row), "product-id")
        );

        const Product *product = find_displayed_product(ui, id);

        if (!ui->db_available || product == NULL) {
            clear_product_selection(ui);
            return;
        }

        ui->selected_product_id = id;
        ui->inputs_from_product = 1;

        gtk_editable_set_text(
            GTK_EDITABLE(ui->name_entry), product->product_name
        );
        gtk_editable_set_text(
            GTK_EDITABLE(ui->price_entry), product->price
        );
        gtk_editable_set_text(GTK_EDITABLE(ui->quantity_entry), "");
    }

    update_selection_display(ui);
    set_database_controls(ui);
}

static void disconnect_product_selection(AppUi *ui)
{
    if (ui->product_list != NULL && ui->selection_handler_id != 0) {
        g_signal_handler_disconnect(
            ui->product_list, ui->selection_handler_id
        );
        ui->selection_handler_id = 0;
    }
}

static void install_product_list(AppUi *ui, GtkWidget *widget)
{
    disconnect_product_selection(ui);
    ui->product_list = NULL;

    gtk_scrolled_window_set_child(ui->list_scroll, widget);

    ui->product_list = GTK_LIST_BOX(widget);
    ui->selection_handler_id = g_signal_connect(
        ui->product_list, "row-selected",
        G_CALLBACK(on_product_selected), ui
    );
}

static void update_summary(AppUi *ui)
{
    char *text = !ui->products_loaded
        ? g_strdup("商品一覧:未取得です。")
        : g_strdup_printf(
            "取得済みの商品:%zu件%s",
            ui->products.count,
            ui->list_stale ? "(再取得が必要です)" : ""
        );

    gtk_label_set_text(ui->summary, text);
    g_free(text);
}

static void set_database_controls(AppUi *ui)
{
    int normal = ui->db_available && !ui->delete_pending;
    int selected = can_operate_selected_product(ui);

    gtk_widget_set_sensitive(GTK_WIDGET(ui->name_entry), normal);
    gtk_widget_set_sensitive(GTK_WIDGET(ui->price_entry), normal);
    gtk_widget_set_sensitive(GTK_WIDGET(ui->quantity_entry), selected);

    gtk_widget_set_sensitive(
        GTK_WIDGET(ui->register_button),
        normal && !ui->inputs_from_product
    );

    GtkButton *targets[] = {
        ui->update_button,
        ui->delete_button,
        ui->receive_button,
        ui->ship_button,
        ui->history_button
    };

    for (size_t i = 0; i < sizeof targets / sizeof targets[0]; ++i) {
        gtk_widget_set_sensitive(GTK_WIDGET(targets[i]), selected);
    }

    gtk_widget_set_sensitive(GTK_WIDGET(ui->refresh_button), normal);
    gtk_widget_set_sensitive(GTK_WIDGET(ui->clear_button), normal);

    if (ui->product_list != NULL) {
        gtk_widget_set_sensitive(
            GTK_WIDGET(ui->product_list),
            normal && ui->products_loaded && !ui->list_stale
        );
    }

    gtk_widget_set_sensitive(
        GTK_WIDGET(ui->confirm_delete_button),
        ui->delete_pending && ui->db_available && ui->conn != NULL
    );

    gtk_widget_set_sensitive(
        GTK_WIDGET(ui->cancel_delete_button),
        ui->delete_pending
    );
}

static void finish_delete_confirmation(AppUi *ui)
{
    ui->delete_pending = 0;
    ui->delete_target = (Product){0};

    gtk_widget_set_visible(ui->delete_panel, FALSE);
    set_database_controls(ui);
}

static void stop_database_actions(AppUi *ui)
{
    ui->db_available = 0;
    ui->db_failed = 1;

    finish_delete_confirmation(ui);
    clear_product_selection(ui);

    gtk_label_set_text(
        ui->connection_status,
        "DB操作:継続利用を停止しました。"
    );
}

static ListRefreshResult refresh_products(AppUi *ui)
{
    ProductList incoming = {0};
    ListRefreshResult refresh = {0};

    ui->list_stale = 1;
    clear_product_selection(ui);

    refresh.db_result = fetch_products(ui->conn, &incoming);

    if (refresh.db_result.status == APP_OK) {
        GtkWidget *widget = build_product_list(&incoming);

        if (widget != NULL) {
            install_product_list(ui, widget);

            free_product_list(&ui->products);
            ui->products = incoming;
            incoming = (ProductList){0};

            ui->products_loaded = 1;
            ui->list_stale = 0;
            refresh.displayed = 1;
        }
    }

    free_product_list(&incoming);
    update_summary(ui);
    set_database_controls(ui);

    return refresh;
}

static int refresh_requires_stop(ListRefreshResult refresh)
{
    return refresh.db_result.status != APP_OK ||
           !refresh.db_result.connection_reusable ||
           !refresh.displayed;
}

static void on_refresh(GtkButton *button, gpointer user_data)
{
    (void)button;
    AppUi *ui = user_data;

    if (!ui->db_available || ui->conn == NULL || ui->delete_pending) {
        return;
    }

    ListRefreshResult refresh = refresh_products(ui);
    int stop = refresh_requires_stop(refresh);

    show_message(
        ui,
        refresh.displayed
            ? "商品一覧を更新しました"
            : "商品一覧を更新できません",
        refresh.displayed
            ? "取得した商品を一覧へ表示しました。"
            : "前回の一覧を最新の情報として使用できません。",
        stop
            ? "アプリを終了し、接続状態と診断情報を確認してください。"
            : "操作対象の商品を一覧から選択してください。",
        stop ? "LIST-STOP" : "LIST-OK"
    );

    record_result("LIST", refresh.db_result);

    if (stop) {
        stop_database_actions(ui);
    }
}

static void on_input_changed(GtkEditable *editable, gpointer user_data)
{
    (void)editable;
    AppUi *ui = user_data;

    const char *name = gtk_editable_get_text(
        GTK_EDITABLE(ui->name_entry)
    );
    const char *price = gtk_editable_get_text(
        GTK_EDITABLE(ui->price_entry)
    );
    const char *quantity = gtk_editable_get_text(
        GTK_EDITABLE(ui->quantity_entry)
    );

    char *name_text = name[0] == '\0'
        ? g_strdup("商品名を入力してください。")
        : validate_product_name(name) == 0
        ? g_strdup_printf(
            "商品名:%ld文字、%zuバイト。入力形式は使用できます。",
            (long)g_utf8_strlen(name, -1),
            strlen(name)
        )
        : g_strdup(
            "商品名は空白だけにせず、制御文字を含めず1〜100文字で入力してください。"
        );

    gtk_label_set_text(ui->name_preview, name_text);
    g_free(name_text);

    gtk_label_set_text(
        ui->price_preview,
        price[0] == '\0'
            ? "単価を入力してください。"
            : validate_price(price) == 0
            ? "単価の入力形式は使用できます。"
            : "単価は整数部1〜8桁、小数部は指定する場合1〜2桁です。"
    );

    int value = 0;
    char text[160];

    if (quantity[0] == '\0') {
        snprintf(
            text, sizeof text,
            "入出庫数量を入力してください。1以上の半角数字を使用します。"
        );
    } else if (parse_int_range(quantity, 1, INT_MAX, &value) == 0) {
        snprintf(
            text, sizeof text,
            "数量:%d個。入力形式は使用できます。",
            value
        );
    } else {
        snprintf(
            text, sizeof text,
            "数量は1〜%dの半角数字で入力してください。",
            INT_MAX
        );
    }

    gtk_label_set_text(ui->quantity_preview, text);
}

static void clear_product_inputs(AppUi *ui)
{
    ui->inputs_from_product = 0;

    gtk_editable_set_text(GTK_EDITABLE(ui->name_entry), "");
    gtk_editable_set_text(GTK_EDITABLE(ui->price_entry), "");
    gtk_editable_set_text(GTK_EDITABLE(ui->quantity_entry), "");

    clear_product_selection(ui);
    gtk_widget_grab_focus(GTK_WIDGET(ui->name_entry));
}

static void on_clear(GtkButton *button, gpointer user_data)
{
    (void)button;
    AppUi *ui = user_data;

    if (ui->db_available && !ui->delete_pending) {
        clear_product_inputs(ui);
    }
}

static int collect_product_input(AppUi *ui, ProductInput *input)
{
    const char *name = gtk_editable_get_text(
        GTK_EDITABLE(ui->name_entry)
    );
    const char *price = gtk_editable_get_text(
        GTK_EDITABLE(ui->price_entry)
    );

    if (validate_product_name(name) != 0 ||
        validate_price(price) != 0 ||
        strlen(name) >= sizeof input->product_name ||
        strlen(price) >= sizeof input->price) {
        show_message(
            ui,
            "商品情報の入力エラー",
            "商品名と単価の入力条件を確認してください。",
            "入力内容を修正し、操作をやり直してください。",
            "INPUT-PRODUCT"
        );
        return 0;
    }

    memcpy(input->product_name, name, strlen(name) + 1);
    memcpy(input->price, price, strlen(price) + 1);

    return 1;
}

/* DBへの確定結果と、その後の一覧更新結果を分ける */
static void handle_write_result(AppUi *ui, WriteKind kind, int id,
                                const char *context, AppResult result)
{
    const char *action = action_name(kind);

    int known = result.status == APP_OK ||
        (kind != WRITE_REGISTER && result.status == APP_NOT_UPDATED) ||
        (kind == WRITE_DELETE && result.status == APP_HISTORY_EXISTS);

    if (!known) {
        int stop = result.status != APP_INVALID_ARGUMENT ||
                   !result.connection_reusable;

        if (stop) {
            ui->list_stale = 1;
        }

        char *title = g_strdup_printf(
            "%s%s",
            action,
            result.status == APP_UNCERTAIN ? "結果不明" : "エラー"
        );

        char *detail = g_strdup_printf(
            "商品ID:%d\n%s\n%s",
            id,
            context,
            result.status == APP_UNCERTAIN
                ? "確定したかどうかを確認できません。同じ操作を繰り返さないでください。"
                : "処理を正常に完了できませんでした。"
        );

        char *code = g_strdup_printf(
            "%s-%s",
            action_code(kind),
            result.status == APP_UNCERTAIN ? "UNCERTAIN" : "ERROR"
        );

        show_message(
            ui, title, detail,
            stop
                ? "アプリを終了し、診断情報とDBの保存状態を確認してください。"
                : "入力条件を確認してください。",
            code
        );

        record_result(code, result);

        g_free(title);
        g_free(detail);
        g_free(code);

        update_summary(ui);

        if (stop) {
            stop_database_actions(ui);
        }
        return;
    }

    ui->list_stale = 1;

    ListRefreshResult refresh = {0};
    int attempted = result.connection_reusable;

    if (attempted) {
        refresh = refresh_products(ui);
    }

    int stop = !attempted || refresh_requires_stop(refresh);
    const char *lead;

    if (result.status == APP_OK) {
        lead = kind == WRITE_RECEIVE
            ? "在庫更新とIN履歴の登録はDBへ確定済みです。"
            : kind == WRITE_SHIP
            ? "在庫更新とOUT履歴の登録はDBへ確定済みです。"
            : "商品への操作はDBへ確定済みです。";
    } else if (result.status == APP_HISTORY_EXISTS) {
        lead = "履歴によって削除が拒否されました。今回は削除していません。";
    } else {
        lead = kind == WRITE_SHIP
            ? "出庫なし:対象が存在しないか、実行時の在庫が不足していた可能性があります。"
            : kind == WRITE_RECEIVE
            ? "入庫なし:対象が存在しないか、在庫の上限を超える可能性があります。"
            : kind == WRITE_DELETE
            ? "削除なし:対象が存在しないか、在庫が0ではない可能性があります。"
            : "変更なし:同じ値だったか、対象が存在しない可能性があります。";
    }

    char *title = g_strdup_printf(
        "%s%s・一覧%s%s",
        action,
        result.status == APP_OK ? "成功" : "なし",
        !attempted
            ? "未更新"
            : refresh.displayed ? "更新完了" : "更新失敗",
        stop ? "・DB操作停止" : ""
    );

    char *detail = g_strdup_printf(
        "%s\n商品ID:%d\n%s", lead, id, context
    );

    char *code = g_strdup_printf(
        "%s%s-%s",
        action_code(kind),
        result.status == APP_OK
            ? ""
            : result.status == APP_HISTORY_EXISTS ? "-HISTORY" : "-NONE",
        !attempted
            ? "STOP"
            : refresh.displayed
            ? stop ? "LIST-STOP" : "LIST-OK"
            : refresh.db_result.status == APP_OK ? "LIST-VIEW" : "LIST-DB"
    );

    int completed = result.status == APP_OK && !stop;

    const char *guide = stop
        ? "同じ操作を繰り返さず、アプリを終了してDBの保存状態を確認してください。"
        : completed && is_stock_action(kind)
        ? "数量をクリアしました。次の操作や履歴確認では商品を選び直してください。"
        : completed && (kind == WRITE_REGISTER || kind == WRITE_DELETE)
        ? "入力欄をクリアしました。次の操作を選んでください。"
        : "入力を保持しています。操作対象を選び直してください。";

    show_message(ui, title, detail, guide, code);
    record_result(code, result);

    if (attempted) {
        record_result("WRITE-LIST", refresh.db_result);
    }

    g_free(title);
    g_free(detail);
    g_free(code);

    update_summary(ui);

    if (stop) {
        stop_database_actions(ui);
    } else if (completed &&
               (kind == WRITE_REGISTER || kind == WRITE_DELETE)) {
        clear_product_inputs(ui);
    } else if (completed && is_stock_action(kind)) {
        gtk_editable_set_text(GTK_EDITABLE(ui->quantity_entry), "");
    }
}

static void perform_product_write(AppUi *ui, WriteKind kind)
{
    if (!ui->db_available || ui->conn == NULL || ui->delete_pending ||
        (kind == WRITE_REGISTER
            ? ui->inputs_from_product
            : !can_operate_selected_product(ui))) {
        return;
    }

    ProductInput input = {0};

    if (!collect_product_input(ui, &input)) {
        return;
    }

    int id = kind == WRITE_REGISTER ? 0 : ui->selected_product_id;

    AppResult result = kind == WRITE_REGISTER
        ? register_product(ui->conn, &input, &id)
        : update_product(ui->conn, id, &input);

    char *context = g_strdup_printf(
        "商品名:%s\n単価:%s",
        input.product_name,
        input.price
    );

    handle_write_result(ui, kind, id, context, result);
    g_free(context);
}

static void on_register(GtkButton *button, gpointer user_data)
{
    (void)button;
    perform_product_write(user_data, WRITE_REGISTER);
}

static void on_update(GtkButton *button, gpointer user_data)
{
    (void)button;
    perform_product_write(user_data, WRITE_UPDATE);
}

static void perform_stock_action(AppUi *ui, WriteKind kind)
{
    if (!can_operate_selected_product(ui)) {
        return;
    }

    int quantity = 0;
    const char *text = gtk_editable_get_text(
        GTK_EDITABLE(ui->quantity_entry)
    );

    if (parse_int_range(text, 1, INT_MAX, &quantity) != 0) {
        char *detail = g_strdup_printf(
            "数量は1〜%dの半角数字で入力してください。",
            INT_MAX
        );

        show_message(
            ui,
            "入出庫数量の入力エラー",
            detail,
            "数量を修正し、操作をやり直してください。",
            "STOCK-INPUT"
        );

        g_free(detail);
        gtk_widget_grab_focus(GTK_WIDGET(ui->quantity_entry));
        return;
    }

    int id = ui->selected_product_id;
    const Product *product = find_displayed_product(ui, id);

    if (product == NULL) {
        ui->list_stale = 1;
        clear_product_selection(ui);
        update_summary(ui);

        show_message(
            ui,
            "選択状態を確認できません",
            "入出庫は実行していません。",
            "商品一覧を更新してください。",
            "STOCK-STATE"
        );
        return;
    }

    /* 一覧再取得で配列が解放される前に、説明用の値をコピーする */
    char *context = g_strdup_printf(
        "商品名(一覧取得時):%s\n%s数量:%d\n履歴種別:%s",
        product->product_name,
        action_name(kind),
        quantity,
        kind == WRITE_RECEIVE ? "IN" : "OUT"
    );

    AppResult result = kind == WRITE_RECEIVE
        ? receive_stock(ui->conn, id, quantity)
        : ship_stock(ui->conn, id, quantity);

    handle_write_result(ui, kind, id, context, result);
    g_free(context);
}

static void on_receive(GtkButton *button, gpointer user_data)
{
    (void)button;
    perform_stock_action(user_data, WRITE_RECEIVE);
}

static void on_ship(GtkButton *button, gpointer user_data)
{
    (void)button;
    perform_stock_action(user_data, WRITE_SHIP);
}

static int delete_check_failed(AppUi *ui, AppResult result)
{
    if (result.status == APP_OK && result.connection_reusable) {
        return 0;
    }

    show_message(
        ui,
        "削除前の確認エラー",
        "削除は実行していません。",
        "アプリを終了し、診断情報と接続状態を確認してください。",
        "DEL-CHECK"
    );

    record_result("DEL-CHECK", result);
    stop_database_actions(ui);

    return 1;
}

static void on_delete(GtkButton *button, gpointer user_data)
{
    (void)button;
    AppUi *ui = user_data;

    if (!can_operate_selected_product(ui)) {
        return;
    }

    Product current = {0};

    AppResult result = find_product(
        ui->conn, ui->selected_product_id, ¤t
    );

    if (result.status == APP_NOT_FOUND) {
        ui->list_stale = 1;
        clear_product_selection(ui);
        update_summary(ui);

        show_message(
            ui,
            "削除対象がありません",
            "削除は実行していません。",
            "商品一覧を更新してください。",
            "DEL-NOT-FOUND"
        );

        record_result("DEL-NOT-FOUND", result);

        if (!result.connection_reusable) {
            stop_database_actions(ui);
        }
        return;
    }

    if (delete_check_failed(ui, result)) {
        return;
    }

    if (current.stock != 0) {
        show_message(
            ui,
            "在庫があるため削除できません",
            "削除対象は在庫数0の商品です。",
            "在庫数を確認してください。",
            "DEL-STOCK"
        );
        return;
    }

    int has_history = -1;

    result = check_product_history(
        ui->conn, current.product_id, &has_history
    );

    if (delete_check_failed(ui, result)) {
        return;
    }

    if (has_history != 0) {
        show_message(
            ui,
            "履歴があるため削除できません",
            "削除は実行していません。",
            "在庫履歴を確認してください。",
            "DEL-HISTORY-CHECK"
        );
        return;
    }

    ui->delete_target = current;
    ui->delete_pending = 1;

    char *detail = g_strdup_printf(
        "商品ID:%d\n商品名:%s\n単価:%s\n"
        "在庫数:%d\n履歴:なし\n削除しますか?",
        current.product_id,
        current.product_name,
        current.price,
        current.stock
    );

    gtk_label_set_text(ui->delete_detail, detail);
    g_free(detail);

    gtk_widget_set_visible(ui->delete_panel, TRUE);
    set_database_controls(ui);
    gtk_widget_grab_focus(GTK_WIDGET(ui->cancel_delete_button));
}

static void on_cancel_delete(GtkButton *button, gpointer user_data)
{
    (void)button;
    AppUi *ui = user_data;

    if (!ui->delete_pending) {
        return;
    }

    finish_delete_confirmation(ui);

    show_message(
        ui,
        "削除を取り消しました",
        "DBへ削除を要求していません。",
        "次の操作を選んでください。",
        "DEL-CANCEL"
    );
}

static void on_confirm_delete(GtkButton *button, gpointer user_data)
{
    (void)button;
    AppUi *ui = user_data;

    if (!ui->delete_pending ||
        !ui->db_available || ui->conn == NULL) {
        return;
    }

    Product target = ui->delete_target;
    finish_delete_confirmation(ui);

    char *context = g_strdup_printf(
        "確認した商品名:%s\n確認した単価:%s",
        target.product_name,
        target.price
    );

    AppResult result = delete_product(ui->conn, target.product_id);

    handle_write_result(
        ui, WRITE_DELETE, target.product_id, context, result
    );

    g_free(context);
}

/* 履歴を、共通関数から受け取った順序で全件表示する */
static GtkWidget *build_history_list(const StockHistoryList *history)
{
    if (history->count > (size_t)INT_MAX - 2) {
        return NULL;
    }

    GtkListBox *list = GTK_LIST_BOX(gtk_list_box_new());

    gtk_list_box_set_selection_mode(list, GTK_SELECTION_NONE);
    gtk_list_box_set_show_separators(list, TRUE);

    const char *headers[4] = {
        "履歴ID", "種別", "数量", "記録日時"
    };

    append_table_row(list, headers, 0);

    for (size_t i = 0; i < history->count; ++i) {
        const StockHistory *row = &history->items[i];
        char id[32], quantity[32];

        snprintf(id, sizeof id, "%d", row->history_id);
        snprintf(quantity, sizeof quantity, "%d", row->quantity);

        const char *cells[4] = {
            id,
            strcmp(row->movement_type, "IN") == 0
                ? "IN(入庫)"
                : "OUT(出庫)",
            quantity,
            row->recorded_at
        };

        append_table_row(list, cells, 0);
    }

    if (history->count == 0) {
        const char *cells[4] = {
            "この商品の入出庫履歴はありません。", "", "", ""
        };
        append_table_row(list, cells, 0);
    }

    return GTK_WIDGET(list);
}

static void history_read_failed(AppUi *ui, AppResult result,
                                 const char *code)
{
    clear_history(ui);

    show_message(
        ui,
        "在庫履歴の取得エラー",
        "履歴を取得できませんでした。0件とは判断できません。",
        "アプリを終了し、診断情報と接続状態を確認してください。",
        code
    );

    record_result(code, result);
    stop_database_actions(ui);
}

/* 入力欄ではなく、選択中の商品IDで履歴を取得する */
static void on_history(GtkButton *button, gpointer user_data)
{
    (void)button;
    AppUi *ui = user_data;

    if (!can_operate_selected_product(ui)) {
        return;
    }

    int id = ui->selected_product_id;
    Product current = {0};
    StockHistoryList incoming = {0};

    clear_history(ui);

    AppResult checked = find_product(ui->conn, id, ¤t);

    if (checked.status == APP_NOT_FOUND) {
        ui->list_stale = 1;
        clear_product_selection(ui);
        update_summary(ui);

        show_message(
            ui,
            "履歴の対象商品がありません",
            "商品が見つからないため、履歴は取得していません。",
            checked.connection_reusable
                ? "商品一覧を更新してください。"
                : "アプリを終了し、接続状態を確認してください。",
            "HST-NOT-FOUND"
        );

        record_result("HST-NOT-FOUND", checked);

        if (!checked.connection_reusable) {
            stop_database_actions(ui);
        }
        return;
    }

    if (checked.status != APP_OK || !checked.connection_reusable) {
        history_read_failed(ui, checked, "HST-CHECK");
        return;
    }

    AppResult fetched = fetch_stock_history(
        ui->conn, id, &incoming
    );

    if (fetched.status != APP_OK) {
        free_stock_history_list(&incoming);
        history_read_failed(ui, fetched, "HST-DB");
        return;
    }

    GtkWidget *list = build_history_list(&incoming);

    if (list == NULL) {
        free_stock_history_list(&incoming);

        show_message(
            ui,
            "在庫履歴の表示エラー",
            "履歴の取得は成功しましたが、表示可能な件数を超えています。",
            "診断情報を確認してください。",
            "HST-VIEW"
        );

        record_result("HST-VIEW", fetched);

        if (!fetched.connection_reusable) {
            stop_database_actions(ui);
        }
        return;
    }

    int stop = !fetched.connection_reusable;

    if (stop) {
        /* 操作停止後も、取得済みの履歴は読み取り用に表示する */
        stop_database_actions(ui);
    }

    gtk_scrolled_window_set_child(ui->history_scroll, list);

    const char *name = incoming.count > 0
        ? incoming.items[0].product_name
        : current.product_name;

    char *scope = g_strdup_printf(
        "履歴対象の商品ID:%d\n"
        "商品名(DB取得時):%s\n"
        "取得した履歴:%zu件(履歴IDの昇順)%s",
        id,
        name,
        incoming.count,
        stop ? "\nDB操作は停止しています。" : ""
    );

    gtk_label_set_text(ui->history_scope, scope);
    g_free(scope);

    show_message(
        ui,
        stop
            ? "在庫履歴を表示・DB操作停止"
            : "在庫履歴を表示しました",
        incoming.count == 0
            ? "検索は成功しました。履歴取得時点で、この商品の記録は0件です。"
            : "取得時点の入出庫記録を表示しました。商品や在庫は変更していません。",
        stop
            ? "アプリを終了し、診断情報を確認してください。"
            : "再取得するときは、在庫履歴を表示ボタンをもう一度押してください。",
        stop ? "HST-OK-STOP" : "HST-OK"
    );

    record_result("HST", fetched);

    /* ラベルへの設定後、取得配列を解放する */
    free_stock_history_list(&incoming);
}

static GtkButton *append_button(GtkWidget *box, const char *text,
                                 GCallback callback, AppUi *ui)
{
    GtkButton *button = GTK_BUTTON(gtk_button_new_with_label(text));

    gtk_box_append(GTK_BOX(box), GTK_WIDGET(button));
    g_signal_connect(button, "clicked", callback, ui);

    return button;
}

static GtkScrolledWindow *append_scroll(GtkWidget *box, int height)
{
    GtkWidget *scroll = gtk_scrolled_window_new();

    gtk_scrolled_window_set_policy(
        GTK_SCROLLED_WINDOW(scroll),
        GTK_POLICY_AUTOMATIC,
        GTK_POLICY_AUTOMATIC
    );

    gtk_scrolled_window_set_has_frame(
        GTK_SCROLLED_WINDOW(scroll), TRUE
    );

    gtk_scrolled_window_set_min_content_height(
        GTK_SCROLLED_WINDOW(scroll), height
    );

    gtk_widget_set_hexpand(scroll, TRUE);
    gtk_widget_set_vexpand(scroll, TRUE);
    gtk_box_append(GTK_BOX(box), scroll);

    return GTK_SCROLLED_WINDOW(scroll);
}

static gboolean on_close_request(GtkWindow *window, gpointer user_data)
{
    (void)window;
    AppUi *ui = user_data;

    ui->delete_pending = 0;
    ui->delete_target = (Product){0};

    disconnect_product_selection(ui);
    ui->product_list = NULL;
    ui->window = NULL;

    return FALSE;
}

static void on_activate(GtkApplication *app, gpointer user_data)
{
    AppUi *ui = user_data;

    if (ui->window != NULL) {
        gtk_window_present(ui->window);
        return;
    }

    ui->window = GTK_WINDOW(gtk_application_window_new(app));

    gtk_window_set_title(
        ui->window,
        "在庫管理アプリ:商品操作・入出庫・履歴表示"
    );

    gtk_window_set_default_size(ui->window, 1200, 1000);

    g_signal_connect(
        ui->window, "close-request",
        G_CALLBACK(on_close_request), ui
    );

    GtkWidget *root = gtk_box_new(GTK_ORIENTATION_VERTICAL, 8);

    gtk_widget_set_margin_top(root, 16);
    gtk_widget_set_margin_bottom(root, 16);
    gtk_widget_set_margin_start(root, 16);
    gtk_widget_set_margin_end(root, 16);

    /* 収まらない場合は、画面全体もスクロールできるようにする */
    GtkWidget *page_scroll = gtk_scrolled_window_new();

    gtk_scrolled_window_set_policy(
        GTK_SCROLLED_WINDOW(page_scroll),
        GTK_POLICY_AUTOMATIC,
        GTK_POLICY_AUTOMATIC
    );

    gtk_window_set_child(ui->window, page_scroll);
    gtk_scrolled_window_set_child(
        GTK_SCROLLED_WINDOW(page_scroll), root
    );

    append_label(
        root, "商品の登録・変更・削除、入出庫と在庫履歴"
    );

    ui->connection_status = append_label(
        root,
        ui->db_available ? "DB接続:成功" : "DB接続:失敗"
    );

    GtkWidget *form = gtk_grid_new();

    gtk_grid_set_row_spacing(GTK_GRID(form), 4);
    gtk_grid_set_column_spacing(GTK_GRID(form), 16);
    gtk_box_append(GTK_BOX(root), form);

    ui->name_entry = GTK_ENTRY(gtk_entry_new());
    ui->price_entry = GTK_ENTRY(gtk_entry_new());
    ui->quantity_entry = GTK_ENTRY(gtk_entry_new());

    gtk_entry_set_max_length(ui->name_entry, 100);

    gtk_entry_set_input_purpose(
        ui->price_entry, GTK_INPUT_PURPOSE_NUMBER
    );
    gtk_entry_set_input_purpose(
        ui->quantity_entry, GTK_INPUT_PURPOSE_DIGITS
    );

    gtk_entry_set_placeholder_text(ui->quantity_entry, "例:2");
    gtk_entry_set_alignment(ui->price_entry, 1.0f);
    gtk_entry_set_alignment(ui->quantity_entry, 1.0f);

    GtkEntry *entries[3] = {
        ui->name_entry, ui->price_entry, ui->quantity_entry
    };

    const char *labels[3] = {
        "商品名", "単価", "入出庫数量"
    };

    GtkLabel **previews[3] = {
        &ui->name_preview,
        &ui->price_preview,
        &ui->quantity_preview
    };

    for (int i = 0; i < 3; ++i) {
        gtk_grid_attach(
            GTK_GRID(form),
            gtk_label_new(labels[i]),
            0, i * 2, 1, 1
        );

        gtk_widget_set_hexpand(GTK_WIDGET(entries[i]), TRUE);

        gtk_grid_attach(
            GTK_GRID(form),
            GTK_WIDGET(entries[i]),
            1, i * 2, 1, 1
        );

        *previews[i] = GTK_LABEL(gtk_label_new(""));

        gtk_label_set_xalign(*previews[i], 0.0f);
        gtk_label_set_wrap(*previews[i], TRUE);

        gtk_grid_attach(
            GTK_GRID(form),
            GTK_WIDGET(*previews[i]),
            1, i * 2 + 1, 1, 1
        );
    }

    ui->input_mode = append_label(root, "");

    GtkWidget *buttons = gtk_box_new(
        GTK_ORIENTATION_HORIZONTAL, 8
    );
    gtk_box_append(GTK_BOX(root), buttons);

    ui->register_button = append_button(
        buttons, "商品を登録", G_CALLBACK(on_register), ui
    );
    ui->update_button = append_button(
        buttons, "商品を変更", G_CALLBACK(on_update), ui
    );
    ui->delete_button = append_button(
        buttons, "商品を削除", G_CALLBACK(on_delete), ui
    );
    ui->receive_button = append_button(
        buttons, "入庫", G_CALLBACK(on_receive), ui
    );
    ui->ship_button = append_button(
        buttons, "出庫", G_CALLBACK(on_ship), ui
    );
    ui->history_button = append_button(
        buttons, "在庫履歴を表示", G_CALLBACK(on_history), ui
    );
    ui->refresh_button = append_button(
        buttons, "一覧を更新", G_CALLBACK(on_refresh), ui
    );
    ui->clear_button = append_button(
        buttons, "入力欄をクリア", G_CALLBACK(on_clear), ui
    );

    ui->delete_panel = gtk_frame_new("削除の確認");

    GtkWidget *delete_box = gtk_box_new(
        GTK_ORIENTATION_VERTICAL, 8
    );

    gtk_frame_set_child(GTK_FRAME(ui->delete_panel), delete_box);
    ui->delete_detail = append_label(delete_box, "");

    GtkWidget *delete_buttons = gtk_box_new(
        GTK_ORIENTATION_HORIZONTAL, 8
    );

    gtk_box_append(GTK_BOX(delete_box), delete_buttons);

    ui->cancel_delete_button = append_button(
        delete_buttons,
        "取り消す",
        G_CALLBACK(on_cancel_delete),
        ui
    );

    ui->confirm_delete_button = append_button(
        delete_buttons,
        "削除を実行",
        G_CALLBACK(on_confirm_delete),
        ui
    );

    gtk_widget_add_css_class(
        GTK_WIDGET(ui->confirm_delete_button),
        "destructive-action"
    );

    gtk_box_append(GTK_BOX(root), ui->delete_panel);
    gtk_widget_set_visible(ui->delete_panel, FALSE);

    ui->summary = append_label(root, "");
    ui->selection_status = append_label(root, "");
    ui->list_scroll = append_scroll(root, 140);

    ProductList empty = {0};
    install_product_list(ui, build_product_list(&empty));

    ui->history_scope = append_label(root, "");
    gtk_label_set_selectable(ui->history_scope, TRUE);

    ui->history_scroll = append_scroll(root, 140);
    clear_history(ui);

    ui->result_title = append_label(root, "操作結果");
    ui->message = append_label(root, "");
    ui->next_action = append_label(root, "");

    gtk_label_set_selectable(ui->message, TRUE);
    gtk_label_set_selectable(ui->next_action, TRUE);

    for (int i = 0; i < 3; ++i) {
        g_signal_connect(
            entries[i], "changed",
            G_CALLBACK(on_input_changed), ui
        );
    }

    on_input_changed(NULL, ui);
    update_selection_display(ui);
    update_summary(ui);
    set_database_controls(ui);

    if (ui->db_available) {
        on_refresh(NULL, ui);
    } else {
        show_message(
            ui,
            "DB接続エラー",
            ui->connection_error.user_message,
            "アプリを終了し、接続設定とサーバーの状態を確認してください。",
            ui->connection_error.display_code
        );
    }

    gtk_window_present(ui->window);
}

int main(int argc, char *argv[])
{
    int check_only = argc == 2 &&
                     strcmp(argv[1], "--check-config") == 0;

    if (!check_only && argc != 1) {
        fputs(
            "使い方:inventory_register.exe [--check-config]\n",
            stderr
        );
        return EXIT_FAILURE;
    }

    DbConfigStorage storage = {0};
    char reason[512] = {0};

    if (load_db_config(
            "inventory.conf",
            &storage,
            reason,
            sizeof reason) != 0) {
        fprintf(
            stderr,
            "接続設定を読み込めませんでした。\n%s\n",
            reason
        );
        return EXIT_FAILURE;
    }

    if (check_only) {
        puts("設定の検証が完了しました。MySQLへは接続していません。");
        return EXIT_SUCCESS;
    }

    DbConfig config = {
        .host = storage.host,
        .port = storage.port,
        .database = storage.database,
        .user = storage.user
    };

    AppUi ui = {0};

    ui.conn = connect_database(
        &config,
        getenv("INVENTORY_DB_PASSWORD"),
        &ui.connection_error
    );

    ui.db_available = ui.conn != NULL;
    ui.db_failed = !ui.db_available;

    if (!ui.db_available) {
        g_printerr(
            "接続失敗 code=%s stage=%s mysql_error=%u sqlstate=%s\n",
            ui.connection_error.display_code,
            ui.connection_error.stage,
            ui.connection_error.number,
            ui.connection_error.sqlstate
        );
    }

    GtkApplication *app = gtk_application_new(
        "org.example.InventoryRegister",
        G_APPLICATION_DEFAULT_FLAGS
    );

    g_signal_connect(
        app, "activate", G_CALLBACK(on_activate), &ui
    );

    int status = g_application_run(
        G_APPLICATION(app), argc, argv
    );

    free_product_list(&ui.products);

    if (ui.conn != NULL) {
        mysql_close(ui.conn);
    }

    g_object_unref(app);

    return ui.db_failed ? EXIT_FAILURE : status;
}

選択中の商品IDで取得する

履歴取得の中心はon_historyです。

最初に、商品を選択して操作できる状態かを確認します。

/* 商品未選択時やDB操作停止中は、取得へ進まない */
if (!can_operate_selected_product(ui)) {
    return;
}

次に、選択中の商品IDを保存します。

/* 履歴の対象は、選択中の商品IDで決める */
int id = ui->selected_product_id;
Product current = {0};
StockHistoryList incoming = {0};

履歴表示では、商品名、単価、数量の入力欄を検索条件に使用しません。

情報履歴表示での扱い
選択中の商品ID検索条件に使用する
編集中の商品名保存も検索条件への使用も行わない
編集中の単価保存も検索条件への使用も行わない
入出庫数量入力を要求しない

商品名や単価を編集中でも、履歴表示によって変更が保存されることはありません。

成功と接続状態を確認してから次の関数を呼ぶ

商品確認後は、APP_OKだけでなく、connection_reusableも確認します。

/* 次のDB処理へ進めるか確認する */
if (checked.status != APP_OK || !checked.connection_reusable) {
    history_read_failed(ui, checked, "HST-CHECK");
    return;
}

この確認を通過してから、履歴を取得します。

/* 共通の取得関数を呼ぶ */
AppResult fetched = fetch_stock_history(
    ui->conn, id, &incoming
);

履歴を全件取得できても、ステートメント終了時の問題により、接続を続けて使えない場合があります。

その場合は、取得済みの履歴を表示し、以後のDB操作を停止します。

状態GUIの動き
取得成功、接続利用可能履歴を表示し、操作を続けられる
取得成功、接続利用不可履歴を表示し、DB操作を停止する
取得失敗取得エラーを表示し、DB操作を停止する

取得した履歴を全件表示する

build_history_listでは、配列を先頭から順に読み取ります。

/* 共通関数から受け取った順番で表示する */
for (size_t i = 0; i < history->count; ++i) {
    const StockHistory *row = &history->items[i];
    char id[32], quantity[32];

    snprintf(id, sizeof id, "%d", row->history_id);
    snprintf(quantity, sizeof quantity, "%d", row->quantity);

    const char *cells[4] = {
        id,
        strcmp(row->movement_type, "IN") == 0
            ? "IN(入庫)"
            : "OUT(出庫)",
        quantity,
        row->recorded_at
    };

    append_table_row(list, cells, 0);
}

共通関数が返す種別は、検証済みのINまたはOUTです。画面では日本語の補足を加えています。

履歴IDは昇順ですが、欠番があっても問題ありません。また、複数の接続で処理した場合、履歴IDの順序が厳密な確定順を表すとは限りません。

履歴0件とエラーを区別する

0件の案内を表示するのは、取得結果がAPP_OKだった場合だけです。

/* 検索に成功し、該当記録がなかった場合の表示 */
if (history->count == 0) {
    const char *cells[4] = {
        "この商品の入出庫履歴はありません。", "", "", ""
    };
    append_table_row(list, cells, 0);
}

在庫数0と履歴0件も、別の状態です。

以前に入庫と出庫を行い、現在の在庫が0になっている商品には、入出庫履歴が残っています。在庫数だけを見て履歴の有無を決めないようにしましょう。

別の商品を選択したら履歴を消す

商品ID 23の履歴を表示したまま商品ID 24を選択すると、履歴の対象を読み違える原因になります。

そのため、商品選択の変更時にclear_historyを呼び出します。

/* 前の商品の履歴を外す */
clear_history(ui);

履歴欄の中身は、gtk_scrolled_window_set_childで置き換えています。GtkScrolledWindowは、設定した子ウィジェットをスクロール領域へ表示します。

操作履歴欄の状態
別の商品を選択する未取得へ戻す
商品一覧を更新する未取得へ戻す
入力欄をクリアする未取得へ戻す
入出庫後に一覧を更新する古い履歴を消す
履歴表示ボタンを再度押す同じ商品の履歴を再取得する

今回は履歴を自動更新しません。入出庫後は商品を選び直してから、在庫履歴を表示ボタンを押してください。

表示ができたら履歴配列を解放する

各セルのラベルへ文字列を設定した後は、取得配列を解放します。

/* 取得した配列は、表示部品の作成と設定が終わったら解放する */
free_stock_history_list(&incoming);

ラベルは表示文字列を保持するため、履歴配列を解放した後も表示を続けられます。

配列の要素へのポインターを、後から動くコールバックへ保存する処理は追加していません。

データ管理する担当解放時点
商品一覧のProductListAppUi一覧置き換え時、アプリ終了時
履歴のStockHistoryListon_history表示部品への設定後
一時的な表示文字列作成した処理ラベルへの設定後

また、表示更新にはgtk_label_set_textを使用しています。この関数は既存の文字列を置き換え、マークアップの解釈を無効にします。商品名を文字列として表示できます。

ファイルの配置を確認しよう

ビルド前に、必要なファイルが存在することを確認します。

MSYS2 UCRT64で実行してください。

cd /c/c-mysql/chap15
ls include/app_types.h include/stock_history.h src/stock/stock_history_list.c gui/inventory_register.c

配置確認の実行結果の例

次の四つのパスが表示されます。表示順や改行位置は端末によって異なります。

include/app_types.h
include/stock_history.h
src/stock/stock_history_list.c
gui/inventory_register.c

stock_history.hが見つからない場合は、次の場所へ保存したか確認してください。

C:\c-mysql\chap15\include\stock_history.h

ファイル名の末尾に.txtが付いていないことも確認しましょう。

UCRT64でビルドして起動しよう

次のコマンドでビルドします。

gcc -std=c17 -Wall -Wextra -Wpedantic \
  -Iinclude gui/inventory_register.c \
  src/db/db.c src/db/db_config.c \
  src/product/product.c src/product/product_list.c \
  src/product/product_find.c src/product/product_update.c \
  src/product/product_delete.c \
  src/stock/stock_receive.c src/stock/stock_ship.c \
  src/stock/stock_history.c src/stock/stock_history_list.c \
  src/common/validation.c \
  -o inventory_register.exe \
  $(pkg-config --cflags --libs gtk4 mysqlclient)

-Iincludeは、ヘッダーを探す場所へ、現在のフォルダー内のincludeを追加する指定です。

src/stock/stock_history_list.cも指定して、履歴取得関数の本体をリンクします。

エラーの例主に確認すること
stock_history.hが見つからない保存場所、ファイル名、作業フォルダー、-Iinclude
StockHistoryListが未定義include/app_types.hに履歴用の型があるか
fetch_stock_historyの参照を解決できないsrc/stock/stock_history_list.cをビルドへ含めたか

ビルドできたら、起動します。

bash run_gui_register.sh

実行結果の例

ここでは、15.4で商品ID 30を削除し、その後は商品を追加・削除していない状態を例にします。

最初に共有いただいた商品数は22件でした。そこから商品ID 30を削除していれば、取得件数は21件です。

取得済みの商品:21件

商品ID 30を削除していない環境では22件になります。件数は固定値ではなく、DBから実際に取得した値を表示します。

商品ID 23の履歴を表示する

商品一覧から、次の商品を選択します。

商品ID商品名単価在庫数
23入庫確認ノートA5190.506

在庫履歴を表示ボタンを押すと、履歴欄の上に対象の商品ID、商品名、実際の取得件数が表示されます。

履歴一覧には、保存されているその商品の全記録が表示されます。

次の表は、15.5と15.6で増えた二つの記録に注目した確認例です。

対応する操作種別数量
15.5で成功した3個の入庫IN(入庫)3
15.6で成功した2個の出庫OUT(出庫)2

画面には、各記録の履歴IDと記録日時も表示されます。それらの値と履歴の総件数は、実際のDBの内容で確認してください。

メッセージ欄には、次のように表示されます。

在庫履歴を表示しました

取得時点の入出庫記録を表示しました。
商品や在庫は変更していません。

次の操作:再取得するときは、在庫履歴を表示ボタンをもう一度押してください。
確認コード:HST-OK

履歴表示だけでは、商品数も在庫数6個も変わりません。

履歴が0件の場合

履歴のない商品では、履歴欄に次の案内が表示されます。

この商品の入出庫履歴はありません。

メッセージ欄には、正常に検索できたことを表示します。

在庫履歴を表示しました

検索は成功しました。
履歴取得時点で、この商品の記録は0件です。

次の操作:再取得するときは、在庫履歴を表示ボタンをもう一度押してください。
確認コード:HST-OK

どの商品に履歴がないかは、実際のstock_historyで確認してください。

取得エラーの場合

履歴取得に失敗した場合は、次の表示になります。

在庫履歴の取得エラー

履歴を取得できませんでした。0件とは判断できません。

次の操作:アプリを終了し、診断情報と接続状態を確認してください。
確認コード:HST-DB

接続状態の表示も変わります。

DB操作:継続利用を停止しました。

取得エラーを、履歴なしとして表示していないことを確認しましょう。

図3:商品を切り替えたら履歴も取得し直す

この図から分かること

商品を切り替えた直後は、前の商品の履歴を表示し続けません。

履歴欄を未取得へ戻し、新しい対象の履歴を表示ボタンで取得します。

SQLの結果と画面を照合しよう

MySQLでも、商品ID 23の記録を確認できます。

SELECT
    h.history_id,
    h.product_id,
    p.product_name,
    h.movement_type,
    h.quantity,
    h.recorded_at
FROM stock_history AS h
INNER JOIN products AS p
    ON p.product_id = h.product_id
WHERE h.product_id = 23
ORDER BY h.history_id ASC;

実行結果の例

+------------+------------+-------------------------+---------------+----------+---------------------+
| history_id | product_id | product_name            | movement_type | quantity | recorded_at         |
+------------+------------+-------------------------+---------------+----------+---------------------+
|         17 |         23 | 入庫確認ノートA4        | IN            |        5 | 2026-10-28 01:46:58 |
|         18 |         23 | 入庫確認ノートA4        | IN            |        3 | 2026-10-28 02:10:13 |
|         19 |         23 | 入庫確認ノートA4        | OUT           |        3 | 2026-10-29 00:29:07 |
|         20 |         23 | 入庫確認ノートA4        | OUT           |        5 | 2026-10-29 00:35:26 |
|         21 |         23 | 入庫確認ノートA4        | IN            |        4 | 2026-10-29 01:28:05 |
|         22 |         23 | 入庫確認ノートA4        | OUT           |        2 | 2026-10-29 01:28:56 |
|         23 |         23 | 入庫確認ノートA4        | IN            |        1 | 2026-10-29 22:42:16 |
|         25 |         23 | 入庫確認ノートA4        | IN            |        2 | 2026-10-30 01:24:53 |
|         28 |         23 | 入庫確認ノートA4        | IN            |        3 | 2026-11-03 17:17:43 |
|         29 |         23 | 入庫確認ノートA4        | OUT           |        2 | 2026-11-03 21:34:26 |
+------------+------------+-------------------------+---------------+----------+---------------------+
10 rows in set (0.00 sec)

確認するポイントは、次のとおりです。

  • SQLとGUIの取得件数が一致する。
  • 履歴IDの並びが一致する。
  • INとOUTの種類が一致する。
  • 数量と記録日時が一致する。
  • 履歴を表示するだけでは、記録が追加されない。

別の接続で入出庫が行われた場合は、確認する時点によって内容が変わります。その場合はGUIでも履歴を再取得してください。

操作を変えて確認しよう

確認する操作期待する動き
商品を選択していない在庫履歴を表示ボタンが無効になる
商品ID 23を選択して表示する商品ID 23の履歴が表示される
同じ商品の履歴を再度表示する表示が置き換わり、行が重複しない
別の商品を選択する前の履歴が消える
商品名だけを編集中に表示する選択中の商品IDで取得し、編集内容は保存しない
数量が空欄のまま表示する数量入力を要求せず履歴を取得する
商品一覧を更新する選択と履歴表示が初期化される
入出庫を成功させる商品を選び直して、新しい履歴を確認できる
履歴がない商品を表示する検索成功として0件を案内する
取得エラーが発生する0件と表示せず、DB操作を停止する

今回のプログラムは、履歴を全件取得し、GUIの処理と同じスレッドで表示を作ります。通信や大量の履歴取得に時間がかかる場合は、その間、画面の応答も待ちになります。

まずは現在のデータで、対象商品の選択、履歴表示、再取得、商品の切り替えを確認してください。次の記事では、操作前の確認画面と操作後のメッセージを整えていきます。

Follow me!