C++11: Convert NULL to nullptr (!117)

In C++11, nullptr [1] is the strongly typed value to use instead of the
macro NULL [2].  Use everywhere [3][4].

[1] nullptr, the pointer literal (since C++11)
    https://en.cppreference.com/w/cpp/language/nullptr
[2] NULL
    https://en.cppreference.com/w/cpp/types/NULL
[3] Bjarne Stroustrup's C++ Style and Technique FAQ, Should I use NULL
    or 0?
    https://www.stroustrup.com/bs_faq2.html#null
        "In C++, the definition of NULL is 0, so there is only an
        aesthetic difference.  I prefer to avoid macros, so I use 0.
        Another problem with NULL is that people sometimes mistakenly
        believe that it is different from 0 and/or not an integer.  In
        pre-standard code, NULL was/is sometimes defined to something
        unsuitable and therefore had/has to be avoided.  That's less
        common these days.

        If you have to name the null pointer, call it nullptr; that's
        what it's called in C++11.  Then, "nullptr" will be a keyword.
        "
[4] What is nullptr in C++? Advantages, Use Cases & Examples
    https://favtutor.com/blogs/nullptr-cpp
        "Advantages of nullptr
        ...
        Compatible: Null pointers are compatible with null pointer
        constants in the C style (such as NULL and 0).  This implies
        that old C code that uses these constants and null pointers can
        communicate with each other in C++.
        "

Closes !117 - Require C++11 compilation

include/Win_GParted.h

@@ -212,7 +212,7 @@ private:
 	                                            // operations applied to partitions for displaying in the UI.
 	const Partition * selected_partition_ptr;   // Pointer to the selected partition.  (Alias to element
 	                                            // in Win_GParted::m_display_device.partitions[] vector).
-	const Partition * copied_partition;         // NULL or copy of source partition object.
+	const Partition* copied_partition;          // nullptr or copy of source partition object.
 	std::vector<Operation *> operations;
 
 //gui stuff

src/DMRaid.cc

@@ -163,8 +163,8 @@ bool DMRaid::is_dmraid_device( const Glib::ustring & dev_path )
 		if ( ! device_found && file_test( dev_path, Glib::FILE_TEST_IS_SYMLINK ) )
 		{
 			//Path is a symbolic link so find real path
-			char * rpath = realpath( dev_path.c_str(), NULL );
+			char* rpath = realpath(dev_path.c_str(), nullptr);
-			if ( rpath != NULL )
+			if (rpath != nullptr)
 			{
 				Glib::ustring tmp_path = rpath;
 				free( rpath );
@@ -233,8 +233,8 @@ Glib::ustring DMRaid::get_dmraid_name( const Glib::ustring & dev_path )
 		if ( dmraid_name .empty() && file_test( dev_path, Glib::FILE_TEST_IS_SYMLINK ) )
 		{
 			//Path is a symbolic link so find real path
-			char * rpath = realpath( dev_path.c_str(), NULL );
+			char* rpath = realpath(dev_path.c_str(), nullptr);
-			if ( rpath != NULL )
+			if (rpath != nullptr)
 			{
 				Glib::ustring tmp_path = rpath;
 				free( rpath );

src/Dialog_Base_Partition.cc

@@ -31,7 +31,7 @@ namespace GParted
 Dialog_Base_Partition::Dialog_Base_Partition(const Device& device)
  : m_device(device)
 {
-	frame_resizer_base = NULL;
+	frame_resizer_base = nullptr;
 	GRIP = false ;
 	this ->fixed_start = false ;
 	this ->set_resizable( false );
@@ -165,7 +165,7 @@ void Dialog_Base_Partition::Set_Resizer( bool extended )
 
 const Partition & Dialog_Base_Partition::Get_New_Partition()
 {
-	g_assert( new_partition != NULL );  // Bug: Not initialised by derived Dialog_Partition_*() constructor calling set_data()
+	g_assert(new_partition != nullptr);  // Bug: Not initialised by derived Dialog_Partition_*() constructor calling set_data()
 
 	prepare_new_partition();
 	return *new_partition;
@@ -173,7 +173,7 @@ const Partition & Dialog_Base_Partition::Get_New_Partition()
 
 void Dialog_Base_Partition::prepare_new_partition()
 {
-	g_assert( new_partition != NULL );  // Bug: Not initialised by derived Dialog_Partition_*() constructor calling set_data()
+	g_assert(new_partition != nullptr);  // Bug: Not initialised by derived Dialog_Partition_*() constructor calling set_data()
 
 	Sector old_size = new_partition->get_sector_length();
 

src/Dialog_Partition_Copy.cc

@@ -43,7 +43,7 @@ Dialog_Partition_Copy::Dialog_Partition_Copy(const Device& device, const FS& fs,
 Dialog_Partition_Copy::~Dialog_Partition_Copy()
 {
 	delete new_partition;
-	new_partition = NULL;
+	new_partition = nullptr;
 }
 
 void Dialog_Partition_Copy::set_data( const Partition & selected_partition, const Partition & copied_partition )
@@ -145,7 +145,7 @@ void Dialog_Partition_Copy::set_data( const Partition & selected_partition, cons
 
 const Partition & Dialog_Partition_Copy::Get_New_Partition()
 {
-	g_assert( new_partition != NULL );  // Bug: Not initialised by constructor calling set_data()
+	g_assert(new_partition != nullptr);  // Bug: Not initialised by constructor calling set_data()
 
 	//first call baseclass to get the correct new partition
 	Dialog_Base_Partition::prepare_new_partition();

src/Dialog_Partition_New.cc

@@ -51,7 +51,7 @@ Dialog_Partition_New::Dialog_Partition_New( const Device & device,
 Dialog_Partition_New::~Dialog_Partition_New()
 {
 	delete new_partition;
-	new_partition = NULL;
+	new_partition = nullptr;
 
 	// Work around a Gtk issue fixed in 3.24.0.
 	// https://gitlab.gnome.org/GNOME/gtk/issues/125
@@ -212,7 +212,7 @@ void Dialog_Partition_New::set_data( const Device & device,
 
 const Partition & Dialog_Partition_New::Get_New_Partition()
 {
-	g_assert( new_partition != NULL );  // Bug: Not initialised by constructor calling set_data()
+	g_assert(new_partition != nullptr);  // Bug: Not initialised by constructor calling set_data()
 
 	PartitionType part_type ;
 	Sector new_start, new_end;
@@ -339,7 +339,7 @@ const Partition & Dialog_Partition_New::Get_New_Partition()
 
 void Dialog_Partition_New::combobox_changed(bool combo_type_changed)
 {
-	g_assert( new_partition != NULL );  // Bug: Not initialised by constructor calling set_data()
+	g_assert(new_partition != nullptr);  // Bug: Not initialised by constructor calling set_data()
 
 	// combo_type
 	if (combo_type_changed)
@@ -414,7 +414,8 @@ void Dialog_Partition_New::combobox_changed(bool combo_type_changed)
 
 void Dialog_Partition_New::build_filesystems_combo(bool only_unformatted)
 {
-	g_assert( new_partition != NULL );  // Bug: Not initialised by constructor calling set_data()
+	g_assert(new_partition != nullptr);  // Bug: Not initialised by constructor calling set_data()
+
 	combo_filesystem.items().clear();
 
 	// Fill the file system combobox

src/Dialog_Partition_Resize_Move.cc

@@ -40,7 +40,7 @@ Dialog_Partition_Resize_Move::Dialog_Partition_Resize_Move(const Device& device,
 Dialog_Partition_Resize_Move::~Dialog_Partition_Resize_Move()
 {
 	delete new_partition;
-	new_partition = NULL;
+	new_partition = nullptr;
 }
 
 void Dialog_Partition_Resize_Move::set_data( const Partition & selected_partition,
@@ -78,7 +78,7 @@ void Dialog_Partition_Resize_Move::set_data( const Partition & selected_partitio
 
 void Dialog_Partition_Resize_Move::Resize_Move_Normal( const PartitionVector & partitions )
 {
-	g_assert( new_partition != NULL );  // Bug: Not initialised by constructor calling set_data()
+	g_assert(new_partition != nullptr);  // Bug: Not initialised by constructor calling set_data()
 
 	// Don't permit shrinking an existing file system (other than linux-swap) when the
 	// usage is unknown as that sets the minimum resize.
@@ -118,7 +118,7 @@ void Dialog_Partition_Resize_Move::Resize_Move_Normal( const PartitionVector & p
 
 	Sector previous, next ;
 	previous = next = 0 ;
-	const Partition* prev_unalloc_partition = NULL;
+	const Partition* prev_unalloc_partition = nullptr;
 	//also check the partitions file system ( if this is a 'resize-only' then previous should be 0 )	
 	if (t >= 1 && partitions[t-1].type == TYPE_UNALLOCATED && ! this->fixed_start)
 	{ 
@@ -157,7 +157,7 @@ void Dialog_Partition_Resize_Move::Resize_Move_Normal( const PartitionVector & p
 	// Only need to use MIN_SPACE_BEFORE_MB to reserve 1 MiB to protect the partition
 	// table or EBR if there is a previous unallocated partition allowing the start of
 	// this selected partition to be resize/moved to the left.
-	if (prev_unalloc_partition == NULL)
+	if (prev_unalloc_partition == nullptr)
 		MIN_SPACE_BEFORE_MB = 0 ;
 	else
 		MIN_SPACE_BEFORE_MB = Dialog_Base_Partition::MB_Needed_for_Boot_Record(*prev_unalloc_partition);
@@ -231,7 +231,7 @@ void Dialog_Partition_Resize_Move::Resize_Move_Normal( const PartitionVector & p
 
 void Dialog_Partition_Resize_Move::Resize_Move_Extended( const PartitionVector & partitions )
 {
-	g_assert( new_partition != NULL );  // Bug: Not initialised by constructor calling set_data()
+	g_assert(new_partition != nullptr);  // Bug: Not initialised by constructor calling set_data()
 
 	set_title(Glib::ustring::compose(_("Resize/Move %1"), new_partition->get_path()));
 
@@ -243,7 +243,7 @@ void Dialog_Partition_Resize_Move::Resize_Move_Extended( const PartitionVector &
 
 	Sector previous, next ;
 	previous = next = 0 ;
-	const Partition* prev_unalloc_partition = NULL;
+	const Partition* prev_unalloc_partition = nullptr;
 	//calculate length and start of previous
 	if (t > 0 && partitions[t-1].type == TYPE_UNALLOCATED)
 	{
@@ -263,7 +263,7 @@ void Dialog_Partition_Resize_Move::Resize_Move_Extended( const PartitionVector &
 	// Only need to use MIN_SPACE_BEFORE_MB to reserve 1 MiB to protect the partition
 	// table or EBR if there is a previous unallocated partition allowing the start of
 	// this selected partition to be resize/moved to the left.
-	if (prev_unalloc_partition == NULL)
+	if (prev_unalloc_partition == nullptr)
 		MIN_SPACE_BEFORE_MB = 0 ;
 	else
 		MIN_SPACE_BEFORE_MB = Dialog_Base_Partition::MB_Needed_for_Boot_Record(*prev_unalloc_partition);

src/Dialog_Rescue_Data.cc

@@ -164,7 +164,7 @@ void Dialog_Rescue_Data::on_view_clicked(int nPart)
 	char tmpDir[32]=tmp_prefix;
 
 	char * tmpDirResult = mkdtemp(tmpDir);
-	if ( tmpDirResult == NULL )
+	if (tmpDirResult == nullptr)
 	{
 		Glib::ustring error_txt = _("An error occurred while creating a temporary directory for use as a mount point.");
 		error_txt += "\n";
@@ -212,8 +212,8 @@ void Dialog_Rescue_Data::on_view_clicked(int nPart)
 /* Opens the default browser in a directory */
 void Dialog_Rescue_Data::open_ro_view(Glib::ustring mountPoint)
 {
-	GError *error = NULL ;
+	GError* error = nullptr;
-	GdkScreen *gscreen = NULL ;
+	GdkScreen* gscreen = nullptr;
 
 	Glib::ustring uri = "file:" + mountPoint ;
 
@@ -221,7 +221,7 @@ void Dialog_Rescue_Data::open_ro_view(Glib::ustring mountPoint)
 
 	gtk_show_uri( gscreen, uri .c_str(), gtk_get_current_event_time(), &error ) ;
 
-	if ( error != NULL )
+	if (error != nullptr)
 	{
 		Glib::ustring sec_text(_("Error:"));
 		sec_text.append("\n");

src/DrawingAreaVisualDisk.cc

@@ -33,7 +33,7 @@ namespace GParted
 
 DrawingAreaVisualDisk::DrawingAreaVisualDisk()
 {
-	selected_vp = NULL ;
+	selected_vp = nullptr;
 
 	// Set some standard colors
 	color_used .set( Utils::get_color( GParted::FS_USED ) );
@@ -57,7 +57,7 @@ void DrawingAreaVisualDisk::load_partitions( const PartitionVector & partitions,
 
 void DrawingAreaVisualDisk::set_selected( const Partition * partition_ptr )
 {
-	selected_vp = NULL ;
+	selected_vp = nullptr;
 	set_selected( visual_partitions, partition_ptr );
 
 	queue_draw() ;
@@ -66,7 +66,7 @@ void DrawingAreaVisualDisk::set_selected( const Partition * partition_ptr )
 void DrawingAreaVisualDisk::clear()
 {
 	visual_partitions .clear() ;
-	selected_vp = NULL ;
+	selected_vp = nullptr;
 
 	queue_resize() ;
 }
@@ -343,7 +343,7 @@ bool DrawingAreaVisualDisk::on_button_press_event( GdkEventButton * event )
 {
 	bool ret_val = Gtk::DrawingArea::on_button_press_event( event ) ;
 
-	selected_vp = NULL ;
+	selected_vp = nullptr;
 	set_selected( visual_partitions, static_cast<int>( event ->x ), static_cast<int>( event ->y ) ) ;
 	queue_draw() ;
 	

src/FileSystem.cc

@@ -91,7 +91,7 @@ int FileSystem::execute_command( const Glib::ustring & command, OperationDetail
 {
 	StreamSlot empty_stream_slot;
 	TimedSlot empty_timed_slot;
-	return execute_command_internal(command, NULL, operationdetail, flags, empty_stream_slot, empty_timed_slot);
+	return execute_command_internal(command, nullptr, operationdetail, flags, empty_stream_slot, empty_timed_slot);
 }
 
 
@@ -114,7 +114,7 @@ int FileSystem::execute_command( const Glib::ustring & command, OperationDetail
                                  StreamSlot stream_progress_slot )
 {
 	TimedSlot empty_timed_slot;
-	return execute_command_internal(command, NULL, operationdetail, flags, stream_progress_slot, empty_timed_slot);
+	return execute_command_internal(command, nullptr, operationdetail, flags, stream_progress_slot, empty_timed_slot);
 }
 
 
@@ -125,7 +125,7 @@ int FileSystem::execute_command( const Glib::ustring & command, OperationDetail
                                  TimedSlot timed_progress_slot )
 {
 	StreamSlot empty_stream_slot;
-	return execute_command_internal(command, NULL, operationdetail, flags, empty_stream_slot, timed_progress_slot);
+	return execute_command_internal(command, nullptr, operationdetail, flags, empty_stream_slot, timed_progress_slot);
 }
 
 
@@ -150,7 +150,7 @@ int FileSystem::execute_command_internal(const Glib::ustring& command, const cha
 			Glib::SPAWN_DO_NOT_REAP_CHILD | Glib::SPAWN_SEARCH_PATH,
 			sigc::ptr_fun(setup_child),
 			&pid,
-			(input != NULL) ? &in : 0,
+			(input != nullptr) ? &in : 0,
 			&out,
 			&err );
 	} catch (Glib::SpawnError &e) {
@@ -194,7 +194,7 @@ int FileSystem::execute_command_internal(const Glib::ustring& command, const cha
 			pid,
 			flags & EXEC_CANCEL_SAFE ) );
 
-	if (input != NULL && in != -1)
+	if (input != nullptr && in != -1)
 	{
 		// Write small amount of input to pipe to the child process.  Linux will
 		// always accept up to 4096 bytes without blocking.  See pipe(7).
@@ -252,7 +252,7 @@ Glib::ustring FileSystem::mk_temp_dir( const Glib::ustring & infix, OperationDet
 	operationdetail .add_child( OperationDetail(
 			Glib::ustring( "mkdir -v " ) + dir_buf, STATUS_EXECUTE, FONT_BOLD_ITALIC ) ) ;
 	const char * dir_name = mkdtemp( dir_buf ) ;
-	if ( NULL == dir_name )
+	if (nullptr == dir_name)
 	{
 		int e = errno ;
 		operationdetail .get_last_child() .add_child( OperationDetail(

src/GParted_Core.cc

@@ -201,7 +201,7 @@ void GParted_Core::set_devices_thread( std::vector<Device> * pdevices )
 			ped_device_probe_all();
 		}
 
-		PedDevice* lp_device = ped_device_get_next( NULL ) ;
+		PedDevice* lp_device = ped_device_get_next(nullptr);
 		while ( lp_device ) 
 		{
 			/* TO TRANSLATORS: looks like   Confirming /dev/sda */
@@ -243,7 +243,7 @@ void GParted_Core::set_devices_thread( std::vector<Device> * pdevices )
 #endif
 
 			PedDevice* lp_device = ped_device_get( device_paths[t].c_str() );
-			if ( lp_device == NULL || ! useable_device( lp_device ) )
+			if (lp_device == nullptr || ! useable_device(lp_device))
 			{
 				// Remove this disk device which isn't useable
 				device_paths.erase( device_paths.begin() + t-- );
@@ -272,7 +272,7 @@ void GParted_Core::set_devices_thread( std::vector<Device> * pdevices )
 	}
 
 	set_thread_status_message("") ;
-	g_idle_add( (GSourceFunc)_mainquit, NULL );
+	g_idle_add((GSourceFunc)_mainquit, nullptr);
 }
 
 // runs gpart on the specified parameter
@@ -516,11 +516,11 @@ bool GParted_Core::new_disklabel( const Glib::ustring & device_path, const Glib:
 {
 	bool return_value = false ;
 
-	PedDevice* lp_device = NULL ;
+	PedDevice* lp_device = nullptr;
-	PedDisk* lp_disk = NULL ;
+	PedDisk* lp_disk = nullptr;
 	if ( get_device( device_path, lp_device ) )
 	{
-		PedDiskType *type = NULL ;
+		PedDiskType* type = nullptr;
 		type = ped_disk_type_get( disklabel .c_str() ) ;
 		
 		if ( type )
@@ -549,8 +549,8 @@ bool GParted_Core::new_disklabel( const Glib::ustring & device_path, const Glib:
 bool GParted_Core::toggle_flag( const Partition & partition, const Glib::ustring & flag, bool state ) 
 {
 	bool succes = false ;
-	PedDevice* lp_device = NULL ;
+	PedDevice* lp_device = nullptr;
-	PedDisk* lp_disk = NULL ;
+	PedDisk* lp_disk = nullptr;
 	if ( get_device_and_disk( partition .device_path, lp_device, lp_disk ) )
 	{
 		PedPartition* lp_partition = get_lp_partition( lp_disk, partition );
@@ -590,7 +590,7 @@ std::vector<Glib::ustring> GParted_Core::get_disklabeltypes()
 	std::vector<Glib::ustring> disklabeltypes ;
 
 	PedDiskType *disk_type ;
-	for ( disk_type = ped_disk_type_get_next( NULL ) ; disk_type ; disk_type = ped_disk_type_get_next( disk_type ) )
+	for (disk_type = ped_disk_type_get_next(nullptr); disk_type; disk_type = ped_disk_type_get_next(disk_type))
 		disklabeltypes .push_back( disk_type->name ) ;
 
 	 return disklabeltypes ;
@@ -600,8 +600,8 @@ std::map<Glib::ustring, bool> GParted_Core::get_available_flags( const Partition
 {
 	std::map<Glib::ustring, bool> flag_info ;
 
-	PedDevice* lp_device = NULL ;
+	PedDevice* lp_device = nullptr;
-	PedDisk* lp_disk = NULL ;
+	PedDisk* lp_disk = nullptr;
 	if ( get_device_and_disk( partition .device_path, lp_device, lp_disk ) )
 	{
 		PedPartition* lp_partition = get_lp_partition( lp_disk, partition );
@@ -624,13 +624,13 @@ std::map<Glib::ustring, bool> GParted_Core::get_available_flags( const Partition
 
 Glib::ustring GParted_Core::get_partition_path(const PedPartition *lp_partition)
 {
-	g_assert(lp_partition != NULL);  // Bug: Not initialised by suitable ped_disk_*partition*() call
+	g_assert(lp_partition != nullptr);  // Bug: Not initialised by suitable ped_disk_*partition*() call
 
 	char * lp_path;  //we have to free the result of ped_partition_get_path()
 	Glib::ustring partition_path = "Partition path not found";
 
 	lp_path = ped_partition_get_path(lp_partition);
-	if ( lp_path != NULL )
+	if (lp_path != nullptr)
 	{
 		partition_path = lp_path;
 		free(lp_path);
@@ -653,8 +653,8 @@ Glib::ustring GParted_Core::get_partition_path(const PedPartition *lp_partition)
 
 void GParted_Core::set_device_from_disk( Device & device, const Glib::ustring & device_path )
 {
-	PedDevice* lp_device = NULL;
+	PedDevice* lp_device = nullptr;
-	PedDisk* lp_disk = NULL;
+	PedDisk* lp_disk = nullptr;
 
 	if (! get_device(device_path, lp_device, true))
 		return;
@@ -677,7 +677,7 @@ void GParted_Core::set_device_from_disk( Device & device, const Glib::ustring &
 		device.cylsize = MEBIBYTE / device.sector_size;
 
 	std::vector<Glib::ustring> messages;
-	FSType fstype = detect_filesystem(lp_device, NULL, messages);
+	FSType fstype = detect_filesystem(lp_device, nullptr, messages);
 
 	if (fstype != FS_UNKNOWN)
 	{
@@ -826,11 +826,11 @@ void GParted_Core::set_device_partitions( Device & device, PedDevice* lp_device,
 	//clear partitions
 	device .partitions .clear() ;
 
-	PedPartition* lp_partition = ped_disk_next_partition( lp_disk, NULL ) ;
+	PedPartition* lp_partition = ped_disk_next_partition(lp_disk, nullptr);
 	while ( lp_partition )
 	{
 		libparted_messages .clear() ;
-		Partition * partition_temp = NULL;
+		Partition* partition_temp = nullptr;
 		bool partition_is_busy = false ;
 		FSType fstype;
 		std::vector<Glib::ustring> detect_messages;
@@ -930,7 +930,7 @@ void GParted_Core::set_device_partitions( Device & device, PedDevice* lp_device,
 
 		// Only for libparted reported partition types that we care about: NORMAL,
 		// LOGICAL, EXTENDED
-		if ( partition_temp != NULL )
+		if (partition_temp != nullptr)
 		{
 			set_partition_label_and_uuid( *partition_temp );
 			set_mountpoints( *partition_temp );
@@ -986,7 +986,7 @@ void GParted_Core::set_device_one_partition( Device & device, PedDevice * lp_dev
 	Glib::ustring path = lp_device->path;
 	bool partition_is_busy = is_busy(device.get_path(), fstype, path);
 
-	Partition * partition_temp = NULL;
+	Partition* partition_temp = nullptr;
 	if ( fstype == FS_LUKS )
 		partition_temp = new PartitionLUKS();
 	else
@@ -1008,7 +1008,7 @@ void GParted_Core::set_device_one_partition( Device & device, PedDevice * lp_dev
 
 	set_partition_label_and_uuid( *partition_temp );
 	set_mountpoints( *partition_temp );
-	set_used_sectors( *partition_temp, NULL );
+	set_used_sectors(*partition_temp, nullptr);
 
 	device.partitions.push_back_adopt( partition_temp );
 }
@@ -1039,7 +1039,7 @@ void GParted_Core::set_luks_partition( PartitionLUKS & partition )
 
 	set_partition_label_and_uuid( encrypted );
 	set_mountpoints( encrypted );
-	set_used_sectors( encrypted, NULL );
+	set_used_sectors(encrypted, nullptr);
 }
 
 void GParted_Core::set_partition_label_and_uuid( Partition & partition )
@@ -1095,18 +1095,18 @@ FSType GParted_Core::detect_filesystem_in_encryption_mapping(const Glib::ustring
 
 	FSType fstype = FS_UNKNOWN;
 
-	PedDevice *lp_device = NULL;
+	PedDevice* lp_device = nullptr;
 	if (get_device(path, lp_device))
 	{
 		// Run libparted partition table and file system identification.  Only use
 		// (get the first partition) if it's a "loop" table; because GParted only
 		// supports one block device to one encryption mapping to one file system.
-		PedDisk *lp_disk = NULL;
+		PedDisk* lp_disk = nullptr;
-		PedPartition *lp_partition = NULL;
+		PedPartition* lp_partition = nullptr;
 		if (get_disk(lp_device, lp_disk) && lp_disk && lp_disk->type        &&
 		    lp_disk->type->name && strcmp(lp_disk->type->name, "loop") == 0   )
 		{
-			lp_partition = ped_disk_next_partition(lp_disk, NULL);
+			lp_partition = ped_disk_next_partition(lp_disk, nullptr);
 		}
 		// Clear the "unrecognised disk label" message reported when libparted
 		// fails to detect anything.
@@ -1148,19 +1148,19 @@ FSType GParted_Core::detect_filesystem_internal(const Glib::ustring& path, Byte_
 		FSType       fstype;
 	} signatures[] = {
 		//offset1, sig1              , offset2, sig2   , fstype
-		{     0LL, "LUKS\xBA\xBE"    ,     0LL, NULL  , FS_LUKS           },
+		{     0LL, "LUKS\xBA\xBE"    ,     0LL, nullptr, FS_LUKS           },
-		{     3LL, "-FVE-FS-"        ,     0LL, NULL  , FS_BITLOCKER      },
+		{     3LL, "-FVE-FS-"        ,     0LL, nullptr, FS_BITLOCKER      },
-		{     0LL, "\x52\x56\xBE\x1B",     0LL, NULL  , FS_GRUB2_CORE_IMG },
+		{     0LL, "\x52\x56\xBE\x1B",     0LL, nullptr, FS_GRUB2_CORE_IMG },
-		{     0LL, "\x52\x56\xBE\x6F",     0LL, NULL  , FS_GRUB2_CORE_IMG },
+		{     0LL, "\x52\x56\xBE\x6F",     0LL, nullptr, FS_GRUB2_CORE_IMG },
-		{     0LL, "\x52\xE8\x28\x01",     0LL, NULL  , FS_GRUB2_CORE_IMG },
+		{     0LL, "\x52\xE8\x28\x01",     0LL, nullptr, FS_GRUB2_CORE_IMG },
-		{     0LL, "\x52\xBF\xF4\x81",     0LL, NULL  , FS_GRUB2_CORE_IMG },
+		{     0LL, "\x52\xBF\xF4\x81",     0LL, nullptr, FS_GRUB2_CORE_IMG },
-		{     0LL, "\x52\x56\xBE\x63",     0LL, NULL  , FS_GRUB2_CORE_IMG },
+		{     0LL, "\x52\x56\xBE\x63",     0LL, nullptr, FS_GRUB2_CORE_IMG },
-		{     0LL, "\x52\x56\xBE\x56",     0LL, NULL  , FS_GRUB2_CORE_IMG },
+		{     0LL, "\x52\x56\xBE\x56",     0LL, nullptr, FS_GRUB2_CORE_IMG },
 		{    24LL, "\x01\x00"        ,    32LL, "NXSB" , FS_APFS           },
 		{   512LL, "LABELONE"        ,   536LL, "LVM2" , FS_LVM2_PV        },
-		{  1030LL, "\x34\x34"        ,     0LL, NULL  , FS_NILFS2         },
+		{  1030LL, "\x34\x34"        ,     0LL, nullptr, FS_NILFS2         },
-		{ 65536LL, "ReIsEr4"         ,     0LL, NULL  , FS_REISER4        },
+		{ 65536LL, "ReIsEr4"         ,     0LL, nullptr, FS_REISER4        },
-		{ 65600LL, "_BHRfS_M"        ,     0LL, NULL  , FS_BTRFS          }
+		{ 65600LL, "_BHRfS_M"        ,     0LL, nullptr, FS_BTRFS          }
 	};
 	// For simple BitLocker recognition consider validation of BIOS Parameter block
 	// fields unnecessary.
@@ -1189,14 +1189,14 @@ FSType GParted_Core::detect_filesystem_internal(const Glib::ustring& path, Byte_
 
 	for ( unsigned int i = 0 ; i < sizeof( signatures ) / sizeof( signatures[0] ) ; i ++ )
 	{
-		const size_t len1 = std::min( ( signatures[i].sig1 == NULL ) ? 0U : strlen( signatures[i].sig1 ),
+		const size_t len1 = std::min((signatures[i].sig1 == nullptr) ? 0U : strlen(signatures[i].sig1),
 		                             sizeof(magic1));
-		const size_t len2 = std::min( ( signatures[i].sig2 == NULL ) ? 0U : strlen( signatures[i].sig2 ),
+		const size_t len2 = std::min((signatures[i].sig2 == nullptr) ? 0U : strlen(signatures[i].sig2),
 		                             sizeof(magic2));
 		// NOTE: From this point onwards signatures[].sig1 and .sig2 are treated
 		// as character buffers of known lengths len1 and len2, not NUL terminated
 		// strings.
-		if ( len1 == 0UL || ( signatures[i].sig2 != NULL && len2 == 0UL ) )
+		if (len1 == 0UL || (signatures[i].sig2 != nullptr && len2 == 0UL))
 			continue;  // Don't allow 0 length signatures to match
 
 		Byte_Value read_offset = signatures[i].offset1 / sector_size * sector_size;
@@ -1220,11 +1220,11 @@ FSType GParted_Core::detect_filesystem_internal(const Glib::ustring& path, Byte_
 		memcpy(magic1, buf + signatures[i].offset1 % sector_size, len1);
 
 		// WARNING: This assumes offset2 is in the same sector as offset1
-		if (signatures[i].sig2 != NULL)
+		if (signatures[i].sig2 != nullptr)
 			memcpy(magic2, buf + signatures[i].offset2 % sector_size, len2);
 
 		if (memcmp(magic1, signatures[i].sig1, len1) == 0                                    &&
-		    (signatures[i].sig2 == NULL || memcmp(magic2, signatures[i].sig2, len2) == 0)   )
+		    (signatures[i].sig2 == nullptr || memcmp(magic2, signatures[i].sig2, len2) == 0)   )
 		{
 			fstype = signatures[i].fstype;
 			break;
@@ -1241,7 +1241,7 @@ FSType GParted_Core::detect_filesystem_internal(const Glib::ustring& path, Byte_
 FSType GParted_Core::detect_filesystem(const PedDevice *lp_device, const PedPartition *lp_partition,
                                        std::vector<Glib::ustring> &messages)
 {
-	g_assert(lp_device != NULL);  // Bug: Not initialised by call to ped_device_get() or ped_device_get_next()
+	g_assert(lp_device != nullptr);  // Bug: Not initialised by call to ped_device_get() or ped_device_get_next()
 
 	Glib::ustring fsname = "";
 	Glib::ustring path;
@@ -1382,7 +1382,7 @@ FSType GParted_Core::detect_filesystem(const PedDevice *lp_device, const PedPart
 	
 void GParted_Core::read_label( Partition & partition )
 {
-	FileSystem* p_filesystem = NULL;
+	FileSystem* p_filesystem = nullptr;
 	switch (get_fs(partition.fstype).read_label)
 	{
 		case FS::EXTERNAL:
@@ -1398,7 +1398,7 @@ void GParted_Core::read_label( Partition & partition )
 
 void GParted_Core::read_uuid( Partition & partition )
 {
-	FileSystem* p_filesystem = NULL;
+	FileSystem* p_filesystem = nullptr;
 	switch (get_fs(partition.fstype).read_uuid)
 	{
 		case FS::EXTERNAL:
@@ -1574,7 +1574,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(const Glib::ustring& device_path, FSType fstype, const Glib::ustring& partition_path)
 {
-	FileSystem * p_filesystem = NULL ;
+	FileSystem* p_filesystem = nullptr;
 	bool busy = false ;
 
 	if ( supported_filesystem( fstype ) )
@@ -1620,7 +1620,7 @@ void GParted_Core::set_used_sectors( Partition & partition, PedDisk* lp_disk )
 {
 	if (supported_filesystem(partition.fstype))
 	{
-		FileSystem* p_filesystem = NULL;
+		FileSystem* p_filesystem = nullptr;
 		if ( partition.busy )
 		{
 			switch(get_fs(partition.fstype).online_read)
@@ -1738,8 +1738,8 @@ void GParted_Core::mounted_fs_set_used_sectors( Partition & partition )
 #ifdef HAVE_LIBPARTED_FS_RESIZE
 void GParted_Core::LP_set_used_sectors( Partition & partition, PedDisk* lp_disk )
 {
-	PedFileSystem *fs = NULL;
+	PedFileSystem* fs = nullptr;
-	PedConstraint *constraint = NULL;
+	PedConstraint* constraint = nullptr;
 
 	if ( lp_disk )
 	{
@@ -1815,13 +1815,13 @@ bool GParted_Core::create_partition( Partition & new_partition, OperationDetail
 	operationdetail .add_child( OperationDetail( _("create empty partition") ) ) ;
 	
 	new_partition .partition_number = 0 ;
-	PedDevice* lp_device = NULL ;
+	PedDevice* lp_device = nullptr;
-	PedDisk* lp_disk = NULL ;
+	PedDisk* lp_disk = nullptr;
 	if ( get_device_and_disk( new_partition .device_path, lp_device, lp_disk ) )
 	{
 		PedPartitionType type;
-		PedConstraint *constraint = NULL ;
+		PedConstraint* constraint = nullptr;
-		PedFileSystemType* fs_type = NULL ;
+		PedFileSystemType* fs_type = nullptr;
 
 		//create new partition
 		switch ( new_partition .type )
@@ -1935,7 +1935,7 @@ bool GParted_Core::create_filesystem( const Partition & partition, OperationDeta
 							Utils::get_filesystem_string(partition.fstype))));
 	
 	bool succes = false ;
-	FileSystem* p_filesystem = NULL ;
+	FileSystem* p_filesystem = nullptr;
 	switch (get_fs(partition.fstype).create)
 	{
 		case FS::NONE:
@@ -1982,8 +1982,8 @@ bool GParted_Core::delete_partition( const Partition & partition, OperationDetai
 	operationdetail .add_child( OperationDetail( _("delete partition") ) ) ;
 
 	bool succes = false ;
-	PedDevice* lp_device = NULL ;
+	PedDevice* lp_device = nullptr;
-	PedDisk* lp_disk = NULL ;
+	PedDisk* lp_disk = nullptr;
 	if ( get_device_and_disk( partition .device_path, lp_device, lp_disk ) )
 	{
 		PedPartition* lp_partition = get_lp_partition( lp_disk, partition );
@@ -1998,8 +1998,8 @@ bool GParted_Core::delete_partition( const Partition & partition, OperationDetai
 	DMRaid dmraid ;
 	if ( succes && dmraid .is_dmraid_device( partition .device_path ) )
 	{
-		PedDevice* lp_device = NULL ;
+		PedDevice* lp_device = nullptr;
-		PedDisk* lp_disk = NULL ;
+		PedDisk* lp_disk = nullptr;
 		//Open disk handle before and close after to prevent application crash.
 		if ( get_device_and_disk( partition .device_path, lp_device, lp_disk ) )
 		{
@@ -2029,7 +2029,7 @@ bool GParted_Core::remove_filesystem( const Partition & partition, OperationDeta
 	}
 
 	bool success = true ;
-	FileSystem* p_filesystem = NULL ;
+	FileSystem* p_filesystem = nullptr;
 
 	switch (get_fs(partition.fstype ).remove)
 	{
@@ -2071,7 +2071,7 @@ bool GParted_Core::label_filesystem( const Partition & partition, OperationDetai
 	}
 
 	bool succes = false ;
-	FileSystem* p_filesystem = NULL ;
+	FileSystem* p_filesystem = nullptr;
 	const FS& fs_cap = get_fs(partition.fstype);
 	FS::Support support = (partition.busy) ? fs_cap.online_write_label : fs_cap.write_label;
 	switch (support)
@@ -2100,8 +2100,8 @@ bool GParted_Core::name_partition( const Partition & partition, OperationDetail
 				                  partition.name, partition.get_path() ) ) );
 
 	bool success = false;
-	PedDevice *lp_device = NULL;
+	PedDevice* lp_device = nullptr;
-	PedDisk *lp_disk = NULL;
+	PedDisk* lp_disk = nullptr;
 	if ( get_device_and_disk( partition.device_path, lp_device, lp_disk ) )
 	{
 		PedPartition *lp_partition = ped_disk_get_partition_by_sector( lp_disk, partition.get_sector() );
@@ -2139,7 +2139,7 @@ bool GParted_Core::change_filesystem_uuid( const Partition & partition, Operatio
 	}
 
 	bool succes = false ;
-	FileSystem* p_filesystem = NULL ;
+	FileSystem* p_filesystem = nullptr;
 	switch (get_fs(partition.fstype).write_uuid)
 	{
 		case FS::EXTERNAL:
@@ -2175,7 +2175,7 @@ bool GParted_Core::resize_move( const Partition & partition_old,
 		{
 			return move( partition_old, partition_new, operationdetail );
 		}
-		Partition * temp = NULL;
+		Partition* temp = nullptr;
 		if ( partition_new .get_sector_length() > partition_old .get_sector_length() )
 		{
 			//first move, then grow. Since old.length < new.length and new.start is valid, temp is valid.
@@ -2197,7 +2197,7 @@ bool GParted_Core::resize_move( const Partition & partition_old,
 			success = resize_move( *temp, partition_new, operationdetail );
 
 		delete temp;
-		temp = NULL;
+		temp = nullptr;
 
 		return success;
 	}
@@ -2264,7 +2264,7 @@ bool GParted_Core::move( const Partition & partition_old,
 			}
 
 			delete partition_restore;
-			partition_restore = NULL;
+			partition_restore = nullptr;
 		}
 		else
 		{
@@ -2280,7 +2280,7 @@ bool GParted_Core::move( const Partition & partition_old,
 	}
 
 	delete partition_all_space;
-	partition_all_space = NULL;
+	partition_all_space = nullptr;
 
 	if ( ! success )
 		return false;
@@ -2313,7 +2313,7 @@ bool GParted_Core::move_filesystem( const Partition & partition_old,
 	}
 
 	bool succes = false ;
-	FileSystem* p_filesystem = NULL ;
+	FileSystem* p_filesystem = nullptr;
 	Sector total_done = 0;
 	switch (get_fs(partition_old.fstype).move)
 	{
@@ -2373,12 +2373,12 @@ bool GParted_Core::resize_move_filesystem_using_libparted( const Partition & par
 	operationdetail .add_child( OperationDetail( _("using libparted"), STATUS_NONE ) ) ;
 
 	bool return_value = false ;
-	PedDevice* lp_device = NULL ;
+	PedDevice* lp_device = nullptr;
-	PedDisk* lp_disk = NULL ;
+	PedDisk* lp_disk = nullptr;
 	if ( get_device_and_disk( partition_old .device_path, lp_device, lp_disk ) )
 	{
-		PedFileSystem *	fs = NULL ;
+		PedFileSystem* fs = nullptr;
-		PedGeometry * lp_geom = NULL ;	
+		PedGeometry* lp_geom = nullptr;
 
 		lp_geom = ped_geometry_new( lp_device,
 					    partition_old .sector_start,
@@ -2388,7 +2388,7 @@ bool GParted_Core::resize_move_filesystem_using_libparted( const Partition & par
 			fs = ped_file_system_open( lp_geom );
 
 			ped_geometry_destroy( lp_geom );
-			lp_geom = NULL;
+			lp_geom = nullptr;
 
 			if ( fs )
 			{
@@ -2426,8 +2426,8 @@ void GParted_Core::thread_lp_ped_file_system_resize( PedFileSystem * fs,
                                                      PedGeometry * lp_geom,
                                                      bool * return_value )
 {
-	*return_value = ped_file_system_resize( fs, lp_geom, NULL );
+	*return_value = ped_file_system_resize(fs, lp_geom, nullptr);
-	g_idle_add( (GSourceFunc)_mainquit, NULL );
+	g_idle_add((GSourceFunc)_mainquit, nullptr);
 }
 #endif
 
@@ -2729,9 +2729,9 @@ bool GParted_Core::resize_move_partition( const Partition & partition_old,
 		rollback_success = rollback_success && update_dmraid_entry( *partition_restore, operationdetail );
 
 		delete partition_restore;
-		partition_restore = NULL;
+		partition_restore = nullptr;
 		delete partition_intersection;
-		partition_intersection = NULL;
+		partition_intersection = nullptr;
 
 		operationdetail.get_last_child().set_success_and_capture_errors( rollback_success );
 	}
@@ -2745,14 +2745,14 @@ bool GParted_Core::resize_move_partition_implement( const Partition & partition_
                                                     Sector & new_end )
 {
 	bool success = false;
-	PedDevice *lp_device = NULL;
+	PedDevice* lp_device = nullptr;
-	PedDisk *lp_disk = NULL;
+	PedDisk* lp_disk = nullptr;
 	if ( get_device_and_disk( partition_old.device_path, lp_device, lp_disk ) )
 	{
 		PedPartition *lp_partition = get_lp_partition( lp_disk, partition_old );
 		if ( lp_partition )
 		{
-			PedConstraint *constraint = NULL;
+			PedConstraint* constraint = nullptr;
 			if ( partition_new.alignment == ALIGN_STRICT   ||
 			     partition_new.alignment == ALIGN_MEBIBYTE ||
 			     partition_new.strict_start                   )
@@ -2969,7 +2969,7 @@ bool GParted_Core::resize_filesystem_implement( const Partition & partition_old,
 		action = ( partition_old.busy ) ? fs_cap.online_shrink : fs_cap.shrink;
 	}
 	bool success = false;
-	FileSystem* p_filesystem = NULL;
+	FileSystem* p_filesystem = nullptr;
 	switch ( action )
 	{
 		case FS::NONE:
@@ -3078,7 +3078,7 @@ bool GParted_Core::copy_filesystem( const Partition & partition_src,
 			                  partition_dst.get_path() ) ) );
 
 	bool success = false;
-	FileSystem* p_filesystem = NULL;
+	FileSystem* p_filesystem = nullptr;
 	switch (get_fs(partition_dst.fstype).copy)
 	{
 		case FS::GPARTED:
@@ -3306,8 +3306,8 @@ void GParted_Core::rollback_move_filesystem( const Partition & partition_src,
 
 		delete temp_src;
 		delete temp_dst;
-		temp_src = NULL;
+		temp_src = nullptr;
-		temp_dst = NULL;
+		temp_dst = nullptr;
 	}
 }
 
@@ -3332,7 +3332,7 @@ bool GParted_Core::check_repair_filesystem( const Partition & partition, Operati
 						  partition .get_path() ) ) ) ;
 	
 	bool succes = false ;
-	FileSystem* p_filesystem = NULL ;
+	FileSystem* p_filesystem = nullptr;
 	switch (get_fs(partition.fstype).check)
 	{
 		case FS::NONE:
@@ -3380,7 +3380,7 @@ bool GParted_Core::check_repair_maximize( const Partition & partition,
 		temp_offline->busy = false;
 		bool success = maximize_encryption( *temp_offline, operationdetail );
 		delete temp_offline;
-		temp_offline = NULL;
+		temp_offline = nullptr;
 		if ( ! success )
 			return false;
 
@@ -3408,8 +3408,8 @@ bool GParted_Core::set_partition_type( const Partition & partition, OperationDet
 
 	bool return_value = false ;
 	
-	PedDevice* lp_device = NULL ;
+	PedDevice* lp_device = nullptr;
-	PedDisk* lp_disk = NULL ;
+	PedDisk* lp_disk = nullptr;
 	if ( get_device_and_disk( partition .device_path, lp_device, lp_disk ) )
 	{
 		PedPartition* lp_partition = ped_disk_get_partition_by_sector( lp_disk, partition.get_sector() );
@@ -3420,7 +3420,7 @@ bool GParted_Core::set_partition_type( const Partition & partition, OperationDet
 			// 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;
+			PedFileSystemType* lp_fs_type = nullptr;
 			if (partition.fstype != FS_CLEARED)
 				lp_fs_type = ped_file_system_type_get(fs_type.c_str());
 
@@ -3503,8 +3503,8 @@ bool GParted_Core::calibrate_partition( Partition & partition, OperationDetail &
 		operationdetail.add_child( OperationDetail( Glib::ustring::compose( _("calibrate %1"), curr_path ) ) );
 	
 		bool success = false;
-		PedDevice* lp_device = NULL ;
+		PedDevice* lp_device = nullptr;
-		PedDisk* lp_disk = NULL ;
+		PedDisk* lp_disk = nullptr;
 		if ( get_device( partition.device_path, lp_device ) )
 		{	
 			if ( partition.type == TYPE_UNPARTITIONED )
@@ -3612,14 +3612,14 @@ bool GParted_Core::calculate_exact_geom( const Partition & partition_old,
 		FONT_ITALIC ) ) ;
 	
 	bool succes = false ;
-	PedDevice* lp_device = NULL ;
+	PedDevice* lp_device = nullptr;
-	PedDisk* lp_disk = NULL ;
+	PedDisk* lp_disk = nullptr;
 	if ( get_device_and_disk( partition_old .device_path, lp_device, lp_disk ) )
 	{
 		PedPartition* lp_partition = get_lp_partition( lp_disk, partition_old );
 		if ( lp_partition )
 		{
-			PedConstraint *constraint = NULL ;
+			PedConstraint* constraint = nullptr;
 			constraint = ped_constraint_any( lp_device ) ;
 			
 			if ( constraint )
@@ -3673,7 +3673,7 @@ bool GParted_Core::update_dmraid_entry( const Partition & partition, OperationDe
 	DMRaid dmraid;
 	if ( dmraid.is_dmraid_device( partition.device_path ) )
 	{
-		PedDevice *lp_device = NULL;
+		PedDevice* lp_device = nullptr;
 		PedDisk *lp_disk;
 		// Open disk handle before and close after to prevent application crash.
 		if ( get_device_and_disk( partition.device_path, lp_device, lp_disk ) )
@@ -3696,7 +3696,7 @@ FileSystem * GParted_Core::get_filesystem_object( FSType fstype )
 // Return true for file systems with an implementation class, false otherwise
 bool GParted_Core::supported_filesystem( FSType fstype )
 {
-	return supported_filesystems->get_fs_object(fstype) != NULL;
+	return supported_filesystems->get_fs_object(fstype) != nullptr;
 }
 
 
@@ -3704,7 +3704,7 @@ FS_Limits GParted_Core::get_filesystem_limits( FSType fstype, const Partition &
 {
 	FileSystem* p_filesystem = supported_filesystems->get_fs_object(fstype);
 	FS_Limits fs_limits;
-	if ( p_filesystem != NULL )
+	if (p_filesystem != nullptr)
 		fs_limits = p_filesystem->get_filesystem_limits( partition );
 	return fs_limits;
 }
@@ -3739,13 +3739,13 @@ bool GParted_Core::erase_filesystem_signatures( const Partition & partition, Ope
 
 	//Get device, disk & partition and open the device.  Allocate buffer and fill with
 	//  zeros.  Buffer size is the greater of 4 KiB and the sector size.
-	PedDevice* lp_device = NULL ;
+	PedDevice* lp_device = nullptr;
-	PedDisk* lp_disk = NULL ;
+	PedDisk* lp_disk = nullptr;
-	PedPartition* lp_partition = NULL ;
+	PedPartition* lp_partition = nullptr;
-	PedGeometry *lp_geom = NULL;
+	PedGeometry* lp_geom = nullptr;
 	bool device_is_open = false ;
 	Byte_Value bufsize = 4LL * KIBIBYTE ;
-	char * buf = NULL ;
+	char* buf = nullptr;
 	if ( get_device( partition.device_path, lp_device ) )
 	{
 		if ( partition.type == TYPE_UNPARTITIONED )
@@ -3763,7 +3763,7 @@ bool GParted_Core::erase_filesystem_signatures( const Partition & partition, Ope
 				lp_geom = ped_geometry_duplicate(&lp_partition->geom);
 		}
 
-		if (lp_geom != NULL && ped_device_open(lp_device))
+		if (lp_geom != nullptr && ped_device_open(lp_device))
 		{
 			device_is_open = true ;
 
@@ -3901,7 +3901,7 @@ bool GParted_Core::erase_filesystem_signatures( const Partition & partition, Ope
 	}
 	if ( buf )
 		free( buf ) ;
-	if (lp_geom != NULL)
+	if (lp_geom != nullptr)
 		ped_geometry_destroy(lp_geom);
 
 	//Linux kernel doesn't maintain buffer cache coherency between the whole disk
@@ -4047,7 +4047,7 @@ void GParted_Core::capture_libparted_messages( OperationDetail & operationdetail
 
 bool GParted_Core::useable_device(const PedDevice* lp_device)
 {
-	g_assert( lp_device != NULL );  // Bug: Not initialised by call to ped_device_get() or ped_device_get_next()
+	g_assert(lp_device != nullptr);  // Bug: Not initialised by call to ped_device_get() or ped_device_get_next()
 
 	char * buf = static_cast<char *>( malloc( lp_device->sector_size ) );
 	if ( ! buf )
@@ -4119,7 +4119,7 @@ bool GParted_Core::get_device( const Glib::ustring & device_path, PedDevice *& l
 
 bool GParted_Core::get_disk(PedDevice *lp_device, PedDisk*& lp_disk)
 {
-	g_assert(lp_device != NULL);  // Bug: Not initialised by call to ped_device_get() or ped_device_get_next()
+	g_assert(lp_device != nullptr);  // Bug: Not initialised by call to ped_device_get() or ped_device_get_next()
 
 	lp_disk = ped_disk_new(lp_device);
 
@@ -4129,7 +4129,7 @@ bool GParted_Core::get_disk(PedDevice *lp_device, PedDisk*& lp_disk)
 	// /dev/PTN entries don't exist.
 	settle_device(SETTLE_DEVICE_PROBE_MAX_WAIT_SECONDS);
 
-	return (lp_disk != NULL);
+	return (lp_disk != nullptr);
 }
 
 
@@ -4152,11 +4152,11 @@ void GParted_Core::destroy_device_and_disk( PedDevice*& lp_device, PedDisk*& lp_
 {
 	if ( lp_disk )
 		ped_disk_destroy( lp_disk ) ;
-	lp_disk = NULL ;
+	lp_disk = nullptr;
 
 	if ( lp_device )
 		ped_device_destroy( lp_device ) ;
-	lp_device = NULL ;
+	lp_device = nullptr;
 }
 
 bool GParted_Core::commit( PedDisk* lp_disk )
@@ -4324,7 +4324,7 @@ PedExceptionOption GParted_Core::ped_exception_handler( PedException * e )
 GParted_Core::~GParted_Core() 
 {
 	delete supported_filesystems;
-	supported_filesystems = NULL;
+	supported_filesystems = nullptr;
 }
 
 

src/Mount_Info.cc

@@ -153,11 +153,11 @@ bool Mount_Info::is_dev_mounted_at(const Glib::ustring& path, const Glib::ustrin
 void Mount_Info::read_mountpoints_from_file( const Glib::ustring & filename, MountMapping & map )
 {
 	FILE* fp = setmntent( filename .c_str(), "r" );
-	if ( fp == NULL )
+	if (fp == nullptr)
 		return;
 
-	struct mntent* p = NULL;
+	struct mntent* p = nullptr;
-	while ( ( p = getmntent( fp ) ) != NULL )
+	while ((p = getmntent(fp)) != nullptr)
 	{
 		Glib::ustring node = lookup_uuid_or_label(p->mnt_fsname);
 		if (node.empty())

src/Operation.cc

@@ -29,35 +29,35 @@ Operation::Operation()
 
 Partition & Operation::get_partition_original()
 {
-	g_assert( partition_original != NULL );  // Bug: Not initialised by derived Operation*() constructor or reset later
+	g_assert(partition_original != nullptr);  // Bug: Not initialised by derived Operation*() constructor or reset later
 
 	return *partition_original;
 }
 
 const Partition & Operation::get_partition_original() const
 {
-	g_assert( partition_original != NULL );  // Bug: Not initialised by derived Operation*() constructor or reset later
+	g_assert(partition_original != nullptr);  // Bug: Not initialised by derived Operation*() constructor or reset later
 
 	return *partition_original;
 }
 
 Partition & Operation::get_partition_new()
 {
-	g_assert( partition_new != NULL );  // Bug: Not initialised by derived Operation*() constructor or reset later
+	g_assert(partition_new != nullptr);  // Bug: Not initialised by derived Operation*() constructor or reset later
 
 	return *partition_new;
 }
 
 const Partition & Operation::get_partition_new() const
 {
-	g_assert( partition_new != NULL );  // Bug: Not initialised by derived Operation*() constructor or reset later
+	g_assert(partition_new != nullptr);  // Bug: Not initialised by derived Operation*() constructor or reset later
 
 	return *partition_new;
 }
 
 int Operation::find_index_original( const PartitionVector & partitions )
 {
-	g_assert( partition_original != NULL );  // Bug: Not initialised by derived Operation*() constructor or reset later
+	g_assert(partition_original != nullptr);  // Bug: Not initialised by derived Operation*() constructor or reset later
 
 	for ( unsigned int t = 0 ; t < partitions .size() ; t++ )
 		if ( partition_original->sector_start >= partitions[t].sector_start &&
@@ -71,7 +71,7 @@ int Operation::find_index_original( const PartitionVector & partitions )
 // this->partition_new.  Return vector index or -1 when no match found.
 int Operation::find_index_new( const PartitionVector & partitions )
 {
-	g_assert( partition_new != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_new != nullptr);  // Bug: Not initialised by constructor or reset later
 
 	for ( unsigned int i = 0 ; i < partitions.size() ; i ++ )
 		if ( partition_new->sector_start >= partitions[i].sector_start &&
@@ -93,8 +93,8 @@ void Operation::insert_unallocated( PartitionVector & partitions,
 // it with this operation's new partition.
 void Operation::substitute_new( PartitionVector & partitions )
 {
-	g_assert( partition_original != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_original != nullptr);  // Bug: Not initialised by constructor or reset later
-	g_assert( partition_new != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_new != nullptr);  // Bug: Not initialised by constructor or reset later
 
 	int index_extended;
 	int index;
@@ -130,7 +130,7 @@ void Operation::insert_new( PartitionVector & partitions )
 	// their operations to the disk graphic.  Hence their use of,
 	// find_index_original().
 
-	g_assert( partition_new != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_new != nullptr);  // Bug: Not initialised by constructor or reset later
 
 	int index_extended;
 	int index;

src/OperationChangeUUID.cc

@@ -37,8 +37,8 @@ OperationChangeUUID::~OperationChangeUUID()
 {
 	delete partition_original;
 	delete partition_new;
-	partition_original = NULL;
+	partition_original = nullptr;
-	partition_new = NULL;
+	partition_new = nullptr;
 }
 
 void OperationChangeUUID::apply_to_visual( PartitionVector & partitions )
@@ -48,7 +48,7 @@ void OperationChangeUUID::apply_to_visual( PartitionVector & partitions )
 
 void OperationChangeUUID::create_description()
 {
-	g_assert( partition_new != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_new != nullptr);  // Bug: Not initialised by constructor or reset later
 
 	if ( partition_new->get_filesystem_partition().uuid == UUID_RANDOM_NTFS_HALF )
 	{
@@ -68,7 +68,7 @@ void OperationChangeUUID::create_description()
 
 bool OperationChangeUUID::merge_operations( const Operation & candidate )
 {
-	g_assert( partition_new != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_new != nullptr);  // Bug: Not initialised by constructor or reset later
 
 	if ( candidate.type == OPERATION_CHANGE_UUID              &&
 	     *partition_new == candidate.get_partition_original()    )

src/OperationCheck.cc

@@ -34,8 +34,8 @@ OperationCheck::~OperationCheck()
 {
 	delete partition_original;
 	delete partition_new;
-	partition_original = NULL;
+	partition_original = nullptr;
-	partition_new = NULL;
+	partition_new = nullptr;
 }
 
 void OperationCheck::apply_to_visual( PartitionVector & partitions )
@@ -44,7 +44,7 @@ void OperationCheck::apply_to_visual( PartitionVector & partitions )
 
 void OperationCheck::create_description() 
 {
-	g_assert( partition_original != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_original != nullptr);  // Bug: Not initialised by constructor or reset later
 
 	/*TO TRANSLATORS: looks like  Check and repair file system (ext3) on /dev/hda4 */
 	description = Glib::ustring::compose( _("Check and repair file system (%1) on %2"),
@@ -54,7 +54,7 @@ void OperationCheck::create_description()
 
 bool OperationCheck::merge_operations( const Operation & candidate )
 {
-	g_assert( partition_original != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_original != nullptr);  // Bug: Not initialised by constructor or reset later
 
 	if ( candidate.type      == OPERATION_CHECK                    &&
 	     *partition_original == candidate.get_partition_original()    )

src/OperationCopy.cc

@@ -40,28 +40,28 @@ OperationCopy::~OperationCopy()
 	delete partition_original;
 	delete partition_new;
 	delete partition_copied;
-	partition_original = NULL;
+	partition_original = nullptr;
-	partition_new = NULL;
+	partition_new = nullptr;
-	partition_copied = NULL;
+	partition_copied = nullptr;
 }
 
 Partition & OperationCopy::get_partition_copied()
 {
-	g_assert( partition_copied != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_copied != nullptr);  // Bug: Not initialised by constructor or reset later
 
 	return *partition_copied;
 }
 
 const Partition & OperationCopy::get_partition_copied() const
 {
-	g_assert( partition_copied != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_copied != nullptr);  // Bug: Not initialised by constructor or reset later
 
 	return *partition_copied;
 }
 
 void OperationCopy::apply_to_visual( PartitionVector & partitions )
 {
-	g_assert( partition_original != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_original != nullptr);  // Bug: Not initialised by constructor or reset later
 
 	if ( partition_original->type == TYPE_UNALLOCATED )
 		// Paste into unallocated space creating new partition
@@ -73,9 +73,9 @@ void OperationCopy::apply_to_visual( PartitionVector & partitions )
 
 void OperationCopy::create_description() 
 {
-	g_assert( partition_original != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_original != nullptr);  // Bug: Not initialised by constructor or reset later
-	g_assert( partition_new != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_new != nullptr);  // Bug: Not initialised by constructor or reset later
-	g_assert( partition_copied != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_copied != nullptr);  // Bug: Not initialised by constructor or reset later
 
 	if ( partition_original->type == TYPE_UNALLOCATED )
 	{

src/OperationCreate.cc

@@ -39,8 +39,8 @@ OperationCreate::~OperationCreate()
 {
 	delete partition_original;
 	delete partition_new;
-	partition_original = NULL;
+	partition_original = nullptr;
-	partition_new = NULL;
+	partition_new = nullptr;
 }
 
 void OperationCreate::apply_to_visual( PartitionVector & partitions )
@@ -50,7 +50,7 @@ void OperationCreate::apply_to_visual( PartitionVector & partitions )
 
 void OperationCreate::create_description() 
 {
-	g_assert( partition_new != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_new != nullptr);  // Bug: Not initialised by constructor or reset later
 
 	switch( partition_new->type )
 	{
@@ -79,7 +79,7 @@ void OperationCreate::create_description()
 
 bool OperationCreate::merge_operations( const Operation & candidate )
 {
-	g_assert( partition_new != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_new != nullptr);  // Bug: Not initialised by constructor or reset later
 
 	if ( candidate.type                            == OPERATION_FORMAT                   &&
 	     candidate.get_partition_original().status == STAT_NEW                           &&

src/OperationDelete.cc

@@ -33,7 +33,7 @@ OperationDelete::OperationDelete( const Device & device, const Partition & parti
 OperationDelete::~OperationDelete()
 {
 	delete partition_original;
-	partition_original = NULL;
+	partition_original = nullptr;
 }
 
 Partition & OperationDelete::get_partition_new()
@@ -54,7 +54,7 @@ const Partition & OperationDelete::get_partition_new() const
 
 void OperationDelete::apply_to_visual( PartitionVector & partitions )
 {
-	g_assert( partition_original != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_original != nullptr);  // Bug: Not initialised by constructor or reset later
 
 	int index_extended;
 	int index;
@@ -103,7 +103,7 @@ void OperationDelete::apply_to_visual( PartitionVector & partitions )
 
 void OperationDelete::create_description() 
 {
-	g_assert( partition_original != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_original != nullptr);  // Bug: Not initialised by constructor or reset later
 
 	if ( partition_original->type == TYPE_LOGICAL )
 		description = _("Logical Partition") ;

src/OperationDetail.cc

@@ -90,13 +90,13 @@ void OperationDetail::set_status( OperationDetailStatus status )
 		{
 			case STATUS_EXECUTE:
 				time_elapsed = -1 ;
-				time_start = std::time( NULL ) ;
+				time_start = std::time(nullptr);
 				break ;
 			case STATUS_ERROR:
 			case STATUS_WARNING:
 			case STATUS_SUCCESS:
 				if( time_start != -1 )
-					time_elapsed = std::time( NULL ) - time_start ;
+					time_elapsed = std::time(nullptr) - time_start;
 				break ;
 
 			default:

src/OperationFormat.cc

@@ -36,14 +36,14 @@ OperationFormat::~OperationFormat()
 {
 	delete partition_original;
 	delete partition_new;
-	partition_original = NULL;
+	partition_original = nullptr;
-	partition_new = NULL;
+	partition_new = nullptr;
 }
 
 void OperationFormat::apply_to_visual( PartitionVector & partitions )
 {
-	g_assert( partition_original != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_original != nullptr);  // Bug: Not initialised by constructor or reset later
-	g_assert( partition_new != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_new != nullptr);  // Bug: Not initialised by constructor or reset later
 
 	if (partition_original->type == TYPE_UNPARTITIONED && partition_new->fstype == FS_CLEARED)
 	{
@@ -68,8 +68,8 @@ void OperationFormat::apply_to_visual( PartitionVector & partitions )
 
 void OperationFormat::create_description() 
 {
-	g_assert( partition_original != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_original != nullptr);  // Bug: Not initialised by constructor or reset later
-	g_assert( partition_new != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_new != nullptr);  // Bug: Not initialised by constructor or reset later
 
 	/*TO TRANSLATORS: looks like  Format /dev/hda4 as linux-swap */
 	description = Glib::ustring::compose( _("Format %1 as %2"),
@@ -79,7 +79,7 @@ void OperationFormat::create_description()
 
 bool OperationFormat::merge_operations( const Operation & candidate )
 {
-	g_assert( partition_new != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_new != nullptr);  // Bug: Not initialised by constructor or reset later
 
 	if ( candidate.type == OPERATION_FORMAT                   &&
 	     *partition_new == candidate.get_partition_original()    )

src/OperationLabelFileSystem.cc

@@ -36,8 +36,8 @@ OperationLabelFileSystem::~OperationLabelFileSystem()
 {
 	delete partition_original;
 	delete partition_new;
-	partition_original = NULL;
+	partition_original = nullptr;
-	partition_new = NULL;
+	partition_new = nullptr;
 }
 
 void OperationLabelFileSystem::apply_to_visual( PartitionVector & partitions )
@@ -47,7 +47,7 @@ void OperationLabelFileSystem::apply_to_visual( PartitionVector & partitions )
 
 void OperationLabelFileSystem::create_description()
 {
-	g_assert( partition_new != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_new != nullptr);  // Bug: Not initialised by constructor or reset later
 
 	if( partition_new->get_filesystem_partition().get_filesystem_label().empty() )
 	{
@@ -66,7 +66,7 @@ void OperationLabelFileSystem::create_description()
 
 bool OperationLabelFileSystem::merge_operations( const Operation & candidate )
 {
-	g_assert( partition_new != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_new != nullptr);  // Bug: Not initialised by constructor or reset later
 
 	if ( candidate.type == OPERATION_LABEL_FILESYSTEM         &&
 	     *partition_new == candidate.get_partition_original()    )

src/OperationNamePartition.cc

@@ -36,8 +36,8 @@ OperationNamePartition::~OperationNamePartition()
 {
 	delete partition_original;
 	delete partition_new;
-	partition_original = NULL;
+	partition_original = nullptr;
-	partition_new = NULL;
+	partition_new = nullptr;
 }
 
 void OperationNamePartition::apply_to_visual( PartitionVector & partitions )
@@ -47,7 +47,7 @@ void OperationNamePartition::apply_to_visual( PartitionVector & partitions )
 
 void OperationNamePartition::create_description()
 {
-	g_assert( partition_new != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_new != nullptr);  // Bug: Not initialised by constructor or reset later
 
 	if( partition_new->name.empty() )
 	{
@@ -66,7 +66,7 @@ void OperationNamePartition::create_description()
 
 bool OperationNamePartition::merge_operations( const Operation & candidate )
 {
-	g_assert( partition_new != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_new != nullptr);  // Bug: Not initialised by constructor or reset later
 
 	if ( candidate.type == OPERATION_NAME_PARTITION           &&
 	     *partition_new == candidate.get_partition_original()    )

src/OperationResizeMove.cc

@@ -37,13 +37,13 @@ OperationResizeMove::~OperationResizeMove()
 {
 	delete partition_original;
 	delete partition_new;
-	partition_original = NULL;
+	partition_original = nullptr;
-	partition_new = NULL;
+	partition_new = nullptr;
 }
 
 void OperationResizeMove::apply_to_visual( PartitionVector & partitions )
 {
-	g_assert( partition_original != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_original != nullptr);  // Bug: Not initialised by constructor or reset later
 
 	if ( partition_original->type == TYPE_EXTENDED )
 		apply_extended_to_visual( partitions ) ;
@@ -53,8 +53,8 @@ void OperationResizeMove::apply_to_visual( PartitionVector & partitions )
 
 void OperationResizeMove::create_description() 
 {
-	g_assert( partition_original != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_original != nullptr);  // Bug: Not initialised by constructor or reset later
-	g_assert( partition_new != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_new != nullptr);  // Bug: Not initialised by constructor or reset later
 
 	//i'm not too happy with this, but i think it is the correct way from a i18n POV
 	enum Action
@@ -143,8 +143,8 @@ void OperationResizeMove::create_description()
 
 void OperationResizeMove::apply_normal_to_visual( PartitionVector & partitions )
 {
-	g_assert( partition_original != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_original != nullptr);  // Bug: Not initialised by constructor or reset later
-	g_assert( partition_new != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_new != nullptr);  // Bug: Not initialised by constructor or reset later
 
 	int index_extended;
 	int index;
@@ -185,7 +185,7 @@ void OperationResizeMove::apply_normal_to_visual( PartitionVector & partitions )
 
 void OperationResizeMove::apply_extended_to_visual( PartitionVector & partitions )
 {
-	g_assert( partition_new != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_new != nullptr);  // Bug: Not initialised by constructor or reset later
 
 	int index_extended;
 
@@ -239,7 +239,7 @@ void OperationResizeMove::remove_adjacent_unallocated( PartitionVector & partiti
 
 bool OperationResizeMove::merge_operations( const Operation & candidate )
 {
-	g_assert( partition_new != NULL );  // Bug: Not initialised by constructor or reset later
+	g_assert(partition_new != nullptr);  // Bug: Not initialised by constructor or reset later
 
 	if ( candidate.type == OPERATION_RESIZE_MOVE              &&
 	     *partition_new == candidate.get_partition_original()    )

src/OptionComboBox.cc

@@ -27,7 +27,7 @@ namespace GParted
 // NOTE: As stated in Gtkmm3 documentation, slots can be shared for all model instances.
 // See: Class Reference for Gtk::TreeModelColumn and Gtk::TreeModelColumnRecord.
 //     https://developer.gnome.org/gtkmm/3.22/classGtk_1_1TreeModelColumnRecord.html#details
-OptionStore::Slots *OptionStore::m_slots = NULL;
+OptionStore::Slots* OptionStore::m_slots = nullptr;
 
 
 OptionStore_Item::OptionStore_Item(const Glib::RefPtr<OptionStore>& ref_model,

src/PasswordRAMStore.cc

@@ -85,11 +85,11 @@ const size_t ProtectedMemSize = 4096;
 PWStore::PWStore()
 {
 	// MAP_ANONYMOUS also ensures RAM is zero initialised.
-	protected_mem = (char *) mmap( NULL, ProtectedMemSize, PROT_READ|PROT_WRITE,
+	protected_mem = (char*) mmap(nullptr, ProtectedMemSize, PROT_READ|PROT_WRITE,
 	                             MAP_PRIVATE|MAP_ANONYMOUS|MAP_LOCKED, -1, 0);
 	if ( protected_mem == MAP_FAILED )
 	{
-		protected_mem = NULL;
+		protected_mem = nullptr;
 		std::cerr << "No locked virtual memory for password RAM store" << std::endl;
 	}
 }
@@ -97,13 +97,13 @@ PWStore::PWStore()
 PWStore::~PWStore()
 {
 	erase_all();
-	if ( protected_mem != NULL )
+	if (protected_mem != nullptr)
 		munmap( protected_mem, ProtectedMemSize );
 }
 
 bool PWStore::insert( const Glib::ustring & key, const char * password )
 {
-	if ( protected_mem == NULL )
+	if (protected_mem == nullptr)
 		// No locked memory for passwords
 		return false;
 
@@ -157,7 +157,7 @@ const char * PWStore::lookup( const Glib::ustring & key )
 	}
 
 	// No such key
-	return NULL;
+	return nullptr;
 }
 
 PWStore::iterator PWStore::find_key( const Glib::ustring & key )
@@ -174,7 +174,7 @@ PWStore::iterator PWStore::find_key( const Glib::ustring & key )
 void PWStore::erase_all()
 {
 	pw_entries.clear();
-	if ( protected_mem != NULL )
+	if (protected_mem != nullptr)
 		// WARNING:
 		// memset() can be optimised away if the compiler knows the memory is not
 		// accessed again.  In this case this memset() is in a separate method
@@ -206,7 +206,7 @@ static PWStore single_pwstore;
 bool PasswordRAMStore::store( const Glib::ustring & key, const char * password )
 {
 	const char * looked_up_pw = single_pwstore.lookup( key );
-	if ( looked_up_pw == NULL )
+	if (looked_up_pw == nullptr)
 		return single_pwstore.insert( key, password );
 
 	if ( strcmp( looked_up_pw, password ) == 0 )

src/PipeCapture.cc

@@ -156,7 +156,7 @@ bool PipeCapture::OnReadable( Glib::IOCondition condition )
 					// delimited by an end pointer.
 					new_ptr ++;
 				read_ptr = new_ptr;
-				if ( read_ptr == NULL )
+				if (read_ptr == nullptr)
 					read_ptr = end_ptr;
 			}
 

src/SupportedFileSystems.cc

@@ -52,13 +52,13 @@ SupportedFileSystems::SupportedFileSystems()
 	//     their derived FileSystem object, which determines and implements their
 	//     supported actions.
 	//     supported_filesystem() -> true
-	// 2)  Basic supported file systems have a NULL pointer entry, with
+	// 2)  Basic supported file systems have a nullptr pointer entry, with
 	//     find_supported_filesystems() creating a basic set of supported actions.
 	//     supported_filesystem() -> false
 	// 3)  Unsupported file systems have no entry, and no supported actions.
 	//     supported_filesystem() -> false
-	m_fs_objects[FS_UNKNOWN]         = NULL;
+	m_fs_objects[FS_UNKNOWN]         = nullptr;
-	m_fs_objects[FS_OTHER]           = NULL;
+	m_fs_objects[FS_OTHER]           = nullptr;
 	m_fs_objects[FS_BTRFS]           = new btrfs();
 	m_fs_objects[FS_EXFAT]           = new exfat();
 	m_fs_objects[FS_EXT2]            = new ext2(FS_EXT2);
@@ -80,16 +80,16 @@ SupportedFileSystems::SupportedFileSystems()
 	m_fs_objects[FS_REISERFS]        = new reiserfs();
 	m_fs_objects[FS_UDF]             = new udf();
 	m_fs_objects[FS_XFS]             = new xfs();
-	m_fs_objects[FS_APFS]            = NULL;
+	m_fs_objects[FS_APFS]            = nullptr;
-	m_fs_objects[FS_ATARAID]         = NULL;
+	m_fs_objects[FS_ATARAID]         = nullptr;
-	m_fs_objects[FS_BITLOCKER]       = NULL;
+	m_fs_objects[FS_BITLOCKER]       = nullptr;
-	m_fs_objects[FS_GRUB2_CORE_IMG]  = NULL;
+	m_fs_objects[FS_GRUB2_CORE_IMG]  = nullptr;
-	m_fs_objects[FS_ISO9660]         = NULL;
+	m_fs_objects[FS_ISO9660]         = nullptr;
-	m_fs_objects[FS_LINUX_SWRAID]    = NULL;
+	m_fs_objects[FS_LINUX_SWRAID]    = nullptr;
-	m_fs_objects[FS_LINUX_SWSUSPEND] = NULL;
+	m_fs_objects[FS_LINUX_SWSUSPEND] = nullptr;
-	m_fs_objects[FS_REFS]            = NULL;
+	m_fs_objects[FS_REFS]            = nullptr;
-	m_fs_objects[FS_UFS]             = NULL;
+	m_fs_objects[FS_UFS]             = nullptr;
-	m_fs_objects[FS_ZFS]             = NULL;
+	m_fs_objects[FS_ZFS]             = nullptr;
 }
 
 
@@ -99,7 +99,7 @@ SupportedFileSystems::~SupportedFileSystems()
 	for (iter = m_fs_objects.begin(); iter != m_fs_objects.end(); iter++)
 	{
 		delete iter->second;
-		iter->second = NULL;
+		iter->second = nullptr;
 	}
 }
 
@@ -137,7 +137,7 @@ FileSystem* SupportedFileSystems::get_fs_object(FSType fstype) const
 {
 	FSObjectsMap::const_iterator iter = m_fs_objects.find(fstype);
 	if (iter == m_fs_objects.end())
-		return NULL;
+		return nullptr;
 	else
 		return iter->second;
 }
@@ -167,7 +167,7 @@ const std::vector<FS>& SupportedFileSystems::get_all_fs_support() const
 // Return true for file systems with an implementation class, false otherwise.
 bool SupportedFileSystems::supported_filesystem(FSType fstype) const
 {
-	return get_fs_object(fstype) != NULL;
+	return get_fs_object(fstype) != nullptr;
 }
 
 

src/Utils.cc

@@ -614,7 +614,7 @@ double Utils::sector_to_unit( Sector sectors, Byte_Value sector_size, SIZE_UNIT
 int Utils::execute_command( const Glib::ustring & command )
 {
 	Glib::ustring dummy ;
-	return execute_command( command, NULL, dummy, dummy );
+	return execute_command(command, nullptr, dummy, dummy);
 }
 
 class CommandStatus
@@ -679,7 +679,7 @@ int Utils::execute_command( const Glib::ustring & command,
 			    Glib::ustring & error,
 			    bool use_C_locale )
 {
-	return execute_command( command, NULL, output, error, use_C_locale );
+	return execute_command(command, nullptr, output, error, use_C_locale);
 }
 
 int Utils::execute_command( const Glib::ustring & command,
@@ -704,7 +704,7 @@ int Utils::execute_command( const Glib::ustring & command,
 			Glib::SPAWN_DO_NOT_REAP_CHILD | Glib::SPAWN_SEARCH_PATH,
 			use_C_locale ? sigc::ptr_fun( set_locale ) : sigc::slot< void >(),
 			&pid,
-			( input != NULL ) ? &in : 0,
+			(input != nullptr) ? &in : 0,
 			&out,
 			&err );
 	} catch (Glib::SpawnError &e) {
@@ -725,7 +725,7 @@ int Utils::execute_command( const Glib::ustring & command,
 	outputcapture.connect_signal();
 	errorcapture.connect_signal();
 
-	if ( input != NULL && in != -1 )
+	if (input != nullptr && in != -1)
 	{
 		// Write small amount of input to pipe to the child process.  Linux will
 		// always accept up 4096 bytes without blocking.  See pipe(7).
@@ -830,7 +830,7 @@ Glib::ustring Utils::get_lang()
 {
 	//Extract base language from string that may look like "en_CA.UTF-8"
 	//  and return in the form "en-CA"
-	Glib::ustring lang = setlocale( LC_CTYPE, NULL ) ;
+	Glib::ustring lang = setlocale(LC_CTYPE, nullptr);
 
 	//Strip off anything after the period "." or at sign "@"
 	lang = Utils::regexp_label( lang .c_str(), "^([^.@]*)") ;

src/Win_GParted.cc

@@ -71,8 +71,8 @@ namespace GParted
 	
 Win_GParted::Win_GParted( const std::vector<Glib::ustring> & user_devices )
 {
-	copied_partition = NULL;
+	copied_partition = nullptr;
-	selected_partition_ptr = NULL;
+	selected_partition_ptr = nullptr;
 	new_count = 1;
 	current_device = 0 ;
 	OPERATIONSLIST_OPEN = true ;
@@ -156,7 +156,7 @@ Win_GParted::Win_GParted( const std::vector<Glib::ustring> & user_devices )
 Win_GParted::~Win_GParted()
 {
 	delete copied_partition;
-	copied_partition = NULL;
+	copied_partition = nullptr;
 }
 
 void Win_GParted::init_menubar() 
@@ -1070,13 +1070,13 @@ void Win_GParted::Refresh_Visual()
 
 	// Refresh copy partition source as necessary and select the largest unallocated
 	// partition if there is one.
-	selected_partition_ptr = NULL;
+	selected_partition_ptr = nullptr;
 	Sector largest_unalloc_size = -1 ;
 	Sector current_size ;
 
 	for (unsigned int i = 0; i < m_display_device.partitions.size(); i++)
 	{
-		if (copied_partition != NULL && m_display_device.partitions[i].get_path() == copied_partition->get_path())
+		if (copied_partition != nullptr && m_display_device.partitions[i].get_path() == copied_partition->get_path())
 		{
 			delete copied_partition;
 			copied_partition = m_display_device.partitions[i].clone();
@@ -1096,7 +1096,7 @@ void Win_GParted::Refresh_Visual()
 		{
 			for (unsigned int j = 0; j < m_display_device.partitions[i].logicals.size(); j++)
 			{
-				if (copied_partition != NULL &&
+				if (copied_partition != nullptr &&
 				    m_display_device.partitions[i].logicals[j].get_path() == copied_partition->get_path())
 				{
 					delete copied_partition;
@@ -1199,7 +1199,7 @@ void Win_GParted::set_valid_operations()
 
 	// Set default name for the open/close crypt menu item.
 	const FileSystem * luks_filesystem_object = gparted_core.get_filesystem_object( FS_LUKS );
-	g_assert( luks_filesystem_object != NULL );  // Bug: LUKS FileSystem object not found
+	g_assert(luks_filesystem_object != nullptr);  // Bug: LUKS FileSystem object not found
 	dynamic_cast<Gtk::Label *>(partitionmenu_items[MENU_TOGGLE_CRYPT_BUSY]->get_child())
 		->set_label( luks_filesystem_object->get_custom_text( CTEXT_ACTIVATE_FILESYSTEM ) );
 	// Set default name for the file system active/deactivate menu item.
@@ -1345,7 +1345,7 @@ void Win_GParted::set_valid_operations()
 		// Temporarily disable copying of encrypted content into new partitions
 		// which can't yet be encrypted, until full LUKS read-write support is
 		// implemented.
-		if ( copied_partition             != NULL    &&
+		if ( copied_partition             != nullptr &&
 		     ! devices[current_device].readonly      &&
 		     copied_partition->fstype     != FS_LUKS    )
 		{
@@ -1490,7 +1490,7 @@ void Win_GParted::set_valid_operations()
 		}
 
 		// See if there is a partition to be copied and it fits inside this selected partition
-		if ( copied_partition != NULL                                              &&
+		if ( copied_partition != nullptr                                           &&
 		     ( copied_partition->get_filesystem_partition().get_byte_length() <=
 		       selected_filesystem.get_byte_length()                             ) &&
 		     selected_partition_ptr->status == STAT_REAL                           &&
@@ -1828,19 +1828,19 @@ void Win_GParted::show_help(const Glib::ustring & filename /* E.g., "gparted" */
 		return;
 	}
 
-	GError *error = NULL;
+	GError* error = nullptr;
 
 	// Display help window
 #if HAVE_GTK_SHOW_URI_ON_WINDOW
-	// NULL is provided for the gtk_show_uri_on_window() parent window
+	// nullptr is provided for the gtk_show_uri_on_window() parent window
 	// so that failures to launch yelp are reported.
 	// https://gitlab.gnome.org/GNOME/gparted/-/merge_requests/82#note_1106114
-	gtk_show_uri_on_window(NULL, uri.c_str(), gtk_get_current_event_time(), &error);
+	gtk_show_uri_on_window(nullptr, uri.c_str(), gtk_get_current_event_time(), &error);
 #else
 	GdkScreen *gscreen = gdk_screen_get_default();
 	gtk_show_uri(gscreen, uri.c_str(), gtk_get_current_event_time(), &error);
 #endif
-	if (error != NULL)
+	if (error != nullptr)
 	{
 		Gtk::MessageDialog errorDialog(*this,
 		                               _("Failed to open GParted Manual help file"),
@@ -1998,7 +1998,7 @@ bool Win_GParted::max_amount_prim_reached()
 
 void Win_GParted::activate_resize()
 {
-	g_assert( selected_partition_ptr != NULL );  // Bug: Partition callback without a selected partition
+	g_assert(selected_partition_ptr != nullptr);  // 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
 
 	const Partition & selected_filesystem_ptn = selected_partition_ptr->get_filesystem_partition();
@@ -2067,7 +2067,7 @@ void Win_GParted::activate_resize()
 	dialog .set_transient_for( *this ) ;	
 
 	delete working_ptn;
-	working_ptn = NULL;
+	working_ptn = nullptr;
 
 	if (dialog.run() == Gtk::RESPONSE_OK                                           &&
 	    ask_for_password_for_encrypted_resize_as_required(*selected_partition_ptr)   )
@@ -2102,7 +2102,7 @@ void Win_GParted::activate_resize()
 		operation->icon = Utils::mk_pixbuf(*this, Gtk::Stock::GOTO_LAST, Gtk::ICON_SIZE_MENU);
 
 		delete resized_ptn;
-		resized_ptn = NULL;
+		resized_ptn = nullptr;
 
 		// Display warning if moving a non-extended partition which already exists
 		// on the disk.
@@ -2153,7 +2153,7 @@ bool Win_GParted::ask_for_password_for_encrypted_resize_as_required(const Partit
 		return true;
 
 	const char *pw = PasswordRAMStore::lookup(partition.uuid);
-	if (pw != NULL)
+	if (pw != nullptr)
 		// GParted already has a password for this encryption mapping which was
 		// previously used successfully or tested for correctness.
 		//
@@ -2214,7 +2214,7 @@ bool Win_GParted::ask_for_password_for_encrypted_resize_as_required(const Partit
 
 void Win_GParted::activate_copy()
 {
-	g_assert( selected_partition_ptr != NULL );  // Bug: Partition callback without a selected partition
+	g_assert(selected_partition_ptr != nullptr);  // 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
 
 	delete copied_partition;
@@ -2223,8 +2223,8 @@ void Win_GParted::activate_copy()
 
 void Win_GParted::activate_paste()
 {
-	g_assert( copied_partition != NULL );  // Bug: Paste called without partition to copy
+	g_assert(copied_partition != nullptr);  // Bug: Paste called without partition to copy
-	g_assert( selected_partition_ptr != NULL );  // Bug: Partition callback without a selected partition
+	g_assert(selected_partition_ptr != nullptr);  // 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
 
 	// Unrecognised whole disk device (See GParted_Core::set_device_from_disk(), "unrecognized")
@@ -2258,7 +2258,7 @@ void Win_GParted::activate_paste()
 			                             *selected_partition_ptr,
 			                             *part_temp);
 			delete part_temp;
-			part_temp = NULL;
+			part_temp = nullptr;
 			dialog .set_transient_for( *this );
 		
 			if ( dialog .run() == Gtk::RESPONSE_OK )
@@ -2368,7 +2368,7 @@ void Win_GParted::activate_paste()
 		operation->icon = Utils::mk_pixbuf(*this, Gtk::Stock::COPY, Gtk::ICON_SIZE_MENU);
 
 		delete partition_new;
-		partition_new = NULL;
+		partition_new = nullptr;
 
 		Add_Operation( devices[current_device], operation );
 
@@ -2396,7 +2396,7 @@ void Win_GParted::activate_paste()
 
 void Win_GParted::activate_new()
 {
-	g_assert( selected_partition_ptr != NULL );  // Bug: Partition callback without a selected partition
+	g_assert(selected_partition_ptr != nullptr);  // 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
 
 	// Unrecognised whole disk device (See GParted_Core::set_device_from_disk(), "unrecognized")
@@ -2437,7 +2437,7 @@ void Win_GParted::activate_new()
 
 void Win_GParted::activate_delete()
 { 
-	g_assert( selected_partition_ptr != NULL );  // Bug: Partition callback without a selected partition
+	g_assert(selected_partition_ptr != nullptr);  // 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
 
 	// VGNAME from mount mount
@@ -2474,7 +2474,7 @@ void Win_GParted::activate_delete()
 	}
 	
 	//if partition is on the clipboard...(NOTE: we can't use Partition::== here..)
-	if ( copied_partition != NULL && selected_partition_ptr->get_path() == copied_partition->get_path() )
+	if (copied_partition != nullptr && selected_partition_ptr->get_path() == copied_partition->get_path())
 	{
 		Gtk::MessageDialog dialog( *this,
 		                           Glib::ustring::compose( _("Are you sure you want to delete %1?"),
@@ -2501,7 +2501,7 @@ void Win_GParted::activate_delete()
 
 		// Deleting partition on the clipboard.  Clear clipboard.
 		delete copied_partition;
-		copied_partition = NULL;
+		copied_partition = nullptr;
 	}
 
 	// If deleted one is NEW, it doesn't make sense to add it to the operationslist,
@@ -2550,7 +2550,7 @@ void Win_GParted::activate_delete()
 
 void Win_GParted::activate_info()
 {
-	g_assert( selected_partition_ptr != NULL );  // Bug: Partition callback without a selected partition
+	g_assert(selected_partition_ptr != nullptr);  // 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
 
 	Dialog_Partition_Info dialog( *selected_partition_ptr );
@@ -2560,7 +2560,7 @@ void Win_GParted::activate_info()
 
 void Win_GParted::activate_format( FSType new_fs )
 {
-	g_assert( selected_partition_ptr != NULL );  // Bug: Partition callback without a selected partition
+	g_assert(selected_partition_ptr != nullptr);  // 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
 
 	const Partition & filesystem_ptn = selected_partition_ptr->get_filesystem_partition();
@@ -2700,18 +2700,19 @@ void Win_GParted::activate_format( FSType new_fs )
 	}
 
 	delete temp_ptn;
-	temp_ptn = NULL;
+	temp_ptn = nullptr;
 }
 
+
 bool Win_GParted::open_encrypted_partition( const Partition & partition,
                                             const char * entered_password,
                                             Glib::ustring & message )
 {
-	const char * pw = NULL;
+	const char* pw = nullptr;
-	if ( entered_password == NULL )
+	if (entered_password == nullptr)
 	{
 		pw = PasswordRAMStore::lookup( partition.uuid );
-		if ( pw == NULL )
+		if (pw == nullptr)
 		{
 			// Internal documentation message never shown to user.
 			message = "No stored password available";
@@ -2739,7 +2740,7 @@ bool Win_GParted::open_encrypted_partition( const Partition & partition,
 	Glib::ustring error;
 	bool success = ! Utils::execute_command( cmd, pw, output, error );
 	hide_pulsebar();
-	if ( success && pw != NULL )
+	if (success && pw != nullptr)
 		// Save the password just entered and successfully used to open the LUKS
 		// mapping.
 		PasswordRAMStore::store( partition.uuid, pw );
@@ -2754,7 +2755,7 @@ bool Win_GParted::open_encrypted_partition( const Partition & partition,
 
 void Win_GParted::toggle_crypt_busy_state()
 {
-	g_assert( selected_partition_ptr != NULL );  // Bug: Partition callback without a selected partition
+	g_assert(selected_partition_ptr != nullptr);  // 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
 
 	enum Action
@@ -2808,7 +2809,7 @@ void Win_GParted::toggle_crypt_busy_state()
 		case LUKSOPEN:
 		{
 			// Attempt to unlock LUKS using stored passphrase first.
-			success = open_encrypted_partition( *selected_partition_ptr, NULL, error_msg );
+			success = open_encrypted_partition(*selected_partition_ptr, nullptr, error_msg);
 			if ( success )
 				break;
 
@@ -2941,7 +2942,7 @@ void Win_GParted::show_toggle_failure_dialog( const Glib::ustring & failure_summ
 
 void Win_GParted::toggle_fs_busy_state()
 {
-	g_assert( selected_partition_ptr != NULL );  // Bug: Partition callback without a selected partition
+	g_assert(selected_partition_ptr != nullptr);  // 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
 
 	enum Action
@@ -3054,7 +3055,7 @@ void Win_GParted::toggle_fs_busy_state()
 
 void Win_GParted::activate_mount_partition( unsigned int index ) 
 {
-	g_assert( selected_partition_ptr != NULL );  // Bug: Partition callback without a selected partition
+	g_assert(selected_partition_ptr != nullptr);  // 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
 
 	Glib::ustring disallowed_msg = _("The mount action cannot be performed when an operation is pending for the partition.");
@@ -3261,7 +3262,7 @@ void Win_GParted::activate_attempt_rescue_data()
 
 void Win_GParted::activate_manage_flags() 
 {
-	g_assert( selected_partition_ptr != NULL );  // Bug: Partition callback without a selected partition
+	g_assert(selected_partition_ptr != nullptr);  // 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
 
 	get_window()->set_cursor(Gdk::Cursor::create(Gdk::WATCH));
@@ -3287,7 +3288,7 @@ void Win_GParted::activate_manage_flags()
 
 void Win_GParted::activate_check() 
 {
-	g_assert( selected_partition_ptr != NULL );  // Bug: Partition callback without a selected partition
+	g_assert(selected_partition_ptr != nullptr);  // 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
 
 	if (! ask_for_password_for_encrypted_resize_as_required(*selected_partition_ptr))
@@ -3311,7 +3312,7 @@ void Win_GParted::activate_check()
 
 void Win_GParted::activate_label_filesystem()
 {
-	g_assert( selected_partition_ptr != NULL );  // Bug: Partition callback without a selected partition
+	g_assert(selected_partition_ptr != nullptr);  // 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
 
 	const Partition & filesystem_ptn = selected_partition_ptr->get_filesystem_partition();
@@ -3332,7 +3333,7 @@ void Win_GParted::activate_label_filesystem()
 		operation->icon = Utils::mk_pixbuf(*this, Gtk::Stock::EXECUTE, Gtk::ICON_SIZE_MENU);
 
 		delete part_temp;
-		part_temp = NULL;
+		part_temp = nullptr;
 
 		Add_Operation( devices[current_device], operation );
 		// Try to merge this label file system operation with all previous
@@ -3345,7 +3346,7 @@ void Win_GParted::activate_label_filesystem()
 
 void Win_GParted::activate_name_partition()
 {
-	g_assert( selected_partition_ptr != NULL );  // Bug: Partition callback without a selected partition
+	g_assert(selected_partition_ptr != nullptr);  // 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
 
 	Dialog_Partition_Name dialog( *selected_partition_ptr,
@@ -3366,7 +3367,7 @@ void Win_GParted::activate_name_partition()
 		operation->icon = Utils::mk_pixbuf(*this, Gtk::Stock::EXECUTE, Gtk::ICON_SIZE_MENU);
 
 		delete part_temp;
-		part_temp = NULL;
+		part_temp = nullptr;
 
 		Add_Operation( devices[current_device], operation );
 		// Try to merge this name partition operation with all previous
@@ -3379,7 +3380,7 @@ void Win_GParted::activate_name_partition()
 
 void Win_GParted::activate_change_uuid()
 {
-	g_assert( selected_partition_ptr != NULL );  // Bug: Partition callback without a selected partition
+	g_assert(selected_partition_ptr != nullptr);  // 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
 
 	const Partition & filesystem_ptn = selected_partition_ptr->get_filesystem_partition();
@@ -3424,7 +3425,7 @@ void Win_GParted::activate_change_uuid()
 	operation->icon = Utils::mk_pixbuf(*this, Gtk::Stock::EXECUTE, Gtk::ICON_SIZE_MENU);
 
 	delete temp_ptn;
-	temp_ptn = NULL;
+	temp_ptn = nullptr;
 
 	Add_Operation( devices[current_device], operation );
 	// Try to merge this change UUID operation with all previous operations.

src/luks.cc

@@ -159,7 +159,7 @@ bool luks::resize( const Partition & partition_new, OperationDetail & operationd
 		// device sector size.
 		size = "--size " + Utils::num_to_str( ( partition_new.get_byte_length() - mapping.offset ) / 512LL ) + " ";
 
-	const char *pw = NULL;
+	const char* pw = nullptr;
 	if (mapping.key_loc == KEYLOC_KeyRing)
 		pw = PasswordRAMStore::lookup(partition_new.uuid);