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 / modules / OSRFloppy.ycp < prev    next >
Text File  |  2006-11-29  |  7KB  |  309 lines
  1. /**
  2.  *  File:
  3.  *    OSRFloppy.ycp
  4.  *
  5.  *  Module:
  6.  *     Read/Write files from floppy with dialog support.
  7.  *
  8.  *  Summary:
  9.  *      How to use OSRFloppy module:
  10.  *    1. OSRFloppy::Open( with ui support, count of files to read/wirte );
  11.  *
  12.  *      2. optional: OSRFloppy::NextStep(_(Copy the file ..  ));
  13.  *        WFM::Execute(.local.bash, "/bin/cp ... "); or
  14.  *        OSRFloppy::ReadMap( .. ) or
  15.  *        OSRFloppy::SaveMap( .. )
  16.  *
  17.  *    3. OSRFloppy::Close();
  18.  *
  19.  *  Author:
  20.  *    Johannes Buchhold <jbuch@suse.de>
  21.  *
  22.  * $Id: OSRFloppy.ycp 24138 2005-07-18 15:30:14Z jsuchome $
  23.  */
  24. {
  25.   module "OSRFloppy";
  26.  
  27.   textdomain "repair";
  28.  
  29.   import "StorageDevices";
  30.   import "Storage";
  31.   import "Report";
  32.   import "Label";
  33.  
  34.   import "OSRModuleLoading";
  35.  
  36.   /**
  37.    * Default mount point
  38.    */
  39.   global string mount_point            = "/media/floppy";
  40.  
  41.   /**
  42.    * Default floppy device
  43.    */
  44.   global string floppy_device           = StorageDevices::FloppyDevice;
  45.  
  46.   /**
  47.    * Supported file systems
  48.    */
  49.   list<string> needed_fs_kernel_modules        = ["fat", "vfat" ];
  50.  
  51.   /**
  52.    * Only for internal use.
  53.    */
  54.   boolean dialog_open            = false;
  55.   boolean use_ui        = true;
  56.   integer step            = 0;
  57.   global boolean opened        = false;
  58.  
  59.  
  60.   /**
  61.    * Reset the internal values.
  62.    */
  63.   define void Reset(boolean local_use_ui)``{
  64.       use_ui = local_use_ui;
  65.       step  = 0;
  66.       mount_point = "/media/floppy";
  67.   }
  68.  
  69.   /**
  70.    * Check if a floppy device exists.
  71.    */
  72.   define boolean CheckPresent()``{
  73.  
  74.       if ( ! StorageDevices::FloppyPresent )
  75.       {
  76.       // error message
  77.       string message = _("
  78. No floppy device was detected. Loading a
  79. file from a removable device is not possible.
  80. ");
  81.  
  82.       if ( use_ui ) {
  83.           Report::Error(message);
  84.       }
  85.       else {
  86.           y2error(message);
  87.       }
  88.       return false;
  89.       }
  90.       return true;
  91.   }
  92.  
  93.   /**
  94.    * Load needed fs modules.
  95.    */
  96.   define boolean LoadFsModules()``{
  97.       boolean error = false;
  98.  
  99.       foreach (string module_name, needed_fs_kernel_modules, ``{
  100.  
  101.       if ( !error ) {
  102.  
  103.           if ( !OSRModuleLoading::Load (module_name,"","","",false, true ))
  104.           {
  105.           // error popup, %1 is name of kernel module (driver)
  106.           string message = sformat(_("
  107. An error occurred while loading the %1 kernel
  108. module. Mounting the floppy device is not possible.
  109. System information cannot be read.
  110.  
  111. "), "");
  112.           if ( use_ui )
  113.               Report::Error(message);
  114.           else
  115.               y2error(message );
  116.           error = true;
  117.           }
  118.       }
  119.       });
  120.       return !error;
  121.   }
  122.  
  123.   /**
  124.    * Check the mount point! If the mount point does not exist
  125.    * CheckMountPoint create it.
  126.    */
  127.   define boolean CheckMountPoint()``{
  128.  
  129.       string command  =  sformat("/usr/bin/test -d %1", mount_point );
  130.  
  131.       if (  WFM::Execute(.local.bash, command) != 0 )  {
  132.  
  133.       // error popup (%1 is mount point, e.g. /media/floppy)
  134.       string message = sformat (_("
  135. The default floppy mount point %1
  136. does not exist and cannot be created.
  137. "), mount_point);
  138.  
  139.       if ((integer) WFM::Execute (.local.bash, sformat("if /usr/bin/test -d %1; then /bin/mkdir %1; fi", "/media" )) == 0)
  140.       {
  141.           if ((integer) WFM::Execute (.local.bash, sformat("if /usr/bin/test -d %1; then /bin/mkdir %1; fi", "/media/floppy" )) == 0)
  142.           {
  143.           return true;
  144.           }
  145.       }
  146.       if ( use_ui )
  147.           Report::Error(message);
  148.       else
  149.           y2error(message);
  150.       return false;
  151.       }
  152.       return true;
  153.   }
  154.  
  155.  
  156.   /**
  157.    * Mount default floppy device
  158.    */
  159.   define boolean Mount()``{
  160.  
  161.       //WFM::Execute(.local.bash, "/bin/umount " + mount_point );
  162.       string mpoint = Storage::DeviceMounted( floppy_device );
  163.       if ( mpoint != "") {
  164.       y2milestone("Floppy is already mounted on %1", mpoint );
  165.       mount_point = mpoint;
  166.       return true;
  167.       }
  168.  
  169.  
  170.       if ( WFM::Execute(.local.bash, "/bin/mount " + floppy_device + " "+mount_point+ " -t auto" ) != 0 )
  171.       {
  172.     // error popup
  173.     string message = _("\nAn error occurred while mounting the floppy.");
  174.     if ( use_ui )
  175.         Report::Error(message);
  176.     else
  177.         y2error(message );
  178.     return  false;
  179.       }
  180.       return true;
  181.   }
  182.  
  183.  
  184.   /**
  185.    * Unmount floppy device
  186.    */
  187.   define boolean Umount()``{
  188.       if( Storage::DeviceMounted(floppy_device) == "")
  189.       return true;
  190.       if ((integer)WFM::Execute(.local.bash, "/bin/umount "+ mount_point) != 0)
  191.       {
  192.     // error popup
  193.     string message = _("An error occurred while unmounting the floppy.");
  194.  
  195.     if ( use_ui )
  196.         Report::Error(message);
  197.     else
  198.         y2error(message );
  199.     return  false;
  200.       }
  201.       return true;
  202.   }
  203.  
  204.   /**
  205.    * Open the floppy dialog
  206.    */
  207.   define boolean OpenFloppyDialog(string label, integer steps)``{
  208.  
  209.     UI::OpenDialog (
  210.     `VBox(
  211.         `ProgressBar (`id(`progress), label, steps, 0),
  212.         `VSpacing(0.4),
  213.         `PushButton(`id(`cancel ) , Label::CancelButton() )
  214.         )
  215.     );
  216.     UI::SetFocus(`id(`cancel ));
  217.     dialog_open = true;
  218.     return true;
  219.   }
  220.  
  221.   /**
  222.    * Change the text in the floppy dialog and increase the progress bar.
  223.    * If not dialog is opened, write the test to the YaST2 log file (y2log).
  224.    */
  225.   global define void NextStep( string label ) ``{
  226.       y2milestone( label );
  227.       if ( dialog_open && use_ui ) {
  228.       step = step + 1;
  229.       UI::ChangeWidget(`id(`progress), `Value, step);
  230.       UI::ChangeWidget(`id(`progress), `Label, label );
  231.       }
  232.       else {
  233.       y2milestone( label );
  234.       }
  235.   }
  236.  
  237.   /**
  238.    * Close the floppy dialog if the dialog is opened.
  239.    */
  240.  define boolean CloseFloppyDialog()``{
  241.       if ( dialog_open ) {
  242.       if ( UI::CloseDialog() ) {
  243.           dialog_open = false;
  244.           return true;
  245.       }
  246.       y2error("Floppy Dialog could not be closed");
  247.       return false;
  248.       }
  249.       return true;
  250.   }
  251.  
  252.  /**
  253.   * Open floppy for IO.
  254.   * Afterwards you must call OSRFloppy::Close().
  255.   */
  256.   global define boolean Open(boolean use_ui, integer count_io_files )``{
  257.  
  258.       if( opened ) {
  259.       y2error("Floppy is already opened. Please use
  260. CloseFloppy(...) to close floppy device.");
  261.       return false;
  262.       }
  263.       opened = true;
  264.  
  265.       Reset( use_ui );
  266.  
  267.       //progress bar label
  268.       if  ( use_ui ) OpenFloppyDialog( _("Checking floppy device..."), count_io_files + 4 );
  269.       if ( ! CheckPresent()) return false;
  270.  
  271.       // label text
  272.       NextStep(_("Loading file system modules...") );
  273.       if ( ! LoadFsModules()) return false;
  274.  
  275.       // label text
  276.       NextStep(_("Checking mount point..."));
  277.       if ( ! CheckMountPoint()) return false;
  278.  
  279.       // label text
  280.       NextStep(_("Mounting floppy..."));
  281.       if ( ! Mount()) return false;
  282.  
  283.       return true;
  284.   }
  285.  
  286.   /**
  287.    * Close Floppy Dialog and unmount floppy device.
  288.    * You must call OSRFloppy::Open(.. ) before.
  289.    */
  290.   global define boolean Close()``{
  291.  
  292.       if( ! opened ) {
  293.       y2error("Floppy is not opend. Could not close floppy device.");
  294.       return false;
  295.       }
  296.       boolean error = false;
  297.       // label text
  298.       NextStep(_("Unmounting floppy..."));
  299.       if ( !Umount())    error = true;
  300.  
  301.       if ( use_ui )    CloseFloppyDialog();
  302.  
  303.       opened = false;
  304.       return ! error;
  305.   }
  306.  
  307.  
  308. }//EOF
  309.