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

Rename enum FILESYSTEM to FSType 

There are too many different types of things named "filesystem" in the
GParted code with the potential to cause confusion.  Namely:

    std::vector<FS> FILESYSTEMS
                              Vector of file system capabilities.

    class FileSystem          Base class interfacing to file system
                              specific executables for querying and
                              modification.

    enum FILESYSTEM           Symbolic constants representing each file
                              system type.

Many recent written or re-written functions already used a variable
named fstype.  Rename enum FILESYSTEM to enum FSType to clearly
distinguish it from the other things with very similar names.  Only
changing the name of the enumeration, not the name of variables of that
type too because that is a lot more lines of code and those can be
changed when the relevant code is re-written.
This commit is contained in:
Mike Fleetwood 2018-01-02 17:44:01 +00:00 committed by Curtis Gedak
parent 32c483c314
commit 175d27c55d
15 changed files with 66 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/Dialog_Partition_New.h
View File

@ -51,7 +51,7 @@ private:
unsigned short new_count,
const std::vector<FS> & FILESYSTEMS );
void Build_Filesystems_Menu( bool only_unformatted ) ;
Byte_Value get_filesystem_min_limit( FILESYSTEM fstype );
Byte_Value get_filesystem_min_limit( FSType fstype );
Gtk::Table table_create;
Gtk::OptionMenu optionmenu_type, optionmenu_filesystem;

20
include/GParted_Core.h
View File

@ -59,15 +59,15 @@ public:
bool toggle_flag( const Partition & partition, const Glib::ustring & flag, bool state ) ;
const std::vector<FS> & get_filesystems() const ;
const FS & get_fs( GParted::FILESYSTEM filesystem ) const ;
const FS & get_fs( FSType filesystem ) const;
static std::vector<Glib::ustring> get_disklabeltypes() ;
std::map<Glib::ustring, bool> get_available_flags( const Partition & partition ) ;
Glib::ustring get_libparted_version() ;
Glib::ustring get_thread_status_message() ;
static FileSystem * get_filesystem_object( FILESYSTEM filesystem );
static bool supported_filesystem( FILESYSTEM fstype );
static FS_Limits get_filesystem_limits( FILESYSTEM fstype, const Partition & partition );
static FileSystem * get_filesystem_object( FSType filesystem );
static bool supported_filesystem( FSType fstype );
static FS_Limits get_filesystem_limits( FSType fstype, const Partition & partition );
static bool filesystem_resize_disallowed( const Partition & partition ) ;
static void insert_unallocated( const Glib::ustring & device_path,
PartitionVector & partitions,
@ -83,18 +83,18 @@ private:
void set_device_from_disk( Device & device, const Glib::ustring & device_path );
void set_device_serial_number( Device & device );
void set_device_partitions( Device & device, PedDevice* lp_device, PedDisk* lp_disk ) ;
void set_device_one_partition( Device & device, PedDevice * lp_device, FILESYSTEM fstype,
void set_device_one_partition( Device & device, PedDevice * lp_device, FSType fstype,
std::vector<Glib::ustring> & messages );
void set_luks_partition( PartitionLUKS & partition );
void set_partition_label_and_uuid( Partition & partition );
static FILESYSTEM detect_filesystem_internal( PedDevice * lp_device, PedPartition * lp_partition );
static FILESYSTEM detect_filesystem( PedDevice * lp_device, PedPartition * lp_partition,
std::vector<Glib::ustring> & messages );
static FSType detect_filesystem_internal( PedDevice * lp_device, PedPartition * lp_partition );
static FSType detect_filesystem( PedDevice * lp_device, PedPartition * lp_partition,
std::vector<Glib::ustring> & messages );
void read_label( Partition & partition ) ;
void read_uuid( Partition & partition ) ;
void set_mountpoints( Partition & partition );
bool set_mountpoints_helper( Partition & partition, const Glib::ustring & path );
bool is_busy( FILESYSTEM fstype, const Glib::ustring & path ) ;
bool is_busy( FSType fstype, const Glib::ustring & path );
void set_used_sectors( Partition & partition, PedDisk* lp_disk );
void mounted_set_used_sectors( Partition & partition ) ;
#ifdef HAVE_LIBPARTED_FS_RESIZE
@ -233,7 +233,7 @@ private:
static PedExceptionOption ped_exception_handler( PedException * e ) ;
std::vector<FS> FILESYSTEMS ;
static std::map< FILESYSTEM, FileSystem * > FILESYSTEM_MAP ;
static std::map< FSType, FileSystem * > FILESYSTEM_MAP;
std::vector<PedPartitionFlag> flags;
std::vector<Glib::ustring> device_paths ;
bool probe_devices ;

6
include/Partition.h
View File

@ -76,7 +76,7 @@ public:
const Glib::ustring & partition,
int partition_number,
PartitionType type,
FILESYSTEM filesystem,
FSType filesystem,
Sector sector_start,
Sector sector_end,
Byte_Value sector_size,
@ -99,7 +99,7 @@ public:
bool inside_extended );
void set_unpartitioned( const Glib::ustring & device_path,
const Glib::ustring & partition_path,
FILESYSTEM fstype,
FSType fstype,
Sector length,
Byte_Value sector_size,
bool busy );
@ -154,7 +154,7 @@ public:
PartitionType type;// UNALLOCATED, PRIMARY, LOGICAL, etc...
PartitionStatus status; //STAT_REAL, STAT_NEW, etc..
PartitionAlignment alignment; //ALIGN_CYLINDER, ALIGN_STRICT, etc
FILESYSTEM filesystem ;
FSType filesystem;
Glib::ustring uuid ;
Glib::ustring name;
Sector sector_start;

2
include/PartitionLUKS.h
View File

@ -35,7 +35,7 @@ public:
Partition * clone_as_plain() const;
void set_luks( const Glib::ustring & path,
FILESYSTEM fstype,
FSType fstype,
Sector header_size,
Sector mapping_size,
Byte_Value sector_size,

20
include/Utils.h
View File

@ -57,7 +57,7 @@ const Glib::ustring UUID_RANDOM_NTFS_HALF = _("(Half new UUID - will be randomly
extern const Glib::ustring DEV_MAPPER_PATH;
enum FILESYSTEM
enum FSType
{
// Special partition types and functions
FS_UNALLOCATED = 0,
@ -144,7 +144,7 @@ struct FS
EXTERNAL = 3
};
FILESYSTEM filesystem ;
FSType filesystem;
Support busy ; //How to determine if partition/file system is busy
Support read ; //Can and how to read sector usage while inactive
Support read_label ;
@ -163,7 +163,7 @@ struct FS
Support online_grow ;
Support online_shrink ;
FS( FILESYSTEM fstype = FS_UNKNOWN ) : filesystem( fstype )
FS( FSType fstype = FS_UNKNOWN ) : filesystem( fstype )
{
busy = read = read_label = write_label = read_uuid = write_uuid = create =
create_with_label = grow = shrink = move = check = copy = remove = online_read =
@ -183,15 +183,15 @@ public:
, float yalign = 0.5 /* ALIGN_CENTER */
) ;
static Glib::ustring num_to_str( Sector number ) ;
static Glib::ustring get_color( FILESYSTEM filesystem ) ;
static Glib::RefPtr<Gdk::Pixbuf> get_color_as_pixbuf( FILESYSTEM filesystem, int width, int height ) ;
static Glib::ustring get_color( FSType filesystem );
static Glib::RefPtr<Gdk::Pixbuf> get_color_as_pixbuf( FSType filesystem, int width, int height );
static int get_max_partition_name_length( Glib::ustring & tabletype );
static int get_filesystem_label_maxlength( FILESYSTEM filesystem ) ;
static Glib::ustring get_filesystem_string( FILESYSTEM filesystem ) ;
static int get_filesystem_label_maxlength( FSType filesystem );
static Glib::ustring get_filesystem_string( FSType filesystem );
static const Glib::ustring get_encrypted_string();
static const Glib::ustring get_filesystem_string( bool encrypted, FILESYSTEM fstype );
static const Glib::ustring get_filesystem_kernel_name( FILESYSTEM fstype );
static Glib::ustring get_filesystem_software( FILESYSTEM filesystem ) ;
static const Glib::ustring get_filesystem_string( bool encrypted, FSType fstype );
static const Glib::ustring get_filesystem_kernel_name( FSType fstype );
static Glib::ustring get_filesystem_software( FSType filesystem );
static bool kernel_supports_fs( const Glib::ustring & fs ) ;
static bool kernel_version_at_least( int major_ver, int minor_ver, int patch_ver ) ;
static Glib::ustring format_size( Sector sectors, Byte_Value sector_size ) ;

4
include/Win_GParted.h
View File

@ -60,7 +60,7 @@ private:
void init_toolbar() ;
void init_partition_menu() ;
Gtk::Menu * create_format_menu() ;
void create_format_menu_add_item( FILESYSTEM filesystem, bool activate ) ;
void create_format_menu_add_item( FSType filesystem, bool activate );
void init_device_info() ;
void init_hpaned_main() ;
@ -176,7 +176,7 @@ private:
void activate_new();
void activate_delete();
void activate_info();
void activate_format( GParted::FILESYSTEM new_fs );
void activate_format( FSType new_fs );
bool check_toggle_busy_allowed( const Glib::ustring & disallowed_msg );
void show_toggle_failure_dialog( const Glib::ustring & failure_summary,
const Glib::ustring & marked_up_error );

4
include/ext2.h
View File

@ -31,7 +31,7 @@ namespace GParted
class ext2 : public FileSystem
{
const enum FILESYSTEM specific_type;
const enum FSType specific_type;
Glib::ustring dump_cmd;
Glib::ustring fsck_cmd;
Glib::ustring image_cmd;
@ -40,7 +40,7 @@ class ext2 : public FileSystem
Glib::ustring resize_cmd;
Glib::ustring tune_cmd;
public:
ext2( enum FILESYSTEM type ) : specific_type( type ), dump_cmd( "" ), fsck_cmd( "" ), image_cmd( "" ),
ext2( enum FSType type ) : specific_type( type ), dump_cmd( "" ), fsck_cmd( "" ), image_cmd( "" ),
label_cmd( "" ), mkfs_cmd( "" ), resize_cmd( "" ), tune_cmd( "" ),
force_auto_64bit( false ) {};
FS get_filesystem_support() ;

4
include/fat16.h
View File

@ -27,11 +27,11 @@ namespace GParted
class fat16 : public FileSystem
{
const enum FILESYSTEM specific_type ;
const enum FSType specific_type;
Glib::ustring create_cmd ;
Glib::ustring check_cmd ;
public:
fat16( enum FILESYSTEM type ) : specific_type( type ), create_cmd( "" ), check_cmd( "" ) {} ;
fat16( enum FSType type ) : specific_type( type ), create_cmd( "" ), check_cmd( "" ) {};
const Glib::ustring get_custom_text( CUSTOM_TEXT ttype, int index = 0 ) const;
FS get_filesystem_support() ;
void set_used_sectors( Partition & partition ) ;

2
src/Dialog_Partition_New.cc
View File

@ -429,7 +429,7 @@ void Dialog_Partition_New::Build_Filesystems_Menu( bool only_unformatted )
}
}
Byte_Value Dialog_Partition_New::get_filesystem_min_limit( FILESYSTEM fstype )
Byte_Value Dialog_Partition_New::get_filesystem_min_limit( FSType fstype )
{
return GParted_Core::get_filesystem_limits( fstype, *new_partition ).min_size;
}

2
src/Dialog_Rescue_Data.cc
View File

@ -335,7 +335,7 @@ void Dialog_Rescue_Data::read_partitions_from_buffer()
Glib::ustring part_path;
int part_num;
PartitionType type=GParted::TYPE_PRIMARY;
FILESYSTEM fs=GParted::FS_UNALLOCATED;
FSType fs = FS_UNALLOCATED;
Sector sec_start=0;
Sector sec_end=0;
Byte_Value sec_size=this->sector_size;

38
src/GParted_Core.cc
View File

@ -111,10 +111,10 @@ void GParted_Core::find_supported_core()
void GParted_Core::find_supported_filesystems()
{
std::map< FILESYSTEM, FileSystem * >::iterator f ;
std::map< FSType, FileSystem * >::iterator f;
// Iteration of std::map is ordered according to operator< of the key. Hence the
// FILESYSTEMS vector is constructed in FILESYSTEM enum order: FS_UNALLOCATED,
// FILESYSTEMS vector is constructed in FSType enum order: FS_UNALLOCATED,
// FS_UNKNOWN, FS_CLEARED, FS_EXTENDED, FS_BTRFS, ..., FS_LINUX_SWRAID,
// LINUX_SWSUSPEND which ultimately controls the default order of file systems in
// menus and dialogs.
@ -779,7 +779,7 @@ const std::vector<FS> & GParted_Core::get_filesystems() const
// Return supported capabilities of the file system type or, if not found, not supported
// capabilities set.
const FS & GParted_Core::get_fs( GParted::FILESYSTEM filesystem ) const
const FS & GParted_Core::get_fs( FSType filesystem ) const
{
for ( unsigned int t = 0 ; t < FILESYSTEMS .size() ; t++ )
{
@ -885,7 +885,7 @@ void GParted_Core::set_device_from_disk( Device & device, const Glib::ustring &
device.cylsize = MEBIBYTE / device.sector_size;
std::vector<Glib::ustring> messages;
FILESYSTEM fstype = detect_filesystem( lp_device, NULL, messages );
FSType fstype = detect_filesystem( lp_device, NULL, messages );
// FS_Info (blkid) recognised file system signature on whole disk device.
// Need to detect before libparted reported partitioning to avoid bug in
// libparted 1.9.0 to 2.3 inclusive which recognised FAT file systems as
@ -1033,7 +1033,7 @@ void GParted_Core::set_device_partitions( Device & device, PedDevice* lp_device,
libparted_messages .clear() ;
Partition * partition_temp = NULL;
bool partition_is_busy = false ;
GParted::FILESYSTEM filesystem;
FSType filesystem;
std::vector<Glib::ustring> detect_messages;
//Retrieve partition path
@ -1177,7 +1177,7 @@ void GParted_Core::set_device_partitions( Device & device, PedDevice* lp_device,
// Create one Partition object spanning the Device after identifying the file system
// on the whole disk device. Much simplified equivalent of set_device_partitions().
void GParted_Core::set_device_one_partition( Device & device, PedDevice * lp_device, FILESYSTEM fstype,
void GParted_Core::set_device_one_partition( Device & device, PedDevice * lp_device, FSType fstype,
std::vector<Glib::ustring> & messages )
{
device.partitions.clear();
@ -1224,7 +1224,7 @@ void GParted_Core::set_luks_partition( PartitionLUKS & partition )
Glib::ustring mapping_path = DEV_MAPPER_PATH + mapping.name;
PedDevice* lp_device = NULL;
std::vector<Glib::ustring> detect_messages;
FILESYSTEM fstype = FS_UNKNOWN;
FSType fstype = FS_UNKNOWN;
if ( get_device( mapping_path, lp_device ) )
{
fstype = detect_filesystem( lp_device, NULL, detect_messages );
@ -1291,11 +1291,11 @@ void GParted_Core::set_partition_label_and_uuid( Partition & partition )
// GParted simple internal file system signature detection. Use sparingly. Only when
// (old versions of) blkid and libparted don't recognise a signature.
FILESYSTEM GParted_Core::detect_filesystem_internal( PedDevice * lp_device, PedPartition * lp_partition )
FSType GParted_Core::detect_filesystem_internal( PedDevice * lp_device, PedPartition * lp_partition )
{
char magic1[16]; // Big enough for largest signatures[].sig1 or sig2
char magic2[16];
FILESYSTEM fstype = FS_UNKNOWN;
FSType fstype = FS_UNKNOWN;
char * buf = static_cast<char *>( malloc( lp_device->sector_size ) );
if ( ! buf )
@ -1312,7 +1312,7 @@ FILESYSTEM GParted_Core::detect_filesystem_internal( PedDevice * lp_device, PedP
const char * sig1;
Byte_Value offset2;
const char * sig2;
FILESYSTEM fstype;
FSType fstype;
} signatures[] = {
//offset1, sig1 , offset2, sig2 , fstype
{ 65536LL, "ReIsEr4" , 0LL, NULL , FS_REISER4 },
@ -1380,8 +1380,8 @@ FILESYSTEM GParted_Core::detect_filesystem_internal( PedDevice * lp_device, PedP
return fstype;
}
FILESYSTEM GParted_Core::detect_filesystem( PedDevice * lp_device, PedPartition * lp_partition,
std::vector<Glib::ustring> & messages )
FSType GParted_Core::detect_filesystem( PedDevice * lp_device, PedPartition * lp_partition,
std::vector<Glib::ustring> & messages )
{
Glib::ustring fsname = "";
Glib::ustring path;
@ -1477,7 +1477,7 @@ FILESYSTEM GParted_Core::detect_filesystem( PedDevice * lp_device, PedPartition
}
// (Q4) Fallback to GParted simple internal file system detection
FILESYSTEM fstype = detect_filesystem_internal( lp_device, lp_partition );
FSType fstype = detect_filesystem_internal( lp_device, lp_partition );
if ( fstype != FS_UNKNOWN )
return fstype;
@ -1668,7 +1668,7 @@ bool GParted_Core::set_mountpoints_helper( Partition & partition, const Glib::us
}
//Report whether the partition is busy (mounted/active)
bool GParted_Core::is_busy( FILESYSTEM fstype, const Glib::ustring & path )
bool GParted_Core::is_busy( FSType fstype, const Glib::ustring & path )
{
FileSystem * p_filesystem = NULL ;
bool busy = false ;
@ -3768,7 +3768,7 @@ bool GParted_Core::update_dmraid_entry( const Partition & partition, OperationDe
return success;
}
FileSystem * GParted_Core::get_filesystem_object( FILESYSTEM filesystem )
FileSystem * GParted_Core::get_filesystem_object( FSType filesystem )
{
if ( FILESYSTEM_MAP .count( filesystem ) )
return FILESYSTEM_MAP[ filesystem ] ;
@ -3777,12 +3777,12 @@ FileSystem * GParted_Core::get_filesystem_object( FILESYSTEM filesystem )
}
// Return true for file systems with an implementation class, false otherwise
bool GParted_Core::supported_filesystem( FILESYSTEM fstype )
bool GParted_Core::supported_filesystem( FSType fstype )
{
return get_filesystem_object( fstype ) != NULL;
}
FS_Limits GParted_Core::get_filesystem_limits( FILESYSTEM fstype, const Partition & partition )
FS_Limits GParted_Core::get_filesystem_limits( FSType fstype, const Partition & partition )
{
FileSystem *p_filesystem = get_filesystem_object( fstype );
FS_Limits fs_limits;
@ -4162,7 +4162,7 @@ void GParted_Core::init_filesystems()
void GParted_Core::fini_filesystems()
{
std::map<FILESYSTEM, FileSystem *>::iterator fs_iter;
std::map<FSType, FileSystem *>::iterator fs_iter;
for ( fs_iter = FILESYSTEM_MAP.begin() ; fs_iter != FILESYSTEM_MAP.end() ; fs_iter ++ )
{
delete fs_iter->second;
@ -4483,6 +4483,6 @@ GParted_Core::~GParted_Core()
Glib::Thread *GParted_Core::mainthread;
std::map< FILESYSTEM, FileSystem * > GParted_Core::FILESYSTEM_MAP;
std::map< FSType, FileSystem * > GParted_Core::FILESYSTEM_MAP;
} //GParted

4
src/Partition.cc
View File

@ -61,7 +61,7 @@ void Partition::Set( const Glib::ustring & device_path,
const Glib::ustring & partition,
int partition_number,
PartitionType type,
FILESYSTEM filesystem,
FSType filesystem,
Sector sector_start,
Sector sector_end,
Byte_Value sector_size,
@ -198,7 +198,7 @@ void Partition::Set_Unallocated( const Glib::ustring & device_path,
void Partition::set_unpartitioned( const Glib::ustring & device_path,
const Glib::ustring & partition_path,
FILESYSTEM fstype,
FSType fstype,
Sector length,
Byte_Value sector_size,
bool busy )

2
src/PartitionLUKS.cc
View File

@ -70,7 +70,7 @@ Partition * PartitionLUKS::clone_as_plain() const
// like a whole disk device as /dev/mapper/CRYPTNAME contains no partition table and the
// file system starts from sector 0 going to the very end.
void PartitionLUKS::set_luks( const Glib::ustring & path,
FILESYSTEM fstype,
FSType fstype,
Sector header_size,
Sector mapping_size,
Byte_Value sector_size,

14
src/Utils.cc
View File

@ -84,7 +84,7 @@ Glib::ustring Utils::num_to_str( Sector number )
// Use palette from GNOME Human Interface Guidelines as a starting point.
// http://developer.gnome.org/hig-book/2.32/design-color.html.en
// http://web.archive.org/web/20130922173112/https://developer.gnome.org/hig-book/stable/design-color.html.en
Glib::ustring Utils::get_color( FILESYSTEM filesystem )
Glib::ustring Utils::get_color( FSType filesystem )
{
switch( filesystem )
{
@ -128,7 +128,7 @@ Glib::ustring Utils::get_color( FILESYSTEM filesystem )
}
}
Glib::RefPtr<Gdk::Pixbuf> Utils::get_color_as_pixbuf( FILESYSTEM filesystem, int width, int height )
Glib::RefPtr<Gdk::Pixbuf> Utils::get_color_as_pixbuf( FSType filesystem, int width, int height )
{
Glib::RefPtr<Gdk::Pixbuf> pixbuf = Gdk::Pixbuf::create( Gdk::COLORSPACE_RGB, false, 8, width, height ) ;
@ -187,7 +187,7 @@ int Utils::get_max_partition_name_length( Glib::ustring & tabletype )
return 0;
}
int Utils::get_filesystem_label_maxlength( FILESYSTEM filesystem )
int Utils::get_filesystem_label_maxlength( FSType filesystem )
{
switch( filesystem )
{
@ -242,7 +242,7 @@ int Utils::get_filesystem_label_maxlength( FILESYSTEM filesystem )
}
// Return libparted file system name / GParted display name
Glib::ustring Utils::get_filesystem_string( FILESYSTEM filesystem )
Glib::ustring Utils::get_filesystem_string( FSType filesystem )
{
switch( filesystem )
{
@ -314,7 +314,7 @@ const Glib::ustring Utils::get_encrypted_string()
return "[" + Glib::ustring( _("Encrypted") ) + "]";
}
const Glib::ustring Utils::get_filesystem_string( bool encrypted, FILESYSTEM fstype )
const Glib::ustring Utils::get_filesystem_string( bool encrypted, FSType fstype )
{
if ( encrypted )
return get_encrypted_string() + " " + get_filesystem_string( fstype );
@ -324,7 +324,7 @@ const Glib::ustring Utils::get_filesystem_string( bool encrypted, FILESYSTEM fst
// Return Linux kernel name only for mountable file systems.
// (Identical to a subset of the libparted names except that it's hfsplus instead of hfs+).
const Glib::ustring Utils::get_filesystem_kernel_name( FILESYSTEM fstype )
const Glib::ustring Utils::get_filesystem_kernel_name( FSType fstype )
{
switch ( fstype )
{
@ -350,7 +350,7 @@ const Glib::ustring Utils::get_filesystem_kernel_name( FILESYSTEM fstype )
}
}
Glib::ustring Utils::get_filesystem_software( FILESYSTEM filesystem )
Glib::ustring Utils::get_filesystem_software( FSType filesystem )
{
switch( filesystem )
{

9
src/Win_GParted.cc
View File

@ -447,7 +447,7 @@ Gtk::Menu * Win_GParted::create_format_menu()
}
//Add one entry to the Partition --> Format to --> (file system list) menu
void Win_GParted::create_format_menu_add_item( FILESYSTEM filesystem, bool activate )
void Win_GParted::create_format_menu_add_item( FSType filesystem, bool activate )
{
hbox = manage( new Gtk::HBox() ) ;
//the colored square
@ -460,8 +460,7 @@ void Win_GParted::create_format_menu_add_item( FILESYSTEM filesystem, bool activ
menu ->items() .push_back( * manage( new Gtk::MenuItem( *hbox ) ) ) ;
if ( activate )
menu ->items() .back() .signal_activate() .connect(
sigc::bind<GParted::FILESYSTEM>( sigc::mem_fun( *this, &Win_GParted::activate_format ),
filesystem ) ) ;
sigc::bind<FSType>( sigc::mem_fun( *this, &Win_GParted::activate_format ), filesystem ) );
else
menu ->items() .back() .set_sensitive( false ) ;
}
@ -1796,7 +1795,7 @@ void Win_GParted::activate_resize()
Partition * working_ptn;
const Partition & selected_filesystem_ptn = selected_partition_ptr->get_filesystem_partition();
const FILESYSTEM fstype = selected_filesystem_ptn.filesystem;
const FSType fstype = selected_filesystem_ptn.filesystem;
FS fs_cap = gparted_core.get_fs( fstype );
FS_Limits fs_limits = gparted_core.get_filesystem_limits( fstype, selected_filesystem_ptn );
@ -2248,7 +2247,7 @@ void Win_GParted::activate_info()
dialog .run();
}
void Win_GParted::activate_format( GParted::FILESYSTEM new_fs )
void Win_GParted::activate_format( FSType new_fs )
{
g_assert( selected_partition_ptr != NULL ); // Bug: Partition callback without a selected partition
g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object