home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / boot / i386 / root / usr / share / YaST2 / clients / inst_target_selection.ycp < prev    next >
Text File  |  2006-11-29  |  8KB  |  292 lines
  1. /**
  2.  * Module:         inst_target_selection.ycp
  3.  *
  4.  * Authors:         Klaus Kaempf (kkaempf@suse.de)
  5.  *
  6.  * Purpose:         This module selects the harddisk(s) for installation.
  7.  *            -Harddisk recognition
  8.  *            -Selecting the harddisk for the installation by
  9.  *             the user ( if possible harddisks > 1 ).
  10.  *            -Write selected harddisk(s) with SetPartDisk into 
  11.  *                       Storage
  12.  *                      "target_is":<devicename> (key to "targets" map)
  13.  *            if custom, set "target_is":"CUSTOM"
  14.  *
  15.  * $Id: inst_target_selection.ycp 33576 2006-10-23 13:25:11Z fehr $
  16.  */
  17. {
  18.     textdomain "storage";
  19.  
  20.     import "Arch";
  21.     import "Mode";
  22.     import "Stage";
  23.     import "Popup";
  24.     import "Partitions";
  25.     import "Wizard";
  26.     import "Storage";
  27.  
  28.     include "partitioning/custom_part_helptexts.ycp";
  29.  
  30.     //////////////////////////////////////////////////////
  31.     // look what inst_part_propose has said:
  32.  
  33.     y2milestone( "GetPartMode %1", Storage::GetPartMode() );
  34.  
  35.     if( Storage::GetPartMode() == "PROP_MODIFY" ||
  36.         Storage::GetPartMode() == "SUGGESTION" )
  37.         return Storage::GetExitKey();
  38.  
  39.  
  40.     //////////////////////////////////////////////////////
  41.     // if we get here in update mode it's a BUG
  42.  
  43.     if( Mode::update () ) {
  44.     return `cancel;
  45.     }
  46.  
  47. /////////////////////////////////////////////////////////////////////
  48. // MAIN:
  49. /////////////////////////////////////////////////////////////////////
  50.  
  51.     map<string,map> targetMap = Storage::GetTargetMap();
  52.  
  53.     // Check the partition table for correctness
  54.   
  55.     term contents = `Dummy();
  56.  
  57.     boolean custom_val = (Storage::GetPartMode() == "CUSTOM");
  58.     y2milestone( "custom_val %1", custom_val );
  59.  
  60.     if( size(targetMap) > 0) 
  61.     {
  62.     // loop over targetMap and build radio buttons for selection
  63.     // dont use foreach here since we need a counter (as a shortcut)
  64.     // anyway
  65.  
  66.     term buttonbox = `VBox();
  67.  
  68.     integer dskcnt = size( filter( string d, map e, targetMap,
  69.                                    ``(Storage::IsPartitionable( e ))));
  70.     y2milestone( "dskcnt %1", dskcnt );
  71.  
  72.     if( dskcnt>10 )
  73.         {
  74.         integer i = 1;
  75.         list disklist = [];
  76.         foreach( string tname, map tdata, targetMap, 
  77.         ``{
  78.         if( Storage::IsPartitionable( tdata ))
  79.             {
  80.             disklist = add( disklist, 
  81.                     `item(`id(tname), 
  82.                       sformat( "%1: %2", i, tname )));
  83.             i = i + 1;
  84.             }
  85.         });
  86.         buttonbox = add( buttonbox,
  87.                  `SelectionBox(`id(`disklist), `opt(`notify),
  88.                                _("Available &Disks"),
  89.                        disklist ));
  90.         }
  91.     else
  92.         {
  93.         integer i = 1;
  94.         foreach( string tname, map tdata, targetMap, 
  95.         ``{
  96.         if( Storage::IsPartitionable( tdata ))
  97.             {
  98.             string tlinename = tdata["name"]:"?";
  99.             if( tdata["type"]:`CT_UNKNOWN==`CT_DMRAID )
  100.             tlinename = "BIOS RAID " + tdata["name"]:"?";
  101.             string tline = "&" + i + ":    " + tlinename;
  102.             boolean sel = Storage::GetPartDisk()==tname && 
  103.                   !custom_val;
  104.             buttonbox = add( buttonbox, 
  105.                      `Left(`RadioButton(`id(tname), tline, sel )));
  106.             i = i + 1;
  107.             }
  108.         });
  109.         }
  110.  
  111.     buttonbox = add(buttonbox, `VSpacing(0.8) );
  112.     // Check box for expert partitioning mode rather than
  113.     // just selecting one of the hard disks and use
  114.     // a standard partitioning scheme
  115.     buttonbox = 
  116.         add(buttonbox, `Left(`RadioButton(`id("CUSTOM"), `opt(`notify),
  117.                              // label text
  118.                  _("&Custom Partitioning (for experts)"),
  119.                  custom_val )));
  120.     
  121.     // This dialog selects the target disk for the installation.
  122.     // Below this label, all targets are listed that can be used as 
  123.     // installation target
  124.  
  125.                        // heading text
  126.     contents = `Frame( _("Hard Disk"),
  127.                `RadioButtonGroup(`id(`options),
  128.                          `VBox( `VSpacing(0.4),
  129.                             `HSquash(buttonbox),
  130.                             `VSpacing(0.4)
  131.                           )
  132.                         )
  133.              );
  134.     }
  135.     else 
  136.     {
  137.     y2milestone("NO targetMap");
  138.     // normally the target is located on hard disks. Here no hard disks 
  139.     // can be found. YaST2 cannot install. Update CD might have newer drivers.
  140.     contents = `Label (_("No disks found. Try using the update CD, if available, for installation."));
  141.     }
  142.  
  143.  
  144.     // There are several hard disks found. Linux is completely installed on
  145.     // one hard disk - this selection is done here
  146.     // "Preparing Hard Disk - Step 1" is the description of the dialog what to 
  147.     // do while the following locale is the help description
  148.     // help part 1 of 3
  149.     string helptext = _("<p>
  150. All hard disks automatically detected on your system
  151. are shown here. Select the hard disk on which to install &product;.
  152. </p>
  153. ");
  154.     // help part 2 of 3
  155.     helptext = helptext + _("<p>
  156. You may select later which part of the disk is used for &product;.
  157. </p>
  158. ");
  159.     // help part 3 of 3
  160.     helptext = helptext + _("
  161. <p>
  162. The <b>Custom Partitioning</b> option for experts allows full
  163. control over partitioning the hard disks and assigning
  164. partitions to mount points when installing &product;.
  165. </p>
  166. ");
  167.  
  168.  
  169.     // first step of hd prepare, select a single disk or "expert" partitioning
  170.     Wizard::SetContents( _("Preparing Hard Disk: Step 1"),
  171.              contents, helptext, (boolean)WFM::Args(0), 
  172.              (boolean)WFM::Args(1));
  173.     if ( Stage::initial () )
  174.     Wizard::SetTitleIcon( "yast-partitioning" );
  175.     
  176.     if( UI::WidgetExists( `id(`disklist)) && !custom_val )
  177.     {
  178.     UI::ChangeWidget( `id(`disklist), `CurrentItem, Storage::GetPartDisk());
  179.     }
  180.     any ret = nil;
  181.  
  182.     // Event handling
  183.  
  184.     any option = nil;
  185.  
  186.     symbol sym = `none;
  187.  
  188.     repeat
  189.     {
  190.     ret = Wizard::UserInput();
  191.  
  192.  
  193.     y2milestone( "ret %1", ret );
  194.  
  195.     if( is(ret, string) && (string)ret == "CUSTOM" )
  196.         {
  197.         //UI::ChangeWidget( `id(`disklist), `CurrentItem, "" );
  198.         custom_val = !custom_val;
  199.         }
  200.  
  201.     sym = `none;
  202.     if( is( ret, symbol))
  203.         {
  204.         sym = (symbol)ret;
  205.         }
  206.  
  207.     if( sym == `disklist )
  208.         {
  209.         y2milestone( "set CUSTOM false" );
  210.         custom_val = false;
  211.         UI::ChangeWidget( `id("CUSTOM"), `Value, false );
  212.         }
  213.  
  214.     if( sym == `abort && Popup::ReallyAbort(true) )
  215.         return `abort;
  216.     
  217.     if( sym == `next ) 
  218.         {
  219.         option = UI::QueryWidget(`id(`options), `CurrentButton);
  220.         y2milestone( "option %1", option );
  221.         if( option == nil ) 
  222.         {
  223.         string disk = "";
  224.         if( UI::WidgetExists( `id(`disklist)) && !custom_val )
  225.             {
  226.             disk = (string)UI::QueryWidget(`id(`disklist), `CurrentItem);
  227.             if( disk == nil ) disk="";
  228.             }
  229.         if( search( disk, "/dev/" ) == 0 )
  230.             option = disk;
  231.         else
  232.             {
  233.             // there is a selection from which one option must be 
  234.             // chosen - at the moment no option is chosen
  235.             Popup::Message(_("Select one of the options to continue."));
  236.             sym = `again;
  237.             }
  238.         }
  239.         if( option!=nil && substring((string)option,0,5) == "/dev/" )
  240.         {
  241.         if( targetMap[(string)option,"readonly"]:false )
  242.             {
  243.             Popup::Error( Partitions::RdonlyText( (string)option, true ));
  244.             sym = `again;
  245.             }
  246.         else if( Arch::ia64() && targetMap[(string)option,"label"]:"gpt"!="gpt" )
  247.             {
  248.             Popup::Error( ia64_gpt_text() );
  249.             sym = `again;
  250.             }
  251.         else
  252.             {
  253.             Storage::SetPartMode( "USE_DISK" );
  254.             y2milestone( "PartMode Disk old %1 name %2", 
  255.                  Storage::GetPartDisk(), option );
  256.             Storage::DisposeTargetBackup("disk");
  257.             Storage::CreateTargetBackup("disk");
  258.             Storage::ResetOndiskTarget();
  259.             Storage::SetPartDisk( (string)option );
  260.             Storage::SetCustomDisplay( false );
  261.             Storage::SetDoResize( "NO" );
  262.             }
  263.         } // if (option)
  264.         else if( option!=nil )
  265.         {
  266.         y2milestone( "PartMode %1 %2", Storage::GetPartMode(), 
  267.                  Storage::GetPartDisk() );
  268.         Storage::CreateTargetBackup("disk");
  269.         if( Storage::GetPartMode() != "USE_DISK" )
  270.             {
  271.             Storage::ResetOndiskTarget();
  272.             }
  273.         // map tg = Storage::GetTargetMap();
  274.         // when creating your own setup you probably do not want to have
  275.         // these windows mount point (/windows/C, /windows/D) as default
  276.         // tg = Storage::AddMountPointsForWin(tg);
  277.         // Storage::SetTargetMap( tg );
  278.         Storage::SetCustomDisplay( true );
  279.         }
  280.  
  281.         } // if (ret == next)
  282.     
  283.     } until ( sym == `next || sym == `back || sym == `cancel );
  284.     if( sym != `next )
  285.     {
  286.     Storage::SetPartMode( "SUGGESTION" );
  287.     Storage::SetPartProposalActive( true );
  288.     }
  289.     Storage::SaveExitKey( sym );
  290.     return sym;
  291. }
  292.