#!/bin/bash
# mkdistro.sh - Constroi uma distro linux. Inspirado no Morphix
# Autor: Nelson Gomes da Silveira.<ngsilveira@gmail.com> 
# Equipe de desenvolvimento: 
#			nelsongs <ngsilveira@gmail.com>
#			katatau <katatau@epron.com.br>
#			drjesteves <drjesteves@yahoo.com.br>
# Primeira versao: 2005/06/27
# Versao atual: 2.5
# Ultima atualizacao: 2006/05/28

xhost + >/dev/null # Para o caso de seu terminal nao aceitar executar o xdialog no DISPLAY atual.
# Includes the mkdistrolib contents
source mkdistrolib

# Inicio da Area de Funcoes ============================================

# ================Funcoes de Definicao da Distro =================================

# Esta funcao verifica a existencia da estrutura de trabalho e, caso nao exista, as cria.
function check_folders {
# Raiz do local onde tudo sera trabalhado
[ ! -d "$ROOTDIR" ] && mkdir -p $ROOTDIR 
#Local onde serao geradas as isos finais das distros trabalhadas
[ ! -d "$ISODIR" ] && mkdir -p $ISODIR 
#Local onde sera gerada a distro
[ ! -d "$WORKDIR" ] && mkdir -p $WORKDIR 
#Local onde sera descomprimido e trabalhado o arquivo comprimido morphix (ou dream.mod)
[ ! -d "$BASEDIR" ] && mkdir -p $BASEDIR
#Local para onde serao copiados os arquivos base e modulos anteriores
[ ! -d "$BACKUPDIR" ] && mkdir -p $BACKUPDIR
#Local onde sera feita a remasterizacao do HD
[ ! -d "$HDREMASTERDIR" ] && mkdir -p $HDREMASTERDIR
#Local onde sera trabalhado os minimodulos
[ ! -d "$MINIDIR" ] && mkdir -p $MINIDIR
#Local onde sera trabalhado o arquivo miniroot.gz descomprimidos
[ ! -d "$MINIROOTDIR" ] && mkdir -p $MINIROOTDIR
#Local onde sera trabalhado o modulo principal da distro
[ ! -d "$MAINDIR" ] && mkdir -p $MAINDIR
#Local temporario 1
[ ! -d "$TEMPDIR1" ] && mkdir -p $TEMPDIR1
#Local temporario 2
[ ! -d "$TEMPDIR2" ] && mkdir -p $TEMPDIR2
}

# Esta funcao salva a configuracao escolhida em um arquivo, para posterior recuperacao.
function save_config {
cat <<EOF > $CURRENTDIR/$NAMEDISTRO.cfg
# Config file
DISTROTYPE=$DISTROTYPE
DISTROBRANCH=$DISTROBRANCH
WHEREROOT=$WHEREROOT
ROOTDIR=$ROOTDIR
ISODIR=$ISODIR
WORKDIR=$WORKDIR
BASEDIR=$BASEDIR
MAINDIR=$MAINDIR
MINIDIR=$MINIDIR
MINIROOTDIR=$MINIROOTDIR
BACKUPDIR=$BACKUPDIR
HDREMASTERDIR=$HDREMASTERDIR
NAMEDISTRO=$NAMEDISTRO
NAMEMOD=$NAMEMOD
NAMEISO=$NAMEISO
TEMPDIR1=$TEMPDIR1
TEMPDIR2=$TEMPDIR2
DIRMOD=$DIRMOD
EOF
}

#Esta funcao define a estrutura basica para a distro
function def_distro {
NAMEDISTRO=$($DIALOG --stdout --wrap --title "$T1"  --inputbox "Informe o nome do projeto: (Ex: DL_IceWM)" 8 60) 
choice
NAMEISO="$NAMEDISTRO.iso"
WHEREROOT=$($DIALOG --stdout --wrap --left --title "$T1"  --inputbox "Onde a distro sera construida? Se for em particao diferente forneca somente o dispositivo, sem a barra ( Ex: hdb2 ou sda6)" 14 60 "/") 
export WHEREROOT
if [ "$WHEREROOT" = "/" ]; then
  ROOTDIR="/$NAMEDISTRO"
elif [ $(echo $WHEREROOT | cut -c-2) = "hd" -o $(echo $WHEREROOT | cut -c-2) = "sd" ]; then
#  Caso não exista /media ou /mnt, cria-lo
  [ "$(find / -maxdepth 1 -mindepth 1 -type d | grep "$PART_DIR" | wc -l)" -ne 1 ] && mkdir "/$PART_DIR" 2>/dev/null
  [ ! -d "/$PART_DIR/$WHEREROOT" ] && mkdir -p "/$PART_DIR/$WHEREROOT" 2>/dev/null
  mount -rw /dev/"$WHEREROOT" "/$PART_DIR/$WHEREROOT" >/dev/null 2>/dev/null
  ROOTDIR="/$PART_DIR/$WHEREROOT/$NAMEDISTRO"
else
  ROOTDIR="/$WHEREROOT/$NAMEDISTRO"
fi
WORKDIR="$ROOTDIR/Work"              # Diretorio onde sera montada a distro final
ISODIR="$ROOTDIR/Iso"                # Onde as imagens isos serao criadas ou colocadas
BASEDIR="$ROOTDIR/Base"              # Onde a Base (arquivo morphix) sera descompactado
BACKUPDIR="$ROOTDIR/Backup"	     # Onde serao armazenados arquvos temporarios
HDREMASTERDIR="$ROOTDIR/hdremaster"  # Onde a remasterizcao do instalacao no hd sera gerada
MAINDIR="$ROOTDIR/Main"	             # Onde o modulo principal sera descompactado e trabalhado
MINIDIR="$ROOTDIR/Mini" 	     # Onde o minimodulo sera descompactado e trabalhado
MINIROOTDIR="$ROOTDIR/Miniroot"      # Onde o miniroot.gz sera descompactado e trabalhado
TEMPDIR1="$ROOTDIR/Temp1"	     # Onde arquivos temporarios serao gerados/guardados
TEMPDIR2="$ROOTDIR/Temp2"	     # Onde arquivos temporarios serao gerados/guardados

DISTROFAMILY=$($DIALOG --stdout --wrap --title "$T1"  --radiolist "Informe a familia da distro" 13 60 3 \
"a"  "Morphix" 	on	\
"b"  "Knoppix" 	off	\
"c"  "Mepis"	off)
choice
case "$DISTROFAMILY" in
 "a") DISTROBRANCH="Morphix"
      NAMEMOD="$NAMEDISTRO.mod"
      DIRMOD="mainmod"
  ;;
 "b") DISTROBRANCH="Knoppix"
      NAMEMOD="KNOPPIX"
      DIRMOD="KNOPPIX"
  ;;
 "c") DISTROBRANCH="Mepis"
      NAMEMOD="linux"
      DIRMOD="linux"
  ;;
esac
export WHEREROOT ROOTDIR WORKDIR MAINDIR MINIDIR ISODIR BASEDIR MINIROOTDIR BACKUPDIR HDREMASTERDIR NAMEDISTRO NAMEISO DISTROBRANCH NAMEMOD TEMPDIR1 TEMPDIR2 DIRMOD
check_folders
save_config 
}

# ========= Funcoes verificam/criam a estrutura basica para a montagem da distro =========

# Verifica a existencia da estrutura da base
function verify_existing_base {
if [ ! -d "$WORKDIR/base" ]; then #Nao ha estrutura base montada
 check_folders
 WHICHBASE=$($DIALOG --stdout --wrap --title "$T1"  --radiolist "Escolha de onde o modulo base sera extraido." 19 85 5	\
 "a"  "De uma imagem iso da Base em seu HD" 					on	\
 "b"  "De uma imagem iso de distro gravada em seu HD" 				off	\
 "c"  "De uma distro gravada em CD-ROM/CD-RW" 					off	\
 "d"  "Do repositorio oficial na internet (www.dreamlinux.com.br/downloads)" 	off 	\
 "e"  "Sem modulo Base" 							off)
 choice
 case "$WHICHBASE" in
 "a") #Extrairah de uma imagem iso da base presente no hd local
 	$DIALOG --title "$T1" --wrap --left --msgbox "No dialogo a seguir, localize o caminho completo para a imagem ISO do modulo base em seu HD" 10 75
	choice
 	BASE=$($DIALOG --stdout --no-buttons --title "$T1" --fselect "/" 30 75)
  	choice
  	LOCBASE=$(dirname $BASE)
  	NAMEBASE=$(basename $BASE)
  	echo "Descompactando $NAMEBASE em $WORKDIR. Aguarde..."
	explode_iso $BASE $WORKDIR
  ;;
  "b") #Extrairah de uma imagem iso de distro, gravada em seu HD
 	$DIALOG --title "$T1" --wrap --left --msgbox "No dialogo a seguir, localize o caminho completo para a imagem da distro em seu HD" 10 75
	choice
 	DISTROIMG=$($DIALOG --stdout --no-buttons --title "$T1" --fselect "/" 30 75)
  	choice
  	LOCDISTROIMG=$(dirname $DISTROIMG)
  	NAMEDISTROIMG=$(basename $DISTROIMG)
  	echo "Descompactando $NAMEDISTROIMG em $WORKDIR. Aguarde..."
	if [ "$DISTROBRANCH" = "Morphix" ]; then
	  explode_iso $DISTROIMG $WORKDIR
  	  [ -f $WORKDIR/$DIRMOD/* ] && rm -f $WORKDIR/$DIRMOD/*
	  [ -f $WORKDIR/minimod/* ] && rm -f $WORKDIR/minimod/*
	  [ -d $WORKDIR/copy/* ] && rm -rf $WORKDIR/copy/*
	  [ -f $WORKDIR/copy/* ] && rm -f $WORKDIR/copy/*
	  [ -f $WORKDIR/deb/* ] && rm -f $WORKDIR/deb/*
	  [ -f $WORKDIR/exec/* ] && rm -f $WORKDIR/exec/*
	else
	  mkdir /tmp/tempiso/
 	  mount -o loop $DISTROIMG /tmp/tempiso/
	  rsync -a --exclude "/$DIRMOD/$NAMEMOD" /tmp/tempiso/ $WORKDIR
	  umount /tmp/tempiso
 	  rmdir /tmp/tempiso
	fi
  ;;
 "c") #Extrairah de um CD-ROM/CD-RW
	CDMOUNT=$($DIALOG --stdout --wrap --left --title "$T1"  --inputbox "Forneca um ponto de montagem para o CD-ROM" 12 75 "/media/cdrom")
	[ ! -d "$CDMOUNT" ] && mkdir -p $CDMOUNT 2>/dev/null
	PMOUNT=$(basename $CDMOUNT)
	mount /dev/$PMOUNT $CDMOUNT 2>/dev/null
	echo "Copiando a estrutura Base de $CDMOUNT para $WORKDIR. Aguarde..."
	#No caso de adistro ser knoppix-like
	if [ "$DISTROBRANCH" = "Morphix" ]; then
	  cp -Rp $CDMOUNT/* $WORKDIR/
	  [ -f $WORKDIR/$DIRMOD/* ] && rm -f $WORKDIR/$DIRMOD/*
	  [ -f $WORKDIR/minimod/* ] && rm -f $WORKDIR/minimod/*
	  [ -d $WORKDIR/copy/* ] && rm -rf $WORKDIR/copy/*
	  [ -f $WORKDIR/copy/* ] && rm -f $WORKDIR/copy/*
	  [ -f $WORKDIR/deb/* ] && rm -f $WORKDIR/deb/*
	  [ -f $WORKDIR/exec/* ] && rm -f $WORKDIR/exec/*
	else
	  rsync -a --exclude "/$DIRMOD/$NAMEMOD" $CDMOUNT/ $WORKDIR
	fi
  ;;	
 "d") # Extrairah do repositorio oficial em www.dreamlinux.com.br/downloads
  	cd $CURRENTDIR
	CHOSENBASE=$($DIALOG --stdout --wrap --left --title "$T1"  --inputbox "Forneca o nome da base, existente em $SOURCENET que deseja instalar." 12 75 "DLBase-2.6.14-kanotix-9.iso")
	choice
	echo "Baixando $CHOSENBASE de $SOURCENET em $CURRENTDIR"
  	wget $SOURCENET/baseisos/$CHOSENBASE
  	LOCBASE=$CURRENTDIR
  	NAMEBASE=$CHOSENBASE
  	echo "Descompactando $NAMEBASE em $WORKDIR. Aguarde..."
	explode_iso $NAMEBASE $WORKDIR
  ;;
  "e")  ;;
  esac 
fi
}

function populate ()
{
TYPE_ACTION=$($DIALOG --stdout --wrap --left --title "$T1" --cancel-label "Cancela" --radiolist "Escolha o tipo de atividade:" 13 75 6 \
"a"   "Copie diretorios para a pasta /copy" on	\
"b"   "Copie pacotes deb para serem instalados durante o boot" off  \
"c"   "Copie scripts para serem executados no boot" off \
"d"   "Copie modulos principais para a sua Distro." off \
"e"   "Copie minimodulos para a sua Distro" off \
"x"   "Voltar" off)
case $TYPE_ACTION in
"a")	$DIALOG --wrap --left --title "$T1" --msgbox "Na janela de dialogo que segue localize o diretorio que deseja copiar.\n" 12 75
DIR2COPY=$($DIALOG --stdout --no-buttons --cancel-label "Sair" --title "$T1" --dselect "/" 25 75)
choice
	if [ $? -eq 0 ] ; then
  	  echo "Copiando a pasta $DIR2COPY para $WORKDIR/copy..."
  	  cp -Rfp $DIR2COPY $WORKDIR/copy/
  	  $DIALOG --wrap --title "$T1" --msgbox "Sua pasta foi copiada com sucesso!" 10 75
	fi
;;
"b")	$DIALOG --wrap --left --title "$T1" \
--msgbox "\nNa janela de dialogo que segue localize o pacote .deb que deseja que seja instalado no boot.\n" 13 75  
	DEB2COPY=$($DIALOG --stdout --no-buttons --cancel-label "Sair" --title "$T1" --fselect "/" 25 75)
	choice
	if [ $? -eq 0 ] ; then
  	  LOCDEB2COPY=$(dirname $DEB2COPY)
  	  NAMEDEB2COPY=$(basename $DEB2COPY)
  	  echo "Copiando o pacote .deb $NAMEDEB2COPY para $WORKDIR/deb..."
  	  cp $LOCDEB2COPY/$NAMEDEB2COPY $WORKDIR/deb/
  	  $DIALOG --wrap --title "$T1" --msgbox "Seu pacote .deb foi copiado com sucesso!" 10 75
	fi
;;
"c")	$DIALOG --wrap --left --title "$T1" --msgbox "\nNa janela de dialogo que segue localize o script que deseja que seja executado no boot.\n" 13 75
	SCRIPT2COPY=$($DIALOG --stdout --no-buttons --cancel-label "Sair" --title "$T1" --fselect "/" 25 75)
	choice
	if [ $? -eq 0 ] ; then
 	  LOCSCRIPT2COPY=$(dirname $SCRIPT2COPY)
 	  NAMESCRIPT2COPY=$(basename $SCRIPT2COPY)
  	  echo "Copiando o script $NAMESCRIPT2COPY para $WORKDIR/exec..."
  	  cp $LOCSCRIPT2COPY/$NAMESCRIPT2COPY $WORKDIR/exec/
 	  $DIALOG --wrap --title "$T1" --msgbox "Seu script foi copiado com sucesso!" 10 75
	fi
;;
"d")	$DIALOG --wrap --left --title "$T1" --msgbox "\nNa janela de dialogo que segue localize o modulo principal que deseja copiar.\n" 13 75  
	choice
	MAINMOD2COPY=$($DIALOG --stdout --no-buttons --cancel-label "Sair" --title "$T1" --fselect "/" 30 75)
	choice
	if [ $? -eq 0 ] ; then
 	  LOCMAINMOD2COPY=$(dirname $MAINMOD2COPY)
 	  NAMEMAINMOD2COPY=$(basename $MAINMOD2COPY)
 	  progressBar $MAINMOD2COPY $WORKDIR/mainmod
 	  $DIALOG --wrap --title "$T1" --msgbox "Seu modulo foi copiado com sucesso!" 10 75
	fi
;;
"e")	$DIALOG --wrap --left --title "$T1" --msgbox "\nNa janela de dialogo que segue localize o mini-modulo que deseja copiar.\n" 13 75  
	choice
	MINIMOD2COPY=$($DIALOG --stdout --no-buttons --cancel-label "Sair" --title "$T1" --fselect "/" 25 75)
	choice
	if [ $? -eq 0 ] ; then
 	  LOCMINIMOD2COPY=$(dirname $MINIMOD2COPY)
 	  NAMEMINIMOD2COPY=$(basename $MINIMOD2COPY)
 	  echo "Copiando o mini-modulo $NAMEMINIMOD2COPY para $WORKDIR/minimod"
 	  cp $MINIMOD2COPY $WORKDIR/minimod/
 	  $DIALOG --wrap --title "$T1" --msgbox "Seu mini-modulo foi copiado com sucesso!" 10 75
	fi
;;
"x") : ;;
esac
}

# ===========  Funcoes de apoio para trabalhar no modulo principal ==================
function do_dream_frame {
[ ! -d "$MAINDIR/$IMG_CD" ] && mkdir $MAINDIR/$IMG_CD 
[ ! -d "$MAINDIR/UNION" ] && mkdir $MAINDIR/UNION  # nelsongs
#[ ! -d "$WORKDIR/cdrom" ] && mkdir $WORKDIR/cdrom
#[ ! -d "$WORKDIR/floppy" ] && mkdir $WORKDIR/floppy
[ -f "$MAINDIR/etc/dreaminstalled" ] && rm -f $MAINDIR/etc/dreaminstalled
echo "no" > $MAINDIR/etc/dreaminstalled  #cria uma sinalização para verificar se o sistema esta instalado ou nao 
cd $CURRENTDIR
if [ ! -f "$MAINDIR/etc/hosts" ]; then
  touch $MAINDIR/etc/hosts
  echo "127.0.0.1	localhost.localdomain	localhost	$NAMEHOST" >> $MAINDIR/etc/hosts
  echo " " >> $MAINDIR/etc/hosts
  echo "The following lines are desirable for IPV6 capable hosts" >> $MAINDIR/etc/hosts
  echo "::1		ip6-localhost	ip6-loopback" >> $MAINDIR/etc/hosts
  echo "fe00::0	ip6-localnet" >> $MAINDIR/etc/hosts
  echo "ff00::0	ip6-mcastprefix" >> $MAINDIR/etc/hosts
  echo "ff02::1	ip6-allnodes" >> $MAINDIR/etc/hosts
  echo "ff02::2	ip6-allrouters" >> $MAINDIR/etc/hosts
  echo "ff02::3	ip6-allhosts" >> $MAINDIR/etc/hosts
fi
[ ! -f "$MAINDIR/etc/apt/sources.list" ] && touch $MAINDIR/etc/apt/sources.list
if [ -z "$MAINDIR/etc/apt/sources.list" ]; then
 echo "deb http://ftp.us.debian.org/debian unstable main contrib non-free" >> $MAINDIR/etc/apt/sources.list
 echo "deb http://www.morphix.org/debian ./" >> $MAINDIR/etc/apt/sources.list
 echo "#deb http://www.dreamlinux.com.br/debian ./" >> $MAINDIR/etc/apt/sources.list
fi
if [ ! -f "etc/apt/preferences" ]; then 
  touch $MAINDIR/etc/apt/preferences
#  echo "#Package: *" >> $MAINDIR/etc/apt/preferences
#  echo "#Pin: origin www.os-works.com" >> $MAINDIR/etc/apt/preferences
#  echo "#Pin-Priority: 999" >> $MAINDIR/etc/apt/preferences
fi
}

function set_existingmainmod {
$DIALOG --wrap --title "$T1" --msgbox "Informe o modulo principal que sera descompactado, no dialogo que abrira em seguida" 10 75
MAINMOD=$($DIALOG --stdout --no-buttons --title "$T1" --fselect $1 30 75) 
export MAINMOD
echo "Descompactando $MAINMOD em $MAINDIR. Aguarde..."
uncompress_module $MAINMOD $MAINDIR
cd $CURRENTDIR
}

# Construcao do modulo principal, a partir de um modulo pre-existente
function set_newmainmod {
if [ ! -d "$MAINDIR/bin" ]; then 
  WHICHMAIN=$($DIALOG --stdout --wrap --title "$T1"  --radiolist "Escolha de onde o modulo principal sera obtido." 20 85 5	\
 "a"  "De uma imagem comprimida (cloop, squashfs, tar.gz ou tar.bz2) em disco rigido local" on 	\
 "b"  "De uma imagem iso"  off								\
 "c"  "De um CD-ROM/CD-RW" off								\
 "d"  "Do repositorio oficial na internet (www.dreamlinux.com.br/downloads)" off	\
 "x"  "Ir para o Menu Principal" off)				
 case $WHICHMAIN in
   "a") set_existingmainmod "/"
   	[ "$DISTROBRANCH" = "Morphix" ] && do_dream_frame ;;
   "b") $DIALOG --stdout --wrap --title "$T1" \
	--msgbox "Localize a imagem iso, no dialogo que abrira em seguida" 12 75
	ISOIMG=$($DIALOG --stdout --no-buttons --title "$T1" --fselect "/" 25 75)
	mkdir /tmp/iso /tmp/temp1
	mount -o loop $ISOIMG /tmp/iso
	if [ "$DISTROBRANCH" = "Morphix" ]; then
	  cp -p /tmp/iso/mainmod/*.mod /tmp/temp1/
	  MODIMG=/tmp/temp1/*.mod
	else
	  cp -p /tmp/iso/$DIRMOD/$NAMEMOD /tmp/temp1/
	  MODIMG=/tmp/temp1/"$NAMEMOD"
	fi
	umount /tmp/iso
	rmdir /tmp/iso
	rmdir /tmp/temp1
	COMP=""
  	module_type $MODIMG
  	case $COMP in
   	"cloop") if [ -f "$CLOOP_DEV" -a -b "/dev/cloop" ]; then  #Possui suporte a cloop no kernel
                   mkdir /tmp/cloop 2>/dev/null
	           insmod $CLOOP_DEV file=$MODIMG
	           mount /dev/cloop -o ro /tmp/cloop/
	           cp -a /tmp/cloop/* $MAINDIR/
	           $DIALOG --wrap --left --title "$T1" --msgbox "O modulo $MODIMG foi copiado com sucesso em $MAINDIR." 12 75
	           umount /tmp/cloop/
	           rmmod cloop
	           rmdir /tmp/cloop
	         elif [ -f "/usr/bin/extract_compressed_fs" ]; then # Possui cloop_utils instalado
	           mkdir /tmp/cloop1 /tmp/cloop2 2>/dev/null
  	           extract_compressed_fs $MODIMG > /tmp/cloop1/main.iso 2>/dev/null 
  	           mount -o loop /tmp/cloop1/main.iso /tmp/cloop2/
		   cp -a /tmp/cloop2/* $MAINDIR/
		   $DIALOG --wrap --left --title "$T1" --msgbox "O modulo $MODIMG foi copiado com sucesso em $MAINDIR." 12 75
		   umount /tmp/cloop2/
	           rm -f /tmp/cloop1/main.iso
	           rmdir /tmp/cloop1 /tmp/cloop2
	         else
	           $DIALOG --wrap --left --title "$T1" --msgbox "Voce nao possui os modulos cloop-module e cloop-utils instalados. Por favor, instale-os e retorne para  esta atividade." 12 75
	         fi
   	;;
   	"squashfs") mkdir /tmp/squash 2>/dev/null
	       	    mount -t squashfs $MODIMG /tmp/squash -o loop,ro
		    cp -a /tmp/squash/* $MAINDIR/
	            $DIALOG --wrap --left --title "$T1" --msgbox "O modulo $MODIMG foi copiado com sucesso em $MAINDIR." 12 75
	            umount /tmp/squash
	            rmdir /tmp/squash
   	;;
        esac
   ;;
   "c")	#Extrairah de um CD-ROM/CD-RW
 	CDMOUNT=$($DIALOG --stdout --wrap --left --title "$T1"  --inputbox "Forneca o ponto de montagem do CD-ROM" 12 75 "/media/cdrom")
	[ ! -d "$CDMOUNT" ] && mkdir -p $CDMOUNT 2>/dev/null
	PMOUNT=$(basename $CDMOUNT)
	mount /dev/$PMOUNT $CDMOUNT 2>/dev/null	
        set_existingmainmod $CDMOUNT
	$DIALOG --stdout --wrap --left --title "$T1"  --yesno "Deseja desmontar $CDMOUNT e ejetar o CD?" 12 75
	[ "$?" -eq 0 ] && umount $CDMOUNT && eject /dev/$PMOUNT
   ;;
   "d")	MAIN=$($DIALOG --stdout --title "$T1" --inputbox "Forneca o caminho completo do modulo principal a ser baixado de $SOURCENET. (Ex: basicmainmods/sidmainx.tar.bz2)." 10 75)
	MAINFILE=$(basename $MAIN)
	MAINFOLDER=$(dirname $MAIN)
    	export MAINFILE MAINFOLDER
    	echo "Baixando $MAINFILE de $SOURCENET e descompactando em $MAINDIR. Aguarde..."    
    	wget $SOURCENET/$MAINFOLDER/$MAINFILE
    	decompress_module $MAINFILE $MAINDIR
    	mv $MAINFILE $CURRENTDIR/ 
	[ "$DISTROBRANCH" = "Morphix" ] && do_dream_frame 
   ;;	
   "x") ;;
 esac  
fi
}

# Instala, desinstala e visualiza os pacotes instalados no ambiente chroot
function works_main {
# Verifica a existencia de /morphix em $MAINDIR, caso negativo, copia de /etc
if [ ! -d "$1/$CONTROL_DIR" ]; then
  [ -d "$1/etc/$CONTROL_DIR" ] && mv $1/etc/$CONTROL_DIR/ $1/
fi
cp -fp $CURRENTDIR/mkdistro_main.sh $1/usr/local/bin
cp -fp /etc/resolv.conf $1/etc/ 
#mount --bind /etc/fstab $MAINDIR/etc/fstab
#mount --bind /etc/mtab $MAINDIR/etc/mtab
[ ! -f /usr/bin/X11/Xnest ] && apt-get --force-yes install xnest
Xnest :1 -geometry 790x540 & >/dev/null 2>/dev/null
xnestid=$!
skel_to_root $1  #Copia o conteudo de /etc/skel para /root
mount -t proc /proc $1/proc
chroot $1 /usr/local/bin/mkdistro_main.sh
umount $1/proc
kill $xnestid
root_to_skel $1  #Copia o conteudo de /root para /etc/skel
rm -f $1/usr/local/bin/mkdistro_main.sh
#umount $MAINDIR/etc/fstab
#umount $MAINDIR/etc/mtab
rm -f $1/etc/resolv.conf
touch $1/etc/resolv.conf
}

# Simplesmente acessa o ambiente chroot para trabalhos
function chroot_main {
# Verifica a existencia de /morphix em $MAIN, caso negativo, copia de /etc
if [ ! -d "$1/$CONTROL_DIR" ]; then
  [ -d "$1/etc/$CONTROL_DIR" ] && mv $1/etc/$CONTROL_DIR/ $1/
fi
cp -fp /etc/resolv.conf $1/etc/ 
[ ! -f /usr/bin/X11/Xnest ] && apt-get --force-yes install xnest
Xnest :1 -geometry 790x540 & >/dev/null 2>/dev/null
xnestid=$!
clear
skel_to_root $1
echo "Entrando no ambiente chroot do modulo Principal. Bom trabalho..." 
mount -t proc /proc $1/proc
chroot $1 /bin/bash  
umount $1/proc
kill $xnestid
root_to_skel $1 
rm -f $1/etc/resolv.conf
touch $1/etc/resolv.conf
}

function build_main_img {
TYPE_MOD=$($DIALOG --stdout --wrap --left --title "$T1" --cancel-label "Cancela" --radiolist "Defina o tipo de modulo desejado:" 12 75 2 \
"a"   "Modulo principal da Distro, comprimido em squashfs" on	\
"b"   "Modulo principal da Distro, comprimido em cloop" off  \
"c"   "Modulo generico" off)
case $TYPE_MOD in
"a")    cp -fp $CURRENTDIR/mkdistro_clean.sh $MAINDIR/usr/local/bin/ 
	chroot $MAINDIR /usr/local/bin/mkdistro_clean.sh "root"
	rm -f $MAINDIR/usr/local/bin/mkdistro_clean.sh
	mksquashfs $MAINDIR $WORKDIR/$DIRMOD/$NAMEMOD
	;;
"b")	cp -fp $CURRENTDIR/mkdistro_clean.sh $MAINDIR/usr/local/bin/ 
	chroot $MAINDIR /usr/local/bin/mkdistro_clean.sh "root"
	rm -f $MAINDIR/usr/local/bin/mkdistro_clean.sh
	mod_build $MAINDIR $WORKDIR/$DIRMOD/$NAMEMOD $DISTRO
	;;
"c")	NAMEMODULE=$($DIALOG --stdout --wrap --title "$T1"  --inputbox "Informe o nome do modulo: (Ex: sid.mod, sid.tar.gz, sid.tar.bz2)" 8 60)
	echo "Construindo o modulo $NAMEMODULE. Aguarde..."
	if [[ $NAMEMODULE = *.mod ]] ; then
          COMPRESS=$($DIALOG --stdout --wrap --title "$T1"  --radiolist "Informe o tipo de compressao" 12 60 2 \
	  "a"  "squashfs" on	\
	  "b"  "cloop" 	off)
	  choice
	  case "$COMPRESS" in
 	  "a") mksquashfs $MAINDIR $BACKUPDIR$NAMEMODULE ;;
 	  "b") mod_build $MAINDIR $BACKUPDIR/$NAMEMODULE $DISTRO ;;
	  esac 
	elif [[ $NAMEMODULE = *.tgz ]]; then
  	  cd $MAINDIR
  	  tar -czf $BACKUPDIR/$NAMEMODULE ./
	elif [[ $NAMEMODULE = *.tar.gz ]]; then
  	  cd $MAINDIR
  	  tar -czf $BACKUPDIR/$NAMEMODULE ./
	elif [[ $NAMEMODULE = *.tar.bz2 ]]; then
  	  cd $MAINDIR
  	  tar -cjf $BACKUPDIR/$NAMEMODULE ./
	fi
	cd $CURRENTDIR
	$DIALOG --title "$T1" --msgbox "\nSeu modulo $NAMEMODULE esta pronto em $BACKUPDIR" 10 75 ;;
esac
}

# ========= Construa o seu proprio modulo principal ==================================
function make_your_main {
[ ! -f $CURRENTDIR/*.cfg ] && def_distro
$DIALOG --wrap --left --title "$T1" --msgbox "Para criar um modulo basico personalizado, voce precisa estar conectado a internet, ou possuir o repositorio de pacotes debian desejado em algum lugar de seu HD, bem como possuir o comando debootstrap atualizado." 10 75
YOUR_MOD_TYPE=$($DIALOG --stdout --wrap --left --title "$T1" --inputbox "Qual o tipo de repositorio debian que formara o seu modulo? (Ex: sid etch sarge hoary breezy)" 10 75)
YOUR_MOD_MIRROR=$($DIALOG --stdout --wrap --left --title "$T1" --inputbox "Qual o espelho que fornecera os pacotes para o seu modulo? (Ex: http:\/\/ftp.br.debian.org\/debian unstable main contrib)" 10 75)
choice
`debootstrap $YOUR_MOD_TYPE $MAINDIR $YOUR_MOD_MIRROR`
$DIALOG --wrap --left --title "$T1" --msgbox "Seu novo modulo principal basico esta pronto em $MAINDIR. Voce pode edita-lo para acrescentar ou retirar pacotes, armazena-lo em formato comprimido para uso futuro ou utiliza-lo imadiatamente para a construcao da sua distro, bastando acrescentar gera-lo como modulo comprimido, acrescentar um modulo base  e gerar a iso final da distro" 13 75
}

# Menu Principal de Trabalhos no Modulo Principal
function main_menu {
[ ! -d "$MAINDIR/bin" ] && set_newmainmod
while : ; do
 clear
 answer=$($DIALOG --stdout --cancel-label "Sair"  --title "Main Works - Trabalhar no modulo principal"  --menubox "Escolha uma das opcoes:" 12 75 5 	    		\
	a 'Editar o modulo principal, via menus'		\
	b 'Editar o modulo principal diretamente, via chroot' 	\
	c 'Fechar a imagem do modulo principal' 		\
	d 'Construir o seu proprio modulo principal basico'	\
	x 'Voltar')
	[ $? -ne 0 ] && break  # Se clicou em cancelar ou teclou ESC, sair,,,
	# Tratar as respostas 
	case "$answer" in
		"a") works_main $MAINDIR ;;
		"b") chroot_main $MAINDIR ;;
		"c") build_main_img ;;
		"d") make_your_main ;;
		"x") break ;;
	esac 
done  
}

# ========== Funcoes de trabalho com o modulo base ============================

function set_existingbasemod {
$DIALOG --wrap --title "$T1" --msgbox "Informe o modulo base que sera descompactado, no dialogo que abrira em seguida" 10 75
BASE=$($DIALOG --stdout --no-buttons --title "$T1" --fselect "/" 30 75)
export BASE 
echo "Descompactando o modulo base $BASE em $BASEDIR. Aguarde..."
uncompress_module $BASE $BASEDIR/
}

function set_newbasemod ()
{
if [ ! -d "$BASEDIR/bin" ]; then 
  clear
  check_folders
  WHICHBASE=$($DIALOG --stdout --wrap --title "$T1"  --radiolist "Escolha de onde o Modulo Base basico sera obtido." 14 80 3	\
 "a"  "De uma imagem mod, tar.gz ou tar.bz2 em dispositivo local" on 		\
 "b"  "Do repositorio oficial na internet (www.dreamlinux.com.br/downloads)" off	\
 "x"  "Voltar" off)				
 cd $BASEDIR/
 case $WHICHBASE in
   "a") set_existingbasemod ;;
   "b")	BASE=$($DIALOG --stdout --title "$T1" --inputbox "Forneca o caminho completo do modulo base a ser baixado de $SOURCENET. (Ex: basicbasemods/basicbasesid.tar.bz2)." 10 75)
	BASEFILE=$(basename $BASE)
	BASEFOLDER=$(dirname $BASE)
    	echo "Baixando $BASEFILE de $SOURCENET e descompactando em $BASEDIR. Aguarde..."    
    	wget $SOURCENET/$BASEFOLDER/$BASEFILE
    	decompress_module $BASEFILE $BASEDIR
    	mv $BASEFILE $CURRENTDIR/
   ;; 
   "c") ;;
 esac
 cd $CURRENTDIR  
fi
}

function copy_install_kernel ()
{
$DIALOG --wrap --left --title "$T1" --msgbox "\nNo dialogo que segue localize o .deb do kernel ou modulo de kernel que deseja instalar.\n" 13 75  
FILE_KERNEL=$($DIALOG --stdout --no-buttons --cancel-label "Sair" --title "$T1" --fselect "/" 30 85)
export FILE_KERNEL
choice
if [ $? -eq 0 ] ; then
  LOC_KERNELFILE=$(dirname $FILE_KERNEL)
  NAME_KERNELFILE=$(basename $FILE_KERNEL)
  echo "Copiando o pacote $NAME_KERNELFILE para $BASEDIR"
  cp $FILE_KERNEL $BASEDIR/
  echo "Instalando o pacote $NAME_KERNELFILE..."
  mount -t proc /proc $BASEDIR/proc
  chroot $BASEDIR/ dpkg -i $NAME_KERNELFILE 
  chroot $BASEDIR/ rm -f $NAME_KERNELFILE
  umount $BASEDIR/proc
  $DIALOG --wrap --title "$T1" --msgbox "Seu pacote $NAME_KERNELFILE foi instalado com sucesso!" 10 75
fi
}

function copy_grub_folder ()
{
[ ! -d $WORKDIR/boot/grub ] && mkdir $WORKDIR/boot/grub
$DIALOG --wrap --left --title "$T1" --msgbox "Na janela de dialogo que segue localize o diretorio Grub do qual deseja copiar os arquivos.\n" 12 75
GRUBDIR=$($DIALOG --stdout --no-buttons --cancel-label "Sair" --title "$T1" --dselect "/" 30 75)
choice
if [ $? -eq 0 ] ; then
  echo "Copiando os arquivos da pasta $GRUBDIR para $WORKDIR/boot/grub..."
  cp -fp $GRUBDIR/* $WORKDIR/boot/grub
  $DIALOG --wrap --title "$T1" --msgbox "Sua pasta $GRUBDIR foi reproduzida com sucesso para $WORKDIR/boot!" 10 75
fi
}

function set_kernel_to_boot ()
{
echo "Ajustando o kernel em boot."
cp $BASEDIR/boot/vmlinuz-* $WORKDIR/boot/vmlinuz
$DIALOG --wrap --title "$T1" --msgbox "Seu kernel copiado com sucesso para $WORKDIR/boot!" 10 75
}

function copy_miniroot_to_boot ()
{
$DIALOG --wrap --left --title "$T1" --msgbox "No dialogo a seguir escolha o arquivo miniroot.gz a ser copiado em $WORKDIR/boot.\n" 12 75
FILE_MINIROOT=$($DIALOG --stdout --no-buttons --cancel-label "Sair" --title "$T1" --fselect "/" 30 75)
cp -f $FILE_MINIROOT $WORKDIR/boot/
$DIALOG --wrap --title "$T1" --msgbox "Seu arquivo $FILE_MINIROOT foi copiado com sucesso para $WORKDIR/boot!" 10 75
}

function copy_boot_cat ()
{
$DIALOG --wrap --left --title "$T1" --msgbox "No dialogo a seguir escolha o arquivo boot.cat a ser copiado em $WORKDIR/base.\n" 12 75
FILE_BOOTCAT=$($DIALOG --stdout --no-buttons --cancel-label "Sair" --title "$T1" --fselect "/" 30 75)
cp -f $FILE_BOOTCAT $WORKDIR/base/
$DIALOG --wrap --title "$T1" --msgbox "Seu arquivo $FILE_BOOTCATT foi copiado com sucesso para $WORKDIR/base!" 10 75
}

function set_morphix_structure ()
{
[ ! -d $WORKDIR/base ] && mkdir $WORKDIR/base
[ ! -d $WORKDIR/boot ] && mkdir $WORKDIR/boot && mkdir $WORKDIR/boot/grub
[ ! -d $WORKDIR/cdrom ] && mkdir $WORKDIR/cdrom
[ ! -d $WORKDIR/copy ] && mkdir $WORKDIR/copy
[ ! -d $WORKDIR/deb ] && mkdir $WORKDIR/deb
[ ! -d $WORKDIR/exec ] && mkdir $WORKDIR/exec
[ ! -d $WORKDIR/mainmod ] && mkdir $WORKDIR/mainmod
[ ! -d $WORKDIR/minimod ] && mkdir $WORKDIR/minimod
}

function build_newbasemod {
while : ; do
	clear
	answer=$($DIALOG --stdout --cancel-label "Sair"	--title "New Base - Constroi novo Modulo Base"  --menubox "Escolha uma das opcoes:" 14 75 7 	\
	a 'Descompactar um Modulo Base basico para edicao'	\
	b 'Copiar e Instalar kernels e modulos de kernel na nova base'	\
	c 'Copiar um diretorio Grub para a nova base'		\
	d 'Ajustar a imagem do kernel (vmlinuz) para o diretorio /boot'	\
	e "Copiar um arquivo miniroot.gz para o diretorio /boot" 	\
	f "Copiar um arquivo boot.cat para o diretorio /base"		\
	x 'Voltar')
	[ $? -ne 0 ] && break  # Se clicou em cancelar ou teclou ESC, sair,,,
	# Tratar as respostas 
	case "$answer" in
		"a") set_newbasemod ;;
		"b") copy_install_kernel ;;
		"c") copy_grub_folder ;;
		"d") set_kernel_to_boot ;;
		"e") copy_miniroot_to_boot ;;
		"f") copy_boot_cat ;;
		"x") break ;;
	esac 
done  
}

function basemod_build {
if [ -f $WORKDIR/base/$BASEMOD_NAME ]; then
 echo "Salvando o arquivo $BASEMOD_NAME original em $BACKUPDIR"
 mv $WORKDIR/base/$BASEMOD_NAME $BACKUPDIR
fi
echo "Construindo o novo modulo base (arquivo $BASEMOD_NAME) em $WORKDIR/base/..."
#mod_build $BASEDIR $WORKDIR/base/$BASEMOD_NAME "Projeto DreamLinux"
build_module $BASEDIR $WORKDIR/base/$BASEMOD_NAME "Projeto DreamLinux"
$DIALOG --title "$T2" --msgbox "\n\nO novo modulo base $BASEMOD_NAME esta pronto em $WORKDIR/base." 10 75
}

function baseiso_build { # gera a iso da base. 
NEWBASEIMG=$($DIALOG --stdout --wrap --left --title "$T1" --inputbox "Forneca o nome da nova imagem da Base que sera gerada. (Ex:novabase):" 10 75)
choice
NEWBASEISO="$NEWBASEIMG.iso"
echo "Construindo a iso da nova base..."
iso_build $WORKDIR $ISODIR $NEWBASEISO
}

function explode_basemod {
cd $CURRENT
MOD_BASE=$(ls $WORKDIR/base/ | grep $BASEMOD_NAME)
if [ ! -z "$MOD_BASE" ]; then 
  MOD_BASEFILE=$WORKDIR/base/$MOD_BASE
  uncompress_module $MOD_BASEFILE $BASEDIR 
fi
}

function update_basemod {
 mkdir $BASEDIR/var/lib/apt/lists 2>/dev/null
 mkdir $BASEDIR/var/lib/apt/lists/partial 2>/dev/null
 touch $BASEDIR/var/lib/apt/lists/lock 2>/dev/null
 mkdir $BASEDIR/var/cache/apt 2>/dev/null
 mkdir $BASEDIR/var/cache/apt/archives 2>/dev/null
 mkdir $BASEDIR/var/cache/apt/archives/partial 2>/dev/null
 touch $BASEDIR/var/lib/dpkg/status 2>/dev/null
 mkdir $BASEDIR/var/lib/dpkg/updates 2>/dev/null
 touch $BASEDIR/var/lib/dpkg/available 2>/dev/null
 $DIALOG --wrap --left --title "$T2" --msgbox "\nSua base esta atualizada para receber repositorios debian e operar com apt-get" 12 75
}

# Simplesmente acessa o ambiente chroot da base para trabalhos
function chroot_base {
[ ! -d "$BASEDIR/bin" ] && explode_basemod 
cp -fp /etc/resolv.conf $BASEDIR/etc/
echo "Entrando no ambiente chroot da Base. Bom trabalho..." 
mount -t proc /proc $BASEDIR/proc
chroot $BASEDIR /bin/bash
umount $BASEDIR/proc
rm -f $BASEDIR/etc/resolv.conf
touch $BASEDIR/etc/resolv.conf
}

# Customiza a sua tela de splash na imagem do CD
function splash_custom {
$DIALOG --wrap --left --title "$T1" --msgbox "\nUtilize uma imagem no formato jpg, com as dimensoes 1024x768 pixels.\n\nVai ser aberta uma janela de dialogo para voce localizar uma imagem previamente construida por voce." 13 75
choice  
IMAGEM=$($DIALOG --stdout --no-buttons --cancel-label "Sair" --title "$T1" --fselect "/" 25 75)
choice
if [ $? -eq 0 ] ; then
 LOCIMG=$(dirname $IMAGEM)
 NAMEIMG=$(basename $IMAGEM)
 echo "Substituindo a imagem..."
 mkdir /tmp/tempimg1 /tmp/tempimg2 2>/dev/null
 mv $WORKDIR/boot/miniroot.gz /tmp/tempimg1
 gunzip /tmp/tempimg1/miniroot.gz
 mount -o loop /tmp/tempimg1/miniroot /tmp/tempimg2
 rm -f /tmp/tempimg2/bootsplash/images/silent-1024x768.jpg
 cp $LOCIMG/$NAMEIMG /tmp/tempimg2/bootsplash/images/silent-1024x768.jpg
 chown root.root /tmp/tempimg2/bootsplash/images/silent-1024x768.jpg
 chmod 644 /tmp/tempimg2/bootsplash/images/silent-1024x768.jpg
 umount /tmp/tempimg2
 gzip -9 /tmp/tempimg1/miniroot
 mv /tmp/tempimg1/miniroot.gz $WORKDIR/boot/
 rm -rf /tmp/tempimg2
 rm -rf /tmp/tempimg1
 $DIALOG --wrap --title "$T1" --msgbox "Sua imagem customizada foi copiada com sucesso!" 10 75
fi
}

function work_on_miniroot {
cp -p $WORKDIR/boot/miniroot.gz $TEMPDIR1/
gunzip $TEMPDIR1/miniroot.gz
mount -o loop $TEMPDIR1/miniroot $TEMPDIR2/
#cp -a $CURRENTDIR/temproot2/* $MINIROOTDIR/
#cp -a $CURRENTDIR/temproot2/.* $MINIROOTDIR/
$DIALOG --wrap --left --title "$T1" --msgbox "O arquivo miniroot.gz esta pronto para ser trabalhado em $TEMPDIR2. Apos os trabalhos, feche este dialogo que o arquivo sera recomprimido." 12 75
umount $TEMPDIR2/
gzip -9 $TEMPDIR1/miniroot
$DIALOG --wrap --left --title "$T1" --inputbox "Deseja substituir o miniroot.gz original pelo novo miniroot.gz trabalhado por voce?" 10 75
if [ $? -eq 0 ]; then
  rm -f $WORKDIR/boot/miniroot.gz
  mv $TEMPDIR1/miniroot.gz $WORKDIR/boot
  $DIALOG --wrap --left --title "$T1" --msgbox "Arquivo miniroot.gz regerado e movido com sucesso para $WORKDIR/boot!" 10 75
fi
}

# Menu Principal de Trabalho na Base
function base_menu {
while : ; do
	clear
	answer=$($DIALOG --stdout --cancel-label "Sair"	--title "Base Works - Trabalhos no Modulo Base"  --menubox "Escolha uma das opcoes:" 17 75 9 	\
	a "Descompactar o modulo base para edicao"	\
	b "Adaptar o modulo base para instalar pacotes (se for uma base Morphix)"	\
	c "Editar o modulo base via chroot"		\
	d "Personalizar a tela de splash na imagem do CD"	\
	e "Trabalhar no arquivo miniroot.gz" 		\
	f "Fechar a imagem do modulo base (arquivo $BASEMOD_NAME)"	\
	g "Fechar a iso da sua base modificada"			\
	H "CONSTRUCAO DE UM NOVO MODULO BASE" 	\
	x "Voltar")
	[ $? -ne 0 ] && break  # Se clicou em cancelar ou teclou ESC, sair,,,
	# Tratar as respostas 
	case "$answer" in
		"a") explode_basemod ;;
		"b") update_basemod ;;
		"c") chroot_base ;;
		"d") splash_custom ;;
		"e") work_on_miniroot ;;
		"f") basemod_build ;;
		"g") baseiso_build ;;
		"H") build_newbasemod ;;
		"x") break ;;
	esac 
done  
}

# ==== Remasteriza a partir de uma distro existente, em um CD ou em uma iso gravada no seu computador

function choose_main {
$DIALOG --wrap --left --title "$T1" --msgbox "Informe que modulo utilizara, no dialogo que abrira em seguida" 10 75
MAIN=$($DIALOG --stdout --title "$T1" --no-buttons --fselect "$1" 30 75)
uncompress_module $MAIN $MAINDIR
}

function remaster_from_distro {
if [ ! -d "$WORKDIR/base" ]; then
  #Escolha a distro que sera usada para remasterizar
  DISTROSOURCE=$($DIALOG --stdout --wrap --left --title "$T1"  --radiolist "Escolha de onde extraira a distro que sera remasterizada:" 	10 75 2	 \
  "a"	"De um CD-ROM/CD-RW" on	 \
  "b"	"De uma imagem iso"  off)
  choice
  case $DISTROSOURCE in
    "a") 	CDMOUNT=$($DIALOG --stdout --wrap --left --title "$T1" --inputbox "Informe o ponto de montagem do CD-ROM" 12 75 "/mnt/cdrom")
		export CDMOUNT
		[ ! -d "$CDMOUNT" ] && mkdir -p $CDMOUNT 2>/dev/null
		PMOUNT=$(basename $CDMOUNT)
		mount /dev/$PMOUNT $CDMOUNT 2>/dev/null
		echo "Copiando a estrutura da distro encontrada em $CDMOUNT para $WORKDIR. Aguarde..."
  		cp -Rp $CDMOUNT/* $WORKDIR/
  		umount $CDMOUNT
		eject /dev/$PMOUNT
	;;
    "b")	$DIALOG --stdout --wrap --title "$T1" \
		--msgbox "Informe que imagem iso utilizara, no dialogo que abrira em seguida" 12 75
		ISOIMG=$($DIALOG --stdout --no-buttons --title "$T1" --fselect "/" 25 75)
		explode_iso $ISOIMG $WORKDIR
	;;
  esac
  choose_main $WORKDIR
elif [ ! -d "$MAINDIR/bin" ]; then
  case "$DISTROBRANCH" in 
  "Morphix") if [ -f "$WORKDIR/$DIRMOD/*.mod" ]; then
       	       choose_main $WORKDIR/$DIRMOD
     	     else 
    	       $DIALOG --wrap --title "$T1" --msgbox "Voce nao possui um modulo principal em $WORKDIR/$DIRMOD. Por favor, carregue um modulo manualmente ou apague toda a estrutura e rode o script $0 novamente." 10 75
               exit 0
             fi
  ;;
  *) if [ -f "$WORKDIR/$DIRMOD/$NAMEMOD" ]; then
		uncompress_module "$WORKDIR/$DIRMOD/$NAMEMOD" $MAINDIR
	     else 
    	       $DIALOG --wrap --title "$T1" --msgbox "Voce nao possui um modulo principal em $WORKDIR/$DIRMOD. Por favor, carregue um modulo manualmente ou apague toda a estrutura e rode o script $0 novamente." 10 75
               exit 0
             fi
   ;;
  esac
fi
}

# ==================== Remasteriza a sua distro instalada no hd ==================
# Transforma a sua instalacao no HD em um modulo principal, 

function clean_inside ()
{
cp -fp $CURRENTDIR/mkdistro_clean.sh $1/
chroot $1/ sh mkdistro_clean.sh 
rm -f $1/mkdistro_clean.sh
}

function verify_user ()
{
#=== Detecaco do nome do usuario
if [ "$LOCDISTRO" = "/" ]; then
  USERDIR=$(find /home -maxdepth 1 -mindepth 1 -type d | grep -v root | grep -v morph)
else
  [ ! -d /$PART_DIR/$LOCDISTRO ] && mkdir -p /$PART_DIR/$LOCDISTRO
  mount /dev/$LOCDISTRO /$PART_DIR/$LOCDISTRO 2>/dev/null
  USERDIR=$(find /$PART_DIR/$LOCDISTRO/home -maxdepth 1 -mindepth 1 -type d | grep -v root | grep -v morph)
fi
USERNAME=$(basename $USERDIR) 
$DIALOG --stdout --wrap --left --title "$T1" --yesno "O usuario detetado em $LOCDISTRO foi $USERNAME. Esta correto?" 12 75
if [ $? != 0 ]; then 
  USERNAME=$($DIALOG --stdout --wrap --left --title "$T1" --inputbox "Informe o nome do usuário principal da distro" 12 75)
fi
export USERNAME
}

function hd_remaster {

# Pergunta qual a raiz da distro instalada. 
# Se for /, entao o script esta sendo rodado de dentro da propria distro que vai ser remasterizada.
# Se for hd??? ou sd???, entao o script esta sendo executado de outra particao
# Creditos da ideia de rodar o script a partir de outra particao, ao drjesteves.
# Uma dica: prefira fazer essa remasterizacao a partir de outra particao. Eh muito mais rapido. 

# Caso nao haja ambiente carregado, defina um
[ -z "$NAMEDISTRO" ] && def_distro
verify_existing_base

LOCDISTRO=$($DIALOG --stdout --wrap --left --title "$T1" --inputbox "Local onde a distro esta instalada. Entre / para sinalizar que voce esta rodando este script de dentro da propria distro que esta sendo remasterizada. Entre o nome da particao, sem a barra (ex: hdb3), para sinalizar que a distro a ser remasterizada encontra-se em outra particao." 14 75)

verify_user

if [ "$LOCDISTRO" = "/" ]; then  # script esta rodando da mesma particao a ser reamsterizada
  cd /
  echo "Copiando e criando Diretorios, aguarde..."
  dirs2copy=$(find / -maxdepth 1 -mindepth 1 -type d | grep -v boot | grep -v cdrom | grep -v cdrom1 | grep -v dev | grep -v floppy | grep -v home | grep -v initrd | grep -v media | grep -v mnt | grep -v proc | grep -v srv | grep -v sys | grep -v usr | grep -v var)
  mkdir -p $HDREMASTERDIR/boot $HDREMASTERDIR/dev $HDREMASTERDIR/initrd $HDREMASTERDIR/media $HDREMASTERDIR/mnt $HDREMASTERDIR/proc $HDREMASTERDIR/srv $HDREMASTERDIR/sys 
  if [ "$DISTROBRANCH" = "Morphix" ]; then 
    mkdir $HDREMASTERDIR/$IMG_CD
#    mkdir $HDREMASTERDIR/UNION
  fi
  # Copy the contents of the filesystem into the temporary directory
  for directory in $dirs2copy; do
    [ -d $directory ] && cp -raf $directory $HDREMASTERDIR 
  done
  echo "Copiando home..."
  rsync -a /home $HDREMASTERDIR
  title="Copiando a pasta usr"
  progressBar "/usr" "$HDREMASTERDIR"
  title="Copiando a pasta var"
  progressBar "/var" "$HDREMASTERDIR"
  [ ! -d $HDREMASTERDIR/$CONTROL_DIR -a -d $HDREMASTERDIR/etc/$CONTROL_DIR ] && mv $HDREMASTERDIR/etc/$CONTROL_DIR $HDREMASTERDIR
  [ "$DISTROBRANCH" = "Morphix" ] && rm -rf $HDREMASTERDIR/lib/modules/* # Remove os modulos de kernel: esses vem do modulo base
#  mkdir $HDREMASTERDIR/usr/lib/backup
#  mv $HDREMASTERDIR/usr/lib/libGL* $HDREMASTERDIR/usr/lib/backup/ 
  rm -f $HDREMASTERDIR/etc/X11/XF86Config 2>/dev/null
  rm -f $HDREMASTERDIR/etc/X11/XF86Config-4 2>/dev/null
  rm -f $HDREMASTERDIR/etc/X11/xorg.conf 2>/dev/null
  [ -f "$HDREMASTERDIR/etc/dreaminstalled" ] && rm -f $HDREMASTERDIR/etc/dreaminstalled && echo "no" > $HDREMASTERDIR/etc/dreaminstalled
  # Salva o conteudo de /home/$USERNAME para /etc/skel
  [ -d $HDREMASTERDIR/etc/skel.org ] && rm -rf $HDREMASTERDIR/etc/skel.org
  mv $HDREMASTERDIR/etc/skel $HDREMASTERDIR/etc/skel.org
  rsync -a $HDREMASTERDIR/home/$USERNAME/ $HDREMASTERDIR/etc/skel
  rm -rf $HDREMASTERDIR/home 2>/dev/null
  mkdir -p $HDREMASTERDIR/home
  # retira $USERNAME dos arquivo passwd, group, sudoers e, se houver, do shadow e do gshadow
  deleteuser $HDREMASTERDIR $USERNAME
  echo "Limpando cache, arquivos orfaos e atualizando bd de programas instalados..."
  clean_inside $HDREMASTERDIR
  build_module $HDREMASTERDIR $WORKDIR/$DIRMOD/$NAMEMOD $DISTRO
  echo "Recuperando o espaco usado para remasterizacao. Aguarde...."
  rm -rf $HDREMASTERDIR
  mkdir $HDREMASTERDIR
  cd $CURRENTDIR
else  # Script rodando em uma particao diferente da particao da distro que se deseja remasterizar
  # Creditos da ideia: drjesteves
  echo "Copiando diretorios e arquivos..."
  [ ! -d /$PART_DIR/$LOCDISTRO ] && mkdir -p /$PART_DIR/$LOCDISTRO
  mount /dev/$LOCDISTRO /$PART_DIR/$LOCDISTRO 2>/dev/null
  mv /$PART_DIR/$LOCDISTRO/boot $HDREMASTERDIR/
  mkdir -p /$PART_DIR/$LOCDISTRO/boot
  [ -d /$PART_DIR/$LOCDISTRO/cdrom ] && rm -rf /$PART_DIR/$LOCDISTRO/cdrom
  [ -d /$PART_DIR/$LOCDISTRO/cdrom1 ] && rm -rf /$PART_DIR/$LOCDISTRO/cdrom1
  [ -d /$PART_DIR/$LOCDISTRO/floppy ] && rm -rf /$PART_DIR/$LOCDISTRO/floppy
  mv /$PART_DIR/$LOCDISTRO/dev $HDREMASTERDIR/
  mkdir -p /$PART_DIR/$LOCDISTRO/dev
  cp -af /$PART_DIR/$LOCDISTRO/etc $HDREMASTERDIR/
  [ -d /$PART_DIR/$LOCDISTRO/etc/skel.org ] && rm -rf /$PART_DIR/$LOCDISTRO/etc/skel.org
  mv /$PART_DIR/$LOCDISTRO/etc/skel /$PART_DIR/$LOCDISTRO/etc/skel.org 
  rsync -a /$PART_DIR/$LOCDISTRO/home/$USERNAME/ /$PART_DIR/$LOCDISTRO/etc/skel
  mv /$PART_DIR/$LOCDISTRO/home $HDREMASTERDIR/
  mkdir -p /$PART_DIR/$LOCDISTRO/home
  mkdir -p $HDREMASTERDIR/lib/modules
  cp -a /$PART_DIR/$LOCDISTRO/lib/modules/* $HDREMASTERDIR/lib/modules/ #Vem do modulo base
  rm -rf /$PART_DIR/$LOCDISTRO/lib/modules/*
#  mkdir -p $HDREMASTERDIR/usr/lib
#  cp -pf /$PART_DIR/$LOCDISTRO/usr/lib/libGL* $HDREMASTERDIR/usr/lib/
#  rm -f /$PART_DIR/$LOCDISTRO/usr/lib/libGL*
  rm -f /$PART_DIR/$LOCDISTRO/etc/X11/XF86Config 2>/dev/null
  rm -f /$PART_DIR/$LOCDISTRO/etc/X11/XF86Config-4 2>/dev/null
  rm -f /$PART_DIR/$LOCDISTRO/etc/X11/xorg.conf 2>/dev/null
  [ -f "/$PART_DIR/$LOCDISTRO/etc/dreaminstalled" ] && rm -f /$PART_DIR/$LOCDISTRO/etc/dreaminstalled && echo "no" > /$PART_DIR/$LOCDISTRO/etc/dreaminstalled
  if [ "$DISTROBRANCH" = "Morphix" ]; then 
    mkdir /$PART_DIR/$LOCDISTRO/$IMG_CD
#    mkdir /$PART_DIR/$LOCDISTRO/UNION
    [ ! -d /$PART_DIR/$LOCDISTRO/$CONTROL_DIR -a -d /$PART_DIR/$LOCDISTRO/etc/$CONTROL_DIR ] && cp -a /$PART_DIR/$LOCDISTRO/etc/$CONTROL_DIR/ /$PART_DIR/$LOCDISTRO/ && rm -rf /$PART_DIR/$LOCDISTRO/etc/$CONTROL_DIR 
  fi
  deleteuser /$PART_DIR/$LOCDISTRO $USERNAME
  echo "Limpando cache, arquivos orfaos e atualizando bd de programas instalados..."
  clean_inside /$PART_DIR/$LOCDISTRO
  echo "Gerando o modulo principal $NAMEMOD. Aguarde..."
  build_module /$PART_DIR/$LOCDISTRO $WORKDIR/$DIRMOD/$NAMEMOD $DISTRO
  # Retorna os diretorio preservados
  rm -rf /$PART_DIR/$LOCDISTRO/$IMG_CD
#  rm -rf /$PART_DIR/$LOCDISTRO/UNION
  rm -rf /$PART_DIR/$LOCDISTRO/boot
  rm -rf /$PART_DIR/$LOCDISTRO/dev
  rm -rf /$PART_DIR/$LOCDISTRO/etc
  rm -rf /$PART_DIR/$LOCDISTRO/home
  rm -rf /$PART_DIR/$LOCDISTRO/$CONTROL_DIR
  mv $HDREMASTERDIR/boot/ /$PART_DIR/$LOCDISTRO/
  mv $HDREMASTERDIR/dev/ /$PART_DIR/$LOCDISTRO/
  mv $HDREMASTERDIR/etc/ /$PART_DIR/$LOCDISTRO/
  mv $HDREMASTERDIR/home/ /$PART_DIR/$LOCDISTRO/
  mv $HDREMASTERDIR/lib/modules/* /$PART_DIR/$LOCDISTRO/lib/modules/
  rm -rf $HDREMASTERDIR/lib
#  mv $HDREMASTERDIR/usr/lib/libGL* /$PART_DIR/$LOCDISTRO/usr/lib/
#  rm -rf $HDREMASTERDIR/usr
fi
$DIALOG --title "$T1" --wrap --left --msgbox "Compressao completa. Seu novo modulo $NAMEMOD encontra-se em $WORKDIR/$DIRMOD." 12 75
}
############ HDREMASTER ######################################################
########### UTILITIES FUNCTIONS ###############################################
function module_mount ()
{
$DIALOG --wrap --left --tiltle "$T1" --msgbox "No dialogo a seguir, localize o arquivo cloop ou squashfs que deseja montar." 10 75
FILE=$($DIALOG --stdout --no-buttons --cancel-label "Sair" --title "$T1" --fselect "/" 25 75)
choice
mount_module $FILE
}

function iso_mount {
$DIALOG --wrap --left --tiltle "$T1" --msgbox "No dialogo a seguir, localize o arquivo iso que deseja montar." 10 75
FILE=$($DIALOG --stdout --no-buttons --cancel-label "Sair" --title "$T1" --fselect "/" 25 75)
choice
mount_iso $FILE
}

function module_extract ()
{
$DIALOG --wrap --left --tiltle "$T1" --msgbox "No dialogo a seguir, localize o arquivo cloop ou squashfs que deseja extrair." 10 75
FILE=$($DIALOG --stdout --no-buttons --cancel-label "Sair" --title "$T1" --fselect "/" 25 75)
$DIALOG --wrap --left --tiltle "$T1" --msgbox "No dialogo a seguir, localize o diretorio onde deseja extrair $FILE." 10 75
DIR=$($DIALOG --stdout --no-buttons --cancel-label "Sair" --title "$T1" --dselect "/" 25 75)
choice
COMP=""
module_type $FILE
case $COMP in
  "cloop") explode_mod_cloop $FILE $DIR ;;
  "squashfs") explode_mod_squash $FILE $DIR;;
esac
}

function compress_to_a_file ()
{
TYPE_FILE=$($DIALOG --stdout --wrap --left --title "$T1" --cancel-label "Cancela" --radiolist "Defina o tipo de arquivo desejado:" 19 75 6 \
"a"   "Arquivo comprimido em cloop" on	\
"b"   "Arquivo comprimido em squashfs" off  \
"c"   "Arquivo comprimido em tar.bz2" off \
"d"   "Arquivo comprimido em tar.gz" off \
"e"   "Arquivo iso" off \
"x"   "Voltar" off)
case $TYPE_FILE in
"a")	$DIALOG --stdout --title "$T1" --msgbox "No dialogo a seguir, forneca o caminho completo do diretorio que sera comprimido e gerado como imagem cloop." 10 75
	DIR_ORIG=$($DIALOG --stdout --no-buttons --title "$T1" --dselect "/" 30 75)
	$DIALOG --stdout --title "$T1" --msgbox "Forneca o caminho completo do diretorio onde sera gerado o arquivo comprimido." 10 75
 	DIR_DEST=$($DIALOG --stdout --no-buttons --title "$T1" --dselect "/" 30 75)
 	FILE_NAME=$($DIALOG --stdout --title "$T1" --inputbox "Forneca o nome do arquivo que sera gerado como imagem cloop." 10 75)
 	echo "Construindo a imagem solicitada..."
	mod_build $DIR_ORIG $DIR_DEST/$FILE_NAME
	$DIALOG --wrap --left --title "$T1" --msgbox "Seu arquivo $FILE_NAME encontra-se gerado em $DIR_DEST." 12 75
;;
"b")	$DIALOG --stdout --title "$T1" --msgbox "No dialogo a seguir, forneca o caminho completo do diretorio que sera comprimido e gerado como imagem squashfs." 10 75
	DIR_ORIG=$($DIALOG --stdout --no-buttons --title "$T1" --dselect "/" 30 75)
	$DIALOG --stdout --title "$T1" --msgbox "Forneca o caminho completo do diretorio onde sera gerado o arquivo comprimido." 10 75
 	DIR_DEST=$($DIALOG --stdout --no-buttons --title "$T1" --dselect "/" 30 75)
 	FILE_NAME=$($DIALOG --stdout --title "$T1" --inputbox "Forneca o nome completo do arquivo que sera gerado como imagem squashfs." 10 75)
 	echo "Construindo a imagem solicitada..."
	mksquashfs $DIR_ORIG $DIR_DEST/$FILE_NAME
	$DIALOG --wrap --left --title "$T1" --msgbox "Seu arquivo $FILE_NAME encontra-se gerado em $DIR_DEST." 12 75
;;
"c")	$DIALOG --stdout --title "$T1" --msgbox "No dialogo a seguir, forneca o caminho completo do diretorio que sera comprimido e gerado como imagem tar.bz2." 10 75
	DIR_ORIG=$($DIALOG --stdout --no-buttons --title "$T1" --dselect "/" 30 75)
	$DIALOG --stdout --title "$T1" --msgbox "Forneca o caminho completo do diretorio onde sera gerado o arquivo comprimido." 10 75
 	DIR_DEST=$($DIALOG --stdout --no-buttons --title "$T1" --dselect "/" 30 75)
 	FILE_NAME=$($DIALOG --stdout --title "$T1" --inputbox "Forneca o nome completo do arquivo que sera gerado como imagem tar.bz2." 10 75)
 	echo "Construindo a imagem solicitada..."
	cd $DIR_ORIG
 	tar cjf $DIR_DEST/$FILE_NAME.tar.bz2 ./
 	cd $CURRENT_DIR
	$DIALOG --wrap --left --title "$T1" --msgbox "Seu arquivo $FILE_NAME encontra-se gerado em $DIR_DEST." 12 75
;;
"d")	$DIALOG --stdout --title "$T1" --msgbox "No dialogo a seguir, forneca o caminho completo do diretorio que sera comprimido e gerado como imagem tar.gz." 10 75
	DIR_ORIG=$($DIALOG --stdout --no-buttons --title "$T1" --dselect "/" 30 75)
	$DIALOG --stdout --title "$T1" --msgbox "Forneca o caminho completo do diretorio onde sera gerado o arquivo comprimido." 10 75
 	DIR_DEST=$($DIALOG --stdout --no-buttons --title "$T1" --dselect "/" 30 75)
 	FILE_NAME=$($DIALOG --stdout --title "$T1" --inputbox "Forneca o nome completo do arquivo que sera gerado como imagem tar.gz." 10 75)
 	echo "Construindo a imagem solicitada..."
	cd $DIR_ORIG
 	tar czf $DIR_DEST/$FILE_NAME.tar.gz ./
 	cd $CURRENT_DIR
	$DIALOG --wrap --left --title "$T1" --msgbox "Seu arquivo $FILE_NAME encontra-se gerado em $DIR_DEST." 12 75
;;
"e")	$DIALOG --stdout --title "$T1" --msgbox "No dialogo a seguir, forneca o caminho completo do diretorio que sera gerado como imagem iso." 10 75
	DIR_ORIG=$($DIALOG --stdout --no-buttons --title "$T1" --dselect "/" 30 75)
	$DIALOG --stdout --title "$T1" --msgbox "Forneca o caminho completo do diretorio onde sera gerado o arquivo iso." 10 75
 	DIR_DEST=$($DIALOG --stdout --no-buttons --title "$T1" --dselect "/" 30 75)
 	FILE_NAME=$($DIALOG --stdout --title "$T1" --inputbox "Forneca o nome completo do arquivo que sera gerado como imagem iso." 10 75)
 	echo "Construindo a imagem solicitada..."
	cd $DIR_ORIG
 	mkisofs -pad -l -r -J -v -V "CustomIso" -P "My Custom Iso" -b boot/grub/iso9660_stage1_5 -c base/boot.cat -no-emul-boot -boot-load-size 4 -boot-info-table -hide-rr-moved -o $DIR_DEST/$FILE_NAME $DIR_ORIG
 	cd $CURRENT_DIR
	$DIALOG --wrap --left --title "$T1" --msgbox "Seu arquivo $FILE_NAME encontra-se gerado em $DIR_DEST." 12 75
;;
"x") : ;;
esac
}

# ========= Funcoes relativas ao Menu Principal do MkDistro ====================
function delete_workdir {
WHICH_ENV=$($DIALOG --stdout --wrap --left --title "$T1" --cancel-label "Cancela" --radiolist "Que ambiente de trabalho deseja apagar?:" 13 75 3 \
"a"   "Somente o ambiente de trabalho principal" on	\
"b"   "Todo o ambiente de trabalho" off  		\
"x"   "Voltar" off)
case $WHICH_ENV in
  "a") rm -rf $MAINDIR && mkdir $MAINDIR ;;
  "b") rm -rf $ROOTDIR 
       rm -f $CURRENTDIR/$NAMEDISTRO.cfg
   ;;
esac
if [ "$WHICH_ENV" = "a" ]; then
  $DIALOG --wrap--title "$T1" --msgbox "Seu ambiente de trabalho principal foi apagado." 10 75
else
  $DIALOG --wrap--title "$T1" --msgbox "Seu ambiente de trabalho completo foi apagado." 10 75
fi
}

function new_project () 
{
PROJECT_TYPE=$($DIALOG --stdout --wrap --left --title "$T1" --cancel-label "Cancela" --radiolist "Defina o tipo de projeto:" 13 75 3 \
"a"   "Nova Distro" on	\
"b"   "Nova Base" off  \
"x"   "Voltar" off)
case $PROJECT_TYPE in
	"a")	def_distro 
		verify_existing_base 
		set_newmainmod
	;;
	"b")	def_distro
		set_morphix_structure
		build_newbasemod
	;;
esac

}

function mount_a_distro {
rm -f "$CONFIGFILE"
def_distro 
verify_existing_base 
set_newmainmod
}

function from_a_distro {
[ ! -f $CURRENTDIR/*.cfg ] && def_distro
remaster_from_distro
}

function from_hd_install {
hd_remaster
}

# Menu de Utilitarios
function utilities_menu {
while : ; do
	clear
	answer=$($DIALOG --stdout --cancel-label "Sair"	--title "Utilitarios Diversos"  --menubox "Escolha uma das opcoes:" 14 75 6 \
	a 'Montagem de uma imagem cloop ou squashfs para trabalhos especificos'	\
	b 'Montagem de uma imagem iso para trabalhos especificos'	\
	c 'Descomprimir um modulo cloop ou squashfs em um diretorio'	\
	d 'Criacao de imagens cloop, squashfs, iso, tar.bz2 e tar.gz'	\
	e 'Gravar CD/CDRW'						\
	x 'Voltar')
	[ $? -ne 0 ] && break  # Se clicou em cancelar ou teclou ESC, sair,,,
	# Tratar as respostas 
	case "$answer" in
		"a") module_mount ;;
		"b") iso_mount ;;
		"c") module_extract ;;
		"d") compress_to_a_file ;;
		"e") $($CURRENTDIR/mkcd.sh) ;;
		"x") break ;;
	esac 
done  
}

# Fim da area de funcoes =======================================

# Begin  ===================== Funcao verify_distro ====================
#Verifica as definicoes armazenadas em arquivo
function verify_distro ()
{
# Verifica se existem arquivos de configuração de distros, para trabalho
find *.cfg > $CURRENTDIR/configfiles
#linhas=$(find *.cfg | wc -l)
#arqs=$(find *.cfg)
#lin=$linhas + 5
if [ -f $CURRENTDIR/configfiles -a ! -z $CURRENTDIR/configfiles ]; then
  $DIALOG --title "Arquivos de configuracoes existentes" --cancel-label "Sair"  --textbox "$CURRENTDIR/configfiles" 12 75
  WHICHCONFIG=""
  WHICHCONFIG=$($DIALOG --stdout --wrap --left --title "$T1"  --inputbox "Se deseja trabalhar em alguma Distro definida por um arquivo de configuração, forneca o nome do arquivo e confirme. Caso contrario, cancele:" 12 75)
  retval=$?
  if [ $retval -eq 0 ]; then
    source $WHICHCONFIG #utiliza as definicoes armazenadas
    case $DISTROTYPE in
     "new") DT_TEXT="Nova Distro" ;;
     "mount") DT_TEXT="Monta uma Distro, remasterizando mainmodulos pre-compilados" ;;
     "existing") DT_TEXT="A partir de uma Distro existente" ;;
    esac
    export DISTROTYPE WHEREROOT ROOTDIR ISODIR WORKDIR BASEDIR INITRDDIR BACKUPDIR HDREMASTERDIR DISTROBRANCH NAMEDISTRO NAMEMOD NAMEISO TEMPBASEDIR
    M1="\nSua configuracao atual:\nNome da sua Distro: $NAMEDISTRO\nFamilia da Distro: $DISTROBRANCH\nRaiz de Trabalho: $ROOTDIR\nDiretorio de Trabalho do modulo principal: $MAINDIR\nDiretorio de Geracao de Isos: $ISODIR\nDiretorio de Montagem da distro: $WORKDIR\nDiretorio de Trabalho do modulo base: $BASEDIR\nDiretorio da imagem do Modulo Principal: $DIRMOD\nNome do Modulo: $NAMEMOD\nNome da imagem iso: $NAMEISO\n
Tipo de Distro: $DT_TEXT\n\nDeseja manter essas configuracoes?"
    $DIALOG --wrap --left --ok-label "Sim" --cancel-label "Nao" --title "$T1" --yesno "$M1" 25 75
    retval=$?
    if [ $retval -eq 0 ]; then
     [ $(echo "$WHEREROOT" | cut -c-2) = "hd" -o $(echo "$WHEREROOT" | cut -c-2) = "sd" ] && mount -rw /dev/$WHEREROOT /media/$WHEREROOT >/dev/null 2>/dev/null
     check_folders
    else
     unset WHEREROOT DISTROBRANCH NAMEDISTRO ROOTDIR WORKDIR ISODIR NAMEBASE MAINDIR BASEDIR NAMEMOD NAMEISO
     rm -f $CURRENTDIR/$CONFIGFILE
    fi
  fi
fi
}

# End ==============Funcao verify_distro =============================================

# Inicio da rotina principal do script

# Gets the whole running distro tree
distro_tree

# Caso execute o script como usuario normal, esta rotina solicita a senha do root
# Esta rotina foi originalmente escrita por klaus knopper.
#if [ "`id -u`" != "0" ]; then
if [ $(id -u) -ne 0 ]; then  #by nelsongs 
# sudo only
 if which sudo >/dev/null && ( sudo -l -S </dev/null >/dev/null 2>&1 ) ; then
  exec sudo "$0" "$@" || exit 1
 elif which su-to-root >/dev/null; then
  exec su-to-root $X11 -c "$0" "$@" || exit 1
 elif which su >/dev/null; then  #by nelsongs
  exec su $X11 -c "$0" "$@" || exit 1 #by nelsongs
 else
  $DIALOG --title "$T1" --msgbox "\nPor favor, logue-se como root antes de executar este script!\n" 8 60
  exit 1
 fi
fi

clear

# Apresenta a tela de abertura do script
$DIALOG --wrap --title "$T1"  --msgbox "Gerador de Distros Linux, usando a tecnologia Morphix.\n
Versao: 2.5\n
Copyright (C) 2005 por Nelson Gomes da Silveira (nelsongs) <ngsilveira@gmail.com>\n
Equipe de apoio ao desenvolvimento:\n
Joao Batista Esteves (drjesteves) <drjesteves@yahoo.com.br>\n
Gaspar Domingos de Araujo (katatau) <katatau@epronx.com.br>\n
Creditos Permanentes:\n
Alex de Landgraaf, Comandante-em-Chefe e Ditador Destemido do Projeto Morphix\n
Klaus Knopper, o Grande Mestre, criador do Universo Knoppix\n
Agradecimento especial: Fly da Silva (www.freeos.com.br) pelo espaço inicial para desenvolvimento\n
Ultima atualizacao: 2006/05/28\n
Desenvolvido para o Projeto Dream Linux\n
Documentacao de suporte e forum em: http://www.dreamlinux.com.br/forum\n
Repositorio do Projeto em: http://www.dreamlinux.com.br/downloads." 25 75

#Menu Principal
while : ; do
  clear
  resposta=$($DIALOG --stdout --title "MkDistro - O Construtor de Distros Linux"  \
  --cancel-label "Sair"  --menubox "Escolha uma das opcoes:" 18 80 11 	\
    A  "NOVO PROJETO (Nova Distro ou Novo Modulo Base)"			\
    B  "REMASTERIZAR DISTRO EXISTENTE EM CD OU IMAGEM ISO"		\
    C  "REMASTERIZAR DISTRO INSTALADA NO HD"				\
    D  "REMASTERIZAR DISTRO, TROCANDO/ACRESCENTANDO MODULOS E ARQUIVOS"	\
    E  "FECHAR A IMAGEM ISO FINAL DA DISTRO"				\
    f  "Carregar variaveis de ambiente de Distro"			\
    g  "Executar trabalhos no modulo principal"				\
    h  "Executar trabalhos no modulo base (apenas distros baseadas no Morphix)"	\
    i  "Apagar o ambiente de trabalho atual"				\
    j  "Utilitarios"							\
    x  "Sair")
    [ $? -ne 0 ] && break
    case "$resposta" in
    	A) 	DISTROTYPE="new"
		export DISTROTYPE
		new_project ;;
 	B) 	DISTROTYPE="existing"
		export DISTROTYPE
		from_a_distro ;;
 	C) 	hd_remaster ;; #from_hd_install ;;
	D)	populate ;;
	E)	iso_build $WORKDIR $ISODIR $NAMEISO $DISTROBRANCH;;
	f)	verify_distro ;;
	g) 	main_menu ;;
	h) 	base_menu ;;
	i)	delete_workdir ;;
	j)	utilities_menu ;;
	x) 	break ;;
    esac 
done
