Rename Partition.filesystem member to fstype (!52)

Previously made this change: 175d27c55d Rename enum FILESYSTEM to FSType Now complete the renaming exercise of members and variables currently named 'filesystem'. Closes !52 - Rename members and variables currently named 'filesystem'
2019-06-12 12:03:51 +01:00 · 2019-06-12 12:03:51 +01:00 · b0f92be638
parent 047a2481bb
commit b0f92be638
15 changed files with 198 additions and 198 deletions
--- a/include/Partition.h
+++ b/include/Partition.h
@ -76,7 +76,7 @@ public:
 	          const Glib::ustring & partition,
 	          int partition_number,
 	          PartitionType type,
-	          FSType filesystem,
+	          FSType fstype,
 	          Sector sector_start,
 	          Sector sector_end,
 	          Byte_Value sector_size,
@ -143,7 +143,7 @@ public:
 	virtual Partition & get_filesystem_partition()                 { return *this; };
 	virtual const Glib::ustring get_filesystem_string() const
-	                                { return Utils::get_filesystem_string( filesystem ); };
+	                                { return Utils::get_filesystem_string(fstype); };
 	bool operator==( const Partition & partition ) const ;
 	bool operator!=( const Partition & partition ) const ;
@ -156,7 +156,7 @@ public:
 	PartitionType type;// UNALLOCATED, PRIMARY, LOGICAL, etc...
 	PartitionStatus status; //STAT_REAL, STAT_NEW, etc..
 	PartitionAlignment alignment;   //ALIGN_CYLINDER, ALIGN_STRICT, etc
-	FSType filesystem;
+	FSType fstype;
 	Glib::ustring uuid ;
 	Glib::ustring name;
 	Sector sector_start;
--- a/src/Dialog_FileSystem_Label.cc
+++ b/src/Dialog_FileSystem_Label.cc
@ -43,7 +43,7 @@ Dialog_FileSystem_Label::Dialog_FileSystem_Label( const Partition & partition )
 	hbox->pack_start( *Utils::mk_label("<b>" + Glib::ustring( _("Label:") ) + "</b>"),
 	                  Gtk::PACK_SHRINK );
 	entry = manage( new Gtk::Entry() );
-	entry->set_max_length( Utils::get_filesystem_label_maxlength( partition.filesystem ) );
+	entry->set_max_length(Utils::get_filesystem_label_maxlength(partition.fstype));
 	entry->set_width_chars( 30 );
 	entry->set_activates_default( true );
 	entry->set_text( partition.get_filesystem_label() );
--- a/src/Dialog_Partition_Copy.cc
+++ b/src/Dialog_Partition_Copy.cc
@ -51,7 +51,7 @@ void Dialog_Partition_Copy::set_data( const Partition & selected_partition, cons
 	this ->set_title( Glib::ustring::compose( _("Paste %1"), copied_partition .get_path() ) ) ;
 	// Set partition color
-	Gdk::RGBA partition_color(Utils::get_color(copied_partition.filesystem));
+	Gdk::RGBA partition_color(Utils::get_color(copied_partition.fstype));
 	frame_resizer_base->set_rgb_partition_color( partition_color );
 	//set some widely used values...
--- a/src/Dialog_Partition_Info.cc
+++ b/src/Dialog_Partition_Info.cc
@ -37,8 +37,8 @@ Dialog_Partition_Info::Dialog_Partition_Info( const Partition & partition ) : pa
 	// whitespace (~500 px max for GNOME desktop).  Allow extra space if have any
 	// messages or for LVM2 PV or LUKS encryption.
 	if (partition.have_messages()      ||
-	     partition.filesystem == FS_LVM2_PV ||
+	    partition.fstype == FS_LVM2_PV ||
-	     partition.filesystem == FS_LUKS       )
+	    partition.fstype == FS_LUKS      )
 		this ->set_size_request( -1, 460) ;
 	else
 		this ->set_size_request( -1, 370 ) ;	//Minimum 370 to avoid scrolling on Fedora 20
@ -129,7 +129,7 @@ bool Dialog_Partition_Info::drawingarea_on_draw(const Cairo::RefPtr<Cairo::Conte
 	cr->rectangle(0, 0, 400, 60);
 	cr->fill();
-	if ( partition.filesystem != FS_UNALLOCATED )
+	if (partition.fstype != FS_UNALLOCATED)
 	{
 		// Used
 		Gdk::Cairo::set_source_rgba(cr, color_used);
@ -204,7 +204,7 @@ void Dialog_Partition_Info::init_drawingarea()
 	color_unused.set("white");
 	color_unallocated.set("darkgrey");
 	color_text.set("black");
-	color_partition.set( Utils::get_color( partition.get_filesystem_partition().filesystem ) );
+	color_partition.set(Utils::get_color(partition.get_filesystem_partition().fstype));
 	//set text of pangolayout
 	pango_layout = drawingarea .create_pango_layout( 
@ -232,11 +232,11 @@ void Dialog_Partition_Info::Display_Info()
 	Sector ptn_sectors = partition .get_sector_length() ;
 	Glib::ustring vgname = "" ;  //Also used in partition status message
-	if ( filesystem_ptn.filesystem == FS_LVM2_PV )
+	if (filesystem_ptn.fstype == FS_LVM2_PV)
 		vgname = LVM2_PV_Info::get_vg_name( filesystem_ptn.get_path() );
 	bool filesystem_accessible = false;
-	if ( partition.filesystem != FS_LUKS || partition.busy )
+	if (partition.fstype != FS_LUKS || partition.busy)
 		// As long as this is not a LUKS encrypted partition which is closed the
 		// file system is accessible.
 		filesystem_accessible = true;
@ -259,13 +259,13 @@ void Dialog_Partition_Info::Display_Info()
 	grid->attach(*Utils::mk_label("<b>" + Glib::ustring(_("File system:")) + "</b>"), 1, top, 1, 1);
 	if ( filesystem_accessible )
 	{
-		grid->attach(*Utils::mk_label(Utils::get_filesystem_string(filesystem_ptn.filesystem), true, false, true),
+		grid->attach(*Utils::mk_label(Utils::get_filesystem_string(filesystem_ptn.fstype), true, false, true),
 		             2, top, 1, 1);
 	}
 	top++;
 	//label
-	if ( filesystem_ptn.filesystem != FS_UNALLOCATED && filesystem_ptn.type != TYPE_EXTENDED )
+	if (filesystem_ptn.fstype != FS_UNALLOCATED && filesystem_ptn.type != TYPE_EXTENDED)
 	{
 		grid->attach(*Utils::mk_label("<b>" + Glib::ustring(_("Label:")) + "</b>"),
 		             1, top, 1, 1);
@ -278,7 +278,7 @@ void Dialog_Partition_Info::Display_Info()
 	}
 	// file system uuid
-	if ( filesystem_ptn.filesystem != FS_UNALLOCATED && filesystem_ptn.type != TYPE_EXTENDED )
+	if (filesystem_ptn.fstype != FS_UNALLOCATED && filesystem_ptn.type != TYPE_EXTENDED)
 	{
 		grid->attach(*Utils::mk_label("<b>" + Glib::ustring(_("UUID:")) + "</b>"),
 		             1, top, 1, 1);
@ -300,7 +300,7 @@ void Dialog_Partition_Info::Display_Info()
 	static Glib::ustring luks_closed = _("Closed");
 	//status
-	if ( filesystem_ptn.filesystem != FS_UNALLOCATED && filesystem_ptn.status != STAT_NEW )
+	if (filesystem_ptn.fstype != FS_UNALLOCATED && filesystem_ptn.status != STAT_NEW)
 	{
 		//status
 		Glib::ustring str_temp ;
@ -325,10 +325,10 @@ void Dialog_Partition_Info::Display_Info()
 				 */
 				str_temp = _("Busy (At least one logical partition is mounted)") ;
 			}
-			else if ( filesystem_ptn.filesystem == FS_LINUX_SWAP   ||
+			else if (filesystem_ptn.fstype == FS_LINUX_SWAP   ||
-			          filesystem_ptn.filesystem == FS_LINUX_SWRAID ||
+			         filesystem_ptn.fstype == FS_LINUX_SWRAID ||
-			          filesystem_ptn.filesystem == FS_ATARAID      ||
+			         filesystem_ptn.fstype == FS_ATARAID      ||
-			          filesystem_ptn.filesystem == FS_LVM2_PV         )
+			         filesystem_ptn.fstype == FS_LVM2_PV        )
 			{
 				/* TO TRANSLATORS:  Active
 				 * means that this linux swap, linux software raid partition, or
@ -336,7 +336,7 @@ void Dialog_Partition_Info::Display_Info()
 				 */
 				str_temp = _("Active") ;
 			}
-			else if ( filesystem_ptn.filesystem == FS_LUKS )
+			else if (filesystem_ptn.fstype == FS_LUKS)
 			{
 				// NOTE: LUKS within LUKS
 				// Only ever display LUKS information in the file system
@ -360,9 +360,9 @@ void Dialog_Partition_Info::Display_Info()
 			 */
 			str_temp = _("Not busy (There are no mounted logical partitions)") ;
 		}
-		else if ( filesystem_ptn.filesystem == FS_LINUX_SWAP   ||
+		else if (filesystem_ptn.fstype == FS_LINUX_SWAP   ||
-		          filesystem_ptn.filesystem == FS_LINUX_SWRAID ||
+		         filesystem_ptn.fstype == FS_LINUX_SWRAID ||
-		          filesystem_ptn.filesystem == FS_ATARAID        )
+		         filesystem_ptn.fstype == FS_ATARAID        )
 		{
 			/* TO TRANSLATORS:  Not active
 			 *  means that this linux swap or linux software raid partition
@ -370,12 +370,12 @@ void Dialog_Partition_Info::Display_Info()
 			 */
 			str_temp = _("Not active") ;
 		}
-		else if ( filesystem_ptn.filesystem == FS_LUKS )
+		else if (filesystem_ptn.fstype == FS_LUKS)
 		{
 			// NOTE: LUKS within LUKS
 			str_temp = luks_closed;
 		}
-		else if ( filesystem_ptn.filesystem == FS_LVM2_PV )
+		else if (filesystem_ptn.fstype == FS_LVM2_PV)
 		{
 			if ( vgname .empty() )
 				/* TO TRANSLATORS:  Not active (Not a member of any volume group)
@ -411,7 +411,7 @@ void Dialog_Partition_Info::Display_Info()
 	}
 	//Optional, LVM2 Volume Group name
-	if ( filesystem_ptn.filesystem == FS_LVM2_PV )
+	if (filesystem_ptn.fstype == FS_LVM2_PV)
 	{
 		// Volume Group
 		grid->attach(*Utils::mk_label("<b>" + Glib::ustring(_("Volume Group:")) + "</b>"),
@ -421,15 +421,15 @@ void Dialog_Partition_Info::Display_Info()
 	}
 	//Optional, members of multi-device file systems
-	if ( filesystem_ptn.filesystem == FS_LVM2_PV ||
+	if (filesystem_ptn.fstype == FS_LVM2_PV ||
-	     filesystem_ptn.filesystem == FS_BTRFS      )
+	    filesystem_ptn.fstype == FS_BTRFS     )
 	{
 		// Members
 		grid->attach(*Utils::mk_label("<b>" + Glib::ustring(_("Members:")) + "</b>", true, false, false, Gtk::ALIGN_START),
 		             1, top, 1, 1);
 		std::vector<Glib::ustring> members ;
-		switch ( filesystem_ptn.filesystem )
+		switch (filesystem_ptn.fstype)
 		{
 			case FS_BTRFS:
 				members = btrfs::get_members( filesystem_ptn.get_path() );
@ -446,7 +446,7 @@ void Dialog_Partition_Info::Display_Info()
 		              2, top++, 1, 1);
 	}
-	if ( filesystem_ptn.filesystem == FS_LVM2_PV )
+	if (filesystem_ptn.fstype == FS_LVM2_PV)
 	{
 		// Logical Volumes
 		grid->attach(*Utils::mk_label("<b>" + Glib::ustring(_("Logical Volumes:")) + "</b>", true, false, false, Gtk::ALIGN_START),
@ -508,7 +508,7 @@ void Dialog_Partition_Info::Display_Info()
 	// One blank line
 	grid->attach(*Utils::mk_label(""), 0, top++, 6, 1);
-	if ( partition.filesystem == FS_LUKS )
+	if (partition.fstype == FS_LUKS)
 	{
 		// ENCRYPTION DETAIL SECTION
 		// Encryption headline
@ -518,7 +518,7 @@ void Dialog_Partition_Info::Display_Info()
 		// Encryption
 		grid->attach(*Utils::mk_label("<b>" + Glib::ustring(_("Encryption:")) + "</b>"),
 		             1, top, 1, 1);
-		grid->attach(*Utils::mk_label(Utils::get_filesystem_string(partition.filesystem), true, false, true),
+		grid->attach(*Utils::mk_label(Utils::get_filesystem_string(partition.fstype), true, false, true),
 		             2, top++, 1, 1);
 		// LUKS path
@ -564,7 +564,7 @@ void Dialog_Partition_Info::Display_Info()
 	grid->attach(*Utils::mk_label(partition.get_path(), true, false, true),
 	             2, top++, 1, 1);
-	if (partition.filesystem != FS_UNALLOCATED && partition.status != STAT_NEW)
+	if (partition.fstype != FS_UNALLOCATED && partition.status != STAT_NEW)
 	{
 		// Name
 		grid->attach(*Utils::mk_label("<b>" + Glib::ustring(_("Name:")) + "</b>"),
--- a/src/Dialog_Partition_Resize_Move.cc
+++ b/src/Dialog_Partition_Resize_Move.cc
@ -62,7 +62,7 @@ void Dialog_Partition_Resize_Move::set_data( const Partition & selected_partitio
 	}
 	// Set partition color
-	Gdk::RGBA partition_color(Utils::get_color(selected_partition.filesystem));
+	Gdk::RGBA partition_color(Utils::get_color(selected_partition.fstype));
 	frame_resizer_base->set_rgb_partition_color( partition_color );
 	//store the original values
@ -84,7 +84,7 @@ void Dialog_Partition_Resize_Move::Resize_Move_Normal( const PartitionVector & p
 	// usage is unknown as that sets the minimum resize.
 	if (! new_partition->sector_usage_known()  &&
 	    new_partition->status != STAT_NEW      &&
-	     new_partition->filesystem != FS_LINUX_SWAP    )
+	    new_partition->fstype != FS_LINUX_SWAP   )
 		fs.shrink = FS::NONE;
 	//Disable resizing as it's currently disallowed for the file system in this partition.
--- a/src/Dialog_Progress.cc
+++ b/src/Dialog_Progress.cc
@ -488,7 +488,7 @@ void Dialog_Progress::write_partition_details(const Partition& partition, std::o
 	    << "<td class='number_col'>" << partition.sector_end << "</td>"
 	    << "<td>" << Glib::build_path(", ", partition.flags) << "</td>"
 	    << "<td>" << partition.name << "</td>"
-	    << "<td>" << Utils::get_filesystem_string(partition.filesystem) << "</td>"
+	    << "<td>" << Utils::get_filesystem_string(partition.fstype) << "</td>"
 	    << "<td>" << partition.get_filesystem_label() << "</td>"
 	    << "<td>" << Glib::build_path(", ", partition.get_mountpoints()) << "</td>"
 	    << "</tr>" << std::endl;
--- a/src/Dialog_Rescue_Data.cc
+++ b/src/Dialog_Rescue_Data.cc
@ -111,18 +111,18 @@ void Dialog_Rescue_Data::create_list_of_fs()
 	for(unsigned int i=0;i<this->partitions.size();i++)
 	{
-		if (this->partitions[i].filesystem == FS_UNALLOCATED   ||
+		if (this->partitions[i].fstype == FS_UNALLOCATED   ||
-		    this->partitions[i].filesystem == FS_UNKNOWN       ||
+		    this->partitions[i].fstype == FS_UNKNOWN       ||
-		    this->partitions[i].filesystem == FS_UNFORMATTED   ||
+		    this->partitions[i].fstype == FS_UNFORMATTED   ||
-		    this->partitions[i].filesystem == FS_EXTENDED      ||
+		    this->partitions[i].fstype == FS_EXTENDED      ||
 		    this->partitions[i].type   == TYPE_EXTENDED    ||
 		    this->partitions[i].type   == TYPE_UNALLOCATED   )
 		{
 			continue;
 		}
-		std::string fs_name=Utils::get_filesystem_string( this->partitions[i].filesystem );
+		std::string fs_name = Utils::get_filesystem_string(this->partitions[i].fstype);
-		if(this->partitions[i].filesystem==FS_EXT2)
+		if (this->partitions[i].fstype == FS_EXT2)
 		{
 			fs_name+="/3/4, ReiserFs or XFS";
 		}
--- a/src/DrawingAreaVisualDisk.cc
+++ b/src/DrawingAreaVisualDisk.cc
@ -92,7 +92,7 @@ void DrawingAreaVisualDisk::set_static_data( const PartitionVector & partitions,
 		Sector partition_length = partitions[ t ] .get_sector_length() ;
 		visual_partitions .back() .fraction = partition_length / static_cast<double>( length ) ;
-		Glib::ustring color_str = Utils::get_color( partitions[t].get_filesystem_partition().filesystem );
+		Glib::ustring color_str = Utils::get_color(partitions[t].get_filesystem_partition().fstype);
 		visual_partitions.back().color.set( color_str );
 		if (partitions[t].type == TYPE_EXTENDED)
@ -148,7 +148,7 @@ void DrawingAreaVisualDisk::calc_usage( std::vector<visual_partition> & visual_p
 {
 	for ( unsigned int t = 0 ; t < visual_partitions .size() ; t++ )
 	{
-		if ( visual_partitions[t].partition_ptr->filesystem != FS_UNALLOCATED &&
+		if (visual_partitions[t].partition_ptr->fstype != FS_UNALLOCATED &&
 		    visual_partitions[t].partition_ptr->type   != TYPE_EXTENDED    )
 		{
 			if ( visual_partitions[t].partition_ptr->sector_usage_known() )
--- a/src/GParted_Core.cc
+++ b/src/GParted_Core.cc
@ -1039,8 +1039,8 @@ void GParted_Core::set_partition_label_and_uuid( Partition & partition )
 	// For SWRaid members only get the label and UUID from SWRaid_Info.  Never use
 	// values from FS_Info to avoid showing incorrect information in cases where blkid
 	// reports the wrong values.
-	if (partition.filesystem == FS_LINUX_SWRAID ||
+	if (partition.fstype == FS_LINUX_SWRAID ||
-	    partition.filesystem == FS_ATARAID        )
+	    partition.fstype == FS_ATARAID        )
 	{
 		Glib::ustring label = SWRaid_Info::get_label( partition_path );
 		if ( ! label.empty() )
@ -1329,10 +1329,10 @@ FSType GParted_Core::detect_filesystem( PedDevice * lp_device, PedPartition * lp
 void GParted_Core::read_label( Partition & partition )
 {
 	FileSystem* p_filesystem = NULL;
-	switch ( get_fs( partition.filesystem ).read_label )
+	switch (get_fs(partition.fstype).read_label)
 	{
 		case FS::EXTERNAL:
-			p_filesystem = get_filesystem_object( partition.filesystem );
+			p_filesystem = get_filesystem_object(partition.fstype);
 			if ( p_filesystem )
 				p_filesystem->read_label( partition );
 			break;
@ -1345,10 +1345,10 @@ void GParted_Core::read_label( Partition & partition )
 void GParted_Core::read_uuid( Partition & partition )
 {
 	FileSystem* p_filesystem = NULL;
-	switch ( get_fs( partition.filesystem ).read_uuid )
+	switch (get_fs(partition.fstype).read_uuid)
 	{
 		case FS::EXTERNAL:
-			p_filesystem = get_filesystem_object( partition.filesystem );
+			p_filesystem = get_filesystem_object(partition.fstype);
 			if ( p_filesystem )
 				p_filesystem->read_uuid( partition );
 			break;
@ -1415,19 +1415,19 @@ void GParted_Core::set_mountpoints( Partition & partition )
 {
 	DMRaid dmraid ;	//Use cache of dmraid device information
-	if ( partition.filesystem == FS_LVM2_PV )
+	if (partition.fstype == FS_LVM2_PV)
 	{
 		Glib::ustring vgname = LVM2_PV_Info::get_vg_name( partition.get_path() );
 		if ( ! vgname.empty() )
 			partition.add_mountpoint( vgname );
 	}
-	else if ( partition.filesystem == FS_LINUX_SWRAID )
+	else if (partition.fstype == FS_LINUX_SWRAID)
 	{
 		Glib::ustring array_path = SWRaid_Info::get_array( partition.get_path() );
 		if ( ! array_path.empty() )
 			partition.add_mountpoint( array_path );
 	}
-	else if (partition.filesystem == FS_ATARAID)
+	else if (partition.fstype == FS_ATARAID)
 	{
 		Glib::ustring array_path = SWRaid_Info::get_array(partition.get_path());
 		if (! array_path.empty())
@ -1441,14 +1441,14 @@ void GParted_Core::set_mountpoints( Partition & partition )
 				partition.add_mountpoint(array_path);
 		}
 	}
-	else if ( partition.filesystem == FS_LUKS )
+	else if (partition.fstype == FS_LUKS)
 	{
 		LUKS_Mapping mapping = LUKS_Info::get_cache_entry( partition.get_path() );
 		if ( ! mapping.name.empty() )
 			partition.add_mountpoint( DEV_MAPPER_PATH + mapping.name );
 	}
 	// Swap spaces don't have mount points so don't bother trying to add them.
-	else if ( partition.filesystem != FS_LINUX_SWAP )
+	else if (partition.fstype != FS_LINUX_SWAP)
 	{
 		if ( partition.busy )
 		{
@ -1492,7 +1492,7 @@ void GParted_Core::set_mountpoints( Partition & partition )
 bool GParted_Core::set_mountpoints_helper( Partition & partition, const Glib::ustring & path )
 {
 	Glib::ustring search_path ;
-	if ( partition .filesystem == FS_BTRFS )
+	if (partition.fstype == FS_BTRFS)
 		search_path = btrfs::get_mount_device( path ) ;
 	else
 		search_path = path ;
@ -1553,15 +1553,15 @@ bool GParted_Core::is_busy( FSType fstype, const Glib::ustring & path )
 void GParted_Core::set_used_sectors( Partition & partition, PedDisk* lp_disk )
 {
-	if ( supported_filesystem( partition.filesystem ) )
+	if (supported_filesystem(partition.fstype))
 	{
 		FileSystem* p_filesystem = NULL;
 		if ( partition.busy )
 		{
-			switch( get_fs( partition.filesystem ).online_read )
+			switch(get_fs(partition.fstype).online_read)
 			{
 				case FS::EXTERNAL:
-					p_filesystem = get_filesystem_object( partition.filesystem );
+					p_filesystem = get_filesystem_object(partition.fstype);
 					if ( p_filesystem )
 						p_filesystem->set_used_sectors( partition );
 					break;
@ -1574,10 +1574,10 @@ void GParted_Core::set_used_sectors( Partition & partition, PedDisk* lp_disk )
 		}
 		else  // Not busy file system
 		{
-			switch( get_fs( partition.filesystem ).read )
+			switch(get_fs(partition.fstype).read)
 			{
 				case FS::EXTERNAL:
-					p_filesystem = get_filesystem_object( partition.filesystem );
+					p_filesystem = get_filesystem_object(partition.fstype);
 					if ( p_filesystem )
 						p_filesystem->set_used_sectors( partition );
 					break;
@ -1605,15 +1605,15 @@ void GParted_Core::set_used_sectors( Partition & partition, PedDisk* lp_disk )
 			Glib::ustring temp = _("Unable to read the contents of this file system!");
 			temp += "\n";
 			temp += _("Because of this some operations may be unavailable.");
-			if ( ! Utils::get_filesystem_software( partition.filesystem ).empty() )
+			if (! Utils::get_filesystem_software(partition.fstype).empty())
 			{
 				temp += "\n";
 				temp += _("The cause might be a missing software package.");
 				temp += "\n";
 				/*TO TRANSLATORS: looks like   The following list of software packages is required for NTFS file system support:  ntfsprogs. */
 				temp += Glib::ustring::compose( _("The following list of software packages is required for %1 file system support:  %2."),
-				                          Utils::get_filesystem_string( partition.filesystem ),
+				                               Utils::get_filesystem_string(partition.fstype),
-				                          Utils::get_filesystem_software( partition.filesystem )
+				                               Utils::get_filesystem_software(partition.fstype)
 				                              );
 			}
 			partition.push_back_message( temp );
@ -1623,7 +1623,7 @@ void GParted_Core::set_used_sectors( Partition & partition, PedDisk* lp_disk )
 			/* TO TRANSLATORS: looks like   1.28GiB of unallocated space within the partition. */
 			Glib::ustring temp = Glib::ustring::compose( _("%1 of unallocated space within the partition."),
 			                                       Utils::format_size( unallocated, partition.sector_size ) );
-			FS fs = get_fs( partition.filesystem );
+			FS fs = get_fs(partition.fstype);
 			if ( fs.check != FS::NONE && fs.grow != FS::NONE )
 			{
 				temp += "\n";
@ -1640,7 +1640,7 @@ void GParted_Core::set_used_sectors( Partition & partition, PedDisk* lp_disk )
 		if ( filesystem_resize_disallowed( partition ) )
 		{
-			Glib::ustring temp = get_filesystem_object( partition.filesystem )
+			Glib::ustring temp = get_filesystem_object(partition.fstype)
 			                     ->get_custom_text( CTEXT_RESIZE_DISALLOWED_WARNING );
 			if ( ! temp.empty() )
 				partition.push_back_message( temp );
@ -1719,7 +1719,7 @@ bool GParted_Core::create( Partition & new_partition, OperationDetail & operatio
 	}
 	else
 	{
-		FS_Limits fs_limits = get_filesystem_limits( new_partition.filesystem, new_partition );
+		FS_Limits fs_limits = get_filesystem_limits(new_partition.fstype, new_partition);
 		success = create_partition( new_partition, operationdetail,
 		                            fs_limits.min_size / new_partition.sector_size );
 	}
@ -1733,9 +1733,9 @@ bool GParted_Core::create( Partition & new_partition, OperationDetail & operatio
 	}
 	if (new_partition.type   == TYPE_EXTENDED  ||
-	     new_partition.filesystem == FS_UNFORMATTED    )
+	    new_partition.fstype == FS_UNFORMATTED   )
 		return true;
-	else if ( new_partition.filesystem == FS_CLEARED )
+	else if (new_partition.fstype == FS_CLEARED)
 		return erase_filesystem_signatures( new_partition, operationdetail );
 	else
 		return    erase_filesystem_signatures( new_partition, operationdetail )
@ -1806,7 +1806,7 @@ bool GParted_Core::create_partition( Partition & new_partition, OperationDetail
 			if ( constraint )
 			{
 				if (   min_size > 0
-				    && new_partition .filesystem != FS_XFS // Permit copying to smaller xfs partition
+				    && new_partition.fstype != FS_XFS  // Permit copying to smaller xfs partition
 				   )
 					constraint ->min_size = min_size ;
@ -1856,7 +1856,7 @@ bool GParted_Core::create_partition( Partition & new_partition, OperationDetail
 bool GParted_Core::create_filesystem( const Partition & partition, OperationDetail & operationdetail ) 
 {
-	if ( partition.filesystem == FS_LUKS && partition.busy )
+	if (partition.fstype == FS_LUKS && partition.busy)
 	{
 		operationdetail.add_child( OperationDetail(
 			GPARTED_BUG + ": " + _("partition contains open LUKS encryption for a create file system only step"),
@ -1867,11 +1867,11 @@ bool GParted_Core::create_filesystem( const Partition & partition, OperationDeta
 	operationdetail .add_child( OperationDetail( Glib::ustring::compose(
 							/*TO TRANSLATORS: looks like create new ext3 file system */ 
 							_("create new %1 file system"),
-							Utils::get_filesystem_string( partition .filesystem ) ) ) ) ;
+							Utils::get_filesystem_string(partition.fstype))));
 	bool succes = false ;
 	FileSystem* p_filesystem = NULL ;
-	switch ( get_fs( partition .filesystem ) .create )
+	switch (get_fs(partition.fstype).create)
 	{
 		case FS::NONE:
 			break ;
@ -1880,7 +1880,7 @@ bool GParted_Core::create_filesystem( const Partition & partition, OperationDeta
 		case FS::LIBPARTED:
 			break ;
 		case FS::EXTERNAL:
-			succes = ( p_filesystem = get_filesystem_object( partition .filesystem ) ) &&
+			succes = (p_filesystem = get_filesystem_object(partition.fstype)) &&
 				 p_filesystem ->create( partition, operationdetail .get_last_child() ) ;
 			break ;
@ -1895,7 +1895,7 @@ bool GParted_Core::create_filesystem( const Partition & partition, OperationDeta
 bool GParted_Core::format( const Partition & partition, OperationDetail & operationdetail )
 {
-	if ( partition.filesystem == FS_LUKS && partition.busy )
+	if (partition.fstype == FS_LUKS && partition.busy)
 	{
 		operationdetail.add_child( OperationDetail(
 			GPARTED_BUG + ": " + _("partition contains open LUKS encryption for a format file system only step"),
@ -1903,7 +1903,7 @@ bool GParted_Core::format( const Partition & partition, OperationDetail & operat
 		return false;
 	}
-	if ( partition .filesystem == FS_CLEARED )
+	if (partition.fstype == FS_CLEARED)
 		return    erase_filesystem_signatures(partition, operationdetail)
 		       && set_partition_type(partition, operationdetail);
 	else
@ -1955,7 +1955,7 @@ bool GParted_Core::delete_partition( const Partition & partition, OperationDetai
 bool GParted_Core::remove_filesystem( const Partition & partition, OperationDetail & operationdetail )
 {
-	if ( partition.filesystem == FS_LUKS && partition.busy )
+	if (partition.fstype == FS_LUKS && partition.busy)
 	{
 		operationdetail.add_child( OperationDetail(
 			GPARTED_BUG + ": " + _("partition contains open LUKS encryption for a delete file system only step"),
@ -1966,7 +1966,7 @@ bool GParted_Core::remove_filesystem( const Partition & partition, OperationDeta
 	bool success = true ;
 	FileSystem* p_filesystem = NULL ;
-	switch ( get_fs( partition .filesystem ) .remove )
+	switch (get_fs(partition.fstype ).remove)
 	{
 		case FS::EXTERNAL:
 			//Run file system specific remove method to delete the file system.  Most
@ -1974,8 +1974,8 @@ bool GParted_Core::remove_filesystem( const Partition & partition, OperationDeta
 			//  recovery from accidental partition deletion.
 			operationdetail .add_child( OperationDetail( Glib::ustring::compose(
 								_("delete %1 file system"),
-								Utils::get_filesystem_string( partition .filesystem ) ) ) ) ;
+								Utils::get_filesystem_string(partition.fstype))));
-			success = ( p_filesystem = get_filesystem_object( partition .filesystem ) ) &&
+			success = (p_filesystem = get_filesystem_object(partition.fstype)) &&
 			          p_filesystem ->remove( partition, operationdetail .get_last_child() ) ;
 			operationdetail.get_last_child().set_success_and_capture_errors( success );
 			break ;
@ -1988,7 +1988,7 @@ bool GParted_Core::remove_filesystem( const Partition & partition, OperationDeta
 bool GParted_Core::label_filesystem( const Partition & partition, OperationDetail & operationdetail )
 {
-	if ( partition.filesystem == FS_LUKS && partition.busy )
+	if (partition.fstype == FS_LUKS && partition.busy)
 	{
 		operationdetail.add_child( OperationDetail(
 			GPARTED_BUG + ": " + _("partition contains open LUKS encryption for a label file system only step"),
@ -2007,10 +2007,10 @@ bool GParted_Core::label_filesystem( const Partition & partition, OperationDetai
 	bool succes = false ;
 	FileSystem* p_filesystem = NULL ;
-	switch ( get_fs( partition.filesystem ).write_label )
+	switch (get_fs(partition.fstype).write_label)
 	{
 		case FS::EXTERNAL:
-			succes =    ( p_filesystem = get_filesystem_object( partition.filesystem ) )
+			succes =    (p_filesystem = get_filesystem_object(partition.fstype))
 			         && p_filesystem->write_label( partition, operationdetail.get_last_child() );
 			break;
@ -2051,7 +2051,7 @@ bool GParted_Core::name_partition( const Partition & partition, OperationDetail
 bool GParted_Core::change_filesystem_uuid( const Partition & partition, OperationDetail & operationdetail )
 {
-	if ( partition.filesystem == FS_LUKS && partition.busy )
+	if (partition.fstype == FS_LUKS && partition.busy)
 	{
 		operationdetail.add_child( OperationDetail(
 			GPARTED_BUG + ": " + _("partition contains open LUKS encryption for a change file system UUID only step"),
@ -2073,10 +2073,10 @@ bool GParted_Core::change_filesystem_uuid( const Partition & partition, Operatio
 	bool succes = false ;
 	FileSystem* p_filesystem = NULL ;
-	switch ( get_fs( partition.filesystem ).write_uuid )
+	switch (get_fs(partition.fstype).write_uuid)
 	{
 		case FS::EXTERNAL:
-			succes =    ( p_filesystem = get_filesystem_object( partition.filesystem ) )
+			succes =    (p_filesystem = get_filesystem_object(partition.fstype))
 			         && p_filesystem->write_uuid( partition, operationdetail.get_last_child() );
 			break;
@ -2218,7 +2218,7 @@ bool GParted_Core::move( const Partition & partition_old,
 	if ( ! success )
 		return false;
-	if ( partition_new.filesystem == FS_LINUX_SWAP )
+	if (partition_new.fstype == FS_LINUX_SWAP)
 		// linux-swap is recreated, not moved
 		return recreate_linux_swap_filesystem( partition_new, operationdetail );
@ -2248,7 +2248,7 @@ bool GParted_Core::move_filesystem( const Partition & partition_old,
 	bool succes = false ;
 	FileSystem* p_filesystem = NULL ;
 	Sector total_done = 0;
-	switch ( get_fs( partition_old .filesystem ) .move )
+	switch (get_fs(partition_old.fstype).move)
 	{
 		case FS::NONE:
 			break ;
@ -2283,7 +2283,7 @@ bool GParted_Core::move_filesystem( const Partition & partition_old,
 		case FS::LIBPARTED:
 			break ;
 		case FS::EXTERNAL:
-			succes = ( p_filesystem = get_filesystem_object( partition_new .filesystem ) ) &&
+			succes = (p_filesystem = get_filesystem_object(partition_new.fstype)) &&
 			         p_filesystem ->move( partition_old
 			                            , partition_new
 			                            , operationdetail .get_last_child()
@ -2382,7 +2382,7 @@ bool GParted_Core::resize( const Partition & partition_old,
 		return false ;
 	}
-	if ( partition_new.filesystem == FS_LUKS )
+	if (partition_new.fstype == FS_LUKS)
 		return resize_encryption( partition_old, partition_new, operationdetail );
 	else
 		return resize_plain( partition_old, partition_new, operationdetail );
@ -2392,7 +2392,7 @@ bool GParted_Core::resize_encryption( const Partition & partition_old,
                                      const Partition & partition_new,
                                      OperationDetail & operationdetail )
 {
-	if ( partition_old.filesystem != FS_LUKS )
+	if (partition_old.fstype != FS_LUKS)
 	{
 		operationdetail.add_child( OperationDetail(
 			GPARTED_BUG + ": " + _("partition does not contain LUKS encryption for a resize encryption only step"),
@ -2421,7 +2421,7 @@ bool GParted_Core::resize_encryption( const Partition & partition_old,
 	const Partition & filesystem_ptn_new = partition_new.get_filesystem_partition();
-	if ( filesystem_ptn_new.filesystem == FS_LINUX_SWAP )
+	if (filesystem_ptn_new.fstype == FS_LINUX_SWAP)
 	{
 		// LUKS is resized, but linux-swap is recreated, not resized
 		if ( delta < 0LL )  // shrink
@ -2461,7 +2461,7 @@ bool GParted_Core::resize_plain( const Partition & partition_old,
                                 const Partition & partition_new,
                                 OperationDetail & operationdetail )
 {
-	if ( partition_old.filesystem == FS_LUKS && partition_old.busy )
+	if (partition_old.fstype == FS_LUKS && partition_old.busy)
 	{
 		operationdetail.add_child( OperationDetail(
 			GPARTED_BUG + ": " + _("partition contains open LUKS encryption for a resize file system only step"),
@ -2469,7 +2469,7 @@ bool GParted_Core::resize_plain( const Partition & partition_old,
 		return false;
 	}
-	if ( partition_new.filesystem == FS_LINUX_SWAP )
+	if (partition_new.fstype == FS_LINUX_SWAP)
 	{
 		// linux-swap is recreated, not resized
 		return    resize_move_partition( partition_old, partition_new, operationdetail, true )
@ -2732,7 +2732,7 @@ bool GParted_Core::shrink_encryption( const Partition & partition_old,
                                      const Partition & partition_new,
                                      OperationDetail & operationdetail )
 {
-	if ( ! ( partition_old.filesystem == FS_LUKS && partition_old.busy ) )
+	if (! (partition_old.fstype == FS_LUKS && partition_old.busy))
 	{
 		operationdetail.add_child( OperationDetail(
 			GPARTED_BUG + ": " + _("partition does not contain open LUKS encryption for a shrink encryption only step"),
@ -2748,7 +2748,7 @@ bool GParted_Core::shrink_encryption( const Partition & partition_old,
 bool GParted_Core::maximize_encryption( const Partition & partition, OperationDetail & operationdetail )
 {
-	if ( partition.filesystem != FS_LUKS )
+	if (partition.fstype != FS_LUKS)
 	{
 		operationdetail.add_child( OperationDetail(
 			GPARTED_BUG + ": " + _("partition does not contain LUKS encryption for a maximize encryption only step"),
@ -2763,7 +2763,7 @@ bool GParted_Core::maximize_encryption( const Partition & partition, OperationDe
 	// operation these growing checks are merely retesting those performed to allow
 	// the operation to be queued in the first place.  See
 	// Win_GParted::set_valid_operations().
-	if ( get_fs( partition.filesystem ).grow == FS::NONE )
+	if (get_fs(partition.fstype).grow == FS::NONE)
 	{
 		operationdetail.get_last_child().add_child( OperationDetail(
 				_("growing is not available for this encryption volume"),
@ -2781,7 +2781,7 @@ bool GParted_Core::shrink_filesystem( const Partition & partition_old,
                                      const Partition & partition_new,
                                      OperationDetail & operationdetail )
 {
-	if ( partition_old.filesystem == FS_LUKS && partition_old.busy )
+	if (partition_old.fstype == FS_LUKS && partition_old.busy)
 	{
 		operationdetail.add_child( OperationDetail(
 			GPARTED_BUG + ": " + _("partition contains open LUKS encryption for a shrink file system only step"),
@ -2809,7 +2809,7 @@ bool GParted_Core::shrink_filesystem( const Partition & partition_old,
 bool GParted_Core::maximize_filesystem( const Partition & partition, OperationDetail & operationdetail ) 
 {
-	if ( partition.filesystem == FS_LUKS && partition.busy )
+	if (partition.fstype == FS_LUKS && partition.busy)
 	{
 		operationdetail.add_child( OperationDetail(
 			GPARTED_BUG + ": " + _("partition contains open LUKS encryption for a maximize file system only step"),
@ -2825,7 +2825,7 @@ bool GParted_Core::maximize_filesystem( const Partition & partition, OperationDe
 	// to allow the operation to be queued in the first place.  See
 	// Win_GParted::set_valid_operations() and
 	// Dialog_Partition_Resize_Move::Resize_Move_Normal().
-	if (get_fs(partition.filesystem).grow == FS::NONE)
+	if (get_fs(partition.fstype).grow == FS::NONE)
 	{
 		operationdetail .get_last_child() .add_child( 
 			OperationDetail( _("growing is not available for this file system"),
@ -2837,7 +2837,7 @@ bool GParted_Core::maximize_filesystem( const Partition & partition, OperationDe
 	else if ( filesystem_resize_disallowed( partition ) )
 	{
 		Glib::ustring msg        = _("growing the file system is currently disallowed") ;
-		Glib::ustring custom_msg = get_filesystem_object( partition .filesystem )
+		Glib::ustring custom_msg = get_filesystem_object(partition.fstype)
 		                           ->get_custom_text( CTEXT_RESIZE_DISALLOWED_WARNING ) ;
 		if ( ! custom_msg .empty() )
 		{
@ -2856,7 +2856,7 @@ bool GParted_Core::maximize_filesystem( const Partition & partition, OperationDe
 bool GParted_Core::recreate_linux_swap_filesystem( const Partition & partition, OperationDetail & operationdetail )
 {
-	if ( partition.filesystem != FS_LINUX_SWAP )
+	if (partition.fstype != FS_LINUX_SWAP)
 	{
 		operationdetail.add_child( OperationDetail(
 			/* TO TRANSLATORS: looks like   not a linux-swap file system for a recreate linux-swap only step */
@ -2887,7 +2887,7 @@ bool GParted_Core::resize_filesystem_implement( const Partition & partition_old,
 {
 	bool fill_partition = false;
-	const FS & fs_cap = get_fs( partition_new.filesystem );
+	const FS& fs_cap = get_fs(partition_new.fstype);
 	FS::Support action = FS::NONE;
 	if ( partition_new.get_sector_length() >= partition_old.get_sector_length() )
 	{
@ -2917,7 +2917,7 @@ bool GParted_Core::resize_filesystem_implement( const Partition & partition_old,
 			break;
 #endif
 		case FS::EXTERNAL:
-			success = ( p_filesystem = get_filesystem_object( partition_new.filesystem ) ) &&
+			success = (p_filesystem = get_filesystem_object(partition_new.fstype)) &&
 			          p_filesystem->resize( partition_new,
 			                                operationdetail.get_last_child(),
 			                                fill_partition );
@ -2937,7 +2937,7 @@ bool GParted_Core::copy( const Partition & partition_src,
 	Partition & filesystem_ptn_dst = partition_dst.get_filesystem_partition();
 	if (   filesystem_ptn_dst.get_byte_length() < filesystem_ptn_src.get_byte_length()
-	    && filesystem_ptn_src.filesystem != FS_XFS  // Permit copying to smaller xfs partition
+	    && filesystem_ptn_src.fstype != FS_XFS  // Permit copying to smaller xfs partition
 	   )
 	{
 		operationdetail .add_child( OperationDetail( 
@ -2971,7 +2971,7 @@ bool GParted_Core::copy( const Partition & partition_src,
 	if ( ! success )
 		return false;
-	if ( filesystem_ptn_dst.filesystem == FS_LINUX_SWAP )
+	if (filesystem_ptn_dst.fstype == FS_LINUX_SWAP)
 	{
 		// linux-swap is recreated, not copied
 		return recreate_linux_swap_filesystem( filesystem_ptn_dst, operationdetail );
@ -2989,14 +2989,14 @@ bool GParted_Core::copy_filesystem( const Partition & partition_src,
                                    Partition & partition_dst,
                                    OperationDetail & operationdetail )
 {
-	if ( partition_src.filesystem == FS_LUKS && partition_src.busy )
+	if (partition_src.fstype == FS_LUKS && partition_src.busy)
 	{
 		operationdetail.add_child( OperationDetail(
 			GPARTED_BUG + ": " + _("source partition contains open LUKS encryption for a file system copy only step"),
 			STATUS_ERROR, FONT_ITALIC ) );
 		return false;
 	}
-	if ( partition_dst.filesystem == FS_LUKS && partition_dst.busy )
+	if (partition_dst.fstype == FS_LUKS && partition_dst.busy)
 	{
 		operationdetail.add_child( OperationDetail(
 			GPARTED_BUG + ": " + _("destination partition contains open LUKS encryption for a file system copy only step"),
@ -3011,7 +3011,7 @@ bool GParted_Core::copy_filesystem( const Partition & partition_src,
 	bool success = false;
 	FileSystem* p_filesystem = NULL;
-	switch ( get_fs( partition_dst.filesystem ).copy )
+	switch (get_fs(partition_dst.fstype).copy)
 	{
 		case FS::GPARTED:
 			success = copy_filesystem_internal( partition_src,
@ -3025,7 +3025,7 @@ bool GParted_Core::copy_filesystem( const Partition & partition_src,
 			break;
 		case FS::EXTERNAL:
-			success = ( p_filesystem = get_filesystem_object( partition_dst.filesystem ) ) &&
+			success = (p_filesystem = get_filesystem_object(partition_dst.fstype)) &&
 			          p_filesystem->copy( partition_src,
 			                              partition_dst,
 			                              operationdetail.get_last_child() );
@ -3245,7 +3245,7 @@ void GParted_Core::rollback_move_filesystem( const Partition & partition_src,
 bool GParted_Core::check_repair_filesystem( const Partition & partition, OperationDetail & operationdetail ) 
 {
-	if ( partition.filesystem == FS_LUKS && partition.busy )
+	if (partition.fstype == FS_LUKS && partition.busy)
 	{
 		operationdetail.add_child( OperationDetail(
 			GPARTED_BUG + ": " + _("partition contains open LUKS encryption for a check file system only step"),
@ -3265,7 +3265,7 @@ bool GParted_Core::check_repair_filesystem( const Partition & partition, Operati
 	bool succes = false ;
 	FileSystem* p_filesystem = NULL ;
-	switch ( get_fs( partition .filesystem ) .check )
+	switch (get_fs(partition.fstype).check)
 	{
 		case FS::NONE:
 			operationdetail .get_last_child() .add_child(
@ -3281,7 +3281,7 @@ bool GParted_Core::check_repair_filesystem( const Partition & partition, Operati
 		case FS::LIBPARTED:
 			break ;
 		case FS::EXTERNAL:
-			succes = ( p_filesystem = get_filesystem_object( partition .filesystem ) ) &&
+			succes = (p_filesystem = get_filesystem_object(partition.fstype)) &&
 				 p_filesystem ->check_repair( partition, operationdetail .get_last_child() ) ;
 			break ;
@ -3297,7 +3297,7 @@ bool GParted_Core::check_repair_filesystem( const Partition & partition, Operati
 bool GParted_Core::check_repair_maximize( const Partition & partition,
                                          OperationDetail & operationdetail )
 {
-	if ( partition.filesystem == FS_LUKS )
+	if (partition.fstype == FS_LUKS)
 	{
 		// Pretend that the LUKS partition is closed so that
 		// resize_filesystem_implement() checks the offline .grow capability
@ -3347,20 +3347,20 @@ bool GParted_Core::set_partition_type( const Partition & partition, OperationDet
 		PedPartition* lp_partition = ped_disk_get_partition_by_sector( lp_disk, partition.get_sector() );
 		if ( lp_partition )
 		{
-			Glib::ustring fs_type = Utils::get_filesystem_string( partition.filesystem );
+			Glib::ustring fs_type = Utils::get_filesystem_string(partition.fstype);
 			// Lookup libparted file system type using GParted's name, as most
 			// match.  Exclude cleared as the name won't be recognised by
 			// libparted and get_filesystem_string() has also translated it.
 			PedFileSystemType *lp_fs_type = NULL;
-			if (partition.filesystem != FS_CLEARED)
+			if (partition.fstype != FS_CLEARED)
 				lp_fs_type = ped_file_system_type_get(fs_type.c_str());
 			// If not found, and FS is udf, then try ntfs.
 			// Actually MBR 07 IFS (Microsoft Installable File System) or
 			// GPT BDP (Windows Basic Data Partition).
 			// Ref: https://serverfault.com/a/829172
-			if (! lp_fs_type && partition.filesystem == FS_UDF)
+			if (! lp_fs_type && partition.fstype == FS_UDF)
 				lp_fs_type = ped_file_system_type_get( "ntfs" );
 			// default is Linux (83)
@ -3369,7 +3369,7 @@ bool GParted_Core::set_partition_type( const Partition & partition, OperationDet
 			bool supports_lvm_flag = ped_partition_is_flag_available( lp_partition, PED_PARTITION_LVM );
-			if ( lp_fs_type && partition.filesystem != FS_LVM2_PV )
+			if (lp_fs_type && partition.fstype != FS_LVM2_PV)
 			{
 				// Also clear any libparted LVM flag so that it doesn't
 				// override the file system type
@ -3387,7 +3387,7 @@ bool GParted_Core::set_partition_type( const Partition & partition, OperationDet
 					return_value = true;
 				}
 			}
-			else if ( partition.filesystem == FS_LVM2_PV )
+			else if (partition.fstype == FS_LVM2_PV)
 			{
 				if ( supports_lvm_flag                                            &&
 				     ped_partition_set_flag( lp_partition, PED_PARTITION_LVM, 1 ) &&
@ -3499,7 +3499,7 @@ bool GParted_Core::calibrate_partition( Partition & partition, OperationDetail &
 					STATUS_NONE, 
 					FONT_ITALIC ) ) ;
-				if ( partition.filesystem == FS_LUKS && partition.busy )
+				if (partition.fstype == FS_LUKS && partition.busy)
 				{
 					const Partition & encrypted = dynamic_cast<const PartitionLUKS *>( &partition )->get_encrypted();
 					operationdetail.get_last_child().add_child( OperationDetail(
@ -3635,7 +3635,7 @@ FS_Limits GParted_Core::get_filesystem_limits( FSType fstype, const Partition &
 bool GParted_Core::filesystem_resize_disallowed( const Partition & partition )
 {
-	if ( partition .filesystem == FS_LVM2_PV )
+	if (partition.fstype == FS_LVM2_PV)
 	{
 		//The LVM2 PV can't be resized when it's a member of an export VG
 		Glib::ustring vgname = LVM2_PV_Info::get_vg_name( partition.get_path() );
@ -3648,7 +3648,7 @@ bool GParted_Core::filesystem_resize_disallowed( const Partition & partition )
 bool GParted_Core::erase_filesystem_signatures( const Partition & partition, OperationDetail & operationdetail )
 {
-	if ( partition.filesystem == FS_LUKS && partition.busy )
+	if (partition.fstype == FS_LUKS && partition.busy)
 	{
 		operationdetail.add_child( OperationDetail(
 			GPARTED_BUG + ": " + _("partition contains open LUKS encryption for an erase file system signatures only step"),
@ -3886,7 +3886,7 @@ bool GParted_Core::update_bootsector( const Partition & partition, OperationDeta
 {
 	//only for ntfs atm...
 	//FIXME: this should probably be done in the fs classes...
-	if ( partition .filesystem == FS_NTFS )
+	if (partition.fstype == FS_NTFS)
 	{
 		//The NTFS file system stores a value in the boot record called the
 		//  Number of Hidden Sectors.  This value must match the partition start
@ -3897,7 +3897,7 @@ bool GParted_Core::update_bootsector( const Partition & partition, OperationDeta
 		operationdetail .add_child( OperationDetail( 
 				/*TO TRANSLATORS: update boot sector of ntfs file system on /dev/sdd1 */
 				Glib::ustring::compose( _("update boot sector of %1 file system on %2"),
-					  Utils::get_filesystem_string( partition .filesystem ),
+					  Utils::get_filesystem_string(partition.fstype),
 					  partition .get_path() ) ) ) ;
 		//convert start sector to hex string
--- a/src/OperationFormat.cc
+++ b/src/OperationFormat.cc
@ -45,7 +45,7 @@ void OperationFormat::apply_to_visual( PartitionVector & partitions )
 	g_assert( partition_original != NULL );  // Bug: Not initialised by constructor or reset later
 	g_assert( partition_new != NULL );  // Bug: Not initialised by constructor or reset later
-	if ( partition_original->type == TYPE_UNPARTITIONED && partition_new->filesystem == FS_CLEARED )
+	if (partition_original->type == TYPE_UNPARTITIONED && partition_new->fstype == FS_CLEARED)
 	{
 		// Make format to cleared whole disk device file system preview as
 		// unallocated device, matching what happens when implemented.
--- a/src/Partition.cc
+++ b/src/Partition.cc
@ -41,7 +41,7 @@ void Partition::Reset()
 	status = STAT_REAL;
 	type = TYPE_UNALLOCATED;
 	alignment = ALIGN_STRICT ;
-	filesystem = FS_UNALLOCATED;
+	fstype = FS_UNALLOCATED;
 	have_filesystem_label = false;
 	uuid .clear() ;
 	name.clear();
@ -62,7 +62,7 @@ void Partition::Set( const Glib::ustring & device_path,
                     const Glib::ustring & partition,
                     int partition_number,
                     PartitionType type,
-                     FSType filesystem,
+                     FSType fstype,
                     Sector sector_start,
                     Sector sector_end,
                     Byte_Value sector_size,
@ -73,7 +73,7 @@ void Partition::Set( const Glib::ustring & device_path,
 	this->path = partition;
 	this ->partition_number = partition_number;
 	this ->type = type;
-	this ->filesystem = filesystem;
+	this->fstype = fstype;
 	this ->sector_start = sector_start;
 	this ->sector_end = sector_end;
 	this ->sector_size = sector_size;
--- a/src/PartitionLUKS.cc
+++ b/src/PartitionLUKS.cc
@ -49,7 +49,7 @@ Partition * PartitionLUKS::clone_as_plain() const
 	Partition * plain_ptn = new Partition( *this );
 	// Copy over file system attributes.
-	plain_ptn->filesystem    = this->encrypted.filesystem;
+	plain_ptn->fstype        = this->encrypted.fstype;
 	plain_ptn->uuid          = this->encrypted.uuid;
 	plain_ptn->busy          = this->encrypted.busy;
 	plain_ptn->fs_block_size = this->encrypted.fs_block_size;
@ -247,7 +247,7 @@ Partition & PartitionLUKS::get_filesystem_partition()
 const Glib::ustring PartitionLUKS::get_filesystem_string() const
 {
 	if ( busy )
-		return Utils::get_filesystem_string( true, encrypted.filesystem );
+		return Utils::get_filesystem_string(true, encrypted.fstype);
 	return Utils::get_encrypted_string();
 }
--- a/src/TreeView_Detail.cc
+++ b/src/TreeView_Detail.cc
@ -187,7 +187,7 @@ void TreeView_Detail::create_row( const Gtk::TreeRow & treerow,
 		show_names = true;
 	// file system
-	treerow[treeview_detail_columns.color] = Utils::get_color_as_pixbuf( filesystem_ptn.filesystem, 16, 16 );
+	treerow[treeview_detail_columns.color] = Utils::get_color_as_pixbuf(filesystem_ptn.fstype, 16, 16);
 	treerow[treeview_detail_columns.filesystem] = partition.get_filesystem_string();
 	// mount point
--- a/src/Win_GParted.cc
+++ b/src/Win_GParted.cc
@ -1057,7 +1057,7 @@ void Win_GParted::Refresh_Visual()
 			copied_partition = display_partitions[t].clone();
 		}
-		if ( display_partitions[t].filesystem == FS_UNALLOCATED )
+		if (display_partitions[t].fstype == FS_UNALLOCATED)
 		{
 			current_size = display_partitions[t].get_sector_length();
 			if ( current_size > largest_unalloc_size )
@ -1078,7 +1078,7 @@ void Win_GParted::Refresh_Visual()
 					copied_partition = display_partitions[t].logicals[u].clone();
 				}
-				if ( display_partitions[t].logicals[u].filesystem == FS_UNALLOCATED )
+				if (display_partitions[t].logicals[u].fstype == FS_UNALLOCATED)
 				{
 					current_size = display_partitions[t].logicals[u].get_sector_length();
 					if ( current_size > largest_unalloc_size )
@ -1195,14 +1195,14 @@ void Win_GParted::set_valid_operations()
 	const Partition & selected_filesystem = selected_partition_ptr->get_filesystem_partition();
 	// Get file system and LUKS encryption capabilities
-	const FS & fs_cap = gparted_core.get_fs( selected_filesystem.filesystem );
+	const FS& fs_cap = gparted_core.get_fs(selected_filesystem.fstype);
 	const FS & enc_cap = gparted_core.get_fs( FS_LUKS );
 	//if there's something, there's some info ;)
 	allow_info( true ) ;
 	// Set appropriate name for the open/close crypt menu item.
-	if ( selected_partition_ptr->filesystem == FS_LUKS )
+	if (selected_partition_ptr->fstype == FS_LUKS)
 	{
 		dynamic_cast<Gtk::Label *>(partitionmenu_items[MENU_TOGGLE_CRYPT_BUSY]->get_child())
 			->set_label( luks_filesystem_object->get_custom_text(   selected_partition_ptr->busy
@ -1210,9 +1210,9 @@ void Win_GParted::set_valid_operations()
 			                                                      : CTEXT_ACTIVATE_FILESYSTEM ) );
 	}
 	// Set appropriate name for the file system active/deactivate menu item.
-	if ( selected_partition_ptr->filesystem != FS_LUKS || selected_partition_ptr->busy )
+	if (selected_partition_ptr->fstype != FS_LUKS || selected_partition_ptr->busy)
 	{
-		const FileSystem * filesystem_object = gparted_core.get_filesystem_object( selected_filesystem.filesystem );
+		const FileSystem *filesystem_object = gparted_core.get_filesystem_object(selected_filesystem.fstype);
 		if ( filesystem_object )
 		{
 			dynamic_cast<Gtk::Label *>(partitionmenu_items[MENU_TOGGLE_FS_BUSY]->get_child())
@ -1231,20 +1231,20 @@ void Win_GParted::set_valid_operations()
 	// Only permit encryption open/close when available
 	if (selected_partition_ptr->status == STAT_REAL &&
-	     selected_partition_ptr->filesystem == FS_LUKS   &&
+	    selected_partition_ptr->fstype == FS_LUKS   &&
 	    ! selected_filesystem.busy                    )
 		allow_toggle_crypt_busy_state( true );
 	// Only permit file system mount/unmount and swapon/swapoff when available
 	if (    selected_partition_ptr->status == STAT_REAL
 	     && selected_partition_ptr->type   != TYPE_EXTENDED
-	     && selected_filesystem.filesystem != FS_LVM2_PV
+	     && selected_filesystem.fstype     != FS_LVM2_PV
-	     && selected_filesystem.filesystem != FS_LINUX_SWRAID
+	     && selected_filesystem.fstype     != FS_LINUX_SWRAID
-	     && selected_filesystem.filesystem != FS_ATARAID
+	     && selected_filesystem.fstype     != FS_ATARAID
-	     && selected_filesystem.filesystem != FS_LUKS
+	     && selected_filesystem.fstype     != FS_LUKS
 	     && (    selected_filesystem.busy
 	          || selected_filesystem.get_mountpoints().size() /* Have mount point(s) */
-	          || selected_filesystem.filesystem == FS_LINUX_SWAP
+	          || selected_filesystem.fstype == FS_LINUX_SWAP
 	        )
 	   )
 		allow_toggle_fs_busy_state( true );
@ -1254,7 +1254,7 @@ void Win_GParted::set_valid_operations()
 	// with "Volume group "VGNAME" is exported", otherwise user won't know why the
 	// inactive PV can't be activated.
 	if (    selected_partition_ptr->status == STAT_REAL
-	     && selected_filesystem.filesystem == FS_LVM2_PV      // Active VGNAME from mount point
+	     && selected_filesystem.fstype     == FS_LVM2_PV      // Active VGNAME from mount point
 	     && ( selected_filesystem.busy || selected_filesystem.get_mountpoints().size() > 0 )
 	   )
 		allow_toggle_fs_busy_state( true );
@ -1280,12 +1280,12 @@ void Win_GParted::set_valid_operations()
 	     selected_filesystem.busy              )
 	{
 		// Can the plain file system be online resized?
-		if ( selected_partition_ptr->filesystem != FS_LUKS  &&
+		if (selected_partition_ptr->fstype != FS_LUKS    &&
 		    (fs_cap.online_grow || fs_cap.online_shrink)   )
 			allow_resize( true );
 		// Is resizing an open LUKS mapping and the online file system within
 		// supported?
-		if ( selected_partition_ptr->filesystem == FS_LUKS            &&
+		if ( selected_partition_ptr->fstype == FS_LUKS                &&
 		     selected_partition_ptr->busy                             &&
 		     ( ( enc_cap.online_grow && fs_cap.online_grow )     ||
 		       ( enc_cap.online_shrink && fs_cap.online_shrink )    )    )
@ -1301,7 +1301,7 @@ void Win_GParted::set_valid_operations()
 		return ;
 	// UNALLOCATED space within a partition table or UNALLOCATED whole disk device
-	if ( selected_partition_ptr->filesystem == FS_UNALLOCATED )
+	if (selected_partition_ptr->fstype == FS_UNALLOCATED)
 		allow_new( true );
 	// UNALLOCATED space within a partition table
@ -1314,11 +1314,11 @@ void Win_GParted::set_valid_operations()
 		// implemented.
 		if ( copied_partition             != NULL    &&
 		     ! devices[current_device].readonly      &&
-		     copied_partition->filesystem != FS_LUKS    )
+		     copied_partition->fstype     != FS_LUKS    )
 		{
 			const Partition & copied_filesystem_ptn = copied_partition->get_filesystem_partition();
 			Byte_Value required_size ;
-			if ( copied_filesystem_ptn.filesystem == FS_XFS )
+			if (copied_filesystem_ptn.fstype == FS_XFS)
 				required_size = copied_filesystem_ptn.estimated_min_size() *
 				                copied_filesystem_ptn.sector_size;
 			else
@ -1386,7 +1386,7 @@ void Win_GParted::set_valid_operations()
 	if ( ( selected_partition_ptr->type == TYPE_PRIMARY       ||
 	       selected_partition_ptr->type == TYPE_LOGICAL       ||
 	       selected_partition_ptr->type == TYPE_UNPARTITIONED    ) &&
-	     selected_partition_ptr->filesystem != FS_UNALLOCATED         )
+	     selected_partition_ptr->fstype != FS_UNALLOCATED             )
 	{
 		allow_format( true ) ;
@ -1402,17 +1402,17 @@ void Win_GParted::set_valid_operations()
 		if ( ! devices[current_device].readonly )
 		{
 			// Can the plain file system be resized or moved?
-			if ( selected_partition_ptr->filesystem != FS_LUKS   &&
+			if (selected_partition_ptr->fstype != FS_LUKS     &&
 			    (fs_cap.grow || fs_cap.shrink || fs_cap.move)   )
 				allow_resize( true );
 			// Is growing or moving this closed LUKS mapping permitted?
-			if ( selected_partition_ptr->filesystem == FS_LUKS &&
+			if (selected_partition_ptr->fstype == FS_LUKS &&
 			    ! selected_partition_ptr->busy            &&
 			    (enc_cap.grow || enc_cap.move)              )
 				allow_resize( true );
 			// Is resizing an open LUKS mapping and the file system within
 			// supported?
-			if ( selected_partition_ptr->filesystem == FS_LUKS     &&
+			if ( selected_partition_ptr->fstype == FS_LUKS         &&
 			     selected_partition_ptr->busy                      &&
 	                     ( ( enc_cap.online_grow && fs_cap.grow )     ||
 			       ( enc_cap.online_shrink && fs_cap.shrink )    )    )
@ -1422,7 +1422,7 @@ void Win_GParted::set_valid_operations()
 		// Only allow copying of real partitions, excluding closed encryption
 		// (which are only copied while open).
 		if (selected_partition_ptr->status == STAT_REAL &&
-		     selected_filesystem.filesystem != FS_LUKS   &&
+		    selected_filesystem.fstype     != FS_LUKS   &&
 		    fs_cap.copy                                   )
 			allow_copy( true ) ;
@ -1436,8 +1436,8 @@ void Win_GParted::set_valid_operations()
 		// Generate Mount on submenu, except for LVM2 PVs borrowing mount point to
 		// display the VGNAME and read-only supported LUKS.
-		if ( selected_filesystem.filesystem != FS_LVM2_PV &&
+		if (selected_filesystem.fstype != FS_LVM2_PV     &&
-		     selected_filesystem.filesystem != FS_LUKS    &&
+		    selected_filesystem.fstype != FS_LUKS        &&
 		    selected_filesystem.get_mountpoints().size()   )
 		{
 			partitionmenu_items[MENU_MOUNT]->unset_submenu();
@ -1987,11 +1987,11 @@ void Win_GParted::activate_resize()
 	}
 	Partition * working_ptn;
-	const FSType fstype = selected_filesystem_ptn.filesystem;
+	const FSType fstype = selected_filesystem_ptn.fstype;
 	FS fs_cap = gparted_core.get_fs( fstype );
 	FS_Limits fs_limits = gparted_core.get_filesystem_limits( fstype, selected_filesystem_ptn );
-	if ( selected_partition_ptr->filesystem == FS_LUKS && selected_partition_ptr->busy )
+	if (selected_partition_ptr->fstype == FS_LUKS && selected_partition_ptr->busy)
 	{
 		const FS & enc_cap = gparted_core.get_fs( FS_LUKS );
@ -2123,7 +2123,7 @@ void Win_GParted::activate_paste()
 	// Unrecognised whole disk device (See GParted_Core::set_device_from_disk(), "unrecognized")
 	if (selected_partition_ptr->type   == TYPE_UNPARTITIONED &&
-	     selected_partition_ptr->filesystem == FS_UNALLOCATED        )
+	    selected_partition_ptr->fstype == FS_UNALLOCATED       )
 	{
 		show_disklabel_unrecognized( devices [current_device ] .get_path() ) ;
 		return ;
@ -2136,7 +2136,7 @@ void Win_GParted::activate_paste()
 		if ( ! max_amount_prim_reached() )
 		{
 			FS_Limits fs_limits = gparted_core.get_filesystem_limits(
-			                                      copied_filesystem_ptn.filesystem,
+			                                      copied_filesystem_ptn.fstype,
 			                                      copied_filesystem_ptn );
 			// We don't want the messages, mount points or name of the source
@ -2147,7 +2147,7 @@ void Win_GParted::activate_paste()
 			part_temp->name.clear();
 			Dialog_Partition_Copy dialog(devices[current_device],
-			                             gparted_core.get_fs(copied_filesystem_ptn.filesystem),
+			                             gparted_core.get_fs(copied_filesystem_ptn.fstype),
 			                             fs_limits,
 			                             *selected_partition_ptr,
 			                             *part_temp);
@ -2183,7 +2183,7 @@ void Win_GParted::activate_paste()
 		bool shown_dialog = false ;
 		// VGNAME from mount mount
-		if ( selected_filesystem_ptn.filesystem == FS_LVM2_PV   &&
+		if (selected_filesystem_ptn.fstype == FS_LVM2_PV       &&
 		    ! selected_filesystem_ptn.get_mountpoint().empty()   )
 		{
 			if ( ! remove_non_empty_lvm2_pv_dialog( OPERATION_COPY ) )
@ -2192,7 +2192,7 @@ void Win_GParted::activate_paste()
 		}
 		Partition * partition_new;
-		if ( selected_partition_ptr->filesystem == FS_LUKS && ! selected_partition_ptr->busy )
+		if (selected_partition_ptr->fstype == FS_LUKS && ! selected_partition_ptr->busy)
 		{
 			// Pasting into a closed LUKS encrypted partition will overwrite
 			// the encryption replacing it with a non-encrypted file system.
@ -2221,7 +2221,7 @@ void Win_GParted::activate_paste()
 			// Sub-block so that filesystem_ptn_new reference goes out of
 			// scope before partition_new pointer is deallocated.
 			Partition & filesystem_ptn_new = partition_new->get_filesystem_partition();
-			filesystem_ptn_new.filesystem = copied_filesystem_ptn.filesystem;
+			filesystem_ptn_new.fstype = copied_filesystem_ptn.fstype;
 			filesystem_ptn_new.set_filesystem_label( copied_filesystem_ptn.get_filesystem_label() );
 			filesystem_ptn_new.uuid = copied_filesystem_ptn.uuid;
 			Sector new_size = filesystem_ptn_new.get_sector_length();
@ -2295,7 +2295,7 @@ void Win_GParted::activate_new()
 	// Unrecognised whole disk device (See GParted_Core::set_device_from_disk(), "unrecognized")
 	if (selected_partition_ptr->type   == TYPE_UNPARTITIONED &&
-	     selected_partition_ptr->filesystem == FS_UNALLOCATED        )
+	    selected_partition_ptr->fstype == FS_UNALLOCATED       )
 	{
 		show_disklabel_unrecognized( devices [current_device ] .get_path() ) ;
 	}
@ -2335,7 +2335,7 @@ void Win_GParted::activate_delete()
 	g_assert( valid_display_partition_ptr( selected_partition_ptr ) );  // Bug: Not pointing at a valid display partition object
 	// VGNAME from mount mount
-	if ( selected_partition_ptr->filesystem == FS_LVM2_PV && ! selected_partition_ptr->get_mountpoint().empty() )
+	if (selected_partition_ptr->fstype == FS_LVM2_PV && ! selected_partition_ptr->get_mountpoint().empty())
 	{
 		if ( ! remove_non_empty_lvm2_pv_dialog( OPERATION_DELETE ) )
 			return ;
@ -2383,7 +2383,7 @@ void Win_GParted::activate_delete()
 		/*TO TRANSLATORS: dialogtitle, looks like   Delete /dev/hda2 (ntfs, 2345 MiB) */
 		dialog.set_title( Glib::ustring::compose( _("Delete %1 (%2, %3)"),
 		                                    selected_partition_ptr->get_path(),
-		                                    Utils::get_filesystem_string( selected_partition_ptr->filesystem ),
+		                                    Utils::get_filesystem_string(selected_partition_ptr->fstype),
 		                                    Utils::format_size( selected_partition_ptr->get_sector_length(), selected_partition_ptr->sector_size ) ) );
 		dialog .add_button( Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL );
 		dialog .add_button( Gtk::Stock::DELETE, Gtk::RESPONSE_OK );
@ -2460,7 +2460,7 @@ void Win_GParted::activate_format( FSType new_fs )
 	const Partition & filesystem_ptn = selected_partition_ptr->get_filesystem_partition();
 	// For non-empty LVM2 PV confirm overwrite before continuing.  VGNAME from mount mount.
-	if ( filesystem_ptn.filesystem == FS_LVM2_PV && ! filesystem_ptn.get_mountpoint().empty() )
+	if (filesystem_ptn.fstype == FS_LVM2_PV && ! filesystem_ptn.get_mountpoint().empty())
 	{
 		if ( ! remove_non_empty_lvm2_pv_dialog( OPERATION_FORMAT ) )
 			return ;
@ -2468,7 +2468,7 @@ void Win_GParted::activate_format( FSType new_fs )
 	// Compose Partition object to represent the format operation.
 	Partition * temp_ptn;
-	if ( selected_partition_ptr->filesystem == FS_LUKS && ! selected_partition_ptr->busy )
+	if (selected_partition_ptr->fstype == FS_LUKS && ! selected_partition_ptr->busy)
 	{
 		// Formatting a closed LUKS encrypted partition will erase the encryption
 		// replacing it with a non-encrypted file system.  Start with a plain
@ -2515,7 +2515,7 @@ void Win_GParted::activate_format( FSType new_fs )
 	// Generate minimum and maximum partition size limits for the new file system.
 	FS_Limits fs_limits = gparted_core.get_filesystem_limits( new_fs, temp_ptn->get_filesystem_partition() );
 	bool encrypted = false;
-	if ( selected_partition_ptr->filesystem == FS_LUKS && selected_partition_ptr->busy )
+	if (selected_partition_ptr->fstype == FS_LUKS && selected_partition_ptr->busy)
 	{
 		encrypted = true;
 		// Calculate the actual overhead rather than just using the size of the
@ -2847,21 +2847,21 @@ void Win_GParted::toggle_fs_busy_state()
 	Glib::ustring pulse_msg;
 	Glib::ustring failure_msg;
 	const Partition & filesystem_ptn = selected_partition_ptr->get_filesystem_partition();
-	if ( filesystem_ptn.filesystem == FS_LINUX_SWAP && filesystem_ptn.busy )
+	if (filesystem_ptn.fstype == FS_LINUX_SWAP && filesystem_ptn.busy)
 	{
 		action = SWAPOFF;
 		disallowed_msg = _("The swapoff action cannot be performed when there are operations pending for the partition.");
 		pulse_msg = Glib::ustring::compose( _("Deactivating swap on %1"), filesystem_ptn.get_path() );
 		failure_msg = _("Could not deactivate swap");
 	}
-	else if ( filesystem_ptn.filesystem == FS_LINUX_SWAP && ! filesystem_ptn.busy )
+	else if (filesystem_ptn.fstype == FS_LINUX_SWAP && ! filesystem_ptn.busy)
 	{
 		action = SWAPON;
 		disallowed_msg = _("The swapon action cannot be performed when there are operations pending for the partition.");
 		pulse_msg = Glib::ustring::compose( _("Activating swap on %1"), filesystem_ptn.get_path() );
 		failure_msg = _("Could not activate swap");
 	}
-	else if ( filesystem_ptn.filesystem == FS_LVM2_PV && filesystem_ptn.busy )
+	else if (filesystem_ptn.fstype == FS_LVM2_PV && filesystem_ptn.busy)
 	{
 		action = DEACTIVATE_VG;
 		disallowed_msg = _("The deactivate Volume Group action cannot be performed when there are operations pending for the partition.");
@ -2869,7 +2869,7 @@ void Win_GParted::toggle_fs_busy_state()
 		                              filesystem_ptn.get_mountpoint() );  // VGNAME from point point
 		failure_msg = _("Could not deactivate Volume Group");
 	}
-	else if ( filesystem_ptn.filesystem == FS_LVM2_PV && ! filesystem_ptn.busy )
+	else if (filesystem_ptn.fstype == FS_LVM2_PV && ! filesystem_ptn.busy)
 	{
 		action = ACTIVATE_VG;
 		disallowed_msg = _("The activate Volume Group action cannot be performed when there are operations pending for the partition.");
@ -2971,7 +2971,7 @@ void Win_GParted::activate_mount_partition( unsigned int index )
 	{
 		error_msg = "<i># " + cmd + "\n" + error + "</i>";
-		Glib::ustring type = Utils::get_filesystem_kernel_name( filesystem_ptn.filesystem );
+		Glib::ustring type = Utils::get_filesystem_kernel_name(filesystem_ptn.fstype);
 		if ( ! type.empty() )
 		{
 			// Second try mounting specifying the GParted determined file
@ -3266,7 +3266,7 @@ void Win_GParted::activate_change_uuid()
 	g_assert( valid_display_partition_ptr( selected_partition_ptr ) );  // Bug: Not pointing at a valid display partition object
 	const Partition & filesystem_ptn = selected_partition_ptr->get_filesystem_partition();
-	const FileSystem * filesystem_object = gparted_core.get_filesystem_object( filesystem_ptn.filesystem );
+	const FileSystem *filesystem_object = gparted_core.get_filesystem_object(filesystem_ptn.fstype);
 	if ( filesystem_object->get_custom_text( CTEXT_CHANGE_UUID_WARNING ) != "" )
 	{
 		int i ;
@ -3294,7 +3294,7 @@ void Win_GParted::activate_change_uuid()
 		// Sub-block so that temp_filesystem_ptn reference goes out of scope
 		// before temp_ptn pointer is deallocated.
 		Partition & temp_filesystem_ptn = temp_ptn->get_filesystem_partition();
-		if ( temp_filesystem_ptn.filesystem == FS_NTFS )
+		if (temp_filesystem_ptn.fstype == FS_NTFS)
 			// Explicitly ask for half, so that the user will be aware of it
 			// Also, keep this kind of policy out of the NTFS code.
 			temp_filesystem_ptn.uuid = UUID_RANDOM_NTFS_HALF;
--- a/src/udf.cc
+++ b/src/udf.cc
@ -70,7 +70,7 @@ FS udf::get_filesystem_support()
 FS_Limits udf::get_filesystem_limits( const Partition & partition ) const
 {
-	if ( partition.filesystem == FS_UDF && partition.fs_block_size > 0 )
+	if (partition.fstype == FS_UDF && partition.fs_block_size > 0)
 		// Resizing existing UDF file system
 		return FS_Limits( MIN_UDF_BLOCKS * partition.fs_block_size, MAX_UDF_BLOCKS * partition.fs_block_size );
 	else