From c5dda859f2f5d8fe62369cf050390de05275ce1f Mon Sep 17 00:00:00 2001 From: Leeland Heins Date: Mon, 13 Mar 2017 23:04:47 -0500 Subject: [PATCH] Add files via upload --- Makefile | 29 + calvados.c | 629 ++++++++++++++++++++++ calvados.h | 27 + close_dialog.c | 19 + closing_dialog.c | 16 + create_disk_image.c | 327 ++++++++++++ disk_sector_viewer_popup.c | 124 +++++ do_open_file.c | 18 + help_func_create_disk_image.c | 26 + help_func_select_volume.c | 26 + images/addDiskImageTb.png | Bin 0 -> 274 bytes images/addFilesTb.png | Bin 0 -> 263 bytes images/calvados.png | Bin 0 -> 27151 bytes images/createDiskImageTb.png | Bin 0 -> 246 bytes images/deleteTb.png | Bin 0 -> 224 bytes images/diskImageConverterTb.png | Bin 0 -> 297 bytes images/diskSectorViewerTb.png | Bin 0 -> 230 bytes images/editCommentTb.png | Bin 0 -> 272 bytes images/extractTb.png | Bin 0 -> 308 bytes images/mergeSSTImagesTb.png | Bin 0 -> 282 bytes images/newArchiveTb.png | Bin 0 -> 215 bytes images/openTb.png | Bin 0 -> 300 bytes images/openVolumeTb.png | Bin 0 -> 302 bytes images/printTb.png | Bin 0 -> 290 bytes images/recompressTb.png | Bin 0 -> 263 bytes images/renameTb.png | Bin 0 -> 284 bytes images/testTb.png | Bin 0 -> 282 bytes images/viewTb.png | Bin 0 -> 242 bytes images/volumeCopierTb.png | Bin 0 -> 296 bytes new_archive.c | 39 ++ okfunc_create_disk_image.c | 23 + okfunc_select_volume.c | 23 + open_file.c | 38 ++ preferences.c | 901 ++++++++++++++++++++++++++++++++ save_to_file.c | 17 + select_volume.c | 204 ++++++++ show_about.c | 28 + 37 files changed, 2514 insertions(+) create mode 100644 Makefile create mode 100644 calvados.c create mode 100644 calvados.h create mode 100644 close_dialog.c create mode 100644 closing_dialog.c create mode 100644 create_disk_image.c create mode 100644 disk_sector_viewer_popup.c create mode 100644 do_open_file.c create mode 100644 help_func_create_disk_image.c create mode 100644 help_func_select_volume.c create mode 100644 images/addDiskImageTb.png create mode 100644 images/addFilesTb.png create mode 100644 images/calvados.png create mode 100644 images/createDiskImageTb.png create mode 100644 images/deleteTb.png create mode 100644 images/diskImageConverterTb.png create mode 100644 images/diskSectorViewerTb.png create mode 100644 images/editCommentTb.png create mode 100644 images/extractTb.png create mode 100644 images/mergeSSTImagesTb.png create mode 100644 images/newArchiveTb.png create mode 100644 images/openTb.png create mode 100644 images/openVolumeTb.png create mode 100644 images/printTb.png create mode 100644 images/recompressTb.png create mode 100644 images/renameTb.png create mode 100644 images/testTb.png create mode 100644 images/viewTb.png create mode 100644 images/volumeCopierTb.png create mode 100644 new_archive.c create mode 100644 okfunc_create_disk_image.c create mode 100644 okfunc_select_volume.c create mode 100644 open_file.c create mode 100644 preferences.c create mode 100644 save_to_file.c create mode 100644 select_volume.c create mode 100644 show_about.c diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..582085f --- /dev/null +++ b/Makefile @@ -0,0 +1,29 @@ +# +# Makefile for cavaldos. Prety lame, needs to be improved. +# +NAME=calvados +CFLAGS=-g -Wall -o $(NAME) +GTKFLAGS=-export-dynamic `pkg-config --cflags --libs gtk+-2.0` +SRCS=calvados.c select_volume.c closing_dialog.c close_dialog.c show_about.c \ + disk_sector_viewer_popup.c create_disk_image.c new_archive.c \ + open_file.c okfunc_create_disk_image.c okfunc_select_volume.c \ + help_func_create_disk_image.c help_func_select_volume.c \ + do_open_file.c save_to_file.c preferences.c +HEADERS=calvados.h +CC=gcc +DESTDIR=/usr/local + +INCLUDE=-I/usr/include/glib-2.0/ -I/usr/lib/x86_64-linux-gnu/glib-2.0/include/ -I/usr/include/pango-1.0/ -I/usr/include/cairo/ -I/usr/include/gdk-pixbuf-2.0/ -I/usr/include/atk-1.0/ + +all: calvados + +calvados: $(SRCS) $(HEADERS) + $(CC) $(CFLAGS) $(SRCS) $(GTKFLAGS) + +install: + /usr/bin/install $(NAME) $(DESTDIR)/bin + /usr/bin/install -D images $(DESTDIR)/images + +clean: + /bin/rm -f $(NAME) + diff --git a/calvados.c b/calvados.c new file mode 100644 index 0000000..78cba49 --- /dev/null +++ b/calvados.c @@ -0,0 +1,629 @@ +/* + * + * cavaldos.c + * + * Designed to be a workalike of CiderPress. + * + * 20170310 Leeland Heins + * + */ +#include +#include + +#include "calvados.h" + +int main(int argc, char *argv[]) +{ + /* Our root window */ + GtkWidget *window; + + GtkWidget *vbox; + + GtkWidget *menubar; + + /* File menu widgets */ + GtkWidget *fileMenu; + GtkWidget *newMenu; + GtkWidget *diskImageMi; + GtkWidget *shrinkItArchiveMi; + GtkWidget *fileMi; + GtkWidget *newMi; + GtkWidget *openMi; + GtkWidget *openVolumeMi; + GtkWidget *reopenMi; + GtkWidget *saveChangesMi; + GtkWidget *closeMi; + GtkWidget *fileSep1; + GtkWidget *archiveInfoMi; + GtkWidget *printMi; + GtkWidget *fileSep2; + GtkWidget *quitMi; + + /* Edit menu widgets */ + GtkWidget *editMenu; + GtkWidget *editMi; + GtkWidget *copyMi; + GtkWidget *pasteMi; + GtkWidget *pasteSpecialMi; + GtkWidget *editSep1; + GtkWidget *findMi; + GtkWidget *editSep2; + GtkWidget *sortMenu; + GtkWidget *sortMi; + GtkWidget *byOriginalOrderMi; + GtkWidget *byPathnameMi; + GtkWidget *byFileTypeMi; + GtkWidget *byAuxtypeMi; + GtkWidget *byModificationDateMi; + GtkWidget *byFormatMi; + GtkWidget *bySizeMi; + GtkWidget *byRatioMi; + GtkWidget *byPackedSizeMi; + GtkWidget *byAccessMi; + GtkWidget *selectAllMi; + GtkWidget *invertSelectionMi; + GtkWidget *preferencesMi; + + /* Action menu widgets */ + GtkWidget *actionMenu; + GtkWidget *actionsMi; + GtkWidget *viewMi; + GtkWidget *extractMi; + GtkWidget *testMi; + GtkWidget *renameMi; + GtkWidget *deleteMi; + GtkWidget *recompressMi; + GtkWidget *actionSep1; + GtkWidget *addFilesMi; + GtkWidget *addDiskImageMi; + GtkWidget *createSubdirectoryMi; + GtkWidget *actionSep2; + GtkWidget *openAsDiskImageMi; + GtkWidget *editCommentMi; + GtkWidget *editAttributesMi; + GtkWidget *renameVolumeMi; + GtkWidget *actionSep3; + GtkWidget *convertToDiskImageMi; + GtkWidget *convertToArchiveFileMi; + GtkWidget *importFileFromWAVMi; + GtkWidget *importBASFromTextMi; + + /* Tools menu widgets */ + GtkWidget *toolsMenu; + GtkWidget *toolsMi; + GtkWidget *diskSectorViewerMi; + GtkWidget *diskImageConverterMi; + GtkWidget *bulkDiskImageConverterMi; + GtkWidget *toolsSep1; + GtkWidget *volumeCopierOpenVolumeMi; + GtkWidget *volumeCopierOpenFileMi; + GtkWidget *mergeSSTImagesMi; + GtkWidget *toolsSep2; + GtkWidget *TwoMGPropertiesEditorMi; + GtkWidget *EOLScannerMi; + + /* Help menu widgets */ + GtkWidget *helpMenu; + GtkWidget *helpMi; + GtkWidget *contentsMi; + GtkWidget *visitCalvadosWebsiteMi; + GtkWidget *helpSep1; + GtkWidget *aboutCalvadosMi; + + /* For keyboard accellerators */ + GtkAccelGroup *accel_group = NULL; + + /* For sort submenu */ + GSList *sort_radio_group = NULL; + + /* Tool bar widgets */ + GtkWidget *toolbar; + /*GtkToolItem *newTb;*/ + GtkWidget *openTbImage; + GtkToolItem *openTb; + GtkWidget *openVolumeTbImage; + GtkToolItem *openVolumeTb; + GtkWidget *newArchiveTbImage; + GtkToolItem *newArchiveTb; + /*GtkToolItem *saveTb;*/ + GtkWidget *createDiskImageTbImage; + GtkToolItem *createDiskImageTb; + GtkWidget *printTbImage; + GtkToolItem *printTb; + GtkToolItem *tbSep1; + GtkWidget *addFilesTbImage; + GtkToolItem *addFilesTb; + GtkWidget *addDiskImageTbImage; + GtkToolItem *addDiskImageTb; + GtkWidget *viewTbImage; + GtkToolItem *viewTb; + GtkWidget *extractTbImage; + GtkToolItem *extractTb; + GtkWidget *testTbImage; + GtkToolItem *testTb; + GtkWidget *renameTbImage; + GtkToolItem *renameTb; + GtkWidget *deleteTbImage; + GtkToolItem *deleteTb; + GtkWidget *recompressTbImage; + GtkToolItem *recompressTb; + GtkWidget *editCommentTbImage; + GtkToolItem *editCommentTb; + GtkToolItem *tbSep2; + GtkWidget *diskSectorViewerTbImage; + GtkToolItem *diskSectorViewerTb; + GtkWidget *diskImageConverterTbImage; + GtkToolItem *diskImageConverterTb; + GtkWidget *volumeCopierTbImage; + GtkToolItem *volumeCopierTb; + GtkWidget *mergeSSTImagesTbImage; + GtkToolItem *mergeSSTImagesTb; + GtkToolItem *tbSep3; + GtkToolItem *exitTb; + + GtkWidget *statusbar; + + /* Initialise GTK+ passing to it all command line arguments */ + gtk_init(&argc, &argv); + + /* create a new window, set values */ + window = gtk_window_new(GTK_WINDOW_TOPLEVEL); + gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); + gtk_window_set_default_size(GTK_WINDOW(window), WINDOW_WIDTH, WINDOW_HEIGHT); + gtk_window_set_title(GTK_WINDOW(window), "Calvados"); + + /* Primary app vbox */ + vbox = gtk_vbox_new(FALSE, 0); + gtk_container_add(GTK_CONTAINER(window), vbox); + + /* Primary app menu bar */ + menubar = gtk_menu_bar_new(); + /* File menu */ + fileMenu = gtk_menu_new(); + /* Edit menu */ + editMenu = gtk_menu_new(); + /* Action menu */ + actionMenu = gtk_menu_new(); + /* Tools menu */ + toolsMenu = gtk_menu_new(); + /* Help menu */ + helpMenu = gtk_menu_new(); + + /* For keyboard accellerators */ + accel_group = gtk_accel_group_new(); + gtk_window_add_accel_group(GTK_WINDOW(window), accel_group); + + /* File menu bar items */ + fileMi = gtk_menu_item_new_with_mnemonic("_File"); + + newMenu = gtk_menu_new(); + newMi = gtk_image_menu_item_new_from_stock(GTK_STOCK_NEW, accel_group); + diskImageMi = gtk_menu_item_new_with_label("Disk image"); + shrinkItArchiveMi = gtk_menu_item_new_with_label("ShrinkIt Archive"); + + /* 'New' submenu */ + gtk_menu_item_set_submenu(GTK_MENU_ITEM(newMi), newMenu); + gtk_menu_shell_append(GTK_MENU_SHELL(newMenu), diskImageMi); + gtk_menu_shell_append(GTK_MENU_SHELL(newMenu), shrinkItArchiveMi); + + gtk_widget_add_accelerator(shrinkItArchiveMi, "activate", accel_group, GDK_n, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + openMi = gtk_image_menu_item_new_from_stock(GTK_STOCK_OPEN, accel_group); + + openVolumeMi = gtk_menu_item_new_with_mnemonic("_Open volume..."); + + gtk_widget_add_accelerator(openVolumeMi, "activate", accel_group, GDK_o, GDK_CONTROL_MASK|GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE); + + reopenMi = gtk_menu_item_new_with_mnemonic("_Reopen"); + + gtk_widget_add_accelerator(reopenMi, "activate", accel_group, GDK_r, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + saveChangesMi = gtk_menu_item_new_with_mnemonic("_Save changes"); + + gtk_widget_add_accelerator(saveChangesMi, "activate", accel_group, GDK_s, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + closeMi = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_group); + + fileSep1 = gtk_separator_menu_item_new(); + + archiveInfoMi = gtk_menu_item_new_with_mnemonic("Archive _Info"); + + gtk_widget_add_accelerator(archiveInfoMi, "activate", accel_group, GDK_i, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + printMi = gtk_image_menu_item_new_from_stock(GTK_STOCK_PRINT, accel_group); + + gtk_widget_add_accelerator(printMi, "activate", accel_group, GDK_p, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + fileSep2 = gtk_separator_menu_item_new(); + + quitMi = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, accel_group); + + gtk_widget_add_accelerator(quitMi, "activate", accel_group, GDK_q, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + /* Set up file menu */ + gtk_menu_item_set_submenu(GTK_MENU_ITEM(fileMi), fileMenu); + gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), newMi); + gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), openMi); + gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), openVolumeMi); + gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), reopenMi); + gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), saveChangesMi); + gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), closeMi); + gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), fileSep1); + gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), archiveInfoMi); + gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), printMi); + gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), fileSep2); + gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), quitMi); + /* Add file menu to menu bar */ + gtk_menu_shell_append(GTK_MENU_SHELL(menubar), fileMi); + + /* Edit menu bar items */ + editMi = gtk_menu_item_new_with_mnemonic("_Edit"); + copyMi = gtk_image_menu_item_new_from_stock(GTK_STOCK_COPY, accel_group); + pasteMi = gtk_image_menu_item_new_from_stock(GTK_STOCK_PASTE, accel_group); + pasteSpecialMi = gtk_menu_item_new_with_label("Paste Special"); + editSep1 = gtk_separator_menu_item_new(); + findMi = gtk_image_menu_item_new_from_stock(GTK_STOCK_FIND, accel_group); + editSep2 = gtk_separator_menu_item_new(); + + sortMenu = gtk_menu_new(); + sortMi = gtk_menu_item_new_with_mnemonic("_Sort"); + byOriginalOrderMi = gtk_radio_menu_item_new_with_label(sort_radio_group, "By original order"); + sort_radio_group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(byOriginalOrderMi)); + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(byOriginalOrderMi), TRUE); + byPathnameMi = gtk_radio_menu_item_new_with_label(sort_radio_group, "By pathname"); + sort_radio_group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(byPathnameMi)); + /*gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(byPathnameMi), FALSE);*/ + byFileTypeMi = gtk_radio_menu_item_new_with_label(sort_radio_group, "By file type"); + sort_radio_group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(byFileTypeMi)); + /*gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(byFileTypeMi), FALSE);*/ + byAuxtypeMi = gtk_radio_menu_item_new_with_label(sort_radio_group, "By auxtype"); + sort_radio_group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(byAuxtypeMi)); + /*gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(byAuxtypeMi), FALSE);*/ + byModificationDateMi = gtk_radio_menu_item_new_with_label(sort_radio_group, "By modification date"); + sort_radio_group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(byModificationDateMi)); + /*gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(byModificationDateMi), FALSE);*/ + byFormatMi = gtk_radio_menu_item_new_with_label(sort_radio_group, "By format"); + sort_radio_group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(byFormatMi)); + /*gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(byFormatMi), FALSE);*/ + bySizeMi = gtk_radio_menu_item_new_with_label(sort_radio_group, "By size"); + sort_radio_group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(bySizeMi)); + /*gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(bySizeMi), FALSE);*/ + byRatioMi = gtk_radio_menu_item_new_with_label(sort_radio_group, "By ratio"); + sort_radio_group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(byRatioMi)); + /*gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(byRatioMi), FALSE);*/ + byPackedSizeMi = gtk_radio_menu_item_new_with_label(sort_radio_group, "By packed size"); + sort_radio_group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(byPackedSizeMi)); + /*gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(byPackedSizeMi), FALSE);*/ + byAccessMi = gtk_radio_menu_item_new_with_label(sort_radio_group, "By access"); + sort_radio_group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(byAccessMi)); + /*gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(byAccessMi), FALSE);*/ + + /* 'Sort' submenu */ + gtk_menu_item_set_submenu(GTK_MENU_ITEM(sortMi), sortMenu); + gtk_menu_shell_append(GTK_MENU_SHELL(sortMenu), byOriginalOrderMi); + gtk_menu_shell_append(GTK_MENU_SHELL(sortMenu), byPathnameMi); + gtk_menu_shell_append(GTK_MENU_SHELL(sortMenu), byAuxtypeMi); + gtk_menu_shell_append(GTK_MENU_SHELL(sortMenu), byModificationDateMi); + gtk_menu_shell_append(GTK_MENU_SHELL(sortMenu), byFormatMi); + gtk_menu_shell_append(GTK_MENU_SHELL(sortMenu), bySizeMi); + gtk_menu_shell_append(GTK_MENU_SHELL(sortMenu), byRatioMi); + gtk_menu_shell_append(GTK_MENU_SHELL(sortMenu), byPackedSizeMi); + gtk_menu_shell_append(GTK_MENU_SHELL(sortMenu), byAccessMi); + + selectAllMi = gtk_menu_item_new_with_mnemonic("Select _all"); + gtk_widget_add_accelerator(selectAllMi, "activate", accel_group, GDK_a, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + invertSelectionMi = gtk_menu_item_new_with_mnemonic("_Invert selection"); + gtk_widget_add_accelerator(invertSelectionMi, "activate", accel_group, GDK_i, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + preferencesMi = gtk_menu_item_new_with_mnemonic("_Preferences..."); + gtk_widget_add_accelerator(preferencesMi, "activate", accel_group, GDK_p, GDK_CONTROL_MASK|GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE); + + /* Set up edit menu */ + gtk_menu_item_set_submenu(GTK_MENU_ITEM(editMi), editMenu); + gtk_menu_shell_append(GTK_MENU_SHELL(editMenu), copyMi); + gtk_menu_shell_append(GTK_MENU_SHELL(editMenu), pasteMi); + gtk_menu_shell_append(GTK_MENU_SHELL(editMenu), pasteSpecialMi); + gtk_menu_shell_append(GTK_MENU_SHELL(editMenu), editSep1); + gtk_menu_shell_append(GTK_MENU_SHELL(editMenu), findMi); + gtk_menu_shell_append(GTK_MENU_SHELL(editMenu), editSep2); + gtk_menu_shell_append(GTK_MENU_SHELL(editMenu), sortMi); + gtk_menu_shell_append(GTK_MENU_SHELL(editMenu), selectAllMi); + gtk_menu_shell_append(GTK_MENU_SHELL(editMenu), invertSelectionMi); + gtk_menu_shell_append(GTK_MENU_SHELL(editMenu), preferencesMi); + /* Add edit menu to menu bar */ + gtk_menu_shell_append(GTK_MENU_SHELL(menubar), editMi); + + /* connect 'preferences' menu item to the preferences dialog event */ + g_signal_connect(G_OBJECT(preferencesMi), "activate", G_CALLBACK(preferences), NULL); + + /* Action menu bar items */ + actionsMi = gtk_menu_item_new_with_label("Actions"); + viewMi = gtk_menu_item_new_with_mnemonic("_View..."); + extractMi = gtk_menu_item_new_with_mnemonic("_Extract..."); + testMi = gtk_menu_item_new_with_mnemonic("_Test..."); + renameMi = gtk_menu_item_new_with_label("Rename..."); + deleteMi = gtk_menu_item_new_with_label("Delete..."); + recompressMi = gtk_menu_item_new_with_label("Re-compress..."); + actionSep1 = gtk_separator_menu_item_new(); + addFilesMi = gtk_menu_item_new_with_mnemonic("Add _files"); + addDiskImageMi = gtk_menu_item_new_with_mnemonic("Add _disk image"); + createSubdirectoryMi = gtk_menu_item_new_with_mnemonic("Create _subdirectory"); + actionSep2 = gtk_separator_menu_item_new(); + openAsDiskImageMi = gtk_menu_item_new_with_mnemonic("_Open As Disk Image"); + editCommentMi = gtk_menu_item_new_with_mnemonic("Edit _comment..."); + editAttributesMi = gtk_menu_item_new_with_mnemonic("Edit _attributes..."); + renameVolumeMi = gtk_menu_item_new_with_label("Rename Volume..."); + actionSep3 = gtk_separator_menu_item_new(); + convertToDiskImageMi = gtk_menu_item_new_with_mnemonic("_Convert to disk image..."); + convertToArchiveFileMi = gtk_menu_item_new_with_mnemonic("_Convert to archive file..."); + importFileFromWAVMi = gtk_menu_item_new_with_label("Import File From WAV..."); + importBASFromTextMi = gtk_menu_item_new_with_mnemonic("Import _BAS From Text..."); + + /* Set up action menu */ + gtk_menu_item_set_submenu(GTK_MENU_ITEM(actionsMi), actionMenu); + gtk_menu_shell_append(GTK_MENU_SHELL(actionMenu), viewMi); + gtk_menu_shell_append(GTK_MENU_SHELL(actionMenu), extractMi); + gtk_menu_shell_append(GTK_MENU_SHELL(actionMenu), testMi); + gtk_menu_shell_append(GTK_MENU_SHELL(actionMenu), renameMi); + gtk_menu_shell_append(GTK_MENU_SHELL(actionMenu), deleteMi); + gtk_menu_shell_append(GTK_MENU_SHELL(actionMenu), recompressMi); + gtk_menu_shell_append(GTK_MENU_SHELL(actionMenu), actionSep1); + gtk_menu_shell_append(GTK_MENU_SHELL(actionMenu), addFilesMi); + gtk_menu_shell_append(GTK_MENU_SHELL(actionMenu), addDiskImageMi); + gtk_menu_shell_append(GTK_MENU_SHELL(actionMenu), createSubdirectoryMi); + gtk_menu_shell_append(GTK_MENU_SHELL(actionMenu), actionSep2); + gtk_menu_shell_append(GTK_MENU_SHELL(actionMenu), openAsDiskImageMi); + gtk_menu_shell_append(GTK_MENU_SHELL(actionMenu), editCommentMi); + gtk_menu_shell_append(GTK_MENU_SHELL(actionMenu), editAttributesMi); + gtk_menu_shell_append(GTK_MENU_SHELL(actionMenu), renameVolumeMi); + gtk_menu_shell_append(GTK_MENU_SHELL(actionMenu), actionSep3); + gtk_menu_shell_append(GTK_MENU_SHELL(actionMenu), convertToDiskImageMi); + gtk_menu_shell_append(GTK_MENU_SHELL(actionMenu), convertToArchiveFileMi); + gtk_menu_shell_append(GTK_MENU_SHELL(actionMenu), importFileFromWAVMi); + gtk_menu_shell_append(GTK_MENU_SHELL(actionMenu), importBASFromTextMi); + /* Add action menu to menu bar */ + gtk_menu_shell_append(GTK_MENU_SHELL(menubar), actionsMi); + + /* Tools menu bar items */ + toolsMi = gtk_menu_item_new_with_label("Tools"); + diskSectorViewerMi = gtk_menu_item_new_with_mnemonic("_Disk sector viewer"); + diskImageConverterMi = gtk_menu_item_new_with_mnemonic("Disk _image converter"); + bulkDiskImageConverterMi = gtk_menu_item_new_with_mnemonic("_Bulk disk image converter"); + toolsSep1 = gtk_separator_menu_item_new(); + volumeCopierOpenVolumeMi = gtk_menu_item_new_with_mnemonic("_Volume Copier (open volume)"); + volumeCopierOpenFileMi = gtk_menu_item_new_with_label("Volume Copier (open file)"); + mergeSSTImagesMi = gtk_menu_item_new_with_mnemonic("_Merge SST Images"); + toolsSep2 = gtk_separator_menu_item_new(); + TwoMGPropertiesEditorMi = gtk_menu_item_new_with_label("2MG Properties Editor"); + EOLScannerMi = gtk_menu_item_new_with_label("EOL Scanner"); + + /* Set up tools menu */ + gtk_menu_item_set_submenu(GTK_MENU_ITEM(toolsMi), toolsMenu); + gtk_menu_shell_append(GTK_MENU_SHELL(toolsMenu), diskSectorViewerMi); + gtk_menu_shell_append(GTK_MENU_SHELL(toolsMenu), diskImageConverterMi); + gtk_menu_shell_append(GTK_MENU_SHELL(toolsMenu), bulkDiskImageConverterMi); + gtk_menu_shell_append(GTK_MENU_SHELL(toolsMenu), toolsSep1); + gtk_menu_shell_append(GTK_MENU_SHELL(toolsMenu), volumeCopierOpenVolumeMi); + gtk_menu_shell_append(GTK_MENU_SHELL(toolsMenu), volumeCopierOpenFileMi); + gtk_menu_shell_append(GTK_MENU_SHELL(toolsMenu), mergeSSTImagesMi); + gtk_menu_shell_append(GTK_MENU_SHELL(toolsMenu), toolsSep2); + gtk_menu_shell_append(GTK_MENU_SHELL(toolsMenu), TwoMGPropertiesEditorMi); + gtk_menu_shell_append(GTK_MENU_SHELL(toolsMenu), EOLScannerMi); + /* Add Tools menu to menu bar */ + gtk_menu_shell_append(GTK_MENU_SHELL(menubar), toolsMi); + + /* Help menu bar items */ + helpMi = gtk_menu_item_new_with_mnemonic("_Help"); + contentsMi = gtk_menu_item_new_with_mnemonic("_Contents..."); + visitCalvadosWebsiteMi = gtk_menu_item_new_with_mnemonic("Visit Calvados _website"); + helpSep1 = gtk_separator_menu_item_new(); + aboutCalvadosMi = gtk_menu_item_new_with_label("About Calvados"); + + /* Set up help menu */ + gtk_menu_item_set_submenu(GTK_MENU_ITEM(helpMi), helpMenu); + gtk_menu_shell_append(GTK_MENU_SHELL(helpMenu), contentsMi); + gtk_menu_shell_append(GTK_MENU_SHELL(helpMenu), visitCalvadosWebsiteMi); + gtk_menu_shell_append(GTK_MENU_SHELL(helpMenu), helpSep1); + gtk_menu_shell_append(GTK_MENU_SHELL(helpMenu), aboutCalvadosMi); + /* Add help menu to menu bar */ + gtk_menu_shell_append(GTK_MENU_SHELL(menubar), helpMi); + + /* Add menu bar to vbox */ + gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0); + + /* connect 'open image' menu item to the create welcomeage dialog event */ + g_signal_connect(G_OBJECT(openMi), "activate", G_CALLBACK(open_file), NULL); + + /* connect 'disk image' menu item to the create disk image dialog event */ + g_signal_connect(G_OBJECT(diskImageMi), "activate", G_CALLBACK(create_disk_image), NULL); + + /* connect 'shrinkit archive' menu item to the new archive dialog event */ + g_signal_connect(G_OBJECT(shrinkItArchiveMi), "activate", G_CALLBACK(new_archive), NULL); + + /* connect 'select volume' menu item to the open volume dialog event */ + g_signal_connect(G_OBJECT(openVolumeMi), "activate", G_CALLBACK(select_volume), NULL); + + /* connect 'about' menu item to the about box event */ + g_signal_connect(G_OBJECT(aboutCalvadosMi), "activate", G_CALLBACK(show_about), NULL); + + /* connect 'disk sector viewer' menu item to the popup menu event */ + g_signal_connect(G_OBJECT(diskSectorViewerMi), "activate", G_CALLBACK(disk_sector_viewer_popup), NULL); + + /* Connect 'quit' menu item to the window's "destroy" event */ + g_signal_connect(G_OBJECT(quitMi), "activate", G_CALLBACK(gtk_main_quit), NULL); + + /* Create the tool bar */ + toolbar = gtk_toolbar_new(); + gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); + + /*newTb = gtk_tool_button_new_from_stock(GTK_STOCK_NEW); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), newTb, -1);*/ + + /*openTb = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN);*/ + openTbImage = gtk_image_new_from_file((gchar *)"images/openTb.png"); + openTb = gtk_tool_button_new((GtkWidget *)openTbImage, "Open"); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), openTb, -1); + + gtk_widget_set_tooltip_text(GTK_WIDGET(openTb), "Open (Ctrl-O)"); + + openVolumeTbImage = gtk_image_new_from_file((gchar *)"images/openVolumeTb.png"); + openVolumeTb = gtk_tool_button_new((GtkWidget *)openVolumeTbImage, "Open Volume"); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), openVolumeTb, -1); + + gtk_widget_set_tooltip_text(GTK_WIDGET(openVolumeTb), "Open volume (Ctrl-Shift-O)"); + + newArchiveTbImage = gtk_image_new_from_file((gchar *)"images/newArchiveTb.png"); + newArchiveTb = gtk_tool_button_new((GtkWidget *)newArchiveTbImage, "New Archive"); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), newArchiveTb, -1); + + gtk_widget_set_tooltip_text(GTK_WIDGET(newArchiveTb), "New Archive (Ctrl-N)"); + + createDiskImageTbImage = gtk_image_new_from_file((gchar *)"images/createDiskImageTb.png"); + createDiskImageTb = gtk_tool_button_new((GtkWidget *)createDiskImageTbImage, "Create Disk Image"); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), createDiskImageTb, -1); + + gtk_widget_set_tooltip_text(GTK_WIDGET(createDiskImageTb), "Create Disk Image"); + + /*saveTb = gtk_tool_button_new_from_stock(GTK_STOCK_SAVE); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), saveTb, -1);*/ + + printTbImage = gtk_image_new_from_file((gchar *)"images/printTb.png"); + printTb = gtk_tool_button_new((GtkWidget *)printTbImage, "Print"); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), printTb, -1); + + gtk_widget_add_accelerator(GTK_WIDGET(printTb), "clicked", accel_group, GDK_p, GDK_CONTROL_MASK, GTK_ACCEL_MASK); + + gtk_widget_set_tooltip_text(GTK_WIDGET(printTb), "Print (Ctrl-P)"); + + tbSep1 = gtk_separator_tool_item_new(); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tbSep1, -1); + + addFilesTbImage = gtk_image_new_from_file((gchar *)"images/addFilesTb.png"); + addFilesTb = gtk_tool_button_new((GtkWidget *)addFilesTbImage, "Add Files"); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), addFilesTb, -1); + + gtk_widget_set_tooltip_text(GTK_WIDGET(addFilesTb), "Add Files"); + + addDiskImageTbImage = gtk_image_new_from_file((gchar *)"images/addDiskImageTb.png"); + addDiskImageTb = gtk_tool_button_new((GtkWidget *)addDiskImageTbImage, "Add Disk Image"); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), addDiskImageTb, -1); + + gtk_widget_set_tooltip_text(GTK_WIDGET(addDiskImageTb), "Add disk image"); + + viewTbImage = gtk_image_new_from_file((gchar *)"images/viewTb.png"); + viewTb = gtk_tool_button_new((GtkWidget *)viewTbImage, "View"); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), viewTb, -1); + + gtk_widget_set_tooltip_text(GTK_WIDGET(viewTb), "View (tab)"); + + extractTbImage = gtk_image_new_from_file((gchar *)"images/extractTb.png"); + extractTb = gtk_tool_button_new((GtkWidget *)extractTbImage, "Extract"); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), extractTb, -1); + + gtk_widget_set_tooltip_text(GTK_WIDGET(extractTb), "Extract"); + + testTbImage = gtk_image_new_from_file((gchar *)"images/testTb.png"); + testTb = gtk_tool_button_new((GtkWidget *)testTbImage, "Test"); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), testTb, -1); + + gtk_widget_set_tooltip_text(GTK_WIDGET(testTb), "Test"); + + renameTbImage = gtk_image_new_from_file((gchar *)"images/renameTb.png"); + renameTb = gtk_tool_button_new((GtkWidget *)renameTbImage, "Rename"); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), renameTb, -1); + + gtk_widget_set_tooltip_text(GTK_WIDGET(renameTb), "Rename"); + + deleteTbImage = gtk_image_new_from_file((gchar *)"images/deleteTb.png"); + deleteTb = gtk_tool_button_new((GtkWidget *)deleteTbImage, "Delete"); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), deleteTb, -1); + + gtk_widget_set_tooltip_text(GTK_WIDGET(deleteTb), "Delete (DEL)"); + + recompressTbImage = gtk_image_new_from_file((gchar *)"images/recompressTb.png"); + recompressTb = gtk_tool_button_new((GtkWidget *)recompressTbImage, "Re-compress"); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), recompressTb, -1); + + gtk_widget_set_tooltip_text(GTK_WIDGET(recompressTb), "Recompress"); + + editCommentTbImage = gtk_image_new_from_file((gchar *)"images/editCommentTb.png"); + editCommentTb = gtk_tool_button_new((GtkWidget *)editCommentTbImage, "Edit Comment"); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), editCommentTb, -1); + + gtk_widget_set_tooltip_text(GTK_WIDGET(editCommentTb), "Edit Comment"); + + tbSep2 = gtk_separator_tool_item_new(); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tbSep2, -1); + + diskSectorViewerTbImage = gtk_image_new_from_file((gchar *)"images/diskSectorViewerTb.png"); + diskSectorViewerTb = gtk_tool_button_new((GtkWidget *)diskSectorViewerTbImage, "Disk Sector Viewer"); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), diskSectorViewerTb, -1); + + gtk_widget_set_tooltip_text(GTK_WIDGET(diskSectorViewerTb), "Disk Sector Viewer"); + + diskImageConverterTbImage = gtk_image_new_from_file((gchar *)"images/diskImageConverterTb.png"); + diskImageConverterTb = gtk_tool_button_new((GtkWidget *)diskImageConverterTbImage, "Disk Image Converter"); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), diskImageConverterTb, -1); + + gtk_widget_set_tooltip_text(GTK_WIDGET(diskImageConverterTb), "Disk Image Converter"); + + volumeCopierTbImage = gtk_image_new_from_file((gchar *)"images/volumeCopierTb.png"); + volumeCopierTb = gtk_tool_button_new((GtkWidget *)volumeCopierTbImage, "Volume Copier"); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), volumeCopierTb, -1); + + gtk_widget_set_tooltip_text(GTK_WIDGET(volumeCopierTb), "Volume Copier (open volume)"); + + mergeSSTImagesTbImage = gtk_image_new_from_file((gchar *)"images/mergeSSTImagesTb.png"); + mergeSSTImagesTb = gtk_tool_button_new((GtkWidget *)mergeSSTImagesTbImage, "Merge SST Images"); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), mergeSSTImagesTb, -1); + + gtk_widget_set_tooltip_text(GTK_WIDGET(mergeSSTImagesTb), "Merge SST Images"); + + tbSep3 = gtk_separator_tool_item_new(); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tbSep3, -1); + + exitTb = gtk_tool_button_new_from_stock(GTK_STOCK_QUIT); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), exitTb, -1); + + gtk_widget_set_tooltip_text(GTK_WIDGET(exitTb), "Exit"); + + /* Hook up the open image button to the open file dialog box */ + g_signal_connect(G_OBJECT(openTb), "clicked", G_CALLBACK(open_file), NULL); + + /* Hook up the create disk image button to the create disk image dialog box */ + g_signal_connect(G_OBJECT(createDiskImageTb), "clicked", G_CALLBACK(create_disk_image), NULL); + + /* Hook up the new archive image button to the create disk image dialog box */ + g_signal_connect(G_OBJECT(newArchiveTb), "clicked", G_CALLBACK(new_archive), NULL); + + /* Hook up the open volume button to the select volume dialog box */ + g_signal_connect(G_OBJECT(openVolumeTb), "clicked", G_CALLBACK(select_volume), NULL); + + /* Hook up the disk sector viewer button to the disk sector viewer popup menu */ + g_signal_connect(G_OBJECT(diskSectorViewerTb), "clicked", G_CALLBACK(disk_sector_viewer_popup), NULL); + + /* Hook up the exit button to the quit function */ + g_signal_connect(G_OBJECT(exitTb), "clicked", G_CALLBACK(gtk_main_quit), NULL); + + /* Add the tool bar to the vbox */ + gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 5); + + /*button = gtk_button_new_with_label("Hello Window"); + gtk_container_add(GTK_CONTAINER(vbox), button); + g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(gtk_main_quit), NULL);*/ + + /* Add the status bar */ + statusbar = gtk_statusbar_new(); + gtk_box_pack_end(GTK_BOX(vbox), statusbar, FALSE, TRUE, 0); + + /* connect the windows "destroy" event */ + g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL); + + /* set the window as visible */ + gtk_widget_show_all(window); + + /* run the GTK+ main loop */ + gtk_main(); + + return 0; +} + diff --git a/calvados.h b/calvados.h new file mode 100644 index 0000000..a4a983f --- /dev/null +++ b/calvados.h @@ -0,0 +1,27 @@ +/* + * + * cavaldos.h + * + * Include for cavaldos. + * + */ + +#define WINDOW_WIDTH 1300 +#define WINDOW_HEIGHT 725 + +void close_dialog(GtkWidget *widget, gpointer data); +void closing_dialog(GtkWidget *widget, gpointer data); +void select_volume(); +void show_about(GtkWidget *widget, gpointer data); +void disk_sector_viewer_popup(); +void okfunc_create_disk_image(GtkWidget *widget, gpointer data); +void okfunc_select_volume(GtkWidget *widget, gpointer data); +void help_func_create_disk_image(GtkWidget *widget, gpointer data); +void help_func_select_volume(GtkWidget *widget, gpointer data); +void create_disk_image(); +void do_open_file(char *filename); +void open_file(); +void save_to_file(char *filename); +void new_archive(); +void preferences(); + diff --git a/close_dialog.c b/close_dialog.c new file mode 100644 index 0000000..fb14012 --- /dev/null +++ b/close_dialog.c @@ -0,0 +1,19 @@ +#include +#include + +/* + * + * close_dialog() + * + * Called when closing a dialog + * + */ +void close_dialog(GtkWidget *widget, gpointer data) +{ + /* --- Display message --- */ + /*g_print("Cancel function goes here.\n");*/ + + /* --- Close it. --- */ + gtk_widget_destroy(GTK_WIDGET(data)); +} + diff --git a/closing_dialog.c b/closing_dialog.c new file mode 100644 index 0000000..ceb40e9 --- /dev/null +++ b/closing_dialog.c @@ -0,0 +1,16 @@ +#include +#include + +/* + * + * closing_dialog + * + * Calls when window is about to close. returns FALSE + * to let it close. + * + */ +void closing_dialog(GtkWidget *widget, gpointer data) +{ + gtk_grab_remove(GTK_WIDGET(widget)); +} + diff --git a/create_disk_image.c b/create_disk_image.c new file mode 100644 index 0000000..c4ef9bf --- /dev/null +++ b/create_disk_image.c @@ -0,0 +1,327 @@ +#include +#include + +#include "calvados.h" + +/* + * + * create_disk_image() + * + * Create Disk Image dialog box. + * + */ +void create_disk_image() +{ + GtkWidget *dialog_window; + GtkWidget *ok_button; + GtkWidget *cancel_button; + GtkWidget *help_button; + GtkWidget *hbox1; + GtkWidget *vbox1; + GtkWidget *vbox2; + GtkWidget *filesystemFrame; + GtkWidget *newDiskSizeFrame; + GtkWidget *dosOptionsFrame; + GtkWidget *prodosOptionsFrame; + GtkWidget *pascalOptionsFrame; + GtkWidget *hfsOptionsFrame; + GtkWidget *filesystemVbox; + GtkWidget *newDiskSizeVbox; + GtkWidget *dosOptionsVbox; + GtkWidget *prodosOptionsVbox; + GtkWidget *pascalOptionsVbox; + GtkWidget *hfsOptionsVbox; + GtkWidget *dos32Rb; + GtkWidget *dos33Rb; + GtkWidget *prodosRb; + GtkWidget *pascalRb; + GtkWidget *hfsRb; + GtkWidget *blankRb; + GtkWidget *s140kRb; + GtkWidget *s800kRb; + GtkWidget *s14MRb; + GtkWidget *s5MBRb; + GtkWidget *s16MBRb; + GtkWidget *s20MBRb; + GtkWidget *s32MBRb; + GtkWidget *specifyRb; + GtkWidget *blocksEntry; + GtkWidget *blocksLabel; + GtkWidget *specifyHbox; + GtkWidget *allocateDOSTracksCb; + GtkWidget *diskVolumeLabel; + GtkWidget *diskVolumeEntry; + GtkWidget *diskVolumeHbox; + GtkWidget *prodosVolumeLabel; + GtkWidget *prodosVolumeEntry; + GtkWidget *pascalVolumeLabel; + GtkWidget *pascalVolumeEntry; + GtkWidget *hfsVolumeLabel; + GtkWidget *hfsVolumeEntry; + + /* --- Create the dialog --- */ + dialog_window = gtk_dialog_new(); + + /* --- Trap the window close signal to release the grab --- */ + gtk_signal_connect(GTK_OBJECT(dialog_window), "destroy", + GTK_SIGNAL_FUNC(closing_dialog), + &dialog_window); + + /* --- Set the title --- */ + gtk_window_set_title(GTK_WINDOW(dialog_window), "Create Disk Image"); + + /* --- Add a small border --- */ + gtk_container_border_width(GTK_CONTAINER(dialog_window), 5); + + /* Two columns top portion of dialog vbox */ + hbox1 = gtk_hbox_new(FALSE, 0); + gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog_window)->vbox), hbox1, TRUE, TRUE, 0); + + gtk_widget_show(hbox1); + + /* Left column of hbox1 */ + vbox1 = gtk_vbox_new(FALSE, 0); + gtk_box_pack_start(GTK_BOX(hbox1), vbox1, TRUE, TRUE, 0); + + /* Right column of hbox1 */ + vbox2 = gtk_vbox_new(FALSE, 0); + gtk_box_pack_start(GTK_BOX(hbox1), vbox2, TRUE, TRUE, 0); + + gtk_widget_show(vbox1); + gtk_widget_show(vbox2); + + /* Frames on left column */ + filesystemFrame = gtk_frame_new("Filesystem"); + newDiskSizeFrame = gtk_frame_new("New disk size"); + + /* Frames on right column */ + dosOptionsFrame = gtk_frame_new("DOS options"); + prodosOptionsFrame = gtk_frame_new("ProDOS options"); + pascalOptionsFrame = gtk_frame_new("Pascal options"); + hfsOptionsFrame = gtk_frame_new("HFS options"); + + gtk_box_pack_start(GTK_BOX(vbox1), filesystemFrame, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(vbox1), newDiskSizeFrame, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(vbox2), dosOptionsFrame, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(vbox2), prodosOptionsFrame, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(vbox2), pascalOptionsFrame, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(vbox2), hfsOptionsFrame, TRUE, TRUE, 0); + + gtk_widget_show(filesystemFrame); + gtk_widget_show(newDiskSizeFrame); + gtk_widget_show(dosOptionsFrame); + gtk_widget_show(prodosOptionsFrame); + gtk_widget_show(pascalOptionsFrame); + gtk_widget_show(hfsOptionsFrame); + + filesystemVbox = gtk_vbox_new(FALSE, 0); + gtk_container_add(GTK_CONTAINER(filesystemFrame), filesystemVbox); + gtk_widget_show(filesystemVbox); + + newDiskSizeVbox = gtk_vbox_new(FALSE, 0); + gtk_container_add(GTK_CONTAINER(newDiskSizeFrame), newDiskSizeVbox); + gtk_widget_show(newDiskSizeVbox); + + dosOptionsVbox = gtk_vbox_new(FALSE, 0); + gtk_container_add(GTK_CONTAINER(dosOptionsFrame), dosOptionsVbox); + gtk_widget_show(dosOptionsVbox); + + prodosOptionsVbox = gtk_vbox_new(FALSE, 0); + gtk_container_add(GTK_CONTAINER(prodosOptionsFrame), prodosOptionsVbox); + gtk_widget_show(prodosOptionsVbox); + + pascalOptionsVbox = gtk_vbox_new(FALSE, 0); + gtk_container_add(GTK_CONTAINER(pascalOptionsFrame), pascalOptionsVbox); + gtk_widget_show(pascalOptionsVbox); + + hfsOptionsVbox = gtk_vbox_new(FALSE, 0); + gtk_container_add(GTK_CONTAINER(hfsOptionsFrame), hfsOptionsVbox); + gtk_widget_show(hfsOptionsVbox); + + dos32Rb = gtk_radio_button_new_with_label(NULL, "DOS 3.2 (13-sector)"); + dos33Rb = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(dos32Rb), "DOS 3.3"); + prodosRb = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(dos33Rb), "ProDOS"); + pascalRb = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(prodosRb), "Pascal"); + hfsRb = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(pascalRb), "HFS"); + blankRb = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(hfsRb), "Blank"); + + gtk_box_pack_start(GTK_BOX(filesystemVbox), dos32Rb, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(filesystemVbox), dos33Rb, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(filesystemVbox), prodosRb, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(filesystemVbox), pascalRb, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(filesystemVbox), hfsRb, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(filesystemVbox), blankRb, TRUE, TRUE, 0); + + gtk_widget_show(dos32Rb); + gtk_widget_show(dos33Rb); + gtk_widget_show(prodosRb); + gtk_widget_show(pascalRb); + gtk_widget_show(hfsRb); + gtk_widget_show(blankRb); + + s140kRb = gtk_radio_button_new_with_label(NULL, "140KB (5.25\" floppy)"); + s800kRb = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(s140kRb), "800KB (3.5\" floppy)"); + s14MRb = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(s800kRb), "1.4MB (3.5\" PC floppy)"); + s5MBRb = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(s14MRb), "5MB"); + s16MBRb = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(s5MBRb), "16MB"); + s20MBRb = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(s16MBRb), "20MB"); + s32MBRb = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(s20MBRb), "32MB (largest ProDOS volume)"); + specifyRb = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(s32MBRb), "Specify size:"); + + specifyHbox = gtk_hbox_new(FALSE, 0); + + blocksEntry = gtk_entry_new(); + gtk_entry_set_max_length(GTK_ENTRY(blocksEntry), 8); + + blocksLabel = gtk_label_new(" blocks"); + gtk_misc_set_alignment(GTK_MISC(blocksLabel), 0, 0.5); + + gtk_box_pack_start(GTK_BOX(specifyHbox), specifyRb, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(specifyHbox), blocksEntry, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(specifyHbox), blocksLabel, TRUE, TRUE, 0); + + gtk_box_pack_start(GTK_BOX(newDiskSizeVbox), s140kRb, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(newDiskSizeVbox), s800kRb, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(newDiskSizeVbox), s14MRb, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(newDiskSizeVbox), s5MBRb, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(newDiskSizeVbox), s16MBRb, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(newDiskSizeVbox), s20MBRb, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(newDiskSizeVbox), s32MBRb, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(newDiskSizeVbox), specifyHbox, TRUE, TRUE, 0); + + gtk_widget_show(s140kRb); + gtk_widget_show(s800kRb); + gtk_widget_show(s14MRb); + gtk_widget_show(s5MBRb); + gtk_widget_show(s16MBRb); + gtk_widget_show(s20MBRb); + gtk_widget_show(s32MBRb); + gtk_widget_show(specifyRb); + gtk_widget_show(blocksEntry); + gtk_widget_show(blocksLabel); + gtk_widget_show(specifyHbox); + + allocateDOSTracksCb = gtk_check_button_new_with_label("Allocate DOS tracks"); + + diskVolumeHbox = gtk_hbox_new(FALSE, 0); + + diskVolumeLabel = gtk_label_new("Disk volume: "); + gtk_misc_set_alignment(GTK_MISC(diskVolumeLabel), 0, 0.5); + + diskVolumeEntry = gtk_entry_new(); + gtk_entry_set_max_length(GTK_ENTRY(diskVolumeEntry), 3); + + gtk_box_pack_start(GTK_BOX(diskVolumeHbox), diskVolumeLabel, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(diskVolumeHbox), diskVolumeEntry, TRUE, TRUE, 0); + + gtk_box_pack_start(GTK_BOX(dosOptionsVbox), allocateDOSTracksCb, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(dosOptionsVbox), diskVolumeHbox, TRUE, TRUE, 0); + + gtk_widget_show(allocateDOSTracksCb); + gtk_widget_show(diskVolumeLabel); + gtk_widget_show(diskVolumeEntry); + gtk_widget_show(diskVolumeHbox); + + prodosVolumeLabel = gtk_label_new("ProDOS volume name (15 chars):"); + gtk_misc_set_alignment(GTK_MISC(prodosVolumeLabel), 0, 0.5); + + prodosVolumeEntry = gtk_entry_new(); + gtk_entry_set_max_length(GTK_ENTRY(prodosVolumeEntry), 15); + + gtk_box_pack_start(GTK_BOX(prodosOptionsVbox), prodosVolumeLabel, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(prodosOptionsVbox), prodosVolumeEntry, TRUE, TRUE, 0); + + gtk_widget_show(prodosVolumeLabel); + gtk_widget_show(prodosVolumeEntry); + + pascalVolumeLabel = gtk_label_new("Pascal volume name (7 chars):"); + gtk_misc_set_alignment(GTK_MISC(pascalVolumeLabel), 0, 0.5); + + pascalVolumeEntry = gtk_entry_new(); + gtk_entry_set_max_length(GTK_ENTRY(pascalVolumeEntry), 15); + + gtk_box_pack_start(GTK_BOX(pascalOptionsVbox), pascalVolumeLabel, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(pascalOptionsVbox), pascalVolumeEntry, TRUE, TRUE, 0); + + gtk_widget_show(pascalVolumeLabel); + gtk_widget_show(pascalVolumeEntry); + + hfsVolumeLabel = gtk_label_new("HFS volume name (27 chars):"); + gtk_misc_set_alignment(GTK_MISC(hfsVolumeLabel), 0, 0.5); + + hfsVolumeEntry = gtk_entry_new(); + gtk_entry_set_max_length(GTK_ENTRY(hfsVolumeEntry), 27); + + gtk_box_pack_start(GTK_BOX(hfsOptionsVbox), hfsVolumeLabel, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(hfsOptionsVbox), hfsVolumeEntry, TRUE, TRUE, 0); + + gtk_widget_show(hfsVolumeLabel); + gtk_widget_show(hfsVolumeEntry); + + /* + * --- OK button + */ + + /* --- Create the "OK" button --- */ + ok_button = gtk_button_new_with_label("OK"); + + gtk_signal_connect(GTK_OBJECT(ok_button), "clicked", + GTK_SIGNAL_FUNC(okfunc_create_disk_image), + dialog_window); + + /* --- Allow "Cancel" to be a default --- */ + GTK_WIDGET_SET_FLAGS(ok_button, GTK_CAN_DEFAULT); + + /* --- Add the OK button to the bottom hbox2 --- */ + gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog_window)->action_area), ok_button, TRUE, TRUE, 0); + + /* --- Make the "OK" the default --- */ + gtk_widget_grab_default(ok_button); + + /* --- Make the button visible --- */ + gtk_widget_show(ok_button); + + /* + * --- Cancel button + */ + + /* --- Create the "Cancel" button --- */ + cancel_button = gtk_button_new_with_label("Cancel"); + + gtk_signal_connect(GTK_OBJECT(cancel_button), "clicked", + GTK_SIGNAL_FUNC(close_dialog), + dialog_window); + + /* --- Allow "Cancel" to be a default --- */ + GTK_WIDGET_SET_FLAGS(cancel_button, GTK_CAN_DEFAULT); + + /* --- Add the "Cancel" button to the dialog --- */ + gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog_window)->action_area), cancel_button, TRUE, TRUE, 0); + + /* --- Make the button visible. --- */ + gtk_widget_show(cancel_button); + + /* + * --- Help button + */ + + /* --- Create the "Help" button --- */ + help_button = gtk_button_new_with_label("Help"); + + gtk_signal_connect(GTK_OBJECT(help_button), "clicked", + GTK_SIGNAL_FUNC(help_func_create_disk_image), + dialog_window); + + /* --- Add the "Help" button to the dialog --- */ + gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog_window)->action_area), help_button, TRUE, TRUE, 0); + + /* --- Make the button visible. --- */ + gtk_widget_show(help_button); + + /* --- Show the dialog --- */ + gtk_widget_show(dialog_window); + + /* --- Only this window can be used for now --- */ + gtk_grab_add(dialog_window); +} + diff --git a/disk_sector_viewer_popup.c b/disk_sector_viewer_popup.c new file mode 100644 index 0000000..17dd432 --- /dev/null +++ b/disk_sector_viewer_popup.c @@ -0,0 +1,124 @@ +#include +#include + +#include "calvados.h" + +/* + * + * disk_sector_viewer_popup() + * + * Disk Sector Viewer Popup dialog + * + */ +void disk_sector_viewer_popup() +{ + GtkWidget *dialog_window; + GtkWidget *vbox; + GtkWidget *openDiskButton; + GtkWidget *openVolumeButton; + GtkWidget *openArchiveButton; + GtkWidget *cancelButton; + + /* --- Create a dialog window --- */ + dialog_window = gtk_dialog_new(); + + /* --- Trap the destroy button --- */ + gtk_signal_connect(GTK_OBJECT(dialog_window), "destroy", + GTK_SIGNAL_FUNC(gtk_widget_destroyed), + &dialog_window); + + /* --- Add a title to the window --- */ + /*gtk_window_set_title(GTK_WINDOW(dialog_window), "Disk sector viewer");*/ + gtk_window_set_title(GTK_WINDOW(dialog_window), " "); + + /* --- Create a small border --- */ + gtk_container_border_width(GTK_CONTAINER(dialog_window), 5); + + vbox = gtk_vbox_new(FALSE, 0); + gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog_window)->vbox), vbox, TRUE, TRUE, 0); + gtk_widget_show(vbox); + + /* + * --- "open disk" button + */ + + /* --- Create the "open disk" button --- */ + openDiskButton = gtk_button_new_with_label("Open disk image file"); + + /* --- Need to close the window if they press "ok" --- */ + gtk_signal_connect(GTK_OBJECT(openDiskButton), "clicked", + GTK_SIGNAL_FUNC(close_dialog), + dialog_window); + + /* --- Add the button to the dialog --- */ + gtk_box_pack_start(GTK_BOX(vbox), openDiskButton, TRUE, TRUE, 0); + + /* --- Make the button visible --- */ + gtk_widget_show(openDiskButton); + + /* + * --- "open volume" button + */ + + /* --- Create the "open volume" button --- */ + openVolumeButton = gtk_button_new_with_label("Open logical or physical volume"); + + /* --- Need to close the window if they press "ok" --- */ + gtk_signal_connect(GTK_OBJECT(openVolumeButton), "clicked", + GTK_SIGNAL_FUNC(close_dialog), + dialog_window); + + /* --- Add the button to the dialog --- */ + gtk_box_pack_start(GTK_BOX(vbox), openVolumeButton, TRUE, TRUE, 0); + + /* --- Make the button visible --- */ + gtk_widget_show(openVolumeButton); + + /* + * --- "open archive" button + */ + + /* --- Create the "open archive" button --- */ + openArchiveButton = gtk_button_new_with_label("Open current archive"); + + /* --- Need to close the window if they press "ok" --- */ + gtk_signal_connect(GTK_OBJECT(openArchiveButton), "clicked", + GTK_SIGNAL_FUNC(close_dialog), + dialog_window); + + /* --- Add the button to the dialog --- */ + gtk_box_pack_start(GTK_BOX(vbox), openArchiveButton, TRUE, TRUE, 0); + + /* --- Make the button visible --- */ + gtk_widget_show(openArchiveButton); + + /* + * --- "cancel" button + */ + + /* --- Create the "cancel" button --- */ + cancelButton = gtk_button_new_with_label("Cancel"); + + /* --- Need to close the window if they press "ok" --- */ + gtk_signal_connect(GTK_OBJECT(cancelButton), "clicked", + GTK_SIGNAL_FUNC(close_dialog), + dialog_window); + + /* --- Allow it to be the default button --- */ + GTK_WIDGET_SET_FLAGS(cancelButton, GTK_CAN_DEFAULT); + + /* --- Add the button to the dialog --- */ + gtk_box_pack_start(GTK_BOX(vbox), cancelButton, TRUE, TRUE, 0); + + /* --- Make the button the default button --- */ + gtk_widget_grab_default(cancelButton); + + /* --- Make the button visible --- */ + gtk_widget_show(cancelButton); + + /* --- Make the dialog visible --- */ + gtk_widget_show(dialog_window); + + gtk_grab_add(dialog_window); +} + diff --git a/do_open_file.c b/do_open_file.c new file mode 100644 index 0000000..fcf09f8 --- /dev/null +++ b/do_open_file.c @@ -0,0 +1,18 @@ +#include +#include + +#include "calvados.h" + +/* + * + * do_open_file() + * + * Open a file. + * + */ +void do_open_file(char *filename) +{ + /* --- Display message --- */ + g_print("Open file function goes here.\n"); +} + diff --git a/help_func_create_disk_image.c b/help_func_create_disk_image.c new file mode 100644 index 0000000..ab6c0a1 --- /dev/null +++ b/help_func_create_disk_image.c @@ -0,0 +1,26 @@ +#include +#include + +#include "calvados.h" + +/* + * + * help_func_create_disk_image() + * + * Help Function for create disk image + * + * Show that the "Help" button was pressed + * + */ +void help_func_create_disk_image(GtkWidget *widget, gpointer data) +{ + /* --- Display message --- */ + g_print("Help function goes here.\n"); + + /* --- Close it. --- */ + gtk_widget_destroy(GTK_WIDGET(data)); + + /* Now open the help dialog */ +/*FIXME*/ +} + diff --git a/help_func_select_volume.c b/help_func_select_volume.c new file mode 100644 index 0000000..61279e0 --- /dev/null +++ b/help_func_select_volume.c @@ -0,0 +1,26 @@ +#include +#include + +#include "calvados.h" + +/* + * + * help_func_select_volume() + * + * Help Function for select volume image + * + * Show that the "Help" button was pressed + * + */ +void help_func_select_volume(GtkWidget *widget, gpointer data) +{ + /* --- Display message --- */ + g_print("Help function goes here.\n"); + + /* --- Close it. --- */ + gtk_widget_destroy(GTK_WIDGET(data)); + + /* Now open the help dialog */ +/*FIXME*/ +} + diff --git a/images/addDiskImageTb.png b/images/addDiskImageTb.png new file mode 100644 index 0000000000000000000000000000000000000000..ff2aed663f9195a270842078f2d46fa8d0dcef66 GIT binary patch literal 274 zcmeAS@N?(olHy`uVBq!ia0vp^5jA5L~c#`DCC7XMsm# zF#`j)FbFd;%$ftz!(QU)>&pI+nM+JY;ZJf@3Q%air;B5V$MLtJjzUKiIJjm1r_OtJ z`Niow-fw&Q0+x4gFX|OyW^@hJHgjWQm=qik8k;kdfg$T{YX?WzhE%5alUkp8-+j5l z((UH7FOt`U(iiv4ZCbu7>c+}fLNYgG<~9X&RbDuB>$S1v+g6t|jZjA5L~c#`DCC7XMsm# zF#`j)FbFd;%$ftz!(QU)>&pI+nM+JsWA9Iwi9n$#o-U3d9>?E?Me`j{;BbDt_uAs? zlXv!~9?^Z()^G3W!6D@>7~pPn(uq?^iQ$T4(A!z}mEzWxWY%R|&QDC3`j}Nr`b`bL zgG#7(!(oQ{#r4ZhgqH2t$Z#iP=ChZY8)r^i6t(J4Pg>Sp=kS?zUtR7^S!n($DxFz? zVb{CxvkPWFEn%3%Uv^p|r-9etr*E90UK@jse1ovXQp>+PZ8k9i-N)eR>gTe~DWM4f D5pP`8 literal 0 HcmV?d00001 diff --git a/images/calvados.png b/images/calvados.png new file mode 100644 index 0000000000000000000000000000000000000000..b5ceb0a0ce5f744dbcdbc1f7819997937e62f538 GIT binary patch literal 27151 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 N002ovPDHLkV1mx(e^&qi literal 0 HcmV?d00001 diff --git a/images/createDiskImageTb.png b/images/createDiskImageTb.png new file mode 100644 index 0000000000000000000000000000000000000000..391458dc0006316036a6a31f95bfcdb9d92536fb GIT binary patch literal 246 zcmeAS@N?(olHy`uVBq!ia0vp^;vmey1|%P7U0DF6*pj^6T^Rm@;DWu&Cj&(|3p^r= z85p>QL70(Y)*K0-AbW|YuPggQW-c)aVfFj}%78-6o-U3d9>kOk1^Fqd7H}$I@foV$Y7|-QK;P_ns9l3}D%MQA6Ww*p`6hb1$CSxTBiC zcvAn96`#(SoG$Bmo-%XihEvX|&lhfe9+o&SR&-l)%DPB4Uad1vBd$FudKT!a`T5(n nKc{8#PrrPv;P|)x+%ASHFVnr>8w-~Lox|Yi>gTe~DWM4fW>8?t literal 0 HcmV?d00001 diff --git a/images/deleteTb.png b/images/deleteTb.png new file mode 100644 index 0000000000000000000000000000000000000000..bc283130b2d61db783e6d33da075f356798b856a GIT binary patch literal 224 zcmeAS@N?(olHy`uVBq!ia0vp^5jA5L~c#`DCC7XMsm# zF#`j)FbFd;%$ftz!(QU)>&pI+nM+JjDxm#z22d#1)5S5w7BiE>QSkaUGr18mno@yO5jpoo#iX8TFZRknnUPT#$1b&OCPETH;Aj4cbA!O*PFQS zV*Z1RFLGyoEnX(KvZnIY%DWB1Tn-FO0uA?>{c5f!u^!)gA>P;6n_o}OY^!=njXTg{ N22WQ%mvv4FO#rjjA5L~c#`DCC7XMsm# zF#`j)FbFd;%$ftz!(QU)>&pI+nM+LBD)N4(5>RNHr;B5V$MLOGPl_Hk;Beveubp`* zZG5C(&&(x?1 n8R2O+Tv>FxPpxXc^osp%lYfI~+;=9R4;VaM{an^LB{Ts5jA5L~c#`DCC7XMsm# zF#`j)FbFd;%$ftz!(QU)>&pI+nM+JrqG$h!V?d!|PZ!4!kK<269k~uD@SOINzqb5q z=HHptoW*YvmK^G`tn|tddL$~yE4}bVLPJ zws6lo($leq<#@**i0<#>;jj3~v@=h&P VGB2(WSq8M8!PC{xWt~$(697>MQ2YP@ literal 0 HcmV?d00001 diff --git a/images/editCommentTb.png b/images/editCommentTb.png new file mode 100644 index 0000000000000000000000000000000000000000..8dcd4091236148893c75ad671782241b24e5bc83 GIT binary patch literal 272 zcmeAS@N?(olHy`uVBq!ia0vp^5jA5L~c#`DCC7XMsm# zF#`j)FbFd;%$ftz!(QU)>&pI+nM+K`V1Zy@El_B#r;B5V$MLfvj(i6cIBxU&zqI`E z>1~s{jTKxU8TDzItX-;Z9Dn?n(vv_~v zW;V}x7_UUhFDPVF?49T(m}#=J>iSBafJ&WhTY~3Jce!mIS=4ad^-_G@bET7v_l(4I zSsZg;cX62{J0+&4_OvH{%1dWoMxxK!-AT My85}Sb4q9e0Oy!rnE(I) literal 0 HcmV?d00001 diff --git a/images/extractTb.png b/images/extractTb.png new file mode 100644 index 0000000000000000000000000000000000000000..429476f93f630b358cbf5d862d9e7d7636c3de28 GIT binary patch literal 308 zcmeAS@N?(olHy`uVBq!ia0vp^5jA5L~c#`DCC7XMsm# zF#`j)FbFd;%$ftz!(QU)>&pI+nM+Jgb9-ll6Hw@&r;B5V$MLPxqPdPL@VFd*wC~KN zm|H2S_ximZZfDj03g$9ee)3{~yV1i3MGUJLCRH=!J1T8rEvn5mxL|ld>&W*n|2Yaxw$GKYh?V_1@*YL?++v z-$#W7m$0l5QskKPTW&&K$&APyS`#OUysuv&G9i(@^2Y7rziRgTBpA+g+t~b^$~A{M zY0dlI!bPsi4^^Jad};Idl;fOVl%TlRp3A<=x1_0H=EFRoXBa$P{an^LB{Ts5C8l$+ literal 0 HcmV?d00001 diff --git a/images/mergeSSTImagesTb.png b/images/mergeSSTImagesTb.png new file mode 100644 index 0000000000000000000000000000000000000000..8d804be99d6fc20e483935bd036a05c51f973681 GIT binary patch literal 282 zcmeAS@N?(olHy`uVBq!ia0vp^5jA5L~c#`DCC7XMsm# zF#`j)FbFd;%$ftz!(QU)>&pI+nM+KSJ^XFbR-n*wPZ!4!kK=bkJcSM$a1_t@x4LTA zpH1If*pg2?I`VeQ94D5f?@pgW)w*7=H?r;Up01(Q$h4_g>flnJY42Gsd~%q!`p2h@ zx=ar@?Qjxeg5|s9T)3(qM5PDKW|~?#m@{EB{$YgZ`(7y zRw7}wlz&F_jGt?rzp+it;n3OnU;byAXh;!jR=}=FZq3{4?u8pY-fVmRPu>5OGwM#} Yb0sxpubka@4(MbCPgg&ebxsLQ08S%q>;M1& literal 0 HcmV?d00001 diff --git a/images/newArchiveTb.png b/images/newArchiveTb.png new file mode 100644 index 0000000000000000000000000000000000000000..9eae0778849573075f26cc78d9a52d8b9ee88972 GIT binary patch literal 215 zcmeAS@N?(olHy`uVBq!ia0vp^;vmey1|%P7U0DF6*pj^6T^Rm@;DWu&Cj&(|3p^r= z85p>QL70(Y)*K0-AbW|YuPggQW-c)?8O_J%GJ!%Vo-U3d9>?EKHRL;>z{9-o)ZsrR z|JTgjrEq!KBx6%K!8vnT4ysi4DakGlSSZF=(=_4C;rV$8 zj_qN?y3Y5KEy{1tt@$#~e9uGP|GGAt^yl)<`}^o#2_u`Ryye02+l)Z_7(8A5T-G@y GGywoNZ%LN` literal 0 HcmV?d00001 diff --git a/images/openTb.png b/images/openTb.png new file mode 100644 index 0000000000000000000000000000000000000000..eae5eb40410e3572410706c83e64652e0d79e2df GIT binary patch literal 300 zcmeAS@N?(olHy`uVBq!ia0vp^5jA5L~c#`DCC7XMsm# zF#`j)FbFd;%$ftz!(QU)>&pI+nM;h9_f@JYBT#6kr;B5V$MLOG9Qj%lco^6p?SFH* zBC0a-`-X!$O5Bq!wS;i^8Ef#a%F5|E@ysGDUSwj{x>a?oE=w5iT|Z@0b)egE?f!KjLJYXkMqx6Djj zwQI`5-*=>An{U2JV$kVNPEk-=vgMjz(67(pl?T>`ZREbUmp$&o@#+Vh`8<0bPCdx? qBQ?OR^6+Y=)rPO!k9*y(7nV=*v|i&9enKDU2?kGBKbLh*2~7YQL70(Y)*K0-AbW|YuPggQW-c*)f!(3nQ9z;Ho-U3d9>=#%_2xUGz~el(tGYKo zY)7O;WLhiN-yo?Q3zR+@Y;<-F<(=#%ao1zh&#+K=i<8Vb``v`P*>`B@Z`a&haea^8 zbtCRKT=$#pmp)zdtp9^C>*Ds-c`7|qR&*{>w>Y*#(u$dfp;6_`KKED`sebF-{nKb@6{jKoi4mdKI;Vst0FxSWApigX literal 0 HcmV?d00001 diff --git a/images/printTb.png b/images/printTb.png new file mode 100644 index 0000000000000000000000000000000000000000..7ec80c4901f1a6e37f778c4856ed307f83bf011f GIT binary patch literal 290 zcmeAS@N?(olHy`uVBq!ia0vp^5jA5L~c#`DCC7XMsm# zF#`j)FbFd;%$ftz!(QU)>&pI+nM+Jc+xE3e7Eoxtr;B5V$ML-(7r727aG1P2{O8N> z&EE`o#MiF5)8fc%eg3l!qsEuSCy`AZI?YTU#545Q2tA7Y#PwsEi`>j9F8u-DHrT&x zTD+w4^`{fAwnAp|3`@)S{chZj+!3?oajoi#|67~qw$2h=W!&*$_t6WRI|SSt`qO4~ zXnfhY`GHcAx5!n;{Jx(o2`)ZMqc&w~o9h&tmQSr#yeCv{r5_ gbL?!lye-FA?+)78&qol`;+08JBbfdBvi literal 0 HcmV?d00001 diff --git a/images/recompressTb.png b/images/recompressTb.png new file mode 100644 index 0000000000000000000000000000000000000000..c08709c24a7d9401e490162b2a80a50b3b3e1723 GIT binary patch literal 263 zcmeAS@N?(olHy`uVBq!ia0vp^5jA5L~c#`DCC7XMsm# zF#`j)FbFd;%$ftz!(QU)>&pI+nM+KG^S{W=QlQWjPZ!4!kKgTe~DWM4f D(70N) literal 0 HcmV?d00001 diff --git a/images/renameTb.png b/images/renameTb.png new file mode 100644 index 0000000000000000000000000000000000000000..2e9e657242a2abb9a107c648732efd81428bda9a GIT binary patch literal 284 zcmeAS@N?(olHy`uVBq!ia0vp^5jA5L~c#`DCC7XMsm# zF#`j)FbFd;%$ftz!(QU)>&pI+nM+K;V3NA=f1uDxPZ!4!kK<=UFLE7F;8^ow|EJ6A z^>5E(G7PuU5^~$gXRB+%v*WtxjCKlU-$cr9+eHY=EiQ0!!CB38f+B-=1v# zmm!_5Kl8f~!`yoYHTvgO?0VB0VrGBTR}xxpHRCKpZdy-N)u(UuK$_#J;BL`PwQ_s@ X3S@ph(`K{==x7E{S3j3^P6jA5L~c#`DCC7XMsm# zF#`j)FbFd;%$ftz!(QU)>&pI+nM+Jw&)}QN0-(@xPZ!4!kKBdnRfaf_09Y|Y69??u*n_QhsQCo_1u`njxgN@xNA)h%TP literal 0 HcmV?d00001 diff --git a/images/viewTb.png b/images/viewTb.png new file mode 100644 index 0000000000000000000000000000000000000000..5af669152b5baf2728a1cf53737206e43422cf5e GIT binary patch literal 242 zcmeAS@N?(olHy`uVBq!ia0vp^5jA5L~c#`DCC7XMsm# zF#`j)FbFd;%$ftz!(QU)>&pI+nM+KLEYD%I=q|E+<-n=29A*Q-QA0L>0U2tudw#}o{9N)4c z|IL(S5Maoh*rESj-SC8^vGJdIVjr)ZT{GL*_^`ZfIGeHH$KTsd{Pu~{J-xWRU>$FV h%O;zD-QQ}Pg+K3fQ(m~^wHnYV44$rjF6*2UngIXaR%ieK literal 0 HcmV?d00001 diff --git a/images/volumeCopierTb.png b/images/volumeCopierTb.png new file mode 100644 index 0000000000000000000000000000000000000000..568d11065bb8c43e15a1e5950e39d8f1de67c1f7 GIT binary patch literal 296 zcmeAS@N?(olHy`uVBq!ia0vp^5jA5L~c#`DCC7XMsm# zF#`j)FbFd;%$ftz!(QU)>&pI+nM+JXYf- zcB%U3zcv#dFkkeYeErA~ftTC1onyLjrn%s$s=!tErhohXnmQ^N@pN>Yu3fI^oVjAc zwzE3})ytQ@QZHZ3zs}2~saDt3|KNA_fJtrprMJ7L= z^IXp0^R8ow^Tm2fCttsvyIS%ulfoYH%aIm*tnX&nem=Ke<>7v{9YR+HgS@VK>rZ^v nvqwxpX{xDVjOeWBEyvmOisJ&O*j +#include + +#include "calvados.h" + +/* + * + * new_archive() + * + * New archive dialog box. + * + */ +void new_archive() +{ + GtkWidget *dialog; + + dialog = gtk_file_chooser_dialog_new("New Archive", + NULL, + GTK_FILE_CHOOSER_ACTION_SAVE, + GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, + GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, + NULL); + gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE); + + gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), "Desktop"); + gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "new.shk"); + + + if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { + char *filename; + + filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); + save_to_file(filename); + g_free(filename); + } + + gtk_widget_destroy(dialog); +} + diff --git a/okfunc_create_disk_image.c b/okfunc_create_disk_image.c new file mode 100644 index 0000000..bfccadc --- /dev/null +++ b/okfunc_create_disk_image.c @@ -0,0 +1,23 @@ +#include +#include + +#include "calvados.h" + +/* + * + * okfunc_create_disk_image() + * + * OK Function for create disk image + * + * Show that the "OK" button was pressed + * + */ +void okfunc_create_disk_image(GtkWidget *widget, gpointer data) +{ + /* --- Display message --- */ + g_print("Create function goes here.\n"); + + /* --- Close it. --- */ + gtk_widget_destroy(GTK_WIDGET(data)); +} + diff --git a/okfunc_select_volume.c b/okfunc_select_volume.c new file mode 100644 index 0000000..ac48042 --- /dev/null +++ b/okfunc_select_volume.c @@ -0,0 +1,23 @@ +#include +#include + +#include "calvados.h" + +/* + * + * okfunc_select_volume() + * + * OK Function for select volume + * + * Show that the "OK" button was pressed + * + */ +void okfunc_select_volume(GtkWidget *widget, gpointer data) +{ + /* --- Display message --- */ + g_print("Create function goes here.\n"); + + /* --- Close it. --- */ + gtk_widget_destroy(GTK_WIDGET(data)); +} + diff --git a/open_file.c b/open_file.c new file mode 100644 index 0000000..5c81d41 --- /dev/null +++ b/open_file.c @@ -0,0 +1,38 @@ +#include +#include + +#include "calvados.h" + +/* + * + * open_file() + * + * Open file dialog + * + */ +void open_file() +{ + GtkWidget *dialog; + gint res; + + dialog = gtk_file_chooser_dialog_new("Open", + NULL, + GTK_FILE_CHOOSER_ACTION_OPEN, + GTK_STOCK_CANCEL, + GTK_RESPONSE_CANCEL, + GTK_STOCK_OPEN, + GTK_RESPONSE_ACCEPT, + NULL); + + res = gtk_dialog_run(GTK_DIALOG(dialog)); + if (res == GTK_RESPONSE_ACCEPT) { + char *filename; + GtkFileChooser *chooser = GTK_FILE_CHOOSER(dialog); + filename = gtk_file_chooser_get_filename(chooser); + do_open_file(filename); + g_free(filename); + } + + gtk_widget_destroy(dialog); +} + diff --git a/preferences.c b/preferences.c new file mode 100644 index 0000000..bc24989 --- /dev/null +++ b/preferences.c @@ -0,0 +1,901 @@ +#include +#include + +#include "calvados.h" + +/* + * + * apply_func_preferences() + * + * Actually do apply of preferences. + * + */ +void apply_func_preferences() +{ + g_print("Apply function goes here.\n"); +} + + +/* + * + * help_func_preferences() + * + * Help function for preferences + * + */ +void help_func_preferences() +{ + g_print("Help function goes here.\n"); +} + + +/* + * + * page_switch() + * + * Event that occurs when a different page is now + * the focus. + * + */ +static void page_switch(GtkWidget *widget, + GtkNotebookPage *page, + gint page_num) +{ + g_print("page switch\n"); +} + + +/* + * + * add_page() + * + * Add a page to the notebook + * + * notebook - existing notebook + * szName - name to give to the new page + * + */ +GtkWidget *add_page(GtkWidget *notebook, char *szName) +{ + GtkWidget *label; + /*GtkWidget *frame;*/ + GtkWidget *pageVbox; + + /* --- Create a label from the name. --- */ + label = gtk_label_new(szName); + gtk_widget_show(label); + + /* --- Create a frame for the page --- */ + /*frame = gtk_frame_new(szName);*/ + /*gtk_widget_show(frame);*/ + pageVbox = gtk_vbox_new(FALSE, 0); + gtk_widget_show(pageVbox); + + /* --- Add a page with the frame and label --- */ + /*gtk_notebook_append_page(GTK_NOTEBOOK(notebook), frame, label);*/ + gtk_notebook_append_page(GTK_NOTEBOOK(notebook), pageVbox, label); + + /*return (frame);*/ + return pageVbox; +} + + +/* + * + * create_notebook() + * + * Create a new notebook and add pages to it. + * + * window - window to create the notebook in. + * + */ +GtkWidget *create_notebook(GtkWidget *window, GtkPositionType pos) +{ + GtkWidget *box1; + GtkWidget *notebook; + + /* --- Let us know when getting destroyed. --- */ + gtk_signal_connect(GTK_OBJECT(window), "destroy", + GTK_SIGNAL_FUNC(gtk_widget_destroyed), + &window); + + /* --- Set border width --- */ + gtk_container_border_width(GTK_CONTAINER(window), 0); + + box1 = gtk_vbox_new(FALSE, 0); + gtk_container_add(GTK_CONTAINER(window), box1); + + /* --- Create the notebook --- */ + notebook = gtk_notebook_new(); + + /* --- Listen for the switch page event --- */ + gtk_signal_connect(GTK_OBJECT(notebook), "switch_page", + GTK_SIGNAL_FUNC(page_switch), NULL); + + /* --- Make sure tabs are set on correct side --- */ + gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), pos); + + /* --- Add notebook to vbox --- */ + gtk_box_pack_start(GTK_BOX(box1), notebook, TRUE, TRUE, 0); + + /* --- Give notebook a border --- */ + gtk_container_border_width(GTK_CONTAINER(notebook), 10); + + /* --- Show everything. --- */ + gtk_widget_show_all(window); + + return notebook; +} + + +/* + * + * preferences() + * + * Preferences dialog box + * + */ +void preferences() +{ + GtkWidget *dialog_window; + GtkWidget *dialogVbox; + GtkWidget *notebook; + GtkWidget *generalTab; + GtkWidget *diskImagesTab; + GtkWidget *fileViewerTab; + GtkWidget *compressionTab; + GtkWidget *filesTab; + GtkWidget *generalHbox; + GtkWidget *actionHbox; + GtkWidget *columnsFrame; + GtkWidget *generalLeftVbox; + GtkWidget *pathnameCb; + GtkWidget *typeCb; + GtkWidget *auxTypeCb; + GtkWidget *modDateCb; + GtkWidget *formatCb; + GtkWidget *sizeCb; + GtkWidget *ratioCb; + GtkWidget *packedCb; + GtkWidget *accessCb; + GtkWidget *defaultsButton; + GtkWidget *generalRightVbox; + GtkWidget *nufxArchivesFrame; + GtkWidget *filenameMungingFrame; + GtkWidget *systemFrame; + GtkWidget *miscellaneousFrame; + GtkWidget *nufxArchivesVbox; + GtkWidget *filenameMungingVbox; + GtkWidget *systemVbox; + GtkWidget *miscellaneousVbox; + GtkWidget *mimicShrinkitQuirksCb; + GtkWidget *handleBadMacArchivesCb; + GtkWidget *reduceErrorCheckingCb; + GtkWidget *displayDOS33FilenamesCb; + GtkWidget *showSpacesAsUnderscoresCb; + GtkWidget *fileTypeAssociationsButton; + GtkWidget *stripPathnamesWhenPastingFilesCb; + GtkWidget *beepWhenActionsCompleteSuccessfullyCb; + GtkWidget *generalRightSpacerBox; + GtkWidget *generalLeftSpacerBox; + GtkWidget *diskImagesVbox; + GtkWidget *generalFrame; + GtkWidget *prodosFrame; + GtkWidget *generalVbox; + GtkWidget *prodosVbox; + GtkWidget *confirmDiskImageFormatCb; + GtkWidget *defaultToReadOnlyCb; + GtkWidget *allowWriteAccessCb; + GtkWidget *allowLowerCaseLettersCb; + GtkWidget *useSparseAllocationCb; + GtkWidget *diskImagesSpacerBox; + GtkWidget *fileViewerVbox; + GtkWidget *convertersFrame; + GtkWidget *conversionOptionsFrame; + GtkWidget *convertersVbox; + GtkWidget *convertersHbox; + GtkWidget *convertersLeftVbox; + GtkWidget *convertersRightVbox; + GtkWidget *compressionVbox; + /*GtkWidget *spacerBox;*/ + GtkWidget *highASCIITextCb; + GtkWidget *cpmTextCb; + GtkWidget *pascalTextCb; + GtkWidget *pascalCodeCb; + GtkWidget *applesoftBASICCb; + GtkWidget *integerBASICCb; + GtkWidget *assemblySourceCb; + GtkWidget *proDOSFoldersCb; + GtkWidget *disassembleCodeCb; + GtkWidget *resourceForksCb; + GtkWidget *gwpTeachAWGSCb; + GtkWidget *eightBitWordProcessorCb; + GtkWidget *appleworksWPCb; + GtkWidget *appleworksDBCb; + GtkWidget *appleworksSSCb; + GtkWidget *hiresImagesCb; + GtkWidget *doubleHiresImagesCb; + GtkWidget *superHiresImagesCb; + GtkWidget *printShopGraphicsCb; + GtkWidget *macpaintImagesCb; + GtkWidget *relaxTypeCheckingOnGraphicsCb; + GtkWidget *scrollHorizontallyCb; + GtkWidget *highlightHexDumpColumnsCb; + GtkWidget *preferSyntaxHighlightingCb; + GtkWidget *disassembleBRKCOPCp; + GtkWidget *preferBWforHiresImagesCb; + GtkAdjustment *viewerFileSizeAdjustment; + GtkWidget *preferredDHRHbox; + GtkWidget *preferredDHRLabel; + GList *preferredDHRComboItems = NULL; + GtkWidget *preferredDHRCombo; + GtkWidget *viewerFileSizeHbox; + GtkWidget *viewerFileSizeLabel; + GtkWidget *viewerFileSizeSpinner; + GtkWidget *kBytesLabel; + GtkWidget *conversionOptionsVbox; + GtkWidget *defaultCompressionMethodLabel; + GtkWidget *noCompressionCb; + GtkWidget *squeezeCb; + GtkWidget *squeezeLabel; + GtkWidget *dynamicLZW1Cb; + GtkWidget *dynamicLZW1Label; + GtkWidget *dynamicLZW2Cb; + GtkWidget *dynamicLZW2Label; + GtkWidget *twelveBitLZCCb; + GtkWidget *twelveBitLZCLabel; + GtkWidget *sixteenBitLZCCb; + GtkWidget *sixteenBitLZCLabel; + GtkWidget *deflateCb; + GtkWidget *deflateLabel; + GtkWidget *bzip2Cb; + GtkWidget *bzip2Label; + GtkWidget *filesVbox; + GtkWidget *folderForTemporaryFilesLabel; + GtkWidget *ok_button; + GtkWidget *cancel_button; + GtkWidget *apply_button; + GtkWidget *help_button; + + /* --- Create the dialog --- */ + /*dialog_window = gtk_dialog_new();*/ + dialog_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); + + /* --- Trap the window close signal to release the grab --- */ + gtk_signal_connect(GTK_OBJECT(dialog_window), "destroy", + GTK_SIGNAL_FUNC(closing_dialog), + &dialog_window); + + /* --- Set the title --- */ + gtk_window_set_title(GTK_WINDOW(dialog_window), "Preferences"); + + /* --- Add a small border --- */ + gtk_container_border_width(GTK_CONTAINER(dialog_window), 5); + + /* --- Set the window size. --- */ + /*gtk_widget_set_usize(dialog_window, 500, 450);*/ + + /* --- Show the dialog --- */ + gtk_widget_show(dialog_window); + + dialogVbox = gtk_vbox_new(FALSE, 0); + gtk_container_add(GTK_CONTAINER(dialog_window), dialogVbox); + gtk_widget_show(dialogVbox); + + /*notebook = create_notebook(dialog_window, GTK_POS_TOP);*/ + notebook = create_notebook(dialogVbox, GTK_POS_TOP); + + /* --- Add pages to the notebook --- */ + generalTab = add_page(notebook, "General"); + diskImagesTab = add_page(notebook, "Disk Images"); + fileViewerTab = add_page(notebook, "File Viewer"); + compressionTab = add_page(notebook, "Compression"); + filesTab = add_page(notebook, "Files"); + + /* General tab */ + generalHbox = gtk_hbox_new(FALSE, 0); + + gtk_widget_show(generalHbox); + + gtk_container_add(GTK_CONTAINER(generalTab), generalHbox); + + columnsFrame = gtk_frame_new("Columns"); + + gtk_widget_show(columnsFrame); + + gtk_box_pack_start(GTK_BOX(generalHbox), columnsFrame, TRUE, TRUE, 0); + + /* Left side of general tab */ + generalLeftVbox = gtk_vbox_new(FALSE, 0); + + gtk_container_add(GTK_CONTAINER(columnsFrame), generalLeftVbox); + + gtk_widget_show(generalLeftVbox); + + pathnameCb = gtk_check_button_new_with_label("Pathname"); + typeCb = gtk_check_button_new_with_label("Type"); + auxTypeCb = gtk_check_button_new_with_label("Aux Type"); + modDateCb = gtk_check_button_new_with_label("Mod Date"); + formatCb = gtk_check_button_new_with_label("Format"); + sizeCb = gtk_check_button_new_with_label("Size"); + ratioCb = gtk_check_button_new_with_label("Ratio"); + packedCb = gtk_check_button_new_with_label("Packed"); + accessCb = gtk_check_button_new_with_label("Access"); + defaultsButton = gtk_button_new_with_label("Defaults"); + + gtk_box_pack_start(GTK_BOX(generalLeftVbox), pathnameCb, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(generalLeftVbox), typeCb, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(generalLeftVbox), auxTypeCb, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(generalLeftVbox), modDateCb, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(generalLeftVbox), formatCb, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(generalLeftVbox), sizeCb, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(generalLeftVbox), ratioCb, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(generalLeftVbox), packedCb, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(generalLeftVbox), accessCb, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(generalLeftVbox), defaultsButton, TRUE, TRUE, 0); + + gtk_widget_show(pathnameCb); + gtk_widget_show(typeCb); + gtk_widget_show(auxTypeCb); + gtk_widget_show(modDateCb); + gtk_widget_show(formatCb); + gtk_widget_show(sizeCb); + gtk_widget_show(ratioCb); + gtk_widget_show(packedCb); + gtk_widget_show(accessCb); + gtk_widget_show(defaultsButton); + + /* Left spacer */ + generalLeftSpacerBox = gtk_button_new_with_label(" "); + gtk_box_pack_start(GTK_BOX(generalLeftVbox), generalLeftSpacerBox, TRUE, TRUE, 0); + gtk_widget_show(generalLeftSpacerBox); + + /* Right side of general tab */ + generalRightVbox = gtk_vbox_new(FALSE, 0); + + gtk_box_pack_start(GTK_BOX(generalHbox), generalRightVbox, TRUE, TRUE, 0); + + gtk_widget_show(generalRightVbox); + + nufxArchivesFrame = gtk_frame_new("NuFX (ShrinkIt) archives"); + filenameMungingFrame = gtk_frame_new("Filename munging"); + systemFrame = gtk_frame_new("System"); + miscellaneousFrame = gtk_frame_new("Miscellaneous"); + + gtk_box_pack_start(GTK_BOX(generalRightVbox), nufxArchivesFrame, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(generalRightVbox), filenameMungingFrame, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(generalRightVbox), systemFrame, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(generalRightVbox), miscellaneousFrame, TRUE, TRUE, 0); + + gtk_widget_show(nufxArchivesFrame); + gtk_widget_show(filenameMungingFrame); + gtk_widget_show(systemFrame); + gtk_widget_show(miscellaneousFrame); + + nufxArchivesVbox = gtk_vbox_new(FALSE, 0); + filenameMungingVbox = gtk_vbox_new(FALSE, 0); + systemVbox = gtk_vbox_new(FALSE, 0); + miscellaneousVbox = gtk_vbox_new(FALSE, 0); + + gtk_container_add(GTK_CONTAINER(nufxArchivesFrame), nufxArchivesVbox); + gtk_container_add(GTK_CONTAINER(filenameMungingFrame), filenameMungingVbox); + gtk_container_add(GTK_CONTAINER(systemFrame), systemVbox); + gtk_container_add(GTK_CONTAINER(miscellaneousFrame), miscellaneousVbox); + + gtk_widget_show(nufxArchivesVbox); + gtk_widget_show(filenameMungingVbox); + gtk_widget_show(systemVbox); + gtk_widget_show(miscellaneousVbox); + + /* NuFX frame */ + mimicShrinkitQuirksCb = gtk_check_button_new_with_label("Mimic ShrinkIt Quirks"); + handleBadMacArchivesCb = gtk_check_button_new_with_label("Handle \"bad Mac\" archives"); + reduceErrorCheckingCb = gtk_check_button_new_with_label("Reduce error checking (not recommended)"); + + gtk_box_pack_start(GTK_BOX(nufxArchivesVbox), mimicShrinkitQuirksCb, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(nufxArchivesVbox), handleBadMacArchivesCb, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(nufxArchivesVbox), reduceErrorCheckingCb, TRUE, TRUE, 0); + + gtk_widget_show(mimicShrinkitQuirksCb); + gtk_widget_show(handleBadMacArchivesCb); + gtk_widget_show(reduceErrorCheckingCb); + + /* Filename munging frame */ + displayDOS33FilenamesCb = gtk_check_button_new_with_label("Display DOS 3.3 Filenames in lower case"); + showSpacesAsUnderscoresCb = gtk_check_button_new_with_label("Show spaces as underscores"); + + gtk_box_pack_start(GTK_BOX(filenameMungingVbox), displayDOS33FilenamesCb, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(filenameMungingVbox), showSpacesAsUnderscoresCb, TRUE, TRUE, 0); + + gtk_widget_show(displayDOS33FilenamesCb); + gtk_widget_show(showSpacesAsUnderscoresCb); + + /* System frame */ + fileTypeAssociationsButton = gtk_button_new_with_label("File type associations"); + + gtk_box_pack_start(GTK_BOX(systemVbox), fileTypeAssociationsButton, TRUE, TRUE, 0); + + gtk_widget_show(fileTypeAssociationsButton); + + /* Miscellaneous frame */ + stripPathnamesWhenPastingFilesCb = gtk_check_button_new_with_label("Strip pathnames when pasting files"); + beepWhenActionsCompleteSuccessfullyCb = gtk_check_button_new_with_label("Beep when actions complete successfully"); + + gtk_box_pack_start(GTK_BOX(miscellaneousVbox), stripPathnamesWhenPastingFilesCb, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(miscellaneousVbox), beepWhenActionsCompleteSuccessfullyCb, TRUE, TRUE, 0); + + gtk_widget_show(stripPathnamesWhenPastingFilesCb); + gtk_widget_show(beepWhenActionsCompleteSuccessfullyCb); + + /* Right spacer */ + generalRightSpacerBox = gtk_button_new_with_label(" "); + gtk_box_pack_start(GTK_BOX(generalRightVbox), generalRightSpacerBox, TRUE, TRUE, 0); + gtk_widget_show(generalRightSpacerBox); + + /* Disk images tab */ + diskImagesVbox = gtk_vbox_new(FALSE, 0); + + gtk_container_add(GTK_CONTAINER(diskImagesTab), diskImagesVbox); + + gtk_widget_show(diskImagesVbox); + + /* General frame */ + generalFrame = gtk_frame_new("General"); + + gtk_widget_show(generalFrame); + + gtk_box_pack_start(GTK_BOX(diskImagesVbox), generalFrame, TRUE, TRUE, 0); + + generalVbox = gtk_vbox_new(FALSE, 0); + + gtk_container_add(GTK_CONTAINER(generalFrame), generalVbox); + + gtk_widget_show(generalVbox); + + confirmDiskImageFormatCb = gtk_check_button_new_with_label("Confirm disk image format"); + + gtk_box_pack_start(GTK_BOX(generalVbox), confirmDiskImageFormatCb, TRUE, TRUE, 0); + + gtk_widget_show(confirmDiskImageFormatCb); + + defaultToReadOnlyCb = gtk_check_button_new_with_label("Default to read-only when opening volumes"); + + gtk_box_pack_start(GTK_BOX(generalVbox), defaultToReadOnlyCb, TRUE, TRUE, 0); + + gtk_widget_show(defaultToReadOnlyCb); + + allowWriteAccessCb = gtk_check_button_new_with_label("Allow write access to physical disk 0 (not recommended)"); + + gtk_box_pack_start(GTK_BOX(generalVbox), allowWriteAccessCb, TRUE, TRUE, 0); + + gtk_widget_show(allowWriteAccessCb); + + /* ProDOS frame */ + prodosFrame = gtk_frame_new("ProDOS"); + + gtk_widget_show(prodosFrame); + + gtk_box_pack_start(GTK_BOX(diskImagesVbox), prodosFrame, TRUE, TRUE, 0); + + prodosVbox = gtk_vbox_new(FALSE, 0); + + gtk_container_add(GTK_CONTAINER(prodosFrame), prodosVbox); + + gtk_widget_show(prodosVbox); + + allowLowerCaseLettersCb = gtk_check_button_new_with_label("Allow lower case letters and spaces in filenames"); + + gtk_box_pack_start(GTK_BOX(prodosVbox), allowLowerCaseLettersCb, TRUE, TRUE, 0); + + gtk_widget_show(allowLowerCaseLettersCb); + + useSparseAllocationCb = gtk_check_button_new_with_label("Use sparse allocation for empty blocks"); + + gtk_box_pack_start(GTK_BOX(prodosVbox), useSparseAllocationCb, TRUE, TRUE, 0); + + gtk_widget_show(useSparseAllocationCb); + + /* spacer */ + diskImagesSpacerBox = gtk_button_new_with_label(" "); + gtk_box_pack_start(GTK_BOX(diskImagesVbox), diskImagesSpacerBox, TRUE, TRUE, 0); + gtk_widget_show(diskImagesSpacerBox); + + /* File viewer Tab */ + fileViewerVbox = gtk_vbox_new(FALSE, 0); + + gtk_container_add(GTK_CONTAINER(fileViewerTab), fileViewerVbox); + + gtk_widget_show(fileViewerVbox); + + /* File viewer frames */ + convertersFrame = gtk_frame_new("Converters"); + + gtk_box_pack_start(GTK_BOX(fileViewerVbox), convertersFrame, TRUE, TRUE, 0); + + conversionOptionsFrame = gtk_frame_new("Conversion options"); + + gtk_box_pack_start(GTK_BOX(fileViewerVbox), conversionOptionsFrame, TRUE, TRUE, 0); + + gtk_widget_show(convertersFrame); + gtk_widget_show(conversionOptionsFrame); + + /* Converters frame */ + convertersVbox = gtk_vbox_new(FALSE, 0); + + gtk_container_add(GTK_CONTAINER(convertersFrame), convertersVbox); + + gtk_widget_show(convertersVbox); + + convertersHbox = gtk_hbox_new(FALSE, 0); + + gtk_widget_show(convertersHbox); + + gtk_box_pack_start(GTK_BOX(convertersVbox), convertersHbox, TRUE, TRUE, 0); + + convertersLeftVbox = gtk_vbox_new(FALSE, 0); + + gtk_box_pack_start(GTK_BOX(convertersHbox), convertersLeftVbox, TRUE, TRUE, 0); + + convertersRightVbox = gtk_vbox_new(FALSE, 0); + + gtk_box_pack_start(GTK_BOX(convertersHbox), convertersRightVbox, TRUE, TRUE, 0); + + gtk_widget_show(convertersVbox); + + gtk_widget_show(convertersHbox); + + gtk_widget_show(convertersRightVbox); + + gtk_widget_show(convertersLeftVbox); + + /* Left side of converters frame */ + highASCIITextCb = gtk_check_button_new_with_label("High-ASCII text"); + gtk_box_pack_start(GTK_BOX(convertersLeftVbox), highASCIITextCb, TRUE, TRUE, 0); + gtk_widget_show(highASCIITextCb); + + cpmTextCb = gtk_check_button_new_with_label("CP/M text"); + gtk_box_pack_start(GTK_BOX(convertersLeftVbox), cpmTextCb, TRUE, TRUE, 0); + gtk_widget_show(cpmTextCb); + + pascalTextCb = gtk_check_button_new_with_label("Pascal text"); + gtk_box_pack_start(GTK_BOX(convertersLeftVbox), pascalTextCb, TRUE, TRUE, 0); + gtk_widget_show(pascalTextCb); + + pascalCodeCb = gtk_check_button_new_with_label("Pascal code"); + gtk_box_pack_start(GTK_BOX(convertersLeftVbox), pascalCodeCb, TRUE, TRUE, 0); + gtk_widget_show(pascalCodeCb); + + applesoftBASICCb = gtk_check_button_new_with_label("Applesoft BASIC"); + gtk_box_pack_start(GTK_BOX(convertersLeftVbox), applesoftBASICCb, TRUE, TRUE, 0); + gtk_widget_show(applesoftBASICCb); + + integerBASICCb = gtk_check_button_new_with_label("Integer BASIC"); + gtk_box_pack_start(GTK_BOX(convertersLeftVbox), integerBASICCb, TRUE, TRUE, 0); + gtk_widget_show(integerBASICCb); + + assemblySourceCb = gtk_check_button_new_with_label("Assembly source"); + gtk_box_pack_start(GTK_BOX(convertersLeftVbox), assemblySourceCb, TRUE, TRUE, 0); + gtk_widget_show(assemblySourceCb); + + proDOSFoldersCb = gtk_check_button_new_with_label("ProDOS folders"); + gtk_box_pack_start(GTK_BOX(convertersLeftVbox), proDOSFoldersCb, TRUE, TRUE, 0); + gtk_widget_show(proDOSFoldersCb); + + disassembleCodeCb = gtk_check_button_new_with_label("Disassemble code"); + gtk_box_pack_start(GTK_BOX(convertersLeftVbox), disassembleCodeCb, TRUE, TRUE, 0); + gtk_widget_show(disassembleCodeCb); + + resourceForksCb = gtk_check_button_new_with_label("Resource forks"); + gtk_box_pack_start(GTK_BOX(convertersLeftVbox), resourceForksCb, TRUE, TRUE, 0); + gtk_widget_show(resourceForksCb); + + /* Right side of converters frame */ + gwpTeachAWGSCb = gtk_check_button_new_with_label("GWP (Teach, AWGS)"); + gtk_box_pack_start(GTK_BOX(convertersRightVbox), gwpTeachAWGSCb, TRUE, TRUE, 0); + gtk_widget_show(gwpTeachAWGSCb); + + eightBitWordProcessorCb = gtk_check_button_new_with_label("8-bit word processor"); + gtk_box_pack_start(GTK_BOX(convertersRightVbox), eightBitWordProcessorCb, TRUE, TRUE, 0); + gtk_widget_show(eightBitWordProcessorCb); + + appleworksWPCb = gtk_check_button_new_with_label("AppleWorks WP"); + gtk_box_pack_start(GTK_BOX(convertersRightVbox), appleworksWPCb, TRUE, TRUE, 0); + gtk_widget_show(appleworksWPCb); + + appleworksDBCb = gtk_check_button_new_with_label("AppleWorks DB"); + gtk_box_pack_start(GTK_BOX(convertersRightVbox), appleworksDBCb, TRUE, TRUE, 0); + gtk_widget_show(appleworksDBCb); + + appleworksSSCb = gtk_check_button_new_with_label("AppleWorks SS"); + gtk_box_pack_start(GTK_BOX(convertersRightVbox), appleworksSSCb, TRUE, TRUE, 0); + gtk_widget_show(appleworksSSCb); + + hiresImagesCb = gtk_check_button_new_with_label("Hi-Res images"); + gtk_box_pack_start(GTK_BOX(convertersRightVbox), hiresImagesCb, TRUE, TRUE, 0); + gtk_widget_show(hiresImagesCb); + + doubleHiresImagesCb = gtk_check_button_new_with_label("Double Hi-Res images"); + gtk_box_pack_start(GTK_BOX(convertersRightVbox), doubleHiresImagesCb, TRUE, TRUE, 0); + gtk_widget_show(doubleHiresImagesCb); + + superHiresImagesCb = gtk_check_button_new_with_label("Super Hi-Res images"); + gtk_box_pack_start(GTK_BOX(convertersRightVbox), superHiresImagesCb, TRUE, TRUE, 0); + gtk_widget_show(superHiresImagesCb); + + printShopGraphicsCb = gtk_check_button_new_with_label("Print Shop graphics"); + gtk_box_pack_start(GTK_BOX(convertersRightVbox), printShopGraphicsCb, TRUE, TRUE, 0); + gtk_widget_show(printShopGraphicsCb); + + macpaintImagesCb = gtk_check_button_new_with_label("MacPaint images"); + gtk_box_pack_start(GTK_BOX(convertersRightVbox), macpaintImagesCb, TRUE, TRUE, 0); + gtk_widget_show(macpaintImagesCb); + + /* Last one in converter frame */ + relaxTypeCheckingOnGraphicsCb = gtk_check_button_new_with_label("Relax type-checking on graphics"); + gtk_box_pack_start(GTK_BOX(convertersVbox), relaxTypeCheckingOnGraphicsCb, TRUE, TRUE, 0); + gtk_widget_show(relaxTypeCheckingOnGraphicsCb); + + /* Conversion options frame */ + conversionOptionsVbox = gtk_vbox_new(FALSE, 0); + + gtk_container_add(GTK_CONTAINER(conversionOptionsFrame), conversionOptionsVbox); + + gtk_widget_show(conversionOptionsVbox); + + scrollHorizontallyCb = gtk_check_button_new_with_label("Scroll horizontally instead of wrapping words"); + gtk_box_pack_start(GTK_BOX(conversionOptionsVbox), scrollHorizontallyCb, TRUE, TRUE, 0); + gtk_widget_show(scrollHorizontallyCb); + + highlightHexDumpColumnsCb = gtk_check_button_new_with_label("Highlight hex dump columns (small files)"); + gtk_box_pack_start(GTK_BOX(conversionOptionsVbox), highlightHexDumpColumnsCb, TRUE, TRUE, 0); + gtk_widget_show(highlightHexDumpColumnsCb); + + preferSyntaxHighlightingCb = gtk_check_button_new_with_label("Prefer syntax highlighting on BASIC programs"); + gtk_box_pack_start(GTK_BOX(conversionOptionsVbox), preferSyntaxHighlightingCb, TRUE, TRUE, 0); + gtk_widget_show(preferSyntaxHighlightingCb); + + disassembleBRKCOPCp = gtk_check_button_new_with_label("Disassemble BRK/COP as single-byte instructions"); + gtk_box_pack_start(GTK_BOX(conversionOptionsVbox), disassembleBRKCOPCp, TRUE, TRUE, 0); + gtk_widget_show(disassembleBRKCOPCp); + + preferBWforHiresImagesCb = gtk_check_button_new_with_label("Prefer B&W for hi-res images"); + gtk_box_pack_start(GTK_BOX(conversionOptionsVbox), preferBWforHiresImagesCb, TRUE, TRUE, 0); + gtk_widget_show(preferBWforHiresImagesCb); + + preferredDHRHbox = gtk_hbox_new(FALSE, 0); + + gtk_box_pack_start(GTK_BOX(conversionOptionsVbox), preferredDHRHbox, TRUE, TRUE, 0); + + gtk_widget_show(preferredDHRHbox); + + preferredDHRLabel = gtk_label_new("Preferred DHR"); + gtk_misc_set_alignment(GTK_MISC(preferredDHRLabel), 0, 0.5); + gtk_box_pack_start(GTK_BOX(preferredDHRHbox), preferredDHRLabel, TRUE, TRUE, 0); + gtk_widget_show(preferredDHRLabel); + + /* + * --- Create a list of the items first + */ + preferredDHRComboItems = g_list_append(preferredDHRComboItems, "Black & White"); + preferredDHRComboItems = g_list_append(preferredDHRComboItems, "Latched color (recommended)"); + preferredDHRComboItems = g_list_append(preferredDHRComboItems, "Simple 140"); + preferredDHRComboItems = g_list_append(preferredDHRComboItems, "Sliding window"); + + /* --- Make a combo box. --- */ + preferredDHRCombo = gtk_combo_new(); + + /* --- Create the drop down portion of the combo --- */ + gtk_combo_set_popdown_strings(GTK_COMBO(preferredDHRCombo), preferredDHRComboItems); + + /* --- Default the text in the field to a value --- */ + gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(preferredDHRCombo)->entry), "Latched color (recommended)"); + + /* --- Make the edit portion non-editable. They can pick a + * value from the drop down, they just can't end up with + * a value that's not in the drop down. + */ + gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(preferredDHRCombo)->entry), FALSE); + + gtk_box_pack_start(GTK_BOX(preferredDHRHbox), preferredDHRCombo, TRUE, TRUE, 0); + + gtk_widget_show(preferredDHRCombo); + + viewerFileSizeHbox = gtk_hbox_new(FALSE, 0); + + gtk_box_pack_start(GTK_BOX(fileViewerVbox), viewerFileSizeHbox, TRUE, TRUE, 0); + + gtk_widget_show(viewerFileSizeHbox); + + viewerFileSizeLabel = gtk_label_new("Viewer file size"); + gtk_misc_set_alignment(GTK_MISC(viewerFileSizeLabel), 0, 0.5); + gtk_box_pack_start(GTK_BOX(viewerFileSizeHbox), viewerFileSizeLabel, TRUE, TRUE, 0); + gtk_widget_show(viewerFileSizeLabel); + + viewerFileSizeAdjustment = (GtkAdjustment *)gtk_adjustment_new(1024, 0, 32767, 64, 64, 0); + viewerFileSizeSpinner = gtk_spin_button_new(viewerFileSizeAdjustment, 1.0, 5); + gtk_box_pack_start(GTK_BOX(viewerFileSizeHbox), viewerFileSizeSpinner, TRUE, TRUE, 0); + gtk_widget_show(viewerFileSizeSpinner); + + kBytesLabel = gtk_label_new("kBytes"); + gtk_misc_set_alignment(GTK_MISC(kBytesLabel), 0, 0.5); + gtk_widget_show(kBytesLabel); + gtk_box_pack_start(GTK_BOX(viewerFileSizeHbox), kBytesLabel, TRUE, TRUE, 0); + + + /* Compression tab */ + compressionVbox = gtk_vbox_new(FALSE, 0); + + gtk_container_add(GTK_CONTAINER(compressionTab), compressionVbox); + + gtk_widget_show(compressionVbox); + + defaultCompressionMethodLabel = gtk_label_new("Default compression method:"); + gtk_widget_show(defaultCompressionMethodLabel); + gtk_box_pack_start(GTK_BOX(compressionVbox), defaultCompressionMethodLabel, TRUE, TRUE, 0); + + noCompressionCb = gtk_check_button_new_with_label("No compression"); + gtk_box_pack_start(GTK_BOX(compressionVbox), noCompressionCb, TRUE, TRUE, 0); + gtk_widget_show(noCompressionCb); + + squeezeCb = gtk_check_button_new_with_label("Squeeze"); + gtk_box_pack_start(GTK_BOX(compressionVbox), squeezeCb, TRUE, TRUE, 0); + gtk_widget_show(squeezeCb); + + squeezeLabel = gtk_label_new("Uses a combination of RLE and Huffman.\rNot compatible with ProDOS 8 ShrinkIt."); + gtk_box_pack_start(GTK_BOX(compressionVbox), squeezeLabel, TRUE, TRUE, 0); + gtk_widget_show(squeezeLabel); + + dynamicLZW1Cb = gtk_check_button_new_with_label("Dynamic LZW/1"); + gtk_box_pack_start(GTK_BOX(compressionVbox), dynamicLZW1Cb, TRUE, TRUE, 0); + gtk_widget_show(dynamicLZW1Cb); + + dynamicLZW1Label = gtk_label_new("The compression method used by ProDOS 8 ShrinkIt."); + gtk_box_pack_start(GTK_BOX(compressionVbox), dynamicLZW1Label, TRUE, TRUE, 0); + gtk_widget_show(dynamicLZW1Label); + + dynamicLZW2Cb = gtk_check_button_new_with_label("Dynamic LZW/2 (recommended)"); + gtk_box_pack_start(GTK_BOX(compressionVbox), dynamicLZW2Cb, TRUE, TRUE, 0); + gtk_widget_show(dynamicLZW2Cb); + + dynamicLZW2Label = gtk_label_new("The compression method used by GS/ShrinkIt"); + gtk_box_pack_start(GTK_BOX(compressionVbox), dynamicLZW2Label, TRUE, TRUE, 0); + gtk_widget_show(dynamicLZW2Label); + + twelveBitLZCCb = gtk_check_button_new_with_label("12-bit LZC"); + gtk_box_pack_start(GTK_BOX(compressionVbox), twelveBitLZCCb, TRUE, TRUE, 0); + gtk_widget_show(twelveBitLZCCb); + + twelveBitLZCLabel = gtk_label_new("Compression used by UNIX \"compress\" command.\rNot compatible with ProDOS 8 ShrinkIt."); + gtk_box_pack_start(GTK_BOX(compressionVbox), twelveBitLZCLabel, TRUE, TRUE, 0); + gtk_widget_show(twelveBitLZCLabel); + + sixteenBitLZCCb = gtk_check_button_new_with_label("16-bit LZC"); + gtk_box_pack_start(GTK_BOX(compressionVbox), sixteenBitLZCCb, TRUE, TRUE, 0); + gtk_widget_show(sixteenBitLZCCb); + + sixteenBitLZCLabel = gtk_label_new("Compression used by UNIX \"compress\" command.\rNot compatible with ProDOS 8 ShrinkIt."); + gtk_box_pack_start(GTK_BOX(compressionVbox), sixteenBitLZCLabel, TRUE, TRUE, 0); + gtk_widget_show(sixteenBitLZCLabel); + + deflateCb = gtk_check_button_new_with_label("deflate"); + gtk_box_pack_start(GTK_BOX(compressionVbox), deflateCb, TRUE, TRUE, 0); + gtk_widget_show(deflateCb); + + deflateLabel = gtk_label_new("Uses a combination of RLE and Huffman.\rNot compatible with ProDOS 8 ShrinkIt."); + gtk_box_pack_start(GTK_BOX(compressionVbox), deflateLabel, TRUE, TRUE, 0); + gtk_widget_show(deflateLabel); + + bzip2Cb = gtk_check_button_new_with_label("Bzip2"); + gtk_box_pack_start(GTK_BOX(compressionVbox), bzip2Cb, TRUE, TRUE, 0); + gtk_widget_show(bzip2Cb); + + bzip2Label = gtk_label_new("Compression used by bzip2.\rNot compatible with any Apple II applications."); + gtk_box_pack_start(GTK_BOX(compressionVbox), bzip2Label, TRUE, TRUE, 0); + gtk_widget_show(bzip2Label); + + + /* Files tab */ + filesVbox = gtk_vbox_new(FALSE, 0); + + gtk_container_add(GTK_CONTAINER(filesTab), filesVbox); + + gtk_widget_show(filesVbox); + + folderForTemporaryFilesLabel = gtk_label_new("Folder for temporary files:"); + gtk_widget_show(folderForTemporaryFilesLabel); + gtk_box_pack_start(GTK_BOX(filesVbox), folderForTemporaryFilesLabel, TRUE, TRUE, 0); + + + /* spacer */ + /*spacerBox = gtk_button_new_with_label(" "); + gtk_box_pack_start(GTK_BOX(dialogVbox), spacerBox, TRUE, TRUE, 0); + gtk_widget_show(spacerBox);*/ + + /* Action area */ + actionHbox = gtk_hbox_new(FALSE, 0); + + gtk_widget_show(actionHbox); + + gtk_container_add(GTK_CONTAINER(dialogVbox), actionHbox); + + /* + * --- OK button + */ + + /* --- Create the "OK" button --- */ + ok_button = gtk_button_new_with_label("OK"); + + gtk_signal_connect(GTK_OBJECT(ok_button), "clicked", + GTK_SIGNAL_FUNC(okfunc_create_disk_image), + dialog_window); + + /* --- Allow "Cancel" to be a default --- */ + GTK_WIDGET_SET_FLAGS(ok_button, GTK_CAN_DEFAULT); + + /* --- Add the OK button to the bottom hbox2 --- */ + gtk_box_pack_start(GTK_BOX(actionHbox), ok_button, TRUE, TRUE, 0); + + /* --- Make the "OK" the default --- */ + gtk_widget_grab_default(ok_button); + + /* --- Make the button visible --- */ + gtk_widget_show(ok_button); + + /* + * --- Cancel button + */ + + /* --- Create the "Cancel" button --- */ + cancel_button = gtk_button_new_with_label("Cancel"); + + gtk_signal_connect(GTK_OBJECT(cancel_button), "clicked", + GTK_SIGNAL_FUNC(close_dialog), + dialog_window); + + /* --- Allow "Cancel" to be a default --- */ + GTK_WIDGET_SET_FLAGS(cancel_button, GTK_CAN_DEFAULT); + + /* --- Add the "Cancel" button to the dialog --- */ + gtk_box_pack_start(GTK_BOX(actionHbox), cancel_button, TRUE, TRUE, 0); + + /* --- Make the button visible. --- */ + gtk_widget_show(cancel_button); + + /* + * --- Apply button + */ + + /* --- Create the "Apply" button --- */ + apply_button = gtk_button_new_with_label("Apply"); + + gtk_signal_connect(GTK_OBJECT(apply_button), "clicked", + GTK_SIGNAL_FUNC(apply_func_preferences), + dialog_window); + + /* --- Add the "Apply" button to the dialog --- */ + gtk_box_pack_start(GTK_BOX(actionHbox), apply_button, TRUE, TRUE, 0); + + /* --- Make the button visible. --- */ + gtk_widget_show(apply_button); + + /* + * --- Help button + */ + + /* --- Create the "Help" button --- */ + help_button = gtk_button_new_with_label("Help"); + + gtk_signal_connect(GTK_OBJECT(help_button), "clicked", + GTK_SIGNAL_FUNC(help_func_preferences), + dialog_window); + + /* --- Add the "Help" button to the dialog --- */ + gtk_box_pack_start(GTK_BOX(actionHbox), help_button, TRUE, TRUE, 0); + + /* --- Make the button visible. --- */ + gtk_widget_show(help_button); + + /* --- Only this window can be used for now --- */ + gtk_grab_add(dialog_window); +} + diff --git a/save_to_file.c b/save_to_file.c new file mode 100644 index 0000000..3744fe8 --- /dev/null +++ b/save_to_file.c @@ -0,0 +1,17 @@ +#include +#include + +#include "calvados.h" + +/* + * + * save_to_file() + * + * Actually save data to a file + * + */ +void save_to_file(char *filename) +{ + g_print("Save to file goes here.\n"); +} + diff --git a/select_volume.c b/select_volume.c new file mode 100644 index 0000000..b8292c6 --- /dev/null +++ b/select_volume.c @@ -0,0 +1,204 @@ +#include +#include + +#include "calvados.h" + +enum { + COL_VOLUME_OR_DEVICE_NAME = 0, + COL_REMARK, + NUM_SELECT_VOLUME_COLS +}; + + +/* + * + * select_volume() + * + * Select volume dialog box + * + */ +void select_volume() +{ + GtkWidget *dialog_window; + GtkWidget *ok_button; + GtkWidget *cancel_button; + GtkWidget *help_button; + GtkWidget *showLabel; + GList *showComboItems = NULL; + GtkWidget *showCombo; + GtkWidget *showHbox; + GtkListStore *store; + /*GtkTreeIter iter;*/ + GtkCellRenderer *renderer; + GtkTreeModel *model; + GtkWidget *view; + GtkWidget *openAsReadOnlyCB; + + /* --- Create the dialog --- */ + dialog_window = gtk_dialog_new(); + + /* --- Trap the window close signal to release the grab --- */ + gtk_signal_connect(GTK_OBJECT(dialog_window), "destroy", + GTK_SIGNAL_FUNC(closing_dialog), + &dialog_window); + + /* --- Set the title --- */ + gtk_window_set_title(GTK_WINDOW(dialog_window), "Select Volume"); + + /* --- Add a small border --- */ + gtk_container_border_width(GTK_CONTAINER(dialog_window), 5); + + showHbox = gtk_hbox_new(FALSE, 0); + + showLabel = gtk_label_new("Show: "); + gtk_misc_set_alignment(GTK_MISC(showLabel), 0, 0.5); + + /* + * --- Create a list of the items first + */ + showComboItems = g_list_append(showComboItems, "Both logical and physical"); + showComboItems = g_list_append(showComboItems, "Logical volumes"); + showComboItems = g_list_append(showComboItems, "Physical disks"); + + /* --- Make a combo box. --- */ + showCombo = gtk_combo_new(); + + /* --- Create the drop down portion of the combo --- */ + gtk_combo_set_popdown_strings(GTK_COMBO(showCombo), showComboItems); + + /* --- Default the text in the field to a value --- */ + gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(showCombo)->entry), "Both logical and physical"); + + /* --- Make the edit portion non-editable. They can pick a + * value from the drop down, they just can't end up with + * a value that's not in the drop down. + */ + gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(showCombo)->entry), FALSE); + + gtk_box_pack_start(GTK_BOX(showHbox), showLabel, TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(showHbox), showCombo, TRUE, TRUE, 0); + + gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog_window)->vbox), showHbox, TRUE, TRUE, 0); + + gtk_widget_show(showLabel); + gtk_widget_show(showCombo); + gtk_widget_show(showHbox); + + store = gtk_list_store_new(NUM_SELECT_VOLUME_COLS, G_TYPE_STRING, G_TYPE_UINT); + +/*FIXME*/ + /* This needs to be in a loop reading from somewhere */ + /* Append a row and fill in some data */ + /*gtk_list_store_append(store, &iter); + gtk_list_store_set(store, &iter, + COL_VOLUME_OR_DEVICE_NAME, "", + COL_REMARK, "", + -1);*/ + + view = gtk_tree_view_new(); + + /* --- Column #1 --- */ + renderer = gtk_cell_renderer_text_new(); + gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), + -1, + "Volume or Device Name", + renderer, + "text", COL_VOLUME_OR_DEVICE_NAME, + NULL); + + /* --- Column #2 --- */ + renderer = gtk_cell_renderer_text_new(); + gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), + -1, + "Remark", + renderer, + "text", COL_REMARK, + NULL); + + model = GTK_TREE_MODEL(store); + + gtk_tree_view_set_model(GTK_TREE_VIEW(view), model); + + /* The tree view has acquired its own reference to the + * model, so we can drop ours. That way the model will + * be freed automatically when the tree view is destroyed */ + g_object_unref(model); + + gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog_window)->vbox), view, TRUE, TRUE, 0); + + gtk_widget_show(view); + + openAsReadOnlyCB = gtk_check_button_new_with_label("Open as read-only (writing to the volume will be disabled)"); + gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(openAsReadOnlyCB), TRUE); + + gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog_window)->vbox), openAsReadOnlyCB, TRUE, TRUE, 0); + + gtk_widget_show(openAsReadOnlyCB); + + /* + * --- OK button + */ + + /* --- Create the "OK" button --- */ + ok_button = gtk_button_new_with_label("OK"); + + gtk_signal_connect(GTK_OBJECT(ok_button), "clicked", + GTK_SIGNAL_FUNC(okfunc_select_volume), + dialog_window); + + /* --- Allow "Cancel" to be a default --- */ + GTK_WIDGET_SET_FLAGS(ok_button, GTK_CAN_DEFAULT); + + /* --- Add the OK button to the bottom hbox2 --- */ + gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog_window)->action_area), ok_button, TRUE, TRUE, 0); + + /* --- Make the "OK" the default --- */ + gtk_widget_grab_default(ok_button); + + /* --- Make the button visible --- */ + gtk_widget_show(ok_button); + + /* + * --- Cancel button + */ + + /* --- Create the "Cancel" button --- */ + cancel_button = gtk_button_new_with_label("Cancel"); + + gtk_signal_connect(GTK_OBJECT(cancel_button), "clicked", + GTK_SIGNAL_FUNC(close_dialog), + dialog_window); + + /* --- Allow "Cancel" to be a default --- */ + GTK_WIDGET_SET_FLAGS(cancel_button, GTK_CAN_DEFAULT); + + /* --- Add the "Cancel" button to the dialog --- */ + gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog_window)->action_area), cancel_button, TRUE, TRUE, 0); + + /* --- Make the button visible. --- */ + gtk_widget_show(cancel_button); + + /* + * --- Help button + */ + + /* --- Create the "Help" button --- */ + help_button = gtk_button_new_with_label("Help"); + + gtk_signal_connect(GTK_OBJECT(help_button), "clicked", + GTK_SIGNAL_FUNC(help_func_select_volume), + dialog_window); + + /* --- Add the "Help" button to the dialog --- */ + gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog_window)->action_area), help_button, TRUE, TRUE, 0); + + /* --- Make the button visible. --- */ + gtk_widget_show(help_button); + + /* --- Show the dialog --- */ + gtk_widget_show(dialog_window); + + /* --- Only this window can be used for now --- */ + gtk_grab_add(dialog_window); +} + diff --git a/show_about.c b/show_about.c new file mode 100644 index 0000000..eaf10c4 --- /dev/null +++ b/show_about.c @@ -0,0 +1,28 @@ +#include +#include + +/* + * + * show_about() + * + * Show the about box + * + */ +void show_about(GtkWidget *widget, gpointer data) +{ + GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file("images/calvados.png", NULL); + + GtkWidget *dialog = gtk_about_dialog_new(); + gtk_about_dialog_set_name(GTK_ABOUT_DIALOG(dialog), "Calvados"); + gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(dialog), "0.1"); + gtk_about_dialog_set_copyright(GTK_ABOUT_DIALOG(dialog),"(c) Leeland Heins"); + gtk_about_dialog_set_comments(GTK_ABOUT_DIALOG(dialog), + "Calvados is intended to be a work-alike of CiderPress for Linux."); + gtk_about_dialog_set_website(GTK_ABOUT_DIALOG(dialog), + "http://softwarejanitor.com"); + gtk_about_dialog_set_logo(GTK_ABOUT_DIALOG(dialog), pixbuf); + g_object_unref(pixbuf), pixbuf = NULL; + gtk_dialog_run(GTK_DIALOG(dialog)); + gtk_widget_destroy(dialog); +} +