torios-dev team mailing list archive

[Nio Wiklund <nio.wiklund@xxxxxxxxx>]

Den 2015-02-25 01:43, Israel skrev:
> Hi everyone,
> This will be the last build to test for a while.
> It is uploading now.
> 
> This will be the one to report on until we get things fixed.
> I know the settings-manager has issues with the desktop... but it is
> what it is right now.
> I have to take a break for a few days
> 
> Not sure when it will finish uploading.
> ba7c45e77c489054d905c4645d9200da  ToriOS-2015-02-24-beta.iso
> 

Hi Israel,

I'm testing this iso file, ToriOS-2015-02-24-beta.iso.

*Live session*

It boots nicely and finds the wired network quickly. Several things are
improved :-)

But I must report the following issues.


1. There is no network applet on the panel. By intention or a bug?

nm-applet on the command line starts it.

The menu option (Settings manager, Panel) does not work.


2. You seem to have mixed up the modifications of the desktop files for

- One Button Installer
- OBI high resolution

The 'OBI high resolution' should have been left untouched, but you
decreased its resolution. You gave it the Exec line that belongs to 'One
Button Installer'. You did not change the Icon line of the One Button
Installer. See detailed description in mails from yesterday (febr 24).


3. zMktbl

Failed to execute child process "gksu" (No such file of directory)

If you remove gksu from the Exec line it works. The alternative is to
install gksu, but it is not necessary in the live session since it logs
you in as root.


4. partition-help

You made an empty line by moving the final " (quote character) to the
next line in 'partition-help'. This causes an unnecessary need for
scrolling in the help text window (or the first line is lost).


5. autoselect mkpxpy select-part2 confirm-partition can go wrong

I just found an old bug in my old scripts. The information in blkid is
sometimes not updated after editing the labels with gparted unless it is
cleared with

-c /dev/null

See the attached files (which are fixed and tested (so far only by me)).


6. Mounting by clicking in the file browser does not work.

It works to mount with the command line tool mount.


7. The wallpaper file 'default.jpg' is used. 'default.png' is much
bigger, 726 kibibytes. There is also '9w-bg.png'. I suggest that you
remove both png files to save space.


There are things that must be fixed in order to get a polished iso file
with ToriOS to release. But it has improved a lot and is getting close :-)


*Installed system*

It boots nicely and finds the wired network quickly. Several things are
improved :-)


1. There is no network applet on the panel. By intention or a bug?

There is no network applet on the panel. By intention or a bug?

nm-applet on the command line starts it.

The menu option (Settings manager, Panel) does not work.

But after reboot the nm-applet survives on the panel :-)

and at boot it uses 80 MB RAM in my IBM Thinkpad T42 with Pentium M CPU.
This is slightly more than before, but it works better too.

free -m in a terminal window


2. The bookmark(?) 'Applicatio...' in the left panel of pcmanfm shows
five items (in the main box) without any icons. They are links and work,
but it looks a little strange in icon view, which is the default.


3. The wallpaper file 'default.jpg' is used. 'default.png' is much
bigger, 726 kibibytes. I suggest that you remove the png file to save space.


I have only tested a few things, but I have found only a few things to
complain about in the installed system. I think it is very good now.

Best regards
Nio

#!/bin/bash

LC_ALL=C;LANG=C

echo "--- Use Gparted and prepare the device for the OBI ---"
echo "1. Put the label obi-root to one partition and format it to FAT32"
echo "2. Put the label obi-swap to one partition and format it to FAT32"
echo "(It is fast to format to FAT32, and it will be overwritten by the OBI)"
echo "*. The other partitions 'can be anything else'"
echo "----------------------------------------------------------------------"

#rootpart=$(sudo blkid|grep -i obi|grep -im1 root|cut -d: -f1)
rootpart=$(blkid -c /dev/null|grep -im1 -e obi-root -e obiroot|cut -d: -f1)
swappart=$(blkid -c /dev/null|grep -im1 -e obi-swap -e obiswap|cut -d: -f1)

echo "$rootpart $swappart" | tee partitions
# read -p "Press Enter to return to the menu"

function echoout {
  echo "[OBI] $@"
  echo "$@" >> "${HOME}"/obi-installer.log
}


function mklub {
## Find the path that OBI is installed to...
## if it is from the Debian package it will be /usr/share/OBI/

if [ -f "/home/$USER/mkpxpy" ]
then
  dpath="/home/$USER"
elif [ -f "$PWD/mkpxpy" ]
then
  dpath="$PWD"

elif [ -f "${HOME}/mkpxpy" ]
then
  dpath="${HOME}"
elif [ -f "/usr/share/OBI/mkpxpy" ]
then
  dpath="/usr/share/OBI"
else
  echo "Script not found. Change directory!"
fi


# variables
LC_ALL=C
LANG=C
swapping=true

# system and partitions

system="$1"
tarball="$2"
rootpart="$3"
swappart="$4"

##Save these variables to the logfile for examination later
echoout "$system"
echoout "$tarball"
echoout "$rootpart"
echoout "$swappart"

## check if swap partition exists... if not... NO swap
if [ -z "$swappart" ]
then
 swapping=false
fi

# Unmount the partition  if it is mounted
MOUNTIE=$(mount |grep /mnt)
if [ ! -z "${MOUNTIE}" ]
then
  umount /mnt
fi

# make file system

mkfs.ext4  "$rootpart"
sync

# mount what will be the root partition

mount "$rootpart" /mnt
if [ $? != 0 ]
then
 echoout "mount of what should become the root partition failed: $rootpart"
 exit
fi

# copy the files
# check for tarballs
if [ -d "/tarballs" ]
then
  tarpath="/tarballs"
elif [ -d "${HOME}/tarballs" ]
then
  tarpath="${HOME}/tarballs"
elif [ -d "${PWD}/tarballs" ]
then
  tarpath="${PWD}/tarballs"
else
  tarpath="${PWD}"
  echo "Error finding the tarball path"
fi
startdir="$dpath"
cd /mnt
#df .

## see if the tarball has the fullpath listed in selected, or not...
if [ "$tarball" == "$(basename "$tarball")" ]
then
 trbll="$tarpath/$tarball"
else
 trbll="$tarball"
fi

## check if there is gz or xz.... if not FAIL
if [ "$tarball" != "${tarball/.gz}" ]
then
 echoout "pv $trbll | tar -xz"
 pv "$trbll" | tar -xz
elif [ "$tarball" != "${tarball/.xz}" ]
then
 echoout "pv $trbll | tar -xJ"
 pv "$trbll" | tar -xJ
else
 read -p "only gzip and xz compression implemented"
 exit
fi

echoout "the tarball $tarball is expanded, syncing the drive ..."
sync
cd "$startdir"

# match the UUIDs to the fstab in the tarball and activate the swap

c=0;for i in $(grep ^UUID /mnt/etc/fstab|grep ext4|sed -e s/\ .*// -e 's/UUID=//'); do echo $i;c=$(($c+1));done;echo $c
if [ $c -ne 1 ]
then
 echoout "There are $c ext4 partitions in /mnt/etc/fstab, should be 1"
 exit
fi

c=0;for i in $(grep ^UUID /mnt/etc/fstab|grep swap|sed -e s/\ .*// -e 's/UUID=//'); do echo $i;c=$(($c+1));done;echo $c

if $swapping
then
 if [ $c -ne 1 ]
 then
  echoout "There are $c swap partitions in /mnt/etc/fstab, should be 1"
  exit
 fi
 suidblkid=$(blkid -c /dev/null|grep "$swappart"|grep 'TYPE="swap"')
 if [ $? -eq 0 ]
 then
  echoout "Use existing swap partition $swappart - keep its UUID"
  swapoff "$swappart"
 else
  echoout "Make $swappart a swap partition - and get new UUID"
  mkswap "$swappart"
 fi
 swapuid=$(grep ^UUID /mnt/etc/fstab|grep swap|sed -e s/\ .*// -e 's/UUID=//')
 swapUUID=$(blkid -c /dev/null "$swappart"|sed -e 's/.*UUID="//' -e 's/".*//')
fi

rootuid=$(grep ^UUID /mnt/etc/fstab|grep ext4|sed -e s/\ .*// -e 's/UUID=//')
rootUUID=$(blkid -c /dev/null "$rootpart"|sed -e 's/.*UUID="//' -e 's/".*//')

if $swapping
then
 sed s/"$swapuid"/"$swapUUID"/ /mnt/etc/fstab0 > /mnt/etc/fstab1
else
 grep ^UUID /mnt/etc/fstab0|grep swap
 if [ $? -eq 0 ]
 then
  swapline=$(grep ^UUID /mnt/etc/fstab0|grep swap)
  sed s/"$swapline"/"#$swapline"/ /mnt/etc/fstab0 > /mnt/etc/fstab1
 else 
  cp /mnt/etc/fstab0 /mnt/etc/fstab1
 fi
fi

if [ -f /mnt/boot/grub/grub.cfg ]
then
  mv /mnt/boot/grub/grub.cfg /mnt/boot/grub/grub.cfg0
  sed s/"$rootuid"/"$rootUUID"/ /mnt/boot/grub/grub.cfg0 > /mnt/boot/grub/grub.cfg
  rm /mnt/boot/grub/grub.cfg0
else
  echoout "MISSING /mnt/boot/grub/grub.cfg"
fi

if [ -f /mnt/etc/grub.d/40_custom ]
then
  mv /mnt/etc/grub.d/40_custom /mnt/etc/grub.d/40_custom0
  sed s/"$rootuid"/"$rootUUID"/ /mnt/etc/grub.d/40_custom0 > /mnt/etc/grub.d/40_custom
  rm /mnt/etc/grub.d/40_custom0
  chmod ugo+x /mnt/etc/grub.d/40_custom
else
  echoout "MISSING /mnt/etc/grub.d/40_custom"
fi
if [ -f /mnt/etc/fstab ]
then
  mv /mnt/etc/fstab /mnt/etc/fstab0
  sed s/"$rootuid"/"$rootUUID"/ /mnt/etc/fstab1 > /mnt/etc/fstab
  rm /mnt/etc/fstab{0,1}
else
  echoout "MISSING /mnt/etc/fstab"
fi

# label=${system//\ /_}
labelfix

tune2fs -L "$label" "$rootpart"
# tune2fs -U "$rootuid" "$rootpart"
# mkswap -U "$swapuid" "$swappart"
df -h /mnt

if $swapping
then
 swapon "$swappart" -p 3
 swapon -s
fi

blkid -c /dev/null

# install the bootloader

target="${rootpart:0:8}"

/bin/echo -n "Bootloader: "
"$dpath"/grub-installer "$target"
sync
umount "$rootpart"
#/bin/echo -n "File checking with "
#e2fsck -f "$rootpart"

# finish

echo "-----------------------------------------------------------------------"
echoout "The installation of $system to $rootpart and $swappart has finished"
echo ""
echo "Now you can shut down the computer and remove the"
echo "installation media (typically a USB drive)"
echo "and boot the computer from the installed system."
}

#!/bin/bash

# usage

if [ "$(whoami)" != "root" ] || ! ( [ "$1" == "root" ] || [ "$1" == "swap" ] )
then
 echo "Select partition for the advanced OBI level"
 echo "-------------------------------------------"
 echo "Usage: sudo $0 <root|swap>"
 echo "only alternatives:"
 echo "sudo $0 root"
 echo "sudo $0 swap"
 exit
fi

# variables

LC_ALL=C;LANG=C
item=0
seltxt=
rootpart=
swappart=
partitions=partitions
partitionS="Partition  Start   End     Size    Type   FSys  Label"
partd1=$(mktemp)
partd2=$(mktemp)

version=$( grep -i 'obi version' change.log|tail -n1|tr -s ' ' ' '| \
       cut -d ' ' -f 5-6)

# live drive and mounted partitions

ltest0=$(grep -m 1 " / " /etc/mtab|cut -d ' ' -f 1)
if [ "$ltest0" == "/cow" ]
then
 ltest1=$(grep " /isodevice" /etc/mtab|cut -c 5-8)
 livedrive=$ltest1
elif [ "$ltest0" == "rootfs" ]
then
 ltest1=$(grep "iso9660" /etc/mtab|cut -c 5-8)
 livedrive=$ltest1
elif [ "${ltest0/\/dev\/[^f]d}" != "$ltest0" ]
then
 livedrive=$(grep " / " /etc/mtab|cut -c 5-8)
else
 livedrive="_not_found"
fi
livedrive="/dev$livedrive"
#echo ltest0=$ltest0
#echo ltest1=$ltest1
#echo livedrive=$livedrive

booted=$(df|grep ^/dev/|grep ' /$'|cut -d ' ' -f 1) # mark *LIVE

# Create a first list from parted

parted -ls|grep -v extended|grep -v ^Sector|grep -v ^Partition \
|sed -e 's/      /  /' -e 's/boot//' -e 's/hidden//' -e 's/msftdata//' \
-e 's/linux-swap(v1)/swap/' \
-e 's/ *, *//' \
-e 's/primary   /prim   /' \
-e 's/primary$/prim   n.a./' \
-e 's/logical   /logic  /' \
-e 's/logical$/logic  n.a./' \
-e 's/^Model: /Model      /' \
-e 's/.*Error:/Error     /' \
-e 's/^Disk /Disk       /' \
-e s/Number.*/"$partitionS"/ \
> "$partd1"

# Create a second (tweaked) list from the first list

#  if [ "${tj:1:7}" == "Warning" ] || [ "${tj:1:5}" == "Error" ]
#  then
#    tj=$(sudo fdisk -lu "$j" 2>/dev/null|grep "$j":|sed s/\,\ .*//)
#  fi

while read line
do
# echo "$line"
# sleep 0.2

 if [ "$line" != "" ]
 then
  if [ "${line:0:4}" == "Disk" ]
  then
   device="${line:11:8}"
   if [ "$livedrive" == "$device" ]
   then
    tmpstr="${line:18:1} Booted   from device${line:8}   ***LIVE***"
   else
    tmpstr="${line:18:1} Device${line:8}"
   fi
   line=$tmpstr
  fi

  if [ "${line/Error}" != "$line" ]
  then
#   echo "ErrorTO  1         2"     
#   echo "12345678901234567890"
   
   device="${line:11:8}"
#   echo "$device"
   if [ "$device" == "/dev/zra" ]
   then
    line="zram       zram device found"
   else
    tmpstr=$(sudo fdisk -lu "$device" 2>/dev/null|grep "$device": \
     |sed -e s/\,\ .*// -e 's/Disk/Device  /')
    tmpstr="${line:18:1} ${tmpstr} - Booted?  busy or wiped or bad partition table"
    line="$tmpstr"
   fi
  fi

  if [ "${line/Warning}" != "$line" ]
  then
   echo "${line:0:7} Warning test output"
   tmpstr="No (wiped?) or bad partition table:   Disk ${line/Warning:}"
   line="$tmpstr"
#    line=$(sudo fdisk -lu "$j" 2>/dev/null|grep "$j":|sed s/\,\ .*//)
  fi

  if [ "${line:0:1}" '>' "0" ] && ( [ "${line:0:1}" '<' "9" ] || [ "${line:0:1}" == "9" ] )
  then
   fsys=$(blkid -c /dev/null $device$line:0:2}|grep ' TYPE'|sed -e 's/.*TYPE=//'|cut -d\" -f2)
   if [ "$fsys" != "" ]
   then
    line="${line/n.a./$fsys}"
   fi
   label=$(blkid -c /dev/null $device$line:0:2}|grep LABEL|sed -e 's/.*LABEL=//'|cut -d\" -f2)

# Lines for partitions fixed for > 9 partitions, lines written

   if [ "${line:1:1}" == " " ]
   then
    line="$device${line:0:1} ${line:2}  $label"
   else
    line="$device${line:0:2}${line:3}  $label"
   fi
  fi
  echo "$line" >> "$partd2"
 fi
done < "$partd1"
echo "$partitionS" >> "$partd2"

#less "$partd2"

# Check if there are default partitions

partitions=partitions
rootpart=
swappart=
if test -f "$partitions"
then
 read rootpart swappart < "$partitions"
 if [  $? -ne 0 ]
 then
  read rootpart dummy < "$partitions"
 fi
fi
#echo "rootpart=$rootpart"
#echo "swappart=$swappart"
#read -p "checking rootpart and swappart"

# Select root or swap partition

if [ "$1" == "root" ] || [ "$rootpart" == "" ]
then
 targ="Root"
 if [ "$rootpart" != "" ]
 then
  choice="$rootpart"
 else
  choice=1
 fi
elif [ "$1" == "swap" ]
then
 targ="Swap"
 if [ "$swappart" != "" ]
 then
  choice="$swappart"
 else
  choice=1
 fi
fi 

# Create the list variables aind and bvar for the dialog screen

aind=0
bind=0

while read line
do
# adev[$aind]="${line:0:9}"# Lines for partitions fixed for > 9 partitions
 adev[$aind]="${line:0:10}"
 atxt[$aind]="${line:11}"
# echo ${adev[$aind]}
# echo ${atxt[$aind]}
 df|grep "${line:0:10}">/dev/null
 if [ $? -eq 0 ]
 then
  mounted=true
  umount "${line:0:10}" 2>/dev/null
  sync
  df|grep "${line:0:10}">/dev/null
  if [ $? -eq 0 ]
  then
   mounted=true
  else
   mounted=false
  fi
  else
  mounted=false
 fi
 if [ "${line:0:9}" == "Partition" ] || [ "${line:0:5}" == "Model" ] || \
    [ "${line:02:6}" == "Device" ] || [ "${line:02:6}" == "Booted" ] || \
    [ "${line:0:4}" == "zram" ]
 then
  atxt[$aind]="\Z4\Zb"${atxt[$aind]}"\Zn"
 fi
 if [ "${line/9660}" != "$line" ]
 then
  adev[$aind]="ISOSYS:${line:7:2}"
  atxt[$aind]="\Z2"${line:11}"\Zn"
 fi
 if [ "${adev[$aind]}" == "$booted" ]
 then
  adev[$aind]="MOUNTD:${line:7:2}"
  atxt[$aind]="\Z2"${line:11}" \Z2\Z5*SYSTEM\Zn"
 elif $mounted
 then
  adev[$aind]="MOUNTD:${line:7:2}"
  atxt[$aind]="\Z1"${line:11}" \Zn\Z5*MOUNTED\Zn"
 elif [ "${adev[$aind]}" == "${rootpart}" ] \
   || [ "${adev[$aind]}" == "${rootpart} " ]
 then
  atxt[$aind]=${line:11}" \Z1\Zb*ROOT\Zn"
 elif [ "${adev[$aind]}" == "${swappart}" ] \
   || [ "${adev[$aind]}" == "${swappart} " ]
 then
  atxt[$aind]=${line:11}" \Z1\Zb*SWAP\Zn"
 fi
 aind=$(($aind + 1))
done < "$partd2"

if [ "$targ" == "Swap" ]
then
 adev[$aind]="n"
 atxt[$aind]="select to have no swap partition"
 aind=$(($aind + 1))
fi
adev[$aind]="w"
atxt[$aind]="wipe previous selection of partitions"
aind=$(($aind + 1))
adev[$aind]="q"
atxt[$aind]="quit selecting partition"
aind=$(($aind + 1))

for (( xi=0; xi < $aind ; xi++ ))
do
 if [ "${adev[$xi]}" == "q" ]
 then
  bvar[$bind]="q"
 else
#  bvar[$bind]=$(($xi+1))
  bvar[$bind]=${adev[$xi]}
 fi
 bind=$(($bind + 1))
 bvar[$bind]="${atxt[$xi]}"
 bind=$(($bind + 1))
done

#echo "$aind"
#read -p "stop to read aind"

# select device - the Advanced button

 ans=$(dialog \
 --no-shadow --backtitle "One Button Installer $version - Select partition - the $targ button" \
 --title "Select the $targ partition with the arrow keys, scroll if necessary" \
 --default-item "$choice" --colors --ok-label "$targ partition" --cancel-label "Quit" \
 --menu "Available partitions black \Z4\Zb(set basic OBI level to select a device)\Zn" \
 0 80 $aind "${bvar[@]}"  3>&1 1>&2 2>&3 3>&- )

#echo "ans=$ans"
rm "$partd1" "$partd2"

# identify selection

if [ "${ans:0:4}" == "/dev" ]
then
 if [ "$targ" == "Root" ]
 then
  rootpart="$ans"
 elif [ "$targ" == "Swap" ]
 then
  swappart="$ans"
 fi

# select to have no swap partition

elif [ "$ans" == "n" ]
then
 echo "$rootpart" > "$partitions"
 exit

# wipe selection and exit

elif [ "$ans" == "w" ]
then
 > "$partitions"
 exit

# quit without writing

else
 exit
fi

# write selection

if [ "$rootpart" != "$swappart" ]
then
 echo "$rootpart" "$swappart" > "$partitions"
else
 echo "$rootpart" > "$partitions"
fi
cat "$partitions"

#!/bin/bash

#-----------------------------------------------------------------------------
#
# author sudodus alias nio-wiklund at launchpad
#
# date        editor   comment
# 2013-06-25  sudodus  linux installer from tarball of installed system
# 2013-06-27  sudodus  raring.tar.gz
# 2013-08-09  sudodus  removed lame logic for wipe as alternative to install
# 2013-12-05  sudodus  select-partition created from select-device
#            
#-----------------------------------------------------------------------------

## Logging function

function echoout {
  echo "[OBI] $@"
  echo "$@" >> "${HOME}"/obi-installer.log
}

# main program

# variables

mkctrl "$system" "$tarball" "$rootpart" "$swappart"

choice=1
bs=4096
count=256
cnt=
target=
source="$1"
LC_ALL=C
LANG=C
tmpstr=
tiptxt="tips.txt"

if [ ! -z "${APTCACHE}" ]
then
  ver_no=$(apt-cache policy one-button-installer | grep Installed: | sed 's/Installed://' | sed 's/ubuntu.*//')
  version="$prgnam $ver_no"
else
## if we can't find apt-cache to grep the version just display the old version
  version=$( grep -i 'obi version' change.log|tail -n1|tr -s ' ' ' '| \
       cut -d ' ' -f 5-6)
fi
if [ -f "/home/$USER/mkhelp" ]
then
  dpath="/home/$USER"
elif [ -f "${HOME}/mkhelp" ]
then
  dpath="${HOME}"
elif [ -f "${PWD}/mkhelp" ]
then
  dpath="${PWD}"
elif [ -f /usr/share/OBI/mkhelp ]
then
  dpath="/usr/share/OBI/"
else
  echo "Script not found. Change directory!"
  exit 1
fi

# usage

if [ "$(whoami)" != "root" ]
then
 echo "Usage:"
 echo "Install $system to a partition on an"
 echo "internal hard disk drive or external USB or eSATA drive"
 echo "---- Install $system --------"
 echo "sudo $0"
 exit
fi
if [ "$1" != "" ]
then
 echoout ":-( Use no extra parameters :-("
 exit
fi

# select action

ans=$(dialog --backtitle "One Button Installer $version - Confirm partition" \
--yesno "Do you want to install $system?" 0 0 \
3>&1 1>&2 2>&3 3>&- )

if [ "$?" != "0" ]
then
 read -p "Press Enter to quit (return to the main menu)"
 exit
fi

while [ "$ans" != "g" ]
do
 chocnt=7
 choice=g
 read rootpart swappart < "$partitions"
 if [ "$rootpart" == "" ]
 then
  rootpart=$(blkid -c /dev/null|grep -i obi|grep -im1 root|cut -d: -f1)
  swappart=$(blkid -c /dev/null|grep -i obi|grep -im1 swap|cut -d: -f1)
  echo "$rootpart $swappart" > "$partitions"
 fi
 
 if test -b "$rootpart"
 then
  CHECK_ROOT=$(mount |grep "$rootpart")
  if [ ! -z "$CHECK_ROOT" ]
  then
    echoout "$rootpart is mounted:
$CHECK_ROOT"
    umount "$rootpart"
    echoout "$rootpart has been unmounted"
  else
    echoout "$rootpart was not mounted"
  fi
  if [ $? -ne 0 ]
  then
   echoout "the root partition ($rootpart) should *not* be mounted."
  fi
 fi
 if test -b "$swappart"
 then
  CHECK_SWAP=$(mount |grep "$swappart")
  if [ ! -z "$CHECK_SWAP" ]
  then
    echoout "$swappart is mounted:
$CHECK_SWAP"
    umount "$swappart"
    echoout "$swappart has been unmounted"
  else
    echoout "$swappart was not mounted"
  fi
  if [ $? -ne 0 ]
  then
   echoout "the pre-selected swap partition ($swappart) should *not* be mounted."
  fi
 fi
 
 if [ "${tarball/noswap}" == "$tarball" ]
 then
  if [ ! -z "$swappart" ]
  then
   swapshow="$swappart"
  else
   choice=s
   swapshow="\Z1\ZbNO SWAP\Zn"
  fi
  swaptxt1="and the swap partition:  \Z1$swapshow\Zn\n\n"
  swapcmd2="s"
  swaptxt2=" Swap partition - select or change"
 else
  chocnt=$(($chocnt-1))
  swaptxt1=""
  swapcmd2="q"
  swaptxt2=" Quit from this menu (return to the starter menu)"
  swappart=""
  echo "$rootpart" > "$partitions"
 fi
 if [ "$rootpart" != "" ]
 then
  rootshow="$rootpart"
  gocmd="g"
  gotxt=" Go ahead - confirm the choice"
 else
  choice=r
  rootshow="\Z1\ZbNO ROOT\Zn"
  gocmd="r"
  gotxt=" Start selecting a Root partition"
 fi


ans=$(dialog --cr-wrap --no-collapse --no-shadow --default-item "$choice" \
--backtitle "One Button Installer $version - Confirm partition" \
--title "Please select an action with a letter key or the arrow keys" \
--colors --cancel-label Quit --menu \
"The One Button Installer is prepared to start installing\n
the operating system:    \Z4$system\Zn\n
to the root partition:   \Z1$rootshow\Zn\n
$swaptxt1
Change or confirm the partitions or quit" 19 76 "$chocnt" \
"$gocmd" "$gotxt" \
o " Overview" \
a " Autoselect - select root and swap partitions automatically" \
r " Root partition - select or change" \
"$swapcmd2" "$swaptxt2" \
t " Tips (howto prepare partitions with Gparted)" \
q " Quit from this menu (return to the starter menu)" \
  3>&1 1>&2 2>&3 3>&- )

 if [ "$ans" == "g" ]
 then
  echo "$ans"
 elif [ "$ans" == "o" ]
 then 
  "$dpath/select-part1"
 elif [ "$ans" == "a" ]
 then 
  "$dpath/autoselect"
 elif [ "$ans" == "r" ]
 then
  "$dpath/select-part2" root
 elif [ "$ans" == "s" ]
 then 
  "$dpath/select-part2" swap
 elif [ "$ans" == "t" ]
 then 
  dialog --backtitle 'One Button Installer - Tips (use arrow keys to scroll)' \
  --textbox "$tiptxt" 17 76
 elif [ "$ans" == "q" ]
 then 
  exit
 else
  exit
 fi
done

# here we go

# echo "$system" "$tarball" "$target" "$rootpart" "$swappart"
# read -p "Press enter to continue or ctrl C to quit"

 warning_dialog


 ans=$(dialog --cr-wrap --no-collapse --defaultno --colors \
--backtitle "One Button Installer $version - Confirm partition - final WARNING" \
--yesno "The One Button Installer is prepared to start installing\n\n
the operating system    \Z4$system\Zn\n
to the root partition   \Z1$rootpart\Zn\n
$swaptxt1
\Z1This is the \Z7 FINAL WARNING \Z1 before starting to install !!!\n
Do you really want to install and overwrite these partitions?\Zn" 13 76 \
 3>&1 1>&2 2>&3 3>&- )

 ans="$?"
 normal_dialog

 if [ "$ans" != "0" ]
 then
  exit
 fi

 cnt="count=$count"

# install

 echo " "
 if [ ! -z "$swappart" ]
 then
   echoout "Installing $system to $rootpart with swap on $swappart ..."
 else
   echoout "Installing $system to $rootpart with no swap partition..."
 fi
 echo " "
 echoout "mklub $system $tarball $rootpart $swappart"
 read -sn1 -t3

mklub "$system" "$tarball" "$rootpart" "$swappart"

 read -p "Check the result and press Enter to continue"