/** \file   uistatusbar.c
 *  \brief  Native GTK3 UI statusbar stuff
 *
 *  The status bar widget is part of every machine window. This widget
 *  reacts to UI notifications from the emulation core and otherwise
 *  does not interact with the rest of the main menu.
 *
 *  Functions described as "Statusbar API functions" are called by the
 *  rest of the UI or the emulation system itself to report that the
 *  status displays must be updated to reflect possibly new
 *  information. It is not necessary for the data to be truly new; the
 *  statusbar implementation will treat repeated reports of the same
 *  state as no-ops when necessary for performance.
 *
 *  \author Marco van den Heuvel <blackystardust68@yahoo.com>
 *  \author Michael C. Martin <mcmartin@gmail.com>
 *  \author Bas Wassink <b.wassink@ziggo.nl>
 *  \author David Hogan <david.q.hogan@gmail.com>
 */

/*
 * Resources controlled by this widget. We probably need to expand this list.
 * (Do not add resources controlled by widgets #include'd by this widget, only
 *  add resources actually controlled from this widget)
 *
 * $VICERES SoundVolume         all
 * $VICERES C128ColumnKey       x128
 * $VICERES CrtcShowStatusbar   xcbm2 xpet
 * $VICERES TEDShowStatusbar    xplus4
 * $VICERES VDCShowStatusbar    x128
 * $VICERES VICShowStatusbar    xvic
 * $VICERES VICIIShowStatusbar  x64 x64sc x64dtv xscpu64 x128 xcbm5x0
 * $VICERES DiagPin             xpet
 * $VICERES SpeedSwitch         xscpu64
 * $VICERES JiffySwitch         xscpu64
 *
 */

/*
 * This file is part of VICE, the Versatile Commodore Emulator.
 * See README for copyright notice.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
 *  02111-1307  USA.
 *
 */

#include "vice.h"
#include <stdio.h>
#include <gtk/gtk.h>

#include "archdep_defs.h"
#include "archdep.h"
#include "attach.h"
#include "autostart.h"
#include "contentpreviewwidget.h"
#include "crtcontrolwidget.h"
#include "datasette.h"
#include "dirmenupopup.h"
#include "diskcontents.h"
#include "diskimage.h"
#include "diskimage/fsimage.h"
#include "drive-check.h"
#include "drive.h"
#include "drive.h"
#include "drivetypes.h"
#include "fliplist.h"
#include "hotkeys.h"
#include "joyport.h"
#include "joystickmenupopup.h"
#include "kbddebugwidget.h"
#include "keyboard.h"
#include "lib.h"
#include "log.h"
#include "machine.h"
#include "mainlock.h"
#include "resources.h"
#include "statusbarledwidget.h"
#include "statusbarrecordingwidget.h"
#include "statusbarspeedwidget.h"
#include "tapecontents.h"
#include "tapeport.h"
#include "types.h"
#include "ui.h"
#include "uiapi.h"
#include "uiactions.h"
#include "uidatasette.h"
#include "uidiskattach.h"
#include "uifliplist.h"
#include "uimenu.h"
#include "uisettings.h"
#include "userport/userport_joystick.h"
#include "vice_gtk3.h"

#include "uistatusbar.h"


/** \brief The maximum number of status bars we will permit to exist at once. */
#define MAX_STATUS_BARS 3

/** \brief  Timeout for statusbar messages in seconds */
#define MESSAGE_TIMEOUT 5

/** \brief  Maximum length for drive unit status string */
#define DRIVE_UNIT_STR_MAX_LEN 8

/** \brief  Maximum length for drive track status string */
#define DRIVE_TRACK_STR_MAX_LEN 16


/** \brief  Tape status widget column indexes
 */
enum {
    TAPE_STATUS_COL_HEADER,     /**< label with 'datasette [12] */
    TAPE_STATUS_COL_COUNTER,    /**< label with counter */
    TAPE_STATUS_COL_MOTOR       /**< custom motor widget */
};


/** \brief  Diskdrive drive indexes per unit
 *
 * A dual-drive unit has two drives as the name implies.
 */
enum {
    DRIVE_UNIT_DRIVE_0,     /**< first drive, always valid */
    DRIVE_UNIT_DRIVE_1,     /**< second drive (2040, 3040, 4040, 8050, 8250) */
    DRIVE_UNIT_DRIVE_MAX    /**< maximum number of drives per unit */
};


/* Position of diskdrive units in their wrapper grid:
 *
 * +--------------+---------------+
 * | 8:0 18.0 [=] | 10:0 18.0 [=] |
 * | 8:1 18.0 [=] | 10:1 18.0 [=] |
 * +--------------+---------------+
 * | 9:0 18.0 [=] | 11:0 18.0 [=] |
 * | 9:1 18.0 [=] | 11:1 18.0 [=] |
 * +--------------+---------------+
 */
#define UNIT_8_COL  0
#define UNIT_8_ROW  0
#define UNIT_9_COL  0
#define UNIT_9_ROW  1
#define UNIT_10_COL 1
#define UNIT_10_ROW 0
#define UNIT_11_COL 1
#define UNIT_11_ROW 1


/** \brief  Column indexes for the drive widgets
 *
 * These are columns in their containing grid, not the status bar grid.
 */
static const int unit_cols[NUM_DISK_UNITS] = {
    UNIT_8_COL, UNIT_9_COL, UNIT_10_COL, UNIT_11_COL
};


/** \brief  Row indexes for the drive widgets
 *
 * These are rows in their containing grid, not the status bar grid.
 */
static const int unit_rows[NUM_DISK_UNITS] = {
    UNIT_8_ROW, UNIT_9_ROW, UNIT_10_ROW, UNIT_11_ROW
};


/** \brief  Column indexes for the drive status widgets
 *
 * Each status widget has a label for the unit number (8-11), suffixed with
 * a drive number for dual-drive units, ie '8:0 and 8:1' for unit 8.
 * Another label is used to display the current position of the head, currently
 * only the track number is displayed, not the sector number. The third widget
 * is the drive LED.
 */
enum {
    DRIVE_STATUS_NUMBER,    /**< label containing unit number and drive number */
    DRIVE_STATUS_HEAD,      /**< label containing position of the head */
    DRIVE_STATUS_LED        /**< led custom widget */
};


/** \brief  CSS for the drive widgets
 *
 * The negative margins look weird, but otherwise we have a lot of padding, and
 * the drive widgets already take up a lot of space when having dual-drives
 * enabled.
 */
#define DRIVE_WIDGET_CSS \
    "label {\n" \
    "    font-family: monospace;\n" \
    "    font-size:100%;\n" \
    "    margin-top: 0px;\n" \
    "    margin-bottom: -4px;\n" \
    "}\n"


/** \brief  Joysticks widget: column of label
 */
#define JOYSTICK_COL_LABEL  0

/** \brief  Joysticks widget: column of first joystick indicator widget
 */
#define JOYSTICK_COL_STATUS 1

/* Status bar column indexes */
#define SB_COL_LEDS             0
#define SB_COL_WIDGETS          0
#define SB_COL_MESSAGES         0
#define SB_COL_KBD_DEBUG        0
#define SB_COL_MESSAGES_VSEP    (SB_COL_MESSAGES + 1)
#define SB_COL_RECORDING        (SB_COL_MESSAGES_VSEP + 1)
#define SB_COLUMN_COUNT         (SB_COL_RECORDING + 1)


/** \brief  Status bar row indexes
 */
enum {
    SB_ROW_LEDS,            /**< row with small LEDs */
    SB_ROW_LEDS_HSEP,       /**< horizontal separator between LEDs and large
                                 widgets */
    SB_ROW_WIDGETS,         /**< large widgets/containers */
    SB_ROW_WIDGETS_HSEP,    /**< horizontal separator between large widgets
                                 and messages/recording */
    SB_ROW_MESSAGES,        /**< messages AND separator AND recording */
    SB_ROW_MESSAGES_HSEP,   /**< horizontal separator between messages/recording
                                 and the keyboard debugging widget */
    SB_ROW_KBD_DEBUG        /**< keyboard debugging */
};


/** \brief  Size of a statusbar message, including nul character
 */
#define MESSAGE_TEXT_SIZE   1024


/** \brief Global data that custom status bar widgets base their rendering
 *         on.
 *
 *  This data is usually set by calls from the emulation core or from
 *  other parts of the UI in response to user commands or I/O events.
 *
 *  \todo The PET can have two tape drives.
 *
 *  \todo Two-unit drive units are not covered by this structure.
 */
typedef struct ui_sb_state_s {
    /** \brief Identifier for the currently displayed status bar
     * message.
     *
     * Used to correlate timeout events so that a new message
     * isn't erased by some older message timing out. */
    intptr_t statustext_msgid;

    /** \brief Current tape state (play, rewind, etc) */
    int tape_control[TAPEPORT_MAX_PORTS];

    /** \brief Nonzero if the tape motor is powered. */
    int tape_motor_status[TAPEPORT_MAX_PORTS];

    /** \brief Location on the tape of datasette #1 */
    int tape_counter[TAPEPORT_MAX_PORTS];

    /** \brief Which drives are to be displayed in the status bar.
     *
     *  This is a bitmask, with bits 0-3 representing drives 8-11,
     *  respectively.
     */
    int drives_enabled;

    /** \brief  Drive type for each unit
     *
     * Used to determine if the layout needs changing due to changes in drive
     * type that change a unit's dual-drive status.
     */
    int drives_type[NUM_DISK_UNITS];

    /** \brief  Drive type changes involving dual-drive status
     *
     * Each bit represents a unit, with bit 0-3 -> representing units 8-11.
     * If a bit is set it means the dual-drive state of that unit has changed
     * and the UI needs updating of the widgets for that unit.
     */
    unsigned int drives_dual;

    /** \brief Nonzero if True Drive Emulation is active and drive
     *         LEDs should be drawn. */
    int drives_tde_enabled;

    /** \brief true if drive ui layout is needed */
    bool drives_layout_needed;

    /** \brief Color descriptors for the drive LED colors, 0=red, 1=green */
    int drive_led_types[NUM_DISK_UNITS][2][DRIVE_LEDS_MAX];

    /** \brief Current intensity of each drive LED, 0=off,
     *         1000=max. */
    unsigned int current_drive_leds[NUM_DISK_UNITS][2][DRIVE_LEDS_MAX];

    /** \brief true if a drive led has been changed */
    bool current_drive_leds_updated[NUM_DISK_UNITS][2][DRIVE_LEDS_MAX];

    /** \brief unit:drive label for each unit and its drives */
    char current_drive_unit_str[NUM_DISK_UNITS][2][DRIVE_UNIT_STR_MAX_LEN];

    /** \brief true if a drive unit string has been changed */
    bool current_drive_unit_str_updated[NUM_DISK_UNITS][2];

    /** \brief device:track.halftrack label for each unit and its drives */
    char current_drive_track_str[NUM_DISK_UNITS][2][DRIVE_TRACK_STR_MAX_LEN];

    /** \brief true if a drive track string has been changed */
    bool current_drive_track_str_updated[NUM_DISK_UNITS][2];

    /** \brief Current state for each of the joyports.
     *
     *  This is an 7-bit bitmask, representing, from least to most
     *  significant bits: up, down, left, right, fire button,
     *  secondary fire button, tertiary fire button. */
    int current_joyports[JOYPORT_MAX_PORTS];

    /** \brief Which joystick ports are actually available.
     *
     *  This is a bitmask representing notional ports 0-4, which are
     *  themselves defined in joyport/joyport.h. Cases like a SIDcard
     *  control port on a Plus/4 without other userport control ports
     *  mean that the set of active joyports may be discontinuous. */
    uint32_t active_joyports;

    /** \brief  Statusbar message
     *
     * Message to display in the message widget.
     */
    char message_text[MESSAGE_TEXT_SIZE];

    /** \brief  Statusbar message is pending
     *
     * Keeps track of whether a newly arrived message has been displayed by the
     * UI thread.
     */
    bool message_pending;

    /** \brief  Statusbar fadeout
     *
     * Determines if the current statusbar message should fade out after 5
     * seconds.
     */
    bool message_fadeout;

} ui_sb_state_t;


/** \brief Used to safely access sb_state between threads. */
static pthread_mutex_t sb_state_lock = PTHREAD_MUTEX_INITIALIZER;


/** \brief The current state of the status bars across the UI.
 *
 * Don't use directly! Use lock_sb_state / unlock_sb_state instead.
 * I thought this pattern would make it more obvious to future
 * developers that they shouldn't just use sb_state without locking.
 */
static ui_sb_state_t sb_state_do_not_use_directly;


/** \brief The full structure representing a status bar widget.
 *
 *  This includes the top-level widget and then every subwidget that
 *  needs to be individually addressed or manipulated by the
 *  status-report API. */
typedef struct ui_statusbar_s {
    /** \brief The status bar widget proper.
     *
     *  This is the widget the rest of the UI code will store and pack
     *  into windows. */
    GtkWidget *bar;

    /** \brief  Row with LED widgets
     */
    GtkWidget *led_row_grid;

    /** \brief  Current index in the LED row to append new LEDs
     */
    int led_row_column;

    /** \brief  Row with large/composed widgets of a status bar
     *
     * A grid containing widgets for the large row of a status bar.
     */
    GtkWidget *widget_row_grid;

    /** \brief  Current column to append new widgets
     *
     * Keeps track of the column to append new widgets with statusbar_append()
     * and statusbar_apppend_end().
     *
     * The function statusbar_append() appends widgets from left to right to
     * the top row of a status bar, the function statusbar_append_end() is used
     * to put the last top widget (volume) on the status bar setting its aligment
     * and hexpand properties so it appears to the right of the status bar.
     */
    int widget_row_column;

    /** \brief  Warp mode LED widget */
    GtkWidget *warp_led;

    /** \brief  Pause LED widget */
    GtkWidget *pause_led;

    /** \brief  shiftlock LED widget */
    GtkWidget *shiftlock_led;

    /** \brief  40/80 LED widget */
    GtkWidget *mode4080_led;

    /** \brief  capslock LED widget */
    GtkWidget *capslock_led;

    /** \brief  Userport diagnostic pin widget (PET) */
    GtkWidget *diagnosticpin_led;

    /** \brief  Turbo LED widget (SCPU64) */
    GtkWidget *supercpu_turbo_led;

    /** \brief  JiffyDOS LED widget (SCPU64) */
    GtkWidget *supercpu_jiffy_led;

    /** \brief  Widget displaying CPU speed and FPS
     *
     * Also used to set refresh rate, CPU speed, pause, warp and adv-frame
     */
    GtkWidget *speed;

    /** \brief  Stateful data used by the speed widget */
    statusbar_speed_widget_state_t speed_state;

    /** \brief  Status bar messages */
    GtkWidget *msg;

    /** \brief  Recording control/display widget */
    GtkWidget *record;

    /** \brief CRT control widget checkbox */
    GtkWidget *crt;

    /** \brief  Mixer control widget checkbox */
    GtkWidget *mixer;

    /** \brief  Tape status widgets
     */
    GtkWidget *tape_status[TAPEPORT_MAX_PORTS];

    /** \brief  Tape popup menus
     */
    GtkWidget *tape_menu[TAPEPORT_MAX_PORTS];

    /** \brief  Used to optimise tape widget updates
     *
     * FIXME:   Should probably be moved to sb_status?
     */
    int displayed_tape_counter[TAPEPORT_MAX_PORTS];

    /** \brief The joyport status widget. */
    GtkWidget *joysticks;

    /*
     * New diskdrive layout code
     */

    /* Four diskdrive units (8-11) */
    GtkWidget *drive_unit[NUM_DISK_UNITS];

    /* Four units with max two drives each: */
    GtkWidget *drive_menu[NUM_DISK_UNITS][DRIVE_UNIT_DRIVE_MAX];

    /** \brief The volume control
     *
     * Only enabled for VSID at the moment.
     */
    GtkWidget *volume;

    /** \brief The hand-shaped cursor to change to when popup menus
     *         are available. */
    GdkCursor *hand_ptr;

    /** \brief  Keyboard debugging widget */
    GtkWidget *kbd_debug;

    /** \brief PRIMARY_WINDOW, SECONDARY_WINDOW, etc */
    int window_identity;
} ui_statusbar_t;


/** \brief The collection of status bars currently active.
 *
 *  Inactive status bars have a NULL pointer for their "bar" field. */
static ui_statusbar_t allocated_bars[MAX_STATUS_BARS];


/** \brief  Cursor used when hovering over the joysticks widgets
 *
 * TODO:    figure out if I need to clean this up or that Gtk will?
 */
static GdkCursor *joywidget_mouse_ptr = NULL;


/** \brief  Timeout ID of the message widget
 */
static guint timeout_id = 0;


/* Forward decl. */
static void tape_dir_autostart_callback(const char *image,
                                        int index,
                                        int device,
                                        unsigned int drive);
static void disk_dir_autostart_callback(const char *image,
                                        int index,
                                        int device,
                                        unsigned int drive);


/** \brief  Trigger redraw of a widget on the UI thread
 *
 * \param[in,out]   user_data   widget to redraw
 *
 * \return  FALSE
 */
static gboolean redraw_widget_on_ui_thread_impl(gpointer user_data)
{
    gtk_widget_queue_draw((GtkWidget *)user_data);

    return FALSE;
}

/** \brief Queue a redraw of widget on the ui thread.
 *
 * It's not safe to ask a widget to redraw from the vice thread.
 *
 * \param[in,out]   widget  widget to redraw
 */
static void redraw_widget_on_ui_thread(GtkWidget *widget)
{
    gdk_threads_add_timeout(0, redraw_widget_on_ui_thread_impl, (gpointer)widget);
}

/** \brief Get a locked reference to sb_state */
static ui_sb_state_t *lock_sb_state(void)
{
    pthread_mutex_lock(&sb_state_lock);
    return &sb_state_do_not_use_directly;
}

/** \brief Release a locked reference to sb_state_do_not_use_directly */
static void unlock_sb_state(void)
{
    pthread_mutex_unlock(&sb_state_lock);
}

/*****************************************************************************
 *                          Gtk3 event handlers                              *
 ****************************************************************************/


/** \brief  Timeout callback for the stausbar message widget
 *
 * \param[in,out]   data    message widget
 *
 * \return  FALSE (delete timer source)
 */
static gboolean message_timeout_handler(gpointer data)
{
    GtkLabel *label = data;

    gtk_label_set_text(label, "");
    timeout_id = 0; /* signal no timeouts pending (this should be fun) */
    return FALSE;
}


/** \brief Draws the tape icon based on the current control and motor status.
 *
 *  \param widget  The tape icon GtkDrawingArea being drawn to.
 *  \param cr      The cairo context that handles the drawing.
 *  \param data    tape port index
 *
 *  \return FALSE, telling GTK to continue event processing
 */
static gboolean draw_tape_icon_cb(GtkWidget *widget, cairo_t *cr, gpointer data)
{
    int width, height;
    double x, y, inset;
    int tape_motor_status;
    int tape_control;
    ui_sb_state_t *sb_state;
    int index = GPOINTER_TO_INT(data);

    /* Copy any sb_state that we need to use - don't hold lock while drawing */
    sb_state = lock_sb_state();
    tape_motor_status = sb_state->tape_motor_status[index];
    tape_control = sb_state->tape_control[index];
    unlock_sb_state();

    width = gtk_widget_get_allocated_width(widget);
    height = gtk_widget_get_allocated_height(widget);
    if (width > height) {
        x = (width - height) / 2.0;
        y = 0.0;
        inset = height / 10.0;
    } else {
        x = 0.0;
        y = (height - width) / 2.0;
        inset = width / 10.0;
    }

    if (tape_motor_status) {
        cairo_set_source_rgb(cr, 0, 0.75, 0);
    } else {
        cairo_set_source_rgb(cr, 0.5, 0.5, 0.5);
    }
    cairo_rectangle(cr, x + inset, y + inset, inset * 8, inset * 8);
    cairo_fill(cr);

    cairo_set_source_rgb(cr, 0, 0, 0);
    switch (tape_control) {
    case DATASETTE_CONTROL_STOP:
        cairo_rectangle(cr, x + 2.5*inset, y + 2.5*inset, inset * 5, inset * 5);
        cairo_fill(cr);
        break;
    case DATASETTE_CONTROL_START:
        cairo_move_to(cr, x + 3*inset, y + 2.5*inset);
        cairo_line_to(cr, x + 3*inset, y + 7.5*inset);
        cairo_line_to(cr, x + 7*inset, y + 5*inset);
        cairo_close_path(cr);
        cairo_fill(cr);
        break;
    case DATASETTE_CONTROL_FORWARD:
        cairo_move_to(cr, x + 2.5*inset, y + 2.5*inset);
        cairo_line_to(cr, x + 2.5*inset, y + 7.5*inset);
        cairo_line_to(cr, x + 5*inset, y + 5*inset);
        cairo_close_path(cr);
        cairo_fill(cr);
        cairo_move_to(cr, x + 5*inset, y + 2.5*inset);
        cairo_line_to(cr, x + 5*inset, y + 7.5*inset);
        cairo_line_to(cr, x + 7.5*inset, y + 5*inset);
        cairo_close_path(cr);
        cairo_fill(cr);
        break;
    case DATASETTE_CONTROL_REWIND:
        cairo_move_to(cr, x + 5*inset, y + 2.5*inset);
        cairo_line_to(cr, x + 5*inset, y + 7.5*inset);
        cairo_line_to(cr, x + 2.5*inset, y + 5*inset);
        cairo_close_path(cr);
        cairo_fill(cr);
        cairo_move_to(cr, x + 7.5*inset, y + 2.5*inset);
        cairo_line_to(cr, x + 7.5*inset, y + 7.5*inset);
        cairo_line_to(cr, x + 5*inset, y + 5*inset);
        cairo_close_path(cr);
        cairo_fill(cr);
        break;
    case DATASETTE_CONTROL_RECORD:
        cairo_new_sub_path(cr);
        cairo_arc(cr, x + 5*inset, y + 5*inset, 2.5*inset, 0, 2 * G_PI);
        cairo_close_path(cr);
        cairo_fill(cr);
        cairo_set_source_rgb(cr, 1, 0, 0);
        cairo_new_sub_path(cr);
        cairo_arc(cr, x + 5*inset, y + 5*inset, 2*inset, 0, 2 * G_PI);
        cairo_close_path(cr);
        cairo_fill(cr);
        break;
    case DATASETTE_CONTROL_RESET:
    case DATASETTE_CONTROL_RESET_COUNTER:
    default:
        /* Things that aren't really controls look like we stop it. */
        /* TODO: Should RESET_COUNTER be wiped out by the time it gets here? */
        cairo_rectangle(cr, x + 2.5*inset, y + 2.5*inset, inset * 5, inset * 5);
        cairo_fill(cr);
    }

    return FALSE;
}


/** \brief  Handler for the 'activate' event of the 'Configure drives' item
 *
 * Opens the settings UI at the drive settings "page".
 *
 * \param[in]   widget  menu item triggering the event (unused)
 * \param[in]   data    extra event data (unused)
 */
static void on_drive_configure_activate(GtkWidget *widget, gpointer data)
{
    ui_settings_dialog_show("peripheral/drive");
}


/** \brief  Handler for the 'activate' event of the 'Reset drive \#X in ... mode' item
 *
 * Triggers a reset for drive ((int)data + 8).
 *
 * \param[in]   widget  menu item triggering the event (unused)
 * \param[in]   data    drive number (0-3)
 */
static void on_drive_reset_config_clicked(GtkWidget *widget, gpointer data)
{
    drive_cpu_trigger_reset_button(((GPOINTER_TO_INT(data)>>4)&15),
       GPOINTER_TO_INT(data) & 15 );
}

/** \brief Draw the LED associated with some drive's LED state.
 *
 *  \param widget  The drive LED GtkDrawingArea being drawn to.
 *  \param cr      The cairo context that handles the drawing.
 *  \param data    The index (0-3) of which drive this represents.
 *
 *  \return FALSE, telling GTK to continue event processing
 */
static gboolean draw_drive_led_cb(GtkWidget *widget, cairo_t *cr, gpointer data)
{
    int width, height;
    int unit;
    int drive;
    int i;
    double red = 0.0, green = 0.0, x, y, w, h;
    ui_sb_state_t *sb_state;

    width = gtk_widget_get_allocated_width(widget);
    height = gtk_widget_get_allocated_height(widget);
    unit = GPOINTER_TO_INT(data) & 0xff;
    drive = GPOINTER_TO_INT(data) >> 8;
    sb_state = lock_sb_state();

    /* FIXME: this should display two LEDs some day, right now we combine the
       two LEDs of a drive into one that we display. */
    for (i = 0; i < DRIVE_LEDS_MAX; ++i) {
        int led_color = sb_state->drive_led_types[unit][drive][i];
        if (led_color) {
            green += sb_state->current_drive_leds[unit][drive][i] / 1000.0;
        } else {
            red += sb_state->current_drive_leds[unit][drive][i] / 1000.0;
        }
    }
    unlock_sb_state();

    /* Cairo clamps these for us */
    cairo_set_source_rgb(cr, red, green, 0);
    /* LED is half text height and aims for a 2x1 aspect ratio */
    h = height / 2.0;
    w = 2.0 * h;
    x = (width / 2.0) - h;
    y = height / 4.0;
    cairo_rectangle(cr, x, y, w, h);
    cairo_fill(cr);
    return FALSE;
}


/** \brief Draw the current input status from a joyport.
 *
 *  This produces five squares arranged in a + shape, with directions
 *  represented as green squares when active and black when not. The
 *  fire buttons are represented by the central square, with red,
 *  green, and blue components representing the three possible
 *  buttons.
 *
 *  For traditional Commodore joysticks, there is only one fire button
 *  and this will be diplayed as a red square when the button is
 *  pressed.
 *
 *  \param widget  The joyport GtkDrawingArea being drawn to.
 *  \param cr      The cairo context that handles the drawing.
 *  \param data    The index (0-4) of which joyport this represents.
 *
 *  \return FALSE, telling GTK to continue event processing
 */
static gboolean draw_joyport_cb(GtkWidget *widget, cairo_t *cr, gpointer data)
{
    int width, height, val;
    double e, s, x, y;
    ui_sb_state_t *sb_state;

    /* FIXME This is called very often due to cpu/fps label updates
     * triggering a relayout/redraw */

    width = gtk_widget_get_allocated_width(widget);
    height = gtk_widget_get_allocated_height(widget);

    sb_state = lock_sb_state();
    val = sb_state->current_joyports[GPOINTER_TO_INT(data)];
    unlock_sb_state();

    /* This widget "wants" to draw 6x6 squares inside a 20x20
     * space. We compute x and y offsets for a scaled square within
     * the real widget space, and then the actual widths for a square
     * edge (e) and the spaces between them (s). */

    if (width > height) {
        s = height / 20.0;
        x = (width - height) / 2.0;
        y = 0.0;
    } else {
        s = width / 20.0;
        y = (height - width) / 2.0;
        x = 0.0;
    }
    e = s * 5.0;

    /* Then we render the five squares. This seems like it could be
     * done more programatically, but enough changes each iteration
     * that we might as well unroll it. */

    /* Up: Bit 0 */
    cairo_set_source_rgb(cr, 0, (val&0x01) ? 1 : 0, 0);
    cairo_rectangle(cr, x + e + 2*s, y+s, e, e);
    cairo_fill(cr);
    /* Down: Bit 1 */
    cairo_set_source_rgb(cr, 0, (val&0x02) ? 1 : 0, 0);
    cairo_rectangle(cr, x + e + 2*s, y + 2*e + 3*s, e, e);
    cairo_fill(cr);
    /* Left: Bit 2 */
    cairo_set_source_rgb(cr, 0, (val&0x04) ? 1 : 0, 0);
    cairo_rectangle(cr, x + s, y + e + 2*s, e, e);
    cairo_fill(cr);
    /* Right: Bit 3 */
    cairo_set_source_rgb(cr, 0, (val&0x08) ? 1 : 0, 0);
    cairo_rectangle(cr, x + 2*e + 3*s, y + e + 2*s, e, e);
    cairo_fill(cr);
    /* Fire buttons: Bits 4-6. Each of the three notional fire buttons
     * controls the red, green, or blue color of the fire button
     * area. By default, we are using one-button joysticks and so this
     * region will be either black or red. */
    cairo_set_source_rgb(cr, (val&0x10) ? 1 : 0,
                             (val&0x20) ? 1 : 0,
                             (val&0x40) ? 1 : 0);
    cairo_rectangle(cr, x + e + 2*s, y + e + 2*s, e, e);
    cairo_fill(cr);

    return FALSE;
}


/** \brief Respond to mouse clicks on the tape status widget.
 *
 *  This displays the tape control popup menu.
 *
 *  \param widget  The GtkWidget that received the click. Ignored.
 *  \param event   The event representing the bottom operation.
 *  \param data    An integer representing which window's status bar was
 *                 clicked and thus where the popup window should go,
 *                 and tape unit number shifted 8 bits to the right.
 *
 *  \return TRUE if further event processing should be skipped.
 *
 *  \todo This callback and the way it is configured both will need to
 *        be significantly reworked to manage multiple tape drives.
 */
static gboolean ui_do_datasette_popup(GtkWidget *widget,
                                      GdkEvent *event,
                                      gpointer data)
{
    int bar_index = GPOINTER_TO_INT(data) & 0xff;
    int port = GPOINTER_TO_INT(data) >> 8;
    int tape_index = port - TAPEPORT_UNIT_1;

    mainlock_assert_is_not_vice_thread();

    if (((GdkEventButton *)event)->button == GDK_BUTTON_PRIMARY) {
        ui_statusbar_t bar;
        GtkWidget *tape_status;
        GtkWidget *tape_menu;

        bar = allocated_bars[bar_index];
        tape_status = bar.tape_status[tape_index];
        tape_menu = bar.tape_menu[tape_index];

        if (tape_status != NULL && tape_menu != NULL) {
            GList *children;
            GList *child;
            gint action_id;

            /* Set accelerators for attach/detach items
             *
             * Needs to happen here since the tape menus are created on status
             * bar initialization and the hotkeys can change in the mean time.
             */
            child = children = gtk_container_get_children(GTK_CONTAINER(tape_menu));

            action_id = port == 1 ? ACTION_TAPE_ATTACH_1 : ACTION_TAPE_ATTACH_2;
            vhk_gtk_set_menu_item_accel_label(GTK_WIDGET(child->data), action_id);

            child = child->next;
            action_id = port == 1 ? ACTION_TAPE_DETACH_1 : ACTION_TAPE_DETACH_2;
            vhk_gtk_set_menu_item_accel_label(GTK_WIDGET(child->data), action_id);

            g_list_free(children);

            ui_datasette_update_sensitive(tape_menu, port);
            gtk_menu_popup_at_widget(GTK_MENU(tape_menu),
                                     tape_status,
                                     GDK_GRAVITY_NORTH_EAST,
                                     GDK_GRAVITY_SOUTH_EAST,
                                     event);
        }
        return TRUE;
    } else if (((GdkEventButton *)event)->button == GDK_BUTTON_SECONDARY) {
        GtkWidget *dir_menu;

        dir_menu = dir_menu_popup_create(port,
                                         0,
                                         tapecontents_read,
                                         tape_dir_autostart_callback);
        gtk_menu_popup_at_widget(GTK_MENU(dir_menu),
                                 widget,
                                 GDK_GRAVITY_NORTH_EAST,
                                 GDK_GRAVITY_SOUTH_EAST,
                                 event);
        return TRUE;
    }
    return FALSE;
}


/** \brief  Respond to mouse clicks on a disk drive status widget.
 *
 *  This displays the drive control popup menu.
 *
 *  \param[in]  widget  The GtkWidget that received the click. Ignored.
 *  \param[in]  event   The event representing the bottom operation.
 *  \param[in]  data    Unit index (bits 0-7) and drive number (bit 8)
 *
 *  \return TRUE if further event processing should be skipped.
 */
static gboolean ui_do_drive_popup(GtkWidget *widget, GdkEvent *event, gpointer data)
{
    GtkWidget *drive_menu;
    GtkWidget *drive_menu_item;
    GtkWidget *label;
    gchar buffer[256];
    GList *children;
    GList *child;
    int action;
    int i = GPOINTER_TO_INT(data) & 0xff;
    int drive = GPOINTER_TO_INT(data) >> 8;
    int buttons;

    mainlock_assert_is_not_vice_thread();

    drive_menu = allocated_bars[0].drive_menu[i][drive];

    /* set "Attach" item label based on dual-drive status */
    child = children = gtk_container_get_children(GTK_CONTAINER(drive_menu));
    if (child != NULL && child->data != NULL) {

        drive_menu_item = child->data;
        label = gtk_bin_get_child(GTK_BIN(drive_menu_item));

        if (drive_is_dualdrive_by_devnr(i + DRIVE_UNIT_MIN)) {
            g_snprintf(buffer, sizeof(buffer),
                       "Attach disk to drive #%d:%d...",
                       i + DRIVE_UNIT_MIN, drive);
        } else {
            g_snprintf(buffer, sizeof(buffer),
                       "Attach disk to drive #%d...",
                       i + DRIVE_UNIT_MIN);
        }
        gtk_label_set_text(GTK_LABEL(label), buffer);

        /* set hotkey, if any */
        action = ui_action_id_drive_attach(i + DRIVE_UNIT_MIN, drive);
        vhk_gtk_set_menu_item_accel_label(drive_menu_item, action);
    }

    /* set "Detach" item label based on dual-drive status */
    child = child->next;
    if (child != NULL && child->data != NULL) {

        drive_menu_item = child->data;
        label = gtk_bin_get_child(GTK_BIN(drive_menu_item));

        if (drive_is_dualdrive_by_devnr(i + DRIVE_UNIT_MIN)) {
            g_snprintf(buffer, sizeof(buffer),
                       "Detach disk from drive #%d:%d...",
                       i + DRIVE_UNIT_MIN, drive);
        } else {
            g_snprintf(buffer, sizeof(buffer),
                       "Detach disk from drive #%d...",
                       i + DRIVE_UNIT_MIN);
        }
        gtk_label_set_text(GTK_LABEL(label), buffer);

        /* set hotkey, if any */
        action = ui_action_id_drive_detach(i + DRIVE_UNIT_MIN, drive);
        vhk_gtk_set_menu_item_accel_label(drive_menu_item, action);
    }

    g_list_free(children);

    ui_populate_fliplist_menu(drive_menu, i + DRIVE_UNIT_MIN, 0);
    /* XXX: this code is a duplicate of the drive_menu creation code, so we
     *      should probably refactor this a bit
     */
    popup_menu_add_separator(drive_menu);

    drive_menu_item = gtk_menu_item_new_with_label("Configure drives ...");
    g_signal_connect(drive_menu_item, "activate",
                     G_CALLBACK(on_drive_configure_activate), NULL);
    gtk_container_add(GTK_CONTAINER(drive_menu), drive_menu_item);

    /*
     * Add drive reset item
     */
    g_snprintf(buffer, sizeof(buffer), "Reset drive #%d", i + DRIVE_UNIT_MIN);
    drive_menu_item = popup_menu_item_action_new(buffer,
                                                 ui_action_id_drive_reset(i + DRIVE_UNIT_MIN));
    gtk_container_add(GTK_CONTAINER(drive_menu), drive_menu_item);

    buttons = drive_has_buttons(i);

    /* Add reset to configuration mode for CMD HDs */
    if ((buttons & DRIVE_BUTTON_WRITE_PROTECT) == DRIVE_BUTTON_WRITE_PROTECT) {
        g_snprintf(buffer, sizeof(buffer),
                   "Reset drive #%d to Configuration Mode",
                   i + DRIVE_UNIT_MIN);
        drive_menu_item = gtk_menu_item_new_with_label(buffer);
        g_signal_connect(drive_menu_item, "activate",
                         G_CALLBACK(on_drive_reset_config_clicked),
                         GINT_TO_POINTER((i << 4) + DRIVE_BUTTON_WRITE_PROTECT));
        gtk_container_add(GTK_CONTAINER(drive_menu), drive_menu_item);
    }

    /* Add reset to installation mode for CMD HDs */
    if ((buttons & (DRIVE_BUTTON_SWAP_8|DRIVE_BUTTON_SWAP_9)) == (DRIVE_BUTTON_SWAP_8|DRIVE_BUTTON_SWAP_9)) {
        g_snprintf(buffer, sizeof(buffer),
                   "Reset drive #%d to Installation Mode",
                   i + DRIVE_UNIT_MIN);
        drive_menu_item = gtk_menu_item_new_with_label(buffer);
        g_signal_connect(drive_menu_item, "activate",
                         G_CALLBACK(on_drive_reset_config_clicked),
                         GINT_TO_POINTER((i << 4) + (DRIVE_BUTTON_SWAP_8|DRIVE_BUTTON_SWAP_9)));
        gtk_container_add(GTK_CONTAINER(drive_menu), drive_menu_item);
    }

    /* Add 'add image to fliplist' */
    gtk_container_add(GTK_CONTAINER(drive_menu), gtk_separator_menu_item_new());

    drive_menu_item = popup_menu_item_action_new(
            "Add current image to fliplist",
            ui_action_id_fliplist_add(i + DRIVE_UNIT_MIN, 0));
    gtk_widget_set_sensitive(drive_menu_item,
                             file_system_get_image(i + DRIVE_UNIT_MIN, 0) != NULL);
    gtk_container_add(GTK_CONTAINER(drive_menu), drive_menu_item);

    /* Add 'clear fliplist' */
    drive_menu_item = popup_menu_item_action_new(
            "Clear fliplist",
            ui_action_id_fliplist_clear(i + DRIVE_UNIT_MIN, 0));
    gtk_widget_set_sensitive(drive_menu_item,
                             fliplist_init_iterate(i + DRIVE_UNIT_MIN) != NULL);
    gtk_container_add(GTK_CONTAINER(drive_menu), drive_menu_item);

    gtk_widget_show_all(drive_menu);

    if (((GdkEventButton *)event)->button == GDK_BUTTON_PRIMARY) {
        /* show popup for attaching/detaching disk images */
        gtk_menu_popup_at_widget(GTK_MENU(drive_menu),
                                 widget,
                                 GDK_GRAVITY_NORTH_EAST,
                                 GDK_GRAVITY_SOUTH_EAST,
                                 event);
    } else if (((GdkEventButton *)event)->button == GDK_BUTTON_SECONDARY) {
        /* show popup to run file in currently attached image */
        GtkWidget *dir_menu = dir_menu_popup_create(i + DRIVE_UNIT_MIN,
                                                    drive,
                                                    diskcontents_filesystem_read,
                                                    disk_dir_autostart_callback);

        /* show popup for selecting file in currently attached image */
        gtk_menu_popup_at_widget(GTK_MENU(dir_menu),
                                 widget,
                                 GDK_GRAVITY_NORTH_EAST,
                                 GDK_GRAVITY_SOUTH_EAST,
                                 event);
    }

    return TRUE;
}


/** \brief  Handler for the enter/leave-notify events of the joysticks widget
 *
 * \param[in]   widget      widget triggering the event
 * \param[in]   event       event reference
 * \param[in]   user_data   extra event data (unused)
 *
 * \return  bool    (FALSE = keep propagating event, TRUE = stop)
 */
static gboolean on_joystick_widget_hover(GtkWidget *widget, GdkEvent *event,
                                         gpointer user_data)
{
    if (event != NULL) {
        GdkDisplay *display = gtk_widget_get_display(widget);
        GdkWindow *window = gtk_widget_get_window(widget);
        GdkCursor *cursor;

        if (display == NULL) {
            debug_gtk3("failed to retrieve GdkDisplay.");
            return FALSE;
        }
        if (window == NULL) {
            debug_gtk3("failed to retrieve GdkWindow.");
            return FALSE;
        }

        if (event->type == GDK_ENTER_NOTIFY) {
            if (joywidget_mouse_ptr == NULL) {
                joywidget_mouse_ptr = gdk_cursor_new_from_name(display, "pointer");
            }
            cursor = joywidget_mouse_ptr;

        } else {
            cursor = NULL;
        }
        gdk_window_set_cursor(window, cursor);
    }
    return FALSE;
}


/** \brief  Handler for button-press events of the joysticks widget
 *
 * \param[in]   widget      widget triggering the event
 * \param[in]   event       event reference
 * \param[in]   user_data   extra event data (unused)
 *
 * \return  TRUE to stop other handlers, FALSE to propagate event further
 */
static gboolean on_joystick_widget_button_press(GtkWidget *widget,
                                                GdkEvent *event,
                                                gpointer user_data)
{
    GdkEventButton *ev = (GdkEventButton *)event;

    mainlock_assert_is_not_vice_thread();

    if (ev->button == GDK_BUTTON_PRIMARY || ev->button == GDK_BUTTON_SECONDARY) {
        GtkWidget *menu = joystick_menu_popup_create();

        gtk_menu_popup_at_widget(GTK_MENU(menu), widget,
                GDK_GRAVITY_NORTH_WEST, GDK_GRAVITY_SOUTH_WEST,
                event);
        return TRUE;
    }
    return FALSE;
}


/** Event handler for hovering over a clickable part of the status bar.
 *
 *  This will switch to or from the "hand" cursor as needed, creating
 *  it if necessary.
 *
 *  \param widget    The widget firing the event
 *  \param event     The GdkEventCross that caused the callback
 *  \param user_data The ui_statusbar_t object containing widget
 *
 *  \return TRUE if further event processing should be blocked.
 */
static gboolean ui_statusbar_cross_cb(GtkWidget *widget,
                                      GdkEvent *event,
                                      gpointer user_data)
{
    ui_statusbar_t *sb = (ui_statusbar_t *)user_data;

    if (event && event->type == GDK_ENTER_NOTIFY) {
        GdkDisplay *display;

        /* Sanity check arguments */
        if (sb == NULL) {
            /* Should be impossible */
            fprintf(stderr, "Error: ui_statusbar_t* is NULL.\n");
            return FALSE;
        }
        /* If the "hand" pointer hasn't been created yet, create it */
        display = gtk_widget_get_display(widget);
        if (display != NULL && sb->hand_ptr == NULL) {
            sb->hand_ptr = gdk_cursor_new_from_name(display, "pointer");
            if (sb->hand_ptr == NULL) {
                fprintf(stderr, "GTK3 CURSOR: Could not allocate custom"
                       " pointer for status bar\n");
            }
        }
        /* If the "hand" pointer is OK, use it */
        if (sb->hand_ptr != NULL) {
            GdkWindow *window = gtk_widget_get_window(widget);
            if (window) {
                gdk_window_set_cursor(window, sb->hand_ptr);
            }
        }
    } else {
        /* We're leaving the target widget, so change the pointer back
         * to default */
        GdkWindow *window = gtk_widget_get_window(widget);

        if (window) {
            gdk_window_set_cursor(window, NULL);
        }
    }
    return FALSE;
}


/** \brief  Widget destruction callback for status bars.
 *
 * \param[in]   sb      The status bar being destroyed. This should be
 *                      registered in some ui_statusbar_t structure as the
 *                      bar field.
 * \param[in]   index   status bar index
 */
static void destroy_statusbar_cb(GtkWidget *sb, gpointer index)
{
    ui_statusbar_t *bar;
    int w;
    int idx = GPOINTER_TO_INT(index);

    bar = &(allocated_bars[idx]);

    /* Invalidate all widget references. We need to do this so we can guard
     * against UI update requests after the UI has been destroyed.
     */
    bar->bar = NULL;
    bar->led_row_grid = NULL;
    bar->widget_row_grid = NULL;
    bar->warp_led = NULL;
    bar->pause_led = NULL;
    bar->shiftlock_led = NULL;
    bar->mode4080_led = NULL;
    bar->capslock_led = NULL;
    bar->diagnosticpin_led = NULL;
    bar->supercpu_turbo_led = NULL;
    bar->supercpu_jiffy_led = NULL;
    bar->speed = NULL;
    bar->msg = NULL;
    bar->record = NULL;
    bar->crt = NULL;
    bar->mixer = NULL;
    for (w = 0; w < TAPEPORT_MAX_PORTS; w++) {
        bar->tape_status[w] = NULL;
        bar->tape_menu[w] = NULL;
    }
    bar->joysticks = NULL;
    for (w = 0; w < NUM_DISK_UNITS; w++) {
        int d;

        bar->drive_unit[w] = NULL;
        for (d = 0; d < DRIVE_UNIT_DRIVE_MAX; d++) {
            bar->drive_menu[w][d] = NULL;
        }
    }
    bar->volume = NULL;
    bar->hand_ptr = NULL;
    bar->kbd_debug = NULL;
}


/** \brief  Handler for the 'toggled' event of the CRT controls checkbox
 *
 * Toggles the display state of the CRT controls
 *
 * \param[in]   widget  checkbox triggering the event
 * \param[in]   data    extra event data (unused
 */
static void on_crt_toggled(GtkWidget *widget, gpointer data)
{
    gboolean state;

    mainlock_assert_is_not_vice_thread();

    state = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
    ui_enable_crt_controls((gboolean)state);
}


/** \brief  Handler for the 'toggled' event of the mixer controls checkbox
 *
 * Toggles the display state of the mixer controls
 *
 * \param[in]   widget  checkbox triggering the event
 * \param[in]   data    extra event data (unused
 */
static void on_mixer_toggled(GtkWidget *widget, gpointer data)
{
    gboolean state;

    mainlock_assert_is_not_vice_thread();

    state = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
    ui_enable_mixer_controls((gboolean)state);
}


/** \brief  Handler for the 'value-changed' event of the volume control
 *
 * Updates the master volume
 *
 * \param[in]   widget  GtkVolumeButton control
 * \param[in]   value   new volume value (1.0 - 0.0)
 * \param[in]   data    extra event data (unused
 */
static void on_volume_value_changed(GtkScaleButton *widget,
                                    gdouble value,
                                    gpointer data)
{
    resources_set_int("SoundVolume", (int)(value * 100.0));
}


/*****************************************************************************
 *                          Private functions                                *
 ****************************************************************************/


/** \brief Extracts the list of enabled drives from the DriveType
 *         resources.
 *
 *  \return A bitmask value suitable for ui_sb_state_s::drives_enabled.
 */
static int compute_drives_enabled_mask(void)
{
    int unit, mask;
    int result = 0;
    for (unit = 0, mask = 1; unit < NUM_DISK_UNITS; ++unit, mask <<= 1) {
        int status = 0, value = 0;
        status = resources_get_int_sprintf("Drive%dType", &value, unit + DRIVE_UNIT_MIN);
        if (status == 0 && value != 0) {
            result |= mask;
        }
    }
    return result;
}


/** \brief Create a new drive widget for inclusion in the status bar.
 *
 *  \param unit The drive unit to create (0-3, indicating devices
 *              8-11)
 *
 *  \return The constructed widget. This widget will be a floating
 *          reference.
 */
static GtkWidget *ui_drive_widget_create(int unit, int bar_index)
{
    GtkWidget *grid;
    GtkWidget *number;
    GtkWidget *track;
    GtkWidget *led;
    GtkCssProvider *drive_css;
    int drive_num;

    mainlock_assert_is_not_vice_thread();

    grid = gtk_grid_new();
    gtk_widget_set_hexpand(grid, FALSE);
    gtk_widget_set_vexpand(grid, FALSE);
    /* create reusable CSS provider for the unit/drive and track labels */
    drive_css = vice_gtk3_css_provider_new(DRIVE_WIDGET_CSS);

    for (drive_num = 0; drive_num < DRIVE_UNIT_DRIVE_MAX; drive_num++) {
        GtkWidget *drive_grid;  /* grid for a single drive of a unit */
        GtkWidget *event_box;
        char drive_id[16];

        g_snprintf(drive_id,
                   sizeof(drive_id),
                   "%2d:%d",
                   unit + DRIVE_UNIT_MIN,
                   drive_num);
        number = gtk_label_new(drive_id);
        gtk_widget_set_halign(number, GTK_ALIGN_START);
        vice_gtk3_css_provider_add(number, drive_css);

        track = gtk_label_new(" 18.5");
        gtk_widget_set_hexpand(track, TRUE);
        gtk_widget_set_halign(track, GTK_ALIGN_END);
        vice_gtk3_css_provider_add(track, drive_css);

        led = gtk_drawing_area_new();
        gtk_widget_set_size_request(led, 30, 15);
        gtk_widget_set_no_show_all(led, TRUE);
        gtk_widget_set_has_window(led, TRUE);
        /* Labels will notice clicks by default, but drawing areas need to
         * be told to. */
        gtk_widget_add_events(led, GDK_BUTTON_PRESS_MASK|GDK_ENTER_NOTIFY_MASK|GDK_LEAVE_NOTIFY_MASK);
        g_signal_connect_unlocked(led,
                                  "draw",
                                  G_CALLBACK(draw_drive_led_cb),
                                  GINT_TO_POINTER(unit | (drive_num << 8)));
        /* for some reason we need to set the crossing event handlers on the led
         * itself, otherwise changing the mouse pointer on hover doesn't work. */
        g_signal_connect(led,
                         "enter-notify-event",
                         G_CALLBACK(ui_statusbar_cross_cb),
                         &allocated_bars[bar_index]);
        g_signal_connect(led,
                         "leave-notify-event",
                         G_CALLBACK(ui_statusbar_cross_cb),
                         &allocated_bars[bar_index]);

        /* wrap the widgets into a grid */
        drive_grid = gtk_grid_new();
        gtk_widget_set_hexpand(drive_grid, FALSE);
        gtk_widget_set_vexpand(drive_grid, FALSE);

        gtk_grid_attach(GTK_GRID(drive_grid), number, DRIVE_STATUS_NUMBER, 0, 1, 1);
        gtk_grid_attach(GTK_GRID(drive_grid), track, DRIVE_STATUS_HEAD, 0, 1, 1);
        gtk_grid_attach(GTK_GRID(drive_grid), led, DRIVE_STATUS_LED, 0, 1, 1);
        gtk_widget_show_all(drive_grid);


        event_box = gtk_event_box_new();
        gtk_event_box_set_visible_window(GTK_EVENT_BOX(event_box), FALSE);
        /* FIXME: unit number should be passed as-is, not as index! */
        g_signal_connect(event_box,
                         "button-press-event",
                         G_CALLBACK(ui_do_drive_popup),
                         GINT_TO_POINTER(unit | (drive_num << 8)));
        g_signal_connect(event_box,
                         "enter-notify-event",
                         G_CALLBACK(ui_statusbar_cross_cb),
                         &allocated_bars[bar_index]);
        g_signal_connect(event_box,
                         "leave-notify-event",
                         G_CALLBACK(ui_statusbar_cross_cb),
                         &allocated_bars[bar_index]);

        gtk_container_add(GTK_CONTAINER(event_box), drive_grid);
        gtk_widget_show_all(event_box);

        gtk_grid_attach(GTK_GRID(grid), event_box, 0, drive_num, 1, 1);
    }

    gtk_widget_show_all(grid);
    return grid;
}


/** \brief  Get disk unit widget
 *
 * \param[in]   bar     status bar index (0 or 1)
 * \param[in]   unit    unit number (8-11)
 *
 * \return  GtkGrid
 */
static GtkWidget *drive_get_unit_widget(int bar, int unit)
{
    return allocated_bars[bar].drive_unit[unit - DRIVE_UNIT_MIN];
}


/** \brief  Get drive status widget
 *
 * \param[in]   bar     status bar index (0 or 1)
 * \param[in]   unit    unit number (8-11)
 * \param[in]   drive   drive number (0 or 1)
 *
 * \return  GtkEventBox containing the GtkGrid with the drive widgets
 *
 * \note    Perhaps this can be changed to return the contained GtkGrid if we
 *          find out we never need to work directly with the GtkEventBox.
 */
static GtkWidget *drive_get_drive_widget(int bar, int unit, int drive)
{
    GtkWidget *unit_widget;

    unit_widget = allocated_bars[bar].drive_unit[unit - DRIVE_UNIT_MIN];
    return gtk_grid_get_child_at(GTK_GRID(unit_widget), 0, drive);
}


/** \brief  Get child widget of a drive status widget
 *
 * \param[in]   bar     status bar index (0 or 1)
 * \param[in]   unit    unit number (8-11)
 * \param[in]   drive   drive number (0 or 1)
 * \param[in]   column  column, see #DRIVE_STATUS_NUMBER, #DRIVE_STATUS_HEAD,
 *                      #DRIVE_STATUS_LED
 *
 * \return  Child widget
 */
static GtkWidget *drive_get_child_widget(int bar, int unit, int drive, int column)
{
    GtkWidget *event_box;
    GtkWidget *grid;

    event_box = drive_get_drive_widget(bar, unit, drive);
    if (event_box != NULL) {
        grid = gtk_bin_get_child(GTK_BIN(event_box));
        if (grid != NULL) {
            return gtk_grid_get_child_at(GTK_GRID(grid), column, 0);
        }
    }
    return NULL;
}


/** \brief  Get widget displaying the unit[:drive] number
 *
 * \param[in]   bar     status bar index (0 or 1)
 * \param[in]   unit    unit number (8-11)
 * \param[in]   drive   drive number (0 or 1)
 *
 * \return  GtkLabel
 */
static GtkWidget *drive_get_number_widget(int bar, int unit, int drive)
{
    return drive_get_child_widget(bar, unit, drive, DRIVE_STATUS_NUMBER);
}


/** \brief  Get widget displaying the drive head position
 *
 * \param[in]   bar     status bar index (0 or 1)
 * \param[in]   unit    unit number (8-11)
 * \param[in]   drive   drive number (0 or 1)
 *
 * \return  GtkLabel
 */
static GtkWidget *drive_get_head_widget(int bar, int unit, int drive)
{
    return drive_get_child_widget(bar, unit, drive, DRIVE_STATUS_HEAD);
}


/** \brief  Get widget displaying the LED
 *
 * \param[in]   bar     status bar index (0 or 1)
 * \param[in]   unit    unit number (8-11)
 * \param[in]   drive   drive number (0 or 1)
 *
 * \return  GtkDrawingArea
 */
static GtkWidget *drive_get_led_widget(int bar, int unit, int drive)
{
    return drive_get_child_widget(bar, unit, drive, DRIVE_STATUS_LED);
}


/** \brief  Callback for the disk directory popup menu
 *
 * Autostarts the selected file in the directory
 *
 * \param[in]   image   image name
 * \param[in]   index   directory index of the file to start
 * \param[in]   device  device number (0-3)
 * \param[in]   drive   drive number (0 or 1) of device
 */
static void disk_dir_autostart_callback(const char *image,
                                        int index,
                                        int device,
                                        unsigned int drive)
{
    char *autostart_image;

    /* make a copy of the image name since autostart will reattach the disk
     * image, freeing memory used by the image name passed to us in the process
     */
    autostart_image = lib_strdup(image);
    autostart_disk(device + 8, drive, autostart_image, NULL, index + 1, AUTOSTART_MODE_RUN);
    lib_free(autostart_image);
}


/** \brief  Callback for the tape directory popup menu
 *
 * Autostarts the selected file in the directory
 *
 * \param[in]   image   image name
 * \param[in]   index   directory index of the file to start
 * \param[in]   device  device number (unused, but perhaps useful for PET)
 * \param[in]   drive   drive number (unused)
 */
static void tape_dir_autostart_callback(const char *image,
                                        int index,
                                        int device,
                                        unsigned int drive)
{
    char *autostart_image;

    /* make a copy of the image name since autostart will reattach the tape
     * image, freeing memory used by the image name passed to us in the process
     */
    autostart_image = lib_strdup(image);
    autostart_tape(autostart_image, NULL, index + 1, AUTOSTART_MODE_RUN, TAPEPORT_PORT_1 /* FIXME */);
    lib_free(autostart_image);
}


/** \brief Create a new tape widget for inclusion in the status bar.
 *
 * \param[in]   port    port number
 * \param[in]   bar     status bar index
 *
 *  \return The constructed widget. This widget will be a floating
 *          reference.
 */
static GtkWidget *ui_tape_widget_create(int port, int bar)
{
    GtkWidget *grid;
    GtkWidget *header;
    GtkWidget *counter;
    GtkWidget *motor;
    gchar title[256];

    mainlock_assert_is_not_vice_thread();

    grid = gtk_grid_new();
    gtk_widget_set_hexpand(grid, FALSE);
    gtk_widget_set_vexpand(grid, FALSE);

    if (machine_class == VICE_MACHINE_PET) {
        g_snprintf(title, sizeof(title), "Tape #%d:", port);
        header = gtk_label_new(title);
    } else {
        header = gtk_label_new("Tape:");
    }
    gtk_widget_set_hexpand(header, FALSE);
    gtk_widget_set_halign(header, GTK_ALIGN_START);
    gtk_widget_set_margin_end(header, 8);

    counter = gtk_label_new("?");

    motor = gtk_drawing_area_new();
    gtk_widget_set_size_request(motor, 20, 20);
    /* Labels will notice clicks by default, but drawing areas need to
     * be told to. */
    gtk_widget_add_events(motor, GDK_BUTTON_PRESS_MASK|GDK_ENTER_NOTIFY_MASK|GDK_LEAVE_NOTIFY_MASK);
    g_signal_connect(motor, "enter-notify-event",
            G_CALLBACK(ui_statusbar_cross_cb), &allocated_bars[bar]);
    g_signal_connect(motor, "leave-notify-event",
            G_CALLBACK(ui_statusbar_cross_cb), &allocated_bars[bar]);

    gtk_grid_attach(GTK_GRID(grid), header, TAPE_STATUS_COL_HEADER, 0, 1, 1);
    gtk_grid_attach(GTK_GRID(grid), counter, TAPE_STATUS_COL_COUNTER, 0, 1, 1);
    gtk_grid_attach(GTK_GRID(grid), motor, TAPE_STATUS_COL_MOTOR, 0, 1, 1);
    g_signal_connect_unlocked(motor,
                              "draw",
                              G_CALLBACK(draw_tape_icon_cb),
                              GINT_TO_POINTER(port - 1));

    return grid;
}


/** \brief Create a bitfield of enabled joyports for detecting changes
 */
static uint32_t build_active_joyport_mask(void)
{
    int active_joyport_mask = 0;
    int i;

    for (i = 0; i < JOYPORT_MAX_PORTS; ++i) {
        active_joyport_mask <<= 1;
        if (joyport_port_is_active(i)) {
            active_joyport_mask |= 1;
        }
    }

    return active_joyport_mask;
}

/** \brief Alter widget visibility within the joyport widget so that
 *         only currently existing joystick ports are displayed.
 */
static void update_joyport_layout(void)
{
    int i;
    int j;

    for (j = 0; j < MAX_STATUS_BARS; ++j) {
        GtkWidget *joyports_grid;
        GtkWidget *child;
        int active;

        if (allocated_bars[j].joysticks == NULL) {
            continue;
        }
        joyports_grid =  gtk_bin_get_child(GTK_BIN(allocated_bars[j].joysticks));

        /* Hide and show the joystick ports as required */
        active = 0;     /* count number of active joysticks */
        for (i = 0; i < JOYPORT_MAX_PORTS; ++i) {
            child = gtk_grid_get_child_at(GTK_GRID(joyports_grid),
                                          i + JOYSTICK_COL_STATUS, 0);
            if (child) {
                if (joyport_port_is_active(i)) {
                    gtk_widget_set_no_show_all(child, FALSE);
                    gtk_widget_show_all(child);
                    active++;
                } else {
                    gtk_widget_set_no_show_all(child, TRUE);
                    gtk_widget_hide(child);
                }
            }
        }
        /* Hide the label when no joysticks are active */
        child = gtk_grid_get_child_at(GTK_GRID(joyports_grid),
                                      JOYSTICK_COL_LABEL, 0);
        if (child != NULL) {
            if (active == 0) {
                /* hide the label */
                gtk_widget_hide(child);
            } else {
                gtk_widget_show(child);
            }
        }
    }
}


/** \brief  Create a master joyport widget for inclusion in the status bar.
 *
 *  Individual joyport representations are part of this widget and
 *  update functions will index the GtkGrid in the master widget to
 *  reach them.
 *
 *  \return The constructed widget. This widget will be a floating
 *          reference.
 */
static GtkWidget *ui_joystick_widget_create(void)
{
    GtkWidget *grid;
    GtkWidget *label;
    GtkWidget *event_box;
    int i;

    mainlock_assert_is_not_vice_thread();

    grid = gtk_grid_new();
    gtk_orientable_set_orientation(GTK_ORIENTABLE(grid),
            GTK_ORIENTATION_HORIZONTAL);
    gtk_widget_set_hexpand(grid, FALSE);
    label = gtk_label_new("Joysticks:");
    gtk_widget_set_halign(label, GTK_ALIGN_START);
    gtk_widget_set_hexpand(label, FALSE);
    gtk_widget_set_margin_end(label, 8);
    gtk_container_add(GTK_CONTAINER(grid), label);
    /* Create all possible joystick displays */
    for (i = 0; i < JOYPORT_MAX_PORTS; ++i) {
        GtkWidget *joyport = gtk_drawing_area_new();
        /* add events it should respond to */
        gtk_widget_add_events(joyport,
                GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK|
                GDK_ENTER_NOTIFY_MASK|GDK_LEAVE_NOTIFY_MASK);
        gtk_widget_set_size_request(joyport,20,20);
        gtk_container_add(GTK_CONTAINER(grid), joyport);
        g_signal_connect_unlocked(joyport, "draw", G_CALLBACK(draw_joyport_cb),
                GINT_TO_POINTER(i));
        g_signal_connect(joyport, "enter-notify-event",
                G_CALLBACK(on_joystick_widget_hover), NULL);
        g_signal_connect(joyport, "leave-notify-event",
                G_CALLBACK(on_joystick_widget_hover), NULL);
        gtk_widget_set_no_show_all(joyport, TRUE);
        gtk_widget_hide(joyport);
    }

    /*
     * Pack the joystick grid into an event box so we can have a popup menu and
     * also change the cursor shape to indicate to the user the joystick widget
     * is clickable.
     */
    event_box = gtk_event_box_new();
    gtk_event_box_set_visible_window(GTK_EVENT_BOX(event_box), FALSE);
    gtk_container_add(GTK_CONTAINER(event_box), grid);

    g_signal_connect(event_box, "button-press-event",
            G_CALLBACK(on_joystick_widget_button_press), NULL);
    g_signal_connect(event_box, "enter-notify-event",
            G_CALLBACK(on_joystick_widget_hover), NULL);
    g_signal_connect(event_box, "leave-notify-event",
            G_CALLBACK(on_joystick_widget_hover), NULL);

    return event_box;
}


/** \brief Lay out the disk drive widgets inside a status bar.
 *
 * Enable/disable unit, drive, LED widgets based on current configuration.
 *
 * \param[in]   bar_index   Which status bar to lay out.
 */
static void layout_statusbar_drives(ui_sb_state_t *state_snapshot, int bar_index)
{
    int unit;
    int state;
    int tde;
    GtkWidget *bar = allocated_bars[bar_index].bar;

    if (bar == NULL) {
        return;
    }

    state = state_snapshot->drives_enabled;
    tde = state_snapshot->drives_tde_enabled;

    for (unit = DRIVE_UNIT_MIN; unit <= DRIVE_UNIT_MAX; unit++) {
        GtkWidget *unit_widget;
        GtkWidget *drive0_widget;
        GtkWidget *drive1_widget;
        GtkWidget *led0_widget;
        GtkWidget *led1_widget;
        unsigned int dual;

        unit_widget = drive_get_unit_widget(bar_index, unit);
        drive0_widget = drive_get_drive_widget(bar_index, unit, DRIVE_UNIT_DRIVE_0);
        drive1_widget = drive_get_drive_widget(bar_index, unit, DRIVE_UNIT_DRIVE_1);
        led0_widget = drive_get_led_widget(bar_index, unit, DRIVE_UNIT_DRIVE_0);
        led1_widget = drive_get_led_widget(bar_index, unit, DRIVE_UNIT_DRIVE_1);
        dual = drive_check_dual(diskunit_context[unit - DRIVE_UNIT_MIN]->type);

        /* update unit and drives visibility */
        if (state & 1) {
            gtk_widget_show(unit_widget);
            gtk_widget_show(drive0_widget);
            if (dual) {
                gtk_widget_show(drive1_widget);
            } else {
                gtk_widget_hide(drive1_widget);
            }
        } else {
            gtk_widget_hide(unit_widget);
            gtk_widget_hide(drive0_widget);
            gtk_widget_hide(drive1_widget);
        }
        /* update LED visibility */
        if (tde & 1) {
            gtk_widget_show(led0_widget);
            gtk_widget_show(led1_widget);
        } else {
            gtk_widget_hide(led0_widget);
            gtk_widget_hide(led1_widget);
        }

        state >>= 1;
        tde >>= 1;
        dual >>= 1;
    }
}


/** \brief  Callback for the 'attach' disk popup menu item
 *
 * Trigger the proper 'attach' UI action for the given unit and drive.
 *
 * \param[in]   item    menu item (unused)
 * \param[in]   data    unit and drive number
 *
 * \return  `TRUE`
 */
static gboolean on_disk_attach(GtkWidget *item, gpointer data)
{
    gint unit;
    gint drive;

    unit = GPOINTER_TO_INT(data) >> 8;
    drive = GPOINTER_TO_INT(data) & 0xff;
    ui_action_trigger(ui_action_id_drive_attach(unit, drive));
    return TRUE;
}


/** \brief  Callback for the 'attach' disk popup menu item
 *
 * Trigger the proper 'detach' UI action for the given unit and drive.
 *
 * \param[in]   item    menu item (unused)
 * \param[in]   data    unit and drive number
 *
 * \return  `TRUE`
 */

static gboolean on_disk_detach(GtkWidget *item, gpointer data)
{
    gint unit;
    gint drive;

    unit = GPOINTER_TO_INT(data) >> 8;
    drive = GPOINTER_TO_INT(data) & 0xff;
    ui_action_trigger(ui_action_id_drive_detach(unit, drive));
    return TRUE;
}


/** \brief Create a popup menu to attach to a disk drive widget.
 *
 *  \param[in]  unit    unit number (8-11)
 *  \param[in]  drive   drive number (0 or 1)
 *
 *  \return The GtkMenu for use as a popup, as a floating reference.
 */
static GtkWidget *ui_drive_menu_create(gint unit, gint drive)
{
    GtkWidget *drive_menu;
    GtkWidget *drive_menu_item;

    mainlock_assert_is_not_vice_thread();

    drive_menu = gtk_menu_new();
    drive_menu_item = gtk_menu_item_new_with_label("Attach <fill-in-details>");
    g_signal_connect(drive_menu_item, "activate",
            G_CALLBACK(on_disk_attach),
            UNIT_DRIVE_TO_PTR(unit, drive));
    gtk_container_add(GTK_CONTAINER(drive_menu), drive_menu_item);

    drive_menu_item = gtk_menu_item_new_with_label("Detach <fill-in-details>");
    g_signal_connect(drive_menu_item, "activate",
                     G_CALLBACK(on_disk_detach),
                     UNIT_DRIVE_TO_PTR(unit, drive));
    gtk_container_add(GTK_CONTAINER(drive_menu), drive_menu_item);

    /* GTK2/GNOME UI put TDE and Read-only checkboxes here, but that
     * seems excessive or possibly too fine-grained, so skip that for
     * now. Also: make fliplist usable for drive 1. */
    ui_populate_fliplist_menu(drive_menu, unit, drive);
    gtk_container_add(GTK_CONTAINER(drive_menu),
            gtk_separator_menu_item_new());

    drive_menu_item = gtk_menu_item_new_with_label("Configure drives...");
    g_signal_connect(drive_menu_item, "activate",
            G_CALLBACK(on_drive_configure_activate), NULL);
    gtk_container_add(GTK_CONTAINER(drive_menu), drive_menu_item);

    gtk_widget_show_all(drive_menu);
    return drive_menu;
}


/** \brief  Create volume button for the status bar
 *
 * \return  GtkVolumeButton
 */
static GtkWidget *ui_volume_button_create(void)
{
    GtkWidget *volume;
    int sound_vol = 0;

    volume = gtk_volume_button_new();
    gtk_widget_set_can_focus(volume, FALSE);

    resources_get_int("SoundVolume", &sound_vol);
    gtk_scale_button_set_value(GTK_SCALE_BUTTON(volume),
            (gdouble)sound_vol / 100.0);

    g_object_set(volume, "use-symbolic", TRUE, NULL);

    g_signal_connect(volume, "value-changed",
            G_CALLBACK(on_volume_value_changed), NULL);

    return volume;
}


/** \brief  Callback function for the Warp mode LED
 *
 * \param[in]   led     warp mode LED
 * \param[in]   active  new state of the LED
 */
static void warp_led_callback(GtkWidget *widget, gboolean active)
{
    /* this updates warp state throughout the UI */
    ui_action_trigger(ACTION_WARP_MODE_TOGGLE);
}

/** \brief  Create status bar LED for Warp mode
 *
 * \return  LED widget
 */
static GtkWidget *warp_led_create(void)
{
    GtkWidget *led = statusbar_led_widget_create("warp:", "#00ff00", "#000");

    statusbar_led_widget_set_toggleable(led, TRUE);
    statusbar_led_widget_set_toggle_callback(led, warp_led_callback);
    gtk_widget_show_all(led);
    return led;
}

/** \brief  Set Warp mode LED state
 *
 * \param[in]   bar     status bar index
 * \param[in]   active  LED status
 */
void warp_led_set_active(int bar, gboolean active)
{
    GtkWidget *led = allocated_bars[bar].warp_led;

    if (led != NULL) {
        statusbar_led_widget_set_active(led, active);
    }
}

/** \brief  Callback function for the Pause LED
 *
 * \param[in]   led     pause LED
 * \param[in]   active  new state of the LED
 */
static void pause_led_callback(GtkWidget *widget, gboolean active)
{
    /* this updates pause state throughout the UI */
    ui_action_trigger(ACTION_PAUSE_TOGGLE);
}


/** \brief  Create status bar LED for Pause
 *
 * \return  LED widget
 */
static GtkWidget *pause_led_create(void)
{
    GtkWidget *led = statusbar_led_widget_create("pause:", "#ff0000", "#000");

    statusbar_led_widget_set_toggleable(led, TRUE);
    statusbar_led_widget_set_toggle_callback(led, pause_led_callback);
    gtk_widget_show_all(led);
    return led;
}


/** \brief  Set Pause LED state
 *
 * \param[in]   bar     status bar index
 * \param[in]   active  LED status
 */
void pause_led_set_active(int bar, gboolean active)
{
    GtkWidget *led = allocated_bars[bar].pause_led;

    if (led != NULL) {
        statusbar_led_widget_set_active(led, active);
    }
}

/** \brief  Create status bar LED for shiftlock
 *
 * \return  LED widget
 */
static GtkWidget *shiftlock_led_create(void)
{
    GtkWidget *led = statusbar_led_widget_create("shift-lock:", "#ff0000", "#000");
    /*statusbar_led_widget_set_toggleable(led, TRUE);
      statusbar_led_widget_set_toggle_callback(led, shiftlock_led_callback);*/
    gtk_widget_show_all(led);
    return led;
}


/** \brief  Set shiftlock LED state
 *
 * \param[in]   bar     status bar index
 * \param[in]   active  LED status
 */
void shiftlock_led_set_active(int bar, gboolean active)
{
    GtkWidget *led = allocated_bars[bar].shiftlock_led;

    if (led != NULL) {
        statusbar_led_widget_set_active(led, active);
    }
}

/** \brief  Callback function for the 40/80 LED
 *
 * \param[in]   led     40/80 LED
 * \param[in]   active  new state of the LED
 */
static void mode4080_led_callback(GtkWidget *widget, gboolean active)
{
    keyboard_custom_key_toggle(KBD_CUSTOM_4080);
}

/** \brief  Create status bar LED for 40/80 key
 *
 * \return  LED widget
 */
static GtkWidget *mode4080_led_create(void)
{
    GtkWidget *led = statusbar_led_widget_create("80col:", "#00ff00", "#000");

    statusbar_led_widget_set_toggleable(led, TRUE);
    statusbar_led_widget_set_toggle_callback(led, mode4080_led_callback);
    gtk_widget_show_all(led);
    return led;
}

/** \brief  Set 40/80 LED state
 *
 * \param[in]   bar     status bar index
 * \param[in]   active  LED status
 */
void mode4080_led_set_active(int bar, gboolean active)
{
    GtkWidget *led = allocated_bars[bar].mode4080_led;

    if (led != NULL) {
        statusbar_led_widget_set_active(led, active);
    }
}

/** \brief  Callback function for the capslock LED
 *
 * \param[in]   led     capslock LED
 * \param[in]   active  new state of the LED
 */
static void capslock_led_callback(GtkWidget *widget, gboolean active)
{
    keyboard_custom_key_toggle(KBD_CUSTOM_CAPS);
}

/** \brief  Create status bar LED for capslock key
 *
 * \return  LED widget
 */
static GtkWidget *capslock_led_create(void)
{
    GtkWidget *led = statusbar_led_widget_create("caps:", "#00ff00", "#000");

    statusbar_led_widget_set_toggleable(led, TRUE);
    statusbar_led_widget_set_toggle_callback(led, capslock_led_callback);
    gtk_widget_show_all(led);
    return led;
}

/** \brief  Set capslock LED state
 *
 * \param[in]   bar     status bar index
 * \param[in]   active  LED status
 */
void capslock_led_set_active(int bar, gboolean active)
{
    GtkWidget *led = allocated_bars[bar].capslock_led;

    if (led != NULL) {
        statusbar_led_widget_set_active(led, active);
    }
}

/** \brief  Callback function for the PET diagnostic pin LED
 *
 * \param[in]   led     diagnostic pin LED
 * \param[in]   active  new state of the LED
 */
static void diagnosticpin_led_callback(GtkWidget *widget, gboolean active)
{
    resources_set_int("DiagPin", active ? 1 : 0);
}

static GtkWidget *diagnosticpin_led_create(void)
{
    GtkWidget *led = statusbar_led_widget_create("diag-pin:", "#ffa500", "#000");

    statusbar_led_widget_set_toggleable(led, TRUE);
    statusbar_led_widget_set_toggle_callback(led, diagnosticpin_led_callback);
    gtk_widget_show_all(led);
    return led;
}

/** \brief  Set PET userport diagnostic pin led state
 *
 * \param[in]   bar     status bar index
 * \param[in]   active  new state for led
 */
void diagnosticpin_led_set_active(int bar, gboolean active)
{
    GtkWidget *led = allocated_bars[bar].diagnosticpin_led;

    if (led != NULL) {
        statusbar_led_widget_set_active(led, active);
    }
}

void diagnosticpin_led_set_visible(int bar, gboolean active)
{
    GtkWidget *led = allocated_bars[bar].diagnosticpin_led;

    if (led != NULL) {
        gtk_widget_set_visible(led, active);
        gtk_widget_set_sensitive(led, active);
    }
}

/** \brief  Callback for the SuperCPU turbo LED
 *
 * Set resource "SpeedSwitch" to \a active.
 *
 * \param[in]   self    turbo LED (ignored)
 * \param[in]   active  new LED state
 */
static void supercpu_turbo_led_callback(GtkWidget *self, gboolean active)
{
    resources_set_int("SpeedSwitch", active ? 1 : 0);
}

/** \brief  Create SuperCPU "turbo" led widget
 *
 * \return  LED widget
 */
static GtkWidget *supercpu_turbo_led_create(void)
{
    GtkWidget *led;
    int        speed = 0;

    /* according to images of the actual SuperCPU it has a red LED to indicate
     * turbo mode */
    led = statusbar_led_widget_create("turbo:", "#ff0000", "#000");
    resources_get_int("SpeedSwitch", &speed);
    statusbar_led_widget_set_active(led, speed);
    statusbar_led_widget_set_toggleable(led, TRUE);
    statusbar_led_widget_set_toggle_callback(led, supercpu_turbo_led_callback);
    gtk_widget_show_all(led);
    return led;
}

/** \brief  Set SCPU64 turbo led state
 *
 * \param[in]   bar     status bar index
 * \param[in]   active  new state for led
 */
void supercpu_turbo_led_set_active(int bar, gboolean active)
{
    GtkWidget *led = allocated_bars[bar].supercpu_turbo_led;

    if (led != NULL) {
        statusbar_led_widget_set_active(led, active);
    }
}

/** \brief  Callback for the SuperCPU JiffyDOS LED
 *
 * Set resource "SpeedSwitch" to \a active.
 *
 * \param[in]   self    turbo LED (ignored)
 * \param[in]   active  new LED state
 */
static void supercpu_jiffy_led_callback(GtkWidget *self, gboolean active)
{
    resources_set_int("JiffySwitch", active ? 1 : 0);
}

/** \brief  Create SuperCPU JiffyDOS LED widget
 *
 * \return  LED widget
 */
static GtkWidget *supercpu_jiffy_led_create(void)
{
    GtkWidget *led;
    int        jiffy = 0;

    /* according to images of the actual SuperCPU it has a red LED to indicate
     * turbo mode */
    led = statusbar_led_widget_create("JiffyDOS:", "#00ff00", "#000");
    resources_get_int("JiffySwitch", &jiffy);
    statusbar_led_widget_set_active(led, jiffy);
    statusbar_led_widget_set_toggleable(led, TRUE);
    statusbar_led_widget_set_toggle_callback(led, supercpu_jiffy_led_callback);
    gtk_widget_show_all(led);
    return led;
}

/** \brief  Set SCPU64 JiffyDOS LED state
 *
 * \param[in]   bar     status bar index
 * \param[in]   active  new state for led
 */
void supercpu_jiffy_led_set_active(int bar, gboolean active)
{
    GtkWidget *led = allocated_bars[bar].supercpu_jiffy_led;

    if (led != NULL) {
        statusbar_led_widget_set_active(led, active);
    }
}


/** \brief  Get status bar index for \a window
 *
 * \param[in]   window  GtkWindow instance
 *
 * \return  index or -1 on error
 */
int ui_statusbar_index_for_window(GtkWidget *window)
{
    GtkWidget *bin;

    bin = gtk_bin_get_child(GTK_BIN(window));
    if (bin != NULL) {
        GtkWidget *bar = gtk_grid_get_child_at(GTK_GRID(bin), 0, 2);
        int i;

        for (i = 0; i < MAX_STATUS_BARS; i++) {
            if (allocated_bars[i].bar == bar) {
                return i;
            }
        }
    }
    return -1;
}


/** \brief  Append a widget to the LEDs row of a status bar
 *
 * Append \a led to status bar with index \a bar, optionally adding a
 * separator before the new widget.
 *
 * \param[in]   bar         status bar index
 * \param[in]   widget      widget to append
 * \param[in]   separator   append separator before appending the widget
 */
static void statusbar_append_led(int bar, GtkWidget *led, gboolean separator)
{
    GtkWidget *grid;
    int column;

    /* sanity check */
    if (bar < 0 || bar >= MAX_STATUS_BARS) {
        log_error(LOG_DEFAULT, "Invalid status bar index of %d.", bar);
        return;
    }

    grid = allocated_bars[bar].led_row_grid;
    column = allocated_bars[bar].led_row_column;

    if (separator && column > 0) {
        GtkWidget *sep = gtk_separator_new(GTK_ORIENTATION_VERTICAL);

        gtk_grid_attach(GTK_GRID(grid), sep, column, 0, 1, 1);
        allocated_bars[bar].led_row_column = ++column;
    }

    gtk_grid_attach(GTK_GRID(grid), led, column, 0, 1, 1);
    allocated_bars[bar].led_row_column++;
}


/** \brief  Append a widget to the widgets row of a status bar
 *
 * Append \a widget to status bar with index \a bar, optionally adding a
 * separator before the new widget.
 *
 * \param[in]   bar         status bar index
 * \param[in]   widget      widget to append
 * \param[in]   separator   append separator before appending the widget
 */
static void statusbar_append_widget(int bar, GtkWidget *widget, gboolean separator)
{
    GtkWidget *grid;
    int column;

    /* sanity check */
    if (bar < 0 || bar >= MAX_STATUS_BARS) {
        log_error(LOG_DEFAULT, "Invalid status bar index of %d.", bar);
        return;
    }

    grid = allocated_bars[bar].widget_row_grid;
    column = allocated_bars[bar].widget_row_column;

    if (separator && column > 0) {
        GtkWidget *sep = gtk_separator_new(GTK_ORIENTATION_VERTICAL);

        gtk_grid_attach(GTK_GRID(grid), sep, column, 0, 1, 1);
        allocated_bars[bar].widget_row_column = ++column;
    }

    gtk_grid_attach(GTK_GRID(grid), widget, column, 0, 1, 1);
    allocated_bars[bar].widget_row_column++;
}


/** \brief  Append a widget to the top row of a status bar at the end
 *
 * Append \a widget to status bar with index \a bar.
 *
 * \param[in]   bar         status bar index
 * \param[in]   widget      widget to append
 * \param[in]   separator   append separator before appending the widget
 */
static void statusbar_append_widget_end(int bar, GtkWidget *widget)
{
    GtkWidget *grid;
    int column;

    /* sanity check */
    if (bar < 0 || bar >= MAX_STATUS_BARS) {
        log_error(LOG_DEFAULT, "Invalid status bar index of %d.", bar);
        return;
    }

    grid = allocated_bars[bar].widget_row_grid;
    column = allocated_bars[bar].widget_row_column;

    gtk_widget_set_halign(widget, GTK_ALIGN_END);
    gtk_widget_set_hexpand(widget, TRUE);
    gtk_grid_attach(GTK_GRID(grid), widget, column, 0, 1, 1);
    allocated_bars[bar].widget_row_column++;
}



/*****************************************************************************
 *                              Public functions                             *
 ****************************************************************************/

/** \brief Initialize the status bar subsystem.
 *
 *  \warning This function _must_ be called before any call to
 *           ui_statusbar_create() and _must not_ be called after any
 *           call to it.
 */
void ui_statusbar_init(void)
{
    int i;
    ui_sb_state_t *sb_state;

    /* Most things need initialisation to zero and allocated_bars is
     * static, so not much to do here. */
    for (i = 0; i < MAX_STATUS_BARS; ++i) {
        GtkWidget *grid;


        grid = gtk_grid_new();
        gtk_widget_set_valign(grid, GTK_ALIGN_START);
        gtk_grid_set_column_spacing(GTK_GRID(grid), 8);
        gtk_grid_set_row_spacing(GTK_GRID(grid), 0);
        allocated_bars[i].led_row_grid = grid;
        allocated_bars[i].led_row_column = 0;

        grid = gtk_grid_new();
        gtk_widget_set_valign(grid, GTK_ALIGN_START);
        gtk_grid_set_column_spacing(GTK_GRID(grid), 8);
        gtk_grid_set_row_spacing(GTK_GRID(grid), 0);
        allocated_bars[i].widget_row_grid = grid;
        allocated_bars[i].widget_row_column = 0;

        allocated_bars[i].displayed_tape_counter[0] = -1;
        allocated_bars[i].displayed_tape_counter[1] = -1;
    }

    sb_state = lock_sb_state();
    /* Set an impossible number of joyports to enabled so that the status
     * is guarenteed to be updated. */
    sb_state->active_joyports = ~0;
    unlock_sb_state();
}


/** \brief Clean up any resources the statusbar system uses that
 *         weren't cleaned up when the status bars themselves were
 *         destroyed. */
void ui_statusbar_shutdown(void)
{
    mainlock_assert_is_not_vice_thread();
}


/** \brief  Create a new status bar.
 *
 *  This function should be called once as part of creating a new
 *  machine window.
 *
 *  \param[in]  window_identity window identity
 *
 *  \return A new status bar, as a floating reference, or NULL if all
 *          possible status bars have been allocated already.
 */
GtkWidget *ui_statusbar_create(int window_identity)
{
    GtkWidget *sb;

    /* LEDs */
    GtkWidget *warp_led;
    GtkWidget *pause_led;
    GtkWidget *shiftlock_led = NULL;
    GtkWidget *mode4080_led  = NULL;
    GtkWidget *capslock_led  = NULL;
    GtkWidget *diagpin_led   = NULL;
    GtkWidget *turbo_led     = NULL;
    GtkWidget *jiffy_led     = NULL;

    /* top row widgets/wrappers */
    GtkWidget *speed;
    GtkWidget *checkboxes;
    GtkWidget *tape_and_joy;
    GtkWidget *drive_units;
    GtkWidget *volume;

    GtkWidget *tape_wrapper;
    GtkWidget *tape_status;
    GtkWidget *tape_menu;
    GtkWidget *tape_events;
    GtkWidget *joysticks;
    GtkWidget *sep;
    GtkWidget *crt;
    GtkWidget *mixer;
    GtkWidget *message;
    GtkWidget *recording;
    GtkWidget *kbd_debug_widget;
    int i;
    int j;

    mainlock_assert_is_not_vice_thread();

    for (i = 0; i < MAX_STATUS_BARS; ++i) {
        if (allocated_bars[i].bar == NULL) {
            break;
        }
    }
    if (i == MAX_STATUS_BARS) {
        /* Fatal error (should never happen) */
        log_error(LOG_DEFAULT,
                  "Maxium number of status bars (%d) exceeded.",
                  MAX_STATUS_BARS);
        archdep_vice_exit(1);
    }

    allocated_bars[i].window_identity = window_identity;

    sb = vice_gtk3_grid_new_spaced(8, 0);
    gtk_widget_set_hexpand(sb, FALSE);
    g_signal_connect(sb, "destroy",
                     G_CALLBACK(destroy_statusbar_cb), GINT_TO_POINTER(i));
    allocated_bars[i].bar = sb;

    /* First row: LEDs */
    gtk_grid_attach(GTK_GRID(sb),
                    allocated_bars[i].led_row_grid,
                    SB_COL_LEDS, SB_ROW_LEDS, SB_COLUMN_COUNT, 1);

    /* Second row: horizontal separator */
#if 0
    sep = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
    gtk_grid_attach(GTK_GRID(sb),
                    sep,
                    SB_COL_LEDS, SB_ROW_LEDS_HSEP, SB_COLUMN_COUNT, 1);
#endif
    /* Third row: variable amount of widgets */
    gtk_grid_attach(GTK_GRID(sb),
                    allocated_bars[i].widget_row_grid,
                    SB_COL_WIDGETS, SB_ROW_WIDGETS, SB_COLUMN_COUNT, 1);

    /* Fourth row: horizontal separator */
#if 0
    sep = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
    gtk_grid_attach(GTK_GRID(sb),
                    sep,
                    SB_COL_WIDGETS, SB_ROW_WIDGETS_HSEP, SB_COLUMN_COUNT, 1);
#endif
    /* Fifth row: messages, separator and recording */
    message = gtk_label_new(NULL);
    gtk_widget_set_hexpand(message, TRUE);
    gtk_widget_set_halign(message, GTK_ALIGN_START);
    gtk_label_set_ellipsize(GTK_LABEL(message), PANGO_ELLIPSIZE_END);
    gtk_widget_set_margin_start(message, 8);
    gtk_widget_set_margin_end(message, 8);
    allocated_bars[i].msg = message;
    gtk_grid_attach(GTK_GRID(sb),
                    message,
                    SB_COL_MESSAGES, SB_ROW_MESSAGES, 1, 1);
    /* add vertical separator */
    sep = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
    gtk_grid_attach(GTK_GRID(sb),
                    sep,
                    SB_COL_MESSAGES_VSEP, SB_ROW_MESSAGES, 1, 1);
    /* Recording */
    recording = statusbar_recording_widget_create();
    gtk_widget_set_hexpand(recording, TRUE);
    allocated_bars[i].record = recording;
    gtk_grid_attach(GTK_GRID(sb),
                    recording,
                    SB_COL_RECORDING, SB_ROW_MESSAGES, 1, 1);

    /*
     * Add LEds
     */

    /* Warp mode */
    warp_led = warp_led_create();
    /* add a little margin */
    gtk_widget_set_margin_start(warp_led, 8);
    allocated_bars[i].warp_led = warp_led;
    statusbar_append_led(i, warp_led, FALSE);

    /* Pause */
    pause_led = pause_led_create();
    allocated_bars[i].pause_led = pause_led;
    statusbar_append_led(i, pause_led, FALSE);  /* no separator, for now */

    if (machine_class != VICE_MACHINE_VSID) {
        /* shiftlock */
        shiftlock_led = shiftlock_led_create();
        statusbar_append_led(i, shiftlock_led, FALSE);  /* no separator, for now */
    }
    allocated_bars[i].shiftlock_led = shiftlock_led;

    if (machine_class == VICE_MACHINE_C128) {
        /* 40/80 */
        mode4080_led = mode4080_led_create();
        statusbar_append_led(i, mode4080_led, FALSE);  /* no separator, for now */
        /* capslock */
        capslock_led = capslock_led_create();
        statusbar_append_led(i, capslock_led, FALSE);  /* no separator, for now */
    }
    allocated_bars[i].mode4080_led = mode4080_led;
    allocated_bars[i].capslock_led = capslock_led;

    if (machine_class == VICE_MACHINE_PET) {
        /* userport diagnostic pin */
        diagpin_led = diagnosticpin_led_create();
        statusbar_append_led(i, diagpin_led, FALSE);
    }
    allocated_bars[i].diagnosticpin_led = diagpin_led;

    if (machine_class == VICE_MACHINE_SCPU64) {
        /* SuperCPU SPEED switch (turbo/normal) */
        turbo_led = supercpu_turbo_led_create();
        statusbar_append_led(i, turbo_led, FALSE);
        /* SuperCPU JiffyDOS switch */
        jiffy_led = supercpu_jiffy_led_create();
        statusbar_append_led(i, jiffy_led, FALSE);
    }
    allocated_bars[i].supercpu_turbo_led = turbo_led;
    allocated_bars[i].supercpu_jiffy_led = jiffy_led;

    /*
     * Add widgets to the widgets row
     */
    speed = NULL;
    checkboxes = NULL;
    tape_and_joy = NULL;
    drive_units = NULL;
    volume = NULL;

    /* CPU/FPS - No FPS on VDC Window for now */
    speed = statusbar_speed_widget_create(&allocated_bars[i].speed_state);
    gtk_widget_set_margin_start(speed, 8);
    allocated_bars[i].speed = speed;

    /* CRT and Mixer controls */
    if (machine_class != VICE_MACHINE_VSID) {
        crt = gtk_check_button_new_with_label("CRT");
        gtk_widget_set_can_focus(crt, FALSE);
        gtk_widget_set_halign(crt, GTK_ALIGN_START);
        gtk_widget_set_valign(crt, GTK_ALIGN_START);
        gtk_widget_set_hexpand(crt, FALSE);
        gtk_widget_set_vexpand(crt, FALSE);
        gtk_widget_show_all(crt);
        g_signal_connect(crt, "toggled", G_CALLBACK(on_crt_toggled), NULL);

        mixer = gtk_check_button_new_with_label("Mixer");
        gtk_widget_set_can_focus(mixer, FALSE);
        gtk_widget_set_halign(mixer, GTK_ALIGN_START);
        gtk_widget_set_valign(mixer, GTK_ALIGN_START);
        gtk_widget_set_hexpand(mixer, FALSE);
        gtk_widget_set_vexpand(mixer, FALSE);
        gtk_widget_show_all(mixer);
        g_signal_connect(mixer, "toggled", G_CALLBACK(on_mixer_toggled), NULL);
    } else {
        crt = NULL;
        mixer = NULL;
    }
    allocated_bars[i].crt = crt;
    allocated_bars[i].mixer = mixer;

    /* Mixer/CRT checkboxes (all expect VSID) */
    if (machine_class != VICE_MACHINE_VSID) {
        /* wrap checkboxes in a grid to avoid extra vertical spacing */
        checkboxes = gtk_grid_new();

        gtk_grid_attach(GTK_GRID(checkboxes), crt, 0, 0, 1, 1);
        gtk_grid_attach(GTK_GRID(checkboxes), mixer, 0, 1, 1, 1);

    }

    /* Tape widget(s) and joysticks (neither for VSID) */
    tape_wrapper = NULL;
    joysticks = NULL;
    /* No datasette for DTV, SCPU or VSID */
    if ((machine_class != VICE_MACHINE_C64DTV) &&
            (machine_class != VICE_MACHINE_SCPU64) &&
            (machine_class != VICE_MACHINE_VSID)) {

        int ports = machine_class == VICE_MACHINE_PET ? 2 : 1;

        /* wrap tape widget(s) in a grid */
        tape_wrapper = gtk_grid_new();

        /* add widgets and event boxes */
        for (j = 0; j < ports; j++) {
            int port_number = j + TAPEPORT_UNIT_1;

            tape_status = ui_tape_widget_create(port_number, i);
            tape_menu = ui_create_datasette_control_menu(port_number);

            /* Clicking the tape status is supposed to pop up a window. This
             * requires a way to make sure events are captured by random
             * internal widgets; the GtkEventBox manages that task for us. */
            tape_events = gtk_event_box_new();
            gtk_event_box_set_visible_window(GTK_EVENT_BOX(tape_events), FALSE);
            gtk_container_add(GTK_CONTAINER(tape_events), tape_status);
            gtk_grid_attach(GTK_GRID(tape_wrapper), tape_events, 0, j, 1, 1);

            allocated_bars[i].tape_status[j] = tape_status;
            allocated_bars[i].tape_menu[j] = tape_menu;

            g_signal_connect(tape_events, "button-press-event",
                    G_CALLBACK(ui_do_datasette_popup),
                    GINT_TO_POINTER(i | (port_number << 8)));
            g_signal_connect(tape_events, "enter-notify-event",
                    G_CALLBACK(ui_statusbar_cross_cb), &allocated_bars[i]);
            g_signal_connect(tape_events, "leave-notify-event",
                    G_CALLBACK(ui_statusbar_cross_cb), &allocated_bars[i]);
        }
    }

    /* Joystick widgets: row below tape widget(s) */
    if (machine_class != VICE_MACHINE_VSID) {
        joysticks = ui_joystick_widget_create();
        gtk_widget_set_halign(joysticks, GTK_ALIGN_START);
        allocated_bars[i].joysticks = joysticks;
    }

    /* Append tape widgets and/or joysticks widget to top row */
    if (tape_wrapper != NULL || joysticks != NULL) {
        tape_and_joy = gtk_grid_new();
        int row = 0;

        if (tape_wrapper != NULL) {
            gtk_grid_attach(GTK_GRID(tape_and_joy), tape_wrapper, 0, row++, 1, 1);
        }
        if (joysticks != NULL) {
            gtk_grid_attach(GTK_GRID(tape_and_joy), joysticks, 0, row, 1, 1);
        }
    }


    /* Drive widgets (all expect VSID) */
    if (machine_class != VICE_MACHINE_VSID) {
        drive_units = gtk_grid_new();
        /* results in dual drives of a unit being grouped closer together than the
         * units: */
        gtk_grid_set_row_spacing(GTK_GRID(drive_units), 4);
        gtk_widget_set_hexpand(drive_units, FALSE);
        gtk_widget_set_vexpand(drive_units, FALSE);
        gtk_widget_set_halign(drive_units, GTK_ALIGN_START);
        gtk_widget_set_valign(drive_units, GTK_ALIGN_START);

        for (j = 0; j < NUM_DISK_UNITS; ++j) {
            GtkWidget *drive_unit;
            GtkWidget *drive_menu;
            int drive_num;

            drive_unit = ui_drive_widget_create(j, i);
            gtk_widget_set_hexpand(drive_unit, FALSE);
            allocated_bars[i].drive_unit[j] = drive_unit;
            for (drive_num = 0; drive_num < DRIVE_UNIT_DRIVE_MAX; drive_num++) {
                drive_menu = ui_drive_menu_create(j + DRIVE_UNIT_MIN, drive_num);
                allocated_bars[i].drive_menu[j][drive_num] = drive_menu;
            }
            gtk_grid_attach(GTK_GRID(drive_units), drive_unit, unit_cols[j], unit_rows[j], 1, 1);
        }
    }

    /*
     * Add volume control widget
     *
     * FIXME: The widget doesn't show on MacOS/Windows due to the rendering
     *        canvas somehow having z-index priority over the widget. This
     *        works fine on Linux (as far as we know).
     */
#if (!defined(WINDOWS_COMPILE)) && (!defined(MACOS_COMPILE))
    volume = ui_volume_button_create();
    gtk_widget_set_hexpand(volume, TRUE);
#else
    /* Windows or MacOS, only create the volume button for VSID */
    if (machine_class == VICE_MACHINE_VSID) {
        volume = ui_volume_button_create();
        gtk_widget_set_hexpand(volume, TRUE);
    }
#endif
    allocated_bars[i].volume = volume;

    /*
     * Add all valid widgets to the top row
     */
    if (speed != NULL) {
        statusbar_append_widget(i, speed, FALSE);
    }
    if (checkboxes != NULL) {
        statusbar_append_widget(i, checkboxes, TRUE);
    }
    if (tape_and_joy != NULL) {
        statusbar_append_widget(i, tape_and_joy, TRUE);
    }
    if (drive_units != NULL) {
        statusbar_append_widget(i, drive_units, TRUE);
    }
    if (volume != NULL) {
        statusbar_append_widget_end(i, volume);
    }

    /*
     * Add keyboard debugging widget (all except VSID)
     */
    if (machine_class != VICE_MACHINE_VSID) {
        sep = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
        gtk_grid_attach(GTK_GRID(sb),
                        sep,
                        SB_COL_MESSAGES, SB_ROW_MESSAGES_HSEP, SB_COLUMN_COUNT, 1);

        kbd_debug_widget = kbd_debug_widget_create();
        allocated_bars[i].kbd_debug = kbd_debug_widget;
        gtk_grid_attach(GTK_GRID(sb),
                        kbd_debug_widget,
                        SB_COL_KBD_DEBUG, SB_ROW_KBD_DEBUG, SB_COLUMN_COUNT, 1);
    }

    return sb;
}


/** \brief Statusbar API function to register an elapsed time.
 *
 *  \param current The current time value in seconds
 *  \param total   The maximum time value in seconds
 *
 */
void ui_display_event_time(unsigned int current, unsigned int total)
{
    GtkWidget *widget;

    /* Ok to call from VICE thread */
    widget = allocated_bars[0].record;
    statusbar_recording_widget_set_time(widget, current, total);
}


/** \brief Statusbar API function to display playback status.
 *
 *  \param playback_status  Unknown.
 *  \param version          seems to be the VICE version major.minor during
 *                          playback and `NULL` when playback is done.
 *
 *  \todo This function is not implemented and its API is not
 *        understood.
 *
 * \note    Since the statusbar message display widget has been removed, we
 *          have some space to implement a widget to display information
 *          regarding playback/recording.
 */
void ui_display_playback(int playback_status, char *version)
{
    GtkWidget *widget = allocated_bars[0].record;

    /* Ok to call from VICE thread */
    statusbar_recording_widget_set_event_playback(widget, version);
}

/** \brief  Statusbar API function to display recording status.
 *
 *  \param  recording_status    seems to be bool indicating recording active
 *
 *  \todo   This function is not implemented and its API is not
 *          understood.
 *
 * \note    Since the statusbar message display widget has been removed, we
 *          have some space to implement a widget to display information
 *          regarding playback/recording.
 */
void ui_display_recording(int recording_status)
{
    GtkWidget *widget;

    /* Ok to call from VICE thread */
    widget = allocated_bars[0].record;
    statusbar_recording_widget_set_recording_status(widget, recording_status);
}


/** \brief  Statusbar API function to display a message in the status bar.
 *
 *  \param  text    The text to display.
 *  \param  fadeout Erase the text after five* seconds unless it has already
 *                  been replaced.
 *
 * \note    Safe to call from VICE thread.
 * \see     #MESSAGE_TIMEOUT for the actual timeout in seconds
 */
void ui_display_statustext(const char *text, bool fadeout)
{
    ui_sb_state_t *sb_state = lock_sb_state();

    strncpy(sb_state->message_text, text, MESSAGE_TEXT_SIZE);
    /* strncpy() doesn't add a 0 when len(text) == buflen: */
    sb_state->message_text[MESSAGE_TEXT_SIZE - 1] = '\0';
    sb_state->message_fadeout = fadeout;
    sb_state->message_pending = true;

    unlock_sb_state();
}

/** \brief  Statusbar API function to display current volume
 *
 * This function is a NOP since the volume can be checked and altered via the
 * Mixer Controls via the statusbar.
 *
 * \param[in]   vol     new volume level
 */
void ui_display_volume(int vol)
{
    /* NOP */
}


/** \brief  Statusbar API function to display current joyport inputs.
 *  \param  joyport An array of bytes of size at least
 *                  JOYPORT_MAX_PORTS+1, with data regarding each
 *                  active joyport.
 *  \warning The joyport array is, for all practical purposes,
 *           _1-indexed_. joyport[0] is unused.
 *  \sa ui_sb_state_s::current_joyports Describes the format of the
 *      data encoded in the joyport array. Note that current_joyports
 *      is 0-indexed as is typical for C arrays.
 */

/* FIXME: during the joystick data extension the joyport type has become uint16_t,
   I did not change anything except the parameter of the function
 */
void ui_display_joyport(uint16_t *joyport)
{
    int i;
    ui_sb_state_t *sb_state;

    sb_state = lock_sb_state();

    for (i = 0; i < JOYPORT_MAX_PORTS; ++i) {
        /* Compare the new value to the current one, set the new
         * value, and queue a redraw if and only if there was a
         * change. And yes, the input joystick ports are 1-indexed. I
         * don't know either. */
        if (sb_state->current_joyports[i] != joyport[i+1]) {
            int j;
            sb_state->current_joyports[i] = joyport[i+1];
            for (j = 0; j < MAX_STATUS_BARS; ++j) {
                if (allocated_bars[j].joysticks) {
                    GtkWidget *grid;
                    GtkWidget *widget;

                    grid = gtk_bin_get_child(GTK_BIN(allocated_bars[j].joysticks));
                    widget = gtk_grid_get_child_at(GTK_GRID(grid), i + 1, 0);
                    if (widget) {
                        redraw_widget_on_ui_thread(widget);
                    }
                }
            }
        }
    }

    unlock_sb_state();
}


/** \brief  Get tape motor widget by tape port index
 *
 * \param[in]   bar     status bar index
 * \param[in]   port    tape port index
 *
 * \return  tape motor widget or NULL if not present
 */
static GtkWidget *tape_get_motor_widget(int bar, int port)
{
    GtkWidget *status;
    GtkWidget *motor = NULL;

    status = allocated_bars[bar].tape_status[port];
    if (status != NULL) {
        motor = gtk_grid_get_child_at(GTK_GRID(status), TAPE_STATUS_COL_MOTOR, 0);
    }
    return motor;
}


/** \brief  Statusbar API function to report changes in tape control status.
 *
 * \param[in]   port    tape port index (0 or 1)
 * \param[in]   control The new tape control. See the DATASETTE_CONTROL_*
 *                      constants in datasette.h for legal values of this
 *                      parameter.
 */
void ui_display_tape_control_status(int port, int control)
{
    ui_sb_state_t *sb_state;

    /* Ok to call from VICE thread */

    sb_state = lock_sb_state();

    if (control != sb_state->tape_control[port]) {
        int i;
        sb_state->tape_control[port] = control;

        for (i = 0; i < MAX_STATUS_BARS; ++i) {
            GtkWidget *motor = tape_get_motor_widget(i, port);
            if (motor != NULL) {
                redraw_widget_on_ui_thread(motor);
            }
        }
    }

    unlock_sb_state();
}

/** \brief  Statusbar API function to report changes in tape position.
 *
 * \param[in]   port    tape port index (0 or 1)
 * \param[in]   counter the new value of the position counter
 *
 *  \note   Only the last three digits of the counter will be displayed.
 */
void ui_display_tape_counter(int port, int counter)
{
    ui_sb_state_t *sb_state;
    int index = port;

    sb_state = lock_sb_state();
    sb_state->tape_counter[index] = counter;
    unlock_sb_state();
}


/** \brief  Statusbar API function to report changes in the tape motor.
 *
 * \param[in]   port    tape port index (0 or 1)
 * \param[in]   motor   Nonzero if the tape motor is now on.
 */
void ui_display_tape_motor_status(int port, int motor)
{
    ui_sb_state_t *sb_state;

    /* Ok to call from VICE thread */
    sb_state = lock_sb_state();

    if (motor != sb_state->tape_motor_status[port]) {
        int i;
        sb_state->tape_motor_status[port] = motor;

        for (i = 0; i < MAX_STATUS_BARS; ++i) {
            GtkWidget *widget = tape_get_motor_widget(i, port);

            if (widget != NULL) {
                redraw_widget_on_ui_thread(widget);
            }
        }
    }

    unlock_sb_state();
}


/** \brief  Statusbar API function to report changes in tape status.
 *  \param  tape_status The new tape status.
 *  \note   This function does nothing and its API is not
 *          understood. Furthermore, no other extant UIs appear to react
 *          to this call.
 */
void ui_set_tape_status(int port, int tape_status)
{
    /* Ok to call from VICE thread */
}


/** \brief  Statusbar API function to report mounting or unmounting of a tape
 *          image.
 *
 *  \param  image   The filename of the tape image (if mounted), or the
 *                  empty string or NULL (if unmounting).
 */
void ui_display_tape_current_image(int port, const char *image)
{
}


/** \brief  Statusbar API function to report changes in drive LED intensity.
 *
 * This function simply updates global state, rendering occurs in ui_update_statusbars().
 *
 *  \param  drive_number    The unit to update (0-3 for drives 8-11)
 *  \param  drive_base      Drive 0 or 1 of dualdrives
 *  \param  led_pwm1        The intensity of the first LED (0=off,
 *                          1000=maximum intensity)
 *  \param  led_pwm2        The intensity of the second LED (0=off,
 *                          1000=maximum intensity)
 *  \todo   Dual drive code doesn't have its separate Error LED.
 *          Its setting is mixed in in the led_status of drive 0.
 *          Also those error LEDs don't flash but are just on
 *          (or on some models, change the green/red LED to red).
 */
void ui_display_drive_led(unsigned int drive_number,
                          unsigned int drive_base,
                          unsigned int led_pwm1,
                          unsigned int led_pwm2)
{
    ui_sb_state_t *sb_state;

    /* Ok to call from VICE thread */

    if (drive_number > NUM_DISK_UNITS - 1) {
        /* TODO: Fatal error? */
        debug_gtk3("Error: illegal drive number %u.", drive_number);
        abort();
    }

    sb_state = lock_sb_state();
    sb_state->current_drive_leds[drive_number][drive_base][0] = led_pwm1;
    sb_state->current_drive_leds[drive_number][drive_base][1] = led_pwm2;
    sb_state->current_drive_leds_updated[drive_number][drive_base][0] = true;
    sb_state->current_drive_leds_updated[drive_number][drive_base][1] = true;
    unlock_sb_state();
}


/** \brief  Statusbar API function to report changes in drive head location.
 *
 * This function simply updates global state, rendering occurs in ui_update_statusbars().
 *
 *  \param  drive_number        The unit to update (0-3 for drives 8-11)
 *  \param  drive_base          Drive 0 or 1 of dualdrives
 *  \param  half_track_number   Twice the value of the head
 *                              location. 18.0 is 36, while 18.5 would be 37.
 *  \param  drive_side          drive side for dual-head drives (0 or 1)
 *
 *  \todo   The statusbar API does not yet support dual-unit disk
 *          drives. The drive_base argument will likely come into play
 *          once it does.
 */
void ui_display_drive_track(unsigned int drive_number,
                            unsigned int drive_base,
                            unsigned int half_track_number,
                            unsigned int drive_side)
{
    ui_sb_state_t *sb_state;
    int doubleside, dualdrive;

    /* Ok to call from VICE thread */

    if (drive_number > NUM_DISK_UNITS - 1) {
        /* TODO: Fatal error? */
        return;
    }

    sb_state = lock_sb_state();
    doubleside = drive_get_num_heads(sb_state->drives_type[drive_number]) == 2 ? 1 : 0;
    dualdrive = drive_check_dual(sb_state->drives_type[drive_number]);

    if (dualdrive) {
        snprintf(
            sb_state->current_drive_unit_str[drive_number][drive_base],
            DRIVE_UNIT_STR_MAX_LEN - 1,
            "%u:%u",
            drive_number + 8,
            drive_base);
    } else {
        snprintf(
            sb_state->current_drive_unit_str[drive_number][drive_base],
            DRIVE_UNIT_STR_MAX_LEN - 1,
            "%u",
            drive_number + 8);
    }
    sb_state->current_drive_unit_str[drive_number][drive_base][DRIVE_UNIT_STR_MAX_LEN - 1] = '\0';
    sb_state->current_drive_unit_str_updated[drive_number][drive_base] = true;

    if (doubleside) {
        snprintf(
            sb_state->current_drive_track_str[drive_number][drive_base],
            DRIVE_TRACK_STR_MAX_LEN - 1,
            " %u:%04.1lf",  /* space instead of 0 padding looks weird with the
                               drive side in front */
            drive_side,
            half_track_number / 2.0);
    } else {
        snprintf(
            sb_state->current_drive_track_str[drive_number][drive_base],
            DRIVE_TRACK_STR_MAX_LEN - 1,
            " %4.1lf",
            half_track_number / 2.0);
    }

    sb_state->current_drive_track_str[drive_number][drive_base][DRIVE_TRACK_STR_MAX_LEN - 1] = '\0';
    sb_state->current_drive_track_str_updated[drive_number][drive_base] = true;

    unlock_sb_state();
}


/** \brief Update information about each drive.
 *
 *  \param state           A bitmask int, where bits 0-3 indicate
 *                         whether or not drives 8-11 respectively are
 *                         being emulated carefully enough to provide
 *                         LED information.
 *  \param drive_led_color An array of size at least NUM_DISK_UNITS that
 *                         provides information about the LEDs on this
 *                         drive. An element of this array will only
 *                         be checked if the corresponding bit in
 *                         state is 1.
 *  \note Before calling this function, the drive configuration
 *        resources (Drive8Type, Drive9Type, etc) should all be set to
 *        the values you wish to display.
 *  \warning If a drive's LEDs are active when its LED values change,
 *           the UI will not reflect the LED type change until the
 *           next time the led's values are updated. This should not
 *           happen under normal circumstances.
 *  \sa compute_drives_enabled_mask() for how this function determines
 *      which drives are truly active
 *  \sa ui_sb_state_s::drive_led_types for the data in each element of
 *      drive_led_color
 */
void ui_enable_drive_status(ui_drive_enable_t state, int *drive_led_color)
{
    int unit, enabled, drive, i;
    ui_sb_state_t *sb_state;

    /* Ok to call from VICE thread */

    sb_state = lock_sb_state();

    /* Update the drive LEDs first, unconditionally. */
    enabled = state;
    for (unit = 0; unit < NUM_DISK_UNITS; ++unit) {
        for (drive = 0; drive < 2; drive++) {
            if (enabled & 1) {
                for (i = 0; i < DRIVE_LEDS_MAX; i++) {
                    sb_state->drive_led_types[unit][drive][i] = (drive_led_color[unit] >> i) & 1;
                    sb_state->current_drive_leds[unit][drive][i] = 0;
                }
            }
        }
        enabled >>= 1;
    }

    /* Determine drive types and determine dual-drive changes */
    sb_state->drives_dual = 0;
    for (unit = 0; unit < NUM_DISK_UNITS; unit++) {
        int curtype;
        bool old_dual;
        bool new_dual;

        if (resources_get_int_sprintf("Drive%dType", &curtype, unit + DRIVE_UNIT_MIN) < 0) {
            curtype = 0;
        }
        old_dual = (bool)drive_check_dual(sb_state->drives_type[unit]);
        new_dual = (bool)drive_check_dual(curtype);
        if (old_dual != new_dual) {
            sb_state->drives_dual |= 1 << unit;
        }

        /* update drive type */
        sb_state->drives_type[unit] = curtype;
    }

    /* Now give enabled its "real" value based on the drive
     * definitions. */
    enabled = compute_drives_enabled_mask();

    /* Now, if necessary, update the status bar layouts. We won't need
     * to do this if the only change was the kind of drives hooked up,
     * instead of the number */
    if ((state != sb_state->drives_tde_enabled)
            || (enabled != sb_state->drives_enabled)
            || (sb_state->drives_dual != 0)) {
        sb_state->drives_enabled = enabled;
        sb_state->drives_tde_enabled = state;
        sb_state->drives_layout_needed = true;
    }

    unlock_sb_state();
}

/** \brief  Statusbar API function to report mounting or unmounting of
 *          a disk image.
 *
 *  \param  unit_number     0-3 to represent disk units at device 8-11.
 *  \param  drive_number    0-1 to represent the drives in a unit
 *  \param  image           The filename of the disk image (if mounted),
 *                          or the empty string or NULL (if unmounting).
 *  \todo This API is insufficient to describe drives with two disk units.
 */
void ui_display_drive_current_image(unsigned int unit_number, unsigned int drive_number, const char *image)
{
}


/** \brief  Determine if the CRT controls widget is enabled in \a window
 *
 * \param[in]   window  GtkWindow instance
 *
 * \return  bool
 */
gboolean ui_statusbar_crt_controls_enabled(GtkWidget *window)
{
    int bar;

    mainlock_assert_is_not_vice_thread();

    bar = ui_statusbar_index_for_window(window);
    if (bar >= 0) {
        GtkWidget *crt = allocated_bars[bar].crt;

        if (crt != NULL) {
            return gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(crt));
        }
    }
    return FALSE;
}


/** \brief  Determine if the mixer controls widget is enabled in \a window
 *
 * \param[in]   window  GtkWindow instance
 *
 * \return  bool
 */
gboolean ui_statusbar_mixer_controls_enabled(GtkWidget *window)
{
    int bar;

    mainlock_assert_is_not_vice_thread();

    bar = ui_statusbar_index_for_window(window);
    if (bar >= 0) {
        GtkWidget *mixer = allocated_bars[bar].mixer;

        if (mixer != NULL) {
            return gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(mixer));
        }
    }
    return FALSE;
}


/** \brief  Update status bar message widget
 *
 * \param[in]   state   statusbar state, obtained through lock_sb_state()
 */
static void statusbar_update_message(ui_sb_state_t *sb_state)
{
    if (sb_state->message_pending) {
        /* Only the primary window gets statusbar messages (?) */
        GtkWidget *msg = allocated_bars[0].msg;

       /* remove any previous fadout handler */
        if (timeout_id > 0) {
            g_source_remove(timeout_id);;
            timeout_id = 0;
        }

        /* set new text */
        /* debug_gtk3("New status text: '%s'.", sb_state->message_text); */
        gtk_label_set_text(GTK_LABEL(msg), sb_state->message_text);

        /* do we need a timeout? */
        if (sb_state->message_fadeout) {
            timeout_id = g_timeout_add_seconds(
                    MESSAGE_TIMEOUT,
                    message_timeout_handler,
                    msg);
        }
        /* we're done */
        sb_state->message_pending = false;
    }
}



/** \brief  Update VSID-specific status bar
 */
void ui_update_vsid_statusbar(void)
{
    GtkWidget *speed_widget;
    ui_statusbar_t *bar = &allocated_bars[0];
    ui_sb_state_t *sb_state = lock_sb_state();

    /* cpu/fps */
    speed_widget = bar->speed;
    if (speed_widget != NULL) {
        statusbar_speed_widget_update(speed_widget, &bar->speed_state, bar->window_identity);
    }

    /* messages */
    statusbar_update_message(sb_state);

    unlock_sb_state();
}


/** \brief  Update status bars for non-VSID machines
 */
void ui_update_statusbars(void)
{
    /* TODO: Don't call this for each top level window as it updates all statusbars */
    ui_statusbar_t *bar;
    GtkWidget *speed_widget;
    int i;
    int j;
    ui_sb_state_t *sb_state;
    ui_sb_state_t state_snapshot;
    uint32_t active_joyports;
    bool active_joyports_changed = false;
    int unit;
    sb_state = lock_sb_state();

    /* Have any joyports been enabled / disabled? */
    active_joyports = build_active_joyport_mask();
    if (active_joyports != sb_state->active_joyports) {
        active_joyports_changed = true;
        sb_state->active_joyports = active_joyports;
    }

    /* Take a safe copy of the sb_state so we don't hold the lock during display */
    state_snapshot = *sb_state;

    /* Reset any 'updated needed' flags */
    sb_state->drives_layout_needed = false;

    for (j = 0; j < NUM_DISK_UNITS; ++j) {
        sb_state->current_drive_track_str_updated[j][0] = false;
        sb_state->current_drive_track_str_updated[j][1] = false;
        sb_state->current_drive_unit_str_updated[j][0]  = false;
        sb_state->current_drive_unit_str_updated[j][1]  = false;
        for (int d = 0; d < 2; d++) {
            sb_state->current_drive_leds_updated[j][d][0] = false;
            sb_state->current_drive_leds_updated[j][d][1] = false;
        }
    }

    /* statusbar messages */
    statusbar_update_message(sb_state);

    /* we can release the lock now */
    unlock_sb_state();

    for (i = 0; i < MAX_STATUS_BARS; ++i) {
        bar = &allocated_bars[i];
        if (bar->bar == NULL) {
            continue;
        }

        /*
         * Emulation speed, fps, warp
         */

        speed_widget = bar->speed;
        if (speed_widget != NULL) {
            statusbar_speed_widget_update(speed_widget, &bar->speed_state, bar->window_identity);
        }

        /*
         * Update Tape
         */
        for (j = 0; j < TAPEPORT_MAX_PORTS; j++) {
            GtkWidget *tape_status = bar->tape_status[j];

            if (tape_status != NULL
                    && bar->displayed_tape_counter[j] != state_snapshot.tape_counter[j]) {
                GtkWidget *tape_counter;
                int count;

                tape_counter = gtk_grid_get_child_at(GTK_GRID(tape_status),
                                                     TAPE_STATUS_COL_COUNTER, 0);
                count = state_snapshot.tape_counter[j];

                if (tape_counter != NULL) {
                    char buffer[32];

                    g_snprintf(buffer, sizeof(buffer), "%03d", count % 1000);
                    gtk_label_set_text(GTK_LABEL(tape_counter), buffer);
                }
                bar->displayed_tape_counter[j] = count;
            }
        }

        /*
         * Joystick
         */

        if (active_joyports_changed) {
            update_joyport_layout();
        }

        /*
         * Drive track, half track, and led
         */

        if (state_snapshot.drives_layout_needed) {
            layout_statusbar_drives(&state_snapshot, i);
        }

        for (unit = DRIVE_UNIT_MIN; unit <= DRIVE_UNIT_MAX; unit++) {

            /* Only update the widgets if their state has changed .. */
            for (int drive = 0; drive < 2; drive++) {

                GtkWidget *number = drive_get_number_widget(i, unit, drive);
                GtkWidget *head = drive_get_head_widget(i, unit, drive);
                GtkWidget *led = drive_get_led_widget(i, unit, drive);

                if (state_snapshot.current_drive_track_str_updated[unit - DRIVE_UNIT_MIN][drive]) {
                    if (head != NULL) {
                        char *s = state_snapshot.current_drive_track_str[unit - DRIVE_UNIT_MIN][drive];
                        gtk_label_set_text(GTK_LABEL(head), s);
                    }
                }

                if (state_snapshot.current_drive_unit_str_updated[unit - DRIVE_UNIT_MIN][drive]) {
                    if (number != NULL) {
                        char *s = state_snapshot.current_drive_unit_str[unit - DRIVE_UNIT_MIN][drive];
                        gtk_label_set_text(GTK_LABEL(number), s);
                    }
                }

                /* Only draw the LEDs if they have changed */
                if (state_snapshot.current_drive_leds_updated[unit - DRIVE_UNIT_MIN][drive][0]) {
                    if (led != NULL) {
                        gtk_widget_queue_draw(led);
                    }
                }

                /* TODO: Another LED for dual drive */
            }
        }
    }
}


/** \brief  Show/hide the statusbar kdb debug widget of \a window
 *
 * \param[in,out]   window  GtkWindow instance
 * \param[in]       state   Display state
 *
 * \todo    Replace integer literals
 */
static void kbd_statusbar_widget_enable(GtkWidget *window, gboolean state)
{
    GtkWidget *main_grid;
    GtkWidget *statusbar;
    GtkWidget *kbd;

    mainlock_assert_is_not_vice_thread();

    main_grid = gtk_bin_get_child(GTK_BIN(window));
    if (main_grid != NULL) {
        statusbar = gtk_grid_get_child_at(GTK_GRID(main_grid), 0, 2);
        if (statusbar != NULL) {
            kbd = gtk_grid_get_child_at(GTK_GRID(statusbar), 0, SB_ROW_KBD_DEBUG);
            if (kbd != NULL) {
                if (state) {
                    gtk_widget_show_all(kbd);
                } else {
                    gtk_widget_hide(kbd);
                }
            }
        }
    }
}


/** \brief  Show/hide the keyboard debugging widget on the status bar
 *
 * Show/hide the keyboard debugging widget on the status bar of a single window.
 *
 * \param[in]   window  main window instance
 * \param[in]   state   visible state
 */
void ui_statusbar_set_kbd_debug_for_window(GtkWidget *window, gboolean state)
{
    mainlock_assert_is_not_vice_thread();

    kbd_statusbar_widget_enable(window, state);
}


/** \brief  Show/hide the keyboard debugging widget on the status bar
 *
 * Show/hide the keyboard debugging widget on the status bar (of both windows
 * in the case of x128).
 *
 * \param[in]   state   visible state
 *
 * \note    Only call from a finalized UI.
 */
void ui_statusbar_set_kbd_debug(gboolean state)
{
    GtkWidget *window;

    mainlock_assert_is_not_vice_thread();

    /* standard VIC/VICII/TED/CRTC window */
    window = ui_get_window_by_index(0);
    kbd_statusbar_widget_enable(window, state);

    /* C128: Handle the VDC */
    if (machine_class == VICE_MACHINE_C128) {
        window = ui_get_window_by_index(1); /* VDC */
        kbd_statusbar_widget_enable(window, state);
    }
}


/** \brief  Get active 'Recording' widget
 *
 * \return  recording widget
 */
GtkWidget *ui_statusbar_get_recording_widget(void)
{
    int w = ui_get_main_window_index();
    return allocated_bars[w].record;
}


/** \brief  Show reset on statusbar
 *
 * A device was reset, so we show it on the statusbar
 *
 * \param[in]   device  device number
 * \param[in]   mode    reset mode (soft(0) or hard(1) ,only for device 0)
 */
void ui_display_reset(int device, int mode)
{
}


/** \brief  Update status bar debug widget instances
 *
 * \param[in]   report  Gdk key event
 *
 * \note    Can only be called from the UI thread.
 */
void ui_statusbar_update_kbd_debug(GdkEvent *report)
{
    GtkWidget *widget;

    mainlock_assert_is_not_vice_thread();

    if (machine_class == VICE_MACHINE_VSID) {
        return;
    }

    /* update primary window debug widget */
    widget = allocated_bars[0].kbd_debug;
    if (widget != NULL) {
        kbd_debug_widget_update(widget, report);
    }
    if (machine_class == VICE_MACHINE_C128) {
        /* update secondary window debug widget */
        widget = allocated_bars[1].kbd_debug;
        if (widget != NULL) {
            kbd_debug_widget_update(widget, report);
        }
    }
}


/** \brief  Set visibility of the status bar for a main window
 *
 * \param[in]   window  main window
 * \param[in]   visible visibility of status bar for \a window
 *
 * \return  TRUE on success
 */
gboolean ui_statusbar_set_visible_for_window(GtkWidget *window, gboolean visible)
{
    GtkWidget *main_grid;
    GtkWidget *statusbar;

    main_grid = gtk_bin_get_child(GTK_BIN(window));
    if (main_grid == NULL) {
        return FALSE;
    }
    statusbar = gtk_grid_get_child_at(GTK_GRID(main_grid), 0, 2);
    if (statusbar == NULL) {
        return FALSE;
    }

    if (visible) {
        if (!ui_is_fullscreen() || ui_fullscreen_has_decorations()) {
            gtk_widget_show(statusbar);
        }
    } else {
        gtk_widget_hide(statusbar);
    }
    return TRUE;
}


/** \brief  Show/Hide statusbar of the **active** window
 *
 * Toggle visibility of statusbar based on "${chip}ShowStatusbar" resource.
 *
 * \return  TRUE (don't pass event along further)
 */
gboolean ui_action_toggle_show_statusbar(void)
{
    video_canvas_t *canvas = ui_get_active_canvas();
    if (canvas != NULL) {
        GtkWindow *window;
        int show = 0;
        const char *chip_name = canvas->videoconfig->chip_name;

        resources_get_int_sprintf("%sShowStatusbar", &show, chip_name);
        show = !show;
        resources_set_int_sprintf("%sShowStatusbar", show, chip_name);

        window = ui_get_active_window();
        ui_statusbar_set_visible_for_window(GTK_WIDGET(window), show);
        /* update menu item's toggled state! */
        vhk_gtk_set_check_item_blocked_by_action(ACTION_SHOW_STATUSBAR_TOGGLE,
                                                 show);
    }
    return TRUE;
}


/** \brief  Recreate CRT controls on the status bars
 *
 * Destroy the old CRT controls and create new ones. To be called whenever the
 * video standard changes.
 */
void ui_statusbar_recreate_crt_controls(void)
{
    int i;

    mainlock_assert_is_not_vice_thread();

    for (i = PRIMARY_WINDOW; i <= SECONDARY_WINDOW; i++) {
        GtkWidget      *window;
        GtkWidget      *grid;
        GtkWidget      *controls;
        video_canvas_t *canvas;
        const char     *chip;

        window   = ui_get_window_by_index(i);
        if (window == NULL) {
            continue;
        }
        canvas   = ui_get_canvas_for_window(i);
        chip     = canvas->videoconfig->chip_name;
        grid     = gtk_bin_get_child(GTK_BIN(window));
        controls = gtk_grid_get_child_at(GTK_GRID(grid), 0, 3);
        gtk_widget_destroy(controls);

        controls = crt_control_widget_create(NULL, chip, TRUE);
        gtk_grid_attach(GTK_GRID(grid), controls, 0, 3, 1, 1);

        if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(allocated_bars[i].crt))) {
            gtk_widget_show(controls);
        } else {
            gtk_widget_hide(controls);
        }
    }
}
