Mirrors
/
gparted
mirror of https://gitlab.gnome.org/GNOME/gparted.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

changed progressfeedbackhandling a bit. Because this affected 

* changed progressfeedbackhandling a bit. Because this affected
  OperationDetail i had to make changes in almost every file.
This commit is contained in:
Bart Hakvoort 2006-08-20 09:33:54 +00:00
parent f61b537c0d
commit 889ab1232f
35 changed files with 647 additions and 608 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
ChangeLog
View File

@ -1,3 +1,8 @@
2006-08-20 Bart Hakvoort <hakvoort@cvs.gnome.org>
* changed progressfeedbackhandling a bit. Because this affected
OperationDetail i had to make changes in almost every file.
2006-08-16 Bart Hakvoort <hakvoort@cvs.gnome.org> 2006-08-16 Bart Hakvoort <hakvoort@cvs.gnome.org>
* src/GParted_Core.cc: added 'time remaining' to progressfeedback. * src/GParted_Core.cc: added 'time remaining' to progressfeedback.

7
include/Dialog_Progress.h
View File

@ -43,7 +43,8 @@ public:
sigc::signal< bool, Operation * > signal_apply_operation ; sigc::signal< bool, Operation * > signal_apply_operation ;
private: private:
void update_operation_details( const Gtk::TreeRow & treerow, const OperationDetail & operation_detail ) ; void on_signal_update( const OperationDetail & operationdetail ) ;
void dispatcher_on_update_gui_elements() ;
void on_signal_show() ; void on_signal_show() ;
void on_expander_changed() ; void on_expander_changed() ;
void on_cell_data_description( Gtk::CellRenderer * renderer, const Gtk::TreeModel::iterator & iter) ; void on_cell_data_description( Gtk::CellRenderer * renderer, const Gtk::TreeModel::iterator & iter) ;
@ -89,11 +90,15 @@ private:
treeview_operations_Columns treeview_operations_columns; treeview_operations_Columns treeview_operations_columns;
std::vector<Operation *> operations ; std::vector<Operation *> operations ;
OperationDetail operationdetail ;
bool running, succes, cancel, pulse ; bool running, succes, cancel, pulse ;
pthread_t pthread ; pthread_t pthread ;
double fraction ; double fraction ;
unsigned int t ; unsigned int t ;
Glib::ustring str_temp ; Glib::ustring str_temp ;
Glib::Dispatcher dispatcher_update_gui_elements ;
Glib::ustring label_current_sub_text ;
}; };
}//GParted }//GParted

16
include/FileSystem.h
View File

@ -34,18 +34,18 @@ public:
virtual ~FileSystem() {} virtual ~FileSystem() {}
virtual FS get_filesystem_support() = 0 ; virtual FS get_filesystem_support() = 0 ;
virtual void Set_Used_Sectors( Partition & partition ) = 0 ; virtual void set_used_sectors( Partition & partition ) = 0 ;
virtual bool Create( const Partition & new_partition, std::vector<OperationDetail> & operation_details ) = 0 ; virtual bool create( const Partition & new_partition, OperationDetail & operationdetail ) = 0 ;
virtual bool Resize( const Partition & partition_new, virtual bool resize( const Partition & partition_new,
std::vector<OperationDetail> & operation_details, OperationDetail & operationdetail,
bool fill_partition = false ) = 0 ; bool fill_partition = false ) = 0 ;
virtual bool Copy( const Glib::ustring & src_part_path, virtual bool copy( const Glib::ustring & src_part_path,
const Glib::ustring & dest_part_path, const Glib::ustring & dest_part_path,
std::vector<OperationDetail> & operation_details ) = 0 ; OperationDetail & operationdetail ) = 0 ;
virtual bool Check_Repair( const Partition & partition, std::vector<OperationDetail> & operation_details ) = 0 ; virtual bool check_repair( const Partition & partition, OperationDetail & operationdetail ) = 0 ;
protected: protected:
int execute_command( const Glib::ustring & command, std::vector<OperationDetail> & operation_details ) ; int execute_command( const Glib::ustring & command, OperationDetail & operationdetail ) ;
//those are used in several places.. //those are used in several places..
Glib::ustring output, error ; Glib::ustring output, error ;

51
include/GParted_Core.h
View File

@ -71,60 +71,54 @@ private:
void set_flags( Partition & partition ) ; void set_flags( Partition & partition ) ;
//operationstuff... //operationstuff...
bool create( const Device & device, bool create( const Device & device, Partition & new_partition, OperationDetail & operationdetail ) ;
Partition & new_partition, bool create_partition( Partition & new_partition, OperationDetail & operationdetail, Sector min_size = 0 ) ;
std::vector<OperationDetail> & operation_details ) ; bool create_filesystem( const Partition & partition, OperationDetail & operationdetail ) ;
bool create_partition( Partition & new_partition,
std::vector<OperationDetail> & operation_details,
Sector min_size = 0 ) ;
bool create_filesystem( const Partition & partition, std::vector<OperationDetail> & operation_details ) ;
bool format( const Partition & partition, std::vector<OperationDetail> & operation_details ) ; bool format( const Partition & partition, OperationDetail & operationdetail ) ;
bool Delete( const Partition & partition, std::vector<OperationDetail> & operation_details ) ; bool Delete( const Partition & partition, OperationDetail & operationdetail ) ;
bool resize_move( const Device & device, bool resize_move( const Device & device,
const Partition & partition_old, const Partition & partition_old,
Partition & partition_new, Partition & partition_new,
std::vector<OperationDetail> & operation_details ) ; OperationDetail & operationdetail ) ;
bool move( const Device & device, bool move( const Device & device,
const Partition & partition_old, const Partition & partition_old,
const Partition & partition_new, const Partition & partition_new,
std::vector<OperationDetail> & operation_details ) ; OperationDetail & operationdetail ) ;
bool move_filesystem( const Partition & partition_old, bool move_filesystem( const Partition & partition_old,
const Partition & partition_new, const Partition & partition_new,
std::vector<OperationDetail> & operation_details ) ; OperationDetail & operationdetail ) ;
bool move_filesystem_using_gparted( const Partition & partition_old, bool move_filesystem_using_gparted( const Partition & partition_old,
const Partition & partition_new, const Partition & partition_new,
std::vector<OperationDetail> & operation_details ) ; OperationDetail & operationdetail ) ;
bool resize_move_filesystem_using_libparted( const Partition & partition_old, bool resize_move_filesystem_using_libparted( const Partition & partition_old,
const Partition & partition_new, const Partition & partition_new,
std::vector<OperationDetail> & operation_details ) ; OperationDetail & operationdetail ) ;
bool resize( const Partition & partition_old, bool resize( const Partition & partition_old,
const Partition & partition_new, const Partition & partition_new,
std::vector<OperationDetail> & operation_detail ) ; OperationDetail & operationdetail ) ;
bool resize_move_partition( const Partition & partition_old, bool resize_move_partition( const Partition & partition_old,
const Partition & partition_new, const Partition & partition_new,
std::vector<OperationDetail> & operation_details ) ; OperationDetail & operationdetail ) ;
bool resize_filesystem( const Partition & partition_old, bool resize_filesystem( const Partition & partition_old,
const Partition & partition_new, const Partition & partition_new,
std::vector<OperationDetail> & operation_details, OperationDetail & operationdetail,
bool fill_partition = false ) ; bool fill_partition = false ) ;
bool maximize_filesystem( const Partition & partition, bool maximize_filesystem( const Partition & partition, OperationDetail & operationdetail ) ;
std::vector<OperationDetail> & operation_details ) ;
bool copy( const Partition & partition_src, bool copy( const Partition & partition_src,
Partition & partition_dest, Partition & partition_dest,
Sector min_size, Sector min_size,
std::vector<OperationDetail> & operation_details ) ; OperationDetail & operationdetail ) ;
bool copy_filesystem( const Partition & partition_src, bool copy_filesystem( const Partition & partition_src,
const Partition & partition_dest, const Partition & partition_dest,
std::vector<OperationDetail> & operation_details ) ; OperationDetail & operationdetail ) ;
bool check_repair_filesystem( const Partition & partition, std::vector<OperationDetail> & operation_details ) ; bool check_repair_filesystem( const Partition & partition, OperationDetail & operationdetail ) ;
bool set_partition_type( const Partition & partition, bool set_partition_type( const Partition & partition, OperationDetail & operationdetail ) ;
std::vector<OperationDetail> & operation_details ) ;
void set_progress_info( Sector total, Sector done, std::time_t time_start, OperationDetail & operationdetail ) ; void set_progress_info( Sector total, Sector done, std::time_t time_start, OperationDetail & operationdetail ) ;
@ -138,7 +132,7 @@ private:
CopyType copytype, CopyType copytype,
Sector & optimal_blocksize, Sector & optimal_blocksize,
Sector & offset, Sector & offset,
std::vector<OperationDetail> & operation_details ) ; OperationDetail & operationdetail ) ;
bool copy_blocks( const Glib::ustring & src_device, bool copy_blocks( const Glib::ustring & src_device,
const Glib::ustring & dst_device, const Glib::ustring & dst_device,
@ -146,9 +140,8 @@ private:
Sector dst_start, Sector dst_start,
Sector blocksize, Sector blocksize,
Sector sectors, Sector sectors,
std::vector<OperationDetail> & operation_details, OperationDetail & operationdetail,
CopyType copytype, CopyType copytype ) ;
bool show_progress = true ) ;
bool copy_block( PedDevice * lp_device_src, bool copy_block( PedDevice * lp_device_src,
PedDevice * lp_device_dst, PedDevice * lp_device_dst,
@ -158,7 +151,7 @@ private:
Glib::ustring & error_message ) ; Glib::ustring & error_message ) ;
bool calculate_exact_geom( const Partition & partition_old, bool calculate_exact_geom( const Partition & partition_old,
Partition & partition_new, Partition & partition_new,
std::vector<OperationDetail> & operation_details, OperationDetail & operationdetail,
Sector min_size = -1 ) ; Sector min_size = -1 ) ;
bool set_proper_filesystem( const FILESYSTEM & filesystem ) ; bool set_proper_filesystem( const FILESYSTEM & filesystem ) ;
bool wait_for_node( const Glib::ustring & node ) ; bool wait_for_node( const Glib::ustring & node ) ;

21
include/OperationDetail.h
View File

@ -51,15 +51,30 @@ public:
Font font = FONT_NORMAL ) ; Font font = FONT_NORMAL ) ;
void set_description( const Glib::ustring & description, Font font = FONT_NORMAL ) ; void set_description( const Glib::ustring & description, Font font = FONT_NORMAL ) ;
Glib::ustring get_description() const ; Glib::ustring get_description() const ;
void set_status( OperationDetailStatus status ) ;
OperationDetailStatus get_status() const ;
void set_treepath( const Glib::ustring & treepath ) ;
Glib::ustring get_treepath() const ;
void add_child( const OperationDetail & operationdetail ) ;
std::vector<OperationDetail> & get_childs() ;
const std::vector<OperationDetail> & get_childs() const ;
OperationDetail & get_last_child() ;
OperationDetailStatus status ;
double fraction ; double fraction ;
Glib::ustring progress_text ; Glib::ustring progress_text ;
std::vector<OperationDetail> sub_details ; sigc::signal< void, const OperationDetail & > signal_update ;
private: private:
void on_update( const OperationDetail & operationdetail ) ;
Glib::ustring description ; Glib::ustring description ;
OperationDetailStatus status ;
Glib::ustring treepath ;
std::vector<OperationDetail> sub_details ;
}; };
} //GParted } //GParted

14
include/ext2.h
View File

@ -28,15 +28,13 @@ class ext2 : public FileSystem
{ {
public: public:
FS get_filesystem_support() ; FS get_filesystem_support() ;
void Set_Used_Sectors( Partition & partition ) ; void set_used_sectors( Partition & partition ) ;
bool Create( const Partition & new_partition, std::vector<OperationDetail> & operation_details ) ; bool create( const Partition & new_partition, OperationDetail & operationdetail ) ;
bool Resize( const Partition & partition_new, bool resize( const Partition & partition_new, OperationDetail & operationdetail, bool fill_partition = false ) ;
std::vector<OperationDetail> & operation_details, bool copy( const Glib::ustring & src_part_path,
bool fill_partition = false ) ;
bool Copy( const Glib::ustring & src_part_path,
const Glib::ustring & dest_part_path, const Glib::ustring & dest_part_path,
std::vector<OperationDetail> & operation_details ) ; OperationDetail & operationdetail ) ;
bool Check_Repair( const Partition & partition, std::vector<OperationDetail> & operation_details ) ; bool check_repair( const Partition & partition, OperationDetail & operationdetail ) ;
}; };
} //GParted } //GParted

14
include/ext3.h
View File

@ -28,15 +28,13 @@ class ext3 : public FileSystem
{ {
public: public:
FS get_filesystem_support() ; FS get_filesystem_support() ;
void Set_Used_Sectors( Partition & partition ) ; void set_used_sectors( Partition & partition ) ;
bool Create( const Partition & new_partition, std::vector<OperationDetail> & operation_details ) ; bool create( const Partition & new_partition, OperationDetail & operationdetail ) ;
bool Resize( const Partition & partition_new, bool resize( const Partition & partition_new, OperationDetail & operationdetail, bool fill_partition = false ) ;
std::vector<OperationDetail> & operation_details, bool copy( const Glib::ustring & src_part_path,
bool fill_partition = false ) ;
bool Copy( const Glib::ustring & src_part_path,
const Glib::ustring & dest_part_path, const Glib::ustring & dest_part_path,
std::vector<OperationDetail> & operation_details ) ; OperationDetail & operationdetail ) ;
bool Check_Repair( const Partition & partition, std::vector<OperationDetail> & operation_details ) ; bool check_repair( const Partition & partition, OperationDetail & operationdetail ) ;
}; };

14
include/fat16.h
View File

@ -28,15 +28,13 @@ class fat16 : public FileSystem
{ {
public: public:
FS get_filesystem_support() ; FS get_filesystem_support() ;
void Set_Used_Sectors( Partition & partition ) ; void set_used_sectors( Partition & partition ) ;
bool Create( const Partition & new_partition, std::vector<OperationDetail> & operation_details ) ; bool create( const Partition & new_partition, OperationDetail & operationdetail ) ;
bool Resize( const Partition & partition_new, bool resize( const Partition & partition_new, OperationDetail & operationdetail, bool fill_partition = false ) ;
std::vector<OperationDetail> & operation_details, bool copy( const Glib::ustring & src_part_path,
bool fill_partition = false ) ;
bool Copy( const Glib::ustring & src_part_path,
const Glib::ustring & dest_part_path, const Glib::ustring & dest_part_path,
std::vector<OperationDetail> & operation_details ) ; OperationDetail & operationdetail ) ;
bool Check_Repair( const Partition & partition, std::vector<OperationDetail> & operation_details ) ; bool check_repair( const Partition & partition, OperationDetail & operationdetail ) ;
}; };
} //GParted } //GParted

14
include/fat32.h
View File

@ -28,15 +28,13 @@ class fat32 : public FileSystem
{ {
public: public:
FS get_filesystem_support(); FS get_filesystem_support();
void Set_Used_Sectors( Partition & partition ) ; void set_used_sectors( Partition & partition ) ;
bool Create( const Partition & new_partition, std::vector<OperationDetail> & operation_details ) ; bool create( const Partition & new_partition, OperationDetail & operationdetail ) ;
bool Resize( const Partition & partition_new, bool resize( const Partition & partition_new, OperationDetail & operationdetail, bool fill_partition = false ) ;
std::vector<OperationDetail> & operation_details, bool copy( const Glib::ustring & src_part_path,
bool fill_partition = false ) ;
bool Copy( const Glib::ustring & src_part_path,
const Glib::ustring & dest_part_path, const Glib::ustring & dest_part_path,
std::vector<OperationDetail> & operation_details ) ; OperationDetail & operationdetail ) ;
bool Check_Repair( const Partition & partition, std::vector<OperationDetail> & operation_details ) ; bool check_repair( const Partition & partition, OperationDetail & operationdetail ) ;
}; };
} //GParted } //GParted

14
include/hfs.h
View File

@ -28,15 +28,13 @@ class hfs : public FileSystem
{ {
public: public:
FS get_filesystem_support() ; FS get_filesystem_support() ;
void Set_Used_Sectors( Partition & partition ) ; void set_used_sectors( Partition & partition ) ;
bool Create( const Partition & new_partition, std::vector<OperationDetail> & operation_details ) ; bool create( const Partition & new_partition, OperationDetail & operationdetail ) ;
bool Resize( const Partition & partition_new, bool resize( const Partition & partition_new, OperationDetail & operationdetail, bool fill_partition = false ) ;
std::vector<OperationDetail> & operation_details, bool copy( const Glib::ustring & src_part_path,
bool fill_partition = false ) ;
bool Copy( const Glib::ustring & src_part_path,
const Glib::ustring & dest_part_path, const Glib::ustring & dest_part_path,
std::vector<OperationDetail> & operation_details ) ; OperationDetail & operationdetail ) ;
bool Check_Repair( const Partition & partition, std::vector<OperationDetail> & operation_details ) ; bool check_repair( const Partition & partition, OperationDetail & operationdetail ) ;
}; };
} //GParted } //GParted

14
include/hfsplus.h
View File

@ -28,15 +28,13 @@ class hfsplus : public FileSystem
{ {
public: public:
FS get_filesystem_support() ; FS get_filesystem_support() ;
void Set_Used_Sectors( Partition & partition ) ; void set_used_sectors( Partition & partition ) ;
bool Create( const Partition & new_partition, std::vector<OperationDetail> & operation_details ) ; bool create( const Partition & new_partition, OperationDetail & operationdetail ) ;
bool Resize( const Partition & partition_new, bool resize( const Partition & partition_new, OperationDetail & operationdetail, bool fill_partition = false ) ;
std::vector<OperationDetail> & operation_details, bool copy( const Glib::ustring & src_part_path,
bool fill_partition = false ) ;
bool Copy( const Glib::ustring & src_part_path,
const Glib::ustring & dest_part_path, const Glib::ustring & dest_part_path,
std::vector<OperationDetail> & operation_details ) ; OperationDetail & operationdetail ) ;
bool Check_Repair( const Partition & partition, std::vector<OperationDetail> & operation_details ) ; bool check_repair( const Partition & partition, OperationDetail & operationdetail ) ;
}; };
} //GParted } //GParted

14
include/jfs.h
View File

@ -28,15 +28,13 @@ class jfs : public FileSystem
{ {
public: public:
FS get_filesystem_support() ; FS get_filesystem_support() ;
void Set_Used_Sectors( Partition & partition ) ; void set_used_sectors( Partition & partition ) ;
bool Create( const Partition & new_partition, std::vector<OperationDetail> & operation_details ) ; bool create( const Partition & new_partition, OperationDetail & operationdetail ) ;
bool Resize( const Partition & partition_new, bool resize( const Partition & partition_new, OperationDetail & operationdetail, bool fill_partition = false ) ;
std::vector<OperationDetail> & operation_details, bool copy( const Glib::ustring & src_part_path,
bool fill_partition = false ) ;
bool Copy( const Glib::ustring & src_part_path,
const Glib::ustring & dest_part_path, const Glib::ustring & dest_part_path,
std::vector<OperationDetail> & operation_details ) ; OperationDetail & operationdetail ) ;
bool Check_Repair( const Partition & partition, std::vector<OperationDetail> & operation_details ) ; bool check_repair( const Partition & partition, OperationDetail & operationdetail ) ;
}; };
} //GParted } //GParted

14
include/linux_swap.h
View File

@ -28,15 +28,13 @@ class linux_swap : public FileSystem
{ {
public: public:
FS get_filesystem_support() ; FS get_filesystem_support() ;
void Set_Used_Sectors( Partition & partition ) ; void set_used_sectors( Partition & partition ) ;
bool Create( const Partition & new_partition, std::vector<OperationDetail> & operation_details ) ; bool create( const Partition & new_partition, OperationDetail & operationdetail ) ;
bool Resize( const Partition & partition_new, bool resize( const Partition & partition_new, OperationDetail & operationdetail, bool fill_partition = false ) ;
std::vector<OperationDetail> & operation_details, bool copy( const Glib::ustring & src_part_path,
bool fill_partition = false ) ;
bool Copy( const Glib::ustring & src_part_path,
const Glib::ustring & dest_part_path, const Glib::ustring & dest_part_path,
std::vector<OperationDetail> & operation_details ) ; OperationDetail & operationdetail ) ;
bool Check_Repair( const Partition & partition, std::vector<OperationDetail> & operation_details ) ; bool check_repair( const Partition & partition, OperationDetail & operationdetail ) ;
}; };
} //GParted } //GParted

14
include/ntfs.h
View File

@ -28,15 +28,13 @@ class ntfs : public FileSystem
{ {
public: public:
FS get_filesystem_support() ; FS get_filesystem_support() ;
void Set_Used_Sectors( Partition & partition ) ; void set_used_sectors( Partition & partition ) ;
bool Create( const Partition & new_partition, std::vector<OperationDetail> & operation_details ) ; bool create( const Partition & new_partition, OperationDetail & operationdetail ) ;
bool Resize( const Partition & partition_new, bool resize( const Partition & partition_new, OperationDetail & operationdetail, bool fill_partition = false ) ;
std::vector<OperationDetail> & operation_details, bool copy( const Glib::ustring & src_part_path,
bool fill_partition = false ) ;
bool Copy( const Glib::ustring & src_part_path,
const Glib::ustring & dest_part_path, const Glib::ustring & dest_part_path,
std::vector<OperationDetail> & operation_details ) ; OperationDetail & operationdetail ) ;
bool Check_Repair( const Partition & partition, std::vector<OperationDetail> & operation_details ) ; bool check_repair( const Partition & partition, OperationDetail & operationdetail ) ;
}; };
} //GParted } //GParted

14
include/reiser4.h
View File

@ -28,15 +28,13 @@ class reiser4 : public FileSystem
{ {
public: public:
FS get_filesystem_support() ; FS get_filesystem_support() ;
void Set_Used_Sectors( Partition & partition ) ; void set_used_sectors( Partition & partition ) ;
bool Create( const Partition & new_partition, std::vector<OperationDetail> & operation_details ) ; bool create( const Partition & new_partition, OperationDetail & operationdetail ) ;
bool Resize( const Partition & partition_new, bool resize( const Partition & partition_new, OperationDetail & operationdetail, bool fill_partition = false ) ;
std::vector<OperationDetail> & operation_details, bool copy( const Glib::ustring & src_part_path,
bool fill_partition = false ) ;
bool Copy( const Glib::ustring & src_part_path,
const Glib::ustring & dest_part_path, const Glib::ustring & dest_part_path,
std::vector<OperationDetail> & operation_details ) ; OperationDetail & operationdetail ) ;
bool Check_Repair( const Partition & partition, std::vector<OperationDetail> & operation_details ) ; bool check_repair( const Partition & partition, OperationDetail & operationdetail ) ;
}; };
} //GParted } //GParted

14
include/reiserfs.h
View File

@ -28,15 +28,13 @@ class reiserfs : public FileSystem
{ {
public: public:
FS get_filesystem_support() ; FS get_filesystem_support() ;
void Set_Used_Sectors( Partition & partition ) ; void set_used_sectors( Partition & partition ) ;
bool Create( const Partition & new_partition, std::vector<OperationDetail> & operation_details ) ; bool create( const Partition & new_partition, OperationDetail & operationdetail ) ;
bool Resize( const Partition & partition_new, bool resize( const Partition & partition_new, OperationDetail & operationdetail, bool fill_partition = false ) ;
std::vector<OperationDetail> & operation_details, bool copy( const Glib::ustring & src_part_path,
bool fill_partition = false ) ;
bool Copy( const Glib::ustring & src_part_path,
const Glib::ustring & dest_part_path, const Glib::ustring & dest_part_path,
std::vector<OperationDetail> & operation_details ) ; OperationDetail & operationdetail ) ;
bool Check_Repair( const Partition & partition, std::vector<OperationDetail> & operation_details ) ; bool check_repair( const Partition & partition, OperationDetail & operationdetail ) ;
}; };
} //GParted } //GParted

14
include/ufs.h
View File

@ -28,15 +28,13 @@ class ufs : public FileSystem
{ {
public: public:
FS get_filesystem_support() ; FS get_filesystem_support() ;
void Set_Used_Sectors( Partition & partition ) ; void set_used_sectors( Partition & partition ) ;
bool Create( const Partition & new_partition, std::vector<OperationDetail> & operation_details ) ; bool create( const Partition & new_partition, OperationDetail & operationdetail ) ;
bool Resize( const Partition & partition_new, bool resize( const Partition & partition_new, OperationDetail & operationdetail, bool fill_partition = false ) ;
std::vector<OperationDetail> & operation_details, bool copy( const Glib::ustring & src_part_path,
bool fill_partition = false ) ;
bool Copy( const Glib::ustring & src_part_path,
const Glib::ustring & dest_part_path, const Glib::ustring & dest_part_path,
std::vector<OperationDetail> & operation_details ) ; OperationDetail & operationdetail ) ;
bool Check_Repair( const Partition & partition, std::vector<OperationDetail> & operation_details ) ; bool check_repair( const Partition & partition, OperationDetail & operationdetail ) ;
}; };
} //GParted } //GParted

14
include/xfs.h
View File

@ -28,15 +28,13 @@ class xfs : public FileSystem
{ {
public: public:
FS get_filesystem_support() ; FS get_filesystem_support() ;
void Set_Used_Sectors( Partition & partition ) ; void set_used_sectors( Partition & partition ) ;
bool Create( const Partition & new_partition, std::vector<OperationDetail> & operation_details ) ; bool create( const Partition & new_partition, OperationDetail & operationdetail ) ;
bool Resize( const Partition & partition_new, bool resize( const Partition & partition_new, OperationDetail & operationdetail, bool fill_partition = false ) ;
std::vector<OperationDetail> & operation_details, bool copy( const Glib::ustring & src_part_path,
bool fill_partition = false ) ;
bool Copy( const Glib::ustring & src_part_path,
const Glib::ustring & dest_part_path, const Glib::ustring & dest_part_path,
std::vector<OperationDetail> & operation_details ) ; OperationDetail & operationdetail ) ;
bool Check_Repair( const Partition & partition, std::vector<OperationDetail> & operation_details ) ; bool check_repair( const Partition & partition, OperationDetail & operationdetail ) ;
}; };
} //GParted } //GParted

145
src/Dialog_Progress.cc
View File

@ -35,6 +35,9 @@ Dialog_Progress::Dialog_Progress( const std::vector<Operation *> & operations )
cancel = false ; cancel = false ;
fraction = 1.00 / operations .size() ; fraction = 1.00 / operations .size() ;
dispatcher_update_gui_elements .connect(
sigc::mem_fun( this, &Dialog_Progress::dispatcher_on_update_gui_elements ) ) ;
Glib::ustring str_temp = "<span weight=\"bold\" size=\"larger\">" ; Glib::ustring str_temp = "<span weight=\"bold\" size=\"larger\">" ;
str_temp += _("Applying pending operations") ; str_temp += _("Applying pending operations") ;
@ -54,7 +57,8 @@ Dialog_Progress::Dialog_Progress( const std::vector<Operation *> & operations )
label_current_sub .set_alignment( Gtk::ALIGN_LEFT ); label_current_sub .set_alignment( Gtk::ALIGN_LEFT );
this ->get_vbox() ->pack_start( label_current_sub, Gtk::PACK_SHRINK ); this ->get_vbox() ->pack_start( label_current_sub, Gtk::PACK_SHRINK );
this ->get_vbox() ->pack_start( * Utils::mk_label( "<b>" + static_cast<Glib::ustring>( _("Completed Operations:") ) + "</b>" ), Gtk::PACK_SHRINK ); this ->get_vbox() ->pack_start( * Utils::mk_label( "<b>" + Glib::ustring( _("Completed Operations:") ) + "</b>" ),
Gtk::PACK_SHRINK );
this ->get_vbox() ->pack_start( progressbar_all, Gtk::PACK_SHRINK ); this ->get_vbox() ->pack_start( progressbar_all, Gtk::PACK_SHRINK );
//create some icons here, instead of recreating them every time //create some icons here, instead of recreating them every time
@ -77,6 +81,7 @@ Dialog_Progress::Dialog_Progress( const std::vector<Operation *> & operations )
for ( unsigned int t = 0 ; t < operations .size() ; t++ ) for ( unsigned int t = 0 ; t < operations .size() ; t++ )
{ {
this ->operations[ t ] ->operation_detail .set_description( operations[ t ] ->description, FONT_BOLD ) ; this ->operations[ t ] ->operation_detail .set_description( operations[ t ] ->description, FONT_BOLD ) ;
this ->operations[ t ] ->operation_detail .set_treepath( Utils::num_to_str( t ) ) ;
treerow = *( treestore_operations ->append() ); treerow = *( treestore_operations ->append() );
treerow[ treeview_operations_columns .operation_icon ] = operations[ t ] ->icon ; treerow[ treeview_operations_columns .operation_icon ] = operations[ t ] ->icon ;
@ -94,7 +99,7 @@ Dialog_Progress::Dialog_Progress( const std::vector<Operation *> & operations )
scrolledwindow .set_policy( Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC ) ; scrolledwindow .set_policy( Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC ) ;
scrolledwindow .add( treeview_operations ) ; scrolledwindow .add( treeview_operations ) ;
expander_details .set_label( "<b>" + static_cast<Glib::ustring>( _("Details") ) + "</b>" ) ; expander_details .set_label( "<b>" + Glib::ustring( _("Details") ) + "</b>" ) ;
expander_details .set_use_markup( true ) ; expander_details .set_use_markup( true ) ;
expander_details .property_expanded() .signal_changed() .connect( expander_details .property_expanded() .signal_changed() .connect(
sigc::mem_fun(*this, &Dialog_Progress::on_expander_changed) ); sigc::mem_fun(*this, &Dialog_Progress::on_expander_changed) );
@ -109,81 +114,85 @@ Dialog_Progress::Dialog_Progress( const std::vector<Operation *> & operations )
this ->show_all_children() ; this ->show_all_children() ;
} }
void Dialog_Progress::update_operation_details( const Gtk::TreeRow & treerow, void Dialog_Progress::on_signal_update( const OperationDetail & operationdetail )
const OperationDetail & operation_detail )
{ {
//append new rows (if any) Gtk::TreeModel::iterator iter = treestore_operations ->get_iter( operationdetail .get_treepath() ) ;
for ( unsigned int t = treerow .children() .size() ; t < operation_detail .sub_details .size() ; t++ )
{
Gtk::TreeRow treerow_child = *( treestore_operations ->append( treerow .children() ) ) ;
//FIXME, consider adding a textwidget to the tree for storing the text. simply storing text directly in the tree
//doesn't work with HUGE amounts of text.
treerow_child[ treeview_operations_columns .operation_description ] =
operation_detail .sub_details[ t ] .get_description() ;
treerow_child[ treeview_operations_columns .hidden_status ] = STATUS_NONE ;
}
//check status and update if necessary
if ( operation_detail .status != treerow[ treeview_operations_columns .hidden_status ] )
{
treerow[ treeview_operations_columns .hidden_status ] = operation_detail .status ;
switch ( operation_detail .status ) if ( iter )
{
Gtk::TreeRow treerow = *iter ;
treerow[ treeview_operations_columns .operation_description ] = operationdetail .get_description() ;
switch ( operationdetail .get_status() )
{ {
case STATUS_EXECUTE: case STATUS_EXECUTE:
treerow[ treeview_operations_columns .status_icon ] = icon_execute ; treerow[ treeview_operations_columns .status_icon ] = icon_execute ;
break ; break ;
case STATUS_SUCCES: case STATUS_SUCCES:
treerow[ treeview_operations_columns .status_icon ] = icon_succes ; treerow[ treeview_operations_columns .status_icon ] = icon_succes ;
break ; break ;
case STATUS_ERROR: case STATUS_ERROR:
treerow[ treeview_operations_columns .status_icon ] = icon_error ; treerow[ treeview_operations_columns .status_icon ] = icon_error ;
break ; break ;
case STATUS_INFO: case STATUS_INFO:
treerow[ treeview_operations_columns .status_icon ] = icon_info ; treerow[ treeview_operations_columns .status_icon ] = icon_info ;
break ; break ;
case STATUS_N_A: case STATUS_N_A:
treerow[ treeview_operations_columns .status_icon ] = icon_n_a ; treerow[ treeview_operations_columns .status_icon ] = icon_n_a ;
break ; break ;
case STATUS_NONE:
default : static_cast< Glib::RefPtr<Gdk::Pixbuf> >(
treerow[ treeview_operations_columns .hidden_status ] = STATUS_NONE ; treerow[ treeview_operations_columns .status_icon ] ) .clear() ;
break ; break ;
} }
pulse = operationdetail .fraction < 0 ;
//update the gui elements..
this ->operationdetail = operationdetail ;
if ( operationdetail .get_status() == STATUS_EXECUTE )
label_current_sub_text = operationdetail .get_description() ;
dispatcher_update_gui_elements() ;
} }
else//it's an new od which needs to be added to the model.
//check description and update if necessary
//FIXME: it feels quite inefficient to do this for every row, maybe we should add a new status which indicates
//this row may be changed and should be checked...(otoh, if/when we start displaying the output of the command
//in realtime almost every row is going to need this and such a status might become useless...)
if ( operation_detail .get_description() != treerow[ treeview_operations_columns .operation_description ] )
treerow[ treeview_operations_columns .operation_description ] = operation_detail .get_description() ;
if ( operation_detail .fraction >= 0 )
{ {
pulse = false ; unsigned int pos = operationdetail .get_treepath() .rfind( ":" ) ;
progressbar_current .set_fraction( operation_detail .fraction ) ; if ( pos >= 0 && pos < operationdetail .get_treepath() .length() )
progressbar_current .set_text( operation_detail .progress_text ) ; iter= treestore_operations ->get_iter(
} operationdetail .get_treepath() .substr( 0,
else operationdetail .get_treepath() .rfind( ":" ) ) ) ;
pulse = true ; else
iter= treestore_operations ->get_iter( operationdetail .get_treepath() ) ;
//and update the children.. (since sometimes freshly added treerows are not appended yet to the children() list if ( iter)
//we also check if t < treerow .children() .size()) {
for ( unsigned int t = 0 ; t < operation_detail .sub_details .size() && t < treerow .children() .size() ; t++ ) treestore_operations ->append( static_cast<Gtk::TreeRow>( *iter) .children() ) ;
update_operation_details( treerow .children()[ t ], operation_detail .sub_details[ t ] ) ; on_signal_update( operationdetail ) ;
}
}
}
void Dialog_Progress::dispatcher_on_update_gui_elements()
{
label_current_sub .set_markup( "<i>" + label_current_sub_text + "</i>\n" ) ;
if ( operationdetail .fraction >= 0 )
{
progressbar_current .set_fraction( operationdetail .fraction ) ;
progressbar_current .set_text( operationdetail .progress_text ) ;
}
} }
void Dialog_Progress::on_signal_show() void Dialog_Progress::on_signal_show()
{ {
for ( t = 0 ; t < operations .size() && succes && ! cancel ; t++ ) for ( t = 0 ; t < operations .size() && succes && ! cancel ; t++ )
{ {
operations[ t ] ->operation_detail .signal_update .connect(
sigc::mem_fun( this, &Dialog_Progress::on_signal_update ) ) ;
label_current .set_markup( "<b>" + operations[ t ] ->description + "</b>" ) ; label_current .set_markup( "<b>" + operations[ t ] ->description + "</b>" ) ;
progressbar_all .set_text( String::ucompose( _("%1 of %2 operations completed"), t, operations .size() ) ) ; progressbar_all .set_text( String::ucompose( _("%1 of %2 operations completed"), t, operations .size() ) ) ;
@ -192,8 +201,7 @@ void Dialog_Progress::on_signal_show()
treerow = treestore_operations ->children()[ t ] ; treerow = treestore_operations ->children()[ t ] ;
//set status to 'execute' //set status to 'execute'
operations[ t ] ->operation_detail .status = STATUS_EXECUTE ; operations[ t ] ->operation_detail .set_status( STATUS_EXECUTE ) ;
update_operation_details( treerow, operations[ t ] ->operation_detail ) ;
//set focus... //set focus...
treeview_operations .set_cursor( static_cast<Gtk::TreePath>( treerow ) ) ; treeview_operations .set_cursor( static_cast<Gtk::TreePath>( treerow ) ) ;
@ -202,20 +210,8 @@ void Dialog_Progress::on_signal_show()
running = true ; running = true ;
pthread_create( & pthread, NULL, Dialog_Progress::static_pthread_apply_operation, this ); pthread_create( & pthread, NULL, Dialog_Progress::static_pthread_apply_operation, this );
int ms = 200 ; //'refreshrate' of the treeview..
while ( running ) while ( running )
{ {
if ( ms >= 200 )
{
update_operation_details( treerow, operations[ t ] ->operation_detail ) ;
if ( operations[ t ] ->operation_detail .sub_details .size() > 0 )
label_current_sub .set_markup(//FIXME: move this to update_operation_details and
//show every sub that has STATUS_EXECUTE...
"<i>" +
operations[ t ] ->operation_detail .sub_details .back() .get_description() +
"</i>\n" ) ;
ms = 0 ;
}
if ( pulse ) if ( pulse )
progressbar_current .pulse() ; progressbar_current .pulse() ;
@ -223,12 +219,10 @@ void Dialog_Progress::on_signal_show()
Gtk::Main::iteration(); Gtk::Main::iteration();
usleep( 10000 ) ; usleep( 10000 ) ;
ms += 10 ;
} }
//set status (succes/error) for this operation //set status (succes/error) for this operation
operations[ t ] ->operation_detail .status = succes ? STATUS_SUCCES : STATUS_ERROR ; operations[ t ] ->operation_detail .set_status( succes ? STATUS_SUCCES : STATUS_ERROR ) ;
update_operation_details( treerow, operations[ t ] ->operation_detail ) ;
} }
//add save button //add save button
@ -355,10 +349,10 @@ void Dialog_Progress::on_save()
} }
} }
void Dialog_Progress::echo_operation_details( const OperationDetail & operation_detail, std::ofstream & out ) void Dialog_Progress::echo_operation_details( const OperationDetail & operationdetail, std::ofstream & out )
{ {
//replace '\n' with '<br>' //replace '\n' with '<br>'
Glib::ustring temp = operation_detail .get_description() ; Glib::ustring temp = operationdetail .get_description() ;
for ( unsigned int index = temp .find( "\n" ) ; index < temp .length() ; index = temp .find( "\n" ) ) for ( unsigned int index = temp .find( "\n" ) ; index < temp .length() ; index = temp .find( "\n" ) )
temp .replace( index, 1, "<BR />" ) ; temp .replace( index, 1, "<BR />" ) ;
@ -369,10 +363,10 @@ void Dialog_Progress::echo_operation_details( const OperationDetail & operation_
out << temp ; out << temp ;
//show status... //show status...
if ( operation_detail .status != STATUS_NONE ) if ( operationdetail .get_status() != STATUS_NONE )
{ {
out << "&nbsp;&nbsp;&nbsp;&nbsp;" ; out << "&nbsp;&nbsp;&nbsp;&nbsp;" ;
switch ( operation_detail .status ) switch ( operationdetail .get_status() )
{ {
case STATUS_EXECUTE: case STATUS_EXECUTE:
out << "( EXECUTING )" ; out << "( EXECUTING )" ;
@ -383,6 +377,12 @@ void Dialog_Progress::echo_operation_details( const OperationDetail & operation_
case STATUS_ERROR: case STATUS_ERROR:
out << "( ERROR )" ; out << "( ERROR )" ;
break ; break ;
case STATUS_INFO:
out << "( INFO )" ;
break ;
case STATUS_N_A:
out << "( N/A )" ;
break ;
default: default:
break ; break ;
@ -393,19 +393,18 @@ void Dialog_Progress::echo_operation_details( const OperationDetail & operation_
out << "</TD>" << std::endl ; out << "</TD>" << std::endl ;
out << "</TR>" << std::endl ; out << "</TR>" << std::endl ;
if ( operation_detail .sub_details. size() ) if ( operationdetail .get_childs(). size() )
{ {
out << "<TR>" << std::endl ; out << "<TR>" << std::endl ;
out << "<TD>&nbsp;&nbsp;&nbsp;&nbsp;</TD>" << std::endl ; out << "<TD>&nbsp;&nbsp;&nbsp;&nbsp;</TD>" << std::endl ;
out << "<TD>" << std::endl ; out << "<TD>" << std::endl ;
for ( unsigned int t = 0 ; t < operation_detail .sub_details .size() ; t++ ) for ( unsigned int t = 0 ; t < operationdetail .get_childs() .size() ; t++ )
echo_operation_details( operation_detail .sub_details[ t ], out ) ; echo_operation_details( operationdetail .get_childs()[ t ], out ) ;
out << "</TD>" << std::endl ; out << "</TD>" << std::endl ;
out << "</TR>" << std::endl ; out << "</TR>" << std::endl ;
} }
out << "</TABLE>" << std::endl ; out << "</TABLE>" << std::endl ;
} }

8
src/FileSystem.cc
View File

@ -25,17 +25,17 @@ FileSystem::FileSystem()
{ {
} }
int FileSystem::execute_command( const Glib::ustring & command, std::vector<OperationDetail> & operation_details ) int FileSystem::execute_command( const Glib::ustring & command, OperationDetail & operationdetail )
{ {
operation_details .push_back( OperationDetail( command, STATUS_NONE, FONT_BOLD_ITALIC ) ) ; operationdetail .add_child( OperationDetail( command, STATUS_NONE, FONT_BOLD_ITALIC ) ) ;
int exit_status = Utils::execute_command( command, output, error ) ; int exit_status = Utils::execute_command( command, output, error ) ;
if ( ! output .empty() ) if ( ! output .empty() )
operation_details .back() .sub_details .push_back( OperationDetail( output, STATUS_NONE, FONT_ITALIC ) ) ; operationdetail .get_last_child() .add_child( OperationDetail( output, STATUS_NONE, FONT_ITALIC ) ) ;
if ( ! error .empty() ) if ( ! error .empty() )
operation_details .back() .sub_details .push_back( OperationDetail( error, STATUS_NONE, FONT_ITALIC ) ) ; operationdetail .get_last_child() .add_child( OperationDetail( error, STATUS_NONE, FONT_ITALIC ) ) ;
return exit_status ; return exit_status ;
} }

328
src/GParted_Core.cc
View File

@ -232,6 +232,8 @@ bool GParted_Core::snap_to_cylinder( const Device & device, Partition & partitio
{ {
if ( ! partition .strict ) if ( ! partition .strict )
{ {
//FIXME: this doesn't work to well, when dealing with layouts which contain an extended partition
//because of the metadata length % cylindersize isn't always 0
Sector diff = partition .sector_start % device .cylsize ; Sector diff = partition .sector_start % device .cylsize ;
if ( diff ) if ( diff )
{ {
@ -288,7 +290,7 @@ bool GParted_Core::apply_operation_to_disk( Operation * operation )
if ( operation ->partition_original .status == GParted::STAT_COPY ) if ( operation ->partition_original .status == GParted::STAT_COPY )
{ {
succes = false ; succes = false ;
operation ->operation_detail .sub_details .push_back( operation ->operation_detail .add_child(
OperationDetail( String::ucompose( _("find real path of %1"), OperationDetail( String::ucompose( _("find real path of %1"),
operation ->partition_original .get_path() ) ) ) ; operation ->partition_original .get_path() ) ) ) ;
@ -307,7 +309,7 @@ bool GParted_Core::apply_operation_to_disk( Operation * operation )
free( lp_path ) ; free( lp_path ) ;
succes = true ; succes = true ;
operation ->operation_detail .sub_details .back() .sub_details .push_back( operation ->operation_detail .get_last_child() .add_child(
OperationDetail( String::ucompose( _("path: %1"), OperationDetail( String::ucompose( _("path: %1"),
operation ->partition_new .get_path() ), operation ->partition_new .get_path() ),
STATUS_NONE, STATUS_NONE,
@ -317,30 +319,28 @@ bool GParted_Core::apply_operation_to_disk( Operation * operation )
close_device_and_disk() ; close_device_and_disk() ;
} }
operation ->operation_detail .sub_details .back() .status = succes ? STATUS_SUCCES : STATUS_ERROR ; operation ->operation_detail .get_last_child() .set_status( succes ? STATUS_SUCCES : STATUS_ERROR ) ;
} }
if ( succes ) if ( succes )
switch ( operation ->type ) switch ( operation ->type )
{ {
case OPERATION_DELETE: case OPERATION_DELETE:
succes = Delete( operation ->partition_original, succes = Delete( operation ->partition_original, operation ->operation_detail ) ;
operation ->operation_detail .sub_details ) ;
break ; break ;
case OPERATION_CREATE: case OPERATION_CREATE:
succes = create( operation ->device, succes = create( operation ->device,
operation ->partition_new, operation ->partition_new,
operation ->operation_detail .sub_details ) ; operation ->operation_detail ) ;
break ; break ;
case OPERATION_RESIZE_MOVE: case OPERATION_RESIZE_MOVE:
succes = resize_move( operation ->device, succes = resize_move( operation ->device,
operation ->partition_original, operation ->partition_original,
operation ->partition_new, operation ->partition_new,
operation ->operation_detail .sub_details ) ; operation ->operation_detail ) ;
break ; break ;
case OPERATION_FORMAT: case OPERATION_FORMAT:
succes = format( operation ->partition_new, succes = format( operation ->partition_new, operation ->operation_detail ) ;
operation ->operation_detail .sub_details ) ;
break ; break ;
case OPERATION_COPY: case OPERATION_COPY:
//when copying to an existing partition we have to change the 'copy of..' to a valid path //when copying to an existing partition we have to change the 'copy of..' to a valid path
@ -348,17 +348,16 @@ bool GParted_Core::apply_operation_to_disk( Operation * operation )
succes = copy( static_cast<OperationCopy*>( operation ) ->partition_copied, succes = copy( static_cast<OperationCopy*>( operation ) ->partition_copied,
operation ->partition_new, operation ->partition_new,
static_cast<OperationCopy*>( operation ) ->partition_copied .get_length(), static_cast<OperationCopy*>( operation ) ->partition_copied .get_length(),
operation ->operation_detail .sub_details ) ; operation ->operation_detail ) ;
break ; break ;
} }
if ( libparted_messages .size() > 0 ) if ( libparted_messages .size() > 0 )
{ {
operation ->operation_detail .sub_details .push_back( operation ->operation_detail .add_child( OperationDetail( _("libparted messages"), STATUS_INFO ) ) ;
OperationDetail( _("libparted messages"), STATUS_INFO ) ) ;
for ( unsigned int t = 0 ; t < libparted_messages .size() ; t++ ) for ( unsigned int t = 0 ; t < libparted_messages .size() ; t++ )
operation ->operation_detail .sub_details .back() .sub_details .push_back( operation ->operation_detail .get_last_child() .add_child(
OperationDetail( libparted_messages[ t ], STATUS_NONE, FONT_ITALIC ) ) ; OperationDetail( libparted_messages[ t ], STATUS_NONE, FONT_ITALIC ) ) ;
} }
@ -840,7 +839,7 @@ void GParted_Core::set_used_sectors( std::vector<Partition> & partitions )
{ {
case GParted::FS::EXTERNAL : case GParted::FS::EXTERNAL :
if ( set_proper_filesystem( partitions[ t ] .filesystem ) ) if ( set_proper_filesystem( partitions[ t ] .filesystem ) )
p_filesystem ->Set_Used_Sectors( partitions[ t ] ) ; p_filesystem ->set_used_sectors( partitions[ t ] ) ;
break ; break ;
case GParted::FS::LIBPARTED : case GParted::FS::LIBPARTED :
LP_set_used_sectors( partitions[ t ] ) ; LP_set_used_sectors( partitions[ t ] ) ;
@ -898,31 +897,27 @@ void GParted_Core::set_flags( Partition & partition )
partition .flags .push_back( ped_partition_flag_get_name( flags[ t ] ) ) ; partition .flags .push_back( ped_partition_flag_get_name( flags[ t ] ) ) ;
} }
bool GParted_Core::create( const Device & device, bool GParted_Core::create( const Device & device, Partition & new_partition, OperationDetail & operationdetail )
Partition & new_partition,
std::vector<OperationDetail> & operation_details )
{ {
if ( new_partition .type == GParted::TYPE_EXTENDED ) if ( new_partition .type == GParted::TYPE_EXTENDED )
{ {
return create_partition( new_partition, operation_details ) ; return create_partition( new_partition, operationdetail ) ;
} }
else if ( create_partition( new_partition, operation_details, get_fs( new_partition .filesystem ) .MIN ) ) else if ( create_partition( new_partition, operationdetail, get_fs( new_partition .filesystem ) .MIN ) )
{ {
if ( new_partition .filesystem == GParted::FS_UNFORMATTED ) if ( new_partition .filesystem == GParted::FS_UNFORMATTED )
return true ; return true ;
else else
return set_partition_type( new_partition, operation_details ) && return set_partition_type( new_partition, operationdetail ) &&
create_filesystem( new_partition, operation_details ) ; create_filesystem( new_partition, operationdetail ) ;
} }
return false ; return false ;
} }
bool GParted_Core::create_partition( Partition & new_partition, bool GParted_Core::create_partition( Partition & new_partition, OperationDetail & operationdetail, Sector min_size )
std::vector<OperationDetail> & operation_details,
Sector min_size )
{ {
operation_details .push_back( OperationDetail( _("create empty partition") ) ) ; operationdetail .add_child( OperationDetail( _("create empty partition") ) ) ;
new_partition .partition_number = 0 ; new_partition .partition_number = 0 ;
@ -989,7 +984,7 @@ bool GParted_Core::create_partition( Partition & new_partition,
new_partition .sector_start = lp_partition ->geom .start ; new_partition .sector_start = lp_partition ->geom .start ;
new_partition .sector_end = lp_partition ->geom .end ; new_partition .sector_end = lp_partition ->geom .end ;
operation_details .back() .sub_details .push_back( OperationDetail( operationdetail .get_last_child() .add_child( OperationDetail(
String::ucompose( _("path: %1"), new_partition .get_path() ) + "\n" + String::ucompose( _("path: %1"), new_partition .get_path() ) + "\n" +
String::ucompose( _("start: %1"), new_partition .sector_start ) + "\n" + String::ucompose( _("start: %1"), new_partition .sector_start ) + "\n" +
String::ucompose( _("end: %1"), new_partition .sector_end ) + "\n" + String::ucompose( _("end: %1"), new_partition .sector_end ) + "\n" +
@ -1018,23 +1013,23 @@ bool GParted_Core::create_partition( Partition & new_partition,
) )
) )
{ {
operation_details .back() .status = STATUS_SUCCES ; operationdetail .get_last_child() .set_status( STATUS_SUCCES ) ;
return true ; return true ;
} }
else else
{ {
operation_details .back() .status = STATUS_ERROR ; operationdetail .get_last_child() .set_status( STATUS_ERROR ) ;
return false ; return false ;
} }
} }
bool GParted_Core::create_filesystem( const Partition & partition, std::vector<OperationDetail> & operation_details ) bool GParted_Core::create_filesystem( const Partition & partition, OperationDetail & operationdetail )
{ {
operation_details .push_back( OperationDetail( String::ucompose( operationdetail .add_child( OperationDetail( String::ucompose(
_("create new %1 filesystem"), _("create new %1 filesystem"),
Utils::get_filesystem_string( partition .filesystem ) ) ) ) ; Utils::get_filesystem_string( partition .filesystem ) ) ) ) ;
bool succes = false ; bool succes = false ;
switch ( get_fs( partition .filesystem ) .create ) switch ( get_fs( partition .filesystem ) .create )
@ -1047,25 +1042,24 @@ bool GParted_Core::create_filesystem( const Partition & partition, std::vector<O
break ; break ;
case GParted::FS::EXTERNAL: case GParted::FS::EXTERNAL:
succes = set_proper_filesystem( partition .filesystem ) && succes = set_proper_filesystem( partition .filesystem ) &&
p_filesystem ->Create( partition, operation_details .back() .sub_details ) ; p_filesystem ->create( partition, operationdetail .get_last_child() ) ;
break ; break ;
} }
operation_details .back() .status = succes ? STATUS_SUCCES : STATUS_ERROR ; operationdetail .get_last_child() .set_status( succes ? STATUS_SUCCES : STATUS_ERROR ) ;
return succes ; return succes ;
} }
bool GParted_Core::format( const Partition & partition, std::vector<OperationDetail> & operation_details ) bool GParted_Core::format( const Partition & partition, OperationDetail & operationdetail )
{ {
//remove all filesystem signatures... //remove all filesystem signatures...
erase_filesystem_signatures( partition ) ; erase_filesystem_signatures( partition ) ;
return set_partition_type( partition, operation_details ) && return set_partition_type( partition, operationdetail ) && create_filesystem( partition, operationdetail ) ;
create_filesystem( partition, operation_details ) ;
} }
bool GParted_Core::Delete( const Partition & partition, std::vector<OperationDetail> & operation_details ) bool GParted_Core::Delete( const Partition & partition, OperationDetail & operationdetail )
{ {
bool return_value = false ; bool return_value = false ;
@ -1088,42 +1082,42 @@ bool GParted_Core::Delete( const Partition & partition, std::vector<OperationDet
bool GParted_Core::resize_move( const Device & device, bool GParted_Core::resize_move( const Device & device,
const Partition & partition_old, const Partition & partition_old,
Partition & partition_new, Partition & partition_new,
std::vector<OperationDetail> & operation_details ) OperationDetail & operationdetail )
{ {
if ( calculate_exact_geom( partition_old, partition_new, operation_details ) ) if ( calculate_exact_geom( partition_old, partition_new, operationdetail ) )
{ {
//extended is a special case.. //extended is a special case..
if ( partition_old .type == GParted::TYPE_EXTENDED ) if ( partition_old .type == GParted::TYPE_EXTENDED )
return resize_move_partition( partition_old, partition_new, operation_details ) ; return resize_move_partition( partition_old, partition_new, operationdetail ) ;
//see if we need move or resize.. //see if we need move or resize..
if ( partition_new .sector_start == partition_old .sector_start ) if ( partition_new .sector_start == partition_old .sector_start )
return resize( partition_old, partition_new, operation_details ) ; return resize( partition_old, partition_new, operationdetail ) ;
else if ( partition_new .get_length() > partition_old .get_length() ) else if ( partition_new .get_length() > partition_old .get_length() )
{ {
//first move, then grow... //first move, then grow...
Partition temp = partition_new ; Partition temp = partition_new ;
temp .sector_end = temp .sector_start + partition_old .get_length() -1 ; temp .sector_end = temp .sector_start + partition_old .get_length() -1 ;
return calculate_exact_geom( partition_old, temp, operation_details, temp .get_length() ) && return calculate_exact_geom( partition_old, temp, operationdetail, temp .get_length() ) &&
move( device, partition_old, temp, operation_details ) && move( device, partition_old, temp, operationdetail ) &&
resize( temp, partition_new, operation_details ) ; resize( temp, partition_new, operationdetail ) ;
} }
else if ( partition_new .get_length() < partition_old .get_length() ) else if ( partition_new .get_length() < partition_old .get_length() )
{ {
//first shrink, then move.. //first shrink, then move..
Partition temp = partition_old ; Partition temp = partition_old ;
temp .sector_end = partition_old .sector_start + partition_new .get_length() -1 ; temp .sector_end = partition_old .sector_start + partition_new .get_length() -1 ;
//FIXME: shrink and move of fat32 fs in 1 operation throws path not found errors
return calculate_exact_geom( partition_old, temp, operation_details ) && return calculate_exact_geom( partition_old, temp, operationdetail ) &&
resize( partition_old, temp, operation_details ) && resize( partition_old, temp, operationdetail ) &&
calculate_exact_geom( temp, partition_new, operation_details, temp .get_length() ) && calculate_exact_geom( temp, partition_new, operationdetail, temp .get_length() ) &&
move( device, temp, partition_new, operation_details ) ; move( device, temp, partition_new, operationdetail ) ;
} }
else else
return calculate_exact_geom( return calculate_exact_geom(
partition_old, partition_new, operation_details, partition_old .get_length() ) && partition_old, partition_new, operationdetail, partition_old .get_length() ) &&
move( device, partition_old, partition_new, operation_details ) ; move( device, partition_old, partition_new, operationdetail ) ;
} }
return false ; return false ;
@ -1132,34 +1126,32 @@ bool GParted_Core::resize_move( const Device & device,
bool GParted_Core::move( const Device & device, bool GParted_Core::move( const Device & device,
const Partition & partition_old, const Partition & partition_old,
const Partition & partition_new, const Partition & partition_new,
std::vector<OperationDetail> & operation_details ) OperationDetail & operationdetail )
{ {
return check_repair_filesystem( partition_old, operation_details ) && return check_repair_filesystem( partition_old, operationdetail ) &&
move_filesystem( partition_old, partition_new, operation_details ) && move_filesystem( partition_old, partition_new, operationdetail ) &&
resize_move_partition( partition_old, resize_move_partition( partition_old, partition_new, operationdetail ) &&
partition_new, check_repair_filesystem( partition_new, operationdetail ) &&
operation_details ) && maximize_filesystem( partition_new, operationdetail ) ;
check_repair_filesystem( partition_new, operation_details ) &&
maximize_filesystem( partition_new, operation_details ) ;
} }
bool GParted_Core::move_filesystem( const Partition & partition_old, bool GParted_Core::move_filesystem( const Partition & partition_old,
const Partition & partition_new, const Partition & partition_new,
std::vector<OperationDetail> & operation_details ) OperationDetail & operationdetail )
{ {
if ( partition_new .sector_start < partition_old .sector_start ) if ( partition_new .sector_start < partition_old .sector_start )
operation_details .push_back( OperationDetail( _("move filesystem to the left") ) ) ; operationdetail .add_child( OperationDetail( _("move filesystem to the left") ) ) ;
else if ( partition_new .sector_start > partition_old .sector_start ) else if ( partition_new .sector_start > partition_old .sector_start )
operation_details .push_back( OperationDetail( _("move filesystem to the right") ) ) ; operationdetail .add_child( OperationDetail( _("move filesystem to the right") ) ) ;
else else
{ {
operation_details .push_back( OperationDetail( _("move filesystem") ) ) ; operationdetail .add_child( OperationDetail( _("move filesystem") ) ) ;
operation_details .back() .sub_details .push_back( operationdetail .get_last_child() .add_child(
OperationDetail( _("new and old filesystem have the same positition. skipping this operation"), OperationDetail( _("new and old filesystem have the same positition. skipping this operation"),
STATUS_NONE, STATUS_NONE,
FONT_ITALIC ) ) ; FONT_ITALIC ) ) ;
operation_details .back() .status = STATUS_SUCCES ; operationdetail .get_last_child() .set_status( STATUS_SUCCES ) ;
return true ; return true ;
} }
@ -1170,33 +1162,33 @@ bool GParted_Core::move_filesystem( const Partition & partition_old,
break ; break ;
case GParted::FS::GPARTED: case GParted::FS::GPARTED:
succes = move_filesystem_using_gparted( partition_old, succes = move_filesystem_using_gparted( partition_old,
partition_new, partition_new,
operation_details .back() .sub_details ) ; operationdetail .get_last_child() ) ;
break ; break ;
case GParted::FS::LIBPARTED: case GParted::FS::LIBPARTED:
succes = resize_move_filesystem_using_libparted( partition_old, succes = resize_move_filesystem_using_libparted( partition_old,
partition_new, partition_new,
operation_details .back() .sub_details ) ; operationdetail .get_last_child() ) ;
break ; break ;
case GParted::FS::EXTERNAL: case GParted::FS::EXTERNAL:
break ; break ;
} }
operation_details .back() .status = succes ? STATUS_SUCCES : STATUS_ERROR ; operationdetail .get_last_child() .set_status( succes ? STATUS_SUCCES : STATUS_ERROR ) ;
return succes ; return succes ;
} }
bool GParted_Core::move_filesystem_using_gparted( const Partition & partition_old, bool GParted_Core::move_filesystem_using_gparted( const Partition & partition_old,
const Partition & partition_new, const Partition & partition_new,
std::vector<OperationDetail> & operation_details ) OperationDetail & operationdetail )
{ {
operation_details .push_back( OperationDetail( _("using internal algorithm"), STATUS_NONE ) ) ; operationdetail .add_child( OperationDetail( _("using internal algorithm"), STATUS_NONE ) ) ;
CopyType copytype = partition_new .sector_start < partition_old .sector_start ? START_TO_END : END_TO_START ; CopyType copytype = partition_new .sector_start < partition_old .sector_start ? START_TO_END : END_TO_START ;
Sector optimal_blocksize, offset ; Sector optimal_blocksize, offset ;
return find_optimal_blocksize( partition_old, partition_new, copytype, optimal_blocksize, offset, operation_details ) return find_optimal_blocksize( partition_old, partition_new, copytype, optimal_blocksize, offset, operationdetail )
&& &&
copy_blocks( partition_old .device_path, copy_blocks( partition_old .device_path,
partition_new .device_path, partition_new .device_path,
@ -1204,15 +1196,15 @@ bool GParted_Core::move_filesystem_using_gparted( const Partition & partition_ol
partition_new .sector_start + offset, partition_new .sector_start + offset,
optimal_blocksize, optimal_blocksize,
partition_old .get_length() - offset, partition_old .get_length() - offset,
operation_details, operationdetail,
copytype ) ; copytype ) ;
} }
bool GParted_Core::resize_move_filesystem_using_libparted( const Partition & partition_old, bool GParted_Core::resize_move_filesystem_using_libparted( const Partition & partition_old,
const Partition & partition_new, const Partition & partition_new,
std::vector<OperationDetail> & operation_details ) OperationDetail & operationdetail )
{ {
operation_details .push_back( OperationDetail( _("using libparted"), STATUS_NONE ) ) ; operationdetail .add_child( OperationDetail( _("using libparted"), STATUS_NONE ) ) ;
bool return_value = false ; bool return_value = false ;
if ( open_device_and_disk( partition_old .device_path ) ) if ( open_device_and_disk( partition_old .device_path ) )
@ -1245,28 +1237,25 @@ bool GParted_Core::resize_move_filesystem_using_libparted( const Partition & par
bool GParted_Core::resize( const Partition & partition_old, bool GParted_Core::resize( const Partition & partition_old,
const Partition & partition_new, const Partition & partition_new,
std::vector<OperationDetail> & operation_details ) OperationDetail & operationdetail )
{ {
bool succes = false ; bool succes = false ;
if ( check_repair_filesystem( partition_new, operation_details ) ) if ( check_repair_filesystem( partition_new, operationdetail ) )
{ {
succes = true ; succes = true ;
if ( succes && partition_new .get_length() < partition_old .get_length() ) if ( succes && partition_new .get_length() < partition_old .get_length() )
succes = resize_filesystem( partition_old, partition_new, operation_details ) ; succes = resize_filesystem( partition_old, partition_new, operationdetail ) ;
if ( succes ) if ( succes )
succes = resize_move_partition( succes = resize_move_partition( partition_old, partition_new, operationdetail ) ;
partition_old,
partition_new,
operation_details ) ;
//these 3 are always executed, however, if 1 of them fails the whole operation fails //these 2 are always executed, however, if 1 of them fails the whole operation fails
if ( ! check_repair_filesystem( partition_new, operation_details ) ) if ( ! check_repair_filesystem( partition_new, operationdetail ) )
succes = false ; succes = false ;
//expand filesystem to fit exactly in partition //expand filesystem to fit exactly in partition
if ( ! maximize_filesystem( partition_new, operation_details ) ) if ( ! maximize_filesystem( partition_new, operationdetail ) )
succes = false ; succes = false ;
return succes ; return succes ;
@ -1277,7 +1266,7 @@ bool GParted_Core::resize( const Partition & partition_old,
bool GParted_Core::resize_move_partition( const Partition & partition_old, bool GParted_Core::resize_move_partition( const Partition & partition_old,
const Partition & partition_new, const Partition & partition_new,
std::vector<OperationDetail> & operation_details ) OperationDetail & operationdetail )
{ {
//i'm not too happy with this, but i think it is the correct way from a i18n POV //i'm not too happy with this, but i think it is the correct way from a i18n POV
enum Action enum Action
@ -1343,16 +1332,16 @@ bool GParted_Core::resize_move_partition( const Partition & partition_old,
Utils::format_size( partition_old .get_length() ), Utils::format_size( partition_old .get_length() ),
Utils::format_size( partition_new .get_length() ) ) ; Utils::format_size( partition_new .get_length() ) ) ;
operation_details .push_back( OperationDetail( description ) ) ; operationdetail .add_child( OperationDetail( description ) ) ;
if ( action == NONE ) if ( action == NONE )
operation_details .back() .sub_details .push_back( operationdetail .get_last_child() .add_child(
OperationDetail( _("new and old partition have the same size and positition. continuing anyway"), OperationDetail( _("new and old partition have the same size and positition. continuing anyway"),
STATUS_NONE, STATUS_NONE,
FONT_ITALIC ) ) ; FONT_ITALIC ) ) ;
operation_details .back() .sub_details .push_back( operationdetail .get_last_child() .add_child(
OperationDetail( OperationDetail(
String::ucompose( _("old start: %1"), partition_old .sector_start ) + "\n" + String::ucompose( _("old start: %1"), partition_old .sector_start ) + "\n" +
String::ucompose( _("old end: %1"), partition_old .sector_end ) + "\n" + String::ucompose( _("old end: %1"), partition_old .sector_end ) + "\n" +
@ -1409,7 +1398,7 @@ bool GParted_Core::resize_move_partition( const Partition & partition_old,
if ( return_value ) if ( return_value )
{ {
operation_details .back() .sub_details .push_back( operationdetail .get_last_child() .add_child(
OperationDetail( OperationDetail(
String::ucompose( _("new start: %1"), new_start ) + "\n" + String::ucompose( _("new start: %1"), new_start ) + "\n" +
String::ucompose( _("new end: %1"), new_end ) + "\n" + String::ucompose( _("new end: %1"), new_end ) + "\n" +
@ -1422,13 +1411,13 @@ bool GParted_Core::resize_move_partition( const Partition & partition_old,
if ( partition_old .type == GParted::TYPE_EXTENDED ) if ( partition_old .type == GParted::TYPE_EXTENDED )
{ {
operation_details .back() .status = return_value ? STATUS_SUCCES : STATUS_ERROR ; operationdetail .get_last_child() .set_status( return_value ? STATUS_SUCCES : STATUS_ERROR ) ;
return return_value ; return return_value ;
} }
else else
{ {
return_value &= wait_for_node( partition_new .get_path() ) ; return_value &= wait_for_node( partition_new .get_path() ) ;
operation_details .back() .status = return_value ? STATUS_SUCCES : STATUS_ERROR ; operationdetail .get_last_child() .set_status( return_value ? STATUS_SUCCES : STATUS_ERROR ) ;
return return_value ; return return_value ;
} }
@ -1436,7 +1425,7 @@ bool GParted_Core::resize_move_partition( const Partition & partition_old,
bool GParted_Core::resize_filesystem( const Partition & partition_old, bool GParted_Core::resize_filesystem( const Partition & partition_old,
const Partition & partition_new, const Partition & partition_new,
std::vector<OperationDetail> & operation_details, OperationDetail & operationdetail,
bool fill_partition ) bool fill_partition )
{ {
//by default 'grow' to accomodate expand_filesystem() //by default 'grow' to accomodate expand_filesystem()
@ -1446,15 +1435,15 @@ bool GParted_Core::resize_filesystem( const Partition & partition_old,
{ {
if ( partition_new .get_length() < partition_old .get_length() ) if ( partition_new .get_length() < partition_old .get_length() )
{ {
operation_details .push_back( OperationDetail( _("shrink filesystem") ) ) ; operationdetail .add_child( OperationDetail( _("shrink filesystem") ) ) ;
action = get_fs( partition_old .filesystem ) .shrink ; action = get_fs( partition_old .filesystem ) .shrink ;
} }
else if ( partition_new .get_length() > partition_old .get_length() ) else if ( partition_new .get_length() > partition_old .get_length() )
operation_details .push_back( OperationDetail( _("grow filesystem") ) ) ; operationdetail .add_child( OperationDetail( _("grow filesystem") ) ) ;
else else
{ {
operation_details .push_back( OperationDetail( _("resize filesystem") ) ) ; operationdetail .add_child( OperationDetail( _("resize filesystem") ) ) ;
operation_details .back() .sub_details .push_back( operationdetail .get_last_child() .add_child(
OperationDetail( OperationDetail(
_("new and old filesystem have the same size and positition. continuing anyway"), _("new and old filesystem have the same size and positition. continuing anyway"),
STATUS_NONE, STATUS_NONE,
@ -1472,53 +1461,52 @@ bool GParted_Core::resize_filesystem( const Partition & partition_old,
case GParted::FS::LIBPARTED: case GParted::FS::LIBPARTED:
succes = resize_move_filesystem_using_libparted( partition_old, succes = resize_move_filesystem_using_libparted( partition_old,
partition_new, partition_new,
operation_details .back() .sub_details ) ; operationdetail .get_last_child() ) ;
break ; break ;
case GParted::FS::EXTERNAL: case GParted::FS::EXTERNAL:
succes = set_proper_filesystem( partition_new .filesystem ) && succes = set_proper_filesystem( partition_new .filesystem ) &&
p_filesystem ->Resize( partition_new, p_filesystem ->resize( partition_new,
operation_details .back() .sub_details, operationdetail .get_last_child(),
fill_partition ) ; fill_partition ) ;
break ; break ;
} }
operation_details .back() .status = succes ? STATUS_SUCCES : STATUS_ERROR ; operationdetail .get_last_child() .set_status( succes ? STATUS_SUCCES : STATUS_ERROR ) ;
return succes ; return succes ;
} }
bool GParted_Core::maximize_filesystem( const Partition & partition, bool GParted_Core::maximize_filesystem( const Partition & partition, OperationDetail & operationdetail )
std::vector<OperationDetail> & operation_details )
{ {
operation_details .push_back( OperationDetail( _("grow filesystem to fill the partition") ) ) ; operationdetail .add_child( OperationDetail( _("grow filesystem to fill the partition") ) ) ;
if ( get_fs( partition .filesystem ) .grow == GParted::FS::NONE ) if ( get_fs( partition .filesystem ) .grow == GParted::FS::NONE )
{ {
operation_details .back() .sub_details .push_back( operationdetail .get_last_child() .add_child(
OperationDetail( _("growing is not available for this filesystem"), OperationDetail( _("growing is not available for this filesystem"),
STATUS_NONE, STATUS_NONE,
FONT_ITALIC ) ) ; FONT_ITALIC ) ) ;
operation_details .back() .status = STATUS_N_A ; operationdetail .get_last_child() .set_status( STATUS_N_A ) ;
return true ; return true ;
} }
return resize_filesystem( partition, partition, operation_details, true ) ; return resize_filesystem( partition, partition, operationdetail, true ) ;
} }
bool GParted_Core::copy( const Partition & partition_src, bool GParted_Core::copy( const Partition & partition_src,
Partition & partition_dest, Partition & partition_dest,
Sector min_size, Sector min_size,
std::vector<OperationDetail> & operation_details ) OperationDetail & operationdetail )
{ {
if ( check_repair_filesystem( partition_src, operation_details ) ) if ( check_repair_filesystem( partition_src, operationdetail ) )
{ {
bool succes = true ; bool succes = true ;
if ( partition_dest .status == GParted::STAT_COPY ) if ( partition_dest .status == GParted::STAT_COPY )
succes = create_partition( partition_dest, operation_details, min_size ) ; succes = create_partition( partition_dest, operationdetail, min_size ) ;
if ( succes && set_partition_type( partition_dest, operation_details ) ) if ( succes && set_partition_type( partition_dest, operationdetail ) )
{ {
operation_details .push_back( OperationDetail( operationdetail .add_child( OperationDetail(
String::ucompose( _("copy filesystem of %1 to %2"), String::ucompose( _("copy filesystem of %1 to %2"),
partition_src .get_path(), partition_src .get_path(),
partition_dest .get_path() ) ) ) ; partition_dest .get_path() ) ) ) ;
@ -1529,7 +1517,7 @@ bool GParted_Core::copy( const Partition & partition_src,
case GParted::FS::GPARTED : case GParted::FS::GPARTED :
succes = copy_filesystem( partition_src, succes = copy_filesystem( partition_src,
partition_dest, partition_dest,
operation_details .back() .sub_details ) ; operationdetail .get_last_child() ) ;
break ; break ;
case GParted::FS::LIBPARTED : case GParted::FS::LIBPARTED :
@ -1538,9 +1526,9 @@ bool GParted_Core::copy( const Partition & partition_src,
case GParted::FS::EXTERNAL : case GParted::FS::EXTERNAL :
succes = set_proper_filesystem( partition_dest .filesystem ) && succes = set_proper_filesystem( partition_dest .filesystem ) &&
p_filesystem ->Copy( partition_src .get_path(), p_filesystem ->copy( partition_src .get_path(),
partition_dest .get_path(), partition_dest .get_path(),
operation_details .back() .sub_details ) ; operationdetail .get_last_child() ) ;
break ; break ;
default : default :
@ -1548,11 +1536,11 @@ bool GParted_Core::copy( const Partition & partition_src,
break ; break ;
} }
operation_details .back() .status = succes ? STATUS_SUCCES : STATUS_ERROR ; operationdetail .get_last_child() .set_status( succes ? STATUS_SUCCES : STATUS_ERROR ) ;
return ( succes && return ( succes &&
check_repair_filesystem( partition_dest, operation_details ) && check_repair_filesystem( partition_dest, operationdetail ) &&
maximize_filesystem( partition_dest, operation_details ) ) ; maximize_filesystem( partition_dest, operationdetail ) ) ;
} }
} }
@ -1561,7 +1549,7 @@ bool GParted_Core::copy( const Partition & partition_src,
bool GParted_Core::copy_filesystem( const Partition & partition_src, bool GParted_Core::copy_filesystem( const Partition & partition_src,
const Partition & partition_dst, const Partition & partition_dst,
std::vector<OperationDetail> & operation_details ) OperationDetail & operationdetail )
{ {
Sector optimal_blocksize, offset ; Sector optimal_blocksize, offset ;
@ -1570,7 +1558,7 @@ bool GParted_Core::copy_filesystem( const Partition & partition_src,
START_TO_END, START_TO_END,
optimal_blocksize, optimal_blocksize,
offset, offset,
operation_details ) operationdetail )
&& &&
copy_blocks( partition_src .device_path, copy_blocks( partition_src .device_path,
partition_dst .device_path, partition_dst .device_path,
@ -1578,13 +1566,13 @@ bool GParted_Core::copy_filesystem( const Partition & partition_src,
partition_dst .sector_start + offset, partition_dst .sector_start + offset,
optimal_blocksize, optimal_blocksize,
partition_src .get_length() - offset, partition_src .get_length() - offset,
operation_details, operationdetail,
START_TO_END ) ; START_TO_END ) ;
} }
bool GParted_Core::check_repair_filesystem( const Partition & partition, std::vector<OperationDetail> & operation_details ) bool GParted_Core::check_repair_filesystem( const Partition & partition, OperationDetail & operationdetail )
{ {
operation_details .push_back( OperationDetail( operationdetail .add_child( OperationDetail(
String::ucompose( _("check filesystem on %1 for errors and (if possible) fix them"), String::ucompose( _("check filesystem on %1 for errors and (if possible) fix them"),
partition .get_path() ) ) ) ; partition .get_path() ) ) ) ;
@ -1592,10 +1580,12 @@ bool GParted_Core::check_repair_filesystem( const Partition & partition, std::ve
switch ( get_fs( partition .filesystem ) .check ) switch ( get_fs( partition .filesystem ) .check )
{ {
case GParted::FS::NONE: case GParted::FS::NONE:
operation_details .back() .sub_details .push_back( operationdetail .get_last_child() .add_child(
OperationDetail( _("checking is not available for this filesystem"), STATUS_NONE, FONT_ITALIC ) ) ; OperationDetail( _("checking is not available for this filesystem"),
STATUS_NONE,
FONT_ITALIC ) ) ;
operation_details .back() .status = STATUS_N_A ; operationdetail .get_last_child() .set_status( STATUS_N_A ) ;
return true ; return true ;
break ; break ;
@ -1605,20 +1595,19 @@ bool GParted_Core::check_repair_filesystem( const Partition & partition, std::ve
break ; break ;
case GParted::FS::EXTERNAL: case GParted::FS::EXTERNAL:
succes = set_proper_filesystem( partition .filesystem ) && succes = set_proper_filesystem( partition .filesystem ) &&
p_filesystem ->Check_Repair( partition, operation_details .back() .sub_details ) ; p_filesystem ->check_repair( partition, operationdetail .get_last_child() ) ;
break ; break ;
} }
operation_details .back() .status = succes ? STATUS_SUCCES : STATUS_ERROR ; operationdetail .get_last_child() .set_status( succes ? STATUS_SUCCES : STATUS_ERROR ) ;
return succes ; return succes ;
} }
bool GParted_Core::set_partition_type( const Partition & partition, bool GParted_Core::set_partition_type( const Partition & partition, OperationDetail & operationdetail )
std::vector<OperationDetail> & operation_details )
{ {
operation_details .push_back( OperationDetail( operationdetail .add_child( OperationDetail(
String::ucompose( _("set partitiontype on %1"), partition .get_path() ) ) ) ; String::ucompose( _("set partitiontype on %1"), partition .get_path() ) ) ) ;
bool return_value = false ; bool return_value = false ;
@ -1637,7 +1626,7 @@ bool GParted_Core::set_partition_type( const Partition & partition,
if ( lp_partition && ped_partition_set_system( lp_partition, fs_type ) && commit() ) if ( lp_partition && ped_partition_set_system( lp_partition, fs_type ) && commit() )
{ {
operation_details .back() .sub_details .push_back( operationdetail .get_last_child() .add_child(
OperationDetail( String::ucompose( _("new partitiontype: %1"), OperationDetail( String::ucompose( _("new partitiontype: %1"),
lp_partition ->fs_type ->name ), lp_partition ->fs_type ->name ),
STATUS_NONE, STATUS_NONE,
@ -1650,7 +1639,7 @@ bool GParted_Core::set_partition_type( const Partition & partition,
close_device_and_disk() ; close_device_and_disk() ;
} }
operation_details .back() .status = return_value ? STATUS_SUCCES : STATUS_ERROR ; operationdetail .get_last_child() .set_status( return_value ? STATUS_SUCCES : STATUS_ERROR ) ;
return return_value ; return return_value ;
} }
@ -1697,7 +1686,7 @@ bool GParted_Core::find_optimal_blocksize( const Partition & partition_old,
CopyType copytype, CopyType copytype,
Sector & optimal_blocksize, Sector & optimal_blocksize,
Sector & offset, Sector & offset,
std::vector<OperationDetail> & operation_details ) OperationDetail & operationdetail )
{//FIXME, this probing is actually quite clumsy and suboptimal.. {//FIXME, this probing is actually quite clumsy and suboptimal..
//find out if there is a better way to determine a (close to) optimal blocksize... //find out if there is a better way to determine a (close to) optimal blocksize...
bool succes = true ; bool succes = true ;
@ -1707,7 +1696,7 @@ bool GParted_Core::find_optimal_blocksize( const Partition & partition_old,
if ( partition_old .get_length() > 100000 ) if ( partition_old .get_length() > 100000 )
{ {
operation_details .push_back( OperationDetail( _("finding optimal blocksize"), STATUS_NONE ) ) ; operationdetail .add_child( OperationDetail( _("finding optimal blocksize"), STATUS_NONE ) ) ;
std::clock_t clockticks_start, smallest_ticks = -1 ; std::clock_t clockticks_start, smallest_ticks = -1 ;
@ -1728,9 +1717,8 @@ bool GParted_Core::find_optimal_blocksize( const Partition & partition_old,
partition_new .sector_start + offset, partition_new .sector_start + offset,
blocksizes[ t ], blocksizes[ t ],
20000, 20000,
operation_details .back() .sub_details, operationdetail .get_last_child(),
copytype, copytype ) ;
false ) ;
if ( (std::clock() - clockticks_start) < smallest_ticks || smallest_ticks == -1 ) if ( (std::clock() - clockticks_start) < smallest_ticks || smallest_ticks == -1 )
{ {
@ -1738,7 +1726,7 @@ bool GParted_Core::find_optimal_blocksize( const Partition & partition_old,
optimal_blocksize = blocksizes[ t ] ; optimal_blocksize = blocksizes[ t ] ;
} }
operation_details .back() .sub_details .back() .sub_details .push_back( OperationDetail( operationdetail .get_last_child() .get_last_child() .add_child( OperationDetail(
String::ucompose( _("%1 clockticks"), std::clock() - clockticks_start ), String::ucompose( _("%1 clockticks"), std::clock() - clockticks_start ),
STATUS_NONE, STATUS_NONE,
FONT_ITALIC ) ) ; FONT_ITALIC ) ) ;
@ -1746,7 +1734,7 @@ bool GParted_Core::find_optimal_blocksize( const Partition & partition_old,
offset += 20000 ; offset += 20000 ;
} }
operation_details .back() .sub_details .push_back( OperationDetail( operationdetail .get_last_child() .add_child( OperationDetail(
String::ucompose( _("optimal blocksize is %1 sectors (%2)"), String::ucompose( _("optimal blocksize is %1 sectors (%2)"),
optimal_blocksize, optimal_blocksize,
Utils::format_size( optimal_blocksize ) ) , Utils::format_size( optimal_blocksize ) ) ,
@ -1762,12 +1750,11 @@ bool GParted_Core::copy_blocks( const Glib::ustring & src_device,
Sector dst_start, Sector dst_start,
Sector blocksize, Sector blocksize,
Sector sectors, Sector sectors,
std::vector<OperationDetail> & operation_details, OperationDetail & operationdetail,
CopyType copytype, CopyType copytype )
bool show_progress )
{ {
operation_details .push_back( OperationDetail( operationdetail .add_child( OperationDetail(
String::ucompose( _("copy %1 sectors using a blocksize of %2 sectors"), sectors, blocksize ), STATUS_NONE ) ) ; String::ucompose( _("copy %1 sectors using a blocksize of %2 sectors"), sectors, blocksize ) ) ) ;
bool succes = false ; bool succes = false ;
PedDevice *lp_device_src, *lp_device_dst ; PedDevice *lp_device_src, *lp_device_dst ;
@ -1783,9 +1770,10 @@ bool GParted_Core::copy_blocks( const Glib::ustring & src_device,
{ {
ped_device_sync( lp_device_dst ) ; ped_device_sync( lp_device_dst ) ;
//add an empty sub which we will constantly update in the loop //add an empty sub which we will constantly update in the loop
operation_details .back() .sub_details .push_back( OperationDetail( "", STATUS_NONE ) ) ; operationdetail .get_last_child() .add_child( OperationDetail( "", STATUS_NONE ) ) ;
std::time_t time_start = std::time(NULL) ; std::time_t time_start, time_last_progress_update ;
time_start = time_last_progress_update = std::time(NULL) ;
Sector t ; Sector t ;
if ( copytype == START_TO_END ) if ( copytype == START_TO_END )
{ {
@ -1799,12 +1787,16 @@ bool GParted_Core::copy_blocks( const Glib::ustring & src_device,
blocksize, blocksize,
error_message ) ) error_message ) )
break ; break ;
if ( show_progress && (std::time(NULL) - time_start) > 1 ) if ( (std::time(NULL) - time_last_progress_update) >= 1 )
{
set_progress_info( sectors, set_progress_info( sectors,
t + blocksize, t + blocksize,
time_start, time_start,
operation_details .back() .sub_details .back() ) ; operationdetail .get_last_child() .get_last_child() ) ;
time_last_progress_update = std::time(NULL) ;
}
} }
if ( rest_sectors > 0 && if ( rest_sectors > 0 &&
@ -1830,11 +1822,15 @@ bool GParted_Core::copy_blocks( const Glib::ustring & src_device,
error_message ) ) error_message ) )
break ; break ;
if ( show_progress && (std::time(NULL) - time_start) > 1 ) if ( (std::time(NULL) - time_last_progress_update) >= 1 )
{
set_progress_info( sectors, set_progress_info( sectors,
t + blocksize, t + blocksize,
time_start, time_start,
operation_details .back() .sub_details .back() ) ; operationdetail .get_last_child() .get_last_child() ) ;
time_last_progress_update = std::time(NULL) ;
}
} }
if ( rest_sectors > 0 && if ( rest_sectors > 0 &&
@ -1850,17 +1846,17 @@ bool GParted_Core::copy_blocks( const Glib::ustring & src_device,
//final description //final description
operation_details .back() .sub_details .back() .set_description( operationdetail .get_last_child() .get_last_child() .set_description(
String::ucompose( _("%1 of %2 copied"), t, sectors ), FONT_ITALIC ) ; String::ucompose( _("%1 of %2 copied"), t, sectors ), FONT_ITALIC ) ;
//reset fraction to -1 to make room for a new one (or a pulsebar) //reset fraction to -1 to make room for a new one (or a pulsebar)
operation_details .back() .sub_details .back() .fraction = -1 ; operationdetail .get_last_child() .get_last_child() .fraction = -1 ;
if ( t == sectors ) if ( t == sectors )
succes = true ; succes = true ;
if ( ! succes && ! error_message .empty() ) if ( ! succes && ! error_message .empty() )
operation_details .back() .sub_details .push_back( operationdetail .get_last_child() .add_child(
OperationDetail( error_message, STATUS_NONE, FONT_ITALIC ) ) ; OperationDetail( error_message, STATUS_NONE, FONT_ITALIC ) ) ;
//close and destroy the devices.. //close and destroy the devices..
@ -1874,6 +1870,8 @@ bool GParted_Core::copy_blocks( const Glib::ustring & src_device,
} }
} }
operationdetail .get_last_child() .set_status( succes ? STATUS_SUCCES : STATUS_ERROR ) ;
return succes ; return succes ;
} }
@ -1905,17 +1903,17 @@ bool GParted_Core::copy_block( PedDevice * lp_device_src,
bool GParted_Core::calculate_exact_geom( const Partition & partition_old, bool GParted_Core::calculate_exact_geom( const Partition & partition_old,
Partition & partition_new, Partition & partition_new,
std::vector<OperationDetail> & operation_details, OperationDetail & operationdetail,
Sector min_size ) Sector min_size )
{ {
operation_details .push_back( OperationDetail( operationdetail .add_child( OperationDetail(
String::ucompose( _("calculate new size and position of %1"), partition_new .get_path() ) ) ) ; String::ucompose( _("calculate new size and position of %1"), partition_new .get_path() ) ) ) ;
if ( min_size >= 0 ) if ( min_size >= 0 )
operation_details .back() .sub_details .push_back( operationdetail .get_last_child() .add_child(
OperationDetail( String::ucompose( _("minimum size: %1"), min_size ), STATUS_NONE ) ) ; OperationDetail( String::ucompose( _("minimum size: %1"), min_size ), STATUS_NONE ) ) ;
operation_details .back() .sub_details .push_back( operationdetail .get_last_child() .add_child(
OperationDetail( OperationDetail(
String::ucompose( _("requested start: %1"), partition_new .sector_start ) + "\n" + String::ucompose( _("requested start: %1"), partition_new .sector_start ) + "\n" +
String::ucompose( _("requested end: %1"), partition_new .sector_end ) + "\n" + String::ucompose( _("requested end: %1"), partition_new .sector_end ) + "\n" +
@ -1969,7 +1967,7 @@ bool GParted_Core::calculate_exact_geom( const Partition & partition_old,
if ( succes ) if ( succes )
{ {
operation_details .back() .sub_details .push_back( operationdetail .get_last_child() .add_child(
OperationDetail( OperationDetail(
String::ucompose( _("new start: %1"), partition_new .sector_start ) + "\n" + String::ucompose( _("new start: %1"), partition_new .sector_start ) + "\n" +
String::ucompose( _("new end: %1"), partition_new .sector_end ) + "\n" + String::ucompose( _("new end: %1"), partition_new .sector_end ) + "\n" +
@ -1980,7 +1978,7 @@ bool GParted_Core::calculate_exact_geom( const Partition & partition_old,
FONT_ITALIC ) ) ; FONT_ITALIC ) ) ;
} }
operation_details .back() .status = succes ? STATUS_SUCCES : STATUS_ERROR ; operationdetail .get_last_child() .set_status( succes ? STATUS_SUCCES : STATUS_ERROR ) ;
return succes ; return succes ;
} }

62
src/OperationDetail.cc
View File

@ -17,6 +17,7 @@
#include "../include/OperationDetail.h" #include "../include/OperationDetail.h"
#include "../include/Utils.h"
namespace GParted namespace GParted
{ {
@ -52,11 +53,72 @@ void OperationDetail::set_description( const Glib::ustring & description, Font f
this ->description = "<b><i>" + Glib::Markup::escape_text( description ) + "</i></b>" ; this ->description = "<b><i>" + Glib::Markup::escape_text( description ) + "</i></b>" ;
break ; break ;
} }
if ( ! treepath .empty() )
on_update( *this ) ;
} }
Glib::ustring OperationDetail::get_description() const Glib::ustring OperationDetail::get_description() const
{ {
return description ; return description ;
} }
void OperationDetail::set_status( OperationDetailStatus status )
{
if ( this ->status != STATUS_ERROR )
{
this ->status = status ;
on_update( *this ) ;
}
}
OperationDetailStatus OperationDetail::get_status() const
{
return status ;
}
void OperationDetail::set_treepath( const Glib::ustring & treepath )
{
this ->treepath = treepath ;
}
Glib::ustring OperationDetail::get_treepath() const
{
return treepath ;
}
void OperationDetail::add_child( const OperationDetail & operationdetail )
{
sub_details .push_back( operationdetail ) ;
sub_details .back() .set_treepath( treepath + ":" + Utils::num_to_str( sub_details .size() -1 ) ) ;
sub_details .back() .signal_update .connect( sigc::mem_fun( this, &OperationDetail::on_update ) ) ;
on_update( sub_details .back() ) ;
}
std::vector<OperationDetail> & OperationDetail::get_childs()
{
return sub_details ;
}
const std::vector<OperationDetail> & OperationDetail::get_childs() const
{
return sub_details ;
}
OperationDetail & OperationDetail::get_last_child()
{
//little bit of (healthy?) paranoia
if ( sub_details .size() == 0 )
add_child( OperationDetail( "---", STATUS_ERROR ) ) ;
return sub_details .back() ;
}
void OperationDetail::on_update( const OperationDetail & operationdetail )
{
signal_update .emit( operationdetail ) ;
}
} //GParted } //GParted

20
src/ext2.cc
View File

@ -51,7 +51,7 @@ FS ext2::get_filesystem_support()
return fs ; return fs ;
} }
void ext2::Set_Used_Sectors( Partition & partition ) void ext2::set_used_sectors( Partition & partition )
{ {
if ( ! Utils::execute_command( "dumpe2fs -h " + partition .get_path(), output, error, true ) ) if ( ! Utils::execute_command( "dumpe2fs -h " + partition .get_path(), output, error, true ) )
{ {
@ -72,14 +72,12 @@ void ext2::Set_Used_Sectors( Partition & partition )
partition .messages .push_back( error ) ; partition .messages .push_back( error ) ;
} }
bool ext2::Create( const Partition & new_partition, std::vector<OperationDetail> & operation_details ) bool ext2::create( const Partition & new_partition, OperationDetail & operationdetail )
{ {
return ! execute_command( "mkfs.ext2 " + new_partition .get_path(), operation_details ) ; return ! execute_command( "mkfs.ext2 " + new_partition .get_path(), operationdetail ) ;
} }
bool ext2::Resize( const Partition & partition_new, bool ext2::resize( const Partition & partition_new, OperationDetail & operationdetail, bool fill_partition )
std::vector<OperationDetail> & operation_details,
bool fill_partition )
{ {
Glib::ustring str_temp = "resize2fs " + partition_new .get_path() ; Glib::ustring str_temp = "resize2fs " + partition_new .get_path() ;
@ -87,19 +85,19 @@ bool ext2::Resize( const Partition & partition_new,
str_temp += " " + Utils::num_to_str( Utils::round( Utils::sector_to_unit( str_temp += " " + Utils::num_to_str( Utils::round( Utils::sector_to_unit(
partition_new .get_length(), GParted::UNIT_KIB ) ) -1, true ) + "K" ; partition_new .get_length(), GParted::UNIT_KIB ) ) -1, true ) + "K" ;
return ! execute_command( str_temp, operation_details ) ; return ! execute_command( str_temp, operationdetail ) ;
} }
bool ext2::Copy( const Glib::ustring & src_part_path, bool ext2::copy( const Glib::ustring & src_part_path,
const Glib::ustring & dest_part_path, const Glib::ustring & dest_part_path,
std::vector<OperationDetail> & operation_details ) OperationDetail & operationdetail )
{ {
return true ; return true ;
} }
bool ext2::Check_Repair( const Partition & partition, std::vector<OperationDetail> & operation_details ) bool ext2::check_repair( const Partition & partition, OperationDetail & operationdetail )
{ {
exit_status = execute_command( "e2fsck -f -y -v " + partition .get_path(), operation_details ) ; exit_status = execute_command( "e2fsck -f -y -v " + partition .get_path(), operationdetail ) ;
//exitstatus 256 isn't documented, but it's returned when the 'FILESYSTEM IS MODIFIED' //exitstatus 256 isn't documented, but it's returned when the 'FILESYSTEM IS MODIFIED'
//this is quite normal (especially after a copy) so we let the function return true... //this is quite normal (especially after a copy) so we let the function return true...

20
src/ext3.cc
View File

@ -52,7 +52,7 @@ FS ext3::get_filesystem_support()
return fs ; return fs ;
} }
void ext3::Set_Used_Sectors( Partition & partition ) void ext3::set_used_sectors( Partition & partition )
{ {
if ( ! Utils::execute_command( "dumpe2fs -h " + partition .get_path(), output, error, true ) ) if ( ! Utils::execute_command( "dumpe2fs -h " + partition .get_path(), output, error, true ) )
{ {
@ -73,14 +73,12 @@ void ext3::Set_Used_Sectors( Partition & partition )
partition .messages .push_back( error ) ; partition .messages .push_back( error ) ;
} }
bool ext3::Create( const Partition & new_partition, std::vector<OperationDetail> & operation_details ) bool ext3::create( const Partition & new_partition, OperationDetail & operationdetail )
{ {
return ! execute_command( "mkfs.ext3 " + new_partition .get_path(), operation_details ) ; return ! execute_command( "mkfs.ext3 " + new_partition .get_path(), operationdetail ) ;
} }
bool ext3::Resize( const Partition & partition_new, bool ext3::resize( const Partition & partition_new, OperationDetail & operationdetail, bool fill_partition )
std::vector<OperationDetail> & operation_details,
bool fill_partition )
{ {
Glib::ustring str_temp = "resize2fs " + partition_new .get_path() ; Glib::ustring str_temp = "resize2fs " + partition_new .get_path() ;
@ -88,19 +86,19 @@ bool ext3::Resize( const Partition & partition_new,
str_temp += " " + Utils::num_to_str( Utils::round( Utils::sector_to_unit( str_temp += " " + Utils::num_to_str( Utils::round( Utils::sector_to_unit(
partition_new .get_length(), GParted::UNIT_KIB ) ) -1, true ) + "K" ; partition_new .get_length(), GParted::UNIT_KIB ) ) -1, true ) + "K" ;
return ! execute_command( str_temp, operation_details ) ; return ! execute_command( str_temp, operationdetail ) ;
} }
bool ext3::Copy( const Glib::ustring & src_part_path, bool ext3::copy( const Glib::ustring & src_part_path,
const Glib::ustring & dest_part_path, const Glib::ustring & dest_part_path,
std::vector<OperationDetail> & operation_details ) OperationDetail & operationdetail )
{ {
return true ; return true ;
} }
bool ext3::Check_Repair( const Partition & partition, std::vector<OperationDetail> & operation_details ) bool ext3::check_repair( const Partition & partition, OperationDetail & operationdetail )
{ {
exit_status = execute_command( "e2fsck -f -y -v " + partition .get_path(), operation_details ) ; exit_status = execute_command( "e2fsck -f -y -v " + partition .get_path(), operationdetail ) ;
//exitstatus 256 isn't documented, but it's returned when the 'FILESYSTEM IS MODIFIED' //exitstatus 256 isn't documented, but it's returned when the 'FILESYSTEM IS MODIFIED'
//this is quite normal (especially after a copy) so we let the function return true... //this is quite normal (especially after a copy) so we let the function return true...

18
src/fat16.cc
View File

@ -49,7 +49,7 @@ FS fat16::get_filesystem_support()
return fs ; return fs ;
} }
void fat16::Set_Used_Sectors( Partition & partition ) void fat16::set_used_sectors( Partition & partition )
{ {
exit_status = Utils::execute_command( "dosfsck -a -v " + partition .get_path(), output, error, true ) ; exit_status = Utils::execute_command( "dosfsck -a -v " + partition .get_path(), output, error, true ) ;
if ( exit_status == 0 || exit_status == 1 ) if ( exit_status == 0 || exit_status == 1 )
@ -73,28 +73,26 @@ void fat16::Set_Used_Sectors( Partition & partition )
partition .messages .push_back( error ) ; partition .messages .push_back( error ) ;
} }
bool fat16::Create( const Partition & new_partition, std::vector<OperationDetail> & operation_details ) bool fat16::create( const Partition & new_partition, OperationDetail & operationdetail )
{ {
return ! execute_command( "mkdosfs -F16 -v " + new_partition .get_path(), operation_details ) ; return ! execute_command( "mkdosfs -F16 -v " + new_partition .get_path(), operationdetail ) ;
} }
bool fat16::Resize( const Partition & partition_new, bool fat16::resize( const Partition & partition_new, OperationDetail & operationdetail, bool fill_partition )
std::vector<OperationDetail> & operation_details,
bool fill_partition )
{ {
return true ; return true ;
} }
bool fat16::Copy( const Glib::ustring & src_part_path, bool fat16::copy( const Glib::ustring & src_part_path,
const Glib::ustring & dest_part_path, const Glib::ustring & dest_part_path,
std::vector<OperationDetail> & operation_details ) OperationDetail & operationdetail )
{ {
return true ; return true ;
} }
bool fat16::Check_Repair( const Partition & partition, std::vector<OperationDetail> & operation_details ) bool fat16::check_repair( const Partition & partition, OperationDetail & operationdetail )
{ {
exit_status = execute_command( "dosfsck -a -w -v " + partition .get_path(), operation_details ) ; exit_status = execute_command( "dosfsck -a -w -v " + partition .get_path(), operationdetail ) ;
return ( exit_status == 0 || exit_status == 1 ) ; return ( exit_status == 0 || exit_status == 1 ) ;
} }

18
src/fat32.cc
View File

@ -48,7 +48,7 @@ FS fat32::get_filesystem_support()
return fs ; return fs ;
} }
void fat32::Set_Used_Sectors( Partition & partition ) void fat32::set_used_sectors( Partition & partition )
{ {
exit_status = Utils::execute_command( "dosfsck -a -v " + partition .get_path(), output, error, true ) ; exit_status = Utils::execute_command( "dosfsck -a -v " + partition .get_path(), output, error, true ) ;
if ( exit_status == 0 || exit_status == 1 ) if ( exit_status == 0 || exit_status == 1 )
@ -72,28 +72,26 @@ void fat32::Set_Used_Sectors( Partition & partition )
partition .messages .push_back( error ) ; partition .messages .push_back( error ) ;
} }
bool fat32::Create( const Partition & new_partition, std::vector<OperationDetail> & operation_details ) bool fat32::create( const Partition & new_partition, OperationDetail & operationdetail )
{ {
return ! execute_command( "mkdosfs -F32 -v " + new_partition .get_path(), operation_details ) ; return ! execute_command( "mkdosfs -F32 -v " + new_partition .get_path(), operationdetail ) ;
} }
bool fat32::Resize( const Partition & partition_new, bool fat32::resize( const Partition & partition_new, OperationDetail & operationdetail, bool fill_partition )
std::vector<OperationDetail> & operation_details,
bool fill_partition )
{ {
return true ; return true ;
} }
bool fat32::Copy( const Glib::ustring & src_part_path, bool fat32::copy( const Glib::ustring & src_part_path,
const Glib::ustring & dest_part_path, const Glib::ustring & dest_part_path,
std::vector<OperationDetail> & operation_details ) OperationDetail & operationdetail )
{ {
return true ; return true ;
} }
bool fat32::Check_Repair( const Partition & partition, std::vector<OperationDetail> & operation_details ) bool fat32::check_repair( const Partition & partition, OperationDetail & operationdetail )
{ {
exit_status = execute_command( "dosfsck -a -w -v " + partition .get_path(), operation_details ) ; exit_status = execute_command( "dosfsck -a -w -v " + partition .get_path(), operationdetail ) ;
return ( exit_status == 0 || exit_status == 1 ) ; return ( exit_status == 0 || exit_status == 1 ) ;
} }

16
src/hfs.cc
View File

@ -41,30 +41,28 @@ FS hfs::get_filesystem_support()
return fs ; return fs ;
} }
void hfs::Set_Used_Sectors( Partition & partition ) void hfs::set_used_sectors( Partition & partition )
{ {
} }
bool hfs::Create( const Partition & new_partition, std::vector<OperationDetail> & operation_details ) bool hfs::create( const Partition & new_partition, OperationDetail & operationdetail )
{ {
return ! execute_command( "hformat " + new_partition .get_path(), operation_details ) ; return ! execute_command( "hformat " + new_partition .get_path(), operationdetail ) ;
} }
bool hfs::Resize( const Partition & partition_new, bool hfs::resize( const Partition & partition_new, OperationDetail & operationdetail, bool fill_partition )
std::vector<OperationDetail> & operation_details,
bool fill_partition )
{ {
return true ; return true ;
} }
bool hfs::Copy( const Glib::ustring & src_part_path, bool hfs::copy( const Glib::ustring & src_part_path,
const Glib::ustring & dest_part_path, const Glib::ustring & dest_part_path,
std::vector<OperationDetail> & operation_details ) OperationDetail & operationdetail )
{ {
return true ; return true ;
} }
bool hfs::Check_Repair( const Partition & partition, std::vector<OperationDetail> & operation_details ) bool hfs::check_repair( const Partition & partition, OperationDetail & operationdetail )
{ {
return true ; return true ;
} }

14
src/hfsplus.cc
View File

@ -36,30 +36,28 @@ FS hfsplus::get_filesystem_support()
return fs ; return fs ;
} }
void hfsplus::Set_Used_Sectors( Partition & partition ) void hfsplus::set_used_sectors( Partition & partition )
{ {
} }
bool hfsplus::Create( const Partition & new_partition, std::vector<OperationDetail> & operation_details ) bool hfsplus::create( const Partition & new_partition, OperationDetail & operationdetail )
{ {
return true ; return true ;
} }
bool hfsplus::Resize( const Partition & partition_new, bool hfsplus::resize( const Partition & partition_new, OperationDetail & operationdetail, bool fill_partition )
std::vector<OperationDetail> & operation_details,
bool fill_partition )
{ {
return true ; return true ;
} }
bool hfsplus::Copy( const Glib::ustring & src_part_path, bool hfsplus::copy( const Glib::ustring & src_part_path,
const Glib::ustring & dest_part_path, const Glib::ustring & dest_part_path,
std::vector<OperationDetail> & operation_details ) OperationDetail & operationdetail )
{ {
return true ; return true ;
} }
bool hfsplus::Check_Repair( const Partition & partition, std::vector<OperationDetail> & operation_details ) bool hfsplus::check_repair( const Partition & partition, OperationDetail & operationdetail )
{ {
return true ; return true ;
} }

62
src/jfs.cc
View File

@ -70,7 +70,7 @@ FS jfs::get_filesystem_support()
return fs ; return fs ;
} }
void jfs::Set_Used_Sectors( Partition & partition ) void jfs::set_used_sectors( Partition & partition )
{ {
if ( ! Utils::execute_command( "echo dm | jfs_debugfs " + partition .get_path(), output, error, true ) ) if ( ! Utils::execute_command( "echo dm | jfs_debugfs " + partition .get_path(), output, error, true ) )
{ {
@ -93,83 +93,81 @@ void jfs::Set_Used_Sectors( Partition & partition )
partition .messages .push_back( error ) ; partition .messages .push_back( error ) ;
} }
bool jfs::Create( const Partition & new_partition, std::vector<OperationDetail> & operation_details ) bool jfs::create( const Partition & new_partition, OperationDetail & operationdetail )
{ {
return ! execute_command( "mkfs.jfs -q " + new_partition .get_path(), operation_details ) ; return ! execute_command( "mkfs.jfs -q " + new_partition .get_path(), operationdetail ) ;
} }
bool jfs::Resize( const Partition & partition_new, bool jfs::resize( const Partition & partition_new, OperationDetail & operationdetail, bool fill_partition )
std::vector<OperationDetail> & operation_details,
bool fill_partition )
{ {
bool return_value = false ; bool return_value = false ;
Glib::ustring error ; Glib::ustring error ;
Glib::ustring TEMP_MP = Glib::get_tmp_dir() + "/gparted_tmp_jfs_mountpoint" ; Glib::ustring TEMP_MP = Glib::get_tmp_dir() + "/gparted_tmp_jfs_mountpoint" ;
//create mountpoint... //create mountpoint...
operation_details .push_back( operationdetail .add_child( OperationDetail( String::ucompose( _("create temporary mountpoint (%1)"), TEMP_MP ) ) ) ;
OperationDetail( String::ucompose( _("create temporary mountpoint (%1)"), TEMP_MP ) ) ) ;
if ( ! mkdir( TEMP_MP .c_str(), 0 ) ) if ( ! mkdir( TEMP_MP .c_str(), 0 ) )
{ {
operation_details .back() .status = STATUS_SUCCES ; operationdetail .get_last_child() .set_status( STATUS_SUCCES ) ;
//mount partition //mount partition
operation_details .push_back( operationdetail .add_child(
OperationDetail( String::ucompose( _("mount %1 on %2"), partition_new .get_path(), TEMP_MP ) ) ) ; OperationDetail( String::ucompose( _("mount %1 on %2"), partition_new .get_path(), TEMP_MP ) ) ) ;
if ( ! execute_command( "mount -v -t jfs " + partition_new .get_path() + " " + TEMP_MP, if ( ! execute_command( "mount -v -t jfs " + partition_new .get_path() + " " + TEMP_MP,
operation_details .back() .sub_details ) ) operationdetail .get_last_child() ) )
{ {
operation_details .back() .status = STATUS_SUCCES ; operationdetail .get_last_child() .set_status( STATUS_SUCCES ) ;
//remount the partition to resize the filesystem //remount the partition to resize the filesystem
operation_details .push_back( operationdetail .add_child(
OperationDetail( String::ucompose( _("remount %1 on %2 with the 'resize' flag enabled"), OperationDetail( String::ucompose( _("remount %1 on %2 with the 'resize' flag enabled"),
partition_new .get_path(), TEMP_MP ) ) ) ; partition_new .get_path(),
TEMP_MP ) ) ) ;
if ( ! execute_command( if ( ! execute_command(
"mount -v -t jfs -o remount,resize " + partition_new .get_path() + " " + TEMP_MP, "mount -v -t jfs -o remount,resize " + partition_new .get_path() + " " + TEMP_MP,
operation_details .back() .sub_details ) ) operationdetail .get_last_child() ) )
{ {
operation_details .back() .status = STATUS_SUCCES ; operationdetail .get_last_child() .set_status( STATUS_SUCCES ) ;
return_value = true ; return_value = true ;
} }
else else
{ {
operation_details .back() .status = STATUS_ERROR ; operationdetail .get_last_child() .set_status( STATUS_ERROR ) ;
} }
//and unmount it... //and unmount it...
operation_details .push_back( operationdetail .add_child(
OperationDetail( String::ucompose( _("unmount %1"), partition_new .get_path() ) ) ) ; OperationDetail( String::ucompose( _("unmount %1"), partition_new .get_path() ) ) ) ;
if ( ! execute_command( "umount -v " + partition_new .get_path(), if ( ! execute_command( "umount -v " + partition_new .get_path(),
operation_details .back() .sub_details ) ) operationdetail .get_last_child() ) )
{ {
operation_details .back() .status = STATUS_SUCCES ; operationdetail .get_last_child() .set_status( STATUS_SUCCES ) ;
} }
else else
{ {
operation_details .back() .status = STATUS_ERROR ; operationdetail .get_last_child() .set_status( STATUS_ERROR ) ;
return_value = false ; return_value = false ;
} }
} }
else else
{ {
operation_details .back() .status = STATUS_ERROR ; operationdetail .get_last_child() .set_status( STATUS_ERROR ) ;
} }
//remove the mountpoint.. //remove the mountpoint..
operation_details .push_back( operationdetail .add_child(
OperationDetail( String::ucompose( _("remove temporary mountpoint (%1)"), TEMP_MP ) ) ) ; OperationDetail( String::ucompose( _("remove temporary mountpoint (%1)"), TEMP_MP ) ) ) ;
if ( ! rmdir( TEMP_MP .c_str() ) ) if ( ! rmdir( TEMP_MP .c_str() ) )
{ {
operation_details .back() .status = STATUS_SUCCES ; operationdetail .get_last_child() .set_status( STATUS_SUCCES ) ;
} }
else else
{ {
operation_details .back() .status = STATUS_ERROR ; operationdetail .get_last_child() .set_status( STATUS_ERROR ) ;
operation_details .back() .sub_details .push_back( operationdetail .get_last_child() .add_child(
OperationDetail( Glib::strerror( errno ), STATUS_NONE ) ) ; OperationDetail( Glib::strerror( errno ), STATUS_NONE ) ) ;
return_value = false ; return_value = false ;
@ -177,24 +175,24 @@ bool jfs::Resize( const Partition & partition_new,
} }
else else
{ {
operation_details .back() .status = STATUS_ERROR ; operationdetail .get_last_child() .set_status( STATUS_ERROR ) ;
operation_details .back() .sub_details .push_back( operationdetail .get_last_child() .add_child(
OperationDetail( Glib::strerror( errno ), STATUS_NONE ) ) ; OperationDetail( Glib::strerror( errno ), STATUS_NONE ) ) ;
} }
return return_value ; return return_value ;
} }
bool jfs::Copy( const Glib::ustring & src_part_path, bool jfs::copy( const Glib::ustring & src_part_path,
const Glib::ustring & dest_part_path, const Glib::ustring & dest_part_path,
std::vector<OperationDetail> & operation_details ) OperationDetail & operationdetail )
{ {
return true ; return true ;
} }
bool jfs::Check_Repair( const Partition & partition, std::vector<OperationDetail> & operation_details ) bool jfs::check_repair( const Partition & partition, OperationDetail & operationdetail )
{ {
exit_status = execute_command( "jfs_fsck -f " + partition .get_path(), operation_details ) ; exit_status = execute_command( "jfs_fsck -f " + partition .get_path(), operationdetail ) ;
return ( exit_status == 0 || exit_status == 1 ) ; return ( exit_status == 0 || exit_status == 1 ) ;
} }

29
src/linux_swap.cc
View File

@ -39,30 +39,39 @@ FS linux_swap::get_filesystem_support()
return fs ; return fs ;
} }
void linux_swap::Set_Used_Sectors( Partition & partition ) void linux_swap::set_used_sectors( Partition & partition )
{ {
} }
bool linux_swap::Create( const Partition & new_partition, std::vector<OperationDetail> & operation_details ) bool linux_swap::create( const Partition & new_partition, OperationDetail & operationdetail )
{ {
return ! execute_command( "mkswap " + new_partition .get_path(), operation_details ) ; return ! execute_command( "mkswap " + new_partition .get_path(), operationdetail ) ;
} }
bool linux_swap::Resize( const Partition & partition_new, bool linux_swap::resize( const Partition & partition_new, OperationDetail & operationdetail, bool fill_partition )
std::vector<OperationDetail> & operation_details,
bool fill_partition )
{ {
return Create( partition_new, operation_details ) ; operationdetail .add_child( OperationDetail(
String::ucompose( _("create new %1 filesystem"), Utils::get_filesystem_string( FS_LINUX_SWAP ) ) ) ) ;
if ( create( partition_new, operationdetail .get_last_child() ) )
{
operationdetail .get_last_child() .set_status( STATUS_SUCCES ) ;
return true ;
}
else
{
operationdetail .get_last_child() .set_status( STATUS_ERROR ) ;
return false ;
}
} }
bool linux_swap::Copy( const Glib::ustring & src_part_path, bool linux_swap::copy( const Glib::ustring & src_part_path,
const Glib::ustring & dest_part_path, const Glib::ustring & dest_part_path,
std::vector<OperationDetail> & operation_details ) OperationDetail & operationdetail )
{ {
return true ; return true ;
} }
bool linux_swap::Check_Repair( const Partition & partition, std::vector<OperationDetail> & operation_details ) bool linux_swap::check_repair( const Partition & partition, OperationDetail & operationdetail )
{ {
return true ; return true ;
} }

36
src/ntfs.cc
View File

@ -54,7 +54,7 @@ FS ntfs::get_filesystem_support()
return fs ; return fs ;
} }
void ntfs::Set_Used_Sectors( Partition & partition ) void ntfs::set_used_sectors( Partition & partition )
{ {
if ( ! Utils::execute_command( "ntfscluster --force " + partition .get_path(), output, error, true ) ) if ( ! Utils::execute_command( "ntfscluster --force " + partition .get_path(), output, error, true ) )
{ {
@ -70,14 +70,12 @@ void ntfs::Set_Used_Sectors( Partition & partition )
partition .messages .push_back( error ) ; partition .messages .push_back( error ) ;
} }
bool ntfs::Create( const Partition & new_partition, std::vector<OperationDetail> & operation_details ) bool ntfs::create( const Partition & new_partition, OperationDetail & operationdetail )
{ {
return ! execute_command( "mkntfs -Q -vv " + new_partition .get_path(), operation_details ) ; return ! execute_command( "mkntfs -Q -vv " + new_partition .get_path(), operationdetail ) ;
} }
bool ntfs::Resize( const Partition & partition_new, bool ntfs::resize( const Partition & partition_new, OperationDetail & operationdetail, bool fill_partition )
std::vector<OperationDetail> & operation_details,
bool fill_partition )
{ {
bool return_value = false ; bool return_value = false ;
Glib::ustring str_temp = "ntfsresize -P --force --force " + partition_new .get_path() ; Glib::ustring str_temp = "ntfsresize -P --force --force " + partition_new .get_path() ;
@ -90,43 +88,43 @@ bool ntfs::Resize( const Partition & partition_new,
} }
//simulation.. //simulation..
operation_details .push_back( OperationDetail( _("run simulation") ) ) ; operationdetail .add_child( OperationDetail( _("run simulation") ) ) ;
if ( ! execute_command( str_temp + " --no-action", operation_details .back() .sub_details ) ) if ( ! execute_command( str_temp + " --no-action", operationdetail .get_last_child() ) )
{ {
operation_details .back() .status = STATUS_SUCCES ; operationdetail .get_last_child() .set_status( STATUS_SUCCES ) ;
//real resize //real resize
operation_details .push_back( OperationDetail( _("real resize") ) ) ; operationdetail .add_child( OperationDetail( _("real resize") ) ) ;
if ( ! execute_command( str_temp, operation_details .back() .sub_details ) ) if ( ! execute_command( str_temp, operationdetail .get_last_child() ) )
{ {
operation_details .back() .status = STATUS_SUCCES ; operationdetail .get_last_child() .set_status( STATUS_SUCCES ) ;
return_value = true ; return_value = true ;
} }
else else
{ {
operation_details .back() .status = STATUS_ERROR ; operationdetail .get_last_child() .set_status( STATUS_ERROR ) ;
} }
} }
else else
{ {
operation_details .back() .status = STATUS_ERROR ; operationdetail .get_last_child() .set_status( STATUS_ERROR ) ;
} }
return return_value ; return return_value ;
} }
bool ntfs::Copy( const Glib::ustring & src_part_path, bool ntfs::copy( const Glib::ustring & src_part_path,
const Glib::ustring & dest_part_path, const Glib::ustring & dest_part_path,
std::vector<OperationDetail> & operation_details ) OperationDetail & operationdetail )
{ {
return ! execute_command( "ntfsclone -f --overwrite " + dest_part_path + " " + src_part_path, operation_details ) ; return ! execute_command( "ntfsclone -f --overwrite " + dest_part_path + " " + src_part_path, operationdetail ) ;
} }
bool ntfs::Check_Repair( const Partition & partition, std::vector<OperationDetail> & operation_details ) bool ntfs::check_repair( const Partition & partition, OperationDetail & operationdetail )
{ {
return ! execute_command( "ntfsresize -P -i -f -v " + partition .get_path(), operation_details ) ; return ! execute_command( "ntfsresize -P -i -f -v " + partition .get_path(), operationdetail ) ;
} }
} //GParted } //GParted

18
src/reiser4.cc
View File

@ -50,7 +50,7 @@ FS reiser4::get_filesystem_support()
return fs ; return fs ;
} }
void reiser4::Set_Used_Sectors( Partition & partition ) void reiser4::set_used_sectors( Partition & partition )
{ {
if ( ! Utils::execute_command( "debugfs.reiser4 " + partition .get_path(), output, error, true ) ) if ( ! Utils::execute_command( "debugfs.reiser4 " + partition .get_path(), output, error, true ) )
{ {
@ -71,28 +71,26 @@ void reiser4::Set_Used_Sectors( Partition & partition )
partition .messages .push_back( error ) ; partition .messages .push_back( error ) ;
} }
bool reiser4::Create( const Partition & new_partition, std::vector<OperationDetail> & operation_details ) bool reiser4::create( const Partition & new_partition, OperationDetail & operationdetail )
{ {
return ! execute_command( "mkfs.reiser4 --yes " + new_partition .get_path(), operation_details ) ; return ! execute_command( "mkfs.reiser4 --yes " + new_partition .get_path(), operationdetail ) ;
} }
bool reiser4::Resize( const Partition & partition_new, bool reiser4::resize( const Partition & partition_new, OperationDetail & operationdetail, bool fill_partition )
std::vector<OperationDetail> & operation_details,
bool fill_partition )
{ {
return true ; return true ;
} }
bool reiser4::Copy( const Glib::ustring & src_part_path, bool reiser4::copy( const Glib::ustring & src_part_path,
const Glib::ustring & dest_part_path, const Glib::ustring & dest_part_path,
std::vector<OperationDetail> & operation_details ) OperationDetail & operationdetail )
{ {
return true ; return true ;
} }
bool reiser4::Check_Repair( const Partition & partition, std::vector<OperationDetail> & operation_details ) bool reiser4::check_repair( const Partition & partition, OperationDetail & operationdetail )
{ {
return ! execute_command( "fsck.reiser4 --yes --fix " + partition .get_path(), operation_details ) ; return ! execute_command( "fsck.reiser4 --yes --fix " + partition .get_path(), operationdetail ) ;
} }
} //GParted } //GParted

20
src/reiserfs.cc
View File

@ -55,7 +55,7 @@ FS reiserfs::get_filesystem_support()
return fs ; return fs ;
} }
void reiserfs::Set_Used_Sectors( Partition & partition ) void reiserfs::set_used_sectors( Partition & partition )
{ {
if ( ! Utils::execute_command( "debugreiserfs " + partition .get_path(), output, error, true ) ) if ( ! Utils::execute_command( "debugreiserfs " + partition .get_path(), output, error, true ) )
{ {
@ -76,14 +76,12 @@ void reiserfs::Set_Used_Sectors( Partition & partition )
partition .messages .push_back( error ) ; partition .messages .push_back( error ) ;
} }
bool reiserfs::Create( const Partition & new_partition, std::vector<OperationDetail> & operation_details ) bool reiserfs::create( const Partition & new_partition, OperationDetail & operationdetail )
{ {
return ! execute_command( "mkreiserfs -f " + new_partition .get_path(), operation_details ) ; return ! execute_command( "mkreiserfs -f " + new_partition .get_path(), operationdetail ) ;
} }
bool reiserfs::Resize( const Partition & partition_new, bool reiserfs::resize( const Partition & partition_new, OperationDetail & operationdetail, bool fill_partition )
std::vector<OperationDetail> & operation_details,
bool fill_partition )
{ {
Glib::ustring str_temp = "echo y | resize_reiserfs " + partition_new .get_path() ; Glib::ustring str_temp = "echo y | resize_reiserfs " + partition_new .get_path() ;
@ -94,21 +92,21 @@ bool reiserfs::Resize( const Partition & partition_new,
partition_new .get_length(), GParted::UNIT_BYTE ) ) -1, true ) ; partition_new .get_length(), GParted::UNIT_BYTE ) ) -1, true ) ;
} }
exit_status = execute_command( str_temp, operation_details ) ; exit_status = execute_command( str_temp, operationdetail ) ;
return ( exit_status == 0 || exit_status == 256 ) ; return ( exit_status == 0 || exit_status == 256 ) ;
} }
bool reiserfs::Copy( const Glib::ustring & src_part_path, bool reiserfs::copy( const Glib::ustring & src_part_path,
const Glib::ustring & dest_part_path, const Glib::ustring & dest_part_path,
std::vector<OperationDetail> & operation_details ) OperationDetail & operationdetail )
{ {
return true ; return true ;
} }
bool reiserfs::Check_Repair( const Partition & partition, std::vector<OperationDetail> & operation_details ) bool reiserfs::check_repair( const Partition & partition, OperationDetail & operationdetail )
{ {
exit_status = execute_command( "reiserfsck --y --fix-fixable " + partition .get_path(), operation_details ) ; exit_status = execute_command( "reiserfsck --y --fix-fixable " + partition .get_path(), operationdetail ) ;
return ( exit_status == 0 || exit_status == 1 || exit_status == 256 ) ; return ( exit_status == 0 || exit_status == 1 || exit_status == 256 ) ;
} }

16
src/ufs.cc
View File

@ -33,30 +33,28 @@ FS ufs::get_filesystem_support()
return fs ; return fs ;
} }
void ufs::Set_Used_Sectors( Partition & partition ) void ufs::set_used_sectors( Partition & partition )
{ {
} }
bool ufs::Create( const Partition & new_partition, std::vector<OperationDetail> & operation_details ) bool ufs::create( const Partition & new_partition, OperationDetail & operationdetail )
{ {
return true ; return true ;
} }
bool ufs::Resize( const Partition & partition_new, bool ufs::resize( const Partition & partition_new, OperationDetail & operationdetail, bool fill_partition )
std::vector<OperationDetail> & operation_details,
bool fill_partition )
{ {
return true ; return true ;
} }
bool ufs::Copy( const Glib::ustring & src_part_path, bool ufs::copy( const Glib::ustring & src_part_path,
const Glib::ustring & dest_part_path, const Glib::ustring & dest_part_path,
std::vector<OperationDetail> & operation_details ) OperationDetail & operationdetail )
{ {
return true ; return true ;
} }
bool ufs::Check_Repair( const Partition & partition, std::vector<OperationDetail> & operation_details ) bool ufs::check_repair( const Partition & partition, OperationDetail & operationdetail )
{ {
return true ; return true ;
} }

143
src/xfs.cc
View File

@ -70,7 +70,7 @@ FS xfs::get_filesystem_support()
return fs ; return fs ;
} }
void xfs::Set_Used_Sectors( Partition & partition ) void xfs::set_used_sectors( Partition & partition )
{ {
if ( ! Utils::execute_command( if ( ! Utils::execute_command(
"xfs_db -c 'sb 0' -c 'print blocksize' -c 'print fdblocks' -r " + partition .get_path(), "xfs_db -c 'sb 0' -c 'print blocksize' -c 'print fdblocks' -r " + partition .get_path(),
@ -95,80 +95,76 @@ void xfs::Set_Used_Sectors( Partition & partition )
partition .messages .push_back( error ) ; partition .messages .push_back( error ) ;
} }
bool xfs::Create( const Partition & new_partition, std::vector<OperationDetail> & operation_details ) bool xfs::create( const Partition & new_partition, OperationDetail & operationdetail )
{ {
return ! execute_command( "mkfs.xfs -f " + new_partition .get_path(), operation_details ) ; return ! execute_command( "mkfs.xfs -f " + new_partition .get_path(), operationdetail ) ;
} }
bool xfs::Resize( const Partition & partition_new, bool xfs::resize( const Partition & partition_new, OperationDetail & operationdetail, bool fill_partition )
std::vector<OperationDetail> & operation_details,
bool fill_partition )
{ {
bool return_value = false ; bool return_value = false ;
Glib::ustring error ; Glib::ustring error ;
Glib::ustring TEMP_MP = Glib::get_tmp_dir() + "/gparted_tmp_xfs_mountpoint" ; Glib::ustring TEMP_MP = Glib::get_tmp_dir() + "/gparted_tmp_xfs_mountpoint" ;
//create mountpoint... //create mountpoint...
operation_details .push_back( operationdetail .add_child( OperationDetail( String::ucompose( _("create temporary mountpoint (%1)"), TEMP_MP ) ) ) ;
OperationDetail( String::ucompose( _("create temporary mountpoint (%1)"), TEMP_MP ) ) ) ;
if ( ! mkdir( TEMP_MP .c_str(), 0 ) ) if ( ! mkdir( TEMP_MP .c_str(), 0 ) )
{ {
operation_details .back() .status = STATUS_SUCCES ; operationdetail .get_last_child() .set_status( STATUS_SUCCES ) ;
//mount partition //mount partition
operation_details .push_back( operationdetail .add_child(
OperationDetail( String::ucompose( _("mount %1 on %2"), partition_new .get_path(), TEMP_MP ) ) ) ; OperationDetail( String::ucompose( _("mount %1 on %2"), partition_new .get_path(), TEMP_MP ) ) ) ;
if ( ! execute_command( "mount -v -t xfs " + partition_new .get_path() + " " + TEMP_MP, if ( ! execute_command( "mount -v -t xfs " + partition_new .get_path() + " " + TEMP_MP,
operation_details .back() .sub_details ) ) operationdetail .get_last_child() ) )
{ {
operation_details .back() .status = STATUS_SUCCES ; operationdetail .get_last_child() .set_status( STATUS_SUCCES ) ;
//grow the mounted filesystem.. //grow the mounted filesystem..
operation_details .push_back( OperationDetail( _("grow mounted filesystem") ) ) ; operationdetail .add_child( OperationDetail( _("grow mounted filesystem") ) ) ;
if ( ! execute_command ( "xfs_growfs " + TEMP_MP, if ( ! execute_command ( "xfs_growfs " + TEMP_MP, operationdetail .get_last_child() ) )
operation_details .back() .sub_details ) )
{ {
operation_details .back() .status = STATUS_SUCCES ; operationdetail .get_last_child() .set_status( STATUS_SUCCES ) ;
return_value = true ; return_value = true ;
} }
else else
{ {
operation_details .back() .status = STATUS_ERROR ; operationdetail .get_last_child() .set_status( STATUS_ERROR ) ;
} }
//and unmount it... //and unmount it...
operation_details .push_back( operationdetail .add_child(
OperationDetail( String::ucompose( _("unmount %1"), partition_new .get_path() ) ) ) ; OperationDetail( String::ucompose( _("unmount %1"), partition_new .get_path() ) ) ) ;
if ( ! execute_command( "umount -v " + partition_new .get_path(), if ( ! execute_command( "umount -v " + partition_new .get_path(),
operation_details .back() .sub_details ) ) operationdetail .get_last_child() ) )
{ {
operation_details .back() .status = STATUS_SUCCES ; operationdetail .get_last_child() .set_status( STATUS_SUCCES ) ;
} }
else else
{ {
operation_details .back() .status = STATUS_ERROR ; operationdetail .get_last_child() .set_status( STATUS_ERROR ) ;
return_value = false ; return_value = false ;
} }
} }
else else
{ {
operation_details .back() .status = STATUS_ERROR ; operationdetail .get_last_child() .set_status( STATUS_ERROR ) ;
} }
//remove the mountpoint.. //remove the mountpoint..
operation_details .push_back( operationdetail .add_child(
OperationDetail( String::ucompose( _("remove temporary mountpoint (%1)"), TEMP_MP ) ) ) ; OperationDetail( String::ucompose( _("remove temporary mountpoint (%1)"), TEMP_MP ) ) ) ;
if ( ! rmdir( TEMP_MP .c_str() ) ) if ( ! rmdir( TEMP_MP .c_str() ) )
{ {
operation_details .back() .status = STATUS_SUCCES ; operationdetail .get_last_child() .set_status( STATUS_SUCCES ) ;
} }
else else
{ {
operation_details .back() .status = STATUS_ERROR ; operationdetail .get_last_child() .set_status( STATUS_ERROR ) ;
operation_details .back() .sub_details .push_back( operationdetail .get_last_child() .add_child(
OperationDetail( Glib::strerror( errno ), STATUS_NONE ) ) ; OperationDetail( Glib::strerror( errno ), STATUS_NONE ) ) ;
return_value = false ; return_value = false ;
@ -176,17 +172,16 @@ bool xfs::Resize( const Partition & partition_new,
} }
else else
{ {
operation_details .back() .status = STATUS_ERROR ; operationdetail .get_last_child() .set_status( STATUS_ERROR ) ;
operation_details .back() .sub_details .push_back( operationdetail .get_last_child() .add_child( OperationDetail( Glib::strerror( errno ), STATUS_NONE ) ) ;
OperationDetail( Glib::strerror( errno ), STATUS_NONE ) ) ;
} }
return return_value ; return return_value ;
} }
bool xfs::Copy( const Glib::ustring & src_part_path, bool xfs::copy( const Glib::ustring & src_part_path,
const Glib::ustring & dest_part_path, const Glib::ustring & dest_part_path,
std::vector<OperationDetail> & operation_details ) OperationDetail & operationdetail )
{ {
bool return_value = false ; bool return_value = false ;
Glib::ustring error ; Glib::ustring error ;
@ -194,108 +189,112 @@ bool xfs::Copy( const Glib::ustring & src_part_path,
Glib::ustring DST = Glib::get_tmp_dir() + "/gparted_tmp_xfs_dest_mountpoint" ; Glib::ustring DST = Glib::get_tmp_dir() + "/gparted_tmp_xfs_dest_mountpoint" ;
//create xfs filesystem on destination.. //create xfs filesystem on destination..
Partition partition( dest_part_path ) ; operationdetail .add_child( OperationDetail(
if ( Create( partition, operation_details ) ) String::ucompose( _("create new %1 filesystem"), Utils::get_filesystem_string( FS_XFS ) ) ) ) ;
if ( create( Partition( dest_part_path ), operationdetail .get_last_child() ) )
{ {
operationdetail .get_last_child() .set_status( STATUS_SUCCES ) ;
//create source mountpoint... //create source mountpoint...
operation_details .push_back( operationdetail .add_child(
OperationDetail( String::ucompose( _("create temporary mountpoint (%1)"), SRC ) ) ) ; OperationDetail( String::ucompose( _("create temporary mountpoint (%1)"), SRC ) ) ) ;
if ( ! mkdir( SRC .c_str(), 0 ) ) if ( ! mkdir( SRC .c_str(), 0 ) )
{ {
operation_details .back() .status = STATUS_SUCCES ; operationdetail .get_last_child() .set_status( STATUS_SUCCES ) ;
//create destination mountpoint... //create destination mountpoint...
operation_details .push_back( operationdetail .add_child(
OperationDetail( String::ucompose( _("create temporary mountpoint (%1)"), DST ) ) ) ; OperationDetail( String::ucompose( _("create temporary mountpoint (%1)"), DST ) ) ) ;
if ( ! mkdir( DST .c_str(), 0 ) ) if ( ! mkdir( DST .c_str(), 0 ) )
{ {
operation_details .back() .status = STATUS_SUCCES ; operationdetail .get_last_child() .set_status( STATUS_SUCCES ) ;
//mount source partition //mount source partition
operation_details .push_back( operationdetail .add_child(
OperationDetail( String::ucompose( _("mount %1 on %2"), src_part_path, SRC ) ) ) ; OperationDetail( String::ucompose( _("mount %1 on %2"), src_part_path, SRC ) ) ) ;
if ( ! execute_command( "mount -v -t xfs -o noatime,ro " + src_part_path + " " + SRC, if ( ! execute_command( "mount -v -t xfs -o noatime,ro " + src_part_path + " " + SRC,
operation_details .back() .sub_details ) ) operationdetail .get_last_child() ) )
{ {
operation_details .back() .status = STATUS_SUCCES ; operationdetail .get_last_child() .set_status( STATUS_SUCCES ) ;
//mount destination partition //mount destination partition
operation_details .push_back( operationdetail .add_child(
OperationDetail( String::ucompose( _("mount %1 on %2"), dest_part_path, DST ) ) ) ; OperationDetail( String::ucompose( _("mount %1 on %2"), dest_part_path, DST ) ) ) ;
if ( ! execute_command( "mount -v -t xfs " + dest_part_path + " " + DST, if ( ! execute_command( "mount -v -t xfs " + dest_part_path + " " + DST,
operation_details .back() .sub_details ) ) operationdetail .get_last_child() ) )
{ {
operation_details .back() .status = STATUS_SUCCES ; operationdetail .get_last_child() .set_status( STATUS_SUCCES ) ;
//copy filesystem.. //copy filesystem..
operation_details .push_back( OperationDetail( _("copy filesystem") ) ) ; operationdetail .add_child( OperationDetail( _("copy filesystem") ) ) ;
if ( ! execute_command( if ( ! execute_command(
"xfsdump -J - " + SRC + " | xfsrestore -J - " + DST, "xfsdump -J - " + SRC + " | xfsrestore -J - " + DST,
operation_details .back() .sub_details ) ) operationdetail .get_last_child() ) )
{ {
operation_details .back() .status = STATUS_SUCCES ; operationdetail .get_last_child() .set_status( STATUS_SUCCES ) ;
return_value = true ; return_value = true ;
} }
else else
{ {
operation_details .back() .status = STATUS_ERROR ; operationdetail .get_last_child() .set_status( STATUS_ERROR ) ;
} }
//unmount destination partition //unmount destination partition
operation_details .push_back( operationdetail .add_child(
OperationDetail( String::ucompose( _("unmount %1"), OperationDetail( String::ucompose( _("unmount %1"),
dest_part_path ) ) ) ; dest_part_path ) ) ) ;
if ( ! execute_command( "umount -v " + dest_part_path, if ( ! execute_command( "umount -v " + dest_part_path,
operation_details .back() .sub_details ) ) operationdetail .get_last_child() ) )
{ {
operation_details .back() .status = STATUS_SUCCES ; operationdetail .get_last_child() .set_status( STATUS_SUCCES ) ;
} }
else else
{ {
operation_details .back() .status = STATUS_ERROR ; operationdetail .get_last_child() .set_status( STATUS_ERROR ) ;
return_value = false ; return_value = false ;
} }
} }
else else
{ {
operation_details .back() .status = STATUS_ERROR ; operationdetail .get_last_child() .set_status( STATUS_ERROR ) ;
} }
//unmount source partition //unmount source partition
operation_details .push_back( operationdetail .add_child(
OperationDetail( String::ucompose( _("unmount %1"), src_part_path ) ) ) ; OperationDetail( String::ucompose( _("unmount %1"), src_part_path ) ) ) ;
if ( ! execute_command( "umount -v " + src_part_path, if ( ! execute_command( "umount -v " + src_part_path,
operation_details .back() .sub_details ) ) operationdetail .get_last_child() ) )
{ {
operation_details .back() .status = STATUS_SUCCES ; operationdetail .get_last_child() .set_status( STATUS_SUCCES ) ;
} }
else else
{ {
operation_details .back() .status = STATUS_ERROR ; operationdetail .get_last_child() .set_status( STATUS_ERROR ) ;
return_value = false ; return_value = false ;
} }
} }
else else
{ {
operation_details .back() .status = STATUS_ERROR ; operationdetail .get_last_child() .set_status( STATUS_ERROR ) ;
} }
//remove destination mountpoint.. //remove destination mountpoint..
operation_details .push_back( operationdetail .add_child(
OperationDetail( String::ucompose( _("remove temporary mountpoint (%1)"), DST ) ) ) ; OperationDetail( String::ucompose( _("remove temporary mountpoint (%1)"), DST ) ) ) ;
if ( ! rmdir( DST .c_str() ) ) if ( ! rmdir( DST .c_str() ) )
{ {
operation_details .back() .status = STATUS_SUCCES ; operationdetail .get_last_child() .set_status( STATUS_SUCCES ) ;
} }
else else
{ {
operation_details .back() .status = STATUS_ERROR ; operationdetail .get_last_child() .set_status( STATUS_ERROR ) ;
operation_details .back() .sub_details .push_back( operationdetail .get_last_child() .add_child(
OperationDetail( Glib::strerror( errno ), STATUS_NONE ) ) ; OperationDetail( Glib::strerror( errno ), STATUS_NONE ) ) ;
return_value = false ; return_value = false ;
@ -303,22 +302,22 @@ bool xfs::Copy( const Glib::ustring & src_part_path,
} }
else else
{ {
operation_details .back() .status = STATUS_ERROR ; operationdetail .get_last_child() .set_status( STATUS_ERROR ) ;
operation_details .back() .sub_details .push_back( operationdetail .get_last_child() .add_child(
OperationDetail( Glib::strerror( errno ), STATUS_NONE ) ) ; OperationDetail( Glib::strerror( errno ), STATUS_NONE ) ) ;
} }
//remove source mountpoint.. //remove source mountpoint..
operation_details .push_back( operationdetail .add_child(
OperationDetail( String::ucompose( _("remove temporary mountpoint (%1)"), SRC ) ) ) ; OperationDetail( String::ucompose( _("remove temporary mountpoint (%1)"), SRC ) ) ) ;
if ( ! rmdir( SRC .c_str() ) ) if ( ! rmdir( SRC .c_str() ) )
{ {
operation_details .back() .status = STATUS_SUCCES ; operationdetail .get_last_child() .set_status( STATUS_SUCCES ) ;
} }
else else
{ {
operation_details .back() .status = STATUS_ERROR ; operationdetail .get_last_child() .set_status( STATUS_ERROR ) ;
operation_details .back() .sub_details .push_back( operationdetail .get_last_child() .add_child(
OperationDetail( Glib::strerror( errno ), STATUS_NONE ) ) ; OperationDetail( Glib::strerror( errno ), STATUS_NONE ) ) ;
return_value = false ; return_value = false ;
@ -326,18 +325,20 @@ bool xfs::Copy( const Glib::ustring & src_part_path,
} }
else else
{ {
operation_details .back() .status = STATUS_ERROR ; operationdetail .get_last_child() .set_status( STATUS_ERROR ) ;
operation_details .back() .sub_details .push_back( operationdetail .get_last_child() .add_child(
OperationDetail( Glib::strerror( errno ), STATUS_NONE ) ) ; OperationDetail( Glib::strerror( errno ), STATUS_NONE ) ) ;
} }
} }
else
operationdetail .get_last_child() .set_status( STATUS_ERROR ) ;
return return_value ; return return_value ;
} }
bool xfs::Check_Repair( const Partition & partition, std::vector<OperationDetail> & operation_details ) bool xfs::check_repair( const Partition & partition, OperationDetail & operationdetail )
{ {
return ! execute_command( "xfs_repair -v " + partition .get_path(), operation_details ) ; return ! execute_command( "xfs_repair -v " + partition .get_path(), operationdetail ) ;
} }
} //GParted } //GParted