/////////////////////////////////////////////////////////////////////////
// $Id: gtk_enh_dbg_osdep.cc 13593 2019-11-11 19:40:09Z vruppert $
/////////////////////////////////////////////////////////////////////////
//
//  BOCHS ENHANCED DEBUGGER Ver 1.2
//  (C) Chourdakis Michael, 2008
//  http://www.turboirc.com
//
//  Modified by Bruce Ewing
//
//  Copyright (C) 2008-2019  The Bochs Project

#include "config.h"

#if BX_DEBUGGER && BX_DEBUGGER_GUI

#include "bochs.h"
#include "enh_dbg.h"

#include <gtk/gtk.h>
#include <glib.h>
#include <pthread.h>

// replace the Win32 COLORREF and RGB definitions, for GDK
#define  RGB(R,G,B) {(R<<16)|(G<<8)|B,(R*65535)/255,(G*65535)/255,(B*65535)/255}

// User Customizable Register color table:
// background "register type" colors indexed by RegColor value
const GdkColor ColorList[16] = {
    RGB(255,255,255),   // white
    RGB(200,255,255),   // blue (aqua)
    RGB(230,230,230),   // gray
    RGB(248,255,200),   // yellow
    RGB(216,216,255),   // purple
    RGB(200,255,200),   // green
    RGB(255,230,200),   // orange
    RGB(255,255,255),   // more user definable
    RGB(255,255,255),
    RGB(255,255,255),
    RGB(255,255,255),
    RGB(255,255,255),
    RGB(255,255,255),
    RGB(255,255,255),
    RGB(255,255,255),
    RGB(255,255,255)
};

// END of User Customizable settings

#define TreeParent  GtkTreeIter

void DockResize (int j, Bit32u x);      // need some function prototypes
void SetHorzLimits();
void ParseIDText(const char *x);
void ShowData();
void UpdateStatus();
void doUpdate();
void RefreshDataWin();
void OnBreak();
void ParseBkpt();
void SetBreak(int i);
void ChangeReg();
int HotKey (int ww, int Alt, int Shift, int Control);
void ActivateMenuItem (int LW);
void SetMemLine (int L);
void MakeBL(TreeParent *tp, bx_param_c *p);

#define NUM_CHKS    25  // slight overestimate of # of Optmenu items with checkmarks
#define WSChkIdx    20  // "checkmark index" of the first "wordsize" menu item

// reverse mapping from command indexes to menu item widgets
GtkWidget *Cmd2MI[CMD_IDX_HI - CMD_IDX_LO + 1];

// GTK objects and global stuff
GtkTextMark* EndMark;
GtkTreeViewColumn *AllCols[24];
GtkCellRenderer *LV_Rend[3];
GdkCursor *SizeCurs;
GdkCursor *DockCurs;
gulong mmov_hID;

    // GTK containers
GtkWidget *window;
GtkWidget *menubar;
GtkWidget *CmdMenu;
GtkWidget *ViewMenu;
GtkWidget *OptMenu;
GtkWidget *HelpMenu;
GtkWidget *MainVbox;
GtkWidget *CmdBHbox;
GtkWidget *CpuBHbox;
GtkWidget *StatHbox;
GtkWidget *TreeTbl;
GtkWidget *IOVbox;
GtkWidget *ScrlWinOut;
GtkWidget *ScrlWin[3];
GtkWidget *LVHbox;
GtkWidget *LVEvtBox;
GtkWidget *VSepEvtBox1;
GtkWidget *VSepEvtBox2;

    // GTK menu widgets -- titles, then actual menu items
GtkWidget *CmdTitle;
GtkWidget *ViewTitle;
GtkWidget *OptTitle;
GtkWidget *HelpTitle;

GtkWidget *ContMI;
GtkWidget *StepMI;
GtkWidget *StepNMI;
GtkWidget *BreakMI;
GtkWidget *SetBrkMI;
GtkWidget *WatchWrMI;
GtkWidget *WatchRdMI;
GtkWidget *FindMI;
GtkWidget *RefreshMI;

GtkWidget *PhyDumpMI;
GtkWidget *LinDumpMI;
GtkWidget *StackMI;
GtkWidget *GDTMI;
GtkWidget *IDTMI;
GtkWidget *PageMI;
GtkWidget *ViewBrkMI;
GtkWidget *MemDumpMI;
GtkWidget *PTreeMI;
GtkWidget *DisAsmMI;

GtkWidget *ChkMIs[NUM_CHKS];    // menu items with checkmarks

//GtkWidget *XceptMI;
GtkWidget *DefDisMI;
GtkWidget *SyntaxMI;
GtkWidget *FontMI;
GtkWidget *WrdSizeMI;
GtkWidget *WSmenu;

GtkWidget *AboutMI;

GtkWidget *sep1;        // menu separators
GtkWidget *sep2;
GtkWidget *sep3;
GtkWidget *sep4;
GtkWidget *sep5;
GtkWidget *sep6;
GtkWidget *sep7;
GtkWidget *sep10;

GtkWidget *sep8;        // separators around the ListViews
GtkWidget *sep9;

    // GTK widgets
GtkWidget *CmdBtn[5];                   // "command" buttonrow
GtkWidget *CpuBtn[BX_MAX_SMP_THREADS_SUPPORTED];        // "CPU" buttonrow
GtkWidget *CpuB_label[BX_MAX_SMP_THREADS_SUPPORTED];    // "labels" on CPU buttons

GtkWidget *Stat[4];     // 4 entry "Status Bar"
GtkWidget *StatVSep1;
GtkWidget *StatVSep2;
GtkWidget *StatVSep3;

GtkWidget *IEntry;      // Singleline Input Text Window
GtkWidget *OText;       // Multiline, wrapping, Output Text Window

GtkWidget *PTree;       // bochs param_tree TreeView
GtkWidget *LV[3];       // Register, ASM, MemDump / ListViews (TreeViews)

// GTK-specific settings
gint win_x = -1, win_y = -1, win_w, win_h;
bx_bool window_init = 0;
char fontname[80];
bx_bool font_init = 0;

// HIHI put all these colors in an array, and use #defines for them
// need a "medium gray" color for inactive lists
const GdkColor mgray = RGB(200,200,200);
const GdkColor white = {
    0xffffff,
    0xffff,     // need to specify cell background color sometimes
    0xffff,
    0xffff
};
GdkColor fg_red = RGB(255,0,0);
GdkColor fg_black = RGB(0,0,0);
const GdkColor AsmColors[4] = {
    RGB(0,0,0),
    RGB(0,100,0),
    RGB(150,0,0),
    RGB(0,0,200)
};
const GdkColor PDumpClr[4] = {
    RGB(0,0,0),
    RGB(255,0,150),
    RGB(0,170,255),
    RGB(130,255,0)
};

unsigned int CurXSize;      // last known size of main client window

int DumpSelRow;             // keeps track of "clicks" on MemDump entries
int SelectedEntry;          // keeps track of "clicks" on ASM entries
bx_bool UpdateOWflag = FALSE;
bx_bool HitBrkflag = FALSE;
bx_bool ForcingCheck = FALSE;   // using a hotkey to flip a menu item checkmark
int KeyStateShft;
int KeyStateAlt;
// guint PrevState = GDK_BUTTON1_MASK;  // turn on the "mouseup" bit, to detect the first mousedown
int SizingDelay = 0;
bx_bool EnterSizeMode = FALSE;
unsigned int CurScrX;

//bx_bool UpdInProgress[3];     // flag -- list update incomplete (not OK to paint)

char SelMem[260];       // flag array for which list rows are "selected"
char SelAsm[MAX_ASM];
char SelReg[TOT_REG_NUM + EXTRA_REGS];

// "run" the standard dialog box -- get text from the user
bx_bool ShowAskDialog()
{
    bx_bool ret = FALSE;
    static GtkWidget *dialog = NULL;
    static GtkWidget *AskEntry = NULL;
    static GtkWidget *AskPrompt = NULL;
    const gchar *entry_text;

    if (dialog == NULL)
    {
        dialog = gtk_dialog_new ();
        gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
        gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_OK, GTK_RESPONSE_OK);
        gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
    }
// HIHI should the "transient" line be INSIDE the dialog creation "if"? -- when I tried it, it crashed?
    // The following causes this dialog to stay above the main window
//  gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (window));

    gtk_window_set_title (GTK_WINDOW (dialog), ask_str.title);

    if (AskEntry == NULL)
    {
        AskPrompt = gtk_label_new (ask_str.prompt);
        gtk_widget_show (AskPrompt);
        gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), AskPrompt, TRUE, TRUE, 5);
        AskEntry = gtk_entry_new ();
        // "Enter" (activate) = OK button
        gtk_entry_set_activates_default (GTK_ENTRY (AskEntry), TRUE);
        // increase the width of the Entry to about 80 chars
        gtk_entry_set_width_chars (GTK_ENTRY (AskEntry), 80);
        gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), AskEntry, TRUE, TRUE, 5);
    }

    gtk_widget_show (AskEntry);
    gtk_label_set_text (GTK_LABEL (AskPrompt), ask_str.prompt);
    gtk_widget_grab_focus(AskEntry);        // Entry must be visible before it can get focus
    // and it must have focus before any new text is set, or the dialog will crash
    gtk_entry_set_text (GTK_ENTRY (AskEntry), ask_str.reply);
    if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
    {
        entry_text = gtk_entry_get_text (GTK_ENTRY (AskEntry));
        strcpy (ask_str.reply, entry_text);
        ret = TRUE;
    }

    // if any text remains in the Entry, the dialog box will crash on its next use
    gtk_entry_set_text (GTK_ENTRY (AskEntry), "");      // so clear it
    gtk_widget_grab_focus(IEntry);
    gtk_widget_hide (dialog);   // for reuse!
    return ret;
}

// set all TRUE flags to checked in the Options menu
void InitMenus()
{
//L exception notify is not implemented yet
    menubar = gtk_menu_bar_new();
    CmdMenu =   gtk_menu_new();
    ViewMenu = gtk_menu_new();
    OptMenu =   gtk_menu_new();
    HelpMenu = gtk_menu_new();

    CmdTitle = gtk_menu_item_new_with_label("Commands");        // each menu needs a title
    ViewTitle = gtk_menu_item_new_with_label("View");       // (and the titles are created as widgets)
    OptTitle = gtk_menu_item_new_with_label("Options");
    HelpTitle = gtk_menu_item_new_with_label("Help");

    gtk_menu_item_set_submenu(GTK_MENU_ITEM(CmdTitle), CmdMenu);
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(ViewTitle), ViewMenu);
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(OptTitle), OptMenu);
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(HelpTitle), HelpMenu);
    gtk_menu_shell_append(GTK_MENU_SHELL(menubar), CmdTitle);
    gtk_menu_shell_append(GTK_MENU_SHELL(menubar), ViewTitle);
    gtk_menu_shell_append(GTK_MENU_SHELL(menubar), OptTitle);
    gtk_menu_shell_append(GTK_MENU_SHELL(menubar), HelpTitle);

    // build all the menu items
    // Commands Menu
    ContMI = gtk_menu_item_new_with_label("Continue [c]\t\t\t\t\tF5");
    StepMI = gtk_menu_item_new_with_label("Step [s]\t\t\t\t\t\tF11");
    StepNMI = gtk_menu_item_new_with_label("Step #...\t\t\t\t\t\tF9");
    BreakMI = gtk_menu_item_new_with_label("Break\t\t\t\t\t\tCtrl+C");
    SetBrkMI = gtk_menu_item_new_with_label("Breakpoint (ASM selected)\t\tF6");
    WatchWrMI = gtk_menu_item_new_with_label("Watch Write (PhysDump selected)\tShift+F6");
    WatchRdMI = gtk_menu_item_new_with_label("Watch Read (PhysDump selected)\tAlt+F6");
    FindMI = gtk_menu_item_new_with_label("Find...\t\t\t\t\t\tCtrl+F");
    RefreshMI = gtk_menu_item_new_with_label("Refresh Screen\t\t\t\t\tF4");

    // View Menu
    PhyDumpMI = gtk_menu_item_new_with_label("Physical MemDump...\tCtrl+F7");
    LinDumpMI = gtk_menu_item_new_with_label("Linear MemDump...\t\tF7");
    StackMI = gtk_menu_item_new_with_label("Stack\t\t\t\tF2");
    GDTMI = gtk_menu_item_new_with_label("GDT\t\t\t\t\tCtrl+F2");
    IDTMI = gtk_menu_item_new_with_label("IDT\t\t\t\t\tShift+F2");
    PageMI = gtk_menu_item_new_with_label("Page Table\t\t\tAlt+F2");
    ViewBrkMI = gtk_menu_item_new_with_label("Breakpoints\t\t\tCtrl+F6");
    MemDumpMI = gtk_menu_item_new_with_label("Current MemDump\t\tEsc");
    PTreeMI  = gtk_menu_item_new_with_label("Bochs param_tree\t\tCtrl+F3");
    DisAsmMI = gtk_menu_item_new_with_label("Disassemble...\t\t\tCtrl+D");
    // Options Menu - without checkmarks
    DefDisMI = gtk_menu_item_new_with_label("Default disassembled lines...");
    SyntaxMI = gtk_menu_item_new_with_label("Toggle Intel/ATT syntax\t\tF3");
    FontMI  = gtk_menu_item_new_with_label ("Font...");
    WrdSizeMI = gtk_menu_item_new_with_label("Set MemDump 'Wordsize'...");
    WSmenu = gtk_menu_new();

    // Options Menu - with checkmarks
    ChkMIs[MODE_BRK] = gtk_check_menu_item_new_with_label("Break on CPU mode change\tShift+F5");
    ChkMIs[ONE_CPU] = gtk_check_menu_item_new_with_label("Show CPU0 only");
    ChkMIs[U_CASE]  = gtk_check_menu_item_new_with_label("Text in UPPERCASE");
    ChkMIs[IO_WIN]  = gtk_check_menu_item_new_with_label("Show Input/Output Windows");
    ChkMIs[SHOW_BTN] = gtk_check_menu_item_new_with_label("Show Buttons");
    ChkMIs[MD_HEX] = gtk_check_menu_item_new_with_label("MemDump in Hex\t\t\tAlt+F7");
    ChkMIs[MD_ASC] = gtk_check_menu_item_new_with_label("MemDump in ASCII\t\t\tShift+F7");
    ChkMIs[L_END]  = gtk_check_menu_item_new_with_label("LittleEndian");
    ChkMIs[IGN_SA] = gtk_check_menu_item_new_with_label("Ignore ASM lines");
    ChkMIs[IGN_NT] = gtk_check_menu_item_new_with_label("Ignore Next at t=");
    ChkMIs[R_CLR] = gtk_check_menu_item_new_with_label("Colorize Register Types");
    ChkMIs[E_REG] = gtk_check_menu_item_new_with_label("Show 32bit Registers");
    ChkMIs[S_REG] = gtk_check_menu_item_new_with_label("Show Segment Registers");
    ChkMIs[SYS_R] = gtk_check_menu_item_new_with_label("Show System Registers");
    ChkMIs[C_REG] = gtk_check_menu_item_new_with_label("Show Control Registers");
    ChkMIs[FPU_R] = gtk_check_menu_item_new_with_label("Show MMX/FPU Registers\tAlt+F3");
    ChkMIs[XMM_R] = gtk_check_menu_item_new_with_label("Show SSE Registers\t\tCtrl+F4");
    ChkMIs[D_REG] = gtk_check_menu_item_new_with_label("Show Debug Registers\t\tShift+F4");
//  ChkMIs[T_REG] = gtk_check_menu_item_new_with_label("Show Test Registers");
    ChkMIs[LOG_VIEW] = gtk_check_menu_item_new_with_label("Show log in output window");
    ChkMIs[WSChkIdx] = gtk_check_menu_item_new_with_label("1 byte\t\tAlt+1");
    ChkMIs[WSChkIdx+1] = gtk_check_menu_item_new_with_label("2 bytes\t\tAlt+2");
    ChkMIs[WSChkIdx+2] = gtk_check_menu_item_new_with_label("4 bytes\t\tAlt+4");
    ChkMIs[WSChkIdx+3] = gtk_check_menu_item_new_with_label("8 bytes\t\tAlt+8");
    ChkMIs[WSChkIdx+4] = gtk_check_menu_item_new_with_label("16 bytes\t\tAlt+6");

    // Help Menu
    AboutMI = gtk_menu_item_new_with_label("About...");

    sep1 = gtk_separator_menu_item_new();       // can't reuse menu separators
    sep2 = gtk_separator_menu_item_new();
    sep3 = gtk_separator_menu_item_new();
    sep4 = gtk_separator_menu_item_new();
    sep5 = gtk_separator_menu_item_new();
    sep6 = gtk_separator_menu_item_new();
    sep7 = gtk_separator_menu_item_new();
    sep10 = gtk_separator_menu_item_new();

    // insert all the menu items into each menu
    gtk_menu_shell_append(GTK_MENU_SHELL(CmdMenu), ContMI);
    gtk_menu_shell_append(GTK_MENU_SHELL(CmdMenu), StepMI);
    gtk_menu_shell_append(GTK_MENU_SHELL(CmdMenu), StepNMI);
    gtk_menu_shell_append(GTK_MENU_SHELL(CmdMenu), BreakMI);
    gtk_menu_shell_append(GTK_MENU_SHELL(CmdMenu), sep1);
    gtk_menu_shell_append(GTK_MENU_SHELL(CmdMenu), SetBrkMI);
    gtk_menu_shell_append(GTK_MENU_SHELL(CmdMenu), WatchWrMI);
    gtk_menu_shell_append(GTK_MENU_SHELL(CmdMenu), WatchRdMI);
    gtk_menu_shell_append(GTK_MENU_SHELL(CmdMenu), sep2);
    gtk_menu_shell_append(GTK_MENU_SHELL(CmdMenu), FindMI);
    gtk_menu_shell_append(GTK_MENU_SHELL(CmdMenu), RefreshMI);

    gtk_menu_shell_append(GTK_MENU_SHELL(ViewMenu), PhyDumpMI);
    gtk_menu_shell_append(GTK_MENU_SHELL(ViewMenu), LinDumpMI);
    gtk_menu_shell_append(GTK_MENU_SHELL(ViewMenu), StackMI);
    gtk_menu_shell_append(GTK_MENU_SHELL(ViewMenu), GDTMI);
    gtk_menu_shell_append(GTK_MENU_SHELL(ViewMenu), IDTMI);
    gtk_menu_shell_append(GTK_MENU_SHELL(ViewMenu), PageMI);
    gtk_menu_shell_append(GTK_MENU_SHELL(ViewMenu), ViewBrkMI);
    gtk_menu_shell_append(GTK_MENU_SHELL(ViewMenu), MemDumpMI);
    gtk_menu_shell_append(GTK_MENU_SHELL(ViewMenu), sep3);
    gtk_menu_shell_append(GTK_MENU_SHELL(ViewMenu), PTreeMI);
    gtk_menu_shell_append(GTK_MENU_SHELL(ViewMenu), DisAsmMI);

    gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), ChkMIs[MODE_BRK]);
    gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), ChkMIs[ONE_CPU]);
    gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), DefDisMI);
    gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), SyntaxMI);
    gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), sep4);
    gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), FontMI);
    gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), ChkMIs[U_CASE]);
    gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), ChkMIs[IO_WIN]);
    gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), ChkMIs[SHOW_BTN]);
    gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), sep5);
    gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), ChkMIs[MD_HEX]);
    gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), ChkMIs[MD_ASC]);
    gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), ChkMIs[L_END]);
    gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), WrdSizeMI);
    gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), sep6);
    gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), ChkMIs[IGN_SA]);
    gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), ChkMIs[IGN_NT]);
    gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), sep7);
    gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), ChkMIs[R_CLR]);
    gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), ChkMIs[E_REG]);
    gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), ChkMIs[S_REG]);
    gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), ChkMIs[SYS_R]);
    gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), ChkMIs[C_REG]);
    gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), ChkMIs[FPU_R]);
    gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), ChkMIs[XMM_R]);
    gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), ChkMIs[D_REG]);
//  gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), ChkMIs[T_REG]);
    gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), sep10);
    gtk_menu_shell_append(GTK_MENU_SHELL(OptMenu), ChkMIs[LOG_VIEW]);
    gtk_menu_shell_append(GTK_MENU_SHELL(HelpMenu), AboutMI);

    gtk_menu_item_set_submenu(GTK_MENU_ITEM(WrdSizeMI), WSmenu);        // set up popup menu
    gtk_menu_shell_append(GTK_MENU_SHELL(WSmenu), ChkMIs[WSChkIdx]);
    gtk_menu_shell_append(GTK_MENU_SHELL(WSmenu), ChkMIs[WSChkIdx+1]);
    gtk_menu_shell_append(GTK_MENU_SHELL(WSmenu), ChkMIs[WSChkIdx+2]);
    gtk_menu_shell_append(GTK_MENU_SHELL(WSmenu), ChkMIs[WSChkIdx+3]);
    gtk_menu_shell_append(GTK_MENU_SHELL(WSmenu), ChkMIs[WSChkIdx+4]);

    // init all the checkmarks

    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ChkMIs[E_REG]), SeeReg[0]);
    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ChkMIs[S_REG]), SeeReg[1]);
    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ChkMIs[SYS_R]), SeeReg[2]);
    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ChkMIs[C_REG]), SeeReg[3]);
    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ChkMIs[FPU_R]), SeeReg[4]);
    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ChkMIs[XMM_R]), SeeReg[5]);
    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ChkMIs[D_REG]), SeeReg[6]);
//  gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ShowTRegMI), SeeReg[7]);
    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ChkMIs[ONE_CPU]), SingleCPU);
    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ChkMIs[IO_WIN]), ShowIOWindows);
    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ChkMIs[SHOW_BTN]), ShowButtons);
    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ChkMIs[U_CASE]), UprCase);
    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ChkMIs[L_END]), isLittleEndian);
    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ChkMIs[IGN_SA]), ignSSDisasm);
    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ChkMIs[IGN_NT]), ignoreNxtT);
    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ChkMIs[R_CLR]), SeeRegColors);
    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ChkMIs[LOG_VIEW]), LogView);
    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ChkMIs[WSChkIdx+DumpWSIndex]), TRUE);
    if (DumpInAsciiMode == 0)       // prevent an illegal value
        DumpInAsciiMode = 3;
    // I don't know why, but the next 2 "set_active" commands blow up if moved into SpecialInit
    if ((DumpInAsciiMode & 2) != 0)
        gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ChkMIs[MD_HEX]), TRUE);
    if ((DumpInAsciiMode & 1) != 0)
        gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ChkMIs[MD_ASC]), TRUE);
}

// add a whole row of text into a ListView, all at once
// Note: LineCount should start at 0
void InsertListRow(char *ColumnText[], int ColumnCount, int listnum, int LineCount, int grouping)
{
    char tmp[4];
    GtkTreeIter iter;
    GtkListStore *Database;
    *tmp = 0;
    Database = (GtkListStore *) gtk_tree_view_get_model( GTK_TREE_VIEW(LV[listnum]) );
    gtk_list_store_append (GTK_LIST_STORE(Database), &iter);  /* Acquire an iterator */
    // some rows of the register list only print 2 columns
    // the dump window always prints 18, but the first 17 may be blank and 0 width
    if (ColumnCount == 2)
        gtk_list_store_set (GTK_LIST_STORE(Database), &iter, 0, ColumnText[0], 1, ColumnText[1], 2,
            tmp, 3, (gint) LineCount, -1);
    else if (ColumnCount == 3)
    {
        gtk_list_store_set (GTK_LIST_STORE(Database), &iter, 0, ColumnText[0], 1, ColumnText[1], 2,
            ColumnText[2], 3, (gint) LineCount, -1);
    }
    else
    {
    // it might be easier to use the gtk_list_store_set_valuesv() function?
        gtk_list_store_set (GTK_LIST_STORE(Database), &iter, 0, ColumnText[0], 1, ColumnText[1],
            2, ColumnText[2], 3, ColumnText[3], 4, ColumnText[4], 5, ColumnText[5],
            6, ColumnText[6], 7, ColumnText[7], 8, ColumnText[8], 9, ColumnText[9],
            10, ColumnText[10], 11, ColumnText[11], 12, ColumnText[12], 13, ColumnText[13],
            14, ColumnText[14], 15, ColumnText[15], 16, ColumnText[16], 17, ColumnText[17], 18, (gint) LineCount, -1);
    }
}

void ShowFW()
{
    FWflag = TRUE;      // the X version of this should be stubbed
}

// try to get a list repaint to happen
void Invalidate(int i)
{
    GdkWindow *LstGdk;
    LstGdk = gtk_tree_view_get_bin_window (GTK_TREE_VIEW (LV[i]));
    gdk_window_invalidate_rect (LstGdk, NULL, TRUE);    // rect=NULL means "the whole window"
    gtk_widget_queue_draw(LV[i]);               // redraw the selected ListView "bin" window
}

void SetStatusText(int column, const char *buf)
{
    gtk_label_set_text(GTK_LABEL(Stat[column]), buf);
}

// called by the Find command -- only for LV[ASM] column 2!
void GetLIText(int listnum, int itemnum, int column, char *buf)
{
    char *value;
    GtkTreeIter iter;
    GtkListStore *Database;
    Database = (GtkListStore *) gtk_tree_view_get_model( GTK_TREE_VIEW(LV[listnum]) );
    // get an iter for row # itemnum
    gtk_tree_model_iter_nth_child (GTK_TREE_MODEL(Database), &iter, NULL, itemnum);
    // pull the text out of "row # iter" at the specified column
    gtk_tree_model_get(GTK_TREE_MODEL(Database), &iter, column, &value,  -1);
    strcpy (buf, value);
    g_free(value);
}

// get a bochs command from the user Input window
void GetInputEntry(char *buf)
{
    const gchar *gcp;
    gcp = gtk_entry_get_text(GTK_ENTRY(IEntry));
    strcpy (buf, gcp);
}

// highlights individual rows in ASM or Mem windows
void SetLIState(int listnum, int itemnum, bx_bool Select)
{
    char *Sel = SelAsm;
    int max = MAX_ASM;
    if (listnum == 2)
    {
        Sel = SelMem;
        max = 256;
    }
    if (itemnum >= max)
        itemnum = max-1;
    Sel[itemnum] = Select;
}

// Searches ASM or Reg list for the next (or first) selected row
int GetNextSelectedLI(int listnum, int StartPt)
{
    int L = StartPt;
    char *Sel = SelAsm;
    int end = MAX_ASM;
    bx_bool stop = FALSE;

    if (listnum == REG_WND)
    {
        Sel = SelReg;
        end = TOT_REG_NUM + EXTRA_REGS;
    }
    if (L < -1)
        L = -1;
    while (stop == FALSE)
    {
        if (++L >= end)
            stop = TRUE;
        else
        {
            if (Sel[L] != FALSE)
                stop = TRUE;
        }
    }
    if (L >= end)
        return -1;
    return L;
}

// returns the row number of the ASM list that is showing at the top of the window
// it is also easy to calculate AsmPgSize and ListLineRatio here,
// -- they MUST be calculated somewhere in the os_specific code
int GetASMTopIdx()
{
    GtkAdjustment *va;
//    GtkListStore *Database;
//    Database = (GtkListStore *) gtk_tree_view_get_model( GTK_TREE_VIEW(LV[ASM_WND]) );

    AsmPgSize = 0;
    va = gtk_tree_view_get_vadjustment ( GTK_TREE_VIEW(LV[ASM_WND]) );
    // calculate the number of vertical "pixels" in one row (as a fraction of the scroll range)
    if (AsmLineCount == 0)
        return 0;
    ListLineRatio = (int) (gtk_adjustment_get_upper(va) - gtk_adjustment_get_lower(va)) / AsmLineCount;
    if (ListLineRatio == 0)
        return 0;
    AsmPgSize = (int) gtk_adjustment_get_page_size(va) / ListLineRatio;
    return ((int) gtk_adjustment_get_value(va) / ListLineRatio);
}

// "pixels" is a multiple of (and therefore proportional to) ListLineRatio
// -- it does not technically have to really be a pixel count
void ScrollASM(int pixels)
{
    GtkAdjustment *va = gtk_tree_view_get_vadjustment ( GTK_TREE_VIEW(LV[ASM_WND]) );
    gtk_adjustment_set_value(GTK_ADJUSTMENT(va), gtk_adjustment_get_value(va) + pixels);
}

// handle checkmarks in the "wordsize" popup menu
// Note: setting/clearing a checkmark sends an immediate "activate" signal to the associated menuitem
void ToggleWSchecks(int newWS, int oldWS)
{
    if ((bx_bool) gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(ChkMIs[WSChkIdx + newWS])) == FALSE)
    {
        ForcingCheck = TRUE;        // prevent infinite checkmark loops
        gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ChkMIs[WSChkIdx + newWS]), TRUE);
    }
    if ((bx_bool) gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(ChkMIs[WSChkIdx + oldWS])) != FALSE)
    {
        ForcingCheck = TRUE;        // prevent infinite checkmark loops
        gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ChkMIs[WSChkIdx + oldWS]), FALSE);
    }
}

// repack the ScrollWindows into the ListHbox using a new DockOrder
// FirstListIndex is precalculated in MoveLists, so pass in the value
void RepackLists(int FirstListIndex)
{
    gtk_box_pack_start(GTK_BOX(LVHbox), ScrlWin[FirstListIndex], FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(LVHbox), VSepEvtBox1, FALSE, FALSE, 0);
    gtk_box_pack_end(GTK_BOX(LVHbox), ScrlWin[(DockOrder& 3) -1], FALSE, FALSE, 0);
    gtk_box_pack_end(GTK_BOX(LVHbox), VSepEvtBox2, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(LVHbox), ScrlWin[CurCenterList], TRUE, TRUE, 0);
}

// unpack the ScrollWindows from the ListHbox, then repack using a new DockOrder
// -- also calculate the X-coords of the "bars" between the lists
void MoveLists()
{
    int i;
    g_object_ref(ScrlWin[0]);    // make sure the list widgets do not get deleted
    g_object_ref(ScrlWin[1]);    // when they are removed from their container
    g_object_ref(ScrlWin[2]);
    g_object_ref(VSepEvtBox1);
    g_object_ref(VSepEvtBox2);
    gtk_container_remove (GTK_CONTAINER(LVHbox), ScrlWin[0]);
    gtk_container_remove (GTK_CONTAINER(LVHbox), ScrlWin[1]);
    gtk_container_remove (GTK_CONTAINER(LVHbox), ScrlWin[2]);
    gtk_container_remove (GTK_CONTAINER(LVHbox), VSepEvtBox1);
    gtk_container_remove (GTK_CONTAINER(LVHbox), VSepEvtBox2);

    CurCenterList = ((DockOrder>>4)& 3) -1;     // index of center list
    i = (DockOrder >> 8) -1;            // index of left list

    RepackLists(i);     // pack widgets back into container in new DockOrder
    g_object_unref(ScrlWin[0]);
    g_object_unref(ScrlWin[1]);      // and get rid of the temporary "ref"s
    g_object_unref(ScrlWin[2]);
    g_object_unref(VSepEvtBox1);
    g_object_unref(VSepEvtBox2);

    // use DockOrder to figure out the table X-coordinates of the 2 v-separators
    i = ListWidthPix[i];
//  BarClix[0] = i;
//  BarClix[1] = i + ListWidthPix[CurCenterList];

    BottomAsmLA = ~0;       // force an ASM autoload next time, to resize it
    doDumpRefresh = TRUE;   // force a data window refresh on a break
    if (AtBreak != FALSE)   // can't refresh the windows until a break!
    {
        doUpdate();         // refresh the ASM and Register windows
        RefreshDataWin();   // and whichever data window is up
    }
}

// modify the displayed items in the MainVbox
void VSizeChange()
{
    if (ShowButtons == FALSE)       // set the visibility of the Command Buttons
        gtk_widget_hide(CmdBHbox);
    else
        gtk_widget_show(CmdBHbox);

    if (BX_SMP_PROCESSORS > 1) {
        if (SingleCPU == FALSE) {       // set the visibility of the CPU Buttons
            gtk_widget_show(CpuBHbox);
        } else {
            gtk_widget_hide(CpuBHbox);
        }
    }

    if (ShowIOWindows == FALSE)
    {
        gtk_widget_hide(IOVbox);
        gtk_table_resize(GTK_TABLE(TreeTbl), 3, 1);  // IO windows do not exist, so total table rows = 3
    }
    else
    {
        // Note: if an invisible Entry window contains text and is shown, the program can crash
        // so copy out any text, clear the Entry, make it visible, and then reload it
        const gchar *gcp;
        gcp = gtk_entry_get_text(GTK_ENTRY(IEntry));
        strcpy (tmpcb, gcp);
        gtk_entry_set_text(GTK_ENTRY(IEntry),"");
        gtk_table_resize(GTK_TABLE(TreeTbl), 4, 1);  // IO windows exist, so total table rows = 4
        gtk_widget_show(IOVbox);
        gtk_widget_grab_focus(IEntry);  // Input window loses focus while it is hidden
        gtk_entry_set_text(GTK_ENTRY(IEntry),tmpcb);
    }
    gtk_widget_queue_draw(window);  // redraw everything
}

void TakeInputFocus()
{
    gtk_widget_grab_focus(IEntry);      // get the focus back from the VGA window
}

void MakeListsGray()
{
    if (AtBreak == FALSE)
    {
        SetStatusText(0, "Running");
    }
    else
        SetStatusText(0, "Break");

    // It's good to set the background color OUTSIDE the area of the lists
    // -- except that this seems difficult in gtk
    // So, the default behavior is not quite as pretty, but it is good enough.
}

// ParseIDText (*bochs*) calls this when the window needs to be redrawn with new text --
// funct must not call any GTK functions directly, because it is run from the bochs thread
void SetOutWinTxt()
{
    UpdateOWflag = TRUE;
}

// in the Win32 version, the caret is placed at the beginning of each selected history line,
// but the exact functionality is not important -- just do what is easy
void SelectHistory(int UpDown)
{
    // the History buffer is circular, so wrap 64 to 0, and -1 to 63
    CommandHistoryIdx = (CommandHistoryIdx + UpDown) & 63;
    gtk_entry_set_text(GTK_ENTRY(IEntry),CmdHistory[(CmdHInsert + CommandHistoryIdx) & 63]);
}

void ClearInputWindow()
{
    gtk_entry_set_text(GTK_ENTRY(IEntry),"");
}

// set == 0 to clear a check, 1 or 2 to set a check
void SetMenuCheckmark (int set, int ChkIdx)
{
    bx_bool flag = TRUE;
    if (set == 0)
        flag = FALSE;
    if ((bx_bool) gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(ChkMIs[ChkIdx])) != flag)
    {
        ForcingCheck = TRUE;
        gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ChkMIs[ChkIdx]), flag);
    }
}

// pass in FALSE or 0 to gray out a menu item
void GrayMenuItem (int flag, int CmdIndex)
{
//    GtkWidget *lbl;
    GtkWidget *MI = Cmd2MI[CmdIndex - CMD_IDX_LO + 1];
    // convert the Command Index to a Menu Item widget, and get its label
//    lbl = GTK_BIN(GTK_MENU_ITEM( MI ))->child;
    gtk_widget_set_sensitive ( MI, flag );
}


// finish initting things that must be initted in several stages
// -- this function is usually called only once, during the first doUpdate
void SpecialInit()
{
// Menu items can not be deactivated until after their signals are attached
    GrayMenuItem (0, CMD_EREG);
    GrayMenuItem (0, CMD_WPTWR);
    GrayMenuItem (0, CMD_WPTRD);
    GrayMenuItem (0, CMD_PAGEV);
//  GrayMenuItem (0, CMD_XCEPT);
    if (BX_SMP_PROCESSORS == 1)
        GrayMenuItem (0, CMD_ONECPU);
        // one or the other MemDump mode must always be left on! (unchangeable)
    if ((DumpInAsciiMode & 2) == 0)
        GrayMenuItem (0, CMD_MASCII);
    if ((DumpInAsciiMode & 1) == 0)
        GrayMenuItem (0, CMD_MHEX);

#if BX_SUPPORT_FPU == 0
    GrayMenuItem (0, CMD_FPUR);
#endif

    if (! CpuSupportSSE)
      GrayMenuItem (0, CMD_XMMR);

    doSimuInit = FALSE; // make sure this function is called once per simulation
}

// this routine is stubbed in the GTK version
void RedrawColumns(int listnum)
{
}

// autosize the columns that may be used by other dumps, once, on a DViewMode change
void SetAutoSize6_9()
{
    gtk_tree_view_column_set_sizing(AllCols[6], GTK_TREE_VIEW_COLUMN_AUTOSIZE);
    gtk_tree_view_column_set_sizing(AllCols[7], GTK_TREE_VIEW_COLUMN_AUTOSIZE);
    gtk_tree_view_column_set_sizing(AllCols[8], GTK_TREE_VIEW_COLUMN_AUTOSIZE);
    gtk_tree_view_column_set_sizing(AllCols[9], GTK_TREE_VIEW_COLUMN_AUTOSIZE);
}

// Show/Hide the typical pattern of Dump window columns (show the first n, hide the rest out to 17)
void ShowDListCols (int totcols)
{
    int i = 5;
    int firsthide = totcols + 5;        // convert from a col# to an acolnum
    while (++i < firsthide)
        gtk_tree_view_column_set_visible(AllCols[i], TRUE);
    while (i < 23)
        gtk_tree_view_column_set_visible(AllCols[i], FALSE);
}

// OS-dependent code that runs before each ListFill routine of each type
void StartListUpdate(int listnum)
{
    static int PrevDV = -1;             // type of previous Dump window that was displayed
    GtkListStore *Database;
    // set the scroll position back to the very top
    GtkAdjustment *va = gtk_tree_view_get_vadjustment ( GTK_TREE_VIEW(LV[listnum]) );
    gtk_adjustment_set_value (GTK_ADJUSTMENT(va), 0);
    // then clear the database for the list that is updating
    Database = (GtkListStore *) gtk_tree_view_get_model( GTK_TREE_VIEW(LV[listnum]) );
    gtk_list_store_clear(GTK_LIST_STORE(Database));

    // a DumpAlign change is treated just like a DViewMode change
    if (DViewMode == VIEW_MEMDUMP && PrevDAD != DumpAlign)
        PrevDV = -1;

    // use Upd flag to prevent paint messages, cpu_loop calls, duplicate calls
//  UpdInProgress[listnum] = TRUE;
    if (ResizeColmns != FALSE || (listnum == DUMP_WND && PrevDV != DViewMode))
    {
        // autosize Reg "hex" column, Asm "L.Addr" column
        if (listnum == REG_WND)
            gtk_tree_view_column_set_sizing(AllCols[1], GTK_TREE_VIEW_COLUMN_AUTOSIZE);
        else if (listnum == ASM_WND)
            gtk_tree_view_column_set_sizing(AllCols[3], GTK_TREE_VIEW_COLUMN_AUTOSIZE);
        // otherwise, autosize/rename/hide all the proper Dump list columns
        else
        {
            switch (DViewMode)
            {
                case VIEW_MEMDUMP:
                    // fix the MemDump column "names"
                    if (DumpInitted == FALSE)
                    {
                        GtkTreeIter iter;
                        ShowDListCols (18);     // show all columns -- must be visible to set col titles!
                            // reset a "generic" header for col 0
                        gtk_tree_view_column_set_title(AllCols[6], "Address");
                        gtk_tree_view_column_set_title(AllCols[7], "0");
                        gtk_tree_view_column_set_title(AllCols[8], "1");
                        gtk_tree_view_column_set_title(AllCols[9], "2");
                        gtk_tree_view_column_set_title(AllCols[23], "Ascii");
                        SetAutoSize6_9();       // autosize the usual suspects
                        // add a blank line to "modify the store" -- which will activate autosize
                        gtk_list_store_append (GTK_LIST_STORE(Database), &iter);  /* Acquire an iterator */
                        gtk_list_store_set (GTK_LIST_STORE(Database), &iter, 0, "", -1);
                    }
                    else
                    {
                        gtk_tree_view_column_set_sizing(AllCols[6], GTK_TREE_VIEW_COLUMN_AUTOSIZE);
                        if (PrevDV == VIEW_MEMDUMP)     // autosizing address column only?
                            break;
                        PrevDAD = DumpAlign;
                        gtk_tree_view_column_set_title(AllCols[23], "Ascii");
                        if ((DumpInAsciiMode & 2) == 0)     // hex bit is turned on?
                        {
                                // if dumping ONLY in ascii, hide ALL the other columns
                            ShowDListCols (2);      // show only columns 0 and 17
                            break;
                        }
                        // columns must be visible to set col titles!
                        gtk_tree_view_column_set_visible(AllCols[7], TRUE);
                        gtk_tree_view_column_set_visible(AllCols[8], TRUE);
                        gtk_tree_view_column_set_visible(AllCols[9], TRUE);
                        gtk_tree_view_column_set_title(AllCols[7], "0");
                        gtk_tree_view_column_set_title(AllCols[8], "1");
                        gtk_tree_view_column_set_title(AllCols[9], "2");
                        for (int i = 7 ; i < 24 ; i++)
                        {
                            if (((i - 7) & (DumpAlign - 1)) == 0)       // either autosize,
                            {
                                gtk_tree_view_column_set_sizing(AllCols[i], GTK_TREE_VIEW_COLUMN_AUTOSIZE);
                                gtk_tree_view_column_set_visible(AllCols[i], TRUE);
                            }
                            else            // or set the column invisible
                                gtk_tree_view_column_set_visible(AllCols[i], FALSE);
                        }
                    }
                    break;

                case VIEW_GDT:
                    SetAutoSize6_9();           // autosize the usual suspects
                    if (PrevDV == VIEW_GDT)     // autosizing only?
                        break;
                    ShowDListCols (5);      // show 4 columns, hide the rest out to 17
                    gtk_tree_view_column_set_title(AllCols[6], "Index");        // header for col 0
                    gtk_tree_view_column_set_title(AllCols[7], "Base Address"); // header for col 1
                    gtk_tree_view_column_set_title(AllCols[8], "Size");         // header for col 2
                    gtk_tree_view_column_set_title(AllCols[9], "DPL");          // header for col 3
                    gtk_tree_view_column_set_title(AllCols[23], "Info");        // header for col 4 (17)
                    break;

                case VIEW_IDT:
                    gtk_tree_view_column_set_sizing(AllCols[6], GTK_TREE_VIEW_COLUMN_AUTOSIZE);
                    if (PrevDV == VIEW_IDT)     // autosizing only?
                        break;
                    ShowDListCols (2);      // show 1 column, hide the rest out to 17
                    gtk_tree_view_column_set_title(AllCols[6], "Interrupt");        // header for col 0
                    gtk_tree_view_column_set_title(AllCols[23], "L.Address");       // header for col 1 (17)
                    break;

                case VIEW_PAGING:
                    gtk_tree_view_column_set_sizing(AllCols[6], GTK_TREE_VIEW_COLUMN_AUTOSIZE);
                    if (PrevDV == VIEW_PAGING)      // autosizing only?
                        break;
                    ShowDListCols (2);      // show 1 column, hide the rest out to 17
                    gtk_tree_view_column_set_title(AllCols[6], "L.Address");                // header for col 0
                    gtk_tree_view_column_set_title(AllCols[23], "is mapped to P.Address");  // header for col 1 (17)
                    break;

                case VIEW_STACK:
                    gtk_tree_view_column_set_sizing(AllCols[6], GTK_TREE_VIEW_COLUMN_AUTOSIZE);
                    gtk_tree_view_column_set_sizing(AllCols[7], GTK_TREE_VIEW_COLUMN_AUTOSIZE);
                    if (PrevDV == VIEW_STACK)       // autosizing only?
                        break;
                    ShowDListCols (3);      // show 2 columns, hide the rest out to 17
                    gtk_tree_view_column_set_title(AllCols[6], "L.Address");    // header for col 0
                    gtk_tree_view_column_set_title(AllCols[7], "Value");        // header for col 1
                    gtk_tree_view_column_set_title(AllCols[23], "(dec.)");  // header for col 2 (17)
                    break;

                case VIEW_BREAK:
                    gtk_tree_view_column_set_sizing(AllCols[6], GTK_TREE_VIEW_COLUMN_AUTOSIZE);
                    gtk_tree_view_column_set_sizing(AllCols[7], GTK_TREE_VIEW_COLUMN_AUTOSIZE);
                    if (PrevDV == VIEW_STACK)       // autosizing only?
                        break;
                    ShowDListCols (3);      // show 2 columns, hide the rest out to 17
                    gtk_tree_view_column_set_title(AllCols[6], "Address");  // header for col 0
                    gtk_tree_view_column_set_title(AllCols[7], "Enabled");  // header for col 1
                    gtk_tree_view_column_set_title(AllCols[23], "ID");  // header for col 2 (17)
            }
            PrevDV = DViewMode;
        }
    }
}

void EndListUpdate(int listnum)
{
    int i;

//  UpdInProgress[listnum] = FALSE;     // It's OK to paint the listview now
    // clear selections for each list on a list update
    if (listnum == REG_WND)
    {
        i = TOT_REG_NUM + EXTRA_REGS;
        while (--i >= 0)
            SelReg[i] = 0;
    }
    else if (listnum == ASM_WND)
    {
        i = MAX_ASM;
        while (--i >= 0)
            SelAsm[i] = 0;
    }
    else if (DViewMode == VIEW_MEMDUMP)
    {
        i = 256;
        while (--i >= 0)
            SelMem[i] = 0;
    }

    // AUTOSIZE turns off "user resize" mode! Turning resize mode back on will force
    // autosize back into GROW_ONLY mode -- which is what I want, anyway.
    i = 23;
    while (--i >= 0)
    {
        // the 3rd column in Reg and Asm lists is not resizable
        if (i != 2 && i != 5)
            gtk_tree_view_column_set_resizable  (AllCols[i], TRUE);
    }
//  Invalidate (listnum);
}

void DispMessage(const char *msg, const char *title)
{
    GtkWidget *dialog;
    dialog = gtk_message_dialog_new(GTK_WINDOW(window),
        GTK_DIALOG_DESTROY_WITH_PARENT,
        GTK_MESSAGE_WARNING,
        GTK_BUTTONS_OK,
        "%s", msg);
    gtk_window_set_title(GTK_WINDOW(dialog), title);
    gtk_dialog_run(GTK_DIALOG(dialog));
    gtk_widget_destroy(dialog);
}

// hide/clear param_tree window when showing a different MemDump window (GDT, IDT, etc.)
void HideTree()
{
    GtkTreeStore *treestore;
    if (DViewMode != VIEW_PTREE)
        return;
    treestore = (GtkTreeStore *) gtk_tree_view_get_model( GTK_TREE_VIEW(PTree) );
    gtk_container_remove (GTK_CONTAINER(ScrlWin[2]),PTree);
    gtk_container_add (GTK_CONTAINER(ScrlWin[2]), LV[2]);
    gtk_tree_store_clear(GTK_TREE_STORE(treestore));
}

// exit GDT/IDT/Paging/Stack/Tree -- back to the MemDump window
void ShowMemData(bx_bool initting)
{
    int i = 1;
    if (LinearDump == FALSE)
        i = 0;
    if (initting != FALSE)
    {
        GrayMenuItem (0, CMD_WPTWR);
        GrayMenuItem (0, CMD_WPTRD);
        // update column 0 to say whether its physmem or linear
        gtk_tree_view_column_set_title(AllCols[6], DC0txt[i]);
    }
    HideTree();
    gtk_widget_show(LV[DUMP_WND]);
    DViewMode = VIEW_MEMDUMP;       // returning to MemDump mode
    if (DumpInitted == FALSE)
    {
        StartListUpdate(DUMP_WND);  // autosize for a blank MemDump window
        EndListUpdate(DUMP_WND);
    }
    else
    {
        gtk_tree_view_column_set_title(AllCols[6], DC0txt[i]);
        if (AtBreak == FALSE)
            doDumpRefresh = TRUE;
        else
            ShowData();         // repopulates & resizes all columns
    }
}

// create the top layer of a parameter tree TreeView
void FillPTree()
{
    int n;
    GtkTreeStore *treestore;
    extern bx_list_c *root_param;
    // Note: don't multithread this display -- the user expects it to complete
    if (DViewMode != VIEW_PTREE)
    {
        gtk_container_remove (GTK_CONTAINER(ScrlWin[2]),LV[2]);
        gtk_container_add (GTK_CONTAINER(ScrlWin[2]), PTree);
    }
    doDumpRefresh = FALSE;
    treestore = (GtkTreeStore *) gtk_tree_view_get_model( GTK_TREE_VIEW(PTree) );
    gtk_tree_store_clear(GTK_TREE_STORE(treestore));
    // Note: all tree strings are hardcoded to be in tmpcb -- don't change!
    n = root_param->get_size();
    for (int i=0; i<n; i++)
        MakeBL(NULL, root_param->get(i));
    gtk_widget_show(PTree);
}

void MakeTreeChild (TreeParent *h_P, int ChildCount, TreeParent *h_TC)
{
    GtkTreeStore *treestore;
    treestore = (GtkTreeStore *) gtk_tree_view_get_model( GTK_TREE_VIEW(PTree) );
    gtk_tree_store_append(GTK_TREE_STORE(treestore), h_TC, h_P);            // create the "leaf"
    gtk_tree_store_set(GTK_TREE_STORE(treestore), h_TC, 0, tmpcb, -1);  // and put a name (+ data) on it
}

void update_font()
{
  int i, width;

  g_object_set(G_OBJECT(LV_Rend[0]), "font", fontname, NULL);
  g_object_set(G_OBJECT(LV_Rend[1]), "font", fontname, NULL);
  g_object_set(G_OBJECT(LV_Rend[2]), "font", fontname, NULL);
  // calculate a new value for OneCharWide
  PangoLayout * layout = gtk_widget_create_pango_layout(LV[0], "M");
  PangoFontDescription * fontdesc;
  g_object_get(G_OBJECT(LV_Rend[0]), "font-desc", &fontdesc, NULL); 
  pango_layout_set_font_description(layout, fontdesc); 
  pango_layout_get_pixel_size(layout, &width, &i);
  pango_font_description_free(fontdesc);
  g_object_unref(layout);
  OneCharWide = width;        // The "width" I'm getting is about half what I expect
//OneCharWide = width >> 1;   // pretend that an average char width is half an "M"
  if (OneCharWide > 12) OneCharWide = 12;
}

bx_bool NewFont()
{
    char *ofn;
    if (AtBreak == FALSE)
        return FALSE;
    // need to know the current font, to highlight it
    g_object_get(G_OBJECT(LV_Rend[0]), "font", &ofn, NULL);
    GtkWidget *widget = gtk_font_selection_dialog_new("Choose primary font");
    gtk_font_selection_dialog_set_font_name(GTK_FONT_SELECTION_DIALOG(widget), ofn);
    if (gtk_dialog_run(GTK_DIALOG (widget)) == GTK_RESPONSE_OK) {
        char *nfn = gtk_font_selection_dialog_get_font_name(GTK_FONT_SELECTION_DIALOG(widget));
        strncpy(fontname, nfn, 80);
        g_free(nfn);
        update_font();
    }
    g_free(ofn);
    gtk_widget_destroy(widget);

    return TRUE;
}

// turn off any current sizing/docking mode
void sizing_cancel()
{
    // cancel presize, size, predock, and dock modes
    if (Sizing != 0)
    {
        gtk_event_box_set_above_child (GTK_EVENT_BOX(LVEvtBox), FALSE);
        gtk_event_box_set_above_child (GTK_EVENT_BOX(VSepEvtBox1), TRUE);
        gtk_event_box_set_above_child (GTK_EVENT_BOX(VSepEvtBox2), TRUE);
        if (Sizing < 10)    // cancel (p)resize mode motion detection
            g_signal_handler_disconnect (LVEvtBox, mmov_hID);
        gdk_window_set_cursor (gtk_widget_get_window(LVEvtBox), NULL); // change the cursor to normal
        Sizing = 0;
    }
    EnterSizeMode = FALSE;
    SizingDelay = 0;
    SizeList = 0;
    xClick = -1;
}

// conditionally begin a resize operation
void enter_resize_mode()
{
    // need reasonably accurate column widths in horz. limit calculations -- update widths
    GtkAllocation alloc;
    int width0, width1;
    gint totwidth;
    EnterSizeMode = FALSE;      // presize mode may never have reset this
    // a GtkAllocation structure (inside every widget) is a rectangle: relative x, y, + width & height
    gtk_widget_get_allocation(ScrlWin[0], &alloc);
    width0 = alloc.width;
    ListWidthPix[0] = width0;
    gtk_widget_get_allocation(ScrlWin[1], &alloc);
    width1 = alloc.width;
    ListWidthPix[1] = width1;

    totwidth = gdk_window_get_width(gtk_widget_get_window(window));
    ListWidthPix[2] = totwidth - (width0 + width1);

    if (Sizing < 0)         // in presize mode? -- enter full resize mode
        SetHorzLimits();
}

// begin a pre-dock operation -- cancel if a mouseup event happens
void Set_PreDock(int ListNum, GdkEventButton *event)
{
    // Sadly, in order to narrow the mousedown event to only the ListView (without the scrollbars)
    // information seems to get lost about which button is being pressed
    // -- but the button info seems not reliable anyway (currently) so it must be lived with

    // enter pre-dock mode, autoactivate full docking mode in 2 VGAW refresh time ticks
    xClick = (unsigned int) (event->x_root + 0.5);
    yClick = (unsigned int) (event->y_root + 0.5);
    SizeList = ListNum + 10;
    SizingDelay = 2;
}

// Select one entry in Register ListView
gboolean RegMouseDown_cb(GtkWidget *widget, GdkEventButton *event, gpointer data)
{
    int row;
    GtkTreePath *path;
    gint *pathdat;
    bx_bool onrow;

    Set_PreDock (0, event);
    GrayMenuItem (0, CMD_WPTWR);        // disable watchpoints for physdumps (not selected)
    GrayMenuItem (0, CMD_WPTRD);
    GrayMenuItem (1, CMD_BRKPT);        // enable ASM breakpoints (window is selected by default)
    row = TOT_REG_NUM + EXTRA_REGS;
    while (--row >= 0)
        SelReg[row] = 0;
    onrow = (bx_bool) gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW(LV[0]),
        (gint) (event->x + 0.5), (gint) (event->y + 0.5), &path, NULL, NULL, NULL);
    if (onrow == FALSE)
        return FALSE;
    pathdat = gtk_tree_path_get_indices (path);
    row = (int) *pathdat;
    gtk_tree_path_free (path);
    if (row >= TOT_REG_NUM + EXTRA_REGS || row < 0)
        row = TOT_REG_NUM + EXTRA_REGS -1;
    SelReg[row] = TRUE;
    Invalidate (REG_WND);

    return FALSE;
}

// Select multiple entries in ASM ListView
gboolean AsmMouseDown_cb(GtkWidget *widget, GdkEventButton *event, gpointer data)
{
    GtkTreePath *path;
    gint *pathdat;
    bx_bool onrow;

    Set_PreDock (1, event);
    GrayMenuItem (0, CMD_WPTWR);        // disable watchpoints for physdumps (not selected)
    GrayMenuItem (0, CMD_WPTRD);
    GrayMenuItem (1, CMD_BRKPT);        // enable ASM breakpoints (window is selected)
    if ((event->state & GDK_CONTROL_MASK) == 0)
    {
        int i = MAX_ASM;
        while (--i >= 0)
            SelAsm[i] = 0;
    }
    onrow = (bx_bool) gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW(LV[1]),
        (gint) (event->x + 0.5), (gint) (event->y + 0.5), &path, NULL, NULL, NULL);
    if (onrow == FALSE)
        return FALSE;
    pathdat = gtk_tree_path_get_indices (path);
    SelectedEntry = (int) *pathdat;
    gtk_tree_path_free (path);
    if (SelectedEntry >= MAX_ASM || SelectedEntry < 0)
        SelectedEntry = MAX_ASM -1;
    SelAsm[SelectedEntry] ^= 1;
    Invalidate (ASM_WND);
    return FALSE;
}

// Select multiple entries in Phys or Linear Memdump ListView
gboolean MemMouseDown_cb(GtkWidget *widget, GdkEventButton *event, gpointer data)
{
    int column, cellx;
    GtkTreePath *path;
    gint *pathdat;
    bx_bool onrow;

    Set_PreDock (2, event);
    if (DViewMode != VIEW_MEMDUMP && DViewMode != VIEW_BREAK)
        return FALSE;
    if ((event->state & GDK_CONTROL_MASK) == 0)
    {
        int i = 256;
        while (--i >= 0)
            SelMem[i] = 0;
    }
    onrow = (bx_bool) gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW(LV[2]),
        (gint) (event->x + 0.5), (gint) (event->y + 0.5), &path, NULL, NULL, NULL);
    if (onrow == FALSE)
        return FALSE;
    pathdat = gtk_tree_path_get_indices (path);
    DumpSelRow = (int) *pathdat;
    gtk_tree_path_free (path);

    // handle enabling/disabling watchpoint menu items
    if (LinearDump == FALSE && DViewMode == VIEW_MEMDUMP)
    {
        GrayMenuItem (1, CMD_WPTWR);    // enable watchpoints for physdumps
        GrayMenuItem (1, CMD_WPTRD);
    }
    else
    {
        GrayMenuItem (0, CMD_WPTWR);    // disable watchpoints for lineardumps
        GrayMenuItem (0, CMD_WPTRD);
    }
    if (DViewMode != VIEW_MEMDUMP)      // VIEW_BREAK handling is complete now
    {
        GrayMenuItem (1, CMD_BRKPT);    // enable ASM breakpoints (window is selected by default)
        return FALSE;
    }
    GrayMenuItem (0, CMD_BRKPT);        // disable ASM breakpoints (window is not selected)

    cellx = 0;
    column = 6;     // loop over the Mem window columns, 6 to 23

    while (event->x >= cellx && column < 23)
    {
        int j = cellx += gtk_tree_view_column_get_width(AllCols[column]);
        if (event->x >= j){
            ++column;
            cellx = j;
        }
    }
    if (DumpSelRow >= 256 || DumpSelRow < 0)
        DumpSelRow = 255;
    KeyStateShft = event->state & GDK_SHIFT_MASK;
    KeyStateAlt = event->state & GDK_MOD1_MASK;
    SelMem[DumpSelRow] ^= 1;
    // only set the SelDataAddy for memdumps with a wordsize of 1
    if (DumpAlign == 1 && column > 6)
    {
        SA_valid = TRUE;
        SelectedDataAddress = DumpStart + (DumpSelRow*16) + (column - 7);
    }
    Invalidate (DUMP_WND);
    return FALSE;
}

// Change the CPU display
void CPUb_cb(GtkWidget *widget, gpointer CPUnum)    // "CPUnum" is the value supplied at handler creation
{
    unsigned int newCPU = GPOINTER_TO_INT(CPUnum);
    if (CurrentCPU != newCPU)
    {
        // change text on CurrentCPU button to lowercase and BOLD with markup
        strcpy (tmpcb, "<b>cpu0</b>");
        tmpcb[6] = CurrentCPU + '0';
        gtk_label_set_markup (GTK_LABEL(CpuB_label[CurrentCPU]), tmpcb);
        // change text on newCPU button to uppercase and BOLD with markup
        strcpy (tmpcb, "<b>CPU0</b>");
        tmpcb[6] = newCPU + '0';
        gtk_label_set_markup (GTK_LABEL(CpuB_label[newCPU]), tmpcb);
        CurrentCPU = newCPU;
        BottomAsmLA = ~0;       // force an ASM autoload, to repaint
        if (AtBreak != FALSE)   // if at a break, pretend it just happened
            OnBreak();          // refresh the ASM and Register windows
    }
}

// calls the proper GUI command on activate events -- non breaking
void nbCmd_cb(GtkWidget *widget, gpointer CmdIdx)       // "CmdIdx" is the value supplied at handler creation
{
    if (ForcingCheck == FALSE)      // using a hotkey to flip a menu item checkmark?
        ActivateMenuItem (GPOINTER_TO_INT (CmdIdx));
    ForcingCheck = FALSE;
}

// calls the proper GUI command on activate events, with a sim break
void Cmd_cb(GtkWidget *widget, gpointer CmdIdx)     // "CmdIdx" is the value supplied at handler creation
{
    if (AtBreak == FALSE)
    {
//      DoBreak = TRUE; -- for multithreading
        SIM->debug_break();     // On a menu click always break (with some exceptions)
    }
    ActivateMenuItem (GPOINTER_TO_INT (CmdIdx));
}

// code to run on exit -- arguments are ignored
void Close_cb(GtkWidget *widget, gpointer data)
{
    GtkListStore *Database;
    GtkTreeStore *treestore;
    // clear all the "store" databases
    Database = (GtkListStore *) gtk_tree_view_get_model( GTK_TREE_VIEW(LV[0]) );
    gtk_list_store_clear(GTK_LIST_STORE(Database));
    Database = (GtkListStore *) gtk_tree_view_get_model( GTK_TREE_VIEW(LV[1]) );
    gtk_list_store_clear(GTK_LIST_STORE(Database));
    Database = (GtkListStore *) gtk_tree_view_get_model( GTK_TREE_VIEW(LV[2]) );
    gtk_list_store_clear(GTK_LIST_STORE(Database));
    treestore = (GtkTreeStore *) gtk_tree_view_get_model( GTK_TREE_VIEW(PTree) );
    gtk_tree_store_clear(GTK_TREE_STORE(treestore));

    gtk_window_get_position(GTK_WINDOW(window), &win_x, &win_y);
    gtk_window_get_size(GTK_WINDOW(window), &win_w, &win_h);
    bx_user_quit = 1;
    SIM->debug_break();
    // holding one extra reference to both ScrlWin[2] widgets
    // but I "sank" PTree myself, so it is my understanding that I need to "destroy" it myself
    gtk_widget_destroy(PTree);
    g_object_unref(PTree);
    g_object_unref(LV[2]);
    gdk_cursor_unref(SizeCurs);
    gdk_cursor_unref(DockCurs);

    if (!SIM->is_wx_selected()) {
      gtk_main_quit();
    }
    window = NULL;
}

// there is only one widget that receives keystrokes, the Input Entry widget
// -- process those keydowns for hotkeys and special keys
gboolean keydown_event_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
{
    gboolean ret = FALSE;   // assume the key is NOT a hotkey -- enter it into the widget
    int key = (int) (event->keyval & 0xffff);
    int Control, Shift, Alt;
    Control= Shift= Alt= 0;
    if ((event->state & GDK_CONTROL_MASK) != 0)
        Control = -1;
    if ((event->state & GDK_SHIFT_MASK) != 0)
        Shift = -1;
    if ((event->state & GDK_MOD1_MASK) != 0)        // this is the Alt key mask
        Alt = -1;

    switch (event->keyval)
    {
        case  'c':
        case  'd':
        case  'f':
            if (Control == 0) break;
            key &= 0xdf;            // convert to upper case
        case  VK_UP:
        case  VK_DOWN:
        case  VK_PRIOR:
        case  VK_NEXT:
        case  VK_ESCAPE:
        case  VK_F2:
        case  VK_F3:
        case  VK_F4:
        case  VK_F5:
        case  VK_F6:
        case  VK_F7:
        case  VK_F8:
        case  VK_F9:
        case  VK_F11:
        case  VK_RETURN:
            HotKey (key, Alt, Shift, Control);
            ret = TRUE;
    }
    return ret;
}

// Input window appears to be hidden -- main window received a keydown.
// Force the event to redirect to the hidden IEntry widget
gboolean redirect_keydown(GtkWidget *widget, GdkEvent *event, gpointer data)
{
    // send the event ONLY to IEntry -- do not try to propogate it beyond
    gtk_widget_event(IEntry, event);
    return TRUE;
}

// table (that contains the main windows!) is being resized/moved
// Note: the window gets MANY of these events where the size remains constant
gboolean TblSizeEvent(GtkWidget *widget, GdkEventConfigure *event, gpointer data)
{
    int i, j, k;
    bx_bool unchanged = FALSE;
    gint WinSizeX;
    gint WinSizeY;
    GdkWindow *TblGdk = gtk_widget_get_parent_window(TreeTbl);

    WinSizeX = gdk_window_get_width(TblGdk);
    WinSizeY = gdk_window_get_height(TblGdk);

    // don't "resize" on minimize, if window is too small, or if width is (almost) unchanged
    // -- five pixels spread over 3 windows is negligible
    if (CurXSize > (unsigned int)WinSizeX - 8 && CurXSize <= (unsigned int)WinSizeX)
        unchanged = TRUE;
    if (WinSizeY > 100 && WinSizeX > 150 && unchanged == FALSE)
    {
        CurXSize = WinSizeX -4;     // assume 4 pixels total for the two VSeparators

        // need to recalculate List widths, with the same proportions as before
        i = ListWidthPix[0] + ListWidthPix[1] + ListWidthPix[2];
        if (i == 0)
            i = 1;
        j = (ListWidthPix[2] * CurXSize) / i;
        k = (ListWidthPix[1] * CurXSize) / i;
        i = OneCharWide << 2;
        if (j < i) j = i;
        if (k < i) k = i;
        ListWidthPix[0] = CurXSize - k - j;     // Register list
        ListWidthPix[1] = k;                    // Asm
        ListWidthPix[2] = j;                    // MemDump
        ListVerticalPix = (WinSizeY * 3) /4;
        // set the size of the two ScrlWins that are not in the middle
        // (the middle one automatically takes the rest)
        i= CurCenterList -1;
        if (i < 0)          // wrap -1 to 2
            i = 2;
    // -1 means "let the window manager decide how big to make it"
        gtk_widget_set_size_request(ScrlWin[i], ListWidthPix[i], -1);
        i = CurCenterList + 1;
        if (i == 3)     // wrap 3 to 0
            i = 0;
        gtk_widget_set_size_request(ScrlWin[i], ListWidthPix[i], -1);
    }
    return FALSE;
}

// Note: for some reason, the path shouldn't be freed
void Reg_DblClick (GtkTreeView *treeview, GtkTreePath *path, GtkTreeViewColumn *col, gpointer data)
{
    sizing_cancel();
    if (AtBreak == FALSE)
        return;
    ChangeReg();
}

void Asm_DblClick (GtkTreeView *treeview, GtkTreePath *path, GtkTreeViewColumn *col, gpointer data)
{
    sizing_cancel();
    if (AtBreak == FALSE)
        return;
    SetBreak(SelectedEntry);
}

void Mem_DblClick (GtkTreeView *treeview, GtkTreePath *path, GtkTreeViewColumn *col, gpointer data)
{
    sizing_cancel();
    if (AtBreak == FALSE || (DViewMode != VIEW_MEMDUMP && DViewMode != VIEW_BREAK))
        return;

    if (DViewMode == VIEW_MEMDUMP)
    {
        if (KeyStateShft != 0 && LinearDump == FALSE)
            SetWatchpoint(&num_write_watchpoints,write_watchpoint);

        else if (KeyStateAlt != 0 && LinearDump == FALSE)
            SetWatchpoint(&num_read_watchpoints,read_watchpoint);

        else
//L HIHI Fix how this works in the Windoze version to match GTK?
            SetMemLine(DumpSelRow);
    }
    else            // doubleclick to delete a breakpoint in Breakpoint dump
    {
//L HIHI pre-test DumpSelRow < 256
        if (DumpSelRow < WWP_BaseEntry)
        {
            if (BrkpIDMap[DumpSelRow] == 0)
                ;   // dblclick was on an invalid row
            else if (DumpSelRow > EndPhyEntry)
                bx_dbg_del_vbreak(BrkpIDMap[DumpSelRow]);   // delete Virtual Brk
            else if (DumpSelRow > EndLinEntry)
                bx_dbg_del_pbreak(BrkpIDMap[DumpSelRow]);   // delete Phy Brkpt
            else
            {
                bx_dbg_del_lbreak(BrkpIDMap[DumpSelRow]);   // delete Lin Brkpt
                ParseBkpt();        // get a new set of linear breakpoints
                Invalidate (1);     // breakpoint colors may have changed
            }
        }
        else if (DumpSelRow >= WWP_BaseEntry && DumpSelRow < WWP_BaseEntry + WWPSnapCount)
        {
            // if a watchpoint was clicked, get its index (0 to 15)
            int i = DumpSelRow - WWP_BaseEntry;
            if (WWP_Snapshot[i] == write_watchpoint[i].addr)
                DelWatchpoint(write_watchpoint, &num_write_watchpoints, i);
        }
        else if (DumpSelRow >= RWP_BaseEntry && DumpSelRow < RWP_BaseEntry + RWPSnapCount)
        {
            int i = DumpSelRow - RWP_BaseEntry;
            if (RWP_Snapshot[i] == read_watchpoint[i].addr)
                DelWatchpoint(read_watchpoint, &num_read_watchpoints, i);
        }
        RefreshDataWin();       // show the NEW set of break/watchpoints
    }
}

// enforce that resize moves remain within the window
gboolean LvLeave(GtkWidget *widget, GdkEventCrossing *event, gpointer data)
{
    if (Sizing == 0 && xClick < 0)      // anything to cancel?
        return FALSE;
    // calculate the position of the top left corner of the LV Event Box
    unsigned int x_org = (unsigned int) (event->x_root - event->x + 0.5);
    unsigned int y_org = (unsigned int) (event->y_root - event->y + 0.5);
    unsigned int absx = (unsigned int) (event->x_root + 0.5);
    unsigned int absy = (unsigned int) (event->y_root + 0.5);
    gint width;
    gint height;
    // get the width and height of the ListView hbox window
    width = gdk_window_get_width(event->window);
    height = gdk_window_get_height(event->window);

    // cursor moved outside the box (not just onto a vert. separator)?
    if (absx < x_org || absx >= (x_org + width) || absy < y_org || absy >= (y_org + height))
        sizing_cancel();
    return FALSE;
}

// doing a resizing operation -- keep track of the cursor position
gboolean LV_MouseMove(GtkWidget *widget, GdkEventMotion *event, gpointer data)
{
    int Cur_CliX = (int) (event->x + 0.5);

    if (EnterSizeMode != FALSE)
    {
        // need the "relative" X coordinate of the cursor (wrt the LVEB window)
        int PrevCliX = CurScrX - (int)(event->x_root - event->x + 0.5);
        int i= OneCharWide >> 1;
        Resize_LoX = PrevCliX - i;  // set presize horizontal limits
        Resize_HiX = PrevCliX + i;
        EnterSizeMode = FALSE;
    }
    if (Sizing != 0)
    {
        // enforce horizontal limits of the current resize operation
        if (Cur_CliX > Resize_HiX || Cur_CliX < Resize_LoX)
            sizing_cancel();
    }
    return FALSE;
}

// begin a resizing operation
gboolean LV_MouseDown(GtkWidget *widget, GdkEventButton *event, gpointer data)
{
// pre-size mode activated the LVEventBox, and now the user has clicked the mouse
    enter_resize_mode();    // updates ListWidthPix, verifies presize mode
    return TRUE;
}

// mouse is on top of a separator between listviews -- enter presize mode
gboolean VsEnter(GtkWidget *widget, GdkEventCrossing *event, gpointer SepNum)
{
    int VsepNum = GPOINTER_TO_INT( SepNum );

    // turn on presize mode, if some kind of sizing isn't already running
    if (Sizing == 0)
    {
        Sizing = VsepNum - 2;       // Sizing = -1 or -2 for "presize"
        gdk_window_set_cursor (gtk_widget_get_window(LVEvtBox), SizeCurs);
        EnterSizeMode = TRUE;
        CurScrX = (unsigned int) (event->x_root + 0.5);
        gtk_event_box_set_above_child (GTK_EVENT_BOX(LVEvtBox), TRUE);
        gtk_event_box_set_above_child (GTK_EVENT_BOX(VSepEvtBox1), FALSE);
        gtk_event_box_set_above_child (GTK_EVENT_BOX(VSepEvtBox2), FALSE);
        mmov_hID = g_signal_connect (G_OBJECT (LVEvtBox), "motion_notify_event",
            G_CALLBACK (LV_MouseMove), NULL);
    }
    return FALSE;
}

gboolean LV_MouseUp(GtkWidget *widget, GdkEventButton *event, gpointer data)
{
    SizingDelay = 0;    // cancel pre-dock mode on every mouseup
    SizeList = 0;       // -- this will not affect any other sizing modes
    xClick = -1;
    return FALSE;
}

// either cancel or complete a dock or sizing
gboolean LEB_MouseUp(GtkWidget *widget, GdkEventButton *event, gpointer data)
{
    GtkAllocation alloc;
    int width0, width1, fList, oldcList, dest;
    gint totwidth, heightLV, x, zip;
    if (Sizing != 0 || xClick >= 0)     // complete a resize or dock operation
    {
        int cx = (int)(event->x + 0.5);
        int cy = (int)(event->y + 0.5);
        gtk_widget_get_allocation(ScrlWin[0], &alloc);
        heightLV = alloc.height;
        totwidth = gdk_window_get_width(gtk_widget_get_window(window));
        zip = gdk_window_get_height(gtk_widget_get_window(window));
        dest = fList = (DockOrder >> 8) -1;

        if (Sizing < 10)    // complete a resize operation
        {
            width0 = cx;
            width1 = ListWidthPix[fList] - cx;  // "delta" pixels (pos or neg)
            if (Sizing == 1)    // moving Vsep1?
                gtk_widget_set_size_request(ScrlWin[fList], cx, -1);
            else
            {
                dest = (DockOrder & 3) -1;
                width0 = totwidth - cx - 4; // assume the Vseps are 2 pixels wide
                width1 = ListWidthPix[dest] - width0;   // "delta" pixels (pos or neg)
                gtk_widget_set_size_request(ScrlWin[dest], width0, -1);
            }
            ListWidthPix[dest] = width0;
            ListWidthPix[CurCenterList] += width1;  // tack the delta pixels onto ctr list
        }
        else    // complete a Docking operation
        {
            // get "local" x mouse coordinate value (main window relative)
            gdk_window_get_pointer(gtk_widget_get_window(LVEvtBox), &x, &zip, NULL);
            // verify that mouseup was within a LV window
            if (x >= 0 && cy >= 0 && x < totwidth && cy < heightLV)
            {
                // update the widths of the LVs
                gtk_widget_get_allocation(ScrlWin[0], &alloc);
                width0 = alloc.width;
                ListWidthPix[0] = width0;
                gtk_widget_get_allocation(ScrlWin[1], &alloc);
                width1 = alloc.width;
                ListWidthPix[1] = width1;
                ListWidthPix[2] = totwidth - (width0 + width1);
                oldcList = CurCenterList;
                if ((unsigned) x < ListWidthPix[fList])
                    dest = fList;
                else if ((unsigned) x < ListWidthPix[fList] + ListWidthPix[CurCenterList])
                    dest = CurCenterList;
                else dest = (DockOrder & 3) -1;
                DockResize (dest, (Bit32u) 0);      // ParentX is not used for docking
                // if the center list moved, it will not keep its size properly
                if (oldcList != CurCenterList)
                {
                    gtk_widget_set_size_request(ScrlWin[CurCenterList], -1, -1);
                    gtk_widget_set_size_request(ScrlWin[oldcList], ListWidthPix[oldcList], -1);
                }
            }
        }
        sizing_cancel();
    }
    return TRUE;
}

// one-time init function to make all the buttons/menu items work
void AttachSignals()
{
    int i;
    g_signal_connect (G_OBJECT(window), "destroy",
        G_CALLBACK(Close_cb), (gpointer) NULL);
    g_signal_connect (G_OBJECT(CmdBtn[0]), "clicked", G_CALLBACK(nbCmd_cb), (gpointer) (glong) BtnLkup[0]);
    g_signal_connect (G_OBJECT(CmdBtn[1]), "clicked", G_CALLBACK(nbCmd_cb), (gpointer) (glong) BtnLkup[1]);
    g_signal_connect (G_OBJECT(CmdBtn[2]), "clicked", G_CALLBACK(nbCmd_cb), (gpointer) (glong) BtnLkup[2]);
    g_signal_connect (G_OBJECT(CmdBtn[3]), "clicked", G_CALLBACK(Cmd_cb), (gpointer) (glong) BtnLkup[3]);
    g_signal_connect (G_OBJECT(CmdBtn[4]), "clicked", G_CALLBACK(nbCmd_cb), (gpointer) (glong) BtnLkup[4]);

    i = BX_SMP_PROCESSORS;
    if (i > 1)
    {
        while (--i >= 0)
            g_signal_connect (G_OBJECT(CpuBtn[i]), "clicked", G_CALLBACK(CPUb_cb), (gpointer) (glong) i);
    }

// activate the menu items
    g_signal_connect (G_OBJECT(ContMI), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_CONT);
    g_signal_connect (G_OBJECT(StepMI), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_STEP1);
    g_signal_connect (G_OBJECT(StepNMI), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_STEPN);
    g_signal_connect (G_OBJECT(BreakMI), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_BREAK);
    g_signal_connect (G_OBJECT(SetBrkMI), "activate", G_CALLBACK(Cmd_cb), (gpointer) CMD_BRKPT);
    Cmd2MI[CMD_BRKPT - CMD_IDX_LO + 1] = SetBrkMI;
    g_signal_connect (G_OBJECT(WatchWrMI), "activate", G_CALLBACK(Cmd_cb), (gpointer) CMD_WPTWR);
    Cmd2MI[CMD_WPTWR - CMD_IDX_LO + 1] = WatchWrMI;
    g_signal_connect (G_OBJECT(WatchRdMI), "activate", G_CALLBACK(Cmd_cb), (gpointer) CMD_WPTRD);
    Cmd2MI[CMD_WPTRD - CMD_IDX_LO + 1] = WatchRdMI;
    g_signal_connect (G_OBJECT(FindMI), "activate", G_CALLBACK(Cmd_cb), (gpointer) CMD_FIND);
    g_signal_connect (G_OBJECT(RefreshMI), "activate", G_CALLBACK(Cmd_cb), (gpointer) CMD_RFRSH);

    g_signal_connect (G_OBJECT(PhyDumpMI), "activate", G_CALLBACK(Cmd_cb), (gpointer) CMD_PHYDMP);
    g_signal_connect (G_OBJECT(LinDumpMI), "activate", G_CALLBACK(Cmd_cb), (gpointer) CMD_LINDMP);
    g_signal_connect (G_OBJECT(StackMI), "activate", G_CALLBACK(Cmd_cb), (gpointer) CMD_STACK);
    g_signal_connect (G_OBJECT(GDTMI), "activate", G_CALLBACK(Cmd_cb), (gpointer) CMD_GDTV);
    g_signal_connect (G_OBJECT(IDTMI), "activate", G_CALLBACK(Cmd_cb), (gpointer) CMD_IDTV);
    g_signal_connect (G_OBJECT(PageMI), "activate", G_CALLBACK(Cmd_cb), (gpointer) CMD_PAGEV);
    Cmd2MI[CMD_PAGEV - CMD_IDX_LO + 1] = PageMI;
    g_signal_connect (G_OBJECT(ViewBrkMI), "activate", G_CALLBACK(Cmd_cb), (gpointer) CMD_VBRK);
    g_signal_connect (G_OBJECT(MemDumpMI), "activate", G_CALLBACK(Cmd_cb), (gpointer) CMD_CMEM);
    g_signal_connect (G_OBJECT(PTreeMI), "activate", G_CALLBACK(Cmd_cb), (gpointer) CMD_PTREE);
    g_signal_connect (G_OBJECT(DisAsmMI), "activate", G_CALLBACK(Cmd_cb), (gpointer) CMD_DISASM);

    g_signal_connect (G_OBJECT(ChkMIs[CHK_CMD_MODEB]), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_MODEB);
    g_signal_connect (G_OBJECT(ChkMIs[CHK_CMD_ONECPU]), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_ONECPU);
    Cmd2MI[CMD_ONECPU - CMD_IDX_LO + 1] = ChkMIs[CHK_CMD_ONECPU];
    g_signal_connect (G_OBJECT(DefDisMI), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_DADEF);
    g_signal_connect (G_OBJECT(SyntaxMI), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_ATTI);
    g_signal_connect (G_OBJECT(FontMI), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_FONT);
    g_signal_connect (G_OBJECT(ChkMIs[CHK_CMD_UCASE]), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_UCASE);
    g_signal_connect (G_OBJECT(ChkMIs[CHK_CMD_IOWIN]), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_IOWIN);
    g_signal_connect (G_OBJECT(ChkMIs[CHK_CMD_SBTN]), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_SBTN);
    g_signal_connect (G_OBJECT(ChkMIs[CHK_CMD_MHEX]), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_MHEX);
    Cmd2MI[CMD_MHEX - CMD_IDX_LO + 1] = ChkMIs[CHK_CMD_MHEX];
    g_signal_connect (G_OBJECT(ChkMIs[CHK_CMD_MASCII]), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_MASCII);
    Cmd2MI[CMD_MASCII - CMD_IDX_LO + 1] = ChkMIs[CHK_CMD_MASCII];
    g_signal_connect (G_OBJECT(ChkMIs[CHK_CMD_LEND]), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_LEND);
    g_signal_connect (G_OBJECT(ChkMIs[CHK_CMD_IGNSA]), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_IGNSA);
    g_signal_connect (G_OBJECT(ChkMIs[CHK_CMD_IGNNT]), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_IGNNT);
    g_signal_connect (G_OBJECT(ChkMIs[CHK_CMD_RCLR]), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_RCLR);
    g_signal_connect (G_OBJECT(ChkMIs[CHK_CMD_EREG]), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_EREG);
    Cmd2MI[CMD_EREG - CMD_IDX_LO + 1] = ChkMIs[CHK_CMD_EREG];
    g_signal_connect (G_OBJECT(ChkMIs[S_REG]), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_SREG);
    g_signal_connect (G_OBJECT(ChkMIs[SYS_R]), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_SYSR);
    g_signal_connect (G_OBJECT(ChkMIs[C_REG]), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_CREG);
    g_signal_connect (G_OBJECT(ChkMIs[FPU_R]), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_FPUR);
    Cmd2MI[CMD_FPUR - CMD_IDX_LO + 1] = ChkMIs[FPU_R];
    g_signal_connect (G_OBJECT(ChkMIs[XMM_R]), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_XMMR);
    Cmd2MI[CMD_XMMR - CMD_IDX_LO + 1] = ChkMIs[XMM_R];
    g_signal_connect (G_OBJECT(ChkMIs[D_REG]), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_DREG);
    Cmd2MI[CMD_DREG - CMD_IDX_LO + 1] = ChkMIs[D_REG];
//  g_signal_connect (G_OBJECT(ChkMIs[T_REG]), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_TREG);
//  Cmd2MI[CMD_TREG - CMD_IDX_LO + 1] = ChkMIs[T_REG];
    g_signal_connect (G_OBJECT(ChkMIs[CHK_CMD_LOGVIEW]), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_LOGVIEW);

    g_signal_connect (G_OBJECT(AboutMI), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_ABOUT);

    g_signal_connect (G_OBJECT(ChkMIs[WSChkIdx]), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_WS_1);
    g_signal_connect (G_OBJECT(ChkMIs[WSChkIdx+1]), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_WS_2);
    g_signal_connect (G_OBJECT(ChkMIs[WSChkIdx+2]), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_WS_4);
    g_signal_connect (G_OBJECT(ChkMIs[WSChkIdx+3]), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_WS_8);
    g_signal_connect (G_OBJECT(ChkMIs[WSChkIdx+4]), "activate", G_CALLBACK(nbCmd_cb), (gpointer) CMD_WS16);

    g_signal_connect (G_OBJECT (IEntry), "key_press_event", G_CALLBACK (keydown_event_cb), NULL);
    g_signal_connect (G_OBJECT (window), "key_press_event", G_CALLBACK (redirect_keydown), NULL);
    g_signal_connect (LV[0], "button_press_event", G_CALLBACK (RegMouseDown_cb), NULL);
    g_signal_connect (LV[0], "row-activated", G_CALLBACK(Reg_DblClick), (gpointer) 0);
    g_signal_connect (LV[1], "button_press_event", G_CALLBACK (AsmMouseDown_cb), NULL);
    g_signal_connect (LV[1], "row-activated", G_CALLBACK(Asm_DblClick), (gpointer) 1);
    g_signal_connect (LV[2], "button_press_event", G_CALLBACK (MemMouseDown_cb), NULL);
    g_signal_connect (LV[2], "row-activated", G_CALLBACK(Mem_DblClick), NULL);

    g_signal_connect (G_OBJECT (LVEvtBox), "leave_notify_event", G_CALLBACK (LvLeave), NULL);
    g_signal_connect (G_OBJECT (VSepEvtBox1), "enter_notify_event", G_CALLBACK (VsEnter), (gpointer) 0);
    g_signal_connect (G_OBJECT (VSepEvtBox2), "enter_notify_event", G_CALLBACK (VsEnter), (gpointer) 1);
    g_signal_connect (G_OBJECT (LVEvtBox), "button_press_event", G_CALLBACK (LV_MouseDown), NULL);
    g_signal_connect (G_OBJECT (LVEvtBox), "button_release_event", G_CALLBACK (LEB_MouseUp), NULL);
    g_signal_connect (G_OBJECT (LV[0]), "button_release_event", G_CALLBACK (LV_MouseUp), NULL);
    g_signal_connect (G_OBJECT (LV[1]), "button_release_event", G_CALLBACK (LV_MouseUp), NULL);
    g_signal_connect (G_OBJECT (LV[2]), "button_release_event", G_CALLBACK (LV_MouseUp), NULL);
}

// force the screen to "get current" every half a second
static gboolean VGAWrefreshTick(GtkWidget *widget)
{
    if (bx_user_quit != FALSE)      // may be in the middle of a "destroy"
        return FALSE;
    if (SizingDelay > 0)
    {
        GdkDisplay * display = gdk_display_get_default();
        gint x;
        gint y;     // enter pre-dock mode
        int i, j;
        --SizingDelay;
        gdk_display_get_pointer (display, NULL, &x, &y, NULL);  // absolute x and y mouse coords
        i = x - xClick;
        j = y - yClick;     // calculate the pixel delta from the mousedown event to now
        if (i < 0) i= -i;
        if (j < 0) j= -j;
        if ((SizingDelay == 1 && (i > OneCharWide || j > OneCharWide)) || SizingDelay == 0)
        {
        // transition from predock to full dock mode
            xClick = -1;
            if (SizeList == 0) return FALSE;
            gtk_event_box_set_above_child (GTK_EVENT_BOX(VSepEvtBox1), FALSE);
            gtk_event_box_set_above_child (GTK_EVENT_BOX(VSepEvtBox2), FALSE);
            gtk_event_box_set_above_child (GTK_EVENT_BOX(LVEvtBox), TRUE);
            Sizing = SizeList;      // Sizing tells which ListView is being moved
            gdk_window_set_cursor (gtk_widget_get_window(LVEvtBox), DockCurs);
        }
    }
    UpdateStatus();
    if (PO_Tdelay > 0)      // output window is delaying display of a partial line?
    {
        if (--PO_Tdelay == 0)   // on a timeout, add a lf to complete the line
            ParseIDText ("\n");
    }
    Invalidate (0);
    Invalidate (1);
    if (DViewMode != VIEW_PTREE)
        Invalidate (2);
    vgaw_refresh = TRUE;
    return TRUE;
}

// Need to keep the bochs thread and the gtk_main threads separate -- bochs thread must not
// call GTK functions -- so it needs to set flags to initiate OnBreak, and OutputText updates
static gboolean BochsUpdateTick(GtkWidget *widget)
{
    if (bx_user_quit != FALSE)      // may be in the middle of a "destroy"
        return FALSE;
    if (UpdateOWflag != FALSE)
    {
        // replace the entire Output window's text, then scroll the window to the end
        GtkTextBuffer *OBuffer;     // pull model out of the widget
        UpdateOWflag = FALSE;
        OBuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(OText));
        gtk_text_buffer_set_text(OBuffer, OutWindow, -1);
        gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(OText), EndMark, (gdouble) 0, TRUE, (gdouble) 1, (gdouble) 1);
    }
    if (HitBrkflag != FALSE)
        OnBreak();
    HitBrkflag = FALSE;
    return TRUE;
}


// called from *bochs* at a simulation break, or other ID command completion --
// so it must not call GTK functions directly, only through a shared memory flag
void HitBreak()
{
    if (AtBreak == FALSE)
    {
        AtBreak = TRUE;
        StatusChange = TRUE;
    }
    if (bx_user_quit == FALSE)      // may be in the middle of a "destroy"
        HitBrkflag = TRUE;
}

// special paint procedure for any colors on ListViews
void ListClr_PaintCb(GtkTreeViewColumn *col,
        GtkCellRenderer *renderer,
        GtkTreeModel *model,
        GtkTreeIter *iter,
        gpointer acolnum)
{
    int colnum = GPOINTER_TO_INT ( acolnum );
    gint rownum = 0;

    if (AtBreak == FALSE)
        g_object_set(renderer, "cell-background-gdk", &mgray, "cell-background-set", TRUE, NULL);
    else if (colnum <3)
    {
        // painting REG_WND -- recover the row number for this iter
        gtk_tree_model_get (model, iter, 3, &rownum, -1);
//L HIHI verify rownum in all 3 sections

        if (colnum == 0 && SelReg[rownum] != FALSE)     // is this row selected?
        {
            // if selected, foreground of column 0 = white, background = blue
            g_object_set(renderer, "foreground-gdk", &white, "foreground-set", TRUE, NULL);
            g_object_set(renderer, "cell-background-gdk", &AsmColors[3], "cell-background-set", TRUE, NULL);
            return;
        }
            // set fg (and bg if requested) according to color list
        Bit8u ClrFlgs = RegColor[ RitemToRnum[rownum] ];
        // RitemToRnum converts a ListView row number to the corresponding Register number.
        // RegColor has the 0x80 bit set if the register is supposed to be red.
        // Background color index is in the low nibble of ClrFlgs/RegColor.
        if (SeeRegColors != FALSE)
            g_object_set(renderer, "cell-background-gdk", &ColorList[ClrFlgs &7], "cell-background-set", TRUE, NULL);
        else
            g_object_set(renderer, "cell-background-gdk", &white, "cell-background-set", TRUE, NULL);

        if ((ClrFlgs & 0x80) != 0)      // should this register be red?
            g_object_set(renderer, "foreground-gdk", &fg_red, "foreground-set", TRUE, NULL);
        else
            g_object_set(renderer, "foreground-gdk", &fg_black, "foreground-set", TRUE, NULL);
    }
    else if (colnum < 6)
    {
        // painting ASM_WND -- recover the row number and "Linear Address" for this iter
        gtk_tree_model_get (model, iter, 3, &rownum, -1);
        bx_address h = (bx_address) AsmLA[rownum];

        if (colnum == 3 && SelAsm[rownum] != FALSE)     // is this row selected?
        {
            // if selected, foreground of column 0 = white, background = blue
            g_object_set(renderer, "foreground-gdk", &white, "foreground-set", TRUE, NULL);
            g_object_set(renderer, "cell-background-gdk", &AsmColors[3], "cell-background-set", TRUE, NULL);
            g_object_set(renderer, "weight", PANGO_WEIGHT_NORMAL, "weight-set", TRUE,
                "style", PANGO_STYLE_NORMAL, "style-set", TRUE, NULL);
            return;
        }
        // clear out any gray background
        g_object_set(renderer, "cell-background-gdk", &white, "cell-background-set", TRUE, NULL);
        // use an ellipsis ... on the bytes column
        if (colnum == 4)
            g_object_set(renderer, "ellipsize", PANGO_ELLIPSIZE_END, "ellipsize-set", TRUE, NULL);
        else
            g_object_set(renderer, "ellipsize", PANGO_ELLIPSIZE_NONE, "ellipsize-set", TRUE, NULL);
        int AsmClrNum = 0;          // assume black text
        if (h == CurrentAsmLA)
            AsmClrNum = 1;          // current opcode is colored dark green
        int j= BreakCount;
        while (--j >= 0)            // loop over all breakpoints
        {
            // brk list is sorted -- if the value goes too low, end the loop
            if (BrkLAddr[j] < h)
                j = 0;      // force the loop to end if it goes too far
            else if (BrkLAddr[j] == h)
            {
                j= 0;
                if (h == CurrentAsmLA)
                    AsmClrNum = 3;  // breakpoint @ current opcode = blue
                else
                    AsmClrNum = 2;  // active breakpoint is red
            }
        }
        g_object_set(renderer, "foreground-gdk", &AsmColors[AsmClrNum], "foreground-set", TRUE, NULL);
        // extra visuals for current RIP and breakpoints -- use bold and italic on mnemonics
        if (colnum == 5 && AsmClrNum != 0)
        {
            if ((AsmClrNum&1) != 0)     // current RIP
                g_object_set(renderer, "weight", PANGO_WEIGHT_BOLD, "weight-set", TRUE, NULL);
            if ((AsmClrNum&2) != 0)     // breakpoint
                g_object_set(renderer, "style", PANGO_STYLE_ITALIC, "style-set", TRUE, NULL);
        }
        else
        {
            g_object_set(renderer, "weight", PANGO_WEIGHT_NORMAL, "weight-set", TRUE,
                "style", PANGO_STYLE_NORMAL, "style-set", TRUE, NULL);
        }
    }
    else
    {
        // painting some kind of dump window -- stack and physdump are special
        // clear out any gray background
        gtk_tree_model_get (model, iter, 18, &rownum, -1);
        g_object_set(renderer, "cell-background-gdk", &white, "cell-background-set", TRUE, NULL);
        if (DViewMode == VIEW_STACK)
        {
            // highlight changed lines in stack
            if (rownum < 0 || rownum >= STACK_ENTRIES)  // make sure the line # is legal
                ;
            else if (StackEntChg[rownum] != FALSE)
                g_object_set(renderer, "foreground-gdk", &fg_red, "foreground-set", TRUE, NULL);
            else
                g_object_set(renderer, "foreground-gdk", &fg_black, "foreground-set", TRUE, NULL);
            return;
        }

        // is this row selected (only applies to Memdump windows)?
        if (colnum == 6 && SelMem[rownum] != FALSE && DViewMode == VIEW_MEMDUMP)
        {
            // if selected, foreground of column 0 = white, background = blue
            g_object_set(renderer, "foreground-gdk", &white, "foreground-set", TRUE, NULL);
            g_object_set(renderer, "cell-background-gdk", &AsmColors[3], "cell-background-set", TRUE, NULL);
            return;
        }
        // the only other special painting is for Phys Dump columns, with byte DumpAlign (watchpoints)
        int DmpClrNum = 0;          // assume black text
        if (colnum > 6 && DumpAlign == 1 && LinearDump == FALSE && DViewMode == VIEW_MEMDUMP)
        {
            // For each cell, calculate its equivalent physmem address
            // byte offset = 0 means colnum = 7
            bx_phy_address h = (bx_phy_address) DumpStart + 16*rownum + colnum - 7;
            int j = num_write_watchpoints;
            int i = num_read_watchpoints;
            while (j > 0)
            {
                if (write_watchpoint[--j].addr == h)
                {
                    DmpClrNum = 1;  // write watchpoint
                    j = -1;         // on a match j<0 -- else j == 0
                }
            }
            while (--i >= 0)
            {
                if (read_watchpoint[i].addr == h)
                {
                    if (j < 0)         // BOTH read and write
                        DmpClrNum = 2;
                    else
                        DmpClrNum = 3; // read watchpoint
                    i = 0;             // end the loop on a match
                }
            }
        }
        g_object_set(renderer, "foreground-gdk", &PDumpClr[DmpClrNum], "foreground-set", TRUE, NULL);
        if (DmpClrNum != 0)
            g_object_set(renderer, "cell-background-gdk", &fg_black, "cell-background-set", TRUE, NULL);
    }
}

// build the columns for each of the three main lists
void MakeList(int listnum, const char *ColNameArray[])
{
    int i;
    int nColumns = 3;
    char txt[4];
    GtkListStore *Database;     // "model" that contains the actual data
    GtkCellRenderer *renderer;  // column/cell drawing object
    GtkTreeViewColumn *column;  // column object
    GtkTreeSelection *sel;      // need the tree's selection object

    sel = gtk_tree_view_get_selection (GTK_TREE_VIEW( LV[listnum]) );
    gtk_tree_selection_set_mode (sel, GTK_SELECTION_NONE);

    // format for next funct is ( # of columns, datatype, ... ); -- really stupid argument arrangement!
    if (listnum != DUMP_WND)
        Database = gtk_list_store_new (4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
    else        // 18 columns
    {
        nColumns = 18;
        Database = gtk_list_store_new (19, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
            G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
            G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
            G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
    }

    char *cp = (char*)ColNameArray[0];
    *txt = '0' -1;
    txt[1] = 0;
    // allocate one renderer for each ListView
    renderer = gtk_cell_renderer_text_new();
    LV_Rend[listnum]= renderer;
    for (i=0 ; i < nColumns ; i++)
    {
        // when nColumns == 18, there are only two entries in ColNameArray
        if (nColumns == 3)
            cp = (char*)ColNameArray[i];
        column = gtk_tree_view_column_new_with_attributes(cp,
            renderer, "text", i, NULL);
        gtk_tree_view_append_column(GTK_TREE_VIEW(LV[listnum]), column);
        gtk_tree_view_column_set_cell_data_func(column, renderer, ListClr_PaintCb, (gpointer) (glong) ((listnum*3) + i), NULL);

    // Note: column and renderer are not technically "GTK Objects", so don't unref them
        cp = txt;
        ++*cp;      // cheap way to create "0" through "9" and "A" through "F"
        if (i == 10) *cp = 'A';
        else if (i == 16) cp = (char*)ColNameArray[1];
    // must store copies of all the columns, to change column titles and other "properties" later
        AllCols[(listnum*3) + i] = column;
    }

    gtk_tree_view_set_model(GTK_TREE_VIEW(LV[listnum]), GTK_TREE_MODEL(Database));
    // ListView now holds a reference to Database -- don't need the local reference anymore
    g_object_unref(G_OBJECT (Database));
}

// gtk version of multithreading (doesn't seem to work on some platforms?):
/*
// this function must be called as a new multithread, from the initialization code
// -- it runs the main gtk "event loop", which spawns all the "events",
// "repaint"s, and callbacks -- and never returns, except on a "quit"
gpointer EventLp(gpointer data)
{
    gtk_main();
    g_thread_exit(0);
    return (gpointer) NULL;
}

void MakeGTKthreads()
{
    // do gtk multithreading initialization FIRST -- before ANYTHING ELSE
    GError *error = NULL;
#ifndef G_THREADS_ENABLED
    printf ("init err1: thread support not enabled in glib\n");
    return FALSE;
#endif
#ifndef G_THREADS_IMPL_POSIX
    printf ("init err2: pthread package not found\n");
    return FALSE;
#endif
    if (g_thread_supported() == FALSE)
    {
        printf ("init err3: pthreads/multithreading is not running? No multithread support.\n");
        return FALSE;
    }
    g_thread_init(NULL);
    g_thread_create (EventLp, (gpointer) NULL, FALSE, &error);
}
*/

// multithreading using pure posix threads -- not glib threads
void * EventLp(void *data)
{
    gtk_main();
//  pthread_exit(0);
    return NULL;
}

void MakeGTKthreads()
{
    pthread_t hThread;
//  g_thread_init(NULL);    // if I put this in, it gives me an "undefined reference" of all crazy things!
    pthread_create (&hThread, NULL, EventLp, NULL);
}

// This function must be called immediately after bochs starts
bx_bool OSInit()
{
    int i, argc;
    char *argv[2], **argvp;
    const char* LColNames[] = {
        "Reg Name","Hex Value","Decimal","L.Address","Bytes","Mnemonic","Address","Ascii"
    };
    GtkTextBuffer *Tbuffer;
    GtkTextIter Titer;
    GtkWidget *tmpLbl;
    *bigbuf = 0;            // gtk flames out if you pass in a NULL -- sheesh
    argv[0] = bigbuf;   // so I really do have to fake up an "argv" list
    argv[1] = NULL;
    argvp = argv;
    argc = 1;

    CurXSize = 0;
    if (!SIM->is_wx_selected()) {
      // you MUST call gtk_init, even with faked arguments, because it inits GDK and Glib
      if (gtk_init_check(&argc, &argvp) == FALSE) {
        fprintf(stderr, "gtk init failed, can not access display?\n");
        return FALSE;
      }
    }
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(window), "Bochs Enhanced Debugger");
    gtk_window_set_default_size(GTK_WINDOW(window), 500, 500);
    if (!window_init || ((win_x < 0) && (win_y < 0))) {
      gtk_window_maximize(GTK_WINDOW(window));
    } else {
      gtk_window_resize(GTK_WINDOW(window), win_w, win_h);
      gtk_window_move(GTK_WINDOW(window), win_x, win_y);
    }

    MainVbox = gtk_vbox_new(FALSE, 0);      // vbox that contains EVERYTHING

    gtk_container_add(GTK_CONTAINER(window), MainVbox);

    // make/init the menu "containers" (shells) and menu items
    InitMenus();

    // build the StatusBar
    StatHbox = gtk_hbox_new(FALSE, 3);
    Stat[0] = gtk_label_new("Break");
    gtk_label_set_width_chars (GTK_LABEL(Stat[0]), 7);
    Stat[1] = gtk_label_new("CPU:");
    gtk_label_set_width_chars (GTK_LABEL(Stat[1]), 23);
    Stat[2] = gtk_label_new("t=0");
    gtk_label_set_width_chars (GTK_LABEL(Stat[2]), 19);
    Stat[3] = gtk_label_new("IOPL");
    StatVSep1 = gtk_vseparator_new();
    StatVSep2 = gtk_vseparator_new();
    StatVSep3 = gtk_vseparator_new();
    gtk_box_pack_start(GTK_BOX(StatHbox), Stat[0], FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(StatHbox), StatVSep1, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(StatHbox), Stat[1], FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(StatHbox), StatVSep2, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(StatHbox), Stat[2], FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(StatHbox), StatVSep3, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(StatHbox), Stat[3], TRUE, TRUE, 0);
    // set LEFT, instead of the default centered "justification" of status text
    gtk_misc_set_alignment(GTK_MISC(Stat[0]), (gfloat) 0., (gfloat) 0.5);
    gtk_misc_set_alignment(GTK_MISC(Stat[1]), (gfloat) 0., (gfloat) 0.5);
    gtk_misc_set_alignment(GTK_MISC(Stat[2]), (gfloat) 0., (gfloat) 0.5);
    gtk_misc_set_alignment(GTK_MISC(Stat[3]), (gfloat) 0., (gfloat) 0.5);

    gtk_box_pack_start(GTK_BOX(MainVbox), menubar, FALSE, FALSE, 0);
    gtk_box_pack_end(GTK_BOX(MainVbox), StatHbox, FALSE, FALSE, 0);

    // build the table that holds the TreeView/Input&Output windows
    TreeTbl = gtk_table_new(4, 1, TRUE);    // proportion the remaining space in quarters, vertically
    sep8 = gtk_vseparator_new();            // vertical separators between the ListViews
    sep9 = gtk_vseparator_new();
    VSepEvtBox1 = gtk_event_box_new();      // seps need event boxes to catch "Enter" events
    VSepEvtBox2 = gtk_event_box_new();
    gtk_container_add (GTK_CONTAINER(VSepEvtBox1), sep8);
    gtk_container_add (GTK_CONTAINER(VSepEvtBox2), sep9);
    gtk_widget_add_events(VSepEvtBox1, GDK_ENTER_NOTIFY_MASK);      // masks must be set immediately after creation
    gtk_widget_add_events(VSepEvtBox2, GDK_ENTER_NOTIFY_MASK);
    IOVbox = gtk_vbox_new(FALSE, 0);        // stack the Input Entry and Output TextView vertically

    // create Input window
    IEntry = gtk_entry_new();
    gtk_entry_set_max_length (GTK_ENTRY(IEntry), 190);

    // create Output window
    ScrlWinOut = gtk_scrolled_window_new( NULL, NULL );
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ScrlWinOut), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
    OText = gtk_text_view_new();
    gtk_text_view_set_editable(GTK_TEXT_VIEW(OText), FALSE);    // set it to "read only"
    gtk_widget_set_can_focus(OText, FALSE);
    gtk_container_add (GTK_CONTAINER(ScrlWinOut), OText);
// a TextView *already has* a viewport, so DON'T add another one -- or it won't scroll properly!
//  gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(ScrlWinOut), OText);
    gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(OText), GTK_WRAP_WORD);
    // create a textmark that always points to the very end of OText
    Tbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(OText));
    gtk_text_buffer_get_iter_at_offset (Tbuffer, &Titer, 0);
    EndMark = gtk_text_buffer_create_mark (Tbuffer, NULL, &Titer, FALSE);

    gtk_box_pack_start(GTK_BOX(IOVbox), ScrlWinOut, TRUE, TRUE, 0);
    gtk_box_pack_end(GTK_BOX(IOVbox), IEntry, FALSE, FALSE, 0);
    LVHbox = gtk_hbox_new(FALSE, 0);        // to hold the ListView windows
    LVEvtBox = gtk_event_box_new();     // need to catch "leave" and "move" events for ListViews
    gtk_container_add (GTK_CONTAINER(LVEvtBox), LVHbox);
    gtk_widget_add_events(LVEvtBox, GDK_LEAVE_NOTIFY_MASK | GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK);

    // make Command and CPU Button rows
    CmdBHbox = gtk_hbox_new(TRUE, 0);

    for (i=0 ; i < 5 ; i++)
    {
        CmdBtn[i] = gtk_button_new();
        tmpLbl = gtk_label_new ("");
        sprintf (bigbuf, "<b>%s</b>",BTxt[i]);      // create "bold" pango markup for buttons
        gtk_label_set_markup (GTK_LABEL(tmpLbl), bigbuf);
        gtk_container_add (GTK_CONTAINER(GTK_BUTTON(CmdBtn[i])), tmpLbl);
        gtk_widget_set_can_focus(CmdBtn[i], FALSE);
        gtk_box_pack_start(GTK_BOX(CmdBHbox), CmdBtn[i], TRUE, TRUE, 0);
    }
    gtk_box_pack_start(GTK_BOX(MainVbox), CmdBHbox, FALSE, FALSE, 0);
    // CPU button row does not exist for only 1 cpu
    if (BX_SMP_PROCESSORS > 1)
    {
        CpuBHbox = gtk_hbox_new(TRUE, 0);
        gtk_box_pack_start(GTK_BOX(MainVbox), CpuBHbox, FALSE, FALSE, 0);
        i = 0;
        strcpy (bigbuf, "<b>CPU0</b>");     // Handle CPU0 specially -- it is "selected"
        while (i < BX_SMP_PROCESSORS)
        {
            CpuBtn[i] = gtk_button_new();
            tmpLbl = gtk_label_new ("");
            CpuB_label[i] = tmpLbl;
            gtk_label_set_markup (GTK_LABEL(tmpLbl), bigbuf);
            gtk_container_add (GTK_CONTAINER(GTK_BUTTON(CpuBtn[i])), tmpLbl);
            gtk_widget_set_can_focus(CpuBtn[i], FALSE);
            gtk_box_pack_start(GTK_BOX(CpuBHbox), CpuBtn[i], TRUE, TRUE, 0);
            sprintf (bigbuf, "<b>cpu%d</b>",++i);       // create the next CPU button label
        }
    }

    gtk_box_pack_end(GTK_BOX(MainVbox), TreeTbl, TRUE, TRUE, 0);

    gtk_table_attach_defaults(GTK_TABLE(TreeTbl), LVEvtBox, 0, 1, 0, 3);  // order = LRTB
    gtk_table_attach_defaults(GTK_TABLE(TreeTbl), IOVbox, 0, 1, 3, 4);
    VSizeChange();

    // build the 3 ListView windows
    i = 3;
    while (--i >= 0)
    {
        ScrlWin[i] = gtk_scrolled_window_new( NULL, NULL );
        // always want a horizontal scrollbar, to divide lists from Output window visually
        gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ScrlWin[i]), GTK_POLICY_ALWAYS, GTK_POLICY_AUTOMATIC);
        LV[i] = gtk_tree_view_new();
        gtk_widget_set_can_focus(LV[i], FALSE);
        gtk_container_add (GTK_CONTAINER(ScrlWin[i]), LV[i]);
// all TreeViews *already have* a viewport, so DON'T add another one with the ScrollWindow, or it won't scroll properly!
        MakeList(i, &LColNames[i*3]);
    }
    CurCenterList = ((DockOrder>>4)& 3) -1;     // index of center list
    RepackLists((DockOrder >> 8) -1);           // index of left list

    // make the param_tree widget
    GtkTreeViewColumn *treecol;
    GtkCellRenderer *renderer;
    GtkTreeStore *treestore;
    PTree = gtk_tree_view_new();
    treecol = gtk_tree_view_column_new();
    gtk_tree_view_column_set_title(treecol, "bochs parameter tree");
    gtk_tree_view_append_column(GTK_TREE_VIEW(PTree), treecol);
    renderer = gtk_cell_renderer_text_new();
    gtk_tree_view_column_pack_start(treecol, renderer, TRUE);
    gtk_tree_view_column_add_attribute(treecol, renderer, "text", 0);   // pull display text from treestore col 0
    gtk_widget_set_can_focus(PTree, FALSE);
    treestore = gtk_tree_store_new(1, G_TYPE_STRING);
    gtk_tree_view_set_model(GTK_TREE_VIEW(PTree), GTK_TREE_MODEL(treestore));
    g_object_unref(treestore);      // PTree now references treestore itself

    g_object_ref(PTree);     // keep an extra ref to both ScrlWin[2] widgets,
    g_object_ref(LV[2]);     // so they don't get deleted when removed from their container
    g_object_ref_sink(G_OBJECT(PTree));   // the PTree reference is "floating", so "sink" it

    AttachSignals();        // this must be called AFTER InitMenus()
    TakeInputFocus();
    gtk_widget_show_all(window);

    // In order to catch Enter/Leave events, you need a widget with a Gdk Window. Neither hboxes or VSeps have them,
    // so it is necessary to add event boxes. The windows should be invisible, and when I want them to WORK, they
    // must be ON TOP of the child widgets. LVEvtBox is only needed in resize/dock mode.
    gtk_event_box_set_visible_window (GTK_EVENT_BOX(LVEvtBox), FALSE);
    gtk_event_box_set_above_child (GTK_EVENT_BOX(LVEvtBox), FALSE);
    gtk_event_box_set_visible_window (GTK_EVENT_BOX(VSepEvtBox1), FALSE);
    gtk_event_box_set_above_child (GTK_EVENT_BOX(VSepEvtBox1), TRUE);
    gtk_event_box_set_visible_window (GTK_EVENT_BOX(VSepEvtBox2), FALSE);
    gtk_event_box_set_above_child (GTK_EVENT_BOX(VSepEvtBox2), TRUE);
    // build the sizing/docking cursors
    SizeCurs = gdk_cursor_new (GDK_SB_H_DOUBLE_ARROW);
    DockCurs = gdk_cursor_new (GDK_CROSSHAIR);
    gdk_cursor_ref(SizeCurs);
    gdk_cursor_ref(DockCurs);

    if (!font_init) {
      char *fn;
      g_object_get(G_OBJECT(LV_Rend[0]), "font", &fn, NULL);
      strncpy(fontname, fn, 80);
    } else {
      update_font();
    }

    // the OneCharWide pixel value is used to limit docking and resizing movements
    int width;
    PangoLayout * layout = gtk_widget_create_pango_layout (LV[0], "M");
    PangoFontDescription * fontdesc;
    g_object_get( G_OBJECT( LV_Rend[0] ), "font-desc", &fontdesc, NULL ); 
    pango_layout_set_font_description (layout, fontdesc); 
    pango_layout_get_pixel_size (layout, &width, &i);
    pango_font_description_free (fontdesc);
    g_object_unref(layout);
    OneCharWide = width;        // The "width" I'm getting is about half what I expect
//  OneCharWide = width >> 1;   // pretend that an average char width is half an "M"
    if (OneCharWide > 12) OneCharWide = 12;

//  UpdInProgress[REG_WND] = FALSE;
//  UpdInProgress[ASM_WND] = FALSE;
//  UpdInProgress[DUMP_WND] = FALSE;
    ResizeColmns = TRUE;    // force an initial resize on hex, address columns

    g_timeout_add(500, (GSourceFunc) VGAWrefreshTick, (gpointer) window);
    g_timeout_add(50, (GSourceFunc) BochsUpdateTick, (gpointer) window);

    g_signal_connect (G_OBJECT (window), "configure_event", G_CALLBACK (TblSizeEvent), NULL);
    width = gtk_tree_view_column_get_width(AllCols[4]);
    gtk_tree_view_column_set_fixed_width(AllCols[4], width);
    gtk_tree_view_column_set_sizing(AllCols[4], GTK_TREE_VIEW_COLUMN_FIXED);

    if (!SIM->is_wx_selected()) {
      MakeGTKthreads();
    }
    return TRUE;
}

void CloseDialog()
{
  if (window != NULL) {
    gtk_widget_destroy(window);
  }
}

// recurse displaying each leaf/branch of param_tree -- with values for each leaf
void MakeBL(TreeParent *h_P, bx_param_c *p)
{
    TreeParent h_new;
    bx_list_c *as_list = NULL;
    int n = 0;
    char tmpstr[BX_PATHNAME_LEN];
    strcpy(tmpcb, p->get_name());
    int j = strlen (tmpcb);
    switch (p->get_type())
    {
        case BXT_LIST:
            as_list = (bx_list_c *)p;
            n = as_list->get_size();
            break;
            sprintf (tmpcb + j,": %s",((bx_param_bool_c*)p)->get()?"true":"false");
            break;
            sprintf (tmpcb + j,": %s",((bx_param_enum_c*)p)->get_selected());
            break;
        case BXT_PARAM_BOOL:
        case BXT_PARAM_ENUM:
        case BXT_PARAM_NUM:
        case BXT_PARAM_STRING:
        case BXT_PARAM_BYTESTRING:
            p->dump_param(tmpstr, BX_PATHNAME_LEN);
            sprintf(tmpcb + j,": %s", tmpstr);
            break;
        case BXT_PARAM_DATA:
            sprintf (tmpcb + j,": binary data, size=%d",((bx_shadow_data_c*)p)->get_size());
            break;
    }
    MakeTreeChild (h_P, n, &h_new);
    if (n > 0)
    {
        for (int i=0; i<n; i++)
            MakeBL(&h_new, as_list->get(i));    // recurse for all children that are lists
    }
}

bx_bool ParseOSSettings(const char *param, const char *value)
{
  char *val2, *ptr;

  if (!strcmp(param, "FontName")) {
    strncpy(fontname, value, 80);
    font_init = 1;
    return 1;
  } else if (!strcmp(param, "MainWindow")) {
    val2 = strdup(value);
    ptr = strtok(val2, ",");
    win_x = atoi(ptr);
    ptr = strtok(NULL, ",");
    win_y = atoi(ptr);
    ptr = strtok(NULL, ",");
    win_w = atoi(ptr);
    ptr = strtok(NULL, "\n");
    win_h = atoi(ptr);
    window_init = 1;
    free(val2);
    return 1;
  }
  return 0;
}

void WriteOSSettings(FILE *fd)
{
  if (window != NULL) {
    gtk_window_get_position(GTK_WINDOW(window), &win_x, &win_y);
    gtk_window_get_size(GTK_WINDOW(window), &win_w, &win_h);
  }
  fprintf(fd, "MainWindow = %d, %d, %d, %d\n", win_x, win_y, win_w, win_h);
  fprintf(fd, "FontName = %s\n", fontname);
}

#endif
