/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.

 */

#include <ctype.h>

#include <math.h>

#include <gnome.h>

#include "orchestrator-wrappers.h"

#include "callbacks.h"

#include "interface-globals.h"

#include "window-graphics.h"

#include "disk-block-order.h"

#include "installation-disk-screen.h"

#include "installation-profile.h"

#include "error-logging.h"

/* Uncomment these 2 lines to simulate Sparc behaviour on X86 */

/* #define __sparc */

/* #undef __i386 */

#define	ONE_DECIMAL(x)	((round((x) * 10)) / 10.0)

typedef enum {

	DISK_STATUS_OK = 0,  /* Disk is fine for installation */

	DISK_STATUS_CANT_PRESERVE, /* Partition table is unreadable */

	DISK_STATUS_TOO_SMALL, /* Disk is too small - unusable */

	DISK_STATUS_NO_MEDIA, /* If size (in kb or mb = 0) */

	DISK_STATUS_NO_DISKINFO, /* Indicates target discovery error */

	DISK_STATUS_WARNING, /* Disk warning error */

	DISK_STATUS_LARGE_WARNING /* Disk > 2TB warning */

} DiskStatus;

/* Num of target disks found, including unusable ones */

static gint numdisks = 0;

/* Currently selected disk */

static gint activedisk = -1;

static gboolean activediskisreadable = FALSE;

static DiskStatus *alldiskstatus = NULL;

/* Ptr array of all disks - linked lists suck for random access */

static disk_info_t **alldiskinfo = NULL;

/*

 * Original reference copy of actual disk layout

 * (or the default layout if unreadable)

 */

static disk_parts_t **originalpartitions = NULL;

/* Working copy of the above. Customisations written here */

static disk_parts_t **modifiedpartitions = NULL;

/* Points to either one of the above */

static disk_parts_t **proposedpartitions = NULL;

/* A suggested layout that has one Solaris2 partition for the entire disk */

static disk_parts_t **defaultpartitions = NULL;

/* primaryblkorder and logicalblkorder for each disk */

static DiskBlockOrder **originalprimaryblkorder;

static DiskBlockOrder **modifiedprimaryblkorder;

static DiskBlockOrder **originallogicalblkorder;

static DiskBlockOrder **modifiedlogicalblkorder;

/* Max Width of Disk Combos */

static gint max_combo_width = 0;

/* Whether extended/logical Spinner has focus or not. */

static gboolean spinner_has_focus = FALSE;

/*

 * Signal handler id storage so we can easily block/unblock

 * the partitioning signal handlers that handle text insert

 * and delete events.

 */

static gulong spininserthandlers[FD_NUMPART] = {0, 0, 0, 0};

static gulong spindeletehandlers[FD_NUMPART] = {0, 0, 0, 0};

static GtkWidget *hbuttonbox;

static GtkWidget **diskbuttons;

static GtkAdjustment *viewportadjustment = NULL;

static GtkWidget *scanningbox = NULL;

static GtkIconTheme *icontheme;

/*

 * Partition type to string mappings.

 * Lifted straight out of fdisk.c

 */

static char Ostr[] = "Other OS"; /* New in fdisk.c */

static char Dstr[] = "DOS12";

static char D16str[] = "DOS16";

static char DDstr[] = "DOS-DATA";

static char EDstr[] = "EXT-DOS";

static char DBstr[] = "DOS-BIG";

static char PCstr[] = "PCIX";

static char Ustr[] = "UNIX System";

static char SUstr[] = "Solaris";

static char SU2str[] = "Solaris2";

static char X86str[] = "x86 Boot";

static char DIAGstr[] = "Diagnostic";

static char IFSstr[] = "IFS: NTFS";

static char AIXstr[] = "AIX Boot";

static char AIXDstr[] = "AIX Data";

static char OS2str[] = "OS/2 Boot";

static char WINstr[] = "Win95 FAT32";

static char EWINstr[] = "Ext Win95";

static char FAT95str[] = "FAT16 LBA";

static char EXTLstr[] = "EXT LBA";

static char LINUXstr[] = "Linux";

static char CPMstr[] = "CP/M";

static char NOV2str[] = "Netware 286"; /* New in fdisk.c */

static char NOVstr[] = "Netware 3.x+";

static char QNXstr[] = "QNX 4.x";

static char QNX2str[] = "QNX part 2";

static char QNX3str[] = "QNX part 3";

static char LINNATstr[] = "Linux native";

static char NTFSVOL1str[] = "NT volset 1";

static char NTFSVOL2str[] = "NT volset 2";

static char BSDstr[] = "BSD OS";

static char NEXTSTEPstr[] = "NeXTSTEP";

static char BSDIFSstr[] = "BSDI FS";

static char BSDISWAPstr[] = "BSDI swap"; /* New in fdisk.c */

static char EFIstr[] = "EFI";

static char Actvstr[] = "Active";   /* New in fdisk.c */

static char NAstr[] = "      "; /* New in fdisk.c */

static char Unused[] = "Unused";

static char Extended[] = "Extended";

static gchar *WarningLabelMarkup = N_("<span size=\"smaller\"><span font_desc=\"Bold\">Warning: </span> The data in this partition will be erased.</span>");

/* Forward declaration */

static void

disk_selection_set_active_disk(int disknum);

static void

disk_partitioning_set_from_parts_data(disk_info_t *diskinfo,

	disk_parts_t *partitions);

static GtkWidget *

create_diskbutton_icon(DiskStatus status, disk_info_t *diskinfo);

static void

set_diskbutton_icon(GtkWidget *button, GtkWidget *image);

static GtkWidget*

disk_toggle_button_new_with_label(const gchar *label,

	DiskStatus status, disk_info_t *diskinfo);

static void

disk_viewport_ui_init(GtkViewport *viewport);

static gchar*

disk_viewport_create_disk_tiptext(guint disknum);

static gchar *

disk_viewport_create_disk_label(guint disknum);

static void

disk_viewport_diskbuttons_init(GtkViewport *viewport);

static void

disk_comboboxes_ui_init(void);

static void

disk_comboboxes_ui_reset(void);

static void

disk_combobox_ui_init(GtkComboBox *combobox, gboolean is_primary);

static void

disk_combobox_ui_reset(GtkComboBox *combobox, gboolean is_primary);

static void

disk_partitioning_block_all_handlers(void);

static void

disk_partitioning_unblock_all_handlers(void);

static void

disk_partitioning_block_combox_handler(guint partindex);

static void

disk_partitioning_unblock_combox_handler(guint partindex);

static void

disk_partitioning_block_combobox_handlers(gint mask);

static void

disk_partitioning_unblock_combobox_handlers(gint mask);

static void

disk_partitioning_block_spinbox_handlers(gint mask);

static void

disk_partitioning_unblock_spinbox_handlers(gint mask);

static void

spinners_insert_text_filter(GtkEntry *widget,

	const gchar *newtext,

	gint length,

	gint *position,

	gpointer user_data);

static void

spinners_delete_text_filter(GtkEditable *widget,

	gint start_pos,

	gint end_pos,

	gpointer user_data);

static void

logical_spinners_insert_text_filter(GtkEntry *widget,

	const gchar *newtext,

	gint length,

	gint *position,

	gpointer user_data);

static void

logical_spinners_delete_text_filter(GtkEditable *widget,

	gint start_pos,

	gint end_pos,

	gpointer user_data);

static void

disk_partitioning_set_sensitive(gboolean sensitive);

static gboolean

disk_partitioning_button_focus_handler(GtkWidget *widget,

	GdkEventFocus *event,

	gpointer user_data);

static void

viewport_adjustment_changed(GtkAdjustment *adjustment,

	gpointer user_data);

static void

init_disk_status(void);

static DiskStatus

get_disk_status(guint disknum);

static disk_parts_t *

installation_disk_create_default_layout(disk_info_t *diskinfo);

static gboolean

partition_discovery_monitor(gpointer user_data);

static void

update_disk_partitions_from_ui(disk_parts_t *partitions);

static void

update_logical_disk_partitions_from_ui(disk_parts_t *partitions);

static gboolean

disk_is_too_big(disk_info_t *diskinfo);

static gint

get_max_cell_renderer_width(void);

static void

reset_primary_partitions(gboolean block_handlers);

static void

initialize_default_partition_layout(gint disknum);

static void

logical_partition_spinner_value_changed(GtkWidget *widget,

	gpointer user_data);

static void

logical_partition_combo_changed(GtkWidget *widget,

	gpointer user_data);

static gboolean

logical_partition_spinner_focus_in_handler(GtkWidget *widget,

	GdkEventFocus *event,

	gpointer user_data);

static gboolean

logical_partition_spinner_focus_out_handler(GtkWidget *widget,

	GdkEventFocus *event,

	gpointer user_data);

static void

set_logical_combo_sensitivity(gint pidx,

	gboolean sensitivity,

	gboolean set_all);

static gfloat

calculate_avail_space(DiskBlockOrder *startblkorder,

	gint partindex,

	partition_info_t *partinfo);

static LogicalPartition *

get_logical_partition_at_pos(gint index,

	LogicalPartition *startlogical);

static void

restore_unused_partitions(guint disk_num, disk_parts_t *partitions);

static void

update_primary_unused_partition_size_from_ui(disk_parts_t *partitions,

	gint pidx,

	gfloat diffgb);

static gfloat

get_extended_partition_min_size(disk_parts_t *partitions);

/* Real Glade XML referenced callbacks */

void

installationdisk_wholediskradio_toggled(GtkWidget *widget, gpointer user_data)

{

#if defined(__i386)

	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)) == FALSE)

		return;

	proposedpartitions[activedisk] = defaultpartitions[activedisk];

	gtk_widget_hide(

	    MainWindow.InstallationDiskWindow.custompartitioningvbox);

	gtk_widget_show(

	    MainWindow.InstallationDiskWindow.diskwarninghbox);

#endif

}

void

installationdisk_partitiondiskradio_toggled(GtkWidget *widget,

	gpointer user_data)

{

#if defined(__i386)

	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)) == FALSE)

		return;

	proposedpartitions[activedisk] = modifiedpartitions[activedisk];

	gtk_widget_hide(

	    MainWindow.InstallationDiskWindow.diskwarninghbox);

	gtk_widget_show(

	    MainWindow.InstallationDiskWindow.custompartitioningvbox);

#endif

}

static void

show_warning_message(GtkWidget *warning, gboolean show)

{

	if (show == TRUE)

		gtk_widget_show(warning);

	else

		gtk_widget_hide(warning);

}

static void

update_logical_data_loss_warnings(LogicalPartition *startlogical)

{

	LogicalPartition *curlogical;

	/*

	 * Cycle throught all logical partitions, showing/hiding

	 * Warning box as appropriate

	 */

	for (curlogical = startlogical;

	    curlogical != NULL;

	    curlogical = curlogical->next) {

		if (curlogical->sizechange || curlogical->typechange) {

			show_warning_message(curlogical->warningbox, TRUE);

		} else {

			show_warning_message(curlogical->warningbox, FALSE);

		}

	}

}

static void

update_data_loss_warnings(void)

{

	gint i = 0;

	static GtkWidget **warnings = NULL;

	if (!warnings) {

		warnings = g_new0(GtkWidget *, FD_NUMPART);

		for (i = 0; i < FD_NUMPART; i++)

			warnings[i] =

			    MainWindow.InstallationDiskWindow.partwarnbox[i];

	}

	/*

	 * Cycle through primary paritions, if partition type or size has

	 * changed then show warning message

	 */

	for (i = 0; i < FD_NUMPART; i++) {

		if (MainWindow.InstallationDiskWindow.parttypechanges[i] ||

		    MainWindow.InstallationDiskWindow.partsizechanges[i]) {

			show_warning_message(warnings[i], TRUE);

		} else {

			show_warning_message(warnings[i], FALSE);

		}

		/*

		 * If there is logical partitions defined, cycle through these

		 * And update warnings if type or size have changed here aswell

		 */

		if (MainWindow.InstallationDiskWindow.startlogical[i] != NULL) {

			update_logical_data_loss_warnings(

			    MainWindow.InstallationDiskWindow.startlogical[i]);

		}

	}

}

static void

set_range_avail_from_value(GtkSpinButton *spinner,

	GtkLabel *availlabel,

	gfloat fromval,

	gfloat toval)

{

	gchar *sizestr;

	if (spinner == NULL && availlabel == NULL) {

		return;

	}

	sizestr = g_strdup_printf("%.1f", toval);

	if (spinner != NULL) {

		gtk_spin_button_set_range(spinner, fromval,

		    fromval == 0 ? 0 : strtod(sizestr, NULL));

	}

	if (availlabel != NULL) {

		gtk_label_set_text(availlabel, sizestr);

		gtk_widget_show(GTK_WIDGET(availlabel));

	}

	g_free(sizestr);

}

static void

set_size_widgets_from_value(GtkSpinButton *spinner,

	GtkLabel *availlabel,

	gfloat size)

{

	gchar *sizestr;

	if (spinner == NULL && availlabel == NULL) {

		return;

	}

	sizestr = g_strdup_printf("%.1f", size);

	if (spinner != NULL) {

		gtk_spin_button_set_value(spinner, strtod(sizestr, NULL));

	}

	if (availlabel != NULL) {

		gtk_label_set_text(availlabel, sizestr);

		gtk_widget_show(GTK_WIDGET(availlabel));

	}

	g_free(sizestr);

}

static void

logical_partition_init(guint pidx,

	LogicalPartition *logicalpartition,

	gint top_attach,

	gint bottom_attach)

{

	g_return_if_fail(

	    MainWindow.InstallationDiskWindow.numpartlogical[pidx] > 0);

	/* Create type alignment */

	logicalpartition->typealign = gtk_alignment_new(0.5, 0.5, 1.0, 1.0);

	gtk_alignment_set_padding(GTK_ALIGNMENT(logicalpartition->typealign),

	    0,		/* Top Padding */

	    0,		/* Bottom Padding */

	    LOGICAL_COMBOBOX_INDENT,		/* Left Padding */

	    0);		/* Right Padding */

	/* Create and initialize type combo */

	logicalpartition->typecombo = gtk_combo_box_new();

	disk_combobox_ui_init(

	    GTK_COMBO_BOX(logicalpartition->typecombo), FALSE);

	logicalpartition->partcombosaved = UNUSED_PARTITION;

	logicalpartition->combochangehandler = g_signal_connect(

	    G_OBJECT(logicalpartition->typecombo),

	    "changed",

	    G_CALLBACK(logical_partition_combo_changed),

	    logicalpartition);

	g_signal_handler_block(

	    (gpointer *)logicalpartition->typecombo,

	    logicalpartition->combochangehandler);

	if (spinner_has_focus == TRUE) {

		gtk_widget_set_sensitive(logicalpartition->typecombo, FALSE);