display.c

db.* (pronounced dee-be star) is an advanced, high performance, small footprint embedded database fo

    numfiles = GetNumFiles();
    strcpy(taffile, GetUserTAF(user));
    strcpy(logfile, GetUserLogFile(user));

    for (num_files_open = 0, file = 0; file < numfiles; file++)
    {
        if (UserHasOpen(user, file))
            files_open[num_files_open++] = (short) file;
    }

    if (scroll == -1)
    {
        top = 0;
        taf_left = 0;
        log_left = 0;
    }
    else
    {
        switch (scroll)
        {
            case keyPgDn :
                top += CMD_LINE - 9;
                if (top > (short) (num_files_open - CMD_LINE + 9))
                    top = num_files_open - CMD_LINE + 9;
                break;

            case keyPgUp :
                top -= CMD_LINE - 9;
                if (top < 0)
                    top = 0;
                break;

            case keyLeft :
                taf_left -= 16;
                if (taf_left < 0)
                    taf_left = 0;

                log_left -= 16;
                if (log_left < 0)
                    log_left = 0;
                break;

            case keyRight :
                if (strlen(taffile) > 35)
                {
                    taf_left += 16;
                    if (taf_left > (short) (strlen(taffile) - 35))
                        taf_left = (short) (strlen(taffile) - 35);
                }

                if (strlen(logfile) > 35)
                {
                    log_left += 16;
                    if (log_left > (short) (strlen(logfile) - 35))
                        log_left = (short) (strlen(logfile) - 35);
                }
                break;

            case keyEnd :
                top = num_files_open - CMD_LINE + 9;
                if (top < 0)
                    top = 0;
                break;

            case keyHome:
                top = 0;
                break;
        }

        if (  (scroll > 0) && (top == prev_top) && (taf_left == prev_taf) &&
                (log_left == prev_log))
        {
            return;
        }
    }

    str_test(US_NAME_XY, user_data->name,        GetUserId(user),        clear, 16);
    str_test(US_TAF_XY,  user_data->taffile,     taffile + taf_left,     clear, 35);
    int_test(US_TOUT_XY, &user_data->timeout,    GetUserTimeOut(user),   clear);
    int_test(US_TIME_XY, &user_data->timer,      GetUserTimer(user),     clear);
    str_test(US_STAT_XY, user_data->status,      GetUserStatus(user),    clear, 8);
    str_test(US_REC_XY,  user_data->recover,     GetUserRecover(user),   clear, 3);
    str_test(US_LOG_XY,  user_data->logfile,     logfile + log_left,     clear, 35);
    spc_test(US_LOCK_XY, &user_data->numlocks,   UserNumLock(user),      clear);
    spc_test(US_PEND_XY, &user_data->numreq,     UserNumReq(user),       clear);
    spc_test(US_OPEN_XY, &user_data->numopen,    UserNumOpen(user),      clear);

    for (row = US_TOP, i = top; i < num_files_open && row < CMD_LINE; i++, row++)
    {
        file = files_open[i];

        clear = user_data->lines[row - US_TOP].clr | user_data->clr;

        temp_c = GetLockStat(file);

        if (!UserHasLock(user, file) || (temp_c == 'f'))
            temp_c = ' ';

        char_test(row, 1, &user_data->lines[row - US_TOP].lock, temp_c, clear);
        char_test(row, 11, &user_data->lines[row - US_TOP].req,
            UserWaitingLock(user, file), clear);

        sprintf(temp_s, "(%d) %-36s", file, GetFileName(file, FALSE));
        str_test(row, 20, user_data->lines[row - US_TOP].name, temp_s,
            clear, 45);

        user_data->lines[row - US_TOP].clr = FALSE;
    }

    while (row < (unsigned short)(CMD_LINE - 1))
    {
        clear_line(row, &user_data->lines[row - US_TOP].clr);
        row++;
    }

    user_data->clr = FALSE;

    locate_to_cmnd_line();
}

/**************************************************************************/

static void user_status(short scroll)
{
    unsigned short user;
    unsigned short num_users = GetNumUsers();

    report_func = user_status;

    top_line = US_TOP;
    for (user = 0; user < num_users; user++)
    {
        if (strcmp(user_to_view, GetUserId(user)) == 0)
            break;
    }

    if (user == num_users)
    {
        general_status(0);
        return;
    }

    get_user_info(user);
    print_us_outline();
    print_us_data(scroll, user);
}

/**************************************************************************/

static void print_fs_outline()
{
    if (curr_outline != FILE_STATUS)
    {
        vioClear();
        vioPrint(0, 5, "File Name:");
        vioPrint(2, 0, "Lock(0)__Pend(0)___Open(0)___________________________________________________");

        curr_outline = FILE_STATUS;
        file_data->clr = TRUE;
    }
}

/**************************************************************************/

static void print_fs_data(short scroll, unsigned short file)
{
    static short top = 0, nm_left = 0;
    short prev_top = top, prev_nm = nm_left;
    char name[FILENMLEN];
    char temp_c;
    unsigned short i, user, numusers = GetNumUsers();
    unsigned short num_users_open, row;
    int clear = file_data->clr;

    for (num_users_open = 0, user = 0; user < numusers; user++)
    {
        if (FileOpenByUser(file, user))
            users_open[num_users_open++] = (short) user;
    }

    strcpy(name, GetFileName(file, TRUE));

    if (scroll == -1)
    {
        top = 0;
        nm_left = 0;
    }
    else
    {
        switch (scroll)
        {
            case keyPgDn :
                top += CMD_LINE - 3;
                if (top > (short) (num_users_open - CMD_LINE + 3))
                    top = num_users_open - CMD_LINE + 3;
                break;

            case keyPgUp :
                top -= CMD_LINE - 3;
                if (top < 0)
                    top = 0;
                break;

            case keyLeft :
                nm_left -= 30;
                if (nm_left < 0)
                    nm_left = 0;
                break;

            case keyRight :
                if (strlen(name) > 60)
                {
                    nm_left += 30;
                    if (nm_left > (short) (strlen(name) - 60))
                        nm_left = (short) (strlen(name) - 60);
                }
                break;

            case keyEnd :
                top = num_users_open - CMD_LINE + 3;
                if (top < 0)
                    top = 0;
                break;

            case keyHome:
                top = 0;
                break;
        }

        if ((scroll > 0) && (top == prev_top) && (nm_left == prev_nm))
            return;
    }

    str_test(FS_NAME_XY, file_data->name,     name + nm_left,      clear, 60);
    spc_test(FS_OPEN_XY, &file_data->numopen, FileNumOpen(file),   clear);
    spc_test(FS_LOCK_XY, &file_data->numlock, FileNumLock(file),   clear);
    spc_test(FS_REQ_XY,  &file_data->numreq,  FileNumReq(file),    clear);

    for ( row = FS_TOP, i = top;
          (i < num_users_open) && (row < CMD_LINE);
          i++, row++)
    {
        user = users_open[i];

        clear = file_data->lines[row - FS_TOP].clr | file_data->clr;

        if (FileLockedByUser(file, user))
            temp_c = GetLockStat(file);
        else
            temp_c = ' ';

        char_test(row, 1, &file_data->lines[row - FS_TOP].lock, temp_c, clear);
        char_test(row, 11, &file_data->lines[row - FS_TOP].req,
            FileRequestedByUser(file, user), clear);
        str_test(row, 19, file_data->lines[row - FS_TOP].name,
            GetUserId(user), clear, 16);

        file_data->lines[row - FS_TOP].clr = FALSE;
    }

    while (row < (unsigned short)(CMD_LINE - 1))
    {
        clear_line(row, &file_data->lines[row - FS_TOP].clr);
        row++;
    }

    file_data->clr = FALSE;

    locate_to_cmnd_line();
}

/**************************************************************************/

static void file_status(short scroll)
{
    unsigned short numfiles = GetNumFiles();

    report_func = file_status;

    top_line = FS_TOP;
    if (file_to_view >= numfiles)
    {
        general_status(0);
        return;
    }

    get_file_info(file_to_view);
    print_fs_outline();
    print_fs_data(scroll, file_to_view);
}

/**************************************************************************/

static void help_func(short scroll)
{
    return;
}

/**************************************************************************/

static void show_help()
{
    register unsigned short row;
    static char *help_lines[] =
    {
        "FILE <num>     View more information on file <num>.", 
        "FILES          Display the open file list, lock status and locking user.",
        "KILL <name>    Remove a user from the Lock Manager.",
        "REFRESH <num>  Change the refresh delay to <num> seconds.  (default 2)",
        "SHUTDOWN       Shut down the Lock Manager and exit.",
        "STATUS         Display the Lock Manager general status report.",
        "USER <name>    View more information on a user.",
        "USERS          Display report on users and transaction logfiles.",
        "QUIT/EXIT      Exit the remote console program.",
        "HELP           Display this list.",
        ""
    };

    temp_func = report_func;
    report_func = help_func;

#if defined(SOLARIS) || defined(ISOLARIS) || defined(UNIXWARE)
    vioPrint((short) (top_line - 2), 0,
#else  
    vioPrint((short) (top_line - 1), 0,
#endif 
        "Lock Manager Commands ______________________________________________");

    for (row = top_line; help_lines[row - top_line][0]; row++)
    {
        vioClearLine(row);
        vioPrint(row, 2, help_lines[row - top_line]);
    }

    while (row <= (unsigned short)(CMD_LINE + 1))
        vioClearLine(row++);

    vioPrint((short) (CMD_LINE + 1), 0, "Press any key to continue...            ");
    vioLocate((short) (CMD_LINE + 1), 28);

    return;
}

/**************************************************************************/

static void locate_to_cmnd_line()
{
    vioLocate(CMD_LINE, (short) (9 + strlen(command)));
}

/**************************************************************************/

static void print_command_line()
{
    vioClearLine((short) (CMD_LINE + 1));
    vioPrint(CMD_LINE, 0, "Command [....................]");
    vioPrint(CMD_LINE, 9, command);
}

/**************************************************************************/

void console()
{
    while (get_command() != CMD_QUIT);
}

/**************************************************************************/

int get_display_memory()
{
    user_line = (USERLINE *) psp_cGetMemory((CMD_LINE - UR_TOP) * sizeof(USERLINE), 0);
    if (!user_line) goto cleanup;

    file_line = (FILELINE *) psp_cGetMemory((CMD_LINE - FR_TOP) * sizeof(FILELINE), 0);
    if (!file_line) goto cleanup;

    general = (GENSCREEN *) psp_cGetMemory(sizeof(GENSCREEN), 0);
    if (!general) goto cleanup;

    general->lines = (GENLINE *) psp_cGetMemory((CMD_LINE - G_TOP) * sizeof(GENLINE), 0);
    if (!general->lines) goto cleanup;

    user_data = (USERDATASCREEN *) psp_cGetMemory(sizeof(USERDATASCREEN), 0);
    if (!user_data) goto cleanup;

    user_data->lines = (USERDATALINE *) psp_cGetMemory((CMD_LINE - US_TOP) * sizeof(USERDATALINE), 0);
    if (!user_data->lines) goto cleanup;

    file_data = (FILEDATASCREEN *) psp_cGetMemory(sizeof(FILEDATASCREEN), 0);
    if (!file_data) goto cleanup;

    file_data->lines = (FILEDATALINE *) psp_cGetMemory((CMD_LINE - FS_TOP) * sizeof(FILEDATALINE), 0);
    if (!file_data->lines) goto cleanup;

    files_open = (short *) psp_cGetMemory(512 * sizeof(short), 0);
    if (!files_open) goto cleanup;

    users_open = (short *) psp_cGetMemory(512 * sizeof(short), 0);
    if (!users_open) goto cleanup;

    return S_OKAY;

cleanup:
    free_display_memory();
    return S_NOMEMORY;
}

/**************************************************************************/

void free_display_memory()
{
    if (user_line)
    {
        psp_freeMemory(user_line, 0);
        user_line = NULL;
    }
    if (file_line)
    {
        psp_freeMemory(file_line, 0);
        file_line = NULL;
    }
    if (general)
    {
        if (general->lines)
            psp_freeMemory(general->lines, 0);
        psp_freeMemory(general, 0);
        general = NULL;
    }
    if (user_data)
    {
        if (user_data->lines)
            psp_freeMemory(user_data->lines, 0);
        psp_freeMemory(user_data, 0);
        user_data = NULL;
    }
    if (file_data)
    {
        if (file_data->lines)
            psp_freeMemory(file_data->lines, 0);
        psp_freeMemory(file_data, 0);
        file_data = NULL;
    }
    if (files_open)
    {
        psp_freeMemory(files_open, 0);
        files_open = NULL;
    }
    if (users_open)
    {
        psp_freeMemory(users_open, 0);
        users_open = NULL;
    }
}

/**************************************************************************/

void repaint(int sig)
{
    if (report_func)
    {
        (*report_func)(0);
        print_command_line();
    }

#ifdef HAVE_ALARM
    /* reinstall signal handler */
    signal(SIGALRM, repaint);
    alarm(refresh_secs);
#endif
}

/**************************************************************************/

void vioInit()
{
    if (!vio_ok)
    {
        ioc_on();
        vioClear();
        vioLocate(0, 0);
        vio_ok = 1;
    }
}

void vioTerm()
{
    if (vio_ok)
    {
        vioClear();
        ioc_off();
        vio_ok = 0;
    }
}

static void vioPrint(int x, int y, char *string)
{
    tprintf("@M%s", &x, &y, string);
}

static void vioPutChar(short c)
{
    putchar(c);
}

static void vioLocate(int x, int y)
{
    tprintf("@M", &x, &y);
}

static void vioClear()
{
    tprintf("@m0000@E");
}

static void vioClearLine(int row)
{
    int col_zero = 0;
    tprintf("@M@e", &row, &col_zero);
}